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,2001,2002,2003,2004 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 /* Rewritten by Ben Wing <ben@xemacs.org>. */
25 /* Rewritten by MORIOKA Tomohiko <tomo@m17n.org> for XEmacs CHISE. */
44 /* The various pre-defined charsets. */
46 Lisp_Object Vcharset_ascii;
47 Lisp_Object Vcharset_control_1;
48 Lisp_Object Vcharset_latin_iso8859_1;
49 Lisp_Object Vcharset_latin_iso8859_2;
50 Lisp_Object Vcharset_latin_iso8859_3;
51 Lisp_Object Vcharset_latin_iso8859_4;
52 Lisp_Object Vcharset_thai_tis620;
53 Lisp_Object Vcharset_greek_iso8859_7;
54 Lisp_Object Vcharset_arabic_iso8859_6;
55 Lisp_Object Vcharset_hebrew_iso8859_8;
56 Lisp_Object Vcharset_katakana_jisx0201;
57 Lisp_Object Vcharset_latin_jisx0201;
58 Lisp_Object Vcharset_cyrillic_iso8859_5;
59 Lisp_Object Vcharset_latin_iso8859_9;
60 Lisp_Object Vcharset_japanese_jisx0208_1978;
61 Lisp_Object Vcharset_chinese_gb2312;
62 Lisp_Object Vcharset_chinese_gb12345;
63 Lisp_Object Vcharset_japanese_jisx0208;
64 Lisp_Object Vcharset_japanese_jisx0208_1990;
65 Lisp_Object Vcharset_korean_ksc5601;
66 Lisp_Object Vcharset_japanese_jisx0212;
67 Lisp_Object Vcharset_chinese_cns11643_1;
68 Lisp_Object Vcharset_chinese_cns11643_2;
70 Lisp_Object Vcharset_system_char_id;
71 Lisp_Object Vcharset_ucs;
72 Lisp_Object Vcharset_ucs_bmp;
73 Lisp_Object Vcharset_ucs_smp;
74 Lisp_Object Vcharset_ucs_sip;
75 Lisp_Object Vcharset_latin_viscii;
76 Lisp_Object Vcharset_latin_tcvn5712;
77 Lisp_Object Vcharset_latin_viscii_lower;
78 Lisp_Object Vcharset_latin_viscii_upper;
79 Lisp_Object Vcharset_jis_x0208;
80 Lisp_Object Vcharset_chinese_big5;
81 Lisp_Object Vcharset_ethiopic_ucs;
83 Lisp_Object Vcharset_chinese_big5_1;
84 Lisp_Object Vcharset_chinese_big5_2;
86 #ifdef ENABLE_COMPOSITE_CHARS
87 Lisp_Object Vcharset_composite;
89 /* Hash tables for composite chars. One maps string representing
90 composed chars to their equivalent chars; one goes the
92 Lisp_Object Vcomposite_char_char2string_hash_table;
93 Lisp_Object Vcomposite_char_string2char_hash_table;
95 static int composite_char_row_next;
96 static int composite_char_col_next;
98 #endif /* ENABLE_COMPOSITE_CHARS */
100 struct charset_lookup *chlook;
102 static const struct lrecord_description charset_lookup_description_1[] = {
103 { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte),
105 NUM_LEADING_BYTES+4*128
112 static const struct struct_description charset_lookup_description = {
113 sizeof (struct charset_lookup),
114 charset_lookup_description_1
118 /* Table of number of bytes in the string representation of a character
119 indexed by the first byte of that representation.
121 rep_bytes_by_first_byte(c) is more efficient than the equivalent
122 canonical computation:
124 XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */
126 const Bytecount rep_bytes_by_first_byte[0xA0] =
127 { /* 0x00 - 0x7f are for straight ASCII */
128 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
129 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
130 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
131 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
132 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
133 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
134 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
135 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
136 /* 0x80 - 0x8f are for Dimension-1 official charsets */
138 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
140 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
142 /* 0x90 - 0x9d are for Dimension-2 official charsets */
143 /* 0x9e is for Dimension-1 private charsets */
144 /* 0x9f is for Dimension-2 private charsets */
145 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
151 int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len);
153 decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
157 if (XVECTOR_LENGTH (v) > ccs_len)
160 for (i = 0; i < XVECTOR_LENGTH (v); i++)
162 Lisp_Object c = XVECTOR_DATA(v)[i];
164 if (!NILP (c) && !CHARP (c))
168 int ret = decoding_table_check_elements (c, dim - 1, ccs_len);
180 put_char_ccs_code_point (Lisp_Object character,
181 Lisp_Object ccs, Lisp_Object value)
183 if ( !(EQ (XCHARSET_NAME (ccs), Qmap_ucs)
184 && INTP (value) && (XINT (value) < 0xF0000))
186 /* || (XCHAR (character) != XINT (value)) */ )
188 Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
192 { /* obsolete representation: value must be a list of bytes */
193 Lisp_Object ret = Fcar (value);
197 signal_simple_error ("Invalid value for coded-charset", value);
198 code_point = XINT (ret);
199 if (XCHARSET_GRAPHIC (ccs) == 1)
207 signal_simple_error ("Invalid value for coded-charset",
211 signal_simple_error ("Invalid value for coded-charset",
214 if (XCHARSET_GRAPHIC (ccs) == 1)
216 code_point = (code_point << 8) | j;
219 value = make_int (code_point);
221 else if (INTP (value))
223 code_point = XINT (value);
224 if (XCHARSET_GRAPHIC (ccs) == 1)
226 code_point &= 0x7F7F7F7F;
227 value = make_int (code_point);
231 signal_simple_error ("Invalid value for coded-charset", value);
235 Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
238 decoding_table_remove_char (ccs, XINT (cpos));
241 decoding_table_put_char (ccs, code_point, character);
247 remove_char_ccs (Lisp_Object character, Lisp_Object ccs)
249 Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
250 Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
252 if (VECTORP (decoding_table))
254 Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
258 decoding_table_remove_char (ccs, XINT (cpos));
261 if (CHAR_TABLEP (encoding_table))
263 put_char_id_table (XCHAR_TABLE(encoding_table), character, Qunbound);
271 int leading_code_private_11;
274 Lisp_Object Qcharsetp;
276 /* Qdoc_string, Qdimension, Qchars defined in general.c */
277 Lisp_Object Qregistry, Qfinal, Qgraphic;
278 Lisp_Object Qdirection;
279 Lisp_Object Qreverse_direction_charset;
280 Lisp_Object Qleading_byte;
281 Lisp_Object Qshort_name, Qlong_name;
284 Lisp_Object Qmin_code, Qmax_code, Qcode_offset;
285 Lisp_Object Qmother, Qconversion, Q94x60, Q94x94x60, Qbig5_1, Qbig5_2;
320 Qvietnamese_viscii_lower,
321 Qvietnamese_viscii_upper,
331 Lisp_Object Ql2r, Qr2l;
333 Lisp_Object Vcharset_hash_table;
335 /* Composite characters are characters constructed by overstriking two
336 or more regular characters.
338 1) The old Mule implementation involves storing composite characters
339 in a buffer as a tag followed by all of the actual characters
340 used to make up the composite character. I think this is a bad
341 idea; it greatly complicates code that wants to handle strings
342 one character at a time because it has to deal with the possibility
343 of great big ungainly characters. It's much more reasonable to
344 simply store an index into a table of composite characters.
346 2) The current implementation only allows for 16,384 separate
347 composite characters over the lifetime of the XEmacs process.
348 This could become a potential problem if the user
349 edited lots of different files that use composite characters.
350 Due to FSF bogosity, increasing the number of allowable
351 composite characters under Mule would decrease the number
352 of possible faces that can exist. Mule already has shrunk
353 this to 2048, and further shrinkage would become uncomfortable.
354 No such problems exist in XEmacs.
356 Composite characters could be represented as 0x80 C1 C2 C3,
357 where each C[1-3] is in the range 0xA0 - 0xFF. This allows
358 for slightly under 2^20 (one million) composite characters
359 over the XEmacs process lifetime, and you only need to
360 increase the size of a Mule character from 19 to 21 bits.
361 Or you could use 0x80 C1 C2 C3 C4, allowing for about
362 85 million (slightly over 2^26) composite characters. */
365 /************************************************************************/
366 /* Basic Emchar functions */
367 /************************************************************************/
369 /* Convert a non-ASCII Mule character C into a one-character Mule-encoded
370 string in STR. Returns the number of bytes stored.
371 Do not call this directly. Use the macro set_charptr_emchar() instead.
375 non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
390 else if ( c <= 0x7ff )
392 *p++ = (c >> 6) | 0xc0;
393 *p++ = (c & 0x3f) | 0x80;
395 else if ( c <= 0xffff )
397 *p++ = (c >> 12) | 0xe0;
398 *p++ = ((c >> 6) & 0x3f) | 0x80;
399 *p++ = (c & 0x3f) | 0x80;
401 else if ( c <= 0x1fffff )
403 *p++ = (c >> 18) | 0xf0;
404 *p++ = ((c >> 12) & 0x3f) | 0x80;
405 *p++ = ((c >> 6) & 0x3f) | 0x80;
406 *p++ = (c & 0x3f) | 0x80;
408 else if ( c <= 0x3ffffff )
410 *p++ = (c >> 24) | 0xf8;
411 *p++ = ((c >> 18) & 0x3f) | 0x80;
412 *p++ = ((c >> 12) & 0x3f) | 0x80;
413 *p++ = ((c >> 6) & 0x3f) | 0x80;
414 *p++ = (c & 0x3f) | 0x80;
418 *p++ = (c >> 30) | 0xfc;
419 *p++ = ((c >> 24) & 0x3f) | 0x80;
420 *p++ = ((c >> 18) & 0x3f) | 0x80;
421 *p++ = ((c >> 12) & 0x3f) | 0x80;
422 *p++ = ((c >> 6) & 0x3f) | 0x80;
423 *p++ = (c & 0x3f) | 0x80;
426 BREAKUP_CHAR (c, charset, c1, c2);
427 lb = CHAR_LEADING_BYTE (c);
428 if (LEADING_BYTE_PRIVATE_P (lb))
429 *p++ = PRIVATE_LEADING_BYTE_PREFIX (lb);
431 if (EQ (charset, Vcharset_control_1))
440 /* Return the first character from a Mule-encoded string in STR,
441 assuming it's non-ASCII. Do not call this directly.
442 Use the macro charptr_emchar() instead. */
445 non_ascii_charptr_emchar (const Bufbyte *str)
458 else if ( b >= 0xf8 )
463 else if ( b >= 0xf0 )
468 else if ( b >= 0xe0 )
473 else if ( b >= 0xc0 )
483 for( ; len > 0; len-- )
486 ch = ( ch << 6 ) | ( b & 0x3f );
490 Bufbyte i0 = *str, i1, i2 = 0;
493 if (i0 == LEADING_BYTE_CONTROL_1)
494 return (Emchar) (*++str - 0x20);
496 if (LEADING_BYTE_PREFIX_P (i0))
501 charset = CHARSET_BY_LEADING_BYTE (i0);
502 if (XCHARSET_DIMENSION (charset) == 2)
505 return MAKE_CHAR (charset, i1, i2);
509 /* Return whether CH is a valid Emchar, assuming it's non-ASCII.
510 Do not call this directly. Use the macro valid_char_p() instead. */
514 non_ascii_valid_char_p (Emchar ch)
518 /* Must have only lowest 19 bits set */
522 f1 = CHAR_FIELD1 (ch);
523 f2 = CHAR_FIELD2 (ch);
524 f3 = CHAR_FIELD3 (ch);
530 if (f2 < MIN_CHAR_FIELD2_OFFICIAL ||
531 (f2 > MAX_CHAR_FIELD2_OFFICIAL && f2 < MIN_CHAR_FIELD2_PRIVATE) ||
532 f2 > MAX_CHAR_FIELD2_PRIVATE)
537 if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE &&
538 f2 <= MAX_CHAR_FIELD2_PRIVATE))
542 NOTE: This takes advantage of the fact that
543 FIELD2_TO_OFFICIAL_LEADING_BYTE and
544 FIELD2_TO_PRIVATE_LEADING_BYTE are the same.
546 charset = CHARSET_BY_LEADING_BYTE (f2 + FIELD2_TO_OFFICIAL_LEADING_BYTE);
547 if (EQ (charset, Qnil))
549 return (XCHARSET_CHARS (charset) == 96);
555 if (f1 < MIN_CHAR_FIELD1_OFFICIAL ||
556 (f1 > MAX_CHAR_FIELD1_OFFICIAL && f1 < MIN_CHAR_FIELD1_PRIVATE) ||
557 f1 > MAX_CHAR_FIELD1_PRIVATE)
559 if (f2 < 0x20 || f3 < 0x20)
562 #ifdef ENABLE_COMPOSITE_CHARS
563 if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE)
565 if (UNBOUNDP (Fgethash (make_int (ch),
566 Vcomposite_char_char2string_hash_table,
571 #endif /* ENABLE_COMPOSITE_CHARS */
573 if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F
574 && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE))
577 if (f1 <= MAX_CHAR_FIELD1_OFFICIAL)
579 CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE);
582 CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_PRIVATE_LEADING_BYTE);
584 if (EQ (charset, Qnil))
586 return (XCHARSET_CHARS (charset) == 96);
592 /************************************************************************/
593 /* Basic string functions */
594 /************************************************************************/
596 /* Copy the character pointed to by SRC into DST. Do not call this
597 directly. Use the macro charptr_copy_char() instead.
598 Return the number of bytes copied. */
601 non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst)
603 unsigned int bytes = REP_BYTES_BY_FIRST_BYTE (*src);
605 for (i = bytes; i; i--, dst++, src++)
611 /************************************************************************/
612 /* streams of Emchars */
613 /************************************************************************/
615 /* Treat a stream as a stream of Emchar's rather than a stream of bytes.
616 The functions below are not meant to be called directly; use
617 the macros in insdel.h. */
620 Lstream_get_emchar_1 (Lstream *stream, int ch)
622 Bufbyte str[MAX_EMCHAR_LEN];
623 Bufbyte *strptr = str;
626 str[0] = (Bufbyte) ch;
628 for (bytes = REP_BYTES_BY_FIRST_BYTE (ch) - 1; bytes; bytes--)
630 int c = Lstream_getc (stream);
631 bufpos_checking_assert (c >= 0);
632 *++strptr = (Bufbyte) c;
634 return charptr_emchar (str);
638 Lstream_fput_emchar (Lstream *stream, Emchar ch)
640 Bufbyte str[MAX_EMCHAR_LEN];
641 Bytecount len = set_charptr_emchar (str, ch);
642 return Lstream_write (stream, str, len);
646 Lstream_funget_emchar (Lstream *stream, Emchar ch)
648 Bufbyte str[MAX_EMCHAR_LEN];
649 Bytecount len = set_charptr_emchar (str, ch);
650 Lstream_unread (stream, str, len);
654 /************************************************************************/
656 /************************************************************************/
659 mark_charset (Lisp_Object obj)
661 Lisp_Charset *cs = XCHARSET (obj);
663 mark_object (cs->short_name);
664 mark_object (cs->long_name);
665 mark_object (cs->doc_string);
666 mark_object (cs->registry);
667 mark_object (cs->ccl_program);
669 mark_object (cs->decoding_table);
670 mark_object (cs->mother);
676 print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
678 Lisp_Charset *cs = XCHARSET (obj);
682 error ("printing unreadable object #<charset %s 0x%x>",
683 string_data (XSYMBOL (CHARSET_NAME (cs))->name),
686 write_c_string ("#<charset ", printcharfun);
687 print_internal (CHARSET_NAME (cs), printcharfun, 0);
688 write_c_string (" ", printcharfun);
689 print_internal (CHARSET_SHORT_NAME (cs), printcharfun, 1);
690 write_c_string (" ", printcharfun);
691 print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1);
692 write_c_string (" ", printcharfun);
693 print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1);
694 sprintf (buf, " %d^%d %s cols=%d g%d final='%c' reg=",
696 CHARSET_DIMENSION (cs),
697 CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : "r2l",
698 CHARSET_COLUMNS (cs),
699 CHARSET_GRAPHIC (cs),
701 write_c_string (buf, printcharfun);
702 print_internal (CHARSET_REGISTRY (cs), printcharfun, 0);
703 sprintf (buf, " 0x%x>", cs->header.uid);
704 write_c_string (buf, printcharfun);
707 static const struct lrecord_description charset_description[] = {
708 { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) },
709 { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) },
710 { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) },
711 { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) },
712 { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) },
713 { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) },
714 { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
716 { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) },
717 { XD_LISP_OBJECT, offsetof (Lisp_Charset, mother) },
722 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
723 mark_charset, print_charset, 0, 0, 0,
727 /* Make a new charset. */
728 /* #### SJT Should generic properties be allowed? */
730 make_charset (Charset_ID id, Lisp_Object name,
731 unsigned short chars, unsigned char dimension,
732 unsigned char columns, unsigned char graphic,
733 Bufbyte final, unsigned char direction, Lisp_Object short_name,
734 Lisp_Object long_name, Lisp_Object doc,
736 Lisp_Object decoding_table,
737 Emchar min_code, Emchar max_code,
738 Emchar code_offset, unsigned char byte_offset,
739 Lisp_Object mother, unsigned char conversion)
742 Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
746 XSETCHARSET (obj, cs);
748 CHARSET_ID (cs) = id;
749 CHARSET_NAME (cs) = name;
750 CHARSET_SHORT_NAME (cs) = short_name;
751 CHARSET_LONG_NAME (cs) = long_name;
752 CHARSET_CHARS (cs) = chars;
753 CHARSET_DIMENSION (cs) = dimension;
754 CHARSET_DIRECTION (cs) = direction;
755 CHARSET_COLUMNS (cs) = columns;
756 CHARSET_GRAPHIC (cs) = graphic;
757 CHARSET_FINAL (cs) = final;
758 CHARSET_DOC_STRING (cs) = doc;
759 CHARSET_REGISTRY (cs) = reg;
760 CHARSET_CCL_PROGRAM (cs) = Qnil;
761 CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
763 CHARSET_DECODING_TABLE(cs) = Qunbound;
764 CHARSET_MIN_CODE (cs) = min_code;
765 CHARSET_MAX_CODE (cs) = max_code;
766 CHARSET_CODE_OFFSET (cs) = code_offset;
767 CHARSET_BYTE_OFFSET (cs) = byte_offset;
768 CHARSET_MOTHER (cs) = mother;
769 CHARSET_CONVERSION (cs) = conversion;
773 if (id == LEADING_BYTE_ASCII)
774 CHARSET_REP_BYTES (cs) = 1;
776 CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 1;
778 CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 2;
783 /* some charsets do not have final characters. This includes
784 ASCII, Control-1, Composite, and the two faux private
786 unsigned char iso2022_type
787 = (dimension == 1 ? 0 : 2) + (chars == 94 ? 0 : 1);
789 if (code_offset == 0)
791 assert (NILP (chlook->charset_by_attributes[iso2022_type][final]));
792 chlook->charset_by_attributes[iso2022_type][final] = obj;
796 (chlook->charset_by_attributes[iso2022_type][final][direction]));
797 chlook->charset_by_attributes[iso2022_type][final][direction] = obj;
801 assert (NILP (chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE]));
802 chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj;
804 /* Some charsets are "faux" and don't have names or really exist at
805 all except in the leading-byte table. */
807 Fputhash (name, obj, Vcharset_hash_table);
812 get_unallocated_leading_byte (int dimension)
817 if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
820 lb = chlook->next_allocated_leading_byte++;
824 if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
827 lb = chlook->next_allocated_1_byte_leading_byte++;
831 if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2)
834 lb = chlook->next_allocated_2_byte_leading_byte++;
840 ("No more character sets free for this dimension",
841 make_int (dimension));
847 /* Number of Big5 characters which have the same code in 1st byte. */
849 #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
852 decode_ccs_conversion (int conv_type, int code_point)
854 if ( conv_type == CONVERSION_IDENTICAL )
858 if ( conv_type == CONVERSION_94x60 )
860 int row = code_point >> 8;
861 int cell = code_point & 255;
865 else if (row < 16 + 32 + 30)
866 return (row - (16 + 32)) * 94 + cell - 33;
867 else if (row < 18 + 32 + 30)
869 else if (row < 18 + 32 + 60)
870 return (row - (18 + 32)) * 94 + cell - 33;
872 else if ( conv_type == CONVERSION_94x94x60 )
874 int plane = code_point >> 16;
875 int row = (code_point >> 8) & 255;
876 int cell = code_point & 255;
880 else if (row < 16 + 32 + 30)
882 (plane - 33) * 94 * 60
883 + (row - (16 + 32)) * 94
885 else if (row < 18 + 32 + 30)
887 else if (row < 18 + 32 + 60)
889 (plane - 33) * 94 * 60
890 + (row - (18 + 32)) * 94
893 else if ( conv_type == CONVERSION_BIG5_1 )
896 = (((code_point >> 8) & 0x7F) - 33) * 94
897 + (( code_point & 0x7F) - 33);
898 unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1;
899 unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40);
901 b2 += b2 < 0x3F ? 0x40 : 0x62;
902 return (b1 << 8) | b2;
904 else if ( conv_type == CONVERSION_BIG5_2 )
907 = (((code_point >> 8) & 0x7F) - 33) * 94
908 + (( code_point & 0x7F) - 33)
909 + BIG5_SAME_ROW * (0xC9 - 0xA1);
910 unsigned char b1 = I / (0xFF - 0xA1 + 0x7F - 0x40) + 0xA1;
911 unsigned char b2 = I % (0xFF - 0xA1 + 0x7F - 0x40);
913 b2 += b2 < 0x3F ? 0x40 : 0x62;
914 return (b1 << 8) | b2;
920 decode_defined_char (Lisp_Object ccs, int code_point, int without_inheritance)
922 int dim = XCHARSET_DIMENSION (ccs);
923 Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
931 = get_ccs_octet_table (decoding_table, ccs,
932 (code_point >> (dim * 8)) & 255);
934 if (CHARP (decoding_table))
935 return XCHAR (decoding_table);
937 if (EQ (decoding_table, Qunloaded))
939 char_id = load_char_decoding_entry_maybe (ccs, code_point);
941 #endif /* HAVE_CHISE */
944 else if ( !without_inheritance
945 && CHARSETP (mother = XCHARSET_MOTHER (ccs)) )
948 = decode_ccs_conversion (XCHARSET_CONVERSION (ccs), code_point);
952 code += XCHARSET_CODE_OFFSET(ccs);
953 if ( EQ (mother, Vcharset_ucs) )
954 return DECODE_CHAR (mother, code, without_inheritance);
956 return decode_defined_char (mother, code,
957 without_inheritance);
964 decode_builtin_char (Lisp_Object charset, int code_point)
966 Lisp_Object mother = XCHARSET_MOTHER (charset);
969 if ( XCHARSET_MAX_CODE (charset) > 0 )
971 if ( CHARSETP (mother) )
974 = decode_ccs_conversion (XCHARSET_CONVERSION (charset),
979 decode_builtin_char (mother,
980 code + XCHARSET_CODE_OFFSET(charset));
987 = (XCHARSET_DIMENSION (charset) == 1
989 code_point - XCHARSET_BYTE_OFFSET (charset)
991 ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset))
992 * XCHARSET_CHARS (charset)
993 + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset))
994 + XCHARSET_CODE_OFFSET (charset);
995 if ((cid < XCHARSET_MIN_CODE (charset))
996 || (XCHARSET_MAX_CODE (charset) < cid))
1001 else if ((final = XCHARSET_FINAL (charset)) >= '0')
1003 if (XCHARSET_DIMENSION (charset) == 1)
1005 switch (XCHARSET_CHARS (charset))
1009 + (final - '0') * 94 + ((code_point & 0x7F) - 33);
1012 + (final - '0') * 96 + ((code_point & 0x7F) - 32);
1020 switch (XCHARSET_CHARS (charset))
1023 return MIN_CHAR_94x94
1024 + (final - '0') * 94 * 94
1025 + (((code_point >> 8) & 0x7F) - 33) * 94
1026 + ((code_point & 0x7F) - 33);
1028 return MIN_CHAR_96x96
1029 + (final - '0') * 96 * 96
1030 + (((code_point >> 8) & 0x7F) - 32) * 96
1031 + ((code_point & 0x7F) - 32);
1043 charset_code_point (Lisp_Object charset, Emchar ch, int defined_only)
1045 Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset);
1048 if ( CHAR_TABLEP (encoding_table)
1049 && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table),
1054 Lisp_Object mother = XCHARSET_MOTHER (charset);
1055 int min = XCHARSET_MIN_CODE (charset);
1056 int max = XCHARSET_MAX_CODE (charset);
1059 if ( CHARSETP (mother) )
1061 if (XCHARSET_FINAL (charset) >= '0')
1062 code = charset_code_point (mother, ch, 1);
1064 code = charset_code_point (mother, ch, defined_only);
1066 else if (defined_only)
1068 else if ( ((max == 0) && CHARSETP (mother)
1069 && (XCHARSET_FINAL (charset) == 0))
1070 || ((min <= ch) && (ch <= max)) )
1072 if ( ((max == 0) && CHARSETP (mother) && (code >= 0))
1073 || ((min <= code) && (code <= max)) )
1075 int d = code - XCHARSET_CODE_OFFSET (charset);
1077 if ( XCHARSET_CONVERSION (charset) == CONVERSION_IDENTICAL )
1079 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94 )
1081 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96 )
1083 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
1086 int cell = d % 94 + 33;
1092 return (row << 8) | cell;
1094 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_1 )
1096 int B1 = d >> 8, B2 = d & 0xFF;
1098 = (B1 - 0xA1) * BIG5_SAME_ROW + B2
1099 - (B2 < 0x7F ? 0x40 : 0x62);
1103 return ((I / 94 + 33) << 8) | (I % 94 + 33);
1106 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_BIG5_2 )
1108 int B1 = d >> 8, B2 = d & 0xFF;
1110 = (B1 - 0xA1) * BIG5_SAME_ROW + B2
1111 - (B2 < 0x7F ? 0x40 : 0x62);
1115 I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1);
1116 return ((I / 94 + 33) << 8) | (I % 94 + 33);
1119 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94 )
1120 return ((d / 94 + 33) << 8) | (d % 94 + 33);
1121 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96 )
1122 return ((d / 96 + 32) << 8) | (d % 96 + 32);
1123 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 )
1125 int plane = d / (94 * 60) + 33;
1126 int row = (d % (94 * 60)) / 94;
1127 int cell = d % 94 + 33;
1133 return (plane << 16) | (row << 8) | cell;
1135 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94 )
1137 ( (d / (94 * 94) + 33) << 16)
1138 | ((d / 94 % 94 + 33) << 8)
1140 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96 )
1142 ( (d / (96 * 96) + 32) << 16)
1143 | ((d / 96 % 96 + 32) << 8)
1145 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94x94 )
1147 ( (d / (94 * 94 * 94) + 33) << 24)
1148 | ((d / (94 * 94) % 94 + 33) << 16)
1149 | ((d / 94 % 94 + 33) << 8)
1151 else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96x96 )
1153 ( (d / (96 * 96 * 96) + 32) << 24)
1154 | ((d / (96 * 96) % 96 + 32) << 16)
1155 | ((d / 96 % 96 + 32) << 8)
1159 printf ("Unknown CCS-conversion %d is specified!",
1160 XCHARSET_CONVERSION (charset));
1164 else if (defined_only)
1166 else if ( ( XCHARSET_FINAL (charset) >= '0' ) &&
1167 ( XCHARSET_MIN_CODE (charset) == 0 )
1169 (XCHARSET_CODE_OFFSET (charset) == 0) ||
1170 (XCHARSET_CODE_OFFSET (charset)
1171 == XCHARSET_MIN_CODE (charset))
1176 if (XCHARSET_DIMENSION (charset) == 1)
1178 if (XCHARSET_CHARS (charset) == 94)
1180 if (((d = ch - (MIN_CHAR_94
1181 + (XCHARSET_FINAL (charset) - '0') * 94))
1186 else if (XCHARSET_CHARS (charset) == 96)
1188 if (((d = ch - (MIN_CHAR_96
1189 + (XCHARSET_FINAL (charset) - '0') * 96))
1197 else if (XCHARSET_DIMENSION (charset) == 2)
1199 if (XCHARSET_CHARS (charset) == 94)
1201 if (((d = ch - (MIN_CHAR_94x94
1203 (XCHARSET_FINAL (charset) - '0') * 94 * 94))
1206 return (((d / 94) + 33) << 8) | (d % 94 + 33);
1208 else if (XCHARSET_CHARS (charset) == 96)
1210 if (((d = ch - (MIN_CHAR_96x96
1212 (XCHARSET_FINAL (charset) - '0') * 96 * 96))
1215 return (((d / 96) + 32) << 8) | (d % 96 + 32);
1226 encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
1228 if (c <= MAX_CHAR_BASIC_LATIN)
1230 *charset = Vcharset_ascii;
1235 *charset = Vcharset_control_1;
1240 *charset = Vcharset_latin_iso8859_1;
1244 else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW))
1246 *charset = Vcharset_hebrew_iso8859_8;
1247 return c - MIN_CHAR_HEBREW + 0x20;
1250 else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI))
1252 *charset = Vcharset_thai_tis620;
1253 return c - MIN_CHAR_THAI + 0x20;
1256 else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c)
1257 && (c <= MAX_CHAR_HALFWIDTH_KATAKANA))
1259 return list2 (Vcharset_katakana_jisx0201,
1260 make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33));
1263 else if (c <= MAX_CHAR_BMP)
1265 *charset = Vcharset_ucs_bmp;
1268 else if (c <= MAX_CHAR_SMP)
1270 *charset = Vcharset_ucs_smp;
1271 return c - MIN_CHAR_SMP;
1273 else if (c <= MAX_CHAR_SIP)
1275 *charset = Vcharset_ucs_sip;
1276 return c - MIN_CHAR_SIP;
1278 else if (c < MIN_CHAR_94)
1280 *charset = Vcharset_ucs;
1283 else if (c <= MAX_CHAR_94)
1285 *charset = CHARSET_BY_ATTRIBUTES (94, 1,
1286 ((c - MIN_CHAR_94) / 94) + '0',
1287 CHARSET_LEFT_TO_RIGHT);
1288 if (!NILP (*charset))
1289 return ((c - MIN_CHAR_94) % 94) + 33;
1292 *charset = Vcharset_ucs;
1296 else if (c <= MAX_CHAR_96)
1298 *charset = CHARSET_BY_ATTRIBUTES (96, 1,
1299 ((c - MIN_CHAR_96) / 96) + '0',
1300 CHARSET_LEFT_TO_RIGHT);
1301 if (!NILP (*charset))
1302 return ((c - MIN_CHAR_96) % 96) + 32;
1305 *charset = Vcharset_ucs;
1309 else if (c <= MAX_CHAR_94x94)
1312 = CHARSET_BY_ATTRIBUTES (94, 2,
1313 ((c - MIN_CHAR_94x94) / (94 * 94)) + '0',
1314 CHARSET_LEFT_TO_RIGHT);
1315 if (!NILP (*charset))
1316 return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8)
1317 | (((c - MIN_CHAR_94x94) % 94) + 33);
1320 *charset = Vcharset_ucs;
1324 else if (c <= MAX_CHAR_96x96)
1327 = CHARSET_BY_ATTRIBUTES (96, 2,
1328 ((c - MIN_CHAR_96x96) / (96 * 96)) + '0',
1329 CHARSET_LEFT_TO_RIGHT);
1330 if (!NILP (*charset))
1331 return ((((c - MIN_CHAR_96x96) / 96) % 96) + 32) << 8
1332 | (((c - MIN_CHAR_96x96) % 96) + 32);
1335 *charset = Vcharset_ucs;
1341 *charset = Vcharset_ucs;
1346 Lisp_Object Vdefault_coded_charset_priority_list;
1350 /************************************************************************/
1351 /* Basic charset Lisp functions */
1352 /************************************************************************/
1354 DEFUN ("charsetp", Fcharsetp, 1, 1, 0, /*
1355 Return non-nil if OBJECT is a charset.
1359 return CHARSETP (object) ? Qt : Qnil;
1362 DEFUN ("find-charset", Ffind_charset, 1, 1, 0, /*
1363 Retrieve the charset of the given name.
1364 If CHARSET-OR-NAME is a charset object, it is simply returned.
1365 Otherwise, CHARSET-OR-NAME should be a symbol. If there is no such charset,
1366 nil is returned. Otherwise the associated charset object is returned.
1370 if (CHARSETP (charset_or_name))
1371 return charset_or_name;
1373 CHECK_SYMBOL (charset_or_name);
1374 return Fgethash (charset_or_name, Vcharset_hash_table, Qnil);
1377 DEFUN ("get-charset", Fget_charset, 1, 1, 0, /*
1378 Retrieve the charset of the given name.
1379 Same as `find-charset' except an error is signalled if there is no such
1380 charset instead of returning nil.
1384 Lisp_Object charset = Ffind_charset (name);
1387 signal_simple_error ("No such charset", name);
1391 /* We store the charsets in hash tables with the names as the key and the
1392 actual charset object as the value. Occasionally we need to use them
1393 in a list format. These routines provide us with that. */
1394 struct charset_list_closure
1396 Lisp_Object *charset_list;
1400 add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value,
1401 void *charset_list_closure)
1403 /* This function can GC */
1404 struct charset_list_closure *chcl =
1405 (struct charset_list_closure*) charset_list_closure;
1406 Lisp_Object *charset_list = chcl->charset_list;
1408 *charset_list = Fcons (key /* XCHARSET_NAME (value) */, *charset_list);
1412 DEFUN ("charset-list", Fcharset_list, 0, 0, 0, /*
1413 Return a list of the names of all defined charsets.
1417 Lisp_Object charset_list = Qnil;
1418 struct gcpro gcpro1;
1419 struct charset_list_closure charset_list_closure;
1421 GCPRO1 (charset_list);
1422 charset_list_closure.charset_list = &charset_list;
1423 elisp_maphash (add_charset_to_list_mapper, Vcharset_hash_table,
1424 &charset_list_closure);
1427 return charset_list;
1430 DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /*
1431 Return the name of charset CHARSET.
1435 return XCHARSET_NAME (Fget_charset (charset));
1438 /* #### SJT Should generic properties be allowed? */
1439 DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /*
1440 Define a new character set.
1441 This function is for use with Mule support.
1442 NAME is a symbol, the name by which the character set is normally referred.
1443 DOC-STRING is a string describing the character set.
1444 PROPS is a property list, describing the specific nature of the
1445 character set. Recognized properties are:
1447 'short-name Short version of the charset name (ex: Latin-1)
1448 'long-name Long version of the charset name (ex: ISO8859-1 (Latin-1))
1449 'registry A regular expression matching the font registry field for
1451 'dimension Number of octets used to index a character in this charset.
1452 Either 1 or 2. Defaults to 1.
1453 If UTF-2000 feature is enabled, 3 or 4 are also available.
1454 'columns Number of columns used to display a character in this charset.
1455 Only used in TTY mode. (Under X, the actual width of a
1456 character can be derived from the font used to display the
1457 characters.) If unspecified, defaults to the dimension
1458 (this is almost always the correct value).
1459 'chars Number of characters in each dimension (94 or 96).
1460 Defaults to 94. Note that if the dimension is 2, the
1461 character set thus described is 94x94 or 96x96.
1462 If UTF-2000 feature is enabled, 128 or 256 are also available.
1463 'final Final byte of ISO 2022 escape sequence. Must be
1464 supplied. Each combination of (DIMENSION, CHARS) defines a
1465 separate namespace for final bytes. Note that ISO
1466 2022 restricts the final byte to the range
1467 0x30 - 0x7E if dimension == 1, and 0x30 - 0x5F if
1468 dimension == 2. Note also that final bytes in the range
1469 0x30 - 0x3F are reserved for user-defined (not official)
1471 'graphic 0 (use left half of font on output) or 1 (use right half
1472 of font on output). Defaults to 0. For example, for
1473 a font whose registry is ISO8859-1, the left half
1474 (octets 0x20 - 0x7F) is the `ascii' character set, while
1475 the right half (octets 0xA0 - 0xFF) is the `latin-1'
1476 character set. With 'graphic set to 0, the octets
1477 will have their high bit cleared; with it set to 1,
1478 the octets will have their high bit set.
1479 'direction 'l2r (left-to-right) or 'r2l (right-to-left).
1481 'ccl-program A compiled CCL program used to convert a character in
1482 this charset into an index into the font. This is in
1483 addition to the 'graphic property. The CCL program
1484 is passed the octets of the character, with the high
1485 bit cleared and set depending upon whether the value
1486 of the 'graphic property is 0 or 1.
1487 'mother [UTF-2000 only] Base coded-charset.
1488 'code-min [UTF-2000 only] Minimum code-point of a base coded-charset.
1489 'code-max [UTF-2000 only] Maximum code-point of a base coded-charset.
1490 'code-offset [UTF-2000 only] Offset for a code-point of a base
1492 'conversion [UTF-2000 only] Conversion for a code-point of a base
1493 coded-charset (94x60, 94x94x60, big5-1 or big5-2).
1495 (name, doc_string, props))
1497 int id = 0, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
1498 int direction = CHARSET_LEFT_TO_RIGHT;
1499 Lisp_Object registry = Qnil;
1500 Lisp_Object charset;
1501 Lisp_Object ccl_program = Qnil;
1502 Lisp_Object short_name = Qnil, long_name = Qnil;
1503 Lisp_Object mother = Qnil;
1504 int min_code = 0, max_code = 0, code_offset = 0;
1505 int byte_offset = -1;
1508 CHECK_SYMBOL (name);
1509 if (!NILP (doc_string))
1510 CHECK_STRING (doc_string);
1512 charset = Ffind_charset (name);
1513 if (!NILP (charset))
1514 signal_simple_error ("Cannot redefine existing charset", name);
1517 EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props)
1519 if (EQ (keyword, Qshort_name))
1521 CHECK_STRING (value);
1525 else if (EQ (keyword, Qlong_name))
1527 CHECK_STRING (value);
1531 else if (EQ (keyword, Qiso_ir))
1535 id = - XINT (value);
1539 else if (EQ (keyword, Qdimension))
1542 dimension = XINT (value);
1543 if (dimension < 1 ||
1550 signal_simple_error ("Invalid value for 'dimension", value);
1553 else if (EQ (keyword, Qchars))
1556 chars = XINT (value);
1557 if (chars != 94 && chars != 96
1559 && chars != 128 && chars != 256
1562 signal_simple_error ("Invalid value for 'chars", value);
1565 else if (EQ (keyword, Qcolumns))
1568 columns = XINT (value);
1569 if (columns != 1 && columns != 2)
1570 signal_simple_error ("Invalid value for 'columns", value);
1573 else if (EQ (keyword, Qgraphic))
1576 graphic = XINT (value);
1584 signal_simple_error ("Invalid value for 'graphic", value);
1587 else if (EQ (keyword, Qregistry))
1589 CHECK_STRING (value);
1593 else if (EQ (keyword, Qdirection))
1595 if (EQ (value, Ql2r))
1596 direction = CHARSET_LEFT_TO_RIGHT;
1597 else if (EQ (value, Qr2l))
1598 direction = CHARSET_RIGHT_TO_LEFT;
1600 signal_simple_error ("Invalid value for 'direction", value);
1603 else if (EQ (keyword, Qfinal))
1605 CHECK_CHAR_COERCE_INT (value);
1606 final = XCHAR (value);
1607 if (final < '0' || final > '~')
1608 signal_simple_error ("Invalid value for 'final", value);
1612 else if (EQ (keyword, Qmother))
1614 mother = Fget_charset (value);
1617 else if (EQ (keyword, Qmin_code))
1620 min_code = XUINT (value);
1623 else if (EQ (keyword, Qmax_code))
1626 max_code = XUINT (value);
1629 else if (EQ (keyword, Qcode_offset))
1632 code_offset = XUINT (value);
1635 else if (EQ (keyword, Qconversion))
1637 if (EQ (value, Q94x60))
1638 conversion = CONVERSION_94x60;
1639 else if (EQ (value, Q94x94x60))
1640 conversion = CONVERSION_94x94x60;
1641 else if (EQ (value, Qbig5_1))
1642 conversion = CONVERSION_BIG5_1;
1643 else if (EQ (value, Qbig5_2))
1644 conversion = CONVERSION_BIG5_2;
1646 signal_simple_error ("Unrecognized conversion", value);
1650 else if (EQ (keyword, Qccl_program))
1652 struct ccl_program test_ccl;
1654 if (setup_ccl_program (&test_ccl, value) < 0)
1655 signal_simple_error ("Invalid value for 'ccl-program", value);
1656 ccl_program = value;
1660 signal_simple_error ("Unrecognized property", keyword);
1666 error ("'final must be specified");
1668 if (dimension == 2 && final > 0x5F)
1670 ("Final must be in the range 0x30 - 0x5F for dimension == 2",
1673 if (!NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final,
1674 CHARSET_LEFT_TO_RIGHT)) ||
1675 !NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final,
1676 CHARSET_RIGHT_TO_LEFT)))
1678 ("Character set already defined for this DIMENSION/CHARS/FINAL combo");
1681 id = get_unallocated_leading_byte (dimension);
1683 if (NILP (doc_string))
1684 doc_string = build_string ("");
1686 if (NILP (registry))
1687 registry = build_string ("");
1689 if (NILP (short_name))
1690 XSETSTRING (short_name, XSYMBOL (name)->name);
1692 if (NILP (long_name))
1693 long_name = doc_string;
1696 columns = dimension;
1698 if (byte_offset < 0)
1702 else if (chars == 96)
1708 charset = make_charset (id, name, chars, dimension, columns, graphic,
1709 final, direction, short_name, long_name,
1710 doc_string, registry,
1711 Qnil, min_code, max_code, code_offset, byte_offset,
1712 mother, conversion);
1713 if (!NILP (ccl_program))
1714 XCHARSET_CCL_PROGRAM (charset) = ccl_program;
1718 DEFUN ("make-reverse-direction-charset", Fmake_reverse_direction_charset,
1720 Make a charset equivalent to CHARSET but which goes in the opposite direction.
1721 NEW-NAME is the name of the new charset. Return the new charset.
1723 (charset, new_name))
1725 Lisp_Object new_charset = Qnil;
1726 int id, chars, dimension, columns, graphic, final;
1728 Lisp_Object registry, doc_string, short_name, long_name;
1731 charset = Fget_charset (charset);
1732 if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset)))
1733 signal_simple_error ("Charset already has reverse-direction charset",
1736 CHECK_SYMBOL (new_name);
1737 if (!NILP (Ffind_charset (new_name)))
1738 signal_simple_error ("Cannot redefine existing charset", new_name);
1740 cs = XCHARSET (charset);
1742 chars = CHARSET_CHARS (cs);
1743 dimension = CHARSET_DIMENSION (cs);
1744 columns = CHARSET_COLUMNS (cs);
1745 id = get_unallocated_leading_byte (dimension);
1747 graphic = CHARSET_GRAPHIC (cs);
1748 final = CHARSET_FINAL (cs);
1749 direction = CHARSET_RIGHT_TO_LEFT;
1750 if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT)
1751 direction = CHARSET_LEFT_TO_RIGHT;
1752 doc_string = CHARSET_DOC_STRING (cs);
1753 short_name = CHARSET_SHORT_NAME (cs);
1754 long_name = CHARSET_LONG_NAME (cs);
1755 registry = CHARSET_REGISTRY (cs);
1757 new_charset = make_charset (id, new_name, chars, dimension, columns,
1758 graphic, final, direction, short_name, long_name,
1759 doc_string, registry,
1761 CHARSET_DECODING_TABLE(cs),
1762 CHARSET_MIN_CODE(cs),
1763 CHARSET_MAX_CODE(cs),
1764 CHARSET_CODE_OFFSET(cs),
1765 CHARSET_BYTE_OFFSET(cs),
1767 CHARSET_CONVERSION (cs)
1769 Qnil, 0, 0, 0, 0, Qnil, 0
1773 CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset;
1774 XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset;
1779 DEFUN ("define-charset-alias", Fdefine_charset_alias, 2, 2, 0, /*
1780 Define symbol ALIAS as an alias for CHARSET.
1784 CHECK_SYMBOL (alias);
1785 charset = Fget_charset (charset);
1786 return Fputhash (alias, charset, Vcharset_hash_table);
1789 /* #### Reverse direction charsets not yet implemented. */
1791 DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset,
1793 Return the reverse-direction charset parallel to CHARSET, if any.
1794 This is the charset with the same properties (in particular, the same
1795 dimension, number of characters per dimension, and final byte) as
1796 CHARSET but whose characters are displayed in the opposite direction.
1800 charset = Fget_charset (charset);
1801 return XCHARSET_REVERSE_DIRECTION_CHARSET (charset);
1805 DEFUN ("charset-from-attributes", Fcharset_from_attributes, 3, 4, 0, /*
1806 Return a charset with the given DIMENSION, CHARS, FINAL, and DIRECTION.
1807 If DIRECTION is omitted, both directions will be checked (left-to-right
1808 will be returned if character sets exist for both directions).
1810 (dimension, chars, final, direction))
1812 int dm, ch, fi, di = -1;
1813 Lisp_Object obj = Qnil;
1815 CHECK_INT (dimension);
1816 dm = XINT (dimension);
1817 if (dm < 1 || dm > 2)
1818 signal_simple_error ("Invalid value for DIMENSION", dimension);
1822 if (ch != 94 && ch != 96)
1823 signal_simple_error ("Invalid value for CHARS", chars);
1825 CHECK_CHAR_COERCE_INT (final);
1827 if (fi < '0' || fi > '~')
1828 signal_simple_error ("Invalid value for FINAL", final);
1830 if (EQ (direction, Ql2r))
1831 di = CHARSET_LEFT_TO_RIGHT;
1832 else if (EQ (direction, Qr2l))
1833 di = CHARSET_RIGHT_TO_LEFT;
1834 else if (!NILP (direction))
1835 signal_simple_error ("Invalid value for DIRECTION", direction);
1837 if (dm == 2 && fi > 0x5F)
1839 ("Final must be in the range 0x30 - 0x5F for dimension == 2", final);
1843 obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_LEFT_TO_RIGHT);
1845 obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_RIGHT_TO_LEFT);
1848 obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, di);
1851 return XCHARSET_NAME (obj);
1855 DEFUN ("charset-short-name", Fcharset_short_name, 1, 1, 0, /*
1856 Return short name of CHARSET.
1860 return XCHARSET_SHORT_NAME (Fget_charset (charset));
1863 DEFUN ("charset-long-name", Fcharset_long_name, 1, 1, 0, /*
1864 Return long name of CHARSET.
1868 return XCHARSET_LONG_NAME (Fget_charset (charset));
1871 DEFUN ("charset-description", Fcharset_description, 1, 1, 0, /*
1872 Return description of CHARSET.
1876 return XCHARSET_DOC_STRING (Fget_charset (charset));
1879 DEFUN ("charset-dimension", Fcharset_dimension, 1, 1, 0, /*
1880 Return dimension of CHARSET.
1884 return make_int (XCHARSET_DIMENSION (Fget_charset (charset)));
1887 DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /*
1888 Return property PROP of CHARSET, a charset object or symbol naming a charset.
1889 Recognized properties are those listed in `make-charset', as well as
1890 'name and 'doc-string.
1896 charset = Fget_charset (charset);
1897 cs = XCHARSET (charset);
1899 CHECK_SYMBOL (prop);
1900 if (EQ (prop, Qname)) return CHARSET_NAME (cs);
1901 if (EQ (prop, Qshort_name)) return CHARSET_SHORT_NAME (cs);
1902 if (EQ (prop, Qlong_name)) return CHARSET_LONG_NAME (cs);
1903 if (EQ (prop, Qdoc_string)) return CHARSET_DOC_STRING (cs);
1904 if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs));
1905 if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs));
1906 if (EQ (prop, Qgraphic)) return make_int (CHARSET_GRAPHIC (cs));
1907 if (EQ (prop, Qfinal)) return CHARSET_FINAL (cs) == 0 ?
1908 Qnil : make_char (CHARSET_FINAL (cs));
1909 if (EQ (prop, Qchars)) return make_int (CHARSET_CHARS (cs));
1910 if (EQ (prop, Qregistry)) return CHARSET_REGISTRY (cs);
1911 if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs);
1912 if (EQ (prop, Qdirection))
1913 return CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? Ql2r : Qr2l;
1914 if (EQ (prop, Qreverse_direction_charset))
1916 Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs);
1917 /* #### Is this translation OK? If so, error checking sufficient? */
1918 return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj;
1921 if (EQ (prop, Qmother))
1922 return CHARSET_MOTHER (cs);
1923 if (EQ (prop, Qmin_code))
1924 return make_int (CHARSET_MIN_CODE (cs));
1925 if (EQ (prop, Qmax_code))
1926 return make_int (CHARSET_MAX_CODE (cs));
1928 signal_simple_error ("Unrecognized charset property name", prop);
1929 return Qnil; /* not reached */
1932 DEFUN ("charset-id", Fcharset_id, 1, 1, 0, /*
1933 Return charset identification number of CHARSET.
1937 return make_int(XCHARSET_LEADING_BYTE (Fget_charset (charset)));
1940 /* #### We need to figure out which properties we really want to
1943 DEFUN ("set-charset-ccl-program", Fset_charset_ccl_program, 2, 2, 0, /*
1944 Set the 'ccl-program property of CHARSET to CCL-PROGRAM.
1946 (charset, ccl_program))
1948 struct ccl_program test_ccl;
1950 charset = Fget_charset (charset);
1951 if (setup_ccl_program (&test_ccl, ccl_program) < 0)
1952 signal_simple_error ("Invalid ccl-program", ccl_program);
1953 XCHARSET_CCL_PROGRAM (charset) = ccl_program;
1958 invalidate_charset_font_caches (Lisp_Object charset)
1960 /* Invalidate font cache entries for charset on all devices. */
1961 Lisp_Object devcons, concons, hash_table;
1962 DEVICE_LOOP_NO_BREAK (devcons, concons)
1964 struct device *d = XDEVICE (XCAR (devcons));
1965 hash_table = Fgethash (charset, d->charset_font_cache, Qunbound);
1966 if (!UNBOUNDP (hash_table))
1967 Fclrhash (hash_table);
1971 DEFUN ("set-charset-registry", Fset_charset_registry, 2, 2, 0, /*
1972 Set the 'registry property of CHARSET to REGISTRY.
1974 (charset, registry))
1976 charset = Fget_charset (charset);
1977 CHECK_STRING (registry);
1978 XCHARSET_REGISTRY (charset) = registry;
1979 invalidate_charset_font_caches (charset);
1980 face_property_was_changed (Vdefault_face, Qfont, Qglobal);
1985 DEFUN ("charset-mapping-table", Fcharset_mapping_table, 1, 1, 0, /*
1986 Return mapping-table of CHARSET.
1990 return XCHARSET_DECODING_TABLE (Fget_charset (charset));
1993 DEFUN ("set-charset-mapping-table", Fset_charset_mapping_table, 2, 2, 0, /*
1994 Set mapping-table of CHARSET to TABLE.
1998 struct Lisp_Charset *cs;
2002 charset = Fget_charset (charset);
2003 cs = XCHARSET (charset);
2007 CHARSET_DECODING_TABLE(cs) = Qnil;
2010 else if (VECTORP (table))
2012 int ccs_len = CHARSET_BYTE_SIZE (cs);
2013 int ret = decoding_table_check_elements (table,
2014 CHARSET_DIMENSION (cs),
2019 signal_simple_error ("Too big table", table);
2021 signal_simple_error ("Invalid element is found", table);
2023 signal_simple_error ("Something wrong", table);
2025 CHARSET_DECODING_TABLE(cs) = Qnil;
2028 signal_error (Qwrong_type_argument,
2029 list2 (build_translated_string ("vector-or-nil-p"),
2032 byte_offset = CHARSET_BYTE_OFFSET (cs);
2033 switch (CHARSET_DIMENSION (cs))
2036 for (i = 0; i < XVECTOR_LENGTH (table); i++)
2038 Lisp_Object c = XVECTOR_DATA(table)[i];
2041 Fput_char_attribute (c, XCHARSET_NAME (charset),
2042 make_int (i + byte_offset));
2046 for (i = 0; i < XVECTOR_LENGTH (table); i++)
2048 Lisp_Object v = XVECTOR_DATA(table)[i];
2054 for (j = 0; j < XVECTOR_LENGTH (v); j++)
2056 Lisp_Object c = XVECTOR_DATA(v)[j];
2060 (c, XCHARSET_NAME (charset),
2061 make_int ( ( (i + byte_offset) << 8 )
2067 Fput_char_attribute (v, XCHARSET_NAME (charset),
2068 make_int (i + byte_offset));
2076 DEFUN ("save-charset-mapping-table", Fsave_charset_mapping_table, 1, 1, 0, /*
2077 Save mapping-table of CHARSET.
2081 struct Lisp_Charset *cs;
2082 int byte_min, byte_max;
2083 #ifdef HAVE_LIBCHISE
2085 #else /* HAVE_LIBCHISE */
2087 Lisp_Object db_file;
2088 #endif /* not HAVE_LIBCHISE */
2090 charset = Fget_charset (charset);
2091 cs = XCHARSET (charset);
2093 #ifdef HAVE_LIBCHISE
2094 if ( open_chise_data_source_maybe () )
2098 = chise_ds_get_ccs (default_chise_data_source,
2099 XSTRING_DATA (Fsymbol_name (XCHARSET_NAME(charset))));
2102 printf ("Can't open decoding-table %s\n",
2103 XSTRING_DATA (Fsymbol_name (XCHARSET_NAME(charset))));
2106 #else /* HAVE_LIBCHISE */
2107 db_file = char_attribute_system_db_file (CHARSET_NAME (cs),
2108 Qsystem_char_id, 1);
2109 db = Fopen_database (db_file, Qnil, Qnil, build_string ("w+"), Qnil);
2110 #endif /* not HAVE_LIBCHISE */
2112 byte_min = CHARSET_BYTE_OFFSET (cs);
2113 byte_max = byte_min + CHARSET_BYTE_SIZE (cs);
2114 switch (CHARSET_DIMENSION (cs))
2118 Lisp_Object table_c = XCHARSET_DECODING_TABLE (charset);
2121 for (cell = byte_min; cell < byte_max; cell++)
2123 Lisp_Object c = get_ccs_octet_table (table_c, charset, cell);
2127 #ifdef HAVE_LIBCHISE
2128 chise_ccs_set_decoded_char (dt_ccs, cell, XCHAR (c));
2129 #else /* HAVE_LIBCHISE */
2130 Fput_database (Fprin1_to_string (make_int (cell), Qnil),
2131 Fprin1_to_string (c, Qnil),
2133 #endif /* not HAVE_LIBCHISE */
2140 Lisp_Object table_r = XCHARSET_DECODING_TABLE (charset);
2143 for (row = byte_min; row < byte_max; row++)
2145 Lisp_Object table_c = get_ccs_octet_table (table_r, charset, row);
2148 for (cell = byte_min; cell < byte_max; cell++)
2150 Lisp_Object c = get_ccs_octet_table (table_c, charset, cell);
2154 #ifdef HAVE_LIBCHISE
2155 chise_ccs_set_decoded_char
2157 (row << 8) | cell, XCHAR (c));
2158 #else /* HAVE_LIBCHISE */
2159 Fput_database (Fprin1_to_string (make_int ((row << 8)
2162 Fprin1_to_string (c, Qnil),
2164 #endif /* not HAVE_LIBCHISE */
2172 Lisp_Object table_p = XCHARSET_DECODING_TABLE (charset);
2175 for (plane = byte_min; plane < byte_max; plane++)
2178 = get_ccs_octet_table (table_p, charset, plane);
2181 for (row = byte_min; row < byte_max; row++)
2184 = get_ccs_octet_table (table_r, charset, row);
2187 for (cell = byte_min; cell < byte_max; cell++)
2189 Lisp_Object c = get_ccs_octet_table (table_c, charset,
2194 #ifdef HAVE_LIBCHISE
2195 chise_ccs_set_decoded_char
2200 #else /* HAVE_LIBCHISE */
2201 Fput_database (Fprin1_to_string
2202 (make_int ((plane << 16)
2206 Fprin1_to_string (c, Qnil),
2208 #endif /* not HAVE_LIBCHISE */
2217 Lisp_Object table_g = XCHARSET_DECODING_TABLE (charset);
2220 for (group = byte_min; group < byte_max; group++)
2223 = get_ccs_octet_table (table_g, charset, group);
2226 for (plane = byte_min; plane < byte_max; plane++)
2229 = get_ccs_octet_table (table_p, charset, plane);
2232 for (row = byte_min; row < byte_max; row++)
2235 = get_ccs_octet_table (table_r, charset, row);
2238 for (cell = byte_min; cell < byte_max; cell++)
2241 = get_ccs_octet_table (table_c, charset, cell);
2245 #ifdef HAVE_LIBCHISE
2246 chise_ccs_set_decoded_char
2252 #else /* HAVE_LIBCHISE */
2253 Fput_database (Fprin1_to_string
2254 (make_int (( group << 24)
2259 Fprin1_to_string (c, Qnil),
2261 #endif /* not HAVE_LIBCHISE */
2269 #ifdef HAVE_LIBCHISE
2270 chise_ccs_sync (dt_ccs);
2272 #else /* HAVE_LIBCHISE */
2273 return Fclose_database (db);
2274 #endif /* not HAVE_LIBCHISE */
2277 DEFUN ("reset-charset-mapping-table", Freset_charset_mapping_table, 1, 1, 0, /*
2278 Reset mapping-table of CCS with database file.
2282 #ifdef HAVE_LIBCHISE
2283 CHISE_CCS chise_ccs;
2285 Lisp_Object db_file;
2288 ccs = Fget_charset (ccs);
2290 #ifdef HAVE_LIBCHISE
2291 if ( open_chise_data_source_maybe () )
2294 chise_ccs = chise_ds_get_ccs (default_chise_data_source,
2295 XSTRING_DATA (Fsymbol_name
2296 (XCHARSET_NAME(ccs))));
2297 if (chise_ccs == NULL)
2300 db_file = char_attribute_system_db_file (XCHARSET_NAME(ccs),
2301 Qsystem_char_id, 0);
2305 #ifdef HAVE_LIBCHISE
2306 chise_ccs_setup_db (chise_ccs, 0) == 0
2308 !NILP (Ffile_exists_p (db_file))
2312 XCHARSET_DECODING_TABLE(ccs) = Qunloaded;
2319 load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point)
2321 #ifdef HAVE_LIBCHISE
2322 CHISE_Char_ID char_id;
2324 if ( open_chise_data_source_maybe () )
2328 = chise_ds_decode_char (default_chise_data_source,
2329 XSTRING_DATA(Fsymbol_name (XCHARSET_NAME(ccs))),
2332 decoding_table_put_char (ccs, code_point, make_char (char_id));
2334 decoding_table_put_char (ccs, code_point, Qnil);
2336 /* chise_ccst_close (dt_ccs); */
2338 #else /* HAVE_LIBCHISE */
2341 = char_attribute_system_db_file (XCHARSET_NAME(ccs), Qsystem_char_id,
2344 db = Fopen_database (db_file, Qnil, Qnil, build_string ("r"), Qnil);
2348 = Fget_database (Fprin1_to_string (make_int (code_point), Qnil),
2355 decoding_table_put_char (ccs, code_point, ret);
2356 Fclose_database (db);
2360 decoding_table_put_char (ccs, code_point, Qnil);
2361 Fclose_database (db);
2364 #endif /* not HAVE_LIBCHISE */
2366 #endif /* HAVE_CHISE */
2367 #endif /* UTF2000 */
2370 /************************************************************************/
2371 /* Lisp primitives for working with characters */
2372 /************************************************************************/
2375 DEFUN ("decode-char", Fdecode_char, 2, 4, 0, /*
2376 Make a character from CHARSET and code-point CODE.
2377 If DEFINED_ONLY is non-nil, builtin character is not returned.
2378 If WITHOUT_INHERITANCE is non-nil, inherited character is not returned.
2379 If corresponding character is not found, nil is returned.
2381 (charset, code, defined_only, without_inheritance))
2385 charset = Fget_charset (charset);
2388 if (XCHARSET_GRAPHIC (charset) == 1)
2390 if (NILP (defined_only))
2391 c = DECODE_CHAR (charset, c, !NILP (without_inheritance));
2393 c = decode_defined_char (charset, c, !NILP (without_inheritance));
2394 return c >= 0 ? make_char (c) : Qnil;
2397 DEFUN ("decode-builtin-char", Fdecode_builtin_char, 2, 2, 0, /*
2398 Make a builtin character from CHARSET and code-point CODE.
2404 charset = Fget_charset (charset);
2406 if (EQ (charset, Vcharset_latin_viscii))
2408 Lisp_Object chr = Fdecode_char (charset, code, Qnil, Qnil);
2414 (ret = Fget_char_attribute (chr,
2415 Vcharset_latin_viscii_lower,
2418 charset = Vcharset_latin_viscii_lower;
2422 (ret = Fget_char_attribute (chr,
2423 Vcharset_latin_viscii_upper,
2426 charset = Vcharset_latin_viscii_upper;
2433 if (XCHARSET_GRAPHIC (charset) == 1)
2436 c = decode_builtin_char (charset, c);
2438 c >= 0 ? make_char (c) : Fdecode_char (charset, code, Qnil, Qnil);
2442 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
2443 Make a character from CHARSET and octets ARG1 and ARG2.
2444 ARG2 is required only for characters from two-dimensional charsets.
2445 For example, (make-char 'latin-iso8859-2 185) will return the Latin 2
2446 character s with caron.
2448 (charset, arg1, arg2))
2452 int lowlim, highlim;
2454 charset = Fget_charset (charset);
2455 cs = XCHARSET (charset);
2457 if (EQ (charset, Vcharset_ascii)) lowlim = 0, highlim = 127;
2458 else if (EQ (charset, Vcharset_control_1)) lowlim = 0, highlim = 31;
2460 else if (CHARSET_CHARS (cs) == 256) lowlim = 0, highlim = 255;
2462 else if (CHARSET_CHARS (cs) == 94) lowlim = 33, highlim = 126;
2463 else /* CHARSET_CHARS (cs) == 96) */ lowlim = 32, highlim = 127;
2466 /* It is useful (and safe, according to Olivier Galibert) to strip
2467 the 8th bit off ARG1 and ARG2 because it allows programmers to
2468 write (make-char 'latin-iso8859-2 CODE) where code is the actual
2469 Latin 2 code of the character. */
2477 if (a1 < lowlim || a1 > highlim)
2478 args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim));
2480 if (CHARSET_DIMENSION (cs) == 1)
2484 ("Charset is of dimension one; second octet must be nil", arg2);
2485 return make_char (MAKE_CHAR (charset, a1, 0));
2494 a2 = XINT (arg2) & 0x7f;
2496 if (a2 < lowlim || a2 > highlim)
2497 args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim));
2499 return make_char (MAKE_CHAR (charset, a1, a2));
2502 DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /*
2503 Return the character set of CHARACTER.
2507 CHECK_CHAR_COERCE_INT (character);
2509 return XCHARSET_NAME (CHAR_CHARSET (XCHAR (character)));
2512 DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /*
2513 Return the octet numbered N (should be 0 or 1) of CHARACTER.
2514 N defaults to 0 if omitted.
2518 Lisp_Object charset;
2521 CHECK_CHAR_COERCE_INT (character);
2523 BREAKUP_CHAR (XCHAR (character), charset, octet0, octet1);
2525 if (NILP (n) || EQ (n, Qzero))
2526 return make_int (octet0);
2527 else if (EQ (n, make_int (1)))
2528 return make_int (octet1);
2530 signal_simple_error ("Octet number must be 0 or 1", n);
2534 DEFUN ("encode-char", Fencode_char, 2, 3, 0, /*
2535 Return code-point of CHARACTER in specified CHARSET.
2537 (character, charset, defined_only))
2541 CHECK_CHAR_COERCE_INT (character);
2542 charset = Fget_charset (charset);
2543 code_point = charset_code_point (charset, XCHAR (character),
2544 !NILP (defined_only));
2545 if (code_point >= 0)
2546 return make_int (code_point);
2552 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
2553 Return list of charset and one or two position-codes of CHARACTER.
2557 /* This function can GC */
2558 struct gcpro gcpro1, gcpro2;
2559 Lisp_Object charset = Qnil;
2560 Lisp_Object rc = Qnil;
2568 GCPRO2 (charset, rc);
2569 CHECK_CHAR_COERCE_INT (character);
2572 code_point = ENCODE_CHAR (XCHAR (character), charset);
2573 dimension = XCHARSET_DIMENSION (charset);
2574 while (dimension > 0)
2576 rc = Fcons (make_int (code_point & 255), rc);
2580 rc = Fcons (XCHARSET_NAME (charset), rc);
2582 BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
2584 if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)
2586 rc = list3 (XCHARSET_NAME (charset), make_int (c1), make_int (c2));
2590 rc = list2 (XCHARSET_NAME (charset), make_int (c1));
2599 #ifdef ENABLE_COMPOSITE_CHARS
2600 /************************************************************************/
2601 /* composite character functions */
2602 /************************************************************************/
2605 lookup_composite_char (Bufbyte *str, int len)
2607 Lisp_Object lispstr = make_string (str, len);
2608 Lisp_Object ch = Fgethash (lispstr,
2609 Vcomposite_char_string2char_hash_table,
2615 if (composite_char_row_next >= 128)
2616 signal_simple_error ("No more composite chars available", lispstr);
2617 emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next,
2618 composite_char_col_next);
2619 Fputhash (make_char (emch), lispstr,
2620 Vcomposite_char_char2string_hash_table);
2621 Fputhash (lispstr, make_char (emch),
2622 Vcomposite_char_string2char_hash_table);
2623 composite_char_col_next++;
2624 if (composite_char_col_next >= 128)
2626 composite_char_col_next = 32;
2627 composite_char_row_next++;
2636 composite_char_string (Emchar ch)
2638 Lisp_Object str = Fgethash (make_char (ch),
2639 Vcomposite_char_char2string_hash_table,
2641 assert (!UNBOUNDP (str));
2645 xxDEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /*
2646 Convert a string into a single composite character.
2647 The character is the result of overstriking all the characters in
2652 CHECK_STRING (string);
2653 return make_char (lookup_composite_char (XSTRING_DATA (string),
2654 XSTRING_LENGTH (string)));
2657 xxDEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /*
2658 Return a string of the characters comprising a composite character.
2666 if (CHAR_LEADING_BYTE (emch) != LEADING_BYTE_COMPOSITE)
2667 signal_simple_error ("Must be composite char", ch);
2668 return composite_char_string (emch);
2670 #endif /* ENABLE_COMPOSITE_CHARS */
2673 /************************************************************************/
2674 /* initialization */
2675 /************************************************************************/
2678 syms_of_mule_charset (void)
2680 INIT_LRECORD_IMPLEMENTATION (charset);
2682 DEFSUBR (Fcharsetp);
2683 DEFSUBR (Ffind_charset);
2684 DEFSUBR (Fget_charset);
2685 DEFSUBR (Fcharset_list);
2686 DEFSUBR (Fcharset_name);
2687 DEFSUBR (Fmake_charset);
2688 DEFSUBR (Fmake_reverse_direction_charset);
2689 /* DEFSUBR (Freverse_direction_charset); */
2690 DEFSUBR (Fdefine_charset_alias);
2691 DEFSUBR (Fcharset_from_attributes);
2692 DEFSUBR (Fcharset_short_name);
2693 DEFSUBR (Fcharset_long_name);
2694 DEFSUBR (Fcharset_description);
2695 DEFSUBR (Fcharset_dimension);
2696 DEFSUBR (Fcharset_property);
2697 DEFSUBR (Fcharset_id);
2698 DEFSUBR (Fset_charset_ccl_program);
2699 DEFSUBR (Fset_charset_registry);
2702 DEFSUBR (Fcharset_mapping_table);
2703 DEFSUBR (Fset_charset_mapping_table);
2705 DEFSUBR (Fsave_charset_mapping_table);
2706 DEFSUBR (Freset_charset_mapping_table);
2707 #endif /* HAVE_CHISE */
2708 DEFSUBR (Fdecode_char);
2709 DEFSUBR (Fdecode_builtin_char);
2710 DEFSUBR (Fencode_char);
2713 DEFSUBR (Fmake_char);
2714 DEFSUBR (Fchar_charset);
2715 DEFSUBR (Fchar_octet);
2716 DEFSUBR (Fsplit_char);
2718 #ifdef ENABLE_COMPOSITE_CHARS
2719 DEFSUBR (Fmake_composite_char);
2720 DEFSUBR (Fcomposite_char_string);
2723 defsymbol (&Qcharsetp, "charsetp");
2724 defsymbol (&Qregistry, "registry");
2725 defsymbol (&Qfinal, "final");
2726 defsymbol (&Qgraphic, "graphic");
2727 defsymbol (&Qdirection, "direction");
2728 defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
2729 defsymbol (&Qshort_name, "short-name");
2730 defsymbol (&Qlong_name, "long-name");
2731 defsymbol (&Qiso_ir, "iso-ir");
2733 defsymbol (&Qmother, "mother");
2734 defsymbol (&Qmin_code, "min-code");
2735 defsymbol (&Qmax_code, "max-code");
2736 defsymbol (&Qcode_offset, "code-offset");
2737 defsymbol (&Qconversion, "conversion");
2738 defsymbol (&Q94x60, "94x60");
2739 defsymbol (&Q94x94x60, "94x94x60");
2740 defsymbol (&Qbig5_1, "big5-1");
2741 defsymbol (&Qbig5_2, "big5-2");
2744 defsymbol (&Ql2r, "l2r");
2745 defsymbol (&Qr2l, "r2l");
2747 /* Charsets, compatible with FSF 20.3
2748 Naming convention is Script-Charset[-Edition] */
2749 defsymbol (&Qascii, "ascii");
2750 defsymbol (&Qcontrol_1, "control-1");
2751 defsymbol (&Qlatin_iso8859_1, "latin-iso8859-1");
2752 defsymbol (&Qlatin_iso8859_2, "latin-iso8859-2");
2753 defsymbol (&Qlatin_iso8859_3, "latin-iso8859-3");
2754 defsymbol (&Qlatin_iso8859_4, "latin-iso8859-4");
2755 defsymbol (&Qthai_tis620, "thai-tis620");
2756 defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7");
2757 defsymbol (&Qarabic_iso8859_6, "arabic-iso8859-6");
2758 defsymbol (&Qhebrew_iso8859_8, "hebrew-iso8859-8");
2759 defsymbol (&Qkatakana_jisx0201, "katakana-jisx0201");
2760 defsymbol (&Qlatin_jisx0201, "latin-jisx0201");
2761 defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5");
2762 defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9");
2763 defsymbol (&Qmap_jis_x0208_1978, "=jis-x0208-1978");
2764 defsymbol (&Qmap_gb2312, "=gb2312");
2765 defsymbol (&Qmap_gb12345, "=gb12345");
2766 defsymbol (&Qmap_jis_x0208_1983, "=jis-x0208-1983");
2767 defsymbol (&Qmap_ks_x1001, "=ks-x1001");
2768 defsymbol (&Qmap_jis_x0212, "=jis-x0212");
2769 defsymbol (&Qmap_cns11643_1, "=cns11643-1");
2770 defsymbol (&Qmap_cns11643_2, "=cns11643-2");
2772 defsymbol (&Qsystem_char_id, "system-char-id");
2773 defsymbol (&Qmap_ucs, "=ucs");
2774 defsymbol (&Qucs, "ucs");
2775 defsymbol (&Qucs_bmp, "ucs-bmp");
2776 defsymbol (&Qucs_smp, "ucs-smp");
2777 defsymbol (&Qucs_sip, "ucs-sip");
2778 defsymbol (&Qlatin_viscii, "latin-viscii");
2779 defsymbol (&Qlatin_tcvn5712, "latin-tcvn5712");
2780 defsymbol (&Qlatin_viscii_lower, "latin-viscii-lower");
2781 defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper");
2782 defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower");
2783 defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper");
2784 defsymbol (&Qmap_jis_x0208, "=jis-x0208");
2785 defsymbol (&Qmap_jis_x0208_1990, "=jis-x0208-1990");
2786 defsymbol (&Qmap_big5, "=big5");
2787 defsymbol (&Qethiopic_ucs, "ethiopic-ucs");
2789 defsymbol (&Qchinese_big5_1, "chinese-big5-1");
2790 defsymbol (&Qchinese_big5_2, "chinese-big5-2");
2792 defsymbol (&Qcomposite, "composite");
2796 vars_of_mule_charset (void)
2803 chlook = xnew_and_zero (struct charset_lookup); /* zero for Purify. */
2804 dump_add_root_struct_ptr (&chlook, &charset_lookup_description);
2806 /* Table of charsets indexed by leading byte. */
2807 for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
2808 chlook->charset_by_leading_byte[i] = Qnil;
2811 /* Table of charsets indexed by type/final-byte. */
2812 for (i = 0; i < countof (chlook->charset_by_attributes); i++)
2813 for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
2814 chlook->charset_by_attributes[i][j] = Qnil;
2816 /* Table of charsets indexed by type/final-byte/direction. */
2817 for (i = 0; i < countof (chlook->charset_by_attributes); i++)
2818 for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
2819 for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++)
2820 chlook->charset_by_attributes[i][j][k] = Qnil;
2824 chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE;
2826 chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
2827 chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
2831 leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1;
2832 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11 /*
2833 Leading-code of private TYPE9N charset of column-width 1.
2835 leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1;
2839 Vdefault_coded_charset_priority_list = Qnil;
2840 DEFVAR_LISP ("default-coded-charset-priority-list",
2841 &Vdefault_coded_charset_priority_list /*
2842 Default order of preferred coded-character-sets.
2848 complex_vars_of_mule_charset (void)
2850 staticpro (&Vcharset_hash_table);
2851 Vcharset_hash_table =
2852 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
2854 /* Predefined character sets. We store them into variables for
2858 staticpro (&Vcharset_system_char_id);
2859 Vcharset_system_char_id =
2860 make_charset (LEADING_BYTE_SYSTEM_CHAR_ID, Qsystem_char_id, 256, 4,
2861 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
2862 build_string ("SCID"),
2863 build_string ("CHAR-ID"),
2864 build_string ("System char-id"),
2866 Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
2867 staticpro (&Vcharset_ucs);
2869 make_charset (LEADING_BYTE_UCS, Qmap_ucs, 256, 4,
2870 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
2871 build_string ("UCS"),
2872 build_string ("UCS"),
2873 build_string ("ISO/IEC 10646"),
2875 Qnil, 0, 0xEFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
2876 staticpro (&Vcharset_ucs_bmp);
2878 make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,
2879 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
2880 build_string ("BMP"),
2881 build_string ("UCS-BMP"),
2882 build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
2884 ("\\(ISO10646.*-[01]\\|UCS00-0\\|UNICODE[23]?-0\\)"),
2885 Qnil, 0, 0xFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
2886 staticpro (&Vcharset_ucs_smp);
2888 make_charset (LEADING_BYTE_UCS_SMP, Qucs_smp, 256, 2,
2889 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
2890 build_string ("SMP"),
2891 build_string ("UCS-SMP"),
2892 build_string ("ISO/IEC 10646 Group 0 Plane 1 (SMP)"),
2893 build_string ("UCS00-1"),
2894 Qnil, MIN_CHAR_SMP, MAX_CHAR_SMP,
2895 MIN_CHAR_SMP, 0, Qnil, CONVERSION_IDENTICAL);
2896 staticpro (&Vcharset_ucs_sip);
2898 make_charset (LEADING_BYTE_UCS_SIP, Qucs_sip, 256, 2,
2899 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
2900 build_string ("SIP"),
2901 build_string ("UCS-SIP"),
2902 build_string ("ISO/IEC 10646 Group 0 Plane 2 (SIP)"),
2903 build_string ("\\(ISO10646.*-2\\|UCS00-2\\)"),
2904 Qnil, MIN_CHAR_SIP, MAX_CHAR_SIP,
2905 MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL);
2907 # define MIN_CHAR_THAI 0
2908 # define MAX_CHAR_THAI 0
2909 /* # define MIN_CHAR_HEBREW 0 */
2910 /* # define MAX_CHAR_HEBREW 0 */
2911 # define MIN_CHAR_HALFWIDTH_KATAKANA 0
2912 # define MAX_CHAR_HALFWIDTH_KATAKANA 0
2914 staticpro (&Vcharset_ascii);
2916 make_charset (LEADING_BYTE_ASCII, Qascii, 94, 1,
2917 1, 0, 'B', CHARSET_LEFT_TO_RIGHT,
2918 build_string ("ASCII"),
2919 build_string ("ASCII)"),
2920 build_string ("ASCII (ISO646 IRV)"),
2921 build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"),
2922 Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL);
2923 staticpro (&Vcharset_control_1);
2924 Vcharset_control_1 =
2925 make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
2926 1, 1, 0, CHARSET_LEFT_TO_RIGHT,
2927 build_string ("C1"),
2928 build_string ("Control characters"),
2929 build_string ("Control characters 128-191"),
2931 Qnil, 0x80, 0x9F, 0x80, 0, Qnil, CONVERSION_IDENTICAL);
2932 staticpro (&Vcharset_latin_iso8859_1);
2933 Vcharset_latin_iso8859_1 =
2934 make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
2935 1, 1, 'A', CHARSET_LEFT_TO_RIGHT,
2936 build_string ("Latin-1"),
2937 build_string ("ISO8859-1 (Latin-1)"),
2938 build_string ("ISO8859-1 (Latin-1)"),
2939 build_string ("iso8859-1"),
2940 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2941 staticpro (&Vcharset_latin_iso8859_2);
2942 Vcharset_latin_iso8859_2 =
2943 make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
2944 1, 1, 'B', CHARSET_LEFT_TO_RIGHT,
2945 build_string ("Latin-2"),
2946 build_string ("ISO8859-2 (Latin-2)"),
2947 build_string ("ISO8859-2 (Latin-2)"),
2948 build_string ("iso8859-2"),
2949 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2950 staticpro (&Vcharset_latin_iso8859_3);
2951 Vcharset_latin_iso8859_3 =
2952 make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
2953 1, 1, 'C', CHARSET_LEFT_TO_RIGHT,
2954 build_string ("Latin-3"),
2955 build_string ("ISO8859-3 (Latin-3)"),
2956 build_string ("ISO8859-3 (Latin-3)"),
2957 build_string ("iso8859-3"),
2958 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2959 staticpro (&Vcharset_latin_iso8859_4);
2960 Vcharset_latin_iso8859_4 =
2961 make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
2962 1, 1, 'D', CHARSET_LEFT_TO_RIGHT,
2963 build_string ("Latin-4"),
2964 build_string ("ISO8859-4 (Latin-4)"),
2965 build_string ("ISO8859-4 (Latin-4)"),
2966 build_string ("iso8859-4"),
2967 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2968 staticpro (&Vcharset_thai_tis620);
2969 Vcharset_thai_tis620 =
2970 make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
2971 1, 1, 'T', CHARSET_LEFT_TO_RIGHT,
2972 build_string ("TIS620"),
2973 build_string ("TIS620 (Thai)"),
2974 build_string ("TIS620.2529 (Thai)"),
2975 build_string ("tis620"),
2976 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2977 staticpro (&Vcharset_greek_iso8859_7);
2978 Vcharset_greek_iso8859_7 =
2979 make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
2980 1, 1, 'F', CHARSET_LEFT_TO_RIGHT,
2981 build_string ("ISO8859-7"),
2982 build_string ("ISO8859-7 (Greek)"),
2983 build_string ("ISO8859-7 (Greek)"),
2984 build_string ("iso8859-7"),
2985 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2986 staticpro (&Vcharset_arabic_iso8859_6);
2987 Vcharset_arabic_iso8859_6 =
2988 make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
2989 1, 1, 'G', CHARSET_RIGHT_TO_LEFT,
2990 build_string ("ISO8859-6"),
2991 build_string ("ISO8859-6 (Arabic)"),
2992 build_string ("ISO8859-6 (Arabic)"),
2993 build_string ("iso8859-6"),
2994 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
2995 staticpro (&Vcharset_hebrew_iso8859_8);
2996 Vcharset_hebrew_iso8859_8 =
2997 make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
2998 1, 1, 'H', CHARSET_RIGHT_TO_LEFT,
2999 build_string ("ISO8859-8"),
3000 build_string ("ISO8859-8 (Hebrew)"),
3001 build_string ("ISO8859-8 (Hebrew)"),
3002 build_string ("iso8859-8"),
3004 0 /* MIN_CHAR_HEBREW */,
3005 0 /* MAX_CHAR_HEBREW */, 0, 32,
3006 Qnil, CONVERSION_IDENTICAL);
3007 staticpro (&Vcharset_katakana_jisx0201);
3008 Vcharset_katakana_jisx0201 =
3009 make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
3010 1, 1, 'I', CHARSET_LEFT_TO_RIGHT,
3011 build_string ("JISX0201 Kana"),
3012 build_string ("JISX0201.1976 (Japanese Kana)"),
3013 build_string ("JISX0201.1976 Japanese Kana"),
3014 build_string ("jisx0201\\.1976"),
3015 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3016 staticpro (&Vcharset_latin_jisx0201);
3017 Vcharset_latin_jisx0201 =
3018 make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
3019 1, 0, 'J', CHARSET_LEFT_TO_RIGHT,
3020 build_string ("JISX0201 Roman"),
3021 build_string ("JISX0201.1976 (Japanese Roman)"),
3022 build_string ("JISX0201.1976 Japanese Roman"),
3023 build_string ("jisx0201\\.1976"),
3024 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3025 staticpro (&Vcharset_cyrillic_iso8859_5);
3026 Vcharset_cyrillic_iso8859_5 =
3027 make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
3028 1, 1, 'L', CHARSET_LEFT_TO_RIGHT,
3029 build_string ("ISO8859-5"),
3030 build_string ("ISO8859-5 (Cyrillic)"),
3031 build_string ("ISO8859-5 (Cyrillic)"),
3032 build_string ("iso8859-5"),
3033 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
3034 staticpro (&Vcharset_latin_iso8859_9);
3035 Vcharset_latin_iso8859_9 =
3036 make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
3037 1, 1, 'M', CHARSET_LEFT_TO_RIGHT,
3038 build_string ("Latin-5"),
3039 build_string ("ISO8859-9 (Latin-5)"),
3040 build_string ("ISO8859-9 (Latin-5)"),
3041 build_string ("iso8859-9"),
3042 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
3044 staticpro (&Vcharset_jis_x0208);
3045 Vcharset_jis_x0208 =
3046 make_charset (LEADING_BYTE_JIS_X0208,
3047 Qmap_jis_x0208, 94, 2,
3048 2, 0, 'B', CHARSET_LEFT_TO_RIGHT,
3049 build_string ("JIS X0208"),
3050 build_string ("JIS X0208 Common"),
3051 build_string ("JIS X0208 Common part"),
3052 build_string ("jisx0208\\.1990"),
3054 MIN_CHAR_JIS_X0208_1990,
3055 MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33,
3056 Qnil, CONVERSION_94x94);
3058 staticpro (&Vcharset_japanese_jisx0208_1978);
3059 Vcharset_japanese_jisx0208_1978 =
3060 make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
3061 Qmap_jis_x0208_1978, 94, 2,
3062 2, 0, '@', CHARSET_LEFT_TO_RIGHT,
3063 build_string ("JIS X0208:1978"),
3064 build_string ("JIS X0208:1978 (Japanese)"),
3066 ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"),
3067 build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"),
3074 CONVERSION_IDENTICAL);
3075 staticpro (&Vcharset_chinese_gb2312);
3076 Vcharset_chinese_gb2312 =
3077 make_charset (LEADING_BYTE_CHINESE_GB2312, Qmap_gb2312, 94, 2,
3078 2, 0, 'A', CHARSET_LEFT_TO_RIGHT,
3079 build_string ("GB2312"),
3080 build_string ("GB2312)"),
3081 build_string ("GB2312 Chinese simplified"),
3082 build_string ("gb2312"),
3083 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3084 staticpro (&Vcharset_chinese_gb12345);
3085 Vcharset_chinese_gb12345 =
3086 make_charset (LEADING_BYTE_CHINESE_GB12345, Qmap_gb12345, 94, 2,
3087 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3088 build_string ("G1"),
3089 build_string ("GB 12345)"),
3090 build_string ("GB 12345-1990"),
3091 build_string ("GB12345\\(\\.1990\\)?-0"),
3092 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3093 staticpro (&Vcharset_japanese_jisx0208);
3094 Vcharset_japanese_jisx0208 =
3095 make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qmap_jis_x0208_1983, 94, 2,
3096 2, 0, 'B', CHARSET_LEFT_TO_RIGHT,
3097 build_string ("JISX0208"),
3098 build_string ("JIS X0208:1983 (Japanese)"),
3099 build_string ("JIS X0208:1983 Japanese Kanji"),
3100 build_string ("jisx0208\\.1983"),
3107 CONVERSION_IDENTICAL);
3109 staticpro (&Vcharset_japanese_jisx0208_1990);
3110 Vcharset_japanese_jisx0208_1990 =
3111 make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990,
3112 Qmap_jis_x0208_1990, 94, 2,
3113 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3114 build_string ("JISX0208-1990"),
3115 build_string ("JIS X0208:1990 (Japanese)"),
3116 build_string ("JIS X0208:1990 Japanese Kanji"),
3117 build_string ("jisx0208\\.1990"),
3119 0x2121 /* MIN_CHAR_JIS_X0208_1990 */,
3120 0x7426 /* MAX_CHAR_JIS_X0208_1990 */,
3121 0 /* MIN_CHAR_JIS_X0208_1990 */, 33,
3122 Vcharset_jis_x0208 /* Qnil */,
3123 CONVERSION_IDENTICAL /* CONVERSION_94x94 */);
3125 staticpro (&Vcharset_korean_ksc5601);
3126 Vcharset_korean_ksc5601 =
3127 make_charset (LEADING_BYTE_KOREAN_KSC5601, Qmap_ks_x1001, 94, 2,
3128 2, 0, 'C', CHARSET_LEFT_TO_RIGHT,
3129 build_string ("KSC5601"),
3130 build_string ("KSC5601 (Korean"),
3131 build_string ("KSC5601 Korean Hangul and Hanja"),
3132 build_string ("ksc5601"),
3133 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3134 staticpro (&Vcharset_japanese_jisx0212);
3135 Vcharset_japanese_jisx0212 =
3136 make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qmap_jis_x0212, 94, 2,
3137 2, 0, 'D', CHARSET_LEFT_TO_RIGHT,
3138 build_string ("JISX0212"),
3139 build_string ("JISX0212 (Japanese)"),
3140 build_string ("JISX0212 Japanese Supplement"),
3141 build_string ("jisx0212"),
3142 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3144 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
3145 staticpro (&Vcharset_chinese_cns11643_1);
3146 Vcharset_chinese_cns11643_1 =
3147 make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qmap_cns11643_1, 94, 2,
3148 2, 0, 'G', CHARSET_LEFT_TO_RIGHT,
3149 build_string ("CNS11643-1"),
3150 build_string ("CNS11643-1 (Chinese traditional)"),
3152 ("CNS 11643 Plane 1 Chinese traditional"),
3153 build_string (CHINESE_CNS_PLANE_RE("1")),
3154 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3155 staticpro (&Vcharset_chinese_cns11643_2);
3156 Vcharset_chinese_cns11643_2 =
3157 make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qmap_cns11643_2, 94, 2,
3158 2, 0, 'H', CHARSET_LEFT_TO_RIGHT,
3159 build_string ("CNS11643-2"),
3160 build_string ("CNS11643-2 (Chinese traditional)"),
3162 ("CNS 11643 Plane 2 Chinese traditional"),
3163 build_string (CHINESE_CNS_PLANE_RE("2")),
3164 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
3166 staticpro (&Vcharset_latin_tcvn5712);
3167 Vcharset_latin_tcvn5712 =
3168 make_charset (LEADING_BYTE_LATIN_TCVN5712, Qlatin_tcvn5712, 96, 1,
3169 1, 1, 'Z', CHARSET_LEFT_TO_RIGHT,
3170 build_string ("TCVN 5712"),
3171 build_string ("TCVN 5712 (VSCII-2)"),
3172 build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
3173 build_string ("tcvn5712\\(\\.1993\\)?-1"),
3174 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
3175 staticpro (&Vcharset_latin_viscii_lower);
3176 Vcharset_latin_viscii_lower =
3177 make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
3178 1, 1, '1', CHARSET_LEFT_TO_RIGHT,
3179 build_string ("VISCII lower"),
3180 build_string ("VISCII lower (Vietnamese)"),
3181 build_string ("VISCII lower (Vietnamese)"),
3182 build_string ("MULEVISCII-LOWER"),
3183 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
3184 staticpro (&Vcharset_latin_viscii_upper);
3185 Vcharset_latin_viscii_upper =
3186 make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
3187 1, 1, '2', CHARSET_LEFT_TO_RIGHT,
3188 build_string ("VISCII upper"),
3189 build_string ("VISCII upper (Vietnamese)"),
3190 build_string ("VISCII upper (Vietnamese)"),
3191 build_string ("MULEVISCII-UPPER"),
3192 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
3193 staticpro (&Vcharset_latin_viscii);
3194 Vcharset_latin_viscii =
3195 make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
3196 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
3197 build_string ("VISCII"),
3198 build_string ("VISCII 1.1 (Vietnamese)"),
3199 build_string ("VISCII 1.1 (Vietnamese)"),
3200 build_string ("VISCII1\\.1"),
3201 Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
3202 staticpro (&Vcharset_chinese_big5);
3203 Vcharset_chinese_big5 =
3204 make_charset (LEADING_BYTE_CHINESE_BIG5, Qmap_big5, 256, 2,
3205 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
3206 build_string ("Big5"),
3207 build_string ("Big5"),
3208 build_string ("Big5 Chinese traditional"),
3209 build_string ("big5-0"),
3211 MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP,
3212 MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL);
3214 staticpro (&Vcharset_ethiopic_ucs);
3215 Vcharset_ethiopic_ucs =
3216 make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2,
3217 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
3218 build_string ("Ethiopic (UCS)"),
3219 build_string ("Ethiopic (UCS)"),
3220 build_string ("Ethiopic of UCS"),
3221 build_string ("Ethiopic-Unicode"),
3222 Qnil, 0x1200, 0x137F, 0, 0,
3223 Qnil, CONVERSION_IDENTICAL);
3225 staticpro (&Vcharset_chinese_big5_1);
3226 Vcharset_chinese_big5_1 =
3227 make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 94, 2,
3228 2, 0, '0', CHARSET_LEFT_TO_RIGHT,
3229 build_string ("Big5"),
3230 build_string ("Big5 (Level-1)"),
3232 ("Big5 Level-1 Chinese traditional"),
3233 build_string ("big5"),
3234 Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */
3235 Vcharset_chinese_big5, CONVERSION_BIG5_1);
3236 staticpro (&Vcharset_chinese_big5_2);
3237 Vcharset_chinese_big5_2 =
3238 make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
3239 2, 0, '1', CHARSET_LEFT_TO_RIGHT,
3240 build_string ("Big5"),
3241 build_string ("Big5 (Level-2)"),
3243 ("Big5 Level-2 Chinese traditional"),
3244 build_string ("big5"),
3245 Qnil, 0, 0, 0, 33, /* Qnil, CONVERSION_IDENTICAL */
3246 Vcharset_chinese_big5, CONVERSION_BIG5_2);
3248 #ifdef ENABLE_COMPOSITE_CHARS
3249 /* #### For simplicity, we put composite chars into a 96x96 charset.
3250 This is going to lead to problems because you can run out of
3251 room, esp. as we don't yet recycle numbers. */
3252 staticpro (&Vcharset_composite);
3253 Vcharset_composite =
3254 make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 96, 2,
3255 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
3256 build_string ("Composite"),
3257 build_string ("Composite characters"),
3258 build_string ("Composite characters"),
3261 /* #### not dumped properly */
3262 composite_char_row_next = 32;
3263 composite_char_col_next = 32;
3265 Vcomposite_char_string2char_hash_table =
3266 make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
3267 Vcomposite_char_char2string_hash_table =
3268 make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
3269 staticpro (&Vcomposite_char_string2char_hash_table);
3270 staticpro (&Vcomposite_char_char2string_hash_table);
3271 #endif /* ENABLE_COMPOSITE_CHARS */