xemacs-beta: src/file-coding.c comparison

comparison src/file-coding.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	b8cc9ab3f761
children	da8ed4261e83

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 /* Rewritten by Ben Wing <ben@xemacs.org>. */
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"
 #include "elhash.h"
 #include "insdel.h"
 #include "lstream.h"
-#include "opaque.h"
 #ifdef MULE
 #include "mule-ccl.h"
 #include "chartab.h"
 #endif
 #include "file-coding.h"
-Lisp_Object Qcoding_system_error;
+Lisp_Object Qbuffer_file_coding_system, Qcoding_system_error;
 Lisp_Object Vkeyboard_coding_system;
 Lisp_Object Vterminal_coding_system;
 Lisp_Object Vcoding_system_for_read;
 Lisp_Object Vcoding_system_for_write;
 Lisp_Object Vfile_name_coding_system;
 /* Table of symbols identifying each coding category. */
 Lisp_Object coding_category_symbol[CODING_CATEGORY_LAST + 1];
+/* Coding system currently associated with each coding category. */
+Lisp_Object coding_category_system[CODING_CATEGORY_LAST + 1];
-struct file_coding_dump {
-/* Coding system currently associated with each coding category. */
+/* Table of all coding categories in decreasing order of priority.
-Lisp_Object coding_category_system[CODING_CATEGORY_LAST + 1];
+This describes a permutation of the possible coding categories. */
+int coding_category_by_priority[CODING_CATEGORY_LAST + 1];
-/* Table of all coding categories in decreasing order of priority.
-This describes a permutation of the possible coding categories. */
+Lisp_Object Qcoding_system_p;
-int coding_category_by_priority[CODING_CATEGORY_LAST + 1];
+Lisp_Object Qno_conversion, Qccl, Qiso2022;
-#ifdef MULE
-Lisp_Object ucs_to_mule_table[65536];
-#endif
-} *fcd;
-static const struct lrecord_description fcd_description_1[] = {
-{ XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 },
-#ifdef MULE
-{ XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), 65536 },
-#endif
-{ XD_END }
-};
-static const struct struct_description fcd_description = {
-sizeof (struct file_coding_dump),
-fcd_description_1
-};
-Lisp_Object mule_to_ucs_table;
-Lisp_Object Qcoding_systemp;
-Lisp_Object Qraw_text, Qno_conversion, Qccl, Qiso2022;
 /* Qinternal in general.c */
 Lisp_Object Qmnemonic, Qeol_type;
 Lisp_Object Qcr, Qcrlf, Qlf;
 Lisp_Object Qeol_cr, Qeol_crlf, Qeol_lf;
 Lisp_Object Qcharset_g0, Qcharset_g1, Qcharset_g2, Qcharset_g3;
 Lisp_Object Qforce_g0_on_output, Qforce_g1_on_output;
 Lisp_Object Qforce_g2_on_output, Qforce_g3_on_output;
 Lisp_Object Qno_iso6429;
 Lisp_Object Qinput_charset_conversion, Qoutput_charset_conversion;
-Lisp_Object Qescape_quoted;
+Lisp_Object Qctext, Qescape_quoted;
 Lisp_Object Qshort, Qno_ascii_eol, Qno_ascii_cntl, Qseven, Qlock_shift;
 #endif
 Lisp_Object Qencode, Qdecode;
 Lisp_Object Vcoding_system_hash_table;
 #endif /* MULE */
 EXFUN (Fcopy_coding_system, 2);
 #ifdef MULE
 struct detection_state;
 static int detect_coding_sjis (struct detection_state *st,
-			       const unsigned char *src,
+			       CONST unsigned char *src,
 			       unsigned int n);
 static void decode_coding_sjis (Lstream *decoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst,
 				unsigned int n);
 static void encode_coding_sjis (Lstream *encoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst,
 				unsigned int n);
 static int detect_coding_big5 (struct detection_state *st,
-			       const unsigned char *src,
+			       CONST unsigned char *src,
 			       unsigned int n);
 static void decode_coding_big5 (Lstream *decoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst, unsigned int n);
 static void encode_coding_big5 (Lstream *encoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst, unsigned int n);
 static int detect_coding_ucs4 (struct detection_state *st,
-			       const unsigned char *src,
+			       CONST unsigned char *src,
 			       unsigned int n);
 static void decode_coding_ucs4 (Lstream *decoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst, unsigned int n);
 static void encode_coding_ucs4 (Lstream *encoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst, unsigned int n);
 static int detect_coding_utf8 (struct detection_state *st,
-			       const unsigned char *src,
+			       CONST unsigned char *src,
 			       unsigned int n);
 static void decode_coding_utf8 (Lstream *decoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst, unsigned int n);
 static void encode_coding_utf8 (Lstream *encoding,
-				const unsigned char *src,
+				CONST unsigned char *src,
 				unsigned_char_dynarr *dst, unsigned int 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,
+				  CONST unsigned char *src,
 				  unsigned int n);
 static void decode_coding_iso2022 (Lstream *decoding,
-				   const unsigned char *src,
+				   CONST unsigned char *src,
 				   unsigned_char_dynarr *dst, unsigned int n);
 static void encode_coding_iso2022 (Lstream *encoding,
-				   const unsigned char *src,
+				   CONST unsigned char *src,
 				   unsigned_char_dynarr *dst, unsigned int n);
 #endif /* MULE */
 static void decode_coding_no_conversion (Lstream *decoding,
-					 const unsigned char *src,
+					 CONST unsigned char *src,
 					 unsigned_char_dynarr *dst,
 					 unsigned int n);
 static void encode_coding_no_conversion (Lstream *encoding,
-					 const unsigned char *src,
+					 CONST unsigned char *src,
 					 unsigned_char_dynarr *dst,
 					 unsigned int n);
-static void mule_decode (Lstream *decoding, const unsigned char *src,
+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,
+static void mule_encode (Lstream *encoding, CONST unsigned char *src,
 			 unsigned_char_dynarr *dst, unsigned int n);
 typedef struct codesys_prop codesys_prop;
 struct codesys_prop
 {
 typedef struct
 {
 Dynarr_declare (codesys_prop);
 } codesys_prop_dynarr;
-static const struct lrecord_description codesys_prop_description_1[] = {
-{ XD_LISP_OBJECT, offsetof (codesys_prop, sym) },
-{ XD_END }
-};
-static const struct struct_description codesys_prop_description = {
-sizeof (codesys_prop),
-codesys_prop_description_1
-};
-static const struct lrecord_description codesys_prop_dynarr_description_1[] = {
-XD_DYNARR_DESC (codesys_prop_dynarr, &codesys_prop_description),
-{ XD_END }
-};
-static const struct struct_description codesys_prop_dynarr_description = {
-sizeof (codesys_prop_dynarr),
-codesys_prop_dynarr_description_1
-};
 codesys_prop_dynarr *the_codesys_prop_dynarr;
 enum codesys_prop_enum
 {
 /************************************************************************/
 /*                       Coding system functions                        */
 /************************************************************************/
-static Lisp_Object mark_coding_system (Lisp_Object);
+static Lisp_Object mark_coding_system (Lisp_Object, void (*) (Lisp_Object));
 static void print_coding_system (Lisp_Object, Lisp_Object, int);
 static void finalize_coding_system (void *header, int for_disksave);
-#ifdef MULE
-static const struct lrecord_description ccs_description_1[] = {
-{ XD_LISP_OBJECT, offsetof (charset_conversion_spec, from_charset) },
-{ XD_LISP_OBJECT, offsetof (charset_conversion_spec, to_charset) },
-{ XD_END }
-};
-static const struct struct_description ccs_description = {
-sizeof (charset_conversion_spec),
-ccs_description_1
-};
-static const struct lrecord_description ccsd_description_1[] = {
-XD_DYNARR_DESC (charset_conversion_spec_dynarr, &ccs_description),
-{ XD_END }
-};
-static const struct struct_description ccsd_description = {
-sizeof (charset_conversion_spec_dynarr),
-ccsd_description_1
-};
-#endif
-static const struct lrecord_description coding_system_description[] = {
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, name) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, doc_string) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, mnemonic) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, post_read_conversion) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, pre_write_conversion) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, eol_lf) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, eol_crlf) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, eol_cr) },
-#ifdef MULE
-{ XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Coding_System, iso2022.initial_charset), 4 },
-{ XD_STRUCT_PTR,  offsetof (Lisp_Coding_System, iso2022.input_conv),  1, &ccsd_description },
-{ XD_STRUCT_PTR,  offsetof (Lisp_Coding_System, iso2022.output_conv), 1, &ccsd_description },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, ccl.decode) },
-{ XD_LISP_OBJECT, offsetof (Lisp_Coding_System, ccl.encode) },
-#endif
-{ XD_END }
-};
 DEFINE_LRECORD_IMPLEMENTATION ("coding-system", coding_system,
 			       mark_coding_system, print_coding_system,
 			       finalize_coding_system,
-			       0, 0, coding_system_description,
+			       0, 0, struct Lisp_Coding_System);
-			       Lisp_Coding_System);
 static Lisp_Object
-mark_coding_system (Lisp_Object obj)
+mark_coding_system (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 Lisp_Coding_System *codesys = XCODING_SYSTEM (obj);
-mark_object (CODING_SYSTEM_NAME (codesys));
+markobj (CODING_SYSTEM_NAME (codesys));
-mark_object (CODING_SYSTEM_DOC_STRING (codesys));
+markobj (CODING_SYSTEM_DOC_STRING (codesys));
-mark_object (CODING_SYSTEM_MNEMONIC (codesys));
+markobj (CODING_SYSTEM_MNEMONIC (codesys));
-mark_object (CODING_SYSTEM_EOL_LF (codesys));
+markobj (CODING_SYSTEM_EOL_LF (codesys));
-mark_object (CODING_SYSTEM_EOL_CRLF (codesys));
+markobj (CODING_SYSTEM_EOL_CRLF (codesys));
-mark_object (CODING_SYSTEM_EOL_CR (codesys));
+markobj (CODING_SYSTEM_EOL_CR (codesys));
 switch (CODING_SYSTEM_TYPE (codesys))
 {
 #ifdef MULE
 int i;
 case CODESYS_ISO2022:
 for (i = 0; i < 4; i++)
-	mark_object (CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i));
+	markobj (CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i));
 if (codesys->iso2022.input_conv)
 	{
 	  for (i = 0; i < Dynarr_length (codesys->iso2022.input_conv); i++)
 	    {
 	      struct charset_conversion_spec *ccs =
 		Dynarr_atp (codesys->iso2022.input_conv, i);
-	      mark_object (ccs->from_charset);
+	      markobj (ccs->from_charset);
-	      mark_object (ccs->to_charset);
+	      markobj (ccs->to_charset);
 	    }
 	}
 if (codesys->iso2022.output_conv)
 	{
 	  for (i = 0; i < Dynarr_length (codesys->iso2022.output_conv); i++)
 	    {
 	      struct charset_conversion_spec *ccs =
 		Dynarr_atp (codesys->iso2022.output_conv, i);
-	      mark_object (ccs->from_charset);
+	      markobj (ccs->from_charset);
-	      mark_object (ccs->to_charset);
+	      markobj (ccs->to_charset);
 	    }
 	}
 break;
 case CODESYS_CCL:
-mark_object (CODING_SYSTEM_CCL_DECODE (codesys));
+markobj (CODING_SYSTEM_CCL_DECODE (codesys));
-mark_object (CODING_SYSTEM_CCL_ENCODE (codesys));
+markobj (CODING_SYSTEM_CCL_ENCODE (codesys));
 break;
 #endif /* MULE */
 default:
 break;
 }
-mark_object (CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys));
+markobj (CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys));
 return CODING_SYSTEM_POST_READ_CONVERSION (codesys);
 }
 static void
 print_coding_system (Lisp_Object obj, Lisp_Object printcharfun,
 	  break;
 	}
 }
 }
-static eol_type_t
+static enum eol_type
 symbol_to_eol_type (Lisp_Object symbol)
 {
 CHECK_SYMBOL (symbol);
 if (NILP (symbol))      return EOL_AUTODETECT;
 if (EQ (symbol, Qlf))   return EOL_LF;
 signal_simple_error ("Unrecognized eol type", symbol);
 return EOL_AUTODETECT; /* not reached */
 }
 static Lisp_Object
-eol_type_to_symbol (eol_type_t type)
+eol_type_to_symbol (enum eol_type type)
 {
 switch (type)
 {
 default: abort ();
 case EOL_LF:         return Qlf;
 If there is no such coding system, nil is returned.  Otherwise the
 associated coding system object is returned.
 */
 (coding_system_or_name))
 {
+if (CODING_SYSTEMP (coding_system_or_name))
+return coding_system_or_name;
 if (NILP (coding_system_or_name))
 coding_system_or_name = Qbinary;
-else if (CODING_SYSTEMP (coding_system_or_name))
-return coding_system_or_name;
 else
 CHECK_SYMBOL (coding_system_or_name);
-while (1)
+return Fgethash (coding_system_or_name, Vcoding_system_hash_table, Qnil);
-{
-coding_system_or_name =
-	Fgethash (coding_system_or_name, Vcoding_system_hash_table, Qnil);
-if (CODING_SYSTEMP (coding_system_or_name) || NILP (coding_system_or_name))
-	return coding_system_or_name;
-}
 }
 DEFUN ("get-coding-system", Fget_coding_system, 1, 1, 0, /*
 Retrieve the coding system of the given name.
 Same as `find-coding-system' except that if there is no such
 /* This function can GC */
 struct coding_system_list_closure *cscl =
 (struct coding_system_list_closure *) coding_system_list_closure;
 Lisp_Object *coding_system_list = cscl->coding_system_list;
-*coding_system_list = Fcons (key, *coding_system_list);
+*coding_system_list = Fcons (XCODING_SYSTEM (value)->name,
+			       *coding_system_list);
 return 0;
 }
 DEFUN ("coding-system-list", Fcoding_system_list, 0, 0, 0, /*
 Return a list of the names of all defined coding systems.
 to->name = new_name;
 }
 return new_coding_system;
 }
-DEFUN ("coding-system-canonical-name-p", Fcoding_system_canonical_name_p, 1, 1, 0, /*
+DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias, 2, 2, 0, /*
-Return t if OBJECT names a coding system, and is not a coding system alias.
+Define symbol ALIAS as an alias for coding system CODING-SYSTEM.
 */
-(object))
+(alias, coding_system))
 {
-return CODING_SYSTEMP (Fgethash (object, Vcoding_system_hash_table, Qnil))
-? Qt : Qnil;
-}
-DEFUN ("coding-system-alias-p", Fcoding_system_alias_p, 1, 1, 0, /*
-Return t if OBJECT is a coding system alias.
-All coding system aliases are created by `define-coding-system-alias'.
-*/
-(object))
-{
-return SYMBOLP (Fgethash (object, Vcoding_system_hash_table, Qzero))
-? Qt : Qnil;
-}
-DEFUN ("coding-system-aliasee", Fcoding_system_aliasee, 1, 1, 0, /*
-Return the coding-system symbol for which symbol ALIAS is an alias.
-*/
-(alias))
-{
-Lisp_Object aliasee = Fgethash (alias, Vcoding_system_hash_table, Qnil);
-if (SYMBOLP (aliasee))
-return aliasee;
-else
-signal_simple_error ("Symbol is not a coding system alias", alias);
-return Qnil;		/* To keep the compiler happy */
-}
-static Lisp_Object
-append_suffix_to_symbol (Lisp_Object symbol, const char *ascii_string)
-{
-return Fintern (concat2 (Fsymbol_name (symbol), build_string (ascii_string)),
-		  Qnil);
-}
-/* A maphash function, for removing dangling coding system aliases. */
-static int
-dangling_coding_system_alias_p (Lisp_Object alias,
-				Lisp_Object aliasee,
-				void *dangling_aliases)
-{
-if (SYMBOLP (aliasee)
-&& NILP (Fgethash (aliasee, Vcoding_system_hash_table, Qnil)))
-{
-(*(int *) dangling_aliases)++;
-return 1;
-}
-else
-return 0;
-}
-DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias, 2, 2, 0, /*
-Define symbol ALIAS as an alias for coding system ALIASEE.
-You can use this function to redefine an alias that has already been defined,
-but you cannot redefine a name which is the canonical name for a coding system.
-\(a canonical name of a coding system is what is returned when you call
-`coding-system-name' on a coding system).
-ALIASEE itself can be an alias, which allows you to define nested aliases.
-You are forbidden, however, from creating alias loops or `dangling' aliases.
-These will be detected, and an error will be signaled if you attempt to do so.
-If ALIASEE is nil, then ALIAS will simply be undefined.
-See also `coding-system-alias-p', `coding-system-aliasee',
-and `coding-system-canonical-name-p'.
-*/
-(alias, aliasee))
-{
-Lisp_Object real_coding_system, probe;
 CHECK_SYMBOL (alias);
+if (!NILP (Ffind_coding_system (alias)))
-if (!NILP (Fcoding_system_canonical_name_p (alias)))
+signal_simple_error ("Symbol already names a coding system", alias);
-signal_simple_error
+coding_system = Fget_coding_system (coding_system);
-("Symbol is the canonical name of a coding system and cannot be redefined",
+Fputhash (alias, coding_system, Vcoding_system_hash_table);
-alias);
+/* Set up aliases for subsidiaries. */
-if (NILP (aliasee))
+if (XCODING_SYSTEM_EOL_TYPE (coding_system) == EOL_AUTODETECT)
 {
-Lisp_Object subsidiary_unix = append_suffix_to_symbol (alias, "-unix");
+Lisp_Object str;
-Lisp_Object subsidiary_dos  = append_suffix_to_symbol (alias, "-dos");
+XSETSTRING (str, symbol_name (XSYMBOL (alias)));
-Lisp_Object subsidiary_mac  = append_suffix_to_symbol (alias, "-mac");
+#define FROB(type, name)							\
+do {									\
-Fremhash (alias, Vcoding_system_hash_table);
+	Lisp_Object subsidiary = XCODING_SYSTEM_EOL_##type (coding_system);	\
+	if (!NILP (subsidiary))							\
-/* Undefine subsidiary aliases,
+	  Fdefine_coding_system_alias						\
-	 presumably created by a previous call to this function */
+	    (Fintern (concat2 (str, build_string (name)), Qnil), subsidiary);	\
-if (! NILP (Fcoding_system_alias_p (subsidiary_unix)) &&
+} while (0)
-	  ! NILP (Fcoding_system_alias_p (subsidiary_dos))  &&
+FROB (LF,   "-unix");
-	  ! NILP (Fcoding_system_alias_p (subsidiary_mac)))
+FROB (CRLF, "-dos");
-	{
+FROB (CR,   "-mac");
-	  Fdefine_coding_system_alias (subsidiary_unix, Qnil);
+#undef FROB
-	  Fdefine_coding_system_alias (subsidiary_dos,  Qnil);
+}
-	  Fdefine_coding_system_alias (subsidiary_mac,  Qnil);
+/* FSF return value is a vector of [ALIAS-unix ALIAS-doc ALIAS-mac],
-	}
-/* Undefine dangling coding system aliases. */
-{
-	int dangling_aliases;
-	do {
-	  dangling_aliases = 0;
-	  elisp_map_remhash (dangling_coding_system_alias_p,
-			     Vcoding_system_hash_table,
-			     &dangling_aliases);
-	} while (dangling_aliases > 0);
-}
-return Qnil;
-}
-if (CODING_SYSTEMP (aliasee))
-aliasee = XCODING_SYSTEM_NAME (aliasee);
-/* Checks that aliasee names a coding-system */
-real_coding_system = Fget_coding_system (aliasee);
-/* Check for coding system alias loops */
-if (EQ (alias, aliasee))
-alias_loop: signal_simple_error_2
-("Attempt to create a coding system alias loop", alias, aliasee);
-for (probe = aliasee;
-SYMBOLP (probe);
-probe = Fgethash (probe, Vcoding_system_hash_table, Qzero))
-{
-if (EQ (probe, alias))
-	goto alias_loop;
-}
-Fputhash (alias, aliasee, Vcoding_system_hash_table);
-/* Set up aliases for subsidiaries.
-#### There must be a better way to handle subsidiary coding systems. */
-{
-static const char *suffixes[] = { "-unix", "-dos", "-mac" };
-int i;
-for (i = 0; i < countof (suffixes); i++)
-{
-	Lisp_Object alias_subsidiary =
-	  append_suffix_to_symbol (alias, suffixes[i]);
-	Lisp_Object aliasee_subsidiary =
-	  append_suffix_to_symbol (aliasee, suffixes[i]);
-	if (! NILP (Ffind_coding_system (aliasee_subsidiary)))
-	  Fdefine_coding_system_alias (alias_subsidiary, aliasee_subsidiary);
-}
-}
-/* FSF return value is a vector of [ALIAS-unix ALIAS-dos ALIAS-mac],
 but it doesn't look intentional, so I'd rather return something
 meaningful or nothing at all. */
 return Qnil;
 }
 static Lisp_Object
-subsidiary_coding_system (Lisp_Object coding_system, eol_type_t type)
+subsidiary_coding_system (Lisp_Object coding_system, enum eol_type type)
 {
 Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
 Lisp_Object new_coding_system;
 if (CODING_SYSTEM_EOL_TYPE (cs) != EOL_AUTODETECT)
 /* Now go through the existing categories by priority to retrieve
 the categories not yet specified and preserve their priority
 order. */
 for (j = 0; j <= CODING_CATEGORY_LAST; j++)
 {
-int cat = fcd->coding_category_by_priority[j];
+int cat = coding_category_by_priority[j];
 if (category_to_priority[cat] < 0)
 	category_to_priority[cat] = i++;
 }
 /* Now we need to construct the inverse of the mapping we just
 constructed. */
 for (i = 0; i <= CODING_CATEGORY_LAST; i++)
-fcd->coding_category_by_priority[category_to_priority[i]] = i;
+coding_category_by_priority[category_to_priority[i]] = i;
 /* Phew!  That was confusing. */
 return Qnil;
 }
 {
 int i;
 Lisp_Object list = Qnil;
 for (i = CODING_CATEGORY_LAST; i >= 0; i--)
-list = Fcons (coding_category_symbol[fcd->coding_category_by_priority[i]],
+list = Fcons (coding_category_symbol[coding_category_by_priority[i]],
 		  list);
 return list;
 }
 DEFUN ("set-coding-category-system", Fset_coding_category_system, 2, 2, 0, /*
 (coding_category, coding_system))
 {
 int cat = decode_coding_category (coding_category);
 coding_system = Fget_coding_system (coding_system);
-fcd->coding_category_system[cat] = coding_system;
+coding_category_system[cat] = coding_system;
 return Qnil;
 }
 DEFUN ("coding-category-system", Fcoding_category_system, 1, 1, 0, /*
 Return the coding system associated with a coding category.
 */
 (coding_category))
 {
 int cat = decode_coding_category (coding_category);
-Lisp_Object sys = fcd->coding_category_system[cat];
+Lisp_Object sys = coding_category_system[cat];
 if (!NILP (sys))
 return XCODING_SYSTEM_NAME (sys);
 return Qnil;
 }
 /*                     Detecting the encoding of data                   */
 /************************************************************************/
 struct detection_state
 {
-eol_type_t eol_type;
+enum eol_type eol_type;
 int seen_non_ascii;
 int mask;
 #ifdef MULE
 struct
 {
 /* Perhaps the only thing useful you learn from intensive Microsoft
 technical interviews */
 return (mask & (mask - 1)) == 0;
 }
-static eol_type_t
+static enum eol_type
-detect_eol_type (struct detection_state *st, const unsigned char *src,
+detect_eol_type (struct detection_state *st, CONST unsigned char *src,
 		 unsigned int n)
 {
 int c;
 while (n--)
 {
 c = *src++;
-if (c == '\n')
+if (c == '\r')
-	{
-	  if (st->eol.just_saw_cr)
-	    return EOL_CRLF;
-	  else if (st->eol.seen_anything)
-	    return EOL_LF;
-	}
-else if (st->eol.just_saw_cr)
-	return EOL_CR;
-else if (c == '\r')
 	st->eol.just_saw_cr = 1;
 else
-	st->eol.just_saw_cr = 0;
+	{
+	  if (c == '\n')
+	    {
+	      if (st->eol.just_saw_cr)
+		return EOL_CRLF;
+	      else if (st->eol.seen_anything)
+		return EOL_LF;
+	    }
+	  else if (st->eol.just_saw_cr)
+	    return EOL_CR;
+	  st->eol.just_saw_cr = 0;
+	}
 st->eol.seen_anything = 1;
 }
 return EOL_AUTODETECT;
 }
 is present in st->mask
 1 == definitive answers are here for both st->eol_type and st->mask
 */
 static int
-detect_coding_type (struct detection_state *st, const Extbyte *src,
+detect_coding_type (struct detection_state *st, CONST unsigned char *src,
 		    unsigned int n, int just_do_eol)
 {
 int c;
 if (st->eol_type == EOL_AUTODETECT)
 		 "Invalid `default-buffer-file-coding-system', set to nil");
 	      XBUFFER (Vbuffer_defaults)->buffer_file_coding_system = Qnil;
 	    }
 	}
 if (NILP (retval))
-	retval = Fget_coding_system (Qraw_text);
+	retval = Fget_coding_system (Qno_conversion);
 return retval;
 }
 else
 {
 int i;
 #endif
 /* Look through the coding categories by priority and find
 	 the first one that is allowed. */
 for (i = 0; i <= CODING_CATEGORY_LAST; i++)
 	{
-	  cat = fcd->coding_category_by_priority[i];
+	  cat = coding_category_by_priority[i];
 	  if ((mask & (1 << cat)) &&
-	      !NILP (fcd->coding_category_system[cat]))
+	      !NILP (coding_category_system[cat]))
 	    break;
 	}
 if (cat >= 0)
-	return fcd->coding_category_system[cat];
+	return coding_category_system[cat];
 else
-	return Fget_coding_system (Qraw_text);
+	return Fget_coding_system (Qno_conversion);
 }
 }
 /* Given a seekable read stream and potential coding system and EOL type
 as specified, do any autodetection that is called for.  If the
-coding system and/or EOL type are not `autodetect', they will be left
+coding system and/or EOL type are not autodetect, they will be left
 alone; but this function will never return an autodetect coding system
 or EOL type.
 This function does not automatically fetch subsidiary coding systems;
 that should be unnecessary with the explicit eol-type argument. */
-#define LENGTH(string_constant) (sizeof (string_constant) - 1)
 void
 determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out,
-			      eol_type_t *eol_type_in_out)
+			      enum eol_type *eol_type_in_out)
 {
 struct detection_state decst;
 if (*eol_type_in_out == EOL_AUTODETECT)
 *eol_type_in_out = XCODING_SYSTEM_EOL_TYPE (*codesys_in_out);
 xzero (decst);
 decst.eol_type = *eol_type_in_out;
 decst.mask = ~0;
 /* If autodetection is called for, do it now. */
-if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT
+if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT ||
-|| *eol_type_in_out == EOL_AUTODETECT)
+*eol_type_in_out == EOL_AUTODETECT)
 {
-Extbyte buf[4096];
-Lisp_Object coding_system = Qnil;
+while (1)
-Extbyte *p;
+	{
-ssize_t nread = Lstream_read (stream, buf, sizeof (buf));
+	  unsigned char random_buffer[4096];
-Extbyte *scan_end;
+	  int nread;
-/* Look for initial "-*-"; mode line prefix */
+	  nread = Lstream_read (stream, random_buffer, sizeof (random_buffer));
-for (p = buf,
+	  if (!nread)
-	     scan_end = buf + nread - LENGTH ("-*-coding:?-*-");
-	   p <= scan_end
-	     && *p != '\n'
-	     && *p != '\r';
-	   p++)
-	if (*p == '-' && *(p+1) == '*' && *(p+2) == '-')
-	  {
-	    Extbyte *local_vars_beg = p + 3;
-	    /* Look for final "-*-"; mode line suffix */
-	    for (p = local_vars_beg,
-		   scan_end = buf + nread - LENGTH ("-*-");
-		 p <= scan_end
-		   && *p != '\n'
-		   && *p != '\r';
-		 p++)
-	      if (*p == '-' && *(p+1) == '*' && *(p+2) == '-')
-		{
-		  Extbyte *suffix = p;
-		  /* Look for "coding:" */
-		  for (p = local_vars_beg,
-			 scan_end = suffix - LENGTH ("coding:?");
-		       p <= scan_end;
-		       p++)
-		    if (memcmp ("coding:", p, LENGTH ("coding:")) == 0
-			&& (p == local_vars_beg
-			    || (*(p-1) == ' '  ||
-				*(p-1) == '\t' ||
-				*(p-1) == ';')))
-		      {
-			Extbyte save;
-			int n;
-			p += LENGTH ("coding:");
-			while (*p == ' ' || *p == '\t') p++;
-			/* Get coding system name */
-			save = *suffix; *suffix = '\0';
-			/* Characters valid in a MIME charset name (rfc 1521),
-			   and in a Lisp symbol name. */
-			n = strspn ( (char *) p,
-				    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-				    "abcdefghijklmnopqrstuvwxyz"
-				    "0123456789"
-				    "!$%&*+-.^_{|}~");
-			*suffix = save;
-			if (n > 0)
-			  {
-			    save = p[n]; p[n] = '\0';
-			    coding_system =
-			      Ffind_coding_system (intern ((char *) p));
-			    p[n] = save;
-			  }
-			break;
-		      }
-		  break;
-		}
 	    break;
-	  }
+	  if (detect_coding_type (&decst, random_buffer, nread,
+				  XCODING_SYSTEM_TYPE (*codesys_in_out) !=
-if (NILP (coding_system))
+				  CODESYS_AUTODETECT))
-	do
+	    break;
-	  {
+	}
-	    if (detect_coding_type (&decst, buf, nread,
-				    XCODING_SYSTEM_TYPE (*codesys_in_out)
-				    != CODESYS_AUTODETECT))
-	      break;
-	    nread = Lstream_read (stream, buf, sizeof (buf));
-	    if (nread == 0)
-	      break;
-	  }
-	while (1);
-else if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT
-	       && XCODING_SYSTEM_EOL_TYPE (coding_system) == EOL_AUTODETECT)
-	do
-	  {
-	    if (detect_coding_type (&decst, buf, nread, 1))
-	      break;
-	    nread = Lstream_read (stream, buf, sizeof (buf));
-	    if (!nread)
-	      break;
-	  }
-	while (1);
 *eol_type_in_out = decst.eol_type;
 if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT)
-	{
+	*codesys_in_out = coding_system_from_mask (decst.mask);
-	  if (NILP (coding_system))
-	    *codesys_in_out = coding_system_from_mask (decst.mask);
-	  else
-	    *codesys_in_out = coding_system;
-	}
 }
 /* If we absolutely can't determine the EOL type, just assume LF. */
 if (*eol_type_in_out == EOL_AUTODETECT)
 *eol_type_in_out = EOL_LF;
 decst.eol_type = EOL_AUTODETECT;
 decst.mask = ~0;
 while (1)
 {
 unsigned char random_buffer[4096];
-ssize_t nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
+int nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
 if (!nread)
 	break;
 if (detect_coding_type (&decst, random_buffer, nread, 0))
 	break;
 #ifdef MULE
 decst.mask = postprocess_iso2022_mask (decst.mask);
 #endif
 for (i = CODING_CATEGORY_LAST; i >= 0; i--)
 	{
-	  int sys = fcd->coding_category_by_priority[i];
+	  int sys = coding_category_by_priority[i];
 	  if (decst.mask & (1 << sys))
 	    {
-	      Lisp_Object codesys = fcd->coding_category_system[sys];
+	      Lisp_Object codesys = coding_category_system[sys];
 	      if (!NILP (codesys))
 		codesys = subsidiary_coding_system (codesys, decst.eol_type);
 	      val = Fcons (codesys, val);
 	    }
 	}
 /* EOL_TYPE specifies the type of end-of-line conversion that
 currently applies.  We need to keep this separate from the
 EOL type stored in CODESYS because the latter might indicate
 automatic EOL-type detection while the former will always
 indicate a particular EOL type. */
-eol_type_t eol_type;
+enum eol_type eol_type;
 #ifdef MULE
 /* Additional ISO2022 information.  We define the structure above
 because it's also needed by the detection routines. */
 struct iso2022_decoder iso2022;
 /* Additional information (the state of the running CCL program)
 used by the CCL decoder. */
 struct ccl_program ccl;
-/* counter for UTF-8 or UCS-4 */
-unsigned char counter;
 #endif
 struct detection_state decst;
 };
-static ssize_t decoding_reader (Lstream *stream,
+static int decoding_reader     (Lstream *stream,       unsigned char *data, size_t size);
-				unsigned char *data, size_t size);
+static int decoding_writer     (Lstream *stream, CONST unsigned char *data, size_t size);
-static ssize_t decoding_writer (Lstream *stream,
-				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);
 static int decoding_closer     (Lstream *stream);
-static Lisp_Object decoding_marker (Lisp_Object stream);
+static Lisp_Object decoding_marker (Lisp_Object stream,
+				    void (*markobj) (Lisp_Object));
 DEFINE_LSTREAM_IMPLEMENTATION ("decoding", lstream_decoding,
 			       sizeof (struct decoding_stream));
 static Lisp_Object
-decoding_marker (Lisp_Object stream)
+decoding_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
 {
 Lstream *str = DECODING_STREAM_DATA (XLSTREAM (stream))->other_end;
 Lisp_Object str_obj;
 /* We do not need to mark the coding systems or charsets stored
 within the stream because they are stored in a global list
 and automatically marked. */
 XSETLSTREAM (str_obj, str);
-mark_object (str_obj);
+markobj (str_obj);
 if (str->imp->marker)
-return (str->imp->marker) (str_obj);
+return (str->imp->marker) (str_obj, markobj);
 else
 return Qnil;
 }
 /* Read SIZE bytes of data and store it into DATA.  We are a decoding stream
 so we read data from the other end, decode it, and store it into DATA. */
-static ssize_t
+static int
 decoding_reader (Lstream *stream, unsigned char *data, size_t size)
 {
 struct decoding_stream *str = DECODING_STREAM_DATA (stream);
 unsigned char *orig_data = data;
-ssize_t read_size;
+int read_size;
 int error_occurred = 0;
 /* We need to interface to mule_decode(), which expects to take some
 amount of data and store the result into a Dynarr.  We have
 mule_decode() store into str->runoff, and take data from there
 return error_occurred ? -1 : 0;
 else
 return data - orig_data;
 }
-static ssize_t
+static int
-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;
+int retval;
 /* 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);
 }
 else if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_CCL)
 {
 setup_ccl_program (&str->ccl, CODING_SYSTEM_CCL_DECODE (str->codesys));
 }
-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;
 }
 static int
 decoding_rewinder (Lstream *stream)
 stream for reading using a non-fully-specified coding system and
 a non-seekable input stream. */
 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);
 Lisp_Object obj;
 written to that stream; that is handled in decoding_reader()
 or decoding_writer().  This allows the same functions to
 be used for both reading and writing. */
 static void
-mule_decode (Lstream *decoding, const unsigned char *src,
+mule_decode (Lstream *decoding, CONST unsigned char *src,
 	     unsigned_char_dynarr *dst, unsigned int n)
 {
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 /* If necessary, do encoding-detection now.  We do this when
 break;
 case CODESYS_UTF8:
 decode_coding_utf8 (decoding, src, dst, n);
 break;
 case CODESYS_CCL:
-str->ccl.last_block = str->flags & CODING_STATE_END;
+ccl_driver (&str->ccl, src, dst, n, 0);
-ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_DECODING);
 break;
 case CODESYS_ISO2022:
 decode_coding_iso2022 (decoding, src, dst, n);
 break;
 #endif /* MULE */
 while (1)
 {
 char tempbuf[1024]; /* some random amount */
 Bufpos newpos, even_newer_pos;
 Bufpos oldpos = lisp_buffer_stream_startpos (istr);
-ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
 if (!size_in_bytes)
 	break;
 newpos = lisp_buffer_stream_startpos (istr);
 Lstream_write (ostr, tempbuf, size_in_bytes);
 used by the CCL encoder. */
 struct ccl_program ccl;
 #endif /* MULE */
 };
-static ssize_t encoding_reader (Lstream *stream, unsigned char *data, size_t size);
+static int encoding_reader (Lstream *stream, unsigned char *data, size_t size);
-static ssize_t encoding_writer (Lstream *stream, const unsigned char *data,
+static int encoding_writer (Lstream *stream, CONST unsigned char *data,
-				size_t size);
+			    size_t size);
 static int encoding_rewinder   (Lstream *stream);
 static int encoding_seekable_p (Lstream *stream);
 static int encoding_flusher    (Lstream *stream);
 static int encoding_closer     (Lstream *stream);
-static Lisp_Object encoding_marker (Lisp_Object stream);
+static Lisp_Object encoding_marker (Lisp_Object stream,
+				    void (*markobj) (Lisp_Object));
 DEFINE_LSTREAM_IMPLEMENTATION ("encoding", lstream_encoding,
 			       sizeof (struct encoding_stream));
 static Lisp_Object
-encoding_marker (Lisp_Object stream)
+encoding_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
 {
 Lstream *str = ENCODING_STREAM_DATA (XLSTREAM (stream))->other_end;
 Lisp_Object str_obj;
 /* We do not need to mark the coding systems or charsets stored
 within the stream because they are stored in a global list
 and automatically marked. */
 XSETLSTREAM (str_obj, str);
-mark_object (str_obj);
+markobj (str_obj);
 if (str->imp->marker)
-return (str->imp->marker) (str_obj);
+return (str->imp->marker) (str_obj, markobj);
 else
 return Qnil;
 }
 /* Read SIZE bytes of data and store it into DATA.  We are a encoding stream
 so we read data from the other end, encode it, and store it into DATA. */
-static ssize_t
+static int
 encoding_reader (Lstream *stream, unsigned char *data, size_t size)
 {
 struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
 unsigned char *orig_data = data;
-ssize_t read_size;
+int read_size;
 int error_occurred = 0;
 /* We need to interface to mule_encode(), which expects to take some
 amount of data and store the result into a Dynarr.  We have
 mule_encode() store into str->runoff, and take data from there
 return error_occurred ? -1 : 0;
 else
 return data - orig_data;
 }
-static ssize_t
+static int
-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;
+int retval;
 /* Encode 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_encode (stream, data, str->runoff, size);
 reset_encoding_stream (str);
 }
 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);
 Lisp_Object obj;
 /* Convert N bytes of internally-formatted data stored in SRC to an
 external format, according to the encoding stream ENCODING.
 Store the encoded data into DST. */
 static void
-mule_encode (Lstream *encoding, const unsigned char *src,
+mule_encode (Lstream *encoding, CONST unsigned char *src,
 	     unsigned_char_dynarr *dst, unsigned int n)
 {
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 switch (CODING_SYSTEM_TYPE (str->codesys))
 break;
 case CODESYS_UTF8:
 encode_coding_utf8 (encoding, src, dst, n);
 break;
 case CODESYS_CCL:
-str->ccl.last_block = str->flags & CODING_STATE_END;
+ccl_driver (&str->ccl, src, dst, n, 0);
-ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_ENCODING);
 break;
 case CODESYS_ISO2022:
 encode_coding_iso2022 (encoding, src, dst, n);
 break;
 #endif /* MULE */
 while (1)
 {
 char tempbuf[1024]; /* some random amount */
 Bufpos newpos, even_newer_pos;
 Bufpos oldpos = lisp_buffer_stream_startpos (istr);
-ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
 if (!size_in_bytes)
 	break;
 newpos = lisp_buffer_stream_startpos (istr);
 Lstream_write (ostr, tempbuf, size_in_bytes);
 #define BYTE_SJIS_KATAKANA_P(c)	\
 ((c) >= 0xA1 && (c) <= 0xDF)
 static int
-detect_coding_sjis (struct detection_state *st, const unsigned char *src,
+detect_coding_sjis (struct detection_state *st, CONST unsigned char *src,
 		    unsigned int n)
 {
 int c;
 while (n--)
 }
 /* Convert Shift-JIS data to internal format. */
 static void
-decode_coding_sjis (Lstream *decoding, const unsigned char *src,
+decode_coding_sjis (Lstream *decoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char c;
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 unsigned int flags  = str->flags;
 }
 /* Convert internally-formatted data to Shift-JIS. */
 static void
-encode_coding_sjis (Lstream *encoding, const unsigned char *src,
+encode_coding_sjis (Lstream *encoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char c;
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 unsigned int flags  = str->flags;
 b2 = I % BIG5_SAME_ROW;						\
 b2 += b2 < 0x3F ? 0x40 : 0x62;					\
 } while (0)
 static int
-detect_coding_big5 (struct detection_state *st, const unsigned char *src,
+detect_coding_big5 (struct detection_state *st, CONST unsigned char *src,
 		    unsigned int n)
 {
 int c;
 while (n--)
 }
 /* Convert Big5 data to internal format. */
 static void
-decode_coding_big5 (Lstream *decoding, const unsigned char *src,
+decode_coding_big5 (Lstream *decoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char c;
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 unsigned int flags  = str->flags;
 }
 /* Convert internally-formatted data to Big5. */
 static void
-encode_coding_big5 (Lstream *encoding, const unsigned char *src,
+encode_coding_big5 (Lstream *encoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char c;
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 unsigned int flags  = str->flags;
 /*                                                                      */
 /*  UCS-4 character codes are implemented as nonnegative integers.      */
 /*                                                                      */
 /************************************************************************/
+Lisp_Object ucs_to_mule_table[65536];
+Lisp_Object mule_to_ucs_table;
 DEFUN ("set-ucs-char", Fset_ucs_char, 2, 2, 0, /*
 Map UCS-4 code CODE to Mule character CHARACTER.
 Return T on success, NIL on failure.
 CHECK_CHAR (character);
 CHECK_INT (code);
 c = XINT (code);
-if (c < sizeof (fcd->ucs_to_mule_table))
+if (c < sizeof (ucs_to_mule_table))
 {
-fcd->ucs_to_mule_table[c] = character;
+ucs_to_mule_table[c] = character;
 return Qt;
 }
 else
 return Qnil;
 }
 static Lisp_Object
 ucs_to_char (unsigned long code)
 {
-if (code < sizeof (fcd->ucs_to_mule_table))
+if (code < sizeof (ucs_to_mule_table))
 {
-return fcd->ucs_to_mule_table[code];
+return ucs_to_mule_table[code];
 }
 else if ((0xe00000 <= code) && (code <= 0xe00000 + 94 * 94 * 14))
 {
 unsigned int c;
 Dynarr_add (dst, (code >>  8) & 255);
 Dynarr_add (dst,  code        & 255);
 }
 static int
-detect_coding_ucs4 (struct detection_state *st, const unsigned char *src,
+detect_coding_ucs4 (struct detection_state *st, CONST unsigned char *src,
 		    unsigned int n)
 {
 while (n--)
 {
 int c = *src++;
 }
 return CODING_CATEGORY_UCS4_MASK;
 }
 static void
-decode_coding_ucs4 (Lstream *decoding, const unsigned char *src,
+decode_coding_ucs4 (Lstream *decoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 unsigned int flags = str->flags;
 unsigned int ch    = str->ch;
-unsigned char counter = str->counter;
 while (n--)
 {
 unsigned char c = *src++;
-switch (counter)
+switch (flags)
 	{
 	case 0:
 	  ch = c;
-	  counter = 3;
+	  flags = 3;
 	  break;
 	case 1:
 	  decode_ucs4 ( ( ch << 8 ) | c, dst);
 	  ch = 0;
-	  counter = 0;
+	  flags = 0;
 	  break;
 	default:
 	  ch = ( ch << 8 ) | c;
-	  counter--;
+	  flags--;
 	}
 }
-if (counter & CODING_STATE_END)
+if (flags & CODING_STATE_END)
 DECODE_OUTPUT_PARTIAL_CHAR (ch);
 str->flags = flags;
 str->ch    = ch;
-str->counter = counter;
 }
 static void
-encode_coding_ucs4 (Lstream *encoding, const unsigned char *src,
+encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 unsigned int flags = str->flags;
 unsigned int ch = str->ch;
 #ifdef ENABLE_COMPOSITE_CHARS
 /* 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:
 #endif
 /************************************************************************/
 /*                           UTF-8 methods                              */
 /************************************************************************/
 static int
-detect_coding_utf8 (struct detection_state *st, const unsigned char *src,
+detect_coding_utf8 (struct detection_state *st, CONST unsigned char *src,
 		    unsigned int n)
 {
 while (n--)
 {
 unsigned char c = *src++;
 }
 return CODING_CATEGORY_UTF8_MASK;
 }
 static void
-decode_coding_utf8 (Lstream *decoding, const unsigned char *src,
+decode_coding_utf8 (Lstream *decoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 unsigned int flags  = str->flags;
 unsigned int ch     = str->ch;
 eol_type_t eol_type = str->eol_type;
-unsigned char counter = str->counter;
 while (n--)
 {
 unsigned char c = *src++;
-switch (counter)
+switch (flags)
 	{
 	case 0:
 	  if ( c >= 0xfc )
 	    {
 	      ch = c & 0x01;
-	      counter = 5;
+	      flags = 5;
 	    }
 	  else if ( c >= 0xf8 )
 	    {
 	      ch = c & 0x03;
-	      counter = 4;
+	      flags = 4;
 	    }
 	  else if ( c >= 0xf0 )
 	    {
 	      ch = c & 0x07;
-	      counter = 3;
+	      flags = 3;
 	    }
 	  else if ( c >= 0xe0 )
 	    {
 	      ch = c & 0x0f;
-	      counter = 2;
+	      flags = 2;
 	    }
 	  else if ( c >= 0xc0 )
 	    {
 	      ch = c & 0x1f;
-	      counter = 1;
+	      flags = 1;
 	    }
 	  else
 	    {
 	      DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
 	      decode_ucs4 (c, dst);
 	  break;
 	case 1:
 	  ch = ( ch << 6 ) | ( c & 0x3f );
 	  decode_ucs4 (ch, dst);
 	  ch = 0;
-	  counter = 0;
+	  flags = 0;
 	  break;
 	default:
 	  ch = ( ch << 6 ) | ( c & 0x3f );
-	  counter--;
+	  flags--;
 	}
 label_continue_loop:;
 }
 if (flags & CODING_STATE_END)
 DECODE_OUTPUT_PARTIAL_CHAR (ch);
 str->flags = flags;
 str->ch    = ch;
-str->counter = counter;
 }
 static void
 encode_utf8 (Lisp_Object charset,
 	     unsigned char h, unsigned char l, unsigned_char_dynarr *dst)
 Dynarr_add (dst,  (code        & 0x3f) | 0x80);
 }
 }
 static void
-encode_coding_utf8 (Lstream *encoding, const unsigned char *src,
+encode_coding_utf8 (Lstream *encoding, CONST unsigned char *src,
 		    unsigned_char_dynarr *dst, unsigned int n)
 {
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 unsigned int flags  = str->flags;
 unsigned int ch     = str->ch;
 #ifdef ENABLE_COMPOSITE_CHARS
 /* 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:
 #endif /* ENABLE_COMPOSITE_CHARS */
 while (n--)
 {
 unsigned char c = *src++;
 if (BYTE_ASCII_P (c))
 iso->switched_dir_and_no_valid_charset_yet = 0;
 return 1;
 }
 static int
-detect_coding_iso2022 (struct detection_state *st, const unsigned char *src,
+detect_coding_iso2022 (struct detection_state *st, CONST unsigned char *src,
 		       unsigned int n)
 {
 int mask;
 /* #### There are serious deficiencies in the recognition mechanism
 }
 /* Convert ISO2022-format data to internal format. */
 static void
-decode_coding_iso2022 (Lstream *decoding, const unsigned char *src,
+decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src,
 		       unsigned_char_dynarr *dst, unsigned int n)
 {
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 unsigned int flags  = str->flags;
 unsigned int ch     = str->ch;
 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 inter94[] = "()*+";
-static const char inter96[] = ",-./";
+static CONST char inter96[] = ",-./";
 unsigned int type;
 unsigned char final;
 Lisp_Object old_charset = str->iso2022.charset[reg];
 str->iso2022.charset[reg] = charset;
 }
 /* Convert internally-formatted data to ISO2022 format. */
 static void
-encode_coding_iso2022 (Lstream *encoding, const unsigned char *src,
+encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src,
 		       unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char charmask, c;
 unsigned char char_boundary;
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 #ifdef ENABLE_COMPOSITE_CHARS
 /* 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 */
 char_boundary = str->iso2022.current_char_boundary;
 charset = str->iso2022.current_charset;
 /* This is used when reading in "binary" files -- i.e. files that may
 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,
+decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src,
 			     unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char c;
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
 unsigned int flags  = str->flags;
 str->flags = flags;
 str->ch    = ch;
 }
 static void
-encode_coding_no_conversion (Lstream *encoding, const unsigned char *src,
+encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src,
 			     unsigned_char_dynarr *dst, unsigned int n)
 {
 unsigned char c;
 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
 unsigned int flags  = str->flags;
 str->flags = flags;
 str->ch    = ch;
 }
+/************************************************************************/
+/*                   Simple internal/external functions                 */
+/************************************************************************/
+static Extbyte_dynarr *conversion_out_dynarr;
+static Bufbyte_dynarr *conversion_in_dynarr;
+/* Determine coding system from coding format */
+/* #### not correct for all values of `fmt'! */
+static Lisp_Object
+external_data_format_to_coding_system (enum external_data_format fmt)
+{
+switch (fmt)
+{
+case FORMAT_FILENAME:
+case FORMAT_TERMINAL:
+if (EQ (Vfile_name_coding_system, Qnil) ||
+	  EQ (Vfile_name_coding_system, Qbinary))
+	return Qnil;
+else
+	return Fget_coding_system (Vfile_name_coding_system);
+#ifdef MULE
+case FORMAT_CTEXT:
+return Fget_coding_system (Qctext);
+#endif
+default:
+return Qnil;
+}
+}
+Extbyte *
+convert_to_external_format (CONST Bufbyte *ptr,
+			    Bytecount len,
+			    Extcount *len_out,
+			    enum external_data_format fmt)
+{
+Lisp_Object coding_system = external_data_format_to_coding_system (fmt);
+if (!conversion_out_dynarr)
+conversion_out_dynarr = Dynarr_new (Extbyte);
+else
+Dynarr_reset (conversion_out_dynarr);
+if (NILP (coding_system))
+{
+CONST Bufbyte *end = ptr + len;
+for (; ptr < end;)
+{
+Bufbyte c =
+(BYTE_ASCII_P (*ptr))		   ? *ptr :
+(*ptr == LEADING_BYTE_CONTROL_1)	   ? (*(ptr+1) - 0x20) :
+(*ptr == LEADING_BYTE_LATIN_ISO8859_1) ? (*(ptr+1)) :
+'~';
+Dynarr_add (conversion_out_dynarr, (Extbyte) c);
+INC_CHARPTR (ptr);
+}
+#ifdef ERROR_CHECK_BUFPOS
+assert (ptr == end);
+#endif
+}
+else
+{
+Lisp_Object instream, outstream, da_outstream;
+Lstream *istr, *ostr;
+struct gcpro gcpro1, gcpro2, gcpro3;
+char tempbuf[1024]; /* some random amount */
+instream = make_fixed_buffer_input_stream ((unsigned char *) ptr, len);
+da_outstream = make_dynarr_output_stream
+((unsigned_char_dynarr *) conversion_out_dynarr);
+outstream =
+make_encoding_output_stream (XLSTREAM (da_outstream), coding_system);
+istr = XLSTREAM (instream);
+ostr = XLSTREAM (outstream);
+GCPRO3 (instream, outstream, da_outstream);
+while (1)
+{
+int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+if (!size_in_bytes)
+break;
+Lstream_write (ostr, tempbuf, size_in_bytes);
+}
+Lstream_close (istr);
+Lstream_close (ostr);
+UNGCPRO;
+Lstream_delete (istr);
+Lstream_delete (ostr);
+Lstream_delete (XLSTREAM (da_outstream));
+}
+*len_out = Dynarr_length (conversion_out_dynarr);
+Dynarr_add (conversion_out_dynarr, 0); /* remember to zero-terminate! */
+return Dynarr_atp (conversion_out_dynarr, 0);
+}
+Bufbyte *
+convert_from_external_format (CONST Extbyte *ptr,
+			      Extcount len,
+			      Bytecount *len_out,
+			      enum external_data_format fmt)
+{
+Lisp_Object coding_system = external_data_format_to_coding_system (fmt);
+if (!conversion_in_dynarr)
+conversion_in_dynarr = Dynarr_new (Bufbyte);
+else
+Dynarr_reset (conversion_in_dynarr);
+if (NILP (coding_system))
+{
+CONST Extbyte *end = ptr + len;
+for (; ptr < end; ptr++)
+{
+Extbyte c = *ptr;
+DECODE_ADD_BINARY_CHAR (c, conversion_in_dynarr);
+}
+}
+else
+{
+Lisp_Object instream, outstream, da_outstream;
+Lstream *istr, *ostr;
+struct gcpro gcpro1, gcpro2, gcpro3;
+char tempbuf[1024]; /* some random amount */
+instream = make_fixed_buffer_input_stream ((unsigned char *) ptr, len);
+da_outstream = make_dynarr_output_stream
+((unsigned_char_dynarr *) conversion_in_dynarr);
+outstream =
+make_decoding_output_stream (XLSTREAM (da_outstream), coding_system);
+istr = XLSTREAM (instream);
+ostr = XLSTREAM (outstream);
+GCPRO3 (instream, outstream, da_outstream);
+while (1)
+{
+int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+if (!size_in_bytes)
+break;
+Lstream_write (ostr, tempbuf, size_in_bytes);
+}
+Lstream_close (istr);
+Lstream_close (ostr);
+UNGCPRO;
+Lstream_delete (istr);
+Lstream_delete (ostr);
+Lstream_delete (XLSTREAM (da_outstream));
+}
+*len_out = Dynarr_length (conversion_in_dynarr);
+Dynarr_add (conversion_in_dynarr, 0); /* remember to zero-terminate! */
+return Dynarr_atp (conversion_in_dynarr, 0);
+}
 /************************************************************************/
 /*                             Initialization                           */
 /************************************************************************/
 void
-syms_of_file_coding (void)
+syms_of_mule_coding (void)
 {
-INIT_LRECORD_IMPLEMENTATION (coding_system);
+defsymbol (&Qbuffer_file_coding_system, "buffer-file-coding-system");
 deferror (&Qcoding_system_error, "coding-system-error",
 	    "Coding-system error", Qio_error);
 DEFSUBR (Fcoding_system_p);
 DEFSUBR (Ffind_coding_system);
 DEFSUBR (Fget_coding_system);
 DEFSUBR (Fcoding_system_list);
 DEFSUBR (Fcoding_system_name);
 DEFSUBR (Fmake_coding_system);
 DEFSUBR (Fcopy_coding_system);
-DEFSUBR (Fcoding_system_canonical_name_p);
-DEFSUBR (Fcoding_system_alias_p);
-DEFSUBR (Fcoding_system_aliasee);
 DEFSUBR (Fdefine_coding_system_alias);
 DEFSUBR (Fsubsidiary_coding_system);
 DEFSUBR (Fcoding_system_type);
 DEFSUBR (Fcoding_system_doc_string);
 DEFSUBR (Fset_ucs_char);
 DEFSUBR (Fucs_char);
 DEFSUBR (Fset_char_ucs);
 DEFSUBR (Fchar_ucs);
 #endif /* MULE */
-defsymbol (&Qcoding_systemp, "coding-system-p");
+defsymbol (&Qcoding_system_p, "coding-system-p");
 defsymbol (&Qno_conversion, "no-conversion");
-defsymbol (&Qraw_text, "raw-text");
 #ifdef MULE
 defsymbol (&Qbig5, "big5");
 defsymbol (&Qshift_jis, "shift-jis");
 defsymbol (&Qucs4, "ucs-4");
 defsymbol (&Qutf8, "utf-8");
 #endif /* MULE */
 defsymbol (&Qencode, "encode");
 defsymbol (&Qdecode, "decode");
 #ifdef MULE
+defsymbol (&Qctext, "ctext");
 defsymbol (&coding_category_symbol[CODING_CATEGORY_SHIFT_JIS],
 	     "shift-jis");
 defsymbol (&coding_category_symbol[CODING_CATEGORY_BIG5],
 	     "big5");
 defsymbol (&coding_category_symbol[CODING_CATEGORY_UCS4],
 defsymbol (&coding_category_symbol[CODING_CATEGORY_NO_CONVERSION],
 	     "no-conversion");
 }
 void
-lstream_type_create_file_coding (void)
+lstream_type_create_mule_coding (void)
 {
 LSTREAM_HAS_METHOD (decoding, reader);
 LSTREAM_HAS_METHOD (decoding, writer);
 LSTREAM_HAS_METHOD (decoding, rewinder);
 LSTREAM_HAS_METHOD (decoding, seekable_p);
 LSTREAM_HAS_METHOD (encoding, closer);
 LSTREAM_HAS_METHOD (encoding, marker);
 }
 void
-vars_of_file_coding (void)
+vars_of_mule_coding (void)
 {
 int i;
-fcd = xnew (struct file_coding_dump);
-dumpstruct (&fcd, &fcd_description);
 /* Initialize to something reasonable ... */
 for (i = 0; i <= CODING_CATEGORY_LAST; i++)
 {
-fcd->coding_category_system[i] = Qnil;
+coding_category_system[i] = Qnil;
-fcd->coding_category_by_priority[i] = i;
+coding_category_by_priority[i] = i;
 }
 Fprovide (intern ("file-coding"));
 DEFVAR_LISP ("keyboard-coding-system", &Vkeyboard_coding_system /*
 Not used under a windowing system.
 */ );
 Vterminal_coding_system = Qnil;
 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read /*
-Overriding coding system used when reading from a file or process.
+Overriding coding system used when writing a file or process.
-You should bind this variable with `let', but do not set it globally.
+You should *bind* this, not set it.  If this is non-nil, it specifies
-If this is non-nil, it specifies the coding system that will be used
+the coding system that will be used when a file or process is read
-to decode input on read operations, such as from a file or process.
+in, and overrides `buffer-file-coding-system-for-read',
-It overrides `buffer-file-coding-system-for-read',
 `insert-file-contents-pre-hook', etc.  Use those variables instead of
-this one for permanent changes to the environment.  */ );
+this one for permanent changes to the environment.
+*/ );
 Vcoding_system_for_read = Qnil;
 DEFVAR_LISP ("coding-system-for-write",
 &Vcoding_system_for_write /*
-Overriding coding system used when writing to a file or process.
+Overriding coding system used when writing a file or process.
-You should bind this variable with `let', but do not set it globally.
+You should *bind* this, not set it.  If this is non-nil, it specifies
-If this is non-nil, it specifies the coding system that will be used
+the coding system that will be used when a file or process is wrote
-to encode output for write operations, such as to a file or process.
+in, and overrides `buffer-file-coding-system',
-It overrides `buffer-file-coding-system', `write-region-pre-hook', etc.
+`write-region-pre-hook', etc.  Use those variables instead of this one
-Use those variables instead of this one for permanent changes to the
+for permanent changes to the environment.
-environment.  */ );
+*/ );
 Vcoding_system_for_write = Qnil;
 DEFVAR_LISP ("file-name-coding-system", &Vfile_name_coding_system /*
 Coding system used to convert pathnames when accessing files.
 */ );
 */ );
 enable_multibyte_characters = 1;
 }
 void
-complex_vars_of_file_coding (void)
+complex_vars_of_mule_coding (void)
 {
 staticpro (&Vcoding_system_hash_table);
 Vcoding_system_hash_table =
 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
 the_codesys_prop_dynarr = Dynarr_new (codesys_prop);
-dumpstruct (&the_codesys_prop_dynarr, &codesys_prop_dynarr_description);
 #define DEFINE_CODESYS_PROP(Prop_Type, Sym) do	\
 {						\
 struct codesys_prop csp;			\
 csp.sym = (Sym);				\
 DEFINE_CODESYS_PROP (CODESYS_PROP_CCL,     Qencode);
 DEFINE_CODESYS_PROP (CODESYS_PROP_CCL,     Qdecode);
 #endif /* MULE */
 /* Need to create this here or we're really screwed. */
-Fmake_coding_system
+Fmake_coding_system (Qno_conversion, Qno_conversion, build_string ("No conversion"),
-(Qraw_text, Qno_conversion,
+		       list2 (Qmnemonic, build_string ("Noconv")));
-build_string ("Raw text, which means it converts only line-break-codes."),
-list2 (Qmnemonic, build_string ("Raw")));
+Fcopy_coding_system (Fcoding_system_property (Qno_conversion, Qeol_lf),
+		       Qbinary);
-Fmake_coding_system
-(Qbinary, Qno_conversion,
-build_string ("Binary, which means it does not convert anything."),
-list4 (Qeol_type, Qlf,
-	    Qmnemonic, build_string ("Binary")));
-Fdefine_coding_system_alias (Qno_conversion, Qraw_text);
-Fdefine_coding_system_alias (Qfile_name, Qbinary);
-Fdefine_coding_system_alias (Qterminal, Qbinary);
-Fdefine_coding_system_alias (Qkeyboard, Qbinary);
 /* Need this for bootstrapping */
-fcd->coding_category_system[CODING_CATEGORY_NO_CONVERSION] =
+coding_category_system[CODING_CATEGORY_NO_CONVERSION] =
-Fget_coding_system (Qraw_text);
+Fget_coding_system (Qno_conversion);
 #ifdef MULE
 {
 unsigned int i;
 for (i = 0; i < 65536; i++)
-fcd->ucs_to_mule_table[i] = Qnil;
+ucs_to_mule_table[i] = Qnil;
 }
 staticpro (&mule_to_ucs_table);
 mule_to_ucs_table = Fmake_char_table(Qgeneric);
 #endif /* MULE */
 }

Mercurial > hg > xemacs-beta

comparison src/file-coding.c @ 412:697ef44129c6 r21-2-14