1 /* Basic character set support.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 2006 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H14PRO021
7 Copyright (C) 2003, 2004
8 National Institute of Advanced Industrial Science and Technology (AIST)
9 Registration Number H13PRO009
11 This file is part of GNU Emacs.
13 GNU Emacs is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2, or (at your option)
18 GNU Emacs is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GNU Emacs; see the file COPYING. If not, write to
25 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26 Boston, MA 02110-1301, USA. */
33 #include <sys/types.h>
35 #include "character.h"
41 /*** GENERAL NOTES on CODED CHARACTER SETS (CHARSETS) ***
43 A coded character set ("charset" hereafter) is a meaningful
44 collection (i.e. language, culture, functionality, etc.) of
45 characters. Emacs handles multiple charsets at once. In Emacs Lisp
46 code, a charset is represented by a symbol. In C code, a charset is
47 represented by its ID number or by a pointer to a struct charset.
49 The actual information about each charset is stored in two places.
50 Lispy information is stored in the hash table Vcharset_hash_table as
51 a vector (charset attributes). The other information is stored in
52 charset_table as a struct charset.
56 /* List of all charsets. This variable is used only from Emacs
58 Lisp_Object Vcharset_list
;
60 /* Hash table that contains attributes of each charset. Keys are
61 charset symbols, and values are vectors of charset attributes. */
62 Lisp_Object Vcharset_hash_table
;
64 /* Table of struct charset. */
65 struct charset
*charset_table
;
67 static int charset_table_size
;
68 static int charset_table_used
;
70 Lisp_Object Qcharsetp
;
72 /* Special charset symbols. */
74 Lisp_Object Qeight_bit
;
75 Lisp_Object Qiso_8859_1
;
78 /* The corresponding charsets. */
80 int charset_eight_bit
;
81 int charset_iso_8859_1
;
84 /* The other special charsets. */
85 int charset_jisx0201_roman
;
86 int charset_jisx0208_1978
;
89 /* Value of charset attribute `charset-iso-plane'. */
92 /* Charset of unibyte characters. */
95 /* List of charsets ordered by the priority. */
96 Lisp_Object Vcharset_ordered_list
;
98 /* Incremented everytime we change Vcharset_ordered_list. This is
99 unsigned short so that it fits in Lisp_Int and never matches
101 unsigned short charset_ordered_list_tick
;
103 /* List of iso-2022 charsets. */
104 Lisp_Object Viso_2022_charset_list
;
106 /* List of emacs-mule charsets. */
107 Lisp_Object Vemacs_mule_charset_list
;
109 struct charset
*emacs_mule_charset
[256];
111 /* Mapping table from ISO2022's charset (specified by DIMENSION,
112 CHARS, and FINAL-CHAR) to Emacs' charset. */
113 int iso_charset_table
[ISO_MAX_DIMENSION
][ISO_MAX_CHARS
][ISO_MAX_FINAL
];
115 Lisp_Object Vcharset_map_path
;
117 Lisp_Object Vchar_unified_charset_table
;
119 /* Defined in chartab.c */
121 map_char_table_for_charset
P_ ((void (*c_function
) (Lisp_Object
, Lisp_Object
),
122 Lisp_Object function
, Lisp_Object table
,
123 Lisp_Object arg
, struct charset
*charset
,
124 unsigned from
, unsigned to
));
126 #define CODE_POINT_TO_INDEX(charset, code) \
127 ((charset)->code_linear_p \
128 ? (code) - (charset)->min_code \
129 : (((charset)->code_space_mask[(code) >> 24] & 0x8) \
130 && ((charset)->code_space_mask[((code) >> 16) & 0xFF] & 0x4) \
131 && ((charset)->code_space_mask[((code) >> 8) & 0xFF] & 0x2) \
132 && ((charset)->code_space_mask[(code) & 0xFF] & 0x1)) \
133 ? (((((code) >> 24) - (charset)->code_space[12]) \
134 * (charset)->code_space[11]) \
135 + (((((code) >> 16) & 0xFF) - (charset)->code_space[8]) \
136 * (charset)->code_space[7]) \
137 + (((((code) >> 8) & 0xFF) - (charset)->code_space[4]) \
138 * (charset)->code_space[3]) \
139 + (((code) & 0xFF) - (charset)->code_space[0]) \
140 - ((charset)->char_index_offset)) \
144 /* Convert the character index IDX to code-point CODE for CHARSET.
145 It is assumed that IDX is in a valid range. */
147 #define INDEX_TO_CODE_POINT(charset, idx) \
148 ((charset)->code_linear_p \
149 ? (idx) + (charset)->min_code \
150 : (idx += (charset)->char_index_offset, \
151 (((charset)->code_space[0] + (idx) % (charset)->code_space[2]) \
152 | (((charset)->code_space[4] \
153 + ((idx) / (charset)->code_space[3] % (charset)->code_space[6])) \
155 | (((charset)->code_space[8] \
156 + ((idx) / (charset)->code_space[7] % (charset)->code_space[10])) \
158 | (((charset)->code_space[12] + ((idx) / (charset)->code_space[11])) \
164 /* Set to 1 to warn that a charset map is loaded and thus a buffer
165 text and a string data may be relocated. */
166 int charset_map_loaded
;
168 struct charset_map_entries
174 struct charset_map_entries
*next
;
177 /* Load the mapping information for CHARSET from ENTRIES.
179 If CONTROL_FLAG is 0, setup CHARSET->min_char and CHARSET->max_char.
181 If CONTROL_FLAG is 1, setup CHARSET->min_char, CHARSET->max_char,
182 CHARSET->decoder, and CHARSET->encoder.
184 If CONTROL_FLAG is 2, setup CHARSET->deunifier and
185 Vchar_unify_table. If Vchar_unified_charset_table is non-nil,
189 load_charset_map (charset
, entries
, n_entries
, control_flag
)
190 struct charset
*charset
;
191 struct charset_map_entries
*entries
;
195 Lisp_Object vec
, table
;
196 unsigned max_code
= CHARSET_MAX_CODE (charset
);
197 int ascii_compatible_p
= charset
->ascii_compatible_p
;
198 int min_char
, max_char
, nonascii_min_char
;
200 unsigned char *fast_map
= charset
->fast_map
;
205 if (control_flag
> 0)
207 int n
= CODE_POINT_TO_INDEX (charset
, max_code
) + 1;
209 table
= Fmake_char_table (Qnil
, Qnil
);
210 if (control_flag
== 1)
211 vec
= Fmake_vector (make_number (n
), make_number (-1));
212 else if (! CHAR_TABLE_P (Vchar_unify_table
))
213 Vchar_unify_table
= Fmake_char_table (Qnil
, Qnil
);
215 charset_map_loaded
= 1;
218 min_char
= max_char
= entries
->entry
[0].c
;
219 nonascii_min_char
= MAX_CHAR
;
220 for (i
= 0; i
< n_entries
; i
++)
223 int from_index
, to_index
;
225 int idx
= i
% 0x10000;
227 if (i
> 0 && idx
== 0)
228 entries
= entries
->next
;
229 from
= entries
->entry
[idx
].from
;
230 to
= entries
->entry
[idx
].to
;
231 from_c
= entries
->entry
[idx
].c
;
232 from_index
= CODE_POINT_TO_INDEX (charset
, from
);
235 to_index
= from_index
;
240 to_index
= CODE_POINT_TO_INDEX (charset
, to
);
241 to_c
= from_c
+ (to_index
- from_index
);
243 if (from_index
< 0 || to_index
< 0)
246 if (control_flag
< 2)
252 else if (from_c
< min_char
)
254 if (ascii_compatible_p
)
256 if (! ASCII_BYTE_P (from_c
))
258 if (from_c
< nonascii_min_char
)
259 nonascii_min_char
= from_c
;
261 else if (! ASCII_BYTE_P (to_c
))
263 nonascii_min_char
= 0x80;
267 for (c
= from_c
; c
<= to_c
; c
++)
268 CHARSET_FAST_MAP_SET (c
, fast_map
);
270 if (control_flag
== 1)
272 unsigned code
= from
;
274 if (CHARSET_COMPACT_CODES_P (charset
))
277 ASET (vec
, from_index
, make_number (from_c
));
278 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
279 CHAR_TABLE_SET (table
, from_c
, make_number (code
));
280 if (from_index
== to_index
)
282 from_index
++, from_c
++;
283 code
= INDEX_TO_CODE_POINT (charset
, from_index
);
286 for (; from_index
<= to_index
; from_index
++, from_c
++)
288 ASET (vec
, from_index
, make_number (from_c
));
289 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
290 CHAR_TABLE_SET (table
, from_c
, make_number (from_index
));
296 unsigned code
= from
;
300 int c1
= DECODE_CHAR (charset
, code
);
304 CHAR_TABLE_SET (table
, from_c
, make_number (c1
));
305 CHAR_TABLE_SET (Vchar_unify_table
, c1
, make_number (from_c
));
306 if (CHAR_TABLE_P (Vchar_unified_charset_table
))
307 CHAR_TABLE_SET (Vchar_unified_charset_table
, c1
,
308 CHARSET_NAME (charset
));
310 if (from_index
== to_index
)
312 from_index
++, from_c
++;
313 code
= INDEX_TO_CODE_POINT (charset
, from_index
);
318 if (control_flag
< 2)
320 CHARSET_MIN_CHAR (charset
) = (ascii_compatible_p
321 ? nonascii_min_char
: min_char
);
322 CHARSET_MAX_CHAR (charset
) = max_char
;
323 if (control_flag
== 1)
325 CHARSET_DECODER (charset
) = vec
;
326 CHARSET_ENCODER (charset
) = table
;
330 CHARSET_DEUNIFIER (charset
) = table
;
334 /* Read a hexadecimal number (preceded by "0x") from the file FP while
335 paying attention to comment charcter '#'. */
337 static INLINE
unsigned
345 while ((c
= getc (fp
)) != EOF
)
349 while ((c
= getc (fp
)) != EOF
&& c
!= '\n');
353 if ((c
= getc (fp
)) == EOF
|| c
== 'x')
365 while ((c
= getc (fp
)) != EOF
&& isxdigit (c
))
367 | (c
<= '9' ? c
- '0' : c
<= 'F' ? c
- 'A' + 10 : c
- 'a' + 10));
369 while ((c
= getc (fp
)) != EOF
&& isdigit (c
))
370 n
= (n
* 10) + c
- '0';
377 /* Return a mapping vector for CHARSET loaded from MAPFILE.
378 Each line of MAPFILE has this form
380 where 0xAAAA is a code-point and 0xCCCC is the corresponding
381 character code, or this form
383 where 0xAAAA and 0xBBBB are code-points specifying a range, and
384 0xCCCC is the first character code of the range.
386 The returned vector has this form:
387 [ CODE1 CHAR1 CODE2 CHAR2 .... ]
388 where CODE1 is a code-point or a cons of code-points specifying a
391 extern void add_to_log
P_ ((char *, Lisp_Object
, Lisp_Object
));
394 load_charset_map_from_file (charset
, mapfile
, control_flag
)
395 struct charset
*charset
;
399 unsigned min_code
= CHARSET_MIN_CODE (charset
);
400 unsigned max_code
= CHARSET_MAX_CODE (charset
);
404 Lisp_Object suffixes
;
405 struct charset_map_entries
*head
, *entries
;
408 suffixes
= Fcons (build_string (".map"),
409 Fcons (build_string (".TXT"), Qnil
));
411 fd
= openp (Vcharset_map_path
, mapfile
, suffixes
, NULL
, Qnil
);
413 || ! (fp
= fdopen (fd
, "r")))
415 add_to_log ("Failure in loading charset map: %S", mapfile
, Qnil
);
419 head
= entries
= ((struct charset_map_entries
*)
420 alloca (sizeof (struct charset_map_entries
)));
429 from
= read_hex (fp
, &eof
);
432 if (getc (fp
) == '-')
433 to
= read_hex (fp
, &eof
);
436 c
= (int) read_hex (fp
, &eof
);
438 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
441 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
443 entries
->next
= ((struct charset_map_entries
*)
444 alloca (sizeof (struct charset_map_entries
)));
445 entries
= entries
->next
;
447 idx
= n_entries
% 0x10000;
448 entries
->entry
[idx
].from
= from
;
449 entries
->entry
[idx
].to
= to
;
450 entries
->entry
[idx
].c
= c
;
456 load_charset_map (charset
, head
, n_entries
, control_flag
);
460 load_charset_map_from_vector (charset
, vec
, control_flag
)
461 struct charset
*charset
;
465 unsigned min_code
= CHARSET_MIN_CODE (charset
);
466 unsigned max_code
= CHARSET_MAX_CODE (charset
);
467 struct charset_map_entries
*head
, *entries
;
469 int len
= ASIZE (vec
);
474 add_to_log ("Failure in loading charset map: %V", vec
, Qnil
);
478 head
= entries
= ((struct charset_map_entries
*)
479 alloca (sizeof (struct charset_map_entries
)));
481 for (i
= 0; i
< len
; i
+= 2)
483 Lisp_Object val
, val2
;
495 from
= XFASTINT (val
);
496 to
= XFASTINT (val2
);
501 from
= to
= XFASTINT (val
);
503 val
= AREF (vec
, i
+ 1);
507 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
510 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
512 entries
->next
= ((struct charset_map_entries
*)
513 alloca (sizeof (struct charset_map_entries
)));
514 entries
= entries
->next
;
516 idx
= n_entries
% 0x10000;
517 entries
->entry
[idx
].from
= from
;
518 entries
->entry
[idx
].to
= to
;
519 entries
->entry
[idx
].c
= c
;
523 load_charset_map (charset
, head
, n_entries
, control_flag
);
527 load_charset (charset
)
528 struct charset
*charset
;
530 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP_DEFERRED
)
534 map
= CHARSET_MAP (charset
);
536 load_charset_map_from_file (charset
, map
, 1);
538 load_charset_map_from_vector (charset
, map
, 1);
539 CHARSET_METHOD (charset
) = CHARSET_METHOD_MAP
;
544 DEFUN ("charsetp", Fcharsetp
, Scharsetp
, 1, 1, 0,
545 doc
: /* Return non-nil if and only if OBJECT is a charset.*/)
549 return (CHARSETP (object
) ? Qt
: Qnil
);
554 map_charset_chars (c_function
, function
, arg
,
556 void (*c_function
) P_ ((Lisp_Object
, Lisp_Object
));
557 Lisp_Object function
, arg
;
558 struct charset
*charset
;
564 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP_DEFERRED
)
565 load_charset (charset
);
567 partial
= (from
> CHARSET_MIN_CODE (charset
)
568 || to
< CHARSET_MAX_CODE (charset
));
570 if (CHARSET_UNIFIED_P (charset
)
571 && CHAR_TABLE_P (CHARSET_DEUNIFIER (charset
)))
573 map_char_table_for_charset (c_function
, function
,
574 CHARSET_DEUNIFIER (charset
), arg
,
575 partial
? charset
: NULL
, from
, to
);
578 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_OFFSET
)
580 int from_idx
= CODE_POINT_TO_INDEX (charset
, from
);
581 int to_idx
= CODE_POINT_TO_INDEX (charset
, to
);
582 int from_c
= from_idx
+ CHARSET_CODE_OFFSET (charset
);
583 int to_c
= to_idx
+ CHARSET_CODE_OFFSET (charset
);
585 range
= Fcons (make_number (from_c
), make_number (to_c
));
587 (*c_function
) (arg
, range
);
589 call2 (function
, range
, arg
);
591 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
593 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
595 if (CHARSET_ASCII_COMPATIBLE_P (charset
) && from
<= 127)
597 range
= Fcons (make_number (from
), make_number (to
));
599 XSETCAR (range
, make_number (127));
602 (*c_function
) (arg
, range
);
604 call2 (function
, range
, arg
);
606 map_char_table_for_charset (c_function
, function
,
607 CHARSET_ENCODER (charset
), arg
,
608 partial
? charset
: NULL
, from
, to
);
610 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_SUBSET
)
612 Lisp_Object subset_info
;
615 subset_info
= CHARSET_SUBSET (charset
);
616 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
617 offset
= XINT (AREF (subset_info
, 3));
619 if (from
< XFASTINT (AREF (subset_info
, 1)))
620 from
= XFASTINT (AREF (subset_info
, 1));
622 if (to
> XFASTINT (AREF (subset_info
, 2)))
623 to
= XFASTINT (AREF (subset_info
, 2));
624 map_charset_chars (c_function
, function
, arg
, charset
, from
, to
);
626 else /* i.e. CHARSET_METHOD_SUPERSET */
630 for (parents
= CHARSET_SUPERSET (charset
); CONSP (parents
);
631 parents
= XCDR (parents
))
634 unsigned this_from
, this_to
;
636 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents
))));
637 offset
= XINT (XCDR (XCAR (parents
)));
638 this_from
= from
- offset
;
639 this_to
= to
- offset
;
640 if (this_from
< CHARSET_MIN_CODE (charset
))
641 this_from
= CHARSET_MIN_CODE (charset
);
642 if (this_to
> CHARSET_MAX_CODE (charset
))
643 this_to
= CHARSET_MAX_CODE (charset
);
644 map_charset_chars (c_function
, function
, arg
, charset
,
650 DEFUN ("map-charset-chars", Fmap_charset_chars
, Smap_charset_chars
, 2, 5, 0,
651 doc
: /* Call FUNCTION for all characters in CHARSET.
652 FUNCTION is called with an argument RANGE and the optional 3rd
655 RANGE is a cons (FROM . TO), where FROM and TO indicate a range of
656 characters contained in CHARSET.
658 The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the
659 range of code points of target characters. */)
660 (function
, charset
, arg
, from_code
, to_code
)
661 Lisp_Object function
, charset
, arg
, from_code
, to_code
;
666 CHECK_CHARSET_GET_CHARSET (charset
, cs
);
667 if (NILP (from_code
))
668 from
= CHARSET_MIN_CODE (cs
);
671 CHECK_NATNUM (from_code
);
672 from
= XINT (from_code
);
673 if (from
< CHARSET_MIN_CODE (cs
))
674 from
= CHARSET_MIN_CODE (cs
);
677 to
= CHARSET_MAX_CODE (cs
);
680 CHECK_NATNUM (to_code
);
682 if (to
> CHARSET_MAX_CODE (cs
))
683 to
= CHARSET_MAX_CODE (cs
);
685 map_charset_chars (NULL
, function
, arg
, cs
, from
, to
);
690 /* Define a charset according to the arguments. The Nth argument is
691 the Nth attribute of the charset (the last attribute `charset-id'
692 is not included). See the docstring of `define-charset' for the
695 DEFUN ("define-charset-internal", Fdefine_charset_internal
,
696 Sdefine_charset_internal
, charset_arg_max
, MANY
, 0,
697 doc
: /* For internal use only.
698 usage: (define-charset-internal ...) */)
703 /* Charset attr vector. */
707 struct Lisp_Hash_Table
*hash_table
= XHASH_TABLE (Vcharset_hash_table
);
709 struct charset charset
;
712 int new_definition_p
;
715 if (nargs
!= charset_arg_max
)
716 return Fsignal (Qwrong_number_of_arguments
,
717 Fcons (intern ("define-charset-internal"),
718 make_number (nargs
)));
720 attrs
= Fmake_vector (make_number (charset_attr_max
), Qnil
);
722 CHECK_SYMBOL (args
[charset_arg_name
]);
723 ASET (attrs
, charset_name
, args
[charset_arg_name
]);
725 val
= args
[charset_arg_code_space
];
726 for (i
= 0, dimension
= 0, nchars
= 1; i
< 4; i
++)
728 int min_byte
, max_byte
;
730 min_byte
= XINT (Faref (val
, make_number (i
* 2)));
731 max_byte
= XINT (Faref (val
, make_number (i
* 2 + 1)));
732 if (min_byte
< 0 || min_byte
> max_byte
|| max_byte
>= 256)
733 error ("Invalid :code-space value");
734 charset
.code_space
[i
* 4] = min_byte
;
735 charset
.code_space
[i
* 4 + 1] = max_byte
;
736 charset
.code_space
[i
* 4 + 2] = max_byte
- min_byte
+ 1;
737 nchars
*= charset
.code_space
[i
* 4 + 2];
738 charset
.code_space
[i
* 4 + 3] = nchars
;
743 val
= args
[charset_arg_dimension
];
745 charset
.dimension
= dimension
;
749 charset
.dimension
= XINT (val
);
750 if (charset
.dimension
< 1 || charset
.dimension
> 4)
751 args_out_of_range_3 (val
, make_number (1), make_number (4));
754 charset
.code_linear_p
755 = (charset
.dimension
== 1
756 || (charset
.code_space
[2] == 256
757 && (charset
.dimension
== 2
758 || (charset
.code_space
[6] == 256
759 && (charset
.dimension
== 3
760 || charset
.code_space
[10] == 256)))));
762 if (! charset
.code_linear_p
)
764 charset
.code_space_mask
= (unsigned char *) xmalloc (256);
765 bzero (charset
.code_space_mask
, 256);
766 for (i
= 0; i
< 4; i
++)
767 for (j
= charset
.code_space
[i
* 4]; j
<= charset
.code_space
[i
* 4 + 1];
769 charset
.code_space_mask
[j
] |= (1 << i
);
772 charset
.iso_chars_96
= charset
.code_space
[2] == 96;
774 charset
.min_code
= (charset
.code_space
[0]
775 | (charset
.code_space
[4] << 8)
776 | (charset
.code_space
[8] << 16)
777 | (charset
.code_space
[12] << 24));
778 charset
.max_code
= (charset
.code_space
[1]
779 | (charset
.code_space
[5] << 8)
780 | (charset
.code_space
[9] << 16)
781 | (charset
.code_space
[13] << 24));
782 charset
.char_index_offset
= 0;
784 val
= args
[charset_arg_min_code
];
794 CHECK_NUMBER_CAR (val
);
795 CHECK_NUMBER_CDR (val
);
796 code
= (XINT (XCAR (val
)) << 16) | (XINT (XCDR (val
)));
798 if (code
< charset
.min_code
799 || code
> charset
.max_code
)
800 args_out_of_range_3 (make_number (charset
.min_code
),
801 make_number (charset
.max_code
), val
);
802 charset
.char_index_offset
= CODE_POINT_TO_INDEX (&charset
, code
);
803 charset
.min_code
= code
;
806 val
= args
[charset_arg_max_code
];
816 CHECK_NUMBER_CAR (val
);
817 CHECK_NUMBER_CDR (val
);
818 code
= (XINT (XCAR (val
)) << 16) | (XINT (XCDR (val
)));
820 if (code
< charset
.min_code
821 || code
> charset
.max_code
)
822 args_out_of_range_3 (make_number (charset
.min_code
),
823 make_number (charset
.max_code
), val
);
824 charset
.max_code
= code
;
827 charset
.compact_codes_p
= charset
.max_code
< 0x1000000;
829 val
= args
[charset_arg_invalid_code
];
832 if (charset
.min_code
> 0)
833 charset
.invalid_code
= 0;
836 XSETINT (val
, charset
.max_code
+ 1);
837 if (XINT (val
) == charset
.max_code
+ 1)
838 charset
.invalid_code
= charset
.max_code
+ 1;
840 error ("Attribute :invalid-code must be specified");
846 charset
.invalid_code
= XFASTINT (val
);
849 val
= args
[charset_arg_iso_final
];
851 charset
.iso_final
= -1;
855 if (XINT (val
) < '0' || XINT (val
) > 127)
856 error ("Invalid iso-final-char: %d", XINT (val
));
857 charset
.iso_final
= XINT (val
);
860 val
= args
[charset_arg_iso_revision
];
862 charset
.iso_revision
= -1;
867 args_out_of_range (make_number (63), val
);
868 charset
.iso_revision
= XINT (val
);
871 val
= args
[charset_arg_emacs_mule_id
];
873 charset
.emacs_mule_id
= -1;
877 if ((XINT (val
) > 0 && XINT (val
) <= 128) || XINT (val
) >= 256)
878 error ("Invalid emacs-mule-id: %d", XINT (val
));
879 charset
.emacs_mule_id
= XINT (val
);
882 charset
.ascii_compatible_p
= ! NILP (args
[charset_arg_ascii_compatible_p
]);
884 charset
.supplementary_p
= ! NILP (args
[charset_arg_supplementary_p
]);
886 charset
.unified_p
= 0;
888 bzero (charset
.fast_map
, sizeof (charset
.fast_map
));
890 if (! NILP (args
[charset_arg_code_offset
]))
892 val
= args
[charset_arg_code_offset
];
895 charset
.method
= CHARSET_METHOD_OFFSET
;
896 charset
.code_offset
= XINT (val
);
898 i
= CODE_POINT_TO_INDEX (&charset
, charset
.min_code
);
899 charset
.min_char
= i
+ charset
.code_offset
;
900 i
= CODE_POINT_TO_INDEX (&charset
, charset
.max_code
);
901 charset
.max_char
= i
+ charset
.code_offset
;
902 if (charset
.max_char
> MAX_CHAR
)
903 error ("Unsupported max char: %d", charset
.max_char
);
905 i
= (charset
.min_char
>> 7) << 7;
906 for (; i
< 0x10000 && i
<= charset
.max_char
; i
+= 128)
907 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
909 for (; i
<= charset
.max_char
; i
+= 0x1000)
910 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
912 else if (! NILP (args
[charset_arg_map
]))
914 val
= args
[charset_arg_map
];
915 ASET (attrs
, charset_map
, val
);
917 load_charset_map_from_file (&charset
, val
, 0);
919 load_charset_map_from_vector (&charset
, val
, 0);
920 charset
.method
= CHARSET_METHOD_MAP_DEFERRED
;
922 else if (! NILP (args
[charset_arg_subset
]))
925 Lisp_Object parent_min_code
, parent_max_code
, parent_code_offset
;
926 struct charset
*parent_charset
;
928 val
= args
[charset_arg_subset
];
930 CHECK_CHARSET_GET_CHARSET (parent
, parent_charset
);
931 parent_min_code
= Fnth (make_number (1), val
);
932 CHECK_NATNUM (parent_min_code
);
933 parent_max_code
= Fnth (make_number (2), val
);
934 CHECK_NATNUM (parent_max_code
);
935 parent_code_offset
= Fnth (make_number (3), val
);
936 CHECK_NUMBER (parent_code_offset
);
937 val
= Fmake_vector (make_number (4), Qnil
);
938 ASET (val
, 0, make_number (parent_charset
->id
));
939 ASET (val
, 1, parent_min_code
);
940 ASET (val
, 2, parent_max_code
);
941 ASET (val
, 3, parent_code_offset
);
942 ASET (attrs
, charset_subset
, val
);
944 charset
.method
= CHARSET_METHOD_SUBSET
;
945 /* Here, we just copy the parent's fast_map. It's not accurate,
946 but at least it works for quickly detecting which character
947 DOESN'T belong to this charset. */
948 for (i
= 0; i
< 190; i
++)
949 charset
.fast_map
[i
] = parent_charset
->fast_map
[i
];
951 /* We also copy these for parents. */
952 charset
.min_char
= parent_charset
->min_char
;
953 charset
.max_char
= parent_charset
->max_char
;
955 else if (! NILP (args
[charset_arg_superset
]))
957 val
= args
[charset_arg_superset
];
958 charset
.method
= CHARSET_METHOD_SUPERSET
;
959 val
= Fcopy_sequence (val
);
960 ASET (attrs
, charset_superset
, val
);
962 charset
.min_char
= MAX_CHAR
;
963 charset
.max_char
= 0;
964 for (; ! NILP (val
); val
= Fcdr (val
))
966 Lisp_Object elt
, car_part
, cdr_part
;
968 struct charset
*this_charset
;
973 car_part
= XCAR (elt
);
974 cdr_part
= XCDR (elt
);
975 CHECK_CHARSET_GET_ID (car_part
, this_id
);
976 CHECK_NUMBER (cdr_part
);
977 offset
= XINT (cdr_part
);
981 CHECK_CHARSET_GET_ID (elt
, this_id
);
984 XSETCAR (val
, Fcons (make_number (this_id
), make_number (offset
)));
986 this_charset
= CHARSET_FROM_ID (this_id
);
987 if (charset
.min_char
> this_charset
->min_char
)
988 charset
.min_char
= this_charset
->min_char
;
989 if (charset
.max_char
< this_charset
->max_char
)
990 charset
.max_char
= this_charset
->max_char
;
991 for (i
= 0; i
< 190; i
++)
992 charset
.fast_map
[i
] |= this_charset
->fast_map
[i
];
996 error ("None of :code-offset, :map, :parents are specified");
998 val
= args
[charset_arg_unify_map
];
999 if (! NILP (val
) && !STRINGP (val
))
1001 ASET (attrs
, charset_unify_map
, val
);
1003 CHECK_LIST (args
[charset_arg_plist
]);
1004 ASET (attrs
, charset_plist
, args
[charset_arg_plist
]);
1006 charset
.hash_index
= hash_lookup (hash_table
, args
[charset_arg_name
],
1008 if (charset
.hash_index
>= 0)
1010 new_definition_p
= 0;
1011 id
= XFASTINT (CHARSET_SYMBOL_ID (args
[charset_arg_name
]));
1012 HASH_VALUE (hash_table
, charset
.hash_index
) = attrs
;
1016 charset
.hash_index
= hash_put (hash_table
, args
[charset_arg_name
], attrs
,
1018 if (charset_table_used
== charset_table_size
)
1020 struct charset
*new_table
1021 = (struct charset
*) xmalloc (sizeof (struct charset
)
1022 * (charset_table_size
+ 16));
1023 bcopy (charset_table
, new_table
,
1024 sizeof (struct charset
) * charset_table_size
);
1025 charset_table_size
+= 16;
1026 charset_table
= new_table
;
1028 id
= charset_table_used
++;
1029 new_definition_p
= 1;
1032 ASET (attrs
, charset_id
, make_number (id
));
1034 charset_table
[id
] = charset
;
1036 if (charset
.iso_final
>= 0)
1038 ISO_CHARSET_TABLE (charset
.dimension
, charset
.iso_chars_96
,
1039 charset
.iso_final
) = id
;
1040 if (new_definition_p
)
1041 Viso_2022_charset_list
= nconc2 (Viso_2022_charset_list
,
1042 Fcons (make_number (id
), Qnil
));
1043 if (ISO_CHARSET_TABLE (1, 0, 'J') == id
)
1044 charset_jisx0201_roman
= id
;
1045 else if (ISO_CHARSET_TABLE (2, 0, '@') == id
)
1046 charset_jisx0208_1978
= id
;
1047 else if (ISO_CHARSET_TABLE (2, 0, 'B') == id
)
1048 charset_jisx0208
= id
;
1051 if (charset
.emacs_mule_id
>= 0)
1053 emacs_mule_charset
[charset
.emacs_mule_id
] = CHARSET_FROM_ID (id
);
1054 if (charset
.emacs_mule_id
< 0xA0)
1055 emacs_mule_bytes
[charset
.emacs_mule_id
] = charset
.dimension
+ 1;
1056 if (new_definition_p
)
1057 Vemacs_mule_charset_list
= nconc2 (Vemacs_mule_charset_list
,
1058 Fcons (make_number (id
), Qnil
));
1061 if (new_definition_p
)
1063 Vcharset_list
= Fcons (args
[charset_arg_name
], Vcharset_list
);
1064 Vcharset_ordered_list
= nconc2 (Vcharset_ordered_list
,
1065 Fcons (make_number (id
), Qnil
));
1066 charset_ordered_list_tick
++;
1073 /* Same as Fdefine_charset_internal but arguments are more convenient
1074 to call from C (typically in syms_of_charset). This can define a
1075 charset of `offset' method only. Return the ID of the new
1079 define_charset_internal (name
, dimension
, code_space
, min_code
, max_code
,
1080 iso_final
, iso_revision
, emacs_mule_id
,
1081 ascii_compatible
, supplementary
,
1085 unsigned char *code_space
;
1086 unsigned min_code
, max_code
;
1087 int iso_final
, iso_revision
, emacs_mule_id
;
1088 int ascii_compatible
, supplementary
;
1091 Lisp_Object args
[charset_arg_max
];
1092 Lisp_Object plist
[14];
1096 args
[charset_arg_name
] = name
;
1097 args
[charset_arg_dimension
] = make_number (dimension
);
1098 val
= Fmake_vector (make_number (8), make_number (0));
1099 for (i
= 0; i
< 8; i
++)
1100 ASET (val
, i
, make_number (code_space
[i
]));
1101 args
[charset_arg_code_space
] = val
;
1102 args
[charset_arg_min_code
] = make_number (min_code
);
1103 args
[charset_arg_max_code
] = make_number (max_code
);
1104 args
[charset_arg_iso_final
]
1105 = (iso_final
< 0 ? Qnil
: make_number (iso_final
));
1106 args
[charset_arg_iso_revision
] = make_number (iso_revision
);
1107 args
[charset_arg_emacs_mule_id
]
1108 = (emacs_mule_id
< 0 ? Qnil
: make_number (emacs_mule_id
));
1109 args
[charset_arg_ascii_compatible_p
] = ascii_compatible
? Qt
: Qnil
;
1110 args
[charset_arg_supplementary_p
] = supplementary
? Qt
: Qnil
;
1111 args
[charset_arg_invalid_code
] = Qnil
;
1112 args
[charset_arg_code_offset
] = make_number (code_offset
);
1113 args
[charset_arg_map
] = Qnil
;
1114 args
[charset_arg_subset
] = Qnil
;
1115 args
[charset_arg_superset
] = Qnil
;
1116 args
[charset_arg_unify_map
] = Qnil
;
1118 plist
[0] = intern (":name");
1119 plist
[1] = args
[charset_arg_name
];
1120 plist
[2] = intern (":dimension");
1121 plist
[3] = args
[charset_arg_dimension
];
1122 plist
[4] = intern (":code-space");
1123 plist
[5] = args
[charset_arg_code_space
];
1124 plist
[6] = intern (":iso-final-char");
1125 plist
[7] = args
[charset_arg_iso_final
];
1126 plist
[8] = intern (":emacs-mule-id");
1127 plist
[9] = args
[charset_arg_emacs_mule_id
];
1128 plist
[10] = intern (":ascii-compatible-p");
1129 plist
[11] = args
[charset_arg_ascii_compatible_p
];
1130 plist
[12] = intern (":code-offset");
1131 plist
[13] = args
[charset_arg_code_offset
];
1133 args
[charset_arg_plist
] = Flist (14, plist
);
1134 Fdefine_charset_internal (charset_arg_max
, args
);
1136 return XINT (CHARSET_SYMBOL_ID (name
));
1140 DEFUN ("define-charset-alias", Fdefine_charset_alias
,
1141 Sdefine_charset_alias
, 2, 2, 0,
1142 doc
: /* Define ALIAS as an alias for charset CHARSET. */)
1144 Lisp_Object alias
, charset
;
1148 CHECK_CHARSET_GET_ATTR (charset
, attr
);
1149 Fputhash (alias
, attr
, Vcharset_hash_table
);
1150 Vcharset_list
= Fcons (alias
, Vcharset_list
);
1155 DEFUN ("unibyte-charset", Funibyte_charset
, Sunibyte_charset
, 0, 0, 0,
1156 doc
: /* Return the unibyte charset (set by `set-unibyte-charset'). */)
1159 return CHARSET_NAME (CHARSET_FROM_ID (charset_unibyte
));
1163 DEFUN ("set-unibyte-charset", Fset_unibyte_charset
, Sset_unibyte_charset
,
1165 doc
: /* Set the unibyte charset to CHARSET.
1166 This determines how unibyte/multibyte conversion is done. See also
1167 function `unibyte-charset'. */)
1169 Lisp_Object charset
;
1174 CHECK_CHARSET_GET_CHARSET (charset
, cs
);
1175 if (! cs
->ascii_compatible_p
1176 || cs
->dimension
!= 1)
1177 error ("Inappropriate unibyte charset: %s", SDATA (SYMBOL_NAME (charset
)));
1178 charset_unibyte
= cs
->id
;
1179 memset (unibyte_has_multibyte_table
, 1, 128);
1180 for (i
= 128; i
< 256; i
++)
1182 c
= DECODE_CHAR (cs
, i
);
1183 unibyte_to_multibyte_table
[i
] = (c
< 0 ? BYTE8_TO_CHAR (i
) : c
);
1184 unibyte_has_multibyte_table
[i
] = c
>= 0;
1191 DEFUN ("charset-plist", Fcharset_plist
, Scharset_plist
, 1, 1, 0,
1192 doc
: /* Return the property list of CHARSET. */)
1194 Lisp_Object charset
;
1198 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1199 return CHARSET_ATTR_PLIST (attrs
);
1203 DEFUN ("set-charset-plist", Fset_charset_plist
, Sset_charset_plist
, 2, 2, 0,
1204 doc
: /* Set CHARSET's property list to PLIST. */)
1206 Lisp_Object charset
, plist
;
1210 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1211 CHARSET_ATTR_PLIST (attrs
) = plist
;
1216 DEFUN ("unify-charset", Funify_charset
, Sunify_charset
, 1, 3, 0,
1217 doc
: /* Unify characters of CHARSET with Unicode.
1218 This means reading the relevant file and installing the table defined
1219 by CHARSET's `:unify-map' property.
1221 Optional second arg UNIFY-MAP is a file name string or a vector. It has
1222 the same meaning as the `:unify-map' attribute in the function
1223 `define-charset' (which see).
1225 Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET. */)
1226 (charset
, unify_map
, deunify
)
1227 Lisp_Object charset
, unify_map
, deunify
;
1232 CHECK_CHARSET_GET_ID (charset
, id
);
1233 cs
= CHARSET_FROM_ID (id
);
1234 if (CHARSET_METHOD (cs
) == CHARSET_METHOD_MAP_DEFERRED
)
1237 ? CHARSET_UNIFIED_P (cs
) && ! NILP (CHARSET_DEUNIFIER (cs
))
1238 : ! CHARSET_UNIFIED_P (cs
))
1241 CHARSET_UNIFIED_P (cs
) = 0;
1244 if (CHARSET_METHOD (cs
) != CHARSET_METHOD_OFFSET
)
1245 error ("Can't unify charset: %s", SDATA (SYMBOL_NAME (charset
)));
1246 if (NILP (unify_map
))
1247 unify_map
= CHARSET_UNIFY_MAP (cs
);
1248 if (STRINGP (unify_map
))
1249 load_charset_map_from_file (cs
, unify_map
, 2);
1250 else if (VECTORP (unify_map
))
1251 load_charset_map_from_vector (cs
, unify_map
, 2);
1252 else if (NILP (unify_map
))
1253 error ("No unify-map for charset");
1255 error ("Bad unify-map arg");
1256 CHARSET_UNIFIED_P (cs
) = 1;
1258 else if (CHAR_TABLE_P (Vchar_unify_table
))
1260 int min_code
= CHARSET_MIN_CODE (cs
);
1261 int max_code
= CHARSET_MAX_CODE (cs
);
1262 int min_char
= DECODE_CHAR (cs
, min_code
);
1263 int max_char
= DECODE_CHAR (cs
, max_code
);
1265 char_table_set_range (Vchar_unify_table
, min_char
, max_char
, Qnil
);
1271 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char
,
1272 Sget_unused_iso_final_char
, 2, 2, 0,
1274 Return an unused ISO final char for a charset of DIMENISION and CHARS.
1275 DIMENSION is the number of bytes to represent a character: 1 or 2.
1276 CHARS is the number of characters in a dimension: 94 or 96.
1278 This final char is for private use, thus the range is `0' (48) .. `?' (63).
1279 If there's no unused final char for the specified kind of charset,
1282 Lisp_Object dimension
, chars
;
1286 CHECK_NUMBER (dimension
);
1287 CHECK_NUMBER (chars
);
1288 if (XINT (dimension
) != 1 && XINT (dimension
) != 2 && XINT (dimension
) != 3)
1289 args_out_of_range_3 (dimension
, make_number (1), make_number (3));
1290 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1291 args_out_of_range_3 (chars
, make_number (94), make_number (96));
1292 for (final_char
= '0'; final_char
<= '?'; final_char
++)
1293 if (ISO_CHARSET_TABLE (XINT (dimension
), XINT (chars
), final_char
) < 0)
1295 return (final_char
<= '?' ? make_number (final_char
) : Qnil
);
1299 check_iso_charset_parameter (dimension
, chars
, final_char
)
1300 Lisp_Object dimension
, chars
, final_char
;
1302 CHECK_NATNUM (dimension
);
1303 CHECK_NATNUM (chars
);
1304 CHECK_NATNUM (final_char
);
1306 if (XINT (dimension
) > 3)
1307 error ("Invalid DIMENSION %d, it should be 1, 2, or 3", XINT (dimension
));
1308 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1309 error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars
));
1310 if (XINT (final_char
) < '0' || XINT (final_char
) > '~')
1311 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars
));
1315 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
1317 doc
: /* Declare an equivalent charset for ISO-2022 decoding.
1319 On decoding by an ISO-2022 base coding system, when a charset
1320 specified by DIMENSION, CHARS, and FINAL-CHAR is designated, behave as
1321 if CHARSET is designated instead. */)
1322 (dimension
, chars
, final_char
, charset
)
1323 Lisp_Object dimension
, chars
, final_char
, charset
;
1328 CHECK_CHARSET_GET_ID (charset
, id
);
1329 check_iso_charset_parameter (dimension
, chars
, final_char
);
1330 chars_flag
= XINT (chars
) == 96;
1331 ISO_CHARSET_TABLE (XINT (dimension
), chars_flag
, XINT (final_char
)) = id
;
1336 /* Return information about charsets in the text at PTR of NBYTES
1337 bytes, which are NCHARS characters. The value is:
1339 0: Each character is represented by one byte. This is always
1340 true for a unibyte string. For a multibyte string, true if
1341 it contains only ASCII characters.
1343 1: No charsets other than ascii, control-1, and latin-1 are
1350 string_xstring_p (string
)
1353 const unsigned char *p
= SDATA (string
);
1354 const unsigned char *endp
= p
+ SBYTES (string
);
1356 if (SCHARS (string
) == SBYTES (string
))
1361 int c
= STRING_CHAR_ADVANCE (p
);
1370 /* Find charsets in the string at PTR of NCHARS and NBYTES.
1372 CHARSETS is a vector. If Nth element is non-nil, it means the
1373 charset whose id is N is already found.
1375 It may lookup a translation table TABLE if supplied. */
1378 find_charsets_in_text (ptr
, nchars
, nbytes
, charsets
, table
, multibyte
)
1379 const unsigned char *ptr
;
1380 EMACS_INT nchars
, nbytes
;
1381 Lisp_Object charsets
, table
;
1384 const unsigned char *pend
= ptr
+ nbytes
;
1386 if (nchars
== nbytes
)
1389 ASET (charsets
, charset_ascii
, Qt
);
1396 c
= translate_char (table
, c
);
1397 if (ASCII_BYTE_P (c
))
1398 ASET (charsets
, charset_ascii
, Qt
);
1400 ASET (charsets
, charset_eight_bit
, Qt
);
1407 int c
= STRING_CHAR_ADVANCE (ptr
);
1408 struct charset
*charset
;
1411 c
= translate_char (table
, c
);
1412 charset
= CHAR_CHARSET (c
);
1413 ASET (charsets
, CHARSET_ID (charset
), Qt
);
1418 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
1420 doc
: /* Return a list of charsets in the region between BEG and END.
1421 BEG and END are buffer positions.
1422 Optional arg TABLE if non-nil is a translation table to look up.
1424 If the current buffer is unibyte, the returned list may contain
1425 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1427 Lisp_Object beg
, end
, table
;
1429 Lisp_Object charsets
;
1430 EMACS_INT from
, from_byte
, to
, stop
, stop_byte
;
1433 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
1435 validate_region (&beg
, &end
);
1436 from
= XFASTINT (beg
);
1437 stop
= to
= XFASTINT (end
);
1439 if (from
< GPT
&& GPT
< to
)
1442 stop_byte
= GPT_BYTE
;
1445 stop_byte
= CHAR_TO_BYTE (stop
);
1447 from_byte
= CHAR_TO_BYTE (from
);
1449 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1452 find_charsets_in_text (BYTE_POS_ADDR (from_byte
), stop
- from
,
1453 stop_byte
- from_byte
, charsets
, table
,
1457 from
= stop
, from_byte
= stop_byte
;
1458 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
1465 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1466 if (!NILP (AREF (charsets
, i
)))
1467 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1471 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
1473 doc
: /* Return a list of charsets in STR.
1474 Optional arg TABLE if non-nil is a translation table to look up.
1476 If STR is unibyte, the returned list may contain
1477 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1479 Lisp_Object str
, table
;
1481 Lisp_Object charsets
;
1487 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1488 find_charsets_in_text (SDATA (str
), SCHARS (str
), SBYTES (str
),
1490 STRING_MULTIBYTE (str
));
1492 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1493 if (!NILP (AREF (charsets
, i
)))
1494 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1500 /* Return a character correponding to the code-point CODE of
1504 decode_char (charset
, code
)
1505 struct charset
*charset
;
1509 enum charset_method method
= CHARSET_METHOD (charset
);
1511 if (code
< CHARSET_MIN_CODE (charset
) || code
> CHARSET_MAX_CODE (charset
))
1514 if (method
== CHARSET_METHOD_MAP_DEFERRED
)
1516 load_charset (charset
);
1517 method
= CHARSET_METHOD (charset
);
1520 if (method
== CHARSET_METHOD_SUBSET
)
1522 Lisp_Object subset_info
;
1524 subset_info
= CHARSET_SUBSET (charset
);
1525 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1526 code
-= XINT (AREF (subset_info
, 3));
1527 if (code
< XFASTINT (AREF (subset_info
, 1))
1528 || code
> XFASTINT (AREF (subset_info
, 2)))
1531 c
= DECODE_CHAR (charset
, code
);
1533 else if (method
== CHARSET_METHOD_SUPERSET
)
1535 Lisp_Object parents
;
1537 parents
= CHARSET_SUPERSET (charset
);
1539 for (; CONSP (parents
); parents
= XCDR (parents
))
1541 int id
= XINT (XCAR (XCAR (parents
)));
1542 int code_offset
= XINT (XCDR (XCAR (parents
)));
1543 unsigned this_code
= code
- code_offset
;
1545 charset
= CHARSET_FROM_ID (id
);
1546 if ((c
= DECODE_CHAR (charset
, this_code
)) >= 0)
1552 char_index
= CODE_POINT_TO_INDEX (charset
, code
);
1556 if (method
== CHARSET_METHOD_MAP
)
1558 Lisp_Object decoder
;
1560 decoder
= CHARSET_DECODER (charset
);
1561 if (! VECTORP (decoder
))
1563 c
= XINT (AREF (decoder
, char_index
));
1567 c
= char_index
+ CHARSET_CODE_OFFSET (charset
);
1571 if (CHARSET_UNIFIED_P (charset
)
1574 MAYBE_UNIFY_CHAR (c
);
1580 /* Variable used temporarily by the macro ENCODE_CHAR. */
1581 Lisp_Object charset_work
;
1583 /* Return a code-point of CHAR in CHARSET. If CHAR doesn't belong to
1584 CHARSET, return CHARSET_INVALID_CODE (CHARSET). If STRICT is true,
1585 use CHARSET's strict_max_char instead of max_char. */
1588 encode_char (charset
, c
)
1589 struct charset
*charset
;
1593 enum charset_method method
= CHARSET_METHOD (charset
);
1595 if (CHARSET_UNIFIED_P (charset
))
1597 Lisp_Object deunifier
, deunified
;
1599 deunifier
= CHARSET_DEUNIFIER (charset
);
1600 if (! CHAR_TABLE_P (deunifier
))
1602 Funify_charset (CHARSET_NAME (charset
), Qnil
, Qnil
);
1603 deunifier
= CHARSET_DEUNIFIER (charset
);
1605 deunified
= CHAR_TABLE_REF (deunifier
, c
);
1606 if (! NILP (deunified
))
1607 c
= XINT (deunified
);
1610 if (method
== CHARSET_METHOD_SUBSET
)
1612 Lisp_Object subset_info
;
1613 struct charset
*this_charset
;
1615 subset_info
= CHARSET_SUBSET (charset
);
1616 this_charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1617 code
= ENCODE_CHAR (this_charset
, c
);
1618 if (code
== CHARSET_INVALID_CODE (this_charset
)
1619 || code
< XFASTINT (AREF (subset_info
, 1))
1620 || code
> XFASTINT (AREF (subset_info
, 2)))
1621 return CHARSET_INVALID_CODE (charset
);
1622 code
+= XINT (AREF (subset_info
, 3));
1626 if (method
== CHARSET_METHOD_SUPERSET
)
1628 Lisp_Object parents
;
1630 parents
= CHARSET_SUPERSET (charset
);
1631 for (; CONSP (parents
); parents
= XCDR (parents
))
1633 int id
= XINT (XCAR (XCAR (parents
)));
1634 int code_offset
= XINT (XCDR (XCAR (parents
)));
1635 struct charset
*this_charset
= CHARSET_FROM_ID (id
);
1637 code
= ENCODE_CHAR (this_charset
, c
);
1638 if (code
!= CHARSET_INVALID_CODE (this_charset
))
1639 return code
+ code_offset
;
1641 return CHARSET_INVALID_CODE (charset
);
1644 if (! CHARSET_FAST_MAP_REF ((c
), charset
->fast_map
)
1645 || c
< CHARSET_MIN_CHAR (charset
) || c
> CHARSET_MAX_CHAR (charset
))
1646 return CHARSET_INVALID_CODE (charset
);
1648 if (method
== CHARSET_METHOD_MAP_DEFERRED
)
1650 load_charset (charset
);
1651 method
= CHARSET_METHOD (charset
);
1654 if (method
== CHARSET_METHOD_MAP
)
1656 Lisp_Object encoder
;
1659 encoder
= CHARSET_ENCODER (charset
);
1660 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
1661 return CHARSET_INVALID_CODE (charset
);
1662 val
= CHAR_TABLE_REF (encoder
, c
);
1664 return CHARSET_INVALID_CODE (charset
);
1666 if (! CHARSET_COMPACT_CODES_P (charset
))
1667 code
= INDEX_TO_CODE_POINT (charset
, code
);
1669 else /* method == CHARSET_METHOD_OFFSET */
1671 code
= c
- CHARSET_CODE_OFFSET (charset
);
1672 code
= INDEX_TO_CODE_POINT (charset
, code
);
1679 DEFUN ("decode-char", Fdecode_char
, Sdecode_char
, 2, 3, 0,
1680 doc
: /* Decode the pair of CHARSET and CODE-POINT into a character.
1681 Return nil if CODE-POINT is not valid in CHARSET.
1683 CODE-POINT may be a cons (HIGHER-16-BIT-VALUE . LOWER-16-BIT-VALUE).
1685 Optional argument RESTRICTION specifies a way to map the pair of CCS
1686 and CODE-POINT to a chracter. Currently not supported and just ignored. */)
1687 (charset
, code_point
, restriction
)
1688 Lisp_Object charset
, code_point
, restriction
;
1692 struct charset
*charsetp
;
1694 CHECK_CHARSET_GET_ID (charset
, id
);
1695 if (CONSP (code_point
))
1697 CHECK_NATNUM_CAR (code_point
);
1698 CHECK_NATNUM_CDR (code_point
);
1699 code
= (XINT (XCAR (code_point
)) << 16) | (XINT (XCDR (code_point
)));
1703 CHECK_NATNUM (code_point
);
1704 code
= XINT (code_point
);
1706 charsetp
= CHARSET_FROM_ID (id
);
1707 c
= DECODE_CHAR (charsetp
, code
);
1708 return (c
>= 0 ? make_number (c
) : Qnil
);
1712 DEFUN ("encode-char", Fencode_char
, Sencode_char
, 2, 3, 0,
1713 doc
: /* Encode the character CH into a code-point of CHARSET.
1714 Return nil if CHARSET doesn't include CH.
1716 Optional argument RESTRICTION specifies a way to map CHAR to a
1717 code-point in CCS. Currently not supported and just ignored. */)
1718 (ch
, charset
, restriction
)
1719 Lisp_Object ch
, charset
, restriction
;
1723 struct charset
*charsetp
;
1725 CHECK_CHARSET_GET_ID (charset
, id
);
1727 charsetp
= CHARSET_FROM_ID (id
);
1728 code
= ENCODE_CHAR (charsetp
, XINT (ch
));
1729 if (code
== CHARSET_INVALID_CODE (charsetp
))
1731 if (code
> 0x7FFFFFF)
1732 return Fcons (make_number (code
>> 16), make_number (code
& 0xFFFF));
1733 return make_number (code
);
1737 DEFUN ("make-char", Fmake_char
, Smake_char
, 1, 5, 0,
1739 /* Return a character of CHARSET whose position codes are CODEn.
1741 CODE1 through CODE4 are optional, but if you don't supply sufficient
1742 position codes, it is assumed that the minimum code in each dimension
1744 (charset
, code1
, code2
, code3
, code4
)
1745 Lisp_Object charset
, code1
, code2
, code3
, code4
;
1748 struct charset
*charsetp
;
1752 CHECK_CHARSET_GET_ID (charset
, id
);
1753 charsetp
= CHARSET_FROM_ID (id
);
1755 dimension
= CHARSET_DIMENSION (charsetp
);
1757 code
= (CHARSET_ASCII_COMPATIBLE_P (charsetp
)
1758 ? 0 : CHARSET_MIN_CODE (charsetp
));
1761 CHECK_NATNUM (code1
);
1762 if (XFASTINT (code1
) >= 0x100)
1763 args_out_of_range (make_number (0xFF), code1
);
1764 code
= XFASTINT (code1
);
1770 code
|= charsetp
->code_space
[(dimension
- 2) * 4];
1773 CHECK_NATNUM (code2
);
1774 if (XFASTINT (code2
) >= 0x100)
1775 args_out_of_range (make_number (0xFF), code2
);
1776 code
|= XFASTINT (code2
);
1783 code
|= charsetp
->code_space
[(dimension
- 3) * 4];
1786 CHECK_NATNUM (code3
);
1787 if (XFASTINT (code3
) >= 0x100)
1788 args_out_of_range (make_number (0xFF), code3
);
1789 code
|= XFASTINT (code3
);
1796 code
|= charsetp
->code_space
[0];
1799 CHECK_NATNUM (code4
);
1800 if (XFASTINT (code4
) >= 0x100)
1801 args_out_of_range (make_number (0xFF), code4
);
1802 code
|= XFASTINT (code4
);
1809 if (CHARSET_ISO_FINAL (charsetp
) >= 0)
1811 c
= DECODE_CHAR (charsetp
, code
);
1813 error ("Invalid code(s)");
1814 return make_number (c
);
1818 /* Return the first charset in CHARSET_LIST that contains C.
1819 CHARSET_LIST is a list of charset IDs. If it is nil, use
1820 Vcharset_ordered_list. */
1823 char_charset (c
, charset_list
, code_return
)
1825 Lisp_Object charset_list
;
1826 unsigned *code_return
;
1828 if (NILP (charset_list
))
1829 charset_list
= Vcharset_ordered_list
;
1831 while (CONSP (charset_list
))
1833 struct charset
*charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
1834 unsigned code
= ENCODE_CHAR (charset
, c
);
1836 if (code
!= CHARSET_INVALID_CODE (charset
))
1839 *code_return
= code
;
1842 charset_list
= XCDR (charset_list
);
1848 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
1850 /*Return list of charset and one to four position-codes of CHAR.
1851 The charset is decided by the current priority order of charsets.
1852 A position-code is a byte value of each dimension of the code-point of
1853 CHAR in the charset. */)
1857 struct charset
*charset
;
1862 CHECK_CHARACTER (ch
);
1864 charset
= CHAR_CHARSET (c
);
1867 code
= ENCODE_CHAR (charset
, c
);
1868 if (code
== CHARSET_INVALID_CODE (charset
))
1870 dimension
= CHARSET_DIMENSION (charset
);
1871 for (val
= Qnil
; dimension
> 0; dimension
--)
1873 val
= Fcons (make_number (code
& 0xFF), val
);
1876 return Fcons (CHARSET_NAME (charset
), val
);
1880 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
1881 doc
: /* Return the charset of highest priority that contains CH. */)
1885 struct charset
*charset
;
1887 CHECK_CHARACTER (ch
);
1888 charset
= CHAR_CHARSET (XINT (ch
));
1889 return (CHARSET_NAME (charset
));
1893 DEFUN ("charset-after", Fcharset_after
, Scharset_after
, 0, 1, 0,
1895 Return charset of a character in the current buffer at position POS.
1896 If POS is nil, it defauls to the current point.
1897 If POS is out of range, the value is nil. */)
1902 struct charset
*charset
;
1904 ch
= Fchar_after (pos
);
1905 if (! INTEGERP (ch
))
1907 charset
= CHAR_CHARSET (XINT (ch
));
1908 return (CHARSET_NAME (charset
));
1912 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
1914 Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.
1916 ISO 2022's designation sequence (escape sequence) distinguishes charsets
1917 by their DIMENSION, CHARS, and FINAL-CHAR,
1918 where as Emacs distinguishes them by charset symbol.
1919 See the documentation of the function `charset-info' for the meanings of
1920 DIMENSION, CHARS, and FINAL-CHAR. */)
1921 (dimension
, chars
, final_char
)
1922 Lisp_Object dimension
, chars
, final_char
;
1927 check_iso_charset_parameter (dimension
, chars
, final_char
);
1928 chars_flag
= XFASTINT (chars
) == 96;
1929 id
= ISO_CHARSET_TABLE (XFASTINT (dimension
), chars_flag
,
1930 XFASTINT (final_char
));
1931 return (id
>= 0 ? CHARSET_NAME (CHARSET_FROM_ID (id
)) : Qnil
);
1935 DEFUN ("clear-charset-maps", Fclear_charset_maps
, Sclear_charset_maps
,
1938 Clear encoder and decoder of charsets that are loaded from mapfiles. */)
1942 struct charset
*charset
;
1945 for (i
= 0; i
< charset_table_used
; i
++)
1947 charset
= CHARSET_FROM_ID (i
);
1948 attrs
= CHARSET_ATTRIBUTES (charset
);
1950 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
1952 CHARSET_ATTR_DECODER (attrs
) = Qnil
;
1953 CHARSET_ATTR_ENCODER (attrs
) = Qnil
;
1954 CHARSET_METHOD (charset
) = CHARSET_METHOD_MAP_DEFERRED
;
1957 if (CHARSET_UNIFIED_P (charset
))
1958 CHARSET_ATTR_DEUNIFIER (attrs
) = Qnil
;
1961 if (CHAR_TABLE_P (Vchar_unified_charset_table
))
1963 Foptimize_char_table (Vchar_unified_charset_table
);
1964 Vchar_unify_table
= Vchar_unified_charset_table
;
1965 Vchar_unified_charset_table
= Qnil
;
1971 DEFUN ("charset-priority-list", Fcharset_priority_list
,
1972 Scharset_priority_list
, 0, 1, 0,
1973 doc
: /* Return the list of charsets ordered by priority.
1974 HIGHESTP non-nil means just return the highest priority one. */)
1976 Lisp_Object highestp
;
1978 Lisp_Object val
= Qnil
, list
= Vcharset_ordered_list
;
1980 if (!NILP (highestp
))
1981 return CHARSET_NAME (CHARSET_FROM_ID (XINT (Fcar (list
))));
1983 while (!NILP (list
))
1985 val
= Fcons (CHARSET_NAME (CHARSET_FROM_ID (XINT (XCAR (list
)))), val
);
1988 return Fnreverse (val
);
1991 DEFUN ("set-charset-priority", Fset_charset_priority
, Sset_charset_priority
,
1993 doc
: /* Assign higher priority to the charsets given as arguments.
1994 usage: (set-charset-priority &rest charsets) */)
1999 Lisp_Object new_head
, old_list
, arglist
[2];
2000 Lisp_Object list_2022
, list_emacs_mule
;
2003 old_list
= Fcopy_sequence (Vcharset_ordered_list
);
2005 for (i
= 0; i
< nargs
; i
++)
2007 CHECK_CHARSET_GET_ID (args
[i
], id
);
2008 if (! NILP (Fmemq (make_number (id
), old_list
)))
2010 old_list
= Fdelq (make_number (id
), old_list
);
2011 new_head
= Fcons (make_number (id
), new_head
);
2014 arglist
[0] = Fnreverse (new_head
);
2015 arglist
[1] = old_list
;
2016 Vcharset_ordered_list
= Fnconc (2, arglist
);
2017 charset_ordered_list_tick
++;
2019 for (old_list
= Vcharset_ordered_list
, list_2022
= list_emacs_mule
= Qnil
;
2020 CONSP (old_list
); old_list
= XCDR (old_list
))
2022 if (! NILP (Fmemq (XCAR (old_list
), Viso_2022_charset_list
)))
2023 list_2022
= Fcons (XCAR (old_list
), list_2022
);
2024 if (! NILP (Fmemq (XCAR (old_list
), Vemacs_mule_charset_list
)))
2025 list_emacs_mule
= Fcons (XCAR (old_list
), list_emacs_mule
);
2027 Viso_2022_charset_list
= Fnreverse (list_2022
);
2028 Vemacs_mule_charset_list
= Fnreverse (list_emacs_mule
);
2033 DEFUN ("charset-id-internal", Fcharset_id_internal
, Scharset_id_internal
,
2035 doc
: /* Internal use only.
2036 Return charset identification number of CHARSET. */)
2038 Lisp_Object charset
;
2042 CHECK_CHARSET_GET_ID (charset
, id
);
2043 return make_number (id
);
2051 = Fcons (Fexpand_file_name (build_string ("charsets"), Vdata_directory
),
2057 init_charset_once ()
2061 for (i
= 0; i
< ISO_MAX_DIMENSION
; i
++)
2062 for (j
= 0; j
< ISO_MAX_CHARS
; j
++)
2063 for (k
= 0; k
< ISO_MAX_FINAL
; k
++)
2064 iso_charset_table
[i
][j
][k
] = -1;
2066 for (i
= 0; i
< 256; i
++)
2067 emacs_mule_charset
[i
] = NULL
;
2069 charset_jisx0201_roman
= -1;
2070 charset_jisx0208_1978
= -1;
2071 charset_jisx0208
= -1;
2073 for (i
= 0; i
< 128; i
++)
2074 unibyte_to_multibyte_table
[i
] = i
;
2075 for (; i
< 256; i
++)
2076 unibyte_to_multibyte_table
[i
] = BYTE8_TO_CHAR (i
);
2084 DEFSYM (Qcharsetp
, "charsetp");
2086 DEFSYM (Qascii
, "ascii");
2087 DEFSYM (Qunicode
, "unicode");
2088 DEFSYM (Qeight_bit
, "eight-bit");
2089 DEFSYM (Qiso_8859_1
, "iso-8859-1");
2094 staticpro (&Vcharset_ordered_list
);
2095 Vcharset_ordered_list
= Qnil
;
2097 staticpro (&Viso_2022_charset_list
);
2098 Viso_2022_charset_list
= Qnil
;
2100 staticpro (&Vemacs_mule_charset_list
);
2101 Vemacs_mule_charset_list
= Qnil
;
2103 staticpro (&Vcharset_hash_table
);
2105 Lisp_Object args
[2];
2108 Vcharset_hash_table
= Fmake_hash_table (2, args
);
2111 charset_table_size
= 128;
2112 charset_table
= ((struct charset
*)
2113 xmalloc (sizeof (struct charset
) * charset_table_size
));
2114 charset_table_used
= 0;
2116 staticpro (&Vchar_unified_charset_table
);
2117 Vchar_unified_charset_table
= Fmake_char_table (Qnil
, make_number (-1));
2119 defsubr (&Scharsetp
);
2120 defsubr (&Smap_charset_chars
);
2121 defsubr (&Sdefine_charset_internal
);
2122 defsubr (&Sdefine_charset_alias
);
2123 defsubr (&Sunibyte_charset
);
2124 defsubr (&Sset_unibyte_charset
);
2125 defsubr (&Scharset_plist
);
2126 defsubr (&Sset_charset_plist
);
2127 defsubr (&Sunify_charset
);
2128 defsubr (&Sget_unused_iso_final_char
);
2129 defsubr (&Sdeclare_equiv_charset
);
2130 defsubr (&Sfind_charset_region
);
2131 defsubr (&Sfind_charset_string
);
2132 defsubr (&Sdecode_char
);
2133 defsubr (&Sencode_char
);
2134 defsubr (&Ssplit_char
);
2135 defsubr (&Smake_char
);
2136 defsubr (&Schar_charset
);
2137 defsubr (&Scharset_after
);
2138 defsubr (&Siso_charset
);
2139 defsubr (&Sclear_charset_maps
);
2140 defsubr (&Scharset_priority_list
);
2141 defsubr (&Sset_charset_priority
);
2142 defsubr (&Scharset_id_internal
);
2144 DEFVAR_LISP ("charset-map-path", &Vcharset_map_path
,
2145 doc
: /* *Lisp of directories to search for charset map files. */);
2146 Vcharset_map_path
= Qnil
;
2148 DEFVAR_LISP ("charset-list", &Vcharset_list
,
2149 doc
: /* List of all charsets ever defined. */);
2150 Vcharset_list
= Qnil
;
2153 = define_charset_internal (Qascii
, 1, "\x00\x7F\x00\x00\x00\x00",
2154 0, 127, 'B', -1, 0, 1, 0, 0);
2156 = define_charset_internal (Qiso_8859_1
, 1, "\x00\xFF\x00\x00\x00\x00",
2157 0, 255, -1, -1, -1, 1, 0, 0);
2159 = define_charset_internal (Qunicode
, 3, "\x00\xFF\x00\xFF\x00\x10",
2160 0, MAX_UNICODE_CHAR
, -1, 0, -1, 1, 0, 0);
2162 = define_charset_internal (Qeight_bit
, 1, "\x80\xFF\x00\x00\x00\x00",
2163 128, 255, -1, 0, -1, 0, 0,
2164 MAX_5_BYTE_CHAR
+ 1);
2169 /* arch-tag: 66a89b8d-4c28-47d3-9ca1-56f78440d69f
2170 (do not change this comment) */