X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Ffile-coding.c;h=b2a0c26825282c81b64d689d47ea3385a345f90c;hb=dc6e13eb34013b5568cbdced4bb6d0ec3c3f0275;hp=baad06843b009b4ab14ce3680c1f2de99747177c;hpb=c8aa261a7bf3eb1389d2e018be1d715f73cacd66;p=chise%2Fxemacs-chise.git-

diff --git a/src/file-coding.c b/src/file-coding.c
index baad068..b2a0c26 100644
--- a/src/file-coding.c
+++ b/src/file-coding.c
@@ -66,7 +66,7 @@ struct file_coding_dump {
 static const struct lrecord_description fcd_description_1[] = {
   { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 },
 #if defined(MULE) && !defined(UTF2000)
-  { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), 65536 },
+  { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), countof (fcd->ucs_to_mule_table) },
 #endif
   { XD_END }
 };
@@ -176,68 +176,47 @@ EXFUN (Fcopy_coding_system, 2);
 #ifdef MULE
 struct detection_state;
 static int detect_coding_sjis (struct detection_state *st,
-			       CONST unsigned char *src,
-			       unsigned int n);
-static void decode_coding_sjis (Lstream *decoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst,
-				unsigned int n);
-static void encode_coding_sjis (Lstream *encoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst,
-				unsigned int n);
+			       const Extbyte *src, size_t n);
+static void decode_coding_sjis (Lstream *decoding, const Extbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
+static void encode_coding_sjis (Lstream *encoding, const Bufbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
 static int detect_coding_big5 (struct detection_state *st,
-			       CONST unsigned char *src,
-			       unsigned int n);
-static void decode_coding_big5 (Lstream *decoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_big5 (Lstream *encoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst, unsigned int n);
+			       const Extbyte *src, size_t n);
+static void decode_coding_big5 (Lstream *decoding, const Extbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
+static void encode_coding_big5 (Lstream *encoding, const Bufbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
 static int detect_coding_ucs4 (struct detection_state *st,
-			       CONST unsigned char *src,
-			       unsigned int n);
-static void decode_coding_ucs4 (Lstream *decoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_ucs4 (Lstream *encoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst, unsigned int n);
+			       const Extbyte *src, size_t n);
+static void decode_coding_ucs4 (Lstream *decoding, const Extbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
+static void encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
 static int detect_coding_utf8 (struct detection_state *st,
-			       CONST unsigned char *src,
-			       unsigned int n);
-static void decode_coding_utf8 (Lstream *decoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_utf8 (Lstream *encoding,
-				CONST unsigned char *src,
-				unsigned_char_dynarr *dst, unsigned int n);
+			       const Extbyte *src, size_t n);
+static void decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
+static void encode_coding_utf8 (Lstream *encoding, const Bufbyte *src,
+				unsigned_char_dynarr *dst, size_t n);
 static int postprocess_iso2022_mask (int mask);
 static void reset_iso2022 (Lisp_Object coding_system,
 			   struct iso2022_decoder *iso);
 static int detect_coding_iso2022 (struct detection_state *st,
-				  CONST unsigned char *src,
-				  unsigned int n);
-static void decode_coding_iso2022 (Lstream *decoding,
-				   CONST unsigned char *src,
-				   unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_iso2022 (Lstream *encoding,
-				   CONST unsigned char *src,
-				   unsigned_char_dynarr *dst, unsigned int n);
+				  const Extbyte *src, size_t n);
+static void decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
+				   unsigned_char_dynarr *dst, size_t n);
+static void encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src,
+				   unsigned_char_dynarr *dst, size_t n);
 #endif /* MULE */
-static void decode_coding_no_conversion (Lstream *decoding,
-					 CONST unsigned char *src,
-					 unsigned_char_dynarr *dst,
-					 unsigned int n);
-static void encode_coding_no_conversion (Lstream *encoding,
-					 CONST unsigned char *src,
-					 unsigned_char_dynarr *dst,
-					 unsigned int n);
-static void mule_decode (Lstream *decoding, CONST unsigned char *src,
-			 unsigned_char_dynarr *dst, unsigned int n);
-static void mule_encode (Lstream *encoding, CONST unsigned char *src,
-			 unsigned_char_dynarr *dst, unsigned int n);
+static void decode_coding_no_conversion (Lstream *decoding, const Extbyte *src,
+					 unsigned_char_dynarr *dst, size_t n);
+static void encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src,
+					 unsigned_char_dynarr *dst, size_t n);
+static void mule_decode (Lstream *decoding, const Extbyte *src,
+			 unsigned_char_dynarr *dst, size_t n);
+static void mule_encode (Lstream *encoding, const Bufbyte *src,
+			 unsigned_char_dynarr *dst, size_t n);
 
 typedef struct codesys_prop codesys_prop;
 struct codesys_prop
@@ -732,7 +711,7 @@ nil or 'undecided
      JIS (the Japanese encoding commonly used for e-mail), EUC (the
      standard Unix encoding for Japanese and other languages), and
      Compound Text (the encoding used in X11).  You can specify more
-     specific information about the conversion with the FLAGS argument.
+     specific information about the conversion with the PROPS argument.
 'big5
      Big5 (the encoding commonly used for Taiwanese).
 'ccl
@@ -789,12 +768,12 @@ character set.  Recognized properties are:
 
 'post-read-conversion
      Function called after a file has been read in, to perform the
-     decoding.  Called with two arguments, BEG and END, denoting
+     decoding.  Called with two arguments, START and END, denoting
      a region of the current buffer to be decoded.
 
 'pre-write-conversion
      Function called before a file is written out, to perform the
-     encoding.  Called with two arguments, BEG and END, denoting
+     encoding.  Called with two arguments, START and END, denoting
      a region of the current buffer to be encoded.
 
 
@@ -882,7 +861,6 @@ if TYPE is 'ccl:
        (name, type, doc_string, props))
 {
   Lisp_Coding_System *codesys;
-  Lisp_Object rest, key, value;
   enum coding_system_type ty;
   int need_to_setup_eol_systems = 1;
 
@@ -914,92 +892,118 @@ if TYPE is 'ccl:
     CHECK_STRING (doc_string);
   CODING_SYSTEM_DOC_STRING (codesys) = doc_string;
 
-  EXTERNAL_PROPERTY_LIST_LOOP (rest, key, value, props)
-    {
-      if (EQ (key, Qmnemonic))
-	{
-          if (!NILP (value))
-	    CHECK_STRING (value);
-	  CODING_SYSTEM_MNEMONIC (codesys) = value;
-	}
+  {
+    EXTERNAL_PROPERTY_LIST_LOOP_3 (key, value, props)
+      {
+	if (EQ (key, Qmnemonic))
+	  {
+	    if (!NILP (value))
+	      CHECK_STRING (value);
+	    CODING_SYSTEM_MNEMONIC (codesys) = value;
+	  }
 
-      else if (EQ (key, Qeol_type))
-	{
-	  need_to_setup_eol_systems = NILP (value);
-	  if (EQ (value, Qt))
-	    value = Qnil;
-	  CODING_SYSTEM_EOL_TYPE (codesys) = symbol_to_eol_type (value);
-	}
+	else if (EQ (key, Qeol_type))
+	  {
+	    need_to_setup_eol_systems = NILP (value);
+	    if (EQ (value, Qt))
+	      value = Qnil;
+	    CODING_SYSTEM_EOL_TYPE (codesys) = symbol_to_eol_type (value);
+	  }
 
-      else if (EQ (key, Qpost_read_conversion)) CODING_SYSTEM_POST_READ_CONVERSION (codesys) = value;
-      else if (EQ (key, Qpre_write_conversion)) CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = value;
+	else if (EQ (key, Qpost_read_conversion)) CODING_SYSTEM_POST_READ_CONVERSION (codesys) = value;
+	else if (EQ (key, Qpre_write_conversion)) CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = value;
 #ifdef MULE
-      else if (ty == CODESYS_ISO2022)
-	{
+	else if (ty == CODESYS_ISO2022)
+	  {
 #define FROB_INITIAL_CHARSET(charset_num) \
   CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, charset_num) = \
     ((EQ (value, Qt) || EQ (value, Qnil)) ? value : Fget_charset (value))
 
-	  if      (EQ (key, Qcharset_g0)) FROB_INITIAL_CHARSET (0);
-	  else if (EQ (key, Qcharset_g1)) FROB_INITIAL_CHARSET (1);
-	  else if (EQ (key, Qcharset_g2)) FROB_INITIAL_CHARSET (2);
-	  else if (EQ (key, Qcharset_g3)) FROB_INITIAL_CHARSET (3);
+	    if      (EQ (key, Qcharset_g0)) FROB_INITIAL_CHARSET (0);
+	    else if (EQ (key, Qcharset_g1)) FROB_INITIAL_CHARSET (1);
+	    else if (EQ (key, Qcharset_g2)) FROB_INITIAL_CHARSET (2);
+	    else if (EQ (key, Qcharset_g3)) FROB_INITIAL_CHARSET (3);
 
 #define FROB_FORCE_CHARSET(charset_num) \
   CODING_SYSTEM_ISO2022_FORCE_CHARSET_ON_OUTPUT (codesys, charset_num) = !NILP (value)
 
-	  else if (EQ (key, Qforce_g0_on_output)) FROB_FORCE_CHARSET (0);
-	  else if (EQ (key, Qforce_g1_on_output)) FROB_FORCE_CHARSET (1);
-	  else if (EQ (key, Qforce_g2_on_output)) FROB_FORCE_CHARSET (2);
-	  else if (EQ (key, Qforce_g3_on_output)) FROB_FORCE_CHARSET (3);
+	    else if (EQ (key, Qforce_g0_on_output)) FROB_FORCE_CHARSET (0);
+	    else if (EQ (key, Qforce_g1_on_output)) FROB_FORCE_CHARSET (1);
+	    else if (EQ (key, Qforce_g2_on_output)) FROB_FORCE_CHARSET (2);
+	    else if (EQ (key, Qforce_g3_on_output)) FROB_FORCE_CHARSET (3);
 
 #define FROB_BOOLEAN_PROPERTY(prop) \
   CODING_SYSTEM_ISO2022_##prop (codesys) = !NILP (value)
 
-	  else if (EQ (key, Qshort))         FROB_BOOLEAN_PROPERTY (SHORT);
-	  else if (EQ (key, Qno_ascii_eol))  FROB_BOOLEAN_PROPERTY (NO_ASCII_EOL);
-	  else if (EQ (key, Qno_ascii_cntl)) FROB_BOOLEAN_PROPERTY (NO_ASCII_CNTL);
-	  else if (EQ (key, Qseven))         FROB_BOOLEAN_PROPERTY (SEVEN);
-	  else if (EQ (key, Qlock_shift))    FROB_BOOLEAN_PROPERTY (LOCK_SHIFT);
-	  else if (EQ (key, Qno_iso6429))    FROB_BOOLEAN_PROPERTY (NO_ISO6429);
-	  else if (EQ (key, Qescape_quoted)) FROB_BOOLEAN_PROPERTY (ESCAPE_QUOTED);
+	    else if (EQ (key, Qshort))         FROB_BOOLEAN_PROPERTY (SHORT);
+	    else if (EQ (key, Qno_ascii_eol))  FROB_BOOLEAN_PROPERTY (NO_ASCII_EOL);
+	    else if (EQ (key, Qno_ascii_cntl)) FROB_BOOLEAN_PROPERTY (NO_ASCII_CNTL);
+	    else if (EQ (key, Qseven))         FROB_BOOLEAN_PROPERTY (SEVEN);
+	    else if (EQ (key, Qlock_shift))    FROB_BOOLEAN_PROPERTY (LOCK_SHIFT);
+	    else if (EQ (key, Qno_iso6429))    FROB_BOOLEAN_PROPERTY (NO_ISO6429);
+	    else if (EQ (key, Qescape_quoted)) FROB_BOOLEAN_PROPERTY (ESCAPE_QUOTED);
 
-	  else if (EQ (key, Qinput_charset_conversion))
-	    {
-	      codesys->iso2022.input_conv =
-		Dynarr_new (charset_conversion_spec);
-	      parse_charset_conversion_specs (codesys->iso2022.input_conv,
-					      value);
-	    }
-	  else if (EQ (key, Qoutput_charset_conversion))
-	    {
-	      codesys->iso2022.output_conv =
-		Dynarr_new (charset_conversion_spec);
-	      parse_charset_conversion_specs (codesys->iso2022.output_conv,
-					      value);
-	    }
-	  else
-	    signal_simple_error ("Unrecognized property", key);
-	}
-      else if (EQ (type, Qccl))
-	{
-	  if (EQ (key, Qdecode))
-	    {
-	      CHECK_VECTOR (value);
-	      CODING_SYSTEM_CCL_DECODE (codesys) = value;
-	    }
-	  else if (EQ (key, Qencode))
-	    {
-	      CHECK_VECTOR (value);
-	      CODING_SYSTEM_CCL_ENCODE (codesys) = value;
-	    }
-	  else
-	    signal_simple_error ("Unrecognized property", key);
-	}
+	    else if (EQ (key, Qinput_charset_conversion))
+	      {
+		codesys->iso2022.input_conv =
+		  Dynarr_new (charset_conversion_spec);
+		parse_charset_conversion_specs (codesys->iso2022.input_conv,
+						value);
+	      }
+	    else if (EQ (key, Qoutput_charset_conversion))
+	      {
+		codesys->iso2022.output_conv =
+		  Dynarr_new (charset_conversion_spec);
+		parse_charset_conversion_specs (codesys->iso2022.output_conv,
+						value);
+	      }
+	    else
+	      signal_simple_error ("Unrecognized property", key);
+	  }
+	else if (EQ (type, Qccl))
+	  {
+	    Lisp_Object sym;
+	    struct ccl_program test_ccl;
+	    Extbyte *suffix;
+
+	    /* Check key first.  */
+	    if (EQ (key, Qdecode))
+	      suffix = "-ccl-decode";
+	    else if (EQ (key, Qencode))
+	      suffix = "-ccl-encode";
+	    else
+	      signal_simple_error ("Unrecognized property", key);
+
+	    /* If value is vector, register it as a ccl program
+	       associated with an newly created symbol for
+	       backward compatibility.  */
+	    if (VECTORP (value))
+	      {
+		sym = Fintern (concat2 (Fsymbol_name (name),
+					build_string (suffix)),
+			       Qnil);
+		Fregister_ccl_program (sym, value);
+	      }
+	    else
+	      {
+		CHECK_SYMBOL (value);
+		sym = value;
+	      }
+	    /* check if the given ccl programs are valid.  */
+	    if (setup_ccl_program (&test_ccl, sym) < 0)
+	      signal_simple_error ("Invalid CCL program", value);
+
+	    if (EQ (key, Qdecode))
+	      CODING_SYSTEM_CCL_DECODE (codesys) = sym;
+	    else if (EQ (key, Qencode))
+	      CODING_SYSTEM_CCL_ENCODE (codesys) = sym;
+
+	  }
 #endif /* MULE */
-      else
-	signal_simple_error ("Unrecognized property", key);
-    }
+	else
+	  signal_simple_error ("Unrecognized property", key);
+      }
+  }
 
   if (need_to_setup_eol_systems)
     setup_eol_coding_systems (codesys);
@@ -1071,6 +1075,7 @@ Return the coding-system symbol for which symbol ALIAS is an alias.
     return aliasee;
   else
     signal_simple_error ("Symbol is not a coding system alias", alias);
+  return Qnil;		/* To keep the compiler happy */
 }
 
 static Lisp_Object
@@ -1217,7 +1222,7 @@ subsidiary_coding_system (Lisp_Object coding_system, eol_type_t type)
     case EOL_LF:   new_coding_system = CODING_SYSTEM_EOL_LF   (cs); break;
     case EOL_CR:   new_coding_system = CODING_SYSTEM_EOL_CR   (cs); break;
     case EOL_CRLF: new_coding_system = CODING_SYSTEM_EOL_CRLF (cs); break;
-    default:       abort ();
+    default:       abort (); return Qnil;
     }
 
   return NILP (new_coding_system) ? coding_system : new_coding_system;
@@ -1626,14 +1631,12 @@ mask_has_at_most_one_bit_p (int mask)
 }
 
 static eol_type_t
-detect_eol_type (struct detection_state *st, CONST unsigned char *src,
-		 unsigned int n)
+detect_eol_type (struct detection_state *st, const Extbyte *src,
+		 size_t n)
 {
-  int c;
-
   while (n--)
     {
-      c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       if (c == '\n')
 	{
 	  if (st->eol.just_saw_cr)
@@ -1671,11 +1674,9 @@ detect_eol_type (struct detection_state *st, CONST unsigned char *src,
 */
 
 static int
-detect_coding_type (struct detection_state *st, CONST Extbyte *src,
-		    unsigned int n, int just_do_eol)
+detect_coding_type (struct detection_state *st, const Extbyte *src,
+		    size_t n, int just_do_eol)
 {
-  int c;
-
   if (st->eol_type == EOL_AUTODETECT)
     st->eol_type = detect_eol_type (st, src, n);
 
@@ -1686,7 +1687,7 @@ detect_coding_type (struct detection_state *st, CONST Extbyte *src,
     {
       for (; n; n--, src++)
 	{
-	  c = *src;
+	  unsigned char c = *(unsigned char *) src;
 	  if ((c < 0x20 && !acceptable_control_char_p (c)) || c >= 0x80)
 	    {
 	      st->seen_non_ascii = 1;
@@ -1912,8 +1913,8 @@ determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out,
 
 DEFUN ("detect-coding-region", Fdetect_coding_region, 2, 3, 0, /*
 Detect coding system of the text in the region between START and END.
-Returned a list of possible coding systems ordered by priority.
-If only ASCII characters are found, it returns 'undecided or one of
+Return a list of possible coding systems ordered by priority.
+If only ASCII characters are found, return 'undecided or one of
 its subsidiary coding systems according to a detected end-of-line
 type.  Optional arg BUFFER defaults to the current buffer.
 */
@@ -1938,7 +1939,7 @@ type.  Optional arg BUFFER defaults to the current buffer.
   decst.mask = ~0;
   while (1)
     {
-      unsigned char random_buffer[4096];
+      Extbyte random_buffer[4096];
       ssize_t nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
 
       if (!nread)
@@ -2166,7 +2167,7 @@ struct decoding_stream
 static ssize_t decoding_reader (Lstream *stream,
 				unsigned char *data, size_t size);
 static ssize_t decoding_writer (Lstream *stream,
-				CONST unsigned char *data, size_t size);
+				const unsigned char *data, size_t size);
 static int decoding_rewinder   (Lstream *stream);
 static int decoding_seekable_p (Lstream *stream);
 static int decoding_flusher    (Lstream *stream);
@@ -2251,7 +2252,7 @@ decoding_reader (Lstream *stream, unsigned char *data, size_t size)
 	/* There might be some more end data produced in the translation.
 	   See the comment above. */
 	str->flags |= CODING_STATE_END;
-      mule_decode (stream, data, str->runoff, read_size);
+      mule_decode (stream, (Extbyte *) data, str->runoff, read_size);
     }
 
   if (data - orig_data == 0)
@@ -2261,7 +2262,7 @@ decoding_reader (Lstream *stream, unsigned char *data, size_t size)
 }
 
 static ssize_t
-decoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
+decoding_writer (Lstream *stream, const unsigned char *data, size_t size)
 {
   struct decoding_stream *str = DECODING_STREAM_DATA (stream);
   ssize_t retval;
@@ -2269,7 +2270,7 @@ decoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
   /* Decode all our data into the runoff, and then attempt to write
      it all out to the other end.  Remove whatever chunk we succeeded
      in writing. */
-  mule_decode (stream, data, str->runoff, size);
+  mule_decode (stream, (Extbyte *) data, str->runoff, size);
   retval = Lstream_write (str->other_end, Dynarr_atp (str->runoff, 0),
 			  Dynarr_length (str->runoff));
   if (retval > 0)
@@ -2296,6 +2297,13 @@ reset_decoding_stream (struct decoding_stream *str)
     }
   str->counter = 0;
 #endif /* MULE */
+  if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_AUTODETECT
+      || CODING_SYSTEM_EOL_TYPE (str->codesys) == EOL_AUTODETECT)
+    {
+      xzero (str->decst);
+      str->decst.eol_type = EOL_AUTODETECT;
+      str->decst.mask = ~0;
+    }
   str->flags = str->ch = 0;
 }
 
@@ -2371,7 +2379,7 @@ set_decoding_stream_coding_system (Lstream *lstr, Lisp_Object codesys)
 
 static Lisp_Object
 make_decoding_stream_1 (Lstream *stream, Lisp_Object codesys,
-			CONST char *mode)
+			const char *mode)
 {
   Lstream *lstr = Lstream_new (lstream_decoding, mode);
   struct decoding_stream *str = DECODING_STREAM_DATA (lstr);
@@ -2414,8 +2422,8 @@ make_decoding_output_stream (Lstream *stream, Lisp_Object codesys)
    be used for both reading and writing. */
 
 static void
-mule_decode (Lstream *decoding, CONST unsigned char *src,
-	     unsigned_char_dynarr *dst, unsigned int n)
+mule_decode (Lstream *decoding, const Extbyte *src,
+	     unsigned_char_dynarr *dst, size_t n)
 {
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 
@@ -2479,7 +2487,10 @@ mule_decode (Lstream *decoding, CONST unsigned char *src,
       break;
     case CODESYS_CCL:
       str->ccl.last_block = str->flags & CODING_STATE_END;
-      ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_DECODING);
+      /* When applying ccl program to stream, MUST NOT set NULL
+	 pointer to src.  */
+      ccl_driver (&str->ccl, (src ? (unsigned char *)src : (unsigned char*)""),
+		  dst, n, 0, CCL_MODE_DECODING);
       break;
     case CODESYS_ISO2022:
       decode_coding_iso2022 (decoding, src, dst, n);
@@ -2620,7 +2631,7 @@ struct encoding_stream
 };
 
 static ssize_t encoding_reader (Lstream *stream, unsigned char *data, size_t size);
-static ssize_t encoding_writer (Lstream *stream, CONST unsigned char *data,
+static ssize_t encoding_writer (Lstream *stream, const unsigned char *data,
 				size_t size);
 static int encoding_rewinder   (Lstream *stream);
 static int encoding_seekable_p (Lstream *stream);
@@ -2716,7 +2727,7 @@ encoding_reader (Lstream *stream, unsigned char *data, size_t size)
 }
 
 static ssize_t
-encoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
+encoding_writer (Lstream *stream, const unsigned char *data, size_t size)
 {
   struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
   ssize_t retval;
@@ -2831,7 +2842,7 @@ set_encoding_stream_coding_system (Lstream *lstr, Lisp_Object codesys)
 
 static Lisp_Object
 make_encoding_stream_1 (Lstream *stream, Lisp_Object codesys,
-			CONST char *mode)
+			const char *mode)
 {
   Lstream *lstr = Lstream_new (lstream_encoding, mode);
   struct encoding_stream *str = ENCODING_STREAM_DATA (lstr);
@@ -2862,8 +2873,8 @@ make_encoding_output_stream (Lstream *stream, Lisp_Object codesys)
    Store the encoded data into DST. */
 
 static void
-mule_encode (Lstream *encoding, CONST unsigned char *src,
-	     unsigned_char_dynarr *dst, unsigned int n)
+mule_encode (Lstream *encoding, const Bufbyte *src,
+	     unsigned_char_dynarr *dst, size_t n)
 {
   struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 
@@ -2895,7 +2906,10 @@ mule_encode (Lstream *encoding, CONST unsigned char *src,
       break;
     case CODESYS_CCL:
       str->ccl.last_block = str->flags & CODING_STATE_END;
-      ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_ENCODING);
+      /* When applying ccl program to stream, MUST NOT set NULL
+	 pointer to src.  */
+      ccl_driver (&str->ccl, ((src) ? src : (unsigned char*)""),
+		  dst, n, 0, CCL_MODE_ENCODING);
       break;
     case CODESYS_ISO2022:
       encode_coding_iso2022 (encoding, src, dst, n);
@@ -3009,14 +3023,11 @@ text.  BUFFER defaults to the current buffer if unspecified.
   ((c) >= 0xA1 && (c) <= 0xDF)
 
 static int
-detect_coding_sjis (struct detection_state *st, CONST unsigned char *src,
-		    unsigned int n)
+detect_coding_sjis (struct detection_state *st, const Extbyte *src, size_t n)
 {
-  int c;
-
   while (n--)
     {
-      c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
 	return 0;
       if (st->shift_jis.in_second_byte)
@@ -3034,10 +3045,9 @@ detect_coding_sjis (struct detection_state *st, CONST unsigned char *src,
 /* Convert Shift-JIS data to internal format. */
 
 static void
-decode_coding_sjis (Lstream *decoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_sjis (Lstream *decoding, const Extbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
-  unsigned char c;
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
   unsigned int flags  = str->flags;
   unsigned int ch     = str->ch;
@@ -3045,7 +3055,7 @@ decode_coding_sjis (Lstream *decoding, CONST unsigned char *src,
 
   while (n--)
     {
-      c = *src++;
+      unsigned char c = *(unsigned char *)src++;
 
       if (ch)
 	{
@@ -3102,10 +3112,9 @@ decode_coding_sjis (Lstream *decoding, CONST unsigned char *src,
 /* Convert internally-formatted data to Shift-JIS. */
 
 static void
-encode_coding_sjis (Lstream *encoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_sjis (Lstream *encoding, const Bufbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
-  unsigned char c;
   struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
   unsigned int flags  = str->flags;
   unsigned int ch     = str->ch;
@@ -3116,7 +3125,7 @@ encode_coding_sjis (Lstream *encoding, CONST unsigned char *src,
 
   while (n--)
     {
-      c = *src++;
+      Bufbyte c = *src++;
 #ifdef UTF2000
       switch (char_boundary)
 	{
@@ -3258,16 +3267,16 @@ Return the corresponding character.
 }
 
 DEFUN ("encode-shift-jis-char", Fencode_shift_jis_char, 1, 1, 0, /*
-Encode a JISX0208 character CHAR to SHIFT-JIS coding-system.
+Encode a JISX0208 character CHARACTER to SHIFT-JIS coding-system.
 Return the corresponding character code in SHIFT-JIS as a cons of two bytes.
 */
-       (ch))
+       (character))
 {
   Lisp_Object charset;
   int c1, c2, s1, s2;
 
-  CHECK_CHAR_COERCE_INT (ch);
-  BREAKUP_CHAR (XCHAR (ch), charset, c1, c2);
+  CHECK_CHAR_COERCE_INT (character);
+  BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
   if (EQ (charset, Vcharset_japanese_jisx0208))
     {
       ENCODE_SJIS (c1 | 0x80, c2 | 0x80, s1, s2);
@@ -3382,14 +3391,11 @@ Return the corresponding character code in SHIFT-JIS as a cons of two bytes.
 } while (0)
 
 static int
-detect_coding_big5 (struct detection_state *st, CONST unsigned char *src,
-		    unsigned int n)
+detect_coding_big5 (struct detection_state *st, const Extbyte *src, size_t n)
 {
-  int c;
-
   while (n--)
     {
-      c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO ||
 	  (c >= 0x80 && c <= 0xA0))
 	return 0;
@@ -3408,10 +3414,9 @@ detect_coding_big5 (struct detection_state *st, CONST unsigned char *src,
 /* Convert Big5 data to internal format. */
 
 static void
-decode_coding_big5 (Lstream *decoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_big5 (Lstream *decoding, const Extbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
-  unsigned char c;
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
   unsigned int flags  = str->flags;
   unsigned int ch     = str->ch;
@@ -3419,7 +3424,7 @@ decode_coding_big5 (Lstream *decoding, CONST unsigned char *src,
 
   while (n--)
     {
-      c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       if (ch)
 	{
 	  /* Previous character was first byte of Big5 char. */
@@ -3458,8 +3463,8 @@ decode_coding_big5 (Lstream *decoding, CONST unsigned char *src,
 /* Convert internally-formatted data to Big5. */
 
 static void
-encode_coding_big5 (Lstream *encoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_big5 (Lstream *encoding, const Bufbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
 #ifndef UTF2000
   unsigned char c;
@@ -3548,16 +3553,16 @@ Return the corresponding character.
 }
 
 DEFUN ("encode-big5-char", Fencode_big5_char, 1, 1, 0, /*
-Encode the Big5 character CH to BIG5 coding-system.
+Encode the Big5 character CHARACTER in the BIG5 coding-system.
 Return the corresponding character code in Big5.
 */
-       (ch))
+       (character))
 {
   Lisp_Object charset;
   int c1, c2, b1, b2;
 
-  CHECK_CHAR_COERCE_INT (ch);
-  BREAKUP_CHAR (XCHAR (ch), charset, c1, c2);
+  CHECK_CHAR_COERCE_INT (character);
+  BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
   if (EQ (charset, Vcharset_chinese_big5_1) ||
       EQ (charset, Vcharset_chinese_big5_2))
     {
@@ -3585,13 +3590,13 @@ Return T on success, NIL on failure.
 */
        (code, character))
 {
-  unsigned int c;
+  size_t c;
 
   CHECK_CHAR (character);
-  CHECK_INT (code);
+  CHECK_NATNUM (code);
   c = XINT (code);
 
-  if (c < sizeof (fcd->ucs_to_mule_table))
+  if (c < countof (fcd->ucs_to_mule_table))
     {
       fcd->ucs_to_mule_table[c] = character;
       return Qt;
@@ -3603,7 +3608,7 @@ Return T on success, NIL on failure.
 static Lisp_Object
 ucs_to_char (unsigned long code)
 {
-  if (code < sizeof (fcd->ucs_to_mule_table))
+  if (code < countof (fcd->ucs_to_mule_table))
     {
       return fcd->ucs_to_mule_table[code];
     }
@@ -3615,7 +3620,7 @@ ucs_to_char (unsigned long code)
       c = code % (94 * 94);
       return make_char
 	(MAKE_CHAR (CHARSET_BY_ATTRIBUTES
-		    (CHARSET_TYPE_94X94, code / (94 * 94) + '@',
+		    (94, 2, code / (94 * 94) + '@',
 		     CHARSET_LEFT_TO_RIGHT),
 		    c / 94 + 33, c % 94 + 33));
     }
@@ -3734,12 +3739,11 @@ encode_ucs4 (Lisp_Object charset,
 #endif
 
 static int
-detect_coding_ucs4 (struct detection_state *st, CONST unsigned char *src,
-		    unsigned int n)
+detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, size_t n)
 {
   while (n--)
     {
-      int c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       switch (st->ucs4.in_byte)
 	{
 	case 0:
@@ -3759,8 +3763,8 @@ detect_coding_ucs4 (struct detection_state *st, CONST unsigned char *src,
 }
 
 static void
-decode_coding_ucs4 (Lstream *decoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_ucs4 (Lstream *decoding, const Extbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
   unsigned int flags = str->flags;
@@ -3769,7 +3773,7 @@ decode_coding_ucs4 (Lstream *decoding, CONST unsigned char *src,
 
   while (n--)
     {
-      unsigned char c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       switch (counter)
 	{
 	case 0:
@@ -3795,8 +3799,8 @@ decode_coding_ucs4 (Lstream *decoding, CONST unsigned char *src,
 }
 
 static void
-encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
 #ifndef UTF2000
   struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
@@ -3809,7 +3813,7 @@ encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src,
   /* flags for handling composite chars.  We do a little switcharoo
      on the source while we're outputting the composite char. */
   unsigned int saved_n = 0;
-  CONST unsigned char *saved_src = NULL;
+  const unsigned char *saved_src = NULL;
   int in_composite = 0;
 
  back_to_square_n:
@@ -3862,9 +3866,9 @@ encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src,
 			    {
 			      /* #### Bother! We don't know how to
 				 handle this yet. */
-			      Dynarr_add (dst, 0);
-			      Dynarr_add (dst, 0);
-			      Dynarr_add (dst, 0);
+			      Dynarr_add (dst, '\0');
+			      Dynarr_add (dst, '\0');
+			      Dynarr_add (dst, '\0');
 			      Dynarr_add (dst, '~');
 			    }
 			  else
@@ -3936,12 +3940,11 @@ encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src,
 /************************************************************************/
 
 static int
-detect_coding_utf8 (struct detection_state *st, CONST unsigned char *src,
-		    unsigned int n)
+detect_coding_utf8 (struct detection_state *st, const Extbyte *src, size_t n)
 {
   while (n--)
     {
-      unsigned char c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       switch (st->utf8.in_byte)
 	{
 	case 0:
@@ -3971,8 +3974,8 @@ detect_coding_utf8 (struct detection_state *st, CONST unsigned char *src,
 }
 
 static void
-decode_coding_utf8 (Lstream *decoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
   unsigned int flags  = str->flags;
@@ -3982,7 +3985,7 @@ decode_coding_utf8 (Lstream *decoding, CONST unsigned char *src,
 
   while (n--)
     {
-      unsigned char c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       switch (counter)
 	{
 	case 0:
@@ -4087,8 +4090,8 @@ encode_utf8 (Lisp_Object charset,
 #endif
 
 static void
-encode_coding_utf8 (Lstream *encoding, CONST unsigned char *src,
-		    unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_utf8 (Lstream *encoding, const Bufbyte *src,
+		    unsigned_char_dynarr *dst, size_t n)
 {
   struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
   unsigned int flags  = str->flags;
@@ -4158,7 +4161,7 @@ encode_coding_utf8 (Lstream *encoding, CONST unsigned char *src,
   /* flags for handling composite chars.  We do a little switcharoo
      on the source while we're outputting the composite char. */
   unsigned int saved_n = 0;
-  CONST unsigned char *saved_src = NULL;
+  const unsigned char *saved_src = NULL;
   int in_composite = 0;
 
  back_to_square_n:
@@ -4736,7 +4739,7 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso,
 	}
       if (0x40 <= c && c <= 0x42)
 	{
-	  cs = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94, c,
+	  cs = CHARSET_BY_ATTRIBUTES (94, 2, c,
 				      *flags & CODING_STATE_R2L ?
 				      CHARSET_RIGHT_TO_LEFT :
 				      CHARSET_LEFT_TO_RIGHT);
@@ -4747,7 +4750,9 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso,
 
     default:
       {
-	int type =-1;
+	/* int type =-1; */
+	int chars = 0;
+	int single = 0;
 
 	if (c < '0' || c > '~')
 	  return 0; /* bad final byte */
@@ -4755,24 +4760,25 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso,
 	if (iso->esc >= ISO_ESC_2_8 &&
 	    iso->esc <= ISO_ESC_2_15)
 	  {
-	    type = ((iso->esc >= ISO_ESC_2_12) ?
-		    CHARSET_TYPE_96 : CHARSET_TYPE_94);
+	    chars = (iso->esc >= ISO_ESC_2_12) ? 96 : 94;
+	    single = 1; /* single-byte */
 	    reg = (iso->esc - ISO_ESC_2_8) & 3;
 	  }
 	else if (iso->esc >= ISO_ESC_2_4_8 &&
 		 iso->esc <= ISO_ESC_2_4_15)
 	  {
-	    type = ((iso->esc >= ISO_ESC_2_4_12) ?
-		    CHARSET_TYPE_96X96 : CHARSET_TYPE_94X94);
+	    chars = (iso->esc >= ISO_ESC_2_4_12) ? 96 : 94;
+	    single = -1; /* multi-byte */
 	    reg = (iso->esc - ISO_ESC_2_4_8) & 3;
 	  }
 	else
 	  {
 	    /* Can this ever be reached? -slb */
 	    abort();
+	    return 0;
 	  }
 
-	cs = CHARSET_BY_ATTRIBUTES (type, c,
+	cs = CHARSET_BY_ATTRIBUTES (chars, single, c,
 				    *flags & CODING_STATE_R2L ?
 				    CHARSET_RIGHT_TO_LEFT :
 				    CHARSET_LEFT_TO_RIGHT);
@@ -4865,8 +4871,7 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso,
 }
 
 static int
-detect_coding_iso2022 (struct detection_state *st, CONST unsigned char *src,
-		       unsigned int n)
+detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, size_t n)
 {
   int mask;
 
@@ -4896,7 +4901,7 @@ detect_coding_iso2022 (struct detection_state *st, CONST unsigned char *src,
 
   while (n--)
     {
-      int c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       if (c >= 0xA0)
 	{
 	  mask &= ~CODING_CATEGORY_ISO_7_MASK;
@@ -5056,8 +5061,8 @@ ensure_correct_direction (int direction, Lisp_Coding_System *codesys,
 /* Convert ISO2022-format data to internal format. */
 
 static void
-decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src,
-		       unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
+		       unsigned_char_dynarr *dst, size_t n)
 {
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
   unsigned int flags  = str->flags;
@@ -5077,7 +5082,7 @@ decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src,
 
   while (n--)
     {
-      unsigned char c = *src++;
+      unsigned char c = *(unsigned char *)src++;
       if (flags & CODING_STATE_ESCAPE)
 	{	/* Within ESC sequence */
 	  int retval = parse_iso2022_esc (coding_system, &str->iso2022,
@@ -5316,8 +5321,8 @@ static void
 iso2022_designate (Lisp_Object charset, unsigned char reg,
 		   struct encoding_stream *str, unsigned_char_dynarr *dst)
 {
-  static CONST char inter94[] = "()*+";
-  static CONST char inter96[] = ",-./";
+  static const char inter94[] = "()*+";
+  static const char inter96[] = ",-./";
   unsigned int type;
   unsigned char final;
   Lisp_Object old_charset = str->iso2022.charset[reg];
@@ -5401,8 +5406,8 @@ ensure_shift_out (struct encoding_stream *str, unsigned_char_dynarr *dst)
 /* Convert internally-formatted data to ISO2022 format. */
 
 static void
-encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src,
-		       unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src,
+		       unsigned_char_dynarr *dst, size_t n)
 {
   unsigned char charmask, c;
   unsigned char char_boundary;
@@ -5422,7 +5427,7 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src,
   /* flags for handling composite chars.  We do a little switcharoo
      on the source while we're outputting the composite char. */
   unsigned int saved_n = 0;
-  CONST unsigned char *saved_src = NULL;
+  const unsigned char *saved_src = NULL;
   int in_composite = 0;
 #endif /* ENABLE_COMPOSITE_CHARS */
 
@@ -5928,10 +5933,9 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src,
    contain all 256 possible byte values and that are not to be
    interpreted as being in any particular decoding. */
 static void
-decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src,
-			     unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_no_conversion (Lstream *decoding, const Extbyte *src,
+			     unsigned_char_dynarr *dst, size_t n)
 {
-  unsigned char c;
   struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
   unsigned int flags  = str->flags;
   unsigned int ch     = str->ch;
@@ -5939,7 +5943,7 @@ decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src,
 
   while (n--)
     {
-      c = *src++;
+      unsigned char c = *(unsigned char *)src++;
 
       DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
       DECODE_ADD_BINARY_CHAR (c, dst);
@@ -5953,8 +5957,8 @@ decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src,
 }
 
 static void
-encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src,
-			     unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src,
+			     unsigned_char_dynarr *dst, size_t n)
 {
   unsigned char c;
   struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
@@ -6077,8 +6081,9 @@ encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src,
 void
 syms_of_file_coding (void)
 {
-  deferror (&Qcoding_system_error, "coding-system-error",
-	    "Coding-system error", Qio_error);
+  INIT_LRECORD_IMPLEMENTATION (coding_system);
+
+  DEFERROR_STANDARD (Qcoding_system_error, Qio_error);
 
   DEFSUBR (Fcoding_system_p);
   DEFSUBR (Ffind_coding_system);
@@ -6359,9 +6364,9 @@ complex_vars_of_file_coding (void)
 
 #if defined(MULE) && !defined(UTF2000)
   {
-    unsigned int i;
+    size_t i;
 
-    for (i = 0; i < 65536; i++)
+    for (i = 0; i < countof (fcd->ucs_to_mule_table); i++)
       fcd->ucs_to_mule_table[i] = Qnil;
   }
   staticpro (&mule_to_ucs_table);