code.delx.au - gnu-emacs/blob - src/charset.h

   1 /* Header for multilingual character handler.
   2    Ver.1.0
   3    Copyright (C) 1995 Free Software Foundation, Inc.
   4    Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 #ifndef _CHARSET_H
  24 #define _CHARSET_H
  25
  26 /*** GENERAL NOTE on CHARACTER SET (CHARSET) ***
  27
  28   A character set ("charset" hereafter) is a meaningful collection
  29   (i.e. language, culture, functionality, etc) of characters.  Emacs
  30   handles multiple charsets at once.  Each charset corresponds to one
  31   of ISO charsets (except for a special charset for composition
  32   characters).  Emacs identifies a charset by a unique identification
  33   number, whereas ISO identifies a charset by a triplet of DIMENSION,
  34   CHARS and FINAL-CHAR.  So, hereafter, just saying "charset" means an
  35   identification number (integer value).
  36
  37   The value range of charset is 0x00, 0x80..0xFE.  There are four
  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
  40
  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,
  45   we use the following convention on C variable names:
  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
  50   Each charset (except for ASCII) is assigned a base leading-code
  51   (range 0x80..0x9D).  In addition, a charset of greater than 0xA0
  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
  59   charset" because those are mainly for a charset which is not
  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--
  69   0x80          COMPOSITION      same as charset        -- none --
  70   0x81..0x8F    official dim1    same as charset        -- none --
  71   0x90..0x99    official dim2    same as charset        -- none --
  72   0x9A..0x9F    --never used--
  73   0xA0..0xDF    private dim1        0x9A                same as charset
  74                 of 1-column width
  75   0xE0..0xEF    private dim1        0x9B                same as charset
  76                 of 2-column width
  77   0xF0..0xF4    private dim2        0x9C                same as charset
  78                 of 1-column width
  79   0xF5..0xFE    private dim2        0x9D                same as charset
  80                 of 2-column width
  81   0xFF          --never used--
  82   ---------------------------------------------------------------------------
  83
  84   In the table, "COMPOSITION" means a charset for a composite
  85   character which is a character composed from several (up to 16)
  86   non-composite characters (components).  Although a composite
  87   character can contain components of many charsets, a composite
  88   character itself belongs to the charset CHARSET-COMPOSITION.  See
  89   the document "GENERAL NOTE on COMPOSITE CHARACTER" below for more
  90   detail.
  91
  92 */
  93
  94 /* Definition of special leading-codes.  */
  95 /* Base leading-code.  */
  96 /* Special leading-code followed by components of a composite character.  */
  97 #define LEADING_CODE_COMPOSITION        0x80
  98 /* Leading-code followed by extended leading-code.  */
  99 #define LEADING_CODE_PRIVATE_11 0x9A /* for private DIMENSION1 of 1-column */
 100 #define LEADING_CODE_PRIVATE_12 0x9B /* for private DIMENSION1 of 2-column */
 101 #define LEADING_CODE_PRIVATE_21 0x9C /* for private DIMENSION2 of 1-column */
 102 #define LEADING_CODE_PRIVATE_22 0x9D /* for private DIMENSION2o f 2-column */
 103
 104 /* Extended leading-code.  */
 105 /* Start of each extended leading-codes.  */
 106 #define LEADING_CODE_EXT_11 0xA0 /* follows LEADING_CODE_PRIVATE_11 */
 107 #define LEADING_CODE_EXT_12 0xE0 /* follows LEADING_CODE_PRIVATE_12 */
 108 #define LEADING_CODE_EXT_21 0xF0 /* follows LEADING_CODE_PRIVATE_21 */
 109 #define LEADING_CODE_EXT_22 0xF5 /* follows LEADING_CODE_PRIVATE_22 */
 110 /* Maximum value of extended leading-codes.  */
 111 #define LEADING_CODE_EXT_MAX 0xFE
 112
 113 /* Definition of minimum/maximum charset of each DIMENSION.  */
 114 #define MIN_CHARSET_OFFICIAL_DIMENSION1 0x81
 115 #define MAX_CHARSET_OFFICIAL_DIMENSION1 0x8F
 116 #define MIN_CHARSET_OFFICIAL_DIMENSION2 0x90
 117 #define MAX_CHARSET_OFFICIAL_DIMENSION2 0x99
 118 #define MIN_CHARSET_PRIVATE_DIMENSION1  LEADING_CODE_EXT_11
 119 #define MIN_CHARSET_PRIVATE_DIMENSION2  LEADING_CODE_EXT_21
 120
 121 /* Maximum value of overall charset identification number.  */
 122 #define MAX_CHARSET 0xFE
 123
 124 /* Definition of special charsets.  */
 125 #define CHARSET_ASCII           0
 126 #define CHARSET_COMPOSITION     0x80
 127
 128 extern int charset_ascii;       /* ASCII */
 129 extern int charset_composition; /* for a composite character */
 130 extern int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */
 131 extern int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */
 132 extern int charset_jisx0208;    /* JISX0208.1983 (Japanese Kanji) */
 133 extern int charset_katakana_jisx0201; /* JISX0201.Kana (Japanese Katakana) */
 134 extern int charset_latin_jisx0201; /* JISX0201.Roman (Japanese Roman) */
 135 extern int charset_big5_1;      /* Big5 Level 1 (Chinese Traditional) */
 136 extern int charset_big5_2;      /* Big5 Level 2 (Chinese Traditional) */
 137
 138 /* Check if STR points the head of multi-byte form, i.e. *STR is an
 139    ASCII character or a base leading-code.  */
 140 #define CHAR_HEAD_P(str) ((unsigned char) *(str) < 0xA0)
 141
 142 /*** GENERAL NOTE on CHARACTER REPRESENTATION ***
 143
 144   At first, the term "character" or "char" is used for a multilingual
 145   character (of course, including ASCII character), not for a byte in
 146   computer memory.  We use the term "code" or "byte" for the latter
 147   case.
 148
 149   A character is identified by charset and one or two POSITION-CODEs.
 150   POSITION-CODE is the position of the character in the charset.  A
 151   character of DIMENSION1 charset has one POSITION-CODE: POSITION-CODE-1.
 152   A character of DIMENSION2 charset has two POSITION-CODE:
 153   POSITION-CODE-1 and POSITION-CODE-2.  The code range of
 154   POSITION-CODE is 0x20..0x7F.
 155
 156   Emacs has two kinds of representation of a character: multi-byte
 157   form (for buffer and string) and single-word form (for character
 158   object in Emacs Lisp).  The latter is called "character code" here
 159   after.  Both representation encode the information of charset and
 160   POSITION-CODE but in a different way (for instance, MSB of
 161   POSITION-CODE is set in multi-byte form).
 162
 163   For details of multi-byte form, see the section "2. Emacs internal
 164   format handlers" of `coding.c'.
 165
 166   Emacs uses 19 bits for a character code.  The bits are divided into
 167   3 fields: FIELD1(5bits):FIELD2(7bits):FIELD3(7bits).
 168
 169   A character code of DIMENSION1 character uses FIELD2 to hold charset
 170   and FIELD3 to hold POSITION-CODE-1.  A character code of DIMENSION2
 171   character uses FIELD1 to hold charset, FIELD2 and FIELD3 to hold
 172   POSITION-CODE-1 and POSITION-CODE-2 respectively.
 173
 174   More precisely...
 175
 176   FIELD2 of DIMENSION1 character (except for ASCII) is "charset - 0x70".
 177   This is to make all character codes except for ASCII greater than
 178   256 (ASCII's FIELD2 is 0).  So, the range of FIELD2 of DIMENSION1
 179   character is 0 or 0x11..0x7F.
 180
 181   FIELD1 of DIMENSION2 character is "charset - 0x8F" for official
 182   charset and "charset - 0xE0" for private charset.  So, the range of
 183   FIELD1 of DIMENSION2 character is 0x01..0x1E.
 184
 185   -----------------------------------------------------------------------
 186   charset       FIELD1 (5-bit)      FIELD2 (7-bit)      FIELD3 (7-bit)
 187   -----------------------------------------------------------------------
 188   ASCII         0                   0                   POSITION-CODE-1
 189   DIMENSION1    0                   charset - 0x70      POSITION-CODE-1
 190   DIMENSION2(o) charset - 0x8F      POSITION-CODE-1     POSITION-CODE-2
 191   DIMENSION2(p) charset - 0xE0      POSITION-CODE-1     POSITION-CODE-2
 192   -----------------------------------------------------------------------
 193   "(o)": official, "(p)": private
 194   -----------------------------------------------------------------------
 195
 196 */
 197
 198 /*** GENERAL NOTE on COMPOSITE CHARACTER ***
 199
 200   A composite character is a character composed from several (up to
 201   16) non-composite characters (components).  Although each components
 202   can belong to any charset, a composite character itself belongs to
 203   the charset `charset-composition' and is assigned a special
 204   leading-code `LEADING_CODE_COMPOSITION' for multi-byte form.  See
 205   the document "2. Emacs internal format handlers" in `coding.c' for
 206   more detail about multi-byte form.
 207
 208   A character code of composite character has special format.  In the
 209   above document, FIELD1 of a composite character is 0x1F.  Each
 210   composite character is assigned a sequential number CMPCHAR-ID.
 211   FIELD2 and FIELD3 are combined to make 14bits field for holding
 212   CMPCHAR-ID, which means that Emacs can handle at most 2^14 (= 16384)
 213   composite characters at once.
 214
 215   -----------------------------------------------------------------------
 216   charset               FIELD1 (5-bit)      FIELD2&3 (14-bit)
 217   -----------------------------------------------------------------------
 218   CHARSET-COMPOSITION   0x1F                CMPCHAR-ID
 219   -----------------------------------------------------------------------
 220
 221   Emacs assigns CMPCHAR-ID to a composite character only when it
 222   requires the character code of the composite character (e.g. while
 223   displaying the composite character).
 224
 225 */
 226
 227 /* Masks of each field of character code.  */
 228 #define CHAR_FIELD1_MASK (0x1F << 14)
 229 #define CHAR_FIELD2_MASK (0x7F << 7)
 230 #define CHAR_FIELD3_MASK 0x7F
 231
 232 /* Macros to access each field of character C.  */
 233 #define CHAR_FIELD1(c) (((c) & CHAR_FIELD1_MASK) >> 14)
 234 #define CHAR_FIELD2(c) (((c) & CHAR_FIELD2_MASK) >> 7)
 235 #define CHAR_FIELD3(c) ((c) & CHAR_FIELD3_MASK)
 236
 237 /* Minimum character code of character of each DIMENSION.  */
 238 #define MIN_CHAR_OFFICIAL_DIMENSION1 \
 239   ((MIN_CHARSET_OFFICIAL_DIMENSION1 - 0x70) << 7)
 240 #define MIN_CHAR_PRIVATE_DIMENSION1 \
 241   ((MIN_CHARSET_PRIVATE_DIMENSION1 - 0x70) << 7)
 242 #define MIN_CHAR_OFFICIAL_DIMENSION2 \
 243   ((MIN_CHARSET_OFFICIAL_DIMENSION2 - 0x8F) << 14)
 244 #define MIN_CHAR_PRIVATE_DIMENSION2 \
 245   ((MIN_CHARSET_PRIVATE_DIMENSION2 - 0xE0) << 14)
 246 #define MIN_CHAR_COMPOSITION \
 247   (0x1F << 14)
 248
 249 /* 1 if C is an ASCII character, else 0.  */
 250 #define SINGLE_BYTE_CHAR_P(c) ((c) < 0x100)
 251 /* 1 if C is an composite character, else 0.  */
 252 #define COMPOSITE_CHAR_P(c) ((c) >= MIN_CHAR_COMPOSITION)
 253
 254 /* A char-table containing information of each character set.
 255
 256    Unlike ordinary char-tables, this doesn't contain any nested table.
 257    Only the top level elements are used.  Each element is a vector of
 258    the following information:
 259         CHARSET-ID, BYTES, DIMENSION, CHARS, WIDTH, DIRECTION,
 260         LEADING-CODE-BASE, LEADING-CODE-EXT,
 261         ISO-FINAL-CHAR, ISO-GRAPHIC-PLANE,
 262         REVERSE-CHARSET, SHORT-NAME, LONG-NAME, DESCRIPTION,
 263         PLIST.
 264
 265    CHARSET-ID (integer) is the identification number of the charset.
 266
 267    BYTE (integer) is the length of multi-byte form of a character in
 268    the charset: one of 1, 2, 3, and 4.
 269
 270    DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
 271
 272    CHARS (integer) is the number of characters in a dimension: 94 or 96.
 273
 274    WIDTH (integer) is the number of columns a character in the charset
 275    occupies on the screen: one of 0, 1, and 2.
 276
 277    DIRECTION (integer) is the rendering direction of characters in the
 278    charset when rendering.  If 0, render from right to left, else
 279    render from left to right.
 280
 281    LEADING-CODE-BASE (integer) is the base leading-code for the
 282    charset.
 283
 284    LEADING-CODE-EXT (integer) is the extended leading-code for the
 285    charset.  All charsets of less than 0xA0 has the value 0.
 286
 287    ISO-FINAL-CHAR (character) is the final character of the
 288    corresponding ISO 2022 charset.
 289
 290    ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
 291    while encoding to variants of ISO 2022 coding system, one of the
 292    following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).
 293
 294    REVERSE-CHARSET (integer) is the charset which differs only in
 295    LEFT-TO-RIGHT value from the charset.  If there's no such a
 296    charset, the value is -1.
 297
 298    SHORT-NAME (string) is the short name to refer to the charset.
 299
 300    LONG-NAME (string) is the long name to refer to the charset.
 301
 302    DESCRIPTION (string) is the description string of the charset.
 303
 304    PLIST (property list) may contain any type of information a user
 305    want to put and get by functions `put-charset-property' and
 306    `get-charset-property' respectively.  */
 307 extern Lisp_Object Vcharset_table;
 308
 309 /* Macros to access various information of CHARSET in Vcharset_table.
 310    We provide these macros for efficiency.  No range check of CHARSET.  */
 311
 312 /* Return entry of CHARSET (lisp integer) in Vcharset_table.  */
 313 #define CHARSET_TABLE_ENTRY(charset)                                    \
 314   XCHAR_TABLE (Vcharset_table)->contents[((charset) == CHARSET_ASCII    \
 315                                           ? 0 : (charset) + 128)]
 316
 317 /* Return information INFO-IDX of CHARSET.  */
 318 #define CHARSET_TABLE_INFO(charset, info_idx) \
 319   XVECTOR (CHARSET_TABLE_ENTRY (charset))->contents[info_idx]
 320
 321 #define CHARSET_ID_IDX (0)
 322 #define CHARSET_BYTES_IDX (1)
 323 #define CHARSET_DIMENSION_IDX (2)
 324 #define CHARSET_CHARS_IDX (3)
 325 #define CHARSET_WIDTH_IDX (4)
 326 #define CHARSET_DIRECTION_IDX (5)
 327 #define CHARSET_LEADING_CODE_BASE_IDX (6)
 328 #define CHARSET_LEADING_CODE_EXT_IDX (7)
 329 #define CHARSET_ISO_FINAL_CHAR_IDX (8)
 330 #define CHARSET_ISO_GRAPHIC_PLANE_IDX (9)
 331 #define CHARSET_REVERSE_CHARSET_IDX (10)
 332 #define CHARSET_SHORT_NAME_IDX (11)
 333 #define CHARSET_LONG_NAME_IDX (12)
 334 #define CHARSET_DESCRIPTION_IDX (13)
 335 #define CHARSET_PLIST_IDX (14)
 336 /* Size of a vector of each entry of Vcharset_table.  */
 337 #define CHARSET_MAX_IDX (15)
 338
 339 /* And several more macros to be used frequently.  */
 340 #define CHARSET_BYTES(charset) \
 341   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX))
 342 #define CHARSET_DIMENSION(charset) \
 343   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX))
 344 #define CHARSET_CHARS(charset) \
 345   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_CHARS_IDX))
 346 #define CHARSET_WIDTH(charset) \
 347   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_WIDTH_IDX))
 348 #define CHARSET_DIRECTION(charset) \
 349   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX))
 350 #define CHARSET_LEADING_CODE_BASE(charset) \
 351   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_BASE_IDX))
 352 #define CHARSET_LEADING_CODE_EXT(charset) \
 353   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_EXT_IDX))
 354 #define CHARSET_ISO_FINAL_CHAR(charset) \
 355   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_FINAL_CHAR_IDX))
 356 #define CHARSET_ISO_GRAPHIC_PLANE(charset) \
 357   XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_GRAPHIC_PLANE_IDX))
 358 #define CHARSET_REVERSE_CHARSET(charset) \
 359   XINT (CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX))
 360
 361 /* Macros to specify direction of a charset.  */
 362 #define CHARSET_DIRECTION_LEFT_TO_RIGHT 0
 363 #define CHARSET_DIRECTION_RIGHT_TO_LEFT 1
 364
 365 /* A vector of charset symbol indexed by charset-id.  This is used
 366    only for returning charset symbol from C functions.  */
 367 extern Lisp_Object Vcharset_symbol_table;
 368
 369 /* Return symbol of CHARSET.  */
 370 #define CHARSET_SYMBOL(charset) \
 371   XVECTOR (Vcharset_symbol_table)->contents[charset]
 372
 373 /* 1 if CHARSET is valid, else 0.  */
 374 #define CHARSET_VALID_P(charset)                                         \
 375   ((charset) == 0                                                        \
 376    || ((charset) >= 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
 377    || ((charset) >= MIN_CHARSET_PRIVATE_DIMENSION1 && (charset) <= MAX_CHARSET))
 378
 379 /* 1 if CHARSET is already defined, else 0.  */
 380 #define CHARSET_DEFINED_P(charset)                      \
 381   (((charset) >= 0) && ((charset) <= MAX_CHARSET)       \
 382    && !NILP (CHARSET_TABLE_ENTRY (charset)))
 383
 384 /* Since the information CHARSET-BYTES and CHARSET-WIDTH of
 385    Vcharset_table can be retrieved only from the first byte of
 386    multi-byte form (an ASCII code or a base leading-code), we provide
 387    here tables to be used by macros BYTES_BY_CHAR_HEAD and
 388    WIDTH_BY_CHAR_HEAD for faster information retrieval.  */
 389 extern int bytes_by_char_head[256];
 390 extern int width_by_char_head[256];
 391
 392 #define BYTES_BY_CHAR_HEAD(char_head) bytes_by_char_head[char_head]
 393 #define WIDTH_BY_CHAR_HEAD(char_head) width_by_char_head[char_head]
 394
 395 /* Charset of the character C.  */
 396 #define CHAR_CHARSET(c)                         \
 397   (SINGLE_BYTE_CHAR_P (c)                       \
 398    ? CHARSET_ASCII                              \
 399    : ((c) < MIN_CHAR_OFFICIAL_DIMENSION2        \
 400       ? CHAR_FIELD2 (c) + 0x70                  \
 401       : ((c) < MIN_CHAR_PRIVATE_DIMENSION2      \
 402          ? CHAR_FIELD1 (c) + 0x8F               \
 403          : ((c) < MIN_CHAR_COMPOSITION          \
 404             ? CHAR_FIELD1 (c) + 0xE0            \
 405             : CHARSET_COMPOSITION))))
 406
 407 /* Return charset at the place pointed by P.  */
 408 #define CHARSET_AT(p)                           \
 409   (*(p) < 0x80                                  \
 410    ? CHARSET_ASCII                              \
 411    : (*(p) == LEADING_CODE_COMPOSITION          \
 412       ? CHARSET_COMPOSITION                     \
 413       : (*(p) < LEADING_CODE_PRIVATE_11         \
 414          ? (int)*(p)                            \
 415          : (*(p) <= LEADING_CODE_PRIVATE_22     \
 416             ? (int)*((p) + 1)                   \
 417             : -1))))
 418
 419 /* Same as `CHARSET_AT ()' but perhaps runs faster because of an
 420    additional argument C which is the code (byte) at P.  */
 421 #define FIRST_CHARSET_AT(p, c)                  \
 422   ((c) < 0x80                                   \
 423    ? CHARSET_ASCII                              \
 424    : ((c) == LEADING_CODE_COMPOSITION           \
 425       ? CHARSET_COMPOSITION                     \
 426       : ((c) < LEADING_CODE_PRIVATE_11          \
 427          ? (int)(c)                             \
 428          : ((c) <= LEADING_CODE_PRIVATE_22      \
 429             ? (int)*((p) + 1)                   \
 430             : -1))))
 431
 432 /* Check if two characters C1 and C2 belong to the same charset.
 433    Always return 0 for composite characters.  */
 434 #define SAME_CHARSET_P(c1, c2)                                  \
 435   (c1 < MIN_CHAR_COMPOSITION                                    \
 436    && (SINGLE_BYTE_CHAR_P (c1)                                  \
 437        ? SINGLE_BYTE_CHAR_P (c2)                                \
 438        : (c1 < MIN_CHAR_OFFICIAL_DIMENSION2                     \
 439           ? (c1 & CHAR_FIELD2_MASK) == (c2 & CHAR_FIELD2_MASK)  \
 440           : (c1 & CHAR_FIELD1_MASK) == (c2 & CHAR_FIELD1_MASK))))
 441
 442 /* Return a non-ASCII character of which charset is CHARSET and
 443    position-codes are C1 and C2.  DIMENSION1 character ignores C2.  */
 444 #define MAKE_NON_ASCII_CHAR(charset, c1, c2)                    \
 445   ((charset) == CHARSET_COMPOSITION                             \
 446    ? MAKE_COMPOSITE_CHAR (((c1) << 7) + (c2))                   \
 447    : (CHARSET_DIMENSION (charset) == 1                          \
 448       ? (((charset) - 0x70) << 7) | (c1)                        \
 449       : ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2             \
 450          ? (((charset) - 0x8F) << 14) | ((c1) << 7) | (c2)      \
 451          : (((charset) - 0xE0) << 14) | ((c1) << 7) | (c2))))
 452
 453 /* Return a composite character of which CMPCHAR-ID is ID.  */
 454 #define MAKE_COMPOSITE_CHAR(id) (MIN_CHAR_COMPOSITION + (id))
 455
 456 /* Return CMPCHAR-ID of a composite character C.  */
 457 #define COMPOSITE_CHAR_ID(c) ((c) - MIN_CHAR_COMPOSITION)
 458
 459 /* Return a character of which charset is CHARSET and position-codes
 460    are C1 and C2.  DIMENSION1 character ignores C2.  */
 461 #define MAKE_CHAR(charset, c1, c2)                      \
 462   ((charset) == CHARSET_ASCII                           \
 463    ? (c1)                                               \
 464    : MAKE_NON_ASCII_CHAR ((charset), (c1) & 0x7F, (c2) & 0x7F))
 465
 466 /* The charset of non-ASCII character C is set to CHARSET, and the
 467    position-codes of C are set to C1 and C2.  C2 of DIMENSION1 character
 468    is -1.  */
 469 #define SPLIT_NON_ASCII_CHAR(c, charset, c1, c2)                         \
 470   ((c) < MIN_CHAR_OFFICIAL_DIMENSION2                                    \
 471    ? (charset = CHAR_FIELD2 (c) + 0x70,                                  \
 472       c1 = CHAR_FIELD3 (c),                                              \
 473       c2 = -1)                                                           \
 474    : (charset = ((c) < MIN_CHAR_COMPOSITION                              \
 475                  ? (CHAR_FIELD1 (c)                                      \
 476                     + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)) \
 477                  : CHARSET_COMPOSITION),                                 \
 478       c1 = CHAR_FIELD2 (c),                                              \
 479       c2 = CHAR_FIELD3 (c)))
 480
 481 /* The charset of character C is set to CHARSET, and the
 482    position-codes of C are set to C1 and C2.  C2 of DIMENSION1 character
 483    is -1.  */
 484 #define SPLIT_CHAR(c, charset, c1, c2)                  \
 485   (SINGLE_BYTE_CHAR_P (c)                               \
 486    ? charset = CHARSET_ASCII, c1 = (c), c2 = -1         \
 487    : SPLIT_NON_ASCII_CHAR (c, charset, c1, c2))
 488
 489 /* The charset of the character at STR is set to CHARSET, and the
 490    position-codes are set to C1 and C2.  C2 of DIMENSION1 character is -1.
 491    If the character is a composite character, the upper 7-bit and
 492    lower 7-bit of CMPCHAR-ID are set in C1 and C2 respectively.  No
 493    range checking.  */
 494 #define SPLIT_STRING(str, len, charset, c1, c2)                         \
 495   ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2                     \
 496     || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len                \
 497     || split_non_ascii_string (str, len, &charset, &c1, &c2, 0) < 0)    \
 498    ? c1 = *(str), charset = CHARSET_ASCII                               \
 499    : charset)
 500
 501 /* Mapping table from ISO2022's charset (specified by DIMENSION,
 502    CHARS, and FINAL_CHAR) to Emacs' charset.  Should be accessed by
 503    macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR).  */
 504 extern int iso_charset_table[2][2][128];
 505
 506 #define ISO_CHARSET_TABLE(dimension, chars, final_char) \
 507   iso_charset_table[XINT (dimension) - 1][XINT (chars) > 94][XINT (final_char)]
 508
 509 #define BASE_LEADING_CODE_P(c) (BYTES_BY_CHAR_HEAD ((unsigned char) (c)) > 1)
 510
 511 /* The following two macros CHAR_STRING and STRING_CHAR are the main
 512    entry points to convert between Emacs two types of character
 513    representations: multi-byte form and single-word form (character
 514    code).  */
 515
 516 /* Set STR a pointer to the multi-byte form of the character C.  If C
 517    is not a composite character, the multi-byte form is set in WORKBUF
 518    and STR points WORKBUF.  The caller should allocate at least 4-byte
 519    area at WORKBUF in advance.  Returns the length of the multi-byte
 520    form.  */
 521
 522 #define CHAR_STRING(c, workbuf, str)                    \
 523   (SINGLE_BYTE_CHAR_P (c)                               \
 524    ? *(str = workbuf) = (unsigned char)(c), 1           \
 525    : non_ascii_char_to_string (c, workbuf, &str))
 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
 531 #define STRING_CHAR(str, len)                                   \
 532   ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1            \
 533     || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > (len))     \
 534    ? (unsigned char) *(str)                                     \
 535    : string_to_non_ascii_char (str, len, 0))
 536
 537 /* This is like STRING_CHAR but the third arg ACTUAL_LEN is set to
 538    the length of the multi-byte form.  Just to know the length, use
 539    MULTIBYTE_FORM_LENGTH.  */
 540
 541 #define STRING_CHAR_AND_LENGTH(str, len, actual_len)            \
 542   ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1            \
 543     || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > (len))     \
 544    ? (actual_len = 1), (unsigned char) *(str)                   \
 545    : string_to_non_ascii_char (str, len, &actual_len))
 546
 547 /* Return the length of the multi-byte form at string STR of length LEN.  */
 548
 549 #define MULTIBYTE_FORM_LENGTH(str, len)                         \
 550   ((BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) == 1           \
 551     || BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) > (len))    \
 552    ? 1                                                          \
 553    : multibyte_form_length (str, len))
 554
 555 /* Set C a (possibly multibyte) character at P.  P points into a
 556    string which is the virtual concatenation of STR1 (which ends at
 557    END1) or STR2 (which ends at END2).  */
 558
 559 #define GET_CHAR_AFTER_2(c, p, str1, end1, str2, end2)                      \
 560   do {                                                                      \
 561     const char *dtemp = (p) == (end1) ? (str2) : (p);                       \
 562     const char *dlimit = ((p) >= (str1) && (p) < (end1)) ? (end1) : (end2); \
 563     c = STRING_CHAR (dtemp, dlimit - dtemp);                                \
 564   } while (0)
 565
 566 /* Set C a (possibly multibyte) character before P.  P points into a
 567    string which is the virtual concatenation of STR1 (which ends at
 568    END1) or STR2 (which ends at END2).  */
 569
 570 #define GET_CHAR_BEFORE_2(c, p, str1, end1, str2, end2)                     \
 571   do {                                                                      \
 572     const char *dtemp = (p);                                                \
 573     const char *dlimit = ((p) > (str2) && (p) <= (end2)) ? (str2) : (str1); \
 574     while (dtemp-- > dlimit && (unsigned char) *dtemp >= 0xA0);             \
 575     c = STRING_CHAR (dtemp, p - dtemp);                                     \
 576   } while (0)
 577
 578 #ifdef emacs
 579
 580 /* Increase the buffer point POS of the current buffer to the next
 581    character boundary.  This macro relies on the fact that *GPT_ADDR
 582    and *Z_ADDR are always accessible and the values are '\0'.  No
 583    range checking of POS.  */
 584 #define INC_POS(pos)                            \
 585   do {                                          \
 586     unsigned char *p = POS_ADDR (pos);          \
 587     pos++;                                      \
 588     if (*p++ >= 0x80)                           \
 589       while (!CHAR_HEAD_P (p)) p++, pos++;      \
 590   } while (0)
 591
 592 /* Decrease the buffer point POS of the current buffer to the previous
 593    character boundary.  No range checking of POS.  */
 594 #define DEC_POS(pos)                                            \
 595   do {                                                          \
 596     unsigned char *p, *p_min;                                   \
 597     int pos_saved = --pos;                                      \
 598     if (pos < GPT)                                              \
 599       p = BEG_ADDR + pos - 1, p_min = BEG_ADDR;                 \
 600     else                                                        \
 601       p = BEG_ADDR + GAP_SIZE + pos - 1, p_min = GAP_END_ADDR;  \
 602     while (p > p_min && !CHAR_HEAD_P (p)) p--, pos--;           \
 603     if (*p < 0x80 && pos != pos_saved) pos = pos_saved;         \
 604   } while (0)
 605
 606 #endif /* emacs */
 607
 608 /* Maximum counts of components in one composite character.  */
 609 #define MAX_COMPONENT_COUNT 16
 610
 611 /* Structure to hold information of a composite character.  */
 612 struct cmpchar_info {
 613   /* Byte length of the composite character.  */
 614   int len;
 615
 616   /* Multi-byte form of the composite character.  */
 617   unsigned char *data;
 618
 619   /* Length of glyph codes.  */
 620   int glyph_len;
 621
 622   /* Width of the overall glyph of the composite character.  */
 623   int width;
 624
 625   /* Pointer to an array of glyph codes of the composite character.
 626      This actually contains only character code, no face.  */
 627   GLYPH *glyph;
 628
 629   /* Pointer to an array of composition rules.  The value has the form:
 630         (0xA0 + ((GLOBAL-REF-POINT << 2) | NEW-REF-POINT))
 631      where each XXX-REF-POINT is 0..8.  */
 632   unsigned char *cmp_rule;
 633
 634   /* Pointer to an array of x-axis offset of left edge of glyphs
 635      relative to the left of of glyph[0] except for the first element
 636      which is the absolute offset from the left edge of overall glyph.
 637      The actual pixel offset should be calculated by multiplying each
 638      frame's one column width by this value:
 639         (i.e. FONT_WIDTH (f->output_data.x->font) * col_offset[N]).  */
 640   float *col_offset;
 641
 642   /* Work slot used by `dumpglyphs' (xterm.c).  */
 643   int face_work;
 644 };
 645
 646 /* Table of pointers to the structure `cmpchar_info' indexed by
 647    CMPCHAR-ID.  */
 648 extern struct cmpchar_info **cmpchar_table;
 649 /* Number of the current composite characters.  */
 650 extern int n_cmpchars;
 651
 652 /* This is the maximum length of multi-byte form.  */
 653 #define MAX_LENGTH_OF_MULTI_BYTE_FORM (MAX_COMPONENT_COUNT * 6)
 654
 655 /* Maximum character code currently used.  */
 656 #define MAX_CHAR (MIN_CHAR_COMPOSITION + n_cmpchars)
 657
 658 #endif /* _CHARSET_H */