?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(group thumbs): Add :version keyword.
[emacs.git] / src / charset.h
blobb49ed87a3abc332e8dd7fcb302c06a63ad100332
1 /* Header for multibyte character handler.
2 Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
4 Copyright (C) 2001 Free Software Foundation, Inc.
5
6 This file is part of GNU Emacs.
7
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #ifndef EMACS_CHARSET_H
24 #define EMACS_CHARSET_H
25
26 /* #define BYTE_COMBINING_DEBUG */
27
28 /*** GENERAL NOTE on CHARACTER SET (CHARSET) ***
29
30 A character set ("charset" hereafter) is a meaningful collection
31 (i.e. language, culture, functionality, etc) of characters. Emacs
32 handles multiple charsets at once. Each charset corresponds to one
33 of the ISO charsets. Emacs identifies a charset by a unique
34 identification number, whereas ISO identifies a charset by a triplet
35 of DIMENSION, CHARS and FINAL-CHAR. So, hereafter, just saying
36 "charset" means an identification number (integer value).
37
38 The value range of charsets is 0x00, 0x81..0xFE. There are four
39 kinds of charset depending on DIMENSION (1 or 2) and CHARS (94 or
40 96). For instance, a charset of DIMENSION2_CHARS94 contains 94x94
41 characters.
42
43 Within Emacs Lisp, a charset is treated as a symbol which has a
44 property `charset'. The property value is a vector containing
45 various information about the charset. For readability of C code,
46 we use the following convention for C variable names:
47 charset_symbol: Emacs Lisp symbol of a charset
48 charset_id: Emacs Lisp integer of an identification number of a charset
49 charset: C integer of an identification number of a charset
50
51 Each charset (except for ascii) is assigned a base leading-code
52 (range 0x80..0x9E). In addition, a charset of greater than 0xA0
53 (whose base leading-code is 0x9A..0x9D) is assigned an extended
54 leading-code (range 0xA0..0xFE). In this case, each base
55 leading-code specifies the allowable range of extended leading-code
56 as shown in the table below. A leading-code is used to represent a
57 character in Emacs' buffer and string.
58
59 We call a charset which has extended leading-code a "private
60 charset" because those are mainly for a charset which is not yet
61 registered by ISO. On the contrary, we call a charset which does
62 not have extended leading-code an "official charset".
63
64 ---------------------------------------------------------------------------
65 charset dimension base leading-code extended leading-code
66 ---------------------------------------------------------------------------
67 0x00 official dim1 -- none -- -- none --
68 (ASCII)
69 0x01..0x7F --never used--
70 0x80 official dim1 -- none -- -- none --
71 (eight-bit-graphic)
72 0x81..0x8F official dim1 same as charset -- none --
73 0x90..0x99 official dim2 same as charset -- none --
74 0x9A..0x9D --never used--
75 0x9E official dim1 same as charset -- none --
76 (eight-bit-control)
77 0x9F --never used--
78 0xA0..0xDF private dim1 0x9A same as charset
79 of 1-column width
80 0xE0..0xEF private dim1 0x9B same as charset
81 of 2-column width
82 0xF0..0xF4 private dim2 0x9C same as charset
83 of 1-column width
84 0xF5..0xFE private dim2 0x9D same as charset
85 of 2-column width
86 0xFF --never used--
87 ---------------------------------------------------------------------------
88
89 */
90
91 /* Definition of special leading-codes. */
92 /* Leading-code followed by extended leading-code. */
93 #define LEADING_CODE_PRIVATE_11 0x9A /* for private DIMENSION1 of 1-column */
94 #define LEADING_CODE_PRIVATE_12 0x9B /* for private DIMENSION1 of 2-column */
95 #define LEADING_CODE_PRIVATE_21 0x9C /* for private DIMENSION2 of 1-column */
96 #define LEADING_CODE_PRIVATE_22 0x9D /* for private DIMENSION2 of 2-column */
97
98 #define LEADING_CODE_8_BIT_CONTROL 0x9E /* for `eight-bit-control' */
99
100 /* Extended leading-code. */
101 /* Start of each extended leading-codes. */
102 #define LEADING_CODE_EXT_11 0xA0 /* follows LEADING_CODE_PRIVATE_11 */
103 #define LEADING_CODE_EXT_12 0xE0 /* follows LEADING_CODE_PRIVATE_12 */
104 #define LEADING_CODE_EXT_21 0xF0 /* follows LEADING_CODE_PRIVATE_21 */
105 #define LEADING_CODE_EXT_22 0xF5 /* follows LEADING_CODE_PRIVATE_22 */
106 /* Maximum value of extended leading-codes. */
107 #define LEADING_CODE_EXT_MAX 0xFE
108
109 /* Definition of minimum/maximum charset of each DIMENSION. */
110 #define MIN_CHARSET_OFFICIAL_DIMENSION1 0x80
111 #define MAX_CHARSET_OFFICIAL_DIMENSION1 0x8F
112 #define MIN_CHARSET_OFFICIAL_DIMENSION2 0x90
113 #define MAX_CHARSET_OFFICIAL_DIMENSION2 0x99
114 #define MIN_CHARSET_PRIVATE_DIMENSION1 LEADING_CODE_EXT_11
115 #define MIN_CHARSET_PRIVATE_DIMENSION2 LEADING_CODE_EXT_21
116
117 /* Maximum value of overall charset identification number. */
118 #define MAX_CHARSET 0xFE
119
120 /* Definition of special charsets. */
121 #define CHARSET_ASCII 0 /* 0x00..0x7F */
122 #define CHARSET_8_BIT_CONTROL 0x9E /* 0x80..0x9F */
123 #define CHARSET_8_BIT_GRAPHIC 0x80 /* 0xA0..0xFF */
124
125 extern int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */
126 extern int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */
127 extern int charset_jisx0208; /* JISX0208.1983 (Japanese Kanji) */
128 extern int charset_katakana_jisx0201; /* JISX0201.Kana (Japanese Katakana) */
129 extern int charset_latin_jisx0201; /* JISX0201.Roman (Japanese Roman) */
130 extern int charset_big5_1; /* Big5 Level 1 (Chinese Traditional) */
131 extern int charset_big5_2; /* Big5 Level 2 (Chinese Traditional) */
132
133 /* Check if CH is an ASCII character or a base leading-code.
134 Nowadays, any byte can be the first byte of a character in a
135 multibyte buffer/string. So this macro name is not appropriate. */
136 #define CHAR_HEAD_P(ch) ((unsigned char) (ch) < 0xA0)
137
138 /*** GENERAL NOTE on CHARACTER REPRESENTATION ***
139
140 Firstly, the term "character" or "char" is used for a multilingual
141 character (of course, including ASCII characters), not for a byte in
142 computer memory. We use the term "code" or "byte" for the latter
143 case.
144
145 A character is identified by charset and one or two POSITION-CODEs.
146 POSITION-CODE is the position of the character in the charset. A
147 character of DIMENSION1 charset has one POSITION-CODE: POSITION-CODE-1.
148 A character of DIMENSION2 charset has two POSITION-CODE:
149 POSITION-CODE-1 and POSITION-CODE-2. The code range of
150 POSITION-CODE is 0x20..0x7F.
151
152 Emacs has two kinds of representation of a character: multi-byte
153 form (for buffers and strings) and single-word form (for character
154 objects in Emacs Lisp). The latter is called "character code"
155 hereafter. Both representations encode the information of charset
156 and POSITION-CODE but in a different way (for instance, the MSB of
157 POSITION-CODE is set in multi-byte form).
158
159 For details of the multi-byte form, see the section "2. Emacs
160 internal format handlers" of `coding.c'.
161
162 Emacs uses 19 bits for a character code. The bits are divided into
163 3 fields: FIELD1(5bits):FIELD2(7bits):FIELD3(7bits).
164
165 A character code of DIMENSION1 character uses FIELD2 to hold charset
166 and FIELD3 to hold POSITION-CODE-1. A character code of DIMENSION2
167 character uses FIELD1 to hold charset, FIELD2 and FIELD3 to hold
168 POSITION-CODE-1 and POSITION-CODE-2 respectively.
169
170 More precisely...
171
172 FIELD2 of DIMENSION1 character (except for ascii, eight-bit-control,
173 and eight-bit-graphic) is "charset - 0x70". This is to make all
174 character codes except for ASCII and 8-bit codes greater than 256.
175 So, the range of FIELD2 of DIMENSION1 character is 0, 1, or
176 0x11..0x7F.
177
178 FIELD1 of DIMENSION2 character is "charset - 0x8F" for official
179 charset and "charset - 0xE0" for private charset. So, the range of
180 FIELD1 of DIMENSION2 character is 0x01..0x1E.
181
182 -----------------------------------------------------------------------------
183 charset FIELD1 (5-bit) FIELD2 (7-bit) FIELD3 (7-bit)
184 -----------------------------------------------------------------------------
185 ascii 0 0 0x00..0x7F
186 eight-bit-control 0 1 0x00..0x1F
187 eight-bit-graphic 0 1 0x20..0x7F
188 DIMENSION1 0 charset - 0x70 POSITION-CODE-1
189 DIMENSION2(o) charset - 0x8F POSITION-CODE-1 POSITION-CODE-2
190 DIMENSION2(p) charset - 0xE0 POSITION-CODE-1 POSITION-CODE-2
191 -----------------------------------------------------------------------------
192 "(o)": official, "(p)": private
193 -----------------------------------------------------------------------------
194 */
195
196 /* Masks of each field of character code. */
197 #define CHAR_FIELD1_MASK (0x1F << 14)
198 #define CHAR_FIELD2_MASK (0x7F << 7)
199 #define CHAR_FIELD3_MASK 0x7F
200
201 /* Macros to access each field of character C. */
202 #define CHAR_FIELD1(c) (((c) & CHAR_FIELD1_MASK) >> 14)
203 #define CHAR_FIELD2(c) (((c) & CHAR_FIELD2_MASK) >> 7)
204 #define CHAR_FIELD3(c) ((c) & CHAR_FIELD3_MASK)
205
206 /* Minimum character code of character of each DIMENSION. */
207 #define MIN_CHAR_OFFICIAL_DIMENSION1 \
208 ((0x81 - 0x70) << 7)
209 #define MIN_CHAR_PRIVATE_DIMENSION1 \
210 ((MIN_CHARSET_PRIVATE_DIMENSION1 - 0x70) << 7)
211 #define MIN_CHAR_OFFICIAL_DIMENSION2 \
212 ((MIN_CHARSET_OFFICIAL_DIMENSION2 - 0x8F) << 14)
213 #define MIN_CHAR_PRIVATE_DIMENSION2 \
214 ((MIN_CHARSET_PRIVATE_DIMENSION2 - 0xE0) << 14)
215 /* Maximum character code currently used plus 1. */
216 #define MAX_CHAR (0x1F << 14)
217
218 /* 1 if C is a single byte character, else 0. */
219 #define SINGLE_BYTE_CHAR_P(c) (((unsigned)(c) & 0xFF) == (c))
220
221 /* 1 if BYTE is an ASCII character in itself, in multibyte mode. */
222 #define ASCII_BYTE_P(byte) ((byte) < 0x80)
223
224 /* A char-table containing information on each character set.
225
226 Unlike ordinary char-tables, this doesn't contain any nested tables.
227 Only the top level elements are used. Each element is a vector of
228 the following information:
229 CHARSET-ID, BYTES, DIMENSION, CHARS, WIDTH, DIRECTION,
230 LEADING-CODE-BASE, LEADING-CODE-EXT,
231 ISO-FINAL-CHAR, ISO-GRAPHIC-PLANE,
232 REVERSE-CHARSET, SHORT-NAME, LONG-NAME, DESCRIPTION,
233 PLIST.
234
235 CHARSET-ID (integer) is the identification number of the charset.
236
237 BYTES (integer) is the length of the multi-byte form of a character
238 in the charset: one of 1, 2, 3, and 4.
239
240 DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
241
242 CHARS (integer) is the number of characters in a dimension: 94 or 96.
243
244 WIDTH (integer) is the number of columns a character in the charset
245 occupies on the screen: one of 0, 1, and 2..
246
247 DIRECTION (integer) is the rendering direction of characters in the
248 charset when rendering. If 0, render from left to right, else
249 render from right to left.
250
251 LEADING-CODE-BASE (integer) is the base leading-code for the
252 charset.
253
254 LEADING-CODE-EXT (integer) is the extended leading-code for the
255 charset. All charsets of less than 0xA0 have the value 0.
256
257 ISO-FINAL-CHAR (character) is the final character of the
258 corresponding ISO 2022 charset. It is -1 for such a character
259 that is used only internally (e.g. `eight-bit-control').
260
261 ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
262 while encoding to variants of ISO 2022 coding system, one of the
263 following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR). It
264 is -1 for such a character that is used only internally
265 (e.g. `eight-bit-control').
266
267 REVERSE-CHARSET (integer) is the charset which differs only in
268 LEFT-TO-RIGHT value from the charset. If there's no such a
269 charset, the value is -1.
270
271 SHORT-NAME (string) is the short name to refer to the charset.
272
273 LONG-NAME (string) is the long name to refer to the charset.
274
275 DESCRIPTION (string) is the description string of the charset.
276
277 PLIST (property list) may contain any type of information a user
278 wants to put and get by functions `put-charset-property' and
279 `get-charset-property' respectively. */
280 extern Lisp_Object Vcharset_table;
281
282 /* Macros to access various information of CHARSET in Vcharset_table.
283 We provide these macros for efficiency. No range check of CHARSET. */
284
285 /* Return entry of CHARSET (C integer) in Vcharset_table. */
286 #define CHARSET_TABLE_ENTRY(charset) \
287 XCHAR_TABLE (Vcharset_table)->contents[((charset) == CHARSET_ASCII \
288 ? 0 : (charset) + 128)]
289
290 /* Return information INFO-IDX of CHARSET. */
291 #define CHARSET_TABLE_INFO(charset, info_idx) \
292 XVECTOR (CHARSET_TABLE_ENTRY (charset))->contents[info_idx]
293
294 #define CHARSET_ID_IDX (0)
295 #define CHARSET_BYTES_IDX (1)
296 #define CHARSET_DIMENSION_IDX (2)
297 #define CHARSET_CHARS_IDX (3)
298 #define CHARSET_WIDTH_IDX (4)
299 #define CHARSET_DIRECTION_IDX (5)
300 #define CHARSET_LEADING_CODE_BASE_IDX (6)
301 #define CHARSET_LEADING_CODE_EXT_IDX (7)
302 #define CHARSET_ISO_FINAL_CHAR_IDX (8)
303 #define CHARSET_ISO_GRAPHIC_PLANE_IDX (9)
304 #define CHARSET_REVERSE_CHARSET_IDX (10)
305 #define CHARSET_SHORT_NAME_IDX (11)
306 #define CHARSET_LONG_NAME_IDX (12)
307 #define CHARSET_DESCRIPTION_IDX (13)
308 #define CHARSET_PLIST_IDX (14)
309 /* Size of a vector of each entry of Vcharset_table. */
310 #define CHARSET_MAX_IDX (15)
311
312 /* And several more macros to be used frequently. */
313 #define CHARSET_BYTES(charset) \
314 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX))
315 #define CHARSET_DIMENSION(charset) \
316 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX))
317 #define CHARSET_CHARS(charset) \
318 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_CHARS_IDX))
319 #define CHARSET_WIDTH(charset) \
320 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_WIDTH_IDX))
321 #define CHARSET_DIRECTION(charset) \
322 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX))
323 #define CHARSET_LEADING_CODE_BASE(charset) \
324 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_BASE_IDX))
325 #define CHARSET_LEADING_CODE_EXT(charset) \
326 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_EXT_IDX))
327 #define CHARSET_ISO_FINAL_CHAR(charset) \
328 XINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_FINAL_CHAR_IDX))
329 #define CHARSET_ISO_GRAPHIC_PLANE(charset) \
330 XINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_GRAPHIC_PLANE_IDX))
331 #define CHARSET_REVERSE_CHARSET(charset) \
332 XINT (CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX))
333
334 /* Macros to specify direction of a charset. */
335 #define CHARSET_DIRECTION_LEFT_TO_RIGHT 0
336 #define CHARSET_DIRECTION_RIGHT_TO_LEFT 1
337
338 /* A vector of charset symbol indexed by charset-id. This is used
339 only for returning charset symbol from C functions. */
340 extern Lisp_Object Vcharset_symbol_table;
341
342 /* Return symbol of CHARSET. */
343 #define CHARSET_SYMBOL(charset) \
344 XVECTOR (Vcharset_symbol_table)->contents[charset]
345
346 /* 1 if CHARSET is in valid value range, else 0. */
347 #define CHARSET_VALID_P(charset) \
348 ((charset) == 0 \
349 || ((charset) > 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
350 || ((charset) >= MIN_CHARSET_PRIVATE_DIMENSION1 \
351 && (charset) <= MAX_CHARSET) \
352 || ((charset) == CHARSET_8_BIT_CONTROL) \
353 || ((charset) == CHARSET_8_BIT_GRAPHIC))
354
355 /* 1 if CHARSET is already defined, else 0. */
356 #define CHARSET_DEFINED_P(charset) \
357 (((charset) >= 0) && ((charset) <= MAX_CHARSET) \
358 && !NILP (CHARSET_TABLE_ENTRY (charset)))
359
360 /* Since the information CHARSET-BYTES and CHARSET-WIDTH of
361 Vcharset_table can be retrieved only by the first byte of
362 multi-byte form (an ASCII code or a base leading-code), we provide
363 here tables to be used by macros BYTES_BY_CHAR_HEAD and
364 WIDTH_BY_CHAR_HEAD for faster information retrieval. */
365 extern int bytes_by_char_head[256];
366 extern int width_by_char_head[256];
367
368 #define BYTES_BY_CHAR_HEAD(char_head) \
369 (ASCII_BYTE_P (char_head) ? 1 : bytes_by_char_head[char_head])
370 #define WIDTH_BY_CHAR_HEAD(char_head) \
371 (ASCII_BYTE_P (char_head) ? 1 : width_by_char_head[char_head])
372
373 /* Charset of the character C. */
374 #define CHAR_CHARSET(c) \
375 (SINGLE_BYTE_CHAR_P (c) \
376 ? (ASCII_BYTE_P (c) \
377 ? CHARSET_ASCII \
378 : (c) < 0xA0 ? CHARSET_8_BIT_CONTROL : CHARSET_8_BIT_GRAPHIC) \
379 : ((c) < MIN_CHAR_OFFICIAL_DIMENSION2 \
380 ? CHAR_FIELD2 (c) + 0x70 \
381 : ((c) < MIN_CHAR_PRIVATE_DIMENSION2 \
382 ? CHAR_FIELD1 (c) + 0x8F \
383 : CHAR_FIELD1 (c) + 0xE0)))
384
385 /* Check if two characters C1 and C2 belong to the same charset. */
386 #define SAME_CHARSET_P(c1, c2) \
387 (c1 < MIN_CHAR_OFFICIAL_DIMENSION2 \
388 ? (c1 & CHAR_FIELD2_MASK) == (c2 & CHAR_FIELD2_MASK) \
389 : (c1 & CHAR_FIELD1_MASK) == (c2 & CHAR_FIELD1_MASK))
390
391 /* Return a character of which charset is CHARSET and position-codes
392 are C1 and C2. DIMENSION1 character ignores C2. */
393 #define MAKE_CHAR(charset, c1, c2) \
394 ((charset) == CHARSET_ASCII \
395 ? (c1) & 0x7F \
396 : (((charset) == CHARSET_8_BIT_CONTROL \
397 || (charset) == CHARSET_8_BIT_GRAPHIC) \
398 ? ((c1) & 0x7F) | 0x80 \
399 : ((CHARSET_DEFINED_P (charset) \
400 ? CHARSET_DIMENSION (charset) == 1 \
401 : (charset) < MIN_CHARSET_PRIVATE_DIMENSION2) \
402 ? (((charset) - 0x70) << 7) | ((c1) <= 0 ? 0 : ((c1) & 0x7F)) \
403 : ((((charset) \
404 - ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)) \
405 << 14) \
406 | ((c2) <= 0 ? 0 : ((c2) & 0x7F)) \
407 | ((c1) <= 0 ? 0 : (((c1) & 0x7F) << 7))))))
408
409
410 /* If GENERICP is nonzero, return nonzero iff C is a valid normal or
411 generic character. If GENERICP is zero, return nonzero iff C is a
412 valid normal character. */
413 #define CHAR_VALID_P(c, genericp) \
414 ((c) >= 0 \
415 && (SINGLE_BYTE_CHAR_P (c) || char_valid_p (c, genericp)))
416
417 /* This default value is used when nonascii-translation-table or
418 nonascii-insert-offset fail to convert unibyte character to a valid
419 multibyte character. This makes a Latin-1 character. */
420
421 #define DEFAULT_NONASCII_INSERT_OFFSET 0x800
422
423 /* Parse multibyte string STR of length LENGTH and set BYTES to the
424 byte length of a character at STR. */
425
426 #ifdef BYTE_COMBINING_DEBUG
427
428 #define PARSE_MULTIBYTE_SEQ(str, length, bytes) \
429 do { \
430 int i = 1; \
431 while (i < (length) && ! CHAR_HEAD_P ((str)[i])) i++; \
432 (bytes) = BYTES_BY_CHAR_HEAD ((str)[0]); \
433 if ((bytes) > i) \
434 abort (); \
435 } while (0)
436
437 #else /* not BYTE_COMBINING_DEBUG */
438
439 #define PARSE_MULTIBYTE_SEQ(str, length, bytes) \
440 ((void)(length), (bytes) = BYTES_BY_CHAR_HEAD ((str)[0]))
441
442 #endif /* not BYTE_COMBINING_DEBUG */
443
444 #define VALID_LEADING_CODE_P(code) \
445 (! NILP (CHARSET_TABLE_ENTRY (code)))
446
447 /* Return 1 iff the byte sequence at unibyte string STR (LENGTH bytes)
448 is valid as a multibyte form. If valid, by a side effect, BYTES is
449 set to the byte length of the multibyte form. */
450
451 #define UNIBYTE_STR_AS_MULTIBYTE_P(str, length, bytes) \
452 (((str)[0] < 0x80 || (str)[0] >= 0xA0) \
453 ? ((bytes) = 1) \
454 : (((bytes) = BYTES_BY_CHAR_HEAD ((str)[0])), \
455 ((bytes) <= (length) \
456 && !CHAR_HEAD_P ((str)[1]) \
457 && ((bytes) == 2 \
458 ? (str)[0] != LEADING_CODE_8_BIT_CONTROL \
459 : (!CHAR_HEAD_P ((str)[2]) \
460 && ((bytes) == 3 \
461 ? (((str)[0] != LEADING_CODE_PRIVATE_11 \
462 && (str)[0] != LEADING_CODE_PRIVATE_12) \
463 || VALID_LEADING_CODE_P (str[1])) \
464 : (!CHAR_HEAD_P ((str)[3]) \
465 && VALID_LEADING_CODE_P (str[1]))))))))
466
467
468 /* Return 1 iff the byte sequence at multibyte string STR is valid as
469 a unibyte form. By a side effect, BYTES is set to the byte length
470 of one character at STR. */
471
472 #define MULTIBYTE_STR_AS_UNIBYTE_P(str, bytes) \
473 ((bytes) = BYTES_BY_CHAR_HEAD ((str)[0]), \
474 (str)[0] != LEADING_CODE_8_BIT_CONTROL)
475
476 /* The charset of character C is stored in CHARSET, and the
477 position-codes of C are stored in C1 and C2.
478 We store -1 in C2 if the dimension of the charset is 1. */
479
480 #define SPLIT_CHAR(c, charset, c1, c2) \
481 (SINGLE_BYTE_CHAR_P (c) \
482 ? ((charset \
483 = (ASCII_BYTE_P (c) \
484 ? CHARSET_ASCII \
485 : ((c) < 0xA0 ? CHARSET_8_BIT_CONTROL : CHARSET_8_BIT_GRAPHIC))), \
486 c1 = (c), c2 = -1) \
487 : ((c) & CHAR_FIELD1_MASK \
488 ? (charset = (CHAR_FIELD1 (c) \
489 + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)), \
490 c1 = CHAR_FIELD2 (c), \
491 c2 = CHAR_FIELD3 (c)) \
492 : (charset = CHAR_FIELD2 (c) + 0x70, \
493 c1 = CHAR_FIELD3 (c), \
494 c2 = -1)))
495
496 /* Return 1 iff character C has valid printable glyph. */
497 #define CHAR_PRINTABLE_P(c) (ASCII_BYTE_P (c) || char_printable_p (c))
498
499 /* The charset of the character at STR is stored in CHARSET, and the
500 position-codes are stored in C1 and C2.
501 We store -1 in C2 if the character is just 2 bytes. */
502
503 #define SPLIT_STRING(str, len, charset, c1, c2) \
504 ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2 \
505 || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len \
506 || split_string (str, len, &charset, &c1, &c2) < 0) \
507 ? c1 = *(str), charset = CHARSET_ASCII \
508 : charset)
509
510 /* Mapping table from ISO2022's charset (specified by DIMENSION,
511 CHARS, and FINAL_CHAR) to Emacs' charset. Should be accessed by
512 macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR). */
513 extern int iso_charset_table[2][2][128];
514
515 #define ISO_CHARSET_TABLE(dimension, chars, final_char) \
516 iso_charset_table[XINT (dimension) - 1][XINT (chars) > 94][XINT (final_char)]
517
518 #define BASE_LEADING_CODE_P(c) (BYTES_BY_CHAR_HEAD ((unsigned char) (c)) > 1)
519
520 /* Return how many bytes C will occupy in a multibyte buffer. */
521 #define CHAR_BYTES(c) \
522 (SINGLE_BYTE_CHAR_P (c) \
523 ? ((ASCII_BYTE_P (c) || (c) >= 0xA0) ? 1 : 2) \
524 : char_bytes (c))
525
526 /* The following two macros CHAR_STRING and STRING_CHAR are the main
527 entry points to convert between Emacs's two types of character
528 representations: multi-byte form and single-word form (character
529 code). */
530
531 /* Store multi-byte form of the character C in STR. The caller should
532 allocate at least MAX_MULTIBYTE_LENGTH bytes area at STR in
533 advance. Returns the length of the multi-byte form. If C is an
534 invalid character code, signal an error. */
535
536 #define CHAR_STRING(c, str) \
537 (SINGLE_BYTE_CHAR_P (c) \
538 ? ((ASCII_BYTE_P (c) || c >= 0xA0) \
539 ? (*(str) = (unsigned char)(c), 1) \
540 : (*(str) = LEADING_CODE_8_BIT_CONTROL, *((str)+ 1) = c + 0x20, 2)) \
541 : char_to_string (c, (unsigned char *) str))
542
543 /* Like CHAR_STRING but don't signal an error if C is invalid.
544 Value is -1 in this case. */
545
546 #define CHAR_STRING_NO_SIGNAL(c, str) \
547 (SINGLE_BYTE_CHAR_P (c) \
548 ? ((ASCII_BYTE_P (c) || c >= 0xA0) \
549 ? (*(str) = (unsigned char)(c), 1) \
550 : (*(str) = LEADING_CODE_8_BIT_CONTROL, *((str)+ 1) = c + 0x20, 2)) \
551 : char_to_string_1 (c, (unsigned char *) str))
552
553 /* Return a character code of the character of which multi-byte form
554 is at STR and the length is LEN. If STR doesn't contain valid
555 multi-byte form, only the first byte in STR is returned. */
556
557 #define STRING_CHAR(str, len) \
558 (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1 \
559 ? (unsigned char) *(str) \
560 : string_to_char (str, len, 0))
561
562 /* This is like STRING_CHAR but the third arg ACTUAL_LEN is set to the
563 length of the multi-byte form. Just to know the length, use
564 MULTIBYTE_FORM_LENGTH. */
565
566 #define STRING_CHAR_AND_LENGTH(str, len, actual_len) \
567 (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1 \
568 ? ((actual_len) = 1), (unsigned char) *(str) \
569 : string_to_char (str, len, &(actual_len)))
570
571 /* Fetch the "next" character from Lisp string STRING at byte position
572 BYTEIDX, character position CHARIDX. Store it into OUTPUT.
573
574 All the args must be side-effect-free.
575 BYTEIDX and CHARIDX must be lvalues;
576 we increment them past the character fetched. */
577
578 #define FETCH_STRING_CHAR_ADVANCE(OUTPUT, STRING, CHARIDX, BYTEIDX) \
579 if (1) \
580 { \
581 CHARIDX++; \
582 if (STRING_MULTIBYTE (STRING)) \
583 { \
584 const unsigned char *ptr = SDATA (STRING) + BYTEIDX; \
585 int space_left = SBYTES (STRING) - BYTEIDX; \
586 int actual_len; \
587 \
588 OUTPUT = STRING_CHAR_AND_LENGTH (ptr, space_left, actual_len); \
589 BYTEIDX += actual_len; \
590 } \
591 else \
592 OUTPUT = SREF (STRING, BYTEIDX++); \
593 } \
594 else
595
596 /* Like FETCH_STRING_CHAR_ADVANCE but assume STRING is multibyte. */
597
598 #define FETCH_STRING_CHAR_ADVANCE_NO_CHECK(OUTPUT, STRING, CHARIDX, BYTEIDX) \
599 if (1) \
600 { \
601 const unsigned char *fetch_string_char_ptr = SDATA (STRING) + BYTEIDX; \
602 int fetch_string_char_space_left = SBYTES (STRING) - BYTEIDX; \
603 int actual_len; \
604 \
605 OUTPUT \
606 = STRING_CHAR_AND_LENGTH (fetch_string_char_ptr, \
607 fetch_string_char_space_left, actual_len); \
608 \
609 BYTEIDX += actual_len; \
610 CHARIDX++; \
611 } \
612 else
613
614 /* Like FETCH_STRING_CHAR_ADVANCE but fetch character from the current
615 buffer. */
616
617 #define FETCH_CHAR_ADVANCE(OUTPUT, CHARIDX, BYTEIDX) \
618 if (1) \
619 { \
620 CHARIDX++; \
621 if (!NILP (current_buffer->enable_multibyte_characters)) \
622 { \
623 unsigned char *ptr = BYTE_POS_ADDR (BYTEIDX); \
624 int space_left = ((CHARIDX < GPT ? GPT_BYTE : Z_BYTE) - BYTEIDX); \
625 int actual_len; \
626 \
627 OUTPUT= STRING_CHAR_AND_LENGTH (ptr, space_left, actual_len); \
628 BYTEIDX += actual_len; \
629 } \
630 else \
631 { \
632 OUTPUT = *(BYTE_POS_ADDR (BYTEIDX)); \
633 BYTEIDX++; \
634 } \
635 } \
636 else
637
638 /* Return the length of the multi-byte form at string STR of length LEN. */
639
640 #define MULTIBYTE_FORM_LENGTH(str, len) \
641 (BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) == 1 \
642 ? 1 \
643 : multibyte_form_length (str, len))
644
645 /* If P is before LIMIT, advance P to the next character boundary. It
646 assumes that P is already at a character boundary of the sane
647 mulitbyte form whose end address is LIMIT. */
648
649 #define NEXT_CHAR_BOUNDARY(p, limit) \
650 do { \
651 if ((p) < (limit)) \
652 (p) += BYTES_BY_CHAR_HEAD (*(p)); \
653 } while (0)
654
655
656 /* If P is after LIMIT, advance P to the previous character boundary.
657 It assumes that P is already at a character boundary of the sane
658 mulitbyte form whose beginning address is LIMIT. */
659
660 #define PREV_CHAR_BOUNDARY(p, limit) \
661 do { \
662 if ((p) > (limit)) \
663 { \
664 const unsigned char *p0 = (p); \
665 do { \
666 p0--; \
667 } while (p0 >= limit && ! CHAR_HEAD_P (*p0)); \
668 (p) = (BYTES_BY_CHAR_HEAD (*p0) == (p) - p0) ? p0 : (p) - 1; \
669 } \
670 } while (0)
671
672
673 #ifdef emacs
674
675 /* Increase the buffer byte position POS_BYTE of the current buffer to
676 the next character boundary. This macro relies on the fact that
677 *GPT_ADDR and *Z_ADDR are always accessible and the values are
678 '\0'. No range checking of POS. */
679
680 #ifdef BYTE_COMBINING_DEBUG
681
682 #define INC_POS(pos_byte) \
683 do { \
684 unsigned char *p = BYTE_POS_ADDR (pos_byte); \
685 if (BASE_LEADING_CODE_P (*p)) \
686 { \
687 int len, bytes; \
688 len = Z_BYTE - pos_byte; \
689 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
690 pos_byte += bytes; \
691 } \
692 else \
693 pos_byte++; \
694 } while (0)
695
696 #else /* not BYTE_COMBINING_DEBUG */
697
698 #define INC_POS(pos_byte) \
699 do { \
700 unsigned char *p = BYTE_POS_ADDR (pos_byte); \
701 pos_byte += BYTES_BY_CHAR_HEAD (*p); \
702 } while (0)
703
704 #endif /* not BYTE_COMBINING_DEBUG */
705
706 /* Decrease the buffer byte position POS_BYTE of the current buffer to
707 the previous character boundary. No range checking of POS. */
708 #define DEC_POS(pos_byte) \
709 do { \
710 unsigned char *p, *p_min; \
711 \
712 pos_byte--; \
713 if (pos_byte < GPT_BYTE) \
714 p = BEG_ADDR + pos_byte - BEG_BYTE, p_min = BEG_ADDR; \
715 else \
716 p = BEG_ADDR + GAP_SIZE + pos_byte - BEG_BYTE, p_min = GAP_END_ADDR;\
717 if (p > p_min && !CHAR_HEAD_P (*p)) \
718 { \
719 unsigned char *pend = p--; \
720 int len, bytes; \
721 if (p_min < p - MAX_MULTIBYTE_LENGTH) \
722 p_min = p - MAX_MULTIBYTE_LENGTH; \
723 while (p > p_min && !CHAR_HEAD_P (*p)) p--; \
724 len = pend + 1 - p; \
725 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
726 if (bytes == len) \
727 pos_byte -= len - 1; \
728 } \
729 } while (0)
730
731 /* Increment both CHARPOS and BYTEPOS, each in the appropriate way. */
732
733 #define INC_BOTH(charpos, bytepos) \
734 do \
735 { \
736 (charpos)++; \
737 if (NILP (current_buffer->enable_multibyte_characters)) \
738 (bytepos)++; \
739 else \
740 INC_POS ((bytepos)); \
741 } \
742 while (0)
743
744 /* Decrement both CHARPOS and BYTEPOS, each in the appropriate way. */
745
746 #define DEC_BOTH(charpos, bytepos) \
747 do \
748 { \
749 (charpos)--; \
750 if (NILP (current_buffer->enable_multibyte_characters)) \
751 (bytepos)--; \
752 else \
753 DEC_POS ((bytepos)); \
754 } \
755 while (0)
756
757 /* Increase the buffer byte position POS_BYTE of the current buffer to
758 the next character boundary. This macro relies on the fact that
759 *GPT_ADDR and *Z_ADDR are always accessible and the values are
760 '\0'. No range checking of POS_BYTE. */
761
762 #ifdef BYTE_COMBINING_DEBUG
763
764 #define BUF_INC_POS(buf, pos_byte) \
765 do { \
766 unsigned char *p = BUF_BYTE_ADDRESS (buf, pos_byte); \
767 if (BASE_LEADING_CODE_P (*p)) \
768 { \
769 int len, bytes; \
770 len = BUF_Z_BYTE (buf) - pos_byte; \
771 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
772 pos_byte += bytes; \
773 } \
774 else \
775 pos_byte++; \
776 } while (0)
777
778 #else /* not BYTE_COMBINING_DEBUG */
779
780 #define BUF_INC_POS(buf, pos_byte) \
781 do { \
782 unsigned char *p = BUF_BYTE_ADDRESS (buf, pos_byte); \
783 pos_byte += BYTES_BY_CHAR_HEAD (*p); \
784 } while (0)
785
786 #endif /* not BYTE_COMBINING_DEBUG */
787
788 /* Decrease the buffer byte position POS_BYTE of the current buffer to
789 the previous character boundary. No range checking of POS_BYTE. */
790 #define BUF_DEC_POS(buf, pos_byte) \
791 do { \
792 unsigned char *p, *p_min; \
793 pos_byte--; \
794 if (pos_byte < BUF_GPT_BYTE (buf)) \
795 { \
796 p = BUF_BEG_ADDR (buf) + pos_byte - BEG_BYTE; \
797 p_min = BUF_BEG_ADDR (buf); \
798 } \
799 else \
800 { \
801 p = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - BEG_BYTE;\
802 p_min = BUF_GAP_END_ADDR (buf); \
803 } \
804 if (p > p_min && !CHAR_HEAD_P (*p)) \
805 { \
806 unsigned char *pend = p--; \
807 int len, bytes; \
808 if (p_min < p - MAX_MULTIBYTE_LENGTH) \
809 p_min = p - MAX_MULTIBYTE_LENGTH; \
810 while (p > p_min && !CHAR_HEAD_P (*p)) p--; \
811 len = pend + 1 - p; \
812 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
813 if (bytes == len) \
814 pos_byte -= len - 1; \
815 } \
816 } while (0)
817
818 #endif /* emacs */
819
820 /* This is the maximum byte length of multi-byte sequence. */
821 #define MAX_MULTIBYTE_LENGTH 4
822
823 extern void invalid_character P_ ((int));
824
825 extern int translate_char P_ ((Lisp_Object, int, int, int, int));
826 extern int split_string P_ ((const unsigned char *, int, int *,
827 unsigned char *, unsigned char *));
828 extern int char_to_string P_ ((int, unsigned char *));
829 extern int char_to_string_1 P_ ((int, unsigned char *));
830 extern int string_to_char P_ ((const unsigned char *, int, int *));
831 extern int char_printable_p P_ ((int c));
832 extern int multibyte_form_length P_ ((const unsigned char *, int));
833 extern void parse_str_as_multibyte P_ ((const unsigned char *, int, int *,
834 int *));
835 extern int str_as_multibyte P_ ((unsigned char *, int, int, int *));
836 extern int parse_str_to_multibyte P_ ((unsigned char *, int));
837 extern int str_to_multibyte P_ ((unsigned char *, int, int));
838 extern int str_as_unibyte P_ ((unsigned char *, int));
839 extern int get_charset_id P_ ((Lisp_Object));
840 extern int find_charset_in_text P_ ((const unsigned char *, int, int, int *,
841 Lisp_Object));
842 extern int strwidth P_ ((unsigned char *, int));
843 extern int c_string_width P_ ((const unsigned char *, int, int, int *, int *));
844 extern int lisp_string_width P_ ((Lisp_Object, int, int *, int *));
845 extern int char_bytes P_ ((int));
846 extern int char_valid_p P_ ((int, int));
847
848 EXFUN (Funibyte_char_to_multibyte, 1);
849
850 extern Lisp_Object Vtranslation_table_vector;
851
852 /* Return a translation table of id number ID. */
853 #define GET_TRANSLATION_TABLE(id) \
854 (XCDR(XVECTOR(Vtranslation_table_vector)->contents[(id)]))
855
856 /* A char-table for characters which may invoke auto-filling. */
857 extern Lisp_Object Vauto_fill_chars;
858
859 /* Copy LEN bytes from FROM to TO. This macro should be used only
860 when a caller knows that LEN is short and the obvious copy loop is
861 faster than calling bcopy which has some overhead. Copying a
862 multibyte sequence of a multibyte character is the typical case. */
863
864 #define BCOPY_SHORT(from, to, len) \
865 do { \
866 int i = len; \
867 const unsigned char *from_p = from; \
868 unsigned char *to_p = to; \
869 while (i--) *to_p++ = *from_p++; \
870 } while (0)
871
872 #endif /* EMACS_CHARSET_H */
873
874 /* arch-tag: 3b96db55-4961-481d-ac3e-219f46a2b3aa
875 (do not change this comment) */
Emacs repository mirror