X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=356381d013f0b96eefe912bc454e5433838e891e;hb=bf647aa9fd20de90f9fb48314918c0dca61db1d4;hp=f8bb68b339b86cd1bb9c2e2d77f8a7606dbb4eb1;hpb=e2f9623a83cef88ffe4c2c634d40c91dabdb15ca;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index f8bb68b..356381d 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -1,7 +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,2001 MORIOKA Tomohiko + Copyright (C) 1999,2000,2001,2002,2003 MORIOKA Tomohiko This file is part of XEmacs. @@ -66,50 +66,14 @@ Lisp_Object Vcharset_chinese_cns11643_2; #ifdef UTF2000 Lisp_Object Vcharset_ucs; Lisp_Object Vcharset_ucs_bmp; -Lisp_Object Vcharset_ucs_cns; -Lisp_Object Vcharset_ucs_big5; +Lisp_Object Vcharset_ucs_smp; +Lisp_Object Vcharset_ucs_sip; 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_jis_x0208; Lisp_Object Vcharset_chinese_big5; -Lisp_Object Vcharset_chinese_big5_cdp; -Lisp_Object Vcharset_ideograph_gt; -Lisp_Object Vcharset_ideograph_gt_pj_1; -Lisp_Object Vcharset_ideograph_gt_pj_2; -Lisp_Object Vcharset_ideograph_gt_pj_3; -Lisp_Object Vcharset_ideograph_gt_pj_4; -Lisp_Object Vcharset_ideograph_gt_pj_5; -Lisp_Object Vcharset_ideograph_gt_pj_6; -Lisp_Object Vcharset_ideograph_gt_pj_7; -Lisp_Object Vcharset_ideograph_gt_pj_8; -Lisp_Object Vcharset_ideograph_gt_pj_9; -Lisp_Object Vcharset_ideograph_gt_pj_10; -Lisp_Object Vcharset_ideograph_gt_pj_11; -Lisp_Object Vcharset_ideograph_daikanwa; -Lisp_Object Vcharset_mojikyo; -Lisp_Object Vcharset_mojikyo_2022_1; -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; @@ -134,7 +98,7 @@ struct charset_lookup *chlook; static const struct lrecord_description charset_lookup_description_1[] = { { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), #ifdef UTF2000 - 128+4*128 + NUM_LEADING_BYTES+4*128 #else 128+4*128*2 #endif @@ -180,1136 +144,6 @@ const Bytecount rep_bytes_by_first_byte[0xA0] = #ifdef UTF2000 -#define BT_UINT8_MIN 0 -#define BT_UINT8_MAX (UCHAR_MAX - 3) -#define BT_UINT8_t (UCHAR_MAX - 2) -#define BT_UINT8_nil (UCHAR_MAX - 1) -#define BT_UINT8_unbound UCHAR_MAX - -INLINE_HEADER int INT_UINT8_P (Lisp_Object obj); -INLINE_HEADER int UINT8_VALUE_P (Lisp_Object obj); -INLINE_HEADER unsigned char UINT8_ENCODE (Lisp_Object obj); -INLINE_HEADER Lisp_Object UINT8_DECODE (unsigned char n); -INLINE_HEADER unsigned short UINT8_TO_UINT16 (unsigned char n); - -INLINE_HEADER int -INT_UINT8_P (Lisp_Object obj) -{ - if (INTP (obj)) - { - int num = XINT (obj); - - return (BT_UINT8_MIN <= num) && (num <= BT_UINT8_MAX); - } - else - return 0; -} - -INLINE_HEADER int -UINT8_VALUE_P (Lisp_Object obj) -{ - return EQ (obj, Qunbound) - || EQ (obj, Qnil) || EQ (obj, Qt) || INT_UINT8_P (obj); -} - -INLINE_HEADER unsigned char -UINT8_ENCODE (Lisp_Object obj) -{ - if (EQ (obj, Qunbound)) - return BT_UINT8_unbound; - else if (EQ (obj, Qnil)) - return BT_UINT8_nil; - else if (EQ (obj, Qt)) - return BT_UINT8_t; - else - return XINT (obj); -} - -INLINE_HEADER Lisp_Object -UINT8_DECODE (unsigned char n) -{ - if (n == BT_UINT8_unbound) - return Qunbound; - else if (n == BT_UINT8_nil) - return Qnil; - else if (n == BT_UINT8_t) - return Qt; - else - return make_int (n); -} - -static Lisp_Object -mark_uint8_byte_table (Lisp_Object obj) -{ - return Qnil; -} - -static void -print_uint8_byte_table (Lisp_Object obj, - Lisp_Object printcharfun, int escapeflag) -{ - Lisp_Uint8_Byte_Table *bte = XUINT8_BYTE_TABLE (obj); - int i; - struct gcpro gcpro1, gcpro2; - GCPRO2 (obj, printcharfun); - - write_c_string ("\n#property[i]; - if ( (i & 15) == 0 ) - write_c_string ("\n ", printcharfun); - write_c_string (" ", printcharfun); - if (n == BT_UINT8_unbound) - write_c_string ("void", printcharfun); - else if (n == BT_UINT8_nil) - write_c_string ("nil", printcharfun); - else if (n == BT_UINT8_t) - write_c_string ("t", printcharfun); - else - { - char buf[4]; - - sprintf (buf, "%hd", n); - write_c_string (buf, printcharfun); - } - } - UNGCPRO; - write_c_string (">", printcharfun); -} - -static int -uint8_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - Lisp_Uint8_Byte_Table *te1 = XUINT8_BYTE_TABLE (obj1); - Lisp_Uint8_Byte_Table *te2 = XUINT8_BYTE_TABLE (obj2); - int i; - - for (i = 0; i < 256; i++) - if (te1->property[i] != te2->property[i]) - return 0; - return 1; -} - -static unsigned long -uint8_byte_table_hash (Lisp_Object obj, int depth) -{ - Lisp_Uint8_Byte_Table *te = XUINT8_BYTE_TABLE (obj); - int i; - hashcode_t hash = 0; - - for (i = 0; i < 256; i++) - hash = HASH2 (hash, te->property[i]); - return hash; -} - -DEFINE_LRECORD_IMPLEMENTATION ("uint8-byte-table", uint8_byte_table, - mark_uint8_byte_table, - print_uint8_byte_table, - 0, uint8_byte_table_equal, - uint8_byte_table_hash, - 0 /* uint8_byte_table_description */, - Lisp_Uint8_Byte_Table); - -static Lisp_Object -make_uint8_byte_table (unsigned char initval) -{ - Lisp_Object obj; - int i; - Lisp_Uint8_Byte_Table *cte; - - cte = alloc_lcrecord_type (Lisp_Uint8_Byte_Table, - &lrecord_uint8_byte_table); - - for (i = 0; i < 256; i++) - cte->property[i] = initval; - - XSETUINT8_BYTE_TABLE (obj, cte); - return obj; -} - -static int -uint8_byte_table_same_value_p (Lisp_Object obj) -{ - Lisp_Uint8_Byte_Table *bte = XUINT8_BYTE_TABLE (obj); - unsigned char v0 = bte->property[0]; - int i; - - for (i = 1; i < 256; i++) - { - if (bte->property[i] != v0) - return 0; - } - return -1; -} - - -#define BT_UINT16_MIN 0 -#define BT_UINT16_MAX (USHRT_MAX - 3) -#define BT_UINT16_t (USHRT_MAX - 2) -#define BT_UINT16_nil (USHRT_MAX - 1) -#define BT_UINT16_unbound USHRT_MAX - -INLINE_HEADER int INT_UINT16_P (Lisp_Object obj); -INLINE_HEADER int UINT16_VALUE_P (Lisp_Object obj); -INLINE_HEADER unsigned short UINT16_ENCODE (Lisp_Object obj); -INLINE_HEADER Lisp_Object UINT16_DECODE (unsigned short us); - -INLINE_HEADER int -INT_UINT16_P (Lisp_Object obj) -{ - if (INTP (obj)) - { - int num = XINT (obj); - - return (BT_UINT16_MIN <= num) && (num <= BT_UINT16_MAX); - } - else - return 0; -} - -INLINE_HEADER int -UINT16_VALUE_P (Lisp_Object obj) -{ - return EQ (obj, Qunbound) - || EQ (obj, Qnil) || EQ (obj, Qt) || INT_UINT16_P (obj); -} - -INLINE_HEADER unsigned short -UINT16_ENCODE (Lisp_Object obj) -{ - if (EQ (obj, Qunbound)) - return BT_UINT16_unbound; - else if (EQ (obj, Qnil)) - return BT_UINT16_nil; - else if (EQ (obj, Qt)) - return BT_UINT16_t; - else - return XINT (obj); -} - -INLINE_HEADER Lisp_Object -UINT16_DECODE (unsigned short n) -{ - if (n == BT_UINT16_unbound) - return Qunbound; - else if (n == BT_UINT16_nil) - return Qnil; - else if (n == BT_UINT16_t) - return Qt; - else - return make_int (n); -} - -INLINE_HEADER unsigned short -UINT8_TO_UINT16 (unsigned char n) -{ - if (n == BT_UINT8_unbound) - return BT_UINT16_unbound; - else if (n == BT_UINT8_nil) - return BT_UINT16_nil; - else if (n == BT_UINT8_t) - return BT_UINT16_t; - else - return n; -} - -static Lisp_Object -mark_uint16_byte_table (Lisp_Object obj) -{ - return Qnil; -} - -static void -print_uint16_byte_table (Lisp_Object obj, - Lisp_Object printcharfun, int escapeflag) -{ - Lisp_Uint16_Byte_Table *bte = XUINT16_BYTE_TABLE (obj); - int i; - struct gcpro gcpro1, gcpro2; - GCPRO2 (obj, printcharfun); - - write_c_string ("\n#property[i]; - if ( (i & 15) == 0 ) - write_c_string ("\n ", printcharfun); - write_c_string (" ", printcharfun); - if (n == BT_UINT16_unbound) - write_c_string ("void", printcharfun); - else if (n == BT_UINT16_nil) - write_c_string ("nil", printcharfun); - else if (n == BT_UINT16_t) - write_c_string ("t", printcharfun); - else - { - char buf[7]; - - sprintf (buf, "%hd", n); - write_c_string (buf, printcharfun); - } - } - UNGCPRO; - write_c_string (">", printcharfun); -} - -static int -uint16_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - Lisp_Uint16_Byte_Table *te1 = XUINT16_BYTE_TABLE (obj1); - Lisp_Uint16_Byte_Table *te2 = XUINT16_BYTE_TABLE (obj2); - int i; - - for (i = 0; i < 256; i++) - if (te1->property[i] != te2->property[i]) - return 0; - return 1; -} - -static unsigned long -uint16_byte_table_hash (Lisp_Object obj, int depth) -{ - Lisp_Uint16_Byte_Table *te = XUINT16_BYTE_TABLE (obj); - int i; - hashcode_t hash = 0; - - for (i = 0; i < 256; i++) - hash = HASH2 (hash, te->property[i]); - return hash; -} - -DEFINE_LRECORD_IMPLEMENTATION ("uint16-byte-table", uint16_byte_table, - mark_uint16_byte_table, - print_uint16_byte_table, - 0, uint16_byte_table_equal, - uint16_byte_table_hash, - 0 /* uint16_byte_table_description */, - Lisp_Uint16_Byte_Table); - -static Lisp_Object -make_uint16_byte_table (unsigned short initval) -{ - Lisp_Object obj; - int i; - Lisp_Uint16_Byte_Table *cte; - - cte = alloc_lcrecord_type (Lisp_Uint16_Byte_Table, - &lrecord_uint16_byte_table); - - for (i = 0; i < 256; i++) - cte->property[i] = initval; - - XSETUINT16_BYTE_TABLE (obj, cte); - return obj; -} - -static Lisp_Object -expand_uint8_byte_table_to_uint16 (Lisp_Object table) -{ - Lisp_Object obj; - int i; - Lisp_Uint8_Byte_Table* bte = XUINT8_BYTE_TABLE(table); - Lisp_Uint16_Byte_Table* cte; - - cte = alloc_lcrecord_type (Lisp_Uint16_Byte_Table, - &lrecord_uint16_byte_table); - for (i = 0; i < 256; i++) - { - cte->property[i] = UINT8_TO_UINT16 (bte->property[i]); - } - XSETUINT16_BYTE_TABLE (obj, cte); - return obj; -} - -static int -uint16_byte_table_same_value_p (Lisp_Object obj) -{ - Lisp_Uint16_Byte_Table *bte = XUINT16_BYTE_TABLE (obj); - unsigned short v0 = bte->property[0]; - int i; - - for (i = 1; i < 256; i++) - { - if (bte->property[i] != v0) - return 0; - } - return -1; -} - - -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 void -print_byte_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) -{ - Lisp_Byte_Table *bte = XBYTE_TABLE (obj); - int i; - struct gcpro gcpro1, gcpro2; - GCPRO2 (obj, printcharfun); - - write_c_string ("\n#property[i]; - if ( (i & 15) == 0 ) - write_c_string ("\n ", printcharfun); - write_c_string (" ", printcharfun); - if (EQ (elt, Qunbound)) - write_c_string ("void", printcharfun); - else - print_internal (elt, printcharfun, escapeflag); - } - UNGCPRO; - write_c_string (">", printcharfun); -} - -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, - print_byte_table, - 0, byte_table_equal, - byte_table_hash, - byte_table_description, - Lisp_Byte_Table); - -static Lisp_Object -make_byte_table (Lisp_Object initval) -{ - Lisp_Object obj; - int i; - Lisp_Byte_Table *cte; - - 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 int -byte_table_same_value_p (Lisp_Object obj) -{ - Lisp_Byte_Table *bte = XBYTE_TABLE (obj); - Lisp_Object v0 = bte->property[0]; - int i; - - for (i = 1; i < 256; i++) - { - if (!internal_equal (bte->property[i], v0, 0)) - return 0; - } - return -1; -} - - -Lisp_Object get_byte_table (Lisp_Object table, unsigned char idx); -Lisp_Object put_byte_table (Lisp_Object table, unsigned char idx, - Lisp_Object value); - -Lisp_Object -get_byte_table (Lisp_Object table, unsigned char idx) -{ - if (UINT8_BYTE_TABLE_P (table)) - return UINT8_DECODE (XUINT8_BYTE_TABLE(table)->property[idx]); - else if (UINT16_BYTE_TABLE_P (table)) - return UINT16_DECODE (XUINT16_BYTE_TABLE(table)->property[idx]); - else if (BYTE_TABLE_P (table)) - return XBYTE_TABLE(table)->property[idx]; - else - return table; -} - -Lisp_Object -put_byte_table (Lisp_Object table, unsigned char idx, Lisp_Object value) -{ - if (UINT8_BYTE_TABLE_P (table)) - { - if (UINT8_VALUE_P (value)) - { - XUINT8_BYTE_TABLE(table)->property[idx] = UINT8_ENCODE (value); - if (!UINT8_BYTE_TABLE_P (value) && - !UINT16_BYTE_TABLE_P (value) && !BYTE_TABLE_P (value) - && uint8_byte_table_same_value_p (table)) - { - return value; - } - } - else if (UINT16_VALUE_P (value)) - { - Lisp_Object new = expand_uint8_byte_table_to_uint16 (table); - - XUINT16_BYTE_TABLE(new)->property[idx] = UINT16_ENCODE (value); - return new; - } - else - { - Lisp_Object new = make_byte_table (Qnil); - int i; - - for (i = 0; i < 256; i++) - { - XBYTE_TABLE(new)->property[i] - = UINT8_DECODE (XUINT8_BYTE_TABLE(table)->property[i]); - } - XBYTE_TABLE(new)->property[idx] = value; - return new; - } - } - else if (UINT16_BYTE_TABLE_P (table)) - { - if (UINT16_VALUE_P (value)) - { - XUINT16_BYTE_TABLE(table)->property[idx] = UINT16_ENCODE (value); - if (!UINT8_BYTE_TABLE_P (value) && - !UINT16_BYTE_TABLE_P (value) && !BYTE_TABLE_P (value) - && uint16_byte_table_same_value_p (table)) - { - return value; - } - } - else - { - Lisp_Object new = make_byte_table (Qnil); - int i; - - for (i = 0; i < 256; i++) - { - XBYTE_TABLE(new)->property[i] - = UINT16_DECODE (XUINT16_BYTE_TABLE(table)->property[i]); - } - XBYTE_TABLE(new)->property[idx] = value; - return new; - } - } - else if (BYTE_TABLE_P (table)) - { - XBYTE_TABLE(table)->property[idx] = value; - if (!UINT8_BYTE_TABLE_P (value) && - !UINT16_BYTE_TABLE_P (value) && !BYTE_TABLE_P (value) - && byte_table_same_value_p (table)) - { - return value; - } - } - else if (!internal_equal (table, value, 0)) - { - if (UINT8_VALUE_P (table) && UINT8_VALUE_P (value)) - { - table = make_uint8_byte_table (UINT8_ENCODE (table)); - XUINT8_BYTE_TABLE(table)->property[idx] = UINT8_ENCODE (value); - } - else if (UINT16_VALUE_P (table) && UINT16_VALUE_P (value)) - { - table = make_uint16_byte_table (UINT16_ENCODE (table)); - XUINT16_BYTE_TABLE(table)->property[idx] = UINT16_ENCODE (value); - } - else - { - table = make_byte_table (table); - XBYTE_TABLE(table)->property[idx] = value; - } - } - return table; -} - -static Lisp_Object -mark_char_id_table (Lisp_Object obj) -{ - Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); - - return cte->table; -} - -static void -print_char_id_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) -{ - Lisp_Object table = XCHAR_ID_TABLE (obj)->table; - int i; - struct gcpro gcpro1, gcpro2; - GCPRO2 (obj, printcharfun); - - write_c_string ("#", printcharfun); -} - -static int -char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - Lisp_Object table1 = XCHAR_ID_TABLE (obj1)->table; - Lisp_Object table2 = XCHAR_ID_TABLE (obj2)->table; - int i; - - for (i = 0; i < 256; i++) - { - if (!internal_equal (get_byte_table (table1, i), - get_byte_table (table2, i), 0)) - return 0; - } - return -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, - print_char_id_table, - 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) -{ - Lisp_Object obj; - Lisp_Char_ID_Table *cte; - - cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); - - cte->table = make_byte_table (initval); - - XSETCHAR_ID_TABLE (obj, cte); - return obj; -} - - -Lisp_Object -get_char_id_table (Emchar ch, Lisp_Object table) -{ - unsigned int code = ch; - - return - get_byte_table - (get_byte_table - (get_byte_table - (get_byte_table - (XCHAR_ID_TABLE (table)->table, - (unsigned char)(code >> 24)), - (unsigned char) (code >> 16)), - (unsigned char) (code >> 8)), - (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_Object table1, table2, table3, table4; - - table1 = XCHAR_ID_TABLE (table)->table; - table2 = get_byte_table (table1, (unsigned char)(code >> 24)); - table3 = get_byte_table (table2, (unsigned char)(code >> 16)); - table4 = get_byte_table (table3, (unsigned char)(code >> 8)); - - table4 = put_byte_table (table4, (unsigned char)code, value); - table3 = put_byte_table (table3, (unsigned char)(code >> 8), table4); - table2 = put_byte_table (table2, (unsigned char)(code >> 16), table3); - XCHAR_ID_TABLE (table)->table - = put_byte_table (table1, (unsigned char)(code >> 24), table2); -} - - -Lisp_Object Vchar_attribute_hash_table; -Lisp_Object Vcharacter_composition_table; -Lisp_Object Vcharacter_variant_table; - -Lisp_Object Qideograph_daikanwa; -Lisp_Object Q_decomposition; -Lisp_Object Qucs; -Lisp_Object Qto_ucs; -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); - -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)); -} - - -/* We store the char-attributes in hash tables with the names as the - key and the actual char-id-table object as the value. Occasionally - we need to use them in a list format. These routines provide us - with that. */ -struct char_attribute_list_closure -{ - Lisp_Object *char_attribute_list; -}; - -static int -add_char_attribute_to_list_mapper (Lisp_Object key, Lisp_Object value, - void *char_attribute_list_closure) -{ - /* This function can GC */ - struct char_attribute_list_closure *calcl - = (struct char_attribute_list_closure*) char_attribute_list_closure; - Lisp_Object *char_attribute_list = calcl->char_attribute_list; - - *char_attribute_list = Fcons (key, *char_attribute_list); - return 0; -} - -DEFUN ("char-attribute-list", Fchar_attribute_list, 0, 0, 0, /* -Return the list of all existing character attributes except coded-charsets. -*/ - ()) -{ - Lisp_Object char_attribute_list = Qnil; - struct gcpro gcpro1; - struct char_attribute_list_closure char_attribute_list_closure; - - GCPRO1 (char_attribute_list); - char_attribute_list_closure.char_attribute_list = &char_attribute_list; - elisp_maphash (add_char_attribute_to_list_mapper, - Vchar_attribute_hash_table, - &char_attribute_list_closure); - UNGCPRO; - return char_attribute_list; -} - -DEFUN ("find-char-attribute-table", Ffind_char_attribute_table, 1, 1, 0, /* -Return char-id-table corresponding to ATTRIBUTE. -*/ - (attribute)) -{ - return Fgethash (attribute, Vchar_attribute_hash_table, Qnil); -} - - -/* We store the char-id-tables in hash tables with the attributes as - the key and the actual char-id-table object as the value. Each - char-id-table stores values of an attribute corresponding with - characters. Occasionally we need to get attributes of a character - in a association-list format. These routines provide us with - that. */ -struct char_attribute_alist_closure -{ - Emchar char_id; - Lisp_Object *char_attribute_alist; -}; - -static int -add_char_attribute_alist_mapper (Lisp_Object key, Lisp_Object value, - void *char_attribute_alist_closure) -{ - /* This function can GC */ - struct char_attribute_alist_closure *caacl = - (struct char_attribute_alist_closure*) char_attribute_alist_closure; - Lisp_Object ret = get_char_id_table (caacl->char_id, value); - if (!UNBOUNDP (ret)) - { - Lisp_Object *char_attribute_alist = caacl->char_attribute_alist; - *char_attribute_alist - = Fcons (Fcons (key, ret), *char_attribute_alist); - } - return 0; -} - -DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /* -Return the alist of attributes of CHARACTER. -*/ - (character)) -{ - Lisp_Object alist = Qnil; - int i; - - CHECK_CHAR (character); - { - struct gcpro gcpro1; - struct char_attribute_alist_closure char_attribute_alist_closure; - - GCPRO1 (alist); - char_attribute_alist_closure.char_id = XCHAR (character); - char_attribute_alist_closure.char_attribute_alist = &alist; - elisp_maphash (add_char_attribute_alist_mapper, - Vchar_attribute_hash_table, - &char_attribute_alist_closure); - UNGCPRO; - } - - for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) - { - Lisp_Object ccs = chlook->charset_by_leading_byte[i]; - - if (!NILP (ccs)) - { - 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); - } - } - } - return alist; -} - -DEFUN ("get-char-attribute", Fget_char_attribute, 2, 3, 0, /* -Return the value of CHARACTER's ATTRIBUTE. -Return DEFAULT-VALUE if the value is not exist. -*/ - (character, attribute, default_value)) -{ - 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 - { - Lisp_Object table = Fgethash (attribute, - Vchar_attribute_hash_table, - Qunbound); - if (!UNBOUNDP (table)) - { - Lisp_Object ret = get_char_id_table (XCHAR (character), table); - if (!UNBOUNDP (ret)) - return ret; - } - } - return default_value; -} - -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, 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_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); - 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_vector (1, v); - } - value = seq; - } - else if (EQ (attribute, Qto_ucs) || 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); - } -#if 0 - if (EQ (attribute, Q_ucs)) - attribute = Qto_ucs; -#endif - } - { - Lisp_Object table = Fgethash (attribute, - Vchar_attribute_hash_table, - Qnil); - - if (NILP (table)) - { - table = make_char_id_table (Qunbound); - Fputhash (attribute, table, Vchar_attribute_hash_table); - } - put_char_id_table (XCHAR (character), value, table); - return 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); - } - else - { - Lisp_Object table = Fgethash (attribute, - Vchar_attribute_hash_table, - Qunbound); - if (!UNBOUNDP (table)) - { - put_char_id_table (XCHAR (character), Qunbound, table); - return Qt; - } - } - return Qnil; -} - -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) @@ -1338,71 +172,15 @@ decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len) 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) + || !INTP (value) || (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)) @@ -1450,121 +228,38 @@ put_char_ccs_code_point (Lisp_Object character, if (VECTORP (v)) { Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); - if (!NILP (cpos)) + if (INTP (cpos)) { - decoding_table_remove_char (v, dim, byte_offset, XINT (cpos)); + decoding_table_remove_char (ccs, 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); + decoding_table_put_char (ccs, code_point, character); } - put_char_id_table (XCHAR (character), value, encoding_table); - return Qt; + return value; } Lisp_Object -remove_char_ccs (Lisp_Object character, Lisp_Object ccs) -{ - Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs); - Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); - - if (VECTORP (decoding_table)) - { - Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); - - 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; -} - -EXFUN (Fmake_char, 3); -EXFUN (Fdecode_char, 2); - -DEFUN ("define-char", Fdefine_char, 1, 1, 0, /* -Store character's ATTRIBUTES. -*/ - (attributes)) +remove_char_ccs (Lisp_Object character, Lisp_Object ccs) { - Lisp_Object rest = attributes; - Lisp_Object code = Fcdr (Fassq (Qucs, attributes)); - Lisp_Object character; + Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs); + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); - if (NILP (code)) + if (VECTORP (decoding_table)) { - 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); - if (!NILP (character)) - goto setup_attributes; - } - rest = Fcdr (rest); - } - if ( (!NILP (code = Fcdr (Fassq (Qto_ucs, attributes)))) || - (!NILP (code = Fcdr (Fassq (Q_ucs, attributes)))) ) - + Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); + + if (!NILP (cpos)) { - if (!INTP (code)) - signal_simple_error ("Invalid argument", attributes); - else - character = make_char (XINT (code) + 0x100000); - goto setup_attributes; + decoding_table_remove_char (ccs, XINT (cpos)); } - 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)) + if (CHAR_TABLEP (encoding_table)) { - Lisp_Object cell = Fcar (rest); - - if (!LISTP (cell)) - signal_simple_error ("Invalid argument", attributes); - - Fput_char_attribute (character, Fcar (cell), Fcdr (cell)); - rest = Fcdr (rest); + put_char_id_table (XCHAR_TABLE(encoding_table), character, Qunbound); } - return character; + return Qt; } -Lisp_Object Vutf_2000_version; #endif #ifndef UTF2000 @@ -1579,6 +274,10 @@ Lisp_Object Qdirection; Lisp_Object Qreverse_direction_charset; Lisp_Object Qleading_byte; Lisp_Object Qshort_name, Qlong_name; +#ifdef UTF2000 +Lisp_Object Qmin_code, Qmax_code, Qcode_offset; +Lisp_Object Qmother, Qconversion, Q94x60, Q94x94x60, Qbig5_1, Qbig5_2; +#endif Lisp_Object Qascii, Qcontrol_1, @@ -1598,58 +297,24 @@ Lisp_Object Qascii, Qchinese_gb2312, Qchinese_gb12345, Qjapanese_jisx0208, - Qjapanese_jisx0208_1990, Qkorean_ksc5601, Qjapanese_jisx0212, Qchinese_cns11643_1, Qchinese_cns11643_2, #ifdef UTF2000 + Qucs, Qucs_bmp, - Qucs_cns, - Qucs_big5, + Qucs_smp, + Qucs_sip, Qlatin_viscii, Qlatin_tcvn5712, Qlatin_viscii_lower, Qlatin_viscii_upper, Qvietnamese_viscii_lower, Qvietnamese_viscii_upper, + Qmap_jis_x0208, + Qmap_jis_x0208_1990, Qchinese_big5, - Qchinese_big5_cdp, - Qideograph_gt, - Qideograph_gt_pj_1, - Qideograph_gt_pj_2, - Qideograph_gt_pj_3, - Qideograph_gt_pj_4, - Qideograph_gt_pj_5, - Qideograph_gt_pj_6, - Qideograph_gt_pj_7, - Qideograph_gt_pj_8, - Qideograph_gt_pj_9, - Qideograph_gt_pj_10, - Qideograph_gt_pj_11, - Qmojikyo, - Qmojikyo_2022_1, - 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, @@ -1994,8 +659,8 @@ mark_charset (Lisp_Object obj) mark_object (cs->registry); mark_object (cs->ccl_program); #ifdef UTF2000 - mark_object (cs->encoding_table); - /* mark_object (cs->decoding_table); */ + mark_object (cs->decoding_table); + mark_object (cs->mother); #endif return cs->name; } @@ -2042,7 +707,7 @@ static const struct lrecord_description charset_description[] = { { 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) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, mother) }, #endif { XD_END } }; @@ -2062,8 +727,9 @@ make_charset (Charset_ID id, Lisp_Object name, Lisp_Object long_name, Lisp_Object doc, Lisp_Object reg, Lisp_Object decoding_table, - Emchar ucs_min, Emchar ucs_max, - Emchar code_offset, unsigned char byte_offset) + Emchar min_code, Emchar max_code, + Emchar code_offset, unsigned char byte_offset, + Lisp_Object mother, unsigned char conversion) { Lisp_Object obj; Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset); @@ -2087,12 +753,13 @@ make_charset (Charset_ID id, Lisp_Object name, 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; + CHARSET_DECODING_TABLE(cs) = Qunbound; + CHARSET_MIN_CODE (cs) = min_code; + CHARSET_MAX_CODE (cs) = max_code; + CHARSET_CODE_OFFSET (cs) = code_offset; + CHARSET_BYTE_OFFSET (cs) = byte_offset; + CHARSET_MOTHER (cs) = mother; + CHARSET_CONVERSION (cs) = conversion; #endif #ifndef UTF2000 @@ -2175,37 +842,157 @@ get_unallocated_leading_byte (int dimension) #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40) Emchar +decode_defined_char (Lisp_Object ccs, int code_point) +{ + int dim = XCHARSET_DIMENSION (ccs); + Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs); + Emchar char_id = -1; + Lisp_Object mother; + + while (dim > 0) + { + dim--; + decoding_table + = get_ccs_octet_table (decoding_table, ccs, + (code_point >> (dim * 8)) & 255); + } + if (CHARP (decoding_table)) + return XCHAR (decoding_table); +#ifdef HAVE_CHISE_CLIENT + if (EQ (decoding_table, Qunloaded)) + { + char_id = load_char_decoding_entry_maybe (ccs, code_point); + } +#endif + if (char_id >= 0) + return char_id; + else if ( CHARSETP (mother = XCHARSET_MOTHER (ccs)) ) + { + if ( XCHARSET_CONVERSION (ccs) == CONVERSION_IDENTICAL ) + { + if ( EQ (mother, Vcharset_ucs) ) + return DECODE_CHAR (mother, code_point); + else + return decode_defined_char (mother, code_point); + } + else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_1 ) + { + unsigned int I + = (((code_point >> 8) & 0x7F) - 33) * 94 + + (( code_point & 0x7F) - 33); + unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; + unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); + + b2 += b2 < 0x3F ? 0x40 : 0x62; + return decode_defined_char (mother, (b1 << 8) | b2); + } + else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_2 ) + { + unsigned int I + = (((code_point >> 8) & 0x7F) - 33) * 94 + + (( code_point & 0x7F) - 33) + + BIG5_SAME_ROW * (0xC9 - 0xA1); + unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; + unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); + + b2 += b2 < 0x3F ? 0x40 : 0x62; + return decode_defined_char (mother, (b1 << 8) | b2); + } + } + return -1; +} + +Emchar decode_builtin_char (Lisp_Object charset, int code_point) { + Lisp_Object mother = XCHARSET_MOTHER (charset); int final; - if (EQ (charset, Vcharset_chinese_big5)) + if ( XCHARSET_MAX_CODE (charset) > 0 ) { - int c1 = code_point >> 8; - int c2 = code_point & 0xFF; - unsigned int I; - - if ( ( (0xA1 <= c1) && (c1 <= 0xFE) ) - && - ( ((0x40 <= c2) && (c2 <= 0x7E)) || - ((0xA1 <= c2) && (c2 <= 0xFE)) ) ) + if ( CHARSETP (mother) ) { - I = (c1 - 0xA1) * BIG5_SAME_ROW - + c2 - (c2 < 0x7F ? 0x40 : 0x62); + int code = code_point; - if (c1 < 0xC9) + if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 ) { - charset = Vcharset_chinese_big5_1; + int row = code_point >> 8; + int cell = code_point & 255; + + if (row < 16 + 32) + return -1; + else if (row < 16 + 32 + 30) + code = (row - (16 + 32)) * 94 + cell - 33; + else if (row < 18 + 32 + 30) + return -1; + else if (row < 18 + 32 + 60) + code = (row - (18 + 32)) * 94 + cell - 33; } - else + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 ) + { + int plane = code_point >> 16; + int row = (code_point >> 8) & 255; + int cell = code_point & 255; + + if (row < 16 + 32) + return -1; + else if (row < 16 + 32 + 30) + code + = (plane - 33) * 94 * 60 + + (row - (16 + 32)) * 94 + + cell - 33; + else if (row < 18 + 32 + 30) + return -1; + else if (row < 18 + 32 + 60) + code + = (plane - 33) * 94 * 60 + + (row - (18 + 32)) * 94 + + cell - 33; + } + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 ) + { + unsigned int I + = (((code_point >> 8) & 0x7F) - 33) * 94 + + (( code_point & 0x7F) - 33); + unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; + unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); + + b2 += b2 < 0x3F ? 0x40 : 0x62; + code = (b1 << 8) | b2; + } + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 ) { - charset = Vcharset_chinese_big5_2; - I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1); + unsigned int I + = (((code_point >> 8) & 0x7F) - 33) * 94 + + (( code_point & 0x7F) - 33) + + BIG5_SAME_ROW * (0xC9 - 0xA1); + unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1; + unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40); + + b2 += b2 < 0x3F ? 0x40 : 0x62; + code = (b1 << 8) | b2; } - code_point = ((I / 94 + 33) << 8) | (I % 94 + 33); + return + decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset)); + } + else + { + Emchar cid + = (XCHARSET_DIMENSION (charset) == 1 + ? + code_point - XCHARSET_BYTE_OFFSET (charset) + : + ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset)) + * XCHARSET_CHARS (charset) + + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset)) + + XCHARSET_CODE_OFFSET (charset); + if ((cid < XCHARSET_MIN_CODE (charset)) + || (XCHARSET_MAX_CODE (charset) < cid)) + return -1; + return cid; } } - if ((final = XCHARSET_FINAL (charset)) >= '0') + else if ((final = XCHARSET_FINAL (charset)) >= '0') { if (XCHARSET_DIMENSION (charset) == 1) { @@ -2242,122 +1029,188 @@ decode_builtin_char (Lisp_Object charset, int code_point) } } } - else if (XCHARSET_UCS_MAX (charset)) - { - Emchar cid - = (XCHARSET_DIMENSION (charset) == 1 - ? - code_point - XCHARSET_BYTE_OFFSET (charset) - : - ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset)) - * XCHARSET_CHARS (charset) - + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset)) - - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset); - if ((cid < XCHARSET_UCS_MIN (charset)) - || (XCHARSET_UCS_MAX (charset) < cid)) - return -1; - return cid; - } else return -1; } int -range_charset_code_point (Lisp_Object charset, Emchar ch) +charset_code_point (Lisp_Object charset, Emchar ch, int defined_only) { - int d; + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset); + Lisp_Object ret; - 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 ( CHAR_TABLEP (encoding_table) + && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table), + ch)) ) + return XINT (ret); + else { - if (XCHARSET_DIMENSION (charset) == 1) + Lisp_Object mother = XCHARSET_MOTHER (charset); + int min = XCHARSET_MIN_CODE (charset); + int max = XCHARSET_MAX_CODE (charset); + int code = -1; + + if ( CHARSETP (mother) ) + { + if (XCHARSET_FINAL (charset) >= '0') + code = charset_code_point (mother, ch, 1); + else + code = charset_code_point (mother, ch, defined_only); + } + else if (defined_only) + return -1; + else if ( ((max == 0) && CHARSETP (mother) + && (XCHARSET_FINAL (charset) == 0)) + || ((min <= ch) && (ch <= max)) ) + code = ch; + if ( ((max == 0) && CHARSETP (mother) && (code >= 0)) + || ((min <= code) && (code <= max)) ) { - if (XCHARSET_CHARS (charset) == 94) + int d = code - XCHARSET_CODE_OFFSET (charset); + + if ( XCHARSET_CONVERSION (charset) == CONVERSION_IDENTICAL ) + return d; + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94 ) + return d + 33; + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96 ) + return d + 32; + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 ) { - if (((d = ch - (MIN_CHAR_94 - + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0) - && (d < 94)) - return d + 33; + int row = d / 94; + int cell = d % 94 + 33; + + if (row < 30) + row += 16 + 32; + else + row += 18 + 32; + return (row << 8) | cell; + } + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 ) + { + int B1 = d >> 8, B2 = d & 0xFF; + unsigned int I + = (B1 - 0xA1) * BIG5_SAME_ROW + B2 + - (B2 < 0x7F ? 0x40 : 0x62); + + if (B1 < 0xC9) + { + return ((I / 94 + 33) << 8) | (I % 94 + 33); + } + } + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 ) + { + int B1 = d >> 8, B2 = d & 0xFF; + unsigned int I + = (B1 - 0xA1) * BIG5_SAME_ROW + B2 + - (B2 < 0x7F ? 0x40 : 0x62); + + if (B1 >= 0xC9) + { + I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1); + return ((I / 94 + 33) << 8) | (I % 94 + 33); + } } - else if (XCHARSET_CHARS (charset) == 96) + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94 ) + return ((d / 94 + 33) << 8) | (d % 94 + 33); + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96 ) + return ((d / 96 + 32) << 8) | (d % 96 + 32); + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 ) { - if (((d = ch - (MIN_CHAR_96 - + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0) - && (d < 96)) - return d + 32; + int plane = d / (94 * 60) + 33; + int row = (d % (94 * 60)) / 94; + int cell = d % 94 + 33; + + if (row < 30) + row += 16 + 32; + else + row += 18 + 32; + return (plane << 16) | (row << 8) | cell; } + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94 ) + return + ( (d / (94 * 94) + 33) << 16) + | ((d / 94 % 94 + 33) << 8) + | (d % 94 + 33); + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96 ) + return + ( (d / (96 * 96) + 32) << 16) + | ((d / 96 % 96 + 32) << 8) + | (d % 96 + 32); + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94x94 ) + return + ( (d / (94 * 94 * 94) + 33) << 24) + | ((d / (94 * 94) % 94 + 33) << 16) + | ((d / 94 % 94 + 33) << 8) + | (d % 94 + 33); + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96x96 ) + return + ( (d / (96 * 96 * 96) + 32) << 24) + | ((d / (96 * 96) % 96 + 32) << 16) + | ((d / 96 % 96 + 32) << 8) + | (d % 96 + 32); else - return -1; + { + printf ("Unknown CCS-conversion %d is specified!", + XCHARSET_CONVERSION (charset)); + exit (-1); + } } - else if (XCHARSET_DIMENSION (charset) == 2) + else if ( ( XCHARSET_FINAL (charset) >= '0' ) && + ( XCHARSET_MIN_CODE (charset) == 0 ) + /* + (XCHARSET_CODE_OFFSET (charset) == 0) || + (XCHARSET_CODE_OFFSET (charset) + == XCHARSET_MIN_CODE (charset)) + */ ) { - if (XCHARSET_CHARS (charset) == 94) + int d; + + if (XCHARSET_DIMENSION (charset) == 1) { - if (((d = ch - (MIN_CHAR_94x94 - + (XCHARSET_FINAL (charset) - '0') * 94 * 94)) - >= 0) - && (d < 94 * 94)) - return (((d / 94) + 33) << 8) | (d % 94 + 33); + 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_CHARS (charset) == 96) + else if (XCHARSET_DIMENSION (charset) == 2) { - if (((d = ch - (MIN_CHAR_96x96 - + (XCHARSET_FINAL (charset) - '0') * 96 * 96)) - >= 0) - && (d < 96 * 96)) - return (((d / 96) + 32) << 8) | (d % 96 + 32); + 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; } - else - return -1; } } - if (EQ (charset, Vcharset_mojikyo_2022_1) - && (MIN_CHAR_MOJIKYO < ch) && (ch < MIN_CHAR_MOJIKYO + 94 * 60 * 94)) - { - int m = ch - MIN_CHAR_MOJIKYO - 1; - int byte1 = m / (94 * 60) + 33; - int byte2 = (m % (94 * 60)) / 94; - int byte3 = m % 94 + 33; - - if (byte2 < 30) - byte2 += 16 + 32; - else - byte2 += 18 + 32; - return (byte1 << 16) | (byte2 << 8) | byte3; - } return -1; } @@ -2404,20 +1257,15 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) *charset = Vcharset_ucs_bmp; return c; } - else if (c < MIN_CHAR_DAIKANWA) - { - *charset = Vcharset_ucs; - return c; - } - else if (c <= MAX_CHAR_DAIKANWA) + else if (c <= MAX_CHAR_SMP) { - *charset = Vcharset_ideograph_daikanwa; - return c - MIN_CHAR_DAIKANWA; + *charset = Vcharset_ucs_smp; + return c - MIN_CHAR_SMP; } - else if (c <= MAX_CHAR_MOJIKYO_0) + else if (c <= MAX_CHAR_SIP) { - *charset = Vcharset_mojikyo; - return c - MIN_CHAR_MOJIKYO_0; + *charset = Vcharset_ucs_sip; + return c - MIN_CHAR_SIP; } else if (c < MIN_CHAR_94) { @@ -2480,16 +1328,6 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) return c; } } - else if (c < MIN_CHAR_MOJIKYO) - { - *charset = Vcharset_ucs; - return c; - } - else if (c <= MAX_CHAR_MOJIKYO) - { - *charset = Vcharset_mojikyo; - return c - MIN_CHAR_MOJIKYO; - } else { *charset = Vcharset_ucs; @@ -2604,6 +1442,7 @@ character set. Recognized properties are: this character set. 'dimension Number of octets used to index a character in this charset. Either 1 or 2. Defaults to 1. + If UTF-2000 feature is enabled, 3 or 4 are also available. 'columns Number of columns used to display a character in this charset. Only used in TTY mode. (Under X, the actual width of a character can be derived from the font used to display the @@ -2612,6 +1451,7 @@ character set. Recognized properties are: 'chars Number of characters in each dimension (94 or 96). Defaults to 94. Note that if the dimension is 2, the character set thus described is 94x94 or 96x96. + If UTF-2000 feature is enabled, 128 or 256 are also available. 'final Final byte of ISO 2022 escape sequence. Must be supplied. Each combination of (DIMENSION, CHARS) defines a separate namespace for final bytes. Note that ISO @@ -2636,6 +1476,13 @@ character set. Recognized properties are: is passed the octets of the character, with the high bit cleared and set depending upon whether the value of the 'graphic property is 0 or 1. +'mother [UTF-2000 only] Base coded-charset. +'code-min [UTF-2000 only] Minimum code-point of a base coded-charset. +'code-max [UTF-2000 only] Maximum code-point of a base coded-charset. +'code-offset [UTF-2000 only] Offset for a code-point of a base + coded-charset. +'conversion [UTF-2000 only] Conversion for a code-point of a base + coded-charset (94x60, 94x94x60, big5-1 or big5-2). */ (name, doc_string, props)) { @@ -2645,7 +1492,10 @@ character set. Recognized properties are: Lisp_Object charset; Lisp_Object ccl_program = Qnil; Lisp_Object short_name = Qnil, long_name = Qnil; + Lisp_Object mother = Qnil; + int min_code = 0, max_code = 0, code_offset = 0; int byte_offset = -1; + int conversion = 0; CHECK_SYMBOL (name); if (!NILP (doc_string)) @@ -2664,7 +1514,7 @@ character set. Recognized properties are: short_name = value; } - if (EQ (keyword, Qlong_name)) + else if (EQ (keyword, Qlong_name)) { CHECK_STRING (value); long_name = value; @@ -2674,7 +1524,13 @@ character set. Recognized properties are: { CHECK_INT (value); dimension = XINT (value); - if (dimension < 1 || dimension > 2) + if (dimension < 1 || +#ifdef UTF2000 + dimension > 4 +#else + dimension > 2 +#endif + ) signal_simple_error ("Invalid value for 'dimension", value); } @@ -2682,7 +1538,11 @@ character set. Recognized properties are: { CHECK_INT (value); chars = XINT (value); - if (chars != 94 && chars != 96) + if (chars != 94 && chars != 96 +#ifdef UTF2000 + && chars != 128 && chars != 256 +#endif + ) signal_simple_error ("Invalid value for 'chars", value); } @@ -2698,11 +1558,13 @@ character set. Recognized properties are: { CHECK_INT (value); graphic = XINT (value); + if (graphic < 0 || #ifdef UTF2000 - if (graphic < 0 || graphic > 2) + graphic > 2 #else - if (graphic < 0 || graphic > 1) + graphic > 1 #endif + ) signal_simple_error ("Invalid value for 'graphic", value); } @@ -2730,6 +1592,45 @@ character set. Recognized properties are: signal_simple_error ("Invalid value for 'final", value); } +#ifdef UTF2000 + else if (EQ (keyword, Qmother)) + { + mother = Fget_charset (value); + } + + else if (EQ (keyword, Qmin_code)) + { + CHECK_INT (value); + min_code = XUINT (value); + } + + else if (EQ (keyword, Qmax_code)) + { + CHECK_INT (value); + max_code = XUINT (value); + } + + else if (EQ (keyword, Qcode_offset)) + { + CHECK_INT (value); + code_offset = XUINT (value); + } + + else if (EQ (keyword, Qconversion)) + { + if (EQ (value, Q94x60)) + conversion = CONVERSION_94x60; + else if (EQ (value, Q94x94x60)) + conversion = CONVERSION_94x94x60; + else if (EQ (value, Qbig5_1)) + conversion = CONVERSION_BIG5_1; + else if (EQ (value, Qbig5_2)) + conversion = CONVERSION_BIG5_2; + else + signal_simple_error ("Unrecognized conversion", value); + } + +#endif else if (EQ (keyword, Qccl_program)) { struct ccl_program test_ccl; @@ -2744,8 +1645,10 @@ character set. Recognized properties are: } } +#ifndef UTF2000 if (!final) error ("'final must be specified"); +#endif if (dimension == 2 && final > 0x5F) signal_simple_error ("Final must be in the range 0x30 - 0x5F for dimension == 2", @@ -2788,7 +1691,8 @@ character set. Recognized properties are: charset = make_charset (id, name, chars, dimension, columns, graphic, final, direction, short_name, long_name, doc_string, registry, - Qnil, 0, 0, 0, byte_offset); + Qnil, min_code, max_code, code_offset, byte_offset, + mother, conversion); if (!NILP (ccl_program)) XCHARSET_CCL_PROGRAM (charset) = ccl_program; return charset; @@ -2838,12 +1742,14 @@ NEW-NAME is the name of the new charset. Return the new charset. doc_string, registry, #ifdef UTF2000 CHARSET_DECODING_TABLE(cs), - CHARSET_UCS_MIN(cs), - CHARSET_UCS_MAX(cs), + CHARSET_MIN_CODE(cs), + CHARSET_MAX_CODE(cs), CHARSET_CODE_OFFSET(cs), - CHARSET_BYTE_OFFSET(cs) + CHARSET_BYTE_OFFSET(cs), + CHARSET_MOTHER(cs), + CHARSET_CONVERSION (cs) #else - Qnil, 0, 0, 0, 0 + Qnil, 0, 0, 0, 0, Qnil, 0 #endif ); @@ -2981,7 +1887,8 @@ Recognized properties are those listed in `make-charset', as well as if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs)); if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs)); if (EQ (prop, Qgraphic)) return make_int (CHARSET_GRAPHIC (cs)); - if (EQ (prop, Qfinal)) return make_char (CHARSET_FINAL (cs)); + if (EQ (prop, Qfinal)) return CHARSET_FINAL (cs) == 0 ? + Qnil : make_char (CHARSET_FINAL (cs)); if (EQ (prop, Qchars)) return make_int (CHARSET_CHARS (cs)); if (EQ (prop, Qregistry)) return CHARSET_REGISTRY (cs); if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs); @@ -2993,6 +1900,14 @@ Recognized properties are those listed in `make-charset', as well as /* #### Is this translation OK? If so, error checking sufficient? */ return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj; } +#ifdef UTF2000 + if (EQ (prop, Qmother)) + return CHARSET_MOTHER (cs); + if (EQ (prop, Qmin_code)) + return make_int (CHARSET_MIN_CODE (cs)); + if (EQ (prop, Qmax_code)) + return make_int (CHARSET_MAX_CODE (cs)); +#endif signal_simple_error ("Unrecognized charset property name", prop); return Qnil; /* not reached */ } @@ -3064,7 +1979,7 @@ Set mapping-table of CHARSET to TABLE. (charset, table)) { struct Lisp_Charset *cs; - size_t i; + int i; int byte_offset; charset = Fget_charset (charset); @@ -3072,8 +1987,6 @@ Set mapping-table of CHARSET to TABLE. if (NILP (table)) { - if (VECTORP (CHARSET_DECODING_TABLE(cs))) - make_vector_newer (CHARSET_DECODING_TABLE(cs)); CHARSET_DECODING_TABLE(cs) = Qnil; return table; } @@ -3108,8 +2021,8 @@ Set mapping-table of CHARSET to TABLE. Lisp_Object c = XVECTOR_DATA(table)[i]; if (CHARP (c)) - put_char_ccs_code_point (c, charset, - make_int (i + byte_offset)); + Fput_char_attribute (c, XCHARSET_NAME (charset), + make_int (i + byte_offset)); } break; case 2: @@ -3119,29 +2032,221 @@ Set mapping-table of CHARSET to TABLE. if (VECTORP (v)) { - size_t j; + int 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, + Fput_char_attribute + (c, XCHARSET_NAME (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)); + Fput_char_attribute (v, XCHARSET_NAME (charset), + make_int (i + byte_offset)); } break; } return table; } -#endif + +#ifdef HAVE_CHISE_CLIENT +DEFUN ("save-charset-mapping-table", Fsave_charset_mapping_table, 1, 1, 0, /* +Save mapping-table of CHARSET. +*/ + (charset)) +{ + struct Lisp_Charset *cs; + int byte_min, byte_max; + Lisp_Object db; + Lisp_Object db_file; + + charset = Fget_charset (charset); + cs = XCHARSET (charset); + + db_file = char_attribute_system_db_file (CHARSET_NAME (cs), + Qsystem_char_id, 1); + db = Fopen_database (db_file, Qnil, Qnil, build_string ("w+"), Qnil); + + byte_min = CHARSET_BYTE_OFFSET (cs); + byte_max = byte_min + CHARSET_BYTE_SIZE (cs); + switch (CHARSET_DIMENSION (cs)) + { + case 1: + { + Lisp_Object table_c = XCHARSET_DECODING_TABLE (charset); + int cell; + + for (cell = byte_min; cell < byte_max; cell++) + { + Lisp_Object c = get_ccs_octet_table (table_c, charset, cell); + + if (CHARP (c)) + Fput_database (Fprin1_to_string (make_int (cell), Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); + } + } + break; + case 2: + { + Lisp_Object table_r = XCHARSET_DECODING_TABLE (charset); + int row; + + for (row = byte_min; row < byte_max; row++) + { + Lisp_Object table_c = get_ccs_octet_table (table_r, charset, row); + int cell; + + for (cell = byte_min; cell < byte_max; cell++) + { + Lisp_Object c = get_ccs_octet_table (table_c, charset, cell); + + if (CHARP (c)) + Fput_database (Fprin1_to_string (make_int ((row << 8) + | cell), + Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); + } + } + } + break; + case 3: + { + Lisp_Object table_p = XCHARSET_DECODING_TABLE (charset); + int plane; + + for (plane = byte_min; plane < byte_max; plane++) + { + Lisp_Object table_r + = get_ccs_octet_table (table_p, charset, plane); + int row; + + for (row = byte_min; row < byte_max; row++) + { + Lisp_Object table_c + = get_ccs_octet_table (table_r, charset, row); + int cell; + + for (cell = byte_min; cell < byte_max; cell++) + { + Lisp_Object c = get_ccs_octet_table (table_c, charset, + cell); + + if (CHARP (c)) + Fput_database (Fprin1_to_string (make_int ((plane << 16) + | (row << 8) + | cell), + Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); + } + } + } + } + break; + default: + { + Lisp_Object table_g = XCHARSET_DECODING_TABLE (charset); + int group; + + for (group = byte_min; group < byte_max; group++) + { + Lisp_Object table_p + = get_ccs_octet_table (table_g, charset, group); + int plane; + + for (plane = byte_min; plane < byte_max; plane++) + { + Lisp_Object table_r + = get_ccs_octet_table (table_p, charset, plane); + int row; + + for (row = byte_min; row < byte_max; row++) + { + Lisp_Object table_c + = get_ccs_octet_table (table_r, charset, row); + int cell; + + for (cell = byte_min; cell < byte_max; cell++) + { + Lisp_Object c + = get_ccs_octet_table (table_c, charset, cell); + + if (CHARP (c)) + Fput_database (Fprin1_to_string + (make_int (( group << 24) + | (plane << 16) + | (row << 8) + | cell), + Qnil), + Fprin1_to_string (c, Qnil), + db, Qt); + } + } + } + } + } + } + return Fclose_database (db); +} + +DEFUN ("reset-charset-mapping-table", Freset_charset_mapping_table, 1, 1, 0, /* +Reset mapping-table of CCS with database file. +*/ + (ccs)) +{ + Lisp_Object db_file; + + ccs = Fget_charset (ccs); + db_file = char_attribute_system_db_file (XCHARSET_NAME(ccs), + Qsystem_char_id, 0); + + if (!NILP (Ffile_exists_p (db_file))) + { + XCHARSET_DECODING_TABLE(ccs) = Qunloaded; + return Qt; + } + return Qnil; +} + +Emchar +load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point) +{ + Lisp_Object db; + Lisp_Object db_file + = char_attribute_system_db_file (XCHARSET_NAME(ccs), Qsystem_char_id, + 0); + + db = Fopen_database (db_file, Qnil, Qnil, build_string ("r"), Qnil); + if (!NILP (db)) + { + Lisp_Object ret + = Fget_database (Fprin1_to_string (make_int (code_point), Qnil), + db, Qnil); + if (!NILP (ret)) + { + ret = Fread (ret); + if (CHARP (ret)) + { + decoding_table_put_char (ccs, code_point, ret); + Fclose_database (db); + return XCHAR (ret); + } + } + decoding_table_put_char (ccs, code_point, Qnil); + Fclose_database (db); + } + return -1; +} +#endif /* HAVE_CHISE_CLIENT */ +#endif /* UTF2000 */ /************************************************************************/ @@ -3149,10 +2254,12 @@ Set mapping-table of CHARSET to TABLE. /************************************************************************/ #ifdef UTF2000 -DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /* +DEFUN ("decode-char", Fdecode_char, 2, 3, 0, /* Make a character from CHARSET and code-point CODE. +If DEFINED_ONLY is non-nil, builtin character is not returned. +If corresponding character is not found, nil is returned. */ - (charset, code)) + (charset, code, defined_only)) { int c; @@ -3161,7 +2268,10 @@ Make a character from CHARSET and code-point CODE. c = XINT (code); if (XCHARSET_GRAPHIC (charset) == 1) c &= 0x7F7F7F7F; - c = DECODE_CHAR (charset, c); + if (NILP (defined_only)) + c = DECODE_CHAR (charset, c); + else + c = decode_defined_char (charset, c); return c >= 0 ? make_char (c) : Qnil; } @@ -3176,7 +2286,7 @@ Make a builtin character from CHARSET and code-point CODE. CHECK_INT (code); if (EQ (charset, Vcharset_latin_viscii)) { - Lisp_Object chr = Fdecode_char (charset, code); + Lisp_Object chr = Fdecode_char (charset, code, Qnil); Lisp_Object ret; if (!NILP (chr)) @@ -3205,7 +2315,7 @@ Make a builtin character from CHARSET and code-point CODE. c &= 0x7F7F7F7F; #endif c = decode_builtin_char (charset, c); - return c >= 0 ? make_char (c) : Fdecode_char (charset, code); + return c >= 0 ? make_char (c) : Fdecode_char (charset, code, Qnil); } #endif @@ -3300,6 +2410,25 @@ N defaults to 0 if omitted. signal_simple_error ("Octet number must be 0 or 1", n); } +#ifdef UTF2000 +DEFUN ("encode-char", Fencode_char, 2, 3, 0, /* +Return code-point of CHARACTER in specified CHARSET. +*/ + (character, charset, defined_only)) +{ + int code_point; + + CHECK_CHAR_COERCE_INT (character); + charset = Fget_charset (charset); + code_point = charset_code_point (charset, XCHAR (character), + !NILP (defined_only)); + if (code_point >= 0) + return make_int (code_point); + else + return Qnil; +} +#endif + DEFUN ("split-char", Fsplit_char, 1, 1, 0, /* Return list of charset and one or two position-codes of CHARACTER. */ @@ -3428,12 +2557,6 @@ Return a string of the characters comprising a composite character. void syms_of_mule_charset (void) { -#ifdef UTF2000 - INIT_LRECORD_IMPLEMENTATION (uint8_byte_table); - INIT_LRECORD_IMPLEMENTATION (uint16_byte_table); - INIT_LRECORD_IMPLEMENTATION (byte_table); - INIT_LRECORD_IMPLEMENTATION (char_id_table); -#endif INIT_LRECORD_IMPLEMENTATION (charset); DEFSUBR (Fcharsetp); @@ -3455,22 +2578,16 @@ syms_of_mule_charset (void) DEFSUBR (Fset_charset_ccl_program); DEFSUBR (Fset_charset_registry); #ifdef UTF2000 - DEFSUBR (Fchar_attribute_list); - DEFSUBR (Ffind_char_attribute_table); - 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); +#ifdef HAVE_CHISE_CLIENT + DEFSUBR (Fsave_charset_mapping_table); + DEFSUBR (Freset_charset_mapping_table); #endif -#ifdef UTF2000 DEFSUBR (Fdecode_char); DEFSUBR (Fdecode_builtin_char); + DEFSUBR (Fencode_char); #endif DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); @@ -3490,6 +2607,17 @@ syms_of_mule_charset (void) defsymbol (&Qreverse_direction_charset, "reverse-direction-charset"); defsymbol (&Qshort_name, "short-name"); defsymbol (&Qlong_name, "long-name"); +#ifdef UTF2000 + defsymbol (&Qmother, "mother"); + defsymbol (&Qmin_code, "min-code"); + defsymbol (&Qmax_code, "max-code"); + defsymbol (&Qcode_offset, "code-offset"); + defsymbol (&Qconversion, "conversion"); + defsymbol (&Q94x60, "94x60"); + defsymbol (&Q94x94x60, "94x94x60"); + defsymbol (&Qbig5_1, "big5-1"); + defsymbol (&Qbig5_2, "big5-2"); +#endif defsymbol (&Ql2r, "l2r"); defsymbol (&Qr2l, "r2l"); @@ -3514,79 +2642,24 @@ syms_of_mule_charset (void) defsymbol (&Qchinese_gb2312, "chinese-gb2312"); defsymbol (&Qchinese_gb12345, "chinese-gb12345"); 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 (&Qto_ucs, "=>ucs"); - 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 (&Qucs_cns, "ucs-cns"); - defsymbol (&Qucs_big5, "ucs-big5"); + defsymbol (&Qucs_smp, "ucs-smp"); + defsymbol (&Qucs_sip, "ucs-sip"); 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_gt, "ideograph-gt"); - defsymbol (&Qideograph_gt_pj_1, "ideograph-gt-pj-1"); - defsymbol (&Qideograph_gt_pj_2, "ideograph-gt-pj-2"); - defsymbol (&Qideograph_gt_pj_3, "ideograph-gt-pj-3"); - defsymbol (&Qideograph_gt_pj_4, "ideograph-gt-pj-4"); - defsymbol (&Qideograph_gt_pj_5, "ideograph-gt-pj-5"); - defsymbol (&Qideograph_gt_pj_6, "ideograph-gt-pj-6"); - defsymbol (&Qideograph_gt_pj_7, "ideograph-gt-pj-7"); - defsymbol (&Qideograph_gt_pj_8, "ideograph-gt-pj-8"); - defsymbol (&Qideograph_gt_pj_9, "ideograph-gt-pj-9"); - defsymbol (&Qideograph_gt_pj_10, "ideograph-gt-pj-10"); - defsymbol (&Qideograph_gt_pj_11, "ideograph-gt-pj-11"); - defsymbol (&Qideograph_daikanwa, "ideograph-daikanwa"); + defsymbol (&Qmap_jis_x0208, "=jis-x0208"); + defsymbol (&Qmap_jis_x0208_1990, "=jis-x0208-1990"); defsymbol (&Qchinese_big5, "chinese-big5"); - defsymbol (&Qchinese_big5_cdp, "chinese-big5-cdp"); - defsymbol (&Qmojikyo, "mojikyo"); - defsymbol (&Qmojikyo_2022_1, "mojikyo-2022-1"); - 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"); @@ -3603,8 +2676,8 @@ vars_of_mule_charset (void) int k; #endif - chlook = xnew (struct charset_lookup); - dumpstruct (&chlook, &charset_lookup_description); + chlook = xnew_and_zero (struct charset_lookup); /* zero for Purify. */ + dump_add_root_struct_ptr (&chlook, &charset_lookup_description); /* Table of charsets indexed by leading byte. */ for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) @@ -3639,17 +2712,6 @@ Leading-code of private TYPE9N charset of column-width 1. #endif #ifdef UTF2000 - Vutf_2000_version = build_string("0.17 (Hōryūji)"); - DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /* -Version number of UTF-2000. -*/ ); - - staticpro (&Vcharacter_composition_table); - Vcharacter_composition_table = make_char_id_table (Qnil); - - staticpro (&Vcharacter_variant_table); - Vcharacter_variant_table = make_char_id_table (Qnil); - Vdefault_coded_charset_priority_list = Qnil; DEFVAR_LISP ("default-coded-charset-priority-list", &Vdefault_coded_charset_priority_list /* @@ -3669,10 +2731,6 @@ complex_vars_of_mule_charset (void) ease of access. */ #ifdef UTF2000 - staticpro (&Vchar_attribute_hash_table); - Vchar_attribute_hash_table - = make_lisp_hash_table (16, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); - staticpro (&Vcharset_ucs); Vcharset_ucs = make_charset (LEADING_BYTE_UCS, Qucs, 256, 4, @@ -3681,34 +2739,37 @@ complex_vars_of_mule_charset (void) build_string ("UCS"), build_string ("ISO/IEC 10646"), build_string (""), - Qnil, 0, 0xFFFFFFF, 0, 0); + Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL); 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 ("UCS-BMP"), build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"), - build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"), - Qnil, 0, 0xFFFF, 0, 0); - staticpro (&Vcharset_ucs_cns); - Vcharset_ucs_cns = - make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3, - 1, 2, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("UCS for CNS"), - build_string ("UCS for CNS 11643"), - build_string ("ISO/IEC 10646 for CNS 11643"), - build_string (""), - Qnil, 0, 0, 0, 0); - staticpro (&Vcharset_ucs_big5); - Vcharset_ucs_big5 = - make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3, + build_string + ("\\(ISO10646.*-[01]\\|UCS00-0\\|UNICODE[23]?-0\\)"), + Qnil, 0, 0xFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ucs_smp); + Vcharset_ucs_smp = + make_charset (LEADING_BYTE_UCS_SMP, Qucs_smp, 256, 2, 1, 2, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("UCS for Big5"), - build_string ("UCS for Big5"), - build_string ("ISO/IEC 10646 for Big5"), - build_string (""), - Qnil, 0, 0, 0, 0); + build_string ("SMP"), + build_string ("UCS-SMP"), + build_string ("ISO/IEC 10646 Group 0 Plane 1 (SMP)"), + build_string ("UCS00-1"), + Qnil, MIN_CHAR_SMP, MAX_CHAR_SMP, + MIN_CHAR_SMP, 0, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ucs_sip); + Vcharset_ucs_sip = + make_charset (LEADING_BYTE_UCS_SIP, Qucs_sip, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("SIP"), + build_string ("UCS-SIP"), + build_string ("ISO/IEC 10646 Group 0 Plane 2 (SIP)"), + build_string ("\\(ISO10646.*-2\\|UCS00-2\\)"), + Qnil, MIN_CHAR_SIP, MAX_CHAR_SIP, + MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL); #else # define MIN_CHAR_THAI 0 # define MAX_CHAR_THAI 0 @@ -3725,7 +2786,7 @@ complex_vars_of_mule_charset (void) build_string ("ASCII)"), build_string ("ASCII (ISO646 IRV)"), build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"), - Qnil, 0, 0x7F, 0, 0); + Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_control_1); Vcharset_control_1 = make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1, @@ -3734,7 +2795,7 @@ complex_vars_of_mule_charset (void) build_string ("Control characters"), build_string ("Control characters 128-191"), build_string (""), - Qnil, 0x80, 0x9F, 0, 0); + Qnil, 0x80, 0x9F, 0x80, 0, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_iso8859_1); Vcharset_latin_iso8859_1 = make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1, @@ -3743,7 +2804,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-1 (Latin-1)"), build_string ("ISO8859-1 (Latin-1)"), build_string ("iso8859-1"), - Qnil, 0xA0, 0xFF, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_iso8859_2); Vcharset_latin_iso8859_2 = make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1, @@ -3752,7 +2813,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-2 (Latin-2)"), build_string ("ISO8859-2 (Latin-2)"), build_string ("iso8859-2"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_iso8859_3); Vcharset_latin_iso8859_3 = make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1, @@ -3761,7 +2822,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-3 (Latin-3)"), build_string ("ISO8859-3 (Latin-3)"), build_string ("iso8859-3"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_iso8859_4); Vcharset_latin_iso8859_4 = make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1, @@ -3770,7 +2831,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-4 (Latin-4)"), build_string ("ISO8859-4 (Latin-4)"), build_string ("iso8859-4"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_thai_tis620); Vcharset_thai_tis620 = make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1, @@ -3779,7 +2840,7 @@ complex_vars_of_mule_charset (void) build_string ("TIS620 (Thai)"), build_string ("TIS620.2529 (Thai)"), build_string ("tis620"), - Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_greek_iso8859_7); Vcharset_greek_iso8859_7 = make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1, @@ -3788,7 +2849,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-7 (Greek)"), build_string ("ISO8859-7 (Greek)"), build_string ("iso8859-7"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_arabic_iso8859_6); Vcharset_arabic_iso8859_6 = make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1, @@ -3797,7 +2858,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-6 (Arabic)"), build_string ("ISO8859-6 (Arabic)"), build_string ("iso8859-6"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_hebrew_iso8859_8); Vcharset_hebrew_iso8859_8 = make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1, @@ -3808,7 +2869,8 @@ complex_vars_of_mule_charset (void) build_string ("iso8859-8"), Qnil, 0 /* MIN_CHAR_HEBREW */, - 0 /* MAX_CHAR_HEBREW */, 0, 32); + 0 /* MAX_CHAR_HEBREW */, 0, 32, + Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_katakana_jisx0201); Vcharset_katakana_jisx0201 = make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1, @@ -3817,7 +2879,7 @@ complex_vars_of_mule_charset (void) build_string ("JISX0201.1976 (Japanese Kana)"), build_string ("JISX0201.1976 Japanese Kana"), build_string ("jisx0201\\.1976"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_jisx0201); Vcharset_latin_jisx0201 = make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1, @@ -3826,7 +2888,7 @@ complex_vars_of_mule_charset (void) build_string ("JISX0201.1976 (Japanese Roman)"), build_string ("JISX0201.1976 Japanese Roman"), build_string ("jisx0201\\.1976"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_cyrillic_iso8859_5); Vcharset_cyrillic_iso8859_5 = make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1, @@ -3835,7 +2897,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-5 (Cyrillic)"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("iso8859-5"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_iso8859_9); Vcharset_latin_iso8859_9 = make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1, @@ -3844,7 +2906,22 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-9 (Latin-5)"), build_string ("ISO8859-9 (Latin-5)"), build_string ("iso8859-9"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); +#ifdef UTF2000 + staticpro (&Vcharset_jis_x0208); + Vcharset_jis_x0208 = + make_charset (LEADING_BYTE_JIS_X0208, + Qmap_jis_x0208, 94, 2, + 2, 0, 'B', CHARSET_LEFT_TO_RIGHT, + build_string ("JIS X0208"), + build_string ("JIS X0208 Common"), + build_string ("JIS X0208 Common part"), + build_string ("jisx0208\\.1990"), + Qnil, + MIN_CHAR_JIS_X0208_1990, + MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33, + Qnil, CONVERSION_94x94); +#endif staticpro (&Vcharset_japanese_jisx0208_1978); Vcharset_japanese_jisx0208_1978 = make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, @@ -3855,7 +2932,13 @@ complex_vars_of_mule_charset (void) build_string ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"), build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, +#ifdef UTF2000 + Vcharset_jis_x0208, +#else + Qnil, +#endif + CONVERSION_IDENTICAL); staticpro (&Vcharset_chinese_gb2312); Vcharset_chinese_gb2312 = make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2, @@ -3864,7 +2947,7 @@ complex_vars_of_mule_charset (void) build_string ("GB2312)"), build_string ("GB2312 Chinese simplified"), build_string ("gb2312"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_chinese_gb12345); Vcharset_chinese_gb12345 = make_charset (LEADING_BYTE_CHINESE_GB12345, Qchinese_gb12345, 94, 2, @@ -3873,7 +2956,7 @@ complex_vars_of_mule_charset (void) build_string ("GB 12345)"), build_string ("GB 12345-1990"), build_string ("GB12345\\(\\.1990\\)?-0"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_japanese_jisx0208); Vcharset_japanese_jisx0208 = make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2, @@ -3882,20 +2965,29 @@ complex_vars_of_mule_charset (void) build_string ("JIS X0208:1983 (Japanese)"), build_string ("JIS X0208:1983 Japanese Kanji"), build_string ("jisx0208\\.1983"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, +#ifdef UTF2000 + Vcharset_jis_x0208, +#else + Qnil, +#endif + CONVERSION_IDENTICAL); #ifdef UTF2000 staticpro (&Vcharset_japanese_jisx0208_1990); Vcharset_japanese_jisx0208_1990 = make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990, - Qjapanese_jisx0208_1990, 94, 2, + Qmap_jis_x0208_1990, 94, 2, 2, 0, 0, CHARSET_LEFT_TO_RIGHT, build_string ("JISX0208-1990"), build_string ("JIS X0208:1990 (Japanese)"), build_string ("JIS X0208:1990 Japanese Kanji"), build_string ("jisx0208\\.1990"), Qnil, - MIN_CHAR_JIS_X0208_1990, - MAX_CHAR_JIS_X0208_1990, 0, 33); + 0x2121 /* MIN_CHAR_JIS_X0208_1990 */, + 0x7426 /* MAX_CHAR_JIS_X0208_1990 */, + 0 /* MIN_CHAR_JIS_X0208_1990 */, 33, + Vcharset_jis_x0208 /* Qnil */, + CONVERSION_IDENTICAL /* CONVERSION_94x94 */); #endif staticpro (&Vcharset_korean_ksc5601); Vcharset_korean_ksc5601 = @@ -3905,7 +2997,7 @@ complex_vars_of_mule_charset (void) build_string ("KSC5601 (Korean"), build_string ("KSC5601 Korean Hangul and Hanja"), build_string ("ksc5601"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_japanese_jisx0212); Vcharset_japanese_jisx0212 = make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2, @@ -3914,7 +3006,7 @@ complex_vars_of_mule_charset (void) build_string ("JISX0212 (Japanese)"), build_string ("JISX0212 Japanese Supplement"), build_string ("jisx0212"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$" staticpro (&Vcharset_chinese_cns11643_1); @@ -3926,7 +3018,7 @@ complex_vars_of_mule_charset (void) build_string ("CNS 11643 Plane 1 Chinese traditional"), build_string (CHINESE_CNS_PLANE_RE("1")), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_chinese_cns11643_2); Vcharset_chinese_cns11643_2 = make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2, @@ -3936,7 +3028,7 @@ complex_vars_of_mule_charset (void) build_string ("CNS 11643 Plane 2 Chinese traditional"), build_string (CHINESE_CNS_PLANE_RE("2")), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); #ifdef UTF2000 staticpro (&Vcharset_latin_tcvn5712); Vcharset_latin_tcvn5712 = @@ -3946,7 +3038,7 @@ complex_vars_of_mule_charset (void) build_string ("TCVN 5712 (VSCII-2)"), build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"), build_string ("tcvn5712\\(\\.1993\\)?-1"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_viscii_lower); Vcharset_latin_viscii_lower = make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1, @@ -3955,7 +3047,7 @@ complex_vars_of_mule_charset (void) build_string ("VISCII lower (Vietnamese)"), build_string ("VISCII lower (Vietnamese)"), build_string ("MULEVISCII-LOWER"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_viscii_upper); Vcharset_latin_viscii_upper = make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1, @@ -3964,7 +3056,7 @@ complex_vars_of_mule_charset (void) build_string ("VISCII upper (Vietnamese)"), build_string ("VISCII upper (Vietnamese)"), build_string ("MULEVISCII-UPPER"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_latin_viscii); Vcharset_latin_viscii = make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1, @@ -3973,7 +3065,7 @@ complex_vars_of_mule_charset (void) build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII1\\.1"), - Qnil, 0, 0, 0, 0); + Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_chinese_big5); Vcharset_chinese_big5 = make_charset (LEADING_BYTE_CHINESE_BIG5, Qchinese_big5, 256, 2, @@ -3981,111 +3073,10 @@ complex_vars_of_mule_charset (void) build_string ("Big5"), build_string ("Big5"), build_string ("Big5 Chinese traditional"), - build_string ("big5"), - Qnil, 0, 0, 0, 0); - staticpro (&Vcharset_chinese_big5_cdp); - Vcharset_chinese_big5_cdp = - make_charset (LEADING_BYTE_CHINESE_BIG5_CDP, Qchinese_big5_cdp, 256, 2, - 2, 2, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Big5-CDP"), - build_string ("Big5 + CDP extension"), - build_string ("Big5 with CDP extension"), - build_string ("big5\\.cdp-0"), - Qnil, 0, 0, 0, 0); - staticpro (&Vcharset_ideograph_gt); - Vcharset_ideograph_gt = - make_charset (LEADING_BYTE_GT, Qideograph_gt, 256, 3, - 2, 2, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("GT"), - build_string ("GT"), - build_string ("GT"), - build_string (""), - Qnil, MIN_CHAR_GT, MAX_CHAR_GT, 0, 0); -#define DEF_GT_PJ(n) \ - staticpro (&Vcharset_ideograph_gt_pj_##n); \ - Vcharset_ideograph_gt_pj_##n = \ - make_charset (LEADING_BYTE_GT_PJ_##n, Qideograph_gt_pj_##n, 94, 2, \ - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, \ - build_string ("GT-PJ-"#n), \ - build_string ("GT (pseudo JIS encoding) part "#n), \ - build_string ("GT 2000 (pseudo JIS encoding) part "#n), \ - build_string \ - ("\\(GTpj-"#n "\\|jisx0208\\.GT-"#n "\\)$"), \ - Qnil, 0, 0, 0, 33); - DEF_GT_PJ (1); - DEF_GT_PJ (2); - DEF_GT_PJ (3); - DEF_GT_PJ (4); - DEF_GT_PJ (5); - DEF_GT_PJ (6); - DEF_GT_PJ (7); - DEF_GT_PJ (8); - DEF_GT_PJ (9); - DEF_GT_PJ (10); - DEF_GT_PJ (11); - - 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_2022_1); - Vcharset_mojikyo_2022_1 = - make_charset (LEADING_BYTE_MOJIKYO_2022_1, Qmojikyo_2022_1, 94, 3, - 2, 2, ':', CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-2022-1"), - build_string ("Mojikyo ISO-2022 Part 1"), - build_string ("Konjaku-Mojikyo for ISO/IEC 2022 Part 1"), - build_string (""), - Qnil, 0, 0, 0, 33); - -#define DEF_MOJIKYO_PJ(n) \ - staticpro (&Vcharset_mojikyo_pj_##n); \ - Vcharset_mojikyo_pj_##n = \ - make_charset (LEADING_BYTE_MOJIKYO_PJ_##n, Qmojikyo_pj_##n, 94, 2, \ - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, \ - build_string ("Mojikyo-PJ-"#n), \ - build_string ("Mojikyo (pseudo JIS encoding) part "#n), \ - build_string \ - ("Konjaku-Mojikyo (pseudo JIS encoding) part "#n), \ - build_string \ - ("\\(MojikyoPJ-"#n "\\|jisx0208\\.Mojikyo-"#n "\\)$"), \ - Qnil, 0, 0, 0, 33); - - DEF_MOJIKYO_PJ (1); - DEF_MOJIKYO_PJ (2); - DEF_MOJIKYO_PJ (3); - DEF_MOJIKYO_PJ (4); - DEF_MOJIKYO_PJ (5); - DEF_MOJIKYO_PJ (6); - DEF_MOJIKYO_PJ (7); - DEF_MOJIKYO_PJ (8); - DEF_MOJIKYO_PJ (9); - DEF_MOJIKYO_PJ (10); - DEF_MOJIKYO_PJ (11); - DEF_MOJIKYO_PJ (12); - DEF_MOJIKYO_PJ (13); - DEF_MOJIKYO_PJ (14); - DEF_MOJIKYO_PJ (15); - DEF_MOJIKYO_PJ (16); - DEF_MOJIKYO_PJ (17); - DEF_MOJIKYO_PJ (18); - DEF_MOJIKYO_PJ (19); - DEF_MOJIKYO_PJ (20); - DEF_MOJIKYO_PJ (21); + build_string ("big5-0"), + Qnil, + MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP, + MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL); staticpro (&Vcharset_ethiopic_ucs); Vcharset_ethiopic_ucs = @@ -4095,7 +3086,8 @@ complex_vars_of_mule_charset (void) build_string ("Ethiopic (UCS)"), build_string ("Ethiopic of UCS"), build_string ("Ethiopic-Unicode"), - Qnil, 0x1200, 0x137F, 0x1200, 0); + Qnil, 0x1200, 0x137F, 0, 0, + Qnil, CONVERSION_IDENTICAL); #endif staticpro (&Vcharset_chinese_big5_1); Vcharset_chinese_big5_1 = @@ -4106,7 +3098,8 @@ complex_vars_of_mule_charset (void) build_string ("Big5 Level-1 Chinese traditional"), build_string ("big5"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */ + Vcharset_chinese_big5, CONVERSION_BIG5_1); staticpro (&Vcharset_chinese_big5_2); Vcharset_chinese_big5_2 = make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2, @@ -4116,7 +3109,8 @@ complex_vars_of_mule_charset (void) build_string ("Big5 Level-2 Chinese traditional"), build_string ("big5"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */ + Vcharset_chinese_big5, CONVERSION_BIG5_2); #ifdef ENABLE_COMPOSITE_CHARS /* #### For simplicity, we put composite chars into a 96x96 charset.