HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
various fixes and gratuitous movements.
[bpt/emacs.git] / src / charset.h
CommitLineData
4ed46869 1/* Header for multilingual 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
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 (except for a special charset for composition
31 characters). Emacs identifies a charset by a unique identification
32 number, whereas ISO identifies a charset by a triplet of DIMENSION,
33 CHARS and FINAL-CHAR. So, hereafter, just saying "charset" means an
34 identification number (integer value).
35
36 The value range of charset is 0x00, 0x80..0xFE. There are four
37 kinds of charset depending on DIMENSION (1 or 2) and CHARS (94 or
38 96). For instance, a charset of DIMENSION2_CHARS94 contains 94x94
39
40
41 Within Emacs Lisp, a charset is treated as a symbol which has a
42 property `charset'. The property value is a vector containing
43 various information about the charset. For readability of C codes,
44 we use the following convention on C variable names:
45 charset_symbol: Emacs Lisp symbol of a charset
46 charset_id: Emacs Lisp integer of an identification number of a charset
47 charset: C integer of an identification number of a charset
48
49 Each charset (except for ASCII) is assigned a base leading-code
50 (range 0x80..0x9D). In addition, a charset of greater than 0xA0
51 (whose base leading-code is 0x9A..0x9D) is assigned an extended
52 leading-code (range 0xA0..0xFE). In this case, each base
53 leading-code specify the allowable range of extended leading-code as
54 shown in the table below. A leading-code is used to represent a
55 character in Emacs' buffer and string.
56
57 We call a charset which has extended leading-code as "private
58 charset" because those are mainly for a charset which is not
59 registered by ISO. On the contrary, we call a charset which does
60 not have extended leading-code as "official charset".
61
62 ---------------------------------------------------------------------------
63 charset dimension base leading-code extended leading-code
64 ---------------------------------------------------------------------------
65 0x00 official dim1 -- none -- -- none --
66 (ASCII)
67 0x01..0x7F --never used--
68 0x80 COMPOSITION same as charset -- none --
69 0x81..0x8F official dim1 same as charset -- none --
70 0x90..0x99 official dim2 same as charset -- none --
71 0x9A..0x9F --never used--
72 0xA0..0xDF private dim1 0x9A same as charset
73 of 1-column width
74 0xE0..0xEF private dim1 0x9B same as charset
75 of 2-column width
76 0xF0..0xF4 private dim2 0x9C same as charset
77 of 1-column width
78 0xF5..0xFE private dim2 0x9D same as charset
79 of 2-column width
80 0xFF --never used--
81 ---------------------------------------------------------------------------
82
83 In the table, "COMPOSITION" means a charset for a composite
84 character which is a character composed from several (up to 16)
85 non-composite characters (components). Although a composite
86 character can contain components of many charsets, a composite
87 character itself belongs to the charset CHARSET-COMPOSITION. See
88 the document "GENERAL NOTE on COMPOSITE CHARACTER" below for more
89 detail.
90
91*/
92
93/* Definition of special leading-codes. */
94/* Base leading-code. */
95/* Special leading-code followed by components of a composite character. */
96#define LEADING_CODE_COMPOSITION 0x80
97/* Leading-code followed by extended leading-code. */
98#define LEADING_CODE_PRIVATE_11 0x9A /* for private DIMENSION1 of 1-column */
99#define LEADING_CODE_PRIVATE_12 0x9B /* for private DIMENSION1 of 2-column */
100#define LEADING_CODE_PRIVATE_21 0x9C /* for private DIMENSION2 of 1-column */
5c6257e5 101#define LEADING_CODE_PRIVATE_22 0x9D /* for private DIMENSION2 of 2-column */
4ed46869
KH		 102
103/* Extended leading-code. */
104/* Start of each extended leading-codes. */
105#define LEADING_CODE_EXT_11 0xA0 /* follows LEADING_CODE_PRIVATE_11 */
106#define LEADING_CODE_EXT_12 0xE0 /* follows LEADING_CODE_PRIVATE_12 */
107#define LEADING_CODE_EXT_21 0xF0 /* follows LEADING_CODE_PRIVATE_21 */
108#define LEADING_CODE_EXT_22 0xF5 /* follows LEADING_CODE_PRIVATE_22 */
109/* Maximum value of extended leading-codes. */
110#define LEADING_CODE_EXT_MAX 0xFE
111
112/* Definition of minimum/maximum charset of each DIMENSION. */
113#define MIN_CHARSET_OFFICIAL_DIMENSION1 0x81
114#define MAX_CHARSET_OFFICIAL_DIMENSION1 0x8F
115#define MIN_CHARSET_OFFICIAL_DIMENSION2 0x90
116#define MAX_CHARSET_OFFICIAL_DIMENSION2 0x99
117#define MIN_CHARSET_PRIVATE_DIMENSION1 LEADING_CODE_EXT_11
118#define MIN_CHARSET_PRIVATE_DIMENSION2 LEADING_CODE_EXT_21
119
03e66c53
KH		 120/* Maximum value of overall charset identification number. */
121#define MAX_CHARSET 0xFE
122
4ed46869
KH		 123/* Definition of special charsets. */
124#define CHARSET_ASCII 0
125#define CHARSET_COMPOSITION 0x80
126
127extern int charset_ascii; /* ASCII */
128extern int charset_composition; /* for a composite character */
129extern int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */
130extern int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */
131extern int charset_jisx0208; /* JISX0208.1983 (Japanese Kanji) */
132extern int charset_katakana_jisx0201; /* JISX0201.Kana (Japanese Katakana) */
133extern int charset_latin_jisx0201; /* JISX0201.Roman (Japanese Roman) */
134extern int charset_big5_1; /* Big5 Level 1 (Chinese Traditional) */
135extern int charset_big5_2; /* Big5 Level 2 (Chinese Traditional) */
136
c399b461
RS		 137/* Check if CH is the head of multi-byte form, i.e.,
138 an ASCII character or a base leading-code. */
139#define CHAR_HEAD_P(ch) ((unsigned char) (ch) < 0xA0)
4ed46869
KH		 140
141/*** GENERAL NOTE on CHARACTER REPRESENTATION ***
142
143 At first, the term "character" or "char" is used for a multilingual
144 character (of course, including ASCII character), not for a byte in
145 computer memory. We use the term "code" or "byte" for the latter
146 case.
147
148 A character is identified by charset and one or two POSITION-CODEs.
149 POSITION-CODE is the position of the character in the charset. A
150 character of DIMENSION1 charset has one POSITION-CODE: POSITION-CODE-1.
151 A character of DIMENSION2 charset has two POSITION-CODE:
152 POSITION-CODE-1 and POSITION-CODE-2. The code range of
153 POSITION-CODE is 0x20..0x7F.
154
155 Emacs has two kinds of representation of a character: multi-byte
156 form (for buffer and string) and single-word form (for character
157 object in Emacs Lisp). The latter is called "character code" here
94487c4e 158 after. Both representations encode the information of charset and
4ed46869
KH		 159 POSITION-CODE but in a different way (for instance, MSB of
160 POSITION-CODE is set in multi-byte form).
161
162 For details of multi-byte form, see the section "2. Emacs internal
163 format handlers" of `coding.c'.
164
165 Emacs uses 19 bits for a character code. The bits are divided into
166 3 fields: FIELD1(5bits):FIELD2(7bits):FIELD3(7bits).
167
168 A character code of DIMENSION1 character uses FIELD2 to hold charset
169 and FIELD3 to hold POSITION-CODE-1. A character code of DIMENSION2
170 character uses FIELD1 to hold charset, FIELD2 and FIELD3 to hold
171 POSITION-CODE-1 and POSITION-CODE-2 respectively.
172
173 More precisely...
174
175 FIELD2 of DIMENSION1 character (except for ASCII) is "charset - 0x70".
176 This is to make all character codes except for ASCII greater than
177 256 (ASCII's FIELD2 is 0). So, the range of FIELD2 of DIMENSION1
178 character is 0 or 0x11..0x7F.
179
180 FIELD1 of DIMENSION2 character is "charset - 0x8F" for official
181 charset and "charset - 0xE0" for private charset. So, the range of
182 FIELD1 of DIMENSION2 character is 0x01..0x1E.
183
184 -----------------------------------------------------------------------
185 charset FIELD1 (5-bit) FIELD2 (7-bit) FIELD3 (7-bit)
186 -----------------------------------------------------------------------
187 ASCII 0 0 POSITION-CODE-1
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
197/*** GENERAL NOTE on COMPOSITE CHARACTER ***
198
199 A composite character is a character composed from several (up to
94487c4e 200 16) non-composite characters (components). Although each component
4ed46869
KH		 201 can belong to any charset, a composite character itself belongs to
202 the charset `charset-composition' and is assigned a special
203 leading-code `LEADING_CODE_COMPOSITION' for multi-byte form. See
204 the document "2. Emacs internal format handlers" in `coding.c' for
205 more detail about multi-byte form.
206
207 A character code of composite character has special format. In the
208 above document, FIELD1 of a composite character is 0x1F. Each
209 composite character is assigned a sequential number CMPCHAR-ID.
210 FIELD2 and FIELD3 are combined to make 14bits field for holding
211 CMPCHAR-ID, which means that Emacs can handle at most 2^14 (= 16384)
212 composite characters at once.
213
214 -----------------------------------------------------------------------
215 charset FIELD1 (5-bit) FIELD2&3 (14-bit)
216 -----------------------------------------------------------------------
217 CHARSET-COMPOSITION 0x1F CMPCHAR-ID
218 -----------------------------------------------------------------------
219
220 Emacs assigns CMPCHAR-ID to a composite character only when it
221 requires the character code of the composite character (e.g. while
222 displaying the composite character).
223
224*/
225
226/* Masks of each field of character code. */
227#define CHAR_FIELD1_MASK (0x1F << 14)
228#define CHAR_FIELD2_MASK (0x7F << 7)
229#define CHAR_FIELD3_MASK 0x7F
230
231/* Macros to access each field of character C. */
232#define CHAR_FIELD1(c) (((c) & CHAR_FIELD1_MASK) >> 14)
233#define CHAR_FIELD2(c) (((c) & CHAR_FIELD2_MASK) >> 7)
234#define CHAR_FIELD3(c) ((c) & CHAR_FIELD3_MASK)
235
236/* Minimum character code of character of each DIMENSION. */
237#define MIN_CHAR_OFFICIAL_DIMENSION1 \
238 ((MIN_CHARSET_OFFICIAL_DIMENSION1 - 0x70) << 7)
239#define MIN_CHAR_PRIVATE_DIMENSION1 \
240 ((MIN_CHARSET_PRIVATE_DIMENSION1 - 0x70) << 7)
241#define MIN_CHAR_OFFICIAL_DIMENSION2 \
242 ((MIN_CHARSET_OFFICIAL_DIMENSION2 - 0x8F) << 14)
243#define MIN_CHAR_PRIVATE_DIMENSION2 \
244 ((MIN_CHARSET_PRIVATE_DIMENSION2 - 0xE0) << 14)
245#define MIN_CHAR_COMPOSITION \
246 (0x1F << 14)
4c0fbc08
KH		 247#define MAX_CHAR_COMPOSITION (GLYPH_MASK_CHAR - 1)
248
249/* A generic character for composition characters. */
250#define GENERIC_COMPOSITION_CHAR (GLYPH_MASK_CHAR)
4ed46869
KH		 251
252/* 1 if C is an ASCII character, else 0. */
72b718d7 253#define SINGLE_BYTE_CHAR_P(c) ((c) >= 0 && (c) < 0x100)
4ed46869
KH		 254/* 1 if C is an composite character, else 0. */
255#define COMPOSITE_CHAR_P(c) ((c) >= MIN_CHAR_COMPOSITION)
256
7614f779
KH		 257/* 1 if BYTE is a character in itself, in multibyte mode. */
258#define ASCII_BYTE_P(byte) ((byte) < 0x80)
259
4ed46869
KH		 260/* A char-table containing information of each character set.
261
262 Unlike ordinary char-tables, this doesn't contain any nested table.
263 Only the top level elements are used. Each element is a vector of
264 the following information:
265 CHARSET-ID, BYTES, DIMENSION, CHARS, WIDTH, DIRECTION,
266 LEADING-CODE-BASE, LEADING-CODE-EXT,
267 ISO-FINAL-CHAR, ISO-GRAPHIC-PLANE,
268 REVERSE-CHARSET, SHORT-NAME, LONG-NAME, DESCRIPTION,
269 PLIST.
270
271 CHARSET-ID (integer) is the identification number of the charset.
272
0c01c27e 273 BYTES (integer) is the length of multi-byte form of a character in
4ed46869
KH		 274 the charset: one of 1, 2, 3, and 4.
275
276 DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
277
278 CHARS (integer) is the number of characters in a dimension: 94 or 96.
279
280 WIDTH (integer) is the number of columns a character in the charset
281 occupies on the screen: one of 0, 1, and 2.
282
283 DIRECTION (integer) is the rendering direction of characters in the
28d0c844
KH		 284 charset when rendering. If 0, render from left to right, else
285 render from right to left.
4ed46869
KH		 286
287 LEADING-CODE-BASE (integer) is the base leading-code for the
288 charset.
289
290 LEADING-CODE-EXT (integer) is the extended leading-code for the
291 charset. All charsets of less than 0xA0 has the value 0.
292
293 ISO-FINAL-CHAR (character) is the final character of the
294 corresponding ISO 2022 charset.
295
296 ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
297 while encoding to variants of ISO 2022 coding system, one of the
298 following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).
299
300 REVERSE-CHARSET (integer) is the charset which differs only in
301 LEFT-TO-RIGHT value from the charset. If there's no such a
302 charset, the value is -1.
303
304 SHORT-NAME (string) is the short name to refer to the charset.
305
306 LONG-NAME (string) is the long name to refer to the charset.
307
308 DESCRIPTION (string) is the description string of the charset.
309
310 PLIST (property list) may contain any type of information a user
311 want to put and get by functions `put-charset-property' and
312 `get-charset-property' respectively. */
313extern Lisp_Object Vcharset_table;
314
315/* Macros to access various information of CHARSET in Vcharset_table.
316 We provide these macros for efficiency. No range check of CHARSET. */
317
318/* Return entry of CHARSET (lisp integer) in Vcharset_table. */
d6f92c04
KH		 319#define CHARSET_TABLE_ENTRY(charset) \
320 XCHAR_TABLE (Vcharset_table)->contents[((charset) == CHARSET_ASCII \
321 ? 0 : (charset) + 128)]
4ed46869
KH		 322
323/* Return information INFO-IDX of CHARSET. */
324#define CHARSET_TABLE_INFO(charset, info_idx) \
325 XVECTOR (CHARSET_TABLE_ENTRY (charset))->contents[info_idx]
326
327#define CHARSET_ID_IDX (0)
328#define CHARSET_BYTES_IDX (1)
329#define CHARSET_DIMENSION_IDX (2)
330#define CHARSET_CHARS_IDX (3)
331#define CHARSET_WIDTH_IDX (4)
332#define CHARSET_DIRECTION_IDX (5)
333#define CHARSET_LEADING_CODE_BASE_IDX (6)
334#define CHARSET_LEADING_CODE_EXT_IDX (7)
335#define CHARSET_ISO_FINAL_CHAR_IDX (8)
336#define CHARSET_ISO_GRAPHIC_PLANE_IDX (9)
337#define CHARSET_REVERSE_CHARSET_IDX (10)
338#define CHARSET_SHORT_NAME_IDX (11)
339#define CHARSET_LONG_NAME_IDX (12)
340#define CHARSET_DESCRIPTION_IDX (13)
341#define CHARSET_PLIST_IDX (14)
342/* Size of a vector of each entry of Vcharset_table. */
343#define CHARSET_MAX_IDX (15)
344
345/* And several more macros to be used frequently. */
346#define CHARSET_BYTES(charset) \
347 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX))
348#define CHARSET_DIMENSION(charset) \
349 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX))
350#define CHARSET_CHARS(charset) \
351 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_CHARS_IDX))
352#define CHARSET_WIDTH(charset) \
353 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_WIDTH_IDX))
354#define CHARSET_DIRECTION(charset) \
355 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX))
356#define CHARSET_LEADING_CODE_BASE(charset) \
357 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_BASE_IDX))
358#define CHARSET_LEADING_CODE_EXT(charset) \
359 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_EXT_IDX))
360#define CHARSET_ISO_FINAL_CHAR(charset) \
361 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_FINAL_CHAR_IDX))
362#define CHARSET_ISO_GRAPHIC_PLANE(charset) \
363 XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_GRAPHIC_PLANE_IDX))
364#define CHARSET_REVERSE_CHARSET(charset) \
365 XINT (CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX))
366
367/* Macros to specify direction of a charset. */
368#define CHARSET_DIRECTION_LEFT_TO_RIGHT 0
369#define CHARSET_DIRECTION_RIGHT_TO_LEFT 1
370
371/* A vector of charset symbol indexed by charset-id. This is used
372 only for returning charset symbol from C functions. */
373extern Lisp_Object Vcharset_symbol_table;
374
375/* Return symbol of CHARSET. */
376#define CHARSET_SYMBOL(charset) \
377 XVECTOR (Vcharset_symbol_table)->contents[charset]
378
384107f2 379/* 1 if CHARSET is in valid value range, else 0. */
4ed46869
KH		 380#define CHARSET_VALID_P(charset) \
381 ((charset) == 0 \
382 || ((charset) >= 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
03e66c53 383 || ((charset) >= MIN_CHARSET_PRIVATE_DIMENSION1 && (charset) <= MAX_CHARSET))
4ed46869 384
384107f2 385/* 1 if CHARSET is already defined (and not CHARSET_COMPOSITION), else 0. */
4ed46869 386#define CHARSET_DEFINED_P(charset) \
03e66c53 387 (((charset) >= 0) && ((charset) <= MAX_CHARSET) \
4ed46869
KH		 388 && !NILP (CHARSET_TABLE_ENTRY (charset)))
389
390/* Since the information CHARSET-BYTES and CHARSET-WIDTH of
384107f2 391 Vcharset_table can be retrieved only the first byte of
4ed46869
KH		 392 multi-byte form (an ASCII code or a base leading-code), we provide
393 here tables to be used by macros BYTES_BY_CHAR_HEAD and
394 WIDTH_BY_CHAR_HEAD for faster information retrieval. */
395extern int bytes_by_char_head[256];
396extern int width_by_char_head[256];
397
398#define BYTES_BY_CHAR_HEAD(char_head) bytes_by_char_head[char_head]
399#define WIDTH_BY_CHAR_HEAD(char_head) width_by_char_head[char_head]
400
401/* Charset of the character C. */
402#define CHAR_CHARSET(c) \
403 (SINGLE_BYTE_CHAR_P (c) \
404 ? CHARSET_ASCII \
405 : ((c) < MIN_CHAR_OFFICIAL_DIMENSION2 \
406 ? CHAR_FIELD2 (c) + 0x70 \
407 : ((c) < MIN_CHAR_PRIVATE_DIMENSION2 \
408 ? CHAR_FIELD1 (c) + 0x8F \
409 : ((c) < MIN_CHAR_COMPOSITION \
410 ? CHAR_FIELD1 (c) + 0xE0 \
c1f6608b
KH		 411 : ((c) <= MAX_CHAR_COMPOSITION \
412 ? CHARSET_COMPOSITION \
413 : CHARSET_ASCII)))))
4ed46869
KH		 414
415/* Return charset at the place pointed by P. */
416#define CHARSET_AT(p) \
417 (*(p) < 0x80 \
418 ? CHARSET_ASCII \
419 : (*(p) == LEADING_CODE_COMPOSITION \
420 ? CHARSET_COMPOSITION \
421 : (*(p) < LEADING_CODE_PRIVATE_11 \
422 ? (int)*(p) \
423 : (*(p) <= LEADING_CODE_PRIVATE_22 \
424 ? (int)*((p) + 1) \
425 : -1))))
426
427/* Same as `CHARSET_AT ()' but perhaps runs faster because of an
428 additional argument C which is the code (byte) at P. */
429#define FIRST_CHARSET_AT(p, c) \
430 ((c) < 0x80 \
431 ? CHARSET_ASCII \
432 : ((c) == LEADING_CODE_COMPOSITION \
433 ? CHARSET_COMPOSITION \
434 : ((c) < LEADING_CODE_PRIVATE_11 \
435 ? (int)(c) \
436 : ((c) <= LEADING_CODE_PRIVATE_22 \
437 ? (int)*((p) + 1) \
438 : -1))))
439
440/* Check if two characters C1 and C2 belong to the same charset.
441 Always return 0 for composite characters. */
442#define SAME_CHARSET_P(c1, c2) \
443 (c1 < MIN_CHAR_COMPOSITION \
444 && (SINGLE_BYTE_CHAR_P (c1) \
445 ? SINGLE_BYTE_CHAR_P (c2) \
446 : (c1 < MIN_CHAR_OFFICIAL_DIMENSION2 \
447 ? (c1 & CHAR_FIELD2_MASK) == (c2 & CHAR_FIELD2_MASK) \
448 : (c1 & CHAR_FIELD1_MASK) == (c2 & CHAR_FIELD1_MASK))))
449
450/* Return a non-ASCII character of which charset is CHARSET and
451 position-codes are C1 and C2. DIMENSION1 character ignores C2. */
d6127b83
KH		 452#define MAKE_NON_ASCII_CHAR(charset, c1, c2) \
453 ((charset) == CHARSET_COMPOSITION \
384107f2
KH		 454 ? ((c2) < 0 \
455 ? (((charset) - 0x70) << 7) + (c1) \
456 : MAKE_COMPOSITE_CHAR (((c1) << 7) + (c2))) \
d6127b83 457 : (! CHARSET_DEFINED_P (charset) || CHARSET_DIMENSION (charset) == 1 \
384107f2 458 ? (((charset) - 0x70) << 7) | ((c1) <= 0 ? 0 : (c1)) \
d6127b83 459 : ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2 \
384107f2
KH		 460 ? ((((charset) - 0x8F) << 14) \
461 | ((c1) <= 0 ? 0 : ((c1) << 7)) | ((c2) <= 0 ? 0 : (c2))) \
462 : ((((charset) - 0xE0) << 14) \
463 | ((c1) <= 0 ? 0 : ((c1) << 7)) | ((c2) <= 0 ? 0 : (c2))))))
4ed46869
KH		 464
465/* Return a composite character of which CMPCHAR-ID is ID. */
466#define MAKE_COMPOSITE_CHAR(id) (MIN_CHAR_COMPOSITION + (id))
467
468/* Return CMPCHAR-ID of a composite character C. */
469#define COMPOSITE_CHAR_ID(c) ((c) - MIN_CHAR_COMPOSITION)
470
471/* Return a character of which charset is CHARSET and position-codes
472 are C1 and C2. DIMENSION1 character ignores C2. */
384107f2
KH		 473#define MAKE_CHAR(charset, c1, c2) \
474 ((charset) == CHARSET_ASCII \
475 ? (c1) \
476 : MAKE_NON_ASCII_CHAR ((charset), (c1), (c2)))
4ed46869 477
15979e9e
KH		 478/* If GENERICP is nonzero, return nonzero iff C is a valid normal or
479 generic character. If GENERICP is zero, return nonzero iff C is a
480 valid normal character. */
481#define CHAR_VALID_P(c, genericp) \
482 ((c) >= 0 \
483 && (SINGLE_BYTE_CHAR_P (c) || char_valid_p (c, genericp)))
c6112b99 484
d74d0ca5 485/* This default value is used when nonascii-translation-table or
54e15bb9
KH		 486 nonascii-insert-offset fail to convert unibyte character to a valid
487 multibyte character. This makes a Latin-1 character. */
488
489#define DEFAULT_NONASCII_INSERT_OFFSET 0x800
490
9dd2aa1a
KH		 491/* Parse composite character string STR of length LENGTH (>= 2) and
492 set BYTES to the length of actual multibyte sequence.
493
494 It is assumed that *STR is LEADING_CODE_COMPOSITION and the
495 following (LENGTH - 1) bytes satisfy !CHAR_HEAD_P.
496
497 Actually, the whole multibyte sequence starting with
498 LEADING_CODE_COMPOSITION is treated as a single multibyte
499 character. So, here, we just set BYTES to LENGTH.
500
501 This macro should be called only from PARSE_MULTIBYTE_SEQ. */
384107f2
KH		 502
503#define PARSE_COMPOSITE_SEQ(str, length, bytes) \
504 do { \
505 (bytes) = (length); \
506 } while (0)
507
508
9dd2aa1a
KH		 509/* Parse non-composite multibyte character string STR of length
510 LENGTH (>= 2) and set BYTES to the length of actual multibyte
511 sequence.
512
513 It is assumed that *STR is one of base leading codes (excluding
514 LEADING_CODE_COMPOSITION) and the following (LENGTH - 1) bytes
515 satisfy !CHAR_HEAD_P.
516
517 This macro should be called only from PARSE_MULTIBYTE_SEQ. */
384107f2
KH		 518
519#define PARSE_CHARACTER_SEQ(str, length, bytes) \
520 do { \
521 (bytes) = BYTES_BY_CHAR_HEAD ((str)[0]); \
522 if ((bytes) > (length)) \
523 (bytes) = (length); \
524 } while (0)
525
526/* Parse string STR of length LENGTH and check if a multibyte
527 characters is at STR. If so, set BYTES for that character, else
528 set BYTES to 1. */
529
530#define PARSE_MULTIBYTE_SEQ(str, length, bytes) \
531 do { \
532 int i = 1; \
9dd2aa1a
KH		 533 if (ASCII_BYTE_P (*str)) \
534 bytes = 1; \
384107f2 535 else \
9dd2aa1a
KH		 536 { \
537 while (i < (length) && ! CHAR_HEAD_P ((str)[i])) i++; \
538 if (i == 1) \
539 (bytes) = 1; \
540 else if ((str)[0] == LEADING_CODE_COMPOSITION) \
541 PARSE_COMPOSITE_SEQ (str, i, bytes); \
542 else \
543 PARSE_CHARACTER_SEQ (str, i, bytes); \
544 } \
384107f2 545 } while (0)
54e15bb9 546
feb453fa
RS		 547/* The charset of non-ASCII character C is stored in CHARSET, and the
548 position-codes of C are stored in C1 and C2.
549 We store -1 in C2 if the character is just 2 bytes.
550
551 Do not use this macro for an ASCII character. */
552
4ed46869 553#define SPLIT_NON_ASCII_CHAR(c, charset, c1, c2) \
dfd57aa7
KH		 554 ((c) & CHAR_FIELD1_MASK \
555 ? (charset = ((c) < MIN_CHAR_COMPOSITION \
4ed46869
KH		 556 ? (CHAR_FIELD1 (c) \
557 + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)) \
558 : CHARSET_COMPOSITION), \
559 c1 = CHAR_FIELD2 (c), \
dfd57aa7
KH		 560 c2 = CHAR_FIELD3 (c)) \
561 : (charset = CHAR_FIELD2 (c) + 0x70, \
562 c1 = CHAR_FIELD3 (c), \
563 c2 = -1))
4ed46869 564
feb453fa
RS		 565/* The charset of character C is stored in CHARSET, and the
566 position-codes of C are stored in C1 and C2.
9dd2aa1a 567 We store -1 in C2 if the dimension of the charset is 1. */
feb453fa 568
4ed46869
KH		 569#define SPLIT_CHAR(c, charset, c1, c2) \
570 (SINGLE_BYTE_CHAR_P (c) \
d6f92c04 571 ? charset = CHARSET_ASCII, c1 = (c), c2 = -1 \
4ed46869
KH		 572 : SPLIT_NON_ASCII_CHAR (c, charset, c1, c2))
573
384107f2
KH		 574/* Return 1 iff character C has valid printable glyph. */
575#define CHAR_PRINTABLE_P(c) \
576 (SINGLE_BYTE_CHAR_P (c) \
577 || ((c) >= MIN_CHAR_COMPOSITION \
578 ? (c) < MAX_CHAR \
579 : char_printable_p (c)))
580
feb453fa
RS		 581/* The charset of the character at STR is stored in CHARSET, and the
582 position-codes are stored in C1 and C2.
583 We store -1 in C2 if the character is just 2 bytes.
584
4ed46869
KH		 585 If the character is a composite character, the upper 7-bit and
586 lower 7-bit of CMPCHAR-ID are set in C1 and C2 respectively. No
587 range checking. */
feb453fa 588
4ed46869
KH		 589#define SPLIT_STRING(str, len, charset, c1, c2) \
590 ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2 \
591 || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len \
f6469851 592 || split_non_ascii_string (str, len, &charset, &c1, &c2) < 0) \
4ed46869
KH		 593 ? c1 = *(str), charset = CHARSET_ASCII \
594 : charset)
595
4ed46869
KH		 596/* Mapping table from ISO2022's charset (specified by DIMENSION,
597 CHARS, and FINAL_CHAR) to Emacs' charset. Should be accessed by
598 macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR). */
599extern int iso_charset_table[2][2][128];
600
601#define ISO_CHARSET_TABLE(dimension, chars, final_char) \
602 iso_charset_table[XINT (dimension) - 1][XINT (chars) > 94][XINT (final_char)]
603
604#define BASE_LEADING_CODE_P(c) (BYTES_BY_CHAR_HEAD ((unsigned char) (c)) > 1)
605
3124bc0e 606/* Return how many bytes C will occupy in a multibyte buffer. */
43229ac3
KH		 607#define CHAR_BYTES(c) \
608 ((SINGLE_BYTE_CHAR_P ((c)) || ((c) & ~GLYPH_MASK_CHAR)) ? 1 : char_bytes (c))
3124bc0e 609
4ed46869
KH		 610/* The following two macros CHAR_STRING and STRING_CHAR are the main
611 entry points to convert between Emacs two types of character
612 representations: multi-byte form and single-word form (character
613 code). */
614
615/* Set STR a pointer to the multi-byte form of the character C. If C
616 is not a composite character, the multi-byte form is set in WORKBUF
617 and STR points WORKBUF. The caller should allocate at least 4-byte
618 area at WORKBUF in advance. Returns the length of the multi-byte
c6112b99 619 form. If C is an invalid character code, signal an error. */
4ed46869
KH		 620
621#define CHAR_STRING(c, workbuf, str) \
622 (SINGLE_BYTE_CHAR_P (c) \
623 ? *(str = workbuf) = (unsigned char)(c), 1 \
54c182d1 624 : non_ascii_char_to_string (c, workbuf, (unsigned char **)&str))
4ed46869
KH		 625
626/* Return a character code of the character of which multi-byte form
627 is at STR and the length is LEN. If STR doesn't contain valid
628 multi-byte form, only the first byte in STR is returned. */
629
dfd57aa7
KH		 630#define STRING_CHAR(str, len) \
631 (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1 \
632 ? (unsigned char) *(str) \
384107f2 633 : string_to_non_ascii_char (str, len, 0))
4ed46869 634
384107f2
KH		 635/* This is like STRING_CHAR but the third arg ACTUAL_LEN is set to the
636 length of the multi-byte form. Just to know the length, use
4ed46869
KH		 637 MULTIBYTE_FORM_LENGTH. */
638
384107f2
KH		 639#define STRING_CHAR_AND_LENGTH(str, len, actual_len) \
640 (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1 \
641 ? ((actual_len) = 1), (unsigned char) *(str) \
642 : string_to_non_ascii_char (str, len, &(actual_len)))
d74d0ca5 643
520afed1
RS		 644/* Fetch the "next" multibyte character from Lisp string STRING
645 at byte position BYTEIDX, character position CHARIDX.
646 Store it into OUTPUT.
647
648 All the args must be side-effect-free.
649 BYTEIDX and CHARIDX must be lvalues;
650 we increment them past the character fetched. */
651
652#define FETCH_STRING_CHAR_ADVANCE(OUTPUT, STRING, CHARIDX, BYTEIDX) \
653if (1) \
654 { \
655 unsigned char *fetch_string_char_ptr = &XSTRING (STRING)->data[BYTEIDX]; \
656 int fetch_string_char_space_left = XSTRING (STRING)->size_byte - BYTEIDX; \
657 int actual_len; \
658 \
659 OUTPUT \
660 = STRING_CHAR_AND_LENGTH (fetch_string_char_ptr, \
661 fetch_string_char_space_left, actual_len); \
662 \
663 BYTEIDX += actual_len; \
664 CHARIDX++; \
665 } \
666else
667
4ed46869
KH		 668/* Return the length of the multi-byte form at string STR of length LEN. */
669
d121936f
KH		 670#define MULTIBYTE_FORM_LENGTH(str, len) \
671 (BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) == 1 \
672 ? 1 \
4ed46869
KH		 673 : multibyte_form_length (str, len))
674
675/* Set C a (possibly multibyte) character at P. P points into a
676 string which is the virtual concatenation of STR1 (which ends at
677 END1) or STR2 (which ends at END2). */
678
679#define GET_CHAR_AFTER_2(c, p, str1, end1, str2, end2) \
680 do { \
681 const char *dtemp = (p) == (end1) ? (str2) : (p); \
682 const char *dlimit = ((p) >= (str1) && (p) < (end1)) ? (end1) : (end2); \
683 c = STRING_CHAR (dtemp, dlimit - dtemp); \
684 } while (0)
685
686/* Set C a (possibly multibyte) character before P. P points into a
687 string which is the virtual concatenation of STR1 (which ends at
688 END1) or STR2 (which ends at END2). */
689
690#define GET_CHAR_BEFORE_2(c, p, str1, end1, str2, end2) \
691 do { \
692 const char *dtemp = (p); \
693 const char *dlimit = ((p) > (str2) && (p) <= (end2)) ? (str2) : (str1); \
694 while (dtemp-- > dlimit && (unsigned char) *dtemp >= 0xA0); \
695 c = STRING_CHAR (dtemp, p - dtemp); \
696 } while (0)
697
698#ifdef emacs
699
384107f2
KH		 700/* Increase the buffer byte position POS_BYTE of the current buffer to
701 the next character boundary. This macro relies on the fact that
702 *GPT_ADDR and *Z_ADDR are always accessible and the values are
703 '\0'. No range checking of POS. */
704#define INC_POS(pos_byte) \
705 do { \
706 unsigned char *p = BYTE_POS_ADDR (pos_byte); \
707 if (BASE_LEADING_CODE_P (*p)) \
708 { \
709 int len, bytes; \
710 len = Z_BYTE - pos_byte; \
711 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
712 pos_byte += bytes; \
713 } \
714 else \
715 pos_byte++; \
4ed46869
KH		 716 } while (0)
717
384107f2
KH		 718/* Decrease the buffer byte position POS_BYTE of the current buffer to
719 the previous character boundary. No range checking of POS. */
720#define DEC_POS(pos_byte) \
721 do { \
722 unsigned char *p, *p_min; \
723 \
724 pos_byte--; \
725 if (pos_byte < GPT_BYTE) \
726 p = BEG_ADDR + pos_byte - 1, p_min = BEG_ADDR; \
727 else \
728 p = BEG_ADDR + GAP_SIZE + pos_byte - 1, p_min = GAP_END_ADDR; \
729 if (p > p_min && !CHAR_HEAD_P (*p)) \
730 { \
731 unsigned char *pend = p--; \
732 int len, bytes; \
733 while (p > p_min && !CHAR_HEAD_P (*p)) p--; \
734 len = pend + 1 - p; \
735 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
736 if (bytes == len) \
737 pos_byte -= len - 1; \
738 } \
c399b461
RS		 739 } while (0)
740
741/* Increment both CHARPOS and BYTEPOS, each in the appropriate way. */
742
d619ee06
RS		 743#define INC_BOTH(charpos, bytepos) \
744do \
745 { \
746 (charpos)++; \
747 if (NILP (current_buffer->enable_multibyte_characters)) \
748 (bytepos)++; \
749 else \
750 INC_POS ((bytepos)); \
751 } \
c399b461
RS		 752while (0)
753
754/* Decrement both CHARPOS and BYTEPOS, each in the appropriate way. */
755
d619ee06
RS		 756#define DEC_BOTH(charpos, bytepos) \
757do \
758 { \
759 (charpos)--; \
760 if (NILP (current_buffer->enable_multibyte_characters)) \
761 (bytepos)--; \
762 else \
763 DEC_POS ((bytepos)); \
764 } \
c399b461
RS		 765while (0)
766
384107f2
KH		 767/* Increase the buffer byte position POS_BYTE of the current buffer to
768 the next character boundary. This macro relies on the fact that
769 *GPT_ADDR and *Z_ADDR are always accessible and the values are
770 '\0'. No range checking of POS_BYTE. */
771#define BUF_INC_POS(buf, pos_byte) \
772 do { \
773 unsigned char *p = BUF_BYTE_ADDRESS (buf, pos_byte); \
774 if (BASE_LEADING_CODE_P (*p)) \
bb5999ae 775 { \
384107f2
KH		 776 int len, bytes; \
777 len = BUF_Z_BYTE (buf) - pos_byte; \
778 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
779 pos_byte += bytes; \
bb5999ae 780 } \
384107f2
KH		 781 else \
782 pos_byte++; \
783 } while (0)
784
785/* Decrease the buffer byte position POS_BYTE of the current buffer to
786 the previous character boundary. No range checking of POS_BYTE. */
787#define BUF_DEC_POS(buf, pos_byte) \
788 do { \
789 unsigned char *p, *p_min; \
790 pos_byte--; \
791 if (pos_byte < BUF_GPT_BYTE (buf)) \
792 { \
793 p = BUF_BEG_ADDR (buf) + pos_byte - 1; \
794 p_min = BUF_BEG_ADDR (buf); \
795 } \
796 else \
797 { \
798 p = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - 1; \
799 p_min = BUF_GAP_END_ADDR (buf); \
800 } \
801 if (p > p_min && !CHAR_HEAD_P (*p)) \
802 { \
803 unsigned char *pend = p--; \
804 int len, bytes; \
805 while (p > p_min && !CHAR_HEAD_P (*p)) p--; \
806 len = pend + 1 - p; \
807 PARSE_MULTIBYTE_SEQ (p, len, bytes); \
808 if (bytes == len) \
809 pos_byte -= len - 1; \
810 } \
4ed46869
KH		 811 } while (0)
812
813#endif /* emacs */
814
815/* Maximum counts of components in one composite character. */
816#define MAX_COMPONENT_COUNT 16
817
818/* Structure to hold information of a composite character. */
819struct cmpchar_info {
820 /* Byte length of the composite character. */
821 int len;
822
823 /* Multi-byte form of the composite character. */
824 unsigned char *data;
825
826 /* Length of glyph codes. */
827 int glyph_len;
828
829 /* Width of the overall glyph of the composite character. */
830 int width;
831
832 /* Pointer to an array of glyph codes of the composite character.
833 This actually contains only character code, no face. */
834 GLYPH *glyph;
835
836 /* Pointer to an array of composition rules. The value has the form:
837 (0xA0 + ((GLOBAL-REF-POINT << 2) | NEW-REF-POINT))
838 where each XXX-REF-POINT is 0..8. */
839 unsigned char *cmp_rule;
840
841 /* Pointer to an array of x-axis offset of left edge of glyphs
842 relative to the left of of glyph[0] except for the first element
843 which is the absolute offset from the left edge of overall glyph.
844 The actual pixel offset should be calculated by multiplying each
845 frame's one column width by this value:
846 (i.e. FONT_WIDTH (f->output_data.x->font) * col_offset[N]). */
847 float *col_offset;
848
849 /* Work slot used by `dumpglyphs' (xterm.c). */
850 int face_work;
851};
852
853/* Table of pointers to the structure `cmpchar_info' indexed by
854 CMPCHAR-ID. */
855extern struct cmpchar_info **cmpchar_table;
856/* Number of the current composite characters. */
857extern int n_cmpchars;
858
859/* This is the maximum length of multi-byte form. */
860#define MAX_LENGTH_OF_MULTI_BYTE_FORM (MAX_COMPONENT_COUNT * 6)
861
03e66c53
KH		 862/* Maximum character code currently used. */
863#define MAX_CHAR (MIN_CHAR_COMPOSITION + n_cmpchars)
4ed46869 864
bb5999ae
KH		 865extern void invalid_character P_ ((int));
866
62c6686f 867extern int translate_char P_ ((Lisp_Object, int, int, int, int));
8867de67 868extern int split_non_ascii_string P_ ((const unsigned char *, int, int *,
c04809fb 869 unsigned char *, unsigned char *));
384107f2 870extern int string_to_non_ascii_char P_ ((const unsigned char *, int, int *));
c04809fb 871extern int non_ascii_char_to_string P_ ((int, unsigned char *, unsigned char **));
384107f2 872extern int char_printable_p P_ ((int c));
8867de67
KH		 873extern int multibyte_form_length P_ ((const unsigned char *, int));
874extern int str_cmpchar_id P_ ((const unsigned char *, int));
c04809fb 875extern int get_charset_id P_ ((Lisp_Object));
cf36cf3f 876extern int cmpchar_component P_ ((int, int, int));
3f639f85 877extern int find_charset_in_str P_ ((unsigned char *, int, int *,
8c5b01cc 878 Lisp_Object, int, int));
c04809fb 879extern int strwidth P_ ((unsigned char *, int));
3124bc0e 880extern int char_bytes P_ ((int));
c2d1e590 881extern int char_valid_p P_ ((int, int));
2db95897 882
d74d0ca5 883extern Lisp_Object Vtranslation_table_vector;
62c6686f 884
d74d0ca5 885/* Return a translation table of id number ID. */
62c6686f 886#define GET_TRANSLATION_TABLE(id) \
e35efe89 887 (XCDR(XVECTOR(Vtranslation_table_vector)->contents[(id)]))
c1f6608b 888
69535a4b
KH		 889/* A char-table for characters which may invoke auto-filling. */
890extern Lisp_Object Vauto_fill_chars;
891
c1f6608b
KH		 892/* Copy LEN bytes from FROM to TO. This macro should be used only
893 when a caller knows that LEN is short and the obvious copy loop is
894 faster than calling bcopy which has some overhead. */
895
896#define BCOPY_SHORT(from, to, len) \
897 do { \
898 int i = len; \
ae53401a 899 unsigned char *from_p = from, *to_p = to; \
c1f6608b
KH		 900 while (i--) *from_p++ = *to_p++; \
901 } while (0)
902
3dc9587a
GM		 903/* Length of C in bytes. */
904
905#define CHAR_LEN(C) \
906 (CHAR_CHARSET ((C)) == CHARSET_COMPOSITION \
907 ? cmpchar_table[COMPOSITE_CHAR_ID ((C))]->len \
908 : CHARSET_BYTES (CHAR_CHARSET ((C))))
909
910
03e66c53 911#endif /* _CHARSET_H */
Unnamed repository; edit this file 'description' to name the repository.