In this entry, just `Modified' means that codes for a

composite character is deleted.
(LEADING_CODE_COMPOSITION) (CHARSET_COMPOSITION)
(charset_composition) (MIN_CHAR_COMPOSITION)
(MAX_CHAR_COMPOSITION) (GENERIC_COMPOSITION_CHAR)
(COMPOSITE_CHAR_P) (MAKE_COMPOSITE_CHAR) (COMPOSITE_CHAR_ID)
(PARSE_COMPOSITE_SEQ) (PARSE_CHARACTER_SEQ): Deleted.
(MAX_CHAR) (CHARSET_VALID_P) (CHARSET_DEFINED_P) (CHARSET_AT)
(FIRST_CHARSET_AT) (SAME_CHARSET_P) (MAKE_NON_ASCII_CHAR)
(PARSE_MULTIBYTE_SEQ) (SPLIT_NON_ASCII_CHAR) (CHAR_PRINTABLE_P):
Modified.
(SPLIT_STRING): Call split_string, not split_non_ascii_string.
(CHAR_STRING): Delete WORKBUF argument.  Call char_string, not
non_ascii_char_to_string.
(STRING_CHAR): Call string_to_char, not string_to_non_ascii_char.
(STRING_CHAR_AND_LENGTH): Likewise.
(FETCH_CHAR_ADVANCE): New macro.
(MAX_COMPONENT_COUNT) (struct cmpchar_info): Deleted.
(MAX_MULTIBYTE_LENGTH): New macro.
(MAX_LENGTH_OF_MULTI_BYTE_FORM): Deleted.
(find_charset_in_str): Argument adjusted.
(CHAR_LEN): Modified.

1 files changed, 106 insertions, 255 deletions

diff --git a/src/charset.h b/src/charset.h
index ed5b3a7d2cf..c0b7e4d9eb4 100644
--- a/src/charset.h
+++ b/src/charset.h
@@ -1,4 +1,4 @@
-/* Header for multilingual character handler.
+/* Header for multibyte character handler.
    Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
    Licensed to the Free Software Foundation.
 
@@ -27,21 +27,20 @@ Boston, MA 02111-1307, USA.  */
   A character set ("charset" hereafter) is a meaningful collection
   (i.e. language, culture, functionality, etc) of characters.  Emacs
   handles multiple charsets at once.  Each charset corresponds to one
-  of ISO charsets (except for a special charset for composition
-  characters).  Emacs identifies a charset by a unique identification
-  number, whereas ISO identifies a charset by a triplet of DIMENSION,
-  CHARS and FINAL-CHAR.  So, hereafter, just saying "charset" means an
-  identification number (integer value).
+  of ISO charsets.  Emacs identifies a charset by a unique
+  identification number, whereas ISO identifies a charset by a triplet
+  of DIMENSION, CHARS and FINAL-CHAR.  So, hereafter, just saying
+  "charset" means an identification number (integer value).
 
-  The value range of charset is 0x00, 0x80..0xFE.  There are four
+  The value range of charset is 0x00, 0x81..0xFE.  There are four
   kinds of charset depending on DIMENSION (1 or 2) and CHARS (94 or
   96).  For instance, a charset of DIMENSION2_CHARS94 contains 94x94
-
+  characters.
 
   Within Emacs Lisp, a charset is treated as a symbol which has a
   property `charset'.  The property value is a vector containing
   various information about the charset.  For readability of C codes,
-  we use the following convention on C variable names:
+  we use the following convention for C variable names:
         charset_symbol: Emacs Lisp symbol of a charset
         charset_id: Emacs Lisp integer of an identification number of a charset
         charset: C integer of an identification number of a charset
@@ -55,7 +54,7 @@ Boston, MA 02111-1307, USA.  */
   character in Emacs' buffer and string.
 
   We call a charset which has extended leading-code as "private
-  charset" because those are mainly for a charset which is not
+  charset" because those are mainly for a charset which is not yet
   registered by ISO.  On the contrary, we call a charset which does
   not have extended leading-code as "official charset".
 
@@ -65,7 +64,7 @@ Boston, MA 02111-1307, USA.  */
   0x00          official dim1    -- none --             -- none --
                 (ASCII)
   0x01..0x7F    --never used--
-  0x80          COMPOSITION      same as charset        -- none --
+  0x80          --never used--
   0x81..0x8F    official dim1    same as charset        -- none --
   0x90..0x99    official dim2    same as charset        -- none --
   0x9A..0x9F    --never used--
@@ -80,20 +79,9 @@ Boston, MA 02111-1307, USA.  */
   0xFF          --never used--
   ---------------------------------------------------------------------------
 
-  In the table, "COMPOSITION" means a charset for a composite
-  character which is a character composed from several (up to 16)
-  non-composite characters (components).  Although a composite
-  character can contain components of many charsets, a composite
-  character itself belongs to the charset CHARSET-COMPOSITION.  See
-  the document "GENERAL NOTE on COMPOSITE CHARACTER" below for more
-  detail.
-
 */
 
 /* Definition of special leading-codes.  */
-/* Base leading-code.  */
-/* Special leading-code followed by components of a composite character.  */
-#define LEADING_CODE_COMPOSITION        0x80
 /* Leading-code followed by extended leading-code.  */
 #define LEADING_CODE_PRIVATE_11 0x9A /* for private DIMENSION1 of 1-column */
 #define LEADING_CODE_PRIVATE_12 0x9B /* for private DIMENSION1 of 2-column */
@@ -122,10 +110,8 @@ Boston, MA 02111-1307, USA.  */
 
 /* Definition of special charsets.  */
 #define CHARSET_ASCII           0
-#define CHARSET_COMPOSITION     0x80
 
 extern int charset_ascii;       /* ASCII */
-extern int charset_composition; /* for a composite character */
 extern int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */
 extern int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */
 extern int charset_jisx0208;    /* JISX0208.1983 (Japanese Kanji) */
@@ -194,35 +180,6 @@ extern int charset_big5_2;	/* Big5 Level 2 (Chinese Traditional) */
 
 */
 
-/*** GENERAL NOTE on COMPOSITE CHARACTER ***
-
-  A composite character is a character composed from several (up to
-  16) non-composite characters (components).  Although each component
-  can belong to any charset, a composite character itself belongs to
-  the charset `charset-composition' and is assigned a special
-  leading-code `LEADING_CODE_COMPOSITION' for multi-byte form.  See
-  the document "2. Emacs internal format handlers" in `coding.c' for
-  more detail about multi-byte form.
-
-  A character code of composite character has special format.  In the
-  above document, FIELD1 of a composite character is 0x1F.  Each
-  composite character is assigned a sequential number CMPCHAR-ID.
-  FIELD2 and FIELD3 are combined to make 14bits field for holding
-  CMPCHAR-ID, which means that Emacs can handle at most 2^14 (= 16384)
-  composite characters at once.
-
-  -----------------------------------------------------------------------
-  charset               FIELD1 (5-bit)      FIELD2&3 (14-bit)
-  -----------------------------------------------------------------------
-  CHARSET-COMPOSITION   0x1F                CMPCHAR-ID
-  -----------------------------------------------------------------------  
-
-  Emacs assigns CMPCHAR-ID to a composite character only when it
-  requires the character code of the composite character (e.g. while
-  displaying the composite character).
-
-*/
-
 /* Masks of each field of character code.  */
 #define CHAR_FIELD1_MASK (0x1F << 14)
 #define CHAR_FIELD2_MASK (0x7F << 7)
@@ -242,17 +199,11 @@ extern int charset_big5_2;	/* Big5 Level 2 (Chinese Traditional) */
   ((MIN_CHARSET_OFFICIAL_DIMENSION2 - 0x8F) << 14)
 #define MIN_CHAR_PRIVATE_DIMENSION2 \
   ((MIN_CHARSET_PRIVATE_DIMENSION2 - 0xE0) << 14)
-#define MIN_CHAR_COMPOSITION \
-  (0x1F << 14)
-#define MAX_CHAR_COMPOSITION (GLYPH_MASK_CHAR - 1)
-
-/* A generic character for composition characters.  */
-#define GENERIC_COMPOSITION_CHAR (GLYPH_MASK_CHAR)
+/* Maximum character code currently used plus 1.  */
+#define MAX_CHAR (0x1F << 14)
 
 /* 1 if C is an ASCII character, else 0.  */
 #define SINGLE_BYTE_CHAR_P(c) ((c) >= 0 && (c) < 0x100)
-/* 1 if C is an composite character, else 0.  */
-#define COMPOSITE_CHAR_P(c) ((c) >= MIN_CHAR_COMPOSITION)
 
 /* 1 if BYTE is a character in itself, in multibyte mode.  */
 #define ASCII_BYTE_P(byte) ((byte) < 0x80)
@@ -379,10 +330,10 @@ extern Lisp_Object Vcharset_symbol_table;
 /* 1 if CHARSET is in valid value range, else 0.  */
 #define CHARSET_VALID_P(charset)                                         \
   ((charset) == 0                                                        \
-   || ((charset) >= 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
+   || ((charset) > 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
    || ((charset) >= MIN_CHARSET_PRIVATE_DIMENSION1 && (charset) <= MAX_CHARSET))
 
-/* 1 if CHARSET is already defined (and not CHARSET_COMPOSITION), else 0.  */
+/* 1 if CHARSET is already defined, else 0.  */
 #define CHARSET_DEFINED_P(charset)                      \
   (((charset) >= 0) && ((charset) <= MAX_CHARSET)       \
    && !NILP (CHARSET_TABLE_ENTRY (charset)))
@@ -406,67 +357,47 @@ extern int width_by_char_head[256];
       ? CHAR_FIELD2 (c) + 0x70                  \
       : ((c) < MIN_CHAR_PRIVATE_DIMENSION2      \
          ? CHAR_FIELD1 (c) + 0x8F               \
-         : ((c) < MIN_CHAR_COMPOSITION          \
-            ? CHAR_FIELD1 (c) + 0xE0            \
-            : ((c) <= MAX_CHAR_COMPOSITION      \
-               ? CHARSET_COMPOSITION            \
-               : CHARSET_ASCII)))))
+         : CHAR_FIELD1 (c) + 0xE0)))
 
 /* Return charset at the place pointed by P.  */
-#define CHARSET_AT(p)                           \
-  (*(p) < 0x80                                  \
-   ? CHARSET_ASCII                              \
-   : (*(p) == LEADING_CODE_COMPOSITION          \
-      ? CHARSET_COMPOSITION                     \
-      : (*(p) < LEADING_CODE_PRIVATE_11         \
-         ? (int)*(p)                            \
-         : (*(p) <= LEADING_CODE_PRIVATE_22     \
-            ? (int)*((p) + 1)                   \
-            : -1))))
+#define CHARSET_AT(p)                           \
+  (*(p) < 0x80                                  \
+   ? CHARSET_ASCII                              \
+   : (*(p) < LEADING_CODE_PRIVATE_11            \
+      ? (int)*(p)                               \
+      : (*(p) <= LEADING_CODE_PRIVATE_22        \
+         ? (int)*((p) + 1)                      \
+         : -1)))
 
 /* Same as `CHARSET_AT ()' but perhaps runs faster because of an
    additional argument C which is the code (byte) at P.  */
-#define FIRST_CHARSET_AT(p, c)                  \
-  ((c) < 0x80                                   \
-   ? CHARSET_ASCII                              \
-   : ((c) == LEADING_CODE_COMPOSITION           \
-      ? CHARSET_COMPOSITION                     \
-      : ((c) < LEADING_CODE_PRIVATE_11          \
-         ? (int)(c)                             \
-         : ((c) <= LEADING_CODE_PRIVATE_22      \
-            ? (int)*((p) + 1)                   \
-            : -1))))
-
-/* Check if two characters C1 and C2 belong to the same charset.
-   Always return 0 for composite characters.  */
-#define SAME_CHARSET_P(c1, c2)                                  \
-  (c1 < MIN_CHAR_COMPOSITION                                    \
-   && (SINGLE_BYTE_CHAR_P (c1)                                  \
-       ? SINGLE_BYTE_CHAR_P (c2)                                \
-       : (c1 < MIN_CHAR_OFFICIAL_DIMENSION2                     \
-          ? (c1 & CHAR_FIELD2_MASK) == (c2 & CHAR_FIELD2_MASK)  \
-          : (c1 & CHAR_FIELD1_MASK) == (c2 & CHAR_FIELD1_MASK))))
+#define FIRST_CHARSET_AT(p, c)          \
+  ((c) < 0x80                           \
+   ? CHARSET_ASCII                      \
+   : ((c) < LEADING_CODE_PRIVATE_11     \
+      ? (int)(c)                        \
+      : ((c) <= LEADING_CODE_PRIVATE_22 \
+         ? (int)*((p) + 1)              \
+         : -1)))
+
+/* Check if two characters C1 and C2 belong to the same charset.  */
+#define SAME_CHARSET_P(c1, c2)                                  \
+  (SINGLE_BYTE_CHAR_P (c1)                                      \
+   ? SINGLE_BYTE_CHAR_P (c2)                                    \
+   : (c1 < MIN_CHAR_OFFICIAL_DIMENSION2                         \
+      ? (c1 & CHAR_FIELD2_MASK) == (c2 & CHAR_FIELD2_MASK)      \
+      : (c1 & CHAR_FIELD1_MASK) == (c2 & CHAR_FIELD1_MASK)))
 
 /* Return a non-ASCII character of which charset is CHARSET and
    position-codes are C1 and C2.  DIMENSION1 character ignores C2.  */
 #define MAKE_NON_ASCII_CHAR(charset, c1, c2)                            \
-  ((charset) == CHARSET_COMPOSITION                                     \
-   ? ((c2) < 0                                                          \
-      ? (((charset) - 0x70) << 7) + (c1)                                \
-      : MAKE_COMPOSITE_CHAR (((c1) << 7) + (c2)))                       \
-   : (! CHARSET_DEFINED_P (charset) || CHARSET_DIMENSION (charset) == 1 \
-      ? (((charset) - 0x70) << 7) | ((c1) <= 0 ? 0 : (c1))              \
-      : ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2                     \
-         ? ((((charset) - 0x8F) << 14)                                  \
-            | ((c1) <= 0 ? 0 : ((c1) << 7)) | ((c2) <= 0 ? 0 : (c2)))   \
-         : ((((charset) - 0xE0) << 14)                                  \
-            | ((c1) <= 0 ? 0 : ((c1) << 7)) | ((c2) <= 0 ? 0 : (c2))))))
-
-/* Return a composite character of which CMPCHAR-ID is ID.  */
-#define MAKE_COMPOSITE_CHAR(id) (MIN_CHAR_COMPOSITION + (id))
-
-/* Return CMPCHAR-ID of a composite character C.  */
-#define COMPOSITE_CHAR_ID(c) ((c) - MIN_CHAR_COMPOSITION)
+  (! CHARSET_DEFINED_P (charset) || CHARSET_DIMENSION (charset) == 1    \
+   ? (((charset) - 0x70) << 7) | ((c1) <= 0 ? 0 : (c1))                 \
+   : ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2                        \
+      ? ((((charset) - 0x8F) << 14)                                     \
+         | ((c1) <= 0 ? 0 : ((c1) << 7)) | ((c2) <= 0 ? 0 : (c2)))      \
+      : ((((charset) - 0xE0) << 14)                                     \
+         | ((c1) <= 0 ? 0 : ((c1) << 7)) | ((c2) <= 0 ? 0 : (c2)))))
 
 /* Return a character of which charset is CHARSET and position-codes
    are C1 and C2.  DIMENSION1 character ignores C2.  */
@@ -488,41 +419,6 @@ extern int width_by_char_head[256];
 
 #define DEFAULT_NONASCII_INSERT_OFFSET 0x800
 
-/* Parse composite character string STR of length LENGTH (>= 2) and
-   set BYTES to the length of actual multibyte sequence.
-
-   It is assumed that *STR is LEADING_CODE_COMPOSITION and the
-   following (LENGTH - 1) bytes satisfy !CHAR_HEAD_P.
-
-   Actually, the whole multibyte sequence starting with
-   LEADING_CODE_COMPOSITION is treated as a single multibyte
-   character.  So, here, we just set BYTES to LENGTH.
-
-   This macro should be called only from PARSE_MULTIBYTE_SEQ.  */
-
-#define PARSE_COMPOSITE_SEQ(str, length, bytes) \
-  do {                                          \
-    (bytes) = (length);                         \
-  } while (0)
-
-
-/* Parse non-composite multibyte character string STR of length
-   LENGTH (>= 2) and set BYTES to the length of actual multibyte
-   sequence.
-
-   It is assumed that *STR is one of base leading codes (excluding
-   LEADING_CODE_COMPOSITION) and the following (LENGTH - 1) bytes
-   satisfy !CHAR_HEAD_P.
-
-   This macro should be called only from PARSE_MULTIBYTE_SEQ.  */
-
-#define PARSE_CHARACTER_SEQ(str, length, bytes) \
-  do {                                          \
-    (bytes) = BYTES_BY_CHAR_HEAD ((str)[0]);    \
-    if ((bytes) > (length))                     \
-      (bytes) = (length);                       \
-  } while (0)
-
 /* Parse string STR of length LENGTH and check if a multibyte
    characters is at STR.  If so, set BYTES for that character, else
    set BYTES to 1.  */
@@ -530,17 +426,14 @@ extern int width_by_char_head[256];
 #define PARSE_MULTIBYTE_SEQ(str, length, bytes)                 \
   do {                                                          \
     int i = 1;                                                  \
-    if (ASCII_BYTE_P (*str))                                    \
-      bytes = 1;                                                \
+    while (i < (length) && ! CHAR_HEAD_P ((str)[i])) i++;       \
+    if (i == 1)                                                 \
+      (bytes) = 1;                                              \
     else                                                        \
       {                                                         \
-        while (i < (length) && ! CHAR_HEAD_P ((str)[i])) i++;   \
-        if (i == 1)                                             \
-          (bytes) = 1;                                          \
-        else if ((str)[0] == LEADING_CODE_COMPOSITION)          \
-          PARSE_COMPOSITE_SEQ (str, i, bytes);                  \
-        else                                                    \
-          PARSE_CHARACTER_SEQ (str, i, bytes);                  \
+        (bytes) = BYTES_BY_CHAR_HEAD ((str)[0]);                \
+        if ((bytes) > (length))                                 \
+          (bytes) = (length);                                   \
       }                                                         \
   } while (0)
 
@@ -550,16 +443,14 @@ extern int width_by_char_head[256];
 
    Do not use this macro for an ASCII character.  */
 
-#define SPLIT_NON_ASCII_CHAR(c, charset, c1, c2)                         \
-  ((c) & CHAR_FIELD1_MASK                                                \
-   ? (charset = ((c) < MIN_CHAR_COMPOSITION                              \
-                 ? (CHAR_FIELD1 (c)                                      \
-                    + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)) \
-                 : CHARSET_COMPOSITION),                                 \
-      c1 = CHAR_FIELD2 (c),                                              \
-      c2 = CHAR_FIELD3 (c))                                              \
-   : (charset = CHAR_FIELD2 (c) + 0x70,                                  \
-      c1 = CHAR_FIELD3 (c),                                              \
+#define SPLIT_NON_ASCII_CHAR(c, charset, c1, c2)                        \
+  ((c) & CHAR_FIELD1_MASK                                               \
+   ? (charset = (CHAR_FIELD1 (c)                                        \
+                 + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)),  \
+      c1 = CHAR_FIELD2 (c),                                             \
+      c2 = CHAR_FIELD3 (c))                                             \
+   : (charset = CHAR_FIELD2 (c) + 0x70,                                 \
+      c1 = CHAR_FIELD3 (c),                                             \
       c2 = -1))
 
 /* The charset of character C is stored in CHARSET, and the
@@ -572,25 +463,19 @@ extern int width_by_char_head[256];
    : SPLIT_NON_ASCII_CHAR (c, charset, c1, c2))
 
 /* Return 1 iff character C has valid printable glyph.  */
-#define CHAR_PRINTABLE_P(c)             \
-  (SINGLE_BYTE_CHAR_P (c)               \
-   || ((c) >= MIN_CHAR_COMPOSITION      \
-       ? (c) < MAX_CHAR                 \
-       : char_printable_p (c)))
+#define CHAR_PRINTABLE_P(c)     \
+  (SINGLE_BYTE_CHAR_P (c)       \
+   || char_printable_p (c))
 
 /* The charset of the character at STR is stored in CHARSET, and the
    position-codes are stored in C1 and C2.
-   We store -1 in C2 if the character is just 2 bytes.
-
-   If the character is a composite character, the upper 7-bit and
-   lower 7-bit of CMPCHAR-ID are set in C1 and C2 respectively.  No
-   range checking.  */
+   We store -1 in C2 if the character is just 2 bytes.  */
 
-#define SPLIT_STRING(str, len, charset, c1, c2)                         \
-  ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2                     \
-    || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len                \
-    || split_non_ascii_string (str, len, &charset, &c1, &c2) < 0)       \
-   ? c1 = *(str), charset = CHARSET_ASCII                               \
+#define SPLIT_STRING(str, len, charset, c1, c2)                 \
+  ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2             \
+    || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len        \
+    || split_string (str, len, &charset, &c1, &c2) < 0)         \
+   ? c1 = *(str), charset = CHARSET_ASCII                       \
    : charset)
 
 /* Mapping table from ISO2022's charset (specified by DIMENSION,
@@ -612,16 +497,15 @@ extern int iso_charset_table[2][2][128];
    representations: multi-byte form and single-word form (character
    code).  */
 
-/* Set STR a pointer to the multi-byte form of the character C.  If C
-   is not a composite character, the multi-byte form is set in WORKBUF
-   and STR points WORKBUF.  The caller should allocate at least 4-byte
-   area at WORKBUF in advance.  Returns the length of the multi-byte
-   form.  If C is an invalid character code, signal an error.  */
+/* Store multi-byte form of the character C in STR.  The caller should
+   allocate at least 4-byte area at STR in advance.  Returns the
+   length of the multi-byte form.  If C is an invalid character code,
+   signal an error.  */
 
-#define CHAR_STRING(c, workbuf, str)                    \
-  (SINGLE_BYTE_CHAR_P (c)                               \
-   ? *(str = workbuf) = (unsigned char)(c), 1           \
-   : non_ascii_char_to_string (c, workbuf, (unsigned char **)&str))
+#define CHAR_STRING(c, str)             \
+  (SINGLE_BYTE_CHAR_P (c)               \
+   ? *(str) = (unsigned char)(c), 1     \
+   : char_to_string (c, (unsigned char *)str))
 
 /* Return a character code of the character of which multi-byte form
    is at STR and the length is LEN.  If STR doesn't contain valid
@@ -630,7 +514,7 @@ extern int iso_charset_table[2][2][128];
 #define STRING_CHAR(str, len)                           \
   (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1     \
    ? (unsigned char) *(str)                             \
-   : string_to_non_ascii_char (str, len, 0))
+   : string_to_char (str, len, 0))
 
 /* This is like STRING_CHAR but the third arg ACTUAL_LEN is set to the
    length of the multi-byte form.  Just to know the length, use
@@ -639,7 +523,7 @@ extern int iso_charset_table[2][2][128];
 #define STRING_CHAR_AND_LENGTH(str, len, actual_len)    \
   (BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1     \
    ? ((actual_len) = 1), (unsigned char) *(str)         \
-   : string_to_non_ascii_char (str, len, &(actual_len)))
+   : string_to_char (str, len, &(actual_len)))
 
 /* Fetch the "next" multibyte character from Lisp string STRING
    at byte position BYTEIDX, character position CHARIDX.
@@ -665,6 +549,26 @@ if (1)									      \
   }                                                                           \
 else
 
+/* Like FETCH_STRING_CHAR_SPACE_LEFT but fetch character from the
+   current buffer.  */
+
+#define FETCH_CHAR_ADVANCE(OUTPUT, CHARIDX, BYTEIDX)                      \
+if (1)                                                                    \
+  {                                                                       \
+    unsigned char *fetch_buf_char_ptr = BYTE_POS_ADDR (BYTEIDX);          \
+    int fetch_buf_char_space_left = ((CHARIDX < GPT ? GPT_BYTE : Z_BYTE)  \
+                                       - BYTEIDX);                        \
+    int actual_len;                                                       \
+                                                                          \
+    OUTPUT                                                                \
+        = STRING_CHAR_AND_LENGTH (fetch_buf_char_ptr,                     \
+                                  fetch_buf_char_space_left, actual_len); \
+                                                                          \
+    BYTEIDX += actual_len;                                                \
+    CHARIDX++;                                                            \
+  }                                                                       \
+else
+
 /* Return the length of the multi-byte form at string STR of length LEN.  */
 
 #define MULTIBYTE_FORM_LENGTH(str, len)                 \
@@ -812,70 +716,21 @@ while (0)
 
 #endif /* emacs */
 
-/* Maximum counts of components in one composite character.  */
-#define MAX_COMPONENT_COUNT 16
-
-/* Structure to hold information of a composite character.  */
-struct cmpchar_info {
-  /* Byte length of the composite character.  */
-  int len;
-
-  /* Multi-byte form of the composite character.  */
-  unsigned char *data;
-
-  /* Length of glyph codes.  */
-  int glyph_len;
-
-  /* Width of the overall glyph of the composite character.  */
-  int width;
-
-  /* Pointer to an array of glyph codes of the composite character.
-     This actually contains only character code, no face.  */
-  GLYPH *glyph;
-
-  /* Pointer to an array of composition rules.  The value has the form:
-        (0xA0 + ((GLOBAL-REF-POINT << 2) | NEW-REF-POINT))
-     where each XXX-REF-POINT is 0..8.  */
-  unsigned char *cmp_rule;
-
-  /* Pointer to an array of x-axis offset of left edge of glyphs
-     relative to the left of of glyph[0] except for the first element
-     which is the absolute offset from the left edge of overall glyph.
-     The actual pixel offset should be calculated by multiplying each
-     frame's one column width by this value:
-        (i.e. FONT_WIDTH (f->output_data.x->font) * col_offset[N]).  */
-  float *col_offset;
-
-  /* Work slot used by `dumpglyphs' (xterm.c).  */
-  int face_work;
-};
-
-/* Table of pointers to the structure `cmpchar_info' indexed by
-   CMPCHAR-ID.  */
-extern struct cmpchar_info **cmpchar_table;
-/* Number of the current composite characters.  */
-extern int n_cmpchars;
-
-/* This is the maximum length of multi-byte form.  */
-#define MAX_LENGTH_OF_MULTI_BYTE_FORM (MAX_COMPONENT_COUNT * 6)
-
-/* Maximum character code currently used.  */
-#define MAX_CHAR (MIN_CHAR_COMPOSITION + n_cmpchars)
+/* This is the maximum byte length of multi-byte sequence.  */
+#define MAX_MULTIBYTE_LENGTH 4
 
 extern void invalid_character P_ ((int));
 
 extern int translate_char P_ ((Lisp_Object, int, int, int, int));
-extern int split_non_ascii_string P_ ((const unsigned char *, int, int *,
+extern int split_string P_ ((const unsigned char *, int, int *,
                                        unsigned char *, unsigned char *));
-extern int string_to_non_ascii_char P_ ((const unsigned char *, int, int *));
-extern int non_ascii_char_to_string P_ ((int, unsigned char *, unsigned char **));
+extern int char_to_string P_ ((int, unsigned char *));
+extern int string_to_char P_ ((const unsigned char *, int, int *));
 extern int char_printable_p P_ ((int c));
 extern int multibyte_form_length P_ ((const unsigned char *, int));
-extern int str_cmpchar_id P_ ((const unsigned char *, int));
 extern int get_charset_id P_ ((Lisp_Object));
-extern int cmpchar_component P_ ((int, int, int));
 extern int find_charset_in_str P_ ((unsigned char *, int, int *,
-                                    Lisp_Object, int, int));
+                                    Lisp_Object, int));
 extern int strwidth P_ ((unsigned char *, int));
 extern int char_bytes P_ ((int));
 extern int char_valid_p P_ ((int, int));
@@ -902,10 +757,6 @@ extern Lisp_Object Vauto_fill_chars;
 
 /* Length of C in bytes.  */
 
-#define CHAR_LEN(C)                                     \
-     (CHAR_CHARSET ((C)) == CHARSET_COMPOSITION         \
-      ? cmpchar_table[COMPOSITE_CHAR_ID ((C))]->len     \
-      : CHARSET_BYTES (CHAR_CHARSET ((C))))
-
+#define CHAR_LEN(C) CHARSET_BYTES (CHAR_CHARSET ((C)))
 
 #endif /* _CHARSET_H */