zeroc-ice 3.6b1

data/ext/ice/mcpp/mbchar.c

@@ -0,0 +1,869 @@
+/*-
+ * Copyright (c) 1998, 2002-2008 Kiyoshi Matsui <kmatsui@t3.rim.or.jp>
+ * All rights reserved.
+ *
+ * Some parts of this code are derived from the public domain software
+ * DECUS cpp (1984,1985) written by Martin Minow.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ *                          M B C H A R . C
+ *      C h a r a c t e r    h a n d l i n g    R o u t i n e s
+ *
+ * Character handling and multi-byte character handling routines are
+ * placed here.
+ */
+
+#if PREPROCESSED
+#include    "mcpp.H"
+#else
+#include    "system.H"
+#include    "internal.H"
+#endif
+
+/*
+ * Tables of character types and multi-byte character types.
+ *
+ * Some of these character attributes will be overwritten by
+ *      execution time option '-@post' or '-@old'.
+ * Warning on erroneous sequence will be issued from the caller routines:
+ * scan_quote(), scan_id() or scan_number().
+ */
+
+/* Non-ASCII characters are always checked by mb_read().    */
+#define NA      0x4000  /* Non-ASCII characters */
+
+/* Horizontal spaces (' ', '\t' and TOK_SEP)    */
+#define HSPA    (SPA | HSP)
+
+short *     char_type;  /* Pointer to one of the following type_*[].    */
+
+#define EJ1     0x100   /* 1st byte of EUC_JP   */
+#define EJ2     0x200   /* 2nd byte of EUC_JP   */
+#define GB1     0x400   /* 1st byte of GB2312   */
+#define GB2     0x800   /* 2nd byte of GB2312   */
+#define KS1     0x1000  /* 1st byte of KSC5601  */
+#define KS2     0x2000  /* 2nd byte of KSC5601  */
+
+#define EJ12    (EJ1 | EJ2)     /* 1st byte or 2nd byte of EUC_JP   */
+#define GB12    (GB1 | GB2)
+#define KS12    (KS1 | KS2)
+#define EJ1N    (NA | EJ1)
+#define EU12N   (NA | EJ12 | GB12 | KS12)
+    /* 1st or 2nd byte of EUC_JP, GB2312 or KSC5601, or any other non-ASCII */
+
+static short    type_euc[ UCHARMAX + 1] = {
+/*
+ * For EUC_JP, GB2312, KSC5601 or other similar multi-byte char encodings.
+ */
+
+/* Character type codes */
+/*   0,     1,     2,     3,     4,     5,     6,     7,                    */
+/*   8,     9,     A,     B,     C,     D,     E,     F,       Hex          */
+
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 00           */
+   000,   HSPA,  SPA,   SPA,   SPA,   SPA,   000,   000,    /* 08           */
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 10           */
+    /* 0x17-0x1A and 0x1F will be cleared in some modes by chk_opts()       */
+   000,   LET,   LET,   000,   000,   000,   000,   HSPA,   /* 18           */
+   HSPA,  PUNC,  QUO,   PUNC,  000,   PUNC,  PUNC,  QUO,    /* 20  !"#$%&'  */
+   PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  DOT,   PUNC,   /* 28 ()*+,-./  */
+   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,    /* 30 01234567  */
+   DIG,   DIG,   PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  PUNC,   /* 38 89:;<=>?  */
+
+   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 40 @ABCDEFG  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 48 HIJKLMNO  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 50 PQRSTUVW  */
+   LET,   LET,   LET,   PUNC,  000,   PUNC,  PUNC,  LET,    /* 58 XYZ[\]^_  */
+   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 60 `abcdefg  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 68 hijklmno  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 70 pqrstuvw  */
+   LET,   LET,   LET,   PUNC,  PUNC,  PUNC,  PUNC,  000,    /* 78 xyz{|}~   */
+
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   80 .. 87   */
+   NA,    NA,    NA,    NA,    NA,    NA,    EJ1N,  NA,     /*   88 .. 8F   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   90 .. 97   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   98 .. 9F   */
+   NA,    EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   A0 .. A7   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   A8 .. AF   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   B0 .. B7   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   B8 .. BF   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   C0 .. C7   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   C8 .. CF   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   D0 .. D7   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   D8 .. DF   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   E0 .. E7   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   E8 .. EF   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N,  /*   F0 .. F7   */
+   EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, EU12N, NA,     /*   F8 .. FF   */
+};
+
+static short    type_bsl[ UCHARMAX + 1] = {
+/*
+ * For SJIS, BIGFIVE or other similar encodings which may have '\\' value as
+ * the second byte of multi-byte character.
+ */
+
+#define SJ1     0x100   /* 1st byte of SJIS     */
+#define SJ2     0x200   /* 2nd byte of SJIS     */
+#define BF1     0x400   /* 1st byte of BIGFIVE  */
+#define BF2     0x800   /* 2nd byte of BIGFIVE  */
+
+#define SB2     (SJ2 | BF2)
+#define SJ2N    (NA | SJ2)
+#define SB2N    (NA | SJ2 | BF2)
+#define SJ12N   (NA | SJ1 | SJ2)
+#define BF12N   (NA | BF1 | BF2)
+#define SB12N   (NA | SJ1 | SJ2 | BF1 | BF2)
+#define S2B12N  (NA | SJ2 | BF1 | BF2)
+
+#define LSB2    (LET | SB2)
+#define PSB2    (PUNC| SB2)
+
+/* Character type codes */
+/*   0,     1,     2,     3,     4,     5,     6,     7,                    */
+/*   8,     9,     A,     B,     C,     D,     E,     F,       Hex          */
+
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 00           */
+   000,   HSPA,  SPA,   SPA,   SPA,   SPA,   000,   000,    /* 08           */
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 10           */
+    /* 0x17-0x1A and 0x1F will be cleared in some modes by chk_opts()       */
+   000,   LET,   LET,   000,   000,   000,   000,   HSPA,   /* 18           */
+   HSPA,  PUNC,  QUO,   PUNC,  000,   PUNC,  PUNC,  QUO,    /* 20  !"#$%&'  */
+   PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  DOT,   PUNC,   /* 28 ()*+,-./  */
+   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,    /* 30 01234567  */
+   DIG,   DIG,   PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  PUNC,   /* 38 89:;<=>?  */
+
+   SB2,   LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,   /* 40 @ABCDEFG  */
+   LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,   /* 48 HIJKLMNO  */
+   LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,   /* 50 PQRSTUVW  */
+   LSB2,  LSB2,  LSB2,  PSB2,  SB2,   PSB2,  PSB2,  LSB2,   /* 58 XYZ[\]^_  */
+   SB2,   LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,   /* 60 `abcdefg  */
+   LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,   /* 68 hijklmno  */
+   LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,  LSB2,   /* 70 pqrstuvw  */
+   LSB2,  LSB2,  LSB2,  PSB2,  PSB2,  PSB2,  PSB2,  000,    /* 78 xyz{|}~   */
+
+   SB2N,  SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N,  /*   80 .. 87   */
+   SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N,  /*   88 .. 8F   */
+   SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N,  /*   90 .. 97   */
+   SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N, SJ12N,  /*   98 .. 9F   */
+   SJ2N,  S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   A0 .. A7   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   A8 .. AF   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   B0 .. B7   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   B8 .. BF   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   C0 .. C7   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   C8 .. CF   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   D0 .. D7   */
+   S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N,S2B12N, /*   D8 .. DF   */
+   SB12N, SB12N, SB12N, SB12N, SB12N, SB12N, SB12N, SB12N,  /*   E0 .. E7   */
+   SB12N, SB12N, SB12N, SB12N, SB12N, SB12N, SB12N, SB12N,  /*   E8 .. EF   */
+   SB12N, SB12N, SB12N, SB12N, SB12N, SB12N, SB12N, SB12N,  /*   F0 .. F7   */
+   SB12N, SB12N, SB12N, SB12N, SB12N, BF12N, BF12N, NA,     /*   F8 .. FF   */
+};
+
+/*
+ * For ISO2022_JP multi-byte character encoding.
+ */
+
+#define IS1     0x100   /* 1st byte of shift-sequence   */
+#define IS2     0x200   /* 2nd byte of shift-sequence   */
+#define IS3     0x400   /* 3rd byte of shift-sequence   */
+#define IS4     0x800   /* 4th byte of shift-sequence   */
+#define IJP     0x1000  /* 1st or 2nd byte of ISO-2022-JP (ISO-2022-JP1)    */
+
+#define PIJP    (PUNC | IJP)
+#define QIJP    (QUO | IJP)
+#define DTJP    (DOT | IJP)
+#define DGJP    (DIG | IJP)
+#define LIJP    (LET | IJP)
+
+#define JPS2    (IJP | IS2)
+#define PJPS23  (PIJP | IS2 | IS3)
+#define LJPS3   (LIJP | IS3)
+#define LJPS4   (LIJP | IS4)
+
+static short    type_iso2022_jp[ UCHARMAX + 1] = {
+
+/* Character type codes */
+/*   0,     1,     2,     3,     4,     5,     6,     7,                    */
+/*   8,     9,     A,     B,     C,     D,     E,     F,       Hex          */
+
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 00           */
+   000,   HSPA,  SPA,   SPA,   SPA,   SPA,   000,   000,    /* 08           */
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 10           */
+    /* 0x17-0x1A and 0x1F will be cleared in some modes by chk_opts()       */
+   000,   LET,   LET,   IS1,   000,   000,   000,   HSPA,   /* 18           */
+   HSPA,  PIJP,  QIJP,  PIJP,  JPS2,  PIJP,  PIJP,  QIJP,   /* 20  !"#$%&'  */
+   PJPS23,PIJP,  PIJP,  PIJP,  PIJP,  PIJP,  DTJP,  PIJP,   /* 28 ()*+,-./  */
+   DGJP,  DGJP,  DGJP,  DGJP,  DGJP,  DGJP,  DGJP,  DGJP,   /* 30 01234567  */
+   DGJP,  DGJP,  PIJP,  PIJP,  PIJP,  PIJP,  PIJP,  PIJP,   /* 38 89:;<=>?  */
+
+   IJP,   LIJP,  LJPS3, LIJP,  LJPS4, LIJP,  LIJP,  LIJP,   /* 40 @ABCDEFG  */
+   LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,   /* 48 HIJKLMNO  */
+   LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,   /* 50 PQRSTUVW  */
+   LIJP,  LIJP,  LIJP,  PIJP,  IJP,   PIJP,  PIJP,  LIJP,   /* 58 XYZ[\]^_  */
+   IJP,   LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,   /* 60 `abcdefg  */
+   LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,   /* 68 hijklmno  */
+   LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,  LIJP,   /* 70 pqrstuvw  */
+   LIJP,  LIJP,  LIJP,  PIJP,  PIJP,  PIJP,  PIJP,  000,    /* 78 xyz{|}~   */
+
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   80 .. 87   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   88 .. 8F   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   90 .. 97   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   98 .. 9F   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   A0 .. A7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   A8 .. AF   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   B0 .. B7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   B8 .. BF   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   C0 .. C7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   C8 .. CF   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   D0 .. D7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   D8 .. DF   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   E0 .. E7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   E8 .. EF   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   F0 .. F7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   F8 .. FF   */
+};
+
+/*
+ * For UTF8 multi-byte character encoding.
+ */
+
+#define U2_1    0x100       /* 1st byte of 2-byte encoding of UTF8  */
+#define U3_1    0x200       /* 1st byte of 3-byte encoding of UTF8  */
+#define U4_1    0x400       /* 1st byte of 4-byte encoding of UTF8  */
+#define UCONT   0x800   /* Continuation of a 2, 3, or 4 byte UTF8 sequence  */
+#define U2_1N   (NA | U2_1)
+#define U3_1N   (NA | U3_1)
+#define U4_1N   (NA | U4_1)
+#define UCONTN  (NA | UCONT)
+
+static short    type_utf8[ UCHARMAX + 1] = {
+
+/* Character type codes */
+/*   0,     1,     2,     3,     4,     5,     6,     7,                    */
+/*   8,     9,     A,     B,     C,     D,     E,     F,       Hex          */
+
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 00           */
+   000,   HSPA,  SPA,   SPA,   SPA,   SPA,   000,   000,    /* 08           */
+   000,   000,   000,   000,   000,   000,   000,   000,    /* 10           */
+    /* 0x17-0x1A and 0x1F will be cleared in some modes by chk_opts()       */
+   000,   LET,   LET,   000,   000,   000,   000,   HSPA,   /* 18           */
+   HSPA,  PUNC,  QUO,   PUNC,  000,   PUNC,  PUNC,  QUO,    /* 20  !"#$%&'  */
+   PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  DOT,   PUNC,   /* 28 ()*+,-./  */
+   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,   DIG,    /* 30 01234567  */
+   DIG,   DIG,   PUNC,  PUNC,  PUNC,  PUNC,  PUNC,  PUNC,   /* 38 89:;<=>?  */
+
+   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 40 @ABCDEFG  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 48 HIJKLMNO  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 50 PQRSTUVW  */
+   LET,   LET,   LET,   PUNC,  000,   PUNC,  PUNC,  LET,    /* 58 XYZ[\]^_  */
+   000,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 60 `abcdefg  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 68 hijklmno  */
+   LET,   LET,   LET,   LET,   LET,   LET,   LET,   LET,    /* 70 pqrstuvw  */
+   LET,   LET,   LET,   PUNC,  PUNC,  PUNC,  PUNC,  000,    /* 78 xyz{|}~   */
+
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   80 .. 87   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   88 .. 8F   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   90 .. 97   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   98 .. 9F   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   A0 .. A7   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   A8 .. AF   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   B0 .. B7   */
+   UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN,UCONTN, /*   B8 .. BF   */
+   NA,    NA,    U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N,  /*   C0 .. C7   */
+   U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N,  /*   C8 .. CF   */
+   U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N,  /*   D0 .. D7   */
+   U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N, U2_1N,  /*   D8 .. DF   */
+   U3_1N, U3_1N, U3_1N, U3_1N, U3_1N, U3_1N, U3_1N, U3_1N,  /*   E0 .. E7   */
+   U3_1N, U3_1N, U3_1N, U3_1N, U3_1N, U3_1N, U3_1N, U3_1N,  /*   E8 .. EF   */
+   U4_1N, U4_1N, U4_1N, U4_1N, U4_1N, NA,    NA,    NA,     /*   F0 .. F7   */
+   NA,    NA,    NA,    NA,    NA,    NA,    NA,    NA,     /*   F8 .. FF   */
+};
+
+#define SETLOCALE       2       /* #pragma setlocale (not __setlocale)  */
+
+#define NUM_ENCODING    8
+#define NUM_ALIAS       6
+
+/* Names of encoding recognized.  Table for search_encoding().  */
+static const char * const   encoding_name[ NUM_ENCODING][ NUM_ALIAS] = {
+    /* Visual C full, Visual C short
+        , 4 miscellaneous  */
+    { "english",    "c"
+        , "c",      "en",   "latin",    "iso8859"},
+    { "",     ""
+        , "eucjp",  "euc",  "ujis",     ""},
+    { "chinesesimplified",  "chs"
+        , "gb2312", "cngb",     "euccn",    ""},
+    { "korean",   "kor"
+        , "ksc5601",    "ksx1001",  "wansung",  "euckr"},
+    { "japanese", "jpn"
+        , "sjis",   "shiftjis", "mskanji",  ""},
+    { "chinesetraditional", "cht"
+        , "bigfive",    "big5", "cnbig5",   "euctw"},
+    { "",     ""
+        , "iso2022jp",  "iso2022jp1",   "jis",  ""},
+    { "",     ""
+        , "utf8",   "utf",      "",     ""},
+};
+
+static int      mbstart;
+static int      mb2;
+
+static size_t   mb_read_2byte( int c1, char ** in_pp, char ** out_pp);
+                /* For 2-byte encodings of mbchar   */
+static const char *     search_encoding( char * norm, int alias);
+                /* Search encoding_name[][] table   */
+static void     strip_bar( char * string);
+                /* Remove '_', '-' or '.' in the string */
+static void     conv_case( char * name, char * lim, int upper);
+                /* Convert to upper/lower case      */
+static size_t   mb_read_iso2022_jp( int c1, char ** in_pp, char ** out_pp);
+                /* For ISO2022_JP encoding          */
+static size_t   mb_read_utf8( int c1, char ** in_pp, char ** out_pp);
+                /* For UTF8 mbchar encoding         */
+
+#define NAMLEN          20
+#define UPPER           1               /* To upper */
+#define LOWER           0               /* To lower */
+
+
+const char *    set_encoding(
+    char *  name,       /* Name of encoding specified   */
+    char *  env,        /* Name of environment variable */
+    int     pragma
+        /* 2: #pragma setlocale, 1: #pragma __setlocale, 0: not #pragma */
+)
+/*
+ * Search the encoding specified and re-initialize mbchar settings.
+ */
+{
+    const char *    unknown_encoding
+            = "Unknown encoding: %s%.0ld%.0s";          /* _W1_ */
+    const char *    too_long
+            = "Too long encoding name: %s%.0ld%.0s";    /* _E_  */
+    const char *    loc = "";
+    int     alias;
+    char    norm[ NAMLEN];
+            /*
+             * Normalized name (removed 'xxxxx.', stripped '_', '-', '.'
+             * and lowered.
+             */
+
+    if (strlen( name) >= NAMLEN) {
+        if ((env || pragma) && (warn_level & 1)) {
+            cwarn( too_long, name, 0L, NULL);
+        } else {
+            mcpp_fprintf( ERR, too_long, name);
+            mcpp_fputc( '\n', ERR);
+        }
+    }
+    strcpy( norm, name);
+    if (norm[ 5] == '.')
+        memmove( norm, norm + 5, strlen( norm + 5) + 1);
+        /* Remove initial 'xxxxx.' as 'ja_JP.', 'en_US.' or any other   */
+    conv_case( norm, norm + strlen( norm), LOWER);
+    strip_bar( norm);
+
+    if (strlen( name) == 0) {                       /* ""       */
+        mbchar = MBCHAR;    /* Restore to the default encoding  */
+    } else if (memcmp( norm, "iso8859", 7) == 0     /* iso8859* */
+            || memcmp( norm, "latin", 5) == 0       /* latin*   */
+            || memcmp( norm, "en", 2) == 0) {       /* en*      */
+        mbchar = 0;                 /* No multi-byte character  */
+    } else {
+        alias = 2;
+#if COMPILER == MSC
+        if (pragma == SETLOCALE)        /* #pragma setlocale    */
+            alias = 0;
+#endif
+        loc = search_encoding( norm, alias);        /* Search the name  */
+    }
+    if (loc == NULL) {
+        if ((env || pragma) && (warn_level & 1)) {
+            cwarn( unknown_encoding, name, 0L, NULL);
+        } else {                        /* -m option            */
+            mcpp_fprintf( ERR, unknown_encoding, name);
+            mcpp_fputc( '\n', ERR);
+        }
+    } else {
+        mb_init();                      /* Re-initialize        */
+    }
+    return  loc;
+}
+
+static const char * search_encoding(
+    char *  norm,           /* The name of encoding specified   */
+    int     alias           /* The number of alias to start searching   */
+)
+{
+    const char *    loc;
+    int             lo, al;
+
+    for (lo = 0; lo < NUM_ENCODING; lo++) {
+        for (al = alias ; al < NUM_ALIAS; al++) {
+            loc = encoding_name[ lo][ al];
+            if (str_eq( loc, norm)) {
+                switch (lo) {
+                case 0  :   mbchar = 0;             break;
+                case 1  :   mbchar = EUC_JP;        break;
+                case 2  :   mbchar = GB2312;        break;
+                case 3  :   mbchar = KSC5601;       break;
+                case 4  :   mbchar = SJIS;          break;
+                case 5  :   mbchar = BIGFIVE;       break;
+                case 6  :   mbchar = ISO2022_JP;    break;
+                case 7  :   mbchar = UTF8;          break;
+                }
+                return  loc;
+            }
+        }
+    }
+    return  NULL;
+}
+
+static void strip_bar(
+    char *  string
+)
+/*
+ * Strip '_', '-' or '.' in the string.
+ */
+{
+    char *  cp = string;
+
+    while (*cp != EOS) {
+        if (*cp == '_' || *cp == '-' || *cp == '.')
+            memmove( cp, cp + 1, strlen( cp));
+        else
+            cp++;
+    }
+}
+
+static void     conv_case(
+    char *  name,                       /* (diretory) Name          */
+    char *  lim,                        /* End of (directory) name  */
+    int     upper                       /* TRUE if to upper         */
+)
+/* Convert a string to upper-case letters or lower-case letters in-place    */
+{
+    int     c;
+    char *  sp;
+
+    for (sp = name; sp < lim; sp++) {
+        c = *sp & UCHARMAX;
+#if MBCHAR
+        if ((char_type[ c] & mbstart)) {
+            char    tmp[ PATHMAX+1];
+            char *  tp = tmp;
+            *tp++ = *sp++;
+            mb_read( c, &sp, &tp);
+        } else
+#endif
+        {
+            if (upper)
+                *sp = toupper( c);
+            else
+                *sp = tolower( c);
+        }
+    }
+}
+
+void    mb_init( void)
+/*
+ * Initialize multi-byte character settings.
+ * First called prior to setting the 'mcpp_mode'.
+ * Will be called again each time the multibyte character encoding is changed.
+ */
+{
+    /*
+     * Select the character classification table, select the multi-byte
+     * character reading routine and decide whether multi-byte character
+     * may contain the byte of value 0x5c.
+     */
+    switch (mbchar) {
+    case 0      :
+    case EUC_JP     :
+    case GB2312     :
+    case KSC5601    :
+        char_type = type_euc;
+        bsl_in_mbchar = FALSE;
+        mb_read = mb_read_2byte;
+        break;
+    case SJIS   :
+    case BIGFIVE    :
+        char_type = type_bsl;
+        bsl_in_mbchar = TRUE;
+        mb_read = mb_read_2byte;
+        break;
+    case ISO2022_JP :
+        char_type = type_iso2022_jp;
+        bsl_in_mbchar = TRUE;
+        mb_read = mb_read_iso2022_jp;
+        break;
+    case UTF8   :
+        char_type = type_utf8;
+        bsl_in_mbchar = FALSE;
+        mb_read = mb_read_utf8;
+        break;
+    }
+
+    /* Set the bit patterns for character classification.   */
+    switch (mbchar) {
+    case 0      :
+        mbstart = 0;
+        break;
+    case EUC_JP :
+        mbstart = EJ1;
+        mb2 = EJ2;
+        break;
+    case GB2312 :
+        mbstart = GB1;
+        mb2 = GB2;
+        break;
+    case KSC5601:
+        mbstart = KS1;
+        mb2 = KS2;
+        break;
+    case SJIS   :
+        mbstart = SJ1;
+        mb2 = SJ2;
+        break;
+    case BIGFIVE:
+        mbstart = BF1;
+        mb2 = BF2;
+        break;
+    case ISO2022_JP :
+        mbstart = IS1;
+        break;
+    case UTF8   :
+        mbstart = (U2_1 | U3_1 | U4_1);
+        break;
+    }
+    switch (mbchar) {
+    case 0      :
+        mbchk = 0;
+        break;
+    case EUC_JP :
+    case GB2312 :
+    case KSC5601:
+    case SJIS   :
+    case BIGFIVE:
+    case UTF8   :
+        mbchk = NA;
+        break;
+    case ISO2022_JP :
+        mbchk = (IS1 | NA);
+        break;
+    }
+
+    /*
+     * Set special handling for some encodings to supplement some compiler's
+     * deficiency.
+     */
+    switch (mbchar) {
+    case SJIS   :
+#if ! SJIS_IS_ESCAPE_FREE
+        bsl_need_escape = TRUE;
+#endif
+        break;
+    case BIGFIVE:
+#if ! BIGFIVE_IS_ESCAPE_FREE
+        bsl_need_escape = TRUE;
+#endif
+        break;
+    case ISO2022_JP :
+#if ! ISO2022_JP_IS_ESCAPE_FREE
+        bsl_need_escape = TRUE;
+#endif
+        break;
+    default :
+        bsl_need_escape = FALSE;
+        break;
+    }
+
+    /*
+     * Modify magic characters in character type table.
+     * char_type[] table should be rewritten in accordance with the 'mcpp_mode'
+     * whenever the encoding is changed.
+     */
+    if (mcpp_mode) {                /* If mcpp_mode is already set  */
+        char_type[ DEF_MAGIC] = standard ? LET : 0;
+        char_type[ IN_SRC] = (mcpp_mode == STD) ? LET : 0;
+        char_type[ TOK_SEP] = (mcpp_mode == STD || mcpp_mode == OLD_PREP)
+                ? HSPA: 0;          /* TOK_SEP equals to COM_SEP    */
+    }
+}
+
+static size_t   mb_read_2byte(
+    int     c1,         /* The 1st byte of mbchar sequence (already read)   */
+    char ** in_pp,              /* Pointer to input     */
+    char ** out_pp              /* Pointer to output    */
+)
+/*
+ * Multi-byte character reading routine for 2-byte encodings.
+ */
+{
+    int     error = FALSE;
+    size_t  len = 0;    /* Number of multi-byte characters read.    */
+    char *  in_p = *in_pp;
+    char *  out_p = *out_pp;
+
+    if (! (char_type[ c1 & UCHARMAX] & mbstart))
+        return  MB_ERROR;           /* Not a multi-byte character   */
+
+    do {
+        if (! (char_type[ (*out_p++ = *in_p++) & UCHARMAX] & mb2)) {
+            error = TRUE;
+            break;
+        }
+        len++;
+    } while (char_type[ (*out_p++ = *in_p++) & UCHARMAX] & mbstart);
+    *in_pp = --in_p;
+    *(--out_p) = EOS;
+    *out_pp = out_p;
+    return  error ? (len | MB_ERROR) : len;
+}
+
+static size_t   mb_read_iso2022_jp(
+    int     c1, /* The 1st byte of the sequence already read (always 0x1b). */
+    char ** in_pp,
+    char ** out_pp
+)
+/*
+ * Multi-byte character reading routine for ISO2022_JP.
+ */
+{
+    int     error = FALSE;
+    size_t  len = 0;
+    char *  in_p = *in_pp;
+    char *  out_p = *out_pp;
+    int     c2, c3, c4;
+
+    if (! (char_type[ c1 & UCHARMAX] & mbstart))
+        return  MB_ERROR;
+
+    do {
+
+        *out_p++ = c2 = *in_p++;
+        if (! (char_type[ c2 & UCHARMAX] & IS2)) {
+            error = TRUE;
+            break;
+        }
+        *out_p++ = c3 = *in_p++;
+        if (! (char_type[ c3 & UCHARMAX] & IS3)) {
+            error = TRUE;
+            break;
+        }
+
+        switch (c2) {
+        case 0x24   :
+            switch (c3) {
+            case 0x42   :   /* 0x1b 0x24 0x42:  JIS X 0208-1983 */
+                break;
+            case 0x28   :
+                *out_p++ = c4 = *in_p++;
+                if (! (char_type[ c4 & UCHARMAX] & IS4))
+                    error = TRUE;
+                /* else:    0x1b 0x24 0x28 0x44:    JIS X 0212  */
+                break;
+            default :
+                error = TRUE;
+            }
+            break;
+        case 0x28   :
+            switch (c3) {
+            case 0x42   :   /* 0x1b 0x28 0x42:  ASCII   */
+                c1 = *out_p++ = *in_p++ & UCHARMAX;
+                continue;
+            default :
+                error = TRUE;
+            }
+            break;
+        }
+        if (error)
+            break;
+
+        while (char_type[ c1 = *out_p++ = (*in_p++ & UCHARMAX)] & IJP) {
+            if (! (char_type[ *out_p++ = (*in_p++ & UCHARMAX)] & IJP)) {
+                error = TRUE;
+                break;
+            }
+            len++;          /* String of multi-byte characters  */
+        }
+        if (error)
+            break;
+
+    } while (char_type[ c1] & IS1);     /* 0x1b:    start of shift-sequence */
+
+    *in_pp = --in_p;
+    *(--out_p) = EOS;
+    *out_pp = out_p;
+    return  error ? (len | MB_ERROR) : len;
+}
+
+static size_t   mb_read_utf8(
+    int     c1,
+    char ** in_pp,
+    char ** out_pp
+)
+/*
+ * Multi-byte character reading routine for UTF8.
+ */
+{
+    int     error = FALSE;
+    size_t  len = 0;
+    char *  in_p = *in_pp;
+    char *  out_p = *out_pp;
+
+    if (! (char_type[ c1 & UCHARMAX] & mbstart))
+        return  MB_ERROR;
+
+    do {
+        unsigned int    codepoint;
+        int             i, bytes;
+
+        if ((char_type[ c1 & UCHARMAX] & U4_1) == U4_1)
+            bytes = 4;                          /* 4-byte character */
+        else if ((char_type[ c1 & UCHARMAX] & U3_1) == U3_1)
+            bytes = 3;                          /* 3-byte character */
+        else if ((char_type[ c1 & UCHARMAX] & U2_1) == U2_1)
+            bytes = 2;                          /* 2-byte character */
+
+        /* Must ensure that the sequence is not reserved as a surrogate */
+        codepoint = ((2 << (6-bytes)) - 1) & c1;    /* mask off top bits    */
+
+        /* All bytes left in the sequence must be in 0x80 - 0xBF    */
+        for (i = bytes - 1; i && !error; i--) {
+            codepoint = (codepoint << 6) + ((*in_p) & 0x3fU);
+            if (! (char_type[ (*out_p++ = *in_p++) & UCHARMAX] & UCONT))
+                error = TRUE;
+        }
+
+        /* Check for overlong/underlong sequences */
+        if ((bytes == 2 && (codepoint < 0x80 || codepoint > 0x7FF))
+            || (bytes == 3 && (codepoint < 0x800 || codepoint > 0xFFFF))
+            || (bytes == 4 && (codepoint < 0x10000 || codepoint > 0x10FFFF)))
+            error = TRUE;
+        if ((codepoint >= 0xD800 && codepoint <= 0xDFFF)
+            /* Check for reserved surrogate codepoints */
+                || (codepoint >= 0xFFFE && codepoint <= 0xFFFF))
+                /* Illegal  */
+            error = TRUE;
+#if 0
+        printf( "codepoint:0x%x\n", codepoint);
+#endif
+        if (error)
+            break;
+        len++;
+    } while (char_type[ (*out_p++ = c1 = *in_p++) & UCHARMAX] & mbstart);
+                        /* Start of the next multi-byte character   */
+    *in_pp = --in_p;
+    *(--out_p) = EOS;
+    *out_pp = out_p;
+    return  error ? (len | MB_ERROR) : len;
+}
+
+uexpr_t     mb_eval(
+    char ** seq_pp
+)
+/*
+ * Evaluate the value of a multi-byte character.
+ * This routine does not check the legality of the sequence.
+ * This routine is called from eval_char().
+ * This routine is never called in POST_STD mode.
+ */
+{
+    char *      seq = *seq_pp;
+    uexpr_t     val = 0;
+    int         c, c1;
+
+    if (! (char_type[ c = *seq++ & UCHARMAX] & mbstart)) {
+        *seq_pp = seq;
+        return  c;                  /* Not a multi-byte character   */
+    }
+
+    switch (mbchar) {
+    case EUC_JP :
+    case GB2312 :
+    case KSC5601:
+    case SJIS   :
+    case BIGFIVE:
+        val = (c << 8) + (*seq++ & UCHARMAX);
+        /* Evaluate the 2-byte sequence */
+        break;
+    case ISO2022_JP :
+        if (char_type[ c & UCHARMAX] & IS1) {   /* Skip shift-sequence  */
+            if (char_type[ c = *seq++ & UCHARMAX] & IS2) {
+                if (char_type[ c1 = *seq++ & UCHARMAX] & IS3) {
+                    if (c1 == 0x28)
+                        seq++;
+                    if (c == 0x28 && c1 == 0x42) {  /* Shift-out sequence   */
+                        val = 0;
+                        break;
+                    }
+                    c = *seq++ & UCHARMAX;
+                }
+            }
+        }
+        val = (c << 8) + (*seq++ & UCHARMAX);       /* Evaluate the 2-bytes */
+        break;
+    case UTF8   :   /* Evaluate the sequence of 2, 3 or 4 bytes as it is    */
+        val = (c << 8) + (*seq++ & UCHARMAX);
+        if (char_type[ c & UCHARMAX] & U3_1) {
+            val = (val << 8) + (*seq++ & UCHARMAX);
+        } else if (char_type[ c & UCHARMAX] & U4_1) {
+            val = (val << 8) + (*seq++ & UCHARMAX);
+            val = (val << 8) + (*seq++ & UCHARMAX);
+        }
+        break;
+    }
+
+    *seq_pp = seq;
+    return  val;
+}
+
+int  last_is_mbchar(
+    const char *  in,               /* Input physical line          */
+    int     len                     /* Length of the line minus 2   */
+)
+/*
+ * Return 2, if the last char of the line is second byte of SJIS or BIGFIVE,
+ * else return 0.
+ */
+{
+    const char *    cp = in + len;
+    const char * const      endp = in + len;    /* -> the char befor '\n'   */
+
+    if ((mbchar & (SJIS | BIGFIVE)) == 0)
+        return  0;
+    while (in <= --cp) {                    /* Search backwardly    */
+        if ((char_type[ *cp & UCHARMAX] & mbstart) == 0)
+            break;                  /* Not the first byte of MBCHAR */
+    }
+    if ((endp - cp) & 1)
+        return  0;
+    else
+        return  2;
+}
+