1 /* Basic character set support.
2 Copyright (C) 2001-2012 Free Software Foundation, Inc.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H14PRO021
8 Copyright (C) 2003, 2004
9 National Institute of Advanced Industrial Science and Technology (AIST)
10 Registration Number H13PRO009
12 This file is part of GNU Emacs.
14 GNU Emacs is free software: you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation, either version 3 of the License, or
17 (at your option) any later version.
19 GNU Emacs is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #define CHARSET_INLINE EXTERN_INLINE
35 #include <sys/types.h>
38 #include "character.h"
44 /*** GENERAL NOTES on CODED CHARACTER SETS (CHARSETS) ***
46 A coded character set ("charset" hereafter) is a meaningful
47 collection (i.e. language, culture, functionality, etc.) of
48 characters. Emacs handles multiple charsets at once. In Emacs Lisp
49 code, a charset is represented by a symbol. In C code, a charset is
50 represented by its ID number or by a pointer to a struct charset.
52 The actual information about each charset is stored in two places.
53 Lispy information is stored in the hash table Vcharset_hash_table as
54 a vector (charset attributes). The other information is stored in
55 charset_table as a struct charset.
59 /* Hash table that contains attributes of each charset. Keys are
60 charset symbols, and values are vectors of charset attributes. */
61 Lisp_Object Vcharset_hash_table
;
63 /* Table of struct charset. */
64 struct charset
*charset_table
;
66 static ptrdiff_t charset_table_size
;
67 static int charset_table_used
;
69 Lisp_Object Qcharsetp
;
71 /* Special charset symbols. */
73 static Lisp_Object Qeight_bit
;
74 static Lisp_Object Qiso_8859_1
;
75 static Lisp_Object Qunicode
;
76 static Lisp_Object Qemacs
;
78 /* The corresponding charsets. */
80 int charset_eight_bit
;
81 static int charset_iso_8859_1
;
83 static int charset_emacs
;
85 /* The other special charsets. */
86 int charset_jisx0201_roman
;
87 int charset_jisx0208_1978
;
91 /* Value of charset attribute `charset-iso-plane'. */
92 static Lisp_Object Qgl
, Qgr
;
94 /* Charset of unibyte characters. */
97 /* List of charsets ordered by the priority. */
98 Lisp_Object Vcharset_ordered_list
;
100 /* Sub-list of Vcharset_ordered_list that contains all non-preferred
102 Lisp_Object Vcharset_non_preferred_head
;
104 /* Incremented everytime we change Vcharset_ordered_list. This is
105 unsigned short so that it fits in Lisp_Int and never matches
107 unsigned short charset_ordered_list_tick
;
109 /* List of iso-2022 charsets. */
110 Lisp_Object Viso_2022_charset_list
;
112 /* List of emacs-mule charsets. */
113 Lisp_Object Vemacs_mule_charset_list
;
115 int emacs_mule_charset
[256];
117 /* Mapping table from ISO2022's charset (specified by DIMENSION,
118 CHARS, and FINAL-CHAR) to Emacs' charset. */
119 int iso_charset_table
[ISO_MAX_DIMENSION
][ISO_MAX_CHARS
][ISO_MAX_FINAL
];
121 #define CODE_POINT_TO_INDEX(charset, code) \
122 ((charset)->code_linear_p \
123 ? (int) ((code) - (charset)->min_code) \
124 : (((charset)->code_space_mask[(code) >> 24] & 0x8) \
125 && ((charset)->code_space_mask[((code) >> 16) & 0xFF] & 0x4) \
126 && ((charset)->code_space_mask[((code) >> 8) & 0xFF] & 0x2) \
127 && ((charset)->code_space_mask[(code) & 0xFF] & 0x1)) \
128 ? (int) (((((code) >> 24) - (charset)->code_space[12]) \
129 * (charset)->code_space[11]) \
130 + (((((code) >> 16) & 0xFF) - (charset)->code_space[8]) \
131 * (charset)->code_space[7]) \
132 + (((((code) >> 8) & 0xFF) - (charset)->code_space[4]) \
133 * (charset)->code_space[3]) \
134 + (((code) & 0xFF) - (charset)->code_space[0]) \
135 - ((charset)->char_index_offset)) \
139 /* Return the code-point for the character index IDX in CHARSET.
140 IDX should be an unsigned int variable in a valid range (which is
141 always in nonnegative int range too). IDX contains garbage afterwards. */
143 #define INDEX_TO_CODE_POINT(charset, idx) \
144 ((charset)->code_linear_p \
145 ? (idx) + (charset)->min_code \
146 : (idx += (charset)->char_index_offset, \
147 (((charset)->code_space[0] + (idx) % (charset)->code_space[2]) \
148 | (((charset)->code_space[4] \
149 + ((idx) / (charset)->code_space[3] % (charset)->code_space[6])) \
151 | (((charset)->code_space[8] \
152 + ((idx) / (charset)->code_space[7] % (charset)->code_space[10])) \
154 | (((charset)->code_space[12] + ((idx) / (charset)->code_space[11])) \
157 /* Structure to hold mapping tables for a charset. Used by temacs
158 invoked for dumping. */
162 /* The current charset for which the following tables are setup. */
163 struct charset
*current
;
165 /* 1 iff the following table is used for encoder. */
168 /* When the following table is used for encoding, minimum and
169 maximum character of the current charset. */
170 int min_char
, max_char
;
172 /* A Unicode character corresponding to the code index 0 (i.e. the
173 minimum code-point) of the current charset, or -1 if the code
174 index 0 is not a Unicode character. This is checked when
175 table.encoder[CHAR] is zero. */
179 /* Table mapping code-indices (not code-points) of the current
180 charset to Unicode characters. If decoder[CHAR] is -1, CHAR
181 doesn't belong to the current charset. */
182 int decoder
[0x10000];
183 /* Table mapping Unicode characters to code-indices of the current
184 charset. The first 0x10000 elements are for BMP (0..0xFFFF),
185 and the last 0x10000 are for SMP (0x10000..0x1FFFF) or SIP
186 (0x20000..0x2FFFF). Note that there is no charset map that
187 uses both SMP and SIP. */
188 unsigned short encoder
[0x20000];
190 } *temp_charset_work
;
192 #define SET_TEMP_CHARSET_WORK_ENCODER(C, CODE) \
195 temp_charset_work->zero_index_char = (C); \
196 else if ((C) < 0x20000) \
197 temp_charset_work->table.encoder[(C)] = (CODE); \
199 temp_charset_work->table.encoder[(C) - 0x10000] = (CODE); \
202 #define GET_TEMP_CHARSET_WORK_ENCODER(C) \
203 ((C) == temp_charset_work->zero_index_char ? 0 \
204 : (C) < 0x20000 ? (temp_charset_work->table.encoder[(C)] \
205 ? (int) temp_charset_work->table.encoder[(C)] : -1) \
206 : temp_charset_work->table.encoder[(C) - 0x10000] \
207 ? temp_charset_work->table.encoder[(C) - 0x10000] : -1)
209 #define SET_TEMP_CHARSET_WORK_DECODER(C, CODE) \
210 (temp_charset_work->table.decoder[(CODE)] = (C))
212 #define GET_TEMP_CHARSET_WORK_DECODER(CODE) \
213 (temp_charset_work->table.decoder[(CODE)])
216 /* Set to 1 to warn that a charset map is loaded and thus a buffer
217 text and a string data may be relocated. */
218 int charset_map_loaded
;
220 struct charset_map_entries
226 struct charset_map_entries
*next
;
229 /* Load the mapping information of CHARSET from ENTRIES for
230 initializing (CONTROL_FLAG == 0), decoding (CONTROL_FLAG == 1), and
231 encoding (CONTROL_FLAG == 2).
233 If CONTROL_FLAG is 0, setup CHARSET->min_char, CHARSET->max_char,
234 and CHARSET->fast_map.
236 If CONTROL_FLAG is 1, setup the following tables according to
237 CHARSET->method and inhibit_load_charset_map.
239 CHARSET->method | inhibit_lcm == 0 | inhibit_lcm == 1
240 ----------------------+--------------------+---------------------------
241 CHARSET_METHOD_MAP | CHARSET->decoder | temp_charset_work->decoder
242 ----------------------+--------------------+---------------------------
243 CHARSET_METHOD_OFFSET | Vchar_unify_table | temp_charset_work->decoder
245 If CONTROL_FLAG is 2, setup the following tables.
247 CHARSET->method | inhibit_lcm == 0 | inhibit_lcm == 1
248 ----------------------+--------------------+---------------------------
249 CHARSET_METHOD_MAP | CHARSET->encoder | temp_charset_work->encoder
250 ----------------------+--------------------+--------------------------
251 CHARSET_METHOD_OFFSET | CHARSET->deunifier | temp_charset_work->encoder
255 load_charset_map (struct charset
*charset
, struct charset_map_entries
*entries
, int n_entries
, int control_flag
)
257 Lisp_Object vec
IF_LINT (= Qnil
), table
IF_LINT (= Qnil
);
258 unsigned max_code
= CHARSET_MAX_CODE (charset
);
259 int ascii_compatible_p
= charset
->ascii_compatible_p
;
260 int min_char
, max_char
, nonascii_min_char
;
262 unsigned char *fast_map
= charset
->fast_map
;
269 if (! inhibit_load_charset_map
)
271 if (control_flag
== 1)
273 if (charset
->method
== CHARSET_METHOD_MAP
)
275 int n
= CODE_POINT_TO_INDEX (charset
, max_code
) + 1;
277 vec
= Fmake_vector (make_number (n
), make_number (-1));
278 set_charset_attr (charset
, charset_decoder
, vec
);
282 char_table_set_range (Vchar_unify_table
,
283 charset
->min_char
, charset
->max_char
,
289 table
= Fmake_char_table (Qnil
, Qnil
);
290 set_charset_attr (charset
,
291 (charset
->method
== CHARSET_METHOD_MAP
292 ? charset_encoder
: charset_deunifier
),
298 if (! temp_charset_work
)
299 temp_charset_work
= xmalloc (sizeof *temp_charset_work
);
300 if (control_flag
== 1)
302 memset (temp_charset_work
->table
.decoder
, -1,
303 sizeof (int) * 0x10000);
307 memset (temp_charset_work
->table
.encoder
, 0,
308 sizeof (unsigned short) * 0x20000);
309 temp_charset_work
->zero_index_char
= -1;
311 temp_charset_work
->current
= charset
;
312 temp_charset_work
->for_encoder
= (control_flag
== 2);
315 charset_map_loaded
= 1;
318 min_char
= max_char
= entries
->entry
[0].c
;
319 nonascii_min_char
= MAX_CHAR
;
320 for (i
= 0; i
< n_entries
; i
++)
323 int from_index
, to_index
, lim_index
;
325 int idx
= i
% 0x10000;
327 if (i
> 0 && idx
== 0)
328 entries
= entries
->next
;
329 from
= entries
->entry
[idx
].from
;
330 to
= entries
->entry
[idx
].to
;
331 from_c
= entries
->entry
[idx
].c
;
332 from_index
= CODE_POINT_TO_INDEX (charset
, from
);
335 to_index
= from_index
;
340 to_index
= CODE_POINT_TO_INDEX (charset
, to
);
341 to_c
= from_c
+ (to_index
- from_index
);
343 if (from_index
< 0 || to_index
< 0)
345 lim_index
= to_index
+ 1;
349 else if (from_c
< min_char
)
352 if (control_flag
== 1)
354 if (charset
->method
== CHARSET_METHOD_MAP
)
355 for (; from_index
< lim_index
; from_index
++, from_c
++)
356 ASET (vec
, from_index
, make_number (from_c
));
358 for (; from_index
< lim_index
; from_index
++, from_c
++)
359 CHAR_TABLE_SET (Vchar_unify_table
,
360 CHARSET_CODE_OFFSET (charset
) + from_index
,
361 make_number (from_c
));
363 else if (control_flag
== 2)
365 if (charset
->method
== CHARSET_METHOD_MAP
366 && CHARSET_COMPACT_CODES_P (charset
))
367 for (; from_index
< lim_index
; from_index
++, from_c
++)
369 unsigned code
= from_index
;
370 code
= INDEX_TO_CODE_POINT (charset
, code
);
372 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
373 CHAR_TABLE_SET (table
, from_c
, make_number (code
));
376 for (; from_index
< lim_index
; from_index
++, from_c
++)
378 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
379 CHAR_TABLE_SET (table
, from_c
, make_number (from_index
));
382 else if (control_flag
== 3)
383 for (; from_index
< lim_index
; from_index
++, from_c
++)
384 SET_TEMP_CHARSET_WORK_DECODER (from_c
, from_index
);
385 else if (control_flag
== 4)
386 for (; from_index
< lim_index
; from_index
++, from_c
++)
387 SET_TEMP_CHARSET_WORK_ENCODER (from_c
, from_index
);
388 else /* control_flag == 0 */
390 if (ascii_compatible_p
)
392 if (! ASCII_BYTE_P (from_c
))
394 if (from_c
< nonascii_min_char
)
395 nonascii_min_char
= from_c
;
397 else if (! ASCII_BYTE_P (to_c
))
399 nonascii_min_char
= 0x80;
403 for (; from_c
<= to_c
; from_c
++)
404 CHARSET_FAST_MAP_SET (from_c
, fast_map
);
408 if (control_flag
== 0)
410 CHARSET_MIN_CHAR (charset
) = (ascii_compatible_p
411 ? nonascii_min_char
: min_char
);
412 CHARSET_MAX_CHAR (charset
) = max_char
;
414 else if (control_flag
== 4)
416 temp_charset_work
->min_char
= min_char
;
417 temp_charset_work
->max_char
= max_char
;
422 /* Read a hexadecimal number (preceded by "0x") from the file FP while
423 paying attention to comment character '#'. */
425 static inline unsigned
426 read_hex (FILE *fp
, int *eof
, int *overflow
)
431 while ((c
= getc (fp
)) != EOF
)
435 while ((c
= getc (fp
)) != EOF
&& c
!= '\n');
439 if ((c
= getc (fp
)) == EOF
|| c
== 'x')
449 while (isxdigit (c
= getc (fp
)))
451 if (UINT_MAX
>> 4 < n
)
454 | (c
- ('0' <= c
&& c
<= '9' ? '0'
455 : 'A' <= c
&& c
<= 'F' ? 'A' - 10
463 /* Return a mapping vector for CHARSET loaded from MAPFILE.
464 Each line of MAPFILE has this form
466 where 0xAAAA is a code-point and 0xCCCC is the corresponding
467 character code, or this form
469 where 0xAAAA and 0xBBBB are code-points specifying a range, and
470 0xCCCC is the first character code of the range.
472 The returned vector has this form:
473 [ CODE1 CHAR1 CODE2 CHAR2 .... ]
474 where CODE1 is a code-point or a cons of code-points specifying a
477 Note that this function uses `openp' to open MAPFILE but ignores
478 `file-name-handler-alist' to avoid running any Lisp code. */
481 load_charset_map_from_file (struct charset
*charset
, Lisp_Object mapfile
, int control_flag
)
483 unsigned min_code
= CHARSET_MIN_CODE (charset
);
484 unsigned max_code
= CHARSET_MAX_CODE (charset
);
487 Lisp_Object suffixes
;
488 struct charset_map_entries
*head
, *entries
;
493 suffixes
= Fcons (build_string (".map"),
494 Fcons (build_string (".TXT"), Qnil
));
496 count
= SPECPDL_INDEX ();
497 specbind (Qfile_name_handler_alist
, Qnil
);
498 fd
= openp (Vcharset_map_path
, mapfile
, suffixes
, NULL
, Qnil
);
499 unbind_to (count
, Qnil
);
501 || ! (fp
= fdopen (fd
, "r")))
502 error ("Failure in loading charset map: %s", SDATA (mapfile
));
504 /* Use SAFE_ALLOCA instead of alloca, as `charset_map_entries' is
505 large (larger than MAX_ALLOCA). */
506 SAFE_ALLOCA (head
, struct charset_map_entries
*,
507 sizeof (struct charset_map_entries
));
509 memset (entries
, 0, sizeof (struct charset_map_entries
));
514 unsigned from
, to
, c
;
516 int eof
= 0, overflow
= 0;
518 from
= read_hex (fp
, &eof
, &overflow
);
521 if (getc (fp
) == '-')
522 to
= read_hex (fp
, &eof
, &overflow
);
527 c
= read_hex (fp
, &eof
, &overflow
);
533 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
536 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
538 SAFE_ALLOCA (entries
->next
, struct charset_map_entries
*,
539 sizeof (struct charset_map_entries
));
540 entries
= entries
->next
;
541 memset (entries
, 0, sizeof (struct charset_map_entries
));
545 entries
->entry
[idx
].from
= from
;
546 entries
->entry
[idx
].to
= to
;
547 entries
->entry
[idx
].c
= c
;
552 load_charset_map (charset
, head
, n_entries
, control_flag
);
557 load_charset_map_from_vector (struct charset
*charset
, Lisp_Object vec
, int control_flag
)
559 unsigned min_code
= CHARSET_MIN_CODE (charset
);
560 unsigned max_code
= CHARSET_MAX_CODE (charset
);
561 struct charset_map_entries
*head
, *entries
;
563 int len
= ASIZE (vec
);
569 add_to_log ("Failure in loading charset map: %V", vec
, Qnil
);
573 /* Use SAFE_ALLOCA instead of alloca, as `charset_map_entries' is
574 large (larger than MAX_ALLOCA). */
575 SAFE_ALLOCA (head
, struct charset_map_entries
*,
576 sizeof (struct charset_map_entries
));
578 memset (entries
, 0, sizeof (struct charset_map_entries
));
581 for (i
= 0; i
< len
; i
+= 2)
583 Lisp_Object val
, val2
;
593 from
= XFASTINT (val
);
594 to
= XFASTINT (val2
);
597 from
= to
= XFASTINT (val
);
598 val
= AREF (vec
, i
+ 1);
602 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
605 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
607 SAFE_ALLOCA (entries
->next
, struct charset_map_entries
*,
608 sizeof (struct charset_map_entries
));
609 entries
= entries
->next
;
610 memset (entries
, 0, sizeof (struct charset_map_entries
));
612 idx
= n_entries
% 0x10000;
613 entries
->entry
[idx
].from
= from
;
614 entries
->entry
[idx
].to
= to
;
615 entries
->entry
[idx
].c
= c
;
619 load_charset_map (charset
, head
, n_entries
, control_flag
);
624 /* Load a mapping table for CHARSET. CONTROL-FLAG tells what kind of
625 map it is (see the comment of load_charset_map for the detail). */
628 load_charset (struct charset
*charset
, int control_flag
)
632 if (inhibit_load_charset_map
634 && charset
== temp_charset_work
->current
635 && ((control_flag
== 2) == temp_charset_work
->for_encoder
))
638 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
639 map
= CHARSET_MAP (charset
);
642 if (! CHARSET_UNIFIED_P (charset
))
644 map
= CHARSET_UNIFY_MAP (charset
);
647 load_charset_map_from_file (charset
, map
, control_flag
);
649 load_charset_map_from_vector (charset
, map
, control_flag
);
653 DEFUN ("charsetp", Fcharsetp
, Scharsetp
, 1, 1, 0,
654 doc
: /* Return non-nil if and only if OBJECT is a charset.*/)
657 return (CHARSETP (object
) ? Qt
: Qnil
);
662 map_charset_for_dump (void (*c_function
) (Lisp_Object
, Lisp_Object
),
663 Lisp_Object function
, Lisp_Object arg
,
664 unsigned int from
, unsigned int to
)
666 int from_idx
= CODE_POINT_TO_INDEX (temp_charset_work
->current
, from
);
667 int to_idx
= CODE_POINT_TO_INDEX (temp_charset_work
->current
, to
);
672 range
= Fcons (Qnil
, Qnil
);
675 c
= temp_charset_work
->min_char
;
676 stop
= (temp_charset_work
->max_char
< 0x20000
677 ? temp_charset_work
->max_char
: 0xFFFF);
681 int idx
= GET_TEMP_CHARSET_WORK_ENCODER (c
);
683 if (idx
>= from_idx
&& idx
<= to_idx
)
685 if (NILP (XCAR (range
)))
686 XSETCAR (range
, make_number (c
));
688 else if (! NILP (XCAR (range
)))
690 XSETCDR (range
, make_number (c
- 1));
692 (*c_function
) (arg
, range
);
694 call2 (function
, range
, arg
);
695 XSETCAR (range
, Qnil
);
699 if (c
== temp_charset_work
->max_char
)
701 if (! NILP (XCAR (range
)))
703 XSETCDR (range
, make_number (c
));
705 (*c_function
) (arg
, range
);
707 call2 (function
, range
, arg
);
712 stop
= temp_charset_work
->max_char
;
720 map_charset_chars (void (*c_function
)(Lisp_Object
, Lisp_Object
), Lisp_Object function
,
721 Lisp_Object arg
, struct charset
*charset
, unsigned from
, unsigned to
)
726 partial
= (from
> CHARSET_MIN_CODE (charset
)
727 || to
< CHARSET_MAX_CODE (charset
));
729 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_OFFSET
)
731 int from_idx
= CODE_POINT_TO_INDEX (charset
, from
);
732 int to_idx
= CODE_POINT_TO_INDEX (charset
, to
);
733 int from_c
= from_idx
+ CHARSET_CODE_OFFSET (charset
);
734 int to_c
= to_idx
+ CHARSET_CODE_OFFSET (charset
);
736 if (CHARSET_UNIFIED_P (charset
))
738 if (! CHAR_TABLE_P (CHARSET_DEUNIFIER (charset
)))
739 load_charset (charset
, 2);
740 if (CHAR_TABLE_P (CHARSET_DEUNIFIER (charset
)))
741 map_char_table_for_charset (c_function
, function
,
742 CHARSET_DEUNIFIER (charset
), arg
,
743 partial
? charset
: NULL
, from
, to
);
745 map_charset_for_dump (c_function
, function
, arg
, from
, to
);
748 range
= Fcons (make_number (from_c
), make_number (to_c
));
750 (*c_function
) (arg
, range
);
752 call2 (function
, range
, arg
);
754 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
756 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
757 load_charset (charset
, 2);
758 if (CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
759 map_char_table_for_charset (c_function
, function
,
760 CHARSET_ENCODER (charset
), arg
,
761 partial
? charset
: NULL
, from
, to
);
763 map_charset_for_dump (c_function
, function
, arg
, from
, to
);
765 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_SUBSET
)
767 Lisp_Object subset_info
;
770 subset_info
= CHARSET_SUBSET (charset
);
771 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
772 offset
= XINT (AREF (subset_info
, 3));
774 if (from
< XFASTINT (AREF (subset_info
, 1)))
775 from
= XFASTINT (AREF (subset_info
, 1));
777 if (to
> XFASTINT (AREF (subset_info
, 2)))
778 to
= XFASTINT (AREF (subset_info
, 2));
779 map_charset_chars (c_function
, function
, arg
, charset
, from
, to
);
781 else /* i.e. CHARSET_METHOD_SUPERSET */
785 for (parents
= CHARSET_SUPERSET (charset
); CONSP (parents
);
786 parents
= XCDR (parents
))
789 unsigned this_from
, this_to
;
791 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents
))));
792 offset
= XINT (XCDR (XCAR (parents
)));
793 this_from
= from
> offset
? from
- offset
: 0;
794 this_to
= to
> offset
? to
- offset
: 0;
795 if (this_from
< CHARSET_MIN_CODE (charset
))
796 this_from
= CHARSET_MIN_CODE (charset
);
797 if (this_to
> CHARSET_MAX_CODE (charset
))
798 this_to
= CHARSET_MAX_CODE (charset
);
799 map_charset_chars (c_function
, function
, arg
, charset
,
805 DEFUN ("map-charset-chars", Fmap_charset_chars
, Smap_charset_chars
, 2, 5, 0,
806 doc
: /* Call FUNCTION for all characters in CHARSET.
807 FUNCTION is called with an argument RANGE and the optional 3rd
810 RANGE is a cons (FROM . TO), where FROM and TO indicate a range of
811 characters contained in CHARSET.
813 The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the
814 range of code points (in CHARSET) of target characters. */)
815 (Lisp_Object function
, Lisp_Object charset
, Lisp_Object arg
, Lisp_Object from_code
, Lisp_Object to_code
)
820 CHECK_CHARSET_GET_CHARSET (charset
, cs
);
821 if (NILP (from_code
))
822 from
= CHARSET_MIN_CODE (cs
);
825 from
= XINT (from_code
);
826 if (from
< CHARSET_MIN_CODE (cs
))
827 from
= CHARSET_MIN_CODE (cs
);
830 to
= CHARSET_MAX_CODE (cs
);
834 if (to
> CHARSET_MAX_CODE (cs
))
835 to
= CHARSET_MAX_CODE (cs
);
837 map_charset_chars (NULL
, function
, arg
, cs
, from
, to
);
842 /* Define a charset according to the arguments. The Nth argument is
843 the Nth attribute of the charset (the last attribute `charset-id'
844 is not included). See the docstring of `define-charset' for the
847 DEFUN ("define-charset-internal", Fdefine_charset_internal
,
848 Sdefine_charset_internal
, charset_arg_max
, MANY
, 0,
849 doc
: /* For internal use only.
850 usage: (define-charset-internal ...) */)
851 (ptrdiff_t nargs
, Lisp_Object
*args
)
853 /* Charset attr vector. */
856 EMACS_UINT hash_code
;
857 struct Lisp_Hash_Table
*hash_table
= XHASH_TABLE (Vcharset_hash_table
);
859 struct charset charset
;
862 int new_definition_p
;
865 if (nargs
!= charset_arg_max
)
866 return Fsignal (Qwrong_number_of_arguments
,
867 Fcons (intern ("define-charset-internal"),
868 make_number (nargs
)));
870 attrs
= Fmake_vector (make_number (charset_attr_max
), Qnil
);
872 CHECK_SYMBOL (args
[charset_arg_name
]);
873 ASET (attrs
, charset_name
, args
[charset_arg_name
]);
875 val
= args
[charset_arg_code_space
];
876 for (i
= 0, dimension
= 0, nchars
= 1; ; i
++)
878 Lisp_Object min_byte_obj
, max_byte_obj
;
879 int min_byte
, max_byte
;
881 min_byte_obj
= Faref (val
, make_number (i
* 2));
882 max_byte_obj
= Faref (val
, make_number (i
* 2 + 1));
883 CHECK_RANGED_INTEGER (min_byte_obj
, 0, 255);
884 min_byte
= XINT (min_byte_obj
);
885 CHECK_RANGED_INTEGER (max_byte_obj
, min_byte
, 255);
886 max_byte
= XINT (max_byte_obj
);
887 charset
.code_space
[i
* 4] = min_byte
;
888 charset
.code_space
[i
* 4 + 1] = max_byte
;
889 charset
.code_space
[i
* 4 + 2] = max_byte
- min_byte
+ 1;
894 nchars
*= charset
.code_space
[i
* 4 + 2];
895 charset
.code_space
[i
* 4 + 3] = nchars
;
898 val
= args
[charset_arg_dimension
];
900 charset
.dimension
= dimension
;
903 CHECK_RANGED_INTEGER (val
, 1, 4);
904 charset
.dimension
= XINT (val
);
907 charset
.code_linear_p
908 = (charset
.dimension
== 1
909 || (charset
.code_space
[2] == 256
910 && (charset
.dimension
== 2
911 || (charset
.code_space
[6] == 256
912 && (charset
.dimension
== 3
913 || charset
.code_space
[10] == 256)))));
915 if (! charset
.code_linear_p
)
917 charset
.code_space_mask
= xzalloc (256);
918 for (i
= 0; i
< 4; i
++)
919 for (j
= charset
.code_space
[i
* 4]; j
<= charset
.code_space
[i
* 4 + 1];
921 charset
.code_space_mask
[j
] |= (1 << i
);
924 charset
.iso_chars_96
= charset
.code_space
[2] == 96;
926 charset
.min_code
= (charset
.code_space
[0]
927 | (charset
.code_space
[4] << 8)
928 | (charset
.code_space
[8] << 16)
929 | ((unsigned) charset
.code_space
[12] << 24));
930 charset
.max_code
= (charset
.code_space
[1]
931 | (charset
.code_space
[5] << 8)
932 | (charset
.code_space
[9] << 16)
933 | ((unsigned) charset
.code_space
[13] << 24));
934 charset
.char_index_offset
= 0;
936 val
= args
[charset_arg_min_code
];
939 unsigned code
= cons_to_unsigned (val
, UINT_MAX
);
941 if (code
< charset
.min_code
942 || code
> charset
.max_code
)
943 args_out_of_range_3 (make_fixnum_or_float (charset
.min_code
),
944 make_fixnum_or_float (charset
.max_code
), val
);
945 charset
.char_index_offset
= CODE_POINT_TO_INDEX (&charset
, code
);
946 charset
.min_code
= code
;
949 val
= args
[charset_arg_max_code
];
952 unsigned code
= cons_to_unsigned (val
, UINT_MAX
);
954 if (code
< charset
.min_code
955 || code
> charset
.max_code
)
956 args_out_of_range_3 (make_fixnum_or_float (charset
.min_code
),
957 make_fixnum_or_float (charset
.max_code
), val
);
958 charset
.max_code
= code
;
961 charset
.compact_codes_p
= charset
.max_code
< 0x10000;
963 val
= args
[charset_arg_invalid_code
];
966 if (charset
.min_code
> 0)
967 charset
.invalid_code
= 0;
970 if (charset
.max_code
< UINT_MAX
)
971 charset
.invalid_code
= charset
.max_code
+ 1;
973 error ("Attribute :invalid-code must be specified");
977 charset
.invalid_code
= cons_to_unsigned (val
, UINT_MAX
);
979 val
= args
[charset_arg_iso_final
];
981 charset
.iso_final
= -1;
985 if (XINT (val
) < '0' || XINT (val
) > 127)
986 error ("Invalid iso-final-char: %"pI
"d", XINT (val
));
987 charset
.iso_final
= XINT (val
);
990 val
= args
[charset_arg_iso_revision
];
992 charset
.iso_revision
= -1;
995 CHECK_RANGED_INTEGER (val
, -1, 63);
996 charset
.iso_revision
= XINT (val
);
999 val
= args
[charset_arg_emacs_mule_id
];
1001 charset
.emacs_mule_id
= -1;
1005 if ((XINT (val
) > 0 && XINT (val
) <= 128) || XINT (val
) >= 256)
1006 error ("Invalid emacs-mule-id: %"pI
"d", XINT (val
));
1007 charset
.emacs_mule_id
= XINT (val
);
1010 charset
.ascii_compatible_p
= ! NILP (args
[charset_arg_ascii_compatible_p
]);
1012 charset
.supplementary_p
= ! NILP (args
[charset_arg_supplementary_p
]);
1014 charset
.unified_p
= 0;
1016 memset (charset
.fast_map
, 0, sizeof (charset
.fast_map
));
1018 if (! NILP (args
[charset_arg_code_offset
]))
1020 val
= args
[charset_arg_code_offset
];
1021 CHECK_CHARACTER (val
);
1023 charset
.method
= CHARSET_METHOD_OFFSET
;
1024 charset
.code_offset
= XINT (val
);
1026 i
= CODE_POINT_TO_INDEX (&charset
, charset
.max_code
);
1027 if (MAX_CHAR
- charset
.code_offset
< i
)
1028 error ("Unsupported max char: %d", charset
.max_char
);
1029 charset
.max_char
= i
+ charset
.code_offset
;
1030 i
= CODE_POINT_TO_INDEX (&charset
, charset
.min_code
);
1031 charset
.min_char
= i
+ charset
.code_offset
;
1033 i
= (charset
.min_char
>> 7) << 7;
1034 for (; i
< 0x10000 && i
<= charset
.max_char
; i
+= 128)
1035 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
1036 i
= (i
>> 12) << 12;
1037 for (; i
<= charset
.max_char
; i
+= 0x1000)
1038 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
1039 if (charset
.code_offset
== 0 && charset
.max_char
>= 0x80)
1040 charset
.ascii_compatible_p
= 1;
1042 else if (! NILP (args
[charset_arg_map
]))
1044 val
= args
[charset_arg_map
];
1045 ASET (attrs
, charset_map
, val
);
1046 charset
.method
= CHARSET_METHOD_MAP
;
1048 else if (! NILP (args
[charset_arg_subset
]))
1051 Lisp_Object parent_min_code
, parent_max_code
, parent_code_offset
;
1052 struct charset
*parent_charset
;
1054 val
= args
[charset_arg_subset
];
1055 parent
= Fcar (val
);
1056 CHECK_CHARSET_GET_CHARSET (parent
, parent_charset
);
1057 parent_min_code
= Fnth (make_number (1), val
);
1058 CHECK_NATNUM (parent_min_code
);
1059 parent_max_code
= Fnth (make_number (2), val
);
1060 CHECK_NATNUM (parent_max_code
);
1061 parent_code_offset
= Fnth (make_number (3), val
);
1062 CHECK_NUMBER (parent_code_offset
);
1063 val
= Fmake_vector (make_number (4), Qnil
);
1064 ASET (val
, 0, make_number (parent_charset
->id
));
1065 ASET (val
, 1, parent_min_code
);
1066 ASET (val
, 2, parent_max_code
);
1067 ASET (val
, 3, parent_code_offset
);
1068 ASET (attrs
, charset_subset
, val
);
1070 charset
.method
= CHARSET_METHOD_SUBSET
;
1071 /* Here, we just copy the parent's fast_map. It's not accurate,
1072 but at least it works for quickly detecting which character
1073 DOESN'T belong to this charset. */
1074 for (i
= 0; i
< 190; i
++)
1075 charset
.fast_map
[i
] = parent_charset
->fast_map
[i
];
1077 /* We also copy these for parents. */
1078 charset
.min_char
= parent_charset
->min_char
;
1079 charset
.max_char
= parent_charset
->max_char
;
1081 else if (! NILP (args
[charset_arg_superset
]))
1083 val
= args
[charset_arg_superset
];
1084 charset
.method
= CHARSET_METHOD_SUPERSET
;
1085 val
= Fcopy_sequence (val
);
1086 ASET (attrs
, charset_superset
, val
);
1088 charset
.min_char
= MAX_CHAR
;
1089 charset
.max_char
= 0;
1090 for (; ! NILP (val
); val
= Fcdr (val
))
1092 Lisp_Object elt
, car_part
, cdr_part
;
1093 int this_id
, offset
;
1094 struct charset
*this_charset
;
1099 car_part
= XCAR (elt
);
1100 cdr_part
= XCDR (elt
);
1101 CHECK_CHARSET_GET_ID (car_part
, this_id
);
1102 CHECK_TYPE_RANGED_INTEGER (int, cdr_part
);
1103 offset
= XINT (cdr_part
);
1107 CHECK_CHARSET_GET_ID (elt
, this_id
);
1110 XSETCAR (val
, Fcons (make_number (this_id
), make_number (offset
)));
1112 this_charset
= CHARSET_FROM_ID (this_id
);
1113 if (charset
.min_char
> this_charset
->min_char
)
1114 charset
.min_char
= this_charset
->min_char
;
1115 if (charset
.max_char
< this_charset
->max_char
)
1116 charset
.max_char
= this_charset
->max_char
;
1117 for (i
= 0; i
< 190; i
++)
1118 charset
.fast_map
[i
] |= this_charset
->fast_map
[i
];
1122 error ("None of :code-offset, :map, :parents are specified");
1124 val
= args
[charset_arg_unify_map
];
1125 if (! NILP (val
) && !STRINGP (val
))
1127 ASET (attrs
, charset_unify_map
, val
);
1129 CHECK_LIST (args
[charset_arg_plist
]);
1130 ASET (attrs
, charset_plist
, args
[charset_arg_plist
]);
1132 charset
.hash_index
= hash_lookup (hash_table
, args
[charset_arg_name
],
1134 if (charset
.hash_index
>= 0)
1136 new_definition_p
= 0;
1137 id
= XFASTINT (CHARSET_SYMBOL_ID (args
[charset_arg_name
]));
1138 set_hash_value (hash_table
, charset
.hash_index
, attrs
);
1142 charset
.hash_index
= hash_put (hash_table
, args
[charset_arg_name
], attrs
,
1144 if (charset_table_used
== charset_table_size
)
1146 /* Ensure that charset IDs fit into 'int' as well as into the
1147 restriction imposed by fixnums. Although the 'int' restriction
1148 could be removed, too much other code would need altering; for
1149 example, the IDs are stuffed into struct
1150 coding_system.charbuf[i] entries, which are 'int'. */
1151 int old_size
= charset_table_size
;
1152 struct charset
*new_table
=
1153 xpalloc (0, &charset_table_size
, 1,
1154 min (INT_MAX
, MOST_POSITIVE_FIXNUM
),
1155 sizeof *charset_table
);
1156 memcpy (new_table
, charset_table
, old_size
* sizeof *new_table
);
1157 charset_table
= new_table
;
1158 /* FIXME: This leaks memory, as the old charset_table becomes
1159 unreachable. If the old charset table is charset_table_init
1160 then this leak is intentional; otherwise, it's unclear.
1161 If the latter memory leak is intentional, a
1162 comment should be added to explain this. If not, the old
1163 charset_table should be freed, by passing it as the 1st argument
1164 to xpalloc and removing the memcpy. */
1166 id
= charset_table_used
++;
1167 new_definition_p
= 1;
1170 ASET (attrs
, charset_id
, make_number (id
));
1172 charset_table
[id
] = charset
;
1174 if (charset
.method
== CHARSET_METHOD_MAP
)
1176 load_charset (&charset
, 0);
1177 charset_table
[id
] = charset
;
1180 if (charset
.iso_final
>= 0)
1182 ISO_CHARSET_TABLE (charset
.dimension
, charset
.iso_chars_96
,
1183 charset
.iso_final
) = id
;
1184 if (new_definition_p
)
1185 Viso_2022_charset_list
= nconc2 (Viso_2022_charset_list
,
1186 Fcons (make_number (id
), Qnil
));
1187 if (ISO_CHARSET_TABLE (1, 0, 'J') == id
)
1188 charset_jisx0201_roman
= id
;
1189 else if (ISO_CHARSET_TABLE (2, 0, '@') == id
)
1190 charset_jisx0208_1978
= id
;
1191 else if (ISO_CHARSET_TABLE (2, 0, 'B') == id
)
1192 charset_jisx0208
= id
;
1193 else if (ISO_CHARSET_TABLE (2, 0, 'C') == id
)
1194 charset_ksc5601
= id
;
1197 if (charset
.emacs_mule_id
>= 0)
1199 emacs_mule_charset
[charset
.emacs_mule_id
] = id
;
1200 if (charset
.emacs_mule_id
< 0xA0)
1201 emacs_mule_bytes
[charset
.emacs_mule_id
] = charset
.dimension
+ 1;
1203 emacs_mule_bytes
[charset
.emacs_mule_id
] = charset
.dimension
+ 2;
1204 if (new_definition_p
)
1205 Vemacs_mule_charset_list
= nconc2 (Vemacs_mule_charset_list
,
1206 Fcons (make_number (id
), Qnil
));
1209 if (new_definition_p
)
1211 Vcharset_list
= Fcons (args
[charset_arg_name
], Vcharset_list
);
1212 if (charset
.supplementary_p
)
1213 Vcharset_ordered_list
= nconc2 (Vcharset_ordered_list
,
1214 Fcons (make_number (id
), Qnil
));
1219 for (tail
= Vcharset_ordered_list
; CONSP (tail
); tail
= XCDR (tail
))
1221 struct charset
*cs
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
1223 if (cs
->supplementary_p
)
1226 if (EQ (tail
, Vcharset_ordered_list
))
1227 Vcharset_ordered_list
= Fcons (make_number (id
),
1228 Vcharset_ordered_list
);
1229 else if (NILP (tail
))
1230 Vcharset_ordered_list
= nconc2 (Vcharset_ordered_list
,
1231 Fcons (make_number (id
), Qnil
));
1234 val
= Fcons (XCAR (tail
), XCDR (tail
));
1235 XSETCDR (tail
, val
);
1236 XSETCAR (tail
, make_number (id
));
1239 charset_ordered_list_tick
++;
1246 /* Same as Fdefine_charset_internal but arguments are more convenient
1247 to call from C (typically in syms_of_charset). This can define a
1248 charset of `offset' method only. Return the ID of the new
1252 define_charset_internal (Lisp_Object name
,
1254 const char *code_space_chars
,
1255 unsigned min_code
, unsigned max_code
,
1256 int iso_final
, int iso_revision
, int emacs_mule_id
,
1257 int ascii_compatible
, int supplementary
,
1260 const unsigned char *code_space
= (const unsigned char *) code_space_chars
;
1261 Lisp_Object args
[charset_arg_max
];
1265 args
[charset_arg_name
] = name
;
1266 args
[charset_arg_dimension
] = make_number (dimension
);
1267 val
= Fmake_vector (make_number (8), make_number (0));
1268 for (i
= 0; i
< 8; i
++)
1269 ASET (val
, i
, make_number (code_space
[i
]));
1270 args
[charset_arg_code_space
] = val
;
1271 args
[charset_arg_min_code
] = make_number (min_code
);
1272 args
[charset_arg_max_code
] = make_number (max_code
);
1273 args
[charset_arg_iso_final
]
1274 = (iso_final
< 0 ? Qnil
: make_number (iso_final
));
1275 args
[charset_arg_iso_revision
] = make_number (iso_revision
);
1276 args
[charset_arg_emacs_mule_id
]
1277 = (emacs_mule_id
< 0 ? Qnil
: make_number (emacs_mule_id
));
1278 args
[charset_arg_ascii_compatible_p
] = ascii_compatible
? Qt
: Qnil
;
1279 args
[charset_arg_supplementary_p
] = supplementary
? Qt
: Qnil
;
1280 args
[charset_arg_invalid_code
] = Qnil
;
1281 args
[charset_arg_code_offset
] = make_number (code_offset
);
1282 args
[charset_arg_map
] = Qnil
;
1283 args
[charset_arg_subset
] = Qnil
;
1284 args
[charset_arg_superset
] = Qnil
;
1285 args
[charset_arg_unify_map
] = Qnil
;
1287 args
[charset_arg_plist
] =
1288 listn (CONSTYPE_HEAP
, 14,
1289 intern_c_string (":name"),
1290 args
[charset_arg_name
],
1291 intern_c_string (":dimension"),
1292 args
[charset_arg_dimension
],
1293 intern_c_string (":code-space"),
1294 args
[charset_arg_code_space
],
1295 intern_c_string (":iso-final-char"),
1296 args
[charset_arg_iso_final
],
1297 intern_c_string (":emacs-mule-id"),
1298 args
[charset_arg_emacs_mule_id
],
1299 intern_c_string (":ascii-compatible-p"),
1300 args
[charset_arg_ascii_compatible_p
],
1301 intern_c_string (":code-offset"),
1302 args
[charset_arg_code_offset
]);
1303 Fdefine_charset_internal (charset_arg_max
, args
);
1305 return XINT (CHARSET_SYMBOL_ID (name
));
1309 DEFUN ("define-charset-alias", Fdefine_charset_alias
,
1310 Sdefine_charset_alias
, 2, 2, 0,
1311 doc
: /* Define ALIAS as an alias for charset CHARSET. */)
1312 (Lisp_Object alias
, Lisp_Object charset
)
1316 CHECK_CHARSET_GET_ATTR (charset
, attr
);
1317 Fputhash (alias
, attr
, Vcharset_hash_table
);
1318 Vcharset_list
= Fcons (alias
, Vcharset_list
);
1323 DEFUN ("charset-plist", Fcharset_plist
, Scharset_plist
, 1, 1, 0,
1324 doc
: /* Return the property list of CHARSET. */)
1325 (Lisp_Object charset
)
1329 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1330 return CHARSET_ATTR_PLIST (attrs
);
1334 DEFUN ("set-charset-plist", Fset_charset_plist
, Sset_charset_plist
, 2, 2, 0,
1335 doc
: /* Set CHARSET's property list to PLIST. */)
1336 (Lisp_Object charset
, Lisp_Object plist
)
1340 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1341 ASET (attrs
, charset_plist
, plist
);
1346 DEFUN ("unify-charset", Funify_charset
, Sunify_charset
, 1, 3, 0,
1347 doc
: /* Unify characters of CHARSET with Unicode.
1348 This means reading the relevant file and installing the table defined
1349 by CHARSET's `:unify-map' property.
1351 Optional second arg UNIFY-MAP is a file name string or a vector. It has
1352 the same meaning as the `:unify-map' attribute in the function
1353 `define-charset' (which see).
1355 Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET. */)
1356 (Lisp_Object charset
, Lisp_Object unify_map
, Lisp_Object deunify
)
1361 CHECK_CHARSET_GET_ID (charset
, id
);
1362 cs
= CHARSET_FROM_ID (id
);
1364 ? CHARSET_UNIFIED_P (cs
) && ! NILP (CHARSET_DEUNIFIER (cs
))
1365 : ! CHARSET_UNIFIED_P (cs
))
1368 CHARSET_UNIFIED_P (cs
) = 0;
1371 if (CHARSET_METHOD (cs
) != CHARSET_METHOD_OFFSET
1372 || CHARSET_CODE_OFFSET (cs
) < 0x110000)
1373 error ("Can't unify charset: %s", SDATA (SYMBOL_NAME (charset
)));
1374 if (NILP (unify_map
))
1375 unify_map
= CHARSET_UNIFY_MAP (cs
);
1378 if (! STRINGP (unify_map
) && ! VECTORP (unify_map
))
1379 signal_error ("Bad unify-map", unify_map
);
1380 set_charset_attr (cs
, charset_unify_map
, unify_map
);
1382 if (NILP (Vchar_unify_table
))
1383 Vchar_unify_table
= Fmake_char_table (Qnil
, Qnil
);
1384 char_table_set_range (Vchar_unify_table
,
1385 cs
->min_char
, cs
->max_char
, charset
);
1386 CHARSET_UNIFIED_P (cs
) = 1;
1388 else if (CHAR_TABLE_P (Vchar_unify_table
))
1390 unsigned min_code
= CHARSET_MIN_CODE (cs
);
1391 unsigned max_code
= CHARSET_MAX_CODE (cs
);
1392 int min_char
= DECODE_CHAR (cs
, min_code
);
1393 int max_char
= DECODE_CHAR (cs
, max_code
);
1395 char_table_set_range (Vchar_unify_table
, min_char
, max_char
, Qnil
);
1401 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char
,
1402 Sget_unused_iso_final_char
, 2, 2, 0,
1404 Return an unused ISO final char for a charset of DIMENSION and CHARS.
1405 DIMENSION is the number of bytes to represent a character: 1 or 2.
1406 CHARS is the number of characters in a dimension: 94 or 96.
1408 This final char is for private use, thus the range is `0' (48) .. `?' (63).
1409 If there's no unused final char for the specified kind of charset,
1411 (Lisp_Object dimension
, Lisp_Object chars
)
1415 CHECK_NUMBER (dimension
);
1416 CHECK_NUMBER (chars
);
1417 if (XINT (dimension
) != 1 && XINT (dimension
) != 2 && XINT (dimension
) != 3)
1418 args_out_of_range_3 (dimension
, make_number (1), make_number (3));
1419 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1420 args_out_of_range_3 (chars
, make_number (94), make_number (96));
1421 for (final_char
= '0'; final_char
<= '?'; final_char
++)
1422 if (ISO_CHARSET_TABLE (XINT (dimension
), XINT (chars
), final_char
) < 0)
1424 return (final_char
<= '?' ? make_number (final_char
) : Qnil
);
1428 check_iso_charset_parameter (Lisp_Object dimension
, Lisp_Object chars
, Lisp_Object final_char
)
1430 CHECK_NATNUM (dimension
);
1431 CHECK_NATNUM (chars
);
1432 CHECK_CHARACTER (final_char
);
1434 if (XINT (dimension
) > 3)
1435 error ("Invalid DIMENSION %"pI
"d, it should be 1, 2, or 3",
1437 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1438 error ("Invalid CHARS %"pI
"d, it should be 94 or 96", XINT (chars
));
1439 if (XINT (final_char
) < '0' || XINT (final_char
) > '~')
1440 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'",
1441 (int)XINT (final_char
));
1445 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
1447 doc
: /* Declare an equivalent charset for ISO-2022 decoding.
1449 On decoding by an ISO-2022 base coding system, when a charset
1450 specified by DIMENSION, CHARS, and FINAL-CHAR is designated, behave as
1451 if CHARSET is designated instead. */)
1452 (Lisp_Object dimension
, Lisp_Object chars
, Lisp_Object final_char
, Lisp_Object charset
)
1457 CHECK_CHARSET_GET_ID (charset
, id
);
1458 check_iso_charset_parameter (dimension
, chars
, final_char
);
1459 chars_flag
= XINT (chars
) == 96;
1460 ISO_CHARSET_TABLE (XINT (dimension
), chars_flag
, XINT (final_char
)) = id
;
1465 /* Return information about charsets in the text at PTR of NBYTES
1466 bytes, which are NCHARS characters. The value is:
1468 0: Each character is represented by one byte. This is always
1469 true for a unibyte string. For a multibyte string, true if
1470 it contains only ASCII characters.
1472 1: No charsets other than ascii, control-1, and latin-1 are
1479 string_xstring_p (Lisp_Object string
)
1481 const unsigned char *p
= SDATA (string
);
1482 const unsigned char *endp
= p
+ SBYTES (string
);
1484 if (SCHARS (string
) == SBYTES (string
))
1489 int c
= STRING_CHAR_ADVANCE (p
);
1498 /* Find charsets in the string at PTR of NCHARS and NBYTES.
1500 CHARSETS is a vector. If Nth element is non-nil, it means the
1501 charset whose id is N is already found.
1503 It may lookup a translation table TABLE if supplied. */
1506 find_charsets_in_text (const unsigned char *ptr
, ptrdiff_t nchars
, ptrdiff_t nbytes
, Lisp_Object charsets
, Lisp_Object table
, int multibyte
)
1508 const unsigned char *pend
= ptr
+ nbytes
;
1510 if (nchars
== nbytes
)
1513 ASET (charsets
, charset_ascii
, Qt
);
1520 c
= translate_char (table
, c
);
1521 if (ASCII_BYTE_P (c
))
1522 ASET (charsets
, charset_ascii
, Qt
);
1524 ASET (charsets
, charset_eight_bit
, Qt
);
1531 int c
= STRING_CHAR_ADVANCE (ptr
);
1532 struct charset
*charset
;
1535 c
= translate_char (table
, c
);
1536 charset
= CHAR_CHARSET (c
);
1537 ASET (charsets
, CHARSET_ID (charset
), Qt
);
1542 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
1544 doc
: /* Return a list of charsets in the region between BEG and END.
1545 BEG and END are buffer positions.
1546 Optional arg TABLE if non-nil is a translation table to look up.
1548 If the current buffer is unibyte, the returned list may contain
1549 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1550 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object table
)
1552 Lisp_Object charsets
;
1553 ptrdiff_t from
, from_byte
, to
, stop
, stop_byte
;
1556 int multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
1558 validate_region (&beg
, &end
);
1559 from
= XFASTINT (beg
);
1560 stop
= to
= XFASTINT (end
);
1562 if (from
< GPT
&& GPT
< to
)
1565 stop_byte
= GPT_BYTE
;
1568 stop_byte
= CHAR_TO_BYTE (stop
);
1570 from_byte
= CHAR_TO_BYTE (from
);
1572 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1575 find_charsets_in_text (BYTE_POS_ADDR (from_byte
), stop
- from
,
1576 stop_byte
- from_byte
, charsets
, table
,
1580 from
= stop
, from_byte
= stop_byte
;
1581 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
1588 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1589 if (!NILP (AREF (charsets
, i
)))
1590 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1594 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
1596 doc
: /* Return a list of charsets in STR.
1597 Optional arg TABLE if non-nil is a translation table to look up.
1599 If STR is unibyte, the returned list may contain
1600 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1601 (Lisp_Object str
, Lisp_Object table
)
1603 Lisp_Object charsets
;
1609 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1610 find_charsets_in_text (SDATA (str
), SCHARS (str
), SBYTES (str
),
1612 STRING_MULTIBYTE (str
));
1614 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1615 if (!NILP (AREF (charsets
, i
)))
1616 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1622 /* Return a unified character code for C (>= 0x110000). VAL is a
1623 value of Vchar_unify_table for C; i.e. it is nil, an integer, or a
1626 maybe_unify_char (int c
, Lisp_Object val
)
1628 struct charset
*charset
;
1631 return XFASTINT (val
);
1635 CHECK_CHARSET_GET_CHARSET (val
, charset
);
1637 /* The call to load_charset below can allocate memory, which screws
1638 callers of this function through STRING_CHAR_* macros that hold C
1639 pointers to buffer text, if REL_ALLOC is used. */
1640 r_alloc_inhibit_buffer_relocation (1);
1642 load_charset (charset
, 1);
1643 if (! inhibit_load_charset_map
)
1645 val
= CHAR_TABLE_REF (Vchar_unify_table
, c
);
1651 int code_index
= c
- CHARSET_CODE_OFFSET (charset
);
1652 int unified
= GET_TEMP_CHARSET_WORK_DECODER (code_index
);
1658 r_alloc_inhibit_buffer_relocation (0);
1664 /* Return a character corresponding to the code-point CODE of
1668 decode_char (struct charset
*charset
, unsigned int code
)
1671 enum charset_method method
= CHARSET_METHOD (charset
);
1673 if (code
< CHARSET_MIN_CODE (charset
) || code
> CHARSET_MAX_CODE (charset
))
1676 if (method
== CHARSET_METHOD_SUBSET
)
1678 Lisp_Object subset_info
;
1680 subset_info
= CHARSET_SUBSET (charset
);
1681 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1682 code
-= XINT (AREF (subset_info
, 3));
1683 if (code
< XFASTINT (AREF (subset_info
, 1))
1684 || code
> XFASTINT (AREF (subset_info
, 2)))
1687 c
= DECODE_CHAR (charset
, code
);
1689 else if (method
== CHARSET_METHOD_SUPERSET
)
1691 Lisp_Object parents
;
1693 parents
= CHARSET_SUPERSET (charset
);
1695 for (; CONSP (parents
); parents
= XCDR (parents
))
1697 int id
= XINT (XCAR (XCAR (parents
)));
1698 int code_offset
= XINT (XCDR (XCAR (parents
)));
1699 unsigned this_code
= code
- code_offset
;
1701 charset
= CHARSET_FROM_ID (id
);
1702 if ((c
= DECODE_CHAR (charset
, this_code
)) >= 0)
1708 char_index
= CODE_POINT_TO_INDEX (charset
, code
);
1712 if (method
== CHARSET_METHOD_MAP
)
1714 Lisp_Object decoder
;
1716 decoder
= CHARSET_DECODER (charset
);
1717 if (! VECTORP (decoder
))
1719 load_charset (charset
, 1);
1720 decoder
= CHARSET_DECODER (charset
);
1722 if (VECTORP (decoder
))
1723 c
= XINT (AREF (decoder
, char_index
));
1725 c
= GET_TEMP_CHARSET_WORK_DECODER (char_index
);
1727 else /* method == CHARSET_METHOD_OFFSET */
1729 c
= char_index
+ CHARSET_CODE_OFFSET (charset
);
1730 if (CHARSET_UNIFIED_P (charset
)
1731 && c
> MAX_UNICODE_CHAR
)
1732 MAYBE_UNIFY_CHAR (c
);
1739 /* Variable used temporarily by the macro ENCODE_CHAR. */
1740 Lisp_Object charset_work
;
1742 /* Return a code-point of CHAR in CHARSET. If CHAR doesn't belong to
1743 CHARSET, return CHARSET_INVALID_CODE (CHARSET). If STRICT is true,
1744 use CHARSET's strict_max_char instead of max_char. */
1747 encode_char (struct charset
*charset
, int c
)
1750 enum charset_method method
= CHARSET_METHOD (charset
);
1752 if (CHARSET_UNIFIED_P (charset
))
1754 Lisp_Object deunifier
;
1755 int code_index
= -1;
1757 deunifier
= CHARSET_DEUNIFIER (charset
);
1758 if (! CHAR_TABLE_P (deunifier
))
1760 load_charset (charset
, 2);
1761 deunifier
= CHARSET_DEUNIFIER (charset
);
1763 if (CHAR_TABLE_P (deunifier
))
1765 Lisp_Object deunified
= CHAR_TABLE_REF (deunifier
, c
);
1767 if (INTEGERP (deunified
))
1768 code_index
= XINT (deunified
);
1772 code_index
= GET_TEMP_CHARSET_WORK_ENCODER (c
);
1774 if (code_index
>= 0)
1775 c
= CHARSET_CODE_OFFSET (charset
) + code_index
;
1778 if (method
== CHARSET_METHOD_SUBSET
)
1780 Lisp_Object subset_info
;
1781 struct charset
*this_charset
;
1783 subset_info
= CHARSET_SUBSET (charset
);
1784 this_charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1785 code
= ENCODE_CHAR (this_charset
, c
);
1786 if (code
== CHARSET_INVALID_CODE (this_charset
)
1787 || code
< XFASTINT (AREF (subset_info
, 1))
1788 || code
> XFASTINT (AREF (subset_info
, 2)))
1789 return CHARSET_INVALID_CODE (charset
);
1790 code
+= XINT (AREF (subset_info
, 3));
1794 if (method
== CHARSET_METHOD_SUPERSET
)
1796 Lisp_Object parents
;
1798 parents
= CHARSET_SUPERSET (charset
);
1799 for (; CONSP (parents
); parents
= XCDR (parents
))
1801 int id
= XINT (XCAR (XCAR (parents
)));
1802 int code_offset
= XINT (XCDR (XCAR (parents
)));
1803 struct charset
*this_charset
= CHARSET_FROM_ID (id
);
1805 code
= ENCODE_CHAR (this_charset
, c
);
1806 if (code
!= CHARSET_INVALID_CODE (this_charset
))
1807 return code
+ code_offset
;
1809 return CHARSET_INVALID_CODE (charset
);
1812 if (! CHARSET_FAST_MAP_REF ((c
), charset
->fast_map
)
1813 || c
< CHARSET_MIN_CHAR (charset
) || c
> CHARSET_MAX_CHAR (charset
))
1814 return CHARSET_INVALID_CODE (charset
);
1816 if (method
== CHARSET_METHOD_MAP
)
1818 Lisp_Object encoder
;
1821 encoder
= CHARSET_ENCODER (charset
);
1822 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
1824 load_charset (charset
, 2);
1825 encoder
= CHARSET_ENCODER (charset
);
1827 if (CHAR_TABLE_P (encoder
))
1829 val
= CHAR_TABLE_REF (encoder
, c
);
1831 return CHARSET_INVALID_CODE (charset
);
1833 if (! CHARSET_COMPACT_CODES_P (charset
))
1834 code
= INDEX_TO_CODE_POINT (charset
, code
);
1838 code
= GET_TEMP_CHARSET_WORK_ENCODER (c
);
1839 code
= INDEX_TO_CODE_POINT (charset
, code
);
1842 else /* method == CHARSET_METHOD_OFFSET */
1844 unsigned code_index
= c
- CHARSET_CODE_OFFSET (charset
);
1846 code
= INDEX_TO_CODE_POINT (charset
, code_index
);
1853 DEFUN ("decode-char", Fdecode_char
, Sdecode_char
, 2, 3, 0,
1854 doc
: /* Decode the pair of CHARSET and CODE-POINT into a character.
1855 Return nil if CODE-POINT is not valid in CHARSET.
1857 CODE-POINT may be a cons (HIGHER-16-BIT-VALUE . LOWER-16-BIT-VALUE).
1859 Optional argument RESTRICTION specifies a way to map the pair of CCS
1860 and CODE-POINT to a character. Currently not supported and just ignored. */)
1861 (Lisp_Object charset
, Lisp_Object code_point
, Lisp_Object restriction
)
1865 struct charset
*charsetp
;
1867 CHECK_CHARSET_GET_ID (charset
, id
);
1868 code
= cons_to_unsigned (code_point
, UINT_MAX
);
1869 charsetp
= CHARSET_FROM_ID (id
);
1870 c
= DECODE_CHAR (charsetp
, code
);
1871 return (c
>= 0 ? make_number (c
) : Qnil
);
1875 DEFUN ("encode-char", Fencode_char
, Sencode_char
, 2, 3, 0,
1876 doc
: /* Encode the character CH into a code-point of CHARSET.
1877 Return nil if CHARSET doesn't include CH.
1879 Optional argument RESTRICTION specifies a way to map CH to a
1880 code-point in CCS. Currently not supported and just ignored. */)
1881 (Lisp_Object ch
, Lisp_Object charset
, Lisp_Object restriction
)
1885 struct charset
*charsetp
;
1887 CHECK_CHARSET_GET_ID (charset
, id
);
1888 CHECK_CHARACTER (ch
);
1890 charsetp
= CHARSET_FROM_ID (id
);
1891 code
= ENCODE_CHAR (charsetp
, c
);
1892 if (code
== CHARSET_INVALID_CODE (charsetp
))
1894 return INTEGER_TO_CONS (code
);
1898 DEFUN ("make-char", Fmake_char
, Smake_char
, 1, 5, 0,
1900 /* Return a character of CHARSET whose position codes are CODEn.
1902 CODE1 through CODE4 are optional, but if you don't supply sufficient
1903 position codes, it is assumed that the minimum code in each dimension
1905 (Lisp_Object charset
, Lisp_Object code1
, Lisp_Object code2
, Lisp_Object code3
, Lisp_Object code4
)
1908 struct charset
*charsetp
;
1912 CHECK_CHARSET_GET_ID (charset
, id
);
1913 charsetp
= CHARSET_FROM_ID (id
);
1915 dimension
= CHARSET_DIMENSION (charsetp
);
1917 code
= (CHARSET_ASCII_COMPATIBLE_P (charsetp
)
1918 ? 0 : CHARSET_MIN_CODE (charsetp
));
1921 CHECK_NATNUM (code1
);
1922 if (XFASTINT (code1
) >= 0x100)
1923 args_out_of_range (make_number (0xFF), code1
);
1924 code
= XFASTINT (code1
);
1930 code
|= charsetp
->code_space
[(dimension
- 2) * 4];
1933 CHECK_NATNUM (code2
);
1934 if (XFASTINT (code2
) >= 0x100)
1935 args_out_of_range (make_number (0xFF), code2
);
1936 code
|= XFASTINT (code2
);
1943 code
|= charsetp
->code_space
[(dimension
- 3) * 4];
1946 CHECK_NATNUM (code3
);
1947 if (XFASTINT (code3
) >= 0x100)
1948 args_out_of_range (make_number (0xFF), code3
);
1949 code
|= XFASTINT (code3
);
1956 code
|= charsetp
->code_space
[0];
1959 CHECK_NATNUM (code4
);
1960 if (XFASTINT (code4
) >= 0x100)
1961 args_out_of_range (make_number (0xFF), code4
);
1962 code
|= XFASTINT (code4
);
1969 if (CHARSET_ISO_FINAL (charsetp
) >= 0)
1971 c
= DECODE_CHAR (charsetp
, code
);
1973 error ("Invalid code(s)");
1974 return make_number (c
);
1978 /* Return the first charset in CHARSET_LIST that contains C.
1979 CHARSET_LIST is a list of charset IDs. If it is nil, use
1980 Vcharset_ordered_list. */
1983 char_charset (int c
, Lisp_Object charset_list
, unsigned int *code_return
)
1987 if (NILP (charset_list
))
1988 charset_list
= Vcharset_ordered_list
;
1992 while (CONSP (charset_list
))
1994 struct charset
*charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
1995 unsigned code
= ENCODE_CHAR (charset
, c
);
1997 if (code
!= CHARSET_INVALID_CODE (charset
))
2000 *code_return
= code
;
2003 charset_list
= XCDR (charset_list
);
2005 && c
<= MAX_UNICODE_CHAR
2006 && EQ (charset_list
, Vcharset_non_preferred_head
))
2007 return CHARSET_FROM_ID (charset_unicode
);
2009 return (maybe_null
? NULL
2010 : c
<= MAX_5_BYTE_CHAR
? CHARSET_FROM_ID (charset_emacs
)
2011 : CHARSET_FROM_ID (charset_eight_bit
));
2015 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
2017 /*Return list of charset and one to four position-codes of CH.
2018 The charset is decided by the current priority order of charsets.
2019 A position-code is a byte value of each dimension of the code-point of
2020 CH in the charset. */)
2023 struct charset
*charset
;
2028 CHECK_CHARACTER (ch
);
2030 charset
= CHAR_CHARSET (c
);
2033 code
= ENCODE_CHAR (charset
, c
);
2034 if (code
== CHARSET_INVALID_CODE (charset
))
2036 dimension
= CHARSET_DIMENSION (charset
);
2037 for (val
= Qnil
; dimension
> 0; dimension
--)
2039 val
= Fcons (make_number (code
& 0xFF), val
);
2042 return Fcons (CHARSET_NAME (charset
), val
);
2046 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 2, 0,
2047 doc
: /* Return the charset of highest priority that contains CH.
2048 If optional 2nd arg RESTRICTION is non-nil, it is a list of charsets
2049 from which to find the charset. It may also be a coding system. In
2050 that case, find the charset from what supported by that coding system. */)
2051 (Lisp_Object ch
, Lisp_Object restriction
)
2053 struct charset
*charset
;
2055 CHECK_CHARACTER (ch
);
2056 if (NILP (restriction
))
2057 charset
= CHAR_CHARSET (XINT (ch
));
2060 if (CONSP (restriction
))
2062 int c
= XFASTINT (ch
);
2064 for (; CONSP (restriction
); restriction
= XCDR (restriction
))
2066 struct charset
*rcharset
;
2068 CHECK_CHARSET_GET_CHARSET (XCAR (restriction
), rcharset
);
2069 if (ENCODE_CHAR (rcharset
, c
) != CHARSET_INVALID_CODE (rcharset
))
2070 return XCAR (restriction
);
2074 restriction
= coding_system_charset_list (restriction
);
2075 charset
= char_charset (XINT (ch
), restriction
, NULL
);
2079 return (CHARSET_NAME (charset
));
2083 DEFUN ("charset-after", Fcharset_after
, Scharset_after
, 0, 1, 0,
2085 Return charset of a character in the current buffer at position POS.
2086 If POS is nil, it defaults to the current point.
2087 If POS is out of range, the value is nil. */)
2091 struct charset
*charset
;
2093 ch
= Fchar_after (pos
);
2094 if (! INTEGERP (ch
))
2096 charset
= CHAR_CHARSET (XINT (ch
));
2097 return (CHARSET_NAME (charset
));
2101 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
2103 Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.
2105 ISO 2022's designation sequence (escape sequence) distinguishes charsets
2106 by their DIMENSION, CHARS, and FINAL-CHAR,
2107 whereas Emacs distinguishes them by charset symbol.
2108 See the documentation of the function `charset-info' for the meanings of
2109 DIMENSION, CHARS, and FINAL-CHAR. */)
2110 (Lisp_Object dimension
, Lisp_Object chars
, Lisp_Object final_char
)
2115 check_iso_charset_parameter (dimension
, chars
, final_char
);
2116 chars_flag
= XFASTINT (chars
) == 96;
2117 id
= ISO_CHARSET_TABLE (XFASTINT (dimension
), chars_flag
,
2118 XFASTINT (final_char
));
2119 return (id
>= 0 ? CHARSET_NAME (CHARSET_FROM_ID (id
)) : Qnil
);
2123 DEFUN ("clear-charset-maps", Fclear_charset_maps
, Sclear_charset_maps
,
2127 Clear temporary charset mapping tables.
2128 It should be called only from temacs invoked for dumping. */)
2131 if (temp_charset_work
)
2133 xfree (temp_charset_work
);
2134 temp_charset_work
= NULL
;
2137 if (CHAR_TABLE_P (Vchar_unify_table
))
2138 Foptimize_char_table (Vchar_unify_table
, Qnil
);
2143 DEFUN ("charset-priority-list", Fcharset_priority_list
,
2144 Scharset_priority_list
, 0, 1, 0,
2145 doc
: /* Return the list of charsets ordered by priority.
2146 HIGHESTP non-nil means just return the highest priority one. */)
2147 (Lisp_Object highestp
)
2149 Lisp_Object val
= Qnil
, list
= Vcharset_ordered_list
;
2151 if (!NILP (highestp
))
2152 return CHARSET_NAME (CHARSET_FROM_ID (XINT (Fcar (list
))));
2154 while (!NILP (list
))
2156 val
= Fcons (CHARSET_NAME (CHARSET_FROM_ID (XINT (XCAR (list
)))), val
);
2159 return Fnreverse (val
);
2162 DEFUN ("set-charset-priority", Fset_charset_priority
, Sset_charset_priority
,
2164 doc
: /* Assign higher priority to the charsets given as arguments.
2165 usage: (set-charset-priority &rest charsets) */)
2166 (ptrdiff_t nargs
, Lisp_Object
*args
)
2168 Lisp_Object new_head
, old_list
, arglist
[2];
2169 Lisp_Object list_2022
, list_emacs_mule
;
2173 old_list
= Fcopy_sequence (Vcharset_ordered_list
);
2175 for (i
= 0; i
< nargs
; i
++)
2177 CHECK_CHARSET_GET_ID (args
[i
], id
);
2178 if (! NILP (Fmemq (make_number (id
), old_list
)))
2180 old_list
= Fdelq (make_number (id
), old_list
);
2181 new_head
= Fcons (make_number (id
), new_head
);
2184 arglist
[0] = Fnreverse (new_head
);
2185 arglist
[1] = Vcharset_non_preferred_head
= old_list
;
2186 Vcharset_ordered_list
= Fnconc (2, arglist
);
2187 charset_ordered_list_tick
++;
2189 charset_unibyte
= -1;
2190 for (old_list
= Vcharset_ordered_list
, list_2022
= list_emacs_mule
= Qnil
;
2191 CONSP (old_list
); old_list
= XCDR (old_list
))
2193 if (! NILP (Fmemq (XCAR (old_list
), Viso_2022_charset_list
)))
2194 list_2022
= Fcons (XCAR (old_list
), list_2022
);
2195 if (! NILP (Fmemq (XCAR (old_list
), Vemacs_mule_charset_list
)))
2196 list_emacs_mule
= Fcons (XCAR (old_list
), list_emacs_mule
);
2197 if (charset_unibyte
< 0)
2199 struct charset
*charset
= CHARSET_FROM_ID (XINT (XCAR (old_list
)));
2201 if (CHARSET_DIMENSION (charset
) == 1
2202 && CHARSET_ASCII_COMPATIBLE_P (charset
)
2203 && CHARSET_MAX_CHAR (charset
) >= 0x80)
2204 charset_unibyte
= CHARSET_ID (charset
);
2207 Viso_2022_charset_list
= Fnreverse (list_2022
);
2208 Vemacs_mule_charset_list
= Fnreverse (list_emacs_mule
);
2209 if (charset_unibyte
< 0)
2210 charset_unibyte
= charset_iso_8859_1
;
2215 DEFUN ("charset-id-internal", Fcharset_id_internal
, Scharset_id_internal
,
2217 doc
: /* Internal use only.
2218 Return charset identification number of CHARSET. */)
2219 (Lisp_Object charset
)
2223 CHECK_CHARSET_GET_ID (charset
, id
);
2224 return make_number (id
);
2227 struct charset_sort_data
2229 Lisp_Object charset
;
2235 charset_compare (const void *d1
, const void *d2
)
2237 const struct charset_sort_data
*data1
= d1
, *data2
= d2
;
2238 if (data1
->priority
!= data2
->priority
)
2239 return data1
->priority
< data2
->priority
? -1 : 1;
2243 DEFUN ("sort-charsets", Fsort_charsets
, Ssort_charsets
, 1, 1, 0,
2244 doc
: /* Sort charset list CHARSETS by a priority of each charset.
2245 Return the sorted list. CHARSETS is modified by side effects.
2246 See also `charset-priority-list' and `set-charset-priority'. */)
2247 (Lisp_Object charsets
)
2249 Lisp_Object len
= Flength (charsets
);
2250 ptrdiff_t n
= XFASTINT (len
), i
, j
;
2252 Lisp_Object tail
, elt
, attrs
;
2253 struct charset_sort_data
*sort_data
;
2254 int id
, min_id
= INT_MAX
, max_id
= INT_MIN
;
2259 SAFE_NALLOCA (sort_data
, 1, n
);
2260 for (tail
= charsets
, i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
2263 CHECK_CHARSET_GET_ATTR (elt
, attrs
);
2264 sort_data
[i
].charset
= elt
;
2265 sort_data
[i
].id
= id
= XINT (CHARSET_ATTR_ID (attrs
));
2271 for (done
= 0, tail
= Vcharset_ordered_list
, i
= 0;
2272 done
< n
&& CONSP (tail
); tail
= XCDR (tail
), i
++)
2275 id
= XFASTINT (elt
);
2276 if (id
>= min_id
&& id
<= max_id
)
2277 for (j
= 0; j
< n
; j
++)
2278 if (sort_data
[j
].id
== id
)
2280 sort_data
[j
].priority
= i
;
2284 qsort (sort_data
, n
, sizeof *sort_data
, charset_compare
);
2285 for (i
= 0, tail
= charsets
; CONSP (tail
); tail
= XCDR (tail
), i
++)
2286 XSETCAR (tail
, sort_data
[i
].charset
);
2295 Lisp_Object tempdir
;
2296 tempdir
= Fexpand_file_name (build_string ("charsets"), Vdata_directory
);
2297 if (access (SSDATA (tempdir
), 0) < 0)
2299 /* This used to be non-fatal (dir_warning), but it should not
2300 happen, and if it does sooner or later it will cause some
2301 obscure problem (eg bug#6401), so better abort. */
2302 fprintf (stderr
, "Error: charsets directory not found:\n\
2304 Emacs will not function correctly without the character map files.\n\
2305 Please check your installation!\n",
2310 Vcharset_map_path
= Fcons (tempdir
, Qnil
);
2315 init_charset_once (void)
2319 for (i
= 0; i
< ISO_MAX_DIMENSION
; i
++)
2320 for (j
= 0; j
< ISO_MAX_CHARS
; j
++)
2321 for (k
= 0; k
< ISO_MAX_FINAL
; k
++)
2322 iso_charset_table
[i
][j
][k
] = -1;
2324 for (i
= 0; i
< 256; i
++)
2325 emacs_mule_charset
[i
] = -1;
2327 charset_jisx0201_roman
= -1;
2328 charset_jisx0208_1978
= -1;
2329 charset_jisx0208
= -1;
2330 charset_ksc5601
= -1;
2335 /* Allocate an initial charset table that is large enough to handle
2336 Emacs while it is bootstrapping. As of September 2011, the size
2337 needs to be at least 166; make it a bit bigger to allow for future
2340 Don't make the value so small that the table is reallocated during
2341 bootstrapping, as glibc malloc calls larger than just under 64 KiB
2342 during an initial bootstrap wreak havoc after dumping; see the
2343 M_MMAP_THRESHOLD value in alloc.c, plus there is a extra overhead
2344 internal to glibc malloc and perhaps to Emacs malloc debugging. */
2345 static struct charset charset_table_init
[180];
2348 syms_of_charset (void)
2350 DEFSYM (Qcharsetp
, "charsetp");
2352 DEFSYM (Qascii
, "ascii");
2353 DEFSYM (Qunicode
, "unicode");
2354 DEFSYM (Qemacs
, "emacs");
2355 DEFSYM (Qeight_bit
, "eight-bit");
2356 DEFSYM (Qiso_8859_1
, "iso-8859-1");
2361 staticpro (&Vcharset_ordered_list
);
2362 Vcharset_ordered_list
= Qnil
;
2364 staticpro (&Viso_2022_charset_list
);
2365 Viso_2022_charset_list
= Qnil
;
2367 staticpro (&Vemacs_mule_charset_list
);
2368 Vemacs_mule_charset_list
= Qnil
;
2370 /* Don't staticpro them here. It's done in syms_of_fns. */
2371 QCtest
= intern_c_string (":test");
2372 Qeq
= intern_c_string ("eq");
2374 staticpro (&Vcharset_hash_table
);
2376 Lisp_Object args
[2];
2379 Vcharset_hash_table
= Fmake_hash_table (2, args
);
2382 charset_table
= charset_table_init
;
2383 charset_table_size
= sizeof charset_table_init
/ sizeof *charset_table_init
;
2384 charset_table_used
= 0;
2386 defsubr (&Scharsetp
);
2387 defsubr (&Smap_charset_chars
);
2388 defsubr (&Sdefine_charset_internal
);
2389 defsubr (&Sdefine_charset_alias
);
2390 defsubr (&Scharset_plist
);
2391 defsubr (&Sset_charset_plist
);
2392 defsubr (&Sunify_charset
);
2393 defsubr (&Sget_unused_iso_final_char
);
2394 defsubr (&Sdeclare_equiv_charset
);
2395 defsubr (&Sfind_charset_region
);
2396 defsubr (&Sfind_charset_string
);
2397 defsubr (&Sdecode_char
);
2398 defsubr (&Sencode_char
);
2399 defsubr (&Ssplit_char
);
2400 defsubr (&Smake_char
);
2401 defsubr (&Schar_charset
);
2402 defsubr (&Scharset_after
);
2403 defsubr (&Siso_charset
);
2404 defsubr (&Sclear_charset_maps
);
2405 defsubr (&Scharset_priority_list
);
2406 defsubr (&Sset_charset_priority
);
2407 defsubr (&Scharset_id_internal
);
2408 defsubr (&Ssort_charsets
);
2410 DEFVAR_LISP ("charset-map-path", Vcharset_map_path
,
2411 doc
: /* List of directories to search for charset map files. */);
2412 Vcharset_map_path
= Qnil
;
2414 DEFVAR_BOOL ("inhibit-load-charset-map", inhibit_load_charset_map
,
2415 doc
: /* Inhibit loading of charset maps. Used when dumping Emacs. */);
2416 inhibit_load_charset_map
= 0;
2418 DEFVAR_LISP ("charset-list", Vcharset_list
,
2419 doc
: /* List of all charsets ever defined. */);
2420 Vcharset_list
= Qnil
;
2422 DEFVAR_LISP ("current-iso639-language", Vcurrent_iso639_language
,
2423 doc
: /* ISO639 language mnemonic symbol for the current language environment.
2424 If the current language environment is for multiple languages (e.g. "Latin-1"),
2425 the value may be a list of mnemonics. */);
2426 Vcurrent_iso639_language
= Qnil
;
2429 = define_charset_internal (Qascii
, 1, "\x00\x7F\x00\x00\x00\x00",
2430 0, 127, 'B', -1, 0, 1, 0, 0);
2432 = define_charset_internal (Qiso_8859_1
, 1, "\x00\xFF\x00\x00\x00\x00",
2433 0, 255, -1, -1, -1, 1, 0, 0);
2435 = define_charset_internal (Qunicode
, 3, "\x00\xFF\x00\xFF\x00\x10",
2436 0, MAX_UNICODE_CHAR
, -1, 0, -1, 1, 0, 0);
2438 = define_charset_internal (Qemacs
, 3, "\x00\xFF\x00\xFF\x00\x3F",
2439 0, MAX_5_BYTE_CHAR
, -1, 0, -1, 1, 1, 0);
2441 = define_charset_internal (Qeight_bit
, 1, "\x80\xFF\x00\x00\x00\x00",
2442 128, 255, -1, 0, -1, 0, 1,
2443 MAX_5_BYTE_CHAR
+ 1);
2444 charset_unibyte
= charset_iso_8859_1
;