1 /* Functions to handle multilingual characters.
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Sun Microsystems, Inc.
4 Copyright (C) 1999,2000 MORIOKA Tomohiko
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: FSF 20.3. Not in FSF. */
25 /* Rewritten by Ben Wing <ben@xemacs.org>. */
38 /* The various pre-defined charsets. */
40 Lisp_Object Vcharset_ascii;
41 Lisp_Object Vcharset_control_1;
42 Lisp_Object Vcharset_latin_iso8859_1;
43 Lisp_Object Vcharset_latin_iso8859_2;
44 Lisp_Object Vcharset_latin_iso8859_3;
45 Lisp_Object Vcharset_latin_iso8859_4;
46 Lisp_Object Vcharset_thai_tis620;
47 Lisp_Object Vcharset_greek_iso8859_7;
48 Lisp_Object Vcharset_arabic_iso8859_6;
49 Lisp_Object Vcharset_hebrew_iso8859_8;
50 Lisp_Object Vcharset_katakana_jisx0201;
51 Lisp_Object Vcharset_latin_jisx0201;
52 Lisp_Object Vcharset_cyrillic_iso8859_5;
53 Lisp_Object Vcharset_latin_iso8859_9;
54 Lisp_Object Vcharset_japanese_jisx0208_1978;
55 Lisp_Object Vcharset_chinese_gb2312;
56 Lisp_Object Vcharset_japanese_jisx0208;
57 Lisp_Object Vcharset_japanese_jisx0208_1990;
58 Lisp_Object Vcharset_korean_ksc5601;
59 Lisp_Object Vcharset_japanese_jisx0212;
60 Lisp_Object Vcharset_chinese_cns11643_1;
61 Lisp_Object Vcharset_chinese_cns11643_2;
63 Lisp_Object Vcharset_ucs;
64 Lisp_Object Vcharset_ucs_bmp;
65 Lisp_Object Vcharset_latin_viscii;
66 Lisp_Object Vcharset_latin_tcvn5712;
67 Lisp_Object Vcharset_latin_viscii_lower;
68 Lisp_Object Vcharset_latin_viscii_upper;
69 Lisp_Object Vcharset_ideograph_daikanwa;
70 Lisp_Object Vcharset_mojikyo;
71 Lisp_Object Vcharset_mojikyo_pj_1;
72 Lisp_Object Vcharset_mojikyo_pj_2;
73 Lisp_Object Vcharset_mojikyo_pj_3;
74 Lisp_Object Vcharset_mojikyo_pj_4;
75 Lisp_Object Vcharset_mojikyo_pj_5;
76 Lisp_Object Vcharset_mojikyo_pj_6;
77 Lisp_Object Vcharset_mojikyo_pj_7;
78 Lisp_Object Vcharset_mojikyo_pj_8;
79 Lisp_Object Vcharset_mojikyo_pj_9;
80 Lisp_Object Vcharset_mojikyo_pj_10;
81 Lisp_Object Vcharset_mojikyo_pj_11;
82 Lisp_Object Vcharset_mojikyo_pj_12;
83 Lisp_Object Vcharset_mojikyo_pj_13;
84 Lisp_Object Vcharset_mojikyo_pj_14;
85 Lisp_Object Vcharset_mojikyo_pj_15;
86 Lisp_Object Vcharset_mojikyo_pj_16;
87 Lisp_Object Vcharset_mojikyo_pj_17;
88 Lisp_Object Vcharset_mojikyo_pj_18;
89 Lisp_Object Vcharset_mojikyo_pj_19;
90 Lisp_Object Vcharset_mojikyo_pj_20;
91 Lisp_Object Vcharset_mojikyo_pj_21;
92 Lisp_Object Vcharset_ethiopic_ucs;
94 Lisp_Object Vcharset_chinese_big5_1;
95 Lisp_Object Vcharset_chinese_big5_2;
97 #ifdef ENABLE_COMPOSITE_CHARS
98 Lisp_Object Vcharset_composite;
100 /* Hash tables for composite chars. One maps string representing
101 composed chars to their equivalent chars; one goes the
103 Lisp_Object Vcomposite_char_char2string_hash_table;
104 Lisp_Object Vcomposite_char_string2char_hash_table;
106 static int composite_char_row_next;
107 static int composite_char_col_next;
109 #endif /* ENABLE_COMPOSITE_CHARS */
111 struct charset_lookup *chlook;
113 static const struct lrecord_description charset_lookup_description_1[] = {
114 { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte),
123 static const struct struct_description charset_lookup_description = {
124 sizeof (struct charset_lookup),
125 charset_lookup_description_1
129 /* Table of number of bytes in the string representation of a character
130 indexed by the first byte of that representation.
132 rep_bytes_by_first_byte(c) is more efficient than the equivalent
133 canonical computation:
135 XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */
137 const Bytecount rep_bytes_by_first_byte[0xA0] =
138 { /* 0x00 - 0x7f are for straight ASCII */
139 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
140 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
141 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
142 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
143 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
144 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
145 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
146 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
147 /* 0x80 - 0x8f are for Dimension-1 official charsets */
149 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
151 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
153 /* 0x90 - 0x9d are for Dimension-2 official charsets */
154 /* 0x9e is for Dimension-1 private charsets */
155 /* 0x9f is for Dimension-2 private charsets */
156 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
163 mark_byte_table (Lisp_Object obj)
165 Lisp_Byte_Table *cte = XBYTE_TABLE (obj);
168 for (i = 0; i < 256; i++)
170 mark_object (cte->property[i]);
176 byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
178 Lisp_Byte_Table *cte1 = XBYTE_TABLE (obj1);
179 Lisp_Byte_Table *cte2 = XBYTE_TABLE (obj2);
182 for (i = 0; i < 256; i++)
183 if (BYTE_TABLE_P (cte1->property[i]))
185 if (BYTE_TABLE_P (cte2->property[i]))
187 if (!byte_table_equal (cte1->property[i],
188 cte2->property[i], depth + 1))
195 if (!internal_equal (cte1->property[i], cte2->property[i], depth + 1))
201 byte_table_hash (Lisp_Object obj, int depth)
203 Lisp_Byte_Table *cte = XBYTE_TABLE (obj);
205 return internal_array_hash (cte->property, 256, depth);
208 static const struct lrecord_description byte_table_description[] = {
209 { XD_LISP_OBJECT_ARRAY, offsetof(Lisp_Byte_Table, property), 256 },
213 DEFINE_LRECORD_IMPLEMENTATION ("byte-table", byte_table,
215 internal_object_printer,
218 byte_table_description,
222 make_byte_table (Lisp_Object initval, int older)
226 Lisp_Byte_Table *cte;
229 cte = alloc_older_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
231 cte = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
233 for (i = 0; i < 256; i++)
234 cte->property[i] = initval;
236 XSETBYTE_TABLE (obj, cte);
241 copy_byte_table (Lisp_Object entry)
243 Lisp_Byte_Table *cte = XBYTE_TABLE (entry);
246 Lisp_Byte_Table *ctenew
247 = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
249 for (i = 0; i < 256; i++)
251 Lisp_Object new = cte->property[i];
252 if (BYTE_TABLE_P (new))
253 ctenew->property[i] = copy_byte_table (new);
255 ctenew->property[i] = new;
258 XSETBYTE_TABLE (obj, ctenew);
264 mark_char_id_table (Lisp_Object obj)
266 Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
272 char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
274 Lisp_Char_ID_Table *cte1 = XCHAR_ID_TABLE (obj1);
275 Lisp_Char_ID_Table *cte2 = XCHAR_ID_TABLE (obj2);
277 return byte_table_equal (cte1->table, cte2->table, depth + 1);
281 char_id_table_hash (Lisp_Object obj, int depth)
283 Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
285 return char_id_table_hash (cte->table, depth + 1);
288 static const struct lrecord_description char_id_table_description[] = {
289 { XD_LISP_OBJECT, offsetof(Lisp_Char_ID_Table, table) },
293 DEFINE_LRECORD_IMPLEMENTATION ("char-id-table", char_id_table,
295 internal_object_printer,
296 0, char_id_table_equal,
298 char_id_table_description,
302 make_char_id_table (Lisp_Object initval, int older)
305 Lisp_Char_ID_Table *cte;
308 cte = alloc_older_lcrecord_type (Lisp_Char_ID_Table,
309 &lrecord_char_id_table);
311 cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
313 cte->table = make_byte_table (initval, older);
315 XSETCHAR_ID_TABLE (obj, cte);
322 copy_char_id_table (Lisp_Object entry)
324 Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (entry);
326 Lisp_Char_ID_Table *ctenew
327 = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
329 ctenew->table = copy_byte_table (cte->table);
330 XSETCHAR_ID_TABLE (obj, ctenew);
337 get_char_id_table (Emchar ch, Lisp_Object table)
339 unsigned int code = ch;
341 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table);
342 Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)];
344 if (BYTE_TABLE_P (ret))
345 cpt = XBYTE_TABLE (ret);
349 ret = cpt->property [(unsigned char) (code >> 16)];
350 if (BYTE_TABLE_P (ret))
351 cpt = XBYTE_TABLE (ret);
355 ret = cpt->property [(unsigned char) (code >> 8)];
356 if (BYTE_TABLE_P (ret))
357 cpt = XBYTE_TABLE (ret);
361 return cpt->property [(unsigned char) code];
364 void put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table);
366 put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table)
368 unsigned int code = ch;
369 Lisp_Byte_Table* cpt1 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table);
370 Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)];
372 if (BYTE_TABLE_P (ret))
374 Lisp_Byte_Table* cpt2 = XBYTE_TABLE (ret);
376 ret = cpt2->property[(unsigned char)(code >> 16)];
377 if (BYTE_TABLE_P (ret))
379 Lisp_Byte_Table* cpt3 = XBYTE_TABLE (ret);
381 ret = cpt3->property[(unsigned char)(code >> 8)];
382 if (BYTE_TABLE_P (ret))
384 Lisp_Byte_Table* cpt4 = XBYTE_TABLE (ret);
386 cpt4->property[(unsigned char)code] = value;
388 else if (!EQ (ret, value))
391 = make_byte_table (ret, OLDER_RECORD_P (table));
393 XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
394 cpt3->property[(unsigned char)(code >> 8)] = cpt4;
397 else if (!EQ (ret, value))
399 int older = OLDER_RECORD_P (table);
400 Lisp_Object cpt3 = make_byte_table (ret, older);
401 Lisp_Object cpt4 = make_byte_table (ret, older);
403 XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
404 XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)]
406 cpt2->property[(unsigned char)(code >> 16)] = cpt3;
409 else if (!EQ (ret, value))
411 int older = OLDER_RECORD_P (table);
412 Lisp_Object cpt2 = make_byte_table (ret, older);
413 Lisp_Object cpt3 = make_byte_table (ret, older);
414 Lisp_Object cpt4 = make_byte_table (ret, older);
416 XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
417 XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)] = cpt4;
418 XBYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3;
419 cpt1->property[(unsigned char)(code >> 24)] = cpt2;
424 Lisp_Object Vcharacter_attribute_table;
425 Lisp_Object Vcharacter_name_table;
426 Lisp_Object Vcharacter_ideographic_radical_table;
427 Lisp_Object Vcharacter_ideographic_strokes_table;
428 Lisp_Object Vcharacter_total_strokes_table;
429 Lisp_Object Vcharacter_decomposition_table;
430 Lisp_Object Vcharacter_composition_table;
431 Lisp_Object Vcharacter_variant_table;
434 Lisp_Object Qideographic_radical, Qideographic_strokes;
435 Lisp_Object Qtotal_strokes;
436 Lisp_Object Q_decomposition;
440 Lisp_Object Qisolated;
441 Lisp_Object Qinitial;
444 Lisp_Object Qvertical;
445 Lisp_Object QnoBreak;
446 Lisp_Object Qfraction;
456 Emchar to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg);
458 Lisp_Object put_char_ccs_code_point (Lisp_Object character,
459 Lisp_Object ccs, Lisp_Object value);
460 Lisp_Object remove_char_ccs (Lisp_Object character, Lisp_Object ccs);
462 Lisp_Object put_char_attribute (Lisp_Object character,
463 Lisp_Object attribute, Lisp_Object value);
464 Lisp_Object remove_char_attribute (Lisp_Object character,
465 Lisp_Object attribute);
469 to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg)
475 else if (EQ (v, Qcompat))
477 else if (EQ (v, Qisolated))
479 else if (EQ (v, Qinitial))
481 else if (EQ (v, Qmedial))
483 else if (EQ (v, Qfinal))
485 else if (EQ (v, Qvertical))
487 else if (EQ (v, QnoBreak))
489 else if (EQ (v, Qfraction))
491 else if (EQ (v, Qsuper))
493 else if (EQ (v, Qsub))
495 else if (EQ (v, Qcircle))
497 else if (EQ (v, Qsquare))
499 else if (EQ (v, Qwide))
501 else if (EQ (v, Qnarrow))
503 else if (EQ (v, Qsmall))
505 else if (EQ (v, Qfont))
508 signal_simple_error (err_msg, err_arg);
511 DEFUN ("get-composite-char", Fget_composite_char, 1, 1, 0, /*
512 Return character corresponding with list.
516 Lisp_Object table = Vcharacter_composition_table;
517 Lisp_Object rest = list;
521 Lisp_Object v = Fcar (rest);
523 Emchar c = to_char_id (v, "Invalid value for composition", list);
525 ret = get_char_id_table (c, table);
530 if (!CHAR_ID_TABLE_P (ret))
535 else if (!CONSP (rest))
537 else if (CHAR_ID_TABLE_P (ret))
540 signal_simple_error ("Invalid table is found with", list);
542 signal_simple_error ("Invalid value for composition", list);
545 DEFUN ("char-variants", Fchar_variants, 1, 1, 0, /*
546 Return variants of CHARACTER.
550 CHECK_CHAR (character);
551 return Fcopy_list (get_char_id_table (XCHAR (character),
552 Vcharacter_variant_table));
555 DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /*
556 Return the alist of attributes of CHARACTER.
560 Lisp_Object alist, ret;
562 CHECK_CHAR (character);
563 alist = Fcopy_alist (get_char_id_table (XCHAR (character),
564 Vcharacter_attribute_table));
566 ret = get_char_id_table (XCHAR (character), Vcharacter_name_table);
568 alist = Fcons (Fcons (Qname, ret), alist);
570 ret = get_char_id_table (XCHAR (character),
571 Vcharacter_ideographic_radical_table);
573 alist = Fcons (Fcons (Qideographic_radical, ret), alist);
575 ret = get_char_id_table (XCHAR (character),
576 Vcharacter_ideographic_strokes_table);
578 alist = Fcons (Fcons (Qideographic_strokes, ret), alist);
580 ret = get_char_id_table (XCHAR (character), Vcharacter_total_strokes_table);
582 alist = Fcons (Fcons (Qtotal_strokes, ret), alist);
584 ret = get_char_id_table (XCHAR (character),
585 Vcharacter_decomposition_table);
587 alist = Fcons (Fcons (Q_decomposition, ret), alist);
592 DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /*
593 Return the value of CHARACTER's ATTRIBUTE.
595 (character, attribute))
599 CHECK_CHAR (character);
600 if (!NILP (ccs = Ffind_charset (attribute)))
602 Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
604 if (CHAR_ID_TABLE_P (encoding_table))
605 return get_char_id_table (XCHAR (character), encoding_table);
609 else if (EQ (attribute, Qname))
611 return get_char_id_table (XCHAR (character), Vcharacter_name_table);
613 else if (EQ (attribute, Qideographic_radical))
615 return get_char_id_table (XCHAR (character),
616 Vcharacter_ideographic_radical_table);
618 else if (EQ (attribute, Qideographic_strokes))
620 return get_char_id_table (XCHAR (character),
621 Vcharacter_ideographic_strokes_table);
623 else if (EQ (attribute, Qtotal_strokes))
625 return get_char_id_table (XCHAR (character),
626 Vcharacter_total_strokes_table);
628 else if (EQ (attribute, Q_decomposition))
630 return get_char_id_table (XCHAR (character),
631 Vcharacter_decomposition_table);
636 = get_char_id_table (XCHAR (character), Vcharacter_attribute_table);
641 return Fcdr (Fassq (attribute, ret));
645 DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /*
646 Store CHARACTER's ATTRIBUTE with VALUE.
648 (character, attribute, value))
652 CHECK_CHAR (character);
653 ccs = Ffind_charset (attribute);
656 return put_char_ccs_code_point (character, ccs, value);
658 else if (EQ (attribute, Qname))
660 CHECK_STRING (value);
661 put_char_id_table (XCHAR (character), value, Vcharacter_name_table);
664 else if (EQ (attribute, Qideographic_radical))
667 put_char_id_table (XCHAR (character), value,
668 Vcharacter_ideographic_radical_table);
671 else if (EQ (attribute, Qideographic_strokes))
674 put_char_id_table (XCHAR (character), value,
675 Vcharacter_ideographic_strokes_table);
678 else if (EQ (attribute, Qtotal_strokes))
681 put_char_id_table (XCHAR (character), value,
682 Vcharacter_total_strokes_table);
685 else if (EQ (attribute, Q_decomposition))
690 signal_simple_error ("Invalid value for ->decomposition",
693 if (CONSP (Fcdr (value)))
695 Lisp_Object rest = value;
696 Lisp_Object table = Vcharacter_composition_table;
700 GET_EXTERNAL_LIST_LENGTH (rest, len);
701 seq = make_older_vector (len, Qnil);
705 Lisp_Object v = Fcar (rest);
708 = to_char_id (v, "Invalid value for ->decomposition", value);
711 XVECTOR_DATA(seq)[i++] = v;
713 XVECTOR_DATA(seq)[i++] = make_char (c);
717 put_char_id_table (c, character, table);
722 ntable = get_char_id_table (c, table);
723 if (!CHAR_ID_TABLE_P (ntable))
726 = make_char_id_table (Qnil, OLDER_RECORD_P (table));
727 put_char_id_table (c, ntable, table);
735 Lisp_Object v = Fcar (value);
741 = get_char_id_table (c, Vcharacter_variant_table);
743 if (NILP (Fmemq (v, ret)))
745 put_char_id_table (c, Fcons (character, ret),
746 Vcharacter_variant_table);
749 seq = make_older_vector (1, v);
751 put_char_id_table (XCHAR (character), seq,
752 Vcharacter_decomposition_table);
755 else if (EQ (attribute, Q_ucs))
761 signal_simple_error ("Invalid value for ->ucs", value);
765 ret = get_char_id_table (c, Vcharacter_variant_table);
766 if (NILP (Fmemq (character, ret)))
768 put_char_id_table (c, Fcons (character, ret),
769 Vcharacter_variant_table);
772 return put_char_attribute (character, attribute, value);
775 DEFUN ("remove-char-attribute", Fremove_char_attribute, 2, 2, 0, /*
776 Remove CHARACTER's ATTRIBUTE.
778 (character, attribute))
782 CHECK_CHAR (character);
783 ccs = Ffind_charset (attribute);
786 return remove_char_ccs (character, ccs);
788 return remove_char_attribute (character, attribute);
791 INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs);
793 CHARSET_BYTE_SIZE (Lisp_Charset* cs)
795 /* ad-hoc method for `ascii' */
796 if ((CHARSET_CHARS (cs) == 94) &&
797 (CHARSET_BYTE_OFFSET (cs) != 33))
798 return 128 - CHARSET_BYTE_OFFSET (cs);
800 return CHARSET_CHARS (cs);
803 #define XCHARSET_BYTE_SIZE(ccs) CHARSET_BYTE_SIZE (XCHARSET (ccs))
805 int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len);
807 decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
811 if (XVECTOR_LENGTH (v) > ccs_len)
814 for (i = 0; i < XVECTOR_LENGTH (v); i++)
816 Lisp_Object c = XVECTOR_DATA(v)[i];
818 if (!NILP (c) && !CHARP (c))
822 int ret = decoding_table_check_elements (c, dim - 1, ccs_len);
834 decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset,
837 decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset,
847 i = ((code_point >> (8 * dim)) & 255) - byte_offset;
848 nv = XVECTOR_DATA(v)[i];
854 XVECTOR_DATA(v)[i] = Qnil;
858 decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
859 int code_point, Lisp_Object character);
861 decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
862 int code_point, Lisp_Object character)
866 int ccs_len = XVECTOR_LENGTH (v);
871 i = ((code_point >> (8 * dim)) & 255) - byte_offset;
872 nv = XVECTOR_DATA(v)[i];
876 nv = (XVECTOR_DATA(v)[i] = make_older_vector (ccs_len, Qnil));
882 XVECTOR_DATA(v)[i] = character;
886 put_char_ccs_code_point (Lisp_Object character,
887 Lisp_Object ccs, Lisp_Object value)
889 Lisp_Object encoding_table;
891 if (!EQ (XCHARSET_NAME (ccs), Qucs)
892 || (XCHAR (character) != XINT (value)))
894 Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
895 int dim = XCHARSET_DIMENSION (ccs);
896 int ccs_len = XCHARSET_BYTE_SIZE (ccs);
897 int byte_offset = XCHARSET_BYTE_OFFSET (ccs);
901 { /* obsolete representation: value must be a list of bytes */
902 Lisp_Object ret = Fcar (value);
906 signal_simple_error ("Invalid value for coded-charset", value);
907 code_point = XINT (ret);
908 if (XCHARSET_GRAPHIC (ccs) == 1)
916 signal_simple_error ("Invalid value for coded-charset",
920 signal_simple_error ("Invalid value for coded-charset",
923 if (XCHARSET_GRAPHIC (ccs) == 1)
925 code_point = (code_point << 8) | j;
928 value = make_int (code_point);
930 else if (INTP (value))
932 code_point = XINT (value);
933 if (XCHARSET_GRAPHIC (ccs) == 1)
935 code_point &= 0x7F7F7F7F;
936 value = make_int (code_point);
940 signal_simple_error ("Invalid value for coded-charset", value);
944 Lisp_Object cpos = Fget_char_attribute (character, ccs);
947 decoding_table_remove_char (v, dim, byte_offset, XINT (cpos));
952 XCHARSET_DECODING_TABLE (ccs)
953 = v = make_older_vector (ccs_len, Qnil);
956 decoding_table_put_char (v, dim, byte_offset, code_point, character);
958 if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs)))
960 XCHARSET_ENCODING_TABLE (ccs)
961 = encoding_table = make_char_id_table (Qnil, -1);
963 put_char_id_table (XCHAR (character), value, encoding_table);
968 remove_char_ccs (Lisp_Object character, Lisp_Object ccs)
970 Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
971 Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
973 if (VECTORP (decoding_table))
975 Lisp_Object cpos = Fget_char_attribute (character, ccs);
979 decoding_table_remove_char (decoding_table,
980 XCHARSET_DIMENSION (ccs),
981 XCHARSET_BYTE_OFFSET (ccs),
985 if (CHAR_ID_TABLE_P (encoding_table))
987 put_char_id_table (XCHAR (character), Qnil, encoding_table);
993 put_char_attribute (Lisp_Object character, Lisp_Object attribute,
996 Emchar char_id = XCHAR (character);
997 Lisp_Object ret = get_char_id_table (char_id, Vcharacter_attribute_table);
1000 cell = Fassq (attribute, ret);
1004 ret = Fcons (Fcons (attribute, value), ret);
1006 else if (!EQ (Fcdr (cell), value))
1008 Fsetcdr (cell, value);
1010 put_char_id_table (char_id, ret, Vcharacter_attribute_table);
1015 remove_char_attribute (Lisp_Object character, Lisp_Object attribute)
1017 Emchar char_id = XCHAR (character);
1018 Lisp_Object alist = get_char_id_table (char_id, Vcharacter_attribute_table);
1020 if (EQ (attribute, Fcar (Fcar (alist))))
1022 alist = Fcdr (alist);
1026 Lisp_Object pr = alist;
1027 Lisp_Object r = Fcdr (alist);
1031 if (EQ (attribute, Fcar (Fcar (r))))
1033 XCDR (pr) = Fcdr (r);
1040 put_char_id_table (char_id, alist, Vcharacter_attribute_table);
1044 EXFUN (Fmake_char, 3);
1045 EXFUN (Fdecode_char, 2);
1047 DEFUN ("define-char", Fdefine_char, 1, 1, 0, /*
1048 Store character's ATTRIBUTES.
1052 Lisp_Object rest = attributes;
1053 Lisp_Object code = Fcdr (Fassq (Qucs, attributes));
1054 Lisp_Object character;
1058 while (CONSP (rest))
1060 Lisp_Object cell = Fcar (rest);
1064 signal_simple_error ("Invalid argument", attributes);
1065 if (!NILP (ccs = Ffind_charset (Fcar (cell)))
1066 && ((XCHARSET_FINAL (ccs) != 0) ||
1067 (XCHARSET_UCS_MAX (ccs) > 0)) )
1071 character = Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell)));
1073 character = Fdecode_char (ccs, cell);
1074 goto setup_attributes;
1078 if (!NILP (code = Fcdr (Fassq (Q_ucs, attributes))))
1081 signal_simple_error ("Invalid argument", attributes);
1083 character = make_char (XINT (code) + 0x100000);
1084 goto setup_attributes;
1088 else if (!INTP (code))
1089 signal_simple_error ("Invalid argument", attributes);
1091 character = make_char (XINT (code));
1095 while (CONSP (rest))
1097 Lisp_Object cell = Fcar (rest);
1100 signal_simple_error ("Invalid argument", attributes);
1101 Fput_char_attribute (character, Fcar (cell), Fcdr (cell));
1105 get_char_id_table (XCHAR (character), Vcharacter_attribute_table);
1108 Lisp_Object Vutf_2000_version;
1112 int leading_code_private_11;
1115 Lisp_Object Qcharsetp;
1117 /* Qdoc_string, Qdimension, Qchars defined in general.c */
1118 Lisp_Object Qregistry, Qfinal, Qgraphic;
1119 Lisp_Object Qdirection;
1120 Lisp_Object Qreverse_direction_charset;
1121 Lisp_Object Qleading_byte;
1122 Lisp_Object Qshort_name, Qlong_name;
1136 Qcyrillic_iso8859_5,
1138 Qjapanese_jisx0208_1978,
1141 Qjapanese_jisx0208_1990,
1144 Qchinese_cns11643_1,
1145 Qchinese_cns11643_2,
1150 Qlatin_viscii_lower,
1151 Qlatin_viscii_upper,
1152 Qvietnamese_viscii_lower,
1153 Qvietnamese_viscii_upper,
1154 Qideograph_daikanwa,
1183 Lisp_Object Ql2r, Qr2l;
1185 Lisp_Object Vcharset_hash_table;
1187 /* Composite characters are characters constructed by overstriking two
1188 or more regular characters.
1190 1) The old Mule implementation involves storing composite characters
1191 in a buffer as a tag followed by all of the actual characters
1192 used to make up the composite character. I think this is a bad
1193 idea; it greatly complicates code that wants to handle strings
1194 one character at a time because it has to deal with the possibility
1195 of great big ungainly characters. It's much more reasonable to
1196 simply store an index into a table of composite characters.
1198 2) The current implementation only allows for 16,384 separate
1199 composite characters over the lifetime of the XEmacs process.
1200 This could become a potential problem if the user
1201 edited lots of different files that use composite characters.
1202 Due to FSF bogosity, increasing the number of allowable
1203 composite characters under Mule would decrease the number
1204 of possible faces that can exist. Mule already has shrunk
1205 this to 2048, and further shrinkage would become uncomfortable.
1206 No such problems exist in XEmacs.
1208 Composite characters could be represented as 0x80 C1 C2 C3,
1209 where each C[1-3] is in the range 0xA0 - 0xFF. This allows
1210 for slightly under 2^20 (one million) composite characters
1211 over the XEmacs process lifetime, and you only need to
1212 increase the size of a Mule character from 19 to 21 bits.
1213 Or you could use 0x80 C1 C2 C3 C4, allowing for about
1214 85 million (slightly over 2^26) composite characters. */
1217 /************************************************************************/
1218 /* Basic Emchar functions */
1219 /************************************************************************/
1221 /* Convert a non-ASCII Mule character C into a one-character Mule-encoded
1222 string in STR. Returns the number of bytes stored.
1223 Do not call this directly. Use the macro set_charptr_emchar() instead.
1227 non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
1233 Lisp_Object charset;
1242 else if ( c <= 0x7ff )
1244 *p++ = (c >> 6) | 0xc0;
1245 *p++ = (c & 0x3f) | 0x80;
1247 else if ( c <= 0xffff )
1249 *p++ = (c >> 12) | 0xe0;
1250 *p++ = ((c >> 6) & 0x3f) | 0x80;
1251 *p++ = (c & 0x3f) | 0x80;
1253 else if ( c <= 0x1fffff )
1255 *p++ = (c >> 18) | 0xf0;
1256 *p++ = ((c >> 12) & 0x3f) | 0x80;
1257 *p++ = ((c >> 6) & 0x3f) | 0x80;
1258 *p++ = (c & 0x3f) | 0x80;
1260 else if ( c <= 0x3ffffff )
1262 *p++ = (c >> 24) | 0xf8;
1263 *p++ = ((c >> 18) & 0x3f) | 0x80;
1264 *p++ = ((c >> 12) & 0x3f) | 0x80;
1265 *p++ = ((c >> 6) & 0x3f) | 0x80;
1266 *p++ = (c & 0x3f) | 0x80;
1270 *p++ = (c >> 30) | 0xfc;
1271 *p++ = ((c >> 24) & 0x3f) | 0x80;
1272 *p++ = ((c >> 18) & 0x3f) | 0x80;
1273 *p++ = ((c >> 12) & 0x3f) | 0x80;
1274 *p++ = ((c >> 6) & 0x3f) | 0x80;
1275 *p++ = (c & 0x3f) | 0x80;
1278 BREAKUP_CHAR (c, charset, c1, c2);
1279 lb = CHAR_LEADING_BYTE (c);
1280 if (LEADING_BYTE_PRIVATE_P (lb))
1281 *p++ = PRIVATE_LEADING_BYTE_PREFIX (lb);
1283 if (EQ (charset, Vcharset_control_1))
1292 /* Return the first character from a Mule-encoded string in STR,
1293 assuming it's non-ASCII. Do not call this directly.
1294 Use the macro charptr_emchar() instead. */
1297 non_ascii_charptr_emchar (const Bufbyte *str)
1310 else if ( b >= 0xf8 )
1315 else if ( b >= 0xf0 )
1320 else if ( b >= 0xe0 )
1325 else if ( b >= 0xc0 )
1335 for( ; len > 0; len-- )
1338 ch = ( ch << 6 ) | ( b & 0x3f );
1342 Bufbyte i0 = *str, i1, i2 = 0;
1343 Lisp_Object charset;
1345 if (i0 == LEADING_BYTE_CONTROL_1)
1346 return (Emchar) (*++str - 0x20);
1348 if (LEADING_BYTE_PREFIX_P (i0))
1353 charset = CHARSET_BY_LEADING_BYTE (i0);
1354 if (XCHARSET_DIMENSION (charset) == 2)
1357 return MAKE_CHAR (charset, i1, i2);
1361 /* Return whether CH is a valid Emchar, assuming it's non-ASCII.
1362 Do not call this directly. Use the macro valid_char_p() instead. */
1366 non_ascii_valid_char_p (Emchar ch)
1370 /* Must have only lowest 19 bits set */
1374 f1 = CHAR_FIELD1 (ch);
1375 f2 = CHAR_FIELD2 (ch);
1376 f3 = CHAR_FIELD3 (ch);
1380 Lisp_Object charset;
1382 if (f2 < MIN_CHAR_FIELD2_OFFICIAL ||
1383 (f2 > MAX_CHAR_FIELD2_OFFICIAL && f2 < MIN_CHAR_FIELD2_PRIVATE) ||
1384 f2 > MAX_CHAR_FIELD2_PRIVATE)
1389 if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE &&
1390 f2 <= MAX_CHAR_FIELD2_PRIVATE))
1394 NOTE: This takes advantage of the fact that
1395 FIELD2_TO_OFFICIAL_LEADING_BYTE and
1396 FIELD2_TO_PRIVATE_LEADING_BYTE are the same.
1398 charset = CHARSET_BY_LEADING_BYTE (f2 + FIELD2_TO_OFFICIAL_LEADING_BYTE);
1399 if (EQ (charset, Qnil))
1401 return (XCHARSET_CHARS (charset) == 96);
1405 Lisp_Object charset;
1407 if (f1 < MIN_CHAR_FIELD1_OFFICIAL ||
1408 (f1 > MAX_CHAR_FIELD1_OFFICIAL && f1 < MIN_CHAR_FIELD1_PRIVATE) ||
1409 f1 > MAX_CHAR_FIELD1_PRIVATE)
1411 if (f2 < 0x20 || f3 < 0x20)
1414 #ifdef ENABLE_COMPOSITE_CHARS
1415 if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE)
1417 if (UNBOUNDP (Fgethash (make_int (ch),
1418 Vcomposite_char_char2string_hash_table,
1423 #endif /* ENABLE_COMPOSITE_CHARS */
1425 if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F
1426 && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE))
1429 if (f1 <= MAX_CHAR_FIELD1_OFFICIAL)
1431 CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE);
1434 CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_PRIVATE_LEADING_BYTE);
1436 if (EQ (charset, Qnil))
1438 return (XCHARSET_CHARS (charset) == 96);
1444 /************************************************************************/
1445 /* Basic string functions */
1446 /************************************************************************/
1448 /* Copy the character pointed to by PTR into STR, assuming it's
1449 non-ASCII. Do not call this directly. Use the macro
1450 charptr_copy_char() instead. */
1453 non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str)
1455 Bufbyte *strptr = str;
1457 switch (REP_BYTES_BY_FIRST_BYTE (*strptr))
1459 /* Notice fallthrough. */
1461 case 6: *++strptr = *ptr++;
1462 case 5: *++strptr = *ptr++;
1464 case 4: *++strptr = *ptr++;
1465 case 3: *++strptr = *ptr++;
1466 case 2: *++strptr = *ptr;
1471 return strptr + 1 - str;
1475 /************************************************************************/
1476 /* streams of Emchars */
1477 /************************************************************************/
1479 /* Treat a stream as a stream of Emchar's rather than a stream of bytes.
1480 The functions below are not meant to be called directly; use
1481 the macros in insdel.h. */
1484 Lstream_get_emchar_1 (Lstream *stream, int ch)
1486 Bufbyte str[MAX_EMCHAR_LEN];
1487 Bufbyte *strptr = str;
1489 str[0] = (Bufbyte) ch;
1490 switch (REP_BYTES_BY_FIRST_BYTE (ch))
1492 /* Notice fallthrough. */
1495 ch = Lstream_getc (stream);
1497 *++strptr = (Bufbyte) ch;
1499 ch = Lstream_getc (stream);
1501 *++strptr = (Bufbyte) ch;
1504 ch = Lstream_getc (stream);
1506 *++strptr = (Bufbyte) ch;
1508 ch = Lstream_getc (stream);
1510 *++strptr = (Bufbyte) ch;
1512 ch = Lstream_getc (stream);
1514 *++strptr = (Bufbyte) ch;
1519 return charptr_emchar (str);
1523 Lstream_fput_emchar (Lstream *stream, Emchar ch)
1525 Bufbyte str[MAX_EMCHAR_LEN];
1526 Bytecount len = set_charptr_emchar (str, ch);
1527 return Lstream_write (stream, str, len);
1531 Lstream_funget_emchar (Lstream *stream, Emchar ch)
1533 Bufbyte str[MAX_EMCHAR_LEN];
1534 Bytecount len = set_charptr_emchar (str, ch);
1535 Lstream_unread (stream, str, len);
1539 /************************************************************************/
1540 /* charset object */
1541 /************************************************************************/
1544 mark_charset (Lisp_Object obj)
1546 Lisp_Charset *cs = XCHARSET (obj);
1548 mark_object (cs->short_name);
1549 mark_object (cs->long_name);
1550 mark_object (cs->doc_string);
1551 mark_object (cs->registry);
1552 mark_object (cs->ccl_program);
1554 /* mark_object (cs->encoding_table); */
1555 /* mark_object (cs->decoding_table); */
1561 print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1563 Lisp_Charset *cs = XCHARSET (obj);
1567 error ("printing unreadable object #<charset %s 0x%x>",
1568 string_data (XSYMBOL (CHARSET_NAME (cs))->name),
1571 write_c_string ("#<charset ", printcharfun);
1572 print_internal (CHARSET_NAME (cs), printcharfun, 0);
1573 write_c_string (" ", printcharfun);
1574 print_internal (CHARSET_SHORT_NAME (cs), printcharfun, 1);
1575 write_c_string (" ", printcharfun);
1576 print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1);
1577 write_c_string (" ", printcharfun);
1578 print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1);
1579 sprintf (buf, " %d^%d %s cols=%d g%d final='%c' reg=",
1581 CHARSET_DIMENSION (cs),
1582 CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : "r2l",
1583 CHARSET_COLUMNS (cs),
1584 CHARSET_GRAPHIC (cs),
1585 CHARSET_FINAL (cs));
1586 write_c_string (buf, printcharfun);
1587 print_internal (CHARSET_REGISTRY (cs), printcharfun, 0);
1588 sprintf (buf, " 0x%x>", cs->header.uid);
1589 write_c_string (buf, printcharfun);
1592 static const struct lrecord_description charset_description[] = {
1593 { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) },
1594 { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) },
1595 { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) },
1596 { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) },
1597 { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) },
1598 { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) },
1599 { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
1601 { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) },
1602 { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) },
1607 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
1608 mark_charset, print_charset, 0, 0, 0,
1609 charset_description,
1611 /* Make a new charset. */
1614 make_charset (Charset_ID id, Lisp_Object name,
1615 unsigned short chars, unsigned char dimension,
1616 unsigned char columns, unsigned char graphic,
1617 Bufbyte final, unsigned char direction, Lisp_Object short_name,
1618 Lisp_Object long_name, Lisp_Object doc,
1620 Lisp_Object decoding_table,
1621 Emchar ucs_min, Emchar ucs_max,
1622 Emchar code_offset, unsigned char byte_offset)
1624 unsigned char type = 0;
1626 Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
1630 XSETCHARSET (obj, cs);
1632 CHARSET_ID (cs) = id;
1633 CHARSET_NAME (cs) = name;
1634 CHARSET_SHORT_NAME (cs) = short_name;
1635 CHARSET_LONG_NAME (cs) = long_name;
1636 CHARSET_CHARS (cs) = chars;
1637 CHARSET_DIMENSION (cs) = dimension;
1638 CHARSET_DIRECTION (cs) = direction;
1639 CHARSET_COLUMNS (cs) = columns;
1640 CHARSET_GRAPHIC (cs) = graphic;
1641 CHARSET_FINAL (cs) = final;
1642 CHARSET_DOC_STRING (cs) = doc;
1643 CHARSET_REGISTRY (cs) = reg;
1644 CHARSET_CCL_PROGRAM (cs) = Qnil;
1645 CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
1647 CHARSET_DECODING_TABLE(cs) = Qnil;
1648 CHARSET_ENCODING_TABLE(cs) = Qnil;
1649 CHARSET_UCS_MIN(cs) = ucs_min;
1650 CHARSET_UCS_MAX(cs) = ucs_max;
1651 CHARSET_CODE_OFFSET(cs) = code_offset;
1652 CHARSET_BYTE_OFFSET(cs) = byte_offset;
1655 switch (CHARSET_CHARS (cs))
1658 switch (CHARSET_DIMENSION (cs))
1661 type = CHARSET_TYPE_94;
1664 type = CHARSET_TYPE_94X94;
1669 switch (CHARSET_DIMENSION (cs))
1672 type = CHARSET_TYPE_96;
1675 type = CHARSET_TYPE_96X96;
1681 switch (CHARSET_DIMENSION (cs))
1684 type = CHARSET_TYPE_128;
1687 type = CHARSET_TYPE_128X128;
1692 switch (CHARSET_DIMENSION (cs))
1695 type = CHARSET_TYPE_256;
1698 type = CHARSET_TYPE_256X256;
1705 CHARSET_TYPE (cs) = type;
1709 if (id == LEADING_BYTE_ASCII)
1710 CHARSET_REP_BYTES (cs) = 1;
1712 CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 1;
1714 CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 2;
1719 /* some charsets do not have final characters. This includes
1720 ASCII, Control-1, Composite, and the two faux private
1723 if (code_offset == 0)
1725 assert (NILP (chlook->charset_by_attributes[type][final]));
1726 chlook->charset_by_attributes[type][final] = obj;
1729 assert (NILP (chlook->charset_by_attributes[type][final][direction]));
1730 chlook->charset_by_attributes[type][final][direction] = obj;
1734 assert (NILP (chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE]));
1735 chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj;
1737 /* Some charsets are "faux" and don't have names or really exist at
1738 all except in the leading-byte table. */
1740 Fputhash (name, obj, Vcharset_hash_table);
1745 get_unallocated_leading_byte (int dimension)
1750 if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
1753 lb = chlook->next_allocated_leading_byte++;
1757 if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
1760 lb = chlook->next_allocated_1_byte_leading_byte++;
1764 if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2)
1767 lb = chlook->next_allocated_2_byte_leading_byte++;
1773 ("No more character sets free for this dimension",
1774 make_int (dimension));
1781 make_builtin_char (Lisp_Object charset, int c1, int c2)
1783 if (XCHARSET_UCS_MAX (charset))
1786 = (XCHARSET_DIMENSION (charset) == 1
1788 c1 - XCHARSET_BYTE_OFFSET (charset)
1790 (c1 - XCHARSET_BYTE_OFFSET (charset)) * XCHARSET_CHARS (charset)
1791 + c2 - XCHARSET_BYTE_OFFSET (charset))
1792 - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset);
1793 if ((code < XCHARSET_UCS_MIN (charset))
1794 || (XCHARSET_UCS_MAX (charset) < code))
1795 signal_simple_error ("Arguments makes invalid character",
1799 else if (XCHARSET_DIMENSION (charset) == 1)
1801 switch (XCHARSET_CHARS (charset))
1805 + (XCHARSET_FINAL (charset) - '0') * 94 + (c1 - 33);
1808 + (XCHARSET_FINAL (charset) - '0') * 96 + (c1 - 32);
1815 switch (XCHARSET_CHARS (charset))
1818 return MIN_CHAR_94x94
1819 + (XCHARSET_FINAL (charset) - '0') * 94 * 94
1820 + (c1 - 33) * 94 + (c2 - 33);
1822 return MIN_CHAR_96x96
1823 + (XCHARSET_FINAL (charset) - '0') * 96 * 96
1824 + (c1 - 32) * 96 + (c2 - 32);
1832 range_charset_code_point (Lisp_Object charset, Emchar ch)
1836 if ((XCHARSET_UCS_MIN (charset) <= ch)
1837 && (ch <= XCHARSET_UCS_MAX (charset)))
1839 d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset);
1841 if (XCHARSET_CHARS (charset) == 256)
1843 else if (XCHARSET_DIMENSION (charset) == 1)
1844 return d + XCHARSET_BYTE_OFFSET (charset);
1845 else if (XCHARSET_DIMENSION (charset) == 2)
1847 ((d / XCHARSET_CHARS (charset)
1848 + XCHARSET_BYTE_OFFSET (charset)) << 8)
1849 | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
1850 else if (XCHARSET_DIMENSION (charset) == 3)
1852 ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
1853 + XCHARSET_BYTE_OFFSET (charset)) << 16)
1854 | ((d / XCHARSET_CHARS (charset)
1855 % XCHARSET_CHARS (charset)
1856 + XCHARSET_BYTE_OFFSET (charset)) << 8)
1857 | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
1858 else /* if (XCHARSET_DIMENSION (charset) == 4) */
1860 ((d / (XCHARSET_CHARS (charset)
1861 * XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
1862 + XCHARSET_BYTE_OFFSET (charset)) << 24)
1863 | ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
1864 % XCHARSET_CHARS (charset)
1865 + XCHARSET_BYTE_OFFSET (charset)) << 16)
1866 | ((d / XCHARSET_CHARS (charset) % XCHARSET_CHARS (charset)
1867 + XCHARSET_BYTE_OFFSET (charset)) << 8)
1868 | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
1870 else if (XCHARSET_CODE_OFFSET (charset) == 0)
1872 if (XCHARSET_DIMENSION (charset) == 1)
1874 if (XCHARSET_CHARS (charset) == 94)
1876 if (((d = ch - (MIN_CHAR_94
1877 + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0)
1881 else if (XCHARSET_CHARS (charset) == 96)
1883 if (((d = ch - (MIN_CHAR_96
1884 + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0)
1891 else if (XCHARSET_DIMENSION (charset) == 2)
1893 if (XCHARSET_CHARS (charset) == 94)
1895 if (((d = ch - (MIN_CHAR_94x94
1896 + (XCHARSET_FINAL (charset) - '0') * 94 * 94))
1899 return (((d / 94) + 33) << 8) | (d % 94 + 33);
1901 else if (XCHARSET_CHARS (charset) == 96)
1903 if (((d = ch - (MIN_CHAR_96x96
1904 + (XCHARSET_FINAL (charset) - '0') * 96 * 96))
1907 return (((d / 96) + 32) << 8) | (d % 96 + 32);
1917 encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
1919 if (c <= MAX_CHAR_BASIC_LATIN)
1921 *charset = Vcharset_ascii;
1926 *charset = Vcharset_control_1;
1931 *charset = Vcharset_latin_iso8859_1;
1935 else if ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK))
1937 *charset = Vcharset_greek_iso8859_7;
1938 return c - MIN_CHAR_GREEK + 0x20;
1940 else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC))
1942 *charset = Vcharset_cyrillic_iso8859_5;
1943 return c - MIN_CHAR_CYRILLIC + 0x20;
1946 else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW))
1948 *charset = Vcharset_hebrew_iso8859_8;
1949 return c - MIN_CHAR_HEBREW + 0x20;
1951 else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI))
1953 *charset = Vcharset_thai_tis620;
1954 return c - MIN_CHAR_THAI + 0x20;
1957 else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c)
1958 && (c <= MAX_CHAR_HALFWIDTH_KATAKANA))
1960 return list2 (Vcharset_katakana_jisx0201,
1961 make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33));
1964 else if (c <= MAX_CHAR_BMP)
1966 *charset = Vcharset_ucs_bmp;
1969 else if (c < MIN_CHAR_DAIKANWA)
1971 *charset = Vcharset_ucs;
1975 else if (c <= MAX_CHAR_DAIKANWA)
1977 *charset = Vcharset_ideograph_daikanwa;
1978 return c - MIN_CHAR_DAIKANWA;
1981 else if (c <= MAX_CHAR_MOJIKYO)
1983 *charset = Vcharset_mojikyo;
1984 return c - MIN_CHAR_MOJIKYO;
1986 else if (c < MIN_CHAR_94)
1988 *charset = Vcharset_ucs;
1991 else if (c <= MAX_CHAR_94)
1993 *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94,
1994 ((c - MIN_CHAR_94) / 94) + '0',
1995 CHARSET_LEFT_TO_RIGHT);
1996 if (!NILP (*charset))
1997 return ((c - MIN_CHAR_94) % 94) + 33;
2000 *charset = Vcharset_ucs;
2004 else if (c <= MAX_CHAR_96)
2006 *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96,
2007 ((c - MIN_CHAR_96) / 96) + '0',
2008 CHARSET_LEFT_TO_RIGHT);
2009 if (!NILP (*charset))
2010 return ((c - MIN_CHAR_96) % 96) + 32;
2013 *charset = Vcharset_ucs;
2017 else if (c <= MAX_CHAR_94x94)
2020 = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94,
2021 ((c - MIN_CHAR_94x94) / (94 * 94)) + '0',
2022 CHARSET_LEFT_TO_RIGHT);
2023 if (!NILP (*charset))
2024 return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8)
2025 | (((c - MIN_CHAR_94x94) % 94) + 33);
2028 *charset = Vcharset_ucs;
2032 else if (c <= MAX_CHAR_96x96)
2035 = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96X96,
2036 ((c - MIN_CHAR_96x96) / (96 * 96)) + '0',
2037 CHARSET_LEFT_TO_RIGHT);
2038 if (!NILP (*charset))
2039 return ((((c - MIN_CHAR_96x96) / 96) % 96) + 32) << 8
2040 | (((c - MIN_CHAR_96x96) % 96) + 32);
2043 *charset = Vcharset_ucs;
2049 *charset = Vcharset_ucs;
2054 Lisp_Object Vdefault_coded_charset_priority_list;
2058 /************************************************************************/
2059 /* Basic charset Lisp functions */
2060 /************************************************************************/
2062 DEFUN ("charsetp", Fcharsetp, 1, 1, 0, /*
2063 Return non-nil if OBJECT is a charset.
2067 return CHARSETP (object) ? Qt : Qnil;
2070 DEFUN ("find-charset", Ffind_charset, 1, 1, 0, /*
2071 Retrieve the charset of the given name.
2072 If CHARSET-OR-NAME is a charset object, it is simply returned.
2073 Otherwise, CHARSET-OR-NAME should be a symbol. If there is no such charset,
2074 nil is returned. Otherwise the associated charset object is returned.
2078 if (CHARSETP (charset_or_name))
2079 return charset_or_name;
2081 CHECK_SYMBOL (charset_or_name);
2082 return Fgethash (charset_or_name, Vcharset_hash_table, Qnil);
2085 DEFUN ("get-charset", Fget_charset, 1, 1, 0, /*
2086 Retrieve the charset of the given name.
2087 Same as `find-charset' except an error is signalled if there is no such
2088 charset instead of returning nil.
2092 Lisp_Object charset = Ffind_charset (name);
2095 signal_simple_error ("No such charset", name);
2099 /* We store the charsets in hash tables with the names as the key and the
2100 actual charset object as the value. Occasionally we need to use them
2101 in a list format. These routines provide us with that. */
2102 struct charset_list_closure
2104 Lisp_Object *charset_list;
2108 add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value,
2109 void *charset_list_closure)
2111 /* This function can GC */
2112 struct charset_list_closure *chcl =
2113 (struct charset_list_closure*) charset_list_closure;
2114 Lisp_Object *charset_list = chcl->charset_list;
2116 *charset_list = Fcons (XCHARSET_NAME (value), *charset_list);
2120 DEFUN ("charset-list", Fcharset_list, 0, 0, 0, /*
2121 Return a list of the names of all defined charsets.
2125 Lisp_Object charset_list = Qnil;
2126 struct gcpro gcpro1;
2127 struct charset_list_closure charset_list_closure;
2129 GCPRO1 (charset_list);
2130 charset_list_closure.charset_list = &charset_list;
2131 elisp_maphash (add_charset_to_list_mapper, Vcharset_hash_table,
2132 &charset_list_closure);
2135 return charset_list;
2138 DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /*
2139 Return the name of the given charset.
2143 return XCHARSET_NAME (Fget_charset (charset));
2146 DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /*
2147 Define a new character set.
2148 This function is for use with Mule support.
2149 NAME is a symbol, the name by which the character set is normally referred.
2150 DOC-STRING is a string describing the character set.
2151 PROPS is a property list, describing the specific nature of the
2152 character set. Recognized properties are:
2154 'short-name Short version of the charset name (ex: Latin-1)
2155 'long-name Long version of the charset name (ex: ISO8859-1 (Latin-1))
2156 'registry A regular expression matching the font registry field for
2158 'dimension Number of octets used to index a character in this charset.
2159 Either 1 or 2. Defaults to 1.
2160 'columns Number of columns used to display a character in this charset.
2161 Only used in TTY mode. (Under X, the actual width of a
2162 character can be derived from the font used to display the
2163 characters.) If unspecified, defaults to the dimension
2164 (this is almost always the correct value).
2165 'chars Number of characters in each dimension (94 or 96).
2166 Defaults to 94. Note that if the dimension is 2, the
2167 character set thus described is 94x94 or 96x96.
2168 'final Final byte of ISO 2022 escape sequence. Must be
2169 supplied. Each combination of (DIMENSION, CHARS) defines a
2170 separate namespace for final bytes. Note that ISO
2171 2022 restricts the final byte to the range
2172 0x30 - 0x7E if dimension == 1, and 0x30 - 0x5F if
2173 dimension == 2. Note also that final bytes in the range
2174 0x30 - 0x3F are reserved for user-defined (not official)
2176 'graphic 0 (use left half of font on output) or 1 (use right half
2177 of font on output). Defaults to 0. For example, for
2178 a font whose registry is ISO8859-1, the left half
2179 (octets 0x20 - 0x7F) is the `ascii' character set, while
2180 the right half (octets 0xA0 - 0xFF) is the `latin-1'
2181 character set. With 'graphic set to 0, the octets
2182 will have their high bit cleared; with it set to 1,
2183 the octets will have their high bit set.
2184 'direction 'l2r (left-to-right) or 'r2l (right-to-left).
2186 'ccl-program A compiled CCL program used to convert a character in
2187 this charset into an index into the font. This is in
2188 addition to the 'graphic property. The CCL program
2189 is passed the octets of the character, with the high
2190 bit cleared and set depending upon whether the value
2191 of the 'graphic property is 0 or 1.
2193 (name, doc_string, props))
2195 int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
2196 int direction = CHARSET_LEFT_TO_RIGHT;
2198 Lisp_Object registry = Qnil;
2199 Lisp_Object charset;
2200 Lisp_Object rest, keyword, value;
2201 Lisp_Object ccl_program = Qnil;
2202 Lisp_Object short_name = Qnil, long_name = Qnil;
2203 int byte_offset = -1;
2205 CHECK_SYMBOL (name);
2206 if (!NILP (doc_string))
2207 CHECK_STRING (doc_string);
2209 charset = Ffind_charset (name);
2210 if (!NILP (charset))
2211 signal_simple_error ("Cannot redefine existing charset", name);
2213 EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props)
2215 if (EQ (keyword, Qshort_name))
2217 CHECK_STRING (value);
2221 if (EQ (keyword, Qlong_name))
2223 CHECK_STRING (value);
2227 else if (EQ (keyword, Qdimension))
2230 dimension = XINT (value);
2231 if (dimension < 1 || dimension > 2)
2232 signal_simple_error ("Invalid value for 'dimension", value);
2235 else if (EQ (keyword, Qchars))
2238 chars = XINT (value);
2239 if (chars != 94 && chars != 96)
2240 signal_simple_error ("Invalid value for 'chars", value);
2243 else if (EQ (keyword, Qcolumns))
2246 columns = XINT (value);
2247 if (columns != 1 && columns != 2)
2248 signal_simple_error ("Invalid value for 'columns", value);
2251 else if (EQ (keyword, Qgraphic))
2254 graphic = XINT (value);
2256 if (graphic < 0 || graphic > 2)
2258 if (graphic < 0 || graphic > 1)
2260 signal_simple_error ("Invalid value for 'graphic", value);
2263 else if (EQ (keyword, Qregistry))
2265 CHECK_STRING (value);
2269 else if (EQ (keyword, Qdirection))
2271 if (EQ (value, Ql2r))
2272 direction = CHARSET_LEFT_TO_RIGHT;
2273 else if (EQ (value, Qr2l))
2274 direction = CHARSET_RIGHT_TO_LEFT;
2276 signal_simple_error ("Invalid value for 'direction", value);
2279 else if (EQ (keyword, Qfinal))
2281 CHECK_CHAR_COERCE_INT (value);
2282 final = XCHAR (value);
2283 if (final < '0' || final > '~')
2284 signal_simple_error ("Invalid value for 'final", value);
2287 else if (EQ (keyword, Qccl_program))
2289 CHECK_VECTOR (value);
2290 ccl_program = value;
2294 signal_simple_error ("Unrecognized property", keyword);
2298 error ("'final must be specified");
2299 if (dimension == 2 && final > 0x5F)
2301 ("Final must be in the range 0x30 - 0x5F for dimension == 2",
2305 type = (chars == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96;
2307 type = (chars == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96;
2309 if (!NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_LEFT_TO_RIGHT)) ||
2310 !NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_RIGHT_TO_LEFT)))
2312 ("Character set already defined for this DIMENSION/CHARS/FINAL combo");
2314 id = get_unallocated_leading_byte (dimension);
2316 if (NILP (doc_string))
2317 doc_string = build_string ("");
2319 if (NILP (registry))
2320 registry = build_string ("");
2322 if (NILP (short_name))
2323 XSETSTRING (short_name, XSYMBOL (name)->name);
2325 if (NILP (long_name))
2326 long_name = doc_string;
2329 columns = dimension;
2331 if (byte_offset < 0)
2335 else if (chars == 96)
2341 charset = make_charset (id, name, chars, dimension, columns, graphic,
2342 final, direction, short_name, long_name,
2343 doc_string, registry,
2344 Qnil, 0, 0, 0, byte_offset);
2345 if (!NILP (ccl_program))
2346 XCHARSET_CCL_PROGRAM (charset) = ccl_program;
2350 DEFUN ("make-reverse-direction-charset", Fmake_reverse_direction_charset,
2352 Make a charset equivalent to CHARSET but which goes in the opposite direction.
2353 NEW-NAME is the name of the new charset. Return the new charset.
2355 (charset, new_name))
2357 Lisp_Object new_charset = Qnil;
2358 int id, chars, dimension, columns, graphic, final;
2360 Lisp_Object registry, doc_string, short_name, long_name;
2363 charset = Fget_charset (charset);
2364 if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset)))
2365 signal_simple_error ("Charset already has reverse-direction charset",
2368 CHECK_SYMBOL (new_name);
2369 if (!NILP (Ffind_charset (new_name)))
2370 signal_simple_error ("Cannot redefine existing charset", new_name);
2372 cs = XCHARSET (charset);
2374 chars = CHARSET_CHARS (cs);
2375 dimension = CHARSET_DIMENSION (cs);
2376 columns = CHARSET_COLUMNS (cs);
2377 id = get_unallocated_leading_byte (dimension);
2379 graphic = CHARSET_GRAPHIC (cs);
2380 final = CHARSET_FINAL (cs);
2381 direction = CHARSET_RIGHT_TO_LEFT;
2382 if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT)
2383 direction = CHARSET_LEFT_TO_RIGHT;
2384 doc_string = CHARSET_DOC_STRING (cs);
2385 short_name = CHARSET_SHORT_NAME (cs);
2386 long_name = CHARSET_LONG_NAME (cs);
2387 registry = CHARSET_REGISTRY (cs);
2389 new_charset = make_charset (id, new_name, chars, dimension, columns,
2390 graphic, final, direction, short_name, long_name,
2391 doc_string, registry,
2393 CHARSET_DECODING_TABLE(cs),
2394 CHARSET_UCS_MIN(cs),
2395 CHARSET_UCS_MAX(cs),
2396 CHARSET_CODE_OFFSET(cs),
2397 CHARSET_BYTE_OFFSET(cs)
2403 CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset;
2404 XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset;
2409 DEFUN ("define-charset-alias", Fdefine_charset_alias, 2, 2, 0, /*
2410 Define symbol ALIAS as an alias for CHARSET.
2414 CHECK_SYMBOL (alias);
2415 charset = Fget_charset (charset);
2416 return Fputhash (alias, charset, Vcharset_hash_table);
2419 /* #### Reverse direction charsets not yet implemented. */
2421 DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset,
2423 Return the reverse-direction charset parallel to CHARSET, if any.
2424 This is the charset with the same properties (in particular, the same
2425 dimension, number of characters per dimension, and final byte) as
2426 CHARSET but whose characters are displayed in the opposite direction.
2430 charset = Fget_charset (charset);
2431 return XCHARSET_REVERSE_DIRECTION_CHARSET (charset);
2435 DEFUN ("charset-from-attributes", Fcharset_from_attributes, 3, 4, 0, /*
2436 Return a charset with the given DIMENSION, CHARS, FINAL, and DIRECTION.
2437 If DIRECTION is omitted, both directions will be checked (left-to-right
2438 will be returned if character sets exist for both directions).
2440 (dimension, chars, final, direction))
2442 int dm, ch, fi, di = -1;
2444 Lisp_Object obj = Qnil;
2446 CHECK_INT (dimension);
2447 dm = XINT (dimension);
2448 if (dm < 1 || dm > 2)
2449 signal_simple_error ("Invalid value for DIMENSION", dimension);
2453 if (ch != 94 && ch != 96)
2454 signal_simple_error ("Invalid value for CHARS", chars);
2456 CHECK_CHAR_COERCE_INT (final);
2458 if (fi < '0' || fi > '~')
2459 signal_simple_error ("Invalid value for FINAL", final);
2461 if (EQ (direction, Ql2r))
2462 di = CHARSET_LEFT_TO_RIGHT;
2463 else if (EQ (direction, Qr2l))
2464 di = CHARSET_RIGHT_TO_LEFT;
2465 else if (!NILP (direction))
2466 signal_simple_error ("Invalid value for DIRECTION", direction);
2468 if (dm == 2 && fi > 0x5F)
2470 ("Final must be in the range 0x30 - 0x5F for dimension == 2", final);
2473 type = (ch == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96;
2475 type = (ch == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96;
2479 obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_LEFT_TO_RIGHT);
2481 obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_RIGHT_TO_LEFT);
2484 obj = CHARSET_BY_ATTRIBUTES (type, fi, di);
2487 return XCHARSET_NAME (obj);
2491 DEFUN ("charset-short-name", Fcharset_short_name, 1, 1, 0, /*
2492 Return short name of CHARSET.
2496 return XCHARSET_SHORT_NAME (Fget_charset (charset));
2499 DEFUN ("charset-long-name", Fcharset_long_name, 1, 1, 0, /*
2500 Return long name of CHARSET.
2504 return XCHARSET_LONG_NAME (Fget_charset (charset));
2507 DEFUN ("charset-description", Fcharset_description, 1, 1, 0, /*
2508 Return description of CHARSET.
2512 return XCHARSET_DOC_STRING (Fget_charset (charset));
2515 DEFUN ("charset-dimension", Fcharset_dimension, 1, 1, 0, /*
2516 Return dimension of CHARSET.
2520 return make_int (XCHARSET_DIMENSION (Fget_charset (charset)));
2523 DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /*
2524 Return property PROP of CHARSET.
2525 Recognized properties are those listed in `make-charset', as well as
2526 'name and 'doc-string.
2532 charset = Fget_charset (charset);
2533 cs = XCHARSET (charset);
2535 CHECK_SYMBOL (prop);
2536 if (EQ (prop, Qname)) return CHARSET_NAME (cs);
2537 if (EQ (prop, Qshort_name)) return CHARSET_SHORT_NAME (cs);
2538 if (EQ (prop, Qlong_name)) return CHARSET_LONG_NAME (cs);
2539 if (EQ (prop, Qdoc_string)) return CHARSET_DOC_STRING (cs);
2540 if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs));
2541 if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs));
2542 if (EQ (prop, Qgraphic)) return make_int (CHARSET_GRAPHIC (cs));
2543 if (EQ (prop, Qfinal)) return make_char (CHARSET_FINAL (cs));
2544 if (EQ (prop, Qchars)) return make_int (CHARSET_CHARS (cs));
2545 if (EQ (prop, Qregistry)) return CHARSET_REGISTRY (cs);
2546 if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs);
2547 if (EQ (prop, Qdirection))
2548 return CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? Ql2r : Qr2l;
2549 if (EQ (prop, Qreverse_direction_charset))
2551 Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs);
2555 return XCHARSET_NAME (obj);
2557 signal_simple_error ("Unrecognized charset property name", prop);
2558 return Qnil; /* not reached */
2561 DEFUN ("charset-id", Fcharset_id, 1, 1, 0, /*
2562 Return charset identification number of CHARSET.
2566 return make_int(XCHARSET_LEADING_BYTE (Fget_charset (charset)));
2569 /* #### We need to figure out which properties we really want to
2572 DEFUN ("set-charset-ccl-program", Fset_charset_ccl_program, 2, 2, 0, /*
2573 Set the 'ccl-program property of CHARSET to CCL-PROGRAM.
2575 (charset, ccl_program))
2577 charset = Fget_charset (charset);
2578 CHECK_VECTOR (ccl_program);
2579 XCHARSET_CCL_PROGRAM (charset) = ccl_program;
2584 invalidate_charset_font_caches (Lisp_Object charset)
2586 /* Invalidate font cache entries for charset on all devices. */
2587 Lisp_Object devcons, concons, hash_table;
2588 DEVICE_LOOP_NO_BREAK (devcons, concons)
2590 struct device *d = XDEVICE (XCAR (devcons));
2591 hash_table = Fgethash (charset, d->charset_font_cache, Qunbound);
2592 if (!UNBOUNDP (hash_table))
2593 Fclrhash (hash_table);
2597 DEFUN ("set-charset-registry", Fset_charset_registry, 2, 2, 0, /*
2598 Set the 'registry property of CHARSET to REGISTRY.
2600 (charset, registry))
2602 charset = Fget_charset (charset);
2603 CHECK_STRING (registry);
2604 XCHARSET_REGISTRY (charset) = registry;
2605 invalidate_charset_font_caches (charset);
2606 face_property_was_changed (Vdefault_face, Qfont, Qglobal);
2611 DEFUN ("charset-mapping-table", Fcharset_mapping_table, 1, 1, 0, /*
2612 Return mapping-table of CHARSET.
2616 return XCHARSET_DECODING_TABLE (Fget_charset (charset));
2619 DEFUN ("set-charset-mapping-table", Fset_charset_mapping_table, 2, 2, 0, /*
2620 Set mapping-table of CHARSET to TABLE.
2624 struct Lisp_Charset *cs;
2628 charset = Fget_charset (charset);
2629 cs = XCHARSET (charset);
2633 CHARSET_DECODING_TABLE(cs) = Qnil;
2636 else if (VECTORP (table))
2638 int ccs_len = CHARSET_BYTE_SIZE (cs);
2639 int ret = decoding_table_check_elements (table,
2640 CHARSET_DIMENSION (cs),
2645 signal_simple_error ("Too big table", table);
2647 signal_simple_error ("Invalid element is found", table);
2649 signal_simple_error ("Something wrong", table);
2651 CHARSET_DECODING_TABLE(cs) = Qnil;
2654 signal_error (Qwrong_type_argument,
2655 list2 (build_translated_string ("vector-or-nil-p"),
2658 byte_offset = CHARSET_BYTE_OFFSET (cs);
2659 switch (CHARSET_DIMENSION (cs))
2662 for (i = 0; i < XVECTOR_LENGTH (table); i++)
2664 Lisp_Object c = XVECTOR_DATA(table)[i];
2667 put_char_ccs_code_point (c, charset,
2668 make_int (i + byte_offset));
2672 for (i = 0; i < XVECTOR_LENGTH (table); i++)
2674 Lisp_Object v = XVECTOR_DATA(table)[i];
2680 for (j = 0; j < XVECTOR_LENGTH (v); j++)
2682 Lisp_Object c = XVECTOR_DATA(v)[j];
2685 put_char_ccs_code_point
2687 make_int ( ( (i + byte_offset) << 8 )
2693 put_char_ccs_code_point (v, charset,
2694 make_int (i + byte_offset));
2703 /************************************************************************/
2704 /* Lisp primitives for working with characters */
2705 /************************************************************************/
2708 DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /*
2709 Make a character from CHARSET and code-point CODE.
2715 charset = Fget_charset (charset);
2718 if (XCHARSET_GRAPHIC (charset) == 1)
2720 return make_char (DECODE_CHAR (charset, c));
2724 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
2725 Make a character from CHARSET and octets ARG1 and ARG2.
2726 ARG2 is required only for characters from two-dimensional charsets.
2727 For example, (make-char 'latin-iso8859-2 185) will return the Latin 2
2728 character s with caron.
2730 (charset, arg1, arg2))
2734 int lowlim, highlim;
2736 charset = Fget_charset (charset);
2737 cs = XCHARSET (charset);
2739 if (EQ (charset, Vcharset_ascii)) lowlim = 0, highlim = 127;
2740 else if (EQ (charset, Vcharset_control_1)) lowlim = 0, highlim = 31;
2742 else if (CHARSET_CHARS (cs) == 256) lowlim = 0, highlim = 255;
2744 else if (CHARSET_CHARS (cs) == 94) lowlim = 33, highlim = 126;
2745 else /* CHARSET_CHARS (cs) == 96) */ lowlim = 32, highlim = 127;
2748 /* It is useful (and safe, according to Olivier Galibert) to strip
2749 the 8th bit off ARG1 and ARG2 becaue it allows programmers to
2750 write (make-char 'latin-iso8859-2 CODE) where code is the actual
2751 Latin 2 code of the character. */
2759 if (a1 < lowlim || a1 > highlim)
2760 args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim));
2762 if (CHARSET_DIMENSION (cs) == 1)
2766 ("Charset is of dimension one; second octet must be nil", arg2);
2767 return make_char (MAKE_CHAR (charset, a1, 0));
2776 a2 = XINT (arg2) & 0x7f;
2778 if (a2 < lowlim || a2 > highlim)
2779 args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim));
2781 return make_char (MAKE_CHAR (charset, a1, a2));
2784 DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /*
2785 Return the character set of char CH.
2789 CHECK_CHAR_COERCE_INT (ch);
2791 return XCHARSET_NAME (CHAR_CHARSET (XCHAR (ch)));
2794 DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /*
2795 Return the octet numbered N (should be 0 or 1) of char CH.
2796 N defaults to 0 if omitted.
2800 Lisp_Object charset;
2803 CHECK_CHAR_COERCE_INT (ch);
2805 BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1);
2807 if (NILP (n) || EQ (n, Qzero))
2808 return make_int (octet0);
2809 else if (EQ (n, make_int (1)))
2810 return make_int (octet1);
2812 signal_simple_error ("Octet number must be 0 or 1", n);
2815 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
2816 Return list of charset and one or two position-codes of CHAR.
2820 /* This function can GC */
2821 struct gcpro gcpro1, gcpro2;
2822 Lisp_Object charset = Qnil;
2823 Lisp_Object rc = Qnil;
2831 GCPRO2 (charset, rc);
2832 CHECK_CHAR_COERCE_INT (character);
2835 code_point = ENCODE_CHAR (XCHAR (character), charset);
2836 dimension = XCHARSET_DIMENSION (charset);
2837 while (dimension > 0)
2839 rc = Fcons (make_int (code_point & 255), rc);
2843 rc = Fcons (XCHARSET_NAME (charset), rc);
2845 BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
2847 if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)
2849 rc = list3 (XCHARSET_NAME (charset), make_int (c1), make_int (c2));
2853 rc = list2 (XCHARSET_NAME (charset), make_int (c1));
2862 #ifdef ENABLE_COMPOSITE_CHARS
2863 /************************************************************************/
2864 /* composite character functions */
2865 /************************************************************************/
2868 lookup_composite_char (Bufbyte *str, int len)
2870 Lisp_Object lispstr = make_string (str, len);
2871 Lisp_Object ch = Fgethash (lispstr,
2872 Vcomposite_char_string2char_hash_table,
2878 if (composite_char_row_next >= 128)
2879 signal_simple_error ("No more composite chars available", lispstr);
2880 emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next,
2881 composite_char_col_next);
2882 Fputhash (make_char (emch), lispstr,
2883 Vcomposite_char_char2string_hash_table);
2884 Fputhash (lispstr, make_char (emch),
2885 Vcomposite_char_string2char_hash_table);
2886 composite_char_col_next++;
2887 if (composite_char_col_next >= 128)
2889 composite_char_col_next = 32;
2890 composite_char_row_next++;
2899 composite_char_string (Emchar ch)
2901 Lisp_Object str = Fgethash (make_char (ch),
2902 Vcomposite_char_char2string_hash_table,
2904 assert (!UNBOUNDP (str));
2908 xxDEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /*
2909 Convert a string into a single composite character.
2910 The character is the result of overstriking all the characters in
2915 CHECK_STRING (string);
2916 return make_char (lookup_composite_char (XSTRING_DATA (string),
2917 XSTRING_LENGTH (string)));
2920 xxDEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /*
2921 Return a string of the characters comprising a composite character.
2929 if (CHAR_LEADING_BYTE (emch) != LEADING_BYTE_COMPOSITE)
2930 signal_simple_error ("Must be composite char", ch);
2931 return composite_char_string (emch);
2933 #endif /* ENABLE_COMPOSITE_CHARS */
2936 /************************************************************************/
2937 /* initialization */
2938 /************************************************************************/
2941 syms_of_mule_charset (void)
2944 INIT_LRECORD_IMPLEMENTATION (byte_table);
2945 INIT_LRECORD_IMPLEMENTATION (char_id_table);
2947 INIT_LRECORD_IMPLEMENTATION (charset);
2949 DEFSUBR (Fcharsetp);
2950 DEFSUBR (Ffind_charset);
2951 DEFSUBR (Fget_charset);
2952 DEFSUBR (Fcharset_list);
2953 DEFSUBR (Fcharset_name);
2954 DEFSUBR (Fmake_charset);
2955 DEFSUBR (Fmake_reverse_direction_charset);
2956 /* DEFSUBR (Freverse_direction_charset); */
2957 DEFSUBR (Fdefine_charset_alias);
2958 DEFSUBR (Fcharset_from_attributes);
2959 DEFSUBR (Fcharset_short_name);
2960 DEFSUBR (Fcharset_long_name);
2961 DEFSUBR (Fcharset_description);
2962 DEFSUBR (Fcharset_dimension);
2963 DEFSUBR (Fcharset_property);
2964 DEFSUBR (Fcharset_id);
2965 DEFSUBR (Fset_charset_ccl_program);
2966 DEFSUBR (Fset_charset_registry);
2968 DEFSUBR (Fchar_attribute_alist);
2969 DEFSUBR (Fget_char_attribute);
2970 DEFSUBR (Fput_char_attribute);
2971 DEFSUBR (Fremove_char_attribute);
2972 DEFSUBR (Fdefine_char);
2973 DEFSUBR (Fchar_variants);
2974 DEFSUBR (Fget_composite_char);
2975 DEFSUBR (Fcharset_mapping_table);
2976 DEFSUBR (Fset_charset_mapping_table);
2980 DEFSUBR (Fdecode_char);
2982 DEFSUBR (Fmake_char);
2983 DEFSUBR (Fchar_charset);
2984 DEFSUBR (Fchar_octet);
2985 DEFSUBR (Fsplit_char);
2987 #ifdef ENABLE_COMPOSITE_CHARS
2988 DEFSUBR (Fmake_composite_char);
2989 DEFSUBR (Fcomposite_char_string);
2992 defsymbol (&Qcharsetp, "charsetp");
2993 defsymbol (&Qregistry, "registry");
2994 defsymbol (&Qfinal, "final");
2995 defsymbol (&Qgraphic, "graphic");
2996 defsymbol (&Qdirection, "direction");
2997 defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
2998 defsymbol (&Qshort_name, "short-name");
2999 defsymbol (&Qlong_name, "long-name");
3001 defsymbol (&Ql2r, "l2r");
3002 defsymbol (&Qr2l, "r2l");
3004 /* Charsets, compatible with FSF 20.3
3005 Naming convention is Script-Charset[-Edition] */
3006 defsymbol (&Qascii, "ascii");
3007 defsymbol (&Qcontrol_1, "control-1");
3008 defsymbol (&Qlatin_iso8859_1, "latin-iso8859-1");
3009 defsymbol (&Qlatin_iso8859_2, "latin-iso8859-2");
3010 defsymbol (&Qlatin_iso8859_3, "latin-iso8859-3");
3011 defsymbol (&Qlatin_iso8859_4, "latin-iso8859-4");
3012 defsymbol (&Qthai_tis620, "thai-tis620");
3013 defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7");
3014 defsymbol (&Qarabic_iso8859_6, "arabic-iso8859-6");
3015 defsymbol (&Qhebrew_iso8859_8, "hebrew-iso8859-8");
3016 defsymbol (&Qkatakana_jisx0201, "katakana-jisx0201");
3017 defsymbol (&Qlatin_jisx0201, "latin-jisx0201");
3018 defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5");
3019 defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9");
3020 defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");
3021 defsymbol (&Qchinese_gb2312, "chinese-gb2312");
3022 defsymbol (&Qjapanese_jisx0208, "japanese-jisx0208");
3023 defsymbol (&Qjapanese_jisx0208_1990, "japanese-jisx0208-1990");
3024 defsymbol (&Qkorean_ksc5601, "korean-ksc5601");
3025 defsymbol (&Qjapanese_jisx0212, "japanese-jisx0212");
3026 defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1");
3027 defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2");
3029 defsymbol (&Qname, "name");
3030 defsymbol (&Qideographic_radical, "ideographic-radical");
3031 defsymbol (&Qideographic_strokes, "ideographic-strokes");
3032 defsymbol (&Qtotal_strokes, "total-strokes");
3033 defsymbol (&Q_ucs, "->ucs");
3034 defsymbol (&Q_decomposition, "->decomposition");
3035 defsymbol (&Qcompat, "compat");
3036 defsymbol (&Qisolated, "isolated");
3037 defsymbol (&Qinitial, "initial");
3038 defsymbol (&Qmedial, "medial");
3039 defsymbol (&Qfinal, "final");
3040 defsymbol (&Qvertical, "vertical");
3041 defsymbol (&QnoBreak, "noBreak");
3042 defsymbol (&Qfraction, "fraction");
3043 defsymbol (&Qsuper, "super");
3044 defsymbol (&Qsub, "sub");
3045 defsymbol (&Qcircle, "circle");
3046 defsymbol (&Qsquare, "square");
3047 defsymbol (&Qwide, "wide");
3048 defsymbol (&Qnarrow, "narrow");
3049 defsymbol (&Qsmall, "small");
3050 defsymbol (&Qfont, "font");
3051 defsymbol (&Qucs, "ucs");
3052 defsymbol (&Qucs_bmp, "ucs-bmp");
3053 defsymbol (&Qlatin_viscii, "latin-viscii");
3054 defsymbol (&Qlatin_tcvn5712, "latin-tcvn5712");
3055 defsymbol (&Qlatin_viscii_lower, "latin-viscii-lower");
3056 defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper");
3057 defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower");
3058 defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper");
3059 defsymbol (&Qideograph_daikanwa, "ideograph-daikanwa");
3060 defsymbol (&Qmojikyo, "mojikyo");
3061 defsymbol (&Qmojikyo_pj_1, "mojikyo-pj-1");
3062 defsymbol (&Qmojikyo_pj_2, "mojikyo-pj-2");
3063 defsymbol (&Qmojikyo_pj_3, "mojikyo-pj-3");
3064 defsymbol (&Qmojikyo_pj_4, "mojikyo-pj-4");
3065 defsymbol (&Qmojikyo_pj_5, "mojikyo-pj-5");
3066 defsymbol (&Qmojikyo_pj_6, "mojikyo-pj-6");
3067 defsymbol (&Qmojikyo_pj_7, "mojikyo-pj-7");
3068 defsymbol (&Qmojikyo_pj_8, "mojikyo-pj-8");
3069 defsymbol (&Qmojikyo_pj_9, "mojikyo-pj-9");
3070 defsymbol (&Qmojikyo_pj_10, "mojikyo-pj-10");
3071 defsymbol (&Qmojikyo_pj_11, "mojikyo-pj-11");
3072 defsymbol (&Qmojikyo_pj_12, "mojikyo-pj-12");
3073 defsymbol (&Qmojikyo_pj_13, "mojikyo-pj-13");
3074 defsymbol (&Qmojikyo_pj_14, "mojikyo-pj-14");
3075 defsymbol (&Qmojikyo_pj_15, "mojikyo-pj-15");
3076 defsymbol (&Qmojikyo_pj_16, "mojikyo-pj-16");
3077 defsymbol (&Qmojikyo_pj_17, "mojikyo-pj-17");
3078 defsymbol (&Qmojikyo_pj_18, "mojikyo-pj-18");
3079 defsymbol (&Qmojikyo_pj_19, "mojikyo-pj-19");
3080 defsymbol (&Qmojikyo_pj_20, "mojikyo-pj-20");
3081 defsymbol (&Qmojikyo_pj_21, "mojikyo-pj-21");
3082 defsymbol (&Qethiopic_ucs, "ethiopic-ucs");
3084 defsymbol (&Qchinese_big5_1, "chinese-big5-1");
3085 defsymbol (&Qchinese_big5_2, "chinese-big5-2");
3087 defsymbol (&Qcomposite, "composite");
3091 vars_of_mule_charset (void)
3098 chlook = xnew (struct charset_lookup);
3099 dumpstruct (&chlook, &charset_lookup_description);
3101 /* Table of charsets indexed by leading byte. */
3102 for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
3103 chlook->charset_by_leading_byte[i] = Qnil;
3106 /* Table of charsets indexed by type/final-byte. */
3107 for (i = 0; i < countof (chlook->charset_by_attributes); i++)
3108 for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
3109 chlook->charset_by_attributes[i][j] = Qnil;
3111 /* Table of charsets indexed by type/final-byte/direction. */
3112 for (i = 0; i < countof (chlook->charset_by_attributes); i++)
3113 for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
3114 for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++)
3115 chlook->charset_by_attributes[i][j][k] = Qnil;
3119 chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE;
3121 chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
3122 chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
3126 leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1;
3127 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11 /*
3128 Leading-code of private TYPE9N charset of column-width 1.
3130 leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1;
3134 Vutf_2000_version = build_string("0.15 (Sangō)");
3135 DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
3136 Version number of UTF-2000.
3139 staticpro (&Vcharacter_attribute_table);
3140 Vcharacter_attribute_table = make_char_id_table (Qnil, 0);
3142 staticpro (&Vcharacter_name_table);
3143 Vcharacter_name_table = make_char_id_table (Qnil, 0);
3145 /* staticpro (&Vcharacter_ideographic_radical_table); */
3146 Vcharacter_ideographic_radical_table = make_char_id_table (Qnil, -1);
3148 /* staticpro (&Vcharacter_ideographic_strokes_table); */
3149 Vcharacter_ideographic_strokes_table = make_char_id_table (Qnil, -1);
3151 /* staticpro (&Vcharacter_total_strokes_table); */
3152 Vcharacter_total_strokes_table = make_char_id_table (Qnil, -1);
3154 /* staticpro (&Vcharacter_decomposition_table); */
3155 Vcharacter_decomposition_table = make_char_id_table (Qnil, -1);
3157 /* staticpro (&Vcharacter_composition_table); */
3158 Vcharacter_composition_table = make_char_id_table (Qnil, -1);
3160 staticpro (&Vcharacter_variant_table);
3161 Vcharacter_variant_table = make_char_id_table (Qnil, 0);
3163 Vdefault_coded_charset_priority_list = Qnil;
3164 DEFVAR_LISP ("default-coded-charset-priority-list",
3165 &Vdefault_coded_charset_priority_list /*
3166 Default order of preferred coded-character-sets.
3172 complex_vars_of_mule_charset (void)
3174 staticpro (&Vcharset_hash_table);
3175 Vcharset_hash_table =
3176 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
3178 /* Predefined character sets. We store them into variables for
3182 staticpro (&Vcharset_ucs);
3184 make_charset (LEADING_BYTE_UCS, Qucs, 256, 4,
3185 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
3186 build_string ("UCS"),
3187 build_string ("UCS"),
3188 build_string ("ISO/IEC 10646"),
3190 Qnil, 0, 0xFFFFFFF, 0, 0);
3191 staticpro (&Vcharset_ucs_bmp);
3193 make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,
3194 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
3195 build_string ("BMP"),
3196 build_string ("BMP"),
3197 build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
3198 build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"),
3199 Qnil, 0, 0xFFFF, 0, 0);
3201 # define MIN_CHAR_THAI 0
3202 # define MAX_CHAR_THAI 0
3203 # define MIN_CHAR_HEBREW 0
3204 # define MAX_CHAR_HEBREW 0
3205 # define MIN_CHAR_HALFWIDTH_KATAKANA 0
3206 # define MAX_CHAR_HALFWIDTH_KATAKANA 0
3208 staticpro (&Vcharset_ascii);
3210 make_charset (LEADING_BYTE_ASCII, Qascii, 94, 1,
3211 1, 0, 'B', CHARSET_LEFT_TO_RIGHT,
3212 build_string ("ASCII"),
3213 build_string ("ASCII)"),
3214 build_string ("ASCII (ISO646 IRV)"),
3215 build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"),
3216 Qnil, 0, 0x7F, 0, 0);
3217 staticpro (&Vcharset_control_1);
3218 Vcharset_control_1 =
3219 make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
3220 1, 1, 0, CHARSET_LEFT_TO_RIGHT,
3221 build_string ("C1"),
3222 build_string ("Control characters"),
3223 build_string ("Control characters 128-191"),
3225 Qnil, 0x80, 0x9F, 0, 0);
3226 staticpro (&Vcharset_latin_iso8859_1);
3227 Vcharset_latin_iso8859_1 =
3228 make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
3229 1, 1, 'A', CHARSET_LEFT_TO_RIGHT,
3230 build_string ("Latin-1"),
3231 build_string ("ISO8859-1 (Latin-1)"),
3232 build_string ("ISO8859-1 (Latin-1)"),
3233 build_string ("iso8859-1"),
3234 Qnil, 0xA0, 0xFF, 0, 32);
3235 staticpro (&Vcharset_latin_iso8859_2);
3236 Vcharset_latin_iso8859_2 =
3237 make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
3238 1, 1, 'B', CHARSET_LEFT_TO_RIGHT,
3239 build_string ("Latin-2"),
3240 build_string ("ISO8859-2 (Latin-2)"),
3241 build_string ("ISO8859-2 (Latin-2)"),
3242 build_string ("iso8859-2"),
3244 staticpro (&Vcharset_latin_iso8859_3);
3245 Vcharset_latin_iso8859_3 =
3246 make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
3247 1, 1, 'C', CHARSET_LEFT_TO_RIGHT,
3248 build_string ("Latin-3"),
3249 build_string ("ISO8859-3 (Latin-3)"),
3250 build_string ("ISO8859-3 (Latin-3)"),
3251 build_string ("iso8859-3"),
3253 staticpro (&Vcharset_latin_iso8859_4);
3254 Vcharset_latin_iso8859_4 =
3255 make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
3256 1, 1, 'D', CHARSET_LEFT_TO_RIGHT,
3257 build_string ("Latin-4"),
3258 build_string ("ISO8859-4 (Latin-4)"),
3259 build_string ("ISO8859-4 (Latin-4)"),
3260 build_string ("iso8859-4"),
3262 staticpro (&Vcharset_thai_tis620);
3263 Vcharset_thai_tis620 =
3264 make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
3265 1, 1, 'T', CHARSET_LEFT_TO_RIGHT,
3266 build_string ("TIS620"),
3267 build_string ("TIS620 (Thai)"),
3268 build_string ("TIS620.2529 (Thai)"),
3269 build_string ("tis620"),
3270 Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32);
3271 staticpro (&Vcharset_greek_iso8859_7);
3272 Vcharset_greek_iso8859_7 =
3273 make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
3274 1, 1, 'F', CHARSET_LEFT_TO_RIGHT,
3275 build_string ("ISO8859-7"),
3276 build_string ("ISO8859-7 (Greek)"),
3277 build_string ("ISO8859-7 (Greek)"),
3278 build_string ("iso8859-7"),
3280 0 /* MIN_CHAR_GREEK */,
3281 0 /* MAX_CHAR_GREEK */, 0, 32);
3282 staticpro (&Vcharset_arabic_iso8859_6);
3283 Vcharset_arabic_iso8859_6 =
3284 make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
3285 1, 1, 'G', CHARSET_RIGHT_TO_LEFT,
3286 build_string ("ISO8859-6"),
3287 build_string ("ISO8859-6 (Arabic)"),
3288 build_string ("ISO8859-6 (Arabic)"),
3289 build_string ("iso8859-6"),
3291 staticpro (&Vcharset_hebrew_iso8859_8);
3292 Vcharset_hebrew_iso8859_8 =
3293 make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
3294 1, 1, 'H', CHARSET_RIGHT_TO_LEFT,
3295 build_string ("ISO8859-8"),
3296 build_string ("ISO8859-8 (Hebrew)"),
3297 build_string ("ISO8859-8 (Hebrew)"),
3298 build_string ("iso8859-8"),
3299 Qnil, MIN_CHAR_HEBREW, MAX_CHAR_HEBREW, 0, 32);
3300 staticpro (&Vcharset_katakana_jisx0201);
3301 Vcharset_katakana_jisx0201 =
3302 make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
3303 1, 1, 'I', CHARSET_LEFT_TO_RIGHT,
3304 build_string ("JISX0201 Kana"),
3305 build_string ("JISX0201.1976 (Japanese Kana)"),
3306 build_string ("JISX0201.1976 Japanese Kana"),
3307 build_string ("jisx0201\\.1976"),
3309 staticpro (&Vcharset_latin_jisx0201);
3310 Vcharset_latin_jisx0201 =
3311 make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
3312 1, 0, 'J', CHARSET_LEFT_TO_RIGHT,
3313 build_string ("JISX0201 Roman"),
3314 build_string ("JISX0201.1976 (Japanese Roman)"),
3315 build_string ("JISX0201.1976 Japanese Roman"),
3316 build_string ("jisx0201\\.1976"),
3318 staticpro (&Vcharset_cyrillic_iso8859_5);
3319 Vcharset_cyrillic_iso8859_5 =
3320 make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
3321 1, 1, 'L', CHARSET_LEFT_TO_RIGHT,
3322 build_string ("ISO8859-5"),
3323 build_string ("ISO8859-5 (Cyrillic)"),
3324 build_string ("ISO8859-5 (Cyrillic)"),
3325 build_string ("iso8859-5"),
3327 0 /* MIN_CHAR_CYRILLIC */,
3328 0 /* MAX_CHAR_CYRILLIC */, 0, 32);
3329 staticpro (&Vcharset_latin_iso8859_9);
3330 Vcharset_latin_iso8859_9 =
3331 make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
3332 1, 1, 'M', CHARSET_LEFT_TO_RIGHT,
3333 build_string ("Latin-5"),
3334 build_string ("ISO8859-9 (Latin-5)"),
3335 build_string ("ISO8859-9 (Latin-5)"),
3336 build_string ("iso8859-9"),
3338 staticpro (&Vcharset_japanese_jisx0208_1978);
3339 Vcharset_japanese_jisx0208_1978 =
3340 make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
3341 Qjapanese_jisx0208_1978, 94, 2,
3342 2, 0, '@', CHARSET_LEFT_TO_RIGHT,
3343 build_string ("JIS X0208:1978"),
3344 build_string ("JIS X0208:1978 (Japanese)"),
3346 ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"),
3347 build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"),
3349 staticpro (&Vcharset_chinese_gb2312);
3350 Vcharset_chinese_gb2312 =
3351 make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
3352 2, 0, 'A', CHARSET_LEFT_TO_RIGHT,
3353 build_string ("GB2312"),
3354 build_string ("GB2312)"),
3355 build_string ("GB2312 Chinese simplified"),
3356 build_string ("gb2312"),
3358 staticpro (&Vcharset_japanese_jisx0208);
3359 Vcharset_japanese_jisx0208 =
3360 make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2,
3361 2, 0, 'B', CHARSET_LEFT_TO_RIGHT,
3362 build_string ("JISX0208"),
3363 build_string ("JIS X0208:1983 (Japanese)"),
3364 build_string ("JIS X0208:1983 Japanese Kanji"),
3365 build_string ("jisx0208\\.1983"),
3368 staticpro (&Vcharset_japanese_jisx0208_1990);
3369 Vcharset_japanese_jisx0208_1990 =
3370 make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990,
3371 Qjapanese_jisx0208_1990, 94, 2,
3372 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3373 build_string ("JISX0208-1990"),
3374 build_string ("JIS X0208:1990 (Japanese)"),
3375 build_string ("JIS X0208:1990 Japanese Kanji"),
3376 build_string ("jisx0208\\.1990"),
3378 MIN_CHAR_JIS_X0208_1990,
3379 MAX_CHAR_JIS_X0208_1990, 0, 33);
3381 staticpro (&Vcharset_korean_ksc5601);
3382 Vcharset_korean_ksc5601 =
3383 make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 94, 2,
3384 2, 0, 'C', CHARSET_LEFT_TO_RIGHT,
3385 build_string ("KSC5601"),
3386 build_string ("KSC5601 (Korean"),
3387 build_string ("KSC5601 Korean Hangul and Hanja"),
3388 build_string ("ksc5601"),
3390 staticpro (&Vcharset_japanese_jisx0212);
3391 Vcharset_japanese_jisx0212 =
3392 make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2,
3393 2, 0, 'D', CHARSET_LEFT_TO_RIGHT,
3394 build_string ("JISX0212"),
3395 build_string ("JISX0212 (Japanese)"),
3396 build_string ("JISX0212 Japanese Supplement"),
3397 build_string ("jisx0212"),
3400 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
3401 staticpro (&Vcharset_chinese_cns11643_1);
3402 Vcharset_chinese_cns11643_1 =
3403 make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 94, 2,
3404 2, 0, 'G', CHARSET_LEFT_TO_RIGHT,
3405 build_string ("CNS11643-1"),
3406 build_string ("CNS11643-1 (Chinese traditional)"),
3408 ("CNS 11643 Plane 1 Chinese traditional"),
3409 build_string (CHINESE_CNS_PLANE_RE("1")),
3411 staticpro (&Vcharset_chinese_cns11643_2);
3412 Vcharset_chinese_cns11643_2 =
3413 make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2,
3414 2, 0, 'H', CHARSET_LEFT_TO_RIGHT,
3415 build_string ("CNS11643-2"),
3416 build_string ("CNS11643-2 (Chinese traditional)"),
3418 ("CNS 11643 Plane 2 Chinese traditional"),
3419 build_string (CHINESE_CNS_PLANE_RE("2")),
3422 staticpro (&Vcharset_latin_tcvn5712);
3423 Vcharset_latin_tcvn5712 =
3424 make_charset (LEADING_BYTE_LATIN_TCVN5712, Qlatin_tcvn5712, 96, 1,
3425 1, 1, 'Z', CHARSET_LEFT_TO_RIGHT,
3426 build_string ("TCVN 5712"),
3427 build_string ("TCVN 5712 (VSCII-2)"),
3428 build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
3429 build_string ("tcvn5712-1"),
3431 staticpro (&Vcharset_latin_viscii_lower);
3432 Vcharset_latin_viscii_lower =
3433 make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
3434 1, 1, '1', CHARSET_LEFT_TO_RIGHT,
3435 build_string ("VISCII lower"),
3436 build_string ("VISCII lower (Vietnamese)"),
3437 build_string ("VISCII lower (Vietnamese)"),
3438 build_string ("MULEVISCII-LOWER"),
3440 staticpro (&Vcharset_latin_viscii_upper);
3441 Vcharset_latin_viscii_upper =
3442 make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
3443 1, 1, '2', CHARSET_LEFT_TO_RIGHT,
3444 build_string ("VISCII upper"),
3445 build_string ("VISCII upper (Vietnamese)"),
3446 build_string ("VISCII upper (Vietnamese)"),
3447 build_string ("MULEVISCII-UPPER"),
3449 staticpro (&Vcharset_latin_viscii);
3450 Vcharset_latin_viscii =
3451 make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
3452 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
3453 build_string ("VISCII"),
3454 build_string ("VISCII 1.1 (Vietnamese)"),
3455 build_string ("VISCII 1.1 (Vietnamese)"),
3456 build_string ("VISCII1\\.1"),
3458 staticpro (&Vcharset_ideograph_daikanwa);
3459 Vcharset_ideograph_daikanwa =
3460 make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2,
3461 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
3462 build_string ("Daikanwa"),
3463 build_string ("Morohashi's Daikanwa"),
3464 build_string ("Daikanwa dictionary by MOROHASHI Tetsuji"),
3465 build_string ("Daikanwa"),
3466 Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, 0, 0);
3467 staticpro (&Vcharset_mojikyo);
3469 make_charset (LEADING_BYTE_MOJIKYO, Qmojikyo, 256, 3,
3470 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
3471 build_string ("Mojikyo"),
3472 build_string ("Mojikyo"),
3473 build_string ("Konjaku-Mojikyo"),
3475 Qnil, MIN_CHAR_MOJIKYO, MAX_CHAR_MOJIKYO, 0, 0);
3476 staticpro (&Vcharset_mojikyo_pj_1);
3477 Vcharset_mojikyo_pj_1 =
3478 make_charset (LEADING_BYTE_MOJIKYO_PJ_1, Qmojikyo_pj_1, 94, 2,
3479 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3480 build_string ("Mojikyo-PJ-1"),
3481 build_string ("Mojikyo (pseudo JIS encoding) part 1"),
3483 ("Konjaku-Mojikyo (pseudo JIS encoding) part 1"),
3484 build_string ("jisx0208\\.Mojikyo-1$"),
3486 staticpro (&Vcharset_mojikyo_pj_2);
3487 Vcharset_mojikyo_pj_2 =
3488 make_charset (LEADING_BYTE_MOJIKYO_PJ_2, Qmojikyo_pj_2, 94, 2,
3489 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3490 build_string ("Mojikyo-PJ-2"),
3491 build_string ("Mojikyo (pseudo JIS encoding) part 2"),
3493 ("Konjaku-Mojikyo (pseudo JIS encoding) part 2"),
3494 build_string ("jisx0208\\.Mojikyo-2$"),
3496 staticpro (&Vcharset_mojikyo_pj_3);
3497 Vcharset_mojikyo_pj_3 =
3498 make_charset (LEADING_BYTE_MOJIKYO_PJ_3, Qmojikyo_pj_3, 94, 2,
3499 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3500 build_string ("Mojikyo-PJ-3"),
3501 build_string ("Mojikyo (pseudo JIS encoding) part 3"),
3503 ("Konjaku-Mojikyo (pseudo JIS encoding) part 3"),
3504 build_string ("jisx0208\\.Mojikyo-3$"),
3506 staticpro (&Vcharset_mojikyo_pj_4);
3507 Vcharset_mojikyo_pj_4 =
3508 make_charset (LEADING_BYTE_MOJIKYO_PJ_4, Qmojikyo_pj_4, 94, 2,
3509 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3510 build_string ("Mojikyo-PJ-4"),
3511 build_string ("Mojikyo (pseudo JIS encoding) part 4"),
3513 ("Konjaku-Mojikyo (pseudo JIS encoding) part 4"),
3514 build_string ("jisx0208\\.Mojikyo-4$"),
3516 staticpro (&Vcharset_mojikyo_pj_5);
3517 Vcharset_mojikyo_pj_5 =
3518 make_charset (LEADING_BYTE_MOJIKYO_PJ_5, Qmojikyo_pj_5, 94, 2,
3519 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3520 build_string ("Mojikyo-PJ-5"),
3521 build_string ("Mojikyo (pseudo JIS encoding) part 5"),
3523 ("Konjaku-Mojikyo (pseudo JIS encoding) part 5"),
3524 build_string ("jisx0208\\.Mojikyo-5$"),
3526 staticpro (&Vcharset_mojikyo_pj_6);
3527 Vcharset_mojikyo_pj_6 =
3528 make_charset (LEADING_BYTE_MOJIKYO_PJ_6, Qmojikyo_pj_6, 94, 2,
3529 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3530 build_string ("Mojikyo-PJ-6"),
3531 build_string ("Mojikyo (pseudo JIS encoding) part 6"),
3533 ("Konjaku-Mojikyo (pseudo JIS encoding) part 6"),
3534 build_string ("jisx0208\\.Mojikyo-6$"),
3536 staticpro (&Vcharset_mojikyo_pj_7);
3537 Vcharset_mojikyo_pj_7 =
3538 make_charset (LEADING_BYTE_MOJIKYO_PJ_7, Qmojikyo_pj_7, 94, 2,
3539 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3540 build_string ("Mojikyo-PJ-7"),
3541 build_string ("Mojikyo (pseudo JIS encoding) part 7"),
3543 ("Konjaku-Mojikyo (pseudo JIS encoding) part 7"),
3544 build_string ("jisx0208\\.Mojikyo-7$"),
3546 staticpro (&Vcharset_mojikyo_pj_8);
3547 Vcharset_mojikyo_pj_8 =
3548 make_charset (LEADING_BYTE_MOJIKYO_PJ_8, Qmojikyo_pj_8, 94, 2,
3549 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3550 build_string ("Mojikyo-PJ-8"),
3551 build_string ("Mojikyo (pseudo JIS encoding) part 8"),
3553 ("Konjaku-Mojikyo (pseudo JIS encoding) part 8"),
3554 build_string ("jisx0208\\.Mojikyo-8$"),
3556 staticpro (&Vcharset_mojikyo_pj_9);
3557 Vcharset_mojikyo_pj_9 =
3558 make_charset (LEADING_BYTE_MOJIKYO_PJ_9, Qmojikyo_pj_9, 94, 2,
3559 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3560 build_string ("Mojikyo-PJ-9"),
3561 build_string ("Mojikyo (pseudo JIS encoding) part 9"),
3563 ("Konjaku-Mojikyo (pseudo JIS encoding) part 9"),
3564 build_string ("jisx0208\\.Mojikyo-9$"),
3566 staticpro (&Vcharset_mojikyo_pj_10);
3567 Vcharset_mojikyo_pj_10 =
3568 make_charset (LEADING_BYTE_MOJIKYO_PJ_10, Qmojikyo_pj_10, 94, 2,
3569 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3570 build_string ("Mojikyo-PJ-10"),
3571 build_string ("Mojikyo (pseudo JIS encoding) part 10"),
3573 ("Konjaku-Mojikyo (pseudo JIS encoding) part 10"),
3574 build_string ("jisx0208\\.Mojikyo-10$"),
3576 staticpro (&Vcharset_mojikyo_pj_11);
3577 Vcharset_mojikyo_pj_11 =
3578 make_charset (LEADING_BYTE_MOJIKYO_PJ_11, Qmojikyo_pj_11, 94, 2,
3579 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3580 build_string ("Mojikyo-PJ-11"),
3581 build_string ("Mojikyo (pseudo JIS encoding) part 11"),
3583 ("Konjaku-Mojikyo (pseudo JIS encoding) part 11"),
3584 build_string ("jisx0208\\.Mojikyo-11$"),
3586 staticpro (&Vcharset_mojikyo_pj_12);
3587 Vcharset_mojikyo_pj_12 =
3588 make_charset (LEADING_BYTE_MOJIKYO_PJ_12, Qmojikyo_pj_12, 94, 2,
3589 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3590 build_string ("Mojikyo-PJ-12"),
3591 build_string ("Mojikyo (pseudo JIS encoding) part 12"),
3593 ("Konjaku-Mojikyo (pseudo JIS encoding) part 12"),
3594 build_string ("jisx0208\\.Mojikyo-12$"),
3596 staticpro (&Vcharset_mojikyo_pj_13);
3597 Vcharset_mojikyo_pj_13 =
3598 make_charset (LEADING_BYTE_MOJIKYO_PJ_13, Qmojikyo_pj_13, 94, 2,
3599 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3600 build_string ("Mojikyo-PJ-13"),
3601 build_string ("Mojikyo (pseudo JIS encoding) part 13"),
3603 ("Konjaku-Mojikyo (pseudo JIS encoding) part 13"),
3604 build_string ("jisx0208\\.Mojikyo-13$"),
3606 staticpro (&Vcharset_mojikyo_pj_14);
3607 Vcharset_mojikyo_pj_14 =
3608 make_charset (LEADING_BYTE_MOJIKYO_PJ_14, Qmojikyo_pj_14, 94, 2,
3609 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3610 build_string ("Mojikyo-PJ-14"),
3611 build_string ("Mojikyo (pseudo JIS encoding) part 14"),
3613 ("Konjaku-Mojikyo (pseudo JIS encoding) part 14"),
3614 build_string ("jisx0208\\.Mojikyo-14$"),
3616 staticpro (&Vcharset_mojikyo_pj_15);
3617 Vcharset_mojikyo_pj_15 =
3618 make_charset (LEADING_BYTE_MOJIKYO_PJ_15, Qmojikyo_pj_15, 94, 2,
3619 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3620 build_string ("Mojikyo-PJ-15"),
3621 build_string ("Mojikyo (pseudo JIS encoding) part 15"),
3623 ("Konjaku-Mojikyo (pseudo JIS encoding) part 15"),
3624 build_string ("jisx0208\\.Mojikyo-15$"),
3626 staticpro (&Vcharset_mojikyo_pj_16);
3627 Vcharset_mojikyo_pj_16 =
3628 make_charset (LEADING_BYTE_MOJIKYO_PJ_16, Qmojikyo_pj_16, 94, 2,
3629 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3630 build_string ("Mojikyo-PJ-16"),
3631 build_string ("Mojikyo (pseudo JIS encoding) part 16"),
3633 ("Konjaku-Mojikyo (pseudo JIS encoding) part 16"),
3634 build_string ("jisx0208\\.Mojikyo-16$"),
3636 staticpro (&Vcharset_mojikyo_pj_17);
3637 Vcharset_mojikyo_pj_17 =
3638 make_charset (LEADING_BYTE_MOJIKYO_PJ_17, Qmojikyo_pj_17, 94, 2,
3639 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3640 build_string ("Mojikyo-PJ-17"),
3641 build_string ("Mojikyo (pseudo JIS encoding) part 17"),
3643 ("Konjaku-Mojikyo (pseudo JIS encoding) part 17"),
3644 build_string ("jisx0208\\.Mojikyo-17$"),
3646 staticpro (&Vcharset_mojikyo_pj_18);
3647 Vcharset_mojikyo_pj_18 =
3648 make_charset (LEADING_BYTE_MOJIKYO_PJ_18, Qmojikyo_pj_18, 94, 2,
3649 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3650 build_string ("Mojikyo-PJ-18"),
3651 build_string ("Mojikyo (pseudo JIS encoding) part 18"),
3653 ("Konjaku-Mojikyo (pseudo JIS encoding) part 18"),
3654 build_string ("jisx0208\\.Mojikyo-18$"),
3656 staticpro (&Vcharset_mojikyo_pj_19);
3657 Vcharset_mojikyo_pj_19 =
3658 make_charset (LEADING_BYTE_MOJIKYO_PJ_19, Qmojikyo_pj_19, 94, 2,
3659 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3660 build_string ("Mojikyo-PJ-19"),
3661 build_string ("Mojikyo (pseudo JIS encoding) part 19"),
3663 ("Konjaku-Mojikyo (pseudo JIS encoding) part 19"),
3664 build_string ("jisx0208\\.Mojikyo-19$"),
3666 staticpro (&Vcharset_mojikyo_pj_20);
3667 Vcharset_mojikyo_pj_20 =
3668 make_charset (LEADING_BYTE_MOJIKYO_PJ_20, Qmojikyo_pj_20, 94, 2,
3669 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3670 build_string ("Mojikyo-PJ-20"),
3671 build_string ("Mojikyo (pseudo JIS encoding) part 20"),
3673 ("Konjaku-Mojikyo (pseudo JIS encoding) part 20"),
3674 build_string ("jisx0208\\.Mojikyo-20$"),
3676 staticpro (&Vcharset_mojikyo_pj_21);
3677 Vcharset_mojikyo_pj_21 =
3678 make_charset (LEADING_BYTE_MOJIKYO_PJ_21, Qmojikyo_pj_21, 94, 2,
3679 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3680 build_string ("Mojikyo-PJ-21"),
3681 build_string ("Mojikyo (pseudo JIS encoding) part 21"),
3683 ("Konjaku-Mojikyo (pseudo JIS encoding) part 21"),
3684 build_string ("jisx0208\\.Mojikyo-21$"),
3686 staticpro (&Vcharset_ethiopic_ucs);
3687 Vcharset_ethiopic_ucs =
3688 make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2,
3689 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
3690 build_string ("Ethiopic (UCS)"),
3691 build_string ("Ethiopic (UCS)"),
3692 build_string ("Ethiopic of UCS"),
3693 build_string ("Ethiopic-Unicode"),
3694 Qnil, 0x1200, 0x137F, 0x1200, 0);
3696 staticpro (&Vcharset_chinese_big5_1);
3697 Vcharset_chinese_big5_1 =
3698 make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 94, 2,
3699 2, 0, '0', CHARSET_LEFT_TO_RIGHT,
3700 build_string ("Big5"),
3701 build_string ("Big5 (Level-1)"),
3703 ("Big5 Level-1 Chinese traditional"),
3704 build_string ("big5"),
3706 staticpro (&Vcharset_chinese_big5_2);
3707 Vcharset_chinese_big5_2 =
3708 make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
3709 2, 0, '1', CHARSET_LEFT_TO_RIGHT,
3710 build_string ("Big5"),
3711 build_string ("Big5 (Level-2)"),
3713 ("Big5 Level-2 Chinese traditional"),
3714 build_string ("big5"),
3717 #ifdef ENABLE_COMPOSITE_CHARS
3718 /* #### For simplicity, we put composite chars into a 96x96 charset.
3719 This is going to lead to problems because you can run out of
3720 room, esp. as we don't yet recycle numbers. */
3721 staticpro (&Vcharset_composite);
3722 Vcharset_composite =
3723 make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 96, 2,
3724 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3725 build_string ("Composite"),
3726 build_string ("Composite characters"),
3727 build_string ("Composite characters"),
3730 /* #### not dumped properly */
3731 composite_char_row_next = 32;
3732 composite_char_col_next = 32;
3734 Vcomposite_char_string2char_hash_table =
3735 make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
3736 Vcomposite_char_char2string_hash_table =
3737 make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
3738 staticpro (&Vcomposite_char_string2char_hash_table);
3739 staticpro (&Vcomposite_char_char2string_hash_table);
3740 #endif /* ENABLE_COMPOSITE_CHARS */