X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=blobdiff_plain;f=src%2Fmule-charset.c;h=06a2b68cb47bec59224708b52c1f454a272cb0c4;hp=8c8604e25daa8edccee2ce1bebd7d1a7b2fbd9b4;hb=9f7e1f8c96cb936ba2e2cb5db1185f9bc18c42cf;hpb=5a515f949a4ce029df2774a3af4b287a7b65710a diff --git a/src/mule-charset.c b/src/mule-charset.c index 8c8604e..06a2b68 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -1,7 +1,8 @@ /* Functions to handle multilingual characters. Copyright (C) 1992, 1995 Free Software Foundation, Inc. Copyright (C) 1995 Sun Microsystems, Inc. - Copyright (C) 1999,2000,2001,2002,2003 MORIOKA Tomohiko + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2008, 2009, 2011 + MORIOKA Tomohiko This file is part of XEmacs. @@ -22,10 +23,10 @@ Boston, MA 02111-1307, USA. */ /* Rewritten by Ben Wing . */ -/* Rewritten by MORIOKA Tomohiko for XEmacs UTF-2000. */ +/* Rewritten by MORIOKA Tomohiko for XEmacs CHISE. */ #include -#ifdef CHISE +#ifdef HAVE_LIBCHISE #include #endif #ifdef UTF2000 @@ -57,7 +58,7 @@ Lisp_Object Vcharset_katakana_jisx0201; Lisp_Object Vcharset_latin_jisx0201; Lisp_Object Vcharset_cyrillic_iso8859_5; Lisp_Object Vcharset_latin_iso8859_9; -Lisp_Object Vcharset_japanese_jisx0208_1978; +/* Lisp_Object Vcharset_japanese_jisx0208_1978; */ Lisp_Object Vcharset_chinese_gb2312; Lisp_Object Vcharset_chinese_gb12345; Lisp_Object Vcharset_japanese_jisx0208; @@ -67,6 +68,7 @@ Lisp_Object Vcharset_japanese_jisx0212; Lisp_Object Vcharset_chinese_cns11643_1; Lisp_Object Vcharset_chinese_cns11643_2; #ifdef UTF2000 +Lisp_Object Vcharset_system_char_id; Lisp_Object Vcharset_ucs; Lisp_Object Vcharset_ucs_bmp; Lisp_Object Vcharset_ucs_smp; @@ -175,13 +177,101 @@ decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len) return 0; } +void +decoding_table_put_char (Lisp_Object ccs, + int code_point, Lisp_Object character) +{ +#if 1 + Lisp_Object table1 = XCHARSET_DECODING_TABLE (ccs); + int dim = XCHARSET_DIMENSION (ccs); + + if (dim == 1) + XCHARSET_DECODING_TABLE (ccs) + = put_ccs_octet_table (table1, ccs, code_point, character); + else if (dim == 2) + { + Lisp_Object table2 + = get_ccs_octet_table (table1, ccs, (unsigned char)(code_point >> 8)); + + table2 = put_ccs_octet_table (table2, ccs, + (unsigned char)code_point, character); + XCHARSET_DECODING_TABLE (ccs) + = put_ccs_octet_table (table1, ccs, + (unsigned char)(code_point >> 8), table2); + } + else if (dim == 3) + { + Lisp_Object table2 + = get_ccs_octet_table (table1, ccs, (unsigned char)(code_point >> 16)); + Lisp_Object table3 + = get_ccs_octet_table (table2, ccs, (unsigned char)(code_point >> 8)); + + table3 = put_ccs_octet_table (table3, ccs, + (unsigned char)code_point, character); + table2 = put_ccs_octet_table (table2, ccs, + (unsigned char)(code_point >> 8), table3); + XCHARSET_DECODING_TABLE (ccs) + = put_ccs_octet_table (table1, ccs, + (unsigned char)(code_point >> 16), table2); + } + else /* if (dim == 4) */ + { + Lisp_Object table2 + = get_ccs_octet_table (table1, ccs, (unsigned char)(code_point >> 24)); + Lisp_Object table3 + = get_ccs_octet_table (table2, ccs, (unsigned char)(code_point >> 16)); + Lisp_Object table4 + = get_ccs_octet_table (table3, ccs, (unsigned char)(code_point >> 8)); + + table4 = put_ccs_octet_table (table4, ccs, + (unsigned char)code_point, character); + table3 = put_ccs_octet_table (table3, ccs, + (unsigned char)(code_point >> 8), table4); + table2 = put_ccs_octet_table (table2, ccs, + (unsigned char)(code_point >> 16), table3); + XCHARSET_DECODING_TABLE (ccs) + = put_ccs_octet_table (table1, ccs, + (unsigned char)(code_point >> 24), table2); + } +#else + Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); + int dim = XCHARSET_DIMENSION (ccs); + int byte_offset = XCHARSET_BYTE_OFFSET (ccs); + int i = -1; + Lisp_Object nv; + int ccs_len = XVECTOR_LENGTH (v); + + while (dim > 0) + { + dim--; + i = ((code_point >> (8 * dim)) & 255) - byte_offset; + nv = XVECTOR_DATA(v)[i]; + if (dim > 0) + { + if (!VECTORP (nv)) + { + if (EQ (nv, character)) + return; + else + nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil)); + } + v = nv; + } + else + break; + } + XVECTOR_DATA(v)[i] = character; +#endif +} + Lisp_Object put_char_ccs_code_point (Lisp_Object character, Lisp_Object ccs, Lisp_Object value) { - if (!EQ (XCHARSET_NAME (ccs), Qmap_ucs) - || !INTP (value) - || (XCHAR (character) != XINT (value))) + if ( !( EQ (XCHARSET_NAME (ccs), Qrep_ucs) + && INTP (value) && (XINT (value) < 0xF0000) + && XCHAR (character) == XINT (value) ) + || !INTP (value) ) { Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); int code_point; @@ -279,6 +369,8 @@ Lisp_Object Qleading_byte; Lisp_Object Qshort_name, Qlong_name; Lisp_Object Qiso_ir; #ifdef UTF2000 +Lisp_Object Qto_iso_ir; +Lisp_Object Qpartial; Lisp_Object Qmin_code, Qmax_code, Qcode_offset; Lisp_Object Qmother, Qconversion, Q94x60, Q94x94x60, Qbig5_1, Qbig5_2; #endif @@ -297,16 +389,17 @@ Lisp_Object Qascii, Qlatin_jisx0201, Qcyrillic_iso8859_5, Qlatin_iso8859_9, - Qmap_jis_x0208_1978, - Qmap_gb2312, - Qmap_gb12345, - Qmap_jis_x0208_1983, - Qmap_ks_x1001, - Qmap_jis_x0212, - Qmap_cns11643_1, - Qmap_cns11643_2, +/* Qrep_jis_x0208_1978, */ + Qrep_gb2312, + Qrep_gb12345, + Qrep_jis_x0208_1983, + Qrep_ks_x1001, + Qrep_jis_x0212, + Qrep_cns11643_1, + Qrep_cns11643_2, #ifdef UTF2000 - Qmap_ucs, Qucs, + Qsystem_char_id, + Qrep_ucs, Qucs, Qucs_bmp, Qucs_smp, Qucs_sip, @@ -316,9 +409,9 @@ Lisp_Object Qascii, Qlatin_viscii_upper, Qvietnamese_viscii_lower, Qvietnamese_viscii_upper, - Qmap_jis_x0208, - Qmap_jis_x0208_1990, - Qmap_big5, + Qrep_jis_x0208, + Qrep_jis_x0208_1990, + Qrep_big5, Qethiopic_ucs, #endif Qchinese_big5_1, @@ -730,10 +823,12 @@ make_charset (Charset_ID id, Lisp_Object name, Bufbyte final, unsigned char direction, Lisp_Object short_name, Lisp_Object long_name, Lisp_Object doc, Lisp_Object reg, + int iso_ir, Lisp_Object decoding_table, Emchar min_code, Emchar max_code, Emchar code_offset, unsigned char byte_offset, - Lisp_Object mother, unsigned char conversion) + Lisp_Object mother, unsigned char conversion, + int partial) { Lisp_Object obj; Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset); @@ -757,6 +852,7 @@ make_charset (Charset_ID id, Lisp_Object name, CHARSET_CCL_PROGRAM (cs) = Qnil; CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil; #ifdef UTF2000 + CHARSET_ISO_IR (cs) = iso_ir; CHARSET_DECODING_TABLE(cs) = Qunbound; CHARSET_MIN_CODE (cs) = min_code; CHARSET_MAX_CODE (cs) = max_code; @@ -783,7 +879,7 @@ make_charset (Charset_ID id, Lisp_Object name, unsigned char iso2022_type = (dimension == 1 ? 0 : 2) + (chars == 94 ? 0 : 1); #if UTF2000 - if (code_offset == 0) + if ( ( !partial ) && ( code_offset == 0 ) ) { assert (NILP (chlook->charset_by_attributes[iso2022_type][final])); chlook->charset_by_attributes[iso2022_type][final] = obj; @@ -818,15 +914,22 @@ get_unallocated_leading_byte (int dimension) #else if (dimension == 1) { - if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1) + if (chlook->next_allocated_1_byte_leading_byte > + MAX_LEADING_BYTE_PRIVATE_1) lb = 0; else lb = chlook->next_allocated_1_byte_leading_byte++; } else { - if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) - lb = 0; + /* awfully fragile, but correct */ +#if MAX_LEADING_BYTE_PRIVATE_2 == 255 + if (chlook->next_allocated_2_byte_leading_byte == 0) +#else + if (chlook->next_allocated_2_byte_leading_byte > + MAX_LEADING_BYTE_PRIVATE_2) +#endif + lb = 0; else lb = chlook->next_allocated_2_byte_leading_byte++; } @@ -845,8 +948,76 @@ get_unallocated_leading_byte (int dimension) #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40) +static int +decode_ccs_conversion (int conv_type, int code_point) +{ + if ( conv_type == CONVERSION_IDENTICAL ) + { + return code_point; + } + if ( conv_type == CONVERSION_94x60 ) + { + int row = code_point >> 8; + int cell = code_point & 255; + + if (row < 16 + 32) + return -1; + else if (row < 16 + 32 + 30) + return (row - (16 + 32)) * 94 + cell - 33; + else if (row < 18 + 32 + 30) + return -1; + else if (row < 18 + 32 + 60) + return (row - (18 + 32)) * 94 + cell - 33; + } + else if ( conv_type == CONVERSION_94x94x60 ) + { + int plane = code_point >> 16; + int row = (code_point >> 8) & 255; + int cell = code_point & 255; + + if (row < 16 + 32) + return -1; + else if (row < 16 + 32 + 30) + return + (plane - 33) * 94 * 60 + + (row - (16 + 32)) * 94 + + cell - 33; + else if (row < 18 + 32 + 30) + return -1; + else if (row < 18 + 32 + 60) + return + (plane - 33) * 94 * 60 + + (row - (18 + 32)) * 94 + + cell - 33; + } + else if ( conv_type == CONVERSION_BIG5_1 ) + { + unsigned int I + = (((code_point >> 8) & 0x7F) - 33) * 94 + + (( code_point & 0x7F) - 33); + unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; + unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); + + b2 += b2 < 0x3F ? 0x40 : 0x62; + return (b1 << 8) | b2; + } + else if ( conv_type == CONVERSION_BIG5_2 ) + { + unsigned int I + = (((code_point >> 8) & 0x7F) - 33) * 94 + + (( code_point & 0x7F) - 33) + + BIG5_SAME_ROW * (0xC9 - 0xA1); + unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; + unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); + + b2 += b2 < 0x3F ? 0x40 : 0x62; + return (b1 << 8) | b2; + } + return -1; +} + Emchar -decode_defined_char (Lisp_Object ccs, int code_point) +decode_defined_char (Lisp_Object ccs, int code_point, int without_inheritance) { int dim = XCHARSET_DIMENSION (ccs); Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs); @@ -862,45 +1033,28 @@ decode_defined_char (Lisp_Object ccs, int code_point) } if (CHARP (decoding_table)) return XCHAR (decoding_table); -#ifdef HAVE_CHISE_CLIENT +#ifdef HAVE_CHISE if (EQ (decoding_table, Qunloaded)) { char_id = load_char_decoding_entry_maybe (ccs, code_point); } -#endif +#endif /* HAVE_CHISE */ if (char_id >= 0) return char_id; - else if ( CHARSETP (mother = XCHARSET_MOTHER (ccs)) ) + else if ( !without_inheritance + && CHARSETP (mother = XCHARSET_MOTHER (ccs)) ) { - if ( XCHARSET_CONVERSION (ccs) == CONVERSION_IDENTICAL ) + int code + = decode_ccs_conversion (XCHARSET_CONVERSION (ccs), code_point); + + if (code >= 0) { + code += XCHARSET_CODE_OFFSET(ccs); if ( EQ (mother, Vcharset_ucs) ) - return DECODE_CHAR (mother, code_point); + return DECODE_CHAR (mother, code, without_inheritance); else - return decode_defined_char (mother, code_point); - } - else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_1 ) - { - unsigned int I - = (((code_point >> 8) & 0x7F) - 33) * 94 - + (( code_point & 0x7F) - 33); - unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; - unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); - - b2 += b2 < 0x3F ? 0x40 : 0x62; - return decode_defined_char (mother, (b1 << 8) | b2); - } - else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_2 ) - { - unsigned int I - = (((code_point >> 8) & 0x7F) - 33) * 94 - + (( code_point & 0x7F) - 33) - + BIG5_SAME_ROW * (0xC9 - 0xA1); - unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; - unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); - - b2 += b2 < 0x3F ? 0x40 : 0x62; - return decode_defined_char (mother, (b1 << 8) | b2); + return decode_defined_char (mother, code, + without_inheritance); } } return -1; @@ -916,68 +1070,16 @@ decode_builtin_char (Lisp_Object charset, int code_point) { if ( CHARSETP (mother) ) { - int code = code_point; - - if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 ) - { - int row = code_point >> 8; - int cell = code_point & 255; - - if (row < 16 + 32) - return -1; - else if (row < 16 + 32 + 30) - code = (row - (16 + 32)) * 94 + cell - 33; - else if (row < 18 + 32 + 30) - return -1; - else if (row < 18 + 32 + 60) - code = (row - (18 + 32)) * 94 + cell - 33; - } - else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 ) - { - int plane = code_point >> 16; - int row = (code_point >> 8) & 255; - int cell = code_point & 255; + EMACS_INT code + = decode_ccs_conversion (XCHARSET_CONVERSION (charset), + code_point); - if (row < 16 + 32) - return -1; - else if (row < 16 + 32 + 30) - code - = (plane - 33) * 94 * 60 - + (row - (16 + 32)) * 94 - + cell - 33; - else if (row < 18 + 32 + 30) - return -1; - else if (row < 18 + 32 + 60) - code - = (plane - 33) * 94 * 60 - + (row - (18 + 32)) * 94 - + cell - 33; - } - else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 ) - { - unsigned int I - = (((code_point >> 8) & 0x7F) - 33) * 94 - + (( code_point & 0x7F) - 33); - unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; - unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); - - b2 += b2 < 0x3F ? 0x40 : 0x62; - code = (b1 << 8) | b2; - } - else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 ) - { - unsigned int I - = (((code_point >> 8) & 0x7F) - 33) * 94 - + (( code_point & 0x7F) - 33) - + BIG5_SAME_ROW * (0xC9 - 0xA1); - unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; - unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); - - b2 += b2 < 0x3F ? 0x40 : 0x62; - code = (b1 << 8) | b2; - } - return - decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset)); + if (code >= 0) + return + decode_builtin_char (mother, + code + XCHARSET_CODE_OFFSET(charset)); + else + return -1; } else { @@ -1038,35 +1140,40 @@ decode_builtin_char (Lisp_Object charset, int code_point) } int -charset_code_point (Lisp_Object charset, Emchar ch, int defined_only) +charset_code_point (Lisp_Object charset, Emchar ch, int accepted_mode) { - Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset); Lisp_Object ret; - if ( CHAR_TABLEP (encoding_table) - && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table), - ch)) ) - return XINT (ret); - else + if ( accepted_mode >= 0 ) + { + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset); + + if ( CHAR_TABLEP (encoding_table) + && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table), + ch)) ) + return XINT (ret); + } { Lisp_Object mother = XCHARSET_MOTHER (charset); int min = XCHARSET_MIN_CODE (charset); int max = XCHARSET_MAX_CODE (charset); int code = -1; - if ( CHARSETP (mother) ) - { - if (XCHARSET_FINAL (charset) >= '0') - code = charset_code_point (mother, ch, 1); - else - code = charset_code_point (mother, ch, defined_only); - } - else if (defined_only) + if ( CHARSETP (mother) && ( accepted_mode >= 0) + && ( XCHARSET_FINAL (charset) >= '0' ) + ) + code = charset_code_point (mother, ch, CHAR_DEFINED_ONLY); + else if ( CHARSETP (mother) + && ( XCHARSET_FINAL (charset) < '0' ) + ) + code = charset_code_point (mother, ch, accepted_mode); + else if ( accepted_mode == CHAR_DEFINED_ONLY ) return -1; else if ( ((max == 0) && CHARSETP (mother) && (XCHARSET_FINAL (charset) == 0)) || ((min <= ch) && (ch <= max)) ) code = ch; + if ( ((max == 0) && CHARSETP (mother) && (code >= 0)) || ((min <= code) && (code <= max)) ) { @@ -1159,6 +1266,8 @@ charset_code_point (Lisp_Object charset, Emchar ch, int defined_only) exit (-1); } } + else if ( accepted_mode == CHAR_DEFINED_ONLY ) + return -1; else if ( ( XCHARSET_FINAL (charset) >= '0' ) && ( XCHARSET_MIN_CODE (charset) == 0 ) /* @@ -1219,6 +1328,55 @@ charset_code_point (Lisp_Object charset, Emchar ch, int defined_only) } int +encode_char_2 (Emchar ch, Lisp_Object* charset) +{ + Lisp_Object charsets = Vdefault_coded_charset_priority_list; + int code_point; + + while (!NILP (charsets)) + { + *charset = Ffind_charset (Fcar (charsets)); + if ( !NILP (*charset) + && (XCHARSET_DIMENSION (*charset) <= 2) ) + { + code_point = charset_code_point (*charset, ch, 0); + if (code_point >= 0) + return code_point; + + if ( !NILP (Vdisplay_coded_charset_priority_use_inheritance) && + NILP (Vdisplay_coded_charset_priority_use_hierarchy_order) ) + { + code_point = encode_char_2_search_children (ch, charset); + if (code_point >= 0) + return code_point; + } + } + charsets = Fcdr (charsets); + } + + if ( !NILP (Vdisplay_coded_charset_priority_use_inheritance) && + !NILP (Vdisplay_coded_charset_priority_use_hierarchy_order) ) + { + charsets = Vdefault_coded_charset_priority_list; + while (!NILP (charsets)) + { + *charset = Ffind_charset (Fcar (charsets)); + if ( !NILP (*charset) + && (XCHARSET_DIMENSION (*charset) <= 2) ) + { + code_point = encode_char_2_search_children (ch, charset); + if (code_point >= 0) + return code_point; + } + charsets = Fcdr (charsets); + } + } + + /* otherwise --- maybe for bootstrap */ + return encode_builtin_char_1 (ch, charset); +} + +int encode_builtin_char_1 (Emchar c, Lisp_Object* charset) { if (c <= MAX_CHAR_BASIC_LATIN) @@ -1340,6 +1498,8 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) } Lisp_Object Vdefault_coded_charset_priority_list; +Lisp_Object Vdisplay_coded_charset_priority_use_inheritance; +Lisp_Object Vdisplay_coded_charset_priority_use_hierarchy_order; #endif @@ -1480,6 +1640,8 @@ character set. Recognized properties are: is passed the octets of the character, with the high bit cleared and set depending upon whether the value of the 'graphic property is 0 or 1. +'iso-ir ISO-IR number (for representative coded-charset). +'=>iso-ir [UTF-2000 only] Corresponding ISO-IR number. 'mother [UTF-2000 only] Base coded-charset. 'code-min [UTF-2000 only] Minimum code-point of a base coded-charset. 'code-max [UTF-2000 only] Maximum code-point of a base coded-charset. @@ -1487,16 +1649,19 @@ character set. Recognized properties are: coded-charset. 'conversion [UTF-2000 only] Conversion for a code-point of a base coded-charset (94x60, 94x94x60, big5-1 or big5-2). +'partial [UTF-2000 only] If t, specify as a partial coded-charset. */ (name, doc_string, props)) { int id = 0, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1; + int iso_ir = 0; int direction = CHARSET_LEFT_TO_RIGHT; Lisp_Object registry = Qnil; Lisp_Object charset; Lisp_Object ccl_program = Qnil; Lisp_Object short_name = Qnil, long_name = Qnil; Lisp_Object mother = Qnil; + int partial = 0; int min_code = 0, max_code = 0, code_offset = 0; int byte_offset = -1; int conversion = 0; @@ -1528,10 +1693,19 @@ character set. Recognized properties are: { #ifdef UTF2000 CHECK_INT (value); - id = - XINT (value); + iso_ir = XINT (value); + id = - iso_ir; #endif } +#ifdef UTF2000 + else if (EQ (keyword, Qto_iso_ir)) + { + CHECK_INT (value); + iso_ir = XINT (value); + } +#endif + else if (EQ (keyword, Qdimension)) { CHECK_INT (value); @@ -1605,6 +1779,11 @@ character set. Recognized properties are: } #ifdef UTF2000 + else if (EQ (keyword, Qpartial)) + { + partial = !NILP (value); + } + else if (EQ (keyword, Qmother)) { mother = Fget_charset (value); @@ -1701,11 +1880,52 @@ character set. Recognized properties are: byte_offset = 0; } + if ( (conversion == 0) && NILP (mother) && (min_code > 0) ) + { + switch (chars) + { + case 94: + switch (dimension) + { + case 1: + conversion = CONVERSION_94; + break; + case 2: + conversion = CONVERSION_94x94; + break; + case 3: + conversion = CONVERSION_94x94x94; + break; + case 4: + conversion = CONVERSION_94x94x94x94; + break; + } + break; + case 96: + switch (dimension) + { + case 1: + conversion = CONVERSION_96; + break; + case 2: + conversion = CONVERSION_96x96; + break; + case 3: + conversion = CONVERSION_96x96x96; + break; + case 4: + conversion = CONVERSION_96x96x96x96; + break; + } + break; + } + } + charset = make_charset (id, name, chars, dimension, columns, graphic, final, direction, short_name, long_name, - doc_string, registry, + doc_string, registry, iso_ir, Qnil, min_code, max_code, code_offset, byte_offset, - mother, conversion); + mother, conversion, partial); if (!NILP (ccl_program)) XCHARSET_CCL_PROGRAM (charset) = ccl_program; return charset; @@ -1754,6 +1974,7 @@ NEW-NAME is the name of the new charset. Return the new charset. graphic, final, direction, short_name, long_name, doc_string, registry, #ifdef UTF2000 + CHARSET_ISO_IR(cs), CHARSET_DECODING_TABLE(cs), CHARSET_MIN_CODE(cs), CHARSET_MAX_CODE(cs), @@ -1764,7 +1985,7 @@ NEW-NAME is the name of the new charset. Return the new charset. #else Qnil, 0, 0, 0, 0, Qnil, 0 #endif -); + , 0); CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset; XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset; @@ -1914,6 +2135,14 @@ Recognized properties are those listed in `make-charset', as well as return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj; } #ifdef UTF2000 + if (EQ (prop, Qiso_ir)|| + EQ (prop, Qto_iso_ir)) + { + if ( CHARSET_ISO_IR (cs) > 0 ) + return make_int (CHARSET_ISO_IR (cs)); + else + return Qnil; + } if (EQ (prop, Qmother)) return CHARSET_MOTHER (cs); if (EQ (prop, Qmin_code)) @@ -2068,7 +2297,7 @@ Set mapping-table of CHARSET to TABLE. return table; } -#ifdef HAVE_CHISE_CLIENT +#ifdef HAVE_CHISE DEFUN ("save-charset-mapping-table", Fsave_charset_mapping_table, 1, 1, 0, /* Save mapping-table of CHARSET. */ @@ -2076,15 +2305,34 @@ Save mapping-table of CHARSET. { struct Lisp_Charset *cs; int byte_min, byte_max; +#ifdef HAVE_LIBCHISE + CHISE_CCS dt_ccs; +#else /* HAVE_LIBCHISE */ Lisp_Object db; Lisp_Object db_file; +#endif /* not HAVE_LIBCHISE */ charset = Fget_charset (charset); cs = XCHARSET (charset); +#ifdef HAVE_LIBCHISE + if ( open_chise_data_source_maybe () ) + return -1; + + dt_ccs + = chise_ds_get_ccs (default_chise_data_source, + XSTRING_DATA (Fsymbol_name (XCHARSET_NAME(charset)))); + if (dt_ccs == NULL) + { + printf ("Can't open decoding-table %s\n", + XSTRING_DATA (Fsymbol_name (XCHARSET_NAME(charset)))); + return -1; + } +#else /* HAVE_LIBCHISE */ db_file = char_attribute_system_db_file (CHARSET_NAME (cs), Qsystem_char_id, 1); db = Fopen_database (db_file, Qnil, Qnil, build_string ("w+"), Qnil); +#endif /* not HAVE_LIBCHISE */ byte_min = CHARSET_BYTE_OFFSET (cs); byte_max = byte_min + CHARSET_BYTE_SIZE (cs); @@ -2100,9 +2348,15 @@ Save mapping-table of CHARSET. Lisp_Object c = get_ccs_octet_table (table_c, charset, cell); if (CHARP (c)) - Fput_database (Fprin1_to_string (make_int (cell), Qnil), - Fprin1_to_string (c, Qnil), - db, Qt); + { +#ifdef HAVE_LIBCHISE + chise_ccs_set_decoded_char (dt_ccs, cell, XCHAR (c)); +#else /* HAVE_LIBCHISE */ + Fput_database (Fprin1_to_string (make_int (cell), Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); +#endif /* not HAVE_LIBCHISE */ + } } } break; @@ -2121,11 +2375,19 @@ Save mapping-table of CHARSET. Lisp_Object c = get_ccs_octet_table (table_c, charset, cell); if (CHARP (c)) - Fput_database (Fprin1_to_string (make_int ((row << 8) - | cell), - Qnil), - Fprin1_to_string (c, Qnil), - db, Qt); + { +#ifdef HAVE_LIBCHISE + chise_ccs_set_decoded_char + (dt_ccs, + (row << 8) | cell, XCHAR (c)); +#else /* HAVE_LIBCHISE */ + Fput_database (Fprin1_to_string (make_int ((row << 8) + | cell), + Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); +#endif /* not HAVE_LIBCHISE */ + } } } } @@ -2153,12 +2415,23 @@ Save mapping-table of CHARSET. cell); if (CHARP (c)) - Fput_database (Fprin1_to_string (make_int ((plane << 16) - | (row << 8) - | cell), - Qnil), - Fprin1_to_string (c, Qnil), - db, Qt); + { +#ifdef HAVE_LIBCHISE + chise_ccs_set_decoded_char + (dt_ccs, + (plane << 16) + | (row << 8) + | cell, XCHAR (c)); +#else /* HAVE_LIBCHISE */ + Fput_database (Fprin1_to_string + (make_int ((plane << 16) + | (row << 8) + | cell), + Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); +#endif /* not HAVE_LIBCHISE */ + } } } } @@ -2193,21 +2466,37 @@ Save mapping-table of CHARSET. = get_ccs_octet_table (table_c, charset, cell); if (CHARP (c)) - Fput_database (Fprin1_to_string - (make_int (( group << 24) - | (plane << 16) - | (row << 8) - | cell), - Qnil), - Fprin1_to_string (c, Qnil), - db, Qt); + { +#ifdef HAVE_LIBCHISE + chise_ccs_set_decoded_char + (dt_ccs, + ( group << 24) + | (plane << 16) + | (row << 8) + | cell, XCHAR (c)); +#else /* HAVE_LIBCHISE */ + Fput_database (Fprin1_to_string + (make_int (( group << 24) + | (plane << 16) + | (row << 8) + | cell), + Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); +#endif /* not HAVE_LIBCHISE */ + } } } } } } } +#ifdef HAVE_LIBCHISE + chise_ccs_sync (dt_ccs); + return Qnil; +#else /* HAVE_LIBCHISE */ return Fclose_database (db); +#endif /* not HAVE_LIBCHISE */ } DEFUN ("reset-charset-mapping-table", Freset_charset_mapping_table, 1, 1, 0, /* @@ -2215,13 +2504,35 @@ Reset mapping-table of CCS with database file. */ (ccs)) { +#ifdef HAVE_LIBCHISE + CHISE_CCS chise_ccs; +#else Lisp_Object db_file; +#endif ccs = Fget_charset (ccs); + +#ifdef HAVE_LIBCHISE + if ( open_chise_data_source_maybe () ) + return -1; + + chise_ccs = chise_ds_get_ccs (default_chise_data_source, + XSTRING_DATA (Fsymbol_name + (XCHARSET_NAME(ccs)))); + if (chise_ccs == NULL) + return Qnil; +#else db_file = char_attribute_system_db_file (XCHARSET_NAME(ccs), Qsystem_char_id, 0); +#endif - if (!NILP (Ffile_exists_p (db_file))) + if ( +#ifdef HAVE_LIBCHISE + chise_ccs_setup_db (chise_ccs, 0) == 0 +#else + !NILP (Ffile_exists_p (db_file)) +#endif + ) { XCHARSET_DECODING_TABLE(ccs) = Qunloaded; return Qt; @@ -2232,64 +2543,24 @@ Reset mapping-table of CCS with database file. Emchar load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point) { -#ifdef CHISE - Lisp_Object db_dir = Vexec_directory; - CHISE_DS ds; - CHISE_Decoding_Table *dt_ccs; - int modemask; - int accessmask = 0; - DBTYPE real_subtype; - int status; +#ifdef HAVE_LIBCHISE CHISE_Char_ID char_id; - if (NILP (db_dir)) - db_dir = build_string ("../lib-src"); - db_dir = Fexpand_file_name (build_string ("char-db"), db_dir); - - status = chise_open_data_source (&ds, CHISE_DS_Berkeley_DB, - XSTRING_DATA (db_dir)); - if (status) - { - chise_close_data_source (&ds); - return -1; - } - - modemask = 0755; /* rwxr-xr-x */ - real_subtype = DB_HASH; - accessmask = DB_RDONLY; - - status - = chise_open_decoding_table (&dt_ccs, &ds, - XSTRING_DATA (Fsymbol_name - (XCHARSET_NAME(ccs))), - real_subtype, - accessmask, modemask); - if (status) - { - printf ("Can't open decoding-table %s\n", - XSTRING_DATA (Fsymbol_name (XCHARSET_NAME(ccs)))); - chise_close_decoding_table (dt_ccs); - chise_close_data_source (&ds); - return -1; - } + if ( open_chise_data_source_maybe () ) + return -1; - char_id = chise_dt_get_char (dt_ccs, code_point); - /* - printf ("%s's 0x%X (%d) => 0x%X\n", - XSTRING_DATA (Fsymbol_name (XCHARSET_NAME(ccs))), - code_point, code_point, char_id); - */ + char_id + = chise_ds_decode_char (default_chise_data_source, + XSTRING_DATA(Fsymbol_name (XCHARSET_NAME(ccs))), + code_point); if (char_id >= 0) decoding_table_put_char (ccs, code_point, make_char (char_id)); else decoding_table_put_char (ccs, code_point, Qnil); - chise_close_decoding_table (dt_ccs); - - chise_close_data_source (&ds); - + /* chise_ccst_close (dt_ccs); */ return char_id; -#else +#else /* HAVE_LIBCHISE */ Lisp_Object db; Lisp_Object db_file = char_attribute_system_db_file (XCHARSET_NAME(ccs), Qsystem_char_id, @@ -2315,9 +2586,173 @@ load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point) Fclose_database (db); } return -1; -#endif +#endif /* not HAVE_LIBCHISE */ +} + +#ifdef HAVE_LIBCHISE +DEFUN ("save-charset-properties", Fsave_charset_properties, 1, 1, 0, /* +Save properties of CHARSET. +*/ + (charset)) +{ + struct Lisp_Charset *cs; + CHISE_Property property; + Lisp_Object ccs; + unsigned char* feature_name; + + ccs = Fget_charset (charset); + cs = XCHARSET (ccs); + + if ( open_chise_data_source_maybe () ) + return -1; + + if ( SYMBOLP (charset) && !EQ (charset, XCHARSET_NAME (ccs)) ) + { + property = chise_ds_get_property (default_chise_data_source, + "true-name"); + feature_name = XSTRING_DATA (Fsymbol_name (charset)); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string (CHARSET_NAME (cs), + Qnil))); + chise_property_sync (property); + } + charset = XCHARSET_NAME (ccs); + feature_name = XSTRING_DATA (Fsymbol_name (charset)); + + property = chise_ds_get_property (default_chise_data_source, + "description"); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string + (CHARSET_DOC_STRING (cs), Qnil))); + chise_property_sync (property); + + property = chise_ds_get_property (default_chise_data_source, "type"); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, "CCS"); + chise_property_sync (property); + + property = chise_ds_get_property (default_chise_data_source, "chars"); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string (make_int + (CHARSET_CHARS (cs)), + Qnil))); + chise_property_sync (property); + + property = chise_ds_get_property (default_chise_data_source, "dimension"); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string (make_int + (CHARSET_DIMENSION (cs)), + Qnil))); + chise_property_sync (property); + + if ( CHARSET_FINAL (cs) != 0 ) + { + property = chise_ds_get_property (default_chise_data_source, + "final-byte"); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string (make_int + (CHARSET_FINAL (cs)), + Qnil))); + chise_property_sync (property); + } + + if ( !NILP (CHARSET_MOTHER (cs)) ) + { + Lisp_Object mother = CHARSET_MOTHER (cs); + + if ( CHARSETP (mother) ) + mother = XCHARSET_NAME (mother); + + property = chise_ds_get_property (default_chise_data_source, + "mother"); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string (mother, Qnil))); + chise_property_sync (property); + } + + if ( CHARSET_MAX_CODE (cs) != 0 ) + { + char str[16]; + + property = chise_ds_get_property (default_chise_data_source, + "mother-code-min"); + if ( CHARSET_MIN_CODE (cs) == 0 ) + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, "0"); + else + { + sprintf (str, "#x%X", CHARSET_MIN_CODE (cs)); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, str); + } + chise_property_sync (property); + + property = chise_ds_get_property (default_chise_data_source, + "mother-code-max"); + sprintf (str, "#x%X", CHARSET_MAX_CODE (cs)); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, str); + chise_property_sync (property); + + property = chise_ds_get_property (default_chise_data_source, + "mother-code-offset"); + if ( CHARSET_CODE_OFFSET (cs) == 0 ) + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, "0"); + else + { + sprintf (str, "#x%X", CHARSET_CODE_OFFSET (cs)); + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, str); + } + chise_property_sync (property); + + property = chise_ds_get_property (default_chise_data_source, + "mother-code-conversion"); + if ( CHARSET_CONVERSION (cs) == CONVERSION_IDENTICAL ) + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, "identical"); + else + { + Lisp_Object sym = Qnil; + + if ( CHARSET_CONVERSION (cs) == CONVERSION_94x60 ) + sym = Q94x60; + else if ( CHARSET_CONVERSION (cs) == CONVERSION_94x94x60 ) + sym = Q94x94x60; + else if ( CHARSET_CONVERSION (cs) == CONVERSION_BIG5_1 ) + sym = Qbig5_1; + else if ( CHARSET_CONVERSION (cs) == CONVERSION_BIG5_2 ) + sym = Qbig5_2; + if ( !NILP (sym) ) + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, XSTRING_DATA (Fprin1_to_string (sym, Qnil))); + else + chise_feature_set_property_value + (chise_ds_get_feature (default_chise_data_source, feature_name), + property, "unknown"); + } + chise_property_sync (property); + } + return Qnil; } -#endif /* HAVE_CHISE_CLIENT */ +#endif /* HAVE_LIBCHISE */ + +#endif /* HAVE_CHISE */ #endif /* UTF2000 */ @@ -2326,24 +2761,26 @@ load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point) /************************************************************************/ #ifdef UTF2000 -DEFUN ("decode-char", Fdecode_char, 2, 3, 0, /* +DEFUN ("decode-char", Fdecode_char, 2, 4, 0, /* Make a character from CHARSET and code-point CODE. If DEFINED_ONLY is non-nil, builtin character is not returned. +If WITHOUT_INHERITANCE is non-nil, inherited character is not returned. If corresponding character is not found, nil is returned. */ - (charset, code, defined_only)) + (charset, code, defined_only, without_inheritance)) { int c; charset = Fget_charset (charset); CHECK_INT (code); c = XINT (code); - if (XCHARSET_GRAPHIC (charset) == 1) + if ( (XCHARSET_GRAPHIC (charset) == 0) || + (XCHARSET_GRAPHIC (charset) == 1) ) c &= 0x7F7F7F7F; if (NILP (defined_only)) - c = DECODE_CHAR (charset, c); + c = DECODE_CHAR (charset, c, !NILP (without_inheritance)); else - c = decode_defined_char (charset, c); + c = decode_defined_char (charset, c, !NILP (without_inheritance)); return c >= 0 ? make_char (c) : Qnil; } @@ -2352,13 +2789,14 @@ Make a builtin character from CHARSET and code-point CODE. */ (charset, code)) { - int c; + EMACS_INT c; + Emchar ch; charset = Fget_charset (charset); CHECK_INT (code); if (EQ (charset, Vcharset_latin_viscii)) { - Lisp_Object chr = Fdecode_char (charset, code, Qnil); + Lisp_Object chr = Fdecode_char (charset, code, Qnil, Qnil); Lisp_Object ret; if (!NILP (chr)) @@ -2386,8 +2824,9 @@ Make a builtin character from CHARSET and code-point CODE. if (XCHARSET_GRAPHIC (charset) == 1) c &= 0x7F7F7F7F; #endif - c = decode_builtin_char (charset, c); - return c >= 0 ? make_char (c) : Fdecode_char (charset, code, Qnil); + ch = decode_builtin_char (charset, c); + return + ch >= 0 ? make_char (ch) : Fdecode_char (charset, code, Qnil, Qnil); } #endif @@ -2649,18 +3088,22 @@ syms_of_mule_charset (void) DEFSUBR (Fcharset_id); DEFSUBR (Fset_charset_ccl_program); DEFSUBR (Fset_charset_registry); + #ifdef UTF2000 DEFSUBR (Fcharset_mapping_table); DEFSUBR (Fset_charset_mapping_table); -#ifdef HAVE_CHISE_CLIENT +#ifdef HAVE_CHISE DEFSUBR (Fsave_charset_mapping_table); DEFSUBR (Freset_charset_mapping_table); -#endif - +#ifdef HAVE_LIBCHISE + DEFSUBR (Fsave_charset_properties); +#endif /* HAVE_LIBCHISE */ +#endif /* HAVE_CHISE */ DEFSUBR (Fdecode_char); DEFSUBR (Fdecode_builtin_char); DEFSUBR (Fencode_char); #endif + DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); DEFSUBR (Fchar_octet); @@ -2681,6 +3124,8 @@ syms_of_mule_charset (void) defsymbol (&Qlong_name, "long-name"); defsymbol (&Qiso_ir, "iso-ir"); #ifdef UTF2000 + defsymbol (&Qto_iso_ir, "=>iso-ir"); + defsymbol (&Qpartial, "partial"); defsymbol (&Qmother, "mother"); defsymbol (&Qmin_code, "min-code"); defsymbol (&Qmax_code, "max-code"); @@ -2711,16 +3156,17 @@ syms_of_mule_charset (void) defsymbol (&Qlatin_jisx0201, "latin-jisx0201"); defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5"); defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9"); - defsymbol (&Qmap_jis_x0208_1978, "=jis-x0208-1978"); - defsymbol (&Qmap_gb2312, "=gb2312"); - defsymbol (&Qmap_gb12345, "=gb12345"); - defsymbol (&Qmap_jis_x0208_1983, "=jis-x0208-1983"); - defsymbol (&Qmap_ks_x1001, "=ks-x1001"); - defsymbol (&Qmap_jis_x0212, "=jis-x0212"); - defsymbol (&Qmap_cns11643_1, "=cns11643-1"); - defsymbol (&Qmap_cns11643_2, "=cns11643-2"); + /* defsymbol (&Qrep_jis_x0208_1978, "=jis-x0208@1978"); */ + defsymbol (&Qrep_gb2312, "=gb2312"); + defsymbol (&Qrep_gb12345, "=gb12345"); + defsymbol (&Qrep_jis_x0208_1983, "=jis-x0208@1983"); + defsymbol (&Qrep_ks_x1001, "=ks-x1001"); + defsymbol (&Qrep_jis_x0212, "=jis-x0212"); + defsymbol (&Qrep_cns11643_1, "=cns11643-1"); + defsymbol (&Qrep_cns11643_2, "=cns11643-2"); #ifdef UTF2000 - defsymbol (&Qmap_ucs, "=ucs"); + defsymbol (&Qsystem_char_id, "system-char-id"); + defsymbol (&Qrep_ucs, "=ucs"); defsymbol (&Qucs, "ucs"); defsymbol (&Qucs_bmp, "ucs-bmp"); defsymbol (&Qucs_smp, "ucs-smp"); @@ -2731,9 +3177,9 @@ syms_of_mule_charset (void) defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper"); defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower"); defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper"); - defsymbol (&Qmap_jis_x0208, "=jis-x0208"); - defsymbol (&Qmap_jis_x0208_1990, "=jis-x0208-1990"); - defsymbol (&Qmap_big5, "=big5"); + defsymbol (&Qrep_jis_x0208, "=jis-x0208"); + defsymbol (&Qrep_jis_x0208_1990, "=jis-x0208@1990"); + defsymbol (&Qrep_big5, "=big5"); defsymbol (&Qethiopic_ucs, "ethiopic-ucs"); #endif defsymbol (&Qchinese_big5_1, "chinese-big5-1"); @@ -2791,6 +3237,16 @@ Leading-code of private TYPE9N charset of column-width 1. &Vdefault_coded_charset_priority_list /* Default order of preferred coded-character-sets. */ ); + Vdisplay_coded_charset_priority_use_inheritance = Qt; + DEFVAR_LISP ("display-coded-charset-priority-use-inheritance", + &Vdisplay_coded_charset_priority_use_inheritance /* +If non-nil, use character inheritance. +*/ ); + Vdisplay_coded_charset_priority_use_hierarchy_order = Qt; + DEFVAR_LISP ("display-coded-charset-priority-use-hierarchy-order", + &Vdisplay_coded_charset_priority_use_hierarchy_order /* +If non-nil, prefer nearest character in hierarchy order. +*/ ); #endif } @@ -2805,15 +3261,28 @@ complex_vars_of_mule_charset (void) ease of access. */ #ifdef UTF2000 + staticpro (&Vcharset_system_char_id); + Vcharset_system_char_id = + make_charset (LEADING_BYTE_SYSTEM_CHAR_ID, Qsystem_char_id, 256, 4, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("SCID"), + build_string ("CHAR-ID"), + build_string ("System char-id"), + build_string (""), + 0, + Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_ucs); Vcharset_ucs = - make_charset (LEADING_BYTE_UCS, Qmap_ucs, 256, 4, + make_charset (LEADING_BYTE_UCS, Qrep_ucs, 256, 4, 1, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("UCS"), build_string ("UCS"), build_string ("ISO/IEC 10646"), build_string (""), - Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_UCS, + Qnil, 0, 0xEFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_ucs_bmp); Vcharset_ucs_bmp = make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2, @@ -2822,8 +3291,10 @@ complex_vars_of_mule_charset (void) build_string ("UCS-BMP"), build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"), build_string - ("\\(ISO10646.*-[01]\\|UCS00-0\\|UNICODE[23]?-0\\)"), - Qnil, 0, 0xFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL); + ("\\(ISO10646\\(\\.[0-9]+\\)?-[01]\\|UCS00-0\\|UNICODE[23]?-0\\)"), + - LEADING_BYTE_UCS_BMP, + Qnil, 0, 0xFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_ucs_smp); Vcharset_ucs_smp = make_charset (LEADING_BYTE_UCS_SMP, Qucs_smp, 256, 2, @@ -2832,8 +3303,10 @@ complex_vars_of_mule_charset (void) build_string ("UCS-SMP"), build_string ("ISO/IEC 10646 Group 0 Plane 1 (SMP)"), build_string ("UCS00-1"), + 0, Qnil, MIN_CHAR_SMP, MAX_CHAR_SMP, - MIN_CHAR_SMP, 0, Qnil, CONVERSION_IDENTICAL); + MIN_CHAR_SMP, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_ucs_sip); Vcharset_ucs_sip = make_charset (LEADING_BYTE_UCS_SIP, Qucs_sip, 256, 2, @@ -2842,8 +3315,10 @@ complex_vars_of_mule_charset (void) build_string ("UCS-SIP"), build_string ("ISO/IEC 10646 Group 0 Plane 2 (SIP)"), build_string ("\\(ISO10646.*-2\\|UCS00-2\\)"), + 0, Qnil, MIN_CHAR_SIP, MAX_CHAR_SIP, - MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL); + MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL, + 0); #else # define MIN_CHAR_THAI 0 # define MAX_CHAR_THAI 0 @@ -2860,7 +3335,9 @@ complex_vars_of_mule_charset (void) build_string ("ASCII)"), build_string ("ASCII (ISO646 IRV)"), build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"), - Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_ASCII, + Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_control_1); Vcharset_control_1 = make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1, @@ -2869,7 +3346,9 @@ complex_vars_of_mule_charset (void) build_string ("Control characters"), build_string ("Control characters 128-191"), build_string (""), - Qnil, 0x80, 0x9F, 0x80, 0, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_CONTROL_1, + Qnil, 0x80, 0x9F, 0x80, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_iso8859_1); Vcharset_latin_iso8859_1 = make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1, @@ -2878,7 +3357,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-1 (Latin-1)"), build_string ("ISO8859-1 (Latin-1)"), build_string ("iso8859-1"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_ISO8859_1, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_iso8859_2); Vcharset_latin_iso8859_2 = make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1, @@ -2887,7 +3368,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-2 (Latin-2)"), build_string ("ISO8859-2 (Latin-2)"), build_string ("iso8859-2"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_ISO8859_2, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_iso8859_3); Vcharset_latin_iso8859_3 = make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1, @@ -2896,7 +3379,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-3 (Latin-3)"), build_string ("ISO8859-3 (Latin-3)"), build_string ("iso8859-3"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_ISO8859_3, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_iso8859_4); Vcharset_latin_iso8859_4 = make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1, @@ -2905,7 +3390,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-4 (Latin-4)"), build_string ("ISO8859-4 (Latin-4)"), build_string ("iso8859-4"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_ISO8859_4, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_thai_tis620); Vcharset_thai_tis620 = make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1, @@ -2914,7 +3401,9 @@ complex_vars_of_mule_charset (void) build_string ("TIS620 (Thai)"), build_string ("TIS620.2529 (Thai)"), build_string ("tis620"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_THAI_TIS620, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_greek_iso8859_7); Vcharset_greek_iso8859_7 = make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1, @@ -2923,7 +3412,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-7 (Greek)"), build_string ("ISO8859-7 (Greek)"), build_string ("iso8859-7"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_GREEK_ISO8859_7, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_arabic_iso8859_6); Vcharset_arabic_iso8859_6 = make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1, @@ -2932,7 +3423,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-6 (Arabic)"), build_string ("ISO8859-6 (Arabic)"), build_string ("iso8859-6"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_ARABIC_ISO8859_6, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_hebrew_iso8859_8); Vcharset_hebrew_iso8859_8 = make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1, @@ -2941,10 +3434,12 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-8 (Hebrew)"), build_string ("ISO8859-8 (Hebrew)"), build_string ("iso8859-8"), + - LEADING_BYTE_HEBREW_ISO8859_8, Qnil, 0 /* MIN_CHAR_HEBREW */, 0 /* MAX_CHAR_HEBREW */, 0, 32, - Qnil, CONVERSION_IDENTICAL); + Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_katakana_jisx0201); Vcharset_katakana_jisx0201 = make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1, @@ -2953,7 +3448,9 @@ complex_vars_of_mule_charset (void) build_string ("JISX0201.1976 (Japanese Kana)"), build_string ("JISX0201.1976 Japanese Kana"), build_string ("jisx0201\\.1976"), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_KATAKANA_JISX0201, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_jisx0201); Vcharset_latin_jisx0201 = make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1, @@ -2962,7 +3459,9 @@ complex_vars_of_mule_charset (void) build_string ("JISX0201.1976 (Japanese Roman)"), build_string ("JISX0201.1976 Japanese Roman"), build_string ("jisx0201\\.1976"), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_JISX0201, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_cyrillic_iso8859_5); Vcharset_cyrillic_iso8859_5 = make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1, @@ -2971,7 +3470,9 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-5 (Cyrillic)"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("iso8859-5"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_CYRILLIC_ISO8859_5, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_iso8859_9); Vcharset_latin_iso8859_9 = make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1, @@ -2980,129 +3481,153 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-9 (Latin-5)"), build_string ("ISO8859-9 (Latin-5)"), build_string ("iso8859-9"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_ISO8859_9, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); #ifdef UTF2000 staticpro (&Vcharset_jis_x0208); Vcharset_jis_x0208 = make_charset (LEADING_BYTE_JIS_X0208, - Qmap_jis_x0208, 94, 2, + Qrep_jis_x0208, 94, 2, 2, 0, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("JIS X0208"), build_string ("JIS X0208 Common"), build_string ("JIS X0208 Common part"), build_string ("jisx0208\\.1990"), + - LEADING_BYTE_JAPANESE_JISX0208_1978, Qnil, MIN_CHAR_JIS_X0208_1990, MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33, - Qnil, CONVERSION_94x94); + Qnil, CONVERSION_94x94, + 1); #endif +#if 0 staticpro (&Vcharset_japanese_jisx0208_1978); Vcharset_japanese_jisx0208_1978 = make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, - Qmap_jis_x0208_1978, 94, 2, + Qrep_jis_x0208_1978, 94, 2, 2, 0, '@', CHARSET_LEFT_TO_RIGHT, build_string ("JIS X0208:1978"), build_string ("JIS X0208:1978 (Japanese)"), build_string ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"), build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"), + - LEADING_BYTE_JAPANESE_JISX0208_1978, Qnil, 0, 0, 0, 33, #ifdef UTF2000 Vcharset_jis_x0208, #else Qnil, #endif - CONVERSION_IDENTICAL); + CONVERSION_IDENTICAL, + 0); +#endif staticpro (&Vcharset_chinese_gb2312); Vcharset_chinese_gb2312 = - make_charset (LEADING_BYTE_CHINESE_GB2312, Qmap_gb2312, 94, 2, + make_charset (LEADING_BYTE_CHINESE_GB2312, Qrep_gb2312, 94, 2, 2, 0, 'A', CHARSET_LEFT_TO_RIGHT, build_string ("GB2312"), build_string ("GB2312)"), build_string ("GB2312 Chinese simplified"), build_string ("gb2312"), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_CHINESE_GB2312, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_chinese_gb12345); Vcharset_chinese_gb12345 = - make_charset (LEADING_BYTE_CHINESE_GB12345, Qmap_gb12345, 94, 2, + make_charset (LEADING_BYTE_CHINESE_GB12345, Qrep_gb12345, 94, 2, 2, 0, 0, CHARSET_LEFT_TO_RIGHT, build_string ("G1"), build_string ("GB 12345)"), build_string ("GB 12345-1990"), build_string ("GB12345\\(\\.1990\\)?-0"), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + 0, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_japanese_jisx0208); Vcharset_japanese_jisx0208 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qmap_jis_x0208_1983, 94, 2, + make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qrep_jis_x0208_1983, 94, 2, 2, 0, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0208"), build_string ("JIS X0208:1983 (Japanese)"), build_string ("JIS X0208:1983 Japanese Kanji"), build_string ("jisx0208\\.1983"), + - LEADING_BYTE_JAPANESE_JISX0208, Qnil, 0, 0, 0, 33, #ifdef UTF2000 Vcharset_jis_x0208, #else Qnil, #endif - CONVERSION_IDENTICAL); + CONVERSION_IDENTICAL, + 0); #ifdef UTF2000 staticpro (&Vcharset_japanese_jisx0208_1990); Vcharset_japanese_jisx0208_1990 = make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990, - Qmap_jis_x0208_1990, 94, 2, + Qrep_jis_x0208_1990, 94, 2, 2, 0, 0, CHARSET_LEFT_TO_RIGHT, build_string ("JISX0208-1990"), build_string ("JIS X0208:1990 (Japanese)"), build_string ("JIS X0208:1990 Japanese Kanji"), build_string ("jisx0208\\.1990"), + - LEADING_BYTE_JAPANESE_JISX0208_1990, Qnil, 0x2121 /* MIN_CHAR_JIS_X0208_1990 */, 0x7426 /* MAX_CHAR_JIS_X0208_1990 */, 0 /* MIN_CHAR_JIS_X0208_1990 */, 33, Vcharset_jis_x0208 /* Qnil */, - CONVERSION_IDENTICAL /* CONVERSION_94x94 */); + CONVERSION_IDENTICAL /* CONVERSION_94x94 */, + 0); #endif staticpro (&Vcharset_korean_ksc5601); Vcharset_korean_ksc5601 = - make_charset (LEADING_BYTE_KOREAN_KSC5601, Qmap_ks_x1001, 94, 2, + make_charset (LEADING_BYTE_KOREAN_KSC5601, Qrep_ks_x1001, 94, 2, 2, 0, 'C', CHARSET_LEFT_TO_RIGHT, build_string ("KSC5601"), build_string ("KSC5601 (Korean"), build_string ("KSC5601 Korean Hangul and Hanja"), build_string ("ksc5601"), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_KOREAN_KSC5601, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_japanese_jisx0212); Vcharset_japanese_jisx0212 = - make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qmap_jis_x0212, 94, 2, + make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qrep_jis_x0212, 94, 2, 2, 0, 'D', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0212"), build_string ("JISX0212 (Japanese)"), build_string ("JISX0212 Japanese Supplement"), build_string ("jisx0212"), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_JAPANESE_JISX0212, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$" staticpro (&Vcharset_chinese_cns11643_1); Vcharset_chinese_cns11643_1 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qmap_cns11643_1, 94, 2, + make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qrep_cns11643_1, 94, 2, 2, 0, 'G', CHARSET_LEFT_TO_RIGHT, build_string ("CNS11643-1"), build_string ("CNS11643-1 (Chinese traditional)"), build_string ("CNS 11643 Plane 1 Chinese traditional"), build_string (CHINESE_CNS_PLANE_RE("1")), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_CHINESE_CNS11643_1, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_chinese_cns11643_2); Vcharset_chinese_cns11643_2 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qmap_cns11643_2, 94, 2, + make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qrep_cns11643_2, 94, 2, 2, 0, 'H', CHARSET_LEFT_TO_RIGHT, build_string ("CNS11643-2"), build_string ("CNS11643-2 (Chinese traditional)"), build_string ("CNS 11643 Plane 2 Chinese traditional"), build_string (CHINESE_CNS_PLANE_RE("2")), - Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_CHINESE_CNS11643_2, + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL, + 0); #ifdef UTF2000 staticpro (&Vcharset_latin_tcvn5712); Vcharset_latin_tcvn5712 = @@ -3112,7 +3637,9 @@ complex_vars_of_mule_charset (void) build_string ("TCVN 5712 (VSCII-2)"), build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"), build_string ("tcvn5712\\(\\.1993\\)?-1"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + - LEADING_BYTE_LATIN_TCVN5712, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_viscii_lower); Vcharset_latin_viscii_lower = make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1, @@ -3121,7 +3648,9 @@ complex_vars_of_mule_charset (void) build_string ("VISCII lower (Vietnamese)"), build_string ("VISCII lower (Vietnamese)"), build_string ("MULEVISCII-LOWER"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + 0, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_viscii_upper); Vcharset_latin_viscii_upper = make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1, @@ -3130,7 +3659,9 @@ complex_vars_of_mule_charset (void) build_string ("VISCII upper (Vietnamese)"), build_string ("VISCII upper (Vietnamese)"), build_string ("MULEVISCII-UPPER"), - Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + 0, + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_latin_viscii); Vcharset_latin_viscii = make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1, @@ -3139,18 +3670,22 @@ complex_vars_of_mule_charset (void) build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII1\\.1"), - Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL); + 0, + Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_chinese_big5); Vcharset_chinese_big5 = - make_charset (LEADING_BYTE_CHINESE_BIG5, Qmap_big5, 256, 2, + make_charset (LEADING_BYTE_CHINESE_BIG5, Qrep_big5, 256, 2, 2, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Big5"), build_string ("Big5"), build_string ("Big5 Chinese traditional"), build_string ("big5-0"), + 0, Qnil, MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP, - MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL); + MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL, + 0); staticpro (&Vcharset_ethiopic_ucs); Vcharset_ethiopic_ucs = @@ -3160,8 +3695,10 @@ complex_vars_of_mule_charset (void) build_string ("Ethiopic (UCS)"), build_string ("Ethiopic of UCS"), build_string ("Ethiopic-Unicode"), + 0, Qnil, 0x1200, 0x137F, 0, 0, - Qnil, CONVERSION_IDENTICAL); + Qnil, CONVERSION_IDENTICAL, + 0); #endif staticpro (&Vcharset_chinese_big5_1); Vcharset_chinese_big5_1 = @@ -3172,8 +3709,10 @@ complex_vars_of_mule_charset (void) build_string ("Big5 Level-1 Chinese traditional"), build_string ("big5"), + 0, Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */ - Vcharset_chinese_big5, CONVERSION_BIG5_1); + Vcharset_chinese_big5, CONVERSION_BIG5_1, + 0); staticpro (&Vcharset_chinese_big5_2); Vcharset_chinese_big5_2 = make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2, @@ -3183,8 +3722,10 @@ complex_vars_of_mule_charset (void) build_string ("Big5 Level-2 Chinese traditional"), build_string ("big5"), + 0, Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */ - Vcharset_chinese_big5, CONVERSION_BIG5_2); + Vcharset_chinese_big5, CONVERSION_BIG5_2, + 0); #ifdef ENABLE_COMPOSITE_CHARS /* #### For simplicity, we put composite chars into a 96x96 charset.