X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=eb866108719cd8b90ef167573fc65298e6fb824b;hb=c71f71a4cd68472da3d2ed05a42e60ce28918f46;hp=a0ccd35fcfe387be6dd4aefbd26d2cad7507f047;hpb=0c693dc08f0794304711787b2eb47c144ea4bef1;p=chise%2Fxemacs-chise.git diff --git a/src/mule-charset.c b/src/mule-charset.c index a0ccd35..eb86610 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -19,7 +19,7 @@ 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. */ +/* Synched up with: Mule 2.3. Not in FSF. */ /* Rewritten by Ben Wing . */ @@ -32,7 +32,6 @@ Boston, MA 02111-1307, USA. */ #include "lstream.h" #include "device.h" #include "faces.h" -#include "mule-ccl.h" /* The various pre-defined charsets. */ @@ -42,49 +41,39 @@ Lisp_Object Vcharset_latin_iso8859_1; Lisp_Object Vcharset_latin_iso8859_2; Lisp_Object Vcharset_latin_iso8859_3; Lisp_Object Vcharset_latin_iso8859_4; -Lisp_Object Vcharset_thai_tis620; -Lisp_Object Vcharset_greek_iso8859_7; +Lisp_Object Vcharset_cyrillic_iso8859_5; Lisp_Object Vcharset_arabic_iso8859_6; +Lisp_Object Vcharset_greek_iso8859_7; Lisp_Object Vcharset_hebrew_iso8859_8; +Lisp_Object Vcharset_latin_iso8859_9; +Lisp_Object Vcharset_thai_tis620; Lisp_Object Vcharset_katakana_jisx0201; Lisp_Object Vcharset_latin_jisx0201; -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_japanese_jisx0208; -Lisp_Object Vcharset_korean_ksc5601; Lisp_Object Vcharset_japanese_jisx0212; -Lisp_Object Vcharset_chinese_cns11643_1; -Lisp_Object Vcharset_chinese_cns11643_2; +Lisp_Object Vcharset_chinese_gb2312; Lisp_Object Vcharset_chinese_big5_1; Lisp_Object Vcharset_chinese_big5_2; - -#ifdef ENABLE_COMPOSITE_CHARS +Lisp_Object Vcharset_chinese_cns11643_1; +Lisp_Object Vcharset_chinese_cns11643_2; +Lisp_Object Vcharset_korean_ksc5601; Lisp_Object Vcharset_composite; -/* Hash tables for composite chars. One maps string representing +/* Hashtables for composite chars. One maps string representing composed chars to their equivalent chars; one goes the other way. */ -Lisp_Object Vcomposite_char_char2string_hash_table; -Lisp_Object Vcomposite_char_string2char_hash_table; - -static int composite_char_row_next; -static int composite_char_col_next; - -#endif /* ENABLE_COMPOSITE_CHARS */ +Lisp_Object Vcomposite_char_char2string_hashtable; +Lisp_Object Vcomposite_char_string2char_hashtable; -struct charset_lookup *chlook; +/* Table of charsets indexed by leading byte. */ +Lisp_Object charset_by_leading_byte[128]; -static const struct lrecord_description charset_lookup_description_1[] = { - { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), 128+4*128*2 }, - { XD_END } -}; +/* Table of charsets indexed by type/final-byte/direction. */ +Lisp_Object charset_by_attributes[4][128][2]; -static const struct struct_description charset_lookup_description = { - sizeof (struct charset_lookup), - charset_lookup_description_1 -}; +static int composite_char_row_next; +static int composite_char_col_next; /* Table of number of bytes in the string representation of a character indexed by the first byte of that representation. @@ -92,9 +81,9 @@ static const struct struct_description charset_lookup_description = { rep_bytes_by_first_byte(c) is more efficient than the equivalent canonical computation: - XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */ + (BYTE_ASCII_P (c) ? 1 : XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c))) */ -const Bytecount rep_bytes_by_first_byte[0xA0] = +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, @@ -118,37 +107,39 @@ Lisp_Object Qcharsetp; Lisp_Object Qregistry, Qfinal, Qgraphic; Lisp_Object Qdirection; Lisp_Object Qreverse_direction_charset; -Lisp_Object Qleading_byte; -Lisp_Object Qshort_name, Qlong_name; +Lisp_Object Qccl_program; + +Lisp_Object Qascii, Qcontrol_1, -Lisp_Object Qascii, - Qcontrol_1, Qlatin_iso8859_1, Qlatin_iso8859_2, Qlatin_iso8859_3, Qlatin_iso8859_4, - Qthai_tis620, - Qgreek_iso8859_7, + Qcyrillic_iso8859_5, Qarabic_iso8859_6, + Qgreek_iso8859_7, Qhebrew_iso8859_8, - Qkatakana_jisx0201, - Qlatin_jisx0201, - Qcyrillic_iso8859_5, Qlatin_iso8859_9, + + Qthai_tis620, + + Qkatakana_jisx0201, Qlatin_jisx0201, Qjapanese_jisx0208_1978, - Qchinese_gb2312, Qjapanese_jisx0208, - Qkorean_ksc5601, Qjapanese_jisx0212, - Qchinese_cns11643_1, - Qchinese_cns11643_2, - Qchinese_big5_1, - Qchinese_big5_2, - Qcomposite; + + Qchinese_gb2312, + Qchinese_big5_1, Qchinese_big5_2, + Qchinese_cns11643_1, Qchinese_cns11643_2, + + Qkorean_ksc5601, Qcomposite; Lisp_Object Ql2r, Qr2l; -Lisp_Object Vcharset_hash_table; +Lisp_Object Vcharset_hashtable; + +static Bufbyte next_allocated_1_byte_leading_byte; +static Bufbyte next_allocated_2_byte_leading_byte; /* Composite characters are characters constructed by overstriking two or more regular characters. @@ -217,7 +208,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) { Bufbyte i0 = *str, i1, i2 = 0; Lisp_Object charset; @@ -264,8 +255,7 @@ non_ascii_valid_char_p (Emchar ch) if (f3 < 0x20) return 0; - if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE && - f2 <= MAX_CHAR_FIELD2_PRIVATE)) + if (f3 != 0x20 && f3 != 0x7F) return 1; /* @@ -274,8 +264,6 @@ 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 @@ -289,19 +277,16 @@ non_ascii_valid_char_p (Emchar ch) if (f2 < 0x20 || f3 < 0x20) return 0; -#ifdef ENABLE_COMPOSITE_CHARS if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE) { if (UNBOUNDP (Fgethash (make_int (ch), - Vcomposite_char_char2string_hash_table, + Vcomposite_char_char2string_hashtable, Qunbound))) return 0; return 1; } -#endif /* ENABLE_COMPOSITE_CHARS */ - if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F - && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE)) + if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F) return 1; if (f1 <= MAX_CHAR_FIELD1_OFFICIAL) @@ -311,8 +296,6 @@ 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); } } @@ -322,18 +305,26 @@ non_ascii_valid_char_p (Emchar ch) /* Basic string functions */ /************************************************************************/ -/* 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. */ +/* 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. */ Bytecount -non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst) +non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str) { - unsigned int bytes = REP_BYTES_BY_FIRST_BYTE (*src); - unsigned int i; - for (i = bytes; i; i--, dst++, src++) - *dst = *src; - return bytes; + Bufbyte *strptr = str; + *strptr = *ptr++; + switch (REP_BYTES_BY_FIRST_BYTE (*strptr)) + { + /* Notice fallthrough. */ + case 4: *++strptr = *ptr++; + case 3: *++strptr = *ptr++; + case 2: *++strptr = *ptr; + break; + default: + abort (); + } + return strptr + 1 - str; } @@ -350,15 +341,26 @@ Lstream_get_emchar_1 (Lstream *stream, int ch) { Bufbyte str[MAX_EMCHAR_LEN]; Bufbyte *strptr = str; - unsigned int bytes; str[0] = (Bufbyte) ch; - - for (bytes = REP_BYTES_BY_FIRST_BYTE (ch) - 1; bytes; bytes--) + switch (REP_BYTES_BY_FIRST_BYTE (ch)) { - int c = Lstream_getc (stream); - bufpos_checking_assert (c >= 0); - *++strptr = (Bufbyte) c; + /* Notice fallthrough. */ + 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 (); } return charptr_emchar (str); } @@ -385,22 +387,20 @@ Lstream_funget_emchar (Lstream *stream, Emchar ch) /************************************************************************/ static Lisp_Object -mark_charset (Lisp_Object obj) +mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object)) { - Lisp_Charset *cs = XCHARSET (obj); + struct Lisp_Charset *cs = XCHARSET (obj); - mark_object (cs->short_name); - mark_object (cs->long_name); - mark_object (cs->doc_string); - mark_object (cs->registry); - mark_object (cs->ccl_program); + (markobj) (cs->doc_string); + (markobj) (cs->registry); + (markobj) (cs->ccl_program); return cs->name; } static void print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { - Lisp_Charset *cs = XCHARSET (obj); + struct Lisp_Charset *cs = XCHARSET (obj); char buf[200]; if (print_readably) @@ -411,10 +411,6 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) write_c_string ("#charset_by_attributes[type][final][direction])); - chlook->charset_by_attributes[type][final][direction] = obj; + assert (NILP (charset_by_attributes[type][final][direction])); + charset_by_attributes[type][final][direction] = obj; } - assert (NILP (chlook->charset_by_leading_byte[id - 128])); - chlook->charset_by_leading_byte[id - 128] = obj; + assert (NILP (charset_by_leading_byte[leading_byte - 128])); + charset_by_leading_byte[leading_byte - 128] = obj; + if (leading_byte < 0xA0) + /* official leading byte */ + rep_bytes_by_first_byte[leading_byte] = rep_bytes; /* Some charsets are "faux" and don't have names or really exist at all except in the leading-byte table. */ if (!NILP (name)) - Fputhash (name, obj, Vcharset_hash_table); + Fputhash (name, obj, Vcharset_hashtable); return obj; } @@ -508,17 +491,17 @@ get_unallocated_leading_byte (int dimension) if (dimension == 1) { - if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1) + if (next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1) lb = 0; else - lb = chlook->next_allocated_1_byte_leading_byte++; + lb = next_allocated_1_byte_leading_byte++; } else { - if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) + if (next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2) lb = 0; else - lb = chlook->next_allocated_2_byte_leading_byte++; + lb = next_allocated_2_byte_leading_byte++; } if (!lb) @@ -554,7 +537,7 @@ nil is returned. Otherwise the associated charset object is returned. return charset_or_name; CHECK_SYMBOL (charset_or_name); - return Fgethash (charset_or_name, Vcharset_hash_table, Qnil); + return Fgethash (charset_or_name, Vcharset_hashtable, Qnil); } DEFUN ("get-charset", Fget_charset, 1, 1, 0, /* @@ -580,15 +563,19 @@ struct charset_list_closure }; static int -add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value, +add_charset_to_list_mapper (CONST void *hash_key, void *hash_contents, void *charset_list_closure) { /* This function can GC */ + Lisp_Object key, contents; + Lisp_Object *charset_list; struct charset_list_closure *chcl = (struct charset_list_closure*) charset_list_closure; - Lisp_Object *charset_list = chcl->charset_list; + CVOID_TO_LISP (key, hash_key); + VOID_TO_LISP (contents, hash_contents); + charset_list = chcl->charset_list; - *charset_list = Fcons (XCHARSET_NAME (value), *charset_list); + *charset_list = Fcons (XCHARSET_NAME (contents), *charset_list); return 0; } @@ -603,7 +590,7 @@ Return a list of the names of all defined charsets. GCPRO1 (charset_list); charset_list_closure.charset_list = &charset_list; - elisp_maphash (add_charset_to_list_mapper, Vcharset_hash_table, + elisp_maphash (add_charset_to_list_mapper, Vcharset_hashtable, &charset_list_closure); UNGCPRO; @@ -611,14 +598,13 @@ Return a list of the names of all defined charsets. } DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /* -Return the name of charset CHARSET. +Return the name of the given 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. @@ -627,8 +613,6 @@ DOC-STRING is a string describing the character set. PROPS is a property list, describing the specific nature of the character set. Recognized properties are: -'short-name Short version of the charset name (ex: Latin-1) -'long-name Long version of the charset name (ex: ISO8859-1 (Latin-1)) 'registry A regular expression matching the font registry field for this character set. 'dimension Number of octets used to index a character in this charset. @@ -668,13 +652,13 @@ character set. Recognized properties are: */ (name, doc_string, props)) { - int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1; + int lb, 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; CHECK_SYMBOL (name); if (!NILP (doc_string)) @@ -684,90 +668,73 @@ character set. Recognized properties are: if (!NILP (charset)) signal_simple_error ("Cannot redefine existing charset", name); - { - 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; - } - - 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, 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); - if (graphic < 0 || graphic > 1) - signal_simple_error ("Invalid value for 'graphic", 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, 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)) - { - 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); - } - } + EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props) + { + 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, 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); + if (graphic < 0 || graphic > 1) + signal_simple_error ("Invalid value for 'graphic", 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, 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 + signal_simple_error ("Unrecognized property", keyword); + } if (!final) error ("'final must be specified"); @@ -786,7 +753,7 @@ character set. Recognized properties are: error ("Character set already defined for this DIMENSION/CHARS/FINAL combo"); - id = get_unallocated_leading_byte (dimension); + lb = get_unallocated_leading_byte (dimension); if (NILP (doc_string)) doc_string = build_string (""); @@ -794,16 +761,10 @@ character set. Recognized properties are: if (NILP (registry)) registry = build_string (""); - if (NILP (short_name)) - XSETSTRING (short_name, XSYMBOL (name)->name); - - if (NILP (long_name)) - long_name = doc_string; - if (columns == -1) columns = dimension; - charset = make_charset (id, name, dimension + 2, type, columns, graphic, - final, direction, short_name, long_name, doc_string, registry); + charset = make_charset (-1, name, lb, dimension + 2, type, columns, graphic, + final, direction, doc_string, registry); if (!NILP (ccl_program)) XCHARSET_CCL_PROGRAM (charset) = ccl_program; return charset; @@ -817,10 +778,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 lb, dimension, columns, graphic, final; int direction, type; - Lisp_Object registry, doc_string, short_name, long_name; - Lisp_Charset *cs; + Lisp_Object registry, doc_string; + struct Lisp_Charset *cs; charset = Fget_charset (charset); if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset))) @@ -836,7 +797,7 @@ NEW-NAME is the name of the new charset. Return the new charset. type = CHARSET_TYPE (cs); columns = CHARSET_COLUMNS (cs); dimension = CHARSET_DIMENSION (cs); - id = get_unallocated_leading_byte (dimension); + lb = get_unallocated_leading_byte (dimension); graphic = CHARSET_GRAPHIC (cs); final = CHARSET_FINAL (cs); @@ -844,13 +805,10 @@ NEW-NAME is the name of the new charset. Return the new charset. if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT) direction = CHARSET_LEFT_TO_RIGHT; doc_string = CHARSET_DOC_STRING (cs); - short_name = CHARSET_SHORT_NAME (cs); - long_name = CHARSET_LONG_NAME (cs); registry = CHARSET_REGISTRY (cs); - new_charset = make_charset (id, new_name, dimension + 2, type, columns, - graphic, final, direction, short_name, long_name, - doc_string, registry); + new_charset = make_charset (-1, new_name, lb, dimension + 2, type, columns, + graphic, final, direction, doc_string, registry); CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset; XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset; @@ -930,24 +888,8 @@ will be returned if character sets exist for both directions). return obj; } -DEFUN ("charset-short-name", Fcharset_short_name, 1, 1, 0, /* -Return short name of CHARSET. -*/ - (charset)) -{ - return XCHARSET_SHORT_NAME (Fget_charset (charset)); -} - -DEFUN ("charset-long-name", Fcharset_long_name, 1, 1, 0, /* -Return long name of CHARSET. -*/ - (charset)) -{ - return XCHARSET_LONG_NAME (Fget_charset (charset)); -} - -DEFUN ("charset-description", Fcharset_description, 1, 1, 0, /* -Return description of CHARSET. +DEFUN ("charset-doc-string", Fcharset_doc_string, 1, 1, 0, /* +Return doc string of CHARSET. */ (charset)) { @@ -963,21 +905,19 @@ Return dimension of CHARSET. } DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /* -Return property PROP of CHARSET, a charset object or symbol naming a charset. +Return property PROP of CHARSET. Recognized properties are those listed in `make-charset', as well as 'name and 'doc-string. */ (charset, prop)) { - Lisp_Charset *cs; + struct Lisp_Charset *cs; charset = Fget_charset (charset); cs = XCHARSET (charset); CHECK_SYMBOL (prop); if (EQ (prop, Qname)) return CHARSET_NAME (cs); - if (EQ (prop, Qshort_name)) return CHARSET_SHORT_NAME (cs); - if (EQ (prop, Qlong_name)) return CHARSET_LONG_NAME (cs); if (EQ (prop, Qdoc_string)) return CHARSET_DOC_STRING (cs); if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs)); if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs)); @@ -991,8 +931,10 @@ 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); - /* #### Is this translation OK? If so, error checking sufficient? */ - return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj; + if (NILP (obj)) + return Qnil; + else + return XCHARSET_NAME (obj); } signal_simple_error ("Unrecognized charset property name", prop); return Qnil; /* not reached */ @@ -1003,7 +945,7 @@ Return charset identification number of CHARSET. */ (charset)) { - return make_int(XCHARSET_LEADING_BYTE (Fget_charset (charset))); + return make_int(XCHARSET_ID (Fget_charset (charset))); } /* #### We need to figure out which properties we really want to @@ -1014,11 +956,8 @@ Set the 'ccl-program property of CHARSET to CCL-PROGRAM. */ (charset, ccl_program)) { - struct ccl_program test_ccl; - charset = Fget_charset (charset); - if (setup_ccl_program (&test_ccl, ccl_program) < 0) - signal_simple_error ("Invalid ccl-program", ccl_program); + CHECK_VECTOR (ccl_program); XCHARSET_CCL_PROGRAM (charset) = ccl_program; return Qnil; } @@ -1027,13 +966,13 @@ static void invalidate_charset_font_caches (Lisp_Object charset) { /* Invalidate font cache entries for charset on all devices. */ - Lisp_Object devcons, concons, hash_table; + Lisp_Object devcons, concons, hashtab; DEVICE_LOOP_NO_BREAK (devcons, concons) { struct device *d = XDEVICE (XCAR (devcons)); - hash_table = Fgethash (charset, d->charset_font_cache, Qunbound); - if (!UNBOUNDP (hash_table)) - Fclrhash (hash_table); + hashtab = Fgethash (charset, d->charset_font_cache, Qunbound); + if (!UNBOUNDP (hashtab)) + Fclrhash (hashtab); } } @@ -1057,14 +996,11 @@ Set the 'registry property of CHARSET to REGISTRY. /************************************************************************/ 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. -For example, (make-char 'latin-iso8859-2 185) will return the Latin 2 -character s with caron. +Make a multi-byte character from CHARSET and octets ARG1 and ARG2. */ (charset, arg1, arg2)) { - Lisp_Charset *cs; + struct Lisp_Charset *cs; int a1, a2; int lowlim, highlim; @@ -1077,11 +1013,7 @@ character s with caron. else /* CHARSET_CHARS (cs) == 96) */ lowlim = 32, highlim = 127; CHECK_INT (arg1); - /* It is useful (and safe, according to Olivier Galibert) to strip - 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. */ - a1 = XINT (arg1) & 0x7f; + a1 = XINT (arg1); if (a1 < lowlim || a1 > highlim) args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim)); @@ -1094,7 +1026,7 @@ character s with caron. } CHECK_INT (arg2); - a2 = XINT (arg2) & 0x7f; + a2 = XINT (arg2); if (a2 < lowlim || a2 > highlim) args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim)); @@ -1102,68 +1034,40 @@ character s with caron. } DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /* -Return the character set of CHARACTER. +Return the character set of char CH. */ - (character)) + (ch)) { - CHECK_CHAR_COERCE_INT (character); + CHECK_CHAR_COERCE_INT (ch); return XCHARSET_NAME (CHARSET_BY_LEADING_BYTE - (CHAR_LEADING_BYTE (XCHAR (character)))); + (CHAR_LEADING_BYTE (XCHAR (ch)))); } DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /* -Return the octet numbered N (should be 0 or 1) of CHARACTER. +Return the octet numbered N (should be 0 or 1) of char CH. N defaults to 0 if omitted. */ - (character, n)) + (ch, n)) { Lisp_Object charset; - int octet0, octet1; - - CHECK_CHAR_COERCE_INT (character); + int c1, c2, int_n; - 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); + CHECK_CHAR_COERCE_INT (ch); + if (NILP (n)) + int_n = 0; else - signal_simple_error ("Octet number must be 0 or 1", n); -} - -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; - int c1, c2; - - GCPRO2 (charset, rc); - CHECK_CHAR_COERCE_INT (character); - - BREAKUP_CHAR (XCHAR (character), charset, c1, c2); - - if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2) { - rc = list3 (XCHARSET_NAME (charset), make_int (c1), make_int (c2)); + CHECK_INT (n); + int_n = XINT (n); + if (int_n != 0 && int_n != 1) + signal_simple_error ("Octet number must be 0 or 1", n); } - else - { - rc = list2 (XCHARSET_NAME (charset), make_int (c1)); - } - UNGCPRO; - - return rc; + BREAKUP_CHAR (XCHAR (ch), charset, c1, c2); + return make_int (int_n == 0 ? c1 : c2); } -#ifdef ENABLE_COMPOSITE_CHARS /************************************************************************/ /* composite character functions */ /************************************************************************/ @@ -1173,7 +1077,7 @@ lookup_composite_char (Bufbyte *str, int len) { Lisp_Object lispstr = make_string (str, len); Lisp_Object ch = Fgethash (lispstr, - Vcomposite_char_string2char_hash_table, + Vcomposite_char_string2char_hashtable, Qunbound); Emchar emch; @@ -1184,9 +1088,9 @@ lookup_composite_char (Bufbyte *str, int len) emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next, composite_char_col_next); Fputhash (make_char (emch), lispstr, - Vcomposite_char_char2string_hash_table); + Vcomposite_char_char2string_hashtable); Fputhash (lispstr, make_char (emch), - Vcomposite_char_string2char_hash_table); + Vcomposite_char_string2char_hashtable); composite_char_col_next++; if (composite_char_col_next >= 128) { @@ -1203,13 +1107,13 @@ Lisp_Object composite_char_string (Emchar ch) { Lisp_Object str = Fgethash (make_char (ch), - Vcomposite_char_char2string_hash_table, + Vcomposite_char_char2string_hashtable, Qunbound); assert (!UNBOUNDP (str)); return str; } -xxDEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /* +DEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /* Convert a string into a single composite character. The character is the result of overstriking all the characters in the string. @@ -1221,7 +1125,7 @@ the string. XSTRING_LENGTH (string))); } -xxDEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /* +DEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /* Return a string of the characters comprising a composite character. */ (ch)) @@ -1234,7 +1138,6 @@ Return a string of the characters comprising a composite character. signal_simple_error ("Must be composite char", ch); return composite_char_string (emch); } -#endif /* ENABLE_COMPOSITE_CHARS */ /************************************************************************/ @@ -1244,8 +1147,6 @@ 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); @@ -1255,9 +1156,7 @@ syms_of_mule_charset (void) DEFSUBR (Fmake_reverse_direction_charset); /* DEFSUBR (Freverse_direction_charset); */ DEFSUBR (Fcharset_from_attributes); - DEFSUBR (Fcharset_short_name); - DEFSUBR (Fcharset_long_name); - DEFSUBR (Fcharset_description); + DEFSUBR (Fcharset_doc_string); DEFSUBR (Fcharset_dimension); DEFSUBR (Fcharset_property); DEFSUBR (Fcharset_id); @@ -1267,12 +1166,9 @@ syms_of_mule_charset (void) DEFSUBR (Fmake_char); DEFSUBR (Fchar_charset); DEFSUBR (Fchar_octet); - DEFSUBR (Fsplit_char); -#ifdef ENABLE_COMPOSITE_CHARS DEFSUBR (Fmake_composite_char); DEFSUBR (Fcomposite_char_string); -#endif defsymbol (&Qcharsetp, "charsetp"); defsymbol (&Qregistry, "registry"); @@ -1280,13 +1176,12 @@ syms_of_mule_charset (void) defsymbol (&Qgraphic, "graphic"); defsymbol (&Qdirection, "direction"); defsymbol (&Qreverse_direction_charset, "reverse-direction-charset"); - defsymbol (&Qshort_name, "short-name"); - defsymbol (&Qlong_name, "long-name"); + defsymbol (&Qccl_program, "ccl-program"); defsymbol (&Ql2r, "l2r"); defsymbol (&Qr2l, "r2l"); - /* Charsets, compatible with FSF 20.3 + /* Charsets, compatible with Emacs/Mule 19.33-delta Naming convention is Script-Charset[-Edition] */ defsymbol (&Qascii, "ascii"); defsymbol (&Qcontrol_1, "control-1"); @@ -1294,24 +1189,26 @@ syms_of_mule_charset (void) defsymbol (&Qlatin_iso8859_2, "latin-iso8859-2"); defsymbol (&Qlatin_iso8859_3, "latin-iso8859-3"); defsymbol (&Qlatin_iso8859_4, "latin-iso8859-4"); - defsymbol (&Qthai_tis620, "thai-tis620"); - defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7"); + defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5"); defsymbol (&Qarabic_iso8859_6, "arabic-iso8859-6"); + defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7"); defsymbol (&Qhebrew_iso8859_8, "hebrew-iso8859-8"); + defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9"); + defsymbol (&Qthai_tis620, "thai-tis620"); + defsymbol (&Qkatakana_jisx0201, "katakana-jisx0201"); defsymbol (&Qlatin_jisx0201, "latin-jisx0201"); - defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5"); - defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9"); defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978"); - defsymbol (&Qchinese_gb2312, "chinese-gb2312"); defsymbol (&Qjapanese_jisx0208, "japanese-jisx0208"); - defsymbol (&Qkorean_ksc5601, "korean-ksc5601"); defsymbol (&Qjapanese_jisx0212, "japanese-jisx0212"); - defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1"); - defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2"); + + defsymbol (&Qchinese_gb2312, "chinese-gb2312"); defsymbol (&Qchinese_big5_1, "chinese-big5-1"); defsymbol (&Qchinese_big5_2, "chinese-big5-2"); + defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1"); + defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2"); + defsymbol (&Qkorean_ksc5601, "korean-ksc5601"); defsymbol (&Qcomposite, "composite"); } @@ -1320,273 +1217,204 @@ vars_of_mule_charset (void) { int i, j, k; - 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++) - chlook->charset_by_leading_byte[i] = Qnil; + for (i = 0; i < countof (charset_by_leading_byte); i++) + charset_by_leading_byte[i] = Qnil; /* Table of charsets indexed by type/final-byte/direction. */ - for (i = 0; i < countof (chlook->charset_by_attributes); i++) - for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++) - for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++) - chlook->charset_by_attributes[i][j][k] = Qnil; + 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; - chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; - chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; + next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; + next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; } void complex_vars_of_mule_charset (void) { - staticpro (&Vcharset_hash_table); - Vcharset_hash_table = - make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); + staticpro (&Vcharset_hashtable); + Vcharset_hashtable = make_lisp_hashtable (50, HASHTABLE_NONWEAK, + HASHTABLE_EQ); /* Predefined character sets. We store them into variables for ease of access. */ - staticpro (&Vcharset_ascii); Vcharset_ascii = - make_charset (LEADING_BYTE_ASCII, Qascii, 1, + make_charset (0, Qascii, LEADING_BYTE_ASCII, 1, CHARSET_TYPE_94, 1, 0, 'B', CHARSET_LEFT_TO_RIGHT, - build_string ("ASCII"), - build_string ("ASCII)"), - build_string ("ASCII (ISO646 IRV)"), - build_string ("\\(iso8859-[0-9]*\\|-ascii\\)")); - staticpro (&Vcharset_control_1); + build_string ("ASCII (ISO 646 IRV)"), + build_string ("iso8859-1")); Vcharset_control_1 = - make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 2, - CHARSET_TYPE_94, 1, 1, 0, + make_charset (-1, Qcontrol_1, LEADING_BYTE_CONTROL_1, 2, + CHARSET_TYPE_94, 1, 0, 0, CHARSET_LEFT_TO_RIGHT, - build_string ("C1"), build_string ("Control characters"), - build_string ("Control characters 128-191"), build_string ("")); - staticpro (&Vcharset_latin_iso8859_1); Vcharset_latin_iso8859_1 = - make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 2, + make_charset (129, Qlatin_iso8859_1, LEADING_BYTE_LATIN_ISO8859_1, 2, CHARSET_TYPE_96, 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 ("ISO 8859-1 (Latin-1)"), build_string ("iso8859-1")); - staticpro (&Vcharset_latin_iso8859_2); Vcharset_latin_iso8859_2 = - make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 2, + make_charset (130, Qlatin_iso8859_2, LEADING_BYTE_LATIN_ISO8859_2, 2, CHARSET_TYPE_96, 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 ("ISO 8859-2 (Latin-2)"), build_string ("iso8859-2")); - staticpro (&Vcharset_latin_iso8859_3); Vcharset_latin_iso8859_3 = - make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 2, + make_charset (131, Qlatin_iso8859_3, LEADING_BYTE_LATIN_ISO8859_3, 2, CHARSET_TYPE_96, 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 ("ISO 8859-3 (Latin-3)"), build_string ("iso8859-3")); - staticpro (&Vcharset_latin_iso8859_4); Vcharset_latin_iso8859_4 = - make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 2, + make_charset (132, Qlatin_iso8859_4, LEADING_BYTE_LATIN_ISO8859_4, 2, CHARSET_TYPE_96, 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 ("ISO 8859-4 (Latin-4)"), build_string ("iso8859-4")); - staticpro (&Vcharset_thai_tis620); - Vcharset_thai_tis620 = - make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2, - CHARSET_TYPE_96, 1, 1, 'T', - CHARSET_LEFT_TO_RIGHT, - build_string ("TIS620"), - build_string ("TIS620 (Thai)"), - build_string ("TIS620.2529 (Thai)"), - build_string ("tis620")); - staticpro (&Vcharset_greek_iso8859_7); - Vcharset_greek_iso8859_7 = - make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 2, - CHARSET_TYPE_96, 1, 1, 'F', + Vcharset_cyrillic_iso8859_5 = + make_charset (140, Qcyrillic_iso8859_5, LEADING_BYTE_CYRILLIC_ISO8859_5, 2, + CHARSET_TYPE_96, 1, 1, 'L', CHARSET_LEFT_TO_RIGHT, - build_string ("ISO8859-7"), - build_string ("ISO8859-7 (Greek)"), - build_string ("ISO8859-7 (Greek)"), - build_string ("iso8859-7")); - staticpro (&Vcharset_arabic_iso8859_6); + build_string ("ISO 8859-5 (Cyrillic)"), + build_string ("iso8859-5")); Vcharset_arabic_iso8859_6 = - make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 2, + make_charset (135, Qarabic_iso8859_6, LEADING_BYTE_ARABIC_ISO8859_6, 2, CHARSET_TYPE_96, 1, 1, 'G', CHARSET_RIGHT_TO_LEFT, - build_string ("ISO8859-6"), - build_string ("ISO8859-6 (Arabic)"), - build_string ("ISO8859-6 (Arabic)"), + build_string ("ISO 8859-6 (Arabic)"), build_string ("iso8859-6")); - staticpro (&Vcharset_hebrew_iso8859_8); + Vcharset_greek_iso8859_7 = + make_charset (134, Qgreek_iso8859_7, LEADING_BYTE_GREEK_ISO8859_7, 2, + CHARSET_TYPE_96, 1, 1, 'F', + CHARSET_LEFT_TO_RIGHT, + build_string ("ISO 8859-7 (Greek)"), + build_string ("iso8859-7")); Vcharset_hebrew_iso8859_8 = - make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 2, + make_charset (136, Qhebrew_iso8859_8, LEADING_BYTE_HEBREW_ISO8859_8, 2, CHARSET_TYPE_96, 1, 1, 'H', CHARSET_RIGHT_TO_LEFT, - build_string ("ISO8859-8"), - build_string ("ISO8859-8 (Hebrew)"), - build_string ("ISO8859-8 (Hebrew)"), + build_string ("ISO 8859-8 (Hebrew)"), build_string ("iso8859-8")); - staticpro (&Vcharset_katakana_jisx0201); + Vcharset_latin_iso8859_9 = + make_charset (141, Qlatin_iso8859_9, LEADING_BYTE_LATIN_ISO8859_9, 2, + CHARSET_TYPE_96, 1, 1, 'M', + CHARSET_LEFT_TO_RIGHT, + build_string ("ISO 8859-9 (Latin-5)"), + build_string ("iso8859-9")); + Vcharset_thai_tis620 = + make_charset (133, Qthai_tis620, LEADING_BYTE_THAI_TIS620, 2, + CHARSET_TYPE_96, 1, 1, 'T', + CHARSET_LEFT_TO_RIGHT, + build_string ("TIS 620.2529 (Thai)"), + build_string ("tis620")); + + /* Japanese */ Vcharset_katakana_jisx0201 = - make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 2, + make_charset (137, Qkatakana_jisx0201, + LEADING_BYTE_KATAKANA_JISX0201, 2, CHARSET_TYPE_94, 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 ("JIS X0201-Katakana"), build_string ("jisx0201.1976")); - staticpro (&Vcharset_latin_jisx0201); Vcharset_latin_jisx0201 = - make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 2, + make_charset (138, Qlatin_jisx0201, + LEADING_BYTE_LATIN_JISX0201, 2, CHARSET_TYPE_94, 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 ("JIS X0201-Latin"), build_string ("jisx0201.1976")); - staticpro (&Vcharset_cyrillic_iso8859_5); - Vcharset_cyrillic_iso8859_5 = - make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 2, - CHARSET_TYPE_96, 1, 1, 'L', - CHARSET_LEFT_TO_RIGHT, - build_string ("ISO8859-5"), - build_string ("ISO8859-5 (Cyrillic)"), - build_string ("ISO8859-5 (Cyrillic)"), - build_string ("iso8859-5")); - staticpro (&Vcharset_latin_iso8859_9); - Vcharset_latin_iso8859_9 = - make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 2, - CHARSET_TYPE_96, 1, 1, 'M', - CHARSET_LEFT_TO_RIGHT, - build_string ("Latin-5"), - build_string ("ISO8859-9 (Latin-5)"), - build_string ("ISO8859-9 (Latin-5)"), - build_string ("iso8859-9")); - staticpro (&Vcharset_japanese_jisx0208_1978); Vcharset_japanese_jisx0208_1978 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, 3, + make_charset (144, Qjapanese_jisx0208_1978, + LEADING_BYTE_JAPANESE_JISX0208_1978, 3, CHARSET_TYPE_94X94, 2, 0, '@', CHARSET_LEFT_TO_RIGHT, - build_string ("JISX0208.1978"), - build_string ("JISX0208.1978 (Japanese)"), build_string - ("JISX0208.1978 Japanese Kanji (so called \"old JIS\")"), - build_string ("\\(jisx0208\\|jisc6226\\)\\.1978")); - staticpro (&Vcharset_chinese_gb2312); - Vcharset_chinese_gb2312 = - make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 3, - CHARSET_TYPE_94X94, 2, 0, 'A', - CHARSET_LEFT_TO_RIGHT, - build_string ("GB2312"), - build_string ("GB2312)"), - build_string ("GB2312 Chinese simplified"), - build_string ("gb2312")); - staticpro (&Vcharset_japanese_jisx0208); + ("JIS X0208-1978 (Japanese Kanji; Old Version)"), + build_string ("\\(jisx0208\\|jisc6226\\).19")); Vcharset_japanese_jisx0208 = - make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 3, + make_charset (146, Qjapanese_jisx0208, + LEADING_BYTE_JAPANESE_JISX0208, 3, CHARSET_TYPE_94X94, 2, 0, 'B', CHARSET_LEFT_TO_RIGHT, - build_string ("JISX0208"), - build_string ("JISX0208.1983/1990 (Japanese)"), - build_string ("JISX0208.1983/1990 Japanese Kanji"), + build_string ("JIS X0208-1983 (Japanese Kanji)"), build_string ("jisx0208.19\\(83\\|90\\)")); - staticpro (&Vcharset_korean_ksc5601); - Vcharset_korean_ksc5601 = - make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 3, - CHARSET_TYPE_94X94, 2, 0, 'C', - CHARSET_LEFT_TO_RIGHT, - build_string ("KSC5601"), - build_string ("KSC5601 (Korean"), - build_string ("KSC5601 Korean Hangul and Hanja"), - build_string ("ksc5601")); - staticpro (&Vcharset_japanese_jisx0212); Vcharset_japanese_jisx0212 = - make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 3, + make_charset (148, Qjapanese_jisx0212, + LEADING_BYTE_JAPANESE_JISX0212, 3, CHARSET_TYPE_94X94, 2, 0, 'D', CHARSET_LEFT_TO_RIGHT, - build_string ("JISX0212"), - build_string ("JISX0212 (Japanese)"), - build_string ("JISX0212 Japanese Supplement"), + build_string ("JIS X0212 (Japanese Supplement)"), build_string ("jisx0212")); + /* Chinese */ + Vcharset_chinese_gb2312 = + make_charset (145, Qchinese_gb2312, LEADING_BYTE_CHINESE_GB2312, 3, + CHARSET_TYPE_94X94, 2, 0, 'A', + CHARSET_LEFT_TO_RIGHT, + build_string ("GB 2312 (Simplified Chinese)"), + build_string ("gb2312")); #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$" - staticpro (&Vcharset_chinese_cns11643_1); Vcharset_chinese_cns11643_1 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 3, + make_charset (149, Qchinese_cns11643_1, + LEADING_BYTE_CHINESE_CNS11643_1, 3, CHARSET_TYPE_94X94, 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"), + ("CNS 11643 Plane 1 (Traditional Chinese for daily use)"), build_string (CHINESE_CNS_PLANE_RE("1"))); - staticpro (&Vcharset_chinese_cns11643_2); Vcharset_chinese_cns11643_2 = - make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 3, + make_charset (150, Qchinese_cns11643_2, + LEADING_BYTE_CHINESE_CNS11643_2, 3, CHARSET_TYPE_94X94, 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"), + ("CNS 11643 Plane 2 (Traditional Chinese for daily use)"), build_string (CHINESE_CNS_PLANE_RE("2"))); - staticpro (&Vcharset_chinese_big5_1); Vcharset_chinese_big5_1 = - make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 3, + make_charset (152, Qchinese_big5_1, LEADING_BYTE_CHINESE_BIG5_1, 3, CHARSET_TYPE_94X94, 2, 0, '0', CHARSET_LEFT_TO_RIGHT, - build_string ("Big5"), - build_string ("Big5 (Level-1)"), build_string - ("Big5 Level-1 Chinese traditional"), + ("Big5 Level 1 (Traditional Chinese for daily use)"), build_string ("big5")); - staticpro (&Vcharset_chinese_big5_2); Vcharset_chinese_big5_2 = - make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 3, + make_charset (153, Qchinese_big5_2, LEADING_BYTE_CHINESE_BIG5_2, 3, CHARSET_TYPE_94X94, 2, 0, '1', CHARSET_LEFT_TO_RIGHT, - build_string ("Big5"), - build_string ("Big5 (Level-2)"), build_string - ("Big5 Level-2 Chinese traditional"), + ("Big5 Level 2 (Traditional Chinese for daily use)"), build_string ("big5")); - -#ifdef ENABLE_COMPOSITE_CHARS + Vcharset_korean_ksc5601 = + make_charset (147, Qkorean_ksc5601, LEADING_BYTE_KOREAN_KSC5601, 3, + CHARSET_TYPE_94X94, 2, 0, 'C', + CHARSET_LEFT_TO_RIGHT, + build_string ("KS C5601 (Hangul and Korean Hanja)"), + build_string ("ksc5601")); /* #### 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, 3, + make_charset (-1, Qcomposite, LEADING_BYTE_COMPOSITE, 3, CHARSET_TYPE_96X96, 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; - Vcomposite_char_string2char_hash_table = - make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL); - Vcomposite_char_char2string_hash_table = - make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); - staticpro (&Vcomposite_char_string2char_hash_table); - staticpro (&Vcomposite_char_char2string_hash_table); -#endif /* ENABLE_COMPOSITE_CHARS */ + Vcomposite_char_string2char_hashtable = + make_lisp_hashtable (500, HASHTABLE_NONWEAK, HASHTABLE_EQUAL); + Vcomposite_char_char2string_hashtable = + make_lisp_hashtable (500, HASHTABLE_NONWEAK, HASHTABLE_EQ); + staticpro (&Vcomposite_char_string2char_hashtable); + staticpro (&Vcomposite_char_char2string_hashtable); }