X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Ftext-coding.c;h=14991487174717af48a144ae28ad940bae6be522;hb=86055d56f206c256f3a303fdd74ede157d9f5396;hp=69702baaefc89db18e534020cbca27c4b0c8e5d7;hpb=f52a96980ed9280f8f906a20d4b899dc0b027644;p=chise%2Fxemacs-chise.git- diff --git a/src/text-coding.c b/src/text-coding.c index 69702ba..1499148 100644 --- a/src/text-coding.c +++ b/src/text-coding.c @@ -67,7 +67,7 @@ struct file_coding_dump { static const struct lrecord_description fcd_description_1[] = { { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 }, #if defined(MULE) && !defined(UTF2000) - { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), 65536 }, + { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), countof (fcd->ucs_to_mule_table) }, #endif { XD_END } }; @@ -181,47 +181,38 @@ EXFUN (Fcopy_coding_system, 2); struct detection_state; static void -text_encode_generic (Lstream *encoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); +text_encode_generic (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n); static int detect_coding_sjis (struct detection_state *st, - const unsigned char *src, - unsigned int n); -static void decode_coding_sjis (Lstream *decoding, - const unsigned char *src, - unsigned_char_dynarr *dst, - unsigned int n); + const Extbyte *src, size_t n); +static void decode_coding_sjis (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); void char_encode_shift_jis (struct encoding_stream *str, Emchar c, unsigned_char_dynarr *dst, unsigned int *flags); void char_finish_shift_jis (struct encoding_stream *str, unsigned_char_dynarr *dst, unsigned int *flags); static int detect_coding_big5 (struct detection_state *st, - const unsigned char *src, - unsigned int n); -static void decode_coding_big5 (Lstream *decoding, - const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); -static void encode_coding_big5 (Lstream *encoding, - const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); + const Extbyte *src, size_t n); +static void decode_coding_big5 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); +static void encode_coding_big5 (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n); + static int detect_coding_ucs4 (struct detection_state *st, - const unsigned char *src, - unsigned int n); -static void decode_coding_ucs4 (Lstream *decoding, - const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); + const Extbyte *src, size_t n); +static void decode_coding_ucs4 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); void char_encode_ucs4 (struct encoding_stream *str, Emchar c, unsigned_char_dynarr *dst, unsigned int *flags); void char_finish_ucs4 (struct encoding_stream *str, unsigned_char_dynarr *dst, unsigned int *flags); 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); + const Extbyte *src, size_t n); +static void decode_coding_utf8 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); void char_encode_utf8 (struct encoding_stream *str, Emchar c, unsigned_char_dynarr *dst, unsigned int *flags); void char_finish_utf8 (struct encoding_stream *str, @@ -231,28 +222,22 @@ static int postprocess_iso2022_mask (int mask); static void reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso); static int detect_coding_iso2022 (struct detection_state *st, - const unsigned char *src, - unsigned int n); -static void decode_coding_iso2022 (Lstream *decoding, - const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); + const Extbyte *src, size_t n); +static void decode_coding_iso2022 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); void char_encode_iso2022 (struct encoding_stream *str, Emchar c, unsigned_char_dynarr *dst, unsigned int *flags); void char_finish_iso2022 (struct encoding_stream *str, unsigned_char_dynarr *dst, unsigned int *flags); #endif /* MULE */ -static void decode_coding_no_conversion (Lstream *decoding, - const unsigned char *src, - unsigned_char_dynarr *dst, - unsigned int n); -static void encode_coding_no_conversion (Lstream *encoding, - const unsigned char *src, - unsigned_char_dynarr *dst, - unsigned int n); -static void mule_decode (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); -static void mule_encode (Lstream *encoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n); +static void decode_coding_no_conversion (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); +static void encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n); +static void mule_decode (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n); +static void mule_encode (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n); typedef struct codesys_prop codesys_prop; struct codesys_prop @@ -748,7 +733,7 @@ nil or 'undecided JIS (the Japanese encoding commonly used for e-mail), EUC (the standard Unix encoding for Japanese and other languages), and Compound Text (the encoding used in X11). You can specify more - specific information about the conversion with the FLAGS argument. + specific information about the conversion with the PROPS argument. 'big5 Big5 (the encoding commonly used for Taiwanese). 'ccl @@ -809,12 +794,12 @@ character set. Recognized properties are: 'post-read-conversion Function called after a file has been read in, to perform the - decoding. Called with two arguments, BEG and END, denoting + decoding. Called with two arguments, START and END, denoting a region of the current buffer to be decoded. 'pre-write-conversion Function called before a file is written out, to perform the - encoding. Called with two arguments, BEG and END, denoting + encoding. Called with two arguments, START and END, denoting a region of the current buffer to be encoded. @@ -902,7 +887,6 @@ if TYPE is 'ccl: (name, type, doc_string, props)) { Lisp_Coding_System *codesys; - Lisp_Object rest, key, value; enum coding_system_type ty; int need_to_setup_eol_systems = 1; @@ -934,98 +918,124 @@ if TYPE is 'ccl: CHECK_STRING (doc_string); CODING_SYSTEM_DOC_STRING (codesys) = doc_string; - EXTERNAL_PROPERTY_LIST_LOOP (rest, key, value, props) - { - if (EQ (key, Qmnemonic)) - { - if (!NILP (value)) - CHECK_STRING (value); - CODING_SYSTEM_MNEMONIC (codesys) = value; - } + { + EXTERNAL_PROPERTY_LIST_LOOP_3 (key, value, props) + { + if (EQ (key, Qmnemonic)) + { + if (!NILP (value)) + CHECK_STRING (value); + CODING_SYSTEM_MNEMONIC (codesys) = value; + } - else if (EQ (key, Qeol_type)) - { - need_to_setup_eol_systems = NILP (value); - if (EQ (value, Qt)) - value = Qnil; - CODING_SYSTEM_EOL_TYPE (codesys) = symbol_to_eol_type (value); - } + else if (EQ (key, Qeol_type)) + { + need_to_setup_eol_systems = NILP (value); + if (EQ (value, Qt)) + value = Qnil; + CODING_SYSTEM_EOL_TYPE (codesys) = symbol_to_eol_type (value); + } - else if (EQ (key, Qpost_read_conversion)) - CODING_SYSTEM_POST_READ_CONVERSION (codesys) = value; - else if (EQ (key, Qpre_write_conversion)) - CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = value; + else if (EQ (key, Qpost_read_conversion)) + CODING_SYSTEM_POST_READ_CONVERSION (codesys) = value; + else if (EQ (key, Qpre_write_conversion)) + CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = value; #ifdef UTF2000 - else if (EQ (key, Qdisable_composition)) - CODING_SYSTEM_DISABLE_COMPOSITION (codesys) = !NILP (value); + else if (EQ (key, Qdisable_composition)) + CODING_SYSTEM_DISABLE_COMPOSITION (codesys) = !NILP (value); #endif #ifdef MULE - else if (ty == CODESYS_ISO2022) - { + else if (ty == CODESYS_ISO2022) + { #define FROB_INITIAL_CHARSET(charset_num) \ CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, charset_num) = \ ((EQ (value, Qt) || EQ (value, Qnil)) ? value : Fget_charset (value)) - if (EQ (key, Qcharset_g0)) FROB_INITIAL_CHARSET (0); - else if (EQ (key, Qcharset_g1)) FROB_INITIAL_CHARSET (1); - else if (EQ (key, Qcharset_g2)) FROB_INITIAL_CHARSET (2); - else if (EQ (key, Qcharset_g3)) FROB_INITIAL_CHARSET (3); + if (EQ (key, Qcharset_g0)) FROB_INITIAL_CHARSET (0); + else if (EQ (key, Qcharset_g1)) FROB_INITIAL_CHARSET (1); + else if (EQ (key, Qcharset_g2)) FROB_INITIAL_CHARSET (2); + else if (EQ (key, Qcharset_g3)) FROB_INITIAL_CHARSET (3); #define FROB_FORCE_CHARSET(charset_num) \ CODING_SYSTEM_ISO2022_FORCE_CHARSET_ON_OUTPUT (codesys, charset_num) = !NILP (value) - else if (EQ (key, Qforce_g0_on_output)) FROB_FORCE_CHARSET (0); - else if (EQ (key, Qforce_g1_on_output)) FROB_FORCE_CHARSET (1); - else if (EQ (key, Qforce_g2_on_output)) FROB_FORCE_CHARSET (2); - else if (EQ (key, Qforce_g3_on_output)) FROB_FORCE_CHARSET (3); + else if (EQ (key, Qforce_g0_on_output)) FROB_FORCE_CHARSET (0); + else if (EQ (key, Qforce_g1_on_output)) FROB_FORCE_CHARSET (1); + else if (EQ (key, Qforce_g2_on_output)) FROB_FORCE_CHARSET (2); + else if (EQ (key, Qforce_g3_on_output)) FROB_FORCE_CHARSET (3); #define FROB_BOOLEAN_PROPERTY(prop) \ CODING_SYSTEM_ISO2022_##prop (codesys) = !NILP (value) - else if (EQ (key, Qshort)) FROB_BOOLEAN_PROPERTY (SHORT); - else if (EQ (key, Qno_ascii_eol)) FROB_BOOLEAN_PROPERTY (NO_ASCII_EOL); - else if (EQ (key, Qno_ascii_cntl)) FROB_BOOLEAN_PROPERTY (NO_ASCII_CNTL); - else if (EQ (key, Qseven)) FROB_BOOLEAN_PROPERTY (SEVEN); - else if (EQ (key, Qlock_shift)) FROB_BOOLEAN_PROPERTY (LOCK_SHIFT); - else if (EQ (key, Qno_iso6429)) FROB_BOOLEAN_PROPERTY (NO_ISO6429); - else if (EQ (key, Qescape_quoted)) FROB_BOOLEAN_PROPERTY (ESCAPE_QUOTED); + else if (EQ (key, Qshort)) FROB_BOOLEAN_PROPERTY (SHORT); + else if (EQ (key, Qno_ascii_eol)) FROB_BOOLEAN_PROPERTY (NO_ASCII_EOL); + else if (EQ (key, Qno_ascii_cntl)) FROB_BOOLEAN_PROPERTY (NO_ASCII_CNTL); + else if (EQ (key, Qseven)) FROB_BOOLEAN_PROPERTY (SEVEN); + else if (EQ (key, Qlock_shift)) FROB_BOOLEAN_PROPERTY (LOCK_SHIFT); + else if (EQ (key, Qno_iso6429)) FROB_BOOLEAN_PROPERTY (NO_ISO6429); + else if (EQ (key, Qescape_quoted)) FROB_BOOLEAN_PROPERTY (ESCAPE_QUOTED); - else if (EQ (key, Qinput_charset_conversion)) - { - codesys->iso2022.input_conv = - Dynarr_new (charset_conversion_spec); - parse_charset_conversion_specs (codesys->iso2022.input_conv, - value); - } - else if (EQ (key, Qoutput_charset_conversion)) - { - codesys->iso2022.output_conv = - Dynarr_new (charset_conversion_spec); - parse_charset_conversion_specs (codesys->iso2022.output_conv, - value); - } - else - signal_simple_error ("Unrecognized property", key); - } - else if (EQ (type, Qccl)) - { - if (EQ (key, Qdecode)) - { - CHECK_VECTOR (value); - CODING_SYSTEM_CCL_DECODE (codesys) = value; - } - else if (EQ (key, Qencode)) - { - CHECK_VECTOR (value); - CODING_SYSTEM_CCL_ENCODE (codesys) = value; - } - else - signal_simple_error ("Unrecognized property", key); - } + else if (EQ (key, Qinput_charset_conversion)) + { + codesys->iso2022.input_conv = + Dynarr_new (charset_conversion_spec); + parse_charset_conversion_specs (codesys->iso2022.input_conv, + value); + } + else if (EQ (key, Qoutput_charset_conversion)) + { + codesys->iso2022.output_conv = + Dynarr_new (charset_conversion_spec); + parse_charset_conversion_specs (codesys->iso2022.output_conv, + value); + } + else + signal_simple_error ("Unrecognized property", key); + } + else if (EQ (type, Qccl)) + { + Lisp_Object sym; + struct ccl_program test_ccl; + Extbyte *suffix; + + /* Check key first. */ + if (EQ (key, Qdecode)) + suffix = "-ccl-decode"; + else if (EQ (key, Qencode)) + suffix = "-ccl-encode"; + else + signal_simple_error ("Unrecognized property", key); + + /* If value is vector, register it as a ccl program + associated with an newly created symbol for + backward compatibility. */ + if (VECTORP (value)) + { + sym = Fintern (concat2 (Fsymbol_name (name), + build_string (suffix)), + Qnil); + Fregister_ccl_program (sym, value); + } + else + { + CHECK_SYMBOL (value); + sym = value; + } + /* check if the given ccl programs are valid. */ + if (setup_ccl_program (&test_ccl, sym) < 0) + signal_simple_error ("Invalid CCL program", value); + + if (EQ (key, Qdecode)) + CODING_SYSTEM_CCL_DECODE (codesys) = sym; + else if (EQ (key, Qencode)) + CODING_SYSTEM_CCL_ENCODE (codesys) = sym; + + } #endif /* MULE */ - else - signal_simple_error ("Unrecognized property", key); - } + else + signal_simple_error ("Unrecognized property", key); + } + } if (need_to_setup_eol_systems) setup_eol_coding_systems (codesys); @@ -1097,6 +1107,7 @@ Return the coding-system symbol for which symbol ALIAS is an alias. return aliasee; else signal_simple_error ("Symbol is not a coding system alias", alias); + return Qnil; /* To keep the compiler happy */ } static Lisp_Object @@ -1243,7 +1254,7 @@ subsidiary_coding_system (Lisp_Object coding_system, eol_type_t type) case EOL_LF: new_coding_system = CODING_SYSTEM_EOL_LF (cs); break; case EOL_CR: new_coding_system = CODING_SYSTEM_EOL_CR (cs); break; case EOL_CRLF: new_coding_system = CODING_SYSTEM_EOL_CRLF (cs); break; - default: abort (); + default: abort (); return Qnil; } return NILP (new_coding_system) ? coding_system : new_coding_system; @@ -1652,14 +1663,12 @@ mask_has_at_most_one_bit_p (int mask) } static eol_type_t -detect_eol_type (struct detection_state *st, const unsigned char *src, - unsigned int n) +detect_eol_type (struct detection_state *st, const Extbyte *src, + size_t n) { - int c; - while (n--) { - c = *src++; + unsigned char c = *(unsigned char *)src++; if (c == '\n') { if (st->eol.just_saw_cr) @@ -1698,10 +1707,8 @@ detect_eol_type (struct detection_state *st, const unsigned char *src, static int detect_coding_type (struct detection_state *st, const Extbyte *src, - unsigned int n, int just_do_eol) + size_t n, int just_do_eol) { - int c; - if (st->eol_type == EOL_AUTODETECT) st->eol_type = detect_eol_type (st, src, n); @@ -1712,7 +1719,7 @@ detect_coding_type (struct detection_state *st, const Extbyte *src, { for (; n; n--, src++) { - c = *src; + unsigned char c = *(unsigned char *) src; if ((c < 0x20 && !acceptable_control_char_p (c)) || c >= 0x80) { st->seen_non_ascii = 1; @@ -1938,8 +1945,8 @@ determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out, DEFUN ("detect-coding-region", Fdetect_coding_region, 2, 3, 0, /* Detect coding system of the text in the region between START and END. -Returned a list of possible coding systems ordered by priority. -If only ASCII characters are found, it returns 'undecided or one of +Return a list of possible coding systems ordered by priority. +If only ASCII characters are found, return 'undecided or one of its subsidiary coding systems according to a detected end-of-line type. Optional arg BUFFER defaults to the current buffer. */ @@ -1964,7 +1971,7 @@ type. Optional arg BUFFER defaults to the current buffer. decst.mask = ~0; while (1) { - unsigned char random_buffer[4096]; + Extbyte random_buffer[4096]; ssize_t nread = Lstream_read (istr, random_buffer, sizeof (random_buffer)); if (!nread) @@ -2164,10 +2171,8 @@ struct decoding_stream Some of these flags are dependent on the coding system. */ unsigned int flags; - /* CH holds a partially built-up character. Since we only deal - with one- and two-byte characters at the moment, we only use - this to store the first byte of a two-byte character. */ - unsigned int ch; + /* CPOS holds a partially built-up code-point of character. */ + unsigned int cpos; /* EOL_TYPE specifies the type of end-of-line conversion that currently applies. We need to keep this separate from the @@ -2219,10 +2224,10 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str, { if (CODING_SYSTEM_DISABLE_COMPOSITION (str->codesys)) DECODE_ADD_UCS_CHAR (character, dst); - else if (!CHAR_CODE_TABLE_P (str->combining_table)) + else if (!CHAR_ID_TABLE_P (str->combining_table)) { Lisp_Object ret - = get_char_code_table (character, Vcharacter_composition_table); + = get_char_id_table (character, Vcharacter_composition_table); if (NILP (ret)) DECODE_ADD_UCS_CHAR (character, dst); @@ -2236,12 +2241,12 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str, else { Lisp_Object ret - = get_char_code_table (character, str->combining_table); + = get_char_id_table (character, str->combining_table); if (CHARP (ret)) { Emchar char2 = XCHARVAL (ret); - ret = get_char_code_table (char2, Vcharacter_composition_table); + ret = get_char_id_table (char2, Vcharacter_composition_table); if (NILP (ret)) { DECODE_ADD_UCS_CHAR (char2, dst); @@ -2255,7 +2260,7 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str, str->combining_table = ret; } } - else if (CHAR_CODE_TABLE_P (ret)) + else if (CHAR_ID_TABLE_P (ret)) { str->combined_chars[str->combined_char_count++] = character; str->combining_table = ret; @@ -2360,7 +2365,7 @@ decoding_reader (Lstream *stream, unsigned char *data, size_t size) /* There might be some more end data produced in the translation. See the comment above. */ str->flags |= CODING_STATE_END; - mule_decode (stream, data, str->runoff, read_size); + mule_decode (stream, (Extbyte *) data, str->runoff, read_size); } if (data - orig_data == 0) @@ -2378,7 +2383,7 @@ decoding_writer (Lstream *stream, const unsigned char *data, size_t size) /* Decode all our data into the runoff, and then attempt to write it all out to the other end. Remove whatever chunk we succeeded in writing. */ - mule_decode (stream, data, str->runoff, size); + mule_decode (stream, (Extbyte *) data, str->runoff, size); retval = Lstream_write (str->other_end, Dynarr_atp (str->runoff, 0), Dynarr_length (str->runoff)); if (retval > 0) @@ -2409,7 +2414,7 @@ reset_decoding_stream (struct decoding_stream *str) str->combined_char_count = 0; str->combining_table = Qnil; #endif - str->flags = str->ch = 0; + str->flags = str->cpos = 0; } static int @@ -2527,8 +2532,8 @@ make_decoding_output_stream (Lstream *stream, Lisp_Object codesys) be used for both reading and writing. */ static void -mule_decode (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +mule_decode (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -2592,7 +2597,10 @@ mule_decode (Lstream *decoding, const unsigned char *src, break; case CODESYS_CCL: str->ccl.last_block = str->flags & CODING_STATE_END; - ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_DECODING); + /* When applying ccl program to stream, MUST NOT set NULL + pointer to src. */ + ccl_driver (&str->ccl, (src ? (unsigned char *)src : (unsigned char*)""), + dst, n, 0, CCL_MODE_DECODING); break; case CODESYS_ISO2022: decode_coding_iso2022 (decoding, src, dst, n); @@ -2989,8 +2997,8 @@ make_encoding_output_stream (Lstream *stream, Lisp_Object codesys) Store the encoded data into DST. */ static void -mule_encode (Lstream *encoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +mule_encode (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -3013,7 +3021,10 @@ mule_encode (Lstream *encoding, const unsigned char *src, break; case CODESYS_CCL: str->ccl.last_block = str->flags & CODING_STATE_END; - ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_ENCODING); + /* When applying ccl program to stream, MUST NOT set NULL + pointer to src. */ + ccl_driver (&str->ccl, ((src) ? src : (unsigned char*)""), + dst, n, 0, CCL_MODE_ENCODING); break; #endif /* MULE */ default: @@ -3089,8 +3100,8 @@ text. BUFFER defaults to the current buffer if unspecified. #ifdef MULE static void -text_encode_generic (Lstream *encoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +text_encode_generic (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n) { unsigned char c; unsigned char char_boundary; @@ -3194,14 +3205,11 @@ text_encode_generic (Lstream *encoding, const unsigned char *src, ((c) >= 0xA1 && (c) <= 0xDF) static int -detect_coding_sjis (struct detection_state *st, const unsigned char *src, - unsigned int n) +detect_coding_sjis (struct detection_state *st, const Extbyte *src, size_t n) { - int c; - while (n--) { - c = *src++; + unsigned char c = *(unsigned char *)src++; if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO) return 0; if (st->shift_jis.in_second_byte) @@ -3219,27 +3227,26 @@ detect_coding_sjis (struct detection_state *st, const unsigned char *src, /* Convert Shift-JIS data to internal format. */ static void -decode_coding_sjis (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +decode_coding_sjis (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { - unsigned char c; struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; - unsigned int ch = str->ch; + unsigned int cpos = str->cpos; eol_type_t eol_type = str->eol_type; while (n--) { - c = *src++; + unsigned char c = *(unsigned char *)src++; - if (ch) + if (cpos) { /* Previous character was first byte of Shift-JIS Kanji char. */ if (BYTE_SJIS_TWO_BYTE_2_P (c)) { unsigned char e1, e2; - DECODE_SJIS (ch, c, e1, e2); + DECODE_SJIS (cpos, c, e1, e2); #ifdef UTF2000 DECODE_ADD_UCS_CHAR(MAKE_CHAR(Vcharset_japanese_jisx0208, e1 & 0x7F, @@ -3252,16 +3259,16 @@ decode_coding_sjis (Lstream *decoding, const unsigned char *src, } else { - DECODE_ADD_BINARY_CHAR (ch, dst); + DECODE_ADD_BINARY_CHAR (cpos, dst); DECODE_ADD_BINARY_CHAR (c, dst); } - ch = 0; + cpos = 0; } else { DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst); if (BYTE_SJIS_TWO_BYTE_1_P (c)) - ch = c; + cpos = c; else if (BYTE_SJIS_KATAKANA_P (c)) { #ifdef UTF2000 @@ -3283,10 +3290,10 @@ decode_coding_sjis (Lstream *decoding, const unsigned char *src, label_continue_loop:; } - DECODE_HANDLE_END_OF_CONVERSION (flags, ch, dst); + DECODE_HANDLE_END_OF_CONVERSION (flags, cpos, dst); str->flags = flags; - str->ch = ch; + str->cpos = cpos; } /* Convert internal character representation to Shift_JIS. */ @@ -3306,20 +3313,44 @@ char_encode_shift_jis (struct encoding_stream *str, Emchar ch, } else { - Lisp_Object charset; - unsigned int c1, c2, s1, s2; + unsigned int s1, s2; #ifdef UTF2000 int code_point = charset_code_point (Vcharset_latin_jisx0201, ch); if (code_point >= 0) + Dynarr_add (dst, code_point); + else if ((code_point + = charset_code_point (Vcharset_japanese_jisx0208_1990, ch)) + >= 0) { - charset = Vcharset_latin_jisx0201; - c1 = code_point; - c2 = 0; + ENCODE_SJIS ((code_point >> 8) | 0x80, + (code_point & 0xFF) | 0x80, s1, s2); + Dynarr_add (dst, s1); + Dynarr_add (dst, s2); } + else if ((code_point + = charset_code_point (Vcharset_katakana_jisx0201, ch)) + >= 0) + Dynarr_add (dst, code_point | 0x80); + else if ((code_point + = charset_code_point (Vcharset_japanese_jisx0208, ch)) + >= 0) + { + ENCODE_SJIS ((code_point >> 8) | 0x80, + (code_point & 0xFF) | 0x80, s1, s2); + Dynarr_add (dst, s1); + Dynarr_add (dst, s2); + } + else if ((code_point = charset_code_point (Vcharset_ascii, ch)) + >= 0) + Dynarr_add (dst, code_point); else -#endif - BREAKUP_CHAR (ch, charset, c1, c2); + Dynarr_add (dst, '?'); +#else + Lisp_Object charset; + unsigned int c1, c2; + + BREAKUP_CHAR (ch, charset, c1, c2); if (EQ(charset, Vcharset_katakana_jisx0201)) { @@ -3337,6 +3368,7 @@ char_encode_shift_jis (struct encoding_stream *str, Emchar ch, } else Dynarr_add (dst, '?'); +#endif } } @@ -3372,16 +3404,16 @@ Return the corresponding character. } DEFUN ("encode-shift-jis-char", Fencode_shift_jis_char, 1, 1, 0, /* -Encode a JISX0208 character CHAR to SHIFT-JIS coding-system. +Encode a JISX0208 character CHARACTER to SHIFT-JIS coding-system. Return the corresponding character code in SHIFT-JIS as a cons of two bytes. */ - (ch)) + (character)) { Lisp_Object charset; int c1, c2, s1, s2; - CHECK_CHAR_COERCE_INT (ch); - BREAKUP_CHAR (XCHAR (ch), charset, c1, c2); + CHECK_CHAR_COERCE_INT (character); + BREAKUP_CHAR (XCHAR (character), charset, c1, c2); if (EQ (charset, Vcharset_japanese_jisx0208)) { ENCODE_SJIS (c1 | 0x80, c2 | 0x80, s1, s2); @@ -3496,14 +3528,11 @@ Return the corresponding character code in SHIFT-JIS as a cons of two bytes. } while (0) static int -detect_coding_big5 (struct detection_state *st, const unsigned char *src, - unsigned int n) +detect_coding_big5 (struct detection_state *st, const Extbyte *src, size_t n) { - int c; - while (n--) { - c = *src++; + unsigned char c = *(unsigned char *)src++; if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO || (c >= 0x80 && c <= 0xA0)) return 0; @@ -3522,58 +3551,63 @@ detect_coding_big5 (struct detection_state *st, const unsigned char *src, /* Convert Big5 data to internal format. */ static void -decode_coding_big5 (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +decode_coding_big5 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { - unsigned char c; struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; - unsigned int ch = str->ch; + unsigned int cpos = str->cpos; eol_type_t eol_type = str->eol_type; while (n--) { - c = *src++; - if (ch) + unsigned char c = *(unsigned char *)src++; + if (cpos) { /* Previous character was first byte of Big5 char. */ if (BYTE_BIG5_TWO_BYTE_2_P (c)) { +#ifdef UTF2000 + DECODE_ADD_UCS_CHAR + (DECODE_CHAR (Vcharset_chinese_big5, (cpos << 8) | c), + dst); +#else unsigned char b1, b2, b3; - DECODE_BIG5 (ch, c, b1, b2, b3); + DECODE_BIG5 (cpos, c, b1, b2, b3); Dynarr_add (dst, b1); Dynarr_add (dst, b2); Dynarr_add (dst, b3); +#endif } else { - DECODE_ADD_BINARY_CHAR (ch, dst); + DECODE_ADD_BINARY_CHAR (cpos, dst); DECODE_ADD_BINARY_CHAR (c, dst); } - ch = 0; + cpos = 0; } else { DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst); if (BYTE_BIG5_TWO_BYTE_1_P (c)) - ch = c; + cpos = c; else DECODE_ADD_BINARY_CHAR (c, dst); } label_continue_loop:; } - DECODE_HANDLE_END_OF_CONVERSION (flags, ch, dst); + DECODE_HANDLE_END_OF_CONVERSION (flags, cpos, dst); str->flags = flags; - str->ch = ch; + str->cpos = cpos; } /* Convert internally-formatted data to Big5. */ static void -encode_coding_big5 (Lstream *encoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +encode_coding_big5 (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n) { #ifndef UTF2000 unsigned char c; @@ -3662,16 +3696,16 @@ Return the corresponding character. } DEFUN ("encode-big5-char", Fencode_big5_char, 1, 1, 0, /* -Encode the Big5 character CH to BIG5 coding-system. +Encode the Big5 character CHARACTER in the BIG5 coding-system. Return the corresponding character code in Big5. */ - (ch)) + (character)) { Lisp_Object charset; int c1, c2, b1, b2; - CHECK_CHAR_COERCE_INT (ch); - BREAKUP_CHAR (XCHAR (ch), charset, c1, c2); + CHECK_CHAR_COERCE_INT (character); + BREAKUP_CHAR (XCHAR (character), charset, c1, c2); if (EQ (charset, Vcharset_chinese_big5_1) || EQ (charset, Vcharset_chinese_big5_2)) { @@ -3689,12 +3723,11 @@ Return the corresponding character code in Big5. /************************************************************************/ static int -detect_coding_ucs4 (struct detection_state *st, const unsigned char *src, - unsigned int n) +detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, size_t n) { while (n--) { - int c = *src++; + unsigned char c = *(unsigned char *)src++; switch (st->ucs4.in_byte) { case 0: @@ -3714,39 +3747,39 @@ detect_coding_ucs4 (struct detection_state *st, const unsigned char *src, } static void -decode_coding_ucs4 (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +decode_coding_ucs4 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; - unsigned int ch = str->ch; + unsigned int cpos = str->cpos; unsigned char counter = str->counter; while (n--) { - unsigned char c = *src++; + unsigned char c = *(unsigned char *)src++; switch (counter) { case 0: - ch = c; + cpos = c; counter = 3; break; case 1: - DECODE_ADD_UCS_CHAR ((ch << 8) | c, dst); - ch = 0; + DECODE_ADD_UCS_CHAR ((cpos << 8) | c, dst); + cpos = 0; counter = 0; break; default: - ch = ( ch << 8 ) | c; + cpos = ( cpos << 8 ) | c; counter--; } } if (counter & CODING_STATE_END) - DECODE_OUTPUT_PARTIAL_CHAR (ch); + DECODE_OUTPUT_PARTIAL_CHAR (cpos); - str->flags = flags; - str->ch = ch; - str->counter = counter; + str->flags = flags; + str->cpos = cpos; + str->counter = counter; } void @@ -3771,12 +3804,11 @@ char_finish_ucs4 (struct encoding_stream *str, unsigned_char_dynarr *dst, /************************************************************************/ static int -detect_coding_utf8 (struct detection_state *st, const unsigned char *src, - unsigned int n) +detect_coding_utf8 (struct detection_state *st, const Extbyte *src, size_t n) { while (n--) { - unsigned char c = *src++; + unsigned char c = *(unsigned char *)src++; switch (st->utf8.in_byte) { case 0: @@ -3806,71 +3838,172 @@ detect_coding_utf8 (struct detection_state *st, const unsigned char *src, } static void -decode_coding_utf8 (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +decode_output_utf8_partial_char (unsigned char counter, + unsigned int cpos, + unsigned_char_dynarr *dst) +{ + if (counter == 5) + DECODE_ADD_BINARY_CHAR ( (cpos|0xFC), dst); + else if (counter == 4) + { + if (cpos < (1 << 6)) + DECODE_ADD_BINARY_CHAR ( (cpos|0xF8), dst); + else + { + DECODE_ADD_BINARY_CHAR ( ((cpos >> 6)|0xFC), dst); + DECODE_ADD_BINARY_CHAR ( ((cpos&0x3F)|0x80), dst); + } + } + else if (counter == 3) + { + if (cpos < (1 << 6)) + DECODE_ADD_BINARY_CHAR ( (cpos|0xF0), dst); + else if (cpos < (1 << 12)) + { + DECODE_ADD_BINARY_CHAR ( ((cpos >> 6)|0xF8), dst); + DECODE_ADD_BINARY_CHAR ( ((cpos&0x3F)|0x80), dst); + } + else + { + DECODE_ADD_BINARY_CHAR ( ( (cpos >> 12)|0xFC), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 6)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( ( (cpos &0x3F)|0x80), dst); + } + } + else if (counter == 2) + { + if (cpos < (1 << 6)) + DECODE_ADD_BINARY_CHAR ( (cpos|0xE0), dst); + else if (cpos < (1 << 12)) + { + DECODE_ADD_BINARY_CHAR ( ((cpos >> 6)|0xF0), dst); + DECODE_ADD_BINARY_CHAR ( ((cpos&0x3F)|0x80), dst); + } + else if (cpos < (1 << 18)) + { + DECODE_ADD_BINARY_CHAR ( ( (cpos >> 12)|0xF8), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 6)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( ( (cpos &0x3F)|0x80), dst); + } + else + { + DECODE_ADD_BINARY_CHAR ( ( (cpos >> 18)|0xFC), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 12)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 6)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( ( (cpos &0x3F)|0x80), dst); + } + } + else + { + if (cpos < (1 << 6)) + DECODE_ADD_BINARY_CHAR ( (cpos|0xC0), dst); + else if (cpos < (1 << 12)) + { + DECODE_ADD_BINARY_CHAR ( ((cpos >> 6)|0xE0), dst); + DECODE_ADD_BINARY_CHAR ( ((cpos&0x3F)|0x80), dst); + } + else if (cpos < (1 << 18)) + { + DECODE_ADD_BINARY_CHAR ( ( (cpos >> 12)|0xF0), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 6)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( ( (cpos &0x3F)|0x80), dst); + } + else if (cpos < (1 << 24)) + { + DECODE_ADD_BINARY_CHAR ( ( (cpos >> 18)|0xF8), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 12)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 6)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( ( (cpos &0x3F)|0x80), dst); + } + else + { + DECODE_ADD_BINARY_CHAR ( ( (cpos >> 24)|0xFC), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 18)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 12)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( (((cpos >> 6)&0x3F)|0x80), dst); + DECODE_ADD_BINARY_CHAR ( ( (cpos &0x3F)|0x80), dst); + } + } +} + +static void +decode_coding_utf8 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); - unsigned int flags = str->flags; - unsigned int ch = str->ch; - eol_type_t eol_type = str->eol_type; - unsigned char counter = str->counter; + unsigned int flags = str->flags; + unsigned int cpos = str->cpos; + eol_type_t eol_type = str->eol_type; + unsigned char counter = str->counter; while (n--) { - unsigned char c = *src++; - switch (counter) + unsigned char c = *(unsigned char *)src++; + if (counter == 0) { - case 0: - if ( c >= 0xfc ) + if ( c < 0xC0 ) { - ch = c & 0x01; - counter = 5; + DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst); + DECODE_ADD_UCS_CHAR (c, dst); } - else if ( c >= 0xf8 ) + else if ( c < 0xE0 ) { - ch = c & 0x03; - counter = 4; + cpos = c & 0x1f; + counter = 1; } - else if ( c >= 0xf0 ) + else if ( c < 0xF0 ) { - ch = c & 0x07; - counter = 3; + cpos = c & 0x0f; + counter = 2; } - else if ( c >= 0xe0 ) + else if ( c < 0xF8 ) { - ch = c & 0x0f; - counter = 2; + cpos = c & 0x07; + counter = 3; } - else if ( c >= 0xc0 ) + else if ( c < 0xFC ) { - ch = c & 0x1f; - counter = 1; + cpos = c & 0x03; + counter = 4; } else { - DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst); - DECODE_ADD_UCS_CHAR (c, dst); + cpos = c & 0x01; + counter = 5; } - break; - case 1: - ch = ( ch << 6 ) | ( c & 0x3f ); - DECODE_ADD_UCS_CHAR (ch, dst); - ch = 0; + } + else if ( (c & 0xC0) == 0x80 ) + { + cpos = ( cpos << 6 ) | ( c & 0x3f ); + if (counter == 1) + { + DECODE_ADD_UCS_CHAR (cpos, dst); + cpos = 0; + counter = 0; + } + else + counter--; + } + else + { + decode_output_utf8_partial_char (counter, cpos, dst); + DECODE_ADD_BINARY_CHAR (c, dst); + cpos = 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; + if (counter > 0) + { + decode_output_utf8_partial_char (counter, cpos, dst); + cpos = 0; + counter = 0; + } + str->flags = flags; + str->cpos = cpos; + str->counter = counter; } void @@ -4383,7 +4516,8 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, } if (0x40 <= c && c <= 0x42) { - cs = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94, c, + /* 94^n-set */ + cs = CHARSET_BY_ATTRIBUTES (94, -1, c, *flags & CODING_STATE_R2L ? CHARSET_RIGHT_TO_LEFT : CHARSET_LEFT_TO_RIGHT); @@ -4394,7 +4528,8 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, default: { - int type =-1; + int chars = 0; + int single = 0; if (c < '0' || c > '~') return 0; /* bad final byte */ @@ -4402,15 +4537,15 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, if (iso->esc >= ISO_ESC_2_8 && iso->esc <= ISO_ESC_2_15) { - type = ((iso->esc >= ISO_ESC_2_12) ? - CHARSET_TYPE_96 : CHARSET_TYPE_94); + chars = (iso->esc >= ISO_ESC_2_12) ? 96 : 94; + single = 1; /* single-byte */ reg = (iso->esc - ISO_ESC_2_8) & 3; } else if (iso->esc >= ISO_ESC_2_4_8 && iso->esc <= ISO_ESC_2_4_15) { - type = ((iso->esc >= ISO_ESC_2_4_12) ? - CHARSET_TYPE_96X96 : CHARSET_TYPE_94X94); + chars = (iso->esc >= ISO_ESC_2_4_12) ? 96 : 94; + single = -1; /* multi-byte */ reg = (iso->esc - ISO_ESC_2_4_8) & 3; } else @@ -4419,7 +4554,7 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, abort(); } - cs = CHARSET_BY_ATTRIBUTES (type, c, + cs = CHARSET_BY_ATTRIBUTES (chars, single, c, *flags & CODING_STATE_R2L ? CHARSET_RIGHT_TO_LEFT : CHARSET_LEFT_TO_RIGHT); @@ -4512,8 +4647,7 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, } static int -detect_coding_iso2022 (struct detection_state *st, const unsigned char *src, - unsigned int n) +detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, size_t n) { int mask; @@ -4543,7 +4677,7 @@ detect_coding_iso2022 (struct detection_state *st, const unsigned char *src, while (n--) { - int c = *src++; + unsigned char c = *(unsigned char *)src++; if (c >= 0xA0) { mask &= ~CODING_CATEGORY_ISO_7_MASK; @@ -4703,13 +4837,14 @@ ensure_correct_direction (int direction, Lisp_Coding_System *codesys, /* Convert ISO2022-format data to internal format. */ static void -decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +decode_coding_iso2022 (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); - unsigned int flags = str->flags; - unsigned int ch = str->ch; - eol_type_t eol_type = str->eol_type; + unsigned int flags = str->flags; + unsigned int cpos = str->cpos; + unsigned char counter = str->counter; + eol_type_t eol_type = str->eol_type; #ifdef ENABLE_COMPOSITE_CHARS unsigned_char_dynarr *real_dst = dst; #endif @@ -4724,7 +4859,7 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, while (n--) { - unsigned char c = *src++; + unsigned char c = *(unsigned char *)src++; if (flags & CODING_STATE_ESCAPE) { /* Within ESC sequence */ int retval = parse_iso2022_esc (coding_system, &str->iso2022, @@ -4792,7 +4927,8 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, DECODE_ADD_BINARY_CHAR (c, dst); } } - ch = 0; + cpos = 0; + counter = 0; } else if (BYTE_C0_P (c) || BYTE_C1_P (c)) { /* Control characters */ @@ -4801,11 +4937,16 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, /* If we were in the middle of a character, dump out the partial character. */ - if (ch) + if (counter) { COMPOSE_FLUSH_CHARS (str, dst); - DECODE_ADD_BINARY_CHAR (ch, dst); - ch = 0; + while (counter > 0) + { + counter--; + DECODE_ADD_BINARY_CHAR + ((unsigned char)(cpos >> (counter * 8)), dst); + } + cpos = 0; } /* If we just saw a single-shift character, dump it out. @@ -4906,7 +5047,13 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, to preserve it for the output. */ { COMPOSE_FLUSH_CHARS (str, dst); - DECODE_OUTPUT_PARTIAL_CHAR (ch); + while (counter > 0) + { + counter--; + DECODE_ADD_BINARY_CHAR + ((unsigned char)(cpos >> (counter * 8)), dst); + } + cpos = 0; DECODE_ADD_BINARY_CHAR (c, dst); } @@ -4928,26 +5075,19 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, } #ifdef UTF2000 - if (XCHARSET_DIMENSION (charset) == 1) - { - if (ch) - { - COMPOSE_FLUSH_CHARS (str, dst); - DECODE_ADD_BINARY_CHAR (ch, dst); - ch = 0; - } - COMPOSE_ADD_CHAR (str, - MAKE_CHAR (charset, c & 0x7F, 0), dst); - } - else if (ch) + counter++; + if (XCHARSET_DIMENSION (charset) == counter) { COMPOSE_ADD_CHAR (str, - MAKE_CHAR (charset, ch & 0x7F, c & 0x7F), + DECODE_CHAR (charset, + ((cpos & 0x7F7F7F) << 8) + | (c & 0x7F)), dst); - ch = 0; + cpos = 0; + counter = 0; } else - ch = c; + cpos = (cpos << 8) | c; #else lb = XCHARSET_LEADING_BYTE (charset); switch (XCHARSET_REP_BYTES (charset)) @@ -5000,7 +5140,7 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, #endif } - if (!ch) + if (!cpos) flags &= CODING_STATE_ISO2022_LOCK; } @@ -5010,10 +5150,11 @@ decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, if (flags & CODING_STATE_END) { COMPOSE_FLUSH_CHARS (str, dst); - DECODE_OUTPUT_PARTIAL_CHAR (ch); + DECODE_OUTPUT_PARTIAL_CHAR (cpos); } - str->flags = flags; - str->ch = ch; + str->flags = flags; + str->cpos = cpos; + str->counter = counter; } @@ -5124,7 +5265,7 @@ char_encode_iso2022 (struct encoding_stream *str, Emchar ch, int i; Lisp_Object charset = str->iso2022.current_charset; int half = str->iso2022.current_half; - unsigned int byte1, byte2; + int code_point = -1; if (ch <= 0x7F) { @@ -5186,8 +5327,6 @@ char_encode_iso2022 (struct encoding_stream *str, Emchar ch, reg = -1; for (i = 0; i < 4; i++) { - int code_point; - if ((CHARSETP (charset = str->iso2022.charset[i]) && ((code_point = charset_code_point (charset, ch)) >= 0)) || @@ -5196,16 +5335,6 @@ char_encode_iso2022 (struct encoding_stream *str, Emchar ch, = CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i)) && ((code_point = charset_code_point (charset, ch)) >= 0))) { - if (XCHARSET_DIMENSION (charset) == 1) - { - byte1 = code_point; - byte2 = 0; - } - else /* if (XCHARSET_DIMENSION (charset) == 2) */ - { - byte1 = code_point >> 8; - byte2 = code_point & 255; - } reg = i; break; } @@ -5217,18 +5346,18 @@ char_encode_iso2022 (struct encoding_stream *str, Emchar ch, while (!EQ (Vdefault_coded_charset_priority_list, Qnil)) { - BREAKUP_CHAR (ch, charset, byte1, byte2); + code_point = ENCODE_CHAR (ch, charset); if (XCHARSET_FINAL (charset)) goto found; Vdefault_coded_charset_priority_list = Fcdr (Fmemq (XCHARSET_NAME (charset), Vdefault_coded_charset_priority_list)); } - BREAKUP_CHAR (ch, charset, byte1, byte2); + code_point = ENCODE_CHAR (ch, charset); if (!XCHARSET_FINAL (charset)) { charset = Vcharset_ascii; - byte1 = '~'; + code_point = '~'; } found: Vdefault_coded_charset_priority_list @@ -5309,11 +5438,22 @@ char_encode_iso2022 (struct encoding_stream *str, Emchar ch, switch (XCHARSET_DIMENSION (charset)) { case 1: - Dynarr_add (dst, byte1 | charmask); + Dynarr_add (dst, (code_point & 0xFF) | charmask); break; case 2: - Dynarr_add (dst, byte1 | charmask); - Dynarr_add (dst, byte2 | charmask); + Dynarr_add (dst, ((code_point >> 8) & 0xFF) | charmask); + Dynarr_add (dst, ( code_point & 0xFF) | charmask); + break; + case 3: + Dynarr_add (dst, ((code_point >> 16) & 0xFF) | charmask); + Dynarr_add (dst, ((code_point >> 8) & 0xFF) | charmask); + Dynarr_add (dst, ( code_point & 0xFF) | charmask); + break; + case 4: + Dynarr_add (dst, ((code_point >> 24) & 0xFF) | charmask); + Dynarr_add (dst, ((code_point >> 16) & 0xFF) | charmask); + Dynarr_add (dst, ((code_point >> 8) & 0xFF) | charmask); + Dynarr_add (dst, ( code_point & 0xFF) | charmask); break; default: abort (); @@ -5349,33 +5489,32 @@ char_finish_iso2022 (struct encoding_stream *str, unsigned_char_dynarr *dst, contain all 256 possible byte values and that are not to be interpreted as being in any particular decoding. */ static void -decode_coding_no_conversion (Lstream *decoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +decode_coding_no_conversion (Lstream *decoding, const Extbyte *src, + unsigned_char_dynarr *dst, size_t n) { - unsigned char c; struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; - unsigned int ch = str->ch; + unsigned int cpos = str->cpos; eol_type_t eol_type = str->eol_type; while (n--) { - c = *src++; + unsigned char c = *(unsigned char *)src++; DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst); DECODE_ADD_BINARY_CHAR (c, dst); label_continue_loop:; } - DECODE_HANDLE_END_OF_CONVERSION (flags, ch, dst); + DECODE_HANDLE_END_OF_CONVERSION (flags, cpos, dst); str->flags = flags; - str->ch = ch; + str->cpos = cpos; } static void -encode_coding_no_conversion (Lstream *encoding, const unsigned char *src, - unsigned_char_dynarr *dst, unsigned int n) +encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src, + unsigned_char_dynarr *dst, size_t n) { unsigned char c; struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -5779,7 +5918,7 @@ complex_vars_of_file_coding (void) { unsigned int i; - for (i = 0; i < 65536; i++) + for (i = 0; i < countof (fcd->ucs_to_mule_table); i++) fcd->ucs_to_mule_table[i] = Qnil; } staticpro (&mule_to_ucs_table);