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