X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=91376d7f242574ab819526af348b4e33a1c3d441;hb=2cbece6401b2279497293e6dc54cda607f49db2f;hp=069bdd89d9c9eee8261d028c06c761ae7102dffa;hpb=b5eeb6918c29470b36f8461c402eb0c65cb19bd2;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index 069bdd8..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. @@ -53,10 +54,43 @@ Lisp_Object Vcharset_latin_iso8859_9; Lisp_Object Vcharset_japanese_jisx0208_1978; Lisp_Object Vcharset_chinese_gb2312; Lisp_Object Vcharset_japanese_jisx0208; +Lisp_Object Vcharset_japanese_jisx0208_1990; Lisp_Object Vcharset_korean_ksc5601; 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; Lisp_Object Vcharset_chinese_big5_2; @@ -77,15 +111,21 @@ 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), 128+4*128*2 }, - { XD_END } + { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), +#ifdef UTF2000 + 128+4*128 +#else + 128+4*128*2 +#endif + }, { XD_END } }; static const struct struct_description charset_lookup_description = { - sizeof(struct charset_lookup), + sizeof (struct charset_lookup), charset_lookup_description_1 }; +#ifndef UTF2000 /* Table of number of bytes in the string representation of a character indexed by the first byte of that representation. @@ -105,12 +145,1040 @@ const Bytecount rep_bytes_by_first_byte[0xA0] = 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, /* 0x80 - 0x8f are for Dimension-1 official charsets */ +#ifdef CHAR_IS_UCS4 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, +#else 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +#endif /* 0x90 - 0x9d are for Dimension-2 official charsets */ /* 0x9e is for Dimension-1 private charsets */ /* 0x9f is for Dimension-2 private charsets */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4 }; +#endif + +#ifdef UTF2000 + +static Lisp_Object +mark_byte_table (Lisp_Object obj) +{ + Lisp_Byte_Table *cte = XBYTE_TABLE (obj); + int i; + + for (i = 0; i < 256; i++) + { + mark_object (cte->property[i]); + } + return Qnil; +} + +static int +byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) +{ + Lisp_Byte_Table *cte1 = XBYTE_TABLE (obj1); + Lisp_Byte_Table *cte2 = XBYTE_TABLE (obj2); + int i; + + for (i = 0; i < 256; i++) + if (BYTE_TABLE_P (cte1->property[i])) + { + if (BYTE_TABLE_P (cte2->property[i])) + { + if (!byte_table_equal (cte1->property[i], + cte2->property[i], depth + 1)) + return 0; + } + else + return 0; + } + else + if (!internal_equal (cte1->property[i], cte2->property[i], depth + 1)) + return 0; + return 1; +} + +static unsigned long +byte_table_hash (Lisp_Object obj, int depth) +{ + Lisp_Byte_Table *cte = XBYTE_TABLE (obj); + + return internal_array_hash (cte->property, 256, depth); +} + +static const struct lrecord_description byte_table_description[] = { + { XD_LISP_OBJECT_ARRAY, offsetof(Lisp_Byte_Table, property), 256 }, + { XD_END } +}; + +DEFINE_LRECORD_IMPLEMENTATION ("byte-table", byte_table, + mark_byte_table, + internal_object_printer, + 0, byte_table_equal, + byte_table_hash, + byte_table_description, + Lisp_Byte_Table); + +static Lisp_Object +make_byte_table (Lisp_Object initval, int older) +{ + Lisp_Object obj; + int i; + 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; + + XSETBYTE_TABLE (obj, cte); + return obj; +} + +static Lisp_Object +copy_byte_table (Lisp_Object entry) +{ + Lisp_Byte_Table *cte = XBYTE_TABLE (entry); + Lisp_Object obj; + int i; + 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 (BYTE_TABLE_P (new)) + ctenew->property[i] = copy_byte_table (new); + else + ctenew->property[i] = new; + } + + XSETBYTE_TABLE (obj, ctenew); + return obj; +} + + +static Lisp_Object +mark_char_id_table (Lisp_Object obj) +{ + Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); + + return cte->table; +} + +static int +char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) +{ + Lisp_Char_ID_Table *cte1 = XCHAR_ID_TABLE (obj1); + Lisp_Char_ID_Table *cte2 = XCHAR_ID_TABLE (obj2); + + return byte_table_equal (cte1->table, cte2->table, depth + 1); +} + +static unsigned long +char_id_table_hash (Lisp_Object obj, int depth) +{ + Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); + + return char_id_table_hash (cte->table, depth + 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-id-table", char_id_table, + mark_char_id_table, + internal_object_printer, + 0, char_id_table_equal, + char_id_table_hash, + char_id_table_description, + Lisp_Char_ID_Table); + +static Lisp_Object +make_char_id_table (Lisp_Object initval, int older) +{ + Lisp_Object obj; + 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_byte_table (initval, older); + + XSETCHAR_ID_TABLE (obj, cte); + return obj; +} + +/* not used */ +#if 0 +static Lisp_Object +copy_char_id_table (Lisp_Object entry) +{ + Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (entry); + Lisp_Object obj; + Lisp_Char_ID_Table *ctenew + = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); + + ctenew->table = copy_byte_table (cte->table); + XSETCHAR_ID_TABLE (obj, ctenew); + return obj; +} +#endif + + +Lisp_Object +get_char_id_table (Emchar ch, Lisp_Object table) +{ + unsigned int code = ch; + Lisp_Byte_Table* cpt + = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table); + Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)]; + + if (BYTE_TABLE_P (ret)) + cpt = XBYTE_TABLE (ret); + else + return ret; + + ret = cpt->property [(unsigned char) (code >> 16)]; + if (BYTE_TABLE_P (ret)) + cpt = XBYTE_TABLE (ret); + else + return ret; + + ret = cpt->property [(unsigned char) (code >> 8)]; + 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_id_table (Emchar ch, Lisp_Object value, Lisp_Object table) +{ + unsigned int code = ch; + Lisp_Byte_Table* cpt1 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table); + Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)]; + + if (BYTE_TABLE_P (ret)) + { + Lisp_Byte_Table* cpt2 = XBYTE_TABLE (ret); + + ret = cpt2->property[(unsigned char)(code >> 16)]; + if (BYTE_TABLE_P (ret)) + { + Lisp_Byte_Table* cpt3 = XBYTE_TABLE (ret); + + ret = cpt3->property[(unsigned char)(code >> 8)]; + if (BYTE_TABLE_P (ret)) + { + Lisp_Byte_Table* cpt4 = XBYTE_TABLE (ret); + + cpt4->property[(unsigned char)code] = value; + } + else if (!EQ (ret, 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)) + { + 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)) + { + 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; +Lisp_Object Qsub; +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_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg) +{ + if (INTP (v)) + return XINT (v); + if (CHARP (v)) + return XCHAR (v); + else if (EQ (v, Qcompat)) + return -1; + else if (EQ (v, Qisolated)) + return -2; + else if (EQ (v, Qinitial)) + return -3; + else if (EQ (v, Qmedial)) + return -4; + else if (EQ (v, Qfinal)) + return -5; + else if (EQ (v, Qvertical)) + return -6; + else if (EQ (v, QnoBreak)) + return -7; + else if (EQ (v, Qfraction)) + return -8; + else if (EQ (v, Qsuper)) + return -9; + 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); +} + +DEFUN ("get-composite-char", Fget_composite_char, 1, 1, 0, /* +Return character corresponding with list. +*/ + (list)) +{ + Lisp_Object table = Vcharacter_composition_table; + Lisp_Object rest = list; + + while (CONSP (rest)) + { + Lisp_Object v = Fcar (rest); + Lisp_Object ret; + Emchar c = to_char_id (v, "Invalid value for composition", list); + + ret = get_char_id_table (c, table); + + rest = Fcdr (rest); + if (NILP (rest)) + { + if (!CHAR_ID_TABLE_P (ret)) + return ret; + else + return Qt; + } + else if (!CONSP (rest)) + break; + else if (CHAR_ID_TABLE_P (ret)) + table = ret; + else + signal_simple_error ("Invalid table is found with", list); + } + signal_simple_error ("Invalid value for composition", list); +} + +DEFUN ("char-variants", Fchar_variants, 1, 1, 0, /* +Return variants of CHARACTER. +*/ + (character)) +{ + CHECK_CHAR (character); + return Fcopy_list (get_char_id_table (XCHAR (character), + Vcharacter_variant_table)); +} + +DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /* +Return the alist of attributes of CHARACTER. +*/ + (character)) +{ + Lisp_Object alist, ret; + int i; + + CHECK_CHAR (character); + 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, /* +Return the value of CHARACTER's ATTRIBUTE. +*/ + (character, attribute)) +{ + Lisp_Object ccs; + + CHECK_CHAR (character); + if (!NILP (ccs = Ffind_charset (attribute))) + { + 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 if (EQ (attribute, Qname)) + { + return get_char_id_table (XCHAR (character), Vcharacter_name_table); + } + else if (EQ (attribute, Qideographic_radical)) + { + 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)); + } +} + +DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /* +Store CHARACTER's ATTRIBUTE with VALUE. +*/ + (character, attribute, value)) +{ + Lisp_Object ccs; + + CHECK_CHAR (character); + ccs = Ffind_charset (attribute); + if (!NILP (ccs)) + { + 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; + + if (!CONSP (value)) + signal_simple_error ("Invalid value for ->decomposition", + value); + + if (CONSP (Fcdr (value))) + { + 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)) + { + 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 + { + 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; + } + } + } + else + { + Lisp_Object v = Fcar (value); + + if (INTP (v)) + { + Emchar c = XINT (v); + Lisp_Object ret + = get_char_id_table (c, Vcharacter_variant_table); + + if (NILP (Fmemq (v, ret))) + { + put_char_id_table (c, Fcons (character, ret), + Vcharacter_variant_table); + } + } + seq = make_older_vector (1, v); + } + put_char_id_table (XCHAR (character), seq, + Vcharacter_decomposition_table); + return value; + } + else if (EQ (attribute, Q_ucs)) + { + Lisp_Object ret; + Emchar c; + + if (!INTP (value)) + signal_simple_error ("Invalid value for ->ucs", value); + + c = XINT (value); + + ret = get_char_id_table (c, Vcharacter_variant_table); + if (NILP (Fmemq (character, ret))) + { + 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; + + 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)) + { + 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)) + { + 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); + } + if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs))) + { + XCHARSET_ENCODING_TABLE (ccs) + = encoding_table = make_char_id_table (Qnil, -1); + } + put_char_id_table (XCHAR (character), value, encoding_table); + return Qt; +} + +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); + + if (VECTORP (decoding_table)) + { + Lisp_Object cpos = Fget_char_attribute (character, ccs); + + if (!NILP (cpos)) + { + decoding_table_remove_char (decoding_table, + XCHARSET_DIMENSION (ccs), + XCHARSET_BYTE_OFFSET (ccs), + XINT (cpos)); + } + } + if (CHAR_ID_TABLE_P (encoding_table)) + { + put_char_id_table (XCHAR (character), Qnil, encoding_table); + } + return Qt; +} + +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. +*/ + (attributes)) +{ + Lisp_Object rest = attributes; + Lisp_Object code = Fcdr (Fassq (Qucs, attributes)); + Lisp_Object character; + Lisp_Object daikanwa = Qnil; + + if (NILP (code)) + { + while (CONSP (rest)) + { + Lisp_Object cell = Fcar (rest); + Lisp_Object ccs; + + if (!LISTP (cell)) + signal_simple_error ("Invalid argument", attributes); + if (!NILP (ccs = Ffind_charset (Fcar (cell))) + && ((XCHARSET_FINAL (ccs) != 0) || + (XCHARSET_UCS_MAX (ccs) > 0)) ) + { + cell = 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); + } + if (!NILP (code = Fcdr (Fassq (Q_ucs, attributes)))) + { + if (!INTP (code)) + signal_simple_error ("Invalid argument", attributes); + else + character = make_char (XINT (code) + 0x100000); + goto setup_attributes; + } + return Qnil; + } + else if (!INTP (code)) + signal_simple_error ("Invalid argument", attributes); + else + character = make_char (XINT (code)); + + setup_attributes: + rest = 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_id_table (XCHAR (character), Vcharacter_attribute_table); +} + +Lisp_Object Vutf_2000_version; +#endif + +#ifndef UTF2000 +int leading_code_private_11; +#endif Lisp_Object Qcharsetp; @@ -138,10 +1206,43 @@ Lisp_Object Qascii, Qjapanese_jisx0208_1978, Qchinese_gb2312, Qjapanese_jisx0208, + Qjapanese_jisx0208_1990, Qkorean_ksc5601, Qjapanese_jisx0212, Qchinese_cns11643_1, Qchinese_cns11643_2, +#ifdef UTF2000 + Qucs_bmp, + Qlatin_viscii, + Qlatin_tcvn5712, + Qlatin_viscii_lower, + Qlatin_viscii_upper, + Qvietnamese_viscii_lower, + Qvietnamese_viscii_upper, + 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, Qchinese_big5_2, Qcomposite; @@ -150,9 +1251,6 @@ Lisp_Object Ql2r, Qr2l; Lisp_Object Vcharset_hash_table; -static Bufbyte next_allocated_1_byte_leading_byte; -static Bufbyte next_allocated_2_byte_leading_byte; - /* Composite characters are characters constructed by overstriking two or more regular characters. @@ -196,11 +1294,54 @@ Bytecount non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c) { Bufbyte *p; - Bufbyte lb; +#ifndef UTF2000 + Charset_ID lb; int c1, c2; Lisp_Object charset; +#endif p = str; +#ifdef UTF2000 + if ( c <= 0x7f ) + { + *p++ = c; + } + else if ( c <= 0x7ff ) + { + *p++ = (c >> 6) | 0xc0; + *p++ = (c & 0x3f) | 0x80; + } + else if ( c <= 0xffff ) + { + *p++ = (c >> 12) | 0xe0; + *p++ = ((c >> 6) & 0x3f) | 0x80; + *p++ = (c & 0x3f) | 0x80; + } + else if ( c <= 0x1fffff ) + { + *p++ = (c >> 18) | 0xf0; + *p++ = ((c >> 12) & 0x3f) | 0x80; + *p++ = ((c >> 6) & 0x3f) | 0x80; + *p++ = (c & 0x3f) | 0x80; + } + else if ( c <= 0x3ffffff ) + { + *p++ = (c >> 24) | 0xf8; + *p++ = ((c >> 18) & 0x3f) | 0x80; + *p++ = ((c >> 12) & 0x3f) | 0x80; + *p++ = ((c >> 6) & 0x3f) | 0x80; + *p++ = (c & 0x3f) | 0x80; + } + else + { + *p++ = (c >> 30) | 0xfc; + *p++ = ((c >> 24) & 0x3f) | 0x80; + *p++ = ((c >> 18) & 0x3f) | 0x80; + *p++ = ((c >> 12) & 0x3f) | 0x80; + *p++ = ((c >> 6) & 0x3f) | 0x80; + *p++ = (c & 0x3f) | 0x80; + } +#else BREAKUP_CHAR (c, charset, c1, c2); lb = CHAR_LEADING_BYTE (c); if (LEADING_BYTE_PRIVATE_P (lb)) @@ -211,7 +1352,7 @@ non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c) *p++ = c1 | 0x80; if (c2) *p++ = c2 | 0x80; - +#endif return (p - str); } @@ -220,8 +1361,51 @@ 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; + Emchar ch; + int len; + + b = *str++; + if ( b >= 0xfc ) + { + ch = (b & 0x01); + len = 5; + } + else if ( b >= 0xf8 ) + { + ch = b & 0x03; + len = 4; + } + else if ( b >= 0xf0 ) + { + ch = b & 0x07; + len = 3; + } + else if ( b >= 0xe0 ) + { + ch = b & 0x0f; + len = 2; + } + else if ( b >= 0xc0 ) + { + ch = b & 0x1f; + len = 1; + } + else + { + ch = b; + len = 0; + } + for( ; len > 0; len-- ) + { + b = *str++; + ch = ( ch << 6 ) | ( b & 0x3f ); + } + return ch; +#else Bufbyte i0 = *str, i1, i2 = 0; Lisp_Object charset; @@ -238,11 +1422,13 @@ non_ascii_charptr_emchar (CONST Bufbyte *str) i2 = *++str & 0x7F; return MAKE_CHAR (charset, i1, i2); +#endif } /* Return whether CH is a valid Emchar, assuming it's non-ASCII. Do not call this directly. Use the macro valid_char_p() instead. */ +#ifndef UTF2000 int non_ascii_valid_char_p (Emchar ch) { @@ -319,6 +1505,7 @@ non_ascii_valid_char_p (Emchar ch) return (XCHARSET_CHARS (charset) == 96); } } +#endif /************************************************************************/ @@ -330,13 +1517,17 @@ 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++; switch (REP_BYTES_BY_FIRST_BYTE (*strptr)) { /* Notice fallthrough. */ +#ifdef UTF2000 + case 6: *++strptr = *ptr++; + case 5: *++strptr = *ptr++; +#endif case 4: *++strptr = *ptr++; case 3: *++strptr = *ptr++; case 2: *++strptr = *ptr; @@ -366,6 +1557,16 @@ Lstream_get_emchar_1 (Lstream *stream, int ch) switch (REP_BYTES_BY_FIRST_BYTE (ch)) { /* Notice fallthrough. */ +#ifdef UTF2000 + case 6: + ch = Lstream_getc (stream); + assert (ch >= 0); + *++strptr = (Bufbyte) ch; + case 5: + ch = Lstream_getc (stream); + assert (ch >= 0); + *++strptr = (Bufbyte) ch; +#endif case 4: ch = Lstream_getc (stream); assert (ch >= 0); @@ -409,20 +1610,24 @@ 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); mark_object (cs->doc_string); mark_object (cs->registry); mark_object (cs->ccl_program); +#ifdef UTF2000 + /* mark_object (cs->encoding_table); */ + /* mark_object (cs->decoding_table); */ +#endif return cs->name; } 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) @@ -438,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), @@ -454,34 +1657,52 @@ 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 (Lisp_Charset, decoding_table) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) }, +#endif { XD_END } }; DEFINE_LRECORD_IMPLEMENTATION ("charset", charset, - mark_charset, print_charset, 0, 0, 0, charset_description, - struct Lisp_Charset); + mark_charset, print_charset, 0, 0, 0, + charset_description, + Lisp_Charset); /* Make a new charset. */ static Lisp_Object -make_charset (int id, Lisp_Object name, unsigned char rep_bytes, - unsigned char type, unsigned char columns, unsigned char graphic, - Bufbyte final, unsigned char direction, Lisp_Object short_name, +make_charset (Charset_ID id, Lisp_Object name, + 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) + Lisp_Object reg, + Lisp_Object decoding_table, + 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_REP_BYTES (cs) = rep_bytes; + 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; @@ -489,23 +1710,96 @@ make_charset (int id, Lisp_Object name, unsigned char rep_bytes, CHARSET_REGISTRY (cs) = reg; CHARSET_CCL_PROGRAM (cs) = Qnil; 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 - CHARSET_DIMENSION (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 || - CHARSET_TYPE (cs) == CHARSET_TYPE_96) ? 1 : 2; - CHARSET_CHARS (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 || - CHARSET_TYPE (cs) == CHARSET_TYPE_94X94) ? 94 : 96; + switch (CHARSET_CHARS (cs)) + { + case 94: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_94; + break; + case 2: + type = CHARSET_TYPE_94X94; + break; + } + break; + case 96: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_96; + break; + case 2: + type = CHARSET_TYPE_96X96; + break; + } + break; +#ifdef UTF2000 + case 128: + switch (CHARSET_DIMENSION (cs)) + { + case 1: + type = CHARSET_TYPE_128; + break; + case 2: + type = CHARSET_TYPE_128X128; + break; + } + break; + 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) + CHARSET_REP_BYTES (cs) = 1; + else if (id < 0xA0) + CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 1; + else + CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 2; +#endif if (final) { /* some charsets do not have final characters. This includes ASCII, Control-1, Composite, and the two faux private charsets. */ +#if UTF2000 + if (code_offset == 0) + { + assert (NILP (chlook->charset_by_attributes[type][final])); + chlook->charset_by_attributes[type][final] = obj; + } +#else assert (NILP (chlook->charset_by_attributes[type][final][direction])); chlook->charset_by_attributes[type][final][direction] = obj; +#endif } - assert (NILP (chlook->charset_by_leading_byte[id - 128])); - chlook->charset_by_leading_byte[id - 128] = obj; + 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. */ @@ -517,22 +1811,29 @@ make_charset (int id, Lisp_Object name, unsigned char rep_bytes, static int get_unallocated_leading_byte (int dimension) { - int lb; + Charset_ID lb; +#ifdef UTF2000 + if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE) + lb = 0; + else + 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 if (!lb) signal_simple_error @@ -542,6 +1843,284 @@ get_unallocated_leading_byte (int dimension) return lb; } +#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) +{ + int d; + + if ((XCHARSET_UCS_MIN (charset) <= ch) + && (ch <= XCHARSET_UCS_MAX (charset))) + { + d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_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 + ((d / XCHARSET_CHARS (charset) + + XCHARSET_BYTE_OFFSET (charset)) << 8) + | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset)); + else if (XCHARSET_DIMENSION (charset) == 3) + 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 + ((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) + { + if (XCHARSET_DIMENSION (charset) == 1) + { + if (XCHARSET_CHARS (charset) == 94) + { + if (((d = ch - (MIN_CHAR_94 + + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0) + && (d < 94)) + return d + 33; + } + else if (XCHARSET_CHARS (charset) == 96) + { + if (((d = ch - (MIN_CHAR_96 + + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0) + && (d < 96)) + return d + 32; + } + else + return -1; + } + else if (XCHARSET_DIMENSION (charset) == 2) + { + if (XCHARSET_CHARS (charset) == 94) + { + if (((d = ch - (MIN_CHAR_94x94 + + (XCHARSET_FINAL (charset) - '0') * 94 * 94)) + >= 0) + && (d < 94 * 94)) + return (((d / 94) + 33) << 8) | (d % 94 + 33); + } + else if (XCHARSET_CHARS (charset) == 96) + { + if (((d = ch - (MIN_CHAR_96x96 + + (XCHARSET_FINAL (charset) - '0') * 96 * 96)) + >= 0) + && (d < 96 * 96)) + return (((d / 96) + 32) << 8) | (d % 96 + 32); + } + else + return -1; + } + } + return -1; +} + +int +encode_builtin_char_1 (Emchar c, Lisp_Object* charset) +{ + if (c <= MAX_CHAR_BASIC_LATIN) + { + *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 ((MIN_CHAR_HALFWIDTH_KATAKANA <= c) + && (c <= MAX_CHAR_HALFWIDTH_KATAKANA)) + { + 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) + { + *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) + { + *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) + { + *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) + { + *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) + { + *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 + { + *charset = Vcharset_ucs; + return c; + } +} + +Lisp_Object Vdefault_coded_charset_priority_list; +#endif + /************************************************************************/ /* Basic charset Lisp functions */ @@ -601,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; } @@ -688,6 +2267,7 @@ character set. Recognized properties are: Lisp_Object rest, keyword, value; Lisp_Object ccl_program = Qnil; Lisp_Object short_name = Qnil, long_name = Qnil; + int byte_offset = -1; CHECK_SYMBOL (name); if (!NILP (doc_string)) @@ -739,7 +2319,11 @@ character set. Recognized properties are: { CHECK_INT (value); graphic = XINT (value); +#ifdef UTF2000 + if (graphic < 0 || graphic > 2) +#else if (graphic < 0 || graphic > 1) +#endif signal_simple_error ("Invalid value for 'graphic", value); } @@ -810,8 +2394,21 @@ character set. Recognized properties are: if (columns == -1) columns = dimension; - charset = make_charset (id, name, dimension + 2, type, columns, graphic, - final, direction, short_name, long_name, doc_string, registry); + + if (byte_offset < 0) + { + if (chars == 94) + byte_offset = 33; + else if (chars == 96) + byte_offset = 32; + else + byte_offset = 0; + } + + charset = make_charset (id, name, chars, dimension, columns, graphic, + final, direction, short_name, long_name, + doc_string, registry, + Qnil, 0, 0, 0, byte_offset); if (!NILP (ccl_program)) XCHARSET_CCL_PROGRAM (charset) = ccl_program; return charset; @@ -825,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))) @@ -841,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); @@ -856,9 +2453,19 @@ 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, dimension + 2, type, columns, + new_charset = make_charset (id, new_name, chars, dimension, columns, graphic, final, direction, short_name, long_name, - doc_string, registry); + doc_string, registry, +#ifdef UTF2000 + CHARSET_DECODING_TABLE(cs), + CHARSET_UCS_MIN(cs), + CHARSET_UCS_MAX(cs), + CHARSET_CODE_OFFSET(cs), + CHARSET_BYTE_OFFSET(cs) +#else + Qnil, 0, 0, 0, 0 +#endif +); CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset; XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset; @@ -866,6 +2473,16 @@ NEW-NAME is the name of the new charset. Return the new charset. return new_charset; } +DEFUN ("define-charset-alias", Fdefine_charset_alias, 2, 2, 0, /* +Define symbol ALIAS as an alias for CHARSET. +*/ + (alias, charset)) +{ + CHECK_SYMBOL (alias); + charset = Fget_charset (charset); + return Fputhash (alias, charset, Vcharset_hash_table); +} + /* #### Reverse direction charsets not yet implemented. */ #if 0 DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset, @@ -977,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); @@ -1044,7 +2661,6 @@ invalidate_charset_font_caches (Lisp_Object charset) } } -/* Japanese folks may want to (set-charset-registry 'ascii "jisx0201") */ DEFUN ("set-charset-registry", Fset_charset_registry, 2, 2, 0, /* Set the 'registry property of CHARSET to REGISTRY. */ @@ -1058,11 +2674,120 @@ Set the 'registry property of CHARSET to REGISTRY. return Qnil; } +#ifdef UTF2000 +DEFUN ("charset-mapping-table", Fcharset_mapping_table, 1, 1, 0, /* +Return mapping-table of CHARSET. +*/ + (charset)) +{ + return XCHARSET_DECODING_TABLE (Fget_charset (charset)); +} + +DEFUN ("set-charset-mapping-table", Fset_charset_mapping_table, 2, 2, 0, /* +Set mapping-table of CHARSET to TABLE. +*/ + (charset, table)) +{ + struct Lisp_Charset *cs; + size_t i; + int byte_offset; + + charset = Fget_charset (charset); + cs = XCHARSET (charset); + + if (NILP (table)) + { + CHARSET_DECODING_TABLE(cs) = Qnil; + return table; + } + else if (VECTORP (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)); + + byte_offset = CHARSET_BYTE_OFFSET (cs); + switch (CHARSET_DIMENSION (cs)) + { + case 1: + for (i = 0; i < XVECTOR_LENGTH (table); i++) + { + Lisp_Object c = XVECTOR_DATA(table)[i]; + + if (CHARP (c)) + put_char_ccs_code_point (c, charset, + make_int (i + byte_offset)); + } + break; + case 2: + for (i = 0; i < XVECTOR_LENGTH (table); i++) + { + Lisp_Object v = XVECTOR_DATA(table)[i]; + + if (VECTORP (v)) + { + size_t j; + + for (j = 0; j < XVECTOR_LENGTH (v); j++) + { + Lisp_Object c = XVECTOR_DATA(v)[j]; + + if (CHARP (c)) + put_char_ccs_code_point + (c, charset, + make_int ( ( (i + byte_offset) << 8 ) + | (j + byte_offset) + ) ); + } + } + else if (CHARP (v)) + put_char_ccs_code_point (v, charset, + make_int (i + byte_offset)); + } + break; + } + return table; +} +#endif + /************************************************************************/ /* 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. @@ -1071,7 +2796,7 @@ character s with caron. */ (charset, arg1, arg2)) { - struct Lisp_Charset *cs; + Lisp_Charset *cs; int a1, a2; int lowlim, highlim; @@ -1080,6 +2805,9 @@ character s with caron. if (EQ (charset, Vcharset_ascii)) lowlim = 0, highlim = 127; else if (EQ (charset, Vcharset_control_1)) lowlim = 0, highlim = 31; +#ifdef UTF2000 + else if (CHARSET_CHARS (cs) == 256) lowlim = 0, highlim = 255; +#endif else if (CHARSET_CHARS (cs) == 94) lowlim = 33, highlim = 126; else /* CHARSET_CHARS (cs) == 96) */ lowlim = 32, highlim = 127; @@ -1088,7 +2816,13 @@ character s with caron. the 8th bit off ARG1 and ARG2 becaue it allows programmers to write (make-char 'latin-iso8859-2 CODE) where code is the actual Latin 2 code of the character. */ - a1 = XINT (arg1) & 0x7f; +#ifdef UTF2000 + a1 = XINT (arg1); + if (highlim < 128) + a1 &= 0x7f; +#else + a1 = XINT (arg1); +#endif if (a1 < lowlim || a1 > highlim) args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim)); @@ -1101,7 +2835,13 @@ character s with caron. } CHECK_INT (arg2); +#ifdef UTF2000 + a2 = XINT (arg2); + if (highlim < 128) + a2 &= 0x7f; +#else a2 = XINT (arg2) & 0x7f; +#endif if (a2 < lowlim || a2 > highlim) args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim)); @@ -1115,8 +2855,7 @@ Return the character set of char CH. { CHECK_CHAR_COERCE_INT (ch); - return XCHARSET_NAME (CHARSET_BY_LEADING_BYTE - (CHAR_LEADING_BYTE (XCHAR (ch)))); + return XCHARSET_NAME (CHAR_CHARSET (XCHAR (ch))); } DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /* @@ -1149,11 +2888,27 @@ Return list of charset and one or two position-codes of CHAR. 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) @@ -1164,6 +2919,7 @@ Return list of charset and one or two position-codes of CHAR. { rc = list2 (XCHARSET_NAME (charset), make_int (c1)); } +#endif UNGCPRO; return rc; @@ -1251,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); @@ -1259,6 +3021,7 @@ syms_of_mule_charset (void) DEFSUBR (Fmake_charset); DEFSUBR (Fmake_reverse_direction_charset); /* DEFSUBR (Freverse_direction_charset); */ + DEFSUBR (Fdefine_charset_alias); DEFSUBR (Fcharset_from_attributes); DEFSUBR (Fcharset_short_name); DEFSUBR (Fcharset_long_name); @@ -1268,7 +3031,21 @@ syms_of_mule_charset (void) DEFSUBR (Fcharset_id); DEFSUBR (Fset_charset_ccl_program); DEFSUBR (Fset_charset_registry); +#ifdef UTF2000 + 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); + DEFSUBR (Fcharset_mapping_table); + DEFSUBR (Fset_charset_mapping_table); +#endif +#ifdef UTF2000 + DEFSUBR (Fdecode_char); +#endif DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); DEFSUBR (Fchar_octet); @@ -1310,10 +3087,68 @@ syms_of_mule_charset (void) defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978"); defsymbol (&Qchinese_gb2312, "chinese-gb2312"); defsymbol (&Qjapanese_jisx0208, "japanese-jisx0208"); + defsymbol (&Qjapanese_jisx0208_1990, "japanese-jisx0208-1990"); defsymbol (&Qkorean_ksc5601, "korean-ksc5601"); defsymbol (&Qjapanese_jisx0212, "japanese-jisx0212"); 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"); + defsymbol (&Qsub, "sub"); + defsymbol (&Qcircle, "circle"); + 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"); defsymbol (&Qchinese_big5_2, "chinese-big5-2"); @@ -1323,7 +3158,10 @@ syms_of_mule_charset (void) void vars_of_mule_charset (void) { - int i, j, k; + int i, j; +#ifndef UTF2000 + int k; +#endif chlook = xnew (struct charset_lookup); dumpstruct (&chlook, &charset_lookup_description); @@ -1332,14 +3170,73 @@ vars_of_mule_charset (void) 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 (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 (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 + chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE; +#else + 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 + leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1; + DEFVAR_INT ("leading-code-private-11", &leading_code_private_11 /* +Leading-code of private TYPE9N charset of column-width 1. +*/ ); + leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1; +#endif + +#ifdef UTF2000 + 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_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); - next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; - next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; + /* 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_id_table (Qnil, 0); + + Vdefault_coded_charset_priority_list = Qnil; + DEFVAR_LISP ("default-coded-charset-priority-list", + &Vdefault_coded_charset_priority_list /* +Default order of preferred coded-character-sets. +*/ ); +#endif } void @@ -1352,221 +3249,541 @@ complex_vars_of_mule_charset (void) /* Predefined character sets. We store them into variables for 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, 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)"), + build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"), + Qnil, 0, 0xFFFF, 0, 0); +#else +# define MIN_CHAR_THAI 0 +# define MAX_CHAR_THAI 0 +# define MIN_CHAR_HEBREW 0 +# define MAX_CHAR_HEBREW 0 +# define MIN_CHAR_HALFWIDTH_KATAKANA 0 +# define MAX_CHAR_HALFWIDTH_KATAKANA 0 +#endif staticpro (&Vcharset_ascii); Vcharset_ascii = - make_charset (LEADING_BYTE_ASCII, Qascii, 1, - 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\\)")); + 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, 2, - 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 ("")); + 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, 2, - 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")); + 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, 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")); + 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, 2, - 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")); + 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, 2, - 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")); + build_string ("iso8859-4"), + Qnil, 0, 0, 0, 32); staticpro (&Vcharset_thai_tis620); Vcharset_thai_tis620 = - make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2, - 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")); + 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, 2, - 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")); + build_string ("iso8859-7"), + 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, 2, - 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")); + 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, 2, - 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")); + 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, 2, - 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")); + build_string ("jisx0201\\.1976"), + Qnil, 0, 0, 0, 33); staticpro (&Vcharset_latin_jisx0201); Vcharset_latin_jisx0201 = - make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 2, - 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")); + 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, 2, - 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")); + build_string ("iso8859-5"), + 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, 2, - 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")); + 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, 3, - CHARSET_TYPE_94X94, 2, 0, '@', - CHARSET_LEFT_TO_RIGHT, - build_string ("JISX0208.1978"), - build_string ("JISX0208.1978 (Japanese)"), + 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 - ("JISX0208.1978 Japanese Kanji (so called \"old JIS\")"), - build_string ("\\(jisx0208\\|jisc6226\\)\\.1978")); + ("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, 3, - 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")); + build_string ("gb2312"), + Qnil, 0, 0, 0, 33); staticpro (&Vcharset_japanese_jisx0208); Vcharset_japanese_jisx0208 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 3, - 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 ("JISX0208.1983/1990 (Japanese)"), - build_string ("JISX0208.1983/1990 Japanese Kanji"), - build_string ("jisx0208.19\\(83\\|90\\)")); + 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, 94, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("JISX0208-1990"), + build_string ("JIS X0208:1990 (Japanese)"), + build_string ("JIS X0208:1990 Japanese Kanji"), + build_string ("jisx0208\\.1990"), + 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, 3, - 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")); + build_string ("ksc5601"), + Qnil, 0, 0, 0, 33); staticpro (&Vcharset_japanese_jisx0212); Vcharset_japanese_jisx0212 = - make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 3, - 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"), - build_string ("jisx0212")); + build_string ("jisx0212"), + 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, 3, - 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"))); + 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, 3, - 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 ("CNS 11643 Plane 2 Chinese traditional"), - build_string (CHINESE_CNS_PLANE_RE("2"))); + 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, + 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, 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, 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, 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, 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, 3, - 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")); + 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, 3, - 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 ("Big5 Level-2 Chinese traditional"), - build_string ("big5")); - + build_string ("big5"), + Qnil, 0, 0, 0, 33); #ifdef ENABLE_COMPOSITE_CHARS /* #### For simplicity, we put composite chars into a 96x96 charset. @@ -1574,9 +3791,8 @@ complex_vars_of_mule_charset (void) room, esp. as we don't yet recycle numbers. */ staticpro (&Vcharset_composite); Vcharset_composite = - make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 3, - 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"),