X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Ffile-coding.c;h=59629d8cd54209b92c01109fc29b06bbcd9f1272;hb=2cbece6401b2279497293e6dc54cda607f49db2f;hp=78afa018737e736146de1c779bdd5d9236f99b85;hpb=716cfba952c1dc0d2cf5c968971f3780ba728a89;p=chise%2Fxemacs-chise.git- diff --git a/src/file-coding.c b/src/file-coding.c index 78afa01..59629d8 100644 --- a/src/file-coding.c +++ b/src/file-coding.c @@ -58,14 +58,14 @@ struct file_coding_dump { This describes a permutation of the possible coding categories. */ int coding_category_by_priority[CODING_CATEGORY_LAST + 1]; -#ifdef MULE +#if defined(MULE) && !defined(UTF2000) Lisp_Object ucs_to_mule_table[65536]; #endif } *fcd; static const struct lrecord_description fcd_description_1[] = { { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 }, -#ifdef MULE +#if defined(MULE) && !defined(UTF2000) { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), 65536 }, #endif { XD_END } @@ -176,67 +176,67 @@ EXFUN (Fcopy_coding_system, 2); #ifdef MULE struct detection_state; static int detect_coding_sjis (struct detection_state *st, - CONST unsigned char *src, + const unsigned char *src, unsigned int n); static void decode_coding_sjis (Lstream *decoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static void encode_coding_sjis (Lstream *encoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static int detect_coding_big5 (struct detection_state *st, - CONST unsigned char *src, + const unsigned char *src, unsigned int n); static void decode_coding_big5 (Lstream *decoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static void encode_coding_big5 (Lstream *encoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static int detect_coding_ucs4 (struct detection_state *st, - CONST unsigned char *src, + const unsigned char *src, unsigned int n); static void decode_coding_ucs4 (Lstream *decoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static void encode_coding_ucs4 (Lstream *encoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static int detect_coding_utf8 (struct detection_state *st, - CONST unsigned char *src, + const unsigned char *src, unsigned int n); static void decode_coding_utf8 (Lstream *decoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static void encode_coding_utf8 (Lstream *encoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static int postprocess_iso2022_mask (int mask); static void reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso); static int detect_coding_iso2022 (struct detection_state *st, - CONST unsigned char *src, + const unsigned char *src, unsigned int n); static void decode_coding_iso2022 (Lstream *decoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static void encode_coding_iso2022 (Lstream *encoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); #endif /* MULE */ static void decode_coding_no_conversion (Lstream *decoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); static void encode_coding_no_conversion (Lstream *encoding, - CONST unsigned char *src, + const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); -static void mule_decode (Lstream *decoding, CONST unsigned char *src, +static void mule_decode (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); -static void mule_encode (Lstream *encoding, CONST unsigned char *src, +static void mule_encode (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n); typedef struct codesys_prop codesys_prop; @@ -1071,6 +1071,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 @@ -1626,7 +1627,7 @@ mask_has_at_most_one_bit_p (int mask) } static eol_type_t -detect_eol_type (struct detection_state *st, CONST unsigned char *src, +detect_eol_type (struct detection_state *st, const unsigned char *src, unsigned int n) { int c; @@ -1671,7 +1672,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 Extbyte *src, unsigned int n, int just_do_eol) { int c; @@ -2025,6 +2026,62 @@ do { \ /* C should be a binary character in the range 0 - 255; convert to internal format and add to Dynarr DST. */ +#ifdef UTF2000 +#define DECODE_ADD_BINARY_CHAR(c, dst) \ +do { \ + if (BYTE_ASCII_P (c)) \ + Dynarr_add (dst, c); \ + else \ + { \ + Dynarr_add (dst, (c >> 6) | 0xc0); \ + Dynarr_add (dst, (c & 0x3f) | 0x80); \ + } \ +} while (0) + +INLINE void +DECODE_ADD_UCS_CHAR(Emchar c, unsigned_char_dynarr* dst) +{ + if ( c <= 0x7f ) + { + Dynarr_add (dst, c); + } + else if ( c <= 0x7ff ) + { + Dynarr_add (dst, (c >> 6) | 0xc0); + Dynarr_add (dst, (c & 0x3f) | 0x80); + } + else if ( c <= 0xffff ) + { + Dynarr_add (dst, (c >> 12) | 0xe0); + Dynarr_add (dst, ((c >> 6) & 0x3f) | 0x80); + Dynarr_add (dst, (c & 0x3f) | 0x80); + } + else if ( c <= 0x1fffff ) + { + Dynarr_add (dst, (c >> 18) | 0xf0); + Dynarr_add (dst, ((c >> 12) & 0x3f) | 0x80); + Dynarr_add (dst, ((c >> 6) & 0x3f) | 0x80); + Dynarr_add (dst, (c & 0x3f) | 0x80); + } + else if ( c <= 0x3ffffff ) + { + Dynarr_add (dst, (c >> 24) | 0xf8); + Dynarr_add (dst, ((c >> 18) & 0x3f) | 0x80); + Dynarr_add (dst, ((c >> 12) & 0x3f) | 0x80); + Dynarr_add (dst, ((c >> 6) & 0x3f) | 0x80); + Dynarr_add (dst, (c & 0x3f) | 0x80); + } + else + { + Dynarr_add (dst, (c >> 30) | 0xfc); + Dynarr_add (dst, ((c >> 24) & 0x3f) | 0x80); + Dynarr_add (dst, ((c >> 18) & 0x3f) | 0x80); + Dynarr_add (dst, ((c >> 12) & 0x3f) | 0x80); + Dynarr_add (dst, ((c >> 6) & 0x3f) | 0x80); + Dynarr_add (dst, (c & 0x3f) | 0x80); + } +} +#else #define DECODE_ADD_BINARY_CHAR(c, dst) \ do { \ if (BYTE_ASCII_P (c)) \ @@ -2040,6 +2097,7 @@ do { \ Dynarr_add (dst, c); \ } \ } while (0) +#endif #define DECODE_OUTPUT_PARTIAL_CHAR(ch) \ do { \ @@ -2109,7 +2167,7 @@ struct decoding_stream static ssize_t decoding_reader (Lstream *stream, unsigned char *data, size_t size); static ssize_t decoding_writer (Lstream *stream, - CONST unsigned char *data, size_t size); + const unsigned char *data, size_t size); static int decoding_rewinder (Lstream *stream); static int decoding_seekable_p (Lstream *stream); static int decoding_flusher (Lstream *stream); @@ -2204,7 +2262,7 @@ decoding_reader (Lstream *stream, unsigned char *data, size_t size) } static ssize_t -decoding_writer (Lstream *stream, CONST unsigned char *data, size_t size) +decoding_writer (Lstream *stream, const unsigned char *data, size_t size) { struct decoding_stream *str = DECODING_STREAM_DATA (stream); ssize_t retval; @@ -2239,6 +2297,13 @@ reset_decoding_stream (struct decoding_stream *str) } str->counter = 0; #endif /* MULE */ + if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_AUTODETECT + || CODING_SYSTEM_EOL_TYPE (str->codesys) == EOL_AUTODETECT) + { + xzero (str->decst); + str->decst.eol_type = EOL_AUTODETECT; + str->decst.mask = ~0; + } str->flags = str->ch = 0; } @@ -2314,7 +2379,7 @@ set_decoding_stream_coding_system (Lstream *lstr, Lisp_Object codesys) static Lisp_Object make_decoding_stream_1 (Lstream *stream, Lisp_Object codesys, - CONST char *mode) + const char *mode) { Lstream *lstr = Lstream_new (lstream_decoding, mode); struct decoding_stream *str = DECODING_STREAM_DATA (lstr); @@ -2357,7 +2422,7 @@ make_decoding_output_stream (Lstream *stream, Lisp_Object codesys) be used for both reading and writing. */ static void -mule_decode (Lstream *decoding, CONST unsigned char *src, +mule_decode (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -2563,7 +2628,7 @@ struct encoding_stream }; static ssize_t encoding_reader (Lstream *stream, unsigned char *data, size_t size); -static ssize_t encoding_writer (Lstream *stream, CONST unsigned char *data, +static ssize_t encoding_writer (Lstream *stream, const unsigned char *data, size_t size); static int encoding_rewinder (Lstream *stream); static int encoding_seekable_p (Lstream *stream); @@ -2659,7 +2724,7 @@ encoding_reader (Lstream *stream, unsigned char *data, size_t size) } static ssize_t -encoding_writer (Lstream *stream, CONST unsigned char *data, size_t size) +encoding_writer (Lstream *stream, const unsigned char *data, size_t size) { struct encoding_stream *str = ENCODING_STREAM_DATA (stream); ssize_t retval; @@ -2699,7 +2764,11 @@ reset_encoding_stream (struct encoding_stream *str) str->iso2022.register_right = 1; str->iso2022.current_charset = Qnil; str->iso2022.current_half = 0; +#ifdef UTF2000 + str->iso2022.current_char_boundary = 0; +#else str->iso2022.current_char_boundary = 1; +#endif break; } case CODESYS_CCL: @@ -2770,7 +2839,7 @@ set_encoding_stream_coding_system (Lstream *lstr, Lisp_Object codesys) static Lisp_Object make_encoding_stream_1 (Lstream *stream, Lisp_Object codesys, - CONST char *mode) + const char *mode) { Lstream *lstr = Lstream_new (lstream_encoding, mode); struct encoding_stream *str = ENCODING_STREAM_DATA (lstr); @@ -2801,7 +2870,7 @@ make_encoding_output_stream (Lstream *stream, Lisp_Object codesys) Store the encoded data into DST. */ static void -mule_encode (Lstream *encoding, CONST unsigned char *src, +mule_encode (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -2948,7 +3017,7 @@ text. BUFFER defaults to the current buffer if unspecified. ((c) >= 0xA1 && (c) <= 0xDF) static int -detect_coding_sjis (struct detection_state *st, CONST unsigned char *src, +detect_coding_sjis (struct detection_state *st, const unsigned char *src, unsigned int n) { int c; @@ -2973,7 +3042,7 @@ detect_coding_sjis (struct detection_state *st, CONST unsigned char *src, /* Convert Shift-JIS data to internal format. */ static void -decode_coding_sjis (Lstream *decoding, CONST unsigned char *src, +decode_coding_sjis (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; @@ -2993,10 +3062,16 @@ decode_coding_sjis (Lstream *decoding, CONST unsigned char *src, { unsigned char e1, e2; - Dynarr_add (dst, LEADING_BYTE_JAPANESE_JISX0208); DECODE_SJIS (ch, c, e1, e2); +#ifdef UTF2000 + DECODE_ADD_UCS_CHAR(MAKE_CHAR(Vcharset_japanese_jisx0208, + e1 & 0x7F, + e2 & 0x7F), dst); +#else + Dynarr_add (dst, LEADING_BYTE_JAPANESE_JISX0208); Dynarr_add (dst, e1); Dynarr_add (dst, e2); +#endif } else { @@ -3012,8 +3087,13 @@ decode_coding_sjis (Lstream *decoding, CONST unsigned char *src, ch = c; else if (BYTE_SJIS_KATAKANA_P (c)) { +#ifdef UTF2000 + DECODE_ADD_UCS_CHAR(MAKE_CHAR(Vcharset_katakana_jisx0201, + c & 0x7F, 0), dst); +#else Dynarr_add (dst, LEADING_BYTE_KATAKANA_JISX0201); Dynarr_add (dst, c); +#endif } else DECODE_ADD_BINARY_CHAR (c, dst); @@ -3030,7 +3110,7 @@ decode_coding_sjis (Lstream *decoding, CONST unsigned char *src, /* Convert internally-formatted data to Shift-JIS. */ static void -encode_coding_sjis (Lstream *encoding, CONST unsigned char *src, +encode_coding_sjis (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; @@ -3038,10 +3118,82 @@ encode_coding_sjis (Lstream *encoding, CONST unsigned char *src, unsigned int flags = str->flags; unsigned int ch = str->ch; eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); +#ifdef UTF2000 + unsigned char char_boundary = str->iso2022.current_char_boundary; +#endif while (n--) { c = *src++; +#ifdef UTF2000 + switch (char_boundary) + { + case 0: + if ( c >= 0xfc ) + { + ch = c & 0x01; + char_boundary = 5; + } + else if ( c >= 0xf8 ) + { + ch = c & 0x03; + char_boundary = 4; + } + else if ( c >= 0xf0 ) + { + ch = c & 0x07; + char_boundary = 3; + } + else if ( c >= 0xe0 ) + { + ch = c & 0x0f; + char_boundary = 2; + } + else if ( c >= 0xc0 ) + { + ch = c & 0x1f; + char_boundary = 1; + } + else + { + 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 + Dynarr_add (dst, c); + char_boundary = 0; + } + break; + case 1: + ch = ( ch << 6 ) | ( c & 0x3f ); + { + Lisp_Object charset; + unsigned int c1, c2, s1, s2; + + BREAKUP_CHAR (ch, charset, c1, c2); + if (EQ(charset, Vcharset_katakana_jisx0201)) + { + Dynarr_add (dst, c1 | 0x80); + } + else if (EQ(charset, Vcharset_japanese_jisx0208)) + { + ENCODE_SJIS (c1 | 0x80, c2 | 0x80, s1, s2); + Dynarr_add (dst, s1); + Dynarr_add (dst, s2); + } + } + char_boundary = 0; + break; + default: + ch = ( ch << 6 ) | ( c & 0x3f ); + char_boundary--; + } +#else if (c == '\n') { if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT) @@ -3078,10 +3230,14 @@ encode_coding_sjis (Lstream *encoding, CONST unsigned char *src, ch = 0; } } +#endif } str->flags = flags; str->ch = ch; +#ifdef UTF2000 + str->iso2022.current_char_boundary = char_boundary; +#endif } DEFUN ("decode-shift-jis-char", Fdecode_shift_jis_char, 1, 1, 0, /* @@ -3234,7 +3390,7 @@ Return the corresponding character code in SHIFT-JIS as a cons of two bytes. } while (0) static int -detect_coding_big5 (struct detection_state *st, CONST unsigned char *src, +detect_coding_big5 (struct detection_state *st, const unsigned char *src, unsigned int n) { int c; @@ -3260,7 +3416,7 @@ detect_coding_big5 (struct detection_state *st, CONST unsigned char *src, /* Convert Big5 data to internal format. */ static void -decode_coding_big5 (Lstream *decoding, CONST unsigned char *src, +decode_coding_big5 (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; @@ -3310,9 +3466,10 @@ decode_coding_big5 (Lstream *decoding, CONST unsigned char *src, /* Convert internally-formatted data to Big5. */ static void -encode_coding_big5 (Lstream *encoding, CONST unsigned char *src, +encode_coding_big5 (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { +#ifndef UTF2000 unsigned char c; struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); unsigned int flags = str->flags; @@ -3367,6 +3524,7 @@ encode_coding_big5 (Lstream *encoding, CONST unsigned char *src, str->flags = flags; str->ch = ch; +#endif } @@ -3387,7 +3545,7 @@ Return the corresponding character. if (BYTE_BIG5_TWO_BYTE_1_P (b1) && BYTE_BIG5_TWO_BYTE_2_P (b2)) { - int leading_byte; + Charset_ID leading_byte; Lisp_Object charset; DECODE_BIG5 (b1, b2, leading_byte, c1, c2); charset = CHARSET_BY_LEADING_BYTE (leading_byte); @@ -3427,7 +3585,7 @@ Return the corresponding character code in Big5. /* */ /************************************************************************/ - +#ifndef UTF2000 DEFUN ("set-ucs-char", Fset_ucs_char, 2, 2, 0, /* Map UCS-4 code CODE to Mule character CHARACTER. @@ -3502,7 +3660,11 @@ Return the UCS code (a positive integer) corresponding to CHARACTER. { return Fget_char_table (character, mule_to_ucs_table); } +#endif +#ifdef UTF2000 +#define decode_ucs4 DECODE_ADD_UCS_CHAR +#else /* 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. @@ -3531,7 +3693,9 @@ decode_ucs4 (unsigned long ch, unsigned_char_dynarr *dst) Dynarr_add (dst, 46 + 128); } } +#endif +#ifndef UTF2000 static unsigned long mule_char_to_ucs4 (Lisp_Object charset, unsigned char h, unsigned char l) @@ -3575,9 +3739,10 @@ encode_ucs4 (Lisp_Object charset, Dynarr_add (dst, (code >> 8) & 255); Dynarr_add (dst, code & 255); } +#endif static int -detect_coding_ucs4 (struct detection_state *st, CONST unsigned char *src, +detect_coding_ucs4 (struct detection_state *st, const unsigned char *src, unsigned int n) { while (n--) @@ -3602,7 +3767,7 @@ detect_coding_ucs4 (struct detection_state *st, CONST unsigned char *src, } static void -decode_coding_ucs4 (Lstream *decoding, CONST unsigned char *src, +decode_coding_ucs4 (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -3638,9 +3803,10 @@ decode_coding_ucs4 (Lstream *decoding, CONST unsigned char *src, } static void -encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src, +encode_coding_ucs4 (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { +#ifndef UTF2000 struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); unsigned int flags = str->flags; unsigned int ch = str->ch; @@ -3651,7 +3817,7 @@ encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src, /* flags for handling composite chars. We do a little switcharoo on the source while we're outputting the composite char. */ unsigned int saved_n = 0; - CONST unsigned char *saved_src = NULL; + const unsigned char *saved_src = NULL; int in_composite = 0; back_to_square_n: @@ -3769,6 +3935,7 @@ encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src, str->iso2022.current_charset = charset; /* Verbum caro factum est! */ +#endif } @@ -3777,7 +3944,7 @@ encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src, /************************************************************************/ static int -detect_coding_utf8 (struct detection_state *st, CONST unsigned char *src, +detect_coding_utf8 (struct detection_state *st, const unsigned char *src, unsigned int n) { while (n--) @@ -3812,7 +3979,7 @@ detect_coding_utf8 (struct detection_state *st, CONST unsigned char *src, } static void -decode_coding_utf8 (Lstream *decoding, CONST unsigned char *src, +decode_coding_utf8 (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -3879,6 +4046,7 @@ decode_coding_utf8 (Lstream *decoding, CONST unsigned char *src, str->counter = counter; } +#ifndef UTF2000 static void encode_utf8 (Lisp_Object charset, unsigned char h, unsigned char l, unsigned_char_dynarr *dst) @@ -3924,9 +4092,10 @@ encode_utf8 (Lisp_Object charset, Dynarr_add (dst, (code & 0x3f) | 0x80); } } +#endif static void -encode_coding_utf8 (Lstream *encoding, CONST unsigned char *src, +encode_coding_utf8 (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -3934,13 +4103,70 @@ encode_coding_utf8 (Lstream *encoding, CONST unsigned char *src, 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; +#ifdef UTF2000 + + while (n--) + { + unsigned char c = *src++; + switch (char_boundary) + { + case 0: + if ( c >= 0xfc ) + { + Dynarr_add (dst, c); + char_boundary = 5; + } + else if ( c >= 0xf8 ) + { + Dynarr_add (dst, c); + char_boundary = 4; + } + else if ( c >= 0xf0 ) + { + Dynarr_add (dst, c); + char_boundary = 3; + } + else if ( c >= 0xe0 ) + { + Dynarr_add (dst, c); + char_boundary = 2; + } + else if ( c >= 0xc0 ) + { + Dynarr_add (dst, c); + char_boundary = 1; + } + else + { + 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 + Dynarr_add (dst, c); + char_boundary = 0; + } + break; + case 1: + Dynarr_add (dst, c); + char_boundary = 0; + break; + default: + Dynarr_add (dst, c); + char_boundary--; + } + } +#else /* not UTF2000 */ 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; + const unsigned char *saved_src = NULL; int in_composite = 0; back_to_square_n: @@ -4057,10 +4283,13 @@ encode_coding_utf8 (Lstream *encoding, CONST unsigned char *src, } #endif +#endif /* not UTF2000 */ str->flags = flags; str->ch = ch; str->iso2022.current_char_boundary = char_boundary; +#ifndef UTF2000 str->iso2022.current_charset = charset; +#endif /* Verbum caro factum est! */ } @@ -4644,7 +4873,7 @@ parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso, } static int -detect_coding_iso2022 (struct detection_state *st, CONST unsigned char *src, +detect_coding_iso2022 (struct detection_state *st, const unsigned char *src, unsigned int n) { int mask; @@ -4835,7 +5064,7 @@ ensure_correct_direction (int direction, Lisp_Coding_System *codesys, /* Convert ISO2022-format data to internal format. */ static void -decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src, +decode_coding_iso2022 (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -4960,7 +5189,9 @@ decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src, else { /* Graphic characters */ Lisp_Object charset; - int lb; +#ifndef UTF2000 + Charset_ID lb; +#endif int reg; DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst); @@ -5003,6 +5234,22 @@ decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src, charset = new_charset; } +#ifdef UTF2000 + if (XCHARSET_DIMENSION (charset) == 1) + { + DECODE_OUTPUT_PARTIAL_CHAR (ch); + DECODE_ADD_UCS_CHAR + (MAKE_CHAR (charset, c & 0x7F, 0), dst); + } + else if (ch) + { + DECODE_ADD_UCS_CHAR + (MAKE_CHAR (charset, ch & 0x7F, c & 0x7F), dst); + ch = 0; + } + else + ch = c; +#else lb = XCHARSET_LEADING_BYTE (charset); switch (XCHARSET_REP_BYTES (charset)) { @@ -5051,6 +5298,7 @@ decode_coding_iso2022 (Lstream *decoding, CONST unsigned char *src, else ch = c; } +#endif } if (!ch) @@ -5076,8 +5324,8 @@ static void iso2022_designate (Lisp_Object charset, unsigned char reg, struct encoding_stream *str, unsigned_char_dynarr *dst) { - static CONST char inter94[] = "()*+"; - static CONST char inter96[] = ",-./"; + static const char inter94[] = "()*+"; + static const char inter96[] = ",-./"; unsigned int type; unsigned char final; Lisp_Object old_charset = str->iso2022.charset[reg]; @@ -5161,25 +5409,28 @@ ensure_shift_out (struct encoding_stream *str, unsigned_char_dynarr *dst) /* Convert internally-formatted data to ISO2022 format. */ static void -encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, +encode_coding_iso2022 (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char charmask, c; unsigned char char_boundary; struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); unsigned int flags = str->flags; - unsigned int ch = str->ch; + Emchar ch = str->ch; Lisp_Coding_System *codesys = str->codesys; eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); int i; Lisp_Object charset; int half; +#ifdef UTF2000 + unsigned int byte1, byte2; +#endif #ifdef ENABLE_COMPOSITE_CHARS /* flags for handling composite chars. We do a little switcharoo on the source while we're outputting the composite char. */ unsigned int saved_n = 0; - CONST unsigned char *saved_src = NULL; + const unsigned char *saved_src = NULL; int in_composite = 0; #endif /* ENABLE_COMPOSITE_CHARS */ @@ -5190,6 +5441,216 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, #ifdef ENABLE_COMPOSITE_CHARS back_to_square_n: #endif +#ifdef UTF2000 + while (n--) + { + c = *src++; + + switch (char_boundary) + { + case 0: + if ( c >= 0xfc ) + { + ch = c & 0x01; + char_boundary = 5; + } + else if ( c >= 0xf8 ) + { + ch = c & 0x03; + char_boundary = 4; + } + else if ( c >= 0xf0 ) + { + ch = c & 0x07; + char_boundary = 3; + } + else if ( c >= 0xe0 ) + { + ch = c & 0x0f; + char_boundary = 2; + } + else if ( c >= 0xc0 ) + { + ch = c & 0x1f; + char_boundary = 1; + } + else + { + ch = 0; + + restore_left_to_right_direction (codesys, dst, &flags, 0); + + /* Make sure G0 contains ASCII */ + if ((c > ' ' && c < ISO_CODE_DEL) || + !CODING_SYSTEM_ISO2022_NO_ASCII_CNTL (codesys)) + { + ensure_normal_shift (str, dst); + iso2022_designate (Vcharset_ascii, 0, str, dst); + } + + /* If necessary, restore everything to the default state + at end-of-line */ + if (c == '\n' && + !(CODING_SYSTEM_ISO2022_NO_ASCII_EOL (codesys))) + { + restore_left_to_right_direction (codesys, dst, &flags, 0); + + ensure_normal_shift (str, dst); + + for (i = 0; i < 4; i++) + { + Lisp_Object initial_charset = + CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i); + iso2022_designate (initial_charset, i, str, dst); + } + } + 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 + { + if (CODING_SYSTEM_ISO2022_ESCAPE_QUOTED (codesys) + && fit_to_be_escape_quoted (c)) + Dynarr_add (dst, ISO_CODE_ESC); + Dynarr_add (dst, c); + } + char_boundary = 0; + } + break; + case 1: + ch = ( ch << 6 ) | ( c & 0x3f ); + + char_boundary = 0; + if ( (0x80 <= ch) && (ch <= 0x9f) ) + { + charmask = (half == 0 ? 0x00 : 0x80); + + if (CODING_SYSTEM_ISO2022_ESCAPE_QUOTED (codesys) + && fit_to_be_escape_quoted (ch)) + Dynarr_add (dst, ISO_CODE_ESC); + /* you asked for it ... */ + Dynarr_add (dst, ch); + } + else + { + int reg; + + BREAKUP_CHAR (ch, charset, byte1, byte2); + ensure_correct_direction (XCHARSET_DIRECTION (charset), + codesys, dst, &flags, 0); + + /* Now determine which register to use. */ + reg = -1; + for (i = 0; i < 4; i++) + { + if (EQ (charset, str->iso2022.charset[i]) || + EQ (charset, + CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i))) + { + reg = i; + break; + } + } + + if (reg == -1) + { + if (XCHARSET_GRAPHIC (charset) != 0) + { + if (!NILP (str->iso2022.charset[1]) && + (!CODING_SYSTEM_ISO2022_SEVEN (codesys) || + CODING_SYSTEM_ISO2022_LOCK_SHIFT (codesys))) + reg = 1; + else if (!NILP (str->iso2022.charset[2])) + reg = 2; + else if (!NILP (str->iso2022.charset[3])) + reg = 3; + else + reg = 0; + } + else + reg = 0; + } + + iso2022_designate (charset, reg, str, dst); + + /* Now invoke that register. */ + switch (reg) + { + case 0: + ensure_normal_shift (str, dst); + half = 0; + break; + + case 1: + if (CODING_SYSTEM_ISO2022_SEVEN (codesys)) + { + ensure_shift_out (str, dst); + half = 0; + } + else + half = 1; + break; + + case 2: + if (CODING_SYSTEM_ISO2022_SEVEN (str->codesys)) + { + Dynarr_add (dst, ISO_CODE_ESC); + Dynarr_add (dst, 'N'); + half = 0; + } + else + { + Dynarr_add (dst, ISO_CODE_SS2); + half = 1; + } + break; + + case 3: + if (CODING_SYSTEM_ISO2022_SEVEN (str->codesys)) + { + Dynarr_add (dst, ISO_CODE_ESC); + Dynarr_add (dst, 'O'); + half = 0; + } + else + { + Dynarr_add (dst, ISO_CODE_SS3); + half = 1; + } + break; + + default: + abort (); + } + + charmask = (half == 0 ? 0x00 : 0x80); + + switch (XCHARSET_DIMENSION (charset)) + { + case 1: + Dynarr_add (dst, byte1 | charmask); + break; + case 2: + Dynarr_add (dst, byte1 | charmask); + Dynarr_add (dst, byte2 | charmask); + break; + default: + abort (); + } + } + ch =0; + break; + default: + ch = ( ch << 6 ) | ( c & 0x3f ); + char_boundary--; + } + } +#else /* not UTF2000 */ + while (n--) { c = *src++; @@ -5427,6 +5888,7 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, } } } +#endif /* not UTF2000 */ #ifdef ENABLE_COMPOSITE_CHARS if (in_composite) @@ -5440,7 +5902,11 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, } #endif /* ENABLE_COMPOSITE_CHARS */ +#ifdef UTF2000 + if ( (char_boundary == 0) && flags & CODING_STATE_END) +#else if (char_boundary && flags & CODING_STATE_END) +#endif { restore_left_to_right_direction (codesys, dst, &flags, 0); ensure_normal_shift (str, dst); @@ -5470,7 +5936,7 @@ encode_coding_iso2022 (Lstream *encoding, CONST unsigned char *src, contain all 256 possible byte values and that are not to be interpreted as being in any particular decoding. */ static void -decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src, +decode_coding_no_conversion (Lstream *decoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; @@ -5495,7 +5961,7 @@ decode_coding_no_conversion (Lstream *decoding, CONST unsigned char *src, } static void -encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src, +encode_coding_no_conversion (Lstream *encoding, const unsigned char *src, unsigned_char_dynarr *dst, unsigned int n) { unsigned char c; @@ -5503,10 +5969,68 @@ encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src, unsigned int flags = str->flags; unsigned int ch = str->ch; eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys); +#ifdef UTF2000 + unsigned char char_boundary = str->iso2022.current_char_boundary; +#endif while (n--) { - c = *src++; + c = *src++; +#ifdef UTF2000 + switch (char_boundary) + { + case 0: + if ( c >= 0xfc ) + { + ch = c & 0x01; + char_boundary = 5; + } + else if ( c >= 0xf8 ) + { + ch = c & 0x03; + char_boundary = 4; + } + else if ( c >= 0xf0 ) + { + ch = c & 0x07; + char_boundary = 3; + } + else if ( c >= 0xe0 ) + { + ch = c & 0x0f; + char_boundary = 2; + } + else if ( c >= 0xc0 ) + { + ch = c & 0x1f; + char_boundary = 1; + } + else + { + 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 + Dynarr_add (dst, c); + char_boundary = 0; + } + break; + case 1: + ch = ( ch << 6 ) | ( c & 0x3f ); + Dynarr_add (dst, ch & 0xff); + char_boundary = 0; + break; + default: + ch = ( ch << 6 ) | ( c & 0x3f ); + char_boundary--; + } +#else /* not UTF2000 */ if (c == '\n') { if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT) @@ -5542,10 +6066,14 @@ encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src, untranslatable character, so ignore it */ ch = 0; } +#endif /* not UTF2000 */ } str->flags = flags; str->ch = ch; +#ifdef UTF2000 + str->iso2022.current_char_boundary = char_boundary; +#endif } @@ -5557,6 +6085,8 @@ encode_coding_no_conversion (Lstream *encoding, CONST unsigned char *src, void syms_of_file_coding (void) { + INIT_LRECORD_IMPLEMENTATION (coding_system); + deferror (&Qcoding_system_error, "coding-system-error", "Coding-system error", Qio_error); @@ -5594,10 +6124,12 @@ syms_of_file_coding (void) DEFSUBR (Fencode_shift_jis_char); DEFSUBR (Fdecode_big5_char); DEFSUBR (Fencode_big5_char); +#ifndef UTF2000 DEFSUBR (Fset_ucs_char); DEFSUBR (Fucs_char); DEFSUBR (Fset_char_ucs); DEFSUBR (Fchar_ucs); +#endif /* not UTF2000 */ #endif /* MULE */ defsymbol (&Qcoding_systemp, "coding-system-p"); defsymbol (&Qno_conversion, "no-conversion"); @@ -5812,6 +6344,13 @@ complex_vars_of_file_coding (void) list4 (Qeol_type, Qlf, Qmnemonic, build_string ("Binary"))); +#ifdef UTF2000 + Fmake_coding_system + (Qutf8, Qutf8, + build_string ("Coding-system of ISO/IEC 10646 UTF-8."), + list2 (Qmnemonic, build_string ("UTF8"))); +#endif + Fdefine_coding_system_alias (Qno_conversion, Qraw_text); Fdefine_coding_system_alias (Qfile_name, Qbinary); @@ -5823,7 +6362,12 @@ complex_vars_of_file_coding (void) fcd->coding_category_system[CODING_CATEGORY_NO_CONVERSION] = Fget_coding_system (Qraw_text); -#ifdef MULE +#ifdef UTF2000 + fcd->coding_category_system[CODING_CATEGORY_UTF8] + = Fget_coding_system (Qutf8); +#endif + +#if defined(MULE) && !defined(UTF2000) { unsigned int i; @@ -5832,5 +6376,5 @@ complex_vars_of_file_coding (void) } staticpro (&mule_to_ucs_table); mule_to_ucs_table = Fmake_char_table(Qgeneric); -#endif /* MULE */ +#endif /* defined(MULE) && !defined(UTF2000) */ }