X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=3fb4030bee0a3b932bfef5d18e1e2df08a40812b;hb=7c20beeb0e0dae144d6cb5785761366d9b5c369a;hp=c17dcba2c2da6568ba27f67984ae47a39a63ed22;hpb=c8db677c8739a82ce43293d09ebc2552089dee39;p=chise%2Fxemacs-chise.git- diff --git a/src/mule-charset.c b/src/mule-charset.c index c17dcba..3fb4030 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -1,7 +1,7 @@ /* Functions to handle multilingual characters. Copyright (C) 1992, 1995 Free Software Foundation, Inc. Copyright (C) 1995 Sun Microsystems, Inc. - Copyright (C) 1999,2000 MORIOKA Tomohiko + Copyright (C) 1999,2000,2001 MORIOKA Tomohiko This file is part of XEmacs. @@ -20,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" @@ -53,6 +56,7 @@ 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; @@ -62,12 +66,31 @@ Lisp_Object Vcharset_chinese_cns11643_2; #ifdef UTF2000 Lisp_Object Vcharset_ucs; Lisp_Object Vcharset_ucs_bmp; +Lisp_Object Vcharset_ucs_cns; +Lisp_Object Vcharset_ucs_jis; +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_japanese_jef_china3; +Lisp_Object Vcharset_ideograph_gt; +Lisp_Object Vcharset_ideograph_gt_pj_1; +Lisp_Object Vcharset_ideograph_gt_pj_2; +Lisp_Object Vcharset_ideograph_gt_pj_3; +Lisp_Object Vcharset_ideograph_gt_pj_4; +Lisp_Object Vcharset_ideograph_gt_pj_5; +Lisp_Object Vcharset_ideograph_gt_pj_6; +Lisp_Object Vcharset_ideograph_gt_pj_7; +Lisp_Object Vcharset_ideograph_gt_pj_8; +Lisp_Object Vcharset_ideograph_gt_pj_9; +Lisp_Object Vcharset_ideograph_gt_pj_10; +Lisp_Object Vcharset_ideograph_gt_pj_11; Lisp_Object Vcharset_ideograph_daikanwa; Lisp_Object Vcharset_mojikyo; +Lisp_Object Vcharset_mojikyo_2022_1; Lisp_Object Vcharset_mojikyo_pj_1; Lisp_Object Vcharset_mojikyo_pj_2; Lisp_Object Vcharset_mojikyo_pj_3; @@ -159,546 +182,6 @@ const Bytecount rep_bytes_by_first_byte[0xA0] = #ifdef UTF2000 -static Lisp_Object -mark_byte_table (Lisp_Object obj) -{ - Lisp_Byte_Table *cte = XBYTE_TABLE (obj); - int i; - - for (i = 0; i < 256; i++) - { - mark_object (cte->property[i]); - } - return Qnil; -} - -static int -byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - Lisp_Byte_Table *cte1 = XBYTE_TABLE (obj1); - Lisp_Byte_Table *cte2 = XBYTE_TABLE (obj2); - int i; - - for (i = 0; i < 256; i++) - if (BYTE_TABLE_P (cte1->property[i])) - { - if (BYTE_TABLE_P (cte2->property[i])) - { - if (!byte_table_equal (cte1->property[i], - cte2->property[i], depth + 1)) - return 0; - } - else - return 0; - } - else - if (!internal_equal (cte1->property[i], cte2->property[i], depth + 1)) - return 0; - return 1; -} - -static unsigned long -byte_table_hash (Lisp_Object obj, int depth) -{ - Lisp_Byte_Table *cte = XBYTE_TABLE (obj); - - return internal_array_hash (cte->property, 256, depth); -} - -static const struct lrecord_description byte_table_description[] = { - { XD_LISP_OBJECT_ARRAY, offsetof(Lisp_Byte_Table, property), 256 }, - { XD_END } -}; - -DEFINE_LRECORD_IMPLEMENTATION ("byte-table", byte_table, - mark_byte_table, - internal_object_printer, - 0, byte_table_equal, - byte_table_hash, - byte_table_description, - Lisp_Byte_Table); - -static Lisp_Object -make_byte_table (Lisp_Object initval, int older) -{ - Lisp_Object obj; - int i; - Lisp_Byte_Table *cte; - - if (older) - cte = alloc_older_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table); - else - cte = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table); - - for (i = 0; i < 256; i++) - cte->property[i] = initval; - - XSETBYTE_TABLE (obj, cte); - return obj; -} - -static Lisp_Object -copy_byte_table (Lisp_Object entry) -{ - Lisp_Byte_Table *cte = XBYTE_TABLE (entry); - Lisp_Object obj; - int i; - Lisp_Byte_Table *ctenew - = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table); - - for (i = 0; i < 256; i++) - { - Lisp_Object new = cte->property[i]; - if (BYTE_TABLE_P (new)) - ctenew->property[i] = copy_byte_table (new); - else - ctenew->property[i] = new; - } - - XSETBYTE_TABLE (obj, ctenew); - return obj; -} - - -static Lisp_Object -mark_char_id_table (Lisp_Object obj) -{ - Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); - - return cte->table; -} - -static int -char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) -{ - Lisp_Char_ID_Table *cte1 = XCHAR_ID_TABLE (obj1); - Lisp_Char_ID_Table *cte2 = XCHAR_ID_TABLE (obj2); - - return byte_table_equal (cte1->table, cte2->table, depth + 1); -} - -static unsigned long -char_id_table_hash (Lisp_Object obj, int depth) -{ - Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj); - - return char_id_table_hash (cte->table, depth + 1); -} - -static const struct lrecord_description char_id_table_description[] = { - { XD_LISP_OBJECT, offsetof(Lisp_Char_ID_Table, table) }, - { XD_END } -}; - -DEFINE_LRECORD_IMPLEMENTATION ("char-id-table", char_id_table, - mark_char_id_table, - internal_object_printer, - 0, char_id_table_equal, - char_id_table_hash, - char_id_table_description, - Lisp_Char_ID_Table); - -static Lisp_Object -make_char_id_table (Lisp_Object initval, int older) -{ - Lisp_Object obj; - Lisp_Char_ID_Table *cte; - - if (older) - cte = alloc_older_lcrecord_type (Lisp_Char_ID_Table, - &lrecord_char_id_table); - else - cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); - - cte->table = make_byte_table (initval, older); - - XSETCHAR_ID_TABLE (obj, cte); - return obj; -} - -/* not used */ -#if 0 -static Lisp_Object -copy_char_id_table (Lisp_Object entry) -{ - Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (entry); - Lisp_Object obj; - Lisp_Char_ID_Table *ctenew - = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table); - - ctenew->table = copy_byte_table (cte->table); - XSETCHAR_ID_TABLE (obj, ctenew); - return obj; -} -#endif - - -Lisp_Object -get_char_id_table (Emchar ch, Lisp_Object table) -{ - unsigned int code = ch; - Lisp_Byte_Table* cpt - = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table); - Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)]; - - if (BYTE_TABLE_P (ret)) - cpt = XBYTE_TABLE (ret); - else - return ret; - - ret = cpt->property [(unsigned char) (code >> 16)]; - if (BYTE_TABLE_P (ret)) - cpt = XBYTE_TABLE (ret); - else - return ret; - - ret = cpt->property [(unsigned char) (code >> 8)]; - if (BYTE_TABLE_P (ret)) - cpt = XBYTE_TABLE (ret); - else - return ret; - - return cpt->property [(unsigned char) code]; -} - -void put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table); -void -put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table) -{ - unsigned int code = ch; - Lisp_Byte_Table* cpt1 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table); - Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)]; - - if (BYTE_TABLE_P (ret)) - { - Lisp_Byte_Table* cpt2 = XBYTE_TABLE (ret); - - ret = cpt2->property[(unsigned char)(code >> 16)]; - if (BYTE_TABLE_P (ret)) - { - Lisp_Byte_Table* cpt3 = XBYTE_TABLE (ret); - - ret = cpt3->property[(unsigned char)(code >> 8)]; - if (BYTE_TABLE_P (ret)) - { - Lisp_Byte_Table* cpt4 = XBYTE_TABLE (ret); - - cpt4->property[(unsigned char)code] = value; - } - else if (!EQ (ret, value)) - { - Lisp_Object cpt4 - = make_byte_table (ret, OLDER_RECORD_P (table)); - - XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - cpt3->property[(unsigned char)(code >> 8)] = cpt4; - } - } - else if (!EQ (ret, value)) - { - int older = OLDER_RECORD_P (table); - Lisp_Object cpt3 = make_byte_table (ret, older); - Lisp_Object cpt4 = make_byte_table (ret, older); - - XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] - = cpt4; - cpt2->property[(unsigned char)(code >> 16)] = cpt3; - } - } - else if (!EQ (ret, value)) - { - int older = OLDER_RECORD_P (table); - Lisp_Object cpt2 = make_byte_table (ret, older); - Lisp_Object cpt3 = make_byte_table (ret, older); - Lisp_Object cpt4 = make_byte_table (ret, older); - - XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value; - XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4; - XBYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3; - cpt1->property[(unsigned char)(code >> 24)] = cpt2; - } -} - - -Lisp_Object Vcharacter_attribute_table; -Lisp_Object Vcharacter_name_table; -Lisp_Object Vcharacter_composition_table; -Lisp_Object Vcharacter_variant_table; - -Lisp_Object Qname; -Lisp_Object Q_decomposition; -Lisp_Object Qucs; -Lisp_Object Q_ucs; -Lisp_Object Qcompat; -Lisp_Object Qisolated; -Lisp_Object Qinitial; -Lisp_Object Qmedial; -Lisp_Object Qfinal; -Lisp_Object Qvertical; -Lisp_Object QnoBreak; -Lisp_Object Qfraction; -Lisp_Object Qsuper; -Lisp_Object Qsub; -Lisp_Object Qcircle; -Lisp_Object Qsquare; -Lisp_Object Qwide; -Lisp_Object Qnarrow; -Lisp_Object Qsmall; -Lisp_Object Qfont; - -Emchar to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg); - -Lisp_Object put_char_ccs_code_point (Lisp_Object character, - Lisp_Object ccs, Lisp_Object value); -Lisp_Object remove_char_ccs (Lisp_Object character, Lisp_Object ccs); - -Lisp_Object put_char_attribute (Lisp_Object character, - Lisp_Object attribute, Lisp_Object value); -Lisp_Object remove_char_attribute (Lisp_Object character, - Lisp_Object attribute); - - -Emchar -to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg) -{ - if (INTP (v)) - return XINT (v); - if (CHARP (v)) - return XCHAR (v); - else if (EQ (v, Qcompat)) - return -1; - else if (EQ (v, Qisolated)) - return -2; - else if (EQ (v, Qinitial)) - return -3; - else if (EQ (v, Qmedial)) - return -4; - else if (EQ (v, Qfinal)) - return -5; - else if (EQ (v, Qvertical)) - return -6; - else if (EQ (v, QnoBreak)) - return -7; - else if (EQ (v, Qfraction)) - return -8; - else if (EQ (v, Qsuper)) - return -9; - else if (EQ (v, Qsub)) - return -10; - else if (EQ (v, Qcircle)) - return -11; - else if (EQ (v, Qsquare)) - return -12; - else if (EQ (v, Qwide)) - return -13; - else if (EQ (v, Qnarrow)) - return -14; - else if (EQ (v, Qsmall)) - return -15; - else if (EQ (v, Qfont)) - return -16; - else - signal_simple_error (err_msg, err_arg); -} - -DEFUN ("get-composite-char", Fget_composite_char, 1, 1, 0, /* -Return character corresponding with list. -*/ - (list)) -{ - Lisp_Object table = Vcharacter_composition_table; - Lisp_Object rest = list; - - while (CONSP (rest)) - { - Lisp_Object v = Fcar (rest); - Lisp_Object ret; - Emchar c = to_char_id (v, "Invalid value for composition", list); - - ret = get_char_id_table (c, table); - - rest = Fcdr (rest); - if (NILP (rest)) - { - if (!CHAR_ID_TABLE_P (ret)) - return ret; - else - return Qt; - } - else if (!CONSP (rest)) - break; - else if (CHAR_ID_TABLE_P (ret)) - table = ret; - else - signal_simple_error ("Invalid table is found with", list); - } - signal_simple_error ("Invalid value for composition", list); -} - -DEFUN ("char-variants", Fchar_variants, 1, 1, 0, /* -Return variants of CHARACTER. -*/ - (character)) -{ - CHECK_CHAR (character); - return Fcopy_list (get_char_id_table (XCHAR (character), - Vcharacter_variant_table)); -} - -DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /* -Return the alist of attributes of CHARACTER. -*/ - (character)) -{ - CHECK_CHAR (character); - return Fcopy_alist (get_char_id_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 ccs; - - CHECK_CHAR (character); - if (!NILP (ccs = Ffind_charset (attribute))) - { - Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs); - - if (CHAR_ID_TABLE_P (encoding_table)) - return get_char_id_table (XCHAR (character), encoding_table); - else - return Qnil; - } - else if (EQ (attribute, Qname)) - { - return get_char_id_table (XCHAR (character), Vcharacter_name_table); - } - else - { - Lisp_Object ret - = get_char_id_table (XCHAR (character), Vcharacter_attribute_table); - - if (EQ (ret, Qnil)) - return Qnil; - else - return Fcdr (Fassq (attribute, ret)); - } -} - -DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /* -Store CHARACTER's ATTRIBUTE with VALUE. -*/ - (character, attribute, value)) -{ - Lisp_Object ccs; - - CHECK_CHAR (character); - ccs = Ffind_charset (attribute); - if (!NILP (ccs)) - { - return put_char_ccs_code_point (character, ccs, value); - } - else if (EQ (attribute, Qname)) - { - CHECK_STRING (value); - put_char_id_table (XCHAR (character), value, Vcharacter_name_table); - return value; - } - else if (EQ (attribute, Q_decomposition)) - { - if (!CONSP (value)) - signal_simple_error ("Invalid value for ->decomposition", - value); - - if (CONSP (Fcdr (value))) - { - Lisp_Object rest = value; - Lisp_Object table = Vcharacter_composition_table; - - while (CONSP (rest)) - { - Lisp_Object v = Fcar (rest); - Lisp_Object ntable; - Emchar c - = to_char_id (v, "Invalid value for ->decomposition", value); - - rest = Fcdr (rest); - if (!CONSP (rest)) - { - put_char_id_table (c, character, table); - break; - } - else - { - ntable = get_char_id_table (c, table); - if (!CHAR_ID_TABLE_P (ntable)) - { - ntable - = make_char_id_table (Qnil, OLDER_RECORD_P (table)); - put_char_id_table (c, ntable, table); - } - table = ntable; - } - } - } - else - { - Lisp_Object v = Fcar (value); - - if (INTP (v)) - { - Emchar c = XINT (v); - Lisp_Object ret - = get_char_id_table (c, Vcharacter_variant_table); - - if (NILP (Fmemq (v, ret))) - { - put_char_id_table (c, Fcons (character, ret), - Vcharacter_variant_table); - } - } - } - } - else if (EQ (attribute, Q_ucs)) - { - Lisp_Object ret; - Emchar c; - - if (!INTP (value)) - signal_simple_error ("Invalid value for ->ucs", value); - - c = XINT (value); - - ret = get_char_id_table (c, Vcharacter_variant_table); - if (NILP (Fmemq (character, ret))) - { - put_char_id_table (c, Fcons (character, ret), - Vcharacter_variant_table); - } - } - return put_char_attribute (character, attribute, value); -} - -DEFUN ("remove-char-attribute", Fremove_char_attribute, 2, 2, 0, /* -Remove CHARACTER's ATTRIBUTE. -*/ - (character, attribute)) -{ - Lisp_Object ccs; - - CHECK_CHAR (character); - ccs = Ffind_charset (attribute); - if (!NILP (ccs)) - { - return remove_char_ccs (character, ccs); - } - return remove_char_attribute (character, attribute); -} - INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs); INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs) @@ -852,7 +335,7 @@ put_char_ccs_code_point (Lisp_Object character, if (VECTORP (v)) { - Lisp_Object cpos = Fget_char_attribute (character, ccs); + Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); if (!NILP (cpos)) { decoding_table_remove_char (v, dim, byte_offset, XINT (cpos)); @@ -869,9 +352,9 @@ put_char_ccs_code_point (Lisp_Object character, if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs))) { XCHARSET_ENCODING_TABLE (ccs) - = encoding_table = make_char_id_table (Qnil, -1); + = encoding_table = make_char_id_table (Qnil); } - put_char_id_table (XCHAR (character), value, encoding_table); + put_char_id_table (XCHAR_TABLE(encoding_table), character, value); return Qt; } @@ -883,7 +366,7 @@ remove_char_ccs (Lisp_Object character, Lisp_Object ccs) if (VECTORP (decoding_table)) { - Lisp_Object cpos = Fget_char_attribute (character, ccs); + Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil); if (!NILP (cpos)) { @@ -893,130 +376,13 @@ remove_char_ccs (Lisp_Object character, Lisp_Object ccs) XINT (cpos)); } } - if (CHAR_ID_TABLE_P (encoding_table)) + if (CHAR_TABLEP (encoding_table)) { - put_char_id_table (XCHAR (character), Qnil, encoding_table); + put_char_id_table (XCHAR_TABLE(encoding_table), character, Qnil); } return Qt; } -Lisp_Object -put_char_attribute (Lisp_Object character, Lisp_Object attribute, - Lisp_Object value) -{ - Emchar char_id = XCHAR (character); - Lisp_Object ret = get_char_id_table (char_id, Vcharacter_attribute_table); - Lisp_Object cell; - - cell = Fassq (attribute, ret); - - if (NILP (cell)) - { - ret = Fcons (Fcons (attribute, value), ret); - } - else if (!EQ (Fcdr (cell), value)) - { - Fsetcdr (cell, value); - } - put_char_id_table (char_id, ret, Vcharacter_attribute_table); - return ret; -} - -Lisp_Object -remove_char_attribute (Lisp_Object character, Lisp_Object attribute) -{ - Emchar char_id = XCHAR (character); - Lisp_Object alist = get_char_id_table (char_id, Vcharacter_attribute_table); - - if (EQ (attribute, Fcar (Fcar (alist)))) - { - alist = Fcdr (alist); - } - else - { - Lisp_Object pr = alist; - Lisp_Object r = Fcdr (alist); - - while (!NILP (r)) - { - if (EQ (attribute, Fcar (Fcar (r)))) - { - XCDR (pr) = Fcdr (r); - break; - } - pr = r; - r = Fcdr (r); - } - } - put_char_id_table (char_id, alist, Vcharacter_attribute_table); - return alist; -} - -EXFUN (Fmake_char, 3); -EXFUN (Fdecode_char, 2); - -DEFUN ("define-char", Fdefine_char, 1, 1, 0, /* -Store character's ATTRIBUTES. -*/ - (attributes)) -{ - Lisp_Object rest = attributes; - Lisp_Object code = Fcdr (Fassq (Qucs, attributes)); - Lisp_Object character; - - if (NILP (code)) - { - while (CONSP (rest)) - { - Lisp_Object cell = Fcar (rest); - Lisp_Object ccs; - - if (!LISTP (cell)) - signal_simple_error ("Invalid argument", attributes); - if (!NILP (ccs = Ffind_charset (Fcar (cell))) - && ((XCHARSET_FINAL (ccs) != 0) || - (XCHARSET_UCS_MAX (ccs) > 0)) ) - { - cell = Fcdr (cell); - if (CONSP (cell)) - character = Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell))); - else - character = Fdecode_char (ccs, cell); - goto setup_attributes; - } - rest = Fcdr (rest); - } - if (!NILP (code = Fcdr (Fassq (Q_ucs, attributes)))) - { - if (!INTP (code)) - signal_simple_error ("Invalid argument", attributes); - else - character = make_char (XINT (code) + 0x100000); - goto setup_attributes; - } - return Qnil; - } - else if (!INTP (code)) - signal_simple_error ("Invalid argument", attributes); - else - character = make_char (XINT (code)); - - setup_attributes: - rest = attributes; - while (CONSP (rest)) - { - Lisp_Object cell = Fcar (rest); - - if (!LISTP (cell)) - signal_simple_error ("Invalid argument", attributes); - Fput_char_attribute (character, Fcar (cell), Fcdr (cell)); - rest = Fcdr (rest); - } - return - get_char_id_table (XCHAR (character), Vcharacter_attribute_table); -} - -Lisp_Object Vutf_2000_version; #endif #ifndef UTF2000 @@ -1048,6 +414,7 @@ Lisp_Object Qascii, Qlatin_iso8859_9, Qjapanese_jisx0208_1978, Qchinese_gb2312, + Qchinese_gb12345, Qjapanese_jisx0208, Qjapanese_jisx0208_1990, Qkorean_ksc5601, @@ -1055,15 +422,35 @@ Lisp_Object Qascii, Qchinese_cns11643_1, Qchinese_cns11643_2, #ifdef UTF2000 + Qucs, Qucs_bmp, + Qucs_cns, + Qucs_jis, + Qucs_big5, Qlatin_viscii, Qlatin_tcvn5712, Qlatin_viscii_lower, Qlatin_viscii_upper, Qvietnamese_viscii_lower, Qvietnamese_viscii_upper, + Qchinese_big5, + Qchinese_big5_cdp, + Qjapanese_jef_china3, 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, Qmojikyo, + Qmojikyo_2022_1, Qmojikyo_pj_1, Qmojikyo_pj_2, Qmojikyo_pj_3, @@ -1356,30 +743,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; } @@ -1396,36 +771,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); } @@ -1462,7 +816,7 @@ mark_charset (Lisp_Object obj) mark_object (cs->registry); mark_object (cs->ccl_program); #ifdef UTF2000 - /* mark_object (cs->encoding_table); */ + mark_object (cs->encoding_table); /* mark_object (cs->decoding_table); */ #endif return cs->name; @@ -1519,8 +873,9 @@ DEFINE_LRECORD_IMPLEMENTATION ("charset", charset, mark_charset, print_charset, 0, 0, 0, charset_description, Lisp_Charset); -/* Make a new charset. */ +/* Make a new charset. */ +/* #### SJT Should generic properties be allowed? */ static Lisp_Object make_charset (Charset_ID id, Lisp_Object name, unsigned short chars, unsigned char dimension, @@ -1532,7 +887,6 @@ make_charset (Charset_ID id, Lisp_Object name, Emchar ucs_min, Emchar ucs_max, Emchar code_offset, unsigned char byte_offset) { - unsigned char type = 0; Lisp_Object obj; Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset); @@ -1552,68 +906,15 @@ make_charset (Charset_ID id, Lisp_Object name, CHARSET_FINAL (cs) = final; CHARSET_DOC_STRING (cs) = doc; CHARSET_REGISTRY (cs) = reg; - CHARSET_CCL_PROGRAM (cs) = Qnil; - CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil; -#ifdef UTF2000 - CHARSET_DECODING_TABLE(cs) = Qnil; - CHARSET_ENCODING_TABLE(cs) = Qnil; - CHARSET_UCS_MIN(cs) = ucs_min; - CHARSET_UCS_MAX(cs) = ucs_max; - CHARSET_CODE_OFFSET(cs) = code_offset; - CHARSET_BYTE_OFFSET(cs) = byte_offset; -#endif - - switch (CHARSET_CHARS (cs)) - { - case 94: - switch (CHARSET_DIMENSION (cs)) - { - case 1: - type = CHARSET_TYPE_94; - break; - case 2: - type = CHARSET_TYPE_94X94; - break; - } - break; - case 96: - switch (CHARSET_DIMENSION (cs)) - { - case 1: - type = CHARSET_TYPE_96; - break; - case 2: - type = CHARSET_TYPE_96X96; - break; - } - break; -#ifdef UTF2000 - case 128: - switch (CHARSET_DIMENSION (cs)) - { - case 1: - type = CHARSET_TYPE_128; - break; - case 2: - type = CHARSET_TYPE_128X128; - break; - } - break; - case 256: - switch (CHARSET_DIMENSION (cs)) - { - case 1: - type = CHARSET_TYPE_256; - break; - case 2: - type = CHARSET_TYPE_256X256; - break; - } - break; -#endif - } -#ifndef UTF2000 - CHARSET_TYPE (cs) = type; + CHARSET_CCL_PROGRAM (cs) = Qnil; + CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil; +#ifdef UTF2000 + CHARSET_DECODING_TABLE(cs) = Qnil; + CHARSET_ENCODING_TABLE(cs) = Qnil; + CHARSET_UCS_MIN(cs) = ucs_min; + CHARSET_UCS_MAX(cs) = ucs_max; + CHARSET_CODE_OFFSET(cs) = code_offset; + CHARSET_BYTE_OFFSET(cs) = byte_offset; #endif #ifndef UTF2000 @@ -1630,15 +931,18 @@ make_charset (Charset_ID id, Lisp_Object name, /* 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 (chlook->charset_by_attributes[type][final])); - chlook->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 (chlook->charset_by_attributes[type][final][direction])); - chlook->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 } @@ -1688,55 +992,96 @@ get_unallocated_leading_byte (int dimension) } #ifdef UTF2000 +/* Number of Big5 characters which have the same code in 1st byte. */ + +#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40) + Emchar -make_builtin_char (Lisp_Object charset, int c1, int c2) +decode_builtin_char (Lisp_Object charset, int code_point) { - if (XCHARSET_UCS_MAX (charset)) - { - Emchar code - = (XCHARSET_DIMENSION (charset) == 1 - ? - c1 - XCHARSET_BYTE_OFFSET (charset) - : - (c1 - XCHARSET_BYTE_OFFSET (charset)) * XCHARSET_CHARS (charset) - + c2 - XCHARSET_BYTE_OFFSET (charset)) - - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset); - if ((code < XCHARSET_UCS_MIN (charset)) - || (XCHARSET_UCS_MAX (charset) < code)) - signal_simple_error ("Arguments makes invalid character", - make_char (code)); - return code; - } - else if (XCHARSET_DIMENSION (charset) == 1) + int final; + + if (EQ (charset, Vcharset_chinese_big5)) { - switch (XCHARSET_CHARS (charset)) + 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)) ) ) { - case 94: - return MIN_CHAR_94 - + (XCHARSET_FINAL (charset) - '0') * 94 + (c1 - 33); - case 96: - return MIN_CHAR_96 - + (XCHARSET_FINAL (charset) - '0') * 96 + (c1 - 32); - default: - abort (); + 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 ((final = XCHARSET_FINAL (charset)) >= '0') { - switch (XCHARSET_CHARS (charset)) + if (XCHARSET_DIMENSION (charset) == 1) + { + 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 { - case 94: - return MIN_CHAR_94x94 - + (XCHARSET_FINAL (charset) - '0') * 94 * 94 - + (c1 - 33) * 94 + (c2 - 33); - case 96: - return MIN_CHAR_96x96 - + (XCHARSET_FINAL (charset) - '0') * 96 * 96 - + (c1 - 32) * 96 + (c2 - 32); - default: - abort (); + 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 (XCHARSET_UCS_MAX (charset)) + { + Emchar cid + = (XCHARSET_DIMENSION (charset) == 1 + ? + code_point - XCHARSET_BYTE_OFFSET (charset) + : + ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset)) + * XCHARSET_CHARS (charset) + + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset)) + - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset); + if ((cid < XCHARSET_UCS_MIN (charset)) + || (XCHARSET_UCS_MAX (charset) < cid)) + return -1; + return cid; + } + else + return -1; } int @@ -1821,6 +1166,20 @@ range_charset_code_point (Lisp_Object charset, Emchar ch) return -1; } } + if (EQ (charset, Vcharset_mojikyo_2022_1) + && (MIN_CHAR_MOJIKYO < ch) && (ch < MIN_CHAR_MOJIKYO + 94 * 60 * 94)) + { + int m = ch - MIN_CHAR_MOJIKYO - 1; + int byte1 = m / (94 * 60) + 33; + int byte2 = (m % (94 * 60)) / 94; + int byte3 = m % 94 + 33; + + if (byte2 < 30) + byte2 += 16 + 32; + else + byte2 += 18 + 32; + return (byte1 << 16) | (byte2 << 8) | byte3; + } return -1; } @@ -1843,22 +1202,12 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) return c & 0x7F; } /* - else if ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK)) - { - *charset = Vcharset_greek_iso8859_7; - return c - MIN_CHAR_GREEK + 0x20; - } - else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC)) - { - *charset = Vcharset_cyrillic_iso8859_5; - return c - MIN_CHAR_CYRILLIC + 0x20; - } - */ else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW)) { *charset = Vcharset_hebrew_iso8859_8; return c - MIN_CHAR_HEBREW + 0x20; } + */ else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI)) { *charset = Vcharset_thai_tis620; @@ -1882,17 +1231,15 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) *charset = Vcharset_ucs; return c; } - /* else if (c <= MAX_CHAR_DAIKANWA) { *charset = Vcharset_ideograph_daikanwa; return c - MIN_CHAR_DAIKANWA; } - */ - else if (c <= MAX_CHAR_MOJIKYO) + else if (c <= MAX_CHAR_MOJIKYO_0) { *charset = Vcharset_mojikyo; - return c - MIN_CHAR_MOJIKYO; + return c - MIN_CHAR_MOJIKYO_0; } else if (c < MIN_CHAR_94) { @@ -1901,7 +1248,7 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) } else if (c <= MAX_CHAR_94) { - *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94, + *charset = CHARSET_BY_ATTRIBUTES (94, 1, ((c - MIN_CHAR_94) / 94) + '0', CHARSET_LEFT_TO_RIGHT); if (!NILP (*charset)) @@ -1914,7 +1261,7 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) } else if (c <= MAX_CHAR_96) { - *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96, + *charset = CHARSET_BY_ATTRIBUTES (96, 1, ((c - MIN_CHAR_96) / 96) + '0', CHARSET_LEFT_TO_RIGHT); if (!NILP (*charset)) @@ -1928,7 +1275,7 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) else if (c <= MAX_CHAR_94x94) { *charset - = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94, + = CHARSET_BY_ATTRIBUTES (94, 2, ((c - MIN_CHAR_94x94) / (94 * 94)) + '0', CHARSET_LEFT_TO_RIGHT); if (!NILP (*charset)) @@ -1943,7 +1290,7 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) else if (c <= MAX_CHAR_96x96) { *charset - = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96X96, + = CHARSET_BY_ATTRIBUTES (96, 2, ((c - MIN_CHAR_96x96) / (96 * 96)) + '0', CHARSET_LEFT_TO_RIGHT); if (!NILP (*charset)) @@ -1955,6 +1302,26 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset) return c; } } + else if (c < MIN_CHAR_MOJIKYO) + { + *charset = Vcharset_ucs; + return c; + } + else if (c <= MAX_CHAR_MOJIKYO) + { + *charset = Vcharset_mojikyo; + return c - MIN_CHAR_MOJIKYO; + } + else if (c < MIN_CHAR_JEF_CHINA3) + { + *charset = Vcharset_ucs; + return c; + } + else if (c <= MAX_CHAR_JEF_CHINA3) + { + *charset = Vcharset_japanese_jef_china3; + return c - MAX_CHAR_JEF_CHINA3; + } else { *charset = Vcharset_ucs; @@ -2024,7 +1391,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; } @@ -2047,13 +1414,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. @@ -2105,10 +1473,8 @@ character set. Recognized properties are: { 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; int byte_offset = -1; @@ -2121,89 +1487,94 @@ 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 || dimension > 2) + 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) + 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); #ifdef UTF2000 - if (graphic < 0 || graphic > 2) + if (graphic < 0 || graphic > 2) #else - if (graphic < 0 || graphic > 1) + if (graphic < 0 || 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; - } + else if (EQ (keyword, Qccl_program)) + { + struct ccl_program test_ccl; - else - signal_simple_error ("Unrecognized property", keyword); - } + 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); + } + } if (!final) error ("'final must be specified"); @@ -2212,13 +1583,10 @@ character set. Recognized properties are: ("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"); @@ -2351,7 +1719,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); @@ -2380,19 +1747,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); @@ -2432,7 +1794,7 @@ 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. */ @@ -2460,10 +1822,8 @@ 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; } signal_simple_error ("Unrecognized charset property name", prop); return Qnil; /* not reached */ @@ -2485,8 +1845,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; } @@ -2541,6 +1904,8 @@ Set mapping-table of CHARSET to TABLE. if (NILP (table)) { + if (VECTORP (CHARSET_DECODING_TABLE(cs))) + make_vector_newer (CHARSET_DECODING_TABLE(cs)); CHARSET_DECODING_TABLE(cs) = Qnil; return table; } @@ -2628,7 +1993,51 @@ Make a character from CHARSET and code-point CODE. c = XINT (code); if (XCHARSET_GRAPHIC (charset) == 1) c &= 0x7F7F7F7F; - return make_char (DECODE_CHAR (charset, c)); + c = DECODE_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); + 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); } #endif @@ -2657,7 +2066,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 @@ -2693,27 +2102,27 @@ 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 ("char-octet", Fchar_octet, 1, 2, 0, /* -Return the octet numbered N (should be 0 or 1) of char CH. +Return the octet numbered N (should be 0 or 1) of CHARACTER. N defaults to 0 if omitted. */ - (ch, n)) + (character, n)) { Lisp_Object charset; int octet0, octet1; - CHECK_CHAR_COERCE_INT (ch); + CHECK_CHAR_COERCE_INT (character); - BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1); + BREAKUP_CHAR (XCHAR (character), charset, octet0, octet1); if (NILP (n) || EQ (n, Qzero)) return make_int (octet0); @@ -2724,7 +2133,7 @@ N defaults to 0 if omitted. } DEFUN ("split-char", Fsplit_char, 1, 1, 0, /* -Return list of charset and one or two position-codes of CHAR. +Return list of charset and one or two position-codes of CHARACTER. */ (character)) { @@ -2851,10 +2260,6 @@ Return a string of the characters comprising a composite character. void syms_of_mule_charset (void) { -#ifdef UTF2000 - INIT_LRECORD_IMPLEMENTATION (byte_table); - INIT_LRECORD_IMPLEMENTATION (char_id_table); -#endif INIT_LRECORD_IMPLEMENTATION (charset); DEFSUBR (Fcharsetp); @@ -2876,19 +2281,13 @@ 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 (Fremove_char_attribute); - DEFSUBR (Fdefine_char); - DEFSUBR (Fchar_variants); - DEFSUBR (Fget_composite_char); DEFSUBR (Fcharset_mapping_table); DEFSUBR (Fset_charset_mapping_table); #endif #ifdef UTF2000 DEFSUBR (Fdecode_char); + DEFSUBR (Fdecode_builtin_char); #endif DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); @@ -2930,6 +2329,7 @@ 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"); @@ -2937,35 +2337,35 @@ syms_of_mule_charset (void) defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1"); defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2"); #ifdef UTF2000 - defsymbol (&Qname, "name"); - defsymbol (&Q_ucs, "->ucs"); - defsymbol (&Q_decomposition, "->decomposition"); - defsymbol (&Qcompat, "compat"); - defsymbol (&Qisolated, "isolated"); - defsymbol (&Qinitial, "initial"); - defsymbol (&Qmedial, "medial"); - defsymbol (&Qfinal, "final"); - defsymbol (&Qvertical, "vertical"); - defsymbol (&QnoBreak, "noBreak"); - defsymbol (&Qfraction, "fraction"); - defsymbol (&Qsuper, "super"); - defsymbol (&Qsub, "sub"); - defsymbol (&Qcircle, "circle"); - defsymbol (&Qsquare, "square"); - defsymbol (&Qwide, "wide"); - defsymbol (&Qnarrow, "narrow"); - defsymbol (&Qsmall, "small"); - defsymbol (&Qfont, "font"); defsymbol (&Qucs, "ucs"); defsymbol (&Qucs_bmp, "ucs-bmp"); + defsymbol (&Qucs_cns, "ucs-cns"); + defsymbol (&Qucs_jis, "ucs-jis"); + 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, "ideograph-daikanwa"); + defsymbol (&Qchinese_big5, "chinese-big5"); + defsymbol (&Qchinese_big5_cdp, "chinese-big5-cdp"); + defsymbol (&Qjapanese_jef_china3, "japanese-jef-china3"); defsymbol (&Qmojikyo, "mojikyo"); + defsymbol (&Qmojikyo_2022_1, "mojikyo-2022-1"); defsymbol (&Qmojikyo_pj_1, "mojikyo-pj-1"); defsymbol (&Qmojikyo_pj_2, "mojikyo-pj-2"); defsymbol (&Qmojikyo_pj_3, "mojikyo-pj-3"); @@ -3003,8 +2403,8 @@ vars_of_mule_charset (void) int k; #endif - chlook = xnew (struct charset_lookup); - dumpstruct (&chlook, &charset_lookup_description); + chlook = xnew_and_zero (struct charset_lookup); /* zero for Purify. */ + dump_add_root_struct_ptr (&chlook, &charset_lookup_description); /* Table of charsets indexed by leading byte. */ for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) @@ -3039,23 +2439,6 @@ Leading-code of private TYPE9N charset of column-width 1. #endif #ifdef UTF2000 - Vutf_2000_version = build_string("0.15 (Sangō)"); - DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /* -Version number of UTF-2000. -*/ ); - - staticpro (&Vcharacter_attribute_table); - Vcharacter_attribute_table = make_char_id_table (Qnil, 0); - - staticpro (&Vcharacter_name_table); - Vcharacter_name_table = make_char_id_table (Qnil, 0); - - /* staticpro (&Vcharacter_composition_table); */ - Vcharacter_composition_table = make_char_id_table (Qnil, -1); - - staticpro (&Vcharacter_variant_table); - Vcharacter_variant_table = make_char_id_table (Qnil, 0); - Vdefault_coded_charset_priority_list = Qnil; DEFVAR_LISP ("default-coded-charset-priority-list", &Vdefault_coded_charset_priority_list /* @@ -3093,11 +2476,38 @@ complex_vars_of_mule_charset (void) build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"), build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"), Qnil, 0, 0xFFFF, 0, 0); + staticpro (&Vcharset_ucs_cns); + Vcharset_ucs_cns = + make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("UCS for CNS"), + build_string ("UCS for CNS 11643"), + build_string ("ISO/IEC 10646 for CNS 11643"), + build_string (""), + Qnil, 0, 0, 0, 0); + staticpro (&Vcharset_ucs_jis); + Vcharset_ucs_jis = + make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3, + 1, 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); + staticpro (&Vcharset_ucs_big5); + Vcharset_ucs_big5 = + make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3, + 1, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("UCS for Big5"), + build_string ("UCS for Big5"), + build_string ("ISO/IEC 10646 for Big5"), + build_string (""), + Qnil, 0, 0, 0, 0); #else # define MIN_CHAR_THAI 0 # define MAX_CHAR_THAI 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 #endif @@ -3172,9 +2582,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-7 (Greek)"), build_string ("ISO8859-7 (Greek)"), build_string ("iso8859-7"), - Qnil, - 0 /* MIN_CHAR_GREEK */, - 0 /* MAX_CHAR_GREEK */, 0, 32); + Qnil, 0, 0, 0, 32); staticpro (&Vcharset_arabic_iso8859_6); Vcharset_arabic_iso8859_6 = make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1, @@ -3192,7 +2600,9 @@ complex_vars_of_mule_charset (void) 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); staticpro (&Vcharset_katakana_jisx0201); Vcharset_katakana_jisx0201 = make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1, @@ -3219,9 +2629,7 @@ complex_vars_of_mule_charset (void) build_string ("ISO8859-5 (Cyrillic)"), build_string ("ISO8859-5 (Cyrillic)"), build_string ("iso8859-5"), - Qnil, - 0 /* MIN_CHAR_CYRILLIC */, - 0 /* MAX_CHAR_CYRILLIC */, 0, 32); + Qnil, 0, 0, 0, 32); staticpro (&Vcharset_latin_iso8859_9); Vcharset_latin_iso8859_9 = make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1, @@ -3251,6 +2659,15 @@ complex_vars_of_mule_charset (void) build_string ("GB2312 Chinese simplified"), build_string ("gb2312"), Qnil, 0, 0, 0, 33); + 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); staticpro (&Vcharset_japanese_jisx0208); Vcharset_japanese_jisx0208 = make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2, @@ -3322,7 +2739,7 @@ complex_vars_of_mule_charset (void) build_string ("TCVN 5712"), build_string ("TCVN 5712 (VSCII-2)"), build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"), - build_string ("tcvn5712-1"), + build_string ("tcvn5712\\(\\.1993\\)?-1"), Qnil, 0, 0, 0, 32); staticpro (&Vcharset_latin_viscii_lower); Vcharset_latin_viscii_lower = @@ -3351,6 +2768,65 @@ complex_vars_of_mule_charset (void) build_string ("VISCII 1.1 (Vietnamese)"), build_string ("VISCII1\\.1"), Qnil, 0, 0, 0, 0); + 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"), + Qnil, 0, 0, 0, 0); + staticpro (&Vcharset_chinese_big5_cdp); + Vcharset_chinese_big5_cdp = + make_charset (LEADING_BYTE_CHINESE_BIG5_CDP, Qchinese_big5_cdp, 256, 2, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("Big5-CDP"), + build_string ("Big5 + CDP extension"), + build_string ("Big5 with CDP extension"), + build_string ("big5\\.cdp-0"), + Qnil, 0, 0, 0, 0); + staticpro (&Vcharset_japanese_jef_china3); + Vcharset_japanese_jef_china3 = + make_charset (LEADING_BYTE_JEF_CHINA3, Qjapanese_jef_china3, 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_JEF_CHINA3, MAX_CHAR_JEF_CHINA3, 0, 0); + staticpro (&Vcharset_ideograph_gt); + Vcharset_ideograph_gt = + make_charset (LEADING_BYTE_GT, Qideograph_gt, 256, 3, + 2, 2, 0, CHARSET_LEFT_TO_RIGHT, + build_string ("GT"), + build_string ("GT"), + build_string ("GT"), + build_string (""), + Qnil, MIN_CHAR_GT, MAX_CHAR_GT, 0, 0); +#define DEF_GT_PJ(n) \ + staticpro (&Vcharset_ideograph_gt_pj_##n); \ + Vcharset_ideograph_gt_pj_##n = \ + make_charset (LEADING_BYTE_GT_PJ_##n, Qideograph_gt_pj_##n, 94, 2, \ + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, \ + build_string ("GT-PJ-"#n), \ + build_string ("GT (pseudo JIS encoding) part "#n), \ + build_string ("GT 2000 (pseudo JIS encoding) part "#n), \ + build_string \ + ("\\(GTpj-"#n "\\|jisx0208\\.GT-"#n "\\)$"), \ + Qnil, 0, 0, 0, 33); + DEF_GT_PJ (1); + DEF_GT_PJ (2); + DEF_GT_PJ (3); + DEF_GT_PJ (4); + DEF_GT_PJ (5); + DEF_GT_PJ (6); + DEF_GT_PJ (7); + DEF_GT_PJ (8); + DEF_GT_PJ (9); + DEF_GT_PJ (10); + DEF_GT_PJ (11); + staticpro (&Vcharset_ideograph_daikanwa); Vcharset_ideograph_daikanwa = make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2, @@ -3369,216 +2845,51 @@ complex_vars_of_mule_charset (void) build_string ("Konjaku-Mojikyo"), build_string (""), Qnil, MIN_CHAR_MOJIKYO, MAX_CHAR_MOJIKYO, 0, 0); - staticpro (&Vcharset_mojikyo_pj_1); - Vcharset_mojikyo_pj_1 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_1, Qmojikyo_pj_1, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-1"), - build_string ("Mojikyo (pseudo JIS encoding) part 1"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 1"), - build_string ("jisx0208\\.Mojikyo-1$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_2); - Vcharset_mojikyo_pj_2 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_2, Qmojikyo_pj_2, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-2"), - build_string ("Mojikyo (pseudo JIS encoding) part 2"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 2"), - build_string ("jisx0208\\.Mojikyo-2$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_3); - Vcharset_mojikyo_pj_3 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_3, Qmojikyo_pj_3, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-3"), - build_string ("Mojikyo (pseudo JIS encoding) part 3"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 3"), - build_string ("jisx0208\\.Mojikyo-3$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_4); - Vcharset_mojikyo_pj_4 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_4, Qmojikyo_pj_4, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-4"), - build_string ("Mojikyo (pseudo JIS encoding) part 4"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 4"), - build_string ("jisx0208\\.Mojikyo-4$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_5); - Vcharset_mojikyo_pj_5 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_5, Qmojikyo_pj_5, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-5"), - build_string ("Mojikyo (pseudo JIS encoding) part 5"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 5"), - build_string ("jisx0208\\.Mojikyo-5$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_6); - Vcharset_mojikyo_pj_6 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_6, Qmojikyo_pj_6, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-6"), - build_string ("Mojikyo (pseudo JIS encoding) part 6"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 6"), - build_string ("jisx0208\\.Mojikyo-6$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_7); - Vcharset_mojikyo_pj_7 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_7, Qmojikyo_pj_7, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-7"), - build_string ("Mojikyo (pseudo JIS encoding) part 7"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 7"), - build_string ("jisx0208\\.Mojikyo-7$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_8); - Vcharset_mojikyo_pj_8 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_8, Qmojikyo_pj_8, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-8"), - build_string ("Mojikyo (pseudo JIS encoding) part 8"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 8"), - build_string ("jisx0208\\.Mojikyo-8$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_9); - Vcharset_mojikyo_pj_9 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_9, Qmojikyo_pj_9, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-9"), - build_string ("Mojikyo (pseudo JIS encoding) part 9"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 9"), - build_string ("jisx0208\\.Mojikyo-9$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_10); - Vcharset_mojikyo_pj_10 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_10, Qmojikyo_pj_10, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-10"), - build_string ("Mojikyo (pseudo JIS encoding) part 10"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 10"), - build_string ("jisx0208\\.Mojikyo-10$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_11); - Vcharset_mojikyo_pj_11 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_11, Qmojikyo_pj_11, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-11"), - build_string ("Mojikyo (pseudo JIS encoding) part 11"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 11"), - build_string ("jisx0208\\.Mojikyo-11$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_12); - Vcharset_mojikyo_pj_12 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_12, Qmojikyo_pj_12, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-12"), - build_string ("Mojikyo (pseudo JIS encoding) part 12"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 12"), - build_string ("jisx0208\\.Mojikyo-12$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_13); - Vcharset_mojikyo_pj_13 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_13, Qmojikyo_pj_13, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-13"), - build_string ("Mojikyo (pseudo JIS encoding) part 13"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 13"), - build_string ("jisx0208\\.Mojikyo-13$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_14); - Vcharset_mojikyo_pj_14 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_14, Qmojikyo_pj_14, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-14"), - build_string ("Mojikyo (pseudo JIS encoding) part 14"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 14"), - build_string ("jisx0208\\.Mojikyo-14$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_15); - Vcharset_mojikyo_pj_15 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_15, Qmojikyo_pj_15, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-15"), - build_string ("Mojikyo (pseudo JIS encoding) part 15"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 15"), - build_string ("jisx0208\\.Mojikyo-15$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_16); - Vcharset_mojikyo_pj_16 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_16, Qmojikyo_pj_16, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-16"), - build_string ("Mojikyo (pseudo JIS encoding) part 16"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 16"), - build_string ("jisx0208\\.Mojikyo-16$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_17); - Vcharset_mojikyo_pj_17 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_17, Qmojikyo_pj_17, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-17"), - build_string ("Mojikyo (pseudo JIS encoding) part 17"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 17"), - build_string ("jisx0208\\.Mojikyo-17$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_18); - Vcharset_mojikyo_pj_18 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_18, Qmojikyo_pj_18, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-18"), - build_string ("Mojikyo (pseudo JIS encoding) part 18"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 18"), - build_string ("jisx0208\\.Mojikyo-18$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_19); - Vcharset_mojikyo_pj_19 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_19, Qmojikyo_pj_19, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-19"), - build_string ("Mojikyo (pseudo JIS encoding) part 19"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 19"), - build_string ("jisx0208\\.Mojikyo-19$"), - Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_20); - Vcharset_mojikyo_pj_20 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_20, Qmojikyo_pj_20, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-20"), - build_string ("Mojikyo (pseudo JIS encoding) part 20"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 20"), - build_string ("jisx0208\\.Mojikyo-20$"), + staticpro (&Vcharset_mojikyo_2022_1); + Vcharset_mojikyo_2022_1 = + make_charset (LEADING_BYTE_MOJIKYO_2022_1, Qmojikyo_2022_1, 94, 3, + 2, 2, ':', CHARSET_LEFT_TO_RIGHT, + build_string ("Mojikyo-2022-1"), + build_string ("Mojikyo ISO-2022 Part 1"), + build_string ("Konjaku-Mojikyo for ISO/IEC 2022 Part 1"), + build_string (""), Qnil, 0, 0, 0, 33); - staticpro (&Vcharset_mojikyo_pj_21); - Vcharset_mojikyo_pj_21 = - make_charset (LEADING_BYTE_MOJIKYO_PJ_21, Qmojikyo_pj_21, 94, 2, - 2, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("Mojikyo-PJ-21"), - build_string ("Mojikyo (pseudo JIS encoding) part 21"), - build_string - ("Konjaku-Mojikyo (pseudo JIS encoding) part 21"), - build_string ("jisx0208\\.Mojikyo-21$"), + +#define DEF_MOJIKYO_PJ(n) \ + staticpro (&Vcharset_mojikyo_pj_##n); \ + Vcharset_mojikyo_pj_##n = \ + make_charset (LEADING_BYTE_MOJIKYO_PJ_##n, Qmojikyo_pj_##n, 94, 2, \ + 2, 0, 0, CHARSET_LEFT_TO_RIGHT, \ + build_string ("Mojikyo-PJ-"#n), \ + build_string ("Mojikyo (pseudo JIS encoding) part "#n), \ + build_string \ + ("Konjaku-Mojikyo (pseudo JIS encoding) part "#n), \ + build_string \ + ("\\(MojikyoPJ-"#n "\\|jisx0208\\.Mojikyo-"#n "\\)$"), \ Qnil, 0, 0, 0, 33); + + DEF_MOJIKYO_PJ (1); + DEF_MOJIKYO_PJ (2); + DEF_MOJIKYO_PJ (3); + DEF_MOJIKYO_PJ (4); + DEF_MOJIKYO_PJ (5); + DEF_MOJIKYO_PJ (6); + DEF_MOJIKYO_PJ (7); + DEF_MOJIKYO_PJ (8); + DEF_MOJIKYO_PJ (9); + DEF_MOJIKYO_PJ (10); + DEF_MOJIKYO_PJ (11); + DEF_MOJIKYO_PJ (12); + DEF_MOJIKYO_PJ (13); + DEF_MOJIKYO_PJ (14); + DEF_MOJIKYO_PJ (15); + DEF_MOJIKYO_PJ (16); + DEF_MOJIKYO_PJ (17); + DEF_MOJIKYO_PJ (18); + DEF_MOJIKYO_PJ (19); + DEF_MOJIKYO_PJ (20); + DEF_MOJIKYO_PJ (21); + staticpro (&Vcharset_ethiopic_ucs); Vcharset_ethiopic_ucs = make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2,