nkf.c

   1 /*
   2  * Copyright (c) 1987, Fujitsu LTD. (Itaru ICHIKAWA).
   3  * Copyright (c) 1996-2009, The nkf Project.
   4  *
   5  * This software is provided 'as-is', without any express or implied
   6  * warranty. In no event will the authors be held liable for any damages
   7  * arising from the use of this software.
   8  *
   9  * Permission is granted to anyone to use this software for any purpose,
  10  * including commercial applications, and to alter it and redistribute it
  11  * freely, subject to the following restrictions:
  12  *
  13  * 1. The origin of this software must not be misrepresented; you must not
  14  * claim that you wrote the original software. If you use this software
  15  * in a product, an acknowledgment in the product documentation would be
  16  * appreciated but is not required.
  17  *
  18  * 2. Altered source versions must be plainly marked as such, and must not be
  19  * misrepresented as being the original software.
  20  *
  21  * 3. This notice may not be removed or altered from any source distribution.
  22  */
  23 #define NKF_VERSION "2.1.1"
  24 #define NKF_RELEASE_DATE "2010-01-05"
  25 #define COPY_RIGHT \
  26     "Copyright (C) 1987, FUJITSU LTD. (I.Ichikawa).\n" \
  27     "Copyright (C) 1996-2010, The nkf Project."
  28
  29 #include "config.h"
  30 #include "nkf.h"
  31 #include "utf8tbl.h"
  32 #ifdef __WIN32__
  33 #include <windows.h>
  34 #include <locale.h>
  35 #endif
  36 #if defined(__OS2__)
  37 # define INCL_DOS
  38 # define INCL_DOSERRORS
  39 # include <os2.h>
  40 #endif
  41 #include <assert.h>
  42
  43
  44 /* state of output_mode and input_mode
  45
  46    c2           0 means ASCII
  47    JIS_X_0201_1976_K
  48    ISO_8859_1
  49    JIS_X_0208
  50    EOF      all termination
  51    c1           32bit data
  52
  53  */
  54
  55 /* MIME ENCODE */
  56
  57 #define         FIXED_MIME      7
  58 #define         STRICT_MIME     8
  59
  60 /* byte order */
  61 enum byte_order {
  62     ENDIAN_BIG    = 1,
  63     ENDIAN_LITTLE = 2,
  64     ENDIAN_2143   = 3,
  65     ENDIAN_3412   = 4
  66 };
  67
  68 /* ASCII CODE */
  69
  70 #define         BS      0x08
  71 #define         TAB     0x09
  72 #define         LF      0x0a
  73 #define         CR      0x0d
  74 #define         ESC     0x1b
  75 #define         SP      0x20
  76 #define         DEL     0x7f
  77 #define         SI      0x0f
  78 #define         SO      0x0e
  79 #define         SS2     0x8e
  80 #define         SS3     0x8f
  81 #define         CRLF    0x0D0A
  82
  83
  84 /* encodings */
  85
  86 enum nkf_encodings {
  87     ASCII,
  88     ISO_8859_1,
  89     ISO_2022_JP,
  90     CP50220,
  91     CP50221,
  92     CP50222,
  93     ISO_2022_JP_1,
  94     ISO_2022_JP_3,
  95     ISO_2022_JP_2004,
  96     SHIFT_JIS,
  97     WINDOWS_31J,
  98     CP10001,
  99     EUC_JP,
 100     EUCJP_NKF,
 101     CP51932,
 102     EUCJP_MS,
 103     EUCJP_ASCII,
 104     SHIFT_JISX0213,
 105     SHIFT_JIS_2004,
 106     EUC_JISX0213,
 107     EUC_JIS_2004,
 108     UTF_8,
 109     UTF_8N,
 110     UTF_8_BOM,
 111     UTF8_MAC,
 112     UTF_16,
 113     UTF_16BE,
 114     UTF_16BE_BOM,
 115     UTF_16LE,
 116     UTF_16LE_BOM,
 117     UTF_32,
 118     UTF_32BE,
 119     UTF_32BE_BOM,
 120     UTF_32LE,
 121     UTF_32LE_BOM,
 122     BINARY,
 123     NKF_ENCODING_TABLE_SIZE,
 124     JIS_X_0201_1976_K = 0x1013, /* I */ /* JIS C 6220-1969 */
 125     /* JIS_X_0201_1976_R = 0x1014, */ /* J */ /* JIS C 6220-1969 */
 126     /* JIS_X_0208_1978   = 0x1040, */ /* @ */ /* JIS C 6226-1978 */
 127     /* JIS_X_0208_1983   = 0x1087, */ /* B */ /* JIS C 6226-1983 */
 128     JIS_X_0208        = 0x1168, /* @B */
 129     JIS_X_0212        = 0x1159, /* D */
 130     /* JIS_X_0213_2000_1 = 0x1228, */ /* O */
 131     JIS_X_0213_2 = 0x1229, /* P */
 132     JIS_X_0213_1 = 0x1233 /* Q */
 133 };
 134
 135 static nkf_char s_iconv(nkf_char c2, nkf_char c1, nkf_char c0);
 136 static nkf_char e_iconv(nkf_char c2, nkf_char c1, nkf_char c0);
 137 static nkf_char w_iconv(nkf_char c2, nkf_char c1, nkf_char c0);
 138 static nkf_char w_iconv16(nkf_char c2, nkf_char c1, nkf_char c0);
 139 static nkf_char w_iconv32(nkf_char c2, nkf_char c1, nkf_char c0);
 140 static void j_oconv(nkf_char c2, nkf_char c1);
 141 static void s_oconv(nkf_char c2, nkf_char c1);
 142 static void e_oconv(nkf_char c2, nkf_char c1);
 143 static void w_oconv(nkf_char c2, nkf_char c1);
 144 static void w_oconv16(nkf_char c2, nkf_char c1);
 145 static void w_oconv32(nkf_char c2, nkf_char c1);
 146
 147 typedef struct {
 148     const char *name;
 149     nkf_char (*iconv)(nkf_char c2, nkf_char c1, nkf_char c0);
 150     void (*oconv)(nkf_char c2, nkf_char c1);
 151 } nkf_native_encoding;
 152
 153 nkf_native_encoding NkfEncodingASCII =          { "ASCII", e_iconv, e_oconv };
 154 nkf_native_encoding NkfEncodingISO_2022_JP =    { "ISO-2022-JP", e_iconv, j_oconv };
 155 nkf_native_encoding NkfEncodingShift_JIS =      { "Shift_JIS", s_iconv, s_oconv };
 156 nkf_native_encoding NkfEncodingEUC_JP =         { "EUC-JP", e_iconv, e_oconv };
 157 nkf_native_encoding NkfEncodingUTF_8 =          { "UTF-8", w_iconv, w_oconv };
 158 nkf_native_encoding NkfEncodingUTF_16 =         { "UTF-16", w_iconv16, w_oconv16 };
 159 nkf_native_encoding NkfEncodingUTF_32 =         { "UTF-32", w_iconv32, w_oconv32 };
 160
 161 typedef struct {
 162     const int id;
 163     const char *name;
 164     const nkf_native_encoding *base_encoding;
 165 } nkf_encoding;
 166
 167 nkf_encoding nkf_encoding_table[] = {
 168     {ASCII,             "US-ASCII",             &NkfEncodingASCII},
 169     {ISO_8859_1,        "ISO-8859-1",           &NkfEncodingASCII},
 170     {ISO_2022_JP,       "ISO-2022-JP",          &NkfEncodingISO_2022_JP},
 171     {CP50220,           "CP50220",              &NkfEncodingISO_2022_JP},
 172     {CP50221,           "CP50221",              &NkfEncodingISO_2022_JP},
 173     {CP50222,           "CP50222",              &NkfEncodingISO_2022_JP},
 174     {ISO_2022_JP_1,     "ISO-2022-JP-1",        &NkfEncodingISO_2022_JP},
 175     {ISO_2022_JP_3,     "ISO-2022-JP-3",        &NkfEncodingISO_2022_JP},
 176     {ISO_2022_JP_2004,  "ISO-2022-JP-2004",     &NkfEncodingISO_2022_JP},
 177     {SHIFT_JIS,         "Shift_JIS",            &NkfEncodingShift_JIS},
 178     {WINDOWS_31J,       "Windows-31J",          &NkfEncodingShift_JIS},
 179     {CP10001,           "CP10001",              &NkfEncodingShift_JIS},
 180     {EUC_JP,            "EUC-JP",               &NkfEncodingEUC_JP},
 181     {EUCJP_NKF,         "eucJP-nkf",            &NkfEncodingEUC_JP},
 182     {CP51932,           "CP51932",              &NkfEncodingEUC_JP},
 183     {EUCJP_MS,          "eucJP-MS",             &NkfEncodingEUC_JP},
 184     {EUCJP_ASCII,       "eucJP-ASCII",          &NkfEncodingEUC_JP},
 185     {SHIFT_JISX0213,    "Shift_JISX0213",       &NkfEncodingShift_JIS},
 186     {SHIFT_JIS_2004,    "Shift_JIS-2004",       &NkfEncodingShift_JIS},
 187     {EUC_JISX0213,      "EUC-JISX0213",         &NkfEncodingEUC_JP},
 188     {EUC_JIS_2004,      "EUC-JIS-2004",         &NkfEncodingEUC_JP},
 189     {UTF_8,             "UTF-8",                &NkfEncodingUTF_8},
 190     {UTF_8N,            "UTF-8N",               &NkfEncodingUTF_8},
 191     {UTF_8_BOM,         "UTF-8-BOM",            &NkfEncodingUTF_8},
 192     {UTF8_MAC,          "UTF8-MAC",             &NkfEncodingUTF_8},
 193     {UTF_16,            "UTF-16",               &NkfEncodingUTF_16},
 194     {UTF_16BE,          "UTF-16BE",             &NkfEncodingUTF_16},
 195     {UTF_16BE_BOM,      "UTF-16BE-BOM",         &NkfEncodingUTF_16},
 196     {UTF_16LE,          "UTF-16LE",             &NkfEncodingUTF_16},
 197     {UTF_16LE_BOM,      "UTF-16LE-BOM",         &NkfEncodingUTF_16},
 198     {UTF_32,            "UTF-32",               &NkfEncodingUTF_32},
 199     {UTF_32BE,          "UTF-32BE",             &NkfEncodingUTF_32},
 200     {UTF_32BE_BOM,      "UTF-32BE-BOM",         &NkfEncodingUTF_32},
 201     {UTF_32LE,          "UTF-32LE",             &NkfEncodingUTF_32},
 202     {UTF_32LE_BOM,      "UTF-32LE-BOM",         &NkfEncodingUTF_32},
 203     {BINARY,            "BINARY",               &NkfEncodingASCII},
 204     {-1,                NULL,                   NULL}
 205 };
 206
 207 struct {
 208     const char *name;
 209     const int id;
 210 } encoding_name_to_id_table[] = {
 211     {"US-ASCII",                ASCII},
 212     {"ASCII",                   ASCII},
 213     {"646",                     ASCII},
 214     {"ROMAN8",                  ASCII},
 215     {"ISO-2022-JP",             ISO_2022_JP},
 216     {"ISO2022JP-CP932",         CP50220},
 217     {"CP50220",                 CP50220},
 218     {"CP50221",                 CP50221},
 219     {"CSISO2022JP",             CP50221},
 220     {"CP50222",                 CP50222},
 221     {"ISO-2022-JP-1",           ISO_2022_JP_1},
 222     {"ISO-2022-JP-3",           ISO_2022_JP_3},
 223     {"ISO-2022-JP-2004",        ISO_2022_JP_2004},
 224     {"SHIFT_JIS",               SHIFT_JIS},
 225     {"SJIS",                    SHIFT_JIS},
 226     {"PCK",                     SHIFT_JIS},
 227     {"WINDOWS-31J",             WINDOWS_31J},
 228     {"CSWINDOWS31J",            WINDOWS_31J},
 229     {"CP932",                   WINDOWS_31J},
 230     {"MS932",                   WINDOWS_31J},
 231     {"CP10001",                 CP10001},
 232     {"EUCJP",                   EUC_JP},
 233     {"EUC-JP",                  EUC_JP},
 234     {"EUCJP-NKF",               EUCJP_NKF},
 235     {"CP51932",                 CP51932},
 236     {"EUC-JP-MS",               EUCJP_MS},
 237     {"EUCJP-MS",                EUCJP_MS},
 238     {"EUCJPMS",                 EUCJP_MS},
 239     {"EUC-JP-ASCII",            EUCJP_ASCII},
 240     {"EUCJP-ASCII",             EUCJP_ASCII},
 241     {"SHIFT_JISX0213",          SHIFT_JISX0213},
 242     {"SHIFT_JIS-2004",          SHIFT_JIS_2004},
 243     {"EUC-JISX0213",            EUC_JISX0213},
 244     {"EUC-JIS-2004",            EUC_JIS_2004},
 245     {"UTF-8",                   UTF_8},
 246     {"UTF-8N",                  UTF_8N},
 247     {"UTF-8-BOM",               UTF_8_BOM},
 248     {"UTF8-MAC",                UTF8_MAC},
 249     {"UTF-8-MAC",               UTF8_MAC},
 250     {"UTF-16",                  UTF_16},
 251     {"UTF-16BE",                UTF_16BE},
 252     {"UTF-16BE-BOM",            UTF_16BE_BOM},
 253     {"UTF-16LE",                UTF_16LE},
 254     {"UTF-16LE-BOM",            UTF_16LE_BOM},
 255     {"UTF-32",                  UTF_32},
 256     {"UTF-32BE",                UTF_32BE},
 257     {"UTF-32BE-BOM",            UTF_32BE_BOM},
 258     {"UTF-32LE",                UTF_32LE},
 259     {"UTF-32LE-BOM",            UTF_32LE_BOM},
 260     {"BINARY",                  BINARY},
 261     {NULL,                      -1}
 262 };
 263
 264 #if defined(DEFAULT_CODE_JIS)
 265 #define     DEFAULT_ENCIDX ISO_2022_JP
 266 #elif defined(DEFAULT_CODE_SJIS)
 267 #define     DEFAULT_ENCIDX SHIFT_JIS
 268 #elif defined(DEFAULT_CODE_WINDOWS_31J)
 269 #define     DEFAULT_ENCIDX WINDOWS_31J
 270 #elif defined(DEFAULT_CODE_EUC)
 271 #define     DEFAULT_ENCIDX EUC_JP
 272 #elif defined(DEFAULT_CODE_UTF8)
 273 #define     DEFAULT_ENCIDX UTF_8
 274 #endif
 275
 276
 277 #define         is_alnum(c)  \
 278     (('a'<=c && c<='z')||('A'<= c && c<='Z')||('0'<=c && c<='9'))
 279
 280 /* I don't trust portablity of toupper */
 281 #define nkf_toupper(c)  (('a'<=c && c<='z')?(c-('a'-'A')):c)
 282 #define nkf_isoctal(c)  ('0'<=c && c<='7')
 283 #define nkf_isdigit(c)  ('0'<=c && c<='9')
 284 #define nkf_isxdigit(c)  (nkf_isdigit(c) || ('a'<=c && c<='f') || ('A'<=c && c <= 'F'))
 285 #define nkf_isblank(c) (c == SP || c == TAB)
 286 #define nkf_isspace(c) (nkf_isblank(c) || c == CR || c == LF)
 287 #define nkf_isalpha(c) (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
 288 #define nkf_isalnum(c) (nkf_isdigit(c) || nkf_isalpha(c))
 289 #define nkf_isprint(c) (SP<=c && c<='~')
 290 #define nkf_isgraph(c) ('!'<=c && c<='~')
 291 #define hex2bin(c) (('0'<=c&&c<='9') ? (c-'0') : \
 292                     ('A'<=c&&c<='F') ? (c-'A'+10) : \
 293                     ('a'<=c&&c<='f') ? (c-'a'+10) : 0)
 294 #define bin2hex(c) ("0123456789ABCDEF"[c&15])
 295 #define is_eucg3(c2) (((unsigned short)c2 >> 8) == SS3)
 296 #define nkf_noescape_mime(c) ((c == CR) || (c == LF) || \
 297                               ((c > SP) && (c < DEL) && (c != '?') && (c != '=') && (c != '_') \
 298                                && (c != '(') && (c != ')') && (c != '.') && (c != 0x22)))
 299
 300 #define is_ibmext_in_sjis(c2) (CP932_TABLE_BEGIN <= c2 && c2 <= CP932_TABLE_END)
 301 #define nkf_byte_jisx0201_katakana_p(c) (SP <= c && c <= 0x5F)
 302
 303 #define         HOLD_SIZE       1024
 304 #if defined(INT_IS_SHORT)
 305 #define         IOBUF_SIZE      2048
 306 #else
 307 #define         IOBUF_SIZE      16384
 308 #endif
 309
 310 #define         DEFAULT_J       'B'
 311 #define         DEFAULT_R       'B'
 312
 313
 314 #define         GETA1   0x22
 315 #define         GETA2   0x2e
 316
 317
 318 /* MIME preprocessor */
 319
 320 #ifdef EASYWIN /*Easy Win */
 321 extern POINT _BufferSize;
 322 #endif
 323
 324 struct input_code{
 325     const char *name;
 326     nkf_char stat;
 327     nkf_char score;
 328     nkf_char index;
 329     nkf_char buf[3];
 330     void (*status_func)(struct input_code *, nkf_char);
 331     nkf_char (*iconv_func)(nkf_char c2, nkf_char c1, nkf_char c0);
 332     int _file_stat;
 333 };
 334
 335 static const char *input_codename = NULL; /* NULL: unestablished, "": BINARY */
 336 static nkf_encoding *input_encoding = NULL;
 337 static nkf_encoding *output_encoding = NULL;
 338
 339 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
 340 /* UCS Mapping
 341  * 0: Shift_JIS, eucJP-ascii
 342  * 1: eucJP-ms
 343  * 2: CP932, CP51932
 344  * 3: CP10001
 345  */
 346 #define UCS_MAP_ASCII   0
 347 #define UCS_MAP_MS      1
 348 #define UCS_MAP_CP932   2
 349 #define UCS_MAP_CP10001 3
 350 static int ms_ucs_map_f = UCS_MAP_ASCII;
 351 #endif
 352 #ifdef UTF8_INPUT_ENABLE
 353 /* no NEC special, NEC-selected IBM extended and IBM extended characters */
 354 static  int     no_cp932ext_f = FALSE;
 355 /* ignore ZERO WIDTH NO-BREAK SPACE */
 356 static  int     no_best_fit_chars_f = FALSE;
 357 static  int     input_endian = ENDIAN_BIG;
 358 static  nkf_char     unicode_subchar = '?'; /* the regular substitution character */
 359 static  void    (*encode_fallback)(nkf_char c) = NULL;
 360 static  void    w_status(struct input_code *, nkf_char);
 361 #endif
 362 #ifdef UTF8_OUTPUT_ENABLE
 363 static  int     output_bom_f = FALSE;
 364 static  int     output_endian = ENDIAN_BIG;
 365 #endif
 366
 367 static  void    std_putc(nkf_char c);
 368 static  nkf_char     std_getc(FILE *f);
 369 static  nkf_char     std_ungetc(nkf_char c,FILE *f);
 370
 371 static  nkf_char     broken_getc(FILE *f);
 372 static  nkf_char     broken_ungetc(nkf_char c,FILE *f);
 373
 374 static  nkf_char     mime_getc(FILE *f);
 375
 376 static void mime_putc(nkf_char c);
 377
 378 /* buffers */
 379
 380 #if !defined(PERL_XS) && !defined(WIN32DLL)
 381 static unsigned char   stdibuf[IOBUF_SIZE];
 382 static unsigned char   stdobuf[IOBUF_SIZE];
 383 #endif
 384
 385 /* flags */
 386 static int             unbuf_f = FALSE;
 387 static int             estab_f = FALSE;
 388 static int             nop_f = FALSE;
 389 static int             binmode_f = TRUE;       /* binary mode */
 390 static int             rot_f = FALSE;          /* rot14/43 mode */
 391 static int             hira_f = FALSE;          /* hira/kata henkan */
 392 static int             alpha_f = FALSE;        /* convert JIx0208 alphbet to ASCII */
 393 static int             mime_f = MIME_DECODE_DEFAULT;   /* convert MIME B base64 or Q */
 394 static int             mime_decode_f = FALSE;  /* mime decode is explicitly on */
 395 static int             mimebuf_f = FALSE;      /* MIME buffered input */
 396 static int             broken_f = FALSE;       /* convert ESC-less broken JIS */
 397 static int             iso8859_f = FALSE;      /* ISO8859 through */
 398 static int             mimeout_f = FALSE;       /* base64 mode */
 399 static int             x0201_f = X0201_DEFAULT; /* convert JIS X 0201 */
 400 static int             iso2022jp_f = FALSE;    /* replace non ISO-2022-JP with GETA */
 401
 402 #ifdef UNICODE_NORMALIZATION
 403 static int nfc_f = FALSE;
 404 static nkf_char (*i_nfc_getc)(FILE *) = std_getc; /* input of ugetc */
 405 static nkf_char (*i_nfc_ungetc)(nkf_char c ,FILE *f) = std_ungetc;
 406 #endif
 407
 408 #ifdef INPUT_OPTION
 409 static int cap_f = FALSE;
 410 static nkf_char (*i_cgetc)(FILE *) = std_getc; /* input of cgetc */
 411 static nkf_char (*i_cungetc)(nkf_char c ,FILE *f) = std_ungetc;
 412
 413 static int url_f = FALSE;
 414 static nkf_char (*i_ugetc)(FILE *) = std_getc; /* input of ugetc */
 415 static nkf_char (*i_uungetc)(nkf_char c ,FILE *f) = std_ungetc;
 416 #endif
 417
 418 #define PREFIX_EUCG3    NKF_INT32_C(0x8F00)
 419 #define CLASS_MASK      NKF_INT32_C(0xFF000000)
 420 #define CLASS_UNICODE   NKF_INT32_C(0x01000000)
 421 #define VALUE_MASK      NKF_INT32_C(0x00FFFFFF)
 422 #define UNICODE_BMP_MAX NKF_INT32_C(0x0000FFFF)
 423 #define UNICODE_MAX     NKF_INT32_C(0x0010FFFF)
 424 #define nkf_char_euc3_new(c) ((c) | PREFIX_EUCG3)
 425 #define nkf_char_unicode_new(c) ((c) | CLASS_UNICODE)
 426 #define nkf_char_unicode_p(c) ((c & CLASS_MASK) == CLASS_UNICODE)
 427 #define nkf_char_unicode_bmp_p(c) ((c & VALUE_MASK) <= UNICODE_BMP_MAX)
 428 #define nkf_char_unicode_value_p(c) ((c & VALUE_MASK) <= UNICODE_MAX)
 429
 430 #ifdef NUMCHAR_OPTION
 431 static int numchar_f = FALSE;
 432 static nkf_char (*i_ngetc)(FILE *) = std_getc; /* input of ugetc */
 433 static nkf_char (*i_nungetc)(nkf_char c ,FILE *f) = std_ungetc;
 434 #endif
 435
 436 #ifdef CHECK_OPTION
 437 static int noout_f = FALSE;
 438 static void no_putc(nkf_char c);
 439 static int debug_f = FALSE;
 440 static void debug(const char *str);
 441 static nkf_char (*iconv_for_check)(nkf_char c2,nkf_char c1,nkf_char c0) = 0;
 442 #endif
 443
 444 static int guess_f = 0; /* 0: OFF, 1: ON, 2: VERBOSE */
 445 static  void    set_input_codename(const char *codename);
 446
 447 #ifdef EXEC_IO
 448 static int exec_f = 0;
 449 #endif
 450
 451 #ifdef SHIFTJIS_CP932
 452 /* invert IBM extended characters to others */
 453 static int cp51932_f = FALSE;
 454
 455 /* invert NEC-selected IBM extended characters to IBM extended characters */
 456 static int cp932inv_f = TRUE;
 457
 458 /* static nkf_char cp932_conv(nkf_char c2, nkf_char c1); */
 459 #endif /* SHIFTJIS_CP932 */
 460
 461 static int x0212_f = FALSE;
 462 static int x0213_f = FALSE;
 463
 464 static unsigned char prefix_table[256];
 465
 466 static void e_status(struct input_code *, nkf_char);
 467 static void s_status(struct input_code *, nkf_char);
 468
 469 struct input_code input_code_list[] = {
 470     {"EUC-JP",    0, 0, 0, {0, 0, 0}, e_status, e_iconv, 0},
 471     {"Shift_JIS", 0, 0, 0, {0, 0, 0}, s_status, s_iconv, 0},
 472 #ifdef UTF8_INPUT_ENABLE
 473     {"UTF-8",     0, 0, 0, {0, 0, 0}, w_status, w_iconv, 0},
 474     {"UTF-16",     0, 0, 0, {0, 0, 0}, NULL, w_iconv16, 0},
 475     {"UTF-32",     0, 0, 0, {0, 0, 0}, NULL, w_iconv32, 0},
 476 #endif
 477     {0}
 478 };
 479
 480 static int              mimeout_mode = 0; /* 0, -1, 'Q', 'B', 1, 2 */
 481 static int              base64_count = 0;
 482
 483 /* X0208 -> ASCII converter */
 484
 485 /* fold parameter */
 486 static int             f_line = 0;    /* chars in line */
 487 static int             f_prev = 0;
 488 static int             fold_preserve_f = FALSE; /* preserve new lines */
 489 static int             fold_f  = FALSE;
 490 static int             fold_len  = 0;
 491
 492 /* options */
 493 static unsigned char   kanji_intro = DEFAULT_J;
 494 static unsigned char   ascii_intro = DEFAULT_R;
 495
 496 /* Folding */
 497
 498 #define FOLD_MARGIN  10
 499 #define DEFAULT_FOLD 60
 500
 501 static int             fold_margin  = FOLD_MARGIN;
 502
 503 /* process default */
 504
 505 static nkf_char
 506 no_connection2(nkf_char c2, nkf_char c1, nkf_char c0)
 507 {
 508     fprintf(stderr,"nkf internal module connection failure.\n");
 509     exit(EXIT_FAILURE);
 510     return 0; /* LINT */
 511 }
 512
 513 static void
 514 no_connection(nkf_char c2, nkf_char c1)
 515 {
 516     no_connection2(c2,c1,0);
 517 }
 518
 519 static nkf_char (*iconv)(nkf_char c2,nkf_char c1,nkf_char c0) = no_connection2;
 520 static void (*oconv)(nkf_char c2,nkf_char c1) = no_connection;
 521
 522 static void (*o_zconv)(nkf_char c2,nkf_char c1) = no_connection;
 523 static void (*o_fconv)(nkf_char c2,nkf_char c1) = no_connection;
 524 static void (*o_eol_conv)(nkf_char c2,nkf_char c1) = no_connection;
 525 static void (*o_rot_conv)(nkf_char c2,nkf_char c1) = no_connection;
 526 static void (*o_hira_conv)(nkf_char c2,nkf_char c1) = no_connection;
 527 static void (*o_base64conv)(nkf_char c2,nkf_char c1) = no_connection;
 528 static void (*o_iso2022jp_check_conv)(nkf_char c2,nkf_char c1) = no_connection;
 529
 530 /* static redirections */
 531
 532 static  void   (*o_putc)(nkf_char c) = std_putc;
 533
 534 static  nkf_char    (*i_getc)(FILE *f) = std_getc; /* general input */
 535 static  nkf_char    (*i_ungetc)(nkf_char c,FILE *f) =std_ungetc;
 536
 537 static  nkf_char    (*i_bgetc)(FILE *) = std_getc; /* input of mgetc */
 538 static  nkf_char    (*i_bungetc)(nkf_char c ,FILE *f) = std_ungetc;
 539
 540 static  void   (*o_mputc)(nkf_char c) = std_putc ; /* output of mputc */
 541
 542 static  nkf_char    (*i_mgetc)(FILE *) = std_getc; /* input of mgetc */
 543 static  nkf_char    (*i_mungetc)(nkf_char c ,FILE *f) = std_ungetc;
 544
 545 /* for strict mime */
 546 static  nkf_char    (*i_mgetc_buf)(FILE *) = std_getc; /* input of mgetc_buf */
 547 static  nkf_char    (*i_mungetc_buf)(nkf_char c,FILE *f) = std_ungetc;
 548
 549 /* Global states */
 550 static int output_mode = ASCII;    /* output kanji mode */
 551 static int input_mode =  ASCII;    /* input kanji mode */
 552 static int mime_decode_mode =   FALSE;    /* MIME mode B base64, Q hex */
 553
 554 /* X0201 / X0208 conversion tables */
 555
 556 /* X0201 kana conversion table */
 557 /* 90-9F A0-DF */
 558 static const unsigned char cv[]= {
 559     0x21,0x21,0x21,0x23,0x21,0x56,0x21,0x57,
 560     0x21,0x22,0x21,0x26,0x25,0x72,0x25,0x21,
 561     0x25,0x23,0x25,0x25,0x25,0x27,0x25,0x29,
 562     0x25,0x63,0x25,0x65,0x25,0x67,0x25,0x43,
 563     0x21,0x3c,0x25,0x22,0x25,0x24,0x25,0x26,
 564     0x25,0x28,0x25,0x2a,0x25,0x2b,0x25,0x2d,
 565     0x25,0x2f,0x25,0x31,0x25,0x33,0x25,0x35,
 566     0x25,0x37,0x25,0x39,0x25,0x3b,0x25,0x3d,
 567     0x25,0x3f,0x25,0x41,0x25,0x44,0x25,0x46,
 568     0x25,0x48,0x25,0x4a,0x25,0x4b,0x25,0x4c,
 569     0x25,0x4d,0x25,0x4e,0x25,0x4f,0x25,0x52,
 570     0x25,0x55,0x25,0x58,0x25,0x5b,0x25,0x5e,
 571     0x25,0x5f,0x25,0x60,0x25,0x61,0x25,0x62,
 572     0x25,0x64,0x25,0x66,0x25,0x68,0x25,0x69,
 573     0x25,0x6a,0x25,0x6b,0x25,0x6c,0x25,0x6d,
 574     0x25,0x6f,0x25,0x73,0x21,0x2b,0x21,0x2c,
 575     0x00,0x00};
 576
 577
 578 /* X0201 kana conversion table for daguten */
 579 /* 90-9F A0-DF */
 580 static const unsigned char dv[]= {
 581     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 582     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 583     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 584     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 585     0x00,0x00,0x00,0x00,0x00,0x00,0x25,0x74,
 586     0x00,0x00,0x00,0x00,0x25,0x2c,0x25,0x2e,
 587     0x25,0x30,0x25,0x32,0x25,0x34,0x25,0x36,
 588     0x25,0x38,0x25,0x3a,0x25,0x3c,0x25,0x3e,
 589     0x25,0x40,0x25,0x42,0x25,0x45,0x25,0x47,
 590     0x25,0x49,0x00,0x00,0x00,0x00,0x00,0x00,
 591     0x00,0x00,0x00,0x00,0x25,0x50,0x25,0x53,
 592     0x25,0x56,0x25,0x59,0x25,0x5c,0x00,0x00,
 593     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 594     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 595     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 596     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 597     0x00,0x00};
 598
 599 /* X0201 kana conversion table for han-daguten */
 600 /* 90-9F A0-DF */
 601 static const unsigned char ev[]= {
 602     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 603     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 604     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 605     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 606     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 607     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 608     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 609     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 610     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 611     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 612     0x00,0x00,0x00,0x00,0x25,0x51,0x25,0x54,
 613     0x25,0x57,0x25,0x5a,0x25,0x5d,0x00,0x00,
 614     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 615     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 616     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 617     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 618     0x00,0x00};
 619
 620
 621 /* X0208 kigou conversion table */
 622 /* 0x8140 - 0x819e */
 623 static const unsigned char fv[] = {
 624
 625     0x00,0x00,0x00,0x00,0x2c,0x2e,0x00,0x3a,
 626     0x3b,0x3f,0x21,0x00,0x00,0x27,0x60,0x00,
 627     0x5e,0x00,0x5f,0x00,0x00,0x00,0x00,0x00,
 628     0x00,0x00,0x00,0x00,0x00,0x2d,0x00,0x2f,
 629     0x5c,0x00,0x00,0x7c,0x00,0x00,0x60,0x27,
 630     0x22,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,
 631     0x7b,0x7d,0x3c,0x3e,0x00,0x00,0x00,0x00,
 632     0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,
 633     0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,
 634     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 635     0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40,
 636     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
 637 } ;
 638
 639
 640
 641 static int option_mode = 0;
 642 static int             file_out_f = FALSE;
 643 #ifdef OVERWRITE
 644 static int             overwrite_f = FALSE;
 645 static int             preserve_time_f = FALSE;
 646 static int             backup_f = FALSE;
 647 static char            *backup_suffix = "";
 648 #endif
 649
 650 static int eolmode_f = 0;   /* CR, LF, CRLF */
 651 static int input_eol = 0; /* 0: unestablished, EOF: MIXED */
 652 static nkf_char prev_cr = 0; /* CR or 0 */
 653 #ifdef EASYWIN /*Easy Win */
 654 static int             end_check;
 655 #endif /*Easy Win */
 656
 657 static void *
 658 nkf_xmalloc(size_t size)
 659 {
 660     void *ptr;
 661
 662     if (size == 0) size = 1;
 663
 664     ptr = malloc(size);
 665     if (ptr == NULL) {
 666         perror("can't malloc");
 667         exit(EXIT_FAILURE);
 668     }
 669
 670     return ptr;
 671 }
 672
 673 static void *
 674 nkf_xrealloc(void *ptr, size_t size)
 675 {
 676     if (size == 0) size = 1;
 677
 678     ptr = realloc(ptr, size);
 679     if (ptr == NULL) {
 680         perror("can't realloc");
 681         exit(EXIT_FAILURE);
 682     }
 683
 684     return ptr;
 685 }
 686
 687 #define nkf_xfree(ptr) free(ptr)
 688
 689 static int
 690 nkf_str_caseeql(const char *src, const char *target)
 691 {
 692     int i;
 693     for (i = 0; src[i] && target[i]; i++) {
 694         if (nkf_toupper(src[i]) != nkf_toupper(target[i])) return FALSE;
 695     }
 696     if (src[i] || target[i]) return FALSE;
 697     else return TRUE;
 698 }
 699
 700 static nkf_encoding*
 701 nkf_enc_from_index(int idx)
 702 {
 703     if (idx < 0 || NKF_ENCODING_TABLE_SIZE <= idx) {
 704         return 0;
 705     }
 706     return &nkf_encoding_table[idx];
 707 }
 708
 709 static int
 710 nkf_enc_find_index(const char *name)
 711 {
 712     int i;
 713     if (name[0] == 'X' && *(name+1) == '-') name += 2;
 714     for (i = 0; encoding_name_to_id_table[i].id >= 0; i++) {
 715         if (nkf_str_caseeql(encoding_name_to_id_table[i].name, name)) {
 716             return encoding_name_to_id_table[i].id;
 717         }
 718     }
 719     return -1;
 720 }
 721
 722 static nkf_encoding*
 723 nkf_enc_find(const char *name)
 724 {
 725     int idx = -1;
 726     idx = nkf_enc_find_index(name);
 727     if (idx < 0) return 0;
 728     return nkf_enc_from_index(idx);
 729 }
 730
 731 #define nkf_enc_name(enc) (enc)->name
 732 #define nkf_enc_to_index(enc) (enc)->id
 733 #define nkf_enc_to_base_encoding(enc) (enc)->base_encoding
 734 #define nkf_enc_to_iconv(enc) nkf_enc_to_base_encoding(enc)->iconv
 735 #define nkf_enc_to_oconv(enc) nkf_enc_to_base_encoding(enc)->oconv
 736 #define nkf_enc_asciicompat(enc) (\
 737                                   nkf_enc_to_base_encoding(enc) == &NkfEncodingASCII ||\
 738                                   nkf_enc_to_base_encoding(enc) == &NkfEncodingISO_2022_JP)
 739 #define nkf_enc_unicode_p(enc) (\
 740                                 nkf_enc_to_base_encoding(enc) == &NkfEncodingUTF_8 ||\
 741                                 nkf_enc_to_base_encoding(enc) == &NkfEncodingUTF_16 ||\
 742                                 nkf_enc_to_base_encoding(enc) == &NkfEncodingUTF_32)
 743 #define nkf_enc_cp5022x_p(enc) (\
 744                                 nkf_enc_to_index(enc) == CP50220 ||\
 745                                 nkf_enc_to_index(enc) == CP50221 ||\
 746                                 nkf_enc_to_index(enc) == CP50222)
 747
 748 #ifdef DEFAULT_CODE_LOCALE
 749 static const char*
 750 nkf_locale_charmap()
 751 {
 752 #ifdef HAVE_LANGINFO_H
 753     return nl_langinfo(CODESET);
 754 #elif defined(__WIN32__)
 755     static char buf[16];
 756     sprintf(buf, "CP%d", GetACP());
 757     return buf;
 758 #elif defined(__OS2__)
 759 # if defined(INT_IS_SHORT)
 760     /* OS/2 1.x */
 761     return NULL;
 762 # else
 763     /* OS/2 32bit */
 764     static char buf[16];
 765     ULONG ulCP[1], ulncp;
 766     DosQueryCp(sizeof(ulCP), ulCP, &ulncp);
 767     if (ulCP[0] == 932 || ulCP[0] == 943)
 768         strcpy(buf, "Shift_JIS");
 769     else
 770         sprintf(buf, "CP%lu", ulCP[0]);
 771     return buf;
 772 # endif
 773 #endif
 774     return NULL;
 775 }
 776
 777 static nkf_encoding*
 778 nkf_locale_encoding()
 779 {
 780     nkf_encoding *enc = 0;
 781     const char *encname = nkf_locale_charmap();
 782     if (encname)
 783         enc = nkf_enc_find(encname);
 784     return enc;
 785 }
 786 #endif /* DEFAULT_CODE_LOCALE */
 787
 788 static nkf_encoding*
 789 nkf_utf8_encoding()
 790 {
 791     return &nkf_encoding_table[UTF_8];
 792 }
 793
 794 static nkf_encoding*
 795 nkf_default_encoding()
 796 {
 797     nkf_encoding *enc = 0;
 798 #ifdef DEFAULT_CODE_LOCALE
 799     enc = nkf_locale_encoding();
 800 #elif defined(DEFAULT_ENCIDX)
 801     enc = nkf_enc_from_index(DEFAULT_ENCIDX);
 802 #endif
 803     if (!enc) enc = nkf_utf8_encoding();
 804     return enc;
 805 }
 806
 807 typedef struct {
 808     long capa;
 809     long len;
 810     nkf_char *ptr;
 811 } nkf_buf_t;
 812
 813 static nkf_buf_t *
 814 nkf_buf_new(int length)
 815 {
 816     nkf_buf_t *buf = nkf_xmalloc(sizeof(nkf_buf_t));
 817     buf->ptr = nkf_xmalloc(length);
 818     buf->capa = length;
 819     buf->len = 0;
 820     return buf;
 821 }
 822
 823 #if 0
 824 static void
 825 nkf_buf_dispose(nkf_buf_t *buf)
 826 {
 827     nkf_xfree(buf->ptr);
 828     nkf_xfree(buf);
 829 }
 830 #endif
 831
 832 #define nkf_buf_length(buf) ((buf)->len)
 833 #define nkf_buf_empty_p(buf) ((buf)->len == 0)
 834
 835 static unsigned char
 836 nkf_buf_at(nkf_buf_t *buf, int index)
 837 {
 838     assert(index <= buf->len);
 839     return buf->ptr[index];
 840 }
 841
 842 static void
 843 nkf_buf_clear(nkf_buf_t *buf)
 844 {
 845     buf->len = 0;
 846 }
 847
 848 static void
 849 nkf_buf_push(nkf_buf_t *buf, nkf_char c)
 850 {
 851     if (buf->capa <= buf->len) {
 852         exit(EXIT_FAILURE);
 853     }
 854     buf->ptr[buf->len++] = c;
 855 }
 856
 857 static unsigned char
 858 nkf_buf_pop(nkf_buf_t *buf)
 859 {
 860     assert(!nkf_buf_empty_p(buf));
 861     return buf->ptr[--buf->len];
 862 }
 863
 864 /* Normalization Form C */
 865 #ifndef PERL_XS
 866 #ifdef WIN32DLL
 867 #define fprintf dllprintf
 868 #endif
 869
 870 static void
 871 version(void)
 872 {
 873     fprintf(HELP_OUTPUT,"Network Kanji Filter Version " NKF_VERSION " (" NKF_RELEASE_DATE ") \n" COPY_RIGHT "\n");
 874 }
 875
 876 static void
 877 usage(void)
 878 {
 879     fprintf(HELP_OUTPUT,
 880             "Usage:  nkf -[flags] [--] [in file] .. [out file for -O flag]\n"
 881 #ifdef UTF8_OUTPUT_ENABLE
 882             " j/s/e/w  Specify output encoding ISO-2022-JP, Shift_JIS, EUC-JP\n"
 883             "          UTF options is -w[8[0],{16,32}[{B,L}[0]]]\n"
 884 #else
 885 #endif
 886 #ifdef UTF8_INPUT_ENABLE
 887             " J/S/E/W  Specify input encoding ISO-2022-JP, Shift_JIS, EUC-JP\n"
 888             "          UTF option is -W[8,[16,32][B,L]]\n"
 889 #else
 890             " J/S/E    Specify output encoding ISO-2022-JP, Shift_JIS, EUC-JP\n"
 891 #endif
 892             );
 893     fprintf(HELP_OUTPUT,
 894             " m[BQSN0] MIME decode [B:base64,Q:quoted,S:strict,N:nonstrict,0:no decode]\n"
 895             " M[BQ]    MIME encode [B:base64 Q:quoted]\n"
 896             " f/F      Folding: -f60 or -f or -f60-10 (fold margin 10) F preserve nl\n"
 897             );
 898     fprintf(HELP_OUTPUT,
 899             " Z[0-4]   Default/0: Convert JISX0208 Alphabet to ASCII\n"
 900             "          1: Kankaku to one space  2: to two spaces  3: HTML Entity\n"
 901             "          4: JISX0208 Katakana to JISX0201 Katakana\n"
 902             " X,x      Assume X0201 kana in MS-Kanji, -x preserves X0201\n"
 903             );
 904     fprintf(HELP_OUTPUT,
 905             " O        Output to File (DEFAULT 'nkf.out')\n"
 906             " L[uwm]   Line mode u:LF w:CRLF m:CR (DEFAULT noconversion)\n"
 907             );
 908     fprintf(HELP_OUTPUT,
 909             " --ic=<encoding>        Specify the input encoding\n"
 910             " --oc=<encoding>        Specify the output encoding\n"
 911             " --hiragana --katakana  Hiragana/Katakana Conversion\n"
 912             " --katakana-hiragana    Converts each other\n"
 913             );
 914     fprintf(HELP_OUTPUT,
 915 #ifdef INPUT_OPTION
 916             " --{cap, url}-input     Convert hex after ':' or '%%'\n"
 917 #endif
 918 #ifdef NUMCHAR_OPTION
 919             " --numchar-input        Convert Unicode Character Reference\n"
 920 #endif
 921 #ifdef UTF8_INPUT_ENABLE
 922             " --fb-{skip, html, xml, perl, java, subchar}\n"
 923             "                        Specify unassigned character's replacement\n"
 924 #endif
 925             );
 926     fprintf(HELP_OUTPUT,
 927 #ifdef OVERWRITE
 928             " --in-place[=SUF]       Overwrite original files\n"
 929             " --overwrite[=SUF]      Preserve timestamp of original files\n"
 930 #endif
 931             " -g --guess             Guess the input code\n"
 932             " -v --version           Print the version\n"
 933             " --help/-V              Print this help / configuration\n"
 934             );
 935     version();
 936 }
 937
 938 static void
 939 show_configuration(void)
 940 {
 941     fprintf(HELP_OUTPUT,
 942             "Summary of my nkf " NKF_VERSION " (" NKF_RELEASE_DATE ") configuration:\n"
 943             "  Compile-time options:\n"
 944             "    Compiled at:                 " __DATE__ " " __TIME__ "\n"
 945            );
 946     fprintf(HELP_OUTPUT,
 947             "    Default output encoding:     "
 948 #ifdef DEFAULT_CODE_LOCALE
 949             "LOCALE (%s)\n", nkf_enc_name(nkf_default_encoding())
 950 #elif defined(DEFAULT_ENCIDX)
 951             "CONFIG (%s)\n", nkf_enc_name(nkf_default_encoding())
 952 #else
 953             "NONE\n"
 954 #endif
 955            );
 956     fprintf(HELP_OUTPUT,
 957             "    Default output end of line:  "
 958 #if DEFAULT_NEWLINE == CR
 959             "CR"
 960 #elif DEFAULT_NEWLINE == CRLF
 961             "CRLF"
 962 #else
 963             "LF"
 964 #endif
 965             "\n"
 966             "    Decode MIME encoded string:  "
 967 #if MIME_DECODE_DEFAULT
 968             "ON"
 969 #else
 970             "OFF"
 971 #endif
 972             "\n"
 973             "    Convert JIS X 0201 Katakana: "
 974 #if X0201_DEFAULT
 975             "ON"
 976 #else
 977             "OFF"
 978 #endif
 979             "\n"
 980             "    --help, --version output:    "
 981 #if HELP_OUTPUT_HELP_OUTPUT
 982             "HELP_OUTPUT"
 983 #else
 984             "STDOUT"
 985 #endif
 986             "\n");
 987 }
 988 #endif /*PERL_XS*/
 989
 990 #ifdef OVERWRITE
 991 static char*
 992 get_backup_filename(const char *suffix, const char *filename)
 993 {
 994     char *backup_filename;
 995     int asterisk_count = 0;
 996     int i, j;
 997     int filename_length = strlen(filename);
 998
 999     for(i = 0; suffix[i]; i++){
1000         if(suffix[i] == '*') asterisk_count++;
1001     }
1002
1003     if(asterisk_count){
1004         backup_filename = nkf_xmalloc(strlen(suffix) + (asterisk_count * (filename_length - 1)) + 1);
1005         for(i = 0, j = 0; suffix[i];){
1006             if(suffix[i] == '*'){
1007                 backup_filename[j] = '\0';
1008                 strncat(backup_filename, filename, filename_length);
1009                 i++;
1010                 j += filename_length;
1011             }else{
1012                 backup_filename[j++] = suffix[i++];
1013             }
1014         }
1015         backup_filename[j] = '\0';
1016     }else{
1017         j = filename_length + strlen(suffix);
1018         backup_filename = nkf_xmalloc(j + 1);
1019         strcpy(backup_filename, filename);
1020         strcat(backup_filename, suffix);
1021         backup_filename[j] = '\0';
1022     }
1023     return backup_filename;
1024 }
1025 #endif
1026
1027 #ifdef UTF8_INPUT_ENABLE
1028 static void
1029 nkf_each_char_to_hex(void (*f)(nkf_char c2,nkf_char c1), nkf_char c)
1030 {
1031     int shift = 20;
1032     c &= VALUE_MASK;
1033     while(shift >= 0){
1034         if(c >= NKF_INT32_C(1)<<shift){
1035             while(shift >= 0){
1036                 (*f)(0, bin2hex(c>>shift));
1037                 shift -= 4;
1038             }
1039         }else{
1040             shift -= 4;
1041         }
1042     }
1043     return;
1044 }
1045
1046 static void
1047 encode_fallback_html(nkf_char c)
1048 {
1049     (*oconv)(0, '&');
1050     (*oconv)(0, '#');
1051     c &= VALUE_MASK;
1052     if(c >= NKF_INT32_C(1000000))
1053         (*oconv)(0, 0x30+(c/NKF_INT32_C(1000000))%10);
1054     if(c >= NKF_INT32_C(100000))
1055         (*oconv)(0, 0x30+(c/NKF_INT32_C(100000) )%10);
1056     if(c >= 10000)
1057         (*oconv)(0, 0x30+(c/10000  )%10);
1058     if(c >= 1000)
1059         (*oconv)(0, 0x30+(c/1000   )%10);
1060     if(c >= 100)
1061         (*oconv)(0, 0x30+(c/100    )%10);
1062     if(c >= 10)
1063         (*oconv)(0, 0x30+(c/10     )%10);
1064     if(c >= 0)
1065         (*oconv)(0, 0x30+ c         %10);
1066     (*oconv)(0, ';');
1067     return;
1068 }
1069
1070 static void
1071 encode_fallback_xml(nkf_char c)
1072 {
1073     (*oconv)(0, '&');
1074     (*oconv)(0, '#');
1075     (*oconv)(0, 'x');
1076     nkf_each_char_to_hex(oconv, c);
1077     (*oconv)(0, ';');
1078     return;
1079 }
1080
1081 static void
1082 encode_fallback_java(nkf_char c)
1083 {
1084     (*oconv)(0, '\\');
1085     c &= VALUE_MASK;
1086     if(!nkf_char_unicode_bmp_p(c)){
1087         (*oconv)(0, 'U');
1088         (*oconv)(0, '0');
1089         (*oconv)(0, '0');
1090         (*oconv)(0, bin2hex(c>>20));
1091         (*oconv)(0, bin2hex(c>>16));
1092     }else{
1093         (*oconv)(0, 'u');
1094     }
1095     (*oconv)(0, bin2hex(c>>12));
1096     (*oconv)(0, bin2hex(c>> 8));
1097     (*oconv)(0, bin2hex(c>> 4));
1098     (*oconv)(0, bin2hex(c    ));
1099     return;
1100 }
1101
1102 static void
1103 encode_fallback_perl(nkf_char c)
1104 {
1105     (*oconv)(0, '\\');
1106     (*oconv)(0, 'x');
1107     (*oconv)(0, '{');
1108     nkf_each_char_to_hex(oconv, c);
1109     (*oconv)(0, '}');
1110     return;
1111 }
1112
1113 static void
1114 encode_fallback_subchar(nkf_char c)
1115 {
1116     c = unicode_subchar;
1117     (*oconv)((c>>8)&0xFF, c&0xFF);
1118     return;
1119 }
1120 #endif
1121
1122 static const struct {
1123     const char *name;
1124     const char *alias;
1125 } long_option[] = {
1126     {"ic=", ""},
1127     {"oc=", ""},
1128     {"base64","jMB"},
1129     {"euc","e"},
1130     {"euc-input","E"},
1131     {"fj","jm"},
1132     {"help",""},
1133     {"jis","j"},
1134     {"jis-input","J"},
1135     {"mac","sLm"},
1136     {"mime","jM"},
1137     {"mime-input","m"},
1138     {"msdos","sLw"},
1139     {"sjis","s"},
1140     {"sjis-input","S"},
1141     {"unix","eLu"},
1142     {"version","v"},
1143     {"windows","sLw"},
1144     {"hiragana","h1"},
1145     {"katakana","h2"},
1146     {"katakana-hiragana","h3"},
1147     {"guess=", ""},
1148     {"guess", "g2"},
1149     {"cp932", ""},
1150     {"no-cp932", ""},
1151 #ifdef X0212_ENABLE
1152     {"x0212", ""},
1153 #endif
1154 #ifdef UTF8_OUTPUT_ENABLE
1155     {"utf8", "w"},
1156     {"utf16", "w16"},
1157     {"ms-ucs-map", ""},
1158     {"fb-skip", ""},
1159     {"fb-html", ""},
1160     {"fb-xml", ""},
1161     {"fb-perl", ""},
1162     {"fb-java", ""},
1163     {"fb-subchar", ""},
1164     {"fb-subchar=", ""},
1165 #endif
1166 #ifdef UTF8_INPUT_ENABLE
1167     {"utf8-input", "W"},
1168     {"utf16-input", "W16"},
1169     {"no-cp932ext", ""},
1170     {"no-best-fit-chars",""},
1171 #endif
1172 #ifdef UNICODE_NORMALIZATION
1173     {"utf8mac-input", ""},
1174 #endif
1175 #ifdef OVERWRITE
1176     {"overwrite", ""},
1177     {"overwrite=", ""},
1178     {"in-place", ""},
1179     {"in-place=", ""},
1180 #endif
1181 #ifdef INPUT_OPTION
1182     {"cap-input", ""},
1183     {"url-input", ""},
1184 #endif
1185 #ifdef NUMCHAR_OPTION
1186     {"numchar-input", ""},
1187 #endif
1188 #ifdef CHECK_OPTION
1189     {"no-output", ""},
1190     {"debug", ""},
1191 #endif
1192 #ifdef SHIFTJIS_CP932
1193     {"cp932inv", ""},
1194 #endif
1195 #ifdef EXEC_IO
1196     {"exec-in", ""},
1197     {"exec-out", ""},
1198 #endif
1199     {"prefix=", ""},
1200 };
1201
1202 static void
1203 set_input_encoding(nkf_encoding *enc)
1204 {
1205     switch (nkf_enc_to_index(enc)) {
1206     case ISO_8859_1:
1207         iso8859_f = TRUE;
1208         break;
1209     case CP50220:
1210     case CP50221:
1211     case CP50222:
1212         x0201_f = TRUE;
1213 #ifdef SHIFTJIS_CP932
1214         cp51932_f = TRUE;
1215 #endif
1216 #ifdef UTF8_OUTPUT_ENABLE
1217         ms_ucs_map_f = UCS_MAP_CP932;
1218 #endif
1219         break;
1220     case ISO_2022_JP_1:
1221         x0212_f = TRUE;
1222         break;
1223     case ISO_2022_JP_3:
1224         x0212_f = TRUE;
1225         x0213_f = TRUE;
1226         break;
1227     case ISO_2022_JP_2004:
1228         x0212_f = TRUE;
1229         x0213_f = TRUE;
1230         break;
1231     case SHIFT_JIS:
1232         break;
1233     case WINDOWS_31J:
1234         x0201_f = TRUE;
1235 #ifdef SHIFTJIS_CP932
1236         cp51932_f = TRUE;
1237 #endif
1238 #ifdef UTF8_OUTPUT_ENABLE
1239         ms_ucs_map_f = UCS_MAP_CP932;
1240 #endif
1241         break;
1242         break;
1243     case CP10001:
1244 #ifdef SHIFTJIS_CP932
1245         cp51932_f = TRUE;
1246 #endif
1247 #ifdef UTF8_OUTPUT_ENABLE
1248         ms_ucs_map_f = UCS_MAP_CP10001;
1249 #endif
1250         break;
1251     case EUC_JP:
1252         break;
1253     case EUCJP_NKF:
1254         break;
1255     case CP51932:
1256         x0201_f = TRUE;
1257 #ifdef SHIFTJIS_CP932
1258         cp51932_f = TRUE;
1259 #endif
1260 #ifdef UTF8_OUTPUT_ENABLE
1261         ms_ucs_map_f = UCS_MAP_CP932;
1262 #endif
1263         break;
1264     case EUCJP_MS:
1265 #ifdef SHIFTJIS_CP932
1266         cp51932_f = FALSE;
1267 #endif
1268 #ifdef UTF8_OUTPUT_ENABLE
1269         ms_ucs_map_f = UCS_MAP_MS;
1270 #endif
1271         break;
1272     case EUCJP_ASCII:
1273 #ifdef SHIFTJIS_CP932
1274         cp51932_f = FALSE;
1275 #endif
1276 #ifdef UTF8_OUTPUT_ENABLE
1277         ms_ucs_map_f = UCS_MAP_ASCII;
1278 #endif
1279         break;
1280     case SHIFT_JISX0213:
1281     case SHIFT_JIS_2004:
1282         x0213_f = TRUE;
1283 #ifdef SHIFTJIS_CP932
1284         cp51932_f = FALSE;
1285 #endif
1286         break;
1287     case EUC_JISX0213:
1288     case EUC_JIS_2004:
1289         x0213_f = TRUE;
1290 #ifdef SHIFTJIS_CP932
1291         cp51932_f = FALSE;
1292 #endif
1293         break;
1294 #ifdef UTF8_INPUT_ENABLE
1295 #ifdef UNICODE_NORMALIZATION
1296     case UTF8_MAC:
1297         nfc_f = TRUE;
1298         break;
1299 #endif
1300     case UTF_16:
1301     case UTF_16BE:
1302     case UTF_16BE_BOM:
1303         input_endian = ENDIAN_BIG;
1304         break;
1305     case UTF_16LE:
1306     case UTF_16LE_BOM:
1307         input_endian = ENDIAN_LITTLE;
1308         break;
1309     case UTF_32:
1310     case UTF_32BE:
1311     case UTF_32BE_BOM:
1312         input_endian = ENDIAN_BIG;
1313         break;
1314     case UTF_32LE:
1315     case UTF_32LE_BOM:
1316         input_endian = ENDIAN_LITTLE;
1317         break;
1318 #endif
1319     }
1320 }
1321
1322 static void
1323 set_output_encoding(nkf_encoding *enc)
1324 {
1325     switch (nkf_enc_to_index(enc)) {
1326     case CP50220:
1327         x0201_f = TRUE;
1328 #ifdef SHIFTJIS_CP932
1329         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1330 #endif
1331 #ifdef UTF8_OUTPUT_ENABLE
1332         ms_ucs_map_f = UCS_MAP_CP932;
1333 #endif
1334         break;
1335     case CP50221:
1336         x0201_f = TRUE;
1337 #ifdef SHIFTJIS_CP932
1338         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1339 #endif
1340 #ifdef UTF8_OUTPUT_ENABLE
1341         ms_ucs_map_f = UCS_MAP_CP932;
1342 #endif
1343         break;
1344     case ISO_2022_JP:
1345 #ifdef SHIFTJIS_CP932
1346         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1347 #endif
1348         break;
1349     case ISO_2022_JP_1:
1350         x0212_f = TRUE;
1351 #ifdef SHIFTJIS_CP932
1352         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1353 #endif
1354         break;
1355     case ISO_2022_JP_3:
1356         x0212_f = TRUE;
1357         x0213_f = TRUE;
1358 #ifdef SHIFTJIS_CP932
1359         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1360 #endif
1361         break;
1362     case SHIFT_JIS:
1363         break;
1364     case WINDOWS_31J:
1365         x0201_f = TRUE;
1366 #ifdef UTF8_OUTPUT_ENABLE
1367         ms_ucs_map_f = UCS_MAP_CP932;
1368 #endif
1369         break;
1370     case CP10001:
1371 #ifdef UTF8_OUTPUT_ENABLE
1372         ms_ucs_map_f = UCS_MAP_CP10001;
1373 #endif
1374         break;
1375     case EUC_JP:
1376         x0212_f = TRUE;
1377 #ifdef SHIFTJIS_CP932
1378         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1379 #endif
1380 #ifdef UTF8_OUTPUT_ENABLE
1381         ms_ucs_map_f = UCS_MAP_ASCII;
1382 #endif
1383         break;
1384     case EUCJP_NKF:
1385         x0212_f = FALSE;
1386 #ifdef SHIFTJIS_CP932
1387         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1388 #endif
1389 #ifdef UTF8_OUTPUT_ENABLE
1390         ms_ucs_map_f = UCS_MAP_ASCII;
1391 #endif
1392         break;
1393     case CP51932:
1394         x0201_f = TRUE;
1395 #ifdef SHIFTJIS_CP932
1396         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1397 #endif
1398 #ifdef UTF8_OUTPUT_ENABLE
1399         ms_ucs_map_f = UCS_MAP_CP932;
1400 #endif
1401         break;
1402     case EUCJP_MS:
1403         x0212_f = TRUE;
1404 #ifdef UTF8_OUTPUT_ENABLE
1405         ms_ucs_map_f = UCS_MAP_MS;
1406 #endif
1407         break;
1408     case EUCJP_ASCII:
1409         x0212_f = TRUE;
1410 #ifdef UTF8_OUTPUT_ENABLE
1411         ms_ucs_map_f = UCS_MAP_ASCII;
1412 #endif
1413         break;
1414     case SHIFT_JISX0213:
1415     case SHIFT_JIS_2004:
1416         x0213_f = TRUE;
1417 #ifdef SHIFTJIS_CP932
1418         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1419 #endif
1420         break;
1421     case EUC_JISX0213:
1422     case EUC_JIS_2004:
1423         x0212_f = TRUE;
1424         x0213_f = TRUE;
1425 #ifdef SHIFTJIS_CP932
1426         if (cp932inv_f == TRUE) cp932inv_f = FALSE;
1427 #endif
1428         break;
1429 #ifdef UTF8_OUTPUT_ENABLE
1430     case UTF_8_BOM:
1431         output_bom_f = TRUE;
1432         break;
1433     case UTF_16:
1434     case UTF_16BE_BOM:
1435         output_bom_f = TRUE;
1436         break;
1437     case UTF_16LE:
1438         output_endian = ENDIAN_LITTLE;
1439         output_bom_f = FALSE;
1440         break;
1441     case UTF_16LE_BOM:
1442         output_endian = ENDIAN_LITTLE;
1443         output_bom_f = TRUE;
1444         break;
1445     case UTF_32:
1446     case UTF_32BE_BOM:
1447         output_bom_f = TRUE;
1448         break;
1449     case UTF_32LE:
1450         output_endian = ENDIAN_LITTLE;
1451         output_bom_f = FALSE;
1452         break;
1453     case UTF_32LE_BOM:
1454         output_endian = ENDIAN_LITTLE;
1455         output_bom_f = TRUE;
1456         break;
1457 #endif
1458     }
1459 }
1460
1461 static struct input_code*
1462 find_inputcode_byfunc(nkf_char (*iconv_func)(nkf_char c2,nkf_char c1,nkf_char c0))
1463 {
1464     if (iconv_func){
1465         struct input_code *p = input_code_list;
1466         while (p->name){
1467             if (iconv_func == p->iconv_func){
1468                 return p;
1469             }
1470             p++;
1471         }
1472     }
1473     return 0;
1474 }
1475
1476 static void
1477 set_iconv(nkf_char f, nkf_char (*iconv_func)(nkf_char c2,nkf_char c1,nkf_char c0))
1478 {
1479 #ifdef INPUT_CODE_FIX
1480     if (f || !input_encoding)
1481 #endif
1482         if (estab_f != f){
1483             estab_f = f;
1484         }
1485
1486     if (iconv_func
1487 #ifdef INPUT_CODE_FIX
1488         && (f == -TRUE || !input_encoding) /* -TRUE means "FORCE" */
1489 #endif
1490        ){
1491         iconv = iconv_func;
1492     }
1493 #ifdef CHECK_OPTION
1494     if (estab_f && iconv_for_check != iconv){
1495         struct input_code *p = find_inputcode_byfunc(iconv);
1496         if (p){
1497             set_input_codename(p->name);
1498             debug(p->name);
1499         }
1500         iconv_for_check = iconv;
1501     }
1502 #endif
1503 }
1504
1505 #ifdef X0212_ENABLE
1506 static nkf_char
1507 x0212_shift(nkf_char c)
1508 {
1509     nkf_char ret = c;
1510     c &= 0x7f;
1511     if (is_eucg3(ret)){
1512         if (0x75 <= c && c <= 0x7f){
1513             ret = c + (0x109 - 0x75);
1514         }
1515     }else{
1516         if (0x75 <= c && c <= 0x7f){
1517             ret = c + (0x113 - 0x75);
1518         }
1519     }
1520     return ret;
1521 }
1522
1523
1524 static nkf_char
1525 x0212_unshift(nkf_char c)
1526 {
1527     nkf_char ret = c;
1528     if (0x7f <= c && c <= 0x88){
1529         ret = c + (0x75 - 0x7f);
1530     }else if (0x89 <= c && c <= 0x92){
1531         ret = PREFIX_EUCG3 | 0x80 | (c + (0x75 - 0x89));
1532     }
1533     return ret;
1534 }
1535 #endif /* X0212_ENABLE */
1536
1537 static nkf_char
1538 e2s_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
1539 {
1540     nkf_char ndx;
1541     if (is_eucg3(c2)){
1542         ndx = c2 & 0x7f;
1543         if (x0213_f){
1544             if((0x21 <= ndx && ndx <= 0x2F)){
1545                 if (p2) *p2 = ((ndx - 1) >> 1) + 0xec - ndx / 8 * 3;
1546                 if (p1) *p1 = c1 + ((ndx & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
1547                 return 0;
1548             }else if(0x6E <= ndx && ndx <= 0x7E){
1549                 if (p2) *p2 = ((ndx - 1) >> 1) + 0xbe;
1550                 if (p1) *p1 = c1 + ((ndx & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
1551                 return 0;
1552             }
1553             return 1;
1554         }
1555 #ifdef X0212_ENABLE
1556         else if(nkf_isgraph(ndx)){
1557             nkf_char val = 0;
1558             const unsigned short *ptr;
1559             ptr = x0212_shiftjis[ndx - 0x21];
1560             if (ptr){
1561                 val = ptr[(c1 & 0x7f) - 0x21];
1562             }
1563             if (val){
1564                 c2 = val >> 8;
1565                 c1 = val & 0xff;
1566                 if (p2) *p2 = c2;
1567                 if (p1) *p1 = c1;
1568                 return 0;
1569             }
1570             c2 = x0212_shift(c2);
1571         }
1572 #endif /* X0212_ENABLE */
1573     }
1574     if(0x7F < c2) return 1;
1575     if (p2) *p2 = ((c2 - 1) >> 1) + ((c2 <= 0x5e) ? 0x71 : 0xb1);
1576     if (p1) *p1 = c1 + ((c2 & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
1577     return 0;
1578 }
1579
1580 static nkf_char
1581 s2e_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
1582 {
1583 #if defined(SHIFTJIS_CP932) || defined(X0212_ENABLE)
1584     nkf_char val;
1585 #endif
1586     static const char shift_jisx0213_s1a3_table[5][2] ={ { 1, 8}, { 3, 4}, { 5,12}, {13,14}, {15, 0} };
1587     if (0xFC < c1) return 1;
1588 #ifdef SHIFTJIS_CP932
1589     if (!cp932inv_f && is_ibmext_in_sjis(c2)){
1590         val = shiftjis_cp932[c2 - CP932_TABLE_BEGIN][c1 - 0x40];
1591         if (val){
1592             c2 = val >> 8;
1593             c1 = val & 0xff;
1594         }
1595     }
1596     if (cp932inv_f
1597         && CP932INV_TABLE_BEGIN <= c2 && c2 <= CP932INV_TABLE_END){
1598         val = cp932inv[c2 - CP932INV_TABLE_BEGIN][c1 - 0x40];
1599         if (val){
1600             c2 = val >> 8;
1601             c1 = val & 0xff;
1602         }
1603     }
1604 #endif /* SHIFTJIS_CP932 */
1605 #ifdef X0212_ENABLE
1606     if (!x0213_f && is_ibmext_in_sjis(c2)){
1607         val = shiftjis_x0212[c2 - 0xfa][c1 - 0x40];
1608         if (val){
1609             if (val > 0x7FFF){
1610                 c2 = PREFIX_EUCG3 | ((val >> 8) & 0x7f);
1611                 c1 = val & 0xff;
1612             }else{
1613                 c2 = val >> 8;
1614                 c1 = val & 0xff;
1615             }
1616             if (p2) *p2 = c2;
1617             if (p1) *p1 = c1;
1618             return 0;
1619         }
1620     }
1621 #endif
1622     if(c2 >= 0x80){
1623         if(x0213_f && c2 >= 0xF0){
1624             if(c2 <= 0xF3 || (c2 == 0xF4 && c1 < 0x9F)){ /* k=1, 3<=k<=5, k=8, 12<=k<=15 */
1625                 c2 = PREFIX_EUCG3 | 0x20 | shift_jisx0213_s1a3_table[c2 - 0xF0][0x9E < c1];
1626             }else{ /* 78<=k<=94 */
1627                 c2 = PREFIX_EUCG3 | (c2 * 2 - 0x17B);
1628                 if (0x9E < c1) c2++;
1629             }
1630         }else{
1631 #define         SJ0162  0x00e1          /* 01 - 62 ku offset */
1632 #define         SJ6394  0x0161          /* 63 - 94 ku offset */
1633             c2 = c2 + c2 - ((c2 <= 0x9F) ? SJ0162 : SJ6394);
1634             if (0x9E < c1) c2++;
1635         }
1636         if (c1 < 0x9F)
1637             c1 = c1 - ((c1 > DEL) ? SP : 0x1F);
1638         else {
1639             c1 = c1 - 0x7E;
1640         }
1641     }
1642
1643 #ifdef X0212_ENABLE
1644     c2 = x0212_unshift(c2);
1645 #endif
1646     if (p2) *p2 = c2;
1647     if (p1) *p1 = c1;
1648     return 0;
1649 }
1650
1651 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
1652 static void
1653 nkf_unicode_to_utf8(nkf_char val, nkf_char *p1, nkf_char *p2, nkf_char *p3, nkf_char *p4)
1654 {
1655     val &= VALUE_MASK;
1656     if (val < 0x80){
1657         *p1 = val;
1658         *p2 = 0;
1659         *p3 = 0;
1660         *p4 = 0;
1661     }else if (val < 0x800){
1662         *p1 = 0xc0 | (val >> 6);
1663         *p2 = 0x80 | (val & 0x3f);
1664         *p3 = 0;
1665         *p4 = 0;
1666     } else if (nkf_char_unicode_bmp_p(val)) {
1667         *p1 = 0xe0 |  (val >> 12);
1668         *p2 = 0x80 | ((val >>  6) & 0x3f);
1669         *p3 = 0x80 | ( val        & 0x3f);
1670         *p4 = 0;
1671     } else if (nkf_char_unicode_value_p(val)) {
1672         *p1 = 0xf0 |  (val >> 18);
1673         *p2 = 0x80 | ((val >> 12) & 0x3f);
1674         *p3 = 0x80 | ((val >>  6) & 0x3f);
1675         *p4 = 0x80 | ( val        & 0x3f);
1676     } else {
1677         *p1 = 0;
1678         *p2 = 0;
1679         *p3 = 0;
1680         *p4 = 0;
1681     }
1682 }
1683
1684 static nkf_char
1685 nkf_utf8_to_unicode(nkf_char c1, nkf_char c2, nkf_char c3, nkf_char c4)
1686 {
1687     nkf_char wc;
1688     if (c1 <= 0x7F) {
1689         /* single byte */
1690         wc = c1;
1691     }
1692     else if (c1 <= 0xC3) {
1693         /* trail byte or invalid */
1694         return -1;
1695     }
1696     else if (c1 <= 0xDF) {
1697         /* 2 bytes */
1698         wc  = (c1 & 0x1F) << 6;
1699         wc |= (c2 & 0x3F);
1700     }
1701     else if (c1 <= 0xEF) {
1702         /* 3 bytes */
1703         wc  = (c1 & 0x0F) << 12;
1704         wc |= (c2 & 0x3F) << 6;
1705         wc |= (c3 & 0x3F);
1706     }
1707     else if (c2 <= 0xF4) {
1708         /* 4 bytes */
1709         wc  = (c1 & 0x0F) << 18;
1710         wc |= (c2 & 0x3F) << 12;
1711         wc |= (c3 & 0x3F) << 6;
1712         wc |= (c4 & 0x3F);
1713     }
1714     else {
1715         return -1;
1716     }
1717     return wc;
1718 }
1719 #endif
1720
1721 #ifdef UTF8_INPUT_ENABLE
1722 static int
1723 unicode_to_jis_common2(nkf_char c1, nkf_char c0,
1724                        const unsigned short *const *pp, nkf_char psize,
1725                        nkf_char *p2, nkf_char *p1)
1726 {
1727     nkf_char c2;
1728     const unsigned short *p;
1729     unsigned short val;
1730
1731     if (pp == 0) return 1;
1732
1733     c1 -= 0x80;
1734     if (c1 < 0 || psize <= c1) return 1;
1735     p = pp[c1];
1736     if (p == 0)  return 1;
1737
1738     c0 -= 0x80;
1739     if (c0 < 0 || sizeof_utf8_to_euc_C2 <= c0) return 1;
1740     val = p[c0];
1741     if (val == 0) return 1;
1742     if (no_cp932ext_f && (
1743                           (val>>8) == 0x2D || /* NEC special characters */
1744                           val > NKF_INT32_C(0xF300) /* IBM extended characters */
1745                          )) return 1;
1746
1747     c2 = val >> 8;
1748     if (val > 0x7FFF){
1749         c2 &= 0x7f;
1750         c2 |= PREFIX_EUCG3;
1751     }
1752     if (c2 == SO) c2 = JIS_X_0201_1976_K;
1753     c1 = val & 0xFF;
1754     if (p2) *p2 = c2;
1755     if (p1) *p1 = c1;
1756     return 0;
1757 }
1758
1759 static int
1760 unicode_to_jis_common(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *p2, nkf_char *p1)
1761 {
1762     const unsigned short *const *pp;
1763     const unsigned short *const *const *ppp;
1764     static const char no_best_fit_chars_table_C2[] =
1765     {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1766         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1767         1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 2, 1, 1, 2,
1768         0, 0, 1, 1, 0, 1, 0, 1, 2, 1, 1, 1, 1, 1, 1, 1};
1769     static const char no_best_fit_chars_table_C2_ms[] =
1770     {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1771         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1772         1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
1773         0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0};
1774     static const char no_best_fit_chars_table_932_C2[] =
1775     {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1776         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1777         1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
1778         0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0};
1779     static const char no_best_fit_chars_table_932_C3[] =
1780     {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1781         1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
1782         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1783         1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1};
1784     nkf_char ret = 0;
1785
1786     if(c2 < 0x80){
1787         *p2 = 0;
1788         *p1 = c2;
1789     }else if(c2 < 0xe0){
1790         if(no_best_fit_chars_f){
1791             if(ms_ucs_map_f == UCS_MAP_CP932){
1792                 switch(c2){
1793                 case 0xC2:
1794                     if(no_best_fit_chars_table_932_C2[c1&0x3F]) return 1;
1795                     break;
1796                 case 0xC3:
1797                     if(no_best_fit_chars_table_932_C3[c1&0x3F]) return 1;
1798                     break;
1799                 }
1800             }else if(!cp932inv_f){
1801                 switch(c2){
1802                 case 0xC2:
1803                     if(no_best_fit_chars_table_C2[c1&0x3F]) return 1;
1804                     break;
1805                 case 0xC3:
1806                     if(no_best_fit_chars_table_932_C3[c1&0x3F]) return 1;
1807                     break;
1808                 }
1809             }else if(ms_ucs_map_f == UCS_MAP_MS){
1810                 if(c2 == 0xC2 && no_best_fit_chars_table_C2_ms[c1&0x3F]) return 1;
1811             }else if(ms_ucs_map_f == UCS_MAP_CP10001){
1812                 switch(c2){
1813                 case 0xC2:
1814                     switch(c1){
1815                     case 0xA2:
1816                     case 0xA3:
1817                     case 0xA5:
1818                     case 0xA6:
1819                     case 0xAC:
1820                     case 0xAF:
1821                     case 0xB8:
1822                         return 1;
1823                     }
1824                     break;
1825                 }
1826             }
1827         }
1828         pp =
1829             ms_ucs_map_f == UCS_MAP_CP932 ? utf8_to_euc_2bytes_932 :
1830             ms_ucs_map_f == UCS_MAP_MS ? utf8_to_euc_2bytes_ms :
1831             ms_ucs_map_f == UCS_MAP_CP10001 ? utf8_to_euc_2bytes_mac :
1832             utf8_to_euc_2bytes;
1833         ret =  unicode_to_jis_common2(c2, c1, pp, sizeof_utf8_to_euc_2bytes, p2, p1);
1834     }else if(c0 < 0xF0){
1835         if(no_best_fit_chars_f){
1836             if(ms_ucs_map_f == UCS_MAP_CP932){
1837                 if(c2 == 0xE3 && c1 == 0x82 && c0 == 0x94) return 1;
1838             }else if(ms_ucs_map_f == UCS_MAP_MS){
1839                 switch(c2){
1840                 case 0xE2:
1841                     switch(c1){
1842                     case 0x80:
1843                         if(c0 == 0x94 || c0 == 0x96 || c0 == 0xBE) return 1;
1844                         break;
1845                     case 0x88:
1846                         if(c0 == 0x92) return 1;
1847                         break;
1848                     }
1849                     break;
1850                 case 0xE3:
1851                     if(c1 == 0x80 || c0 == 0x9C) return 1;
1852                     break;
1853                 }
1854             }else if(ms_ucs_map_f == UCS_MAP_CP10001){
1855                 switch(c2){
1856                 case 0xE3:
1857                     switch(c1){
1858                     case 0x82:
1859                         if(c0 == 0x94) return 1;
1860                         break;
1861                     case 0x83:
1862                         if(c0 == 0xBB) return 1;
1863                         break;
1864                     }
1865                     break;
1866                 }
1867             }else{
1868                 switch(c2){
1869                 case 0xE2:
1870                     switch(c1){
1871                     case 0x80:
1872                         if(c0 == 0x95) return 1;
1873                         break;
1874                     case 0x88:
1875                         if(c0 == 0xA5) return 1;
1876                         break;
1877                     }
1878                     break;
1879                 case 0xEF:
1880                     switch(c1){
1881                     case 0xBC:
1882                         if(c0 == 0x8D) return 1;
1883                         break;
1884                     case 0xBD:
1885                         if(c0 == 0x9E && !cp932inv_f) return 1;
1886                         break;
1887                     case 0xBF:
1888                         if(0xA0 <= c0 && c0 <= 0xA5) return 1;
1889                         break;
1890                     }
1891                     break;
1892                 }
1893             }
1894         }
1895         ppp =
1896             ms_ucs_map_f == UCS_MAP_CP932 ? utf8_to_euc_3bytes_932 :
1897             ms_ucs_map_f == UCS_MAP_MS ? utf8_to_euc_3bytes_ms :
1898             ms_ucs_map_f == UCS_MAP_CP10001 ? utf8_to_euc_3bytes_mac :
1899             utf8_to_euc_3bytes;
1900         ret = unicode_to_jis_common2(c1, c0, ppp[c2 - 0xE0], sizeof_utf8_to_euc_C2, p2, p1);
1901     }else return -1;
1902 #ifdef SHIFTJIS_CP932
1903     if (!ret && !cp932inv_f && is_eucg3(*p2)) {
1904         nkf_char s2, s1;
1905         if (e2s_conv(*p2, *p1, &s2, &s1) == 0) {
1906             s2e_conv(s2, s1, p2, p1);
1907         }else{
1908             ret = 1;
1909         }
1910     }
1911 #endif
1912     return ret;
1913 }
1914
1915 #ifdef UTF8_OUTPUT_ENABLE
1916 static nkf_char
1917 e2w_conv(nkf_char c2, nkf_char c1)
1918 {
1919     const unsigned short *p;
1920
1921     if (c2 == JIS_X_0201_1976_K) {
1922         if (ms_ucs_map_f == UCS_MAP_CP10001) {
1923             switch (c1) {
1924             case 0x20:
1925                 return 0xA0;
1926             case 0x7D:
1927                 return 0xA9;
1928             }
1929         }
1930         p = euc_to_utf8_1byte;
1931 #ifdef X0212_ENABLE
1932     } else if (is_eucg3(c2)){
1933         if(ms_ucs_map_f == UCS_MAP_ASCII&& c2 == NKF_INT32_C(0x8F22) && c1 == 0x43){
1934             return 0xA6;
1935         }
1936         c2 = (c2&0x7f) - 0x21;
1937         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
1938             p = x0212_to_utf8_2bytes[c2];
1939         else
1940             return 0;
1941 #endif
1942     } else {
1943         c2 &= 0x7f;
1944         c2 = (c2&0x7f) - 0x21;
1945         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
1946             p =
1947                 ms_ucs_map_f == UCS_MAP_ASCII ? euc_to_utf8_2bytes[c2] :
1948                 ms_ucs_map_f == UCS_MAP_CP10001 ? euc_to_utf8_2bytes_mac[c2] :
1949                 euc_to_utf8_2bytes_ms[c2];
1950         else
1951             return 0;
1952     }
1953     if (!p) return 0;
1954     c1 = (c1 & 0x7f) - 0x21;
1955     if (0<=c1 && c1<sizeof_euc_to_utf8_1byte)
1956         return p[c1];
1957     return 0;
1958 }
1959 #endif
1960
1961 static nkf_char
1962 w2e_conv(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *p2, nkf_char *p1)
1963 {
1964     nkf_char ret = 0;
1965
1966     if (!c1){
1967         *p2 = 0;
1968         *p1 = c2;
1969     }else if (0xc0 <= c2 && c2 <= 0xef) {
1970         ret =  unicode_to_jis_common(c2, c1, c0, p2, p1);
1971 #ifdef NUMCHAR_OPTION
1972         if (ret > 0){
1973             if (p2) *p2 = 0;
1974             if (p1) *p1 = nkf_char_unicode_new(nkf_utf8_to_unicode(c2, c1, c0, 0));
1975             ret = 0;
1976         }
1977 #endif
1978     }
1979     return ret;
1980 }
1981
1982 #ifdef UTF8_INPUT_ENABLE
1983 static nkf_char
1984 w16e_conv(nkf_char val, nkf_char *p2, nkf_char *p1)
1985 {
1986     nkf_char c1, c2, c3, c4;
1987     nkf_char ret = 0;
1988     val &= VALUE_MASK;
1989     if (val < 0x80) {
1990         *p2 = 0;
1991         *p1 = val;
1992     }
1993     else if (nkf_char_unicode_bmp_p(val)){
1994         nkf_unicode_to_utf8(val, &c1, &c2, &c3, &c4);
1995         ret =  unicode_to_jis_common(c1, c2, c3, p2, p1);
1996         if (ret > 0){
1997             *p2 = 0;
1998             *p1 = nkf_char_unicode_new(val);
1999             ret = 0;
2000         }
2001     }
2002     else {
2003         *p2 = 0;
2004         *p1 = nkf_char_unicode_new(val);
2005     }
2006     return ret;
2007 }
2008 #endif
2009
2010 static nkf_char
2011 e_iconv(nkf_char c2, nkf_char c1, nkf_char c0)
2012 {
2013     if (c2 == JIS_X_0201_1976_K || c2 == SS2){
2014         if (iso2022jp_f && !x0201_f) {
2015             c2 = GETA1; c1 = GETA2;
2016         } else {
2017             c2 = JIS_X_0201_1976_K;
2018             c1 &= 0x7f;
2019         }
2020 #ifdef X0212_ENABLE
2021     }else if (c2 == 0x8f){
2022         if (c0 == 0){
2023             return -1;
2024         }
2025         if (!cp51932_f && !x0213_f && 0xF5 <= c1 && c1 <= 0xFE && 0xA1 <= c0 && c0 <= 0xFE) {
2026             /* encoding is eucJP-ms, so invert to Unicode Private User Area */
2027             c1 = nkf_char_unicode_new((c1 - 0xF5) * 94 + c0 - 0xA1 + 0xE3AC);
2028             c2 = 0;
2029         } else {
2030             c2 = (c2 << 8) | (c1 & 0x7f);
2031             c1 = c0 & 0x7f;
2032 #ifdef SHIFTJIS_CP932
2033             if (cp51932_f){
2034                 nkf_char s2, s1;
2035                 if (e2s_conv(c2, c1, &s2, &s1) == 0){
2036                     s2e_conv(s2, s1, &c2, &c1);
2037                     if (c2 < 0x100){
2038                         c1 &= 0x7f;
2039                         c2 &= 0x7f;
2040                     }
2041                 }
2042             }
2043 #endif /* SHIFTJIS_CP932 */
2044         }
2045 #endif /* X0212_ENABLE */
2046     } else if ((c2 == EOF) || (c2 == 0) || c2 < SP || c2 == ISO_8859_1) {
2047         /* NOP */
2048     } else {
2049         if (!cp51932_f && ms_ucs_map_f && 0xF5 <= c2 && c2 <= 0xFE && 0xA1 <= c1 && c1 <= 0xFE) {
2050             /* encoding is eucJP-ms, so invert to Unicode Private User Area */
2051             c1 = nkf_char_unicode_new((c2 - 0xF5) * 94 + c1 - 0xA1 + 0xE000);
2052             c2 = 0;
2053         } else {
2054             c1 &= 0x7f;
2055             c2 &= 0x7f;
2056 #ifdef SHIFTJIS_CP932
2057             if (cp51932_f && 0x79 <= c2 && c2 <= 0x7c){
2058                 nkf_char s2, s1;
2059                 if (e2s_conv(c2, c1, &s2, &s1) == 0){
2060                     s2e_conv(s2, s1, &c2, &c1);
2061                     if (c2 < 0x100){
2062                         c1 &= 0x7f;
2063                         c2 &= 0x7f;
2064                     }
2065                 }
2066             }
2067 #endif /* SHIFTJIS_CP932 */
2068         }
2069     }
2070     (*oconv)(c2, c1);
2071     return 0;
2072 }
2073
2074 static nkf_char
2075 s_iconv(nkf_char c2, nkf_char c1, nkf_char c0)
2076 {
2077     if (c2 == JIS_X_0201_1976_K || (0xA1 <= c2 && c2 <= 0xDF)) {
2078         if (iso2022jp_f && !x0201_f) {
2079             c2 = GETA1; c1 = GETA2;
2080         } else {
2081             c1 &= 0x7f;
2082         }
2083     } else if ((c2 == EOF) || (c2 == 0) || c2 < SP) {
2084         /* NOP */
2085     } else if (!x0213_f && 0xF0 <= c2 && c2 <= 0xF9 && 0x40 <= c1 && c1 <= 0xFC) {
2086         /* CP932 UDC */
2087         if(c1 == 0x7F) return 0;
2088         c1 = nkf_char_unicode_new((c2 - 0xF0) * 188 + (c1 - 0x40 - (0x7E < c1)) + 0xE000);
2089         c2 = 0;
2090     } else {
2091         nkf_char ret = s2e_conv(c2, c1, &c2, &c1);
2092         if (ret) return ret;
2093     }
2094     (*oconv)(c2, c1);
2095     return 0;
2096 }
2097
2098 static nkf_char
2099 w_iconv(nkf_char c1, nkf_char c2, nkf_char c3)
2100 {
2101     nkf_char ret = 0, c4 = 0;
2102     static const char w_iconv_utf8_1st_byte[] =
2103     { /* 0xC0 - 0xFF */
2104         20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
2105         21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
2106         30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 33,
2107         40, 41, 41, 41, 42, 43, 43, 43, 50, 50, 50, 50, 60, 60, 70, 70};
2108
2109     if (c3 > 0xFF) {
2110         c4 = c3 & 0xFF;
2111         c3 >>= 8;
2112     }
2113
2114     if (c1 < 0 || 0xff < c1) {
2115     }else if (c1 == 0) { /* 0 : 1 byte*/
2116         c3 = 0;
2117     } else if ((c1 & 0xC0) == 0x80) { /* 0x80-0xbf : trail byte */
2118         return 0;
2119     } else{
2120         switch (w_iconv_utf8_1st_byte[c1 - 0xC0]) {
2121         case 21:
2122             if (c2 < 0x80 || 0xBF < c2) return 0;
2123             break;
2124         case 30:
2125             if (c3 == 0) return -1;
2126             if (c2 < 0xA0 || 0xBF < c2 || (c3 & 0xC0) != 0x80)
2127                 return 0;
2128             break;
2129         case 31:
2130         case 33:
2131             if (c3 == 0) return -1;
2132             if ((c2 & 0xC0) != 0x80 || (c3 & 0xC0) != 0x80)
2133                 return 0;
2134             break;
2135         case 32:
2136             if (c3 == 0) return -1;
2137             if (c2 < 0x80 || 0x9F < c2 || (c3 & 0xC0) != 0x80)
2138                 return 0;
2139             break;
2140         case 40:
2141             if (c3 == 0) return -2;
2142             if (c2 < 0x90 || 0xBF < c2 || (c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2143                 return 0;
2144             break;
2145         case 41:
2146             if (c3 == 0) return -2;
2147             if (c2 < 0x80 || 0xBF < c2 || (c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2148                 return 0;
2149             break;
2150         case 42:
2151             if (c3 == 0) return -2;
2152             if (c2 < 0x80 || 0x8F < c2 || (c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2153                 return 0;
2154             break;
2155         default:
2156             return 0;
2157             break;
2158         }
2159     }
2160     if (c1 == 0 || c1 == EOF){
2161     } else if ((c1 & 0xf8) == 0xf0) { /* 4 bytes */
2162         c2 = nkf_char_unicode_new(nkf_utf8_to_unicode(c1, c2, c3, c4));
2163         c1 = 0;
2164     } else {
2165         ret = w2e_conv(c1, c2, c3, &c1, &c2);
2166     }
2167     if (ret == 0){
2168         (*oconv)(c1, c2);
2169     }
2170     return ret;
2171 }
2172
2173 #define NKF_ICONV_INVALID_CODE_RANGE -13
2174 static size_t
2175 unicode_iconv(nkf_char wc)
2176 {
2177     nkf_char c1, c2;
2178     int ret = 0;
2179
2180     if (wc < 0x80) {
2181         c2 = 0;
2182         c1 = wc;
2183     }else if ((wc>>11) == 27) {
2184         /* unpaired surrogate */
2185         return NKF_ICONV_INVALID_CODE_RANGE;
2186     }else if (wc < 0xFFFF) {
2187         ret = w16e_conv(wc, &c2, &c1);
2188         if (ret) return ret;
2189     }else if (wc < 0x10FFFF) {
2190         c2 = 0;
2191         c1 = nkf_char_unicode_new(wc);
2192     } else {
2193         return NKF_ICONV_INVALID_CODE_RANGE;
2194     }
2195     (*oconv)(c2, c1);
2196     return 0;
2197 }
2198
2199 #define NKF_ICONV_NEED_ONE_MORE_BYTE -1
2200 #define NKF_ICONV_NEED_TWO_MORE_BYTES -2
2201 #define UTF16_TO_UTF32(lead, trail) (((lead) << 10) + (trail) - NKF_INT32_C(0x35FDC00))
2202 static size_t
2203 nkf_iconv_utf_16(nkf_char c1, nkf_char c2, nkf_char c3, nkf_char c4)
2204 {
2205     nkf_char wc;
2206
2207     if (c1 == EOF) {
2208         (*oconv)(EOF, 0);
2209         return 0;
2210     }
2211
2212     if (input_endian == ENDIAN_BIG) {
2213         if (0xD8 <= c1 && c1 <= 0xDB) {
2214             if (0xDC <= c3 && c3 <= 0xDF) {
2215                 wc = UTF16_TO_UTF32(c1 << 8 | c2, c3 << 8 | c4);
2216             } else return NKF_ICONV_NEED_TWO_MORE_BYTES;
2217         } else {
2218             wc = c1 << 8 | c2;
2219         }
2220     } else {
2221         if (0xD8 <= c2 && c2 <= 0xDB) {
2222             if (0xDC <= c4 && c4 <= 0xDF) {
2223                 wc = UTF16_TO_UTF32(c2 << 8 | c1, c4 << 8 | c3);
2224             } else return NKF_ICONV_NEED_TWO_MORE_BYTES;
2225         } else {
2226             wc = c2 << 8 | c1;
2227         }
2228     }
2229
2230     return (*unicode_iconv)(wc);
2231 }
2232
2233 static nkf_char
2234 w_iconv16(nkf_char c2, nkf_char c1, nkf_char c0)
2235 {
2236     (*oconv)(c2, c1);
2237     return 16; /* different from w_iconv32 */
2238 }
2239
2240 static nkf_char
2241 w_iconv32(nkf_char c2, nkf_char c1, nkf_char c0)
2242 {
2243     (*oconv)(c2, c1);
2244     return 32; /* different from w_iconv16 */
2245 }
2246
2247 static size_t
2248 nkf_iconv_utf_32(nkf_char c1, nkf_char c2, nkf_char c3, nkf_char c4)
2249 {
2250     nkf_char wc;
2251
2252     if (c1 == EOF) {
2253         (*oconv)(EOF, 0);
2254         return 0;
2255     }
2256
2257     switch(input_endian){
2258     case ENDIAN_BIG:
2259         wc = c2 << 16 | c3 << 8 | c4;
2260         break;
2261     case ENDIAN_LITTLE:
2262         wc = c3 << 16 | c2 << 8 | c1;
2263         break;
2264     case ENDIAN_2143:
2265         wc = c1 << 16 | c4 << 8 | c3;
2266         break;
2267     case ENDIAN_3412:
2268         wc = c4 << 16 | c1 << 8 | c2;
2269         break;
2270     default:
2271         return NKF_ICONV_INVALID_CODE_RANGE;
2272     }
2273
2274     return (*unicode_iconv)(wc);
2275 }
2276 #endif
2277
2278 #define output_ascii_escape_sequence(mode) do { \
2279             if (output_mode != ASCII && output_mode != ISO_8859_1) { \
2280                     (*o_putc)(ESC); \
2281                     (*o_putc)('('); \
2282                     (*o_putc)(ascii_intro); \
2283                     output_mode = mode; \
2284             } \
2285     } while (0)
2286
2287 static void
2288 output_escape_sequence(int mode)
2289 {
2290     if (output_mode == mode)
2291         return;
2292     switch(mode) {
2293     case ISO_8859_1:
2294         (*o_putc)(ESC);
2295         (*o_putc)('.');
2296         (*o_putc)('A');
2297         break;
2298     case JIS_X_0201_1976_K:
2299         (*o_putc)(ESC);
2300         (*o_putc)('(');
2301         (*o_putc)('I');
2302         break;
2303     case JIS_X_0208:
2304         (*o_putc)(ESC);
2305         (*o_putc)('$');
2306         (*o_putc)(kanji_intro);
2307         break;
2308     case JIS_X_0212:
2309         (*o_putc)(ESC);
2310         (*o_putc)('$');
2311         (*o_putc)('(');
2312         (*o_putc)('D');
2313         break;
2314     case JIS_X_0213_1:
2315         (*o_putc)(ESC);
2316         (*o_putc)('$');
2317         (*o_putc)('(');
2318         (*o_putc)('Q');
2319         break;
2320     case JIS_X_0213_2:
2321         (*o_putc)(ESC);
2322         (*o_putc)('$');
2323         (*o_putc)('(');
2324         (*o_putc)('P');
2325         break;
2326     }
2327     output_mode = mode;
2328 }
2329
2330 static void
2331 j_oconv(nkf_char c2, nkf_char c1)
2332 {
2333 #ifdef NUMCHAR_OPTION
2334     if (c2 == 0 && nkf_char_unicode_p(c1)){
2335         w16e_conv(c1, &c2, &c1);
2336         if (c2 == 0 && nkf_char_unicode_p(c1)){
2337             c2 = c1 & VALUE_MASK;
2338             if (ms_ucs_map_f && 0xE000 <= c2 && c2 <= 0xE757) {
2339                 /* CP5022x UDC */
2340                 c1 &= 0xFFF;
2341                 c2 = 0x7F + c1 / 94;
2342                 c1 = 0x21 + c1 % 94;
2343             } else {
2344                 if (encode_fallback) (*encode_fallback)(c1);
2345                 return;
2346             }
2347         }
2348     }
2349 #endif
2350     if (c2 == 0) {
2351         output_ascii_escape_sequence(ASCII);
2352         (*o_putc)(c1);
2353     }
2354     else if (c2 == EOF) {
2355         output_ascii_escape_sequence(ASCII);
2356         (*o_putc)(EOF);
2357     }
2358     else if (c2 == ISO_8859_1) {
2359         output_ascii_escape_sequence(ISO_8859_1);
2360         (*o_putc)(c1|0x80);
2361     }
2362     else if (c2 == JIS_X_0201_1976_K) {
2363         output_escape_sequence(JIS_X_0201_1976_K);
2364         (*o_putc)(c1);
2365 #ifdef X0212_ENABLE
2366     } else if (is_eucg3(c2)){
2367         output_escape_sequence(x0213_f ? JIS_X_0213_2 : JIS_X_0212);
2368         (*o_putc)(c2 & 0x7f);
2369         (*o_putc)(c1);
2370 #endif
2371     } else {
2372         if(ms_ucs_map_f
2373            ? c2<0x20 || 0x92<c2 || c1<0x20 || 0x7e<c1
2374            : c2<0x20 || 0x7e<c2 || c1<0x20 || 0x7e<c1) return;
2375         output_escape_sequence(x0213_f ? JIS_X_0213_1 : JIS_X_0208);
2376         (*o_putc)(c2);
2377         (*o_putc)(c1);
2378     }
2379 }
2380
2381 static void
2382 e_oconv(nkf_char c2, nkf_char c1)
2383 {
2384     if (c2 == 0 && nkf_char_unicode_p(c1)){
2385         w16e_conv(c1, &c2, &c1);
2386         if (c2 == 0 && nkf_char_unicode_p(c1)){
2387             c2 = c1 & VALUE_MASK;
2388             if (x0212_f && 0xE000 <= c2 && c2 <= 0xE757) {
2389                 /* eucJP-ms UDC */
2390                 c1 &= 0xFFF;
2391                 c2 = c1 / 94;
2392                 c2 += c2 < 10 ? 0x75 : 0x8FEB;
2393                 c1 = 0x21 + c1 % 94;
2394                 if (is_eucg3(c2)){
2395                     (*o_putc)(0x8f);
2396                     (*o_putc)((c2 & 0x7f) | 0x080);
2397                     (*o_putc)(c1 | 0x080);
2398                 }else{
2399                     (*o_putc)((c2 & 0x7f) | 0x080);
2400                     (*o_putc)(c1 | 0x080);
2401                 }
2402                 return;
2403             } else {
2404                 if (encode_fallback) (*encode_fallback)(c1);
2405                 return;
2406             }
2407         }
2408     }
2409
2410     if (c2 == EOF) {
2411         (*o_putc)(EOF);
2412     } else if (c2 == 0) {
2413         output_mode = ASCII;
2414         (*o_putc)(c1);
2415     } else if (c2 == JIS_X_0201_1976_K) {
2416         output_mode = EUC_JP;
2417         (*o_putc)(SS2); (*o_putc)(c1|0x80);
2418     } else if (c2 == ISO_8859_1) {
2419         output_mode = ISO_8859_1;
2420         (*o_putc)(c1 | 0x080);
2421 #ifdef X0212_ENABLE
2422     } else if (is_eucg3(c2)){
2423         output_mode = EUC_JP;
2424 #ifdef SHIFTJIS_CP932
2425         if (!cp932inv_f){
2426             nkf_char s2, s1;
2427             if (e2s_conv(c2, c1, &s2, &s1) == 0){
2428                 s2e_conv(s2, s1, &c2, &c1);
2429             }
2430         }
2431 #endif
2432         if (c2 == 0) {
2433             output_mode = ASCII;
2434             (*o_putc)(c1);
2435         }else if (is_eucg3(c2)){
2436             if (x0212_f){
2437                 (*o_putc)(0x8f);
2438                 (*o_putc)((c2 & 0x7f) | 0x080);
2439                 (*o_putc)(c1 | 0x080);
2440             }
2441         }else{
2442             (*o_putc)((c2 & 0x7f) | 0x080);
2443             (*o_putc)(c1 | 0x080);
2444         }
2445 #endif
2446     } else {
2447         if (!nkf_isgraph(c1) || !nkf_isgraph(c2)) {
2448             set_iconv(FALSE, 0);
2449             return; /* too late to rescue this char */
2450         }
2451         output_mode = EUC_JP;
2452         (*o_putc)(c2 | 0x080);
2453         (*o_putc)(c1 | 0x080);
2454     }
2455 }
2456
2457 static void
2458 s_oconv(nkf_char c2, nkf_char c1)
2459 {
2460 #ifdef NUMCHAR_OPTION
2461     if (c2 == 0 && nkf_char_unicode_p(c1)){
2462         w16e_conv(c1, &c2, &c1);
2463         if (c2 == 0 && nkf_char_unicode_p(c1)){
2464             c2 = c1 & VALUE_MASK;
2465             if (!x0213_f && 0xE000 <= c2 && c2 <= 0xE757) {
2466                 /* CP932 UDC */
2467                 c1 &= 0xFFF;
2468                 c2 = c1 / 188 + (cp932inv_f ? 0xF0 : 0xEB);
2469                 c1 = c1 % 188;
2470                 c1 += 0x40 + (c1 > 0x3e);
2471                 (*o_putc)(c2);
2472                 (*o_putc)(c1);
2473                 return;
2474             } else {
2475                 if(encode_fallback)(*encode_fallback)(c1);
2476                 return;
2477             }
2478         }
2479     }
2480 #endif
2481     if (c2 == EOF) {
2482         (*o_putc)(EOF);
2483         return;
2484     } else if (c2 == 0) {
2485         output_mode = ASCII;
2486         (*o_putc)(c1);
2487     } else if (c2 == JIS_X_0201_1976_K) {
2488         output_mode = SHIFT_JIS;
2489         (*o_putc)(c1|0x80);
2490     } else if (c2 == ISO_8859_1) {
2491         output_mode = ISO_8859_1;
2492         (*o_putc)(c1 | 0x080);
2493 #ifdef X0212_ENABLE
2494     } else if (is_eucg3(c2)){
2495         output_mode = SHIFT_JIS;
2496         if (e2s_conv(c2, c1, &c2, &c1) == 0){
2497             (*o_putc)(c2);
2498             (*o_putc)(c1);
2499         }
2500 #endif
2501     } else {
2502         if (!nkf_isprint(c1) || !nkf_isprint(c2)) {
2503             set_iconv(FALSE, 0);
2504             return; /* too late to rescue this char */
2505         }
2506         output_mode = SHIFT_JIS;
2507         e2s_conv(c2, c1, &c2, &c1);
2508
2509 #ifdef SHIFTJIS_CP932
2510         if (cp932inv_f
2511             && CP932INV_TABLE_BEGIN <= c2 && c2 <= CP932INV_TABLE_END){
2512             nkf_char c = cp932inv[c2 - CP932INV_TABLE_BEGIN][c1 - 0x40];
2513             if (c){
2514                 c2 = c >> 8;
2515                 c1 = c & 0xff;
2516             }
2517         }
2518 #endif /* SHIFTJIS_CP932 */
2519
2520         (*o_putc)(c2);
2521         if (prefix_table[(unsigned char)c1]){
2522             (*o_putc)(prefix_table[(unsigned char)c1]);
2523         }
2524         (*o_putc)(c1);
2525     }
2526 }
2527
2528 #ifdef UTF8_OUTPUT_ENABLE
2529 static void
2530 w_oconv(nkf_char c2, nkf_char c1)
2531 {
2532     nkf_char c3, c4;
2533     nkf_char val;
2534
2535     if (output_bom_f) {
2536         output_bom_f = FALSE;
2537         (*o_putc)('\357');
2538         (*o_putc)('\273');
2539         (*o_putc)('\277');
2540     }
2541
2542     if (c2 == EOF) {
2543         (*o_putc)(EOF);
2544         return;
2545     }
2546
2547     if (c2 == 0 && nkf_char_unicode_p(c1)){
2548         val = c1 & VALUE_MASK;
2549         nkf_unicode_to_utf8(val, &c1, &c2, &c3, &c4);
2550         (*o_putc)(c1);
2551         if (c2) (*o_putc)(c2);
2552         if (c3) (*o_putc)(c3);
2553         if (c4) (*o_putc)(c4);
2554         return;
2555     }
2556
2557     if (c2 == 0) {
2558         (*o_putc)(c1);
2559     } else {
2560         val = e2w_conv(c2, c1);
2561         if (val){
2562             nkf_unicode_to_utf8(val, &c1, &c2, &c3, &c4);
2563             (*o_putc)(c1);
2564             if (c2) (*o_putc)(c2);
2565             if (c3) (*o_putc)(c3);
2566             if (c4) (*o_putc)(c4);
2567         }
2568     }
2569 }
2570
2571 static void
2572 w_oconv16(nkf_char c2, nkf_char c1)
2573 {
2574     if (output_bom_f) {
2575         output_bom_f = FALSE;
2576         if (output_endian == ENDIAN_LITTLE){
2577             (*o_putc)(0xFF);
2578             (*o_putc)(0xFE);
2579         }else{
2580             (*o_putc)(0xFE);
2581             (*o_putc)(0xFF);
2582         }
2583     }
2584
2585     if (c2 == EOF) {
2586         (*o_putc)(EOF);
2587         return;
2588     }
2589
2590     if (c2 == 0 && nkf_char_unicode_p(c1)) {
2591         if (nkf_char_unicode_bmp_p(c1)) {
2592             c2 = (c1 >> 8) & 0xff;
2593             c1 &= 0xff;
2594         } else {
2595             c1 &= VALUE_MASK;
2596             if (c1 <= UNICODE_MAX) {
2597                 c2 = (c1 >> 10) + NKF_INT32_C(0xD7C0);   /* high surrogate */
2598                 c1 = (c1 & 0x3FF) + NKF_INT32_C(0xDC00); /* low surrogate */
2599                 if (output_endian == ENDIAN_LITTLE){
2600                     (*o_putc)(c2 & 0xff);
2601                     (*o_putc)((c2 >> 8) & 0xff);
2602                     (*o_putc)(c1 & 0xff);
2603                     (*o_putc)((c1 >> 8) & 0xff);
2604                 }else{
2605                     (*o_putc)((c2 >> 8) & 0xff);
2606                     (*o_putc)(c2 & 0xff);
2607                     (*o_putc)((c1 >> 8) & 0xff);
2608                     (*o_putc)(c1 & 0xff);
2609                 }
2610             }
2611             return;
2612         }
2613     } else if (c2) {
2614         nkf_char val = e2w_conv(c2, c1);
2615         c2 = (val >> 8) & 0xff;
2616         c1 = val & 0xff;
2617         if (!val) return;
2618     }
2619
2620     if (output_endian == ENDIAN_LITTLE){
2621         (*o_putc)(c1);
2622         (*o_putc)(c2);
2623     }else{
2624         (*o_putc)(c2);
2625         (*o_putc)(c1);
2626     }
2627 }
2628
2629 static void
2630 w_oconv32(nkf_char c2, nkf_char c1)
2631 {
2632     if (output_bom_f) {
2633         output_bom_f = FALSE;
2634         if (output_endian == ENDIAN_LITTLE){
2635             (*o_putc)(0xFF);
2636             (*o_putc)(0xFE);
2637             (*o_putc)(0);
2638             (*o_putc)(0);
2639         }else{
2640             (*o_putc)(0);
2641             (*o_putc)(0);
2642             (*o_putc)(0xFE);
2643             (*o_putc)(0xFF);
2644         }
2645     }
2646
2647     if (c2 == EOF) {
2648         (*o_putc)(EOF);
2649         return;
2650     }
2651
2652     if (c2 == ISO_8859_1) {
2653         c1 |= 0x80;
2654     } else if (c2 == 0 && nkf_char_unicode_p(c1)) {
2655         c1 &= VALUE_MASK;
2656     } else if (c2) {
2657         c1 = e2w_conv(c2, c1);
2658         if (!c1) return;
2659     }
2660     if (output_endian == ENDIAN_LITTLE){
2661         (*o_putc)( c1        & 0xFF);
2662         (*o_putc)((c1 >>  8) & 0xFF);
2663         (*o_putc)((c1 >> 16) & 0xFF);
2664         (*o_putc)(0);
2665     }else{
2666         (*o_putc)(0);
2667         (*o_putc)((c1 >> 16) & 0xFF);
2668         (*o_putc)((c1 >>  8) & 0xFF);
2669         (*o_putc)( c1        & 0xFF);
2670     }
2671 }
2672 #endif
2673
2674 #define SCORE_L2       (1)                   /* Kanji Level 2 */
2675 #define SCORE_KANA     (SCORE_L2 << 1)       /* Halfwidth Katakana */
2676 #define SCORE_DEPEND   (SCORE_KANA << 1)     /* MD Characters */
2677 #define SCORE_CP932    (SCORE_DEPEND << 1)   /* IBM extended characters */
2678 #define SCORE_X0212    (SCORE_CP932 << 1)    /* JIS X 0212 */
2679 #define SCORE_NO_EXIST (SCORE_X0212 << 1)    /* Undefined Characters */
2680 #define SCORE_iMIME    (SCORE_NO_EXIST << 1) /* MIME selected */
2681 #define SCORE_ERROR    (SCORE_iMIME << 1) /* Error */
2682
2683 #define SCORE_INIT (SCORE_iMIME)
2684
2685 static const nkf_char score_table_A0[] = {
2686     0, 0, 0, 0,
2687     0, 0, 0, 0,
2688     0, SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND,
2689     SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND, SCORE_NO_EXIST,
2690 };
2691
2692 static const nkf_char score_table_F0[] = {
2693     SCORE_L2, SCORE_L2, SCORE_L2, SCORE_L2,
2694     SCORE_L2, SCORE_DEPEND, SCORE_NO_EXIST, SCORE_NO_EXIST,
2695     SCORE_DEPEND, SCORE_DEPEND, SCORE_CP932, SCORE_CP932,
2696     SCORE_CP932, SCORE_NO_EXIST, SCORE_NO_EXIST, SCORE_ERROR,
2697 };
2698
2699 static void
2700 set_code_score(struct input_code *ptr, nkf_char score)
2701 {
2702     if (ptr){
2703         ptr->score |= score;
2704     }
2705 }
2706
2707 static void
2708 clr_code_score(struct input_code *ptr, nkf_char score)
2709 {
2710     if (ptr){
2711         ptr->score &= ~score;
2712     }
2713 }
2714
2715 static void
2716 code_score(struct input_code *ptr)
2717 {
2718     nkf_char c2 = ptr->buf[0];
2719 #ifdef UTF8_OUTPUT_ENABLE
2720     nkf_char c1 = ptr->buf[1];
2721 #endif
2722     if (c2 < 0){
2723         set_code_score(ptr, SCORE_ERROR);
2724     }else if (c2 == SS2){
2725         set_code_score(ptr, SCORE_KANA);
2726     }else if (c2 == 0x8f){
2727         set_code_score(ptr, SCORE_X0212);
2728 #ifdef UTF8_OUTPUT_ENABLE
2729     }else if (!e2w_conv(c2, c1)){
2730         set_code_score(ptr, SCORE_NO_EXIST);
2731 #endif
2732     }else if ((c2 & 0x70) == 0x20){
2733         set_code_score(ptr, score_table_A0[c2 & 0x0f]);
2734     }else if ((c2 & 0x70) == 0x70){
2735         set_code_score(ptr, score_table_F0[c2 & 0x0f]);
2736     }else if ((c2 & 0x70) >= 0x50){
2737         set_code_score(ptr, SCORE_L2);
2738     }
2739 }
2740
2741 static void
2742 status_disable(struct input_code *ptr)
2743 {
2744     ptr->stat = -1;
2745     ptr->buf[0] = -1;
2746     code_score(ptr);
2747     if (iconv == ptr->iconv_func) set_iconv(FALSE, 0);
2748 }
2749
2750 static void
2751 status_push_ch(struct input_code *ptr, nkf_char c)
2752 {
2753     ptr->buf[ptr->index++] = c;
2754 }
2755
2756 static void
2757 status_clear(struct input_code *ptr)
2758 {
2759     ptr->stat = 0;
2760     ptr->index = 0;
2761 }
2762
2763 static void
2764 status_reset(struct input_code *ptr)
2765 {
2766     status_clear(ptr);
2767     ptr->score = SCORE_INIT;
2768 }
2769
2770 static void
2771 status_reinit(struct input_code *ptr)
2772 {
2773     status_reset(ptr);
2774     ptr->_file_stat = 0;
2775 }
2776
2777 static void
2778 status_check(struct input_code *ptr, nkf_char c)
2779 {
2780     if (c <= DEL && estab_f){
2781         status_reset(ptr);
2782     }
2783 }
2784
2785 static void
2786 s_status(struct input_code *ptr, nkf_char c)
2787 {
2788     switch(ptr->stat){
2789     case -1:
2790         status_check(ptr, c);
2791         break;
2792     case 0:
2793         if (c <= DEL){
2794             break;
2795         }else if (nkf_char_unicode_p(c)){
2796             break;
2797         }else if (0xa1 <= c && c <= 0xdf){
2798             status_push_ch(ptr, SS2);
2799             status_push_ch(ptr, c);
2800             code_score(ptr);
2801             status_clear(ptr);
2802         }else if ((0x81 <= c && c < 0xa0) || (0xe0 <= c && c <= 0xea)){
2803             ptr->stat = 1;
2804             status_push_ch(ptr, c);
2805         }else if (0xed <= c && c <= 0xee){
2806             ptr->stat = 3;
2807             status_push_ch(ptr, c);
2808 #ifdef SHIFTJIS_CP932
2809         }else if (is_ibmext_in_sjis(c)){
2810             ptr->stat = 2;
2811             status_push_ch(ptr, c);
2812 #endif /* SHIFTJIS_CP932 */
2813 #ifdef X0212_ENABLE
2814         }else if (0xf0 <= c && c <= 0xfc){
2815             ptr->stat = 1;
2816             status_push_ch(ptr, c);
2817 #endif /* X0212_ENABLE */
2818         }else{
2819             status_disable(ptr);
2820         }
2821         break;
2822     case 1:
2823         if ((0x40 <= c && c <= 0x7e) || (0x80 <= c && c <= 0xfc)){
2824             status_push_ch(ptr, c);
2825             s2e_conv(ptr->buf[0], ptr->buf[1], &ptr->buf[0], &ptr->buf[1]);
2826             code_score(ptr);
2827             status_clear(ptr);
2828         }else{
2829             status_disable(ptr);
2830         }
2831         break;
2832     case 2:
2833 #ifdef SHIFTJIS_CP932
2834         if ((0x40 <= c && c <= 0x7e) || (0x80 <= c && c <= 0xfc)) {
2835             status_push_ch(ptr, c);
2836             if (s2e_conv(ptr->buf[0], ptr->buf[1], &ptr->buf[0], &ptr->buf[1]) == 0) {
2837                 set_code_score(ptr, SCORE_CP932);
2838                 status_clear(ptr);
2839                 break;
2840             }
2841         }
2842 #endif /* SHIFTJIS_CP932 */
2843         status_disable(ptr);
2844         break;
2845     case 3:
2846         if ((0x40 <= c && c <= 0x7e) || (0x80 <= c && c <= 0xfc)){
2847             status_push_ch(ptr, c);
2848             s2e_conv(ptr->buf[0], ptr->buf[1], &ptr->buf[0], &ptr->buf[1]);
2849             set_code_score(ptr, SCORE_CP932);
2850             status_clear(ptr);
2851         }else{
2852             status_disable(ptr);
2853         }
2854         break;
2855     }
2856 }
2857
2858 static void
2859 e_status(struct input_code *ptr, nkf_char c)
2860 {
2861     switch (ptr->stat){
2862     case -1:
2863         status_check(ptr, c);
2864         break;
2865     case 0:
2866         if (c <= DEL){
2867             break;
2868         }else if (nkf_char_unicode_p(c)){
2869             break;
2870         }else if (SS2 == c || (0xa1 <= c && c <= 0xfe)){
2871             ptr->stat = 1;
2872             status_push_ch(ptr, c);
2873 #ifdef X0212_ENABLE
2874         }else if (0x8f == c){
2875             ptr->stat = 2;
2876             status_push_ch(ptr, c);
2877 #endif /* X0212_ENABLE */
2878         }else{
2879             status_disable(ptr);
2880         }
2881         break;
2882     case 1:
2883         if (0xa1 <= c && c <= 0xfe){
2884             status_push_ch(ptr, c);
2885             code_score(ptr);
2886             status_clear(ptr);
2887         }else{
2888             status_disable(ptr);
2889         }
2890         break;
2891 #ifdef X0212_ENABLE
2892     case 2:
2893         if (0xa1 <= c && c <= 0xfe){
2894             ptr->stat = 1;
2895             status_push_ch(ptr, c);
2896         }else{
2897             status_disable(ptr);
2898         }
2899 #endif /* X0212_ENABLE */
2900     }
2901 }
2902
2903 #ifdef UTF8_INPUT_ENABLE
2904 static void
2905 w_status(struct input_code *ptr, nkf_char c)
2906 {
2907     switch (ptr->stat){
2908     case -1:
2909         status_check(ptr, c);
2910         break;
2911     case 0:
2912         if (c <= DEL){
2913             break;
2914         }else if (nkf_char_unicode_p(c)){
2915             break;
2916         }else if (0xc0 <= c && c <= 0xdf){
2917             ptr->stat = 1;
2918             status_push_ch(ptr, c);
2919         }else if (0xe0 <= c && c <= 0xef){
2920             ptr->stat = 2;
2921             status_push_ch(ptr, c);
2922         }else if (0xf0 <= c && c <= 0xf4){
2923             ptr->stat = 3;
2924             status_push_ch(ptr, c);
2925         }else{
2926             status_disable(ptr);
2927         }
2928         break;
2929     case 1:
2930     case 2:
2931         if (0x80 <= c && c <= 0xbf){
2932             status_push_ch(ptr, c);
2933             if (ptr->index > ptr->stat){
2934                 int bom = (ptr->buf[0] == 0xef && ptr->buf[1] == 0xbb
2935                            && ptr->buf[2] == 0xbf);
2936                 w2e_conv(ptr->buf[0], ptr->buf[1], ptr->buf[2],
2937                          &ptr->buf[0], &ptr->buf[1]);
2938                 if (!bom){
2939                     code_score(ptr);
2940                 }
2941                 status_clear(ptr);
2942             }
2943         }else{
2944             status_disable(ptr);
2945         }
2946         break;
2947     case 3:
2948         if (0x80 <= c && c <= 0xbf){
2949             if (ptr->index < ptr->stat){
2950                 status_push_ch(ptr, c);
2951             } else {
2952                 status_clear(ptr);
2953             }
2954         }else{
2955             status_disable(ptr);
2956         }
2957         break;
2958     }
2959 }
2960 #endif
2961
2962 static void
2963 code_status(nkf_char c)
2964 {
2965     int action_flag = 1;
2966     struct input_code *result = 0;
2967     struct input_code *p = input_code_list;
2968     while (p->name){
2969         if (!p->status_func) {
2970             ++p;
2971             continue;
2972         }
2973         if (!p->status_func)
2974             continue;
2975         (p->status_func)(p, c);
2976         if (p->stat > 0){
2977             action_flag = 0;
2978         }else if(p->stat == 0){
2979             if (result){
2980                 action_flag = 0;
2981             }else{
2982                 result = p;
2983             }
2984         }
2985         ++p;
2986     }
2987
2988     if (action_flag){
2989         if (result && !estab_f){
2990             set_iconv(TRUE, result->iconv_func);
2991         }else if (c <= DEL){
2992             struct input_code *ptr = input_code_list;
2993             while (ptr->name){
2994                 status_reset(ptr);
2995                 ++ptr;
2996             }
2997         }
2998     }
2999 }
3000
3001 typedef struct {
3002     nkf_buf_t *std_gc_buf;
3003     nkf_char broken_state;
3004     nkf_buf_t *broken_buf;
3005     nkf_char mimeout_state;
3006     nkf_buf_t *nfc_buf;
3007 } nkf_state_t;
3008
3009 static nkf_state_t *nkf_state = NULL;
3010
3011 #define STD_GC_BUFSIZE (256)
3012
3013 static void
3014 nkf_state_init(void)
3015 {
3016     if (nkf_state) {
3017         nkf_buf_clear(nkf_state->std_gc_buf);
3018         nkf_buf_clear(nkf_state->broken_buf);
3019         nkf_buf_clear(nkf_state->nfc_buf);
3020     }
3021     else {
3022         nkf_state = nkf_xmalloc(sizeof(nkf_state_t));
3023         nkf_state->std_gc_buf = nkf_buf_new(STD_GC_BUFSIZE);
3024         nkf_state->broken_buf = nkf_buf_new(3);
3025         nkf_state->nfc_buf = nkf_buf_new(9);
3026     }
3027     nkf_state->broken_state = 0;
3028     nkf_state->mimeout_state = 0;
3029 }
3030
3031 #ifndef WIN32DLL
3032 static nkf_char
3033 std_getc(FILE *f)
3034 {
3035     if (!nkf_buf_empty_p(nkf_state->std_gc_buf)){
3036         return nkf_buf_pop(nkf_state->std_gc_buf);
3037     }
3038     return getc(f);
3039 }
3040 #endif /*WIN32DLL*/
3041
3042 static nkf_char
3043 std_ungetc(nkf_char c, FILE *f)
3044 {
3045     nkf_buf_push(nkf_state->std_gc_buf, c);
3046     return c;
3047 }
3048
3049 #ifndef WIN32DLL
3050 static void
3051 std_putc(nkf_char c)
3052 {
3053     if(c!=EOF)
3054         putchar(c);
3055 }
3056 #endif /*WIN32DLL*/
3057
3058 static unsigned char   hold_buf[HOLD_SIZE*2];
3059 static int             hold_count = 0;
3060 static nkf_char
3061 push_hold_buf(nkf_char c2)
3062 {
3063     if (hold_count >= HOLD_SIZE*2)
3064         return (EOF);
3065     hold_buf[hold_count++] = (unsigned char)c2;
3066     return ((hold_count >= HOLD_SIZE*2) ? EOF : hold_count);
3067 }
3068
3069 static int
3070 h_conv(FILE *f, nkf_char c1, nkf_char c2)
3071 {
3072     int ret;
3073     int hold_index;
3074     nkf_char c3, c4;
3075
3076     /** it must NOT be in the kanji shifte sequence      */
3077     /** it must NOT be written in JIS7                   */
3078     /** and it must be after 2 byte 8bit code            */
3079
3080     hold_count = 0;
3081     push_hold_buf(c1);
3082     push_hold_buf(c2);
3083
3084     while ((c2 = (*i_getc)(f)) != EOF) {
3085         if (c2 == ESC){
3086             (*i_ungetc)(c2,f);
3087             break;
3088         }
3089         code_status(c2);
3090         if (push_hold_buf(c2) == EOF || estab_f) {
3091             break;
3092         }
3093     }
3094
3095     if (!estab_f) {
3096         struct input_code *p = input_code_list;
3097         struct input_code *result = p;
3098         if (c2 == EOF) {
3099             code_status(c2);
3100         }
3101         while (p->name) {
3102             if (p->status_func && p->score < result->score) {
3103                 result = p;
3104             }
3105             p++;
3106         }
3107         set_iconv(TRUE, result->iconv_func);
3108     }
3109
3110
3111     /** now,
3112      ** 1) EOF is detected, or
3113      ** 2) Code is established, or
3114      ** 3) Buffer is FULL (but last word is pushed)
3115      **
3116      ** in 1) and 3) cases, we continue to use
3117      ** Kanji codes by oconv and leave estab_f unchanged.
3118      **/
3119
3120     ret = c2;
3121     hold_index = 0;
3122     while (hold_index < hold_count){
3123         c1 = hold_buf[hold_index++];
3124         if (c1 <= DEL){
3125             (*iconv)(0, c1, 0);
3126             continue;
3127         }else if (iconv == s_iconv && 0xa1 <= c1 && c1 <= 0xdf){
3128             (*iconv)(JIS_X_0201_1976_K, c1, 0);
3129             continue;
3130         }
3131         if (hold_index < hold_count){
3132             c2 = hold_buf[hold_index++];
3133         }else{
3134             c2 = (*i_getc)(f);
3135             if (c2 == EOF){
3136                 c4 = EOF;
3137                 break;
3138             }
3139             code_status(c2);
3140         }
3141         c3 = 0;
3142         switch ((*iconv)(c1, c2, 0)) {  /* can be EUC/SJIS/UTF-8 */
3143         case -2:
3144             /* 4 bytes UTF-8 */
3145             if (hold_index < hold_count){
3146                 c3 = hold_buf[hold_index++];
3147             } else if ((c3 = (*i_getc)(f)) == EOF) {
3148                 ret = EOF;
3149                 break;
3150             }
3151             code_status(c3);
3152             if (hold_index < hold_count){
3153                 c4 = hold_buf[hold_index++];
3154             } else if ((c4 = (*i_getc)(f)) == EOF) {
3155                 c3 = ret = EOF;
3156                 break;
3157             }
3158             code_status(c4);
3159             (*iconv)(c1, c2, (c3<<8)|c4);
3160             break;
3161         case -1:
3162             /* 3 bytes EUC or UTF-8 */
3163             if (hold_index < hold_count){
3164                 c3 = hold_buf[hold_index++];
3165             } else if ((c3 = (*i_getc)(f)) == EOF) {
3166                 ret = EOF;
3167                 break;
3168             } else {
3169                 code_status(c3);
3170             }
3171             (*iconv)(c1, c2, c3);
3172             break;
3173         }
3174         if (c3 == EOF) break;
3175     }
3176     return ret;
3177 }
3178
3179 /*
3180  * Check and Ignore BOM
3181  */
3182 static void
3183 check_bom(FILE *f)
3184 {
3185     int c2;
3186     switch(c2 = (*i_getc)(f)){
3187     case 0x00:
3188         if((c2 = (*i_getc)(f)) == 0x00){
3189             if((c2 = (*i_getc)(f)) == 0xFE){
3190                 if((c2 = (*i_getc)(f)) == 0xFF){
3191                     if(!input_encoding){
3192                         set_iconv(TRUE, w_iconv32);
3193                     }
3194                     if (iconv == w_iconv32) {
3195                         input_endian = ENDIAN_BIG;
3196                         return;
3197                     }
3198                     (*i_ungetc)(0xFF,f);
3199                 }else (*i_ungetc)(c2,f);
3200                 (*i_ungetc)(0xFE,f);
3201             }else if(c2 == 0xFF){
3202                 if((c2 = (*i_getc)(f)) == 0xFE){
3203                     if(!input_encoding){
3204                         set_iconv(TRUE, w_iconv32);
3205                     }
3206                     if (iconv == w_iconv32) {
3207                         input_endian = ENDIAN_2143;
3208                         return;
3209                     }
3210                     (*i_ungetc)(0xFF,f);
3211                 }else (*i_ungetc)(c2,f);
3212                 (*i_ungetc)(0xFF,f);
3213             }else (*i_ungetc)(c2,f);
3214             (*i_ungetc)(0x00,f);
3215         }else (*i_ungetc)(c2,f);
3216         (*i_ungetc)(0x00,f);
3217         break;
3218     case 0xEF:
3219         if((c2 = (*i_getc)(f)) == 0xBB){
3220             if((c2 = (*i_getc)(f)) == 0xBF){
3221                 if(!input_encoding){
3222                     set_iconv(TRUE, w_iconv);
3223                 }
3224                 if (iconv == w_iconv) {
3225                     return;
3226                 }
3227                 (*i_ungetc)(0xBF,f);
3228             }else (*i_ungetc)(c2,f);
3229             (*i_ungetc)(0xBB,f);
3230         }else (*i_ungetc)(c2,f);
3231         (*i_ungetc)(0xEF,f);
3232         break;
3233     case 0xFE:
3234         if((c2 = (*i_getc)(f)) == 0xFF){
3235             if((c2 = (*i_getc)(f)) == 0x00){
3236                 if((c2 = (*i_getc)(f)) == 0x00){
3237                     if(!input_encoding){
3238                         set_iconv(TRUE, w_iconv32);
3239                     }
3240                     if (iconv == w_iconv32) {
3241                         input_endian = ENDIAN_3412;
3242                         return;
3243                     }
3244                     (*i_ungetc)(0x00,f);
3245                 }else (*i_ungetc)(c2,f);
3246                 (*i_ungetc)(0x00,f);
3247             }else (*i_ungetc)(c2,f);
3248             if(!input_encoding){
3249                 set_iconv(TRUE, w_iconv16);
3250             }
3251             if (iconv == w_iconv16) {
3252                 input_endian = ENDIAN_BIG;
3253                 return;
3254             }
3255             (*i_ungetc)(0xFF,f);
3256         }else (*i_ungetc)(c2,f);
3257         (*i_ungetc)(0xFE,f);
3258         break;
3259     case 0xFF:
3260         if((c2 = (*i_getc)(f)) == 0xFE){
3261             if((c2 = (*i_getc)(f)) == 0x00){
3262                 if((c2 = (*i_getc)(f)) == 0x00){
3263                     if(!input_encoding){
3264                         set_iconv(TRUE, w_iconv32);
3265                     }
3266                     if (iconv == w_iconv32) {
3267                         input_endian = ENDIAN_LITTLE;
3268                         return;
3269                     }
3270                     (*i_ungetc)(0x00,f);
3271                 }else (*i_ungetc)(c2,f);
3272                 (*i_ungetc)(0x00,f);
3273             }else (*i_ungetc)(c2,f);
3274             if(!input_encoding){
3275                 set_iconv(TRUE, w_iconv16);
3276             }
3277             if (iconv == w_iconv16) {
3278                 input_endian = ENDIAN_LITTLE;
3279                 return;
3280             }
3281             (*i_ungetc)(0xFE,f);
3282         }else (*i_ungetc)(c2,f);
3283         (*i_ungetc)(0xFF,f);
3284         break;
3285     default:
3286         (*i_ungetc)(c2,f);
3287         break;
3288     }
3289 }
3290
3291 static nkf_char
3292 broken_getc(FILE *f)
3293 {
3294     nkf_char c, c1;
3295
3296     if (!nkf_buf_empty_p(nkf_state->broken_buf)) {
3297         return nkf_buf_pop(nkf_state->broken_buf);
3298     }
3299     c = (*i_bgetc)(f);
3300     if (c=='$' && nkf_state->broken_state != ESC
3301         && (input_mode == ASCII || input_mode == JIS_X_0201_1976_K)) {
3302         c1= (*i_bgetc)(f);
3303         nkf_state->broken_state = 0;
3304         if (c1=='@'|| c1=='B') {
3305             nkf_buf_push(nkf_state->broken_buf, c1);
3306             nkf_buf_push(nkf_state->broken_buf, c);
3307             return ESC;
3308         } else {
3309             (*i_bungetc)(c1,f);
3310             return c;
3311         }
3312     } else if (c=='(' && nkf_state->broken_state != ESC
3313                && (input_mode == JIS_X_0208 || input_mode == JIS_X_0201_1976_K)) {
3314         c1= (*i_bgetc)(f);
3315         nkf_state->broken_state = 0;
3316         if (c1=='J'|| c1=='B') {
3317             nkf_buf_push(nkf_state->broken_buf, c1);
3318             nkf_buf_push(nkf_state->broken_buf, c);
3319             return ESC;
3320         } else {
3321             (*i_bungetc)(c1,f);
3322             return c;
3323         }
3324     } else {
3325         nkf_state->broken_state = c;
3326         return c;
3327     }
3328 }
3329
3330 static nkf_char
3331 broken_ungetc(nkf_char c, FILE *f)
3332 {
3333     if (nkf_buf_length(nkf_state->broken_buf) < 2)
3334         nkf_buf_push(nkf_state->broken_buf, c);
3335     return c;
3336 }
3337
3338 static void
3339 eol_conv(nkf_char c2, nkf_char c1)
3340 {
3341     if (guess_f && input_eol != EOF) {
3342         if (c2 == 0 && c1 == LF) {
3343             if (!input_eol) input_eol = prev_cr ? CRLF : LF;
3344             else if (input_eol != (prev_cr ? CRLF : LF)) input_eol = EOF;
3345         } else if (c2 == 0 && c1 == CR && input_eol == LF) input_eol = EOF;
3346         else if (!prev_cr);
3347         else if (!input_eol) input_eol = CR;
3348         else if (input_eol != CR) input_eol = EOF;
3349     }
3350     if (prev_cr || (c2 == 0 && c1 == LF)) {
3351         prev_cr = 0;
3352         if (eolmode_f != LF) (*o_eol_conv)(0, CR);
3353         if (eolmode_f != CR) (*o_eol_conv)(0, LF);
3354     }
3355     if (c2 == 0 && c1 == CR) prev_cr = CR;
3356     else if (c2 != 0 || c1 != LF) (*o_eol_conv)(c2, c1);
3357 }
3358
3359 /*
3360    Return value of fold_conv()
3361
3362    LF  add newline  and output char
3363    CR  add newline  and output nothing
3364    SP  space
3365    0   skip
3366    1   (or else) normal output
3367
3368    fold state in prev (previous character)
3369
3370    >0x80 Japanese (X0208/X0201)
3371    <0x80 ASCII
3372    LF    new line
3373    SP    space
3374
3375    This fold algorthm does not preserve heading space in a line.
3376    This is the main difference from fmt.
3377  */
3378
3379 #define char_size(c2,c1) (c2?2:1)
3380
3381 static void
3382 fold_conv(nkf_char c2, nkf_char c1)
3383 {
3384     nkf_char prev0;
3385     nkf_char fold_state;
3386
3387     if (c1== CR && !fold_preserve_f) {
3388         fold_state=0;  /* ignore cr */
3389     }else if (c1== LF&&f_prev==CR && fold_preserve_f) {
3390         f_prev = LF;
3391         fold_state=0;  /* ignore cr */
3392     } else if (c1== BS) {
3393         if (f_line>0) f_line--;
3394         fold_state =  1;
3395     } else if (c2==EOF && f_line != 0) {    /* close open last line */
3396         fold_state = LF;
3397     } else if ((c1==LF && !fold_preserve_f)
3398                || ((c1==CR||(c1==LF&&f_prev!=CR))
3399                    && fold_preserve_f)) {
3400         /* new line */
3401         if (fold_preserve_f) {
3402             f_prev = c1;
3403             f_line = 0;
3404             fold_state =  CR;
3405         } else if ((f_prev == c1 && !fold_preserve_f)
3406                    || (f_prev == LF && fold_preserve_f)
3407                   ) {        /* duplicate newline */
3408             if (f_line) {
3409                 f_line = 0;
3410                 fold_state =  LF;    /* output two newline */
3411             } else {
3412                 f_line = 0;
3413                 fold_state =  1;
3414             }
3415         } else  {
3416             if (f_prev&0x80) {     /* Japanese? */
3417                 f_prev = c1;
3418                 fold_state =  0;       /* ignore given single newline */
3419             } else if (f_prev==SP) {
3420                 fold_state =  0;
3421             } else {
3422                 f_prev = c1;
3423                 if (++f_line<=fold_len)
3424                     fold_state =  SP;
3425                 else {
3426                     f_line = 0;
3427                     fold_state =  CR;        /* fold and output nothing */
3428                 }
3429             }
3430         }
3431     } else if (c1=='\f') {
3432         f_prev = LF;
3433         f_line = 0;
3434         fold_state =  LF;            /* output newline and clear */
3435     } else if ((c2==0 && nkf_isblank(c1)) || (c2 == '!' && c1 == '!')) {
3436         /* X0208 kankaku or ascii space */
3437         if (f_prev == SP) {
3438             fold_state = 0;         /* remove duplicate spaces */
3439         } else {
3440             f_prev = SP;
3441             if (++f_line<=fold_len)
3442                 fold_state = SP;         /* output ASCII space only */
3443             else {
3444                 f_prev = SP; f_line = 0;
3445                 fold_state = CR;        /* fold and output nothing */
3446             }
3447         }
3448     } else {
3449         prev0 = f_prev; /* we still need this one... , but almost done */
3450         f_prev = c1;
3451         if (c2 || c2 == JIS_X_0201_1976_K)
3452             f_prev |= 0x80;  /* this is Japanese */
3453         f_line += char_size(c2,c1);
3454         if (f_line<=fold_len) {   /* normal case */
3455             fold_state = 1;
3456         } else {
3457             if (f_line>fold_len+fold_margin) { /* too many kinsoku suspension */
3458                 f_line = char_size(c2,c1);
3459                 fold_state =  LF;       /* We can't wait, do fold now */
3460             } else if (c2 == JIS_X_0201_1976_K) {
3461                 /* simple kinsoku rules  return 1 means no folding  */
3462                 if (c1==(0xde&0x7f)) fold_state = 1; /* \e$B!+\e(B*/
3463                 else if (c1==(0xdf&0x7f)) fold_state = 1; /* \e$B!,\e(B*/
3464                 else if (c1==(0xa4&0x7f)) fold_state = 1; /* \e$B!#\e(B*/
3465                 else if (c1==(0xa3&0x7f)) fold_state = 1; /* \e$B!$\e(B*/
3466                 else if (c1==(0xa1&0x7f)) fold_state = 1; /* \e$B!W\e(B*/
3467                 else if (c1==(0xb0&0x7f)) fold_state = 1; /* - */
3468                 else if (SP<=c1 && c1<=(0xdf&0x7f)) {      /* X0201 */
3469                     f_line = 1;
3470                     fold_state = LF;/* add one new f_line before this character */
3471                 } else {
3472                     f_line = 1;
3473                     fold_state = LF;/* add one new f_line before this character */
3474                 }
3475             } else if (c2==0) {
3476                 /* kinsoku point in ASCII */
3477                 if (  c1==')'||    /* { [ ( */
3478                     c1==']'||
3479                     c1=='}'||
3480                     c1=='.'||
3481                     c1==','||
3482                     c1=='!'||
3483                     c1=='?'||
3484                     c1=='/'||
3485                     c1==':'||
3486                     c1==';') {
3487                     fold_state = 1;
3488                     /* just after special */
3489                 } else if (!is_alnum(prev0)) {
3490                     f_line = char_size(c2,c1);
3491                     fold_state = LF;
3492                 } else if ((prev0==SP) ||   /* ignored new f_line */
3493                            (prev0==LF)||        /* ignored new f_line */
3494                            (prev0&0x80)) {        /* X0208 - ASCII */
3495                     f_line = char_size(c2,c1);
3496                     fold_state = LF;/* add one new f_line before this character */
3497                 } else {
3498                     fold_state = 1;  /* default no fold in ASCII */
3499                 }
3500             } else {
3501                 if (c2=='!') {
3502                     if (c1=='"')  fold_state = 1; /* \e$B!"\e(B */
3503                     else if (c1=='#')  fold_state = 1; /* \e$B!#\e(B */
3504                     else if (c1=='W')  fold_state = 1; /* \e$B!W\e(B */
3505                     else if (c1=='K')  fold_state = 1; /* \e$B!K\e(B */
3506                     else if (c1=='$')  fold_state = 1; /* \e$B!$\e(B */
3507                     else if (c1=='%')  fold_state = 1; /* \e$B!%\e(B */
3508                     else if (c1=='\'') fold_state = 1; /* \e$B!\\e(B */
3509                     else if (c1=='(')  fold_state = 1; /* \e$B!(\e(B */
3510                     else if (c1==')')  fold_state = 1; /* \e$B!)\e(B */
3511                     else if (c1=='*')  fold_state = 1; /* \e$B!*\e(B */
3512                     else if (c1=='+')  fold_state = 1; /* \e$B!+\e(B */
3513                     else if (c1==',')  fold_state = 1; /* \e$B!,\e(B */
3514                     /* default no fold in kinsoku */
3515                     else {
3516                         fold_state = LF;
3517                         f_line = char_size(c2,c1);
3518                         /* add one new f_line before this character */
3519                     }
3520                 } else {
3521                     f_line = char_size(c2,c1);
3522                     fold_state = LF;
3523                     /* add one new f_line before this character */
3524                 }
3525             }
3526         }
3527     }
3528     /* terminator process */
3529     switch(fold_state) {
3530     case LF:
3531         OCONV_NEWLINE((*o_fconv));
3532         (*o_fconv)(c2,c1);
3533         break;
3534     case 0:
3535         return;
3536     case CR:
3537         OCONV_NEWLINE((*o_fconv));
3538         break;
3539     case TAB:
3540     case SP:
3541         (*o_fconv)(0,SP);
3542         break;
3543     default:
3544         (*o_fconv)(c2,c1);
3545     }
3546 }
3547
3548 static nkf_char z_prev2=0,z_prev1=0;
3549
3550 static void
3551 z_conv(nkf_char c2, nkf_char c1)
3552 {
3553
3554     /* if (c2) c1 &= 0x7f; assertion */
3555
3556     if (c2 == JIS_X_0201_1976_K && (c1 == 0x20 || c1 == 0x7D || c1 == 0x7E)) {
3557         (*o_zconv)(c2,c1);
3558         return;
3559     }
3560
3561     if (x0201_f) {
3562         if (z_prev2 == JIS_X_0201_1976_K) {
3563             if (c2 == JIS_X_0201_1976_K) {
3564                 if (c1 == (0xde&0x7f)) { /* \e$BByE@\e(B */
3565                     z_prev2 = 0;
3566                     (*o_zconv)(dv[(z_prev1-SP)*2], dv[(z_prev1-SP)*2+1]);
3567                     return;
3568                 } else if (c1 == (0xdf&0x7f) && ev[(z_prev1-SP)*2]) {  /* \e$BH>ByE@\e(B */
3569                     z_prev2 = 0;
3570                     (*o_zconv)(ev[(z_prev1-SP)*2], ev[(z_prev1-SP)*2+1]);
3571                     return;
3572                 }
3573             }
3574             z_prev2 = 0;
3575             (*o_zconv)(cv[(z_prev1-SP)*2], cv[(z_prev1-SP)*2+1]);
3576         }
3577         if (c2 == JIS_X_0201_1976_K) {
3578             if (dv[(c1-SP)*2] || ev[(c1-SP)*2]) {
3579                 /* wait for \e$BByE@\e(B or \e$BH>ByE@\e(B */
3580                 z_prev1 = c1;
3581                 z_prev2 = c2;
3582                 return;
3583             } else {
3584                 (*o_zconv)(cv[(c1-SP)*2], cv[(c1-SP)*2+1]);
3585                 return;
3586             }
3587         }
3588     }
3589
3590     if (c2 == EOF) {
3591         (*o_zconv)(c2, c1);
3592         return;
3593     }
3594
3595     if (alpha_f&1 && c2 == 0x23) {
3596         /* JISX0208 Alphabet */
3597         c2 = 0;
3598     } else if (c2 == 0x21) {
3599         /* JISX0208 Kigou */
3600         if (0x21==c1) {
3601             if (alpha_f&2) {
3602                 c2 = 0;
3603                 c1 = SP;
3604             } else if (alpha_f&4) {
3605                 (*o_zconv)(0, SP);
3606                 (*o_zconv)(0, SP);
3607                 return;
3608             }
3609         } else if (alpha_f&1 && 0x20<c1 && c1<0x7f && fv[c1-0x20]) {
3610             c2 =  0;
3611             c1 = fv[c1-0x20];
3612         }
3613     }
3614
3615     if (alpha_f&8 && c2 == 0) {
3616         /* HTML Entity */
3617         const char *entity = 0;
3618         switch (c1){
3619         case '>': entity = "&gt;"; break;
3620         case '<': entity = "&lt;"; break;
3621         case '\"': entity = "&quot;"; break;
3622         case '&': entity = "&amp;"; break;
3623         }
3624         if (entity){
3625             while (*entity) (*o_zconv)(0, *entity++);
3626             return;
3627         }
3628     }
3629
3630     if (alpha_f & 16) {
3631         /* JIS X 0208 Katakana to JIS X 0201 Katakana */
3632         if (c2 == 0x21) {
3633             nkf_char c = 0;
3634             switch (c1) {
3635             case 0x23:
3636                 /* U+3002 (0x8142) Ideographic Full Stop -> U+FF61 (0xA1) Halfwidth Ideographic Full Stop */
3637                 c = 0xA1;
3638                 break;
3639             case 0x56:
3640                 /* U+300C (0x8175) Left Corner Bracket -> U+FF62 (0xA2) Halfwidth Left Corner Bracket */
3641                 c = 0xA2;
3642                 break;
3643             case 0x57:
3644                 /* U+300D (0x8176) Right Corner Bracket -> U+FF63 (0xA3) Halfwidth Right Corner Bracket */
3645                 c = 0xA3;
3646                 break;
3647             case 0x22:
3648                 /* U+3001 (0x8141) Ideographic Comma -> U+FF64 (0xA4) Halfwidth Ideographic Comma */
3649                 c = 0xA4;
3650                 break;
3651             case 0x26:
3652                 /* U+30FB (0x8145) Katakana Middle Dot -> U+FF65 (0xA5) Halfwidth Katakana Middle Dot */
3653                 c = 0xA5;
3654                 break;
3655             case 0x3C:
3656                 /* U+30FC (0x815B) Katakana-Hiragana Prolonged Sound Mark -> U+FF70 (0xB0) Halfwidth Katakana-Hiragana Prolonged Sound Mark */
3657                 c = 0xB0;
3658                 break;
3659             case 0x2B:
3660                 /* U+309B (0x814A) Katakana-Hiragana Voiced Sound Mark -> U+FF9E (0xDE) Halfwidth Katakana Voiced Sound Mark */
3661                 c = 0xDE;
3662                 break;
3663             case 0x2C:
3664                 /* U+309C (0x814B) Katakana-Hiragana Semi-Voiced Sound Mark -> U+FF9F (0xDF) Halfwidth Katakana Semi-Voiced Sound Mark */
3665                 c = 0xDF;
3666                 break;
3667             }
3668             if (c) {
3669                 (*o_zconv)(JIS_X_0201_1976_K, c);
3670                 return;
3671             }
3672         } else if (c2 == 0x25) {
3673             /* JISX0208 Katakana */
3674             static const int fullwidth_to_halfwidth[] =
3675             {
3676                 0x0000, 0x2700, 0x3100, 0x2800, 0x3200, 0x2900, 0x3300, 0x2A00,
3677                 0x3400, 0x2B00, 0x3500, 0x3600, 0x365E, 0x3700, 0x375E, 0x3800,
3678                 0x385E, 0x3900, 0x395E, 0x3A00, 0x3A5E, 0x3B00, 0x3B5E, 0x3C00,
3679                 0x3C5E, 0x3D00, 0x3D5E, 0x3E00, 0x3E5E, 0x3F00, 0x3F5E, 0x4000,
3680                 0x405E, 0x4100, 0x415E, 0x2F00, 0x4200, 0x425E, 0x4300, 0x435E,
3681                 0x4400, 0x445E, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00,
3682                 0x4A5E, 0x4A5F, 0x4B00, 0x4B5E, 0x4B5F, 0x4C00, 0x4C5E, 0x4C5F,
3683                 0x4D00, 0x4D5E, 0x4D5F, 0x4E00, 0x4E5E, 0x4E5F, 0x4F00, 0x5000,
3684                 0x5100, 0x5200, 0x5300, 0x2C00, 0x5400, 0x2D00, 0x5500, 0x2E00,
3685                 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x0000, 0x5C00,
3686                 0x0000, 0x0000, 0x2600, 0x5D00, 0x335E, 0x0000, 0x0000, 0x0000,
3687                 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
3688             };
3689             if (fullwidth_to_halfwidth[c1-0x20]){
3690                 c2 = fullwidth_to_halfwidth[c1-0x20];
3691                 (*o_zconv)(JIS_X_0201_1976_K, c2>>8);
3692                 if (c2 & 0xFF) {
3693                     (*o_zconv)(JIS_X_0201_1976_K, c2&0xFF);
3694                 }
3695                 return;
3696             }
3697         }
3698     }
3699     (*o_zconv)(c2,c1);
3700 }
3701
3702
3703 #define rot13(c)  ( \
3704                    ( c < 'A') ? c: \
3705                    (c <= 'M')  ? (c + 13): \
3706                    (c <= 'Z')  ? (c - 13): \
3707                    (c < 'a')   ? (c): \
3708                    (c <= 'm')  ? (c + 13): \
3709                    (c <= 'z')  ? (c - 13): \
3710                    (c) \
3711                   )
3712
3713 #define  rot47(c) ( \
3714                    ( c < '!') ? c: \
3715                    ( c <= 'O') ? (c + 47) : \
3716                    ( c <= '~') ?  (c - 47) : \
3717                    c \
3718                   )
3719
3720 static void
3721 rot_conv(nkf_char c2, nkf_char c1)
3722 {
3723     if (c2 == 0 || c2 == JIS_X_0201_1976_K || c2 == ISO_8859_1) {
3724         c1 = rot13(c1);
3725     } else if (c2) {
3726         c1 = rot47(c1);
3727         c2 = rot47(c2);
3728     }
3729     (*o_rot_conv)(c2,c1);
3730 }
3731
3732 static void
3733 hira_conv(nkf_char c2, nkf_char c1)
3734 {
3735     if (hira_f & 1) {
3736         if (c2 == 0x25) {
3737             if (0x20 < c1 && c1 < 0x74) {
3738                 c2 = 0x24;
3739                 (*o_hira_conv)(c2,c1);
3740                 return;
3741             } else if (c1 == 0x74 && nkf_enc_unicode_p(output_encoding)) {
3742                 c2 = 0;
3743                 c1 = nkf_char_unicode_new(0x3094);
3744                 (*o_hira_conv)(c2,c1);
3745                 return;
3746             }
3747         } else if (c2 == 0x21 && (c1 == 0x33 || c1 == 0x34)) {
3748             c1 += 2;
3749             (*o_hira_conv)(c2,c1);
3750             return;
3751         }
3752     }
3753     if (hira_f & 2) {
3754         if (c2 == 0 && c1 == nkf_char_unicode_new(0x3094)) {
3755             c2 = 0x25;
3756             c1 = 0x74;
3757         } else if (c2 == 0x24 && 0x20 < c1 && c1 < 0x74) {
3758             c2 = 0x25;
3759         } else if (c2 == 0x21 && (c1 == 0x35 || c1 == 0x36)) {
3760             c1 -= 2;
3761         }
3762     }
3763     (*o_hira_conv)(c2,c1);
3764 }
3765
3766
3767 static void
3768 iso2022jp_check_conv(nkf_char c2, nkf_char c1)
3769 {
3770 #define RANGE_NUM_MAX 18
3771     static const nkf_char range[RANGE_NUM_MAX][2] = {
3772         {0x222f, 0x2239,},
3773         {0x2242, 0x2249,},
3774         {0x2251, 0x225b,},
3775         {0x226b, 0x2271,},
3776         {0x227a, 0x227d,},
3777         {0x2321, 0x232f,},
3778         {0x233a, 0x2340,},
3779         {0x235b, 0x2360,},
3780         {0x237b, 0x237e,},
3781         {0x2474, 0x247e,},
3782         {0x2577, 0x257e,},
3783         {0x2639, 0x2640,},
3784         {0x2659, 0x267e,},
3785         {0x2742, 0x2750,},
3786         {0x2772, 0x277e,},
3787         {0x2841, 0x287e,},
3788         {0x4f54, 0x4f7e,},
3789         {0x7425, 0x747e},
3790     };
3791     nkf_char i;
3792     nkf_char start, end, c;
3793
3794     if(c2 >= 0x00 && c2 <= 0x20 && c1 >= 0x7f && c1 <= 0xff) {
3795         c2 = GETA1;
3796         c1 = GETA2;
3797     }
3798     if((c2 >= 0x29 && c2 <= 0x2f) || (c2 >= 0x75 && c2 <= 0x7e)) {
3799         c2 = GETA1;
3800         c1 = GETA2;
3801     }
3802
3803     for (i = 0; i < RANGE_NUM_MAX; i++) {
3804         start = range[i][0];
3805         end   = range[i][1];
3806         c     = (c2 << 8) + c1;
3807         if (c >= start && c <= end) {
3808             c2 = GETA1;
3809             c1 = GETA2;
3810         }
3811     }
3812     (*o_iso2022jp_check_conv)(c2,c1);
3813 }
3814
3815
3816 /* This converts  =?ISO-2022-JP?B?HOGE HOGE?= */
3817
3818 static const unsigned char *mime_pattern[] = {
3819     (const unsigned char *)"\075?EUC-JP?B?",
3820     (const unsigned char *)"\075?SHIFT_JIS?B?",
3821     (const unsigned char *)"\075?ISO-8859-1?Q?",
3822     (const unsigned char *)"\075?ISO-8859-1?B?",
3823     (const unsigned char *)"\075?ISO-2022-JP?B?",
3824     (const unsigned char *)"\075?ISO-2022-JP?B?",
3825     (const unsigned char *)"\075?ISO-2022-JP?Q?",
3826 #if defined(UTF8_INPUT_ENABLE)
3827     (const unsigned char *)"\075?UTF-8?B?",
3828     (const unsigned char *)"\075?UTF-8?Q?",
3829 #endif
3830     (const unsigned char *)"\075?US-ASCII?Q?",
3831     NULL
3832 };
3833
3834
3835 /* \e$B3:Ev$9$k%3!<%I$NM%@hEY$r>e$2$k$?$a$NL\0u\e(B */
3836 nkf_char (*mime_priority_func[])(nkf_char c2, nkf_char c1, nkf_char c0) = {
3837     e_iconv, s_iconv, 0, 0, 0, 0,
3838 #if defined(UTF8_INPUT_ENABLE)
3839     w_iconv, w_iconv,
3840 #endif
3841     0,
3842 };
3843
3844 static const nkf_char mime_encode[] = {
3845     EUC_JP, SHIFT_JIS, ISO_8859_1, ISO_8859_1, JIS_X_0208, JIS_X_0201_1976_K, JIS_X_0201_1976_K,
3846 #if defined(UTF8_INPUT_ENABLE)
3847     UTF_8, UTF_8,
3848 #endif
3849     ASCII,
3850     0
3851 };
3852
3853 static const nkf_char mime_encode_method[] = {
3854     'B', 'B','Q', 'B', 'B', 'B', 'Q',
3855 #if defined(UTF8_INPUT_ENABLE)
3856     'B', 'Q',
3857 #endif
3858     'Q',
3859     0
3860 };
3861
3862
3863 /* MIME preprocessor fifo */
3864
3865 #define MIME_BUF_SIZE   (1024)    /* 2^n ring buffer */
3866 #define MIME_BUF_MASK   (MIME_BUF_SIZE-1)
3867 #define mime_input_buf(n)        mime_input_state.buf[(n)&MIME_BUF_MASK]
3868 static struct {
3869     unsigned char buf[MIME_BUF_SIZE];
3870     unsigned int  top;
3871     unsigned int  last;  /* decoded */
3872     unsigned int  input; /* undecoded */
3873 } mime_input_state;
3874 static nkf_char (*mime_iconv_back)(nkf_char c2,nkf_char c1,nkf_char c0) = NULL;
3875
3876 #define MAXRECOVER 20
3877
3878 static void
3879 mime_input_buf_unshift(nkf_char c)
3880 {
3881     mime_input_buf(--mime_input_state.top) = (unsigned char)c;
3882 }
3883
3884 static nkf_char
3885 mime_ungetc(nkf_char c, FILE *f)
3886 {
3887     mime_input_buf_unshift(c);
3888     return c;
3889 }
3890
3891 static nkf_char
3892 mime_ungetc_buf(nkf_char c, FILE *f)
3893 {
3894     if (mimebuf_f)
3895         (*i_mungetc_buf)(c,f);
3896     else
3897         mime_input_buf(--mime_input_state.input) = (unsigned char)c;
3898     return c;
3899 }
3900
3901 static nkf_char
3902 mime_getc_buf(FILE *f)
3903 {
3904     /* we don't keep eof of mime_input_buf, becase it contains ?= as
3905        a terminator. It was checked in mime_integrity. */
3906     return ((mimebuf_f)?
3907             (*i_mgetc_buf)(f):mime_input_buf(mime_input_state.input++));
3908 }
3909
3910 static void
3911 switch_mime_getc(void)
3912 {
3913     if (i_getc!=mime_getc) {
3914         i_mgetc = i_getc; i_getc = mime_getc;
3915         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
3916         if(mime_f==STRICT_MIME) {
3917             i_mgetc_buf = i_mgetc; i_mgetc = mime_getc_buf;
3918             i_mungetc_buf = i_mungetc; i_mungetc = mime_ungetc_buf;
3919         }
3920     }
3921 }
3922
3923 static void
3924 unswitch_mime_getc(void)
3925 {
3926     if(mime_f==STRICT_MIME) {
3927         i_mgetc = i_mgetc_buf;
3928         i_mungetc = i_mungetc_buf;
3929     }
3930     i_getc = i_mgetc;
3931     i_ungetc = i_mungetc;
3932     if(mime_iconv_back)set_iconv(FALSE, mime_iconv_back);
3933     mime_iconv_back = NULL;
3934 }
3935
3936 static nkf_char
3937 mime_integrity(FILE *f, const unsigned char *p)
3938 {
3939     nkf_char c,d;
3940     unsigned int q;
3941     /* In buffered mode, read until =? or NL or buffer full
3942      */
3943     mime_input_state.input = mime_input_state.top;
3944     mime_input_state.last = mime_input_state.top;
3945
3946     while(*p) mime_input_buf(mime_input_state.input++) = *p++;
3947     d = 0;
3948     q = mime_input_state.input;
3949     while((c=(*i_getc)(f))!=EOF) {
3950         if (((mime_input_state.input-mime_input_state.top)&MIME_BUF_MASK)==0) {
3951             break;   /* buffer full */
3952         }
3953         if (c=='=' && d=='?') {
3954             /* checked. skip header, start decode */
3955             mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3956             /* mime_last_input = mime_input_state.input; */
3957             mime_input_state.input = q;
3958             switch_mime_getc();
3959             return 1;
3960         }
3961         if (!( (c=='+'||c=='/'|| c=='=' || c=='?' || is_alnum(c))))
3962             break;
3963         /* Should we check length mod 4? */
3964         mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3965         d=c;
3966     }
3967     /* In case of Incomplete MIME, no MIME decode  */
3968     mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3969     mime_input_state.last = mime_input_state.input;     /* point undecoded buffer */
3970     mime_decode_mode = 1;              /* no decode on mime_input_buf last in mime_getc */
3971     switch_mime_getc();         /* anyway we need buffered getc */
3972     return 1;
3973 }
3974
3975 static nkf_char
3976 mime_begin_strict(FILE *f)
3977 {
3978     nkf_char c1 = 0;
3979     int i,j,k;
3980     const unsigned char *p,*q;
3981     nkf_char r[MAXRECOVER];    /* recovery buffer, max mime pattern length */
3982
3983     mime_decode_mode = FALSE;
3984     /* =? has been checked */
3985     j = 0;
3986     p = mime_pattern[j];
3987     r[0]='='; r[1]='?';
3988
3989     for(i=2;p[i]>SP;i++) {                   /* start at =? */
3990         if (((r[i] = c1 = (*i_getc)(f))==EOF) || nkf_toupper(c1) != p[i]) {
3991             /* pattern fails, try next one */
3992             q = p;
3993             while (mime_pattern[++j]) {
3994                 p = mime_pattern[j];
3995                 for(k=2;k<i;k++)              /* assume length(p) > i */
3996                     if (p[k]!=q[k]) break;
3997                 if (k==i && nkf_toupper(c1)==p[k]) break;
3998             }
3999             p = mime_pattern[j];
4000             if (p) continue;  /* found next one, continue */
4001             /* all fails, output from recovery buffer */
4002             (*i_ungetc)(c1,f);
4003             for(j=0;j<i;j++) {
4004                 (*oconv)(0,r[j]);
4005             }
4006             return c1;
4007         }
4008     }
4009     mime_decode_mode = p[i-2];
4010
4011     mime_iconv_back = iconv;
4012     set_iconv(FALSE, mime_priority_func[j]);
4013     clr_code_score(find_inputcode_byfunc(mime_priority_func[j]), SCORE_iMIME);
4014
4015     if (mime_decode_mode=='B') {
4016         mimebuf_f = unbuf_f;
4017         if (!unbuf_f) {
4018             /* do MIME integrity check */
4019             return mime_integrity(f,mime_pattern[j]);
4020         }
4021     }
4022     switch_mime_getc();
4023     mimebuf_f = TRUE;
4024     return c1;
4025 }
4026
4027 static nkf_char
4028 mime_begin(FILE *f)
4029 {
4030     nkf_char c1;
4031     int i,k;
4032
4033     /* In NONSTRICT mode, only =? is checked. In case of failure, we  */
4034     /* re-read and convert again from mime_buffer.  */
4035
4036     /* =? has been checked */
4037     k = mime_input_state.last;
4038     mime_input_buf(mime_input_state.last++)='='; mime_input_buf(mime_input_state.last++)='?';
4039     for(i=2;i<MAXRECOVER;i++) {                   /* start at =? */
4040         /* We accept any character type even if it is breaked by new lines */
4041         c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4042         if (c1==LF||c1==SP||c1==CR||
4043             c1=='-'||c1=='_'||is_alnum(c1)) continue;
4044         if (c1=='=') {
4045             /* Failed. But this could be another MIME preemble */
4046             (*i_ungetc)(c1,f);
4047             mime_input_state.last--;
4048             break;
4049         }
4050         if (c1!='?') break;
4051         else {
4052             /* c1=='?' */
4053             c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4054             if (!(++i<MAXRECOVER) || c1==EOF) break;
4055             if (c1=='b'||c1=='B') {
4056                 mime_decode_mode = 'B';
4057             } else if (c1=='q'||c1=='Q') {
4058                 mime_decode_mode = 'Q';
4059             } else {
4060                 break;
4061             }
4062             c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4063             if (!(++i<MAXRECOVER) || c1==EOF) break;
4064             if (c1!='?') {
4065                 mime_decode_mode = FALSE;
4066             }
4067             break;
4068         }
4069     }
4070     switch_mime_getc();
4071     if (!mime_decode_mode) {
4072         /* false MIME premble, restart from mime_buffer */
4073         mime_decode_mode = 1;  /* no decode, but read from the mime_buffer */
4074         /* Since we are in MIME mode until buffer becomes empty,    */
4075         /* we never go into mime_begin again for a while.           */
4076         return c1;
4077     }
4078     /* discard mime preemble, and goto MIME mode */
4079     mime_input_state.last = k;
4080     /* do no MIME integrity check */
4081     return c1;   /* used only for checking EOF */
4082 }
4083
4084 #ifdef CHECK_OPTION
4085 static void
4086 no_putc(nkf_char c)
4087 {
4088     ;
4089 }
4090
4091 static void
4092 debug(const char *str)
4093 {
4094     if (debug_f){
4095         fprintf(stderr, "%s\n", str ? str : "NULL");
4096     }
4097 }
4098 #endif
4099
4100 static void
4101 set_input_codename(const char *codename)
4102 {
4103     if (!input_codename) {
4104         input_codename = codename;
4105     } else if (strcmp(codename, input_codename) != 0) {
4106         input_codename = "";
4107     }
4108 }
4109
4110 static const char*
4111 get_guessed_code(void)
4112 {
4113     if (input_codename && !*input_codename) {
4114         input_codename = "BINARY";
4115     } else {
4116         struct input_code *p = find_inputcode_byfunc(iconv);
4117         if (!input_codename) {
4118             input_codename = "ASCII";
4119         } else if (strcmp(input_codename, "Shift_JIS") == 0) {
4120             if (p->score & (SCORE_DEPEND|SCORE_CP932))
4121                 input_codename = "CP932";
4122         } else if (strcmp(input_codename, "EUC-JP") == 0) {
4123             if (p->score & (SCORE_X0212))
4124                 input_codename = "EUCJP-MS";
4125             else if (p->score & (SCORE_DEPEND|SCORE_CP932))
4126                 input_codename = "CP51932";
4127         } else if (strcmp(input_codename, "ISO-2022-JP") == 0) {
4128             if (p->score & (SCORE_KANA))
4129                 input_codename = "CP50221";
4130             else if (p->score & (SCORE_DEPEND|SCORE_CP932))
4131                 input_codename = "CP50220";
4132         }
4133     }
4134     return input_codename;
4135 }
4136
4137 #if !defined(PERL_XS) && !defined(WIN32DLL)
4138 static void
4139 print_guessed_code(char *filename)
4140 {
4141     if (filename != NULL) printf("%s: ", filename);
4142     if (input_codename && !*input_codename) {
4143         printf("BINARY\n");
4144     } else {
4145         input_codename = get_guessed_code();
4146         if (guess_f == 1) {
4147             printf("%s\n", input_codename);
4148         } else {
4149             printf("%s%s\n",
4150                    input_codename,
4151                    input_eol == CR   ? " (CR)" :
4152                    input_eol == LF   ? " (LF)" :
4153                    input_eol == CRLF ? " (CRLF)" :
4154                    input_eol == EOF  ? " (MIXED NL)" :
4155                    "");
4156         }
4157     }
4158 }
4159 #endif /*WIN32DLL*/
4160
4161 #ifdef INPUT_OPTION
4162
4163 static nkf_char
4164 hex_getc(nkf_char ch, FILE *f, nkf_char (*g)(FILE *f), nkf_char (*u)(nkf_char c, FILE *f))
4165 {
4166     nkf_char c1, c2, c3;
4167     c1 = (*g)(f);
4168     if (c1 != ch){
4169         return c1;
4170     }
4171     c2 = (*g)(f);
4172     if (!nkf_isxdigit(c2)){
4173         (*u)(c2, f);
4174         return c1;
4175     }
4176     c3 = (*g)(f);
4177     if (!nkf_isxdigit(c3)){
4178         (*u)(c2, f);
4179         (*u)(c3, f);
4180         return c1;
4181     }
4182     return (hex2bin(c2) << 4) | hex2bin(c3);
4183 }
4184
4185 static nkf_char
4186 cap_getc(FILE *f)
4187 {
4188     return hex_getc(':', f, i_cgetc, i_cungetc);
4189 }
4190
4191 static nkf_char
4192 cap_ungetc(nkf_char c, FILE *f)
4193 {
4194     return (*i_cungetc)(c, f);
4195 }
4196
4197 static nkf_char
4198 url_getc(FILE *f)
4199 {
4200     return hex_getc('%', f, i_ugetc, i_uungetc);
4201 }
4202
4203 static nkf_char
4204 url_ungetc(nkf_char c, FILE *f)
4205 {
4206     return (*i_uungetc)(c, f);
4207 }
4208 #endif
4209
4210 #ifdef NUMCHAR_OPTION
4211 static nkf_char
4212 numchar_getc(FILE *f)
4213 {
4214     nkf_char (*g)(FILE *) = i_ngetc;
4215     nkf_char (*u)(nkf_char c ,FILE *f) = i_nungetc;
4216     int i = 0, j;
4217     nkf_char buf[12];
4218     long c = -1;
4219
4220     buf[i] = (*g)(f);
4221     if (buf[i] == '&'){
4222         buf[++i] = (*g)(f);
4223         if (buf[i] == '#'){
4224             c = 0;
4225             buf[++i] = (*g)(f);
4226             if (buf[i] == 'x' || buf[i] == 'X'){
4227                 for (j = 0; j < 7; j++){
4228                     buf[++i] = (*g)(f);
4229                     if (!nkf_isxdigit(buf[i])){
4230                         if (buf[i] != ';'){
4231                             c = -1;
4232                         }
4233                         break;
4234                     }
4235                     c <<= 4;
4236                     c |= hex2bin(buf[i]);
4237                 }
4238             }else{
4239                 for (j = 0; j < 8; j++){
4240                     if (j){
4241                         buf[++i] = (*g)(f);
4242                     }
4243                     if (!nkf_isdigit(buf[i])){
4244                         if (buf[i] != ';'){
4245                             c = -1;
4246                         }
4247                         break;
4248                     }
4249                     c *= 10;
4250                     c += hex2bin(buf[i]);
4251                 }
4252             }
4253         }
4254     }
4255     if (c != -1){
4256         return nkf_char_unicode_new(c);
4257     }
4258     while (i > 0){
4259         (*u)(buf[i], f);
4260         --i;
4261     }
4262     return buf[0];
4263 }
4264
4265 static nkf_char
4266 numchar_ungetc(nkf_char c, FILE *f)
4267 {
4268     return (*i_nungetc)(c, f);
4269 }
4270 #endif
4271
4272 #ifdef UNICODE_NORMALIZATION
4273
4274 static nkf_char
4275 nfc_getc(FILE *f)
4276 {
4277     nkf_char (*g)(FILE *f) = i_nfc_getc;
4278     nkf_char (*u)(nkf_char c ,FILE *f) = i_nfc_ungetc;
4279     nkf_buf_t *buf = nkf_state->nfc_buf;
4280     const unsigned char *array;
4281     int lower=0, upper=NORMALIZATION_TABLE_LENGTH-1;
4282     nkf_char c = (*g)(f);
4283
4284     if (c == EOF || c > 0xFF || (c & 0xc0) == 0x80) return c;
4285
4286     nkf_buf_push(buf, c);
4287     do {
4288         while (lower <= upper) {
4289             int mid = (lower+upper) / 2;
4290             int len;
4291             array = normalization_table[mid].nfd;
4292             for (len=0; len < NORMALIZATION_TABLE_NFD_LENGTH && array[len]; len++) {
4293                 if (len >= nkf_buf_length(buf)) {
4294                     c = (*g)(f);
4295                     if (c == EOF) {
4296                         len = 0;
4297                         lower = 1, upper = 0;
4298                         break;
4299                     }
4300                     nkf_buf_push(buf, c);
4301                 }
4302                 if (array[len] != nkf_buf_at(buf, len)) {
4303                     if (array[len] < nkf_buf_at(buf, len)) lower = mid + 1;
4304                     else  upper = mid - 1;
4305                     len = 0;
4306                     break;
4307                 }
4308             }
4309             if (len > 0) {
4310                 int i;
4311                 array = normalization_table[mid].nfc;
4312                 nkf_buf_clear(buf);
4313                 for (i=0; i < NORMALIZATION_TABLE_NFC_LENGTH && array[i]; i++)
4314                     nkf_buf_push(buf, array[i]);
4315                 break;
4316             }
4317         }
4318     } while (lower <= upper);
4319
4320     while (nkf_buf_length(buf) > 1) (*u)(nkf_buf_pop(buf), f);
4321     c = nkf_buf_pop(buf);
4322
4323     return c;
4324 }
4325
4326 static nkf_char
4327 nfc_ungetc(nkf_char c, FILE *f)
4328 {
4329     return (*i_nfc_ungetc)(c, f);
4330 }
4331 #endif /* UNICODE_NORMALIZATION */
4332
4333
4334 static nkf_char
4335 base64decode(nkf_char c)
4336 {
4337     int             i;
4338     if (c > '@') {
4339         if (c < '[') {
4340             i = c - 'A';                        /* A..Z 0-25 */
4341         } else if (c == '_') {
4342             i = '?'         /* 63 */ ;          /* _  63 */
4343         } else {
4344             i = c - 'G'     /* - 'a' + 26 */ ;  /* a..z 26-51 */
4345         }
4346     } else if (c > '/') {
4347         i = c - '0' + '4'   /* - '0' + 52 */ ;  /* 0..9 52-61 */
4348     } else if (c == '+' || c == '-') {
4349         i = '>'             /* 62 */ ;          /* + and -  62 */
4350     } else {
4351         i = '?'             /* 63 */ ;          /* / 63 */
4352     }
4353     return (i);
4354 }
4355
4356 static nkf_char
4357 mime_getc(FILE *f)
4358 {
4359     nkf_char c1, c2, c3, c4, cc;
4360     nkf_char t1, t2, t3, t4, mode, exit_mode;
4361     nkf_char lwsp_count;
4362     char *lwsp_buf;
4363     char *lwsp_buf_new;
4364     nkf_char lwsp_size = 128;
4365
4366     if (mime_input_state.top != mime_input_state.last) {  /* Something is in FIFO */
4367         return  mime_input_buf(mime_input_state.top++);
4368     }
4369     if (mime_decode_mode==1 ||mime_decode_mode==FALSE) {
4370         mime_decode_mode=FALSE;
4371         unswitch_mime_getc();
4372         return (*i_getc)(f);
4373     }
4374
4375     if (mimebuf_f == FIXED_MIME)
4376         exit_mode = mime_decode_mode;
4377     else
4378         exit_mode = FALSE;
4379     if (mime_decode_mode == 'Q') {
4380         if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
4381       restart_mime_q:
4382         if (c1=='_' && mimebuf_f != FIXED_MIME) return SP;
4383         if (c1<=SP || DEL<=c1) {
4384             mime_decode_mode = exit_mode; /* prepare for quit */
4385             return c1;
4386         }
4387         if (c1!='=' && (c1!='?' || mimebuf_f == FIXED_MIME)) {
4388             return c1;
4389         }
4390
4391         mime_decode_mode = exit_mode; /* prepare for quit */
4392         if ((c2 = (*i_mgetc)(f)) == EOF) return (EOF);
4393         if (c1=='?'&&c2=='=' && mimebuf_f != FIXED_MIME) {
4394             /* end Q encoding */
4395             input_mode = exit_mode;
4396             lwsp_count = 0;
4397             lwsp_buf = nkf_xmalloc((lwsp_size+5)*sizeof(char));
4398             while ((c1=(*i_getc)(f))!=EOF) {
4399                 switch (c1) {
4400                 case LF:
4401                 case CR:
4402                     if (c1==LF) {
4403                         if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4404                             i_ungetc(SP,f);
4405                             continue;
4406                         } else {
4407                             i_ungetc(c1,f);
4408                         }
4409                         c1 = LF;
4410                     } else {
4411                         if ((c1=(*i_getc)(f))!=EOF && c1 == LF) {
4412                             if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4413                                 i_ungetc(SP,f);
4414                                 continue;
4415                             } else {
4416                                 i_ungetc(c1,f);
4417                             }
4418                             i_ungetc(LF,f);
4419                         } else {
4420                             i_ungetc(c1,f);
4421                         }
4422                         c1 = CR;
4423                     }
4424                     break;
4425                 case SP:
4426                 case TAB:
4427                     lwsp_buf[lwsp_count] = (unsigned char)c1;
4428                     if (lwsp_count++>lwsp_size){
4429                         lwsp_size <<= 1;
4430                         lwsp_buf_new = nkf_xrealloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4431                         lwsp_buf = lwsp_buf_new;
4432                     }
4433                     continue;
4434                 }
4435                 break;
4436             }
4437             if (lwsp_count > 0 && (c1 != '=' || (lwsp_buf[lwsp_count-1] != SP && lwsp_buf[lwsp_count-1] != TAB))) {
4438                 i_ungetc(c1,f);
4439                 for(lwsp_count--;lwsp_count>0;lwsp_count--)
4440                     i_ungetc(lwsp_buf[lwsp_count],f);
4441                 c1 = lwsp_buf[0];
4442             }
4443             nkf_xfree(lwsp_buf);
4444             return c1;
4445         }
4446         if (c1=='='&&c2<SP) { /* this is soft wrap */
4447             while((c1 =  (*i_mgetc)(f)) <=SP) {
4448                 if (c1 == EOF) return (EOF);
4449             }
4450             mime_decode_mode = 'Q'; /* still in MIME */
4451             goto restart_mime_q;
4452         }
4453         if (c1=='?') {
4454             mime_decode_mode = 'Q'; /* still in MIME */
4455             (*i_mungetc)(c2,f);
4456             return c1;
4457         }
4458         if ((c3 = (*i_mgetc)(f)) == EOF) return (EOF);
4459         if (c2<=SP) return c2;
4460         mime_decode_mode = 'Q'; /* still in MIME */
4461         return ((hex2bin(c2)<<4) + hex2bin(c3));
4462     }
4463
4464     if (mime_decode_mode != 'B') {
4465         mime_decode_mode = FALSE;
4466         return (*i_mgetc)(f);
4467     }
4468
4469
4470     /* Base64 encoding */
4471     /*
4472        MIME allows line break in the middle of
4473        Base64, but we are very pessimistic in decoding
4474        in unbuf mode because MIME encoded code may broken by
4475        less or editor's control sequence (such as ESC-[-K in unbuffered
4476        mode. ignore incomplete MIME.
4477      */
4478     mode = mime_decode_mode;
4479     mime_decode_mode = exit_mode;  /* prepare for quit */
4480
4481     while ((c1 = (*i_mgetc)(f))<=SP) {
4482         if (c1==EOF)
4483             return (EOF);
4484     }
4485   mime_c2_retry:
4486     if ((c2 = (*i_mgetc)(f))<=SP) {
4487         if (c2==EOF)
4488             return (EOF);
4489         if (mime_f != STRICT_MIME) goto mime_c2_retry;
4490         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4491         return c2;
4492     }
4493     if ((c1 == '?') && (c2 == '=')) {
4494         input_mode = ASCII;
4495         lwsp_count = 0;
4496         lwsp_buf = nkf_xmalloc((lwsp_size+5)*sizeof(char));
4497         while ((c1=(*i_getc)(f))!=EOF) {
4498             switch (c1) {
4499             case LF:
4500             case CR:
4501                 if (c1==LF) {
4502                     if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4503                         i_ungetc(SP,f);
4504                         continue;
4505                     } else {
4506                         i_ungetc(c1,f);
4507                     }
4508                     c1 = LF;
4509                 } else {
4510                     if ((c1=(*i_getc)(f))!=EOF) {
4511                         if (c1==SP) {
4512                             i_ungetc(SP,f);
4513                             continue;
4514                         } else if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4515                             i_ungetc(SP,f);
4516                             continue;
4517                         } else {
4518                             i_ungetc(c1,f);
4519                         }
4520                         i_ungetc(LF,f);
4521                     } else {
4522                         i_ungetc(c1,f);
4523                     }
4524                     c1 = CR;
4525                 }
4526                 break;
4527             case SP:
4528             case TAB:
4529                 lwsp_buf[lwsp_count] = (unsigned char)c1;
4530                 if (lwsp_count++>lwsp_size){
4531                     lwsp_size <<= 1;
4532                     lwsp_buf_new = nkf_xrealloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4533                     lwsp_buf = lwsp_buf_new;
4534                 }
4535                 continue;
4536             }
4537             break;
4538         }
4539         if (lwsp_count > 0 && (c1 != '=' || (lwsp_buf[lwsp_count-1] != SP && lwsp_buf[lwsp_count-1] != TAB))) {
4540             i_ungetc(c1,f);
4541             for(lwsp_count--;lwsp_count>0;lwsp_count--)
4542                 i_ungetc(lwsp_buf[lwsp_count],f);
4543             c1 = lwsp_buf[0];
4544         }
4545         nkf_xfree(lwsp_buf);
4546         return c1;
4547     }
4548   mime_c3_retry:
4549     if ((c3 = (*i_mgetc)(f))<=SP) {
4550         if (c3==EOF)
4551             return (EOF);
4552         if (mime_f != STRICT_MIME) goto mime_c3_retry;
4553         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4554         return c3;
4555     }
4556   mime_c4_retry:
4557     if ((c4 = (*i_mgetc)(f))<=SP) {
4558         if (c4==EOF)
4559             return (EOF);
4560         if (mime_f != STRICT_MIME) goto mime_c4_retry;
4561         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4562         return c4;
4563     }
4564
4565     mime_decode_mode = mode; /* still in MIME sigh... */
4566
4567     /* BASE 64 decoding */
4568
4569     t1 = 0x3f & base64decode(c1);
4570     t2 = 0x3f & base64decode(c2);
4571     t3 = 0x3f & base64decode(c3);
4572     t4 = 0x3f & base64decode(c4);
4573     cc = ((t1 << 2) & 0x0fc) | ((t2 >> 4) & 0x03);
4574     if (c2 != '=') {
4575         mime_input_buf(mime_input_state.last++) = (unsigned char)cc;
4576         cc = ((t2 << 4) & 0x0f0) | ((t3 >> 2) & 0x0f);
4577         if (c3 != '=') {
4578             mime_input_buf(mime_input_state.last++) = (unsigned char)cc;
4579             cc = ((t3 << 6) & 0x0c0) | (t4 & 0x3f);
4580             if (c4 != '=')
4581                 mime_input_buf(mime_input_state.last++) = (unsigned char)cc;
4582         }
4583     } else {
4584         return c1;
4585     }
4586     return  mime_input_buf(mime_input_state.top++);
4587 }
4588
4589 static const char basis_64[] =
4590     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4591
4592 #define MIMEOUT_BUF_LENGTH 74
4593 static struct {
4594     char buf[MIMEOUT_BUF_LENGTH+1];
4595     int count;
4596 } mimeout_state;
4597
4598 /*nkf_char mime_lastchar2, mime_lastchar1;*/
4599
4600 static void
4601 open_mime(nkf_char mode)
4602 {
4603     const unsigned char *p;
4604     int i;
4605     int j;
4606     p  = mime_pattern[0];
4607     for(i=0;mime_pattern[i];i++) {
4608         if (mode == mime_encode[i]) {
4609             p = mime_pattern[i];
4610             break;
4611         }
4612     }
4613     mimeout_mode = mime_encode_method[i];
4614     i = 0;
4615     if (base64_count>45) {
4616         if (mimeout_state.count>0 && nkf_isblank(mimeout_state.buf[i])){
4617             (*o_mputc)(mimeout_state.buf[i]);
4618             i++;
4619         }
4620         PUT_NEWLINE((*o_mputc));
4621         (*o_mputc)(SP);
4622         base64_count = 1;
4623         if (mimeout_state.count>0 && nkf_isspace(mimeout_state.buf[i])) {
4624             i++;
4625         }
4626     }
4627     for (;i<mimeout_state.count;i++) {
4628         if (nkf_isspace(mimeout_state.buf[i])) {
4629             (*o_mputc)(mimeout_state.buf[i]);
4630             base64_count ++;
4631         } else {
4632             break;
4633         }
4634     }
4635     while(*p) {
4636         (*o_mputc)(*p++);
4637         base64_count ++;
4638     }
4639     j = mimeout_state.count;
4640     mimeout_state.count = 0;
4641     for (;i<j;i++) {
4642         mime_putc(mimeout_state.buf[i]);
4643     }
4644 }
4645
4646 static void
4647 mime_prechar(nkf_char c2, nkf_char c1)
4648 {
4649     if (mimeout_mode > 0){
4650         if (c2 == EOF){
4651             if (base64_count + mimeout_state.count/3*4> 73){
4652                 (*o_base64conv)(EOF,0);
4653                 OCONV_NEWLINE((*o_base64conv));
4654                 (*o_base64conv)(0,SP);
4655                 base64_count = 1;
4656             }
4657         } else {
4658             if (!(c2 == 0 && (c1 == CR || c1 == LF)) &&
4659                     base64_count + mimeout_state.count/3*4> 66) {
4660                 (*o_base64conv)(EOF,0);
4661                 OCONV_NEWLINE((*o_base64conv));
4662                 (*o_base64conv)(0,SP);
4663                 base64_count = 1;
4664                 mimeout_mode = -1;
4665             }
4666         }
4667     } else if (c2) {
4668         if (c2 != EOF && base64_count + mimeout_state.count/3*4> 60) {
4669             mimeout_mode =  (output_mode==ASCII ||output_mode == ISO_8859_1) ? 'Q' : 'B';
4670             open_mime(output_mode);
4671             (*o_base64conv)(EOF,0);
4672             OCONV_NEWLINE((*o_base64conv));
4673             (*o_base64conv)(0,SP);
4674             base64_count = 1;
4675             mimeout_mode = -1;
4676         }
4677     }
4678 }
4679
4680 static void
4681 close_mime(void)
4682 {
4683     (*o_mputc)('?');
4684     (*o_mputc)('=');
4685     base64_count += 2;
4686     mimeout_mode = 0;
4687 }
4688
4689 static void
4690 eof_mime(void)
4691 {
4692     switch(mimeout_mode) {
4693     case 'Q':
4694     case 'B':
4695         break;
4696     case 2:
4697         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0x3)<< 4)]);
4698         (*o_mputc)('=');
4699         (*o_mputc)('=');
4700         base64_count += 3;
4701         break;
4702     case 1:
4703         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0xF) << 2)]);
4704         (*o_mputc)('=');
4705         base64_count += 2;
4706         break;
4707     }
4708     if (mimeout_mode > 0) {
4709         if (mimeout_f!=FIXED_MIME) {
4710             close_mime();
4711         } else if (mimeout_mode != 'Q')
4712             mimeout_mode = 'B';
4713     }
4714 }
4715
4716 static void
4717 mimeout_addchar(nkf_char c)
4718 {
4719     switch(mimeout_mode) {
4720     case 'Q':
4721         if (c==CR||c==LF) {
4722             (*o_mputc)(c);
4723             base64_count = 0;
4724         } else if(!nkf_isalnum(c)) {
4725             (*o_mputc)('=');
4726             (*o_mputc)(bin2hex(((c>>4)&0xf)));
4727             (*o_mputc)(bin2hex((c&0xf)));
4728             base64_count += 3;
4729         } else {
4730             (*o_mputc)(c);
4731             base64_count++;
4732         }
4733         break;
4734     case 'B':
4735         nkf_state->mimeout_state=c;
4736         (*o_mputc)(basis_64[c>>2]);
4737         mimeout_mode=2;
4738         base64_count ++;
4739         break;
4740     case 2:
4741         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0x3)<< 4) | ((c & 0xF0) >> 4)]);
4742         nkf_state->mimeout_state=c;
4743         mimeout_mode=1;
4744         base64_count ++;
4745         break;
4746     case 1:
4747         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0xF) << 2) | ((c & 0xC0) >>6)]);
4748         (*o_mputc)(basis_64[c & 0x3F]);
4749         mimeout_mode='B';
4750         base64_count += 2;
4751         break;
4752     default:
4753         (*o_mputc)(c);
4754         base64_count++;
4755         break;
4756     }
4757 }
4758
4759 static void
4760 mime_putc(nkf_char c)
4761 {
4762     int i, j;
4763     nkf_char lastchar;
4764
4765     if (mimeout_f == FIXED_MIME){
4766         if (mimeout_mode == 'Q'){
4767             if (base64_count > 71){
4768                 if (c!=CR && c!=LF) {
4769                     (*o_mputc)('=');
4770                     PUT_NEWLINE((*o_mputc));
4771                 }
4772                 base64_count = 0;
4773             }
4774         }else{
4775             if (base64_count > 71){
4776                 eof_mime();
4777                 PUT_NEWLINE((*o_mputc));
4778                 base64_count = 0;
4779             }
4780             if (c == EOF) { /* c==EOF */
4781                 eof_mime();
4782             }
4783         }
4784         if (c != EOF) { /* c==EOF */
4785             mimeout_addchar(c);
4786         }
4787         return;
4788     }
4789
4790     /* mimeout_f != FIXED_MIME */
4791
4792     if (c == EOF) { /* c==EOF */
4793         if (mimeout_mode == -1 && mimeout_state.count > 1) open_mime(output_mode);
4794         j = mimeout_state.count;
4795         mimeout_state.count = 0;
4796         i = 0;
4797         if (mimeout_mode > 0) {
4798             if (!nkf_isblank(mimeout_state.buf[j-1])) {
4799                 for (;i<j;i++) {
4800                     if (nkf_isspace(mimeout_state.buf[i]) && base64_count < 71){
4801                         break;
4802                     }
4803                     mimeout_addchar(mimeout_state.buf[i]);
4804                 }
4805                 eof_mime();
4806                 for (;i<j;i++) {
4807                     mimeout_addchar(mimeout_state.buf[i]);
4808                 }
4809             } else {
4810                 for (;i<j;i++) {
4811                     mimeout_addchar(mimeout_state.buf[i]);
4812                 }
4813                 eof_mime();
4814             }
4815         } else {
4816             for (;i<j;i++) {
4817                 mimeout_addchar(mimeout_state.buf[i]);
4818             }
4819         }
4820         return;
4821     }
4822
4823     if (mimeout_state.count > 0){
4824         lastchar = mimeout_state.buf[mimeout_state.count - 1];
4825     }else{
4826         lastchar = -1;
4827     }
4828
4829     if (mimeout_mode=='Q') {
4830         if (c <= DEL && (output_mode==ASCII ||output_mode == ISO_8859_1)) {
4831             if (c == CR || c == LF) {
4832                 close_mime();
4833                 (*o_mputc)(c);
4834                 base64_count = 0;
4835                 return;
4836             } else if (c <= SP) {
4837                 close_mime();
4838                 if (base64_count > 70) {
4839                     PUT_NEWLINE((*o_mputc));
4840                     base64_count = 0;
4841                 }
4842                 if (!nkf_isblank(c)) {
4843                     (*o_mputc)(SP);
4844                     base64_count++;
4845                 }
4846             } else {
4847                 if (base64_count > 70) {
4848                     close_mime();
4849                     PUT_NEWLINE((*o_mputc));
4850                     (*o_mputc)(SP);
4851                     base64_count = 1;
4852                     open_mime(output_mode);
4853                 }
4854                 if (!nkf_noescape_mime(c)) {
4855                     mimeout_addchar(c);
4856                     return;
4857                 }
4858             }
4859             if (c != 0x1B) {
4860                 (*o_mputc)(c);
4861                 base64_count++;
4862                 return;
4863             }
4864         }
4865     }
4866
4867     if (mimeout_mode <= 0) {
4868         if (c <= DEL && (output_mode==ASCII || output_mode == ISO_8859_1 ||
4869                     output_mode == UTF_8)) {
4870             if (nkf_isspace(c)) {
4871                 int flag = 0;
4872                 if (mimeout_mode == -1) {
4873                     flag = 1;
4874                 }
4875                 if (c==CR || c==LF) {
4876                     if (flag) {
4877                         open_mime(output_mode);
4878                         output_mode = 0;
4879                     } else {
4880                         base64_count = 0;
4881                     }
4882                 }
4883                 for (i=0;i<mimeout_state.count;i++) {
4884                     (*o_mputc)(mimeout_state.buf[i]);
4885                     if (mimeout_state.buf[i] == CR || mimeout_state.buf[i] == LF){
4886                         base64_count = 0;
4887                     }else{
4888                         base64_count++;
4889                     }
4890                 }
4891                 if (flag) {
4892                     eof_mime();
4893                     base64_count = 0;
4894                     mimeout_mode = 0;
4895                 }
4896                 mimeout_state.buf[0] = (char)c;
4897                 mimeout_state.count = 1;
4898             }else{
4899                 if (base64_count > 1
4900                     && base64_count + mimeout_state.count > 76
4901                     && mimeout_state.buf[0] != CR && mimeout_state.buf[0] != LF){
4902                     static const char *str = "boundary=\"";
4903                     static int len = 10;
4904                     i = 0;
4905
4906                     for (; i < mimeout_state.count - len; ++i) {
4907                         if (!strncmp(mimeout_state.buf+i, str, len)) {
4908                             i += len - 2;
4909                             break;
4910                         }
4911                     }
4912
4913                     if (i == 0 || i == mimeout_state.count - len) {
4914                         PUT_NEWLINE((*o_mputc));
4915                         base64_count = 0;
4916                         if (!nkf_isspace(mimeout_state.buf[0])){
4917                             (*o_mputc)(SP);
4918                             base64_count++;
4919                         }
4920                     }
4921                     else {
4922                         int j;
4923                         for (j = 0; j <= i; ++j) {
4924                             (*o_mputc)(mimeout_state.buf[j]);
4925                         }
4926                         PUT_NEWLINE((*o_mputc));
4927                         base64_count = 1;
4928                         for (; j <= mimeout_state.count; ++j) {
4929                             mimeout_state.buf[j - i] = mimeout_state.buf[j];
4930                         }
4931                         mimeout_state.count -= i;
4932                     }
4933                 }
4934                 mimeout_state.buf[mimeout_state.count++] = (char)c;
4935                 if (mimeout_state.count>MIMEOUT_BUF_LENGTH) {
4936                     open_mime(output_mode);
4937                 }
4938             }
4939             return;
4940         }else{
4941             if (lastchar==CR || lastchar == LF){
4942                 for (i=0;i<mimeout_state.count;i++) {
4943                     (*o_mputc)(mimeout_state.buf[i]);
4944                 }
4945                 base64_count = 0;
4946                 mimeout_state.count = 0;
4947             }
4948             if (lastchar==SP) {
4949                 for (i=0;i<mimeout_state.count-1;i++) {
4950                     (*o_mputc)(mimeout_state.buf[i]);
4951                     base64_count++;
4952                 }
4953                 mimeout_state.buf[0] = SP;
4954                 mimeout_state.count = 1;
4955             }
4956             open_mime(output_mode);
4957         }
4958     }else{
4959         /* mimeout_mode == 'B', 1, 2 */
4960         if (c <= DEL && (output_mode==ASCII || output_mode == ISO_8859_1 ||
4961                     output_mode == UTF_8)) {
4962             if (lastchar == CR || lastchar == LF){
4963                 if (nkf_isblank(c)) {
4964                     for (i=0;i<mimeout_state.count;i++) {
4965                         mimeout_addchar(mimeout_state.buf[i]);
4966                     }
4967                     mimeout_state.count = 0;
4968                 } else {
4969                     eof_mime();
4970                     for (i=0;i<mimeout_state.count;i++) {
4971                         (*o_mputc)(mimeout_state.buf[i]);
4972                     }
4973                     base64_count = 0;
4974                     mimeout_state.count = 0;
4975                 }
4976                 mimeout_state.buf[mimeout_state.count++] = (char)c;
4977                 return;
4978             }
4979             if (nkf_isspace(c)) {
4980                 for (i=0;i<mimeout_state.count;i++) {
4981                     if (SP<mimeout_state.buf[i] && mimeout_state.buf[i]<DEL) {
4982                         eof_mime();
4983                         for (i=0;i<mimeout_state.count;i++) {
4984                             (*o_mputc)(mimeout_state.buf[i]);
4985                             base64_count++;
4986                         }
4987                         mimeout_state.count = 0;
4988                     }
4989                 }
4990                 mimeout_state.buf[mimeout_state.count++] = (char)c;
4991                 if (mimeout_state.count>MIMEOUT_BUF_LENGTH) {
4992                     eof_mime();
4993                     for (i=0;i<mimeout_state.count;i++) {
4994                         (*o_mputc)(mimeout_state.buf[i]);
4995                         base64_count++;
4996                     }
4997                     mimeout_state.count = 0;
4998                 }
4999                 return;
5000             }
5001             if (mimeout_state.count>0 && SP<c && c!='=') {
5002                 mimeout_state.buf[mimeout_state.count++] = (char)c;
5003                 if (mimeout_state.count>MIMEOUT_BUF_LENGTH) {
5004                     j = mimeout_state.count;
5005                     mimeout_state.count = 0;
5006                     for (i=0;i<j;i++) {
5007                         mimeout_addchar(mimeout_state.buf[i]);
5008                     }
5009                 }
5010                 return;
5011             }
5012         }
5013     }
5014     if (mimeout_state.count>0) {
5015         j = mimeout_state.count;
5016         mimeout_state.count = 0;
5017         for (i=0;i<j;i++) {
5018             if (mimeout_state.buf[i]==CR || mimeout_state.buf[i]==LF)
5019                 break;
5020             mimeout_addchar(mimeout_state.buf[i]);
5021         }
5022         if (i<j) {
5023             eof_mime();
5024             base64_count=0;
5025             for (;i<j;i++) {
5026                 (*o_mputc)(mimeout_state.buf[i]);
5027             }
5028             open_mime(output_mode);
5029         }
5030     }
5031     mimeout_addchar(c);
5032 }
5033
5034 static void
5035 base64_conv(nkf_char c2, nkf_char c1)
5036 {
5037     mime_prechar(c2, c1);
5038     (*o_base64conv)(c2,c1);
5039 }
5040
5041 #ifdef HAVE_ICONV_H
5042 typedef struct nkf_iconv_t {
5043     iconv_t cd;
5044     char *input_buffer;
5045     size_t input_buffer_size;
5046     char *output_buffer;
5047     size_t output_buffer_size;
5048 }
5049
5050 static nkf_iconv_t
5051 nkf_iconv_new(char *tocode, char *fromcode)
5052 {
5053     nkf_iconv_t converter;
5054
5055     converter->input_buffer_size = IOBUF_SIZE;
5056     converter->input_buffer = nkf_xmalloc(converter->input_buffer_size);
5057     converter->output_buffer_size = IOBUF_SIZE * 2;
5058     converter->output_buffer = nkf_xmalloc(converter->output_buffer_size);
5059     converter->cd = iconv_open(tocode, fromcode);
5060     if (converter->cd == (iconv_t)-1)
5061     {
5062         switch (errno) {
5063         case EINVAL:
5064             perror(fprintf("iconv doesn't support %s to %s conversion.", fromcode, tocode));
5065             return -1;
5066         default:
5067             perror("can't iconv_open");
5068         }
5069     }
5070 }
5071
5072 static size_t
5073 nkf_iconv_convert(nkf_iconv_t *converter, FILE *input)
5074 {
5075     size_t invalid = (size_t)0;
5076     char *input_buffer = converter->input_buffer;
5077     size_t input_length = (size_t)0;
5078     char *output_buffer = converter->output_buffer;
5079     size_t output_length = converter->output_buffer_size;
5080     int c;
5081
5082     do {
5083         if (c != EOF) {
5084             while ((c = (*i_getc)(f)) != EOF) {
5085                 input_buffer[input_length++] = c;
5086                 if (input_length < converter->input_buffer_size) break;
5087             }
5088         }
5089
5090         size_t ret = iconv(converter->cd, &input_buffer, &input_length, &output_buffer, &output_length);
5091         while (output_length-- > 0) {
5092             (*o_putc)(output_buffer[converter->output_buffer_size-output_length]);
5093         }
5094         if (ret == (size_t) - 1) {
5095             switch (errno) {
5096             case EINVAL:
5097                 if (input_buffer != converter->input_buffer)
5098                     memmove(converter->input_buffer, input_buffer, input_length);
5099                 break;
5100             case E2BIG:
5101                 converter->output_buffer_size *= 2;
5102                 output_buffer = realloc(converter->outbuf, converter->output_buffer_size);
5103                 if (output_buffer == NULL) {
5104                     perror("can't realloc");
5105                     return -1;
5106                 }
5107                 converter->output_buffer = output_buffer;
5108                 break;
5109             default:
5110                 perror("can't iconv");
5111                 return -1;
5112             }
5113         } else {
5114             invalid += ret;
5115         }
5116     } while (1);
5117
5118     return invalid;
5119 }
5120
5121
5122 static void
5123 nkf_iconv_close(nkf_iconv_t *convert)
5124 {
5125     nkf_xfree(converter->inbuf);
5126     nkf_xfree(converter->outbuf);
5127     iconv_close(converter->cd);
5128 }
5129 #endif
5130
5131
5132 static void
5133 reinit(void)
5134 {
5135     {
5136         struct input_code *p = input_code_list;
5137         while (p->name){
5138             status_reinit(p++);
5139         }
5140     }
5141     unbuf_f = FALSE;
5142     estab_f = FALSE;
5143     nop_f = FALSE;
5144     binmode_f = TRUE;
5145     rot_f = FALSE;
5146     hira_f = FALSE;
5147     alpha_f = FALSE;
5148     mime_f = MIME_DECODE_DEFAULT;
5149     mime_decode_f = FALSE;
5150     mimebuf_f = FALSE;
5151     broken_f = FALSE;
5152     iso8859_f = FALSE;
5153     mimeout_f = FALSE;
5154     x0201_f = X0201_DEFAULT;
5155     iso2022jp_f = FALSE;
5156 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
5157     ms_ucs_map_f = UCS_MAP_ASCII;
5158 #endif
5159 #ifdef UTF8_INPUT_ENABLE
5160     no_cp932ext_f = FALSE;
5161     no_best_fit_chars_f = FALSE;
5162     encode_fallback = NULL;
5163     unicode_subchar  = '?';
5164     input_endian = ENDIAN_BIG;
5165 #endif
5166 #ifdef UTF8_OUTPUT_ENABLE
5167     output_bom_f = FALSE;
5168     output_endian = ENDIAN_BIG;
5169 #endif
5170 #ifdef UNICODE_NORMALIZATION
5171     nfc_f = FALSE;
5172 #endif
5173 #ifdef INPUT_OPTION
5174     cap_f = FALSE;
5175     url_f = FALSE;
5176     numchar_f = FALSE;
5177 #endif
5178 #ifdef CHECK_OPTION
5179     noout_f = FALSE;
5180     debug_f = FALSE;
5181 #endif
5182     guess_f = 0;
5183 #ifdef EXEC_IO
5184     exec_f = 0;
5185 #endif
5186 #ifdef SHIFTJIS_CP932
5187     cp51932_f = TRUE;
5188     cp932inv_f = TRUE;
5189 #endif
5190 #ifdef X0212_ENABLE
5191     x0212_f = FALSE;
5192     x0213_f = FALSE;
5193 #endif
5194     {
5195         int i;
5196         for (i = 0; i < 256; i++){
5197             prefix_table[i] = 0;
5198         }
5199     }
5200     hold_count = 0;
5201     mimeout_state.count = 0;
5202     mimeout_mode = 0;
5203     base64_count = 0;
5204     f_line = 0;
5205     f_prev = 0;
5206     fold_preserve_f = FALSE;
5207     fold_f = FALSE;
5208     fold_len = 0;
5209     kanji_intro = DEFAULT_J;
5210     ascii_intro = DEFAULT_R;
5211     fold_margin  = FOLD_MARGIN;
5212     o_zconv = no_connection;
5213     o_fconv = no_connection;
5214     o_eol_conv = no_connection;
5215     o_rot_conv = no_connection;
5216     o_hira_conv = no_connection;
5217     o_base64conv = no_connection;
5218     o_iso2022jp_check_conv = no_connection;
5219     o_putc = std_putc;
5220     i_getc = std_getc;
5221     i_ungetc = std_ungetc;
5222     i_bgetc = std_getc;
5223     i_bungetc = std_ungetc;
5224     o_mputc = std_putc;
5225     i_mgetc = std_getc;
5226     i_mungetc  = std_ungetc;
5227     i_mgetc_buf = std_getc;
5228     i_mungetc_buf = std_ungetc;
5229     output_mode = ASCII;
5230     input_mode =  ASCII;
5231     mime_decode_mode = FALSE;
5232     file_out_f = FALSE;
5233     eolmode_f = 0;
5234     input_eol = 0;
5235     prev_cr = 0;
5236     option_mode = 0;
5237     z_prev2=0,z_prev1=0;
5238 #ifdef CHECK_OPTION
5239     iconv_for_check = 0;
5240 #endif
5241     input_codename = NULL;
5242     input_encoding = NULL;
5243     output_encoding = NULL;
5244     nkf_state_init();
5245 #ifdef WIN32DLL
5246     reinitdll();
5247 #endif /*WIN32DLL*/
5248 }
5249
5250 static int
5251 module_connection(void)
5252 {
5253     if (input_encoding) set_input_encoding(input_encoding);
5254     if (!output_encoding) {
5255         output_encoding = nkf_default_encoding();
5256     }
5257     if (!output_encoding) {
5258         if (noout_f || guess_f) output_encoding = nkf_enc_from_index(ISO_2022_JP);
5259         else return -1;
5260     }
5261     set_output_encoding(output_encoding);
5262     oconv = nkf_enc_to_oconv(output_encoding);
5263     o_putc = std_putc;
5264     if (nkf_enc_unicode_p(output_encoding))
5265         output_mode = UTF_8;
5266
5267     /* replace continucation module, from output side */
5268
5269     /* output redicrection */
5270 #ifdef CHECK_OPTION
5271     if (noout_f || guess_f){
5272         o_putc = no_putc;
5273     }
5274 #endif
5275     if (mimeout_f) {
5276         o_mputc = o_putc;
5277         o_putc = mime_putc;
5278         if (mimeout_f == TRUE) {
5279             o_base64conv = oconv; oconv = base64_conv;
5280         }
5281         /* base64_count = 0; */
5282     }
5283
5284     if (eolmode_f || guess_f) {
5285         o_eol_conv = oconv; oconv = eol_conv;
5286     }
5287     if (rot_f) {
5288         o_rot_conv = oconv; oconv = rot_conv;
5289     }
5290     if (iso2022jp_f) {
5291         o_iso2022jp_check_conv = oconv; oconv = iso2022jp_check_conv;
5292     }
5293     if (hira_f) {
5294         o_hira_conv = oconv; oconv = hira_conv;
5295     }
5296     if (fold_f) {
5297         o_fconv = oconv; oconv = fold_conv;
5298         f_line = 0;
5299     }
5300     if (alpha_f || x0201_f) {
5301         o_zconv = oconv; oconv = z_conv;
5302     }
5303
5304     i_getc = std_getc;
5305     i_ungetc = std_ungetc;
5306     /* input redicrection */
5307 #ifdef INPUT_OPTION
5308     if (cap_f){
5309         i_cgetc = i_getc; i_getc = cap_getc;
5310         i_cungetc = i_ungetc; i_ungetc= cap_ungetc;
5311     }
5312     if (url_f){
5313         i_ugetc = i_getc; i_getc = url_getc;
5314         i_uungetc = i_ungetc; i_ungetc= url_ungetc;
5315     }
5316 #endif
5317 #ifdef NUMCHAR_OPTION
5318     if (numchar_f){
5319         i_ngetc = i_getc; i_getc = numchar_getc;
5320         i_nungetc = i_ungetc; i_ungetc= numchar_ungetc;
5321     }
5322 #endif
5323 #ifdef UNICODE_NORMALIZATION
5324     if (nfc_f){
5325         i_nfc_getc = i_getc; i_getc = nfc_getc;
5326         i_nfc_ungetc = i_ungetc; i_ungetc= nfc_ungetc;
5327     }
5328 #endif
5329     if (mime_f && mimebuf_f==FIXED_MIME) {
5330         i_mgetc = i_getc; i_getc = mime_getc;
5331         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
5332     }
5333     if (broken_f & 1) {
5334         i_bgetc = i_getc; i_getc = broken_getc;
5335         i_bungetc = i_ungetc; i_ungetc = broken_ungetc;
5336     }
5337     if (input_encoding) {
5338         set_iconv(-TRUE, nkf_enc_to_iconv(input_encoding));
5339     } else {
5340         set_iconv(FALSE, e_iconv);
5341     }
5342
5343     {
5344         struct input_code *p = input_code_list;
5345         while (p->name){
5346             status_reinit(p++);
5347         }
5348     }
5349     return 0;
5350 }
5351
5352 /*
5353    Conversion main loop. Code detection only.
5354  */
5355
5356 #if !defined(PERL_XS) && !defined(WIN32DLL)
5357 static nkf_char
5358 noconvert(FILE *f)
5359 {
5360     nkf_char    c;
5361
5362     if (nop_f == 2)
5363         module_connection();
5364     while ((c = (*i_getc)(f)) != EOF)
5365         (*o_putc)(c);
5366     (*o_putc)(EOF);
5367     return 1;
5368 }
5369 #endif
5370
5371 #define NEXT continue        /* no output, get next */
5372 #define SKIP c2=0;continue        /* no output, get next */
5373 #define MORE c2=c1;continue  /* need one more byte */
5374 #define SEND ;               /* output c1 and c2, get next */
5375 #define LAST break           /* end of loop, go closing  */
5376 #define set_input_mode(mode) do { \
5377     input_mode = mode; \
5378     shift_mode = 0; \
5379     set_input_codename("ISO-2022-JP"); \
5380     debug("ISO-2022-JP"); \
5381 } while (0)
5382
5383 static int
5384 kanji_convert(FILE *f)
5385 {
5386     nkf_char c1=0, c2=0, c3=0, c4=0;
5387     int shift_mode = 0; /* 0, 1, 2, 3 */
5388     int g2 = 0;
5389     int is_8bit = FALSE;
5390
5391     if (input_encoding && !nkf_enc_asciicompat(input_encoding)) {
5392         is_8bit = TRUE;
5393     }
5394
5395     input_mode = ASCII;
5396     output_mode = ASCII;
5397
5398     if (module_connection() < 0) {
5399 #if !defined(PERL_XS) && !defined(WIN32DLL)
5400         fprintf(stderr, "no output encoding given\n");
5401 #endif
5402         return -1;
5403     }
5404     check_bom(f);
5405
5406 #ifdef UTF8_INPUT_ENABLE
5407     if(iconv == w_iconv32){
5408         while ((c1 = (*i_getc)(f)) != EOF &&
5409                (c2 = (*i_getc)(f)) != EOF &&
5410                (c3 = (*i_getc)(f)) != EOF &&
5411                (c4 = (*i_getc)(f)) != EOF) {
5412             nkf_iconv_utf_32(c1, c2, c3, c4);
5413         }
5414         goto finished;
5415     }
5416     else if (iconv == w_iconv16) {
5417         while ((c1 = (*i_getc)(f)) != EOF &&
5418                (c2 = (*i_getc)(f)) != EOF) {
5419             if (nkf_iconv_utf_16(c1, c2, 0, 0) == -2 &&
5420                 (c3 = (*i_getc)(f)) != EOF &&
5421                 (c4 = (*i_getc)(f)) != EOF) {
5422                 nkf_iconv_utf_16(c1, c2, c3, c4);
5423             }
5424         }
5425         goto finished;
5426     }
5427 #endif
5428
5429     while ((c1 = (*i_getc)(f)) != EOF) {
5430 #ifdef INPUT_CODE_FIX
5431         if (!input_encoding)
5432 #endif
5433             code_status(c1);
5434         if (c2) {
5435             /* second byte */
5436             if (c2 > DEL) {
5437                 /* in case of 8th bit is on */
5438                 if (!estab_f&&!mime_decode_mode) {
5439                     /* in case of not established yet */
5440                     /* It is still ambiguious */
5441                     if (h_conv(f, c2, c1)==EOF) {
5442                         LAST;
5443                     }
5444                     else {
5445                         SKIP;
5446                     }
5447                 }
5448                 else {
5449                     /* in case of already established */
5450                     if (c1 < 0x40) {
5451                         /* ignore bogus code */
5452                         SKIP;
5453                     } else {
5454                         SEND;
5455                     }
5456                 }
5457             }
5458             else {
5459                 /* 2nd byte of 7 bit code or SJIS */
5460                 SEND;
5461             }
5462         }
5463         else if (nkf_char_unicode_p(c1)) {
5464             (*oconv)(0, c1);
5465             NEXT;
5466         }
5467         else {
5468             /* first byte */
5469             if (input_mode == JIS_X_0208 && DEL <= c1 && c1 < 0x92) {
5470                 /* CP5022x */
5471                 MORE;
5472             }else if (input_codename && input_codename[0] == 'I' &&
5473                     0xA1 <= c1 && c1 <= 0xDF) {
5474                 /* JIS X 0201 Katakana in 8bit JIS */
5475                 c2 = JIS_X_0201_1976_K;
5476                 c1 &= 0x7f;
5477                 SEND;
5478             } else if (c1 > DEL) {
5479                 /* 8 bit code */
5480                 if (!estab_f && !iso8859_f) {
5481                     /* not established yet */
5482                     MORE;
5483                 } else { /* estab_f==TRUE */
5484                     if (iso8859_f) {
5485                         c2 = ISO_8859_1;
5486                         c1 &= 0x7f;
5487                         SEND;
5488                     }
5489                     else if ((iconv == s_iconv && 0xA0 <= c1 && c1 <= 0xDF) ||
5490                              (ms_ucs_map_f == UCS_MAP_CP10001 && (c1 == 0xFD || c1 == 0xFE))) {
5491                         /* JIS X 0201 */
5492                         c2 = JIS_X_0201_1976_K;
5493                         c1 &= 0x7f;
5494                         SEND;
5495                     }
5496                     else {
5497                         /* already established */
5498                         MORE;
5499                     }
5500                 }
5501             } else if (SP < c1 && c1 < DEL) {
5502                 /* in case of Roman characters */
5503                 if (shift_mode) {
5504                     /* output 1 shifted byte */
5505                     if (iso8859_f) {
5506                         c2 = ISO_8859_1;
5507                         SEND;
5508                     } else if (nkf_byte_jisx0201_katakana_p(c1)){
5509                         /* output 1 shifted byte */
5510                         c2 = JIS_X_0201_1976_K;
5511                         SEND;
5512                     } else {
5513                         /* look like bogus code */
5514                         SKIP;
5515                     }
5516                 } else if (input_mode == JIS_X_0208 || input_mode == JIS_X_0212 ||
5517                            input_mode == JIS_X_0213_1 || input_mode == JIS_X_0213_2) {
5518                     /* in case of Kanji shifted */
5519                     MORE;
5520                 } else if (c1 == '=' && mime_f && !mime_decode_mode) {
5521                     /* Check MIME code */
5522                     if ((c1 = (*i_getc)(f)) == EOF) {
5523                         (*oconv)(0, '=');
5524                         LAST;
5525                     } else if (c1 == '?') {
5526                         /* =? is mime conversion start sequence */
5527                         if(mime_f == STRICT_MIME) {
5528                             /* check in real detail */
5529                             if (mime_begin_strict(f) == EOF)
5530                                 LAST;
5531                             SKIP;
5532                         } else if (mime_begin(f) == EOF)
5533                             LAST;
5534                         SKIP;
5535                     } else {
5536                         (*oconv)(0, '=');
5537                         (*i_ungetc)(c1,f);
5538                         SKIP;
5539                     }
5540                 } else {
5541                     /* normal ASCII code */
5542                     SEND;
5543                 }
5544             } else if (c1 == SI && (!is_8bit || mime_decode_mode)) {
5545                 shift_mode = 0;
5546                 SKIP;
5547             } else if (c1 == SO && (!is_8bit || mime_decode_mode)) {
5548                 shift_mode = 1;
5549                 SKIP;
5550             } else if (c1 == ESC && (!is_8bit || mime_decode_mode)) {
5551                 if ((c1 = (*i_getc)(f)) == EOF) {
5552                     (*oconv)(0, ESC);
5553                     LAST;
5554                 }
5555                 else if (c1 == '&') {
5556                     /* IRR */
5557                     if ((c1 = (*i_getc)(f)) == EOF) {
5558                         LAST;
5559                     } else {
5560                         SKIP;
5561                     }
5562                 }
5563                 else if (c1 == '$') {
5564                     /* GZDMx */
5565                     if ((c1 = (*i_getc)(f)) == EOF) {
5566                         /* don't send bogus code
5567                            (*oconv)(0, ESC);
5568                            (*oconv)(0, '$'); */
5569                         LAST;
5570                     } else if (c1 == '@' || c1 == 'B') {
5571                         /* JIS X 0208 */
5572                         set_input_mode(JIS_X_0208);
5573                         SKIP;
5574                     } else if (c1 == '(') {
5575                         /* GZDM4 */
5576                         if ((c1 = (*i_getc)(f)) == EOF) {
5577                             /* don't send bogus code
5578                                (*oconv)(0, ESC);
5579                                (*oconv)(0, '$');
5580                                (*oconv)(0, '(');
5581                              */
5582                             LAST;
5583                         } else if (c1 == '@'|| c1 == 'B') {
5584                             /* JIS X 0208 */
5585                             set_input_mode(JIS_X_0208);
5586                             SKIP;
5587 #ifdef X0212_ENABLE
5588                         } else if (c1 == 'D'){
5589                             set_input_mode(JIS_X_0212);
5590                             SKIP;
5591 #endif /* X0212_ENABLE */
5592                         } else if (c1 == 'O' || c1 == 'Q'){
5593                             set_input_mode(JIS_X_0213_1);
5594                             SKIP;
5595                         } else if (c1 == 'P'){
5596                             set_input_mode(JIS_X_0213_2);
5597                             SKIP;
5598                         } else {
5599                             /* could be some special code */
5600                             (*oconv)(0, ESC);
5601                             (*oconv)(0, '$');
5602                             (*oconv)(0, '(');
5603                             (*oconv)(0, c1);
5604                             SKIP;
5605                         }
5606                     } else if (broken_f&0x2) {
5607                         /* accept any ESC-(-x as broken code ... */
5608                         input_mode = JIS_X_0208;
5609                         shift_mode = 0;
5610                         SKIP;
5611                     } else {
5612                         (*oconv)(0, ESC);
5613                         (*oconv)(0, '$');
5614                         (*oconv)(0, c1);
5615                         SKIP;
5616                     }
5617                 } else if (c1 == '(') {
5618                     /* GZD4 */
5619                     if ((c1 = (*i_getc)(f)) == EOF) {
5620                         /* don't send bogus code
5621                            (*oconv)(0, ESC);
5622                            (*oconv)(0, '('); */
5623                         LAST;
5624                     }
5625                     else if (c1 == 'I') {
5626                         /* JIS X 0201 Katakana */
5627                         set_input_mode(JIS_X_0201_1976_K);
5628                         SKIP;
5629                     }
5630                     else if (c1 == 'B' || c1 == 'J' || c1 == 'H') {
5631                         /* ISO-646IRV:1983 or JIS X 0201 Roman or JUNET */
5632                         set_input_mode(ASCII);
5633                         SKIP;
5634                     }
5635                     else if (broken_f&0x2) {
5636                         set_input_mode(ASCII);
5637                         SKIP;
5638                     }
5639                     else {
5640                         (*oconv)(0, ESC);
5641                         (*oconv)(0, '(');
5642                         SEND;
5643                     }
5644                 }
5645                 else if (c1 == '.') {
5646                     /* G2D6 */
5647                     if ((c1 = (*i_getc)(f)) == EOF) {
5648                         LAST;
5649                     }
5650                     else if (c1 == 'A') {
5651                         /* ISO-8859-1 */
5652                         g2 = ISO_8859_1;
5653                         SKIP;
5654                     }
5655                     else {
5656                         (*oconv)(0, ESC);
5657                         (*oconv)(0, '.');
5658                         SEND;
5659                     }
5660                 }
5661                 else if (c1 == 'N') {
5662                     /* SS2 */
5663                     c1 = (*i_getc)(f);
5664                     if (g2 == ISO_8859_1) {
5665                         c2 = ISO_8859_1;
5666                         SEND;
5667                     }else{
5668                         (*i_ungetc)(c1, f);
5669                         /* lonely ESC  */
5670                         (*oconv)(0, ESC);
5671                         SEND;
5672                     }
5673                 }
5674                 else {
5675                     /* lonely ESC  */
5676                     (*oconv)(0, ESC);
5677                     SEND;
5678                 }
5679             } else if (c1 == ESC && iconv == s_iconv) {
5680                 /* ESC in Shift_JIS */
5681                 if ((c1 = (*i_getc)(f)) == EOF) {
5682                     (*oconv)(0, ESC);
5683                     LAST;
5684                 } else if (c1 == '$') {
5685                     /* J-PHONE emoji */
5686                     if ((c1 = (*i_getc)(f)) == EOF) {
5687                         LAST;
5688                     } else if (('E' <= c1 && c1 <= 'G') ||
5689                                ('O' <= c1 && c1 <= 'Q')) {
5690                         /*
5691                            NUM : 0 1 2 3 4 5
5692                            BYTE: G E F O P Q
5693                            C%7 : 1 6 0 2 3 4
5694                            C%7 : 0 1 2 3 4 5 6
5695                            NUM : 2 0 3 4 5 X 1
5696                          */
5697                         static const nkf_char jphone_emoji_first_table[7] =
5698                         {0xE1E0, 0xDFE0, 0xE2E0, 0xE3E0, 0xE4E0, 0xDFE0, 0xE0E0};
5699                         c3 = nkf_char_unicode_new(jphone_emoji_first_table[c1 % 7]);
5700                         if ((c1 = (*i_getc)(f)) == EOF) LAST;
5701                         while (SP <= c1 && c1 <= 'z') {
5702                             (*oconv)(0, c1 + c3);
5703                             if ((c1 = (*i_getc)(f)) == EOF) LAST;
5704                         }
5705                         SKIP;
5706                     }
5707                     else {
5708                         (*oconv)(0, ESC);
5709                         (*oconv)(0, '$');
5710                         SEND;
5711                     }
5712                 }
5713                 else {
5714                     /* lonely ESC  */
5715                     (*oconv)(0, ESC);
5716                     SEND;
5717                 }
5718             } else if (c1 == LF || c1 == CR) {
5719                 if (broken_f&4) {
5720                     input_mode = ASCII; set_iconv(FALSE, 0);
5721                     SEND;
5722                 } else if (mime_decode_f && !mime_decode_mode){
5723                     if (c1 == LF) {
5724                         if ((c1=(*i_getc)(f))!=EOF && c1 == SP) {
5725                             i_ungetc(SP,f);
5726                             continue;
5727                         } else {
5728                             i_ungetc(c1,f);
5729                         }
5730                         c1 = LF;
5731                         SEND;
5732                     } else  { /* if (c1 == CR)*/
5733                         if ((c1=(*i_getc)(f))!=EOF) {
5734                             if (c1==SP) {
5735                                 i_ungetc(SP,f);
5736                                 continue;
5737                             } else if (c1 == LF && (c1=(*i_getc)(f))!=EOF && c1 == SP) {
5738                                 i_ungetc(SP,f);
5739                                 continue;
5740                             } else {
5741                                 i_ungetc(c1,f);
5742                             }
5743                             i_ungetc(LF,f);
5744                         } else {
5745                             i_ungetc(c1,f);
5746                         }
5747                         c1 = CR;
5748                         SEND;
5749                     }
5750                 }
5751             } else
5752                 SEND;
5753         }
5754         /* send: */
5755         switch(input_mode){
5756         case ASCII:
5757             switch ((*iconv)(c2, c1, 0)) {  /* can be EUC / SJIS / UTF-8 */
5758             case -2:
5759                 /* 4 bytes UTF-8 */
5760                 if ((c3 = (*i_getc)(f)) != EOF) {
5761                     code_status(c3);
5762                     c3 <<= 8;
5763                     if ((c4 = (*i_getc)(f)) != EOF) {
5764                         code_status(c4);
5765                         (*iconv)(c2, c1, c3|c4);
5766                     }
5767                 }
5768                 break;
5769             case -1:
5770                 /* 3 bytes EUC or UTF-8 */
5771                 if ((c3 = (*i_getc)(f)) != EOF) {
5772                     code_status(c3);
5773                     (*iconv)(c2, c1, c3);
5774                 }
5775                 break;
5776             }
5777             break;
5778         case JIS_X_0208:
5779         case JIS_X_0213_1:
5780             if (ms_ucs_map_f &&
5781                 0x7F <= c2 && c2 <= 0x92 &&
5782                 0x21 <= c1 && c1 <= 0x7E) {
5783                 /* CP932 UDC */
5784                 c1 = nkf_char_unicode_new((c2 - 0x7F) * 94 + c1 - 0x21 + 0xE000);
5785                 c2 = 0;
5786             }
5787             (*oconv)(c2, c1); /* this is JIS, not SJIS/EUC case */
5788             break;
5789 #ifdef X0212_ENABLE
5790         case JIS_X_0212:
5791             (*oconv)(PREFIX_EUCG3 | c2, c1);
5792             break;
5793 #endif /* X0212_ENABLE */
5794         case JIS_X_0213_2:
5795             (*oconv)(PREFIX_EUCG3 | c2, c1);
5796             break;
5797         default:
5798             (*oconv)(input_mode, c1);  /* other special case */
5799         }
5800
5801         c2 = 0;
5802         c3 = 0;
5803         continue;
5804         /* goto next_word */
5805     }
5806
5807 finished:
5808     /* epilogue */
5809     (*iconv)(EOF, 0, 0);
5810     if (!input_codename)
5811     {
5812         if (is_8bit) {
5813             struct input_code *p = input_code_list;
5814             struct input_code *result = p;
5815             while (p->name){
5816                 if (p->score < result->score) result = p;
5817                 ++p;
5818             }
5819             set_input_codename(result->name);
5820 #ifdef CHECK_OPTION
5821             debug(result->name);
5822 #endif
5823         }
5824     }
5825     return 0;
5826 }
5827
5828 /*
5829  * int options(unsigned char *cp)
5830  *
5831  * return values:
5832  *    0: success
5833  *   -1: ArgumentError
5834  */
5835 static int
5836 options(unsigned char *cp)
5837 {
5838     nkf_char i, j;
5839     unsigned char *p;
5840     unsigned char *cp_back = NULL;
5841     nkf_encoding *enc;
5842
5843     if (option_mode==1)
5844         return 0;
5845     while(*cp && *cp++!='-');
5846     while (*cp || cp_back) {
5847         if(!*cp){
5848             cp = cp_back;
5849             cp_back = NULL;
5850             continue;
5851         }
5852         p = 0;
5853         switch (*cp++) {
5854         case '-':  /* literal options */
5855             if (!*cp || *cp == SP) {        /* ignore the rest of arguments */
5856                 option_mode = 1;
5857                 return 0;
5858             }
5859             for (i=0;i<sizeof(long_option)/sizeof(long_option[0]);i++) {
5860                 p = (unsigned char *)long_option[i].name;
5861                 for (j=0;*p && *p != '=' && *p == cp[j];p++, j++);
5862                 if (*p == cp[j] || cp[j] == SP){
5863                     p = &cp[j] + 1;
5864                     break;
5865                 }
5866                 p = 0;
5867             }
5868             if (p == 0) {
5869 #if !defined(PERL_XS) && !defined(WIN32DLL)
5870                 fprintf(stderr, "unknown long option: --%s\n", cp);
5871 #endif
5872                 return -1;
5873             }
5874             while(*cp && *cp != SP && cp++);
5875             if (long_option[i].alias[0]){
5876                 cp_back = cp;
5877                 cp = (unsigned char *)long_option[i].alias;
5878             }else{
5879 #ifndef PERL_XS
5880                 if (strcmp(long_option[i].name, "help") == 0){
5881                     usage();
5882                     exit(EXIT_SUCCESS);
5883                 }
5884 #endif
5885                 if (strcmp(long_option[i].name, "ic=") == 0){
5886                     enc = nkf_enc_find((char *)p);
5887                     if (!enc) continue;
5888                     input_encoding = enc;
5889                     continue;
5890                 }
5891                 if (strcmp(long_option[i].name, "oc=") == 0){
5892                     enc = nkf_enc_find((char *)p);
5893                     /* if (enc <= 0) continue; */
5894                     if (!enc) continue;
5895                     output_encoding = enc;
5896                     continue;
5897                 }
5898                 if (strcmp(long_option[i].name, "guess=") == 0){
5899                     if (p[0] == '0' || p[0] == '1') {
5900                         guess_f = 1;
5901                     } else {
5902                         guess_f = 2;
5903                     }
5904                     continue;
5905                 }
5906 #ifdef OVERWRITE
5907                 if (strcmp(long_option[i].name, "overwrite") == 0){
5908                     file_out_f = TRUE;
5909                     overwrite_f = TRUE;
5910                     preserve_time_f = TRUE;
5911                     continue;
5912                 }
5913                 if (strcmp(long_option[i].name, "overwrite=") == 0){
5914                     file_out_f = TRUE;
5915                     overwrite_f = TRUE;
5916                     preserve_time_f = TRUE;
5917                     backup_f = TRUE;
5918                     backup_suffix = (char *)p;
5919                     continue;
5920                 }
5921                 if (strcmp(long_option[i].name, "in-place") == 0){
5922                     file_out_f = TRUE;
5923                     overwrite_f = TRUE;
5924                     preserve_time_f = FALSE;
5925                     continue;
5926                 }
5927                 if (strcmp(long_option[i].name, "in-place=") == 0){
5928                     file_out_f = TRUE;
5929                     overwrite_f = TRUE;
5930                     preserve_time_f = FALSE;
5931                     backup_f = TRUE;
5932                     backup_suffix = (char *)p;
5933                     continue;
5934                 }
5935 #endif
5936 #ifdef INPUT_OPTION
5937                 if (strcmp(long_option[i].name, "cap-input") == 0){
5938                     cap_f = TRUE;
5939                     continue;
5940                 }
5941                 if (strcmp(long_option[i].name, "url-input") == 0){
5942                     url_f = TRUE;
5943                     continue;
5944                 }
5945 #endif
5946 #ifdef NUMCHAR_OPTION
5947                 if (strcmp(long_option[i].name, "numchar-input") == 0){
5948                     numchar_f = TRUE;
5949                     continue;
5950                 }
5951 #endif
5952 #ifdef CHECK_OPTION
5953                 if (strcmp(long_option[i].name, "no-output") == 0){
5954                     noout_f = TRUE;
5955                     continue;
5956                 }
5957                 if (strcmp(long_option[i].name, "debug") == 0){
5958                     debug_f = TRUE;
5959                     continue;
5960                 }
5961 #endif
5962                 if (strcmp(long_option[i].name, "cp932") == 0){
5963 #ifdef SHIFTJIS_CP932
5964                     cp51932_f = TRUE;
5965                     cp932inv_f = -TRUE;
5966 #endif
5967 #ifdef UTF8_OUTPUT_ENABLE
5968                     ms_ucs_map_f = UCS_MAP_CP932;
5969 #endif
5970                     continue;
5971                 }
5972                 if (strcmp(long_option[i].name, "no-cp932") == 0){
5973 #ifdef SHIFTJIS_CP932
5974                     cp51932_f = FALSE;
5975                     cp932inv_f = FALSE;
5976 #endif
5977 #ifdef UTF8_OUTPUT_ENABLE
5978                     ms_ucs_map_f = UCS_MAP_ASCII;
5979 #endif
5980                     continue;
5981                 }
5982 #ifdef SHIFTJIS_CP932
5983                 if (strcmp(long_option[i].name, "cp932inv") == 0){
5984                     cp932inv_f = -TRUE;
5985                     continue;
5986                 }
5987 #endif
5988
5989 #ifdef X0212_ENABLE
5990                 if (strcmp(long_option[i].name, "x0212") == 0){
5991                     x0212_f = TRUE;
5992                     continue;
5993                 }
5994 #endif
5995
5996 #ifdef EXEC_IO
5997                 if (strcmp(long_option[i].name, "exec-in") == 0){
5998                     exec_f = 1;
5999                     return 0;
6000                 }
6001                 if (strcmp(long_option[i].name, "exec-out") == 0){
6002                     exec_f = -1;
6003                     return 0;
6004                 }
6005 #endif
6006 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
6007                 if (strcmp(long_option[i].name, "no-cp932ext") == 0){
6008                     no_cp932ext_f = TRUE;
6009                     continue;
6010                 }
6011                 if (strcmp(long_option[i].name, "no-best-fit-chars") == 0){
6012                     no_best_fit_chars_f = TRUE;
6013                     continue;
6014                 }
6015                 if (strcmp(long_option[i].name, "fb-skip") == 0){
6016                     encode_fallback = NULL;
6017                     continue;
6018                 }
6019                 if (strcmp(long_option[i].name, "fb-html") == 0){
6020                     encode_fallback = encode_fallback_html;
6021                     continue;
6022                 }
6023                 if (strcmp(long_option[i].name, "fb-xml") == 0){
6024                     encode_fallback = encode_fallback_xml;
6025                     continue;
6026                 }
6027                 if (strcmp(long_option[i].name, "fb-java") == 0){
6028                     encode_fallback = encode_fallback_java;
6029                     continue;
6030                 }
6031                 if (strcmp(long_option[i].name, "fb-perl") == 0){
6032                     encode_fallback = encode_fallback_perl;
6033                     continue;
6034                 }
6035                 if (strcmp(long_option[i].name, "fb-subchar") == 0){
6036                     encode_fallback = encode_fallback_subchar;
6037                     continue;
6038                 }
6039                 if (strcmp(long_option[i].name, "fb-subchar=") == 0){
6040                     encode_fallback = encode_fallback_subchar;
6041                     unicode_subchar = 0;
6042                     if (p[0] != '0'){
6043                         /* decimal number */
6044                         for (i = 0; i < 7 && nkf_isdigit(p[i]); i++){
6045                             unicode_subchar *= 10;
6046                             unicode_subchar += hex2bin(p[i]);
6047                         }
6048                     }else if(p[1] == 'x' || p[1] == 'X'){
6049                         /* hexadecimal number */
6050                         for (i = 2; i < 8 && nkf_isxdigit(p[i]); i++){
6051                             unicode_subchar <<= 4;
6052                             unicode_subchar |= hex2bin(p[i]);
6053                         }
6054                     }else{
6055                         /* octal number */
6056                         for (i = 1; i < 8 && nkf_isoctal(p[i]); i++){
6057                             unicode_subchar *= 8;
6058                             unicode_subchar += hex2bin(p[i]);
6059                         }
6060                     }
6061                     w16e_conv(unicode_subchar, &i, &j);
6062                     unicode_subchar = i<<8 | j;
6063                     continue;
6064                 }
6065 #endif
6066 #ifdef UTF8_OUTPUT_ENABLE
6067                 if (strcmp(long_option[i].name, "ms-ucs-map") == 0){
6068                     ms_ucs_map_f = UCS_MAP_MS;
6069                     continue;
6070                 }
6071 #endif
6072 #ifdef UNICODE_NORMALIZATION
6073                 if (strcmp(long_option[i].name, "utf8mac-input") == 0){
6074                     nfc_f = TRUE;
6075                     continue;
6076                 }
6077 #endif
6078                 if (strcmp(long_option[i].name, "prefix=") == 0){
6079                     if (nkf_isgraph(p[0])){
6080                         for (i = 1; nkf_isgraph(p[i]); i++){
6081                             prefix_table[p[i]] = p[0];
6082                         }
6083                     }
6084                     continue;
6085                 }
6086 #if !defined(PERL_XS) && !defined(WIN32DLL)
6087                 fprintf(stderr, "unsupported long option: --%s\n", long_option[i].name);
6088 #endif
6089                 return -1;
6090             }
6091             continue;
6092         case 'b':           /* buffered mode */
6093             unbuf_f = FALSE;
6094             continue;
6095         case 'u':           /* non bufferd mode */
6096             unbuf_f = TRUE;
6097             continue;
6098         case 't':           /* transparent mode */
6099             if (*cp=='1') {
6100                 /* alias of -t */
6101                 cp++;
6102                 nop_f = TRUE;
6103             } else if (*cp=='2') {
6104                 /*
6105                  * -t with put/get
6106                  *
6107                  * nkf -t2MB hoge.bin | nkf -t2mB | diff -s - hoge.bin
6108                  *
6109                  */
6110                 cp++;
6111                 nop_f = 2;
6112             } else
6113                 nop_f = TRUE;
6114             continue;
6115         case 'j':           /* JIS output */
6116         case 'n':
6117             output_encoding = nkf_enc_from_index(ISO_2022_JP);
6118             continue;
6119         case 'e':           /* AT&T EUC output */
6120             output_encoding = nkf_enc_from_index(EUCJP_NKF);
6121             continue;
6122         case 's':           /* SJIS output */
6123             output_encoding = nkf_enc_from_index(SHIFT_JIS);
6124             continue;
6125         case 'l':           /* ISO8859 Latin-1 support, no conversion */
6126             iso8859_f = TRUE;  /* Only compatible with ISO-2022-JP */
6127             input_encoding = nkf_enc_from_index(ISO_8859_1);
6128             continue;
6129         case 'i':           /* Kanji IN ESC-$-@/B */
6130             if (*cp=='@'||*cp=='B')
6131                 kanji_intro = *cp++;
6132             continue;
6133         case 'o':           /* ASCII IN ESC-(-J/B/H */
6134             /* ESC ( H was used in initial JUNET messages */
6135             if (*cp=='J'||*cp=='B'||*cp=='H')
6136                 ascii_intro = *cp++;
6137             continue;
6138         case 'h':
6139             /*
6140                bit:1   katakana->hiragana
6141                bit:2   hiragana->katakana
6142              */
6143             if ('9'>= *cp && *cp>='0')
6144                 hira_f |= (*cp++ -'0');
6145             else
6146                 hira_f |= 1;
6147             continue;
6148         case 'r':
6149             rot_f = TRUE;
6150             continue;
6151 #if defined(MSDOS) || defined(__OS2__)
6152         case 'T':
6153             binmode_f = FALSE;
6154             continue;
6155 #endif
6156 #ifndef PERL_XS
6157         case 'V':
6158             show_configuration();
6159             exit(EXIT_SUCCESS);
6160             break;
6161         case 'v':
6162             version();
6163             exit(EXIT_SUCCESS);
6164             break;
6165 #endif
6166 #ifdef UTF8_OUTPUT_ENABLE
6167         case 'w':           /* UTF-8 output */
6168             if (cp[0] == '8') {
6169                 cp++;
6170                 if (cp[0] == '0'){
6171                     cp++;
6172                     output_encoding = nkf_enc_from_index(UTF_8N);
6173                 } else {
6174                     output_bom_f = TRUE;
6175                     output_encoding = nkf_enc_from_index(UTF_8_BOM);
6176                 }
6177             } else {
6178                 int enc_idx;
6179                 if ('1'== cp[0] && '6'==cp[1]) {
6180                     cp += 2;
6181                     enc_idx = UTF_16;
6182                 } else if ('3'== cp[0] && '2'==cp[1]) {
6183                     cp += 2;
6184                     enc_idx = UTF_32;
6185                 } else {
6186                     output_encoding = nkf_enc_from_index(UTF_8);
6187                     continue;
6188                 }
6189                 if (cp[0]=='L') {
6190                     cp++;
6191                     output_endian = ENDIAN_LITTLE;
6192                 } else if (cp[0] == 'B') {
6193                     cp++;
6194                 }
6195                 if (cp[0] == '0'){
6196                     cp++;
6197                     enc_idx = enc_idx == UTF_16
6198                         ? (output_endian == ENDIAN_LITTLE ? UTF_16LE : UTF_16BE)
6199                         : (output_endian == ENDIAN_LITTLE ? UTF_32LE : UTF_32BE);
6200                 } else {
6201                     output_bom_f = TRUE;
6202                     enc_idx = enc_idx == UTF_16
6203                         ? (output_endian == ENDIAN_LITTLE ? UTF_16LE_BOM : UTF_16BE_BOM)
6204                         : (output_endian == ENDIAN_LITTLE ? UTF_32LE_BOM : UTF_32BE_BOM);
6205                 }
6206                 output_encoding = nkf_enc_from_index(enc_idx);
6207             }
6208             continue;
6209 #endif
6210 #ifdef UTF8_INPUT_ENABLE
6211         case 'W':           /* UTF input */
6212             if (cp[0] == '8') {
6213                 cp++;
6214                 input_encoding = nkf_enc_from_index(UTF_8);
6215             }else{
6216                 int enc_idx;
6217                 if ('1'== cp[0] && '6'==cp[1]) {
6218                     cp += 2;
6219                     input_endian = ENDIAN_BIG;
6220                     enc_idx = UTF_16;
6221                 } else if ('3'== cp[0] && '2'==cp[1]) {
6222                     cp += 2;
6223                     input_endian = ENDIAN_BIG;
6224                     enc_idx = UTF_32;
6225                 } else {
6226                     input_encoding = nkf_enc_from_index(UTF_8);
6227                     continue;
6228                 }
6229                 if (cp[0]=='L') {
6230                     cp++;
6231                     input_endian = ENDIAN_LITTLE;
6232                 } else if (cp[0] == 'B') {
6233                     cp++;
6234                     input_endian = ENDIAN_BIG;
6235                 }
6236                 enc_idx = (enc_idx == UTF_16
6237                     ? (input_endian == ENDIAN_LITTLE ? UTF_16LE : UTF_16BE)
6238                     : (input_endian == ENDIAN_LITTLE ? UTF_32LE : UTF_32BE));
6239                 input_encoding = nkf_enc_from_index(enc_idx);
6240             }
6241             continue;
6242 #endif
6243             /* Input code assumption */
6244         case 'J':   /* ISO-2022-JP input */
6245             input_encoding = nkf_enc_from_index(ISO_2022_JP);
6246             continue;
6247         case 'E':   /* EUC-JP input */
6248             input_encoding = nkf_enc_from_index(EUCJP_NKF);
6249             continue;
6250         case 'S':   /* Shift_JIS input */
6251             input_encoding = nkf_enc_from_index(SHIFT_JIS);
6252             continue;
6253         case 'Z':   /* Convert X0208 alphabet to asii */
6254             /* alpha_f
6255                bit:0   Convert JIS X 0208 Alphabet to ASCII
6256                bit:1   Convert Kankaku to one space
6257                bit:2   Convert Kankaku to two spaces
6258                bit:3   Convert HTML Entity
6259                bit:4   Convert JIS X 0208 Katakana to JIS X 0201 Katakana
6260              */
6261             while ('0'<= *cp && *cp <='4') {
6262                 alpha_f |= 1 << (*cp++ - '0');
6263             }
6264             alpha_f |= 1;
6265             continue;
6266         case 'x':   /* Convert X0201 kana to X0208 or X0201 Conversion */
6267             x0201_f = FALSE;    /* No X0201->X0208 conversion */
6268             /* accept  X0201
6269                ESC-(-I     in JIS, EUC, MS Kanji
6270                SI/SO       in JIS, EUC, MS Kanji
6271                SS2         in EUC, JIS, not in MS Kanji
6272                MS Kanji (0xa0-0xdf)
6273                output  X0201
6274                ESC-(-I     in JIS (0x20-0x5f)
6275                SS2         in EUC (0xa0-0xdf)
6276                0xa0-0xd    in MS Kanji (0xa0-0xdf)
6277              */
6278             continue;
6279         case 'X':   /* Convert X0201 kana to X0208 */
6280             x0201_f = TRUE;
6281             continue;
6282         case 'F':   /* prserve new lines */
6283             fold_preserve_f = TRUE;
6284         case 'f':   /* folding -f60 or -f */
6285             fold_f = TRUE;
6286             fold_len = 0;
6287             while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
6288                 fold_len *= 10;
6289                 fold_len += *cp++ - '0';
6290             }
6291             if (!(0<fold_len && fold_len<BUFSIZ))
6292                 fold_len = DEFAULT_FOLD;
6293             if (*cp=='-') {
6294                 fold_margin = 0;
6295                 cp++;
6296                 while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
6297                     fold_margin *= 10;
6298                     fold_margin += *cp++ - '0';
6299                 }
6300             }
6301             continue;
6302         case 'm':   /* MIME support */
6303             /* mime_decode_f = TRUE; */ /* this has too large side effects... */
6304             if (*cp=='B'||*cp=='Q') {
6305                 mime_decode_mode = *cp++;
6306                 mimebuf_f = FIXED_MIME;
6307             } else if (*cp=='N') {
6308                 mime_f = TRUE; cp++;
6309             } else if (*cp=='S') {
6310                 mime_f = STRICT_MIME; cp++;
6311             } else if (*cp=='0') {
6312                 mime_decode_f = FALSE;
6313                 mime_f = FALSE; cp++;
6314             } else {
6315                 mime_f = STRICT_MIME;
6316             }
6317             continue;
6318         case 'M':   /* MIME output */
6319             if (*cp=='B') {
6320                 mimeout_mode = 'B';
6321                 mimeout_f = FIXED_MIME; cp++;
6322             } else if (*cp=='Q') {
6323                 mimeout_mode = 'Q';
6324                 mimeout_f = FIXED_MIME; cp++;
6325             } else {
6326                 mimeout_f = TRUE;
6327             }
6328             continue;
6329         case 'B':   /* Broken JIS support */
6330             /*  bit:0   no ESC JIS
6331                bit:1   allow any x on ESC-(-x or ESC-$-x
6332                bit:2   reset to ascii on NL
6333              */
6334             if ('9'>= *cp && *cp>='0')
6335                 broken_f |= 1<<(*cp++ -'0');
6336             else
6337                 broken_f |= TRUE;
6338             continue;
6339 #ifndef PERL_XS
6340         case 'O':/* for Output file */
6341             file_out_f = TRUE;
6342             continue;
6343 #endif
6344         case 'c':/* add cr code */
6345             eolmode_f = CRLF;
6346             continue;
6347         case 'd':/* delete cr code */
6348             eolmode_f = LF;
6349             continue;
6350         case 'I':   /* ISO-2022-JP output */
6351             iso2022jp_f = TRUE;
6352             continue;
6353         case 'L':  /* line mode */
6354             if (*cp=='u') {         /* unix */
6355                 eolmode_f = LF; cp++;
6356             } else if (*cp=='m') { /* mac */
6357                 eolmode_f = CR; cp++;
6358             } else if (*cp=='w') { /* windows */
6359                 eolmode_f = CRLF; cp++;
6360             } else if (*cp=='0') { /* no conversion  */
6361                 eolmode_f = 0; cp++;
6362             }
6363             continue;
6364 #ifndef PERL_XS
6365         case 'g':
6366             if ('2' <= *cp && *cp <= '9') {
6367                 guess_f = 2;
6368                 cp++;
6369             } else if (*cp == '0' || *cp == '1') {
6370                 guess_f = 1;
6371                 cp++;
6372             } else {
6373                 guess_f = 1;
6374             }
6375             continue;
6376 #endif
6377         case SP:
6378             /* module muliple options in a string are allowed for Perl moudle  */
6379             while(*cp && *cp++!='-');
6380             continue;
6381         default:
6382 #if !defined(PERL_XS) && !defined(WIN32DLL)
6383             fprintf(stderr, "unknown option: -%c\n", *(cp-1));
6384 #endif
6385             /* bogus option but ignored */
6386             return -1;
6387         }
6388     }
6389     return 0;
6390 }
6391
6392 #ifdef WIN32DLL
6393 #include "nkf32dll.c"
6394 #elif defined(PERL_XS)
6395 #else /* WIN32DLL */
6396 int
6397 main(int argc, char **argv)
6398 {
6399     FILE  *fin;
6400     unsigned char  *cp;
6401
6402     char *outfname = NULL;
6403     char *origfname;
6404
6405 #ifdef EASYWIN /*Easy Win */
6406     _BufferSize.y = 400;/*Set Scroll Buffer Size*/
6407 #endif
6408 #ifdef DEFAULT_CODE_LOCALE
6409     setlocale(LC_CTYPE, "");
6410 #endif
6411     nkf_state_init();
6412
6413     for (argc--,argv++; (argc > 0) && **argv == '-'; argc--, argv++) {
6414         cp = (unsigned char *)*argv;
6415         options(cp);
6416 #ifdef EXEC_IO
6417         if (exec_f){
6418             int fds[2], pid;
6419             if (pipe(fds) < 0 || (pid = fork()) < 0){
6420                 abort();
6421             }
6422             if (pid == 0){
6423                 if (exec_f > 0){
6424                     close(fds[0]);
6425                     dup2(fds[1], 1);
6426                 }else{
6427                     close(fds[1]);
6428                     dup2(fds[0], 0);
6429                 }
6430                 execvp(argv[1], &argv[1]);
6431             }
6432             if (exec_f > 0){
6433                 close(fds[1]);
6434                 dup2(fds[0], 0);
6435             }else{
6436                 close(fds[0]);
6437                 dup2(fds[1], 1);
6438             }
6439             argc = 0;
6440             break;
6441         }
6442 #endif
6443     }
6444
6445     if (guess_f) {
6446 #ifdef CHECK_OPTION
6447         int debug_f_back = debug_f;
6448 #endif
6449 #ifdef EXEC_IO
6450         int exec_f_back = exec_f;
6451 #endif
6452 #ifdef X0212_ENABLE
6453         int x0212_f_back = x0212_f;
6454 #endif
6455         int x0213_f_back = x0213_f;
6456         int guess_f_back = guess_f;
6457         reinit();
6458         guess_f = guess_f_back;
6459         mime_f = FALSE;
6460 #ifdef CHECK_OPTION
6461         debug_f = debug_f_back;
6462 #endif
6463 #ifdef EXEC_IO
6464         exec_f = exec_f_back;
6465 #endif
6466         x0212_f = x0212_f_back;
6467         x0213_f = x0213_f_back;
6468     }
6469
6470     if (binmode_f == TRUE)
6471 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6472         if (freopen("","wb",stdout) == NULL)
6473             return (-1);
6474 #else
6475     setbinmode(stdout);
6476 #endif
6477
6478     if (unbuf_f)
6479         setbuf(stdout, (char *) NULL);
6480     else
6481         setvbuffer(stdout, (char *) stdobuf, IOBUF_SIZE);
6482
6483     if (argc == 0) {
6484         if (binmode_f == TRUE)
6485 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6486             if (freopen("","rb",stdin) == NULL) return (-1);
6487 #else
6488         setbinmode(stdin);
6489 #endif
6490         setvbuffer(stdin, (char *) stdibuf, IOBUF_SIZE);
6491         if (nop_f)
6492             noconvert(stdin);
6493         else {
6494             kanji_convert(stdin);
6495             if (guess_f) print_guessed_code(NULL);
6496         }
6497     } else {
6498         int nfiles = argc;
6499         int is_argument_error = FALSE;
6500         while (argc--) {
6501             input_codename = NULL;
6502             input_eol = 0;
6503 #ifdef CHECK_OPTION
6504             iconv_for_check = 0;
6505 #endif
6506             if ((fin = fopen((origfname = *argv++), "r")) == NULL) {
6507                 perror(*(argv-1));
6508                 is_argument_error = TRUE;
6509                 continue;
6510             } else {
6511 #ifdef OVERWRITE
6512                 int fd = 0;
6513                 int fd_backup = 0;
6514 #endif
6515
6516                 /* reopen file for stdout */
6517                 if (file_out_f == TRUE) {
6518 #ifdef OVERWRITE
6519                     if (overwrite_f){
6520                         outfname = nkf_xmalloc(strlen(origfname)
6521                                           + strlen(".nkftmpXXXXXX")
6522                                           + 1);
6523                         strcpy(outfname, origfname);
6524 #ifdef MSDOS
6525                         {
6526                             int i;
6527                             for (i = strlen(outfname); i; --i){
6528                                 if (outfname[i - 1] == '/'
6529                                     || outfname[i - 1] == '\\'){
6530                                     break;
6531                                 }
6532                             }
6533                             outfname[i] = '\0';
6534                         }
6535                         strcat(outfname, "ntXXXXXX");
6536                         mktemp(outfname);
6537                         fd = open(outfname, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
6538                                   S_IREAD | S_IWRITE);
6539 #else
6540                         strcat(outfname, ".nkftmpXXXXXX");
6541                         fd = mkstemp(outfname);
6542 #endif
6543                         if (fd < 0
6544                             || (fd_backup = dup(fileno(stdout))) < 0
6545                             || dup2(fd, fileno(stdout)) < 0
6546                            ){
6547                             perror(origfname);
6548                             return -1;
6549                         }
6550                     }else
6551 #endif
6552                     if(argc == 1) {
6553                         outfname = *argv++;
6554                         argc--;
6555                     } else {
6556                         outfname = "nkf.out";
6557                     }
6558
6559                     if(freopen(outfname, "w", stdout) == NULL) {
6560                         perror (outfname);
6561                         return (-1);
6562                     }
6563                     if (binmode_f == TRUE) {
6564 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6565                         if (freopen("","wb",stdout) == NULL)
6566                             return (-1);
6567 #else
6568                         setbinmode(stdout);
6569 #endif
6570                     }
6571                 }
6572                 if (binmode_f == TRUE)
6573 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6574                     if (freopen("","rb",fin) == NULL)
6575                         return (-1);
6576 #else
6577                 setbinmode(fin);
6578 #endif
6579                 setvbuffer(fin, (char *) stdibuf, IOBUF_SIZE);
6580                 if (nop_f)
6581                     noconvert(fin);
6582                 else {
6583                     char *filename = NULL;
6584                     kanji_convert(fin);
6585                     if (nfiles > 1) filename = origfname;
6586                     if (guess_f) print_guessed_code(filename);
6587                 }
6588                 fclose(fin);
6589 #ifdef OVERWRITE
6590                 if (overwrite_f) {
6591                     struct stat     sb;
6592 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__) && !defined(__WATCOMC__) && !defined(__EMX__) && !defined(__OS2__) && !defined(__DJGPP__)
6593                     time_t tb[2];
6594 #else
6595                     struct utimbuf  tb;
6596 #endif
6597
6598                     fflush(stdout);
6599                     close(fd);
6600                     if (dup2(fd_backup, fileno(stdout)) < 0){
6601                         perror("dup2");
6602                     }
6603                     if (stat(origfname, &sb)) {
6604                         fprintf(stderr, "Can't stat %s\n", origfname);
6605                     }
6606                     /* \e$B%Q!<%_%C%7%g%s$rI|85\e(B */
6607                     if (chmod(outfname, sb.st_mode)) {
6608                         fprintf(stderr, "Can't set permission %s\n", outfname);
6609                     }
6610
6611                     /* \e$B%?%$%`%9%?%s%W$rI|85\e(B */
6612                     if(preserve_time_f){
6613 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__) && !defined(__WATCOMC__) && !defined(__EMX__) && !defined(__OS2__) && !defined(__DJGPP__)
6614                         tb[0] = tb[1] = sb.st_mtime;
6615                         if (utime(outfname, tb)) {
6616                             fprintf(stderr, "Can't set timestamp %s\n", outfname);
6617                         }
6618 #else
6619                         tb.actime  = sb.st_atime;
6620                         tb.modtime = sb.st_mtime;
6621                         if (utime(outfname, &tb)) {
6622                             fprintf(stderr, "Can't set timestamp %s\n", outfname);
6623                         }
6624 #endif
6625                     }
6626                     if(backup_f){
6627                         char *backup_filename = get_backup_filename(backup_suffix, origfname);
6628 #ifdef MSDOS
6629                         unlink(backup_filename);
6630 #endif
6631                         if (rename(origfname, backup_filename)) {
6632                             perror(backup_filename);
6633                             fprintf(stderr, "Can't rename %s to %s\n",
6634                                     origfname, backup_filename);
6635                         }
6636                         nkf_xfree(backup_filename);
6637                     }else{
6638 #ifdef MSDOS
6639                         if (unlink(origfname)){
6640                             perror(origfname);
6641                         }
6642 #endif
6643                     }
6644                     if (rename(outfname, origfname)) {
6645                         perror(origfname);
6646                         fprintf(stderr, "Can't rename %s to %s\n",
6647                                 outfname, origfname);
6648                     }
6649                     nkf_xfree(outfname);
6650                 }
6651 #endif
6652             }
6653         }
6654         if (is_argument_error)
6655             return(-1);
6656     }
6657 #ifdef EASYWIN /*Easy Win */
6658     if (file_out_f == FALSE)
6659         scanf("%d",&end_check);
6660     else
6661         fclose(stdout);
6662 #else /* for Other OS */
6663     if (file_out_f == TRUE)
6664         fclose(stdout);
6665 #endif /*Easy Win */
6666     return (0);
6667 }
6668 #endif /* WIN32DLL */