X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Ffile-coding.c;h=48363a44a695c183154693e6ad9dac96c05cb4e2;hb=ba17ba37ee9b3a9fcc395f8f6fdd565957a44705;hp=4ced7925e5c769d0999ed99659714cfb4906f066;hpb=ea21eb75bbf90355514d65686bd53bea579f8e23;p=chise%2Fxemacs-chise.git diff --git a/src/file-coding.c b/src/file-coding.c index 4ced792..48363a4 100644 --- a/src/file-coding.c +++ b/src/file-coding.c @@ -25,18 +25,16 @@ Boston, MA 02111-1307, USA. */ #include #include "lisp.h" - #include "buffer.h" #include "elhash.h" #include "insdel.h" #include "lstream.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; @@ -47,35 +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]; - - Lisp_Object ucs_to_mule_table[65536]; -} *fcd; - -static const struct lrecord_description fcd_description_1[] = { - { XD_LISP_OBJECT, offsetof(struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 }, - { XD_LISP_OBJECT, offsetof(struct file_coding_dump, ucs_to_mule_table), 65536 }, - { 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; @@ -85,7 +64,6 @@ 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; @@ -97,7 +75,7 @@ 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; @@ -125,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 @@ -190,24 +166,6 @@ static void decode_coding_big5 (Lstream *decoding, 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, - 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); @@ -246,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), 1 }, - { 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 @@ -280,62 +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), 2 }, - { 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(struct Lisp_Coding_System, name), 2 }, - { XD_LISP_OBJECT, offsetof(struct Lisp_Coding_System, mnemonic), 3 }, - { XD_LISP_OBJECT, offsetof(struct Lisp_Coding_System, eol_lf), 3 }, -#ifdef MULE - { XD_LISP_OBJECT, offsetof(struct Lisp_Coding_System, iso2022.initial_charset), 4 }, - { XD_STRUCT_PTR, offsetof(struct Lisp_Coding_System, iso2022.input_conv), 1, &ccsd_description }, - { XD_STRUCT_PTR, offsetof(struct Lisp_Coding_System, iso2022.output_conv), 1, &ccsd_description }, - { XD_LISP_OBJECT, offsetof(struct Lisp_Coding_System, ccl.decode), 2 }, -#endif - { XD_END } -}; - DEFINE_LRECORD_IMPLEMENTATION ("coding-system", coding_system, mark_coding_system, print_coding_system, finalize_coding_system, - 0, 0, coding_system_description, - struct 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)) { @@ -343,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) @@ -360,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); } @@ -383,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); @@ -396,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. */ @@ -442,16 +344,16 @@ 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); @@ -537,7 +439,7 @@ associated coding system object is returned. else CHECK_SYMBOL (coding_system_or_name); - return Fgethash (coding_system_or_name, Vcoding_system_hash_table, Qnil); + return Fgethash (coding_system_or_name, Vcoding_system_hashtable, Qnil); } DEFUN ("get-coding-system", Fget_coding_system, 1, 1, 0, /* @@ -563,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; } @@ -586,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; @@ -602,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; @@ -705,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 @@ -863,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; @@ -875,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; } @@ -989,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; } } @@ -1010,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)); @@ -1024,44 +925,10 @@ be created. return new_coding_system; } -DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias, 2, 2, 0, /* -Define symbol ALIAS as an alias for coding system CODING-SYSTEM. -*/ - (alias, coding_system)) -{ - CHECK_SYMBOL (alias); - if (!NILP (Ffind_coding_system (alias))) - signal_simple_error ("Symbol already names a coding system", alias); - coding_system = Fget_coding_system (coding_system); - Fputhash (alias, coding_system, Vcoding_system_hash_table); - - /* Set up aliases for subsidiaries. */ - if (XCODING_SYSTEM_EOL_TYPE (coding_system) == EOL_AUTODETECT) - { - Lisp_Object str; - XSETSTRING (str, symbol_name (XSYMBOL (alias))); -#define FROB(type, name) \ - do { \ - Lisp_Object subsidiary = XCODING_SYSTEM_EOL_##type (coding_system); \ - if (!NILP (subsidiary)) \ - Fdefine_coding_system_alias \ - (Fintern (concat2 (str, build_string (name)), Qnil), subsidiary); \ - } while (0) - FROB (LF, "-unix"); - FROB (CRLF, "-dos"); - FROB (CR, "-mac"); -#undef FROB - } - /* 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, 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) @@ -1111,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 @@ -1339,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++; } @@ -1348,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; @@ -1363,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; } @@ -1376,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; } @@ -1386,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); @@ -1421,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; @@ -1490,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; } @@ -1527,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; @@ -1549,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; @@ -1567,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); @@ -1604,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 @@ -1618,29 +1466,27 @@ 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, enum eol_type *eol_type_in_out) @@ -1655,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. */ @@ -1795,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; @@ -1816,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); @@ -1908,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) @@ -1921,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. */ @@ -1955,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; @@ -1987,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; } @@ -1997,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 @@ -2059,11 +1818,11 @@ decoding_reader (Lstream *stream, unsigned char *data, size_t size) return data - orig_data; } -static ssize_t +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 @@ -2093,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; } @@ -2132,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); } @@ -2153,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) @@ -2270,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); @@ -2333,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; @@ -2368,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. */ @@ -2418,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; @@ -2442,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; } @@ -2452,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 @@ -2514,11 +2264,11 @@ encoding_reader (Lstream *stream, unsigned char *data, size_t size) return data - orig_data; } -static ssize_t +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 @@ -2618,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); @@ -2682,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); @@ -2741,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; @@ -2774,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. @@ -2833,10 +2576,12 @@ 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--) { @@ -2879,8 +2624,7 @@ 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. */ @@ -2891,9 +2635,11 @@ encode_coding_sjis (Lstream *encoding, CONST unsigned char *src, { 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--) { @@ -2936,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, /* @@ -3003,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. */ @@ -3120,10 +2865,12 @@ 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--) { @@ -3159,8 +2906,7 @@ 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. */ @@ -3171,9 +2917,11 @@ encode_coding_big5 (Lstream *encoding, CONST unsigned char *src, { 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--) { @@ -3221,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); } @@ -3277,848 +3024,193 @@ 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. + + 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. + + 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. + + ---------------------------------------------------------------------- + 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'. + + Designations are done by the following escape sequences. + ---------------------------------------------------------------------- + escape sequence description + ---------------------------------------------------------------------- + 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, "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 + 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 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 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. + + In addition to the above, Emacs handles two more kinds of escape + sequences: ISO6429's direction specification and Emacs' private + sequence for specifying character composition. + + 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 7-bit environment. + + 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, the use + of them for these meanings is restricted to Emacs only. */ -/* 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) +reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso) { - Lisp_Object chr = ucs_to_char (ch); + int i; - 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 + for (i = 0; i < 4; i++) { - Dynarr_add (dst, LEADING_BYTE_JAPANESE_JISX0208); - Dynarr_add (dst, 34 + 128); - Dynarr_add (dst, 46 + 128); + if (!NILP (coding_system)) + iso->charset[i] = + XCODING_SYSTEM_ISO2022_INITIAL_CHARSET (coding_system, i); + else + iso->charset[i] = Qt; + iso->invalid_designated[i] = 0; } + iso->esc = ISO_ESC_NOTHING; + iso->esc_bytes_index = 0; + iso->register_left = 0; + iso->register_right = 1; + iso->switched_dir_and_no_valid_charset_yet = 0; + iso->invalid_switch_dir = 0; + iso->output_direction_sequence = 0; + iso->output_literally = 0; + if (iso->composite_chars) + Dynarr_reset (iso->composite_chars); } -static unsigned long -mule_char_to_ucs4 (Lisp_Object charset, - unsigned char h, unsigned char l) +static int +fit_to_be_escape_quoted (unsigned char c) { - 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) ) + switch (c) { - 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 - 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: - ---------------------------------------------------------------------- - 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 - ---------------------------------------------------------------------- - - In this list, "DIMENSION1_CHARS94" means a graphic character set - of dimension 1, chars 94, and final character , 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. - - Note (**): If is '@', 'A', or 'B', the intermediate character - '(' can be omitted. We refer to this as "short-form" hereafter. - - 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 - 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. - - In addition to the above, Emacs handles two more kinds of escape - sequences: ISO6429's direction specification and Emacs' private - sequence for specifying character composition. - - ISO6429's direction specification takes the following form: - 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. - - Character composition specification takes the following form: - 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. */ - -static void -reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso) -{ - int i; - - for (i = 0; i < 4; i++) - { - if (!NILP (coding_system)) - iso->charset[i] = - XCODING_SYSTEM_ISO2022_INITIAL_CHARSET (coding_system, i); - else - iso->charset[i] = Qt; - iso->invalid_designated[i] = 0; - } - iso->esc = ISO_ESC_NOTHING; - iso->esc_bytes_index = 0; - iso->register_left = 0; - iso->register_right = 1; - iso->switched_dir_and_no_valid_charset_yet = 0; - 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 -fit_to_be_escape_quoted (unsigned char c) -{ - switch (c) - { - case ISO_CODE_ESC: - case ISO_CODE_CSI: - case ISO_CODE_SS2: - case ISO_CODE_SS3: - case ISO_CODE_SO: - case ISO_CODE_SI: - return 1; + case ISO_CODE_ESC: + case ISO_CODE_CSI: + case ISO_CODE_SS2: + case ISO_CODE_SS3: + case ISO_CODE_SO: + case ISO_CODE_SI: + return 1; default: return 0; @@ -4232,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': @@ -4246,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 ****/ @@ -4503,15 +3593,11 @@ static int 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) { @@ -4531,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; @@ -4630,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) @@ -4661,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) { @@ -4694,25 +3780,23 @@ static void 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, @@ -4722,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); @@ -4741,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); @@ -4829,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 @@ -4919,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); } @@ -4932,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]; @@ -5021,31 +4100,28 @@ 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; 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++; @@ -5104,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; @@ -5227,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) @@ -5251,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); @@ -5284,7 +4355,6 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, } } -#ifdef ENABLE_COMPOSITE_CHARS if (in_composite) { n = saved_n; @@ -5294,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) { @@ -5308,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; @@ -5330,10 +4398,12 @@ 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--) { @@ -5346,8 +4416,7 @@ 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 @@ -5356,9 +4425,11 @@ encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src, { 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--) { @@ -5400,8 +4471,7 @@ encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src, } } - str->flags = flags; - str->ch = ch; + CODING_STREAM_COMPOSE (str, flags, ch); } @@ -5414,27 +4484,24 @@ 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'! */ -static Lisp_Object -external_data_format_to_coding_system (enum external_data_format fmt) -{ - switch (fmt) - { - case FORMAT_FILENAME: - case FORMAT_TERMINAL: - if (EQ (Vfile_name_coding_system, Qnil) || - EQ (Vfile_name_coding_system, Qbinary)) - return Qnil; - else - return Fget_coding_system (Vfile_name_coding_system); #ifdef MULE - case FORMAT_CTEXT: - return Fget_coding_system (Qctext); +#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 - default: - return Qnil; - } -} Extbyte * convert_to_external_format (CONST Bufbyte *ptr, @@ -5442,7 +4509,7 @@ convert_to_external_format (CONST Bufbyte *ptr, Extcount *len_out, enum external_data_format fmt) { - Lisp_Object coding_system = external_data_format_to_coding_system (fmt); + Lisp_Object coding_system = FMT_CODING_SYSTEM (fmt); if (!conversion_out_dynarr) conversion_out_dynarr = Dynarr_new (Extbyte); @@ -5486,7 +4553,7 @@ convert_to_external_format (CONST Bufbyte *ptr, GCPRO3 (instream, outstream, da_outstream); while (1) { - 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; Lstream_write (ostr, tempbuf, size_in_bytes); @@ -5510,7 +4577,7 @@ convert_from_external_format (CONST Extbyte *ptr, Bytecount *len_out, enum external_data_format fmt) { - Lisp_Object coding_system = external_data_format_to_coding_system (fmt); + Lisp_Object coding_system = FMT_CODING_SYSTEM (fmt); if (!conversion_in_dynarr) conversion_in_dynarr = Dynarr_new (Bufbyte); @@ -5543,7 +4610,7 @@ convert_from_external_format (CONST Extbyte *ptr, GCPRO3 (instream, outstream, da_outstream); while (1) { - 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; Lstream_write (ostr, tempbuf, size_in_bytes); @@ -5567,8 +4634,9 @@ convert_from_external_format (CONST Extbyte *ptr, /************************************************************************/ 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); @@ -5579,7 +4647,6 @@ syms_of_file_coding (void) DEFSUBR (Fcoding_system_name); DEFSUBR (Fmake_coding_system); DEFSUBR (Fcopy_coding_system); - DEFSUBR (Fdefine_coding_system_alias); DEFSUBR (Fsubsidiary_coding_system); DEFSUBR (Fcoding_system_type); @@ -5603,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 */ @@ -5659,10 +4719,6 @@ syms_of_file_coding (void) "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], @@ -5679,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); @@ -5699,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")); @@ -5764,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 \ { \ @@ -5811,31 +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"))); + Fmake_coding_system (Qno_conversion, Qno_conversion, build_string ("No conversion"), + list2 (Qmnemonic, build_string ("Noconv"))); - Fdefine_coding_system_alias (Qno_conversion, Qraw_text); + 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); }