1 /* Header for charset handler.
2 Copyright (C) 2001-2023 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
7
8 Copyright (C) 2003
9 National Institute of Advanced Industrial Science and Technology (AIST)
10 Registration Number H13PRO009
11
12 This file is part of GNU Emacs.
13
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 (at
17 your option) any later version.
18
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.
23
24 You should have received a copy of the GNU General Public License
25 along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
26
27 #ifndef EMACS_CHARSET_H
28 #define EMACS_CHARSET_H
29
30 #include <verify.h>
31 #include "lisp.h"
32
33 INLINE_HEADER_BEGIN
34
35 /* Index to arguments of Fdefine_charset_internal. */
36
37 enum define_charset_arg_index
38 {
39 charset_arg_name,
40 charset_arg_dimension,
41 charset_arg_code_space,
42 charset_arg_min_code,
43 charset_arg_max_code,
44 charset_arg_iso_final,
45 charset_arg_iso_revision,
46 charset_arg_emacs_mule_id,
47 charset_arg_ascii_compatible_p,
48 charset_arg_supplementary_p,
49 charset_arg_invalid_code,
50 charset_arg_code_offset,
51 charset_arg_map,
52 charset_arg_subset,
53 charset_arg_superset,
54 charset_arg_unify_map,
55 charset_arg_plist,
56 charset_arg_max
57 };
58
59
60 /* Indices to charset attributes vector. */
61
62 enum charset_attr_index
63 {
64 /* ID number of the charset. */
65 charset_id,
66
67 /* Name of the charset (symbol). */
68 charset_name,
69
70 /* Property list of the charset. */
71 charset_plist,
72
73 /* If the method of the charset is `MAP', the value is a mapping
74 vector or a file name that contains mapping vector. Otherwise,
75 nil. */
76 charset_map,
77
78 /* If the method of the charset is `MAP', the value is a vector
79 that maps code points of the charset to characters. The vector
80 is indexed by a character index. A character index is
81 calculated from a code point and the code-space table of the
82 charset. */
83 charset_decoder,
84
85 /* If the method of the charset is `MAP', the value is a
86 char-table that maps characters of the charset to code
87 points. */
88 charset_encoder,
89
90 /* If the method of the charset is `SUBSET', the value is a vector
91 that has this form:
92
93 [ CHARSET-ID MIN-CODE MAX-CODE OFFSET ]
94
95 CHARSET-ID is an ID number of a parent charset. MIN-CODE and
96 MAX-CODE specify the range of characters inherited from the
97 parent. OFFSET is an integer value to add to a code point of
98 the parent charset to get the corresponding code point of this
99 charset. */
100 charset_subset,
101
102 /* If the method of the charset is `SUPERSET', the value is a list
103 whose elements have this form:
104
105 (CHARSET-ID . OFFSET)
106
107 CHARSET-IDs are ID numbers of parent charsets. OFFSET is an
108 integer value to add to a code point of the parent charset to
109 get the corresponding code point of this charset. */
110 charset_superset,
111
112 /* The value is a mapping vector or a file name that contains the
113 mapping. This defines how characters in the charset should be
114 unified with Unicode. The value of the member
115 `charset_deunifier' is created from this information. */
116 charset_unify_map,
117
118 /* If characters in the charset must be unified Unicode, the value
119 is a char table that maps a unified Unicode character code to
120 the non-unified character code in the charset. */
121 charset_deunifier,
122
123 /* The length of the charset attribute vector. */
124 charset_attr_max
125 };
126
127 /* Methods for converting code points and characters of charsets. */
128
129 enum charset_method
130 {
131 /* For a charset of this method, a character code is calculated
132 from a character index (which is calculated from a code point)
133 simply by adding an offset value. */
134 CHARSET_METHOD_OFFSET,
135
136 /* For a charset of this method, a decoder vector and an encoder
137 char-table is used for code point <-> character code
138 conversion. */
139 CHARSET_METHOD_MAP,
140
141 /* A charset of this method is a subset of another charset. */
142 CHARSET_METHOD_SUBSET,
143
144 /* A charset of this method is a superset of other charsets. */
145 CHARSET_METHOD_SUPERSET
146 };
147
148 struct charset
149 {
150 /* Index to charset_table. */
151 int id;
152
153 /* Index to Vcharset_hash_table. */
154 ptrdiff_t hash_index;
155
156 /* Dimension of the charset: 1, 2, 3, or 4. */
157 int dimension;
158
159 /* Byte code range of each dimension. <code_space>[4N] is a minimum
160 byte code of the (N+1)th dimension, <code_space>[4N+1] is a
161 maximum byte code of the (N+1)th dimension, <code_space>[4N+2] is
162 (<code_space>[4N+1] - <code_space>[4N] + 1), <code_space>[4N+3]
163 is the number of characters contained in the first through (N+1)th
164 dimensions, except that there is no <code_space>[15].
165 We get `char-index' of a `code-point' from this
166 information. */
167 int code_space[15];
168
169 /* If B is a byte of Nth dimension of a code-point, the (N-1)th bit
170 of code_space_mask[B] is set. This array is used to quickly
171 check if a code-point is in a valid range. */
172 unsigned char *code_space_mask;
173
174 /* True if there's no gap in code-points. */
175 bool_bf code_linear_p : 1;
176
177 /* True if the charset is treated as 96 chars in ISO-2022
178 as opposed to 94 chars. */
179 bool_bf iso_chars_96 : 1;
180
181 /* True if the charset is compatible with ASCII. */
182 bool_bf ascii_compatible_p : 1;
183
184 /* True if the charset is supplementary. */
185 bool_bf supplementary_p : 1;
186
187 /* True if all the code points are representable by Lisp_Int. */
188 bool_bf compact_codes_p : 1;
189
190 /* True if the charset is unified with Unicode. */
191 bool_bf unified_p : 1;
192
193 /* ISO final byte of the charset: 48..127. It may be -1 if the
194 charset doesn't conform to ISO-2022. */
195 int iso_final;
196
197 /* ISO revision number of the charset. */
198 int iso_revision;
199
200 /* If the charset is identical to what supported by Emacs 21 and the
201 priors, the identification number of the charset used in those
202 version. Otherwise, -1. */
203 int emacs_mule_id;
204
205 /* The method for encoding/decoding characters of the charset. */
206 enum charset_method method;
207
208 /* Minimum and Maximum code points of the charset. */
209 unsigned min_code, max_code;
210
211 /* Offset value used by macros CODE_POINT_TO_INDEX and
212 INDEX_TO_CODE_POINT. */
213 unsigned char_index_offset;
214
215 /* Minimum and Maximum character codes of the charset. If the
216 charset is compatible with ASCII, min_char is a minimum non-ASCII
217 character of the charset. If the method of charset is
218 CHARSET_METHOD_OFFSET, even if the charset is unified, min_char
219 and max_char doesn't change. */
220 int min_char, max_char;
221
222 /* The code returned by ENCODE_CHAR if a character is not encodable
223 by the charset. */
224 unsigned invalid_code;
225
226 /* If the method of the charset is CHARSET_METHOD_MAP, this is a
227 table of bits used to quickly and roughly guess if a character
228 belongs to the charset.
229
230 The first 64 elements are 512 bits for characters less than
231 0x10000. Each bit corresponds to 128-character block. The last
232 126 elements are 1008 bits for the greater characters
233 (0x10000..0x3FFFFF). Each bit corresponds to 4096-character
234 block.
235
236 If a bit is 1, at least one character in the corresponding block is
237 in this charset. */
238 unsigned char fast_map[190];
239
240 /* Offset value to calculate a character code from code-point, and
241 visa versa. */
242 int code_offset;
243 };
244
245 /* Hash table of charset symbols vs. the corresponding attribute
246 vectors. */
247 extern Lisp_Object Vcharset_hash_table;
248
249 /* Table of struct charset. */
250 extern struct charset *charset_table;
251 extern int charset_table_size;
252 extern int charset_table_used;
253
254 #define CHARSET_FROM_ID(id) (charset_table + (id))
255
256 extern Lisp_Object Vcharset_ordered_list;
257 extern Lisp_Object Vcharset_non_preferred_head;
258
259 extern EMACS_UINT charset_ordered_list_tick;
260
261 extern Lisp_Object Viso_2022_charset_list;
262 extern Lisp_Object Vemacs_mule_charset_list;
263
264 extern int emacs_mule_charset[256];
265
266 /* Macros to access information about charset. */
267
268 /* Return the attribute vector of charset whose symbol is SYMBOL. */
269 #define CHARSET_SYMBOL_ATTRIBUTES(symbol) \
270 Fgethash ((symbol), Vcharset_hash_table, Qnil)
271
272 #define CHARSET_ATTR_ID(attrs) AREF ((attrs), charset_id)
273 #define CHARSET_ATTR_NAME(attrs) AREF ((attrs), charset_name)
274 #define CHARSET_ATTR_PLIST(attrs) AREF ((attrs), charset_plist)
275 #define CHARSET_ATTR_MAP(attrs) AREF ((attrs), charset_map)
276 #define CHARSET_ATTR_DECODER(attrs) AREF ((attrs), charset_decoder)
277 #define CHARSET_ATTR_ENCODER(attrs) AREF ((attrs), charset_encoder)
278 #define CHARSET_ATTR_SUBSET(attrs) AREF ((attrs), charset_subset)
279 #define CHARSET_ATTR_SUPERSET(attrs) AREF ((attrs), charset_superset)
280 #define CHARSET_ATTR_UNIFY_MAP(attrs) AREF ((attrs), charset_unify_map)
281 #define CHARSET_ATTR_DEUNIFIER(attrs) AREF ((attrs), charset_deunifier)
282
283 #define CHARSET_SYMBOL_ID(symbol) \
284 CHARSET_ATTR_ID (CHARSET_SYMBOL_ATTRIBUTES (symbol))
285
286 /* Return an index to Vcharset_hash_table of the charset whose symbol
287 is SYMBOL. */
288 #define CHARSET_SYMBOL_HASH_INDEX(symbol) \
289 hash_lookup (XHASH_TABLE (Vcharset_hash_table), symbol, NULL)
290
291 /* Return the attribute vector of CHARSET. */
292 #define CHARSET_ATTRIBUTES(charset) \
293 (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), (charset)->hash_index))
294
295 #define CHARSET_ID(charset) ((charset)->id)
296 #define CHARSET_HASH_INDEX(charset) ((charset)->hash_index)
297 #define CHARSET_DIMENSION(charset) ((charset)->dimension)
298 #define CHARSET_CODE_SPACE(charset) ((charset)->code_space)
299 #define CHARSET_CODE_LINEAR_P(charset) ((charset)->code_linear_p)
300 #define CHARSET_ISO_CHARS_96(charset) ((charset)->iso_chars_96)
301 #define CHARSET_ISO_FINAL(charset) ((charset)->iso_final)
302 #define CHARSET_ISO_PLANE(charset) ((charset)->iso_plane)
303 #define CHARSET_ISO_REVISION(charset) ((charset)->iso_revision)
304 #define CHARSET_EMACS_MULE_ID(charset) ((charset)->emacs_mule_id)
305 #define CHARSET_ASCII_COMPATIBLE_P(charset) ((charset)->ascii_compatible_p)
306 #define CHARSET_COMPACT_CODES_P(charset) ((charset)->compact_codes_p)
307 #define CHARSET_METHOD(charset) ((charset)->method)
308 #define CHARSET_MIN_CODE(charset) ((charset)->min_code)
309 #define CHARSET_MAX_CODE(charset) ((charset)->max_code)
310 #define CHARSET_INVALID_CODE(charset) ((charset)->invalid_code)
311 #define CHARSET_MIN_CHAR(charset) ((charset)->min_char)
312 #define CHARSET_MAX_CHAR(charset) ((charset)->max_char)
313 #define CHARSET_CODE_OFFSET(charset) ((charset)->code_offset)
314 #define CHARSET_UNIFIED_P(charset) ((charset)->unified_p)
315
316 #define CHARSET_NAME(charset) \
317 (CHARSET_ATTR_NAME (CHARSET_ATTRIBUTES (charset)))
318 #define CHARSET_MAP(charset) \
319 (CHARSET_ATTR_MAP (CHARSET_ATTRIBUTES (charset)))
320 #define CHARSET_DECODER(charset) \
321 (CHARSET_ATTR_DECODER (CHARSET_ATTRIBUTES (charset)))
322 #define CHARSET_ENCODER(charset) \
323 (CHARSET_ATTR_ENCODER (CHARSET_ATTRIBUTES (charset)))
324 #define CHARSET_SUBSET(charset) \
325 (CHARSET_ATTR_SUBSET (CHARSET_ATTRIBUTES (charset)))
326 #define CHARSET_SUPERSET(charset) \
327 (CHARSET_ATTR_SUPERSET (CHARSET_ATTRIBUTES (charset)))
328 #define CHARSET_UNIFY_MAP(charset) \
329 (CHARSET_ATTR_UNIFY_MAP (CHARSET_ATTRIBUTES (charset)))
330 #define CHARSET_DEUNIFIER(charset) \
331 (CHARSET_ATTR_DEUNIFIER (CHARSET_ATTRIBUTES (charset)))
332
333 INLINE void
334 set_charset_attr (struct charset *charset, enum charset_attr_index idx,
335 Lisp_Object val)
336 {
337 ASET (CHARSET_ATTRIBUTES (charset), idx, val);
338 }
339
340
341 /* Nonzero if OBJ is a valid charset symbol. */
342 #define CHARSETP(obj) (CHARSET_SYMBOL_HASH_INDEX (obj) >= 0)
343
344 /* Check if X is a valid charset symbol. If not, signal an error. */
345 #define CHECK_CHARSET(x) \
346 do { \
347 if (! SYMBOLP (x) || CHARSET_SYMBOL_HASH_INDEX (x) < 0) \
348 wrong_type_argument (Qcharsetp, (x)); \
349 } while (false)
350
351
352 /* Check if X is a valid charset symbol. If valid, set ID to the id
353 number of the charset. Otherwise, signal an error. */
354 #define CHECK_CHARSET_GET_ID(x, id) \
355 do { \
356 ptrdiff_t idx; \
357 \
358 if (! SYMBOLP (x) || (idx = CHARSET_SYMBOL_HASH_INDEX (x)) < 0) \
359 wrong_type_argument (Qcharsetp, (x)); \
360 id = XFIXNUM (AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx), \
361 charset_id)); \
362 } while (false)
363
364
365 /* Check if X is a valid charset symbol. If valid, set ATTR to the
366 attr vector of the charset. Otherwise, signal an error. */
367 #define CHECK_CHARSET_GET_ATTR(x, attr) \
368 do { \
369 if (!SYMBOLP (x) || NILP (attr = CHARSET_SYMBOL_ATTRIBUTES (x))) \
370 wrong_type_argument (Qcharsetp, (x)); \
371 } while (false)
372
373
374 #define CHECK_CHARSET_GET_CHARSET(x, charset) \
375 do { \
376 int csid; \
377 CHECK_CHARSET_GET_ID (x, csid); \
378 charset = CHARSET_FROM_ID (csid); \
379 } while (false)
380
381
382 /* Lookup Vcharset_ordered_list and return the first charset that
383 contains the character C. */
384 #define CHAR_CHARSET(c) \
385 ((c) < 0x80 ? CHARSET_FROM_ID (charset_ascii) \
386 : char_charset ((c), Qnil, NULL))
387
388 #if false
389 /* Char-table of charset-sets. Each element is a bool vector indexed
390 by a charset ID. */
391 extern Lisp_Object Vchar_charset_set;
392
393 /* Charset-bag of character C. */
394 #define CHAR_CHARSET_SET(c) \
395 CHAR_TABLE_REF (Vchar_charset_set, c)
396
397 /* Check if two characters C1 and C2 belong to the same charset. */
398 #define SAME_CHARSET_P(c1, c2) \
399 intersection_p (CHAR_CHARSET_SET (c1), CHAR_CHARSET_SET (c2))
400
401 #endif
402
403
404 /* Return a character corresponding to the code-point CODE of CHARSET.
405 Try some optimization before calling decode_char. */
406
407 #define DECODE_CHAR(charset, code) \
408 ((ASCII_CHAR_P (code) && (charset)->ascii_compatible_p) \
409 ? (code) \
410 : ((code) < (charset)->min_code || (code) > (charset)->max_code) \
411 ? -1 \
412 : (charset)->unified_p \
413 ? decode_char ((charset), (code)) \
414 : (charset)->method == CHARSET_METHOD_OFFSET \
415 ? ((charset)->code_linear_p \
416 ? (int) ((code) - (charset)->min_code) + (charset)->code_offset \
417 : decode_char ((charset), (code))) \
418 : (charset)->method == CHARSET_METHOD_MAP \
419 ? (((charset)->code_linear_p \
420 && VECTORP (CHARSET_DECODER (charset))) \
421 ? XFIXNUM (AREF (CHARSET_DECODER (charset), \
422 (code) - (charset)->min_code)) \
423 : decode_char ((charset), (code))) \
424 : decode_char ((charset), (code)))
425
426 extern Lisp_Object charset_work;
427
428 /* Return a code point of CHAR in CHARSET.
429 Try some optimization before calling encode_char. */
430
431 #define ENCODE_CHAR(charset, c) \
432 (verify_expr \
433 (sizeof (c) <= sizeof (int), \
434 (ASCII_CHAR_P (c) && (charset)->ascii_compatible_p \
435 ? (unsigned) (c) \
436 : ((charset)->unified_p \
437 || (charset)->method == CHARSET_METHOD_SUBSET \
438 || (charset)->method == CHARSET_METHOD_SUPERSET) \
439 ? encode_char (charset, c) \
440 : (c) < (charset)->min_char || (c) > (charset)->max_char \
441 ? (charset)->invalid_code \
442 : (charset)->method == CHARSET_METHOD_OFFSET \
443 ? ((charset)->code_linear_p \
444 ? (unsigned) ((c) - (charset)->code_offset) + (charset)->min_code \
445 : encode_char (charset, c)) \
446 : (charset)->method == CHARSET_METHOD_MAP \
447 ? (((charset)->compact_codes_p \
448 && CHAR_TABLE_P (CHARSET_ENCODER (charset))) \
449 ? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), c), \
450 (NILP (charset_work) \
451 ? (charset)->invalid_code \
452 : (unsigned) XFIXNAT (charset_work))) \
453 : encode_char (charset, c)) \
454 : encode_char (charset, c))))
455
456
457 /* Set to true when a charset map is loaded to warn that a buffer text
458 and a string data may be relocated. */
459 extern bool charset_map_loaded;
460
461
462 /* Set CHARSET to the charset highest priority of C, CODE to the
463 code-point of C in CHARSET. */
464 #define SPLIT_CHAR(c, charset, code) \
465 ((charset) = char_charset ((c), Qnil, &(code)))
466
467
468 #define ISO_MAX_DIMENSION 3
469 #define ISO_MAX_CHARS 2
470 #define ISO_MAX_FINAL 0x80 /* only 0x30..0xFF are used */
471
472 /* Mapping table from ISO2022's charset (specified by DIMENSION,
473 CHARS, and FINAL_CHAR) to Emacs' charset ID. Should be accessed by
474 macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR). */
475 extern int iso_charset_table[ISO_MAX_DIMENSION][ISO_MAX_CHARS][ISO_MAX_FINAL];
476
477 /* A charset of type iso2022 who has DIMENSION, CHARS_96, and FINAL
478 (final character). */
479 #define ISO_CHARSET_TABLE(dimension, chars_96, final) \
480 iso_charset_table[(dimension) - 1][chars_96][final]
481
482 /* Nonzero if the charset who has FAST_MAP may contain C. */
483 #define CHARSET_FAST_MAP_REF(c, fast_map) \
484 ((c) < 0x10000 \
485 ? fast_map[(c) >> 10] & (1 << (((c) >> 7) & 7)) \
486 : fast_map[((c) >> 15) + 62] & (1 << (((c) >> 12) & 7)))
487
488 #define CHARSET_FAST_MAP_SET(c, fast_map) \
489 do { \
490 if ((c) < 0x10000) \
491 (fast_map)[(c) >> 10] |= 1 << (((c) >> 7) & 7); \
492 else \
493 (fast_map)[((c) >> 15) + 62] |= 1 << (((c) >> 12) & 7); \
494 } while (false)
495
496
497
498 /* True if CHARSET may contain the character C. */
499 #define CHAR_CHARSET_P(c, charset) \
500 ((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p) \
501 || ((CHARSET_UNIFIED_P (charset) \
502 || (charset)->method == CHARSET_METHOD_SUBSET \
503 || (charset)->method == CHARSET_METHOD_SUPERSET) \
504 ? encode_char ((charset), (c)) != (charset)->invalid_code \
505 : (CHARSET_FAST_MAP_REF ((c), (charset)->fast_map) \
506 && ((charset)->method == CHARSET_METHOD_OFFSET \
507 ? (c) >= (charset)->min_char && (c) <= (charset)->max_char \
508 : ((charset)->method == CHARSET_METHOD_MAP \
509 && (charset)->compact_codes_p \
510 && CHAR_TABLE_P (CHARSET_ENCODER (charset))) \
511 ? ! NILP (CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c))) \
512 : encode_char ((charset), (c)) != (charset)->invalid_code))))
513
514
515 /* Special macros for emacs-mule encoding. */
516
517 /* Leading-code followed by extended leading-code. DIMENSION/COLUMN */
518 #define EMACS_MULE_LEADING_CODE_PRIVATE_11 0x9A /* 1/1 */
519 #define EMACS_MULE_LEADING_CODE_PRIVATE_12 0x9B /* 1/2 */
520 #define EMACS_MULE_LEADING_CODE_PRIVATE_21 0x9C /* 2/2 */
521 #define EMACS_MULE_LEADING_CODE_PRIVATE_22 0x9D /* 2/2 */
522
523
524
525 extern int charset_ascii, charset_eight_bit;
526 extern int charset_unicode;
527 extern int charset_jisx0201_roman;
528 extern int charset_jisx0208_1978;
529 extern int charset_jisx0208;
530 extern int charset_ksc5601;
531
532 extern int charset_unibyte;
533
534 extern struct charset *char_charset (int, Lisp_Object, unsigned *);
535 extern Lisp_Object charset_attributes (int);
536
537 extern int decode_char (struct charset *, unsigned);
538 extern unsigned encode_char (struct charset *, int);
539 extern int string_xstring_p (Lisp_Object);
540
541 extern void map_charset_chars (void (*) (Lisp_Object, Lisp_Object),
542 Lisp_Object, Lisp_Object,
543 struct charset *, unsigned, unsigned);
544
545 INLINE_HEADER_END
546
547 #endif /* EMACS_CHARSET_H */