src/charset.h

   1 /* Header for multilingual 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 (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 */
 101 #define LEADING_CODE_PRIVATE_22 0x9D /* for private DIMENSION2 of 2-column */
 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
 120 /* Maximum value of overall charset identification number.  */
 121 #define MAX_CHARSET 0xFE
 122
 123 /* Definition of special charsets.  */
 124 #define CHARSET_ASCII           0
 125 #define CHARSET_COMPOSITION     0x80
 126
 127 extern int charset_ascii;       /* ASCII */
 128 extern int charset_composition; /* for a composite character */
 129 extern int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */
 130 extern int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */
 131 extern int charset_jisx0208;    /* JISX0208.1983 (Japanese Kanji) */
 132 extern int charset_katakana_jisx0201; /* JISX0201.Kana (Japanese Katakana) */
 133 extern int charset_latin_jisx0201; /* JISX0201.Roman (Japanese Roman) */
 134 extern int charset_big5_1;      /* Big5 Level 1 (Chinese Traditional) */
 135 extern int charset_big5_2;      /* Big5 Level 2 (Chinese Traditional) */
 136
 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)
 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
 158   after.  Both representations encode the information of charset and
 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
 200   16) non-composite characters (components).  Although each component
 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)
 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)
 251
 252 /* 1 if C is an ASCII character, else 0.  */
 253 #define SINGLE_BYTE_CHAR_P(c) ((c) >= 0 && (c) < 0x100)
 254 /* 1 if C is an composite character, else 0.  */
 255 #define COMPOSITE_CHAR_P(c) ((c) >= MIN_CHAR_COMPOSITION)
 256
 257 /* 1 if BYTE is a character in itself, in multibyte mode.  */
 258 #define ASCII_BYTE_P(byte) ((byte) < 0x80)
 259
 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
 273    BYTE (integer) is the length of multi-byte form of a character in
 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
 284    charset when rendering.  If 0, render from right to left, else
 285    render from left to right.
 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.  */
 313 extern 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.  */
 319 #define CHARSET_TABLE_ENTRY(charset)                                    \
 320   XCHAR_TABLE (Vcharset_table)->contents[((charset) == CHARSET_ASCII    \
 321                                           ? 0 : (charset) + 128)]
 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.  */
 373 extern Lisp_Object Vcharset_symbol_table;
 374
 375 /* Return symbol of CHARSET.  */
 376 #define CHARSET_SYMBOL(charset) \
 377   XVECTOR (Vcharset_symbol_table)->contents[charset]
 378
 379 /* 1 if CHARSET is valid, else 0.  */
 380 #define CHARSET_VALID_P(charset)                                         \
 381   ((charset) == 0                                                        \
 382    || ((charset) >= 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
 383    || ((charset) >= MIN_CHARSET_PRIVATE_DIMENSION1 && (charset) <= MAX_CHARSET))
 384
 385 /* 1 if CHARSET is already defined, else 0.  */
 386 #define CHARSET_DEFINED_P(charset)                      \
 387   (((charset) >= 0) && ((charset) <= MAX_CHARSET)       \
 388    && !NILP (CHARSET_TABLE_ENTRY (charset)))
 389
 390 /* Since the information CHARSET-BYTES and CHARSET-WIDTH of
 391    Vcharset_table can be retrieved only from the first byte of
 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.  */
 395 extern int bytes_by_char_head[256];
 396 extern 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            \
 411             : ((c) <= MAX_CHAR_COMPOSITION      \
 412                ? CHARSET_COMPOSITION            \
 413                : CHARSET_ASCII)))))
 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.  */
 452 #define MAKE_NON_ASCII_CHAR(charset, c1, c2)                            \
 453   ((charset) == CHARSET_COMPOSITION                                     \
 454    ? MAKE_COMPOSITE_CHAR (((c1) << 7) + (c2))                           \
 455    : (! CHARSET_DEFINED_P (charset) || CHARSET_DIMENSION (charset) == 1 \
 456       ? (((charset) - 0x70) << 7) | (c1)                                \
 457       : ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2                     \
 458          ? (((charset) - 0x8F) << 14) | ((c1) << 7) | (c2)              \
 459          : (((charset) - 0xE0) << 14) | ((c1) << 7) | (c2))))
 460
 461 /* Return a composite character of which CMPCHAR-ID is ID.  */
 462 #define MAKE_COMPOSITE_CHAR(id) (MIN_CHAR_COMPOSITION + (id))
 463
 464 /* Return CMPCHAR-ID of a composite character C.  */
 465 #define COMPOSITE_CHAR_ID(c) ((c) - MIN_CHAR_COMPOSITION)
 466
 467 /* Return a character of which charset is CHARSET and position-codes
 468    are C1 and C2.  DIMENSION1 character ignores C2.  */
 469 #define MAKE_CHAR(charset, c1, c2)                      \
 470   ((charset) == CHARSET_ASCII                           \
 471    ? (c1)                                               \
 472    : MAKE_NON_ASCII_CHAR ((charset), (c1) & 0x7F, (c2) & 0x7F))
 473
 474 /* If GENERICP is nonzero, return nonzero iff C is a valid normal or
 475    generic character.  If GENERICP is zero, return nonzero iff C is a
 476    valid normal character.  */
 477 #define CHAR_VALID_P(c, genericp)       \
 478   ((c) >= 0                             \
 479    && (SINGLE_BYTE_CHAR_P (c) || char_valid_p (c, genericp)))
 480
 481 /* This default value is used when nonascii-translation-table or
 482    nonascii-insert-offset fail to convert unibyte character to a valid
 483    multibyte character.  This makes a Latin-1 character.  */
 484
 485 #define DEFAULT_NONASCII_INSERT_OFFSET 0x800
 486
 487 /* Check if the character C is valid as a multibyte character.  */
 488
 489 #define VALID_MULTIBYTE_CHAR_P(c)                                         \
 490   ((c) < MIN_CHAR_OFFICIAL_DIMENSION2                                     \
 491    ? (!NILP (XCHAR_TABLE (Vcharset_table)->contents[CHAR_FIELD2 (c)       \
 492                                                    + 0xF0])               \
 493       && CHAR_FIELD3 (c) >= 32)                                           \
 494    : ((c) < MIN_CHAR_PRIVATE_DIMENSION2                                   \
 495       ? (!NILP (XCHAR_TABLE (Vcharset_table)->contents[CHAR_FIELD1 (c)    \
 496                                                       + 0x10F])           \
 497          && CHAR_FIELD2 (c) >= 32 && CHAR_FIELD3 (c) >= 32)               \
 498       : ((c) < MIN_CHAR_COMPOSITION                                       \
 499          ? (!NILP (XCHAR_TABLE (Vcharset_table)->contents[CHAR_FIELD1 (c) \
 500                                                          + 0x160])        \
 501             && CHAR_FIELD2 (c) >= 32 && CHAR_FIELD3 (c) >= 32)            \
 502          : (c) < MIN_CHAR_COMPOSITION + n_cmpchars)))
 503
 504 /* The charset of non-ASCII character C is stored in CHARSET, and the
 505    position-codes of C are stored in C1 and C2.
 506    We store -1 in C2 if the character is just 2 bytes.
 507
 508    Do not use this macro for an ASCII character.  */
 509
 510 #define SPLIT_NON_ASCII_CHAR(c, charset, c1, c2)                         \
 511   ((c) & CHAR_FIELD1_MASK                                                \
 512    ? (charset = ((c) < MIN_CHAR_COMPOSITION                              \
 513                  ? (CHAR_FIELD1 (c)                                      \
 514                     + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)) \
 515                  : CHARSET_COMPOSITION),                                 \
 516       c1 = CHAR_FIELD2 (c),                                              \
 517       c2 = CHAR_FIELD3 (c))                                              \
 518    : (charset = CHAR_FIELD2 (c) + 0x70,                                  \
 519       c1 = CHAR_FIELD3 (c),                                              \
 520       c2 = -1))
 521
 522 /* The charset of character C is stored in CHARSET, and the
 523    position-codes of C are stored in C1 and C2.
 524    We store -1 in C2 if the character is just 2 bytes.  */
 525
 526 #define SPLIT_CHAR(c, charset, c1, c2)                  \
 527   (SINGLE_BYTE_CHAR_P (c)                               \
 528    ? charset = CHARSET_ASCII, c1 = (c), c2 = -1         \
 529    : SPLIT_NON_ASCII_CHAR (c, charset, c1, c2))
 530
 531 /* The charset of the character at STR is stored in CHARSET, and the
 532    position-codes are stored in C1 and C2.
 533    We store -1 in C2 if the character is just 2 bytes.
 534
 535    If the character is a composite character, the upper 7-bit and
 536    lower 7-bit of CMPCHAR-ID are set in C1 and C2 respectively.  No
 537    range checking.  */
 538
 539 #define SPLIT_STRING(str, len, charset, c1, c2)                         \
 540   ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2                     \
 541     || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len                \
 542     || split_non_ascii_string (str, len, &charset, &c1, &c2) < 0)       \
 543    ? c1 = *(str), charset = CHARSET_ASCII                               \
 544    : charset)
 545
 546 /* Mapping table from ISO2022's charset (specified by DIMENSION,
 547    CHARS, and FINAL_CHAR) to Emacs' charset.  Should be accessed by
 548    macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR).  */
 549 extern int iso_charset_table[2][2][128];
 550
 551 #define ISO_CHARSET_TABLE(dimension, chars, final_char) \
 552   iso_charset_table[XINT (dimension) - 1][XINT (chars) > 94][XINT (final_char)]
 553
 554 #define BASE_LEADING_CODE_P(c) (BYTES_BY_CHAR_HEAD ((unsigned char) (c)) > 1)
 555
 556 /* Return how many bytes C will occupy in a multibyte buffer.  */
 557 #define CHAR_BYTES(c) \
 558   ((SINGLE_BYTE_CHAR_P ((c)) || ((c) & ~GLYPH_MASK_CHAR)) ? 1 : char_bytes (c))
 559
 560 /* The following two macros CHAR_STRING and STRING_CHAR are the main
 561    entry points to convert between Emacs two types of character
 562    representations: multi-byte form and single-word form (character
 563    code).  */
 564
 565 /* Set STR a pointer to the multi-byte form of the character C.  If C
 566    is not a composite character, the multi-byte form is set in WORKBUF
 567    and STR points WORKBUF.  The caller should allocate at least 4-byte
 568    area at WORKBUF in advance.  Returns the length of the multi-byte
 569    form.  If C is an invalid character code, signal an error.  */
 570
 571 #define CHAR_STRING(c, workbuf, str)                    \
 572   (SINGLE_BYTE_CHAR_P (c)                               \
 573    ? *(str = workbuf) = (unsigned char)(c), 1           \
 574    : non_ascii_char_to_string (c, workbuf, (unsigned char **)&str))
 575
 576 /* Return a character code of the character of which multi-byte form
 577    is at STR and the length is LEN.  If STR doesn't contain valid
 578    multi-byte form, only the first byte in STR is returned.  */
 579
 580 #define STRING_CHAR(str, len)                           \
 581   (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1     \
 582    ? (unsigned char) *(str)                             \
 583    : string_to_non_ascii_char (str, len, 0, 0))
 584
 585 /* This is like STRING_CHAR but the third arg ACTUAL_LEN is set to
 586    the length of the multi-byte form.  Just to know the length, use
 587    MULTIBYTE_FORM_LENGTH.  */
 588
 589 #define STRING_CHAR_AND_LENGTH(str, len, actual_len)            \
 590   (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1             \
 591    ? (actual_len = 1), (unsigned char) *(str)                   \
 592    : string_to_non_ascii_char (str, len, &actual_len, 0))
 593
 594 /* This is like STRING_CHAR_AND_LENGTH but the third arg ACTUAL_LEN
 595    does not include garbage bytes following the multibyte character.  */
 596 #define STRING_CHAR_AND_CHAR_LENGTH(str, len, actual_len)       \
 597   (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1             \
 598    ? (actual_len = 1), (unsigned char) *(str)                   \
 599    : string_to_non_ascii_char (str, len, &actual_len, 1))
 600
 601 /* Fetch the "next" multibyte character from Lisp string STRING
 602    at byte position BYTEIDX, character position CHARIDX.
 603    Store it into OUTPUT.
 604
 605    All the args must be side-effect-free.
 606    BYTEIDX and CHARIDX must be lvalues;
 607    we increment them past the character fetched.  */
 608
 609 #define FETCH_STRING_CHAR_ADVANCE(OUTPUT, STRING, CHARIDX, BYTEIDX)           \
 610 if (1)                                                                        \
 611   {                                                                           \
 612     unsigned char *fetch_string_char_ptr = &XSTRING (STRING)->data[BYTEIDX];  \
 613     int fetch_string_char_space_left = XSTRING (STRING)->size_byte - BYTEIDX; \
 614     int actual_len;                                                           \
 615                                                                               \
 616     OUTPUT                                                                    \
 617       = STRING_CHAR_AND_LENGTH (fetch_string_char_ptr,                        \
 618                                 fetch_string_char_space_left, actual_len);    \
 619                                                                               \
 620     BYTEIDX += actual_len;                                                    \
 621     CHARIDX++;                                                                \
 622   }                                                                           \
 623 else
 624
 625 /* Return the length of the multi-byte form at string STR of length LEN.  */
 626
 627 #define MULTIBYTE_FORM_LENGTH(str, len)                 \
 628   (BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) == 1    \
 629    ? 1                                                  \
 630    : multibyte_form_length (str, len))
 631
 632 /* Set C a (possibly multibyte) character at P.  P points into a
 633    string which is the virtual concatenation of STR1 (which ends at
 634    END1) or STR2 (which ends at END2).  */
 635
 636 #define GET_CHAR_AFTER_2(c, p, str1, end1, str2, end2)                      \
 637   do {                                                                      \
 638     const char *dtemp = (p) == (end1) ? (str2) : (p);                       \
 639     const char *dlimit = ((p) >= (str1) && (p) < (end1)) ? (end1) : (end2); \
 640     c = STRING_CHAR (dtemp, dlimit - dtemp);                                \
 641   } while (0)
 642
 643 /* Set C a (possibly multibyte) character before P.  P points into a
 644    string which is the virtual concatenation of STR1 (which ends at
 645    END1) or STR2 (which ends at END2).  */
 646
 647 #define GET_CHAR_BEFORE_2(c, p, str1, end1, str2, end2)                     \
 648   do {                                                                      \
 649     const char *dtemp = (p);                                                \
 650     const char *dlimit = ((p) > (str2) && (p) <= (end2)) ? (str2) : (str1); \
 651     while (dtemp-- > dlimit && (unsigned char) *dtemp >= 0xA0);             \
 652     c = STRING_CHAR (dtemp, p - dtemp);                                     \
 653   } while (0)
 654
 655 #ifdef emacs
 656
 657 /* Increase the buffer point POS of the current buffer to the next
 658    character boundary.  This macro relies on the fact that *GPT_ADDR
 659    and *Z_ADDR are always accessible and the values are '\0'.  No
 660    range checking of POS.  */
 661 #define INC_POS(pos)                            \
 662   do {                                          \
 663     unsigned char *p = BYTE_POS_ADDR (pos);     \
 664     pos++;                                      \
 665     if (BASE_LEADING_CODE_P (*p++))             \
 666       while (!CHAR_HEAD_P (*p)) p++, pos++;     \
 667   } while (0)
 668
 669 /* Decrease the buffer point POS of the current buffer to the previous
 670    character boundary.  No range checking of POS.  */
 671 #define DEC_POS(pos)                                            \
 672   do {                                                          \
 673     unsigned char *p, *p_min;                                   \
 674                                                                 \
 675     pos--;                                                      \
 676     if (pos < GPT_BYTE)                                         \
 677       p = BEG_ADDR + pos - 1, p_min = BEG_ADDR;                 \
 678     else                                                        \
 679       p = BEG_ADDR + GAP_SIZE + pos - 1, p_min = GAP_END_ADDR;  \
 680     if (p > p_min && !CHAR_HEAD_P (*p))                         \
 681       {                                                         \
 682         int pos_saved = pos--;                                  \
 683         p--;                                                    \
 684         while (p > p_min && !CHAR_HEAD_P (*p)) p--, pos--;      \
 685         if (!BASE_LEADING_CODE_P (*p)) pos = pos_saved;         \
 686       }                                                         \
 687   } while (0)
 688
 689 /* Increment both CHARPOS and BYTEPOS, each in the appropriate way.  */
 690
 691 #define INC_BOTH(charpos, bytepos)                              \
 692 do                                                              \
 693   {                                                             \
 694     (charpos)++;                                                \
 695     if (NILP (current_buffer->enable_multibyte_characters))     \
 696       (bytepos)++;                                              \
 697     else                                                        \
 698       INC_POS ((bytepos));                                      \
 699   }                                                             \
 700 while (0)
 701
 702 /* Decrement both CHARPOS and BYTEPOS, each in the appropriate way.  */
 703
 704 #define DEC_BOTH(charpos, bytepos)                              \
 705 do                                                              \
 706   {                                                             \
 707     (charpos)--;                                                \
 708     if (NILP (current_buffer->enable_multibyte_characters))     \
 709       (bytepos)--;                                              \
 710     else                                                        \
 711       DEC_POS ((bytepos));                                      \
 712   }                                                             \
 713 while (0)
 714
 715 /* Increase the buffer point POS of the current buffer to the next
 716    character boundary.  This macro relies on the fact that *GPT_ADDR
 717    and *Z_ADDR are always accessible and the values are '\0'.  No
 718    range checking of POS.  */
 719 #define BUF_INC_POS(buf, pos)                           \
 720   do {                                                  \
 721     unsigned char *p = BUF_BYTE_ADDRESS (buf, pos);     \
 722     pos++;                                              \
 723     if (BASE_LEADING_CODE_P (*p++))                     \
 724       while (!CHAR_HEAD_P (*p)) p++, pos++;             \
 725   } while (0)
 726
 727 /* Decrease the buffer point POS of the current buffer to the previous
 728    character boundary.  No range checking of POS.  */
 729 #define BUF_DEC_POS(buf, pos)                                   \
 730   do {                                                          \
 731     unsigned char *p, *p_min;                                   \
 732     int pos_saved = --pos;                                      \
 733     if (pos < BUF_GPT_BYTE (buf))                               \
 734       {                                                         \
 735         p = BUF_BEG_ADDR (buf) + pos - 1;                       \
 736         p_min = BUF_BEG_ADDR (buf);                             \
 737       }                                                         \
 738     else                                                        \
 739       {                                                         \
 740         p = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos - 1;  \
 741         p_min = BUF_GAP_END_ADDR (buf);                         \
 742       }                                                         \
 743     if (p > p_min && !CHAR_HEAD_P (*p))                         \
 744       {                                                         \
 745         int pos_saved = pos--;                                  \
 746         p--;                                                    \
 747         while (p > p_min && !CHAR_HEAD_P (*p)) p--, pos--;      \
 748         if (!BASE_LEADING_CODE_P (*p)) pos = pos_saved;         \
 749       }                                                         \
 750   } while (0)
 751
 752 #endif /* emacs */
 753
 754 /* Maximum counts of components in one composite character.  */
 755 #define MAX_COMPONENT_COUNT 16
 756
 757 /* Structure to hold information of a composite character.  */
 758 struct cmpchar_info {
 759   /* Byte length of the composite character.  */
 760   int len;
 761
 762   /* Multi-byte form of the composite character.  */
 763   unsigned char *data;
 764
 765   /* Length of glyph codes.  */
 766   int glyph_len;
 767
 768   /* Width of the overall glyph of the composite character.  */
 769   int width;
 770
 771   /* Pointer to an array of glyph codes of the composite character.
 772      This actually contains only character code, no face.  */
 773   GLYPH *glyph;
 774
 775   /* Pointer to an array of composition rules.  The value has the form:
 776         (0xA0 + ((GLOBAL-REF-POINT << 2) | NEW-REF-POINT))
 777      where each XXX-REF-POINT is 0..8.  */
 778   unsigned char *cmp_rule;
 779
 780   /* Pointer to an array of x-axis offset of left edge of glyphs
 781      relative to the left of of glyph[0] except for the first element
 782      which is the absolute offset from the left edge of overall glyph.
 783      The actual pixel offset should be calculated by multiplying each
 784      frame's one column width by this value:
 785         (i.e. FONT_WIDTH (f->output_data.x->font) * col_offset[N]).  */
 786   float *col_offset;
 787
 788   /* Work slot used by `dumpglyphs' (xterm.c).  */
 789   int face_work;
 790 };
 791
 792 /* Table of pointers to the structure `cmpchar_info' indexed by
 793    CMPCHAR-ID.  */
 794 extern struct cmpchar_info **cmpchar_table;
 795 /* Number of the current composite characters.  */
 796 extern int n_cmpchars;
 797
 798 /* This is the maximum length of multi-byte form.  */
 799 #define MAX_LENGTH_OF_MULTI_BYTE_FORM (MAX_COMPONENT_COUNT * 6)
 800
 801 /* Maximum character code currently used.  */
 802 #define MAX_CHAR (MIN_CHAR_COMPOSITION + n_cmpchars)
 803
 804 extern void invalid_character P_ ((int));
 805
 806 extern int translate_char P_ ((Lisp_Object, int, int, int, int));
 807 extern int split_non_ascii_string P_ ((const unsigned char *, int, int *,
 808                                        unsigned char *, unsigned char *));
 809 extern int string_to_non_ascii_char P_ ((const unsigned char *, int, int *,
 810                                          int));
 811 extern int non_ascii_char_to_string P_ ((int, unsigned char *, unsigned char **));
 812 extern int multibyte_form_length P_ ((const unsigned char *, int));
 813 extern int str_cmpchar_id P_ ((const unsigned char *, int));
 814 extern int get_charset_id P_ ((Lisp_Object));
 815 extern int cmpchar_component P_ ((int, int, int));
 816 extern int find_charset_in_str P_ ((unsigned char *, int, int *,
 817                                     Lisp_Object, int, int));
 818 extern int strwidth P_ ((unsigned char *, int));
 819 extern int char_bytes P_ ((int));
 820 extern int char_valid_p P_ ((int, int));
 821
 822 extern Lisp_Object Vtranslation_table_vector;
 823
 824 /* Return a translation table of id number ID.  */
 825 #define GET_TRANSLATION_TABLE(id) \
 826   (XCONS(XVECTOR(Vtranslation_table_vector)->contents[(id)])->cdr)
 827
 828 /* A char-table for characters which may invoke auto-filling.  */
 829 extern Lisp_Object Vauto_fill_chars;
 830
 831 /* Copy LEN bytes from FROM to TO.  This macro should be used only
 832    when a caller knows that LEN is short and the obvious copy loop is
 833    faster than calling bcopy which has some overhead.  */
 834
 835 #define BCOPY_SHORT(from, to, len)              \
 836   do {                                          \
 837     int i = len;                                \
 838     unsigined char *from_p = from, *to_p = to;  \
 839     while (i--) *from_p++ = *to_p++;            \
 840   } while (0)
 841
 842 #endif /* _CHARSET_H */