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