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