X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Ffile-coding.c;h=8635316d51c3188a8ea2015cfe5475d8cf34d16d;hb=44ea030ec31ae441e59974eb9f6b2a9404611cd8;hp=fca56b0c1e7a48917b43b801da3dba55e1b73349;hpb=3e447015251ce6dcde843cbed10d9033d5538622;p=chise%2Fxemacs-chise.git.1 diff --git a/src/file-coding.c b/src/file-coding.c index fca56b0..48363a4 100644 --- a/src/file-coding.c +++ b/src/file-coding.c @@ -25,19 +25,16 @@ Boston, MA 02111-1307, USA. */ #include #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; @@ -48,39 +45,16 @@ 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]; +/* Table of all coding categories in decreasing order of priority. + This describes a permutation of the possible coding categories. */ +int coding_category_by_priority[CODING_CATEGORY_LAST + 1]; -struct file_coding_dump { - /* Coding system currently associated with each coding category. */ - Lisp_Object coding_category_system[CODING_CATEGORY_LAST + 1]; - - /* Table of all coding categories in decreasing order of priority. - This describes a permutation of the possible coding categories. */ - int coding_category_by_priority[CODING_CATEGORY_LAST + 1]; - -#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 Qcoding_system_p; -Lisp_Object Qraw_text, Qno_conversion, Qccl, Qiso2022; +Lisp_Object Qno_conversion, Qccl, Qiso2022; /* Qinternal in general.c */ Lisp_Object Qmnemonic, Qeol_type; @@ -90,19 +64,18 @@ Lisp_Object Qpost_read_conversion; Lisp_Object Qpre_write_conversion; #ifdef MULE -Lisp_Object Qucs4, Qutf8; Lisp_Object Qbig5, Qshift_jis; 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; +Lisp_Object Vcoding_system_hashtable; int enable_multibyte_characters; @@ -130,10 +103,8 @@ struct iso2022_decoder /* Index for next byte to store in ISO escape sequence. */ int esc_bytes_index; -#ifdef ENABLE_COMPOSITE_CHARS /* Stuff seen so far when composing a string. */ unsigned_char_dynarr *composite_chars; -#endif /* If we saw an invalid designation sequence for a particular register, we flag it here and switch to ASCII. The next time we @@ -176,67 +147,49 @@ 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, - unsigned_char_dynarr *dst, unsigned int 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); -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, + 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; @@ -251,26 +204,6 @@ 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 @@ -285,69 +218,26 @@ 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, - Lisp_Coding_System); + 0, 0, struct 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); + struct Lisp_Coding_System *codesys = XCODING_SYSTEM (obj); - mark_object (CODING_SYSTEM_NAME (codesys)); - mark_object (CODING_SYSTEM_DOC_STRING (codesys)); - mark_object (CODING_SYSTEM_MNEMONIC (codesys)); - mark_object (CODING_SYSTEM_EOL_LF (codesys)); - mark_object (CODING_SYSTEM_EOL_CRLF (codesys)); - mark_object (CODING_SYSTEM_EOL_CR (codesys)); + (markobj) (CODING_SYSTEM_NAME (codesys)); + (markobj) (CODING_SYSTEM_DOC_STRING (codesys)); + (markobj) (CODING_SYSTEM_MNEMONIC (codesys)); + (markobj) (CODING_SYSTEM_EOL_LF (codesys)); + (markobj) (CODING_SYSTEM_EOL_CRLF (codesys)); + (markobj) (CODING_SYSTEM_EOL_CR (codesys)); switch (CODING_SYSTEM_TYPE (codesys)) { @@ -355,15 +245,15 @@ mark_coding_system (Lisp_Object obj) 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); - mark_object (ccs->to_charset); + (markobj) (ccs->from_charset); + (markobj) (ccs->to_charset); } } if (codesys->iso2022.output_conv) @@ -372,22 +262,22 @@ mark_coding_system (Lisp_Object obj) { struct charset_conversion_spec *ccs = Dynarr_atp (codesys->iso2022.output_conv, i); - mark_object (ccs->from_charset); - mark_object (ccs->to_charset); + (markobj) (ccs->from_charset); + (markobj) (ccs->to_charset); } } break; case CODESYS_CCL: - mark_object (CODING_SYSTEM_CCL_DECODE (codesys)); - mark_object (CODING_SYSTEM_CCL_ENCODE (codesys)); + (markobj) (CODING_SYSTEM_CCL_DECODE (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); } @@ -395,7 +285,7 @@ static void print_coding_system (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { - Lisp_Coding_System *c = XCODING_SYSTEM (obj); + struct Lisp_Coding_System *c = XCODING_SYSTEM (obj); if (print_readably) error ("printing unreadable object #", c->header.uid); @@ -408,7 +298,7 @@ print_coding_system (Lisp_Object obj, Lisp_Object printcharfun, static void finalize_coding_system (void *header, int for_disksave) { - Lisp_Coding_System *c = (Lisp_Coding_System *) header; + struct Lisp_Coding_System *c = (struct Lisp_Coding_System *) header; /* Since coding systems never go away, this function is not necessary. But it would be necessary if we changed things so that coding systems could go away. */ @@ -436,7 +326,7 @@ finalize_coding_system (void *header, int for_disksave) } } -static eol_type_t +static enum eol_type symbol_to_eol_type (Lisp_Object symbol) { CHECK_SYMBOL (symbol); @@ -450,20 +340,20 @@ symbol_to_eol_type (Lisp_Object symbol) } 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; case EOL_CRLF: return Qcrlf; case EOL_CR: return Qcr; case EOL_AUTODETECT: return Qnil; + default: abort (); return Qnil; /* not reached */ } } static void -setup_eol_coding_systems (Lisp_Coding_System *codesys) +setup_eol_coding_systems (struct Lisp_Coding_System *codesys) { Lisp_Object codesys_obj; int len = string_length (XSYMBOL (CODING_SYSTEM_NAME (codesys))->name); @@ -541,21 +431,15 @@ 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) - { - 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; - } + return Fgethash (coding_system_or_name, Vcoding_system_hashtable, Qnil); } DEFUN ("get-coding-system", Fget_coding_system, 1, 1, 0, /* @@ -581,15 +465,20 @@ struct coding_system_list_closure }; static int -add_coding_system_to_list_mapper (Lisp_Object key, Lisp_Object value, +add_coding_system_to_list_mapper (CONST void *hash_key, void *hash_contents, void *coding_system_list_closure) { /* This function can GC */ + Lisp_Object key, contents; + Lisp_Object *coding_system_list; struct coding_system_list_closure *cscl = (struct coding_system_list_closure *) coding_system_list_closure; - Lisp_Object *coding_system_list = cscl->coding_system_list; + CVOID_TO_LISP (key, hash_key); + VOID_TO_LISP (contents, hash_contents); + coding_system_list = cscl->coding_system_list; - *coding_system_list = Fcons (key, *coding_system_list); + *coding_system_list = Fcons (XCODING_SYSTEM (contents)->name, + *coding_system_list); return 0; } @@ -604,7 +493,7 @@ Return a list of the names of all defined coding systems. GCPRO1 (coding_system_list); coding_system_list_closure.coding_system_list = &coding_system_list; - elisp_maphash (add_coding_system_to_list_mapper, Vcoding_system_hash_table, + elisp_maphash (add_coding_system_to_list_mapper, Vcoding_system_hashtable, &coding_system_list_closure); UNGCPRO; @@ -620,11 +509,11 @@ Return the name of the given coding system. return XCODING_SYSTEM_NAME (coding_system); } -static Lisp_Coding_System * +static struct Lisp_Coding_System * allocate_coding_system (enum coding_system_type type, Lisp_Object name) { - Lisp_Coding_System *codesys = - alloc_lcrecord_type (Lisp_Coding_System, &lrecord_coding_system); + struct Lisp_Coding_System *codesys = + alloc_lcrecord_type (struct Lisp_Coding_System, lrecord_coding_system); zero_lcrecord (codesys); CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = Qnil; @@ -723,10 +612,6 @@ nil or 'undecided characters will only be present if you explicitly insert them.) 'shift-jis Shift-JIS (a Japanese encoding commonly used in PC operating systems). -'ucs-4 - ISO 10646 UCS-4 encoding. -'utf-8 - ISO 10646 UTF-8 encoding. 'iso2022 Any ISO2022-compliant encoding. Among other things, this includes JIS (the Japanese encoding commonly used for e-mail), EUC (the @@ -881,7 +766,7 @@ if TYPE is 'ccl: */ (name, type, doc_string, props)) { - Lisp_Coding_System *codesys; + struct Lisp_Coding_System *codesys; Lisp_Object rest, key, value; enum coding_system_type ty; int need_to_setup_eol_systems = 1; @@ -893,8 +778,6 @@ if TYPE is 'ccl: else if (EQ (type, Qshift_jis)) { ty = CODESYS_SHIFT_JIS; } else if (EQ (type, Qiso2022)) { ty = CODESYS_ISO2022; } else if (EQ (type, Qbig5)) { ty = CODESYS_BIG5; } - else if (EQ (type, Qucs4)) { ty = CODESYS_UCS4; } - else if (EQ (type, Qutf8)) { ty = CODESYS_UTF8; } else if (EQ (type, Qccl)) { ty = CODESYS_CCL; } #endif else if (EQ (type, Qno_conversion)) { ty = CODESYS_NO_CONVERSION; } @@ -1007,7 +890,7 @@ if TYPE is 'ccl: { Lisp_Object codesys_obj; XSETCODING_SYSTEM (codesys_obj, codesys); - Fputhash (name, codesys_obj, Vcoding_system_hash_table); + Fputhash (name, codesys_obj, Vcoding_system_hashtable); return codesys_obj; } } @@ -1028,12 +911,12 @@ be created. allocate_coding_system (XCODING_SYSTEM_TYPE (old_coding_system), new_name)); - Fputhash (new_name, new_coding_system, Vcoding_system_hash_table); + Fputhash (new_name, new_coding_system, Vcoding_system_hashtable); } { - Lisp_Coding_System *to = XCODING_SYSTEM (new_coding_system); - Lisp_Coding_System *from = XCODING_SYSTEM (old_coding_system); + struct Lisp_Coding_System *to = XCODING_SYSTEM (new_coding_system); + struct Lisp_Coding_System *from = XCODING_SYSTEM (old_coding_system); memcpy (((char *) to ) + sizeof (to->header), ((char *) from) + sizeof (from->header), sizeof (*from) - sizeof (from->header)); @@ -1042,170 +925,10 @@ be created. return new_coding_system; } -DEFUN ("coding-system-canonical-name-p", Fcoding_system_canonical_name_p, 1, 1, 0, /* -Return t if OBJECT names a coding system, and is not a coding system alias. -*/ - (object)) -{ - 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); -} - -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 (Fcoding_system_canonical_name_p (alias))) - signal_simple_error - ("Symbol is the canonical name of a coding system and cannot be redefined", - alias); - - if (NILP (aliasee)) - { - Lisp_Object subsidiary_unix = append_suffix_to_symbol (alias, "-unix"); - Lisp_Object subsidiary_dos = append_suffix_to_symbol (alias, "-dos"); - Lisp_Object subsidiary_mac = append_suffix_to_symbol (alias, "-mac"); - - Fremhash (alias, Vcoding_system_hash_table); - - /* Undefine subsidiary aliases, - presumably created by a previous call to this function */ - if (! NILP (Fcoding_system_alias_p (subsidiary_unix)) && - ! NILP (Fcoding_system_alias_p (subsidiary_dos)) && - ! NILP (Fcoding_system_alias_p (subsidiary_mac))) - { - Fdefine_coding_system_alias (subsidiary_unix, Qnil); - Fdefine_coding_system_alias (subsidiary_dos, Qnil); - Fdefine_coding_system_alias (subsidiary_mac, Qnil); - } - - /* 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); + struct Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system); Lisp_Object new_coding_system; if (CODING_SYSTEM_EOL_TYPE (cs) != EOL_AUTODETECT) @@ -1255,21 +978,22 @@ Return the type of CODING-SYSTEM. { switch (XCODING_SYSTEM_TYPE (Fget_coding_system (coding_system))) { - default: abort (); case CODESYS_AUTODETECT: return Qundecided; #ifdef MULE case CODESYS_SHIFT_JIS: return Qshift_jis; case CODESYS_ISO2022: return Qiso2022; case CODESYS_BIG5: return Qbig5; - case CODESYS_UCS4: return Qucs4; - case CODESYS_UTF8: return Qutf8; case CODESYS_CCL: return Qccl; #endif case CODESYS_NO_CONVERSION: return Qno_conversion; #ifdef DEBUG_XEMACS case CODESYS_INTERNAL: return Qinternal; #endif + default: + abort (); } + + return Qnil; /* not reached */ } #ifdef MULE @@ -1483,7 +1207,7 @@ previously. 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++; } @@ -1492,7 +1216,7 @@ previously. 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; @@ -1507,7 +1231,7 @@ Return a list of coding categories in descending order of priority. 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; } @@ -1520,7 +1244,7 @@ Change the coding system associated with a coding category. 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; } @@ -1530,7 +1254,7 @@ 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); @@ -1544,7 +1268,7 @@ Return the coding system associated with a coding category. struct detection_state { - eol_type_t eol_type; + enum eol_type eol_type; int seen_non_ascii; int mask; #ifdef MULE @@ -1565,20 +1289,6 @@ struct detection_state struct { int mask; - int in_byte; - } - ucs4; - - struct - { - int mask; - int in_byte; - } - utf8; - - struct - { - int mask; int initted; struct iso2022_decoder iso; unsigned int flags; @@ -1625,8 +1335,8 @@ mask_has_at_most_one_bit_p (int mask) return (mask & (mask - 1)) == 0; } -static eol_type_t -detect_eol_type (struct detection_state *st, const unsigned char *src, +static enum eol_type +detect_eol_type (struct detection_state *st, CONST unsigned char *src, unsigned int n) { int c; @@ -1634,19 +1344,21 @@ detect_eol_type (struct detection_state *st, const unsigned char *src, while (n--) { c = *src++; - 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; - else if (c == '\r') + 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; } @@ -1671,7 +1383,7 @@ detect_eol_type (struct detection_state *st, const unsigned char *src, */ 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; @@ -1693,8 +1405,6 @@ detect_coding_type (struct detection_state *st, const Extbyte *src, #ifdef MULE st->shift_jis.mask = ~0; st->big5.mask = ~0; - st->ucs4.mask = ~0; - st->utf8.mask = ~0; st->iso2022.mask = ~0; #endif break; @@ -1711,14 +1421,8 @@ detect_coding_type (struct detection_state *st, const Extbyte *src, st->shift_jis.mask = detect_coding_sjis (st, src, n); if (!mask_has_at_most_one_bit_p (st->big5.mask)) st->big5.mask = detect_coding_big5 (st, src, n); - if (!mask_has_at_most_one_bit_p (st->utf8.mask)) - st->utf8.mask = detect_coding_utf8 (st, src, n); - if (!mask_has_at_most_one_bit_p (st->ucs4.mask)) - st->ucs4.mask = detect_coding_ucs4 (st, src, n); - - st->mask - = st->iso2022.mask | st->shift_jis.mask | st->big5.mask - | st->utf8.mask | st->ucs4.mask; + + st->mask = st->iso2022.mask | st->shift_jis.mask | st->big5.mask; #endif { int retval = mask_has_at_most_one_bit_p (st->mask); @@ -1748,7 +1452,7 @@ coding_system_from_mask (int mask) } } if (NILP (retval)) - retval = Fget_coding_system (Qraw_text); + retval = Fget_coding_system (Qno_conversion); return retval; } else @@ -1762,32 +1466,30 @@ coding_system_from_mask (int mask) 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; @@ -1799,108 +1501,27 @@ determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out, decst.mask = ~0; /* If autodetection is called for, do it now. */ - if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT - || *eol_type_in_out == EOL_AUTODETECT) + if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT || + *eol_type_in_out == EOL_AUTODETECT) { - Extbyte buf[4096]; - Lisp_Object coding_system = Qnil; - Extbyte *p; - ssize_t nread = Lstream_read (stream, buf, sizeof (buf)); - Extbyte *scan_end; - - /* Look for initial "-*-"; mode line prefix */ - for (p = buf, - 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 (NILP (coding_system)) - do - { - 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); + while (1) + { + unsigned char random_buffer[4096]; + int nread; - 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); + nread = Lstream_read (stream, random_buffer, sizeof (random_buffer)); + if (!nread) + break; + if (detect_coding_type (&decst, random_buffer, nread, + XCODING_SYSTEM_TYPE (*codesys_in_out) != + CODESYS_AUTODETECT)) + break; + } *eol_type_in_out = decst.eol_type; if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT) - { - if (NILP (coding_system)) - *codesys_in_out = coding_system_from_mask (decst.mask); - else - *codesys_in_out = coding_system; - } + *codesys_in_out = coding_system_from_mask (decst.mask); } /* If we absolutely can't determine the EOL type, just assume LF. */ @@ -1939,7 +1560,7 @@ type. Optional arg BUFFER defaults to the current buffer. 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; @@ -1960,10 +1581,10 @@ type. Optional arg BUFFER defaults to the current buffer. #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); @@ -2052,12 +1673,10 @@ do { \ #define DECODE_HANDLE_END_OF_CONVERSION(flags, ch, dst) \ do { \ - if (flags & CODING_STATE_END) \ - { \ - DECODE_OUTPUT_PARTIAL_CHAR (ch); \ - if (flags & CODING_STATE_CR) \ - Dynarr_add (dst, '\r'); \ - } \ + DECODE_OUTPUT_PARTIAL_CHAR (ch); \ + if ((flags & CODING_STATE_END) && \ + (flags & CODING_STATE_CR)) \ + Dynarr_add (dst, '\r'); \ } while (0) #define DECODING_STREAM_DATA(stream) LSTREAM_TYPE_DATA (stream, decoding) @@ -2065,7 +1684,7 @@ do { \ struct decoding_stream { /* Coding system that governs the conversion. */ - Lisp_Coding_System *codesys; + struct Lisp_Coding_System *codesys; /* Stream that we read the encoded data from or write the decoded data to. */ @@ -2090,7 +1709,7 @@ struct decoding_stream 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. */ @@ -2099,29 +1718,25 @@ struct decoding_stream /* 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, - unsigned char *data, size_t size); -static ssize_t decoding_writer (Lstream *stream, - const unsigned char *data, size_t size); +static int decoding_reader (Lstream *stream, unsigned char *data, size_t size); +static int 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; @@ -2131,9 +1746,9 @@ decoding_marker (Lisp_Object stream) 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; } @@ -2141,12 +1756,12 @@ decoding_marker (Lisp_Object stream) /* 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 @@ -2203,11 +1818,11 @@ decoding_reader (Lstream *stream, unsigned char *data, size_t size) return data - orig_data; } -static ssize_t -decoding_writer (Lstream *stream, const unsigned char *data, size_t size) +static int +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 @@ -2237,7 +1852,6 @@ reset_decoding_stream (struct decoding_stream *str) { setup_ccl_program (&str->ccl, CODING_SYSTEM_CCL_DECODE (str->codesys)); } - str->counter = 0; #endif /* MULE */ str->flags = str->ch = 0; } @@ -2276,11 +1890,9 @@ decoding_closer (Lstream *stream) } Dynarr_free (str->runoff); #ifdef MULE -#ifdef ENABLE_COMPOSITE_CHARS if (str->iso2022.composite_chars) Dynarr_free (str->iso2022.composite_chars); #endif -#endif return Lstream_close (str->other_end); } @@ -2297,7 +1909,7 @@ decoding_stream_coding_system (Lstream *stream) void set_decoding_stream_coding_system (Lstream *lstr, Lisp_Object codesys) { - Lisp_Coding_System *cs = XCODING_SYSTEM (codesys); + struct Lisp_Coding_System *cs = XCODING_SYSTEM (codesys); struct decoding_stream *str = DECODING_STREAM_DATA (lstr); str->codesys = cs; if (CODING_SYSTEM_EOL_TYPE (cs) != EOL_AUTODETECT) @@ -2314,7 +1926,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); @@ -2357,7 +1969,7 @@ 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, +mule_decode (Lstream *decoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -2414,15 +2026,8 @@ mule_decode (Lstream *decoding, const unsigned char *src, case CODESYS_BIG5: decode_coding_big5 (decoding, src, dst, n); break; - case CODESYS_UCS4: - decode_coding_ucs4 (decoding, src, dst, n); - 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_MODE_DECODING); + ccl_driver (&str->ccl, src, dst, n, 0); break; case CODESYS_ISO2022: decode_coding_iso2022 (decoding, src, dst, n); @@ -2477,7 +2082,7 @@ BUFFER defaults to the current buffer if unspecified. 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; @@ -2512,7 +2117,7 @@ BUFFER defaults to the current buffer if unspecified. struct encoding_stream { /* Coding system that governs the conversion. */ - Lisp_Coding_System *codesys; + struct Lisp_Coding_System *codesys; /* Stream that we read the encoded data from or write the decoded data to. */ @@ -2562,21 +2167,22 @@ struct encoding_stream #endif /* MULE */ }; -static ssize_t encoding_reader (Lstream *stream, unsigned char *data, size_t size); -static ssize_t encoding_writer (Lstream *stream, const unsigned char *data, - size_t size); +static int encoding_reader (Lstream *stream, unsigned char *data, size_t size); +static int encoding_writer (Lstream *stream, CONST unsigned char *data, + 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; @@ -2586,9 +2192,9 @@ encoding_marker (Lisp_Object stream) 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; } @@ -2596,12 +2202,12 @@ encoding_marker (Lisp_Object stream) /* 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 @@ -2658,11 +2264,11 @@ encoding_reader (Lstream *stream, unsigned char *data, size_t size) return data - orig_data; } -static ssize_t -encoding_writer (Lstream *stream, const unsigned char *data, size_t size) +static int +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 @@ -2762,7 +2368,7 @@ encoding_stream_coding_system (Lstream *stream) void set_encoding_stream_coding_system (Lstream *lstr, Lisp_Object codesys) { - Lisp_Coding_System *cs = XCODING_SYSTEM (codesys); + struct Lisp_Coding_System *cs = XCODING_SYSTEM (codesys); struct encoding_stream *str = ENCODING_STREAM_DATA (lstr); str->codesys = cs; reset_encoding_stream (str); @@ -2770,7 +2376,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); @@ -2801,7 +2407,7 @@ 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, +mule_encode (Lstream *encoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -2826,15 +2432,8 @@ mule_encode (Lstream *encoding, const unsigned char *src, case CODESYS_BIG5: encode_coding_big5 (encoding, src, dst, n); break; - case CODESYS_UCS4: - encode_coding_ucs4 (encoding, src, dst, n); - 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_MODE_ENCODING); + ccl_driver (&str->ccl, src, dst, n, 0); break; case CODESYS_ISO2022: encode_coding_iso2022 (encoding, src, dst, n); @@ -2885,7 +2484,7 @@ text. BUFFER defaults to the current buffer if unspecified. 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; @@ -2918,9 +2517,9 @@ text. BUFFER defaults to the current buffer if unspecified. /* Shift-JIS is a coding system encoding three character sets: ASCII, right half of JISX0201-Kana, and JISX0208. An ASCII character is encoded - as is. A character of JISX0201-Kana (DIMENSION1_CHARS94 character set) is + as is. A character of JISX0201-Kana (TYPE94 character set) is encoded by "position-code + 0x80". A character of JISX0208 - (DIMENSION2_CHARS94 character set) is encoded in 2-byte but two + (TYPE94x94 character set) is encoded in 2-byte but two position-codes are divided and shifted so that it fit in the range below. @@ -2948,7 +2547,7 @@ 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, +detect_coding_sjis (struct detection_state *st, CONST unsigned char *src, unsigned int n) { int c; @@ -2973,14 +2572,16 @@ 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, +decode_coding_sjis (Lstream *decoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; + unsigned int flags, ch; + enum eol_type eol_type; 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; + + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = str->eol_type; while (n--) { @@ -3023,21 +2624,22 @@ decode_coding_sjis (Lstream *decoding, const unsigned char *src, DECODE_HANDLE_END_OF_CONVERSION (flags, ch, dst); - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } /* 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; - unsigned int ch = str->ch; - eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); + unsigned int flags, ch; + enum eol_type eol_type; + + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); while (n--) { @@ -3080,8 +2682,7 @@ encode_coding_sjis (Lstream *encoding, const unsigned char *src, } } - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } DEFUN ("decode-shift-jis-char", Fdecode_shift_jis_char, 1, 1, 0, /* @@ -3147,8 +2748,8 @@ Return the corresponding character code in SHIFT-JIS as a cons of two bytes. Since the number of characters in Big5 is larger than maximum characters in Emacs' charset (96x96), it can't be handled as one - charset. So, in Emacs, Big5 is divided into two: `charset-big5-1' - and `charset-big5-2'. Both s are DIMENSION2_CHARS94. The former + charset. So, in Emacs, Big5 is devided into two: `charset-big5-1' + and `charset-big5-2'. Both s are TYPE94x94. The former contains frequently used characters and the latter contains less frequently used characters. */ @@ -3234,7 +2835,7 @@ 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, +detect_coding_big5 (struct detection_state *st, CONST unsigned char *src, unsigned int n) { int c; @@ -3260,14 +2861,16 @@ 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, +decode_coding_big5 (Lstream *decoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; + unsigned int flags, ch; + enum eol_type eol_type; 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; + + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = str->eol_type; while (n--) { @@ -3303,21 +2906,22 @@ decode_coding_big5 (Lstream *decoding, const unsigned char *src, DECODE_HANDLE_END_OF_CONVERSION (flags, ch, dst); - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } /* 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; - unsigned int ch = str->ch; - eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); + unsigned int flags, ch; + enum eol_type eol_type; + + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); while (n--) { @@ -3365,8 +2969,7 @@ encode_coding_big5 (Lstream *encoding, const unsigned char *src, ch = 0; } - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } @@ -3421,786 +3024,133 @@ Return the corresponding character code in Big5. /************************************************************************/ -/* UCS-4 methods */ -/* */ -/* UCS-4 character codes are implemented as nonnegative integers. */ -/* */ +/* ISO2022 methods */ /************************************************************************/ +/* The following note describes the coding system ISO2022 briefly. + Since the intention of this note is to help understanding of the + programs in this file, some parts are NOT ACCURATE or OVERLY + SIMPLIFIED. For thorough understanding, please refer to the + original document of ISO2022. -DEFUN ("set-ucs-char", Fset_ucs_char, 2, 2, 0, /* -Map UCS-4 code CODE to Mule character CHARACTER. + ISO2022 provides many mechanisms to encode several character sets + in 7-bit and 8-bit environments. If one chooses 7-bit environment, + all text is encoded by codes of less than 128. This may make the + encoded text a little bit longer, but the text get more stability + to pass through several gateways (some of them strip off MSB). -Return T on success, NIL on failure. -*/ - (code, character)) -{ - unsigned int c; + There are two kind of character sets: control character set and + graphic character set. The former contains control characters such + as `newline' and `escape' to provide control functions (control + functions are provided also by escape sequence). The latter + contains graphic characters such as 'A' and '-'. Emacs recognizes + two control character sets and many graphic character sets. - CHECK_CHAR (character); - CHECK_INT (code); - c = XINT (code); + Graphic character sets are classified into one of four types, + according to the dimension and number of characters in the set: + TYPE94, TYPE96, TYPE94x94, and TYPE96x96. In addition, each + character set is assigned an identification byte, unique for each + type, called "final character" (denoted as hereafter). The + of each character set is decided by ECMA(*) when it is registered + in ISO. Code range of is 0x30..0x7F (0x30..0x3F are for + private use only). - if (c < sizeof (fcd->ucs_to_mule_table)) - { - fcd->ucs_to_mule_table[c] = character; - return Qt; - } - else - return Qnil; -} + Note (*): ECMA = European Computer Manufacturers Association -static Lisp_Object -ucs_to_char (unsigned long code) -{ - if (code < sizeof (fcd->ucs_to_mule_table)) - { - return fcd->ucs_to_mule_table[code]; - } - else if ((0xe00000 <= code) && (code <= 0xe00000 + 94 * 94 * 14)) - { - unsigned int c; - - code -= 0xe00000; - c = code % (94 * 94); - return make_char - (MAKE_CHAR (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_94X94, code / (94 * 94) + '@', - CHARSET_LEFT_TO_RIGHT), - c / 94 + 33, c % 94 + 33)); - } - else - return Qnil; -} + Here are examples of graphic character set [NAME()]: + o TYPE94 -- ASCII('B'), right-half-of-JISX0201('I'), ... + o TYPE96 -- right-half-of-ISO8859-1('A'), ... + o TYPE94x94 -- GB2312('A'), JISX0208('B'), ... + o TYPE96x96 -- none for the moment -DEFUN ("ucs-char", Fucs_char, 1, 1, 0, /* -Return Mule character corresponding to UCS code CODE (a positive integer). -*/ - (code)) -{ - CHECK_NATNUM (code); - return ucs_to_char (XINT (code)); -} + A code area (1byte=8bits) is divided into 4 areas, C0, GL, C1, and GR. + C0 [0x00..0x1F] -- control character plane 0 + GL [0x20..0x7F] -- graphic character plane 0 + C1 [0x80..0x9F] -- control character plane 1 + GR [0xA0..0xFF] -- graphic character plane 1 -DEFUN ("set-char-ucs", Fset_char_ucs, 2, 2, 0, /* -Map Mule character CHARACTER to UCS code CODE (a positive integer). -*/ - (character, code)) -{ - /* #### Isn't this gilding the lily? Fput_char_table checks its args. - Fset_char_ucs is more restrictive on index arg, but should - check code arg in a char_table method. */ - CHECK_CHAR (character); - CHECK_NATNUM (code); - return Fput_char_table (character, code, mule_to_ucs_table); -} + A control character set is directly designated and invoked to C0 or + C1 by an escape sequence. The most common case is that: + - ISO646's control character set is designated/invoked to C0, and + - ISO6429's control character set is designated/invoked to C1, + and usually these designations/invocations are omitted in encoded + text. In a 7-bit environment, only C0 can be used, and a control + character for C1 is encoded by an appropriate escape sequence to + fit into the environment. All control characters for C1 are + defined to have corresponding escape sequences. -DEFUN ("char-ucs", Fchar_ucs, 1, 1, 0, /* -Return the UCS code (a positive integer) corresponding to CHARACTER. -*/ - (character)) -{ - return Fget_char_table (character, mule_to_ucs_table); -} + A graphic character set is at first designated to one of four + graphic registers (G0 through G3), then these graphic registers are + invoked to GL or GR. These designations and invocations can be + done independently. The most common case is that G0 is invoked to + GL, G1 is invoked to GR, and ASCII is designated to G0. Usually + these invocations and designations are omitted in encoded text. + In a 7-bit environment, only GL can be used. -/* Decode a UCS-4 character into a buffer. If the lookup fails, use - (U+3013) of JIS X 0208, which means correct character - is not found, instead. - #### do something more appropriate (use blob?) - Danger, Will Robinson! Data loss. Should we signal user? */ -static void -decode_ucs4 (unsigned long ch, unsigned_char_dynarr *dst) -{ - Lisp_Object chr = ucs_to_char (ch); + When a graphic character set of TYPE94 or TYPE94x94 is invoked to + GL, codes 0x20 and 0x7F of the GL area work as control characters + SPACE and DEL respectively, and code 0xA0 and 0xFF of GR area + should not be used. - if (! NILP (chr)) - { - Bufbyte work[MAX_EMCHAR_LEN]; - int len; - - ch = XCHAR (chr); - len = (ch < 128) ? - simple_set_charptr_emchar (work, ch) : - non_ascii_set_charptr_emchar (work, ch); - Dynarr_add_many (dst, work, len); - } - else - { - Dynarr_add (dst, LEADING_BYTE_JAPANESE_JISX0208); - Dynarr_add (dst, 34 + 128); - Dynarr_add (dst, 46 + 128); - } -} + There are two ways of invocation: locking-shift and single-shift. + With locking-shift, the invocation lasts until the next different + invocation, whereas with single-shift, the invocation works only + for the following character and doesn't affect locking-shift. + Invocations are done by the following control characters or escape + sequences. -static unsigned long -mule_char_to_ucs4 (Lisp_Object charset, - unsigned char h, unsigned char l) -{ - Lisp_Object code - = Fget_char_table (make_char (MAKE_CHAR (charset, h & 127, l & 127)), - mule_to_ucs_table); - - if (INTP (code)) - { - return XINT (code); - } - else if ( (XCHARSET_DIMENSION (charset) == 2) && - (XCHARSET_CHARS (charset) == 94) ) - { - unsigned char final = XCHARSET_FINAL (charset); - - if ( ('@' <= final) && (final < 0x7f) ) - { - return 0xe00000 + (final - '@') * 94 * 94 - + ((h & 127) - 33) * 94 + (l & 127) - 33; - } - else - { - return '?'; - } - } - else - { - return '?'; - } -} - -static void -encode_ucs4 (Lisp_Object charset, - unsigned char h, unsigned char l, unsigned_char_dynarr *dst) -{ - unsigned long code = mule_char_to_ucs4 (charset, h, l); - Dynarr_add (dst, code >> 24); - Dynarr_add (dst, (code >> 16) & 255); - Dynarr_add (dst, (code >> 8) & 255); - Dynarr_add (dst, code & 255); -} - -static int -detect_coding_ucs4 (struct detection_state *st, const unsigned char *src, - unsigned int n) -{ - while (n--) - { - int c = *src++; - switch (st->ucs4.in_byte) - { - case 0: - if (c >= 128) - return 0; - else - st->ucs4.in_byte++; - break; - case 3: - st->ucs4.in_byte = 0; - break; - default: - st->ucs4.in_byte++; - } - } - return CODING_CATEGORY_UCS4_MASK; -} - -static void -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) - { - case 0: - ch = c; - counter = 3; - break; - case 1: - decode_ucs4 ( ( ch << 8 ) | c, dst); - ch = 0; - counter = 0; - break; - default: - ch = ( ch << 8 ) | c; - counter--; - } - } - if (counter & 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, - 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; - unsigned char char_boundary = str->iso2022.current_char_boundary; - Lisp_Object charset = str->iso2022.current_charset; - -#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; - int in_composite = 0; - - back_to_square_n: -#endif - - while (n--) - { - unsigned char c = *src++; - - if (BYTE_ASCII_P (c)) - { /* Processing ASCII character */ - ch = 0; - encode_ucs4 (Vcharset_ascii, c, 0, dst); - char_boundary = 1; - } - else if (BUFBYTE_LEADING_BYTE_P (c) || BUFBYTE_LEADING_BYTE_P (ch)) - { /* Processing Leading Byte */ - ch = 0; - charset = CHARSET_BY_LEADING_BYTE (c); - if (LEADING_BYTE_PREFIX_P(c)) - ch = c; - char_boundary = 0; - } - else - { /* Processing Non-ASCII character */ - char_boundary = 1; - if (EQ (charset, Vcharset_control_1)) - { - encode_ucs4 (Vcharset_control_1, c, 0, dst); - } - else - { - switch (XCHARSET_REP_BYTES (charset)) - { - case 2: - encode_ucs4 (charset, c, 0, dst); - break; - case 3: - if (XCHARSET_PRIVATE_P (charset)) - { - encode_ucs4 (charset, c, 0, dst); - ch = 0; - } - else if (ch) - { -#ifdef ENABLE_COMPOSITE_CHARS - if (EQ (charset, Vcharset_composite)) - { - if (in_composite) - { - /* #### 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, '~'); - } - else - { - Emchar emch = MAKE_CHAR (Vcharset_composite, - ch & 0x7F, c & 0x7F); - Lisp_Object lstr = composite_char_string (emch); - saved_n = n; - saved_src = src; - in_composite = 1; - src = XSTRING_DATA (lstr); - n = XSTRING_LENGTH (lstr); - } - } - else -#endif /* ENABLE_COMPOSITE_CHARS */ - { - encode_ucs4(charset, ch, c, dst); - } - ch = 0; - } - else - { - ch = c; - char_boundary = 0; - } - break; - case 4: - if (ch) - { - encode_ucs4 (charset, ch, c, dst); - ch = 0; - } - else - { - ch = c; - char_boundary = 0; - } - break; - default: - abort (); - } - } - } - } - -#ifdef ENABLE_COMPOSITE_CHARS - if (in_composite) - { - n = saved_n; - src = saved_src; - in_composite = 0; - goto back_to_square_n; /* Wheeeeeeeee ..... */ - } -#endif /* ENABLE_COMPOSITE_CHARS */ - - str->flags = flags; - str->ch = ch; - str->iso2022.current_char_boundary = char_boundary; - str->iso2022.current_charset = charset; - - /* Verbum caro factum est! */ -} - - -/************************************************************************/ -/* UTF-8 methods */ -/************************************************************************/ - -static int -detect_coding_utf8 (struct detection_state *st, const unsigned char *src, - unsigned int n) -{ - while (n--) - { - unsigned char c = *src++; - switch (st->utf8.in_byte) - { - case 0: - if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO) - return 0; - else if (c >= 0xfc) - st->utf8.in_byte = 5; - else if (c >= 0xf8) - st->utf8.in_byte = 4; - else if (c >= 0xf0) - st->utf8.in_byte = 3; - else if (c >= 0xe0) - st->utf8.in_byte = 2; - else if (c >= 0xc0) - st->utf8.in_byte = 1; - else if (c >= 0x80) - return 0; - break; - default: - if ((c & 0xc0) != 0x80) - return 0; - else - st->utf8.in_byte--; - } - } - return CODING_CATEGORY_UTF8_MASK; -} - -static void -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) - { - case 0: - if ( c >= 0xfc ) - { - ch = c & 0x01; - counter = 5; - } - else if ( c >= 0xf8 ) - { - ch = c & 0x03; - counter = 4; - } - else if ( c >= 0xf0 ) - { - ch = c & 0x07; - counter = 3; - } - else if ( c >= 0xe0 ) - { - ch = c & 0x0f; - counter = 2; - } - else if ( c >= 0xc0 ) - { - ch = c & 0x1f; - counter = 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; - break; - default: - ch = ( ch << 6 ) | ( c & 0x3f ); - counter--; - } - 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) -{ - unsigned long code = mule_char_to_ucs4 (charset, h, l); - if ( code <= 0x7f ) - { - Dynarr_add (dst, code); - } - else if ( code <= 0x7ff ) - { - Dynarr_add (dst, (code >> 6) | 0xc0); - Dynarr_add (dst, (code & 0x3f) | 0x80); - } - else if ( code <= 0xffff ) - { - Dynarr_add (dst, (code >> 12) | 0xe0); - Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80); - Dynarr_add (dst, (code & 0x3f) | 0x80); - } - else if ( code <= 0x1fffff ) - { - Dynarr_add (dst, (code >> 18) | 0xf0); - Dynarr_add (dst, ((code >> 12) & 0x3f) | 0x80); - Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80); - Dynarr_add (dst, (code & 0x3f) | 0x80); - } - else if ( code <= 0x3ffffff ) - { - Dynarr_add (dst, (code >> 24) | 0xf8); - Dynarr_add (dst, ((code >> 18) & 0x3f) | 0x80); - Dynarr_add (dst, ((code >> 12) & 0x3f) | 0x80); - Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80); - Dynarr_add (dst, (code & 0x3f) | 0x80); - } - else - { - Dynarr_add (dst, (code >> 30) | 0xfc); - Dynarr_add (dst, ((code >> 24) & 0x3f) | 0x80); - Dynarr_add (dst, ((code >> 18) & 0x3f) | 0x80); - Dynarr_add (dst, ((code >> 12) & 0x3f) | 0x80); - Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80); - Dynarr_add (dst, (code & 0x3f) | 0x80); - } -} - -static void -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; - eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); - unsigned char char_boundary = str->iso2022.current_char_boundary; - Lisp_Object charset = str->iso2022.current_charset; - -#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; - int in_composite = 0; - - back_to_square_n: -#endif /* ENABLE_COMPOSITE_CHARS */ - - while (n--) - { - unsigned char c = *src++; - - if (BYTE_ASCII_P (c)) - { /* Processing ASCII character */ - ch = 0; - if (c == '\n') - { - if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT) - Dynarr_add (dst, '\r'); - if (eol_type != EOL_CR) - Dynarr_add (dst, c); - } - else - encode_utf8 (Vcharset_ascii, c, 0, dst); - char_boundary = 1; - } - else if (BUFBYTE_LEADING_BYTE_P (c) || BUFBYTE_LEADING_BYTE_P (ch)) - { /* Processing Leading Byte */ - ch = 0; - charset = CHARSET_BY_LEADING_BYTE (c); - if (LEADING_BYTE_PREFIX_P(c)) - ch = c; - char_boundary = 0; - } - else - { /* Processing Non-ASCII character */ - char_boundary = 1; - if (EQ (charset, Vcharset_control_1)) - { - encode_utf8 (Vcharset_control_1, c, 0, dst); - } - else - { - switch (XCHARSET_REP_BYTES (charset)) - { - case 2: - encode_utf8 (charset, c, 0, dst); - break; - case 3: - if (XCHARSET_PRIVATE_P (charset)) - { - encode_utf8 (charset, c, 0, dst); - ch = 0; - } - else if (ch) - { -#ifdef ENABLE_COMPOSITE_CHARS - if (EQ (charset, Vcharset_composite)) - { - if (in_composite) - { - /* #### Bother! We don't know how to - handle this yet. */ - encode_utf8 (Vcharset_ascii, '~', 0, dst); - } - else - { - Emchar emch = MAKE_CHAR (Vcharset_composite, - ch & 0x7F, c & 0x7F); - Lisp_Object lstr = composite_char_string (emch); - saved_n = n; - saved_src = src; - in_composite = 1; - src = XSTRING_DATA (lstr); - n = XSTRING_LENGTH (lstr); - } - } - else -#endif /* ENABLE_COMPOSITE_CHARS */ - { - encode_utf8 (charset, ch, c, dst); - } - ch = 0; - } - else - { - ch = c; - char_boundary = 0; - } - break; - case 4: - if (ch) - { - encode_utf8 (charset, ch, c, dst); - ch = 0; - } - else - { - ch = c; - char_boundary = 0; - } - break; - default: - abort (); - } - } - } - } - -#ifdef ENABLE_COMPOSITE_CHARS - if (in_composite) - { - n = saved_n; - src = saved_src; - in_composite = 0; - goto back_to_square_n; /* Wheeeeeeeee ..... */ - } -#endif - - str->flags = flags; - str->ch = ch; - str->iso2022.current_char_boundary = char_boundary; - str->iso2022.current_charset = charset; - - /* Verbum caro factum est! */ -} - - -/************************************************************************/ -/* ISO2022 methods */ -/************************************************************************/ - -/* The following note describes the coding system ISO2022 briefly. - Since the intention of this note is to help understand the - functions in this file, some parts are NOT ACCURATE or OVERLY - SIMPLIFIED. For thorough understanding, please refer to the - original document of ISO2022. - - ISO2022 provides many mechanisms to encode several character sets - in 7-bit and 8-bit environments. For 7-bit environments, all text - is encoded using bytes less than 128. This may make the encoded - text a little bit longer, but the text passes more easily through - several gateways, some of which strip off MSB (Most Signigant Bit). - - There are two kinds of character sets: control character set and - graphic character set. The former contains control characters such - as `newline' and `escape' to provide control functions (control - functions are also provided by escape sequences). The latter - contains graphic characters such as 'A' and '-'. Emacs recognizes - two control character sets and many graphic character sets. - - Graphic character sets are classified into one of the following - four classes, according to the number of bytes (DIMENSION) and - number of characters in one dimension (CHARS) of the set: - - DIMENSION1_CHARS94 - - DIMENSION1_CHARS96 - - DIMENSION2_CHARS94 - - DIMENSION2_CHARS96 - - In addition, each character set is assigned an identification tag, - unique for each set, called "final character" (denoted as - hereafter). The of each character set is decided by ECMA(*) - when it is registered in ISO. The code range of is 0x30..0x7F - (0x30..0x3F are for private use only). - - Note (*): ECMA = European Computer Manufacturers Association - - Here are examples of graphic character set [NAME()]: - o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ... - o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ... - o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ... - o DIMENSION2_CHARS96 -- none for the moment - - A code area (1 byte = 8 bits) is divided into 4 areas, C0, GL, C1, and GR. - C0 [0x00..0x1F] -- control character plane 0 - GL [0x20..0x7F] -- graphic character plane 0 - C1 [0x80..0x9F] -- control character plane 1 - GR [0xA0..0xFF] -- graphic character plane 1 - - A control character set is directly designated and invoked to C0 or - C1 by an escape sequence. The most common case is that: - - ISO646's control character set is designated/invoked to C0, and - - ISO6429's control character set is designated/invoked to C1, - and usually these designations/invocations are omitted in encoded - text. In a 7-bit environment, only C0 can be used, and a control - character for C1 is encoded by an appropriate escape sequence to - fit into the environment. All control characters for C1 are - defined to have corresponding escape sequences. - - A graphic character set is at first designated to one of four - graphic registers (G0 through G3), then these graphic registers are - invoked to GL or GR. These designations and invocations can be - done independently. The most common case is that G0 is invoked to - GL, G1 is invoked to GR, and ASCII is designated to G0. Usually - these invocations and designations are omitted in encoded text. - In a 7-bit environment, only GL can be used. - - When a graphic character set of CHARS94 is invoked to GL, codes - 0x20 and 0x7F of the GL area work as control characters SPACE and - DEL respectively, and codes 0xA0 and 0xFF of the GR area should not - be used. - - There are two ways of invocation: locking-shift and single-shift. - With locking-shift, the invocation lasts until the next different - invocation, whereas with single-shift, the invocation affects the - following character only and doesn't affect the locking-shift - state. Invocations are done by the following control characters or - escape sequences: + ---------------------------------------------------------------------- + abbrev function cntrl escape seq description + ---------------------------------------------------------------------- + SI/LS0 (shift-in) 0x0F none invoke G0 into GL + SO/LS1 (shift-out) 0x0E none invoke G1 into GL + LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR + LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL + LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR + LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL + LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR + SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char + SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char + ---------------------------------------------------------------------- + The first four are for locking-shift. Control characters for these + functions are defined by macros ISO_CODE_XXX in `coding.h'. - ---------------------------------------------------------------------- - abbrev function cntrl escape seq description - ---------------------------------------------------------------------- - SI/LS0 (shift-in) 0x0F none invoke G0 into GL - SO/LS1 (shift-out) 0x0E none invoke G1 into GL - LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL - LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL - LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*) - LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*) - LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*) - SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char - SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char - ---------------------------------------------------------------------- - (*) These are not used by any known coding system. - - Control characters for these functions are defined by macros - ISO_CODE_XXX in `coding.h'. - - Designations are done by the following escape sequences: + Designations are done by the following escape sequences. ---------------------------------------------------------------------- escape sequence description ---------------------------------------------------------------------- - ESC '(' designate DIMENSION1_CHARS94 to G0 - ESC ')' designate DIMENSION1_CHARS94 to G1 - ESC '*' designate DIMENSION1_CHARS94 to G2 - ESC '+' designate DIMENSION1_CHARS94 to G3 - ESC ',' designate DIMENSION1_CHARS96 to G0 (*) - ESC '-' designate DIMENSION1_CHARS96 to G1 - ESC '.' designate DIMENSION1_CHARS96 to G2 - ESC '/' designate DIMENSION1_CHARS96 to G3 - ESC '$' '(' designate DIMENSION2_CHARS94 to G0 (**) - ESC '$' ')' designate DIMENSION2_CHARS94 to G1 - ESC '$' '*' designate DIMENSION2_CHARS94 to G2 - ESC '$' '+' designate DIMENSION2_CHARS94 to G3 - ESC '$' ',' designate DIMENSION2_CHARS96 to G0 (*) - ESC '$' '-' designate DIMENSION2_CHARS96 to G1 - ESC '$' '.' designate DIMENSION2_CHARS96 to G2 - ESC '$' '/' designate DIMENSION2_CHARS96 to G3 + ESC '(' designate TYPE94 to G0 + ESC ')' designate TYPE94 to G1 + ESC '*' designate TYPE94 to G2 + ESC '+' designate TYPE94 to G3 + ESC ',' designate TYPE96 to G0 (*) + ESC '-' designate TYPE96 to G1 + ESC '.' designate TYPE96 to G2 + ESC '/' designate TYPE96 to G3 + ESC '$' '(' designate TYPE94x94 to G0 (**) + ESC '$' ')' designate TYPE94x94 to G1 + ESC '$' '*' designate TYPE94x94 to G2 + ESC '$' '+' designate TYPE94x94 to G3 + ESC '$' ',' designate TYPE96x96 to G0 (*) + ESC '$' '-' designate TYPE96x96 to G1 + ESC '$' '.' designate TYPE96x96 to G2 + ESC '$' '/' designate TYPE96x96 to G3 ---------------------------------------------------------------------- - - In this list, "DIMENSION1_CHARS94" means a graphic character set - of dimension 1, chars 94, and final character , etc... + In this list, "TYPE94" means a graphic character set of type TYPE94 + and final character , and etc. Note (*): Although these designations are not allowed in ISO2022, Emacs accepts them on decoding, and produces them on encoding - CHARS96 character sets in a coding system which is characterized as - 7-bit environment, non-locking-shift, and non-single-shift. + TYPE96 or TYPE96x96 character set in a coding system which is + characterized as 7-bit environment, non-locking-shift, and + non-single-shift. Note (**): If is '@', 'A', or 'B', the intermediate character - '(' can be omitted. We refer to this as "short-form" hereafter. + '(' can be omitted. We call this as "short-form" here after. Now you may notice that there are a lot of ways for encoding the same multilingual text in ISO2022. Actually, there exist many - coding systems such as Compound Text (used in X11's inter client + coding systems such as Compound Text (used in X's inter client communication, ISO-2022-JP (used in Japanese internet), ISO-2022-KR (used in Korean internet), EUC (Extended UNIX Code, used in Asian localized platforms), and all of these are variants of ISO2022. @@ -4209,19 +3159,19 @@ encode_coding_utf8 (Lstream *encoding, const unsigned char *src, sequences: ISO6429's direction specification and Emacs' private sequence for specifying character composition. - ISO6429's direction specification takes the following form: + ISO6429's direction specification takes the following format: o CSI ']' -- end of the current direction o CSI '0' ']' -- end of the current direction o CSI '1' ']' -- start of left-to-right text o CSI '2' ']' -- start of right-to-left text The control character CSI (0x9B: control sequence introducer) is - abbreviated to the escape sequence ESC '[' in a 7-bit environment. + abbreviated to the escape sequence ESC '[' in 7-bit environment. - Character composition specification takes the following form: + Character composition specification takes the following format: o ESC '0' -- start character composition o ESC '1' -- end character composition - Since these are not standard escape sequences of any ISO standard, - their use with these meanings is restricted to Emacs only. */ + Since these are not standard escape sequences of any ISO, the use + of them for these meanings is restricted to Emacs only. */ static void reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso) @@ -4245,10 +3195,8 @@ reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso) iso->invalid_switch_dir = 0; iso->output_direction_sequence = 0; iso->output_literally = 0; -#ifdef ENABLE_COMPOSITE_CHARS if (iso->composite_chars) Dynarr_reset (iso->composite_chars); -#endif } static int @@ -4376,7 +3324,6 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, reg = 3; half = 1; goto locking_shift; -#ifdef ENABLE_COMPOSITE_CHARS /**** composite ****/ case '0': @@ -4390,7 +3337,6 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, *flags = (*flags & CODING_STATE_ISO2022_LOCK) & ~CODING_STATE_COMPOSITE; return 1; -#endif /* ENABLE_COMPOSITE_CHARS */ /**** directionality ****/ @@ -4644,18 +3590,14 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, } 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 c; int mask; /* #### There are serious deficiencies in the recognition mechanism - here. This needs to be much smarter if it's going to cut it. - The sequence "\xff\x0f" is currently detected as LOCK_SHIFT while - it should be detected as Latin-1. - All the ISO2022 stuff in this file should be synced up with the - code from FSF Emacs-20.4, in which Mule should be more or less stable. - Perhaps we should wait till R2L works in FSF Emacs? */ + here. This needs to be much smarter if it's going to cut it. */ if (!st->iso2022.initted) { @@ -4675,7 +3617,7 @@ detect_coding_iso2022 (struct detection_state *st, const unsigned char *src, while (n--) { - int c = *src++; + c = *src++; if (c >= 0xA0) { mask &= ~CODING_CATEGORY_ISO_7_MASK; @@ -4774,7 +3716,7 @@ postprocess_iso2022_mask (int mask) need to handle the CSI differently. */ static void -restore_left_to_right_direction (Lisp_Coding_System *codesys, +restore_left_to_right_direction (struct Lisp_Coding_System *codesys, unsigned_char_dynarr *dst, unsigned int *flags, int internal_p) @@ -4805,7 +3747,7 @@ restore_left_to_right_direction (Lisp_Coding_System *codesys, need to handle the CSI differently. */ static void -ensure_correct_direction (int direction, Lisp_Coding_System *codesys, +ensure_correct_direction (int direction, struct Lisp_Coding_System *codesys, unsigned_char_dynarr *dst, unsigned int *flags, int internal_p) { @@ -4835,28 +3777,26 @@ 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, +decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { + unsigned char c; + unsigned int flags, ch; + enum eol_type eol_type; 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; -#ifdef ENABLE_COMPOSITE_CHARS - unsigned_char_dynarr *real_dst = dst; -#endif Lisp_Object coding_system; + unsigned_char_dynarr *real_dst = dst; + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = str->eol_type; XSETCODING_SYSTEM (coding_system, str->codesys); -#ifdef ENABLE_COMPOSITE_CHARS if (flags & CODING_STATE_COMPOSITE) dst = str->iso2022.composite_chars; -#endif /* ENABLE_COMPOSITE_CHARS */ while (n--) { - unsigned char c = *src++; + c = *src++; if (flags & CODING_STATE_ESCAPE) { /* Within ESC sequence */ int retval = parse_iso2022_esc (coding_system, &str->iso2022, @@ -4866,7 +3806,6 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, { switch (str->iso2022.esc) { -#ifdef ENABLE_COMPOSITE_CHARS case ISO_ESC_START_COMPOSITE: if (str->iso2022.composite_chars) Dynarr_reset (str->iso2022.composite_chars); @@ -4885,7 +3824,6 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, Dynarr_add_many (dst, comstr, len); break; } -#endif /* ENABLE_COMPOSITE_CHARS */ case ISO_ESC_LITERAL: DECODE_ADD_BINARY_CHAR (c, dst); @@ -4973,8 +3911,7 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, charset = str->iso2022.charset[reg]; /* Error checking: */ - if (! CHARSETP (charset) - || str->iso2022.invalid_designated[reg] + if (NILP (charset) || str->iso2022.invalid_designated[reg] || (((c & 0x7F) == ' ' || (c & 0x7F) == ISO_CODE_DEL) && XCHARSET_CHARS (charset) == 94)) /* Mrmph. We are trying to invoke a register that has no @@ -5063,8 +4000,7 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, if (flags & CODING_STATE_END) DECODE_OUTPUT_PARTIAL_CHAR (ch); - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } @@ -5076,8 +4012,7 @@ 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[] = ",-./"; + CONST char *inter94 = "()*+", *inter96= ",-./"; unsigned int type; unsigned char final; Lisp_Object old_charset = str->iso2022.charset[reg]; @@ -5161,35 +4096,32 @@ 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, +encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char charmask, c; + unsigned int flags, ch; + enum eol_type eol_type; unsigned char char_boundary; struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); - unsigned int flags = str->flags; - unsigned int ch = str->ch; - Lisp_Coding_System *codesys = str->codesys; - eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); + struct Lisp_Coding_System *codesys = str->codesys; int i; Lisp_Object charset; int half; -#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 */ + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); char_boundary = str->iso2022.current_char_boundary; charset = str->iso2022.current_charset; half = str->iso2022.current_half; -#ifdef ENABLE_COMPOSITE_CHARS back_to_square_n: -#endif while (n--) { c = *src++; @@ -5248,10 +4180,7 @@ encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, if (LEADING_BYTE_PREFIX_P(c)) ch = c; else if (!EQ (charset, Vcharset_control_1) -#ifdef ENABLE_COMPOSITE_CHARS - && !EQ (charset, Vcharset_composite) -#endif - ) + && !EQ (charset, Vcharset_composite)) { int reg; @@ -5371,7 +4300,6 @@ encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, } else if (ch) { -#ifdef ENABLE_COMPOSITE_CHARS if (EQ (charset, Vcharset_composite)) { if (in_composite) @@ -5395,7 +4323,6 @@ encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, } } else -#endif /* ENABLE_COMPOSITE_CHARS */ { Dynarr_add (dst, ch & charmask); Dynarr_add (dst, c & charmask); @@ -5428,7 +4355,6 @@ encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, } } -#ifdef ENABLE_COMPOSITE_CHARS if (in_composite) { n = saved_n; @@ -5438,7 +4364,6 @@ encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, Dynarr_add (dst, '1'); /* end composing */ goto back_to_square_n; /* Wheeeeeeeee ..... */ } -#endif /* ENABLE_COMPOSITE_CHARS */ if (char_boundary && flags & CODING_STATE_END) { @@ -5452,8 +4377,7 @@ encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, } } - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); str->iso2022.current_char_boundary = char_boundary; str->iso2022.current_charset = charset; str->iso2022.current_half = half; @@ -5470,14 +4394,16 @@ 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, +decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; + unsigned int flags, ch; + enum eol_type eol_type; 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; + + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = str->eol_type; while (n--) { @@ -5490,19 +4416,20 @@ decode_coding_no_conversion (Lstream *decoding, const unsigned char *src, DECODE_HANDLE_END_OF_CONVERSION (flags, ch, dst); - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, 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; - unsigned int ch = str->ch; - eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); + unsigned int flags, ch; + enum eol_type eol_type; + + CODING_STREAM_DECOMPOSE (str, flags, ch); + eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); while (n--) { @@ -5544,19 +4471,172 @@ encode_coding_no_conversion (Lstream *encoding, const unsigned char *src, } } - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } +/************************************************************************/ +/* Simple internal/external functions */ +/************************************************************************/ + +static Extbyte_dynarr *conversion_out_dynarr; +static Bufbyte_dynarr *conversion_in_dynarr; + +/* Determine coding system from coding format */ + +#define FILE_NAME_CODING_SYSTEM \ + ((NILP (Vfile_name_coding_system) || \ + (EQ ((Vfile_name_coding_system), Qbinary))) ? \ + Qnil : Fget_coding_system (Vfile_name_coding_system)) + +/* #### not correct for all values of `fmt'! */ +#ifdef MULE +#define FMT_CODING_SYSTEM(fmt) \ + (((fmt) == FORMAT_FILENAME) ? FILE_NAME_CODING_SYSTEM : \ + ((fmt) == FORMAT_CTEXT ) ? Fget_coding_system (Qctext) : \ + ((fmt) == FORMAT_TERMINAL) ? FILE_NAME_CODING_SYSTEM : \ + Qnil) +#else +#define FMT_CODING_SYSTEM(fmt) \ + (((fmt) == FORMAT_FILENAME) ? FILE_NAME_CODING_SYSTEM : \ + ((fmt) == FORMAT_TERMINAL) ? FILE_NAME_CODING_SYSTEM : \ + Qnil) +#endif +Extbyte * +convert_to_external_format (CONST Bufbyte *ptr, + Bytecount len, + Extcount *len_out, + enum external_data_format fmt) +{ + Lisp_Object coding_system = FMT_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 = FMT_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) { + defsymbol (&Qbuffer_file_coding_system, "buffer-file-coding-system"); deferror (&Qcoding_system_error, "coding-system-error", "Coding-system error", Qio_error); @@ -5567,10 +4647,6 @@ syms_of_file_coding (void) 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); @@ -5594,19 +4670,12 @@ syms_of_file_coding (void) DEFSUBR (Fencode_shift_jis_char); DEFSUBR (Fdecode_big5_char); DEFSUBR (Fencode_big5_char); - 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"); defsymbol (&Qccl, "ccl"); defsymbol (&Qiso2022, "iso2022"); #endif /* MULE */ @@ -5645,14 +4714,11 @@ syms_of_file_coding (void) 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], - "ucs-4"); - defsymbol (&coding_category_symbol[CODING_CATEGORY_UTF8], - "utf-8"); defsymbol (&coding_category_symbol[CODING_CATEGORY_ISO_7], "iso-7"); defsymbol (&coding_category_symbol[CODING_CATEGORY_ISO_8_DESIGNATE], @@ -5669,7 +4735,7 @@ syms_of_file_coding (void) } void -lstream_type_create_file_coding (void) +lstream_type_create_mule_coding (void) { LSTREAM_HAS_METHOD (decoding, reader); LSTREAM_HAS_METHOD (decoding, writer); @@ -5689,18 +4755,15 @@ lstream_type_create_file_coding (void) } 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; - fcd->coding_category_by_priority[i] = i; + coding_category_system[i] = Qnil; + coding_category_by_priority[i] = i; } Fprovide (intern ("file-coding")); @@ -5718,24 +4781,24 @@ 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. -You should bind this variable with `let', but do not set it globally. -If this is non-nil, it specifies the coding system that will be used -to decode input on read operations, such as from a file or process. -It overrides `buffer-file-coding-system-for-read', +Overriding coding system used when writing a file or process. +You should *bind* this, not set it. If this is non-nil, it specifies +the coding system that will be used when a file or process is read +in, and 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. -You should bind this variable with `let', but do not set it globally. -If this is non-nil, it specifies the coding system that will be used -to encode output for write operations, such as to a file or process. -It overrides `buffer-file-coding-system', `write-region-pre-hook', etc. -Use those variables instead of this one for permanent changes to the -environment. */ ); +Overriding coding system used when writing a file or process. +You should *bind* this, not set it. If this is non-nil, it specifies +the coding system that will be used when a file or process is wrote +in, and overrides `buffer-file-coding-system', +`write-region-pre-hook', etc. Use those variables instead of this one +for permanent changes to the environment. +*/ ); Vcoding_system_for_write = Qnil; DEFVAR_LISP ("file-name-coding-system", &Vfile_name_coding_system /* @@ -5754,14 +4817,13 @@ Setting this to nil does not do anything. } 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); + staticpro (&Vcoding_system_hashtable); + Vcoding_system_hashtable = make_lisp_hashtable (50, HASHTABLE_NONWEAK, + HASHTABLE_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 \ { \ @@ -5801,36 +4863,13 @@ complex_vars_of_file_coding (void) DEFINE_CODESYS_PROP (CODESYS_PROP_CCL, Qdecode); #endif /* MULE */ /* Need to create this here or we're really screwed. */ - Fmake_coding_system - (Qraw_text, Qno_conversion, - build_string ("Raw text, which means it converts only line-break-codes."), - list2 (Qmnemonic, build_string ("Raw"))); - - 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); + Fmake_coding_system (Qno_conversion, Qno_conversion, build_string ("No conversion"), + list2 (Qmnemonic, build_string ("Noconv"))); - Fdefine_coding_system_alias (Qfile_name, Qbinary); - - Fdefine_coding_system_alias (Qterminal, Qbinary); - Fdefine_coding_system_alias (Qkeyboard, Qbinary); + Fcopy_coding_system (Fcoding_system_property (Qno_conversion, Qeol_lf), + Qbinary); /* Need this for bootstrapping */ - fcd->coding_category_system[CODING_CATEGORY_NO_CONVERSION] = - Fget_coding_system (Qraw_text); - -#ifdef MULE - { - unsigned int i; - - for (i = 0; i < 65536; i++) - fcd->ucs_to_mule_table[i] = Qnil; - } - staticpro (&mule_to_ucs_table); - mule_to_ucs_table = Fmake_char_table(Qgeneric); -#endif /* MULE */ + coding_category_system[CODING_CATEGORY_NO_CONVERSION] = + Fget_coding_system (Qno_conversion); }