X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=f184a29a505744f2b81f80d5a509d92fe71a3a23;hb=112b4eb6a71cd613a534b4246b4cc024ed9bf22e;hp=6f89233c62c03b88769cadb1e82b53fa94883345;hpb=bd584c4d0c3b5d213e5340bea5d9706c79f48c4d;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index 6f89233..f184a29 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,2001,2002 MORIOKA Tomohiko This file is part of XEmacs. @@ -19,11 +20,14 @@ along with XEmacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/* Synched up with: FSF 20.3. Not in FSF. */ - /* Rewritten by Ben Wing . */ +/* Rewritten by MORIOKA Tomohiko for XEmacs UTF-2000. */ + #include +#ifdef UTF2000 +#include +#endif #include "lisp.h" #include "buffer.h" @@ -52,16 +56,55 @@ Lisp_Object Vcharset_cyrillic_iso8859_5; Lisp_Object Vcharset_latin_iso8859_9; Lisp_Object Vcharset_japanese_jisx0208_1978; Lisp_Object Vcharset_chinese_gb2312; +Lisp_Object Vcharset_chinese_gb12345; 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_ucs_smp; +Lisp_Object Vcharset_ucs_sip; +Lisp_Object Vcharset_ucs_cns; +Lisp_Object Vcharset_ucs_jis; +Lisp_Object Vcharset_ucs_ks; +Lisp_Object Vcharset_ucs_big5; 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_chinese_big5; +/* Lisp_Object Vcharset_chinese_big5_cdp; */ +Lisp_Object Vcharset_ideograph_hanziku_1; +Lisp_Object Vcharset_ideograph_hanziku_2; +Lisp_Object Vcharset_ideograph_hanziku_3; +Lisp_Object Vcharset_ideograph_hanziku_4; +Lisp_Object Vcharset_ideograph_hanziku_5; +Lisp_Object Vcharset_ideograph_hanziku_6; +Lisp_Object Vcharset_ideograph_hanziku_7; +Lisp_Object Vcharset_ideograph_hanziku_8; +Lisp_Object Vcharset_ideograph_hanziku_9; +Lisp_Object Vcharset_ideograph_hanziku_10; +Lisp_Object Vcharset_ideograph_hanziku_11; +Lisp_Object Vcharset_ideograph_hanziku_12; +Lisp_Object Vcharset_china3_jef; +Lisp_Object Vcharset_ideograph_cbeta; +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_2; Lisp_Object Vcharset_ideograph_daikanwa; Lisp_Object Vcharset_ethiopic_ucs; #endif @@ -82,15 +125,22 @@ static int composite_char_col_next; #endif /* ENABLE_COMPOSITE_CHARS */ -/* Table of charsets indexed by leading byte. */ -Lisp_Object charset_by_leading_byte[NUM_LEADING_BYTES]; +struct charset_lookup *chlook; -/* Table of charsets indexed by type/final-byte/direction. */ +static const struct lrecord_description charset_lookup_description_1[] = { + { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), #ifdef UTF2000 -Lisp_Object charset_by_attributes[4][128]; + 128+4*128 #else -Lisp_Object charset_by_attributes[4][128][2]; + 128+4*128*2 #endif + }, { XD_END } +}; + +static const struct struct_description charset_lookup_description = { + sizeof (struct charset_lookup), + charset_lookup_description_1 +}; #ifndef UTF2000 /* Table of number of bytes in the string representation of a character @@ -99,9 +149,9 @@ Lisp_Object charset_by_attributes[4][128][2]; rep_bytes_by_first_byte(c) is more efficient than the equivalent canonical computation: - (BYTE_ASCII_P (c) ? 1 : XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c))) */ + XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */ -Bytecount rep_bytes_by_first_byte[0xA0] = +const Bytecount rep_bytes_by_first_byte[0xA0] = { /* 0x00 - 0x7f are for straight ASCII */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -126,600 +176,122 @@ Bytecount rep_bytes_by_first_byte[0xA0] = #ifdef UTF2000 -static Lisp_Object -mark_char_byte_table (Lisp_Object obj, void (*markobj) (Lisp_Object)) -{ - struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj); - int i; - - for (i = 0; i < 256; i++) - { - markobj (cte->property[i]); - } - return Qnil; -} - -static int -char_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - struct Lisp_Char_Byte_Table *cte1 = XCHAR_BYTE_TABLE (obj1); - struct Lisp_Char_Byte_Table *cte2 = XCHAR_BYTE_TABLE (obj2); - int i; - - for (i = 0; i < 256; i++) - if (CHAR_BYTE_TABLE_P (cte1->property[i])) - { - if (CHAR_BYTE_TABLE_P (cte2->property[i])) - { - if (!char_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 -char_byte_table_hash (Lisp_Object obj, int depth) -{ - struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj); - - return internal_array_hash (cte->property, 256, depth); -} - -static const struct lrecord_description char_byte_table_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Byte_Table, property), 256 }, - { XD_END } -}; - -DEFINE_LRECORD_IMPLEMENTATION ("char-byte-table", char_byte_table, - mark_char_byte_table, - internal_object_printer, - 0, char_byte_table_equal, - char_byte_table_hash, - char_byte_table_description, - struct Lisp_Char_Byte_Table); - -static Lisp_Object -make_char_byte_table (Lisp_Object initval) +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) { - Lisp_Object obj; int i; - struct Lisp_Char_Byte_Table *cte = - alloc_lcrecord_type (struct Lisp_Char_Byte_Table, - &lrecord_char_byte_table); - - for (i = 0; i < 256; i++) - cte->property[i] = initval; - - XSETCHAR_BYTE_TABLE (obj, cte); - return obj; -} -static Lisp_Object -copy_char_byte_table (Lisp_Object entry) -{ - struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (entry); - Lisp_Object obj; - int i; - struct Lisp_Char_Byte_Table *ctenew = - alloc_lcrecord_type (struct Lisp_Char_Byte_Table, - &lrecord_char_byte_table); + if (XVECTOR_LENGTH (v) > ccs_len) + return -1; - for (i = 0; i < 256; i++) + for (i = 0; i < XVECTOR_LENGTH (v); i++) { - Lisp_Object new = cte->property[i]; - if (CHAR_BYTE_TABLE_P (new)) - ctenew->property[i] = copy_char_byte_table (new); - else - ctenew->property[i] = new; - } - - XSETCHAR_BYTE_TABLE (obj, ctenew); - return obj; -} - - -static Lisp_Object -mark_char_code_table (Lisp_Object obj, void (*markobj) (Lisp_Object)) -{ - struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (obj); - - return cte->table; -} - -static int -char_code_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - struct Lisp_Char_Code_Table *cte1 = XCHAR_CODE_TABLE (obj1); - struct Lisp_Char_Code_Table *cte2 = XCHAR_CODE_TABLE (obj2); - - return char_byte_table_equal (cte1->table, cte2->table, depth + 1); -} - -static unsigned long -char_code_table_hash (Lisp_Object obj, int depth) -{ - struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (obj); - - return char_code_table_hash (cte->table, depth + 1); -} - -static const struct lrecord_description char_code_table_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Code_Table, table), 1 }, - { XD_END } -}; - -DEFINE_LRECORD_IMPLEMENTATION ("char-code-table", char_code_table, - mark_char_code_table, - internal_object_printer, - 0, char_code_table_equal, - char_code_table_hash, - char_code_table_description, - struct Lisp_Char_Code_Table); - -static Lisp_Object -make_char_code_table (Lisp_Object initval) -{ - Lisp_Object obj; - struct Lisp_Char_Code_Table *cte = - alloc_lcrecord_type (struct Lisp_Char_Code_Table, - &lrecord_char_code_table); - - cte->table = make_char_byte_table (initval); - - XSETCHAR_CODE_TABLE (obj, cte); - return obj; -} - -static Lisp_Object -copy_char_code_table (Lisp_Object entry) -{ - struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (entry); - Lisp_Object obj; - struct Lisp_Char_Code_Table *ctenew = - alloc_lcrecord_type (struct Lisp_Char_Code_Table, - &lrecord_char_code_table); - - ctenew->table = copy_char_byte_table (cte->table); - XSETCHAR_CODE_TABLE (obj, ctenew); - return obj; -} - - -Lisp_Object -get_char_code_table (Emchar ch, Lisp_Object table) -{ - unsigned int code = ch; - struct Lisp_Char_Byte_Table* cpt - = XCHAR_BYTE_TABLE (XCHAR_CODE_TABLE (table)->table); - Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)]; - - if (CHAR_BYTE_TABLE_P (ret)) - cpt = XCHAR_BYTE_TABLE (ret); - else - return ret; - - ret = cpt->property [(unsigned char) (code >> 16)]; - if (CHAR_BYTE_TABLE_P (ret)) - cpt = XCHAR_BYTE_TABLE (ret); - else - return ret; + Lisp_Object c = XVECTOR_DATA(v)[i]; - ret = cpt->property [(unsigned char) (code >> 8)]; - if (CHAR_BYTE_TABLE_P (ret)) - cpt = XCHAR_BYTE_TABLE (ret); - else - return ret; - - return cpt->property [(unsigned char) code]; -} - -void -put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table) -{ - unsigned int code = ch; - struct Lisp_Char_Byte_Table* cpt1 - = XCHAR_BYTE_TABLE (XCHAR_CODE_TABLE (table)->table); - Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)]; - - if (CHAR_BYTE_TABLE_P (ret)) - { - struct Lisp_Char_Byte_Table* cpt2 = XCHAR_BYTE_TABLE (ret); - - ret = cpt2->property[(unsigned char)(code >> 16)]; - if (CHAR_BYTE_TABLE_P (ret)) + if (!NILP (c) && !CHARP (c)) { - struct Lisp_Char_Byte_Table* cpt3 = XCHAR_BYTE_TABLE (ret); - - ret = cpt3->property[(unsigned char)(code >> 8)]; - if (CHAR_BYTE_TABLE_P (ret)) - { - struct Lisp_Char_Byte_Table* cpt4 - = XCHAR_BYTE_TABLE (ret); - - cpt4->property[(unsigned char)code] = value; - } - else if (!EQ (ret, value)) + if (VECTORP (c)) { - Lisp_Object cpt4 = make_char_byte_table (ret); - - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - cpt3->property[(unsigned char)(code >> 8)] = cpt4; + int ret = decoding_table_check_elements (c, dim - 1, ccs_len); + if (ret) + return ret; } - } - else if (!EQ (ret, value)) - { - Lisp_Object cpt3 = make_char_byte_table (ret); - Lisp_Object cpt4 = make_char_byte_table (ret); - - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] - = cpt4; - cpt2->property[(unsigned char)(code >> 16)] = cpt3; - } - } - else if (!EQ (ret, value)) - { - Lisp_Object cpt2 = make_char_byte_table (ret); - Lisp_Object cpt3 = make_char_byte_table (ret); - Lisp_Object cpt4 = make_char_byte_table (ret); - - XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4; - XCHAR_BYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3; - cpt1->property[(unsigned char)(code >> 24)] = cpt2; - } -} - - -Lisp_Object Vcharacter_attribute_table; -Lisp_Object Vcharacter_composition_table; -Lisp_Object Vcharacter_variant_table; - -Lisp_Object Q_decomposition; -Lisp_Object Q_ucs; -Lisp_Object Qcompat; -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 Qfont; - -Emchar -to_char_code (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, QnoBreak)) - return -2; - else if (EQ (v, Qfraction)) - return -3; - else if (EQ (v, Qsuper)) - return -4; - else if (EQ (v, Qsub)) - return -5; - else if (EQ (v, Qcircle)) - return -6; - else if (EQ (v, Qsquare)) - return -7; - else if (EQ (v, Qwide)) - return -8; - else if (EQ (v, Qnarrow)) - return -9; - else if (EQ (v, Qfont)) - return -10; - 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_code (v, "Invalid value for composition", list); - - ret = get_char_code_table (c, table); - - rest = Fcdr (rest); - if (NILP (rest)) - { - if (!CHAR_CODE_TABLE_P (ret)) - return ret; else - return Qt; + return -2; } - else if (!CONSP (rest)) - break; - else if (CHAR_CODE_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_code_table (XCHAR (character), - Vcharacter_variant_table)); -} - -DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /* -Return the alist of attributes of CHARACTER. -*/ - (character)) -{ - CHECK_CHAR (character); - return Fcopy_alist (get_char_code_table (XCHAR (character), - Vcharacter_attribute_table)); -} - -DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /* -Return the value of CHARACTER's ATTRIBUTE. -*/ - (character, attribute)) -{ - Lisp_Object ret; - Lisp_Object ccs; - - CHECK_CHAR (character); - ret = get_char_code_table (XCHAR (character), - Vcharacter_attribute_table); - if (EQ (ret, Qnil)) - return Qnil; - - if (!NILP (ccs = Ffind_charset (attribute))) - attribute = ccs; - - return Fcdr (Fassq (attribute, ret)); + return 0; } Lisp_Object -put_char_attribute (Lisp_Object character, Lisp_Object attribute, - Lisp_Object value) -{ - Emchar char_code = XCHAR (character); - Lisp_Object ret - = get_char_code_table (char_code, Vcharacter_attribute_table); - Lisp_Object cell; - - cell = Fassq (attribute, ret); - - if (NILP (cell)) - { - ret = Fcons (Fcons (attribute, value), ret); - } - else if (!EQ (Fcdr (cell), value)) - { - Fsetcdr (cell, value); - } - put_char_code_table (char_code, ret, Vcharacter_attribute_table); - return ret; -} - -DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /* -Store CHARACTER's ATTRIBUTE with VALUE. -*/ - (character, attribute, value)) +put_char_ccs_code_point (Lisp_Object character, + Lisp_Object ccs, Lisp_Object value) { - Lisp_Object ccs; - - CHECK_CHAR (character); - ccs = Ffind_charset (attribute); - if (!NILP (ccs)) + if (!EQ (XCHARSET_NAME (ccs), Qucs) + || !INTP (value) + || (XCHAR (character) != XINT (value))) { - Lisp_Object rest; Lisp_Object v = XCHARSET_DECODING_TABLE (ccs); - Lisp_Object nv; - int i = -1; - int ccs_len; - - /* ad-hoc method for `ascii' */ - if ((XCHARSET_CHARS (ccs) == 94) && - (XCHARSET_BYTE_OFFSET (ccs) != 33)) - ccs_len = 128 - XCHARSET_BYTE_OFFSET (ccs); - else - ccs_len = XCHARSET_CHARS (ccs); - - if (!CONSP (value)) - signal_simple_error ("Invalid value for coded-charset", - value); - - attribute = ccs; - rest = Fget_char_attribute (character, attribute); - if (VECTORP (v)) - { - if (!NILP (rest)) - { - while (!NILP (rest)) - { - Lisp_Object ei = Fcar (rest); - - i = XINT (ei) - XCHARSET_BYTE_OFFSET (ccs); - nv = XVECTOR_DATA(v)[i]; - if (!VECTORP (nv)) - break; - v = nv; - rest = Fcdr (rest); - } - if (i >= 0) - XVECTOR_DATA(v)[i] = Qnil; - v = XCHARSET_DECODING_TABLE (ccs); - } - } - else - { - XCHARSET_DECODING_TABLE (ccs) = v = make_vector (ccs_len, Qnil); - } + int code_point; - if (XCHARSET_GRAPHIC (ccs) == 1) - value = Fcopy_list (value); - rest = value; - i = -1; - while (CONSP (rest)) - { - Lisp_Object ei = Fcar (rest); - - if (!INTP (ei)) - signal_simple_error ("Invalid value for coded-charset", value); - i = XINT (ei); - if ((i < 0) || (255 < i)) + 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)) { - i &= 0x7F; - Fsetcar (rest, make_int (i)); - } - i -= XCHARSET_BYTE_OFFSET (ccs); - nv = XVECTOR_DATA(v)[i]; - rest = Fcdr (rest); - if (CONSP (rest)) - { - if (!VECTORP (nv)) - { - nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil)); - } - v = nv; + 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); } - else - break; + value = make_int (code_point); } - XVECTOR_DATA(v)[i] = character; - } - else if (EQ (attribute, Q_decomposition)) - { - Lisp_Object rest = value; - Lisp_Object table = Vcharacter_composition_table; - - if (!CONSP (value)) - signal_simple_error ("Invalid value for ->decomposition", - value); - - while (CONSP (rest)) + else if (INTP (value)) { - Lisp_Object v = Fcar (rest); - Lisp_Object ntable; - Emchar c - = to_char_code (v, "Invalid value for ->decomposition", value); - - rest = Fcdr (rest); - if (!CONSP (rest)) - { - put_char_code_table (c, character, table); - break; - } - else + code_point = XINT (value); + if (XCHARSET_GRAPHIC (ccs) == 1) { - ntable = get_char_code_table (c, table); - if (!CHAR_CODE_TABLE_P (ntable)) - { - ntable = make_char_code_table (Qnil); - put_char_code_table (c, ntable, table); - } - table = ntable; + code_point &= 0x7F7F7F7F; + value = make_int (code_point); } } - } - 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); + else + signal_simple_error ("Invalid value for coded-charset", value); - ret = get_char_code_table (c, Vcharacter_variant_table); - if (NILP (Fmemq (character, ret))) + if (VECTORP (v)) { - put_char_code_table (c, Fcons (character, ret), - Vcharacter_variant_table); + Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); + if (INTP (cpos)) + { + decoding_table_remove_char (ccs, XINT (cpos)); + } } + decoding_table_put_char (ccs, code_point, character); } - return put_char_attribute (character, attribute, value); + return value; } -Lisp_Object Qucs; - -EXFUN (Fmake_char, 3); - -DEFUN ("define-char", Fdefine_char, 1, 1, 0, /* -Store character's ATTRIBUTES. -*/ - (attributes)) +Lisp_Object +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; + Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); - if (!LISTP (cell)) - signal_simple_error ("Invalid argument", attributes); - if (!NILP (ccs = Ffind_charset (Fcar (cell)))) - { - cell = Fcdr (cell); - character = Fmake_char (ccs, Fcar (cell), - Fcar (Fcdr (cell))); - goto setup_attributes; - } - rest = Fcdr (rest); + if (!NILP (cpos)) + { + 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 - get_char_code_table (XCHAR (character), Vcharacter_attribute_table); + return Qt; } -Lisp_Object Vutf_2000_version; #endif #ifndef UTF2000 @@ -734,6 +306,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, @@ -751,19 +327,58 @@ Lisp_Object Qascii, Qlatin_iso8859_9, Qjapanese_jisx0208_1978, 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_smp, + Qucs_sip, + Qucs_cns, + Qucs_jis, + Qucs_ks, + Qucs_big5, Qlatin_viscii, + Qlatin_tcvn5712, Qlatin_viscii_lower, Qlatin_viscii_upper, Qvietnamese_viscii_lower, Qvietnamese_viscii_upper, + Qchinese_big5, + /* Qchinese_big5_cdp, */ + Qideograph_hanziku_1, + Qideograph_hanziku_2, + Qideograph_hanziku_3, + Qideograph_hanziku_4, + Qideograph_hanziku_5, + Qideograph_hanziku_6, + Qideograph_hanziku_7, + Qideograph_hanziku_8, + Qideograph_hanziku_9, + Qideograph_hanziku_10, + Qideograph_hanziku_11, + Qideograph_hanziku_12, + Qchina3_jef, + Qideograph_cbeta, + Qideograph_daikanwa_2, Qideograph_daikanwa, + 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, Qethiopic_ucs, #endif Qchinese_big5_1, @@ -774,13 +389,6 @@ Lisp_Object Ql2r, Qr2l; Lisp_Object Vcharset_hash_table; -#ifdef UTF2000 -static Charset_ID next_allocated_leading_byte; -#else -static Charset_ID next_allocated_1_byte_leading_byte; -static Charset_ID next_allocated_2_byte_leading_byte; -#endif - /* Composite characters are characters constructed by overstriking two or more regular characters. @@ -891,7 +499,7 @@ non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c) Use the macro charptr_emchar() instead. */ Emchar -non_ascii_charptr_emchar (CONST Bufbyte *str) +non_ascii_charptr_emchar (const Bufbyte *str) { #ifdef UTF2000 Bufbyte b; @@ -983,7 +591,8 @@ non_ascii_valid_char_p (Emchar ch) if (f3 < 0x20) return 0; - if (f3 != 0x20 && f3 != 0x7F) + if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE && + f2 <= MAX_CHAR_FIELD2_PRIVATE)) return 1; /* @@ -992,6 +601,8 @@ non_ascii_valid_char_p (Emchar ch) FIELD2_TO_PRIVATE_LEADING_BYTE are the same. */ charset = CHARSET_BY_LEADING_BYTE (f2 + FIELD2_TO_OFFICIAL_LEADING_BYTE); + if (EQ (charset, Qnil)) + return 0; return (XCHARSET_CHARS (charset) == 96); } else @@ -1016,7 +627,8 @@ non_ascii_valid_char_p (Emchar ch) } #endif /* ENABLE_COMPOSITE_CHARS */ - if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F) + if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F + && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE)) return 1; if (f1 <= MAX_CHAR_FIELD1_OFFICIAL) @@ -1026,6 +638,8 @@ non_ascii_valid_char_p (Emchar ch) charset = CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_PRIVATE_LEADING_BYTE); + if (EQ (charset, Qnil)) + return 0; return (XCHARSET_CHARS (charset) == 96); } } @@ -1036,30 +650,18 @@ non_ascii_valid_char_p (Emchar ch) /* Basic string functions */ /************************************************************************/ -/* Copy the character pointed to by PTR into STR, assuming it's - non-ASCII. Do not call this directly. Use the macro - charptr_copy_char() instead. */ +/* Copy the character pointed to by SRC into DST. Do not call this + directly. Use the macro charptr_copy_char() instead. + Return the number of bytes copied. */ Bytecount -non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str) +non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst) { - 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; - break; - default: - abort (); - } - return strptr + 1 - str; + unsigned int bytes = REP_BYTES_BY_FIRST_BYTE (*src); + unsigned int i; + for (i = bytes; i; i--, dst++, src++) + *dst = *src; + return bytes; } @@ -1076,36 +678,15 @@ Lstream_get_emchar_1 (Lstream *stream, int ch) { Bufbyte str[MAX_EMCHAR_LEN]; Bufbyte *strptr = str; + unsigned int bytes; str[0] = (Bufbyte) ch; - switch (REP_BYTES_BY_FIRST_BYTE (ch)) + + for (bytes = REP_BYTES_BY_FIRST_BYTE (ch) - 1; bytes; bytes--) { - /* 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); - *++strptr = (Bufbyte) ch; - case 3: - ch = Lstream_getc (stream); - assert (ch >= 0); - *++strptr = (Bufbyte) ch; - case 2: - ch = Lstream_getc (stream); - assert (ch >= 0); - *++strptr = (Bufbyte) ch; - break; - default: - abort (); + int c = Lstream_getc (stream); + bufpos_checking_assert (c >= 0); + *++strptr = (Bufbyte) c; } return charptr_emchar (str); } @@ -1132,17 +713,18 @@ Lstream_funget_emchar (Lstream *stream, Emchar ch) /************************************************************************/ static Lisp_Object -mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_charset (Lisp_Object obj) { - struct Lisp_Charset *cs = XCHARSET (obj); + Lisp_Charset *cs = XCHARSET (obj); - markobj (cs->short_name); - markobj (cs->long_name); - markobj (cs->doc_string); - markobj (cs->registry); - markobj (cs->ccl_program); + mark_object (cs->short_name); + mark_object (cs->long_name); + mark_object (cs->doc_string); + mark_object (cs->registry); + mark_object (cs->ccl_program); #ifdef UTF2000 - markobj (cs->decoding_table); + mark_object (cs->decoding_table); + mark_object (cs->mother); #endif return cs->name; } @@ -1150,7 +732,7 @@ mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object)) static void print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { - struct Lisp_Charset *cs = XCHARSET (obj); + Lisp_Charset *cs = XCHARSET (obj); char buf[200]; if (print_readably) @@ -1166,11 +748,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), @@ -1182,9 +762,16 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) } static const struct lrecord_description charset_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, name), 7 }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) }, #ifdef UTF2000 - { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, decoding_table), 2 }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) }, + { XD_LISP_OBJECT, offsetof (Lisp_Charset, mother) }, #endif { XD_END } }; @@ -1192,31 +779,36 @@ static const struct lrecord_description charset_description[] = { DEFINE_LRECORD_IMPLEMENTATION ("charset", charset, mark_charset, print_charset, 0, 0, 0, charset_description, - struct Lisp_Charset); + Lisp_Charset); /* Make a new charset. */ - +/* #### SJT Should generic properties be allowed? */ static Lisp_Object make_charset (Charset_ID id, Lisp_Object name, - unsigned char type, unsigned char columns, unsigned char graphic, + unsigned short chars, unsigned char dimension, + unsigned char columns, unsigned char graphic, Bufbyte final, unsigned char direction, Lisp_Object short_name, Lisp_Object long_name, Lisp_Object doc, Lisp_Object reg, 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; - struct Lisp_Charset *cs = - alloc_lcrecord_type (struct Lisp_Charset, &lrecord_charset); + Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset); + + zero_lcrecord (cs); + XSETCHARSET (obj, cs); CHARSET_ID (cs) = id; CHARSET_NAME (cs) = name; CHARSET_SHORT_NAME (cs) = short_name; CHARSET_LONG_NAME (cs) = long_name; + CHARSET_CHARS (cs) = chars; + CHARSET_DIMENSION (cs) = dimension; CHARSET_DIRECTION (cs) = direction; - CHARSET_TYPE (cs) = type; CHARSET_COLUMNS (cs) = columns; CHARSET_GRAPHIC (cs) = graphic; CHARSET_FINAL (cs) = final; @@ -1225,51 +817,15 @@ 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_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 - switch (CHARSET_TYPE (cs)) - { - case CHARSET_TYPE_94: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 94; - break; - case CHARSET_TYPE_96: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 96; - break; - case CHARSET_TYPE_94X94: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 94; - break; - case CHARSET_TYPE_96X96: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 96; - break; -#ifdef UTF2000 - case CHARSET_TYPE_128: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 128; - break; - case CHARSET_TYPE_128X128: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 128; - break; - case CHARSET_TYPE_256: - CHARSET_DIMENSION (cs) = 1; - CHARSET_CHARS (cs) = 256; - break; - case CHARSET_TYPE_256X256: - CHARSET_DIMENSION (cs) = 2; - CHARSET_CHARS (cs) = 256; - break; -#endif - } - #ifndef UTF2000 if (id == LEADING_BYTE_ASCII) CHARSET_REP_BYTES (cs) = 1; @@ -1278,31 +834,29 @@ make_charset (Charset_ID id, Lisp_Object name, else CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 2; #endif - + if (final) { /* some charsets do not have final characters. This includes ASCII, Control-1, Composite, and the two faux private charsets. */ + unsigned char iso2022_type + = (dimension == 1 ? 0 : 2) + (chars == 94 ? 0 : 1); #if UTF2000 if (code_offset == 0) { - assert (NILP (charset_by_attributes[type][final])); - charset_by_attributes[type][final] = obj; + assert (NILP (chlook->charset_by_attributes[iso2022_type][final])); + chlook->charset_by_attributes[iso2022_type][final] = obj; } #else - assert (NILP (charset_by_attributes[type][final][direction])); - charset_by_attributes[type][final][direction] = obj; + assert (NILP + (chlook->charset_by_attributes[iso2022_type][final][direction])); + chlook->charset_by_attributes[iso2022_type][final][direction] = obj; #endif } - assert (NILP (charset_by_leading_byte[id - MIN_LEADING_BYTE])); - charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj; -#ifndef UTF2000 - if (id < 0xA0) - /* official leading byte */ - rep_bytes_by_first_byte[id] = CHARSET_REP_BYTES (cs); -#endif + assert (NILP (chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE])); + chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj; /* Some charsets are "faux" and don't have names or really exist at all except in the leading-byte table. */ @@ -1317,24 +871,24 @@ get_unallocated_leading_byte (int dimension) Charset_ID lb; #ifdef UTF2000 - if (next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE) + if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE) lb = 0; else - lb = next_allocated_leading_byte++; + lb = chlook->next_allocated_leading_byte++; #else if (dimension == 1) { - if (next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1) + if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1) lb = 0; else - lb = next_allocated_1_byte_leading_byte++; + lb = chlook->next_allocated_1_byte_leading_byte++; } else { - if (next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) + if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) lb = 0; else - lb = next_allocated_2_byte_leading_byte++; + lb = chlook->next_allocated_2_byte_leading_byte++; } #endif @@ -1347,208 +901,526 @@ get_unallocated_leading_byte (int dimension) } #ifdef UTF2000 -Lisp_Object -range_charset_code_point (Lisp_Object charset, Emchar ch) +/* Number of Big5 characters which have the same code in 1st byte. */ + +#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40) + +Emchar +decode_defined_char (Lisp_Object ccs, int code_point) { - int d; + int dim = XCHARSET_DIMENSION (ccs); + Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs); + Emchar char_id = -1; + Lisp_Object mother; - if ((XCHARSET_UCS_MIN (charset) <= ch) - && (ch <= XCHARSET_UCS_MAX (charset))) + while (dim > 0) { - d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset); - - if (XCHARSET_DIMENSION (charset) == 1) - return list1 (make_int (d + XCHARSET_BYTE_OFFSET (charset))); - else if (XCHARSET_DIMENSION (charset) == 2) - return list2 (make_int (d / XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset))); - else if (XCHARSET_DIMENSION (charset) == 3) - return list3 (make_int (d / (XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset)) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d / XCHARSET_CHARS (charset) - % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset))); - else /* if (XCHARSET_DIMENSION (charset) == 4) */ - return list4 (make_int (d / (XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset)) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d / (XCHARSET_CHARS (charset) - * XCHARSET_CHARS (charset)) - % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d / XCHARSET_CHARS (charset) - % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset)), - make_int (d % XCHARSET_CHARS (charset) - + XCHARSET_BYTE_OFFSET (charset))); + dim--; + decoding_table + = get_ccs_octet_table (decoding_table, ccs, + (code_point >> (dim * 8)) & 255); } - else if (XCHARSET_CODE_OFFSET (charset) == 0) + if (CHARP (decoding_table)) + return XCHAR (decoding_table); +#ifdef HAVE_DATABASE + if (EQ (decoding_table, Qunloaded) || + EQ (decoding_table, Qunbound) || + NILP (decoding_table) ) { - if (XCHARSET_DIMENSION (charset) == 1) + 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 (XCHARSET_CHARS (charset) == 94) - { - if (((d = ch - (MIN_CHAR_94 - + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0) - && (d < 94)) - return list1 (make_int (d + 33)); - } - else if (XCHARSET_CHARS (charset) == 96) - { - if (((d = ch - (MIN_CHAR_96 - + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0) - && (d < 96)) - return list1 (make_int (d + 32)); - } + if ( EQ (mother, Vcharset_ucs) ) + return DECODE_CHAR (mother, code_point); else - return Qnil; + return decode_defined_char (mother, code_point); } - else if (XCHARSET_DIMENSION (charset) == 2) + else if ( XCHARSET_CONVERSION (ccs) == CONVERSION_BIG5_1 ) { - if (XCHARSET_CHARS (charset) == 94) - { - if (((d = ch - (MIN_CHAR_94x94 - + (XCHARSET_FINAL (charset) - '0') * 94 * 94)) - >= 0) - && (d < 94 * 94)) - return list2 (make_int ((d / 94) + 33), - make_int (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 list2 (make_int ((d / 96) + 32), - make_int (d % 96 + 32)); - } + 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 Qnil; + return -1; } -Lisp_Object -split_builtin_char (Emchar c) +Emchar +decode_builtin_char (Lisp_Object charset, int code_point) { - if (c < MIN_CHAR_OBS_94x94) + Lisp_Object mother = XCHARSET_MOTHER (charset); + int final; + + if ( CHARSETP (mother) && (XCHARSET_MAX_CODE (charset) > 0) ) { - if (c <= MAX_CHAR_BASIC_LATIN) + int code = code_point; + + if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 ) { - return list2 (Vcharset_ascii, make_int (c)); + int row = code_point >> 8; + int cell = code_point & 255; + + if (row < 16 + 32) + return -1; + else if (row < 16 + 32 + 30) + code = (row - (16 + 32)) * 94 + cell - 33; + else if (row < 18 + 32 + 30) + return -1; + else if (row < 18 + 32 + 60) + code = (row - (18 + 32)) * 94 + cell - 33; } - else if (c < 0xA0) + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 ) { - return list2 (Vcharset_control_1, make_int (c & 0x7F)); + 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 (c <= 0xff) + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 ) { - return list2 (Vcharset_latin_iso8859_1, make_int (c & 0x7F)); + 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 ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK)) + else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 ) { - return list2 (Vcharset_greek_iso8859_7, - make_int (c - MIN_CHAR_GREEK + 0x20)); + 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; } - else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC)) + return + decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset)); + } +#if 0 + else if (EQ (charset, Vcharset_chinese_big5)) + { + 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)) ) ) { - return list2 (Vcharset_cyrillic_iso8859_5, - make_int (c - MIN_CHAR_CYRILLIC + 0x20)); + I = (c1 - 0xA1) * BIG5_SAME_ROW + + c2 - (c2 < 0x7F ? 0x40 : 0x62); + + if (c1 < 0xC9) + { + charset = Vcharset_chinese_big5_1; + } + else + { + charset = Vcharset_chinese_big5_2; + I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1); + } + code_point = ((I / 94 + 33) << 8) | (I % 94 + 33); } - else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW)) + } +#endif + if ((final = XCHARSET_FINAL (charset)) >= '0') + { + if (XCHARSET_DIMENSION (charset) == 1) { - return list2 (Vcharset_hebrew_iso8859_8, - make_int (c - MIN_CHAR_HEBREW + 0x20)); + switch (XCHARSET_CHARS (charset)) + { + case 94: + return MIN_CHAR_94 + + (final - '0') * 94 + ((code_point & 0x7F) - 33); + case 96: + return MIN_CHAR_96 + + (final - '0') * 96 + ((code_point & 0x7F) - 32); + default: + abort (); + return -1; + } } - else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI)) + else { - return list2 (Vcharset_thai_tis620, - make_int (c - MIN_CHAR_THAI + 0x20)); + switch (XCHARSET_CHARS (charset)) + { + case 94: + return MIN_CHAR_94x94 + + (final - '0') * 94 * 94 + + (((code_point >> 8) & 0x7F) - 33) * 94 + + ((code_point & 0x7F) - 33); + case 96: + return MIN_CHAR_96x96 + + (final - '0') * 96 * 96 + + (((code_point >> 8) & 0x7F) - 32) * 96 + + ((code_point & 0x7F) - 32); + default: + abort (); + return -1; + } } - else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c) - && (c <= MAX_CHAR_HALFWIDTH_KATAKANA)) + } + else if (XCHARSET_MAX_CODE (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); + if ((cid < XCHARSET_MIN_CODE (charset)) + || (XCHARSET_MAX_CODE (charset) < cid)) + return -1; + return cid; + } + else + return -1; +} + +int +charset_code_point (Lisp_Object charset, Emchar ch) +{ + Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset); + Lisp_Object ret; + + if ( CHAR_TABLEP (encoding_table) + && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table), + ch)) ) + return XINT (ret); + else + { + Lisp_Object mother = XCHARSET_MOTHER (charset); + int min = XCHARSET_MIN_CODE (charset); + int max = XCHARSET_MAX_CODE (charset); + int code; + + if ( CHARSETP (mother) ) + code = charset_code_point (mother, ch); + else + code = ch; + if ( ((max == 0) && CHARSETP (mother)) || + ((min <= code) && (code <= max)) ) { - return list2 (Vcharset_katakana_jisx0201, - make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33)); + 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 ) + { + 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_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 ) + { + 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 + { + printf ("Unknown CCS-conversion %d is specified!", + XCHARSET_CONVERSION (charset)); + exit (-1); + } } - else + else if ( (XCHARSET_CODE_OFFSET (charset) == 0) || + (XCHARSET_CODE_OFFSET (charset) + == XCHARSET_MIN_CODE (charset)) ) { - return list3 (Vcharset_ucs_bmp, - make_int (c >> 8), make_int (c & 0xff)); + int d; + + 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; + } } } - else if (c <= MAX_CHAR_OBS_94x94) + 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_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) { - return list3 (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_94X94, - ((c - MIN_CHAR_OBS_94x94) / (94 * 94)) + '@', - CHARSET_LEFT_TO_RIGHT), - make_int ((((c - MIN_CHAR_OBS_94x94) / 94) % 94) + 33), - make_int (((c - MIN_CHAR_OBS_94x94) % 94) + 33)); + *charset = Vcharset_ucs_bmp; + return c; + } + else if (c <= MAX_CHAR_SMP) + { + *charset = Vcharset_ucs_smp; + return c - MIN_CHAR_SMP; + } + else if (c <= MAX_CHAR_SIP) + { + *charset = Vcharset_ucs_sip; + return c - MIN_CHAR_SIP; + } + else if (c < MIN_CHAR_DAIKANWA) + { + *charset = Vcharset_ucs; + return c; } else if (c <= MAX_CHAR_DAIKANWA) { - return list3 (Vcharset_ideograph_daikanwa, - make_int ((c - MIN_CHAR_DAIKANWA) >> 8), - make_int ((c - MIN_CHAR_DAIKANWA) & 255)); + *charset = Vcharset_ideograph_daikanwa; + return c - MIN_CHAR_DAIKANWA; + } + else if (c < MIN_CHAR_94) + { + *charset = Vcharset_ucs; + return c; } else if (c <= MAX_CHAR_94) { - return list2 (CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94, - ((c - MIN_CHAR_94) / 94) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int (((c - MIN_CHAR_94) % 94) + 33)); + *charset = CHARSET_BY_ATTRIBUTES (94, 1, + ((c - MIN_CHAR_94) / 94) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return ((c - MIN_CHAR_94) % 94) + 33; + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_96) { - return list2 (CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96, - ((c - MIN_CHAR_96) / 96) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int (((c - MIN_CHAR_96) % 96) + 32)); + *charset = CHARSET_BY_ATTRIBUTES (96, 1, + ((c - MIN_CHAR_96) / 96) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return ((c - MIN_CHAR_96) % 96) + 32; + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_94x94) { - return list3 (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_94X94, - ((c - MIN_CHAR_94x94) / (94 * 94)) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int ((((c - MIN_CHAR_94x94) / 94) % 94) + 33), - make_int (((c - MIN_CHAR_94x94) % 94) + 33)); + *charset + = CHARSET_BY_ATTRIBUTES (94, 2, + ((c - MIN_CHAR_94x94) / (94 * 94)) + '0', + CHARSET_LEFT_TO_RIGHT); + if (!NILP (*charset)) + return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8) + | (((c - MIN_CHAR_94x94) % 94) + 33); + else + { + *charset = Vcharset_ucs; + return c; + } } else if (c <= MAX_CHAR_96x96) { - return list3 (CHARSET_BY_ATTRIBUTES - (CHARSET_TYPE_96X96, - ((c - MIN_CHAR_96x96) / (96 * 96)) + '0', - CHARSET_LEFT_TO_RIGHT), - make_int ((((c - MIN_CHAR_96x96) / 96) % 96) + 32), - make_int (((c - MIN_CHAR_96x96) % 96) + 32)); - } - else - { - return Qnil; + *charset + = CHARSET_BY_ATTRIBUTES (96, 2, + ((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; + } } -} - -Lisp_Object -charset_code_point (Lisp_Object charset, Emchar ch) -{ - Lisp_Object cdef = get_char_code_table (ch, Vcharacter_attribute_table); - - if (!EQ (cdef, Qnil)) + else { - Lisp_Object field = Fassq (charset, cdef); - - if (!EQ (field, Qnil)) - return Fcdr (field); + *charset = Vcharset_ucs; + return c; } - return range_charset_code_point (charset, ch); } Lisp_Object Vdefault_coded_charset_priority_list; @@ -1613,7 +1485,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; } @@ -1636,13 +1508,14 @@ Return a list of the names of all defined charsets. } DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /* -Return the name of the given charset. +Return the name of charset CHARSET. */ (charset)) { return XCHARSET_NAME (Fget_charset (charset)); } +/* #### SJT Should generic properties be allowed? */ DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /* Define a new character set. This function is for use with Mule support. @@ -1657,6 +1530,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 @@ -1665,6 +1539,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 @@ -1689,18 +1564,26 @@ 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)) { int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1; int direction = CHARSET_LEFT_TO_RIGHT; - int type; Lisp_Object registry = Qnil; Lisp_Object charset; - Lisp_Object rest, keyword, value; 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)) @@ -1710,104 +1593,159 @@ character set. Recognized properties are: if (!NILP (charset)) signal_simple_error ("Cannot redefine existing charset", name); - EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props) - { - if (EQ (keyword, Qshort_name)) - { - CHECK_STRING (value); - short_name = value; - } + { + EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props) + { + if (EQ (keyword, Qshort_name)) + { + CHECK_STRING (value); + short_name = value; + } - if (EQ (keyword, Qlong_name)) - { - CHECK_STRING (value); - long_name = value; - } + if (EQ (keyword, Qlong_name)) + { + CHECK_STRING (value); + long_name = value; + } - else if (EQ (keyword, Qdimension)) - { - CHECK_INT (value); - dimension = XINT (value); - if (dimension < 1 || dimension > 2) - signal_simple_error ("Invalid value for 'dimension", value); - } + else if (EQ (keyword, Qdimension)) + { + CHECK_INT (value); + dimension = XINT (value); + if (dimension < 1 || +#ifdef UTF2000 + dimension > 4 +#else + dimension > 2 +#endif + ) + signal_simple_error ("Invalid value for 'dimension", value); + } - else if (EQ (keyword, Qchars)) - { - CHECK_INT (value); - chars = XINT (value); - if (chars != 94 && chars != 96) - signal_simple_error ("Invalid value for 'chars", value); - } + else if (EQ (keyword, Qchars)) + { + CHECK_INT (value); + chars = XINT (value); + if (chars != 94 && chars != 96 +#ifdef UTF2000 + && chars != 128 && chars != 256 +#endif + ) + signal_simple_error ("Invalid value for 'chars", value); + } - else if (EQ (keyword, Qcolumns)) - { - CHECK_INT (value); - columns = XINT (value); - if (columns != 1 && columns != 2) - signal_simple_error ("Invalid value for 'columns", value); - } + else if (EQ (keyword, Qcolumns)) + { + CHECK_INT (value); + columns = XINT (value); + if (columns != 1 && columns != 2) + signal_simple_error ("Invalid value for 'columns", value); + } - else if (EQ (keyword, Qgraphic)) - { - CHECK_INT (value); - graphic = XINT (value); + else if (EQ (keyword, Qgraphic)) + { + 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); - } + ) + signal_simple_error ("Invalid value for 'graphic", value); + } - else if (EQ (keyword, Qregistry)) - { - CHECK_STRING (value); - registry = value; - } + else if (EQ (keyword, Qregistry)) + { + CHECK_STRING (value); + registry = value; + } - else if (EQ (keyword, Qdirection)) - { - if (EQ (value, Ql2r)) - direction = CHARSET_LEFT_TO_RIGHT; - else if (EQ (value, Qr2l)) - direction = CHARSET_RIGHT_TO_LEFT; - else - signal_simple_error ("Invalid value for 'direction", value); - } + else if (EQ (keyword, Qdirection)) + { + if (EQ (value, Ql2r)) + direction = CHARSET_LEFT_TO_RIGHT; + else if (EQ (value, Qr2l)) + direction = CHARSET_RIGHT_TO_LEFT; + else + signal_simple_error ("Invalid value for 'direction", value); + } - else if (EQ (keyword, Qfinal)) - { - CHECK_CHAR_COERCE_INT (value); - final = XCHAR (value); - if (final < '0' || final > '~') - signal_simple_error ("Invalid value for 'final", value); - } + else if (EQ (keyword, Qfinal)) + { + CHECK_CHAR_COERCE_INT (value); + final = XCHAR (value); + if (final < '0' || final > '~') + signal_simple_error ("Invalid value for 'final", value); + } - else if (EQ (keyword, Qccl_program)) - { - CHECK_VECTOR (value); - ccl_program = value; - } +#ifdef UTF2000 + else if (EQ (keyword, Qmother)) + { + mother = Fget_charset (value); + } - else - signal_simple_error ("Unrecognized property", keyword); - } + 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; + + if (setup_ccl_program (&test_ccl, value) < 0) + signal_simple_error ("Invalid value for 'ccl-program", value); + ccl_program = value; + } + + else + signal_simple_error ("Unrecognized property", keyword); + } + } + +#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", make_char (final)); - if (dimension == 1) - type = (chars == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96; - else - type = (chars == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96; - - if (!NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_LEFT_TO_RIGHT)) || - !NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_RIGHT_TO_LEFT))) + if (!NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final, + CHARSET_LEFT_TO_RIGHT)) || + !NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final, + CHARSET_RIGHT_TO_LEFT))) error ("Character set already defined for this DIMENSION/CHARS/FINAL combo"); @@ -1838,10 +1776,11 @@ character set. Recognized properties are: byte_offset = 0; } - charset = make_charset (id, name, type, columns, graphic, + charset = make_charset (id, name, chars, dimension, columns, graphic, final, direction, short_name, long_name, doc_string, registry, - Qnil, 0, 0, 0, byte_offset); + Qnil, min_code, max_code, code_offset, byte_offset, + mother, conversion); if (!NILP (ccl_program)) XCHARSET_CCL_PROGRAM (charset) = ccl_program; return charset; @@ -1855,10 +1794,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))) @@ -1871,9 +1810,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); @@ -1886,17 +1825,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, type, columns, + new_charset = make_charset (id, new_name, chars, dimension, columns, graphic, final, direction, short_name, long_name, 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 ); @@ -1940,7 +1881,6 @@ will be returned if character sets exist for both directions). (dimension, chars, final, direction)) { int dm, ch, fi, di = -1; - int type; Lisp_Object obj = Qnil; CHECK_INT (dimension); @@ -1969,19 +1909,14 @@ will be returned if character sets exist for both directions). signal_simple_error ("Final must be in the range 0x30 - 0x5F for dimension == 2", final); - if (dm == 1) - type = (ch == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96; - else - type = (ch == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96; - - if (di == -1) + if (di == -1) { - obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_LEFT_TO_RIGHT); + obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_LEFT_TO_RIGHT); if (NILP (obj)) - obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_RIGHT_TO_LEFT); + obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_RIGHT_TO_LEFT); } else - obj = CHARSET_BY_ATTRIBUTES (type, fi, di); + obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, di); if (CHARSETP (obj)) return XCHARSET_NAME (obj); @@ -2021,13 +1956,13 @@ Return dimension of CHARSET. } DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /* -Return property PROP of CHARSET. +Return property PROP of CHARSET, a charset object or symbol naming a charset. Recognized properties are those listed in `make-charset', as well as 'name and 'doc-string. */ (charset, prop)) { - struct Lisp_Charset *cs; + Lisp_Charset *cs; charset = Fget_charset (charset); cs = XCHARSET (charset); @@ -2040,7 +1975,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); @@ -2049,11 +1985,17 @@ Recognized properties are those listed in `make-charset', as well as if (EQ (prop, Qreverse_direction_charset)) { Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs); - if (NILP (obj)) - return Qnil; - else - return XCHARSET_NAME (obj); + /* #### 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 */ } @@ -2074,8 +2016,11 @@ Set the 'ccl-program property of CHARSET to CCL-PROGRAM. */ (charset, ccl_program)) { + struct ccl_program test_ccl; + charset = Fget_charset (charset); - CHECK_VECTOR (ccl_program); + if (setup_ccl_program (&test_ccl, ccl_program) < 0) + signal_simple_error ("Invalid ccl-program", ccl_program); XCHARSET_CCL_PROGRAM (charset) = ccl_program; return Qnil; } @@ -2122,39 +2067,40 @@ Set mapping-table of CHARSET to TABLE. (charset, table)) { struct Lisp_Charset *cs; - Lisp_Object old_table; size_t i; + int byte_offset; charset = Fget_charset (charset); cs = XCHARSET (charset); - if (EQ (table, Qnil)) + if (NILP (table)) { - CHARSET_DECODING_TABLE(cs) = table; + CHARSET_DECODING_TABLE(cs) = Qnil; return table; } else if (VECTORP (table)) { - int ccs_len; - - /* ad-hoc method for `ascii' */ - if ((CHARSET_CHARS (cs) == 94) && - (CHARSET_BYTE_OFFSET (cs) != 33)) - ccs_len = 128 - CHARSET_BYTE_OFFSET (cs); - else - ccs_len = CHARSET_CHARS (cs); - - if (XVECTOR_LENGTH (table) > ccs_len) - args_out_of_range (table, make_int (CHARSET_CHARS (cs))); - old_table = CHARSET_DECODING_TABLE(cs); - CHARSET_DECODING_TABLE(cs) = table; + int ccs_len = CHARSET_BYTE_SIZE (cs); + int ret = decoding_table_check_elements (table, + CHARSET_DIMENSION (cs), + ccs_len); + if (ret) + { + if (ret == -1) + signal_simple_error ("Too big table", table); + else if (ret == -2) + signal_simple_error ("Invalid element is found", table); + else + signal_simple_error ("Something wrong", table); + } + CHARSET_DECODING_TABLE(cs) = Qnil; } else signal_error (Qwrong_type_argument, list2 (build_translated_string ("vector-or-nil-p"), table)); - /* signal_simple_error ("Wrong type argument: vector-or-nil-p", table); */ + byte_offset = CHARSET_BYTE_OFFSET (cs); switch (CHARSET_DIMENSION (cs)) { case 1: @@ -2163,9 +2109,8 @@ Set mapping-table of CHARSET to TABLE. Lisp_Object c = XVECTOR_DATA(table)[i]; if (CHARP (c)) - put_char_attribute - (c, charset, - list1 (make_int (i + CHARSET_BYTE_OFFSET (cs)))); + Fput_char_attribute (c, XCHARSET_NAME (charset), + make_int (i + byte_offset)); } break; case 2: @@ -2177,40 +2122,275 @@ Set mapping-table of CHARSET to TABLE. { size_t j; - if (XVECTOR_LENGTH (v) > CHARSET_CHARS (cs)) - { - CHARSET_DECODING_TABLE(cs) = old_table; - args_out_of_range (v, make_int (CHARSET_CHARS (cs))); - } for (j = 0; j < XVECTOR_LENGTH (v); j++) { Lisp_Object c = XVECTOR_DATA(v)[j]; if (CHARP (c)) - put_char_attribute (c, charset, - list2 - (make_int - (i + CHARSET_BYTE_OFFSET (cs)), - make_int - (j + CHARSET_BYTE_OFFSET (cs)))); + Fput_char_attribute + (c, XCHARSET_NAME (charset), + make_int ( ( (i + byte_offset) << 8 ) + | (j + byte_offset) + ) ); } } else if (CHARP (v)) - put_char_attribute (v, charset, - list1 - (make_int (i + CHARSET_BYTE_OFFSET (cs)))); + Fput_char_attribute (v, XCHARSET_NAME (charset), + make_int (i + byte_offset)); } break; } return table; } + +DEFUN ("save-charset-mapping-table", Fsave_charset_mapping_table, 1, 1, 0, /* +Save mapping-table of CHARSET. +*/ + (charset)) +{ +#ifdef HAVE_DATABASE + 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); +#else + return Qnil; #endif +} + +#ifdef HAVE_CHISE_CLIENT +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); + } + } + Fclose_database (db); + } + return -1; +} +#endif /* HAVE_CHISE_CLIENT */ +#endif /* UTF2000 */ /************************************************************************/ /* Lisp primitives for working with characters */ /************************************************************************/ +#ifdef UTF2000 +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, defined_only)) +{ + int c; + + charset = Fget_charset (charset); + CHECK_INT (code); + c = XINT (code); + if (XCHARSET_GRAPHIC (charset) == 1) + c &= 0x7F7F7F7F; + if (NILP (defined_only)) + c = DECODE_CHAR (charset, c); + else + c = decode_defined_char (charset, c); + return c >= 0 ? make_char (c) : Qnil; +} + +DEFUN ("decode-builtin-char", Fdecode_builtin_char, 2, 2, 0, /* +Make a builtin character from CHARSET and code-point CODE. +*/ + (charset, code)) +{ + int c; + + charset = Fget_charset (charset); + CHECK_INT (code); + if (EQ (charset, Vcharset_latin_viscii)) + { + Lisp_Object chr = Fdecode_char (charset, code, Qnil); + Lisp_Object ret; + + if (!NILP (chr)) + { + if (!NILP + (ret = Fget_char_attribute (chr, + Vcharset_latin_viscii_lower, + Qnil))) + { + charset = Vcharset_latin_viscii_lower; + code = ret; + } + else if (!NILP + (ret = Fget_char_attribute (chr, + Vcharset_latin_viscii_upper, + Qnil))) + { + charset = Vcharset_latin_viscii_upper; + code = ret; + } + } + } + c = XINT (code); +#if 0 + if (XCHARSET_GRAPHIC (charset) == 1) + c &= 0x7F7F7F7F; +#endif + c = decode_builtin_char (charset, c); + return c >= 0 ? make_char (c) : Fdecode_char (charset, code, Qnil); +} +#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. @@ -2219,7 +2399,7 @@ character s with caron. */ (charset, arg1, arg2)) { - struct Lisp_Charset *cs; + Lisp_Charset *cs; int a1, a2; int lowlim, highlim; @@ -2236,7 +2416,7 @@ character s with caron. CHECK_INT (arg1); /* It is useful (and safe, according to Olivier Galibert) to strip - the 8th bit off ARG1 and ARG2 becaue it allows programmers to + the 8th bit off ARG1 and ARG2 because it allows programmers to write (make-char 'latin-iso8859-2 CODE) where code is the actual Latin 2 code of the character. */ #ifdef UTF2000 @@ -2272,41 +2452,84 @@ character s with caron. } DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /* -Return the character set of char CH. +Return the character set of CHARACTER. */ - (ch)) + (character)) { - CHECK_CHAR_COERCE_INT (ch); + CHECK_CHAR_COERCE_INT (character); - return XCHARSET_NAME (CHAR_CHARSET (XCHAR (ch))); + return XCHARSET_NAME (CHAR_CHARSET (XCHAR (character))); } -DEFUN ("split-char", Fsplit_char, 1, 1, 0, /* -Return list of charset and one or two position-codes of CHAR. +DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /* +Return the octet numbered N (should be 0 or 1) of CHARACTER. +N defaults to 0 if omitted. */ - (character)) + (character, n)) { -#ifdef UTF2000 - Lisp_Object ret; Lisp_Object charset; + int octet0, octet1; CHECK_CHAR_COERCE_INT (character); - ret = SPLIT_CHAR (XCHAR (character)); - charset = Fcar (ret); - if (CHARSETP (charset)) - return Fcons (XCHARSET_NAME (charset), Fcopy_list (Fcdr (ret))); + + BREAKUP_CHAR (XCHAR (character), charset, octet0, octet1); + + if (NILP (n) || EQ (n, Qzero)) + return make_int (octet0); + else if (EQ (n, make_int (1))) + return make_int (octet1); else - return ret; -#else + signal_simple_error ("Octet number must be 0 or 1", n); +} + +#ifdef UTF2000 +DEFUN ("encode-char", Fencode_char, 2, 2, 0, /* +Return code-point of CHARACTER in specified CHARSET. +*/ + (character, charset)) +{ + int code_point; + + CHECK_CHAR_COERCE_INT (character); + charset = Fget_charset (charset); + code_point = charset_code_point (charset, XCHAR (character)); + 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. +*/ + (character)) +{ /* This function can GC */ struct gcpro gcpro1, gcpro2; Lisp_Object charset = Qnil; Lisp_Object rc = Qnil; +#ifdef UTF2000 + int code_point; + int dimension; +#else int c1, c2; +#endif GCPRO2 (charset, rc); CHECK_CHAR_COERCE_INT (character); +#ifdef UTF2000 + code_point = ENCODE_CHAR (XCHAR (character), charset); + dimension = XCHARSET_DIMENSION (charset); + while (dimension > 0) + { + rc = Fcons (make_int (code_point & 255), rc); + code_point >>= 8; + dimension--; + } + rc = Fcons (XCHARSET_NAME (charset), rc); +#else BREAKUP_CHAR (XCHAR (character), charset, c1, c2); if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2) @@ -2317,9 +2540,10 @@ Return list of charset and one or two position-codes of CHAR. { rc = list2 (XCHARSET_NAME (charset), make_int (c1)); } +#endif UNGCPRO; + return rc; -#endif } @@ -2404,6 +2628,8 @@ Return a string of the characters comprising a composite character. void syms_of_mule_charset (void) { + INIT_LRECORD_IMPLEMENTATION (charset); + DEFSUBR (Fcharsetp); DEFSUBR (Ffind_charset); DEFSUBR (Fget_charset); @@ -2423,18 +2649,19 @@ syms_of_mule_charset (void) DEFSUBR (Fset_charset_ccl_program); DEFSUBR (Fset_charset_registry); #ifdef UTF2000 - DEFSUBR (Fchar_attribute_alist); - DEFSUBR (Fget_char_attribute); - DEFSUBR (Fput_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); + DEFSUBR (Fdecode_builtin_char); + DEFSUBR (Fencode_char); + DEFSUBR (Fsave_charset_mapping_table); +#endif DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); + DEFSUBR (Fchar_octet); DEFSUBR (Fsplit_char); #ifdef ENABLE_COMPOSITE_CHARS @@ -2450,6 +2677,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"); @@ -2472,32 +2710,58 @@ syms_of_mule_charset (void) defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9"); defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978"); 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 (&Q_ucs, "->ucs"); - defsymbol (&Q_decomposition, "->decomposition"); - defsymbol (&Qcompat, "compat"); - 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 (&Qfont, "font"); defsymbol (&Qucs, "ucs"); defsymbol (&Qucs_bmp, "ucs-bmp"); + defsymbol (&Qucs_smp, "ucs-smp"); + defsymbol (&Qucs_sip, "ucs-sip"); + defsymbol (&Qucs_cns, "ucs-cns"); + defsymbol (&Qucs_jis, "ucs-jis"); + defsymbol (&Qucs_ks, "ucs-ks"); + defsymbol (&Qucs_big5, "ucs-big5"); 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_2, "ideograph-daikanwa-2"); defsymbol (&Qideograph_daikanwa, "ideograph-daikanwa"); + defsymbol (&Qchinese_big5, "chinese-big5"); + /* defsymbol (&Qchinese_big5_cdp, "chinese-big5-cdp"); */ + defsymbol (&Qideograph_hanziku_1, "ideograph-hanziku-1"); + defsymbol (&Qideograph_hanziku_2, "ideograph-hanziku-2"); + defsymbol (&Qideograph_hanziku_3, "ideograph-hanziku-3"); + defsymbol (&Qideograph_hanziku_4, "ideograph-hanziku-4"); + defsymbol (&Qideograph_hanziku_5, "ideograph-hanziku-5"); + defsymbol (&Qideograph_hanziku_6, "ideograph-hanziku-6"); + defsymbol (&Qideograph_hanziku_7, "ideograph-hanziku-7"); + defsymbol (&Qideograph_hanziku_8, "ideograph-hanziku-8"); + defsymbol (&Qideograph_hanziku_9, "ideograph-hanziku-9"); + defsymbol (&Qideograph_hanziku_10, "ideograph-hanziku-10"); + defsymbol (&Qideograph_hanziku_11, "ideograph-hanziku-11"); + defsymbol (&Qideograph_hanziku_12, "ideograph-hanziku-12"); + defsymbol (&Qchina3_jef, "china3-jef"); + defsymbol (&Qideograph_cbeta, "ideograph-cbeta"); defsymbol (&Qethiopic_ucs, "ethiopic-ucs"); #endif defsymbol (&Qchinese_big5_1, "chinese-big5-1"); @@ -2514,28 +2778,31 @@ vars_of_mule_charset (void) int k; #endif + 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 (charset_by_leading_byte); i++) - charset_by_leading_byte[i] = Qnil; + for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) + chlook->charset_by_leading_byte[i] = Qnil; #ifdef UTF2000 /* Table of charsets indexed by type/final-byte. */ - for (i = 0; i < countof (charset_by_attributes); i++) - for (j = 0; j < countof (charset_by_attributes[0]); j++) - charset_by_attributes[i][j] = Qnil; + for (i = 0; i < countof (chlook->charset_by_attributes); i++) + for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++) + chlook->charset_by_attributes[i][j] = Qnil; #else /* Table of charsets indexed by type/final-byte/direction. */ - for (i = 0; i < countof (charset_by_attributes); i++) - for (j = 0; j < countof (charset_by_attributes[0]); j++) - for (k = 0; k < countof (charset_by_attributes[0][0]); k++) - charset_by_attributes[i][j][k] = Qnil; + for (i = 0; i < countof (chlook->charset_by_attributes); i++) + for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++) + for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++) + chlook->charset_by_attributes[i][j][k] = Qnil; #endif #ifdef UTF2000 - next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE; + chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE; #else - next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; - next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; + chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; + chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; #endif #ifndef UTF2000 @@ -2547,20 +2814,6 @@ Leading-code of private TYPE9N charset of column-width 1. #endif #ifdef UTF2000 - Vutf_2000_version = build_string("0.12 (Kashiwara)"); - DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /* -Version number of UTF-2000. -*/ ); - - staticpro (&Vcharacter_attribute_table); - Vcharacter_attribute_table = make_char_code_table (Qnil); - - staticpro (&Vcharacter_composition_table); - Vcharacter_composition_table = make_char_code_table (Qnil); - - staticpro (&Vcharacter_variant_table); - Vcharacter_variant_table = make_char_code_table (Qnil); - Vdefault_coded_charset_priority_list = Qnil; DEFVAR_LISP ("default-coded-charset-priority-list", &Vdefault_coded_charset_priority_list /* @@ -2580,304 +2833,520 @@ complex_vars_of_mule_charset (void) ease of access. */ #ifdef UTF2000 + staticpro (&Vcharset_ucs); + Vcharset_ucs = + make_charset (LEADING_BYTE_UCS, Qucs, 256, 4, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("UCS"), + build_string ("UCS"), + build_string ("ISO/IEC 10646"), + build_string (""), + Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ucs_bmp); Vcharset_ucs_bmp = - make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, - CHARSET_TYPE_256X256, 1, 2, 0, - CHARSET_LEFT_TO_RIGHT, - build_string ("BMP"), + make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, 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); + 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 ("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); + staticpro (&Vcharset_ucs_cns); + Vcharset_ucs_cns = + make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3, + 2, 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, Vcharset_ucs, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ucs_jis); + Vcharset_ucs_jis = + make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("UCS for JIS"), + build_string ("UCS for JIS X 0208, 0212 and 0213"), + build_string + ("ISO/IEC 10646 for JIS X 0208, 0212 and 0213"), + build_string (""), + Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ucs_ks); + Vcharset_ucs_ks = + make_charset (LEADING_BYTE_UCS_KS, Qucs_ks, 256, 3, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("UCS for KS"), + build_string ("UCS for CCS defined by KS"), + build_string ("ISO/IEC 10646 for Korean Standards"), + build_string (""), + Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ucs_big5); + Vcharset_ucs_big5 = + make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3, + 2, 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, Vcharset_ucs, CONVERSION_IDENTICAL); #else # define MIN_CHAR_THAI 0 # define MAX_CHAR_THAI 0 -# define MIN_CHAR_GREEK 0 -# define MAX_CHAR_GREEK 0 -# define MIN_CHAR_HEBREW 0 -# define MAX_CHAR_HEBREW 0 + /* # define MIN_CHAR_HEBREW 0 */ + /* # define MAX_CHAR_HEBREW 0 */ # define MIN_CHAR_HALFWIDTH_KATAKANA 0 # define MAX_CHAR_HALFWIDTH_KATAKANA 0 -# define MIN_CHAR_CYRILLIC 0 -# define MAX_CHAR_CYRILLIC 0 #endif + staticpro (&Vcharset_ascii); Vcharset_ascii = - make_charset (LEADING_BYTE_ASCII, Qascii, - CHARSET_TYPE_94, 1, 0, 'B', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_ASCII, Qascii, 94, 1, + 1, 0, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("ASCII"), build_string ("ASCII)"), build_string ("ASCII (ISO646 IRV)"), build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"), - Qnil, 0, 0x7F, 0, 0); + Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_control_1); Vcharset_control_1 = - make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, - CHARSET_TYPE_94, 1, 1, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1, + 1, 1, 0, CHARSET_LEFT_TO_RIGHT, build_string ("C1"), build_string ("Control characters"), build_string ("Control characters 128-191"), build_string (""), - Qnil, 0x80, 0x9F, 0, 0); + 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, - CHARSET_TYPE_96, 1, 1, 'A', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1, + 1, 1, 'A', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-1"), build_string ("ISO8859-1 (Latin-1)"), build_string ("ISO8859-1 (Latin-1)"), build_string ("iso8859-1"), - Qnil, 0xA0, 0xFF, 0, 32); + 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, - CHARSET_TYPE_96, 1, 1, 'B', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1, + 1, 1, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-2"), build_string ("ISO8859-2 (Latin-2)"), build_string ("ISO8859-2 (Latin-2)"), build_string ("iso8859-2"), - Qnil, 0, 0, 0, 32); + 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, - CHARSET_TYPE_96, 1, 1, 'C', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1, + 1, 1, 'C', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-3"), build_string ("ISO8859-3 (Latin-3)"), build_string ("ISO8859-3 (Latin-3)"), build_string ("iso8859-3"), - Qnil, 0, 0, 0, 32); + 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, - CHARSET_TYPE_96, 1, 1, 'D', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1, + 1, 1, 'D', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-4"), build_string ("ISO8859-4 (Latin-4)"), build_string ("ISO8859-4 (Latin-4)"), build_string ("iso8859-4"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_thai_tis620); Vcharset_thai_tis620 = - make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, - CHARSET_TYPE_96, 1, 1, 'T', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1, + 1, 1, 'T', CHARSET_LEFT_TO_RIGHT, build_string ("TIS620"), build_string ("TIS620 (Thai)"), build_string ("TIS620.2529 (Thai)"), build_string ("tis620"), - Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32); + Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, + MIN_CHAR_THAI, 32, Qnil, CONVERSION_96); + staticpro (&Vcharset_greek_iso8859_7); Vcharset_greek_iso8859_7 = - make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, - CHARSET_TYPE_96, 1, 1, 'F', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1, + 1, 1, 'F', CHARSET_LEFT_TO_RIGHT, build_string ("ISO8859-7"), build_string ("ISO8859-7 (Greek)"), build_string ("ISO8859-7 (Greek)"), build_string ("iso8859-7"), - Qnil, MIN_CHAR_GREEK, MAX_CHAR_GREEK, 0, 32); + Qnil, 0, 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, - CHARSET_TYPE_96, 1, 1, 'G', - CHARSET_RIGHT_TO_LEFT, + make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1, + 1, 1, 'G', CHARSET_RIGHT_TO_LEFT, build_string ("ISO8859-6"), build_string ("ISO8859-6 (Arabic)"), build_string ("ISO8859-6 (Arabic)"), build_string ("iso8859-6"), - Qnil, 0, 0, 0, 32); + 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, - CHARSET_TYPE_96, 1, 1, 'H', - CHARSET_RIGHT_TO_LEFT, + make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1, + 1, 1, 'H', CHARSET_RIGHT_TO_LEFT, build_string ("ISO8859-8"), build_string ("ISO8859-8 (Hebrew)"), build_string ("ISO8859-8 (Hebrew)"), build_string ("iso8859-8"), - Qnil, MIN_CHAR_HEBREW, MAX_CHAR_HEBREW, 0, 32); + Qnil, + 0 /* MIN_CHAR_HEBREW */, + 0 /* MAX_CHAR_HEBREW */, 0, 32, + Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_katakana_jisx0201); Vcharset_katakana_jisx0201 = - make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, - CHARSET_TYPE_94, 1, 1, 'I', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1, + 1, 1, 'I', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0201 Kana"), build_string ("JISX0201.1976 (Japanese Kana)"), build_string ("JISX0201.1976 Japanese Kana"), build_string ("jisx0201\\.1976"), - Qnil, - MIN_CHAR_HALFWIDTH_KATAKANA, - MAX_CHAR_HALFWIDTH_KATAKANA, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_latin_jisx0201); Vcharset_latin_jisx0201 = - make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, - CHARSET_TYPE_94, 1, 0, 'J', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1, + 1, 0, 'J', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0201 Roman"), build_string ("JISX0201.1976 (Japanese Roman)"), build_string ("JISX0201.1976 Japanese Roman"), build_string ("jisx0201\\.1976"), - Qnil, 0, 0, 0, 33); + 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, - CHARSET_TYPE_96, 1, 1, 'L', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1, + 1, 1, 'L', CHARSET_LEFT_TO_RIGHT, build_string ("ISO8859-5"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("iso8859-5"), - Qnil, MIN_CHAR_CYRILLIC, MAX_CHAR_CYRILLIC, 0, 32); + Qnil, 0, 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, - CHARSET_TYPE_96, 1, 1, 'M', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1, + 1, 1, 'M', CHARSET_LEFT_TO_RIGHT, build_string ("Latin-5"), build_string ("ISO8859-9 (Latin-5)"), build_string ("ISO8859-9 (Latin-5)"), build_string ("iso8859-9"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_japanese_jisx0208_1978); Vcharset_japanese_jisx0208_1978 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, - CHARSET_TYPE_94X94, 2, 0, '@', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, + Qjapanese_jisx0208_1978, 94, 2, + 2, 0, '@', CHARSET_LEFT_TO_RIGHT, build_string ("JIS X0208:1978"), build_string ("JIS X0208:1978 (Japanese)"), build_string ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"), build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_chinese_gb2312); Vcharset_chinese_gb2312 = - make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, - CHARSET_TYPE_94X94, 2, 0, 'A', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2, + 2, 0, 'A', CHARSET_LEFT_TO_RIGHT, build_string ("GB2312"), build_string ("GB2312)"), build_string ("GB2312 Chinese simplified"), build_string ("gb2312"), - Qnil, 0, 0, 0, 33); + 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, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("G1"), + build_string ("GB 12345)"), + build_string ("GB 12345-1990"), + build_string ("GB12345\\(\\.1990\\)?-0"), + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_japanese_jisx0208); Vcharset_japanese_jisx0208 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, - CHARSET_TYPE_94X94, 2, 0, 'B', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2, + 2, 0, 'B', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0208"), build_string ("JIS X0208:1983 (Japanese)"), build_string ("JIS X0208:1983 Japanese Kanji"), build_string ("jisx0208\\.1983"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, 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, + 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, MIN_CHAR_JIS_X0208_1990, 33, + Qnil, CONVERSION_94x94); +#endif + staticpro (&Vcharset_korean_ksc5601); Vcharset_korean_ksc5601 = - make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, - CHARSET_TYPE_94X94, 2, 0, 'C', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 94, 2, + 2, 0, 'C', CHARSET_LEFT_TO_RIGHT, build_string ("KSC5601"), build_string ("KSC5601 (Korean"), build_string ("KSC5601 Korean Hangul and Hanja"), build_string ("ksc5601"), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_japanese_jisx0212); Vcharset_japanese_jisx0212 = - make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, - CHARSET_TYPE_94X94, 2, 0, 'D', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2, + 2, 0, 'D', CHARSET_LEFT_TO_RIGHT, build_string ("JISX0212"), build_string ("JISX0212 (Japanese)"), build_string ("JISX0212 Japanese Supplement"), 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); Vcharset_chinese_cns11643_1 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, - CHARSET_TYPE_94X94, 2, 0, 'G', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 94, 2, + 2, 0, 'G', CHARSET_LEFT_TO_RIGHT, build_string ("CNS11643-1"), build_string ("CNS11643-1 (Chinese traditional)"), build_string ("CNS 11643 Plane 1 Chinese traditional"), build_string (CHINESE_CNS_PLANE_RE("1")), - Qnil, 0, 0, 0, 33); + 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, - 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")), - Qnil, 0, 0, 0, 33); + Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL); #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\\(\\.1993\\)?-1"), + 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, - CHARSET_TYPE_96, 1, 1, '1', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1, + 1, 1, '1', CHARSET_LEFT_TO_RIGHT, build_string ("VISCII lower"), build_string ("VISCII lower (Vietnamese)"), build_string ("VISCII lower (Vietnamese)"), build_string ("MULEVISCII-LOWER"), - Qnil, 0, 0, 0, 32); + 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, - CHARSET_TYPE_96, 1, 1, '2', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1, + 1, 1, '2', CHARSET_LEFT_TO_RIGHT, build_string ("VISCII upper"), build_string ("VISCII upper (Vietnamese)"), build_string ("VISCII upper (Vietnamese)"), build_string ("MULEVISCII-UPPER"), - Qnil, 0, 0, 0, 32); + Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_latin_viscii); Vcharset_latin_viscii = - make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, - CHARSET_TYPE_256, 1, 2, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("VISCII"), build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII1\\.1"), - Qnil, 0, 0, 0, 0); + 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, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Big5"), + build_string ("Big5"), + build_string ("Big5 Chinese traditional"), + build_string ("big5-0"), + Qnil, + MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP, + MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL); +#if 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, MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP, + MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL); +#endif +#define DEF_HANZIKU(n) \ + staticpro (&Vcharset_ideograph_hanziku_##n); \ + Vcharset_ideograph_hanziku_##n = \ + make_charset (LEADING_BYTE_HANZIKU_##n, Qideograph_hanziku_##n, 256, 2, \ + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, \ + build_string ("HZK-"#n), \ + build_string ("HANZIKU-"#n), \ + build_string ("HANZIKU (pseudo BIG5 encoding) part "#n), \ + build_string \ + ("hanziku-"#n"$"), \ + Qnil, MIN_CHAR_HANZIKU_##n, MAX_CHAR_HANZIKU_##n, \ + MIN_CHAR_HANZIKU_##n, 0, Qnil, CONVERSION_IDENTICAL); + DEF_HANZIKU (1); + DEF_HANZIKU (2); + DEF_HANZIKU (3); + DEF_HANZIKU (4); + DEF_HANZIKU (5); + DEF_HANZIKU (6); + DEF_HANZIKU (7); + DEF_HANZIKU (8); + DEF_HANZIKU (9); + DEF_HANZIKU (10); + DEF_HANZIKU (11); + DEF_HANZIKU (12); + staticpro (&Vcharset_china3_jef); + Vcharset_china3_jef = + make_charset (LEADING_BYTE_CHINA3_JEF, Qchina3_jef, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("JC3"), + build_string ("JEF + CHINA3"), + build_string ("JEF + CHINA3 private characters"), + build_string ("china3jef-0"), + Qnil, MIN_CHAR_CHINA3_JEF, MAX_CHAR_CHINA3_JEF, + MIN_CHAR_CHINA3_JEF, 0, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ideograph_cbeta); + Vcharset_ideograph_cbeta = + make_charset (LEADING_BYTE_CBETA, Qideograph_cbeta, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("CB"), + build_string ("CBETA"), + build_string ("CBETA private characters"), + build_string ("cbeta-0"), + Qnil, MIN_CHAR_CBETA, MAX_CHAR_CBETA, + MIN_CHAR_CBETA, 0, Qnil, CONVERSION_IDENTICAL); + 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, + MIN_CHAR_GT, 0, Qnil, CONVERSION_IDENTICAL); +#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, Qnil, CONVERSION_IDENTICAL); + 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_2); + Vcharset_ideograph_daikanwa_2 = + make_charset (LEADING_BYTE_DAIKANWA_2, Qideograph_daikanwa_2, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Daikanwa Rev."), + build_string ("Morohashi's Daikanwa Rev."), + build_string + ("Daikanwa dictionary (revised version)"), + build_string ("Daikanwa\\(\\.[0-9]+\\)?-2"), + Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL); + staticpro (&Vcharset_ideograph_daikanwa); Vcharset_ideograph_daikanwa = - make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, - CHARSET_TYPE_256X256, 2, 2, 0, - CHARSET_LEFT_TO_RIGHT, - build_string ("Daikanwa"), - build_string ("Morohashi's Daikanwa"), - build_string ("Daikanwa dictionary by MOROHASHI Tetsuji"), + make_charset (LEADING_BYTE_DAIKANWA_3, Qideograph_daikanwa, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Daikanwa"), - Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, 0, 0); + build_string ("Morohashi's Daikanwa Rev.2"), + build_string + ("Daikanwa dictionary (second revised version)"), + build_string ("Daikanwa\\(\\.[0-9]+\\)?-3"), + Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, + MIN_CHAR_DAIKANWA, 0, Qnil, CONVERSION_IDENTICAL); + + staticpro (&Vcharset_ethiopic_ucs); Vcharset_ethiopic_ucs = - make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, - CHARSET_TYPE_256X256, 2, 2, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Ethiopic (UCS)"), build_string ("Ethiopic (UCS)"), build_string ("Ethiopic of UCS"), build_string ("Ethiopic-Unicode"), - Qnil, 0x1200, 0x137F, 0x1200, 0); + Qnil, 0x1200, 0x137F, 0, 0, + Qnil, CONVERSION_IDENTICAL); #endif + staticpro (&Vcharset_chinese_big5_1); Vcharset_chinese_big5_1 = - make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, - CHARSET_TYPE_94X94, 2, 0, '0', - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 94, 2, + 2, 0, '0', CHARSET_LEFT_TO_RIGHT, build_string ("Big5"), build_string ("Big5 (Level-1)"), build_string ("Big5 Level-1 Chinese traditional"), build_string ("big5"), - Qnil, 0, 0, 0, 33); + 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, - 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"), - 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. This is going to lead to problems because you can run out of room, esp. as we don't yet recycle numbers. */ + staticpro (&Vcharset_composite); Vcharset_composite = - make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, - CHARSET_TYPE_96X96, 2, 0, 0, - CHARSET_LEFT_TO_RIGHT, + make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 96, 2, + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, build_string ("Composite"), build_string ("Composite characters"), build_string ("Composite characters"), build_string ("")); + /* #### not dumped properly */ composite_char_row_next = 32; composite_char_col_next = 32;