1 /* Basic character set support.
2 Copyright (C) 2001-2013 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
34 #include <sys/types.h>
37 #include "character.h"
43 /*** GENERAL NOTES on CODED CHARACTER SETS (CHARSETS) ***
45 A coded character set ("charset" hereafter) is a meaningful
46 collection (i.e. language, culture, functionality, etc.) of
47 characters. Emacs handles multiple charsets at once. In Emacs Lisp
48 code, a charset is represented by a symbol. In C code, a charset is
49 represented by its ID number or by a pointer to a struct charset.
51 The actual information about each charset is stored in two places.
52 Lispy information is stored in the hash table Vcharset_hash_table as
53 a vector (charset attributes). The other information is stored in
54 charset_table as a struct charset.
58 /* Hash table that contains attributes of each charset. Keys are
59 charset symbols, and values are vectors of charset attributes. */
60 Lisp_Object Vcharset_hash_table
;
62 /* Table of struct charset. */
63 struct charset
*charset_table
;
65 static ptrdiff_t charset_table_size
;
66 static int charset_table_used
;
68 Lisp_Object Qcharsetp
;
70 /* Special charset symbols. */
72 static Lisp_Object Qeight_bit
;
73 static Lisp_Object Qiso_8859_1
;
74 static Lisp_Object Qunicode
;
75 static Lisp_Object Qemacs
;
77 /* The corresponding charsets. */
79 int charset_eight_bit
;
80 static int charset_iso_8859_1
;
82 static int charset_emacs
;
84 /* The other special charsets. */
85 int charset_jisx0201_roman
;
86 int charset_jisx0208_1978
;
90 /* Value of charset attribute `charset-iso-plane'. */
91 static Lisp_Object Qgl
, Qgr
;
93 /* Charset of unibyte characters. */
96 /* List of charsets ordered by the priority. */
97 Lisp_Object Vcharset_ordered_list
;
99 /* Sub-list of Vcharset_ordered_list that contains all non-preferred
101 Lisp_Object Vcharset_non_preferred_head
;
103 /* Incremented everytime we change Vcharset_ordered_list. This is
104 unsigned short so that it fits in Lisp_Int and never matches
106 unsigned short charset_ordered_list_tick
;
108 /* List of iso-2022 charsets. */
109 Lisp_Object Viso_2022_charset_list
;
111 /* List of emacs-mule charsets. */
112 Lisp_Object Vemacs_mule_charset_list
;
114 int emacs_mule_charset
[256];
116 /* Mapping table from ISO2022's charset (specified by DIMENSION,
117 CHARS, and FINAL-CHAR) to Emacs' charset. */
118 int iso_charset_table
[ISO_MAX_DIMENSION
][ISO_MAX_CHARS
][ISO_MAX_FINAL
];
120 #define CODE_POINT_TO_INDEX(charset, code) \
121 ((charset)->code_linear_p \
122 ? (int) ((code) - (charset)->min_code) \
123 : (((charset)->code_space_mask[(code) >> 24] & 0x8) \
124 && ((charset)->code_space_mask[((code) >> 16) & 0xFF] & 0x4) \
125 && ((charset)->code_space_mask[((code) >> 8) & 0xFF] & 0x2) \
126 && ((charset)->code_space_mask[(code) & 0xFF] & 0x1)) \
127 ? (int) (((((code) >> 24) - (charset)->code_space[12]) \
128 * (charset)->code_space[11]) \
129 + (((((code) >> 16) & 0xFF) - (charset)->code_space[8]) \
130 * (charset)->code_space[7]) \
131 + (((((code) >> 8) & 0xFF) - (charset)->code_space[4]) \
132 * (charset)->code_space[3]) \
133 + (((code) & 0xFF) - (charset)->code_space[0]) \
134 - ((charset)->char_index_offset)) \
138 /* Return the code-point for the character index IDX in CHARSET.
139 IDX should be an unsigned int variable in a valid range (which is
140 always in nonnegative int range too). IDX contains garbage afterwards. */
142 #define INDEX_TO_CODE_POINT(charset, idx) \
143 ((charset)->code_linear_p \
144 ? (idx) + (charset)->min_code \
145 : (idx += (charset)->char_index_offset, \
146 (((charset)->code_space[0] + (idx) % (charset)->code_space[2]) \
147 | (((charset)->code_space[4] \
148 + ((idx) / (charset)->code_space[3] % (charset)->code_space[6])) \
150 | (((charset)->code_space[8] \
151 + ((idx) / (charset)->code_space[7] % (charset)->code_space[10])) \
153 | (((charset)->code_space[12] + ((idx) / (charset)->code_space[11])) \
156 /* Structure to hold mapping tables for a charset. Used by temacs
157 invoked for dumping. */
161 /* The current charset for which the following tables are setup. */
162 struct charset
*current
;
164 /* 1 iff the following table is used for encoder. */
167 /* When the following table is used for encoding, minimum and
168 maximum character of the current charset. */
169 int min_char
, max_char
;
171 /* A Unicode character corresponding to the code index 0 (i.e. the
172 minimum code-point) of the current charset, or -1 if the code
173 index 0 is not a Unicode character. This is checked when
174 table.encoder[CHAR] is zero. */
178 /* Table mapping code-indices (not code-points) of the current
179 charset to Unicode characters. If decoder[CHAR] is -1, CHAR
180 doesn't belong to the current charset. */
181 int decoder
[0x10000];
182 /* Table mapping Unicode characters to code-indices of the current
183 charset. The first 0x10000 elements are for BMP (0..0xFFFF),
184 and the last 0x10000 are for SMP (0x10000..0x1FFFF) or SIP
185 (0x20000..0x2FFFF). Note that there is no charset map that
186 uses both SMP and SIP. */
187 unsigned short encoder
[0x20000];
189 } *temp_charset_work
;
191 #define SET_TEMP_CHARSET_WORK_ENCODER(C, CODE) \
194 temp_charset_work->zero_index_char = (C); \
195 else if ((C) < 0x20000) \
196 temp_charset_work->table.encoder[(C)] = (CODE); \
198 temp_charset_work->table.encoder[(C) - 0x10000] = (CODE); \
201 #define GET_TEMP_CHARSET_WORK_ENCODER(C) \
202 ((C) == temp_charset_work->zero_index_char ? 0 \
203 : (C) < 0x20000 ? (temp_charset_work->table.encoder[(C)] \
204 ? (int) temp_charset_work->table.encoder[(C)] : -1) \
205 : temp_charset_work->table.encoder[(C) - 0x10000] \
206 ? temp_charset_work->table.encoder[(C) - 0x10000] : -1)
208 #define SET_TEMP_CHARSET_WORK_DECODER(C, CODE) \
209 (temp_charset_work->table.decoder[(CODE)] = (C))
211 #define GET_TEMP_CHARSET_WORK_DECODER(CODE) \
212 (temp_charset_work->table.decoder[(CODE)])
215 /* Set to 1 to warn that a charset map is loaded and thus a buffer
216 text and a string data may be relocated. */
217 bool charset_map_loaded
;
219 struct charset_map_entries
225 struct charset_map_entries
*next
;
228 /* Load the mapping information of CHARSET from ENTRIES for
229 initializing (CONTROL_FLAG == 0), decoding (CONTROL_FLAG == 1), and
230 encoding (CONTROL_FLAG == 2).
232 If CONTROL_FLAG is 0, setup CHARSET->min_char, CHARSET->max_char,
233 and CHARSET->fast_map.
235 If CONTROL_FLAG is 1, setup the following tables according to
236 CHARSET->method and inhibit_load_charset_map.
238 CHARSET->method | inhibit_lcm == 0 | inhibit_lcm == 1
239 ----------------------+--------------------+---------------------------
240 CHARSET_METHOD_MAP | CHARSET->decoder | temp_charset_work->decoder
241 ----------------------+--------------------+---------------------------
242 CHARSET_METHOD_OFFSET | Vchar_unify_table | temp_charset_work->decoder
244 If CONTROL_FLAG is 2, setup the following tables.
246 CHARSET->method | inhibit_lcm == 0 | inhibit_lcm == 1
247 ----------------------+--------------------+---------------------------
248 CHARSET_METHOD_MAP | CHARSET->encoder | temp_charset_work->encoder
249 ----------------------+--------------------+--------------------------
250 CHARSET_METHOD_OFFSET | CHARSET->deunifier | temp_charset_work->encoder
254 load_charset_map (struct charset
*charset
, struct charset_map_entries
*entries
, int n_entries
, int control_flag
)
256 Lisp_Object vec
IF_LINT (= Qnil
), table
IF_LINT (= Qnil
);
257 unsigned max_code
= CHARSET_MAX_CODE (charset
);
258 bool ascii_compatible_p
= charset
->ascii_compatible_p
;
259 int min_char
, max_char
, nonascii_min_char
;
261 unsigned char *fast_map
= charset
->fast_map
;
268 if (! inhibit_load_charset_map
)
270 if (control_flag
== 1)
272 if (charset
->method
== CHARSET_METHOD_MAP
)
274 int n
= CODE_POINT_TO_INDEX (charset
, max_code
) + 1;
276 vec
= Fmake_vector (make_number (n
), make_number (-1));
277 set_charset_attr (charset
, charset_decoder
, vec
);
281 char_table_set_range (Vchar_unify_table
,
282 charset
->min_char
, charset
->max_char
,
288 table
= Fmake_char_table (Qnil
, Qnil
);
289 set_charset_attr (charset
,
290 (charset
->method
== CHARSET_METHOD_MAP
291 ? charset_encoder
: charset_deunifier
),
297 if (! temp_charset_work
)
298 temp_charset_work
= xmalloc (sizeof *temp_charset_work
);
299 if (control_flag
== 1)
301 memset (temp_charset_work
->table
.decoder
, -1,
302 sizeof (int) * 0x10000);
306 memset (temp_charset_work
->table
.encoder
, 0,
307 sizeof (unsigned short) * 0x20000);
308 temp_charset_work
->zero_index_char
= -1;
310 temp_charset_work
->current
= charset
;
311 temp_charset_work
->for_encoder
= (control_flag
== 2);
314 charset_map_loaded
= 1;
317 min_char
= max_char
= entries
->entry
[0].c
;
318 nonascii_min_char
= MAX_CHAR
;
319 for (i
= 0; i
< n_entries
; i
++)
322 int from_index
, to_index
, lim_index
;
324 int idx
= i
% 0x10000;
326 if (i
> 0 && idx
== 0)
327 entries
= entries
->next
;
328 from
= entries
->entry
[idx
].from
;
329 to
= entries
->entry
[idx
].to
;
330 from_c
= entries
->entry
[idx
].c
;
331 from_index
= CODE_POINT_TO_INDEX (charset
, from
);
334 to_index
= from_index
;
339 to_index
= CODE_POINT_TO_INDEX (charset
, to
);
340 to_c
= from_c
+ (to_index
- from_index
);
342 if (from_index
< 0 || to_index
< 0)
344 lim_index
= to_index
+ 1;
348 else if (from_c
< min_char
)
351 if (control_flag
== 1)
353 if (charset
->method
== CHARSET_METHOD_MAP
)
354 for (; from_index
< lim_index
; from_index
++, from_c
++)
355 ASET (vec
, from_index
, make_number (from_c
));
357 for (; from_index
< lim_index
; from_index
++, from_c
++)
358 CHAR_TABLE_SET (Vchar_unify_table
,
359 CHARSET_CODE_OFFSET (charset
) + from_index
,
360 make_number (from_c
));
362 else if (control_flag
== 2)
364 if (charset
->method
== CHARSET_METHOD_MAP
365 && CHARSET_COMPACT_CODES_P (charset
))
366 for (; from_index
< lim_index
; from_index
++, from_c
++)
368 unsigned code
= from_index
;
369 code
= INDEX_TO_CODE_POINT (charset
, code
);
371 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
372 CHAR_TABLE_SET (table
, from_c
, make_number (code
));
375 for (; from_index
< lim_index
; from_index
++, from_c
++)
377 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
378 CHAR_TABLE_SET (table
, from_c
, make_number (from_index
));
381 else if (control_flag
== 3)
382 for (; from_index
< lim_index
; from_index
++, from_c
++)
383 SET_TEMP_CHARSET_WORK_DECODER (from_c
, from_index
);
384 else if (control_flag
== 4)
385 for (; from_index
< lim_index
; from_index
++, from_c
++)
386 SET_TEMP_CHARSET_WORK_ENCODER (from_c
, from_index
);
387 else /* control_flag == 0 */
389 if (ascii_compatible_p
)
391 if (! ASCII_BYTE_P (from_c
))
393 if (from_c
< nonascii_min_char
)
394 nonascii_min_char
= from_c
;
396 else if (! ASCII_BYTE_P (to_c
))
398 nonascii_min_char
= 0x80;
402 for (; from_c
<= to_c
; from_c
++)
403 CHARSET_FAST_MAP_SET (from_c
, fast_map
);
407 if (control_flag
== 0)
409 CHARSET_MIN_CHAR (charset
) = (ascii_compatible_p
410 ? nonascii_min_char
: min_char
);
411 CHARSET_MAX_CHAR (charset
) = max_char
;
413 else if (control_flag
== 4)
415 temp_charset_work
->min_char
= min_char
;
416 temp_charset_work
->max_char
= max_char
;
421 /* Read a hexadecimal number (preceded by "0x") from the file FP while
422 paying attention to comment character '#'. */
425 read_hex (FILE *fp
, bool *eof
, bool *overflow
)
430 while ((c
= getc (fp
)) != EOF
)
434 while ((c
= getc (fp
)) != EOF
&& c
!= '\n');
438 if ((c
= getc (fp
)) == EOF
|| c
== 'x')
448 while (c_isxdigit (c
= getc (fp
)))
450 if (UINT_MAX
>> 4 < n
)
453 | (c
- ('0' <= c
&& c
<= '9' ? '0'
454 : 'A' <= c
&& c
<= 'F' ? 'A' - 10
462 /* Return a mapping vector for CHARSET loaded from MAPFILE.
463 Each line of MAPFILE has this form
465 where 0xAAAA is a code-point and 0xCCCC is the corresponding
466 character code, or this form
468 where 0xAAAA and 0xBBBB are code-points specifying a range, and
469 0xCCCC is the first character code of the range.
471 The returned vector has this form:
472 [ CODE1 CHAR1 CODE2 CHAR2 .... ]
473 where CODE1 is a code-point or a cons of code-points specifying a
476 Note that this function uses `openp' to open MAPFILE but ignores
477 `file-name-handler-alist' to avoid running any Lisp code. */
480 load_charset_map_from_file (struct charset
*charset
, Lisp_Object mapfile
, int control_flag
)
482 unsigned min_code
= CHARSET_MIN_CODE (charset
);
483 unsigned max_code
= CHARSET_MAX_CODE (charset
);
486 Lisp_Object suffixes
;
487 struct charset_map_entries
*head
, *entries
;
492 suffixes
= list2 (build_string (".map"), build_string (".TXT"));
494 count
= SPECPDL_INDEX ();
495 specbind (Qfile_name_handler_alist
, Qnil
);
496 fd
= openp (Vcharset_map_path
, mapfile
, suffixes
, NULL
, Qnil
);
497 unbind_to (count
, Qnil
);
499 || ! (fp
= fdopen (fd
, "r")))
500 error ("Failure in loading charset map: %s", SDATA (mapfile
));
502 /* Use SAFE_ALLOCA instead of alloca, as `charset_map_entries' is
503 large (larger than MAX_ALLOCA). */
504 head
= SAFE_ALLOCA (sizeof *head
);
506 memset (entries
, 0, sizeof (struct charset_map_entries
));
511 unsigned from
, to
, c
;
513 bool eof
= 0, overflow
= 0;
515 from
= read_hex (fp
, &eof
, &overflow
);
518 if (getc (fp
) == '-')
519 to
= read_hex (fp
, &eof
, &overflow
);
524 c
= read_hex (fp
, &eof
, &overflow
);
530 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
533 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
535 entries
->next
= SAFE_ALLOCA (sizeof *entries
->next
);
536 entries
= entries
->next
;
537 memset (entries
, 0, sizeof (struct charset_map_entries
));
541 entries
->entry
[idx
].from
= from
;
542 entries
->entry
[idx
].to
= to
;
543 entries
->entry
[idx
].c
= c
;
548 load_charset_map (charset
, head
, n_entries
, control_flag
);
553 load_charset_map_from_vector (struct charset
*charset
, Lisp_Object vec
, int control_flag
)
555 unsigned min_code
= CHARSET_MIN_CODE (charset
);
556 unsigned max_code
= CHARSET_MAX_CODE (charset
);
557 struct charset_map_entries
*head
, *entries
;
559 int len
= ASIZE (vec
);
565 add_to_log ("Failure in loading charset map: %V", vec
, Qnil
);
569 /* Use SAFE_ALLOCA instead of alloca, as `charset_map_entries' is
570 large (larger than MAX_ALLOCA). */
571 head
= SAFE_ALLOCA (sizeof *head
);
573 memset (entries
, 0, sizeof (struct charset_map_entries
));
576 for (i
= 0; i
< len
; i
+= 2)
578 Lisp_Object val
, val2
;
588 from
= XFASTINT (val
);
589 to
= XFASTINT (val2
);
592 from
= to
= XFASTINT (val
);
593 val
= AREF (vec
, i
+ 1);
597 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
600 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
602 entries
->next
= SAFE_ALLOCA (sizeof *entries
->next
);
603 entries
= entries
->next
;
604 memset (entries
, 0, sizeof (struct charset_map_entries
));
606 idx
= n_entries
% 0x10000;
607 entries
->entry
[idx
].from
= from
;
608 entries
->entry
[idx
].to
= to
;
609 entries
->entry
[idx
].c
= c
;
613 load_charset_map (charset
, head
, n_entries
, control_flag
);
618 /* Load a mapping table for CHARSET. CONTROL-FLAG tells what kind of
619 map it is (see the comment of load_charset_map for the detail). */
622 load_charset (struct charset
*charset
, int control_flag
)
626 if (inhibit_load_charset_map
628 && charset
== temp_charset_work
->current
629 && ((control_flag
== 2) == temp_charset_work
->for_encoder
))
632 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
633 map
= CHARSET_MAP (charset
);
636 if (! CHARSET_UNIFIED_P (charset
))
638 map
= CHARSET_UNIFY_MAP (charset
);
641 load_charset_map_from_file (charset
, map
, control_flag
);
643 load_charset_map_from_vector (charset
, map
, control_flag
);
647 DEFUN ("charsetp", Fcharsetp
, Scharsetp
, 1, 1, 0,
648 doc
: /* Return non-nil if and only if OBJECT is a charset.*/)
651 return (CHARSETP (object
) ? Qt
: Qnil
);
656 map_charset_for_dump (void (*c_function
) (Lisp_Object
, Lisp_Object
),
657 Lisp_Object function
, Lisp_Object arg
,
658 unsigned int from
, unsigned int to
)
660 int from_idx
= CODE_POINT_TO_INDEX (temp_charset_work
->current
, from
);
661 int to_idx
= CODE_POINT_TO_INDEX (temp_charset_work
->current
, to
);
666 range
= Fcons (Qnil
, Qnil
);
669 c
= temp_charset_work
->min_char
;
670 stop
= (temp_charset_work
->max_char
< 0x20000
671 ? temp_charset_work
->max_char
: 0xFFFF);
675 int idx
= GET_TEMP_CHARSET_WORK_ENCODER (c
);
677 if (idx
>= from_idx
&& idx
<= to_idx
)
679 if (NILP (XCAR (range
)))
680 XSETCAR (range
, make_number (c
));
682 else if (! NILP (XCAR (range
)))
684 XSETCDR (range
, make_number (c
- 1));
686 (*c_function
) (arg
, range
);
688 call2 (function
, range
, arg
);
689 XSETCAR (range
, Qnil
);
693 if (c
== temp_charset_work
->max_char
)
695 if (! NILP (XCAR (range
)))
697 XSETCDR (range
, make_number (c
));
699 (*c_function
) (arg
, range
);
701 call2 (function
, range
, arg
);
706 stop
= temp_charset_work
->max_char
;
714 map_charset_chars (void (*c_function
)(Lisp_Object
, Lisp_Object
), Lisp_Object function
,
715 Lisp_Object arg
, struct charset
*charset
, unsigned from
, unsigned to
)
718 bool partial
= (from
> CHARSET_MIN_CODE (charset
)
719 || to
< CHARSET_MAX_CODE (charset
));
721 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_OFFSET
)
723 int from_idx
= CODE_POINT_TO_INDEX (charset
, from
);
724 int to_idx
= CODE_POINT_TO_INDEX (charset
, to
);
725 int from_c
= from_idx
+ CHARSET_CODE_OFFSET (charset
);
726 int to_c
= to_idx
+ CHARSET_CODE_OFFSET (charset
);
728 if (CHARSET_UNIFIED_P (charset
))
730 if (! CHAR_TABLE_P (CHARSET_DEUNIFIER (charset
)))
731 load_charset (charset
, 2);
732 if (CHAR_TABLE_P (CHARSET_DEUNIFIER (charset
)))
733 map_char_table_for_charset (c_function
, function
,
734 CHARSET_DEUNIFIER (charset
), arg
,
735 partial
? charset
: NULL
, from
, to
);
737 map_charset_for_dump (c_function
, function
, arg
, from
, to
);
740 range
= Fcons (make_number (from_c
), make_number (to_c
));
742 (*c_function
) (arg
, range
);
744 call2 (function
, range
, arg
);
746 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
748 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
749 load_charset (charset
, 2);
750 if (CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
751 map_char_table_for_charset (c_function
, function
,
752 CHARSET_ENCODER (charset
), arg
,
753 partial
? charset
: NULL
, from
, to
);
755 map_charset_for_dump (c_function
, function
, arg
, from
, to
);
757 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_SUBSET
)
759 Lisp_Object subset_info
;
762 subset_info
= CHARSET_SUBSET (charset
);
763 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
764 offset
= XINT (AREF (subset_info
, 3));
766 if (from
< XFASTINT (AREF (subset_info
, 1)))
767 from
= XFASTINT (AREF (subset_info
, 1));
769 if (to
> XFASTINT (AREF (subset_info
, 2)))
770 to
= XFASTINT (AREF (subset_info
, 2));
771 map_charset_chars (c_function
, function
, arg
, charset
, from
, to
);
773 else /* i.e. CHARSET_METHOD_SUPERSET */
777 for (parents
= CHARSET_SUPERSET (charset
); CONSP (parents
);
778 parents
= XCDR (parents
))
781 unsigned this_from
, this_to
;
783 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents
))));
784 offset
= XINT (XCDR (XCAR (parents
)));
785 this_from
= from
> offset
? from
- offset
: 0;
786 this_to
= to
> offset
? to
- offset
: 0;
787 if (this_from
< CHARSET_MIN_CODE (charset
))
788 this_from
= CHARSET_MIN_CODE (charset
);
789 if (this_to
> CHARSET_MAX_CODE (charset
))
790 this_to
= CHARSET_MAX_CODE (charset
);
791 map_charset_chars (c_function
, function
, arg
, charset
,
797 DEFUN ("map-charset-chars", Fmap_charset_chars
, Smap_charset_chars
, 2, 5, 0,
798 doc
: /* Call FUNCTION for all characters in CHARSET.
799 FUNCTION is called with an argument RANGE and the optional 3rd
802 RANGE is a cons (FROM . TO), where FROM and TO indicate a range of
803 characters contained in CHARSET.
805 The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the
806 range of code points (in CHARSET) of target characters. */)
807 (Lisp_Object function
, Lisp_Object charset
, Lisp_Object arg
, Lisp_Object from_code
, Lisp_Object to_code
)
812 CHECK_CHARSET_GET_CHARSET (charset
, cs
);
813 if (NILP (from_code
))
814 from
= CHARSET_MIN_CODE (cs
);
817 from
= XINT (from_code
);
818 if (from
< CHARSET_MIN_CODE (cs
))
819 from
= CHARSET_MIN_CODE (cs
);
822 to
= CHARSET_MAX_CODE (cs
);
826 if (to
> CHARSET_MAX_CODE (cs
))
827 to
= CHARSET_MAX_CODE (cs
);
829 map_charset_chars (NULL
, function
, arg
, cs
, from
, to
);
834 /* Define a charset according to the arguments. The Nth argument is
835 the Nth attribute of the charset (the last attribute `charset-id'
836 is not included). See the docstring of `define-charset' for the
839 DEFUN ("define-charset-internal", Fdefine_charset_internal
,
840 Sdefine_charset_internal
, charset_arg_max
, MANY
, 0,
841 doc
: /* For internal use only.
842 usage: (define-charset-internal ...) */)
843 (ptrdiff_t nargs
, Lisp_Object
*args
)
845 /* Charset attr vector. */
848 EMACS_UINT hash_code
;
849 struct Lisp_Hash_Table
*hash_table
= XHASH_TABLE (Vcharset_hash_table
);
851 struct charset charset
;
854 bool new_definition_p
;
857 if (nargs
!= charset_arg_max
)
858 return Fsignal (Qwrong_number_of_arguments
,
859 Fcons (intern ("define-charset-internal"),
860 make_number (nargs
)));
862 attrs
= Fmake_vector (make_number (charset_attr_max
), Qnil
);
864 CHECK_SYMBOL (args
[charset_arg_name
]);
865 ASET (attrs
, charset_name
, args
[charset_arg_name
]);
867 val
= args
[charset_arg_code_space
];
868 for (i
= 0, dimension
= 0, nchars
= 1; ; i
++)
870 Lisp_Object min_byte_obj
, max_byte_obj
;
871 int min_byte
, max_byte
;
873 min_byte_obj
= Faref (val
, make_number (i
* 2));
874 max_byte_obj
= Faref (val
, make_number (i
* 2 + 1));
875 CHECK_RANGED_INTEGER (min_byte_obj
, 0, 255);
876 min_byte
= XINT (min_byte_obj
);
877 CHECK_RANGED_INTEGER (max_byte_obj
, min_byte
, 255);
878 max_byte
= XINT (max_byte_obj
);
879 charset
.code_space
[i
* 4] = min_byte
;
880 charset
.code_space
[i
* 4 + 1] = max_byte
;
881 charset
.code_space
[i
* 4 + 2] = max_byte
- min_byte
+ 1;
886 nchars
*= charset
.code_space
[i
* 4 + 2];
887 charset
.code_space
[i
* 4 + 3] = nchars
;
890 val
= args
[charset_arg_dimension
];
892 charset
.dimension
= dimension
;
895 CHECK_RANGED_INTEGER (val
, 1, 4);
896 charset
.dimension
= XINT (val
);
899 charset
.code_linear_p
900 = (charset
.dimension
== 1
901 || (charset
.code_space
[2] == 256
902 && (charset
.dimension
== 2
903 || (charset
.code_space
[6] == 256
904 && (charset
.dimension
== 3
905 || charset
.code_space
[10] == 256)))));
907 if (! charset
.code_linear_p
)
909 charset
.code_space_mask
= xzalloc (256);
910 for (i
= 0; i
< 4; i
++)
911 for (j
= charset
.code_space
[i
* 4]; j
<= charset
.code_space
[i
* 4 + 1];
913 charset
.code_space_mask
[j
] |= (1 << i
);
916 charset
.iso_chars_96
= charset
.code_space
[2] == 96;
918 charset
.min_code
= (charset
.code_space
[0]
919 | (charset
.code_space
[4] << 8)
920 | (charset
.code_space
[8] << 16)
921 | ((unsigned) charset
.code_space
[12] << 24));
922 charset
.max_code
= (charset
.code_space
[1]
923 | (charset
.code_space
[5] << 8)
924 | (charset
.code_space
[9] << 16)
925 | ((unsigned) charset
.code_space
[13] << 24));
926 charset
.char_index_offset
= 0;
928 val
= args
[charset_arg_min_code
];
931 unsigned code
= cons_to_unsigned (val
, UINT_MAX
);
933 if (code
< charset
.min_code
934 || code
> charset
.max_code
)
935 args_out_of_range_3 (make_fixnum_or_float (charset
.min_code
),
936 make_fixnum_or_float (charset
.max_code
), val
);
937 charset
.char_index_offset
= CODE_POINT_TO_INDEX (&charset
, code
);
938 charset
.min_code
= code
;
941 val
= args
[charset_arg_max_code
];
944 unsigned code
= cons_to_unsigned (val
, UINT_MAX
);
946 if (code
< charset
.min_code
947 || code
> charset
.max_code
)
948 args_out_of_range_3 (make_fixnum_or_float (charset
.min_code
),
949 make_fixnum_or_float (charset
.max_code
), val
);
950 charset
.max_code
= code
;
953 charset
.compact_codes_p
= charset
.max_code
< 0x10000;
955 val
= args
[charset_arg_invalid_code
];
958 if (charset
.min_code
> 0)
959 charset
.invalid_code
= 0;
962 if (charset
.max_code
< UINT_MAX
)
963 charset
.invalid_code
= charset
.max_code
+ 1;
965 error ("Attribute :invalid-code must be specified");
969 charset
.invalid_code
= cons_to_unsigned (val
, UINT_MAX
);
971 val
= args
[charset_arg_iso_final
];
973 charset
.iso_final
= -1;
977 if (XINT (val
) < '0' || XINT (val
) > 127)
978 error ("Invalid iso-final-char: %"pI
"d", XINT (val
));
979 charset
.iso_final
= XINT (val
);
982 val
= args
[charset_arg_iso_revision
];
984 charset
.iso_revision
= -1;
987 CHECK_RANGED_INTEGER (val
, -1, 63);
988 charset
.iso_revision
= XINT (val
);
991 val
= args
[charset_arg_emacs_mule_id
];
993 charset
.emacs_mule_id
= -1;
997 if ((XINT (val
) > 0 && XINT (val
) <= 128) || XINT (val
) >= 256)
998 error ("Invalid emacs-mule-id: %"pI
"d", XINT (val
));
999 charset
.emacs_mule_id
= XINT (val
);
1002 charset
.ascii_compatible_p
= ! NILP (args
[charset_arg_ascii_compatible_p
]);
1004 charset
.supplementary_p
= ! NILP (args
[charset_arg_supplementary_p
]);
1006 charset
.unified_p
= 0;
1008 memset (charset
.fast_map
, 0, sizeof (charset
.fast_map
));
1010 if (! NILP (args
[charset_arg_code_offset
]))
1012 val
= args
[charset_arg_code_offset
];
1013 CHECK_CHARACTER (val
);
1015 charset
.method
= CHARSET_METHOD_OFFSET
;
1016 charset
.code_offset
= XINT (val
);
1018 i
= CODE_POINT_TO_INDEX (&charset
, charset
.max_code
);
1019 if (MAX_CHAR
- charset
.code_offset
< i
)
1020 error ("Unsupported max char: %d", charset
.max_char
);
1021 charset
.max_char
= i
+ charset
.code_offset
;
1022 i
= CODE_POINT_TO_INDEX (&charset
, charset
.min_code
);
1023 charset
.min_char
= i
+ charset
.code_offset
;
1025 i
= (charset
.min_char
>> 7) << 7;
1026 for (; i
< 0x10000 && i
<= charset
.max_char
; i
+= 128)
1027 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
1028 i
= (i
>> 12) << 12;
1029 for (; i
<= charset
.max_char
; i
+= 0x1000)
1030 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
1031 if (charset
.code_offset
== 0 && charset
.max_char
>= 0x80)
1032 charset
.ascii_compatible_p
= 1;
1034 else if (! NILP (args
[charset_arg_map
]))
1036 val
= args
[charset_arg_map
];
1037 ASET (attrs
, charset_map
, val
);
1038 charset
.method
= CHARSET_METHOD_MAP
;
1040 else if (! NILP (args
[charset_arg_subset
]))
1043 Lisp_Object parent_min_code
, parent_max_code
, parent_code_offset
;
1044 struct charset
*parent_charset
;
1046 val
= args
[charset_arg_subset
];
1047 parent
= Fcar (val
);
1048 CHECK_CHARSET_GET_CHARSET (parent
, parent_charset
);
1049 parent_min_code
= Fnth (make_number (1), val
);
1050 CHECK_NATNUM (parent_min_code
);
1051 parent_max_code
= Fnth (make_number (2), val
);
1052 CHECK_NATNUM (parent_max_code
);
1053 parent_code_offset
= Fnth (make_number (3), val
);
1054 CHECK_NUMBER (parent_code_offset
);
1055 val
= make_uninit_vector (4);
1056 ASET (val
, 0, make_number (parent_charset
->id
));
1057 ASET (val
, 1, parent_min_code
);
1058 ASET (val
, 2, parent_max_code
);
1059 ASET (val
, 3, parent_code_offset
);
1060 ASET (attrs
, charset_subset
, val
);
1062 charset
.method
= CHARSET_METHOD_SUBSET
;
1063 /* Here, we just copy the parent's fast_map. It's not accurate,
1064 but at least it works for quickly detecting which character
1065 DOESN'T belong to this charset. */
1066 for (i
= 0; i
< 190; i
++)
1067 charset
.fast_map
[i
] = parent_charset
->fast_map
[i
];
1069 /* We also copy these for parents. */
1070 charset
.min_char
= parent_charset
->min_char
;
1071 charset
.max_char
= parent_charset
->max_char
;
1073 else if (! NILP (args
[charset_arg_superset
]))
1075 val
= args
[charset_arg_superset
];
1076 charset
.method
= CHARSET_METHOD_SUPERSET
;
1077 val
= Fcopy_sequence (val
);
1078 ASET (attrs
, charset_superset
, val
);
1080 charset
.min_char
= MAX_CHAR
;
1081 charset
.max_char
= 0;
1082 for (; ! NILP (val
); val
= Fcdr (val
))
1084 Lisp_Object elt
, car_part
, cdr_part
;
1085 int this_id
, offset
;
1086 struct charset
*this_charset
;
1091 car_part
= XCAR (elt
);
1092 cdr_part
= XCDR (elt
);
1093 CHECK_CHARSET_GET_ID (car_part
, this_id
);
1094 CHECK_TYPE_RANGED_INTEGER (int, cdr_part
);
1095 offset
= XINT (cdr_part
);
1099 CHECK_CHARSET_GET_ID (elt
, this_id
);
1102 XSETCAR (val
, Fcons (make_number (this_id
), make_number (offset
)));
1104 this_charset
= CHARSET_FROM_ID (this_id
);
1105 if (charset
.min_char
> this_charset
->min_char
)
1106 charset
.min_char
= this_charset
->min_char
;
1107 if (charset
.max_char
< this_charset
->max_char
)
1108 charset
.max_char
= this_charset
->max_char
;
1109 for (i
= 0; i
< 190; i
++)
1110 charset
.fast_map
[i
] |= this_charset
->fast_map
[i
];
1114 error ("None of :code-offset, :map, :parents are specified");
1116 val
= args
[charset_arg_unify_map
];
1117 if (! NILP (val
) && !STRINGP (val
))
1119 ASET (attrs
, charset_unify_map
, val
);
1121 CHECK_LIST (args
[charset_arg_plist
]);
1122 ASET (attrs
, charset_plist
, args
[charset_arg_plist
]);
1124 charset
.hash_index
= hash_lookup (hash_table
, args
[charset_arg_name
],
1126 if (charset
.hash_index
>= 0)
1128 new_definition_p
= 0;
1129 id
= XFASTINT (CHARSET_SYMBOL_ID (args
[charset_arg_name
]));
1130 set_hash_value_slot (hash_table
, charset
.hash_index
, attrs
);
1134 charset
.hash_index
= hash_put (hash_table
, args
[charset_arg_name
], attrs
,
1136 if (charset_table_used
== charset_table_size
)
1138 /* Ensure that charset IDs fit into 'int' as well as into the
1139 restriction imposed by fixnums. Although the 'int' restriction
1140 could be removed, too much other code would need altering; for
1141 example, the IDs are stuffed into struct
1142 coding_system.charbuf[i] entries, which are 'int'. */
1143 int old_size
= charset_table_size
;
1144 ptrdiff_t new_size
= old_size
;
1145 struct charset
*new_table
=
1146 xpalloc (0, &new_size
, 1,
1147 min (INT_MAX
, MOST_POSITIVE_FIXNUM
),
1148 sizeof *charset_table
);
1149 memcpy (new_table
, charset_table
, old_size
* sizeof *new_table
);
1150 charset_table
= new_table
;
1151 charset_table_size
= new_size
;
1152 /* FIXME: This leaks memory, as the old charset_table becomes
1153 unreachable. If the old charset table is charset_table_init
1154 then this leak is intentional; otherwise, it's unclear.
1155 If the latter memory leak is intentional, a
1156 comment should be added to explain this. If not, the old
1157 charset_table should be freed, by passing it as the 1st argument
1158 to xpalloc and removing the memcpy. */
1160 id
= charset_table_used
++;
1161 new_definition_p
= 1;
1164 ASET (attrs
, charset_id
, make_number (id
));
1166 charset_table
[id
] = charset
;
1168 if (charset
.method
== CHARSET_METHOD_MAP
)
1170 load_charset (&charset
, 0);
1171 charset_table
[id
] = charset
;
1174 if (charset
.iso_final
>= 0)
1176 ISO_CHARSET_TABLE (charset
.dimension
, charset
.iso_chars_96
,
1177 charset
.iso_final
) = id
;
1178 if (new_definition_p
)
1179 Viso_2022_charset_list
= nconc2 (Viso_2022_charset_list
,
1180 list1 (make_number (id
)));
1181 if (ISO_CHARSET_TABLE (1, 0, 'J') == id
)
1182 charset_jisx0201_roman
= id
;
1183 else if (ISO_CHARSET_TABLE (2, 0, '@') == id
)
1184 charset_jisx0208_1978
= id
;
1185 else if (ISO_CHARSET_TABLE (2, 0, 'B') == id
)
1186 charset_jisx0208
= id
;
1187 else if (ISO_CHARSET_TABLE (2, 0, 'C') == id
)
1188 charset_ksc5601
= id
;
1191 if (charset
.emacs_mule_id
>= 0)
1193 emacs_mule_charset
[charset
.emacs_mule_id
] = id
;
1194 if (charset
.emacs_mule_id
< 0xA0)
1195 emacs_mule_bytes
[charset
.emacs_mule_id
] = charset
.dimension
+ 1;
1197 emacs_mule_bytes
[charset
.emacs_mule_id
] = charset
.dimension
+ 2;
1198 if (new_definition_p
)
1199 Vemacs_mule_charset_list
= nconc2 (Vemacs_mule_charset_list
,
1200 list1 (make_number (id
)));
1203 if (new_definition_p
)
1205 Vcharset_list
= Fcons (args
[charset_arg_name
], Vcharset_list
);
1206 if (charset
.supplementary_p
)
1207 Vcharset_ordered_list
= nconc2 (Vcharset_ordered_list
,
1208 list1 (make_number (id
)));
1213 for (tail
= Vcharset_ordered_list
; CONSP (tail
); tail
= XCDR (tail
))
1215 struct charset
*cs
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
1217 if (cs
->supplementary_p
)
1220 if (EQ (tail
, Vcharset_ordered_list
))
1221 Vcharset_ordered_list
= Fcons (make_number (id
),
1222 Vcharset_ordered_list
);
1223 else if (NILP (tail
))
1224 Vcharset_ordered_list
= nconc2 (Vcharset_ordered_list
,
1225 list1 (make_number (id
)));
1228 val
= Fcons (XCAR (tail
), XCDR (tail
));
1229 XSETCDR (tail
, val
);
1230 XSETCAR (tail
, make_number (id
));
1233 charset_ordered_list_tick
++;
1240 /* Same as Fdefine_charset_internal but arguments are more convenient
1241 to call from C (typically in syms_of_charset). This can define a
1242 charset of `offset' method only. Return the ID of the new
1246 define_charset_internal (Lisp_Object name
,
1248 const char *code_space_chars
,
1249 unsigned min_code
, unsigned max_code
,
1250 int iso_final
, int iso_revision
, int emacs_mule_id
,
1251 bool ascii_compatible
, bool supplementary
,
1254 const unsigned char *code_space
= (const unsigned char *) code_space_chars
;
1255 Lisp_Object args
[charset_arg_max
];
1259 args
[charset_arg_name
] = name
;
1260 args
[charset_arg_dimension
] = make_number (dimension
);
1261 val
= make_uninit_vector (8);
1262 for (i
= 0; i
< 8; i
++)
1263 ASET (val
, i
, make_number (code_space
[i
]));
1264 args
[charset_arg_code_space
] = val
;
1265 args
[charset_arg_min_code
] = make_number (min_code
);
1266 args
[charset_arg_max_code
] = make_number (max_code
);
1267 args
[charset_arg_iso_final
]
1268 = (iso_final
< 0 ? Qnil
: make_number (iso_final
));
1269 args
[charset_arg_iso_revision
] = make_number (iso_revision
);
1270 args
[charset_arg_emacs_mule_id
]
1271 = (emacs_mule_id
< 0 ? Qnil
: make_number (emacs_mule_id
));
1272 args
[charset_arg_ascii_compatible_p
] = ascii_compatible
? Qt
: Qnil
;
1273 args
[charset_arg_supplementary_p
] = supplementary
? Qt
: Qnil
;
1274 args
[charset_arg_invalid_code
] = Qnil
;
1275 args
[charset_arg_code_offset
] = make_number (code_offset
);
1276 args
[charset_arg_map
] = Qnil
;
1277 args
[charset_arg_subset
] = Qnil
;
1278 args
[charset_arg_superset
] = Qnil
;
1279 args
[charset_arg_unify_map
] = Qnil
;
1281 args
[charset_arg_plist
] =
1282 listn (CONSTYPE_HEAP
, 14,
1283 intern_c_string (":name"),
1284 args
[charset_arg_name
],
1285 intern_c_string (":dimension"),
1286 args
[charset_arg_dimension
],
1287 intern_c_string (":code-space"),
1288 args
[charset_arg_code_space
],
1289 intern_c_string (":iso-final-char"),
1290 args
[charset_arg_iso_final
],
1291 intern_c_string (":emacs-mule-id"),
1292 args
[charset_arg_emacs_mule_id
],
1293 intern_c_string (":ascii-compatible-p"),
1294 args
[charset_arg_ascii_compatible_p
],
1295 intern_c_string (":code-offset"),
1296 args
[charset_arg_code_offset
]);
1297 Fdefine_charset_internal (charset_arg_max
, args
);
1299 return XINT (CHARSET_SYMBOL_ID (name
));
1303 DEFUN ("define-charset-alias", Fdefine_charset_alias
,
1304 Sdefine_charset_alias
, 2, 2, 0,
1305 doc
: /* Define ALIAS as an alias for charset CHARSET. */)
1306 (Lisp_Object alias
, Lisp_Object charset
)
1310 CHECK_CHARSET_GET_ATTR (charset
, attr
);
1311 Fputhash (alias
, attr
, Vcharset_hash_table
);
1312 Vcharset_list
= Fcons (alias
, Vcharset_list
);
1317 DEFUN ("charset-plist", Fcharset_plist
, Scharset_plist
, 1, 1, 0,
1318 doc
: /* Return the property list of CHARSET. */)
1319 (Lisp_Object charset
)
1323 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1324 return CHARSET_ATTR_PLIST (attrs
);
1328 DEFUN ("set-charset-plist", Fset_charset_plist
, Sset_charset_plist
, 2, 2, 0,
1329 doc
: /* Set CHARSET's property list to PLIST. */)
1330 (Lisp_Object charset
, Lisp_Object plist
)
1334 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1335 ASET (attrs
, charset_plist
, plist
);
1340 DEFUN ("unify-charset", Funify_charset
, Sunify_charset
, 1, 3, 0,
1341 doc
: /* Unify characters of CHARSET with Unicode.
1342 This means reading the relevant file and installing the table defined
1343 by CHARSET's `:unify-map' property.
1345 Optional second arg UNIFY-MAP is a file name string or a vector. It has
1346 the same meaning as the `:unify-map' attribute in the function
1347 `define-charset' (which see).
1349 Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET. */)
1350 (Lisp_Object charset
, Lisp_Object unify_map
, Lisp_Object deunify
)
1355 CHECK_CHARSET_GET_ID (charset
, id
);
1356 cs
= CHARSET_FROM_ID (id
);
1358 ? CHARSET_UNIFIED_P (cs
) && ! NILP (CHARSET_DEUNIFIER (cs
))
1359 : ! CHARSET_UNIFIED_P (cs
))
1362 CHARSET_UNIFIED_P (cs
) = 0;
1365 if (CHARSET_METHOD (cs
) != CHARSET_METHOD_OFFSET
1366 || CHARSET_CODE_OFFSET (cs
) < 0x110000)
1367 error ("Can't unify charset: %s", SDATA (SYMBOL_NAME (charset
)));
1368 if (NILP (unify_map
))
1369 unify_map
= CHARSET_UNIFY_MAP (cs
);
1372 if (! STRINGP (unify_map
) && ! VECTORP (unify_map
))
1373 signal_error ("Bad unify-map", unify_map
);
1374 set_charset_attr (cs
, charset_unify_map
, unify_map
);
1376 if (NILP (Vchar_unify_table
))
1377 Vchar_unify_table
= Fmake_char_table (Qnil
, Qnil
);
1378 char_table_set_range (Vchar_unify_table
,
1379 cs
->min_char
, cs
->max_char
, charset
);
1380 CHARSET_UNIFIED_P (cs
) = 1;
1382 else if (CHAR_TABLE_P (Vchar_unify_table
))
1384 unsigned min_code
= CHARSET_MIN_CODE (cs
);
1385 unsigned max_code
= CHARSET_MAX_CODE (cs
);
1386 int min_char
= DECODE_CHAR (cs
, min_code
);
1387 int max_char
= DECODE_CHAR (cs
, max_code
);
1389 char_table_set_range (Vchar_unify_table
, min_char
, max_char
, Qnil
);
1395 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char
,
1396 Sget_unused_iso_final_char
, 2, 2, 0,
1398 Return an unused ISO final char for a charset of DIMENSION and CHARS.
1399 DIMENSION is the number of bytes to represent a character: 1 or 2.
1400 CHARS is the number of characters in a dimension: 94 or 96.
1402 This final char is for private use, thus the range is `0' (48) .. `?' (63).
1403 If there's no unused final char for the specified kind of charset,
1405 (Lisp_Object dimension
, Lisp_Object chars
)
1409 CHECK_NUMBER (dimension
);
1410 CHECK_NUMBER (chars
);
1411 if (XINT (dimension
) != 1 && XINT (dimension
) != 2 && XINT (dimension
) != 3)
1412 args_out_of_range_3 (dimension
, make_number (1), make_number (3));
1413 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1414 args_out_of_range_3 (chars
, make_number (94), make_number (96));
1415 for (final_char
= '0'; final_char
<= '?'; final_char
++)
1416 if (ISO_CHARSET_TABLE (XINT (dimension
), XINT (chars
), final_char
) < 0)
1418 return (final_char
<= '?' ? make_number (final_char
) : Qnil
);
1422 check_iso_charset_parameter (Lisp_Object dimension
, Lisp_Object chars
, Lisp_Object final_char
)
1424 CHECK_NATNUM (dimension
);
1425 CHECK_NATNUM (chars
);
1426 CHECK_CHARACTER (final_char
);
1428 if (XINT (dimension
) > 3)
1429 error ("Invalid DIMENSION %"pI
"d, it should be 1, 2, or 3",
1431 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1432 error ("Invalid CHARS %"pI
"d, it should be 94 or 96", XINT (chars
));
1433 if (XINT (final_char
) < '0' || XINT (final_char
) > '~')
1434 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'",
1435 (int)XINT (final_char
));
1439 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
1441 doc
: /* Declare an equivalent charset for ISO-2022 decoding.
1443 On decoding by an ISO-2022 base coding system, when a charset
1444 specified by DIMENSION, CHARS, and FINAL-CHAR is designated, behave as
1445 if CHARSET is designated instead. */)
1446 (Lisp_Object dimension
, Lisp_Object chars
, Lisp_Object final_char
, Lisp_Object charset
)
1451 CHECK_CHARSET_GET_ID (charset
, id
);
1452 check_iso_charset_parameter (dimension
, chars
, final_char
);
1453 chars_flag
= XINT (chars
) == 96;
1454 ISO_CHARSET_TABLE (XINT (dimension
), chars_flag
, XINT (final_char
)) = id
;
1459 /* Return information about charsets in the text at PTR of NBYTES
1460 bytes, which are NCHARS characters. The value is:
1462 0: Each character is represented by one byte. This is always
1463 true for a unibyte string. For a multibyte string, true if
1464 it contains only ASCII characters.
1466 1: No charsets other than ascii, control-1, and latin-1 are
1473 string_xstring_p (Lisp_Object string
)
1475 const unsigned char *p
= SDATA (string
);
1476 const unsigned char *endp
= p
+ SBYTES (string
);
1478 if (SCHARS (string
) == SBYTES (string
))
1483 int c
= STRING_CHAR_ADVANCE (p
);
1492 /* Find charsets in the string at PTR of NCHARS and NBYTES.
1494 CHARSETS is a vector. If Nth element is non-nil, it means the
1495 charset whose id is N is already found.
1497 It may lookup a translation table TABLE if supplied. */
1500 find_charsets_in_text (const unsigned char *ptr
, ptrdiff_t nchars
,
1501 ptrdiff_t nbytes
, Lisp_Object charsets
,
1502 Lisp_Object table
, bool multibyte
)
1504 const unsigned char *pend
= ptr
+ nbytes
;
1506 if (nchars
== nbytes
)
1509 ASET (charsets
, charset_ascii
, Qt
);
1516 c
= translate_char (table
, c
);
1517 if (ASCII_BYTE_P (c
))
1518 ASET (charsets
, charset_ascii
, Qt
);
1520 ASET (charsets
, charset_eight_bit
, Qt
);
1527 int c
= STRING_CHAR_ADVANCE (ptr
);
1528 struct charset
*charset
;
1531 c
= translate_char (table
, c
);
1532 charset
= CHAR_CHARSET (c
);
1533 ASET (charsets
, CHARSET_ID (charset
), Qt
);
1538 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
1540 doc
: /* Return a list of charsets in the region between BEG and END.
1541 BEG and END are buffer positions.
1542 Optional arg TABLE if non-nil is a translation table to look up.
1544 If the current buffer is unibyte, the returned list may contain
1545 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1546 (Lisp_Object beg
, Lisp_Object end
, Lisp_Object table
)
1548 Lisp_Object charsets
;
1549 ptrdiff_t from
, from_byte
, to
, stop
, stop_byte
;
1552 bool multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
1554 validate_region (&beg
, &end
);
1555 from
= XFASTINT (beg
);
1556 stop
= to
= XFASTINT (end
);
1558 if (from
< GPT
&& GPT
< to
)
1561 stop_byte
= GPT_BYTE
;
1564 stop_byte
= CHAR_TO_BYTE (stop
);
1566 from_byte
= CHAR_TO_BYTE (from
);
1568 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1571 find_charsets_in_text (BYTE_POS_ADDR (from_byte
), stop
- from
,
1572 stop_byte
- from_byte
, charsets
, table
,
1576 from
= stop
, from_byte
= stop_byte
;
1577 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
1584 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1585 if (!NILP (AREF (charsets
, i
)))
1586 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1590 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
1592 doc
: /* Return a list of charsets in STR.
1593 Optional arg TABLE if non-nil is a translation table to look up.
1595 If STR is unibyte, the returned list may contain
1596 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1597 (Lisp_Object str
, Lisp_Object table
)
1599 Lisp_Object charsets
;
1605 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1606 find_charsets_in_text (SDATA (str
), SCHARS (str
), SBYTES (str
),
1608 STRING_MULTIBYTE (str
));
1610 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1611 if (!NILP (AREF (charsets
, i
)))
1612 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1618 /* Return a unified character code for C (>= 0x110000). VAL is a
1619 value of Vchar_unify_table for C; i.e. it is nil, an integer, or a
1622 maybe_unify_char (int c
, Lisp_Object val
)
1624 struct charset
*charset
;
1627 return XFASTINT (val
);
1631 CHECK_CHARSET_GET_CHARSET (val
, charset
);
1633 /* The call to load_charset below can allocate memory, which screws
1634 callers of this function through STRING_CHAR_* macros that hold C
1635 pointers to buffer text, if REL_ALLOC is used. */
1636 r_alloc_inhibit_buffer_relocation (1);
1638 load_charset (charset
, 1);
1639 if (! inhibit_load_charset_map
)
1641 val
= CHAR_TABLE_REF (Vchar_unify_table
, c
);
1647 int code_index
= c
- CHARSET_CODE_OFFSET (charset
);
1648 int unified
= GET_TEMP_CHARSET_WORK_DECODER (code_index
);
1654 r_alloc_inhibit_buffer_relocation (0);
1660 /* Return a character corresponding to the code-point CODE of
1664 decode_char (struct charset
*charset
, unsigned int code
)
1667 enum charset_method method
= CHARSET_METHOD (charset
);
1669 if (code
< CHARSET_MIN_CODE (charset
) || code
> CHARSET_MAX_CODE (charset
))
1672 if (method
== CHARSET_METHOD_SUBSET
)
1674 Lisp_Object subset_info
;
1676 subset_info
= CHARSET_SUBSET (charset
);
1677 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1678 code
-= XINT (AREF (subset_info
, 3));
1679 if (code
< XFASTINT (AREF (subset_info
, 1))
1680 || code
> XFASTINT (AREF (subset_info
, 2)))
1683 c
= DECODE_CHAR (charset
, code
);
1685 else if (method
== CHARSET_METHOD_SUPERSET
)
1687 Lisp_Object parents
;
1689 parents
= CHARSET_SUPERSET (charset
);
1691 for (; CONSP (parents
); parents
= XCDR (parents
))
1693 int id
= XINT (XCAR (XCAR (parents
)));
1694 int code_offset
= XINT (XCDR (XCAR (parents
)));
1695 unsigned this_code
= code
- code_offset
;
1697 charset
= CHARSET_FROM_ID (id
);
1698 if ((c
= DECODE_CHAR (charset
, this_code
)) >= 0)
1704 char_index
= CODE_POINT_TO_INDEX (charset
, code
);
1708 if (method
== CHARSET_METHOD_MAP
)
1710 Lisp_Object decoder
;
1712 decoder
= CHARSET_DECODER (charset
);
1713 if (! VECTORP (decoder
))
1715 load_charset (charset
, 1);
1716 decoder
= CHARSET_DECODER (charset
);
1718 if (VECTORP (decoder
))
1719 c
= XINT (AREF (decoder
, char_index
));
1721 c
= GET_TEMP_CHARSET_WORK_DECODER (char_index
);
1723 else /* method == CHARSET_METHOD_OFFSET */
1725 c
= char_index
+ CHARSET_CODE_OFFSET (charset
);
1726 if (CHARSET_UNIFIED_P (charset
)
1727 && MAX_UNICODE_CHAR
< c
&& c
<= MAX_5_BYTE_CHAR
)
1729 /* Unify C with a Unicode character if possible. */
1730 Lisp_Object val
= CHAR_TABLE_REF (Vchar_unify_table
, c
);
1731 c
= maybe_unify_char (c
, val
);
1739 /* Variable used temporarily by the macro ENCODE_CHAR. */
1740 Lisp_Object charset_work
;
1742 /* Return a code-point of C in CHARSET. If C 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
)
1985 bool maybe_null
= 0;
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 (! file_accessible_directory_p (SSDATA (tempdir
)))
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
= list1 (tempdir
);
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
;