X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=b55df3ace4f38cb729140a421e698fecd6283153;hb=e3e3297ded763fa55e4847941611e5c788b10036;hp=aba97b7f87d4c0b6ec89d8cf896d531aba3f5ba1;hpb=a9028fb29f742d52fee8854992738cea07a90b28;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index aba97b7..b55df3a 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -63,9 +63,11 @@ Lisp_Object Vcharset_chinese_cns11643_2; 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; @@ -109,7 +111,7 @@ static int composite_char_col_next; struct charset_lookup *chlook; static const struct lrecord_description charset_lookup_description_1[] = { - { XD_LISP_OBJECT, offsetof(struct charset_lookup, charset_by_leading_byte), + { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), #ifdef UTF2000 128+4*128 #else @@ -119,7 +121,7 @@ static const struct lrecord_description charset_lookup_description_1[] = { }; static const struct struct_description charset_lookup_description = { - sizeof(struct charset_lookup), + sizeof (struct charset_lookup), charset_lookup_description_1 }; @@ -158,9 +160,9 @@ const Bytecount rep_bytes_by_first_byte[0xA0] = #ifdef UTF2000 static Lisp_Object -mark_char_byte_table (Lisp_Object obj) +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++) @@ -171,19 +173,19 @@ mark_char_byte_table (Lisp_Object obj) } 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 @@ -196,214 +198,209 @@ 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) { 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 + = 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) +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) { 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 + = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); - cte->table = make_char_byte_table (initval); + cte->table = make_byte_table (initval); - XSETCHAR_CODE_TABLE (obj, cte); + XSETCHAR_ID_TABLE (obj, cte); return obj; } 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; } 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); + Lisp_Object cpt4 = make_byte_table (ret); - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; + 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); + Lisp_Object cpt3 = make_byte_table (ret); + Lisp_Object cpt4 = make_byte_table (ret); - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] + 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); + Lisp_Object cpt2 = make_byte_table (ret); + Lisp_Object cpt3 = make_byte_table (ret); + Lisp_Object cpt4 = make_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; + 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; } } @@ -432,8 +429,9 @@ Lisp_Object Qnarrow; Lisp_Object Qsmall; Lisp_Object Qfont; +Emchar to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg); 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); @@ -487,21 +485,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); @@ -515,8 +513,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, /* @@ -525,8 +523,8 @@ Return the alist of attributes of CHARACTER. (character)) { CHECK_CHAR (character); - return Fcopy_alist (get_char_code_table (XCHAR (character), - Vcharacter_attribute_table)); + return Fcopy_alist (get_char_id_table (XCHAR (character), + Vcharacter_attribute_table)); } DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /* @@ -534,28 +532,38 @@ 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; + { + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); + + if (CHAR_ID_TABLE_P (encoding_table)) + return get_char_id_table (XCHAR (character), encoding_table); + else + return Qnil; + } + else + { + Lisp_Object ret + = get_char_id_table (XCHAR (character), Vcharacter_attribute_table); - return Fcdr (Fassq (attribute, ret)); + if (EQ (ret, Qnil)) + return Qnil; + else + return Fcdr (Fassq (attribute, ret)); + } } +Lisp_Object put_char_attribute (Lisp_Object character, + Lisp_Object attribute, Lisp_Object value); 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); + Emchar char_id = XCHAR (character); + Lisp_Object ret = get_char_id_table (char_id, Vcharacter_attribute_table); Lisp_Object cell; cell = Fassq (attribute, ret); @@ -568,10 +576,44 @@ put_char_attribute (Lisp_Object character, Lisp_Object attribute, { Fsetcdr (cell, value); } - put_char_code_table (char_code, ret, Vcharacter_attribute_table); + put_char_id_table (char_id, ret, Vcharacter_attribute_table); return ret; } - + +Lisp_Object remove_char_attribute (Lisp_Object character, + Lisp_Object attribute); +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; +} + +Lisp_Object Qucs; + DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /* Store CHARACTER's ATTRIBUTE with VALUE. */ @@ -583,134 +625,174 @@ Store CHARACTER's ATTRIBUTE with VALUE. ccs = Ffind_charset (attribute); if (!NILP (ccs)) { - Lisp_Object cpos, rest; - Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); - Lisp_Object nv; - int i = -1; - int ccs_len; - int dim; - int code_point; - - /* 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)) + Lisp_Object encoding_table; + + if (!EQ (XCHARSET_NAME (ccs), Qucs) + || (XCHAR (character) != XINT (value))) { - Lisp_Object ret = Fcar (value); + Lisp_Object cpos, rest; + Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); + Lisp_Object nv; + int i = -1; + int ccs_len; + int dim; + int code_point; + + /* 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 (!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)) + if (CONSP (value)) { - int i; + Lisp_Object ret = Fcar (value); - 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); - i = XINT (ret); + code_point = XINT (ret); if (XCHARSET_GRAPHIC (ccs) == 1) - i &= 0x7F; - code_point = (code_point << 8) | i; - rest = Fcdr (rest); + code_point &= 0x7F; + rest = Fcdr (value); + while (!NILP (rest)) + { + 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); } - value = make_int (code_point); - } - else if (INTP (value)) - { - if (XCHARSET_GRAPHIC (ccs) == 1) - value = make_int (XINT (value) & 0x7F7F7F7F); - } - else - signal_simple_error ("Invalid value for coded-charset", value); + else if (INTP (value)) + { + if (XCHARSET_GRAPHIC (ccs) == 1) + value = make_int (XINT (value) & 0x7F7F7F7F); + } + else + signal_simple_error ("Invalid value for coded-charset", value); - attribute = ccs; - cpos = Fget_char_attribute (character, attribute); - if (VECTORP (v)) - { - if (!NILP (cpos)) + attribute = ccs; + cpos = Fget_char_attribute (character, attribute); + if (VECTORP (v)) { - dim = XCHARSET_DIMENSION (ccs); - code_point = XINT (cpos); - while (dim > 0) + if (!NILP (cpos)) + { + dim = XCHARSET_DIMENSION (ccs); + code_point = XINT (cpos); + while (dim > 0) + { + dim--; + i = ((code_point >> (8 * dim)) & 255) + - XCHARSET_BYTE_OFFSET (ccs); + nv = XVECTOR_DATA(v)[i]; + if (!VECTORP (nv)) + break; + v = nv; + } + if (i >= 0) + XVECTOR_DATA(v)[i] = Qnil; + v = XCHARSET_DECODING_TABLE (ccs); + } + } + else + { + XCHARSET_DECODING_TABLE (ccs) = v + = make_older_vector (ccs_len, Qnil); + } + + dim = XCHARSET_DIMENSION (ccs); + code_point = XINT (value); + i = -1; + while (dim > 0) + { + dim--; + i = ((code_point >> (8 * dim)) & 255) + - XCHARSET_BYTE_OFFSET (ccs); + nv = XVECTOR_DATA(v)[i]; + if (dim > 0) { - dim--; - i = ((code_point >> (8 * dim)) & 255) - - XCHARSET_BYTE_OFFSET (ccs); - nv = XVECTOR_DATA(v)[i]; if (!VECTORP (nv)) - break; + nv = (XVECTOR_DATA(v)[i] + = make_older_vector (ccs_len, Qnil)); v = nv; } - if (i >= 0) - XVECTOR_DATA(v)[i] = Qnil; - v = XCHARSET_DECODING_TABLE (ccs); + else + break; } + XVECTOR_DATA(v)[i] = character; } else + attribute = ccs; + if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs))) { - XCHARSET_DECODING_TABLE (ccs) = v = make_vector (ccs_len, Qnil); - } - - dim = XCHARSET_DIMENSION (ccs); - code_point = XINT (value); - i = -1; - while (dim > 0) - { - dim--; - i = ((code_point >> (8 * dim)) & 255) - XCHARSET_BYTE_OFFSET (ccs); - nv = XVECTOR_DATA(v)[i]; - if (dim > 0) - { - if (!VECTORP (nv)) - nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil)); - v = nv; - } - else - break; + XCHARSET_ENCODING_TABLE (ccs) = encoding_table + = make_char_id_table (Qnil); } - XVECTOR_DATA(v)[i] = character; + put_char_id_table (XCHAR (character), value, encoding_table); + return Qt; } else if (EQ (attribute, Q_decomposition)) { - Lisp_Object rest = value; - Lisp_Object table = Vcharacter_composition_table; - if (!CONSP (value)) signal_simple_error ("Invalid value for ->decomposition", value); - while (CONSP (rest)) + if (CONSP (Fcdr (value))) { - Lisp_Object v = Fcar (rest); - Lisp_Object ntable; - Emchar c - = to_char_code (v, "Invalid value for ->decomposition", value); + Lisp_Object rest = value; + Lisp_Object table = Vcharacter_composition_table; - rest = Fcdr (rest); - if (!CONSP (rest)) + while (CONSP (rest)) { - put_char_code_table (c, character, table); - break; + Lisp_Object v = Fcar (rest); + Lisp_Object ntable; + Emchar c + = to_char_id (v, "Invalid value for ->decomposition", value); + + rest = Fcdr (rest); + if (!CONSP (rest)) + { + put_char_id_table (c, character, table); + break; + } + else + { + ntable = get_char_id_table (c, table); + if (!CHAR_ID_TABLE_P (ntable)) + { + ntable = make_char_id_table (Qnil); + put_char_id_table (c, ntable, table); + } + table = ntable; + } } - else + } + else + { + Lisp_Object v = Fcar (value); + + if (INTP (v)) { - ntable = get_char_code_table (c, table); - if (!CHAR_CODE_TABLE_P (ntable)) + Emchar c = XINT (v); + Lisp_Object ret + = get_char_id_table (c, Vcharacter_variant_table); + + if (NILP (Fmemq (v, ret))) { - ntable = make_char_code_table (Qnil); - put_char_code_table (c, ntable, table); + put_char_id_table (c, Fcons (character, ret), + Vcharacter_variant_table); } - table = ntable; } } } @@ -724,19 +806,77 @@ Store CHARACTER's ATTRIBUTE with VALUE. c = XINT (value); - ret = get_char_code_table (c, Vcharacter_variant_table); + ret = get_char_id_table (c, Vcharacter_variant_table); if (NILP (Fmemq (character, ret))) { - put_char_code_table (c, Fcons (character, ret), - Vcharacter_variant_table); + 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; -Lisp_Object Qucs; + CHECK_CHAR (character); + ccs = Ffind_charset (attribute); + if (!NILP (ccs)) + { + Lisp_Object cpos; + Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); + Lisp_Object nv; + int i = -1; + int ccs_len; + int dim; + int code_point; + Lisp_Object encoding_table; + + /* 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); + + attribute = ccs; + cpos = Fget_char_attribute (character, attribute); + if (VECTORP (v)) + { + if (!NILP (cpos)) + { + dim = XCHARSET_DIMENSION (ccs); + code_point = XINT (cpos); + while (dim > 0) + { + dim--; + i = ((code_point >> (8 * dim)) & 255) + - XCHARSET_BYTE_OFFSET (ccs); + nv = XVECTOR_DATA(v)[i]; + if (!VECTORP (nv)) + break; + v = nv; + } + if (i >= 0) + XVECTOR_DATA(v)[i] = Qnil; + v = XCHARSET_DECODING_TABLE (ccs); + } + } + if (!NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs))) + { + put_char_id_table (XCHAR (character), Qnil, encoding_table); + } + return Qt; + } + return remove_char_attribute (character, attribute); +} EXFUN (Fmake_char, 3); +EXFUN (Fdecode_char, 2); DEFUN ("define-char", Fdefine_char, 1, 1, 0, /* Store character's ATTRIBUTES. @@ -756,11 +896,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); @@ -792,7 +936,7 @@ Store character's ATTRIBUTES. 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; @@ -834,14 +978,15 @@ Lisp_Object Qascii, Qchinese_cns11643_1, Qchinese_cns11643_2, #ifdef UTF2000 - Qucs, 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, @@ -873,13 +1018,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. @@ -990,7 +1128,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; @@ -1146,7 +1284,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++; @@ -1239,7 +1377,7 @@ Lstream_funget_emchar (Lstream *stream, Emchar ch) static Lisp_Object mark_charset (Lisp_Object obj) { - struct Lisp_Charset *cs = XCHARSET (obj); + Lisp_Charset *cs = XCHARSET (obj); mark_object (cs->short_name); mark_object (cs->long_name); @@ -1247,7 +1385,8 @@ mark_charset (Lisp_Object obj) mark_object (cs->registry); mark_object (cs->ccl_program); #ifdef UTF2000 - mark_object (cs->decoding_table); + mark_object (cs->encoding_table); + /* mark_object (cs->decoding_table); */ #endif return cs->name; } @@ -1255,7 +1394,7 @@ mark_charset (Lisp_Object obj) 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) @@ -1285,9 +1424,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 } }; @@ -1295,7 +1441,7 @@ 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 @@ -1311,8 +1457,10 @@ make_charset (Charset_ID id, Lisp_Object name, { 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; @@ -1331,6 +1479,7 @@ 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; @@ -1432,24 +1581,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 @@ -1462,6 +1611,57 @@ get_unallocated_leading_byte (int dimension) } #ifdef UTF2000 +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) { @@ -1565,12 +1765,12 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) *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; @@ -1605,11 +1805,18 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) *charset = Vcharset_ucs; return c; } + /* else if (c <= MAX_CHAR_DAIKANWA) { *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; @@ -1620,14 +1827,26 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94, ((c - MIN_CHAR_94) / 94) + '0', CHARSET_LEFT_TO_RIGHT); - return ((c - MIN_CHAR_94) % 94) + 33; + if (!NILP (*charset)) + return ((c - MIN_CHAR_94) % 94) + 33; + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_96) { *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96, ((c - MIN_CHAR_96) / 96) + '0', CHARSET_LEFT_TO_RIGHT); - return ((c - MIN_CHAR_96) % 96) + 32; + if (!NILP (*charset)) + return ((c - MIN_CHAR_96) % 96) + 32; + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_94x94) { @@ -1635,8 +1854,14 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94, ((c - MIN_CHAR_94x94) / (94 * 94)) + '0', CHARSET_LEFT_TO_RIGHT); - return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8) - | (((c - MIN_CHAR_94x94) % 94) + 33); + 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) { @@ -1644,8 +1869,14 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96X96, ((c - MIN_CHAR_96x96) / (96 * 96)) + '0', CHARSET_LEFT_TO_RIGHT); - return ((((c - MIN_CHAR_96x96) / 96) % 96) + 32) << 8 - | (((c - MIN_CHAR_96x96) % 96) + 32); + 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 { @@ -1961,7 +2192,7 @@ NEW-NAME is the name of the new charset. Return the new charset. 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))) @@ -2130,7 +2361,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); @@ -2268,7 +2499,7 @@ Set mapping-table of CHARSET to TABLE. if (CHARP (c)) put_char_attribute (c, charset, - list1 (make_int (i + CHARSET_BYTE_OFFSET (cs)))); + make_int (i + CHARSET_BYTE_OFFSET (cs))); } break; case 2: @@ -2290,18 +2521,15 @@ Set mapping-table of CHARSET to TABLE. 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_attribute + (c, charset, + make_int ( ((i + CHARSET_BYTE_OFFSET (cs)) << 8) + | (j + CHARSET_BYTE_OFFSET (cs)) )); } } else if (CHARP (v)) put_char_attribute (v, charset, - list1 - (make_int (i + CHARSET_BYTE_OFFSET (cs)))); + make_int (i + CHARSET_BYTE_OFFSET (cs))); } break; } @@ -2314,6 +2542,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. @@ -2322,7 +2567,7 @@ character s with caron. */ (charset, arg1, arg2)) { - struct Lisp_Charset *cs; + Lisp_Charset *cs; int a1, a2; int lowlim, highlim; @@ -2533,6 +2778,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); @@ -2555,6 +2806,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); @@ -2562,6 +2814,9 @@ 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); @@ -2630,11 +2885,13 @@ syms_of_mule_charset (void) 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"); @@ -2693,10 +2950,10 @@ vars_of_mule_charset (void) #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 @@ -2708,19 +2965,19 @@ Leading-code of private TYPE9N charset of column-width 1. #endif #ifdef UTF2000 - Vutf_2000_version = build_string("0.14 (Kawachi-Katakami)"); + Vutf_2000_version = build_string("0.15 (Sangō)"); 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); staticpro (&Vcharacter_composition_table); - Vcharacter_composition_table = make_char_code_table (Qnil); + Vcharacter_composition_table = make_char_id_table (Qnil); staticpro (&Vcharacter_variant_table); - Vcharacter_variant_table = make_char_code_table (Qnil); + Vcharacter_variant_table = make_char_id_table (Qnil); Vdefault_coded_charset_priority_list = Qnil; DEFVAR_LISP ("default-coded-charset-priority-list", @@ -2762,14 +3019,10 @@ 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 = @@ -2842,7 +3095,9 @@ complex_vars_of_mule_charset (void) 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, 96, 1, @@ -2887,7 +3142,9 @@ complex_vars_of_mule_charset (void) 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, 96, 1, @@ -2981,6 +3238,15 @@ 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, 96, 1, @@ -3017,6 +3283,15 @@ complex_vars_of_mule_charset (void) 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,