X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=91376d7f242574ab819526af348b4e33a1c3d441;hb=4f29597e4f3696a59bb08ffece07183c1568c4a5;hp=1d148f4e30c7d2080c4437aa091f352d1311d521;hpb=6c3579d1d3d6132c2759bf5fede210eac64c21a1;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index 1d148f4..91376d7 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -1,6 +1,7 @@ /* Functions to handle multilingual characters. Copyright (C) 1992, 1995 Free Software Foundation, Inc. Copyright (C) 1995 Sun Microsystems, Inc. + Copyright (C) 1999,2000 MORIOKA Tomohiko This file is part of XEmacs. @@ -59,11 +60,35 @@ Lisp_Object Vcharset_japanese_jisx0212; Lisp_Object Vcharset_chinese_cns11643_1; Lisp_Object Vcharset_chinese_cns11643_2; #ifdef UTF2000 +Lisp_Object Vcharset_ucs; Lisp_Object Vcharset_ucs_bmp; Lisp_Object Vcharset_latin_viscii; +Lisp_Object Vcharset_latin_tcvn5712; Lisp_Object Vcharset_latin_viscii_lower; Lisp_Object Vcharset_latin_viscii_upper; Lisp_Object Vcharset_ideograph_daikanwa; +Lisp_Object Vcharset_mojikyo; +Lisp_Object Vcharset_mojikyo_pj_1; +Lisp_Object Vcharset_mojikyo_pj_2; +Lisp_Object Vcharset_mojikyo_pj_3; +Lisp_Object Vcharset_mojikyo_pj_4; +Lisp_Object Vcharset_mojikyo_pj_5; +Lisp_Object Vcharset_mojikyo_pj_6; +Lisp_Object Vcharset_mojikyo_pj_7; +Lisp_Object Vcharset_mojikyo_pj_8; +Lisp_Object Vcharset_mojikyo_pj_9; +Lisp_Object Vcharset_mojikyo_pj_10; +Lisp_Object Vcharset_mojikyo_pj_11; +Lisp_Object Vcharset_mojikyo_pj_12; +Lisp_Object Vcharset_mojikyo_pj_13; +Lisp_Object Vcharset_mojikyo_pj_14; +Lisp_Object Vcharset_mojikyo_pj_15; +Lisp_Object Vcharset_mojikyo_pj_16; +Lisp_Object Vcharset_mojikyo_pj_17; +Lisp_Object Vcharset_mojikyo_pj_18; +Lisp_Object Vcharset_mojikyo_pj_19; +Lisp_Object Vcharset_mojikyo_pj_20; +Lisp_Object Vcharset_mojikyo_pj_21; Lisp_Object Vcharset_ethiopic_ucs; #endif Lisp_Object Vcharset_chinese_big5_1; @@ -83,15 +108,22 @@ static int composite_char_col_next; #endif /* ENABLE_COMPOSITE_CHARS */ -/* Table of charsets indexed by leading byte. */ -Lisp_Object charset_by_leading_byte[NUM_LEADING_BYTES]; +struct charset_lookup *chlook; -/* Table of charsets indexed by type/final-byte/direction. */ +static const struct lrecord_description charset_lookup_description_1[] = { + { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), #ifdef UTF2000 -Lisp_Object charset_by_attributes[4][128]; + 128+4*128 #else -Lisp_Object charset_by_attributes[4][128][2]; + 128+4*128*2 #endif + }, { XD_END } +}; + +static const struct struct_description charset_lookup_description = { + sizeof (struct charset_lookup), + charset_lookup_description_1 +}; #ifndef UTF2000 /* Table of number of bytes in the string representation of a character @@ -100,9 +132,9 @@ Lisp_Object charset_by_attributes[4][128][2]; rep_bytes_by_first_byte(c) is more efficient than the equivalent canonical computation: - (BYTE_ASCII_P (c) ? 1 : XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c))) */ + XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */ -Bytecount rep_bytes_by_first_byte[0xA0] = +const Bytecount rep_bytes_by_first_byte[0xA0] = { /* 0x00 - 0x7f are for straight ASCII */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -128,32 +160,32 @@ Bytecount rep_bytes_by_first_byte[0xA0] = #ifdef UTF2000 static Lisp_Object -mark_char_byte_table (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_byte_table (Lisp_Object obj) { - struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj); + Lisp_Byte_Table *cte = XBYTE_TABLE (obj); int i; for (i = 0; i < 256; i++) { - markobj (cte->property[i]); + mark_object (cte->property[i]); } return Qnil; } static int -char_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) +byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) { - struct Lisp_Char_Byte_Table *cte1 = XCHAR_BYTE_TABLE (obj1); - struct Lisp_Char_Byte_Table *cte2 = XCHAR_BYTE_TABLE (obj2); + Lisp_Byte_Table *cte1 = XBYTE_TABLE (obj1); + Lisp_Byte_Table *cte2 = XBYTE_TABLE (obj2); int i; for (i = 0; i < 256; i++) - if (CHAR_BYTE_TABLE_P (cte1->property[i])) + if (BYTE_TABLE_P (cte1->property[i])) { - if (CHAR_BYTE_TABLE_P (cte2->property[i])) + if (BYTE_TABLE_P (cte2->property[i])) { - if (!char_byte_table_equal (cte1->property[i], - cte2->property[i], depth + 1)) + if (!byte_table_equal (cte1->property[i], + cte2->property[i], depth + 1)) return 0; } else @@ -166,226 +198,253 @@ char_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) } static unsigned long -char_byte_table_hash (Lisp_Object obj, int depth) +byte_table_hash (Lisp_Object obj, int depth) { - struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj); + Lisp_Byte_Table *cte = XBYTE_TABLE (obj); return internal_array_hash (cte->property, 256, depth); } -static const struct lrecord_description char_byte_table_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Byte_Table, property), 256 }, +static const struct lrecord_description byte_table_description[] = { + { XD_LISP_OBJECT_ARRAY, offsetof(Lisp_Byte_Table, property), 256 }, { XD_END } }; -DEFINE_LRECORD_IMPLEMENTATION ("char-byte-table", char_byte_table, - mark_char_byte_table, +DEFINE_LRECORD_IMPLEMENTATION ("byte-table", byte_table, + mark_byte_table, internal_object_printer, - 0, char_byte_table_equal, - char_byte_table_hash, - char_byte_table_description, - struct Lisp_Char_Byte_Table); + 0, byte_table_equal, + byte_table_hash, + byte_table_description, + Lisp_Byte_Table); static Lisp_Object -make_char_byte_table (Lisp_Object initval) +make_byte_table (Lisp_Object initval, int older) { Lisp_Object obj; int i; - struct Lisp_Char_Byte_Table *cte = - alloc_lcrecord_type (struct Lisp_Char_Byte_Table, - &lrecord_char_byte_table); + Lisp_Byte_Table *cte; + + if (older) + cte = alloc_older_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table); + else + cte = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table); for (i = 0; i < 256; i++) cte->property[i] = initval; - XSETCHAR_BYTE_TABLE (obj, cte); + XSETBYTE_TABLE (obj, cte); return obj; } static Lisp_Object -copy_char_byte_table (Lisp_Object entry) +copy_byte_table (Lisp_Object entry) { - struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (entry); + Lisp_Byte_Table *cte = XBYTE_TABLE (entry); Lisp_Object obj; int i; - struct Lisp_Char_Byte_Table *ctenew = - alloc_lcrecord_type (struct Lisp_Char_Byte_Table, - &lrecord_char_byte_table); + Lisp_Byte_Table *ctenew + = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table); for (i = 0; i < 256; i++) { Lisp_Object new = cte->property[i]; - if (CHAR_BYTE_TABLE_P (new)) - ctenew->property[i] = copy_char_byte_table (new); + if (BYTE_TABLE_P (new)) + ctenew->property[i] = copy_byte_table (new); else ctenew->property[i] = new; } - XSETCHAR_BYTE_TABLE (obj, ctenew); + XSETBYTE_TABLE (obj, ctenew); return obj; } static Lisp_Object -mark_char_code_table (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_char_id_table (Lisp_Object obj) { - struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (obj); + Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); return cte->table; } static int -char_code_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) +char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) { - struct Lisp_Char_Code_Table *cte1 = XCHAR_CODE_TABLE (obj1); - struct Lisp_Char_Code_Table *cte2 = XCHAR_CODE_TABLE (obj2); + Lisp_Char_ID_Table *cte1 = XCHAR_ID_TABLE (obj1); + Lisp_Char_ID_Table *cte2 = XCHAR_ID_TABLE (obj2); - return char_byte_table_equal (cte1->table, cte2->table, depth + 1); + return byte_table_equal (cte1->table, cte2->table, depth + 1); } static unsigned long -char_code_table_hash (Lisp_Object obj, int depth) +char_id_table_hash (Lisp_Object obj, int depth) { - struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (obj); + Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); - return char_code_table_hash (cte->table, depth + 1); + return char_id_table_hash (cte->table, depth + 1); } -static const struct lrecord_description char_code_table_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Code_Table, table), 1 }, +static const struct lrecord_description char_id_table_description[] = { + { XD_LISP_OBJECT, offsetof(Lisp_Char_ID_Table, table) }, { XD_END } }; -DEFINE_LRECORD_IMPLEMENTATION ("char-code-table", char_code_table, - mark_char_code_table, +DEFINE_LRECORD_IMPLEMENTATION ("char-id-table", char_id_table, + mark_char_id_table, internal_object_printer, - 0, char_code_table_equal, - char_code_table_hash, - char_code_table_description, - struct Lisp_Char_Code_Table); + 0, char_id_table_equal, + char_id_table_hash, + char_id_table_description, + Lisp_Char_ID_Table); static Lisp_Object -make_char_code_table (Lisp_Object initval) +make_char_id_table (Lisp_Object initval, int older) { Lisp_Object obj; - struct Lisp_Char_Code_Table *cte = - alloc_lcrecord_type (struct Lisp_Char_Code_Table, - &lrecord_char_code_table); + Lisp_Char_ID_Table *cte; + + if (older) + cte = alloc_older_lcrecord_type (Lisp_Char_ID_Table, + &lrecord_char_id_table); + else + cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); - cte->table = make_char_byte_table (initval); + cte->table = make_byte_table (initval, older); - XSETCHAR_CODE_TABLE (obj, cte); + XSETCHAR_ID_TABLE (obj, cte); return obj; } +/* not used */ +#if 0 static Lisp_Object -copy_char_code_table (Lisp_Object entry) +copy_char_id_table (Lisp_Object entry) { - struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (entry); + Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (entry); Lisp_Object obj; - struct Lisp_Char_Code_Table *ctenew = - alloc_lcrecord_type (struct Lisp_Char_Code_Table, - &lrecord_char_code_table); + Lisp_Char_ID_Table *ctenew + = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); - ctenew->table = copy_char_byte_table (cte->table); - XSETCHAR_CODE_TABLE (obj, ctenew); + ctenew->table = copy_byte_table (cte->table); + XSETCHAR_ID_TABLE (obj, ctenew); return obj; } +#endif Lisp_Object -get_char_code_table (Emchar ch, Lisp_Object table) +get_char_id_table (Emchar ch, Lisp_Object table) { unsigned int code = ch; - struct Lisp_Char_Byte_Table* cpt - = XCHAR_BYTE_TABLE (XCHAR_CODE_TABLE (table)->table); + Lisp_Byte_Table* cpt + = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table); Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)]; - if (CHAR_BYTE_TABLE_P (ret)) - cpt = XCHAR_BYTE_TABLE (ret); + if (BYTE_TABLE_P (ret)) + cpt = XBYTE_TABLE (ret); else return ret; ret = cpt->property [(unsigned char) (code >> 16)]; - if (CHAR_BYTE_TABLE_P (ret)) - cpt = XCHAR_BYTE_TABLE (ret); + if (BYTE_TABLE_P (ret)) + cpt = XBYTE_TABLE (ret); else return ret; ret = cpt->property [(unsigned char) (code >> 8)]; - if (CHAR_BYTE_TABLE_P (ret)) - cpt = XCHAR_BYTE_TABLE (ret); + if (BYTE_TABLE_P (ret)) + cpt = XBYTE_TABLE (ret); else return ret; return cpt->property [(unsigned char) code]; } +void put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table); void -put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table) +put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table) { unsigned int code = ch; - struct Lisp_Char_Byte_Table* cpt1 - = XCHAR_BYTE_TABLE (XCHAR_CODE_TABLE (table)->table); + Lisp_Byte_Table* cpt1 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table); Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)]; - if (CHAR_BYTE_TABLE_P (ret)) + if (BYTE_TABLE_P (ret)) { - struct Lisp_Char_Byte_Table* cpt2 = XCHAR_BYTE_TABLE (ret); + Lisp_Byte_Table* cpt2 = XBYTE_TABLE (ret); ret = cpt2->property[(unsigned char)(code >> 16)]; - if (CHAR_BYTE_TABLE_P (ret)) + if (BYTE_TABLE_P (ret)) { - struct Lisp_Char_Byte_Table* cpt3 = XCHAR_BYTE_TABLE (ret); + Lisp_Byte_Table* cpt3 = XBYTE_TABLE (ret); ret = cpt3->property[(unsigned char)(code >> 8)]; - if (CHAR_BYTE_TABLE_P (ret)) + if (BYTE_TABLE_P (ret)) { - struct Lisp_Char_Byte_Table* cpt4 - = XCHAR_BYTE_TABLE (ret); + Lisp_Byte_Table* cpt4 = XBYTE_TABLE (ret); cpt4->property[(unsigned char)code] = value; } else if (!EQ (ret, value)) { - Lisp_Object cpt4 = make_char_byte_table (ret); - - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; + Lisp_Object cpt4 + = make_byte_table (ret, OLDER_RECORD_P (table)); + + XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value; cpt3->property[(unsigned char)(code >> 8)] = cpt4; } } else if (!EQ (ret, value)) { - Lisp_Object cpt3 = make_char_byte_table (ret); - Lisp_Object cpt4 = make_char_byte_table (ret); - - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] + int older = OLDER_RECORD_P (table); + Lisp_Object cpt3 = make_byte_table (ret, older); + Lisp_Object cpt4 = make_byte_table (ret, older); + + XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value; + XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4; cpt2->property[(unsigned char)(code >> 16)] = cpt3; } } else if (!EQ (ret, value)) { - Lisp_Object cpt2 = make_char_byte_table (ret); - Lisp_Object cpt3 = make_char_byte_table (ret); - Lisp_Object cpt4 = make_char_byte_table (ret); - - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4; - XCHAR_BYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3; + int older = OLDER_RECORD_P (table); + Lisp_Object cpt2 = make_byte_table (ret, older); + Lisp_Object cpt3 = make_byte_table (ret, older); + Lisp_Object cpt4 = make_byte_table (ret, older); + + XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value; + XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4; + XBYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3; cpt1->property[(unsigned char)(code >> 24)] = cpt2; } } Lisp_Object Vcharacter_attribute_table; +Lisp_Object Vcharacter_name_table; +Lisp_Object Vcharacter_ideographic_radical_table; +Lisp_Object Vcharacter_ideographic_strokes_table; +Lisp_Object Vcharacter_total_strokes_table; +Lisp_Object Vcharacter_morohashi_daikanwa_table; +Lisp_Object Vcharacter_decomposition_table; Lisp_Object Vcharacter_composition_table; Lisp_Object Vcharacter_variant_table; +Lisp_Object Qname; +Lisp_Object Qideographic_radical, Qideographic_strokes; +Lisp_Object Qtotal_strokes; +Lisp_Object Qmorohashi_daikanwa; +Lisp_Object Qideograph_daikanwa; Lisp_Object Q_decomposition; +Lisp_Object Qucs; Lisp_Object Q_ucs; Lisp_Object Qcompat; +Lisp_Object Qisolated; +Lisp_Object Qinitial; +Lisp_Object Qmedial; +Lisp_Object Qfinal; +Lisp_Object Qvertical; Lisp_Object QnoBreak; Lisp_Object Qfraction; Lisp_Object Qsuper; @@ -394,10 +453,23 @@ Lisp_Object Qcircle; Lisp_Object Qsquare; Lisp_Object Qwide; Lisp_Object Qnarrow; +Lisp_Object Qsmall; Lisp_Object Qfont; +Emchar to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg); + +Lisp_Object put_char_ccs_code_point (Lisp_Object character, + Lisp_Object ccs, Lisp_Object value); +Lisp_Object remove_char_ccs (Lisp_Object character, Lisp_Object ccs); + +Lisp_Object put_char_attribute (Lisp_Object character, + Lisp_Object attribute, Lisp_Object value); +Lisp_Object remove_char_attribute (Lisp_Object character, + Lisp_Object attribute); + + Emchar -to_char_code (Lisp_Object v, char* err_msg, Lisp_Object err_arg) +to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg) { if (INTP (v)) return XINT (v); @@ -405,24 +477,36 @@ to_char_code (Lisp_Object v, char* err_msg, Lisp_Object err_arg) return XCHAR (v); else if (EQ (v, Qcompat)) return -1; - else if (EQ (v, QnoBreak)) + else if (EQ (v, Qisolated)) return -2; - else if (EQ (v, Qfraction)) + else if (EQ (v, Qinitial)) return -3; - else if (EQ (v, Qsuper)) + else if (EQ (v, Qmedial)) return -4; - else if (EQ (v, Qsub)) + else if (EQ (v, Qfinal)) return -5; - else if (EQ (v, Qcircle)) + else if (EQ (v, Qvertical)) return -6; - else if (EQ (v, Qsquare)) + else if (EQ (v, QnoBreak)) return -7; - else if (EQ (v, Qwide)) + else if (EQ (v, Qfraction)) return -8; - else if (EQ (v, Qnarrow)) + else if (EQ (v, Qsuper)) return -9; - else if (EQ (v, Qfont)) + else if (EQ (v, Qsub)) return -10; + else if (EQ (v, Qcircle)) + return -11; + else if (EQ (v, Qsquare)) + return -12; + else if (EQ (v, Qwide)) + return -13; + else if (EQ (v, Qnarrow)) + return -14; + else if (EQ (v, Qsmall)) + return -15; + else if (EQ (v, Qfont)) + return -16; else signal_simple_error (err_msg, err_arg); } @@ -439,21 +523,21 @@ Return character corresponding with list. { Lisp_Object v = Fcar (rest); Lisp_Object ret; - Emchar c = to_char_code (v, "Invalid value for composition", list); + Emchar c = to_char_id (v, "Invalid value for composition", list); - ret = get_char_code_table (c, table); + ret = get_char_id_table (c, table); rest = Fcdr (rest); if (NILP (rest)) { - if (!CHAR_CODE_TABLE_P (ret)) + if (!CHAR_ID_TABLE_P (ret)) return ret; else return Qt; } else if (!CONSP (rest)) break; - else if (CHAR_CODE_TABLE_P (ret)) + else if (CHAR_ID_TABLE_P (ret)) table = ret; else signal_simple_error ("Invalid table is found with", list); @@ -467,8 +551,8 @@ Return variants of CHARACTER. (character)) { CHECK_CHAR (character); - return Fcopy_list (get_char_code_table (XCHAR (character), - Vcharacter_variant_table)); + return Fcopy_list (get_char_id_table (XCHAR (character), + Vcharacter_variant_table)); } DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /* @@ -476,9 +560,68 @@ Return the alist of attributes of CHARACTER. */ (character)) { + Lisp_Object alist, ret; + int i; + CHECK_CHAR (character); - return Fcopy_alist (get_char_code_table (XCHAR (character), - Vcharacter_attribute_table)); + alist = Fcopy_alist (get_char_id_table (XCHAR (character), + Vcharacter_attribute_table)); + + ret = get_char_id_table (XCHAR (character), Vcharacter_name_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qname, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_ideographic_radical_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qideographic_radical, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_ideographic_strokes_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qideographic_strokes, ret), alist); + + ret = get_char_id_table (XCHAR (character), Vcharacter_total_strokes_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qtotal_strokes, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_morohashi_daikanwa_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Qmorohashi_daikanwa, ret), alist); + + ret = get_char_id_table (XCHAR (character), + Vcharacter_decomposition_table); + if (!NILP (ret)) + alist = Fcons (Fcons (Q_decomposition, ret), alist); + + for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) + { + Lisp_Object ccs = chlook->charset_by_leading_byte[i]; + + if (!NILP (ccs)) + { +#if 0 + int code_point = charset_code_point (ccs, XCHAR (character)); + + if (code_point >= 0) + { + alist = Fcons (Fcons (ccs, make_int (code_point)), alist); + } +#else + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); + Lisp_Object cpos; + + if ( CHAR_ID_TABLE_P (encoding_table) + && INTP (cpos = get_char_id_table (XCHAR (character), + encoding_table)) ) + { + alist = Fcons (Fcons (ccs, cpos), alist); + } +#endif + } + } + return alist; } DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /* @@ -486,44 +629,59 @@ Return the value of CHARACTER's ATTRIBUTE. */ (character, attribute)) { - Lisp_Object ret; Lisp_Object ccs; CHECK_CHAR (character); - ret = get_char_code_table (XCHAR (character), - Vcharacter_attribute_table); - if (EQ (ret, Qnil)) - return Qnil; - if (!NILP (ccs = Ffind_charset (attribute))) - attribute = ccs; - - return Fcdr (Fassq (attribute, ret)); -} - -Lisp_Object -put_char_attribute (Lisp_Object character, Lisp_Object attribute, - Lisp_Object value) -{ - Emchar char_code = XCHAR (character); - Lisp_Object ret - = get_char_code_table (char_code, Vcharacter_attribute_table); - Lisp_Object cell; - - cell = Fassq (attribute, ret); + { + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); - if (NILP (cell)) + if (CHAR_ID_TABLE_P (encoding_table)) + return get_char_id_table (XCHAR (character), encoding_table); + else + return Qnil; + } + else if (EQ (attribute, Qname)) { - ret = Fcons (Fcons (attribute, value), ret); + return get_char_id_table (XCHAR (character), Vcharacter_name_table); } - else if (!EQ (Fcdr (cell), value)) + else if (EQ (attribute, Qideographic_radical)) { - Fsetcdr (cell, value); + return get_char_id_table (XCHAR (character), + Vcharacter_ideographic_radical_table); + } + else if (EQ (attribute, Qideographic_strokes)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_ideographic_strokes_table); + } + else if (EQ (attribute, Qtotal_strokes)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_total_strokes_table); + } + else if (EQ (attribute, Qmorohashi_daikanwa)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_morohashi_daikanwa_table); + } + else if (EQ (attribute, Q_decomposition)) + { + return get_char_id_table (XCHAR (character), + Vcharacter_decomposition_table); + } + else + { + Lisp_Object ret + = get_char_id_table (XCHAR (character), Vcharacter_attribute_table); + + if (EQ (ret, Qnil)) + return Qnil; + else + return Fcdr (Fassq (attribute, ret)); } - put_char_code_table (char_code, ret, Vcharacter_attribute_table); - return ret; } - + DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /* Store CHARACTER's ATTRIBUTE with VALUE. */ @@ -535,141 +693,403 @@ Store CHARACTER's ATTRIBUTE with VALUE. ccs = Ffind_charset (attribute); if (!NILP (ccs)) { - Lisp_Object rest; - Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); - Lisp_Object nv; - int i = -1; - int ccs_len; + return put_char_ccs_code_point (character, ccs, value); + } + else if (EQ (attribute, Qname)) + { + CHECK_STRING (value); + put_char_id_table (XCHAR (character), value, Vcharacter_name_table); + return value; + } + else if (EQ (attribute, Qideographic_radical)) + { + CHECK_INT (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_ideographic_radical_table); + return value; + } + else if (EQ (attribute, Qideographic_strokes)) + { + CHECK_INT (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_ideographic_strokes_table); + return value; + } + else if (EQ (attribute, Qtotal_strokes)) + { + CHECK_INT (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_total_strokes_table); + return value; + } + else if (EQ (attribute, Qmorohashi_daikanwa)) + { + CHECK_LIST (value); + put_char_id_table (XCHAR (character), value, + Vcharacter_morohashi_daikanwa_table); + return value; + } + else if (EQ (attribute, Q_decomposition)) + { + Lisp_Object seq; - /* ad-hoc method for `ascii' */ - if ((XCHARSET_CHARS (ccs) == 94) && - (XCHARSET_BYTE_OFFSET (ccs) != 33)) - ccs_len = 128 - XCHARSET_BYTE_OFFSET (ccs); - else - ccs_len = XCHARSET_CHARS (ccs); - if (!CONSP (value)) - signal_simple_error ("Invalid value for coded-charset", + signal_simple_error ("Invalid value for ->decomposition", value); - attribute = ccs; - rest = Fget_char_attribute (character, attribute); - if (VECTORP (v)) + if (CONSP (Fcdr (value))) { - if (!NILP (rest)) + Lisp_Object rest = value; + Lisp_Object table = Vcharacter_composition_table; + size_t len; + int i = 0; + + GET_EXTERNAL_LIST_LENGTH (rest, len); + seq = make_older_vector (len, Qnil); + + while (CONSP (rest)) { - while (!NILP (rest)) + Lisp_Object v = Fcar (rest); + Lisp_Object ntable; + Emchar c + = to_char_id (v, "Invalid value for ->decomposition", value); + + if (c < 0) + XVECTOR_DATA(seq)[i++] = v; + else + XVECTOR_DATA(seq)[i++] = make_char (c); + rest = Fcdr (rest); + if (!CONSP (rest)) + { + put_char_id_table (c, character, table); + break; + } + else { - Lisp_Object ei = Fcar (rest); - - i = XINT (ei) - XCHARSET_BYTE_OFFSET (ccs); - nv = XVECTOR_DATA(v)[i]; - if (!VECTORP (nv)) - break; - v = nv; - rest = Fcdr (rest); + ntable = get_char_id_table (c, table); + if (!CHAR_ID_TABLE_P (ntable)) + { + ntable + = make_char_id_table (Qnil, OLDER_RECORD_P (table)); + put_char_id_table (c, ntable, table); + } + table = ntable; } - if (i >= 0) - XVECTOR_DATA(v)[i] = Qnil; - v = XCHARSET_DECODING_TABLE (ccs); } } else { - XCHARSET_DECODING_TABLE (ccs) = v = make_vector (ccs_len, Qnil); - } + Lisp_Object v = Fcar (value); - if (XCHARSET_GRAPHIC (ccs) == 1) - value = Fcopy_list (value); - rest = value; - i = -1; - while (CONSP (rest)) - { - Lisp_Object ei = Fcar (rest); - - if (!INTP (ei)) - signal_simple_error ("Invalid value for coded-charset", value); - i = XINT (ei); - if ((i < 0) || (255 < i)) - signal_simple_error ("Invalid value for coded-charset", value); - if (XCHARSET_GRAPHIC (ccs) == 1) + if (INTP (v)) { - i &= 0x7F; - Fsetcar (rest, make_int (i)); - } - i -= XCHARSET_BYTE_OFFSET (ccs); - nv = XVECTOR_DATA(v)[i]; - rest = Fcdr (rest); - if (CONSP (rest)) - { - if (!VECTORP (nv)) + Emchar c = XINT (v); + Lisp_Object ret + = get_char_id_table (c, Vcharacter_variant_table); + + if (NILP (Fmemq (v, ret))) { - nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil)); + put_char_id_table (c, Fcons (character, ret), + Vcharacter_variant_table); } - v = nv; } - else - break; + seq = make_older_vector (1, v); } - XVECTOR_DATA(v)[i] = character; + put_char_id_table (XCHAR (character), seq, + Vcharacter_decomposition_table); + return value; } - else if (EQ (attribute, Q_decomposition)) + else if (EQ (attribute, Q_ucs)) { - Lisp_Object rest = value; - Lisp_Object table = Vcharacter_composition_table; + Lisp_Object ret; + Emchar c; - if (!CONSP (value)) - signal_simple_error ("Invalid value for ->decomposition", - value); + if (!INTP (value)) + signal_simple_error ("Invalid value for ->ucs", value); - while (CONSP (rest)) + c = XINT (value); + + ret = get_char_id_table (c, Vcharacter_variant_table); + if (NILP (Fmemq (character, ret))) { - Lisp_Object v = Fcar (rest); - Lisp_Object ntable; - Emchar c - = to_char_code (v, "Invalid value for ->decomposition", value); + put_char_id_table (c, Fcons (character, ret), + Vcharacter_variant_table); + } + } + return put_char_attribute (character, attribute, value); +} + +DEFUN ("remove-char-attribute", Fremove_char_attribute, 2, 2, 0, /* +Remove CHARACTER's ATTRIBUTE. +*/ + (character, attribute)) +{ + Lisp_Object ccs; - rest = Fcdr (rest); - if (!CONSP (rest)) + CHECK_CHAR (character); + ccs = Ffind_charset (attribute); + if (!NILP (ccs)) + { + return remove_char_ccs (character, ccs); + } + return remove_char_attribute (character, attribute); +} + +INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs); +INLINE_HEADER int +CHARSET_BYTE_SIZE (Lisp_Charset* cs) +{ + /* ad-hoc method for `ascii' */ + if ((CHARSET_CHARS (cs) == 94) && + (CHARSET_BYTE_OFFSET (cs) != 33)) + return 128 - CHARSET_BYTE_OFFSET (cs); + else + return CHARSET_CHARS (cs); +} + +#define XCHARSET_BYTE_SIZE(ccs) CHARSET_BYTE_SIZE (XCHARSET (ccs)) + +int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len); +int +decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len) +{ + int i; + + if (XVECTOR_LENGTH (v) > ccs_len) + return -1; + + for (i = 0; i < XVECTOR_LENGTH (v); i++) + { + Lisp_Object c = XVECTOR_DATA(v)[i]; + + if (!NILP (c) && !CHARP (c)) + { + if (VECTORP (c)) { - put_char_code_table (c, character, table); - break; + int ret = decoding_table_check_elements (c, dim - 1, ccs_len); + if (ret) + return ret; } else + return -2; + } + } + return 0; +} + +INLINE_HEADER void +decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset, + int code_point); +INLINE_HEADER void +decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset, + int code_point) +{ + int i = -1; + + while (dim > 0) + { + Lisp_Object nv; + + dim--; + i = ((code_point >> (8 * dim)) & 255) - byte_offset; + nv = XVECTOR_DATA(v)[i]; + if (!VECTORP (nv)) + break; + v = nv; + } + if (i >= 0) + XVECTOR_DATA(v)[i] = Qnil; +} + +INLINE_HEADER void +decoding_table_put_char (Lisp_Object v, int dim, int byte_offset, + int code_point, Lisp_Object character); +INLINE_HEADER void +decoding_table_put_char (Lisp_Object v, int dim, int byte_offset, + int code_point, Lisp_Object character) +{ + 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)) + nv = (XVECTOR_DATA(v)[i] = make_older_vector (ccs_len, Qnil)); + v = nv; + } + else + break; + } + XVECTOR_DATA(v)[i] = character; +} + +Lisp_Object +put_char_ccs_code_point (Lisp_Object character, + Lisp_Object ccs, Lisp_Object value) +{ + Lisp_Object encoding_table; + + if (!EQ (XCHARSET_NAME (ccs), Qucs) + || (XCHAR (character) != XINT (value))) + { + Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); + int dim = XCHARSET_DIMENSION (ccs); + int ccs_len = XCHARSET_BYTE_SIZE (ccs); + int byte_offset = XCHARSET_BYTE_OFFSET (ccs); + int code_point; + + if (CONSP (value)) + { /* obsolete representation: value must be a list of bytes */ + Lisp_Object ret = Fcar (value); + Lisp_Object rest; + + if (!INTP (ret)) + signal_simple_error ("Invalid value for coded-charset", value); + code_point = XINT (ret); + if (XCHARSET_GRAPHIC (ccs) == 1) + code_point &= 0x7F; + rest = Fcdr (value); + while (!NILP (rest)) { - ntable = get_char_code_table (c, table); - if (!CHAR_CODE_TABLE_P (ntable)) - { - ntable = make_char_code_table (Qnil); - put_char_code_table (c, ntable, table); - } - table = ntable; + int j; + + if (!CONSP (rest)) + signal_simple_error ("Invalid value for coded-charset", + value); + ret = Fcar (rest); + if (!INTP (ret)) + signal_simple_error ("Invalid value for coded-charset", + value); + j = XINT (ret); + if (XCHARSET_GRAPHIC (ccs) == 1) + j &= 0x7F; + code_point = (code_point << 8) | j; + rest = Fcdr (rest); + } + value = make_int (code_point); + } + else if (INTP (value)) + { + code_point = XINT (value); + if (XCHARSET_GRAPHIC (ccs) == 1) + { + code_point &= 0x7F7F7F7F; + value = make_int (code_point); } } + else + signal_simple_error ("Invalid value for coded-charset", value); + + if (VECTORP (v)) + { + Lisp_Object cpos = Fget_char_attribute (character, ccs); + if (!NILP (cpos)) + { + decoding_table_remove_char (v, dim, byte_offset, XINT (cpos)); + } + } + else + { + XCHARSET_DECODING_TABLE (ccs) + = v = make_older_vector (ccs_len, Qnil); + } + + decoding_table_put_char (v, dim, byte_offset, code_point, character); } - else if (EQ (attribute, Q_ucs)) + if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs))) { - Lisp_Object ret; - Emchar c; + XCHARSET_ENCODING_TABLE (ccs) + = encoding_table = make_char_id_table (Qnil, -1); + } + put_char_id_table (XCHAR (character), value, encoding_table); + return Qt; +} - if (!INTP (value)) - signal_simple_error ("Invalid value for ->ucs", value); +Lisp_Object +remove_char_ccs (Lisp_Object character, Lisp_Object ccs) +{ + Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs); + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); - c = XINT (value); + if (VECTORP (decoding_table)) + { + Lisp_Object cpos = Fget_char_attribute (character, ccs); - ret = get_char_code_table (c, Vcharacter_variant_table); - if (NILP (Fmemq (character, ret))) + if (!NILP (cpos)) { - put_char_code_table (c, Fcons (character, ret), - Vcharacter_variant_table); + decoding_table_remove_char (decoding_table, + XCHARSET_DIMENSION (ccs), + XCHARSET_BYTE_OFFSET (ccs), + XINT (cpos)); } } - return put_char_attribute (character, attribute, value); + if (CHAR_ID_TABLE_P (encoding_table)) + { + put_char_id_table (XCHAR (character), Qnil, encoding_table); + } + return Qt; } -Lisp_Object Qucs; +Lisp_Object +put_char_attribute (Lisp_Object character, Lisp_Object attribute, + Lisp_Object value) +{ + Emchar char_id = XCHAR (character); + Lisp_Object ret = get_char_id_table (char_id, Vcharacter_attribute_table); + Lisp_Object cell; + + cell = Fassq (attribute, ret); + + if (NILP (cell)) + { + ret = Fcons (Fcons (attribute, value), ret); + } + else if (!EQ (Fcdr (cell), value)) + { + Fsetcdr (cell, value); + } + put_char_id_table (char_id, ret, Vcharacter_attribute_table); + return ret; +} + +Lisp_Object +remove_char_attribute (Lisp_Object character, Lisp_Object attribute) +{ + Emchar char_id = XCHAR (character); + Lisp_Object alist = get_char_id_table (char_id, Vcharacter_attribute_table); + + if (EQ (attribute, Fcar (Fcar (alist)))) + { + alist = Fcdr (alist); + } + else + { + Lisp_Object pr = alist; + Lisp_Object r = Fcdr (alist); + + while (!NILP (r)) + { + if (EQ (attribute, Fcar (Fcar (r)))) + { + XCDR (pr) = Fcdr (r); + break; + } + pr = r; + r = Fcdr (r); + } + } + put_char_id_table (char_id, alist, Vcharacter_attribute_table); + return alist; +} EXFUN (Fmake_char, 3); +EXFUN (Fdecode_char, 2); DEFUN ("define-char", Fdefine_char, 1, 1, 0, /* Store character's ATTRIBUTES. @@ -679,6 +1099,7 @@ Store character's ATTRIBUTES. Lisp_Object rest = attributes; Lisp_Object code = Fcdr (Fassq (Qucs, attributes)); Lisp_Object character; + Lisp_Object daikanwa = Qnil; if (NILP (code)) { @@ -689,11 +1110,15 @@ Store character's ATTRIBUTES. if (!LISTP (cell)) signal_simple_error ("Invalid argument", attributes); - if (!NILP (ccs = Ffind_charset (Fcar (cell)))) + if (!NILP (ccs = Ffind_charset (Fcar (cell))) + && ((XCHARSET_FINAL (ccs) != 0) || + (XCHARSET_UCS_MAX (ccs) > 0)) ) { cell = Fcdr (cell); - character = Fmake_char (ccs, Fcar (cell), - Fcar (Fcdr (cell))); + if (CONSP (cell)) + character = Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell))); + else + character = Fdecode_char (ccs, cell); goto setup_attributes; } rest = Fcdr (rest); @@ -718,14 +1143,34 @@ Store character's ATTRIBUTES. while (CONSP (rest)) { Lisp_Object cell = Fcar (rest); + Lisp_Object key = Fcar (cell); + Lisp_Object value = Fcdr (cell); if (!LISTP (cell)) signal_simple_error ("Invalid argument", attributes); + + if (EQ (key, Qmorohashi_daikanwa)) + { + size_t len; + GET_EXTERNAL_LIST_LENGTH (value, len); + + if (len == 1) + { + if (NILP (daikanwa)) + daikanwa = Fcdr (Fassq (Qideograph_daikanwa, rest)); + if (EQ (Fcar (value), daikanwa)) + goto ignored; + } + } + else if (EQ (key, Qideograph_daikanwa)) + daikanwa = value; + Fput_char_attribute (character, Fcar (cell), Fcdr (cell)); + ignored: rest = Fcdr (rest); } return - get_char_code_table (XCHAR (character), Vcharacter_attribute_table); + get_char_id_table (XCHAR (character), Vcharacter_attribute_table); } Lisp_Object Vutf_2000_version; @@ -769,11 +1214,33 @@ Lisp_Object Qascii, #ifdef UTF2000 Qucs_bmp, Qlatin_viscii, + Qlatin_tcvn5712, Qlatin_viscii_lower, Qlatin_viscii_upper, Qvietnamese_viscii_lower, Qvietnamese_viscii_upper, - Qideograph_daikanwa, + Qmojikyo, + Qmojikyo_pj_1, + Qmojikyo_pj_2, + Qmojikyo_pj_3, + Qmojikyo_pj_4, + Qmojikyo_pj_5, + Qmojikyo_pj_6, + Qmojikyo_pj_7, + Qmojikyo_pj_8, + Qmojikyo_pj_9, + Qmojikyo_pj_10, + Qmojikyo_pj_11, + Qmojikyo_pj_12, + Qmojikyo_pj_13, + Qmojikyo_pj_14, + Qmojikyo_pj_15, + Qmojikyo_pj_16, + Qmojikyo_pj_17, + Qmojikyo_pj_18, + Qmojikyo_pj_19, + Qmojikyo_pj_20, + Qmojikyo_pj_21, Qethiopic_ucs, #endif Qchinese_big5_1, @@ -784,13 +1251,6 @@ Lisp_Object Ql2r, Qr2l; Lisp_Object Vcharset_hash_table; -#ifdef UTF2000 -static Charset_ID next_allocated_leading_byte; -#else -static Charset_ID next_allocated_1_byte_leading_byte; -static Charset_ID next_allocated_2_byte_leading_byte; -#endif - /* Composite characters are characters constructed by overstriking two or more regular characters. @@ -901,7 +1361,7 @@ non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c) Use the macro charptr_emchar() instead. */ Emchar -non_ascii_charptr_emchar (CONST Bufbyte *str) +non_ascii_charptr_emchar (const Bufbyte *str) { #ifdef UTF2000 Bufbyte b; @@ -993,7 +1453,8 @@ non_ascii_valid_char_p (Emchar ch) if (f3 < 0x20) return 0; - if (f3 != 0x20 && f3 != 0x7F) + if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE && + f2 <= MAX_CHAR_FIELD2_PRIVATE)) return 1; /* @@ -1002,6 +1463,8 @@ non_ascii_valid_char_p (Emchar ch) FIELD2_TO_PRIVATE_LEADING_BYTE are the same. */ charset = CHARSET_BY_LEADING_BYTE (f2 + FIELD2_TO_OFFICIAL_LEADING_BYTE); + if (EQ (charset, Qnil)) + return 0; return (XCHARSET_CHARS (charset) == 96); } else @@ -1026,7 +1489,8 @@ non_ascii_valid_char_p (Emchar ch) } #endif /* ENABLE_COMPOSITE_CHARS */ - if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F) + if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F + && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE)) return 1; if (f1 <= MAX_CHAR_FIELD1_OFFICIAL) @@ -1036,6 +1500,8 @@ non_ascii_valid_char_p (Emchar ch) charset = CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_PRIVATE_LEADING_BYTE); + if (EQ (charset, Qnil)) + return 0; return (XCHARSET_CHARS (charset) == 96); } } @@ -1051,7 +1517,7 @@ non_ascii_valid_char_p (Emchar ch) charptr_copy_char() instead. */ Bytecount -non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str) +non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str) { Bufbyte *strptr = str; *strptr = *ptr++; @@ -1142,17 +1608,18 @@ Lstream_funget_emchar (Lstream *stream, Emchar ch) /************************************************************************/ static Lisp_Object -mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_charset (Lisp_Object obj) { - struct Lisp_Charset *cs = XCHARSET (obj); + Lisp_Charset *cs = XCHARSET (obj); - markobj (cs->short_name); - markobj (cs->long_name); - markobj (cs->doc_string); - markobj (cs->registry); - markobj (cs->ccl_program); + mark_object (cs->short_name); + mark_object (cs->long_name); + mark_object (cs->doc_string); + mark_object (cs->registry); + mark_object (cs->ccl_program); #ifdef UTF2000 - markobj (cs->decoding_table); + /* mark_object (cs->encoding_table); */ + /* mark_object (cs->decoding_table); */ #endif return cs->name; } @@ -1160,7 +1627,7 @@ mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object)) static void print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { - struct Lisp_Charset *cs = XCHARSET (obj); + Lisp_Charset *cs = XCHARSET (obj); char buf[200]; if (print_readably) @@ -1176,11 +1643,9 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1); write_c_string (" ", printcharfun); print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1); - sprintf (buf, " %s %s cols=%d g%d final='%c' reg=", - CHARSET_TYPE (cs) == CHARSET_TYPE_94 ? "94" : - CHARSET_TYPE (cs) == CHARSET_TYPE_96 ? "96" : - CHARSET_TYPE (cs) == CHARSET_TYPE_94X94 ? "94x94" : - "96x96", + sprintf (buf, " %d^%d %s cols=%d g%d final='%c' reg=", + CHARSET_CHARS (cs), + CHARSET_DIMENSION (cs), CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : "r2l", CHARSET_COLUMNS (cs), CHARSET_GRAPHIC (cs), @@ -1192,9 +1657,16 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) } static const struct lrecord_description charset_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, name), 7 }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) }, #ifdef UTF2000 - { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, decoding_table), 2 }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) }, #endif { XD_END } }; @@ -1202,13 +1674,13 @@ static const struct lrecord_description charset_description[] = { DEFINE_LRECORD_IMPLEMENTATION ("charset", charset, mark_charset, print_charset, 0, 0, 0, charset_description, - struct Lisp_Charset); - + Lisp_Charset); /* Make a new charset. */ static Lisp_Object make_charset (Charset_ID id, Lisp_Object name, - unsigned char type, unsigned char columns, unsigned char graphic, + unsigned short chars, unsigned char dimension, + unsigned char columns, unsigned char graphic, Bufbyte final, unsigned char direction, Lisp_Object short_name, Lisp_Object long_name, Lisp_Object doc, Lisp_Object reg, @@ -1216,17 +1688,21 @@ make_charset (Charset_ID id, Lisp_Object name, Emchar ucs_min, Emchar ucs_max, Emchar code_offset, unsigned char byte_offset) { + unsigned char type = 0; Lisp_Object obj; - struct Lisp_Charset *cs = - alloc_lcrecord_type (struct Lisp_Charset, &lrecord_charset); + Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset); + + zero_lcrecord (cs); + XSETCHARSET (obj, cs); CHARSET_ID (cs) = id; CHARSET_NAME (cs) = name; CHARSET_SHORT_NAME (cs) = short_name; CHARSET_LONG_NAME (cs) = long_name; + CHARSET_CHARS (cs) = chars; + CHARSET_DIMENSION (cs) = dimension; CHARSET_DIRECTION (cs) = direction; - CHARSET_TYPE (cs) = type; CHARSET_COLUMNS (cs) = columns; CHARSET_GRAPHIC (cs) = graphic; CHARSET_FINAL (cs) = final; @@ -1236,49 +1712,65 @@ make_charset (Charset_ID id, Lisp_Object name, CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil; #ifdef UTF2000 CHARSET_DECODING_TABLE(cs) = Qnil; + CHARSET_ENCODING_TABLE(cs) = Qnil; CHARSET_UCS_MIN(cs) = ucs_min; CHARSET_UCS_MAX(cs) = ucs_max; CHARSET_CODE_OFFSET(cs) = code_offset; CHARSET_BYTE_OFFSET(cs) = byte_offset; #endif - switch (CHARSET_TYPE (cs)) + switch (CHARSET_CHARS (cs)) { - case CHARSET_TYPE_94: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 94; - break; - case CHARSET_TYPE_96: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 96; - break; - case CHARSET_TYPE_94X94: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 94; + case 94: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_94; + break; + case 2: + type = CHARSET_TYPE_94X94; + break; + } break; - case CHARSET_TYPE_96X96: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 96; + case 96: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_96; + break; + case 2: + type = CHARSET_TYPE_96X96; + break; + } break; #ifdef UTF2000 - case CHARSET_TYPE_128: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 128; - break; - case CHARSET_TYPE_128X128: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 128; - break; - case CHARSET_TYPE_256: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 256; + case 128: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_128; + break; + case 2: + type = CHARSET_TYPE_128X128; + break; + } break; - case CHARSET_TYPE_256X256: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 256; + case 256: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_256; + break; + case 2: + type = CHARSET_TYPE_256X256; + break; + } break; #endif } +#ifndef UTF2000 + CHARSET_TYPE (cs) = type; +#endif #ifndef UTF2000 if (id == LEADING_BYTE_ASCII) @@ -1288,7 +1780,7 @@ make_charset (Charset_ID id, Lisp_Object name, else CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 2; #endif - + if (final) { /* some charsets do not have final characters. This includes @@ -1297,22 +1789,17 @@ make_charset (Charset_ID id, Lisp_Object name, #if UTF2000 if (code_offset == 0) { - assert (NILP (charset_by_attributes[type][final])); - charset_by_attributes[type][final] = obj; + assert (NILP (chlook->charset_by_attributes[type][final])); + chlook->charset_by_attributes[type][final] = obj; } #else - assert (NILP (charset_by_attributes[type][final][direction])); - charset_by_attributes[type][final][direction] = obj; + assert (NILP (chlook->charset_by_attributes[type][final][direction])); + chlook->charset_by_attributes[type][final][direction] = obj; #endif } - assert (NILP (charset_by_leading_byte[id - MIN_LEADING_BYTE])); - charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj; -#ifndef UTF2000 - if (id < 0xA0) - /* official leading byte */ - rep_bytes_by_first_byte[id] = CHARSET_REP_BYTES (cs); -#endif + assert (NILP (chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE])); + chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj; /* Some charsets are "faux" and don't have names or really exist at all except in the leading-byte table. */ @@ -1327,24 +1814,24 @@ get_unallocated_leading_byte (int dimension) Charset_ID lb; #ifdef UTF2000 - if (next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE) + if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE) lb = 0; else - lb = next_allocated_leading_byte++; + lb = chlook->next_allocated_leading_byte++; #else if (dimension == 1) { - if (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 = next_allocated_1_byte_leading_byte++; + lb = chlook->next_allocated_1_byte_leading_byte++; } else { - if (next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) + if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) lb = 0; else - lb = next_allocated_2_byte_leading_byte++; + lb = chlook->next_allocated_2_byte_leading_byte++; } #endif @@ -1357,7 +1844,58 @@ get_unallocated_leading_byte (int dimension) } #ifdef UTF2000 -Lisp_Object +Emchar +make_builtin_char (Lisp_Object charset, int c1, int c2) +{ + if (XCHARSET_UCS_MAX (charset)) + { + Emchar code + = (XCHARSET_DIMENSION (charset) == 1 + ? + c1 - XCHARSET_BYTE_OFFSET (charset) + : + (c1 - XCHARSET_BYTE_OFFSET (charset)) * XCHARSET_CHARS (charset) + + c2 - XCHARSET_BYTE_OFFSET (charset)) + - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset); + if ((code < XCHARSET_UCS_MIN (charset)) + || (XCHARSET_UCS_MAX (charset) < code)) + signal_simple_error ("Arguments makes invalid character", + make_char (code)); + return code; + } + else if (XCHARSET_DIMENSION (charset) == 1) + { + switch (XCHARSET_CHARS (charset)) + { + case 94: + return MIN_CHAR_94 + + (XCHARSET_FINAL (charset) - '0') * 94 + (c1 - 33); + case 96: + return MIN_CHAR_96 + + (XCHARSET_FINAL (charset) - '0') * 96 + (c1 - 32); + default: + abort (); + } + } + else + { + switch (XCHARSET_CHARS (charset)) + { + case 94: + return MIN_CHAR_94x94 + + (XCHARSET_FINAL (charset) - '0') * 94 * 94 + + (c1 - 33) * 94 + (c2 - 33); + case 96: + return MIN_CHAR_96x96 + + (XCHARSET_FINAL (charset) - '0') * 96 * 96 + + (c1 - 32) * 96 + (c2 - 32); + default: + abort (); + } + } +} + +int range_charset_code_point (Lisp_Object charset, Emchar ch) { int d; @@ -1366,37 +1904,35 @@ range_charset_code_point (Lisp_Object charset, Emchar ch) && (ch <= XCHARSET_UCS_MAX (charset))) { d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset); - - if (XCHARSET_DIMENSION (charset) == 1) - return list1 (make_int (d + XCHARSET_BYTE_OFFSET (charset))); + + if (XCHARSET_CHARS (charset) == 256) + return d; + else if (XCHARSET_DIMENSION (charset) == 1) + return d + XCHARSET_BYTE_OFFSET (charset); else if (XCHARSET_DIMENSION (charset) == 2) - return list2 (make_int (d / XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset))); + return + ((d / XCHARSET_CHARS (charset) + + XCHARSET_BYTE_OFFSET (charset)) << 8) + | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset)); else if (XCHARSET_DIMENSION (charset) == 3) - return list3 (make_int (d / (XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset)) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d / XCHARSET_CHARS (charset) - % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset))); + return + ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset)) + + XCHARSET_BYTE_OFFSET (charset)) << 16) + | ((d / XCHARSET_CHARS (charset) + % XCHARSET_CHARS (charset) + + XCHARSET_BYTE_OFFSET (charset)) << 8) + | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset)); else /* if (XCHARSET_DIMENSION (charset) == 4) */ - return list4 (make_int (d / (XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset)) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d / (XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset)) - % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d / XCHARSET_CHARS (charset) - % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset))); + return + ((d / (XCHARSET_CHARS (charset) + * XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset)) + + XCHARSET_BYTE_OFFSET (charset)) << 24) + | ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset)) + % XCHARSET_CHARS (charset) + + XCHARSET_BYTE_OFFSET (charset)) << 16) + | ((d / XCHARSET_CHARS (charset) % XCHARSET_CHARS (charset) + + XCHARSET_BYTE_OFFSET (charset)) << 8) + | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset)); } else if (XCHARSET_CODE_OFFSET (charset) == 0) { @@ -1407,17 +1943,17 @@ range_charset_code_point (Lisp_Object charset, Emchar ch) if (((d = ch - (MIN_CHAR_94 + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0) && (d < 94)) - return list1 (make_int (d + 33)); + return d + 33; } else if (XCHARSET_CHARS (charset) == 96) { if (((d = ch - (MIN_CHAR_96 + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0) && (d < 96)) - return list1 (make_int (d + 32)); + return d + 32; } else - return Qnil; + return -1; } else if (XCHARSET_DIMENSION (charset) == 2) { @@ -1427,8 +1963,7 @@ range_charset_code_point (Lisp_Object charset, Emchar ch) + (XCHARSET_FINAL (charset) - '0') * 94 * 94)) >= 0) && (d < 94 * 94)) - return list2 (make_int ((d / 94) + 33), - make_int (d % 94 + 33)); + return (((d / 94) + 33) << 8) | (d % 94 + 33); } else if (XCHARSET_CHARS (charset) == 96) { @@ -1436,129 +1971,151 @@ range_charset_code_point (Lisp_Object charset, Emchar ch) + (XCHARSET_FINAL (charset) - '0') * 96 * 96)) >= 0) && (d < 96 * 96)) - return list2 (make_int ((d / 96) + 32), - make_int (d % 96 + 32)); + return (((d / 96) + 32) << 8) | (d % 96 + 32); } + else + return -1; } } - return Qnil; + return -1; } -Lisp_Object -split_builtin_char (Emchar c) +int +encode_builtin_char_1 (Emchar c, Lisp_Object* charset) { - if (c < MIN_CHAR_OBS_94x94) + if (c <= MAX_CHAR_BASIC_LATIN) { - if (c <= MAX_CHAR_BASIC_LATIN) - { - return list2 (Vcharset_ascii, make_int (c)); - } - else if (c < 0xA0) - { - return list2 (Vcharset_control_1, make_int (c & 0x7F)); - } - else if (c <= 0xff) - { - return list2 (Vcharset_latin_iso8859_1, make_int (c & 0x7F)); - } - else if ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK)) - { - return list2 (Vcharset_greek_iso8859_7, - make_int (c - MIN_CHAR_GREEK + 0x20)); - } - else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC)) - { - return list2 (Vcharset_cyrillic_iso8859_5, - make_int (c - MIN_CHAR_CYRILLIC + 0x20)); - } - else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW)) - { - return list2 (Vcharset_hebrew_iso8859_8, - make_int (c - MIN_CHAR_HEBREW + 0x20)); - } - else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI)) - { - return list2 (Vcharset_thai_tis620, - make_int (c - MIN_CHAR_THAI + 0x20)); - } - else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c) - && (c <= MAX_CHAR_HALFWIDTH_KATAKANA)) - { - return list2 (Vcharset_katakana_jisx0201, - make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33)); - } - else - { - return list3 (Vcharset_ucs_bmp, - make_int (c >> 8), make_int (c & 0xff)); - } + *charset = Vcharset_ascii; + return c; + } + else if (c < 0xA0) + { + *charset = Vcharset_control_1; + return c & 0x7F; + } + else if (c <= 0xff) + { + *charset = Vcharset_latin_iso8859_1; + return c & 0x7F; + } + /* + else if ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK)) + { + *charset = Vcharset_greek_iso8859_7; + return c - MIN_CHAR_GREEK + 0x20; + } + else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC)) + { + *charset = Vcharset_cyrillic_iso8859_5; + return c - MIN_CHAR_CYRILLIC + 0x20; + } + */ + else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW)) + { + *charset = Vcharset_hebrew_iso8859_8; + return c - MIN_CHAR_HEBREW + 0x20; + } + else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI)) + { + *charset = Vcharset_thai_tis620; + return c - MIN_CHAR_THAI + 0x20; } - else if (c <= MAX_CHAR_OBS_94x94) + /* + else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c) + && (c <= MAX_CHAR_HALFWIDTH_KATAKANA)) { - return list3 (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_94X94, - ((c - MIN_CHAR_OBS_94x94) / (94 * 94)) + '@', - CHARSET_LEFT_TO_RIGHT), - make_int ((((c - MIN_CHAR_OBS_94x94) / 94) % 94) + 33), - make_int (((c - MIN_CHAR_OBS_94x94) % 94) + 33)); + return list2 (Vcharset_katakana_jisx0201, + make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33)); } + */ + else if (c <= MAX_CHAR_BMP) + { + *charset = Vcharset_ucs_bmp; + return c; + } + else if (c < MIN_CHAR_DAIKANWA) + { + *charset = Vcharset_ucs; + return c; + } + /* else if (c <= MAX_CHAR_DAIKANWA) { - return list3 (Vcharset_ideograph_daikanwa, - make_int ((c - MIN_CHAR_DAIKANWA) >> 8), - make_int ((c - MIN_CHAR_DAIKANWA) & 255)); + *charset = Vcharset_ideograph_daikanwa; + return c - MIN_CHAR_DAIKANWA; + } + */ + else if (c <= MAX_CHAR_MOJIKYO) + { + *charset = Vcharset_mojikyo; + return c - MIN_CHAR_MOJIKYO; + } + else if (c < MIN_CHAR_94) + { + *charset = Vcharset_ucs; + return c; } else if (c <= MAX_CHAR_94) { - return list2 (CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94, - ((c - MIN_CHAR_94) / 94) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int (((c - MIN_CHAR_94) % 94) + 33)); + *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94, + ((c - MIN_CHAR_94) / 94) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return ((c - MIN_CHAR_94) % 94) + 33; + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_96) { - return list2 (CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96, - ((c - MIN_CHAR_96) / 96) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int (((c - MIN_CHAR_96) % 96) + 32)); + *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96, + ((c - MIN_CHAR_96) / 96) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return ((c - MIN_CHAR_96) % 96) + 32; + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_94x94) { - return list3 (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_94X94, - ((c - MIN_CHAR_94x94) / (94 * 94)) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int ((((c - MIN_CHAR_94x94) / 94) % 94) + 33), - make_int (((c - MIN_CHAR_94x94) % 94) + 33)); + *charset + = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94, + ((c - MIN_CHAR_94x94) / (94 * 94)) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8) + | (((c - MIN_CHAR_94x94) % 94) + 33); + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_96x96) { - return list3 (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_96X96, - ((c - MIN_CHAR_96x96) / (96 * 96)) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int ((((c - MIN_CHAR_96x96) / 96) % 96) + 32), - make_int (((c - MIN_CHAR_96x96) % 96) + 32)); + *charset + = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96X96, + ((c - MIN_CHAR_96x96) / (96 * 96)) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return ((((c - MIN_CHAR_96x96) / 96) % 96) + 32) << 8 + | (((c - MIN_CHAR_96x96) % 96) + 32); + else + { + *charset = Vcharset_ucs; + return c; + } } else { - return Qnil; - } -} - -Lisp_Object -charset_code_point (Lisp_Object charset, Emchar ch) -{ - Lisp_Object cdef = get_char_code_table (ch, Vcharacter_attribute_table); - - if (!EQ (cdef, Qnil)) - { - Lisp_Object field = Fassq (charset, cdef); - - if (!EQ (field, Qnil)) - return Fcdr (field); + *charset = Vcharset_ucs; + return c; } - return range_charset_code_point (charset, ch); } Lisp_Object Vdefault_coded_charset_priority_list; @@ -1623,7 +2180,7 @@ add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value, (struct charset_list_closure*) charset_list_closure; Lisp_Object *charset_list = chcl->charset_list; - *charset_list = Fcons (XCHARSET_NAME (value), *charset_list); + *charset_list = Fcons (key /* XCHARSET_NAME (value) */, *charset_list); return 0; } @@ -1848,7 +2405,7 @@ character set. Recognized properties are: byte_offset = 0; } - charset = make_charset (id, name, type, columns, graphic, + charset = make_charset (id, name, chars, dimension, columns, graphic, final, direction, short_name, long_name, doc_string, registry, Qnil, 0, 0, 0, byte_offset); @@ -1865,10 +2422,10 @@ NEW-NAME is the name of the new charset. Return the new charset. (charset, new_name)) { Lisp_Object new_charset = Qnil; - int id, dimension, columns, graphic, final; - int direction, type; + int id, chars, dimension, columns, graphic, final; + int direction; Lisp_Object registry, doc_string, short_name, long_name; - struct Lisp_Charset *cs; + Lisp_Charset *cs; charset = Fget_charset (charset); if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset))) @@ -1881,9 +2438,9 @@ NEW-NAME is the name of the new charset. Return the new charset. cs = XCHARSET (charset); - type = CHARSET_TYPE (cs); - columns = CHARSET_COLUMNS (cs); + chars = CHARSET_CHARS (cs); dimension = CHARSET_DIMENSION (cs); + columns = CHARSET_COLUMNS (cs); id = get_unallocated_leading_byte (dimension); graphic = CHARSET_GRAPHIC (cs); @@ -1896,7 +2453,7 @@ NEW-NAME is the name of the new charset. Return the new charset. long_name = CHARSET_LONG_NAME (cs); registry = CHARSET_REGISTRY (cs); - new_charset = make_charset (id, new_name, type, columns, + new_charset = make_charset (id, new_name, chars, dimension, columns, graphic, final, direction, short_name, long_name, doc_string, registry, #ifdef UTF2000 @@ -2037,7 +2594,7 @@ Recognized properties are those listed in `make-charset', as well as */ (charset, prop)) { - struct Lisp_Charset *cs; + Lisp_Charset *cs; charset = Fget_charset (charset); cs = XCHARSET (charset); @@ -2132,39 +2689,40 @@ Set mapping-table of CHARSET to TABLE. (charset, table)) { struct Lisp_Charset *cs; - Lisp_Object old_table; size_t i; + int byte_offset; charset = Fget_charset (charset); cs = XCHARSET (charset); - if (EQ (table, Qnil)) + if (NILP (table)) { - CHARSET_DECODING_TABLE(cs) = table; + CHARSET_DECODING_TABLE(cs) = Qnil; return table; } else if (VECTORP (table)) { - int ccs_len; - - /* ad-hoc method for `ascii' */ - if ((CHARSET_CHARS (cs) == 94) && - (CHARSET_BYTE_OFFSET (cs) != 33)) - ccs_len = 128 - CHARSET_BYTE_OFFSET (cs); - else - ccs_len = CHARSET_CHARS (cs); - - if (XVECTOR_LENGTH (table) > ccs_len) - args_out_of_range (table, make_int (CHARSET_CHARS (cs))); - old_table = CHARSET_DECODING_TABLE(cs); - CHARSET_DECODING_TABLE(cs) = table; + int ccs_len = CHARSET_BYTE_SIZE (cs); + int ret = decoding_table_check_elements (table, + CHARSET_DIMENSION (cs), + ccs_len); + if (ret) + { + if (ret == -1) + signal_simple_error ("Too big table", table); + else if (ret == -2) + signal_simple_error ("Invalid element is found", table); + else + signal_simple_error ("Something wrong", table); + } + CHARSET_DECODING_TABLE(cs) = Qnil; } else signal_error (Qwrong_type_argument, list2 (build_translated_string ("vector-or-nil-p"), table)); - /* signal_simple_error ("Wrong type argument: vector-or-nil-p", table); */ + byte_offset = CHARSET_BYTE_OFFSET (cs); switch (CHARSET_DIMENSION (cs)) { case 1: @@ -2173,9 +2731,8 @@ Set mapping-table of CHARSET to TABLE. Lisp_Object c = XVECTOR_DATA(table)[i]; if (CHARP (c)) - put_char_attribute - (c, charset, - list1 (make_int (i + CHARSET_BYTE_OFFSET (cs)))); + put_char_ccs_code_point (c, charset, + make_int (i + byte_offset)); } break; case 2: @@ -2187,28 +2744,21 @@ Set mapping-table of CHARSET to TABLE. { size_t j; - if (XVECTOR_LENGTH (v) > CHARSET_CHARS (cs)) - { - CHARSET_DECODING_TABLE(cs) = old_table; - args_out_of_range (v, make_int (CHARSET_CHARS (cs))); - } for (j = 0; j < XVECTOR_LENGTH (v); j++) { Lisp_Object c = XVECTOR_DATA(v)[j]; if (CHARP (c)) - put_char_attribute (c, charset, - list2 - (make_int - (i + CHARSET_BYTE_OFFSET (cs)), - make_int - (j + CHARSET_BYTE_OFFSET (cs)))); + put_char_ccs_code_point + (c, charset, + make_int ( ( (i + byte_offset) << 8 ) + | (j + byte_offset) + ) ); } } else if (CHARP (v)) - put_char_attribute (v, charset, - list1 - (make_int (i + CHARSET_BYTE_OFFSET (cs)))); + put_char_ccs_code_point (v, charset, + make_int (i + byte_offset)); } break; } @@ -2221,6 +2771,23 @@ Set mapping-table of CHARSET to TABLE. /* Lisp primitives for working with characters */ /************************************************************************/ +#ifdef UTF2000 +DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /* +Make a character from CHARSET and code-point CODE. +*/ + (charset, code)) +{ + int c; + + charset = Fget_charset (charset); + CHECK_INT (code); + c = XINT (code); + if (XCHARSET_GRAPHIC (charset) == 1) + c &= 0x7F7F7F7F; + return make_char (DECODE_CHAR (charset, c)); +} +#endif + DEFUN ("make-char", Fmake_char, 2, 3, 0, /* Make a character from CHARSET and octets ARG1 and ARG2. ARG2 is required only for characters from two-dimensional charsets. @@ -2229,7 +2796,7 @@ character s with caron. */ (charset, arg1, arg2)) { - struct Lisp_Charset *cs; + Lisp_Charset *cs; int a1, a2; int lowlim, highlim; @@ -2291,32 +2858,57 @@ Return the character set of char CH. return XCHARSET_NAME (CHAR_CHARSET (XCHAR (ch))); } -DEFUN ("split-char", Fsplit_char, 1, 1, 0, /* -Return list of charset and one or two position-codes of CHAR. +DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /* +Return the octet numbered N (should be 0 or 1) of char CH. +N defaults to 0 if omitted. */ - (character)) + (ch, n)) { -#ifdef UTF2000 - Lisp_Object ret; Lisp_Object charset; + int octet0, octet1; - CHECK_CHAR_COERCE_INT (character); - ret = SPLIT_CHAR (XCHAR (character)); - charset = Fcar (ret); - if (CHARSETP (charset)) - return Fcons (XCHARSET_NAME (charset), Fcopy_list (Fcdr (ret))); + CHECK_CHAR_COERCE_INT (ch); + + BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1); + + if (NILP (n) || EQ (n, Qzero)) + return make_int (octet0); + else if (EQ (n, make_int (1))) + return make_int (octet1); else - return ret; -#else + signal_simple_error ("Octet number must be 0 or 1", n); +} + +DEFUN ("split-char", Fsplit_char, 1, 1, 0, /* +Return list of charset and one or two position-codes of CHAR. +*/ + (character)) +{ /* This function can GC */ struct gcpro gcpro1, gcpro2; Lisp_Object charset = Qnil; Lisp_Object rc = Qnil; +#ifdef UTF2000 + int code_point; + int dimension; +#else int c1, c2; +#endif GCPRO2 (charset, rc); CHECK_CHAR_COERCE_INT (character); +#ifdef UTF2000 + code_point = ENCODE_CHAR (XCHAR (character), charset); + dimension = XCHARSET_DIMENSION (charset); + while (dimension > 0) + { + rc = Fcons (make_int (code_point & 255), rc); + code_point >>= 8; + dimension--; + } + rc = Fcons (XCHARSET_NAME (charset), rc); +#else BREAKUP_CHAR (XCHAR (character), charset, c1, c2); if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2) @@ -2327,9 +2919,10 @@ Return list of charset and one or two position-codes of CHAR. { rc = list2 (XCHARSET_NAME (charset), make_int (c1)); } +#endif UNGCPRO; + return rc; -#endif } @@ -2414,6 +3007,12 @@ Return a string of the characters comprising a composite character. void syms_of_mule_charset (void) { +#ifdef UTF2000 + INIT_LRECORD_IMPLEMENTATION (byte_table); + INIT_LRECORD_IMPLEMENTATION (char_id_table); +#endif + INIT_LRECORD_IMPLEMENTATION (charset); + DEFSUBR (Fcharsetp); DEFSUBR (Ffind_charset); DEFSUBR (Fget_charset); @@ -2436,6 +3035,7 @@ syms_of_mule_charset (void) DEFSUBR (Fchar_attribute_alist); DEFSUBR (Fget_char_attribute); DEFSUBR (Fput_char_attribute); + DEFSUBR (Fremove_char_attribute); DEFSUBR (Fdefine_char); DEFSUBR (Fchar_variants); DEFSUBR (Fget_composite_char); @@ -2443,8 +3043,12 @@ syms_of_mule_charset (void) DEFSUBR (Fset_charset_mapping_table); #endif +#ifdef UTF2000 + DEFSUBR (Fdecode_char); +#endif DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); + DEFSUBR (Fchar_octet); DEFSUBR (Fsplit_char); #ifdef ENABLE_COMPOSITE_CHARS @@ -2489,9 +3093,19 @@ syms_of_mule_charset (void) defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1"); defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2"); #ifdef UTF2000 + defsymbol (&Qname, "name"); + defsymbol (&Qideographic_radical, "ideographic-radical"); + defsymbol (&Qideographic_strokes, "ideographic-strokes"); + defsymbol (&Qtotal_strokes, "total-strokes"); + defsymbol (&Qmorohashi_daikanwa, "morohashi-daikanwa"); defsymbol (&Q_ucs, "->ucs"); defsymbol (&Q_decomposition, "->decomposition"); defsymbol (&Qcompat, "compat"); + defsymbol (&Qisolated, "isolated"); + defsymbol (&Qinitial, "initial"); + defsymbol (&Qmedial, "medial"); + defsymbol (&Qfinal, "final"); + defsymbol (&Qvertical, "vertical"); defsymbol (&QnoBreak, "noBreak"); defsymbol (&Qfraction, "fraction"); defsymbol (&Qsuper, "super"); @@ -2500,15 +3114,39 @@ syms_of_mule_charset (void) defsymbol (&Qsquare, "square"); defsymbol (&Qwide, "wide"); defsymbol (&Qnarrow, "narrow"); + defsymbol (&Qsmall, "small"); defsymbol (&Qfont, "font"); defsymbol (&Qucs, "ucs"); defsymbol (&Qucs_bmp, "ucs-bmp"); defsymbol (&Qlatin_viscii, "latin-viscii"); + defsymbol (&Qlatin_tcvn5712, "latin-tcvn5712"); defsymbol (&Qlatin_viscii_lower, "latin-viscii-lower"); defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper"); defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower"); defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper"); defsymbol (&Qideograph_daikanwa, "ideograph-daikanwa"); + defsymbol (&Qmojikyo, "mojikyo"); + defsymbol (&Qmojikyo_pj_1, "mojikyo-pj-1"); + defsymbol (&Qmojikyo_pj_2, "mojikyo-pj-2"); + defsymbol (&Qmojikyo_pj_3, "mojikyo-pj-3"); + defsymbol (&Qmojikyo_pj_4, "mojikyo-pj-4"); + defsymbol (&Qmojikyo_pj_5, "mojikyo-pj-5"); + defsymbol (&Qmojikyo_pj_6, "mojikyo-pj-6"); + defsymbol (&Qmojikyo_pj_7, "mojikyo-pj-7"); + defsymbol (&Qmojikyo_pj_8, "mojikyo-pj-8"); + defsymbol (&Qmojikyo_pj_9, "mojikyo-pj-9"); + defsymbol (&Qmojikyo_pj_10, "mojikyo-pj-10"); + defsymbol (&Qmojikyo_pj_11, "mojikyo-pj-11"); + defsymbol (&Qmojikyo_pj_12, "mojikyo-pj-12"); + defsymbol (&Qmojikyo_pj_13, "mojikyo-pj-13"); + defsymbol (&Qmojikyo_pj_14, "mojikyo-pj-14"); + defsymbol (&Qmojikyo_pj_15, "mojikyo-pj-15"); + defsymbol (&Qmojikyo_pj_16, "mojikyo-pj-16"); + defsymbol (&Qmojikyo_pj_17, "mojikyo-pj-17"); + defsymbol (&Qmojikyo_pj_18, "mojikyo-pj-18"); + defsymbol (&Qmojikyo_pj_19, "mojikyo-pj-19"); + defsymbol (&Qmojikyo_pj_20, "mojikyo-pj-20"); + defsymbol (&Qmojikyo_pj_21, "mojikyo-pj-21"); defsymbol (&Qethiopic_ucs, "ethiopic-ucs"); #endif defsymbol (&Qchinese_big5_1, "chinese-big5-1"); @@ -2525,28 +3163,31 @@ vars_of_mule_charset (void) int k; #endif + chlook = xnew (struct charset_lookup); + dumpstruct (&chlook, &charset_lookup_description); + /* Table of charsets indexed by leading byte. */ - for (i = 0; i < countof (charset_by_leading_byte); i++) - charset_by_leading_byte[i] = Qnil; + for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) + chlook->charset_by_leading_byte[i] = Qnil; #ifdef UTF2000 /* Table of charsets indexed by type/final-byte. */ - for (i = 0; i < countof (charset_by_attributes); i++) - for (j = 0; j < countof (charset_by_attributes[0]); j++) - charset_by_attributes[i][j] = Qnil; + for (i = 0; i < countof (chlook->charset_by_attributes); i++) + for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++) + chlook->charset_by_attributes[i][j] = Qnil; #else /* Table of charsets indexed by type/final-byte/direction. */ - for (i = 0; i < countof (charset_by_attributes); i++) - for (j = 0; j < countof (charset_by_attributes[0]); j++) - for (k = 0; k < countof (charset_by_attributes[0][0]); k++) - charset_by_attributes[i][j][k] = Qnil; + for (i = 0; i < countof (chlook->charset_by_attributes); i++) + for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++) + for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++) + chlook->charset_by_attributes[i][j][k] = Qnil; #endif #ifdef UTF2000 - next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE; + chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE; #else - next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; - next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; + chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; + chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; #endif #ifndef UTF2000 @@ -2558,19 +3199,37 @@ Leading-code of private TYPE9N charset of column-width 1. #endif #ifdef UTF2000 - Vutf_2000_version = build_string("0.12 (Kashiwara)"); + Vutf_2000_version = build_string("0.16 (Ōji)"); DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /* Version number of UTF-2000. */ ); staticpro (&Vcharacter_attribute_table); - Vcharacter_attribute_table = make_char_code_table (Qnil); + Vcharacter_attribute_table = make_char_id_table (Qnil, 0); + + staticpro (&Vcharacter_name_table); + Vcharacter_name_table = make_char_id_table (Qnil, 0); + + /* staticpro (&Vcharacter_ideographic_radical_table); */ + Vcharacter_ideographic_radical_table = make_char_id_table (Qnil, -1); + + /* staticpro (&Vcharacter_ideographic_strokes_table); */ + Vcharacter_ideographic_strokes_table = make_char_id_table (Qnil, -1); - staticpro (&Vcharacter_composition_table); - Vcharacter_composition_table = make_char_code_table (Qnil); + /* staticpro (&Vcharacter_total_strokes_table); */ + Vcharacter_total_strokes_table = make_char_id_table (Qnil, -1); + + staticpro (&Vcharacter_morohashi_daikanwa_table); + Vcharacter_morohashi_daikanwa_table = make_char_id_table (Qnil, 0); + + /* staticpro (&Vcharacter_decomposition_table); */ + Vcharacter_decomposition_table = make_char_id_table (Qnil, -1); + + /* staticpro (&Vcharacter_composition_table); */ + Vcharacter_composition_table = make_char_id_table (Qnil, -1); staticpro (&Vcharacter_variant_table); - Vcharacter_variant_table = make_char_code_table (Qnil); + Vcharacter_variant_table = make_char_id_table (Qnil, 0); Vdefault_coded_charset_priority_list = Qnil; DEFVAR_LISP ("default-coded-charset-priority-list", @@ -2591,10 +3250,19 @@ complex_vars_of_mule_charset (void) ease of access. */ #ifdef UTF2000 + staticpro (&Vcharset_ucs); + Vcharset_ucs = + make_charset (LEADING_BYTE_UCS, Qucs, 256, 4, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("UCS"), + build_string ("UCS"), + build_string ("ISO/IEC 10646"), + build_string (""), + Qnil, 0, 0xFFFFFFF, 0, 0); + staticpro (&Vcharset_ucs_bmp); Vcharset_ucs_bmp = - make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, - CHARSET_TYPE_256X256, 1, 2, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("BMP"), build_string ("BMP"), build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"), @@ -2603,176 +3271,176 @@ complex_vars_of_mule_charset (void) #else # define MIN_CHAR_THAI 0 # define MAX_CHAR_THAI 0 -# define MIN_CHAR_GREEK 0 -# define MAX_CHAR_GREEK 0 # define MIN_CHAR_HEBREW 0 # define MAX_CHAR_HEBREW 0 # define MIN_CHAR_HALFWIDTH_KATAKANA 0 # define MAX_CHAR_HALFWIDTH_KATAKANA 0 -# define MIN_CHAR_CYRILLIC 0 -# define MAX_CHAR_CYRILLIC 0 #endif + staticpro (&Vcharset_ascii); Vcharset_ascii = - make_charset (LEADING_BYTE_ASCII, Qascii, - CHARSET_TYPE_94, 1, 0, 'B', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_ASCII, Qascii, 94, 1, + 1, 0, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("ASCII"), build_string ("ASCII)"), build_string ("ASCII (ISO646 IRV)"), build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"), Qnil, 0, 0x7F, 0, 0); + staticpro (&Vcharset_control_1); Vcharset_control_1 = - make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, - CHARSET_TYPE_94, 1, 1, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1, + 1, 1, 0, CHARSET_LEFT_TO_RIGHT, build_string ("C1"), build_string ("Control characters"), build_string ("Control characters 128-191"), build_string (""), Qnil, 0x80, 0x9F, 0, 0); + staticpro (&Vcharset_latin_iso8859_1); Vcharset_latin_iso8859_1 = - make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, - CHARSET_TYPE_96, 1, 1, 'A', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1, + 1, 1, 'A', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-1"), build_string ("ISO8859-1 (Latin-1)"), build_string ("ISO8859-1 (Latin-1)"), build_string ("iso8859-1"), Qnil, 0xA0, 0xFF, 0, 32); + staticpro (&Vcharset_latin_iso8859_2); Vcharset_latin_iso8859_2 = - make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, - CHARSET_TYPE_96, 1, 1, 'B', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1, + 1, 1, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-2"), build_string ("ISO8859-2 (Latin-2)"), build_string ("ISO8859-2 (Latin-2)"), build_string ("iso8859-2"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_latin_iso8859_3); Vcharset_latin_iso8859_3 = - make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, - CHARSET_TYPE_96, 1, 1, 'C', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1, + 1, 1, 'C', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-3"), build_string ("ISO8859-3 (Latin-3)"), build_string ("ISO8859-3 (Latin-3)"), build_string ("iso8859-3"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_latin_iso8859_4); Vcharset_latin_iso8859_4 = - make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, - CHARSET_TYPE_96, 1, 1, 'D', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1, + 1, 1, 'D', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-4"), build_string ("ISO8859-4 (Latin-4)"), build_string ("ISO8859-4 (Latin-4)"), build_string ("iso8859-4"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_thai_tis620); Vcharset_thai_tis620 = - make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, - CHARSET_TYPE_96, 1, 1, 'T', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1, + 1, 1, 'T', CHARSET_LEFT_TO_RIGHT, build_string ("TIS620"), build_string ("TIS620 (Thai)"), build_string ("TIS620.2529 (Thai)"), build_string ("tis620"), Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32); + staticpro (&Vcharset_greek_iso8859_7); Vcharset_greek_iso8859_7 = - make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, - CHARSET_TYPE_96, 1, 1, 'F', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1, + 1, 1, 'F', CHARSET_LEFT_TO_RIGHT, build_string ("ISO8859-7"), build_string ("ISO8859-7 (Greek)"), build_string ("ISO8859-7 (Greek)"), build_string ("iso8859-7"), - Qnil, MIN_CHAR_GREEK, MAX_CHAR_GREEK, 0, 32); + Qnil, + 0 /* MIN_CHAR_GREEK */, + 0 /* MAX_CHAR_GREEK */, 0, 32); + staticpro (&Vcharset_arabic_iso8859_6); Vcharset_arabic_iso8859_6 = - make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, - CHARSET_TYPE_96, 1, 1, 'G', - CHARSET_RIGHT_TO_LEFT, + make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1, + 1, 1, 'G', CHARSET_RIGHT_TO_LEFT, build_string ("ISO8859-6"), build_string ("ISO8859-6 (Arabic)"), build_string ("ISO8859-6 (Arabic)"), build_string ("iso8859-6"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_hebrew_iso8859_8); Vcharset_hebrew_iso8859_8 = - make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, - CHARSET_TYPE_96, 1, 1, 'H', - CHARSET_RIGHT_TO_LEFT, + make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1, + 1, 1, 'H', CHARSET_RIGHT_TO_LEFT, build_string ("ISO8859-8"), build_string ("ISO8859-8 (Hebrew)"), build_string ("ISO8859-8 (Hebrew)"), build_string ("iso8859-8"), Qnil, MIN_CHAR_HEBREW, MAX_CHAR_HEBREW, 0, 32); + staticpro (&Vcharset_katakana_jisx0201); Vcharset_katakana_jisx0201 = - make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, - CHARSET_TYPE_94, 1, 1, 'I', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1, + 1, 1, 'I', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0201 Kana"), build_string ("JISX0201.1976 (Japanese Kana)"), build_string ("JISX0201.1976 Japanese Kana"), build_string ("jisx0201\\.1976"), - Qnil, - MIN_CHAR_HALFWIDTH_KATAKANA, - MAX_CHAR_HALFWIDTH_KATAKANA, 0, 33); + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_latin_jisx0201); Vcharset_latin_jisx0201 = - make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, - CHARSET_TYPE_94, 1, 0, 'J', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1, + 1, 0, 'J', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0201 Roman"), build_string ("JISX0201.1976 (Japanese Roman)"), build_string ("JISX0201.1976 Japanese Roman"), build_string ("jisx0201\\.1976"), Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_cyrillic_iso8859_5); Vcharset_cyrillic_iso8859_5 = - make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, - CHARSET_TYPE_96, 1, 1, 'L', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1, + 1, 1, 'L', CHARSET_LEFT_TO_RIGHT, build_string ("ISO8859-5"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("iso8859-5"), - Qnil, MIN_CHAR_CYRILLIC, MAX_CHAR_CYRILLIC, 0, 32); + Qnil, + 0 /* MIN_CHAR_CYRILLIC */, + 0 /* MAX_CHAR_CYRILLIC */, 0, 32); + staticpro (&Vcharset_latin_iso8859_9); Vcharset_latin_iso8859_9 = - make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, - CHARSET_TYPE_96, 1, 1, 'M', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1, + 1, 1, 'M', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-5"), build_string ("ISO8859-9 (Latin-5)"), build_string ("ISO8859-9 (Latin-5)"), build_string ("iso8859-9"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_japanese_jisx0208_1978); Vcharset_japanese_jisx0208_1978 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, - CHARSET_TYPE_94X94, 2, 0, '@', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, + Qjapanese_jisx0208_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"), Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_chinese_gb2312); Vcharset_chinese_gb2312 = - make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, - CHARSET_TYPE_94X94, 2, 0, 'A', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_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); + staticpro (&Vcharset_japanese_jisx0208); Vcharset_japanese_jisx0208 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, - CHARSET_TYPE_94X94, 2, 0, 'B', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 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"), Qnil, 0, 0, 0, 33); +#ifdef UTF2000 + staticpro (&Vcharset_japanese_jisx0208_1990); Vcharset_japanese_jisx0208_1990 = make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990, - Qjapanese_jisx0208_1990, - CHARSET_TYPE_94X94, 2, 0, 0, - CHARSET_LEFT_TO_RIGHT, + Qjapanese_jisx0208_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"), @@ -2780,19 +3448,20 @@ complex_vars_of_mule_charset (void) Qnil, MIN_CHAR_JIS_X0208_1990, MAX_CHAR_JIS_X0208_1990, 0, 33); +#endif + staticpro (&Vcharset_korean_ksc5601); Vcharset_korean_ksc5601 = - make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, - CHARSET_TYPE_94X94, 2, 0, 'C', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 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); + staticpro (&Vcharset_japanese_jisx0212); Vcharset_japanese_jisx0212 = - make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, - CHARSET_TYPE_94X94, 2, 0, 'D', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2, + 2, 0, 'D', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0212"), build_string ("JISX0212 (Japanese)"), build_string ("JISX0212 Japanese Supplement"), @@ -2800,20 +3469,20 @@ complex_vars_of_mule_charset (void) Qnil, 0, 0, 0, 33); #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$" + staticpro (&Vcharset_chinese_cns11643_1); Vcharset_chinese_cns11643_1 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, - CHARSET_TYPE_94X94, 2, 0, 'G', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_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); + staticpro (&Vcharset_chinese_cns11643_2); Vcharset_chinese_cns11643_2 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, - CHARSET_TYPE_94X94, 2, 0, 'H', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2, + 2, 0, 'H', CHARSET_LEFT_TO_RIGHT, build_string ("CNS11643-2"), build_string ("CNS11643-2 (Chinese traditional)"), build_string @@ -2821,66 +3490,294 @@ complex_vars_of_mule_charset (void) build_string (CHINESE_CNS_PLANE_RE("2")), Qnil, 0, 0, 0, 33); #ifdef UTF2000 + staticpro (&Vcharset_latin_tcvn5712); + Vcharset_latin_tcvn5712 = + make_charset (LEADING_BYTE_LATIN_TCVN5712, Qlatin_tcvn5712, 96, 1, + 1, 1, 'Z', CHARSET_LEFT_TO_RIGHT, + build_string ("TCVN 5712"), + build_string ("TCVN 5712 (VSCII-2)"), + build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"), + build_string ("tcvn5712-1"), + Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_latin_viscii_lower); Vcharset_latin_viscii_lower = - make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, - CHARSET_TYPE_96, 1, 1, '1', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1, + 1, 1, '1', CHARSET_LEFT_TO_RIGHT, build_string ("VISCII lower"), build_string ("VISCII lower (Vietnamese)"), build_string ("VISCII lower (Vietnamese)"), build_string ("MULEVISCII-LOWER"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_latin_viscii_upper); Vcharset_latin_viscii_upper = - make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, - CHARSET_TYPE_96, 1, 1, '2', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1, + 1, 1, '2', CHARSET_LEFT_TO_RIGHT, build_string ("VISCII upper"), build_string ("VISCII upper (Vietnamese)"), build_string ("VISCII upper (Vietnamese)"), build_string ("MULEVISCII-UPPER"), Qnil, 0, 0, 0, 32); + staticpro (&Vcharset_latin_viscii); Vcharset_latin_viscii = - make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, - CHARSET_TYPE_256, 1, 2, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("VISCII"), build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII1\\.1"), Qnil, 0, 0, 0, 0); + staticpro (&Vcharset_ideograph_daikanwa); Vcharset_ideograph_daikanwa = - make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, - CHARSET_TYPE_256X256, 2, 2, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Daikanwa"), build_string ("Morohashi's Daikanwa"), build_string ("Daikanwa dictionary by MOROHASHI Tetsuji"), build_string ("Daikanwa"), Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, 0, 0); + staticpro (&Vcharset_mojikyo); + Vcharset_mojikyo = + make_charset (LEADING_BYTE_MOJIKYO, Qmojikyo, 256, 3, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo"), + build_string ("Mojikyo"), + build_string ("Konjaku-Mojikyo"), + build_string (""), + Qnil, MIN_CHAR_MOJIKYO, MAX_CHAR_MOJIKYO, 0, 0); + staticpro (&Vcharset_mojikyo_pj_1); + Vcharset_mojikyo_pj_1 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_1, Qmojikyo_pj_1, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-1"), + build_string ("Mojikyo (pseudo JIS encoding) part 1"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 1"), + build_string ("jisx0208\\.Mojikyo-1$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_2); + Vcharset_mojikyo_pj_2 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_2, Qmojikyo_pj_2, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-2"), + build_string ("Mojikyo (pseudo JIS encoding) part 2"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 2"), + build_string ("jisx0208\\.Mojikyo-2$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_3); + Vcharset_mojikyo_pj_3 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_3, Qmojikyo_pj_3, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-3"), + build_string ("Mojikyo (pseudo JIS encoding) part 3"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 3"), + build_string ("jisx0208\\.Mojikyo-3$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_4); + Vcharset_mojikyo_pj_4 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_4, Qmojikyo_pj_4, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-4"), + build_string ("Mojikyo (pseudo JIS encoding) part 4"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 4"), + build_string ("jisx0208\\.Mojikyo-4$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_5); + Vcharset_mojikyo_pj_5 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_5, Qmojikyo_pj_5, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-5"), + build_string ("Mojikyo (pseudo JIS encoding) part 5"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 5"), + build_string ("jisx0208\\.Mojikyo-5$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_6); + Vcharset_mojikyo_pj_6 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_6, Qmojikyo_pj_6, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-6"), + build_string ("Mojikyo (pseudo JIS encoding) part 6"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 6"), + build_string ("jisx0208\\.Mojikyo-6$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_7); + Vcharset_mojikyo_pj_7 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_7, Qmojikyo_pj_7, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-7"), + build_string ("Mojikyo (pseudo JIS encoding) part 7"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 7"), + build_string ("jisx0208\\.Mojikyo-7$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_8); + Vcharset_mojikyo_pj_8 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_8, Qmojikyo_pj_8, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-8"), + build_string ("Mojikyo (pseudo JIS encoding) part 8"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 8"), + build_string ("jisx0208\\.Mojikyo-8$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_9); + Vcharset_mojikyo_pj_9 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_9, Qmojikyo_pj_9, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-9"), + build_string ("Mojikyo (pseudo JIS encoding) part 9"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 9"), + build_string ("jisx0208\\.Mojikyo-9$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_10); + Vcharset_mojikyo_pj_10 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_10, Qmojikyo_pj_10, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-10"), + build_string ("Mojikyo (pseudo JIS encoding) part 10"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 10"), + build_string ("jisx0208\\.Mojikyo-10$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_11); + Vcharset_mojikyo_pj_11 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_11, Qmojikyo_pj_11, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-11"), + build_string ("Mojikyo (pseudo JIS encoding) part 11"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 11"), + build_string ("jisx0208\\.Mojikyo-11$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_12); + Vcharset_mojikyo_pj_12 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_12, Qmojikyo_pj_12, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-12"), + build_string ("Mojikyo (pseudo JIS encoding) part 12"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 12"), + build_string ("jisx0208\\.Mojikyo-12$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_13); + Vcharset_mojikyo_pj_13 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_13, Qmojikyo_pj_13, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-13"), + build_string ("Mojikyo (pseudo JIS encoding) part 13"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 13"), + build_string ("jisx0208\\.Mojikyo-13$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_14); + Vcharset_mojikyo_pj_14 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_14, Qmojikyo_pj_14, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-14"), + build_string ("Mojikyo (pseudo JIS encoding) part 14"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 14"), + build_string ("jisx0208\\.Mojikyo-14$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_15); + Vcharset_mojikyo_pj_15 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_15, Qmojikyo_pj_15, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-15"), + build_string ("Mojikyo (pseudo JIS encoding) part 15"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 15"), + build_string ("jisx0208\\.Mojikyo-15$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_16); + Vcharset_mojikyo_pj_16 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_16, Qmojikyo_pj_16, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-16"), + build_string ("Mojikyo (pseudo JIS encoding) part 16"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 16"), + build_string ("jisx0208\\.Mojikyo-16$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_17); + Vcharset_mojikyo_pj_17 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_17, Qmojikyo_pj_17, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-17"), + build_string ("Mojikyo (pseudo JIS encoding) part 17"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 17"), + build_string ("jisx0208\\.Mojikyo-17$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_18); + Vcharset_mojikyo_pj_18 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_18, Qmojikyo_pj_18, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-18"), + build_string ("Mojikyo (pseudo JIS encoding) part 18"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 18"), + build_string ("jisx0208\\.Mojikyo-18$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_19); + Vcharset_mojikyo_pj_19 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_19, Qmojikyo_pj_19, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-19"), + build_string ("Mojikyo (pseudo JIS encoding) part 19"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 19"), + build_string ("jisx0208\\.Mojikyo-19$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_20); + Vcharset_mojikyo_pj_20 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_20, Qmojikyo_pj_20, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-20"), + build_string ("Mojikyo (pseudo JIS encoding) part 20"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 20"), + build_string ("jisx0208\\.Mojikyo-20$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_mojikyo_pj_21); + Vcharset_mojikyo_pj_21 = + make_charset (LEADING_BYTE_MOJIKYO_PJ_21, Qmojikyo_pj_21, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-PJ-21"), + build_string ("Mojikyo (pseudo JIS encoding) part 21"), + build_string + ("Konjaku-Mojikyo (pseudo JIS encoding) part 21"), + build_string ("jisx0208\\.Mojikyo-21$"), + Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_ethiopic_ucs); Vcharset_ethiopic_ucs = - make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, - CHARSET_TYPE_256X256, 2, 2, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Ethiopic (UCS)"), build_string ("Ethiopic (UCS)"), build_string ("Ethiopic of UCS"), build_string ("Ethiopic-Unicode"), Qnil, 0x1200, 0x137F, 0x1200, 0); #endif + staticpro (&Vcharset_chinese_big5_1); Vcharset_chinese_big5_1 = - make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, - CHARSET_TYPE_94X94, 2, 0, '0', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 94, 2, + 2, 0, '0', CHARSET_LEFT_TO_RIGHT, build_string ("Big5"), build_string ("Big5 (Level-1)"), build_string ("Big5 Level-1 Chinese traditional"), build_string ("big5"), Qnil, 0, 0, 0, 33); + staticpro (&Vcharset_chinese_big5_2); Vcharset_chinese_big5_2 = - make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, - CHARSET_TYPE_94X94, 2, 0, '1', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2, + 2, 0, '1', CHARSET_LEFT_TO_RIGHT, build_string ("Big5"), build_string ("Big5 (Level-2)"), build_string @@ -2892,15 +3789,16 @@ complex_vars_of_mule_charset (void) /* #### For simplicity, we put composite chars into a 96x96 charset. This is going to lead to problems because you can run out of room, esp. as we don't yet recycle numbers. */ + staticpro (&Vcharset_composite); Vcharset_composite = - make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, - CHARSET_TYPE_96X96, 2, 0, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 96, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Composite"), build_string ("Composite characters"), build_string ("Composite characters"), build_string ("")); + /* #### not dumped properly */ composite_char_row_next = 32; composite_char_col_next = 32;