src/charset.h

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