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