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?Q?",
3825 #if defined(UTF8_INPUT_ENABLE)
3826     (const unsigned char *)"\075?UTF-8?B?",
3827     (const unsigned char *)"\075?UTF-8?Q?",
3828 #endif
3829     (const unsigned char *)"\075?US-ASCII?Q?",
3830     NULL
3831 };
3832
3833
3834 /* \e$B3:Ev$9$k%3!<%I$NM%@hEY$r>e$2$k$?$a$NL\0u\e(B */
3835 nkf_char (*mime_priority_func[])(nkf_char c2, nkf_char c1, nkf_char c0) = {
3836     e_iconv, s_iconv, 0, 0, 0, 0,
3837 #if defined(UTF8_INPUT_ENABLE)
3838     w_iconv, w_iconv,
3839 #endif
3840     0,
3841 };
3842
3843 static const nkf_char mime_encode[] = {
3844     EUC_JP, SHIFT_JIS, ISO_8859_1, ISO_8859_1, JIS_X_0208, JIS_X_0201_1976_K,
3845 #if defined(UTF8_INPUT_ENABLE)
3846     UTF_8, UTF_8,
3847 #endif
3848     ASCII,
3849     0
3850 };
3851
3852 static const nkf_char mime_encode_method[] = {
3853     'B', 'B','Q', 'B', 'B', 'Q',
3854 #if defined(UTF8_INPUT_ENABLE)
3855     'B', 'Q',
3856 #endif
3857     'Q',
3858     0
3859 };
3860
3861
3862 /* MIME preprocessor fifo */
3863
3864 #define MIME_BUF_SIZE   (1024)    /* 2^n ring buffer */
3865 #define MIME_BUF_MASK   (MIME_BUF_SIZE-1)
3866 #define mime_input_buf(n)        mime_input_state.buf[(n)&MIME_BUF_MASK]
3867 static struct {
3868     unsigned char buf[MIME_BUF_SIZE];
3869     unsigned int  top;
3870     unsigned int  last;  /* decoded */
3871     unsigned int  input; /* undecoded */
3872 } mime_input_state;
3873 static nkf_char (*mime_iconv_back)(nkf_char c2,nkf_char c1,nkf_char c0) = NULL;
3874
3875 #define MAXRECOVER 20
3876
3877 static void
3878 mime_input_buf_unshift(nkf_char c)
3879 {
3880     mime_input_buf(--mime_input_state.top) = (unsigned char)c;
3881 }
3882
3883 static nkf_char
3884 mime_ungetc(nkf_char c, FILE *f)
3885 {
3886     mime_input_buf_unshift(c);
3887     return c;
3888 }
3889
3890 static nkf_char
3891 mime_ungetc_buf(nkf_char c, FILE *f)
3892 {
3893     if (mimebuf_f)
3894         (*i_mungetc_buf)(c,f);
3895     else
3896         mime_input_buf(--mime_input_state.input) = (unsigned char)c;
3897     return c;
3898 }
3899
3900 static nkf_char
3901 mime_getc_buf(FILE *f)
3902 {
3903     /* we don't keep eof of mime_input_buf, becase it contains ?= as
3904        a terminator. It was checked in mime_integrity. */
3905     return ((mimebuf_f)?
3906             (*i_mgetc_buf)(f):mime_input_buf(mime_input_state.input++));
3907 }
3908
3909 static void
3910 switch_mime_getc(void)
3911 {
3912     if (i_getc!=mime_getc) {
3913         i_mgetc = i_getc; i_getc = mime_getc;
3914         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
3915         if(mime_f==STRICT_MIME) {
3916             i_mgetc_buf = i_mgetc; i_mgetc = mime_getc_buf;
3917             i_mungetc_buf = i_mungetc; i_mungetc = mime_ungetc_buf;
3918         }
3919     }
3920 }
3921
3922 static void
3923 unswitch_mime_getc(void)
3924 {
3925     if(mime_f==STRICT_MIME) {
3926         i_mgetc = i_mgetc_buf;
3927         i_mungetc = i_mungetc_buf;
3928     }
3929     i_getc = i_mgetc;
3930     i_ungetc = i_mungetc;
3931     if(mime_iconv_back)set_iconv(FALSE, mime_iconv_back);
3932     mime_iconv_back = NULL;
3933 }
3934
3935 static nkf_char
3936 mime_integrity(FILE *f, const unsigned char *p)
3937 {
3938     nkf_char c,d;
3939     unsigned int q;
3940     /* In buffered mode, read until =? or NL or buffer full
3941      */
3942     mime_input_state.input = mime_input_state.top;
3943     mime_input_state.last = mime_input_state.top;
3944
3945     while(*p) mime_input_buf(mime_input_state.input++) = *p++;
3946     d = 0;
3947     q = mime_input_state.input;
3948     while((c=(*i_getc)(f))!=EOF) {
3949         if (((mime_input_state.input-mime_input_state.top)&MIME_BUF_MASK)==0) {
3950             break;   /* buffer full */
3951         }
3952         if (c=='=' && d=='?') {
3953             /* checked. skip header, start decode */
3954             mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3955             /* mime_last_input = mime_input_state.input; */
3956             mime_input_state.input = q;
3957             switch_mime_getc();
3958             return 1;
3959         }
3960         if (!( (c=='+'||c=='/'|| c=='=' || c=='?' || is_alnum(c))))
3961             break;
3962         /* Should we check length mod 4? */
3963         mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3964         d=c;
3965     }
3966     /* In case of Incomplete MIME, no MIME decode  */
3967     mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3968     mime_input_state.last = mime_input_state.input;     /* point undecoded buffer */
3969     mime_decode_mode = 1;              /* no decode on mime_input_buf last in mime_getc */
3970     switch_mime_getc();         /* anyway we need buffered getc */
3971     return 1;
3972 }
3973
3974 static nkf_char
3975 mime_begin_strict(FILE *f)
3976 {
3977     nkf_char c1 = 0;
3978     int i,j,k;
3979     const unsigned char *p,*q;
3980     nkf_char r[MAXRECOVER];    /* recovery buffer, max mime pattern length */
3981
3982     mime_decode_mode = FALSE;
3983     /* =? has been checked */
3984     j = 0;
3985     p = mime_pattern[j];
3986     r[0]='='; r[1]='?';
3987
3988     for(i=2;p[i]>SP;i++) {                   /* start at =? */
3989         if (((r[i] = c1 = (*i_getc)(f))==EOF) || nkf_toupper(c1) != p[i]) {
3990             /* pattern fails, try next one */
3991             q = p;
3992             while (mime_pattern[++j]) {
3993                 p = mime_pattern[j];
3994                 for(k=2;k<i;k++)              /* assume length(p) > i */
3995                     if (p[k]!=q[k]) break;
3996                 if (k==i && nkf_toupper(c1)==p[k]) break;
3997             }
3998             p = mime_pattern[j];
3999             if (p) continue;  /* found next one, continue */
4000             /* all fails, output from recovery buffer */
4001             (*i_ungetc)(c1,f);
4002             for(j=0;j<i;j++) {
4003                 (*oconv)(0,r[j]);
4004             }
4005             return c1;
4006         }
4007     }
4008     mime_decode_mode = p[i-2];
4009
4010     mime_iconv_back = iconv;
4011     set_iconv(FALSE, mime_priority_func[j]);
4012     clr_code_score(find_inputcode_byfunc(mime_priority_func[j]), SCORE_iMIME);
4013
4014     if (mime_decode_mode=='B') {
4015         mimebuf_f = unbuf_f;
4016         if (!unbuf_f) {
4017             /* do MIME integrity check */
4018             return mime_integrity(f,mime_pattern[j]);
4019         }
4020     }
4021     switch_mime_getc();
4022     mimebuf_f = TRUE;
4023     return c1;
4024 }
4025
4026 static nkf_char
4027 mime_begin(FILE *f)
4028 {
4029     nkf_char c1;
4030     int i,k;
4031
4032     /* In NONSTRICT mode, only =? is checked. In case of failure, we  */
4033     /* re-read and convert again from mime_buffer.  */
4034
4035     /* =? has been checked */
4036     k = mime_input_state.last;
4037     mime_input_buf(mime_input_state.last++)='='; mime_input_buf(mime_input_state.last++)='?';
4038     for(i=2;i<MAXRECOVER;i++) {                   /* start at =? */
4039         /* We accept any character type even if it is breaked by new lines */
4040         c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4041         if (c1==LF||c1==SP||c1==CR||
4042             c1=='-'||c1=='_'||is_alnum(c1)) continue;
4043         if (c1=='=') {
4044             /* Failed. But this could be another MIME preemble */
4045             (*i_ungetc)(c1,f);
4046             mime_input_state.last--;
4047             break;
4048         }
4049         if (c1!='?') break;
4050         else {
4051             /* c1=='?' */
4052             c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4053             if (!(++i<MAXRECOVER) || c1==EOF) break;
4054             if (c1=='b'||c1=='B') {
4055                 mime_decode_mode = 'B';
4056             } else if (c1=='q'||c1=='Q') {
4057                 mime_decode_mode = 'Q';
4058             } else {
4059                 break;
4060             }
4061             c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4062             if (!(++i<MAXRECOVER) || c1==EOF) break;
4063             if (c1!='?') {
4064                 mime_decode_mode = FALSE;
4065             }
4066             break;
4067         }
4068     }
4069     switch_mime_getc();
4070     if (!mime_decode_mode) {
4071         /* false MIME premble, restart from mime_buffer */
4072         mime_decode_mode = 1;  /* no decode, but read from the mime_buffer */
4073         /* Since we are in MIME mode until buffer becomes empty,    */
4074         /* we never go into mime_begin again for a while.           */
4075         return c1;
4076     }
4077     /* discard mime preemble, and goto MIME mode */
4078     mime_input_state.last = k;
4079     /* do no MIME integrity check */
4080     return c1;   /* used only for checking EOF */
4081 }
4082
4083 #ifdef CHECK_OPTION
4084 static void
4085 no_putc(nkf_char c)
4086 {
4087     ;
4088 }
4089
4090 static void
4091 debug(const char *str)
4092 {
4093     if (debug_f){
4094         fprintf(stderr, "%s\n", str ? str : "NULL");
4095     }
4096 }
4097 #endif
4098
4099 static void
4100 set_input_codename(const char *codename)
4101 {
4102     if (!input_codename) {
4103         input_codename = codename;
4104     } else if (strcmp(codename, input_codename) != 0) {
4105         input_codename = "";
4106     }
4107 }
4108
4109 static const char*
4110 get_guessed_code(void)
4111 {
4112     if (input_codename && !*input_codename) {
4113         input_codename = "BINARY";
4114     } else {
4115         struct input_code *p = find_inputcode_byfunc(iconv);
4116         if (!input_codename) {
4117             input_codename = "ASCII";
4118         } else if (strcmp(input_codename, "Shift_JIS") == 0) {
4119             if (p->score & (SCORE_DEPEND|SCORE_CP932))
4120                 input_codename = "CP932";
4121         } else if (strcmp(input_codename, "EUC-JP") == 0) {
4122             if (p->score & (SCORE_X0212))
4123                 input_codename = "EUCJP-MS";
4124             else if (p->score & (SCORE_DEPEND|SCORE_CP932))
4125                 input_codename = "CP51932";
4126         } else if (strcmp(input_codename, "ISO-2022-JP") == 0) {
4127             if (p->score & (SCORE_KANA))
4128                 input_codename = "CP50221";
4129             else if (p->score & (SCORE_DEPEND|SCORE_CP932))
4130                 input_codename = "CP50220";
4131         }
4132     }
4133     return input_codename;
4134 }
4135
4136 #if !defined(PERL_XS) && !defined(WIN32DLL)
4137 static void
4138 print_guessed_code(char *filename)
4139 {
4140     if (filename != NULL) printf("%s: ", filename);
4141     if (input_codename && !*input_codename) {
4142         printf("BINARY\n");
4143     } else {
4144         input_codename = get_guessed_code();
4145         if (guess_f == 1) {
4146             printf("%s\n", input_codename);
4147         } else {
4148             printf("%s%s\n",
4149                    input_codename,
4150                    input_eol == CR   ? " (CR)" :
4151                    input_eol == LF   ? " (LF)" :
4152                    input_eol == CRLF ? " (CRLF)" :
4153                    input_eol == EOF  ? " (MIXED NL)" :
4154                    "");
4155         }
4156     }
4157 }
4158 #endif /*WIN32DLL*/
4159
4160 #ifdef INPUT_OPTION
4161
4162 static nkf_char
4163 hex_getc(nkf_char ch, FILE *f, nkf_char (*g)(FILE *f), nkf_char (*u)(nkf_char c, FILE *f))
4164 {
4165     nkf_char c1, c2, c3;
4166     c1 = (*g)(f);
4167     if (c1 != ch){
4168         return c1;
4169     }
4170     c2 = (*g)(f);
4171     if (!nkf_isxdigit(c2)){
4172         (*u)(c2, f);
4173         return c1;
4174     }
4175     c3 = (*g)(f);
4176     if (!nkf_isxdigit(c3)){
4177         (*u)(c2, f);
4178         (*u)(c3, f);
4179         return c1;
4180     }
4181     return (hex2bin(c2) << 4) | hex2bin(c3);
4182 }
4183
4184 static nkf_char
4185 cap_getc(FILE *f)
4186 {
4187     return hex_getc(':', f, i_cgetc, i_cungetc);
4188 }
4189
4190 static nkf_char
4191 cap_ungetc(nkf_char c, FILE *f)
4192 {
4193     return (*i_cungetc)(c, f);
4194 }
4195
4196 static nkf_char
4197 url_getc(FILE *f)
4198 {
4199     return hex_getc('%', f, i_ugetc, i_uungetc);
4200 }
4201
4202 static nkf_char
4203 url_ungetc(nkf_char c, FILE *f)
4204 {
4205     return (*i_uungetc)(c, f);
4206 }
4207 #endif
4208
4209 #ifdef NUMCHAR_OPTION
4210 static nkf_char
4211 numchar_getc(FILE *f)
4212 {
4213     nkf_char (*g)(FILE *) = i_ngetc;
4214     nkf_char (*u)(nkf_char c ,FILE *f) = i_nungetc;
4215     int i = 0, j;
4216     nkf_char buf[12];
4217     long c = -1;
4218
4219     buf[i] = (*g)(f);
4220     if (buf[i] == '&'){
4221         buf[++i] = (*g)(f);
4222         if (buf[i] == '#'){
4223             c = 0;
4224             buf[++i] = (*g)(f);
4225             if (buf[i] == 'x' || buf[i] == 'X'){
4226                 for (j = 0; j < 7; j++){
4227                     buf[++i] = (*g)(f);
4228                     if (!nkf_isxdigit(buf[i])){
4229                         if (buf[i] != ';'){
4230                             c = -1;
4231                         }
4232                         break;
4233                     }
4234                     c <<= 4;
4235                     c |= hex2bin(buf[i]);
4236                 }
4237             }else{
4238                 for (j = 0; j < 8; j++){
4239                     if (j){
4240                         buf[++i] = (*g)(f);
4241                     }
4242                     if (!nkf_isdigit(buf[i])){
4243                         if (buf[i] != ';'){
4244                             c = -1;
4245                         }
4246                         break;
4247                     }
4248                     c *= 10;
4249                     c += hex2bin(buf[i]);
4250                 }
4251             }
4252         }
4253     }
4254     if (c != -1){
4255         return nkf_char_unicode_new(c);
4256     }
4257     while (i > 0){
4258         (*u)(buf[i], f);
4259         --i;
4260     }
4261     return buf[0];
4262 }
4263
4264 static nkf_char
4265 numchar_ungetc(nkf_char c, FILE *f)
4266 {
4267     return (*i_nungetc)(c, f);
4268 }
4269 #endif
4270
4271 #ifdef UNICODE_NORMALIZATION
4272
4273 static nkf_char
4274 nfc_getc(FILE *f)
4275 {
4276     nkf_char (*g)(FILE *f) = i_nfc_getc;
4277     nkf_char (*u)(nkf_char c ,FILE *f) = i_nfc_ungetc;
4278     nkf_buf_t *buf = nkf_state->nfc_buf;
4279     const unsigned char *array;
4280     int lower=0, upper=NORMALIZATION_TABLE_LENGTH-1;
4281     nkf_char c = (*g)(f);
4282
4283     if (c == EOF || c > 0xFF || (c & 0xc0) == 0x80) return c;
4284
4285     nkf_buf_push(buf, c);
4286     do {
4287         while (lower <= upper) {
4288             int mid = (lower+upper) / 2;
4289             int len;
4290             array = normalization_table[mid].nfd;
4291             for (len=0; len < NORMALIZATION_TABLE_NFD_LENGTH && array[len]; len++) {
4292                 if (len >= nkf_buf_length(buf)) {
4293                     c = (*g)(f);
4294                     if (c == EOF) {
4295                         len = 0;
4296                         lower = 1, upper = 0;
4297                         break;
4298                     }
4299                     nkf_buf_push(buf, c);
4300                 }
4301                 if (array[len] != nkf_buf_at(buf, len)) {
4302                     if (array[len] < nkf_buf_at(buf, len)) lower = mid + 1;
4303                     else  upper = mid - 1;
4304                     len = 0;
4305                     break;
4306                 }
4307             }
4308             if (len > 0) {
4309                 int i;
4310                 array = normalization_table[mid].nfc;
4311                 nkf_buf_clear(buf);
4312                 for (i=0; i < NORMALIZATION_TABLE_NFC_LENGTH && array[i]; i++)
4313                     nkf_buf_push(buf, array[i]);
4314                 break;
4315             }
4316         }
4317     } while (lower <= upper);
4318
4319     while (nkf_buf_length(buf) > 1) (*u)(nkf_buf_pop(buf), f);
4320     c = nkf_buf_pop(buf);
4321
4322     return c;
4323 }
4324
4325 static nkf_char
4326 nfc_ungetc(nkf_char c, FILE *f)
4327 {
4328     return (*i_nfc_ungetc)(c, f);
4329 }
4330 #endif /* UNICODE_NORMALIZATION */
4331
4332
4333 static nkf_char
4334 base64decode(nkf_char c)
4335 {
4336     int             i;
4337     if (c > '@') {
4338         if (c < '[') {
4339             i = c - 'A';                        /* A..Z 0-25 */
4340         } else if (c == '_') {
4341             i = '?'         /* 63 */ ;          /* _  63 */
4342         } else {
4343             i = c - 'G'     /* - 'a' + 26 */ ;  /* a..z 26-51 */
4344         }
4345     } else if (c > '/') {
4346         i = c - '0' + '4'   /* - '0' + 52 */ ;  /* 0..9 52-61 */
4347     } else if (c == '+' || c == '-') {
4348         i = '>'             /* 62 */ ;          /* + and -  62 */
4349     } else {
4350         i = '?'             /* 63 */ ;          /* / 63 */
4351     }
4352     return (i);
4353 }
4354
4355 static nkf_char
4356 mime_getc(FILE *f)
4357 {
4358     nkf_char c1, c2, c3, c4, cc;
4359     nkf_char t1, t2, t3, t4, mode, exit_mode;
4360     nkf_char lwsp_count;
4361     char *lwsp_buf;
4362     char *lwsp_buf_new;
4363     nkf_char lwsp_size = 128;
4364
4365     if (mime_input_state.top != mime_input_state.last) {  /* Something is in FIFO */
4366         return  mime_input_buf(mime_input_state.top++);
4367     }
4368     if (mime_decode_mode==1 ||mime_decode_mode==FALSE) {
4369         mime_decode_mode=FALSE;
4370         unswitch_mime_getc();
4371         return (*i_getc)(f);
4372     }
4373
4374     if (mimebuf_f == FIXED_MIME)
4375         exit_mode = mime_decode_mode;
4376     else
4377         exit_mode = FALSE;
4378     if (mime_decode_mode == 'Q') {
4379         if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
4380       restart_mime_q:
4381         if (c1=='_' && mimebuf_f != FIXED_MIME) return SP;
4382         if (c1<=SP || DEL<=c1) {
4383             mime_decode_mode = exit_mode; /* prepare for quit */
4384             return c1;
4385         }
4386         if (c1!='=' && (c1!='?' || mimebuf_f == FIXED_MIME)) {
4387             return c1;
4388         }
4389
4390         mime_decode_mode = exit_mode; /* prepare for quit */
4391         if ((c2 = (*i_mgetc)(f)) == EOF) return (EOF);
4392         if (c1=='?'&&c2=='=' && mimebuf_f != FIXED_MIME) {
4393             /* end Q encoding */
4394             input_mode = exit_mode;
4395             lwsp_count = 0;
4396             lwsp_buf = nkf_xmalloc((lwsp_size+5)*sizeof(char));
4397             while ((c1=(*i_getc)(f))!=EOF) {
4398                 switch (c1) {
4399                 case LF:
4400                 case CR:
4401                     if (c1==LF) {
4402                         if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4403                             i_ungetc(SP,f);
4404                             continue;
4405                         } else {
4406                             i_ungetc(c1,f);
4407                         }
4408                         c1 = LF;
4409                     } else {
4410                         if ((c1=(*i_getc)(f))!=EOF && c1 == LF) {
4411                             if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4412                                 i_ungetc(SP,f);
4413                                 continue;
4414                             } else {
4415                                 i_ungetc(c1,f);
4416                             }
4417                             i_ungetc(LF,f);
4418                         } else {
4419                             i_ungetc(c1,f);
4420                         }
4421                         c1 = CR;
4422                     }
4423                     break;
4424                 case SP:
4425                 case TAB:
4426                     lwsp_buf[lwsp_count] = (unsigned char)c1;
4427                     if (lwsp_count++>lwsp_size){
4428                         lwsp_size <<= 1;
4429                         lwsp_buf_new = nkf_xrealloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4430                         lwsp_buf = lwsp_buf_new;
4431                     }
4432                     continue;
4433                 }
4434                 break;
4435             }
4436             if (lwsp_count > 0 && (c1 != '=' || (lwsp_buf[lwsp_count-1] != SP && lwsp_buf[lwsp_count-1] != TAB))) {
4437                 i_ungetc(c1,f);
4438                 for(lwsp_count--;lwsp_count>0;lwsp_count--)
4439                     i_ungetc(lwsp_buf[lwsp_count],f);
4440                 c1 = lwsp_buf[0];
4441             }
4442             nkf_xfree(lwsp_buf);
4443             return c1;
4444         }
4445         if (c1=='='&&c2<SP) { /* this is soft wrap */
4446             while((c1 =  (*i_mgetc)(f)) <=SP) {
4447                 if (c1 == EOF) return (EOF);
4448             }
4449             mime_decode_mode = 'Q'; /* still in MIME */
4450             goto restart_mime_q;
4451         }
4452         if (c1=='?') {
4453             mime_decode_mode = 'Q'; /* still in MIME */
4454             (*i_mungetc)(c2,f);
4455             return c1;
4456         }
4457         if ((c3 = (*i_mgetc)(f)) == EOF) return (EOF);
4458         if (c2<=SP) return c2;
4459         mime_decode_mode = 'Q'; /* still in MIME */
4460         return ((hex2bin(c2)<<4) + hex2bin(c3));
4461     }
4462
4463     if (mime_decode_mode != 'B') {
4464         mime_decode_mode = FALSE;
4465         return (*i_mgetc)(f);
4466     }
4467
4468
4469     /* Base64 encoding */
4470     /*
4471        MIME allows line break in the middle of
4472        Base64, but we are very pessimistic in decoding
4473        in unbuf mode because MIME encoded code may broken by
4474        less or editor's control sequence (such as ESC-[-K in unbuffered
4475        mode. ignore incomplete MIME.
4476      */
4477     mode = mime_decode_mode;
4478     mime_decode_mode = exit_mode;  /* prepare for quit */
4479
4480     while ((c1 = (*i_mgetc)(f))<=SP) {
4481         if (c1==EOF)
4482             return (EOF);
4483     }
4484   mime_c2_retry:
4485     if ((c2 = (*i_mgetc)(f))<=SP) {
4486         if (c2==EOF)
4487             return (EOF);
4488         if (mime_f != STRICT_MIME) goto mime_c2_retry;
4489         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4490         return c2;
4491     }
4492     if ((c1 == '?') && (c2 == '=')) {
4493         input_mode = ASCII;
4494         lwsp_count = 0;
4495         lwsp_buf = nkf_xmalloc((lwsp_size+5)*sizeof(char));
4496         while ((c1=(*i_getc)(f))!=EOF) {
4497             switch (c1) {
4498             case LF:
4499             case CR:
4500                 if (c1==LF) {
4501                     if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4502                         i_ungetc(SP,f);
4503                         continue;
4504                     } else {
4505                         i_ungetc(c1,f);
4506                     }
4507                     c1 = LF;
4508                 } else {
4509                     if ((c1=(*i_getc)(f))!=EOF) {
4510                         if (c1==SP) {
4511                             i_ungetc(SP,f);
4512                             continue;
4513                         } else if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4514                             i_ungetc(SP,f);
4515                             continue;
4516                         } else {
4517                             i_ungetc(c1,f);
4518                         }
4519                         i_ungetc(LF,f);
4520                     } else {
4521                         i_ungetc(c1,f);
4522                     }
4523                     c1 = CR;
4524                 }
4525                 break;
4526             case SP:
4527             case TAB:
4528                 lwsp_buf[lwsp_count] = (unsigned char)c1;
4529                 if (lwsp_count++>lwsp_size){
4530                     lwsp_size <<= 1;
4531                     lwsp_buf_new = nkf_xrealloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4532                     lwsp_buf = lwsp_buf_new;
4533                 }
4534                 continue;
4535             }
4536             break;
4537         }
4538         if (lwsp_count > 0 && (c1 != '=' || (lwsp_buf[lwsp_count-1] != SP && lwsp_buf[lwsp_count-1] != TAB))) {
4539             i_ungetc(c1,f);
4540             for(lwsp_count--;lwsp_count>0;lwsp_count--)
4541                 i_ungetc(lwsp_buf[lwsp_count],f);
4542             c1 = lwsp_buf[0];
4543         }
4544         nkf_xfree(lwsp_buf);
4545         return c1;
4546     }
4547   mime_c3_retry:
4548     if ((c3 = (*i_mgetc)(f))<=SP) {
4549         if (c3==EOF)
4550             return (EOF);
4551         if (mime_f != STRICT_MIME) goto mime_c3_retry;
4552         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4553         return c3;
4554     }
4555   mime_c4_retry:
4556     if ((c4 = (*i_mgetc)(f))<=SP) {
4557         if (c4==EOF)
4558             return (EOF);
4559         if (mime_f != STRICT_MIME) goto mime_c4_retry;
4560         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4561         return c4;
4562     }
4563
4564     mime_decode_mode = mode; /* still in MIME sigh... */
4565
4566     /* BASE 64 decoding */
4567
4568     t1 = 0x3f & base64decode(c1);
4569     t2 = 0x3f & base64decode(c2);
4570     t3 = 0x3f & base64decode(c3);
4571     t4 = 0x3f & base64decode(c4);
4572     cc = ((t1 << 2) & 0x0fc) | ((t2 >> 4) & 0x03);
4573     if (c2 != '=') {
4574         mime_input_buf(mime_input_state.last++) = (unsigned char)cc;
4575         cc = ((t2 << 4) & 0x0f0) | ((t3 >> 2) & 0x0f);
4576         if (c3 != '=') {
4577             mime_input_buf(mime_input_state.last++) = (unsigned char)cc;
4578             cc = ((t3 << 6) & 0x0c0) | (t4 & 0x3f);
4579             if (c4 != '=')
4580                 mime_input_buf(mime_input_state.last++) = (unsigned char)cc;
4581         }
4582     } else {
4583         return c1;
4584     }
4585     return  mime_input_buf(mime_input_state.top++);
4586 }
4587
4588 static const char basis_64[] =
4589     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4590
4591 #define MIMEOUT_BUF_LENGTH 74
4592 static struct {
4593     char buf[MIMEOUT_BUF_LENGTH+1];
4594     int count;
4595 } mimeout_state;
4596
4597 /*nkf_char mime_lastchar2, mime_lastchar1;*/
4598
4599 static void
4600 open_mime(nkf_char mode)
4601 {
4602     const unsigned char *p;
4603     int i;
4604     int j;
4605     p  = mime_pattern[0];
4606     for(i=0;mime_pattern[i];i++) {
4607         if (mode == mime_encode[i]) {
4608             p = mime_pattern[i];
4609             break;
4610         }
4611     }
4612     mimeout_mode = mime_encode_method[i];
4613     i = 0;
4614     if (base64_count>45) {
4615         if (mimeout_state.count>0 && nkf_isblank(mimeout_state.buf[i])){
4616             (*o_mputc)(mimeout_state.buf[i]);
4617             i++;
4618         }
4619         PUT_NEWLINE((*o_mputc));
4620         (*o_mputc)(SP);
4621         base64_count = 1;
4622         if (mimeout_state.count>0 && nkf_isspace(mimeout_state.buf[i])) {
4623             i++;
4624         }
4625     }
4626     for (;i<mimeout_state.count;i++) {
4627         if (nkf_isspace(mimeout_state.buf[i])) {
4628             (*o_mputc)(mimeout_state.buf[i]);
4629             base64_count ++;
4630         } else {
4631             break;
4632         }
4633     }
4634     while(*p) {
4635         (*o_mputc)(*p++);
4636         base64_count ++;
4637     }
4638     j = mimeout_state.count;
4639     mimeout_state.count = 0;
4640     for (;i<j;i++) {
4641         mime_putc(mimeout_state.buf[i]);
4642     }
4643 }
4644
4645 static void
4646 mime_prechar(nkf_char c2, nkf_char c1)
4647 {
4648     if (mimeout_mode > 0){
4649         if (c2 == EOF){
4650             if (base64_count + mimeout_state.count/3*4> 73){
4651                 (*o_base64conv)(EOF,0);
4652                 OCONV_NEWLINE((*o_base64conv));
4653                 (*o_base64conv)(0,SP);
4654                 base64_count = 1;
4655             }
4656         } else {
4657             if (!(c2 == 0 && (c1 == CR || c1 == LF)) &&
4658                     base64_count + mimeout_state.count/3*4> 66) {
4659                 (*o_base64conv)(EOF,0);
4660                 OCONV_NEWLINE((*o_base64conv));
4661                 (*o_base64conv)(0,SP);
4662                 base64_count = 1;
4663                 mimeout_mode = -1;
4664             }
4665         }
4666     } else if (c2) {
4667         if (c2 != EOF && base64_count + mimeout_state.count/3*4> 60) {
4668             mimeout_mode =  (output_mode==ASCII ||output_mode == ISO_8859_1) ? 'Q' : 'B';
4669             open_mime(output_mode);
4670             (*o_base64conv)(EOF,0);
4671             OCONV_NEWLINE((*o_base64conv));
4672             (*o_base64conv)(0,SP);
4673             base64_count = 1;
4674             mimeout_mode = -1;
4675         }
4676     }
4677 }
4678
4679 static void
4680 close_mime(void)
4681 {
4682     (*o_mputc)('?');
4683     (*o_mputc)('=');
4684     base64_count += 2;
4685     mimeout_mode = 0;
4686 }
4687
4688 static void
4689 eof_mime(void)
4690 {
4691     switch(mimeout_mode) {
4692     case 'Q':
4693     case 'B':
4694         break;
4695     case 2:
4696         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0x3)<< 4)]);
4697         (*o_mputc)('=');
4698         (*o_mputc)('=');
4699         base64_count += 3;
4700         break;
4701     case 1:
4702         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0xF) << 2)]);
4703         (*o_mputc)('=');
4704         base64_count += 2;
4705         break;
4706     }
4707     if (mimeout_mode > 0) {
4708         if (mimeout_f!=FIXED_MIME) {
4709             close_mime();
4710         } else if (mimeout_mode != 'Q')
4711             mimeout_mode = 'B';
4712     }
4713 }
4714
4715 static void
4716 mimeout_addchar(nkf_char c)
4717 {
4718     switch(mimeout_mode) {
4719     case 'Q':
4720         if (c==CR||c==LF) {
4721             (*o_mputc)(c);
4722             base64_count = 0;
4723         } else if(!nkf_isalnum(c)) {
4724             (*o_mputc)('=');
4725             (*o_mputc)(bin2hex(((c>>4)&0xf)));
4726             (*o_mputc)(bin2hex((c&0xf)));
4727             base64_count += 3;
4728         } else {
4729             (*o_mputc)(c);
4730             base64_count++;
4731         }
4732         break;
4733     case 'B':
4734         nkf_state->mimeout_state=c;
4735         (*o_mputc)(basis_64[c>>2]);
4736         mimeout_mode=2;
4737         base64_count ++;
4738         break;
4739     case 2:
4740         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0x3)<< 4) | ((c & 0xF0) >> 4)]);
4741         nkf_state->mimeout_state=c;
4742         mimeout_mode=1;
4743         base64_count ++;
4744         break;
4745     case 1:
4746         (*o_mputc)(basis_64[((nkf_state->mimeout_state & 0xF) << 2) | ((c & 0xC0) >>6)]);
4747         (*o_mputc)(basis_64[c & 0x3F]);
4748         mimeout_mode='B';
4749         base64_count += 2;
4750         break;
4751     default:
4752         (*o_mputc)(c);
4753         base64_count++;
4754         break;
4755     }
4756 }
4757
4758 static void
4759 mime_putc(nkf_char c)
4760 {
4761     int i, j;
4762     nkf_char lastchar;
4763
4764     if (mimeout_f == FIXED_MIME){
4765         if (mimeout_mode == 'Q'){
4766             if (base64_count > 71){
4767                 if (c!=CR && c!=LF) {
4768                     (*o_mputc)('=');
4769                     PUT_NEWLINE((*o_mputc));
4770                 }
4771                 base64_count = 0;
4772             }
4773         }else{
4774             if (base64_count > 71){
4775                 eof_mime();
4776                 PUT_NEWLINE((*o_mputc));
4777                 base64_count = 0;
4778             }
4779             if (c == EOF) { /* c==EOF */
4780                 eof_mime();
4781             }
4782         }
4783         if (c != EOF) { /* c==EOF */
4784             mimeout_addchar(c);
4785         }
4786         return;
4787     }
4788
4789     /* mimeout_f != FIXED_MIME */
4790
4791     if (c == EOF) { /* c==EOF */
4792         if (mimeout_mode == -1 && mimeout_state.count > 1) open_mime(output_mode);
4793         j = mimeout_state.count;
4794         mimeout_state.count = 0;
4795         i = 0;
4796         if (mimeout_mode > 0) {
4797             if (!nkf_isblank(mimeout_state.buf[j-1])) {
4798                 for (;i<j;i++) {
4799                     if (nkf_isspace(mimeout_state.buf[i]) && base64_count < 71){
4800                         break;
4801                     }
4802                     mimeout_addchar(mimeout_state.buf[i]);
4803                 }
4804                 eof_mime();
4805                 for (;i<j;i++) {
4806                     mimeout_addchar(mimeout_state.buf[i]);
4807                 }
4808             } else {
4809                 for (;i<j;i++) {
4810                     mimeout_addchar(mimeout_state.buf[i]);
4811                 }
4812                 eof_mime();
4813             }
4814         } else {
4815             for (;i<j;i++) {
4816                 mimeout_addchar(mimeout_state.buf[i]);
4817             }
4818         }
4819         return;
4820     }
4821
4822     if (mimeout_state.count > 0){
4823         lastchar = mimeout_state.buf[mimeout_state.count - 1];
4824     }else{
4825         lastchar = -1;
4826     }
4827
4828     if (mimeout_mode=='Q') {
4829         if (c <= DEL && (output_mode==ASCII ||output_mode == ISO_8859_1)) {
4830             if (c == CR || c == LF) {
4831                 close_mime();
4832                 (*o_mputc)(c);
4833                 base64_count = 0;
4834                 return;
4835             } else if (c <= SP) {
4836                 close_mime();
4837                 if (base64_count > 70) {
4838                     PUT_NEWLINE((*o_mputc));
4839                     base64_count = 0;
4840                 }
4841                 if (!nkf_isblank(c)) {
4842                     (*o_mputc)(SP);
4843                     base64_count++;
4844                 }
4845             } else {
4846                 if (base64_count > 70) {
4847                     close_mime();
4848                     PUT_NEWLINE((*o_mputc));
4849                     (*o_mputc)(SP);
4850                     base64_count = 1;
4851                     open_mime(output_mode);
4852                 }
4853                 if (!nkf_noescape_mime(c)) {
4854                     mimeout_addchar(c);
4855                     return;
4856                 }
4857             }
4858             if (c != 0x1B) {
4859                 (*o_mputc)(c);
4860                 base64_count++;
4861                 return;
4862             }
4863         }
4864     }
4865
4866     if (mimeout_mode <= 0) {
4867         if (c <= DEL && (output_mode==ASCII || output_mode == ISO_8859_1 ||
4868                     output_mode == UTF_8)) {
4869             if (nkf_isspace(c)) {
4870                 int flag = 0;
4871                 if (mimeout_mode == -1) {
4872                     flag = 1;
4873                 }
4874                 if (c==CR || c==LF) {
4875                     if (flag) {
4876                         open_mime(output_mode);
4877                         output_mode = 0;
4878                     } else {
4879                         base64_count = 0;
4880                     }
4881                 }
4882                 for (i=0;i<mimeout_state.count;i++) {
4883                     (*o_mputc)(mimeout_state.buf[i]);
4884                     if (mimeout_state.buf[i] == CR || mimeout_state.buf[i] == LF){
4885                         base64_count = 0;
4886                     }else{
4887                         base64_count++;
4888                     }
4889                 }
4890                 if (flag) {
4891                     eof_mime();
4892                     base64_count = 0;
4893                     mimeout_mode = 0;
4894                 }
4895                 mimeout_state.buf[0] = (char)c;
4896                 mimeout_state.count = 1;
4897             }else{
4898                 if (base64_count > 1
4899                     && base64_count + mimeout_state.count > 76
4900                     && mimeout_state.buf[0] != CR && mimeout_state.buf[0] != LF){
4901                     static const char *str = "boundary=\"";
4902                     static int len = 10;
4903                     i = 0;
4904
4905                     for (; i < mimeout_state.count - len; ++i) {
4906                         if (!strncmp(mimeout_state.buf+i, str, len)) {
4907                             i += len - 2;
4908                             break;
4909                         }
4910                     }
4911
4912                     if (i == 0 || i == mimeout_state.count - len) {
4913                         PUT_NEWLINE((*o_mputc));
4914                         base64_count = 0;
4915                         if (!nkf_isspace(mimeout_state.buf[0])){
4916                             (*o_mputc)(SP);
4917                             base64_count++;
4918                         }
4919                     }
4920                     else {
4921                         int j;
4922                         for (j = 0; j <= i; ++j) {
4923                             (*o_mputc)(mimeout_state.buf[j]);
4924                         }
4925                         PUT_NEWLINE((*o_mputc));
4926                         base64_count = 1;
4927                         for (; j <= mimeout_state.count; ++j) {
4928                             mimeout_state.buf[j - i] = mimeout_state.buf[j];
4929                         }
4930                         mimeout_state.count -= i;
4931                     }
4932                 }
4933                 mimeout_state.buf[mimeout_state.count++] = (char)c;
4934                 if (mimeout_state.count>MIMEOUT_BUF_LENGTH) {
4935                     open_mime(output_mode);
4936                 }
4937             }
4938             return;
4939         }else{
4940             if (lastchar==CR || lastchar == LF){
4941                 for (i=0;i<mimeout_state.count;i++) {
4942                     (*o_mputc)(mimeout_state.buf[i]);
4943                 }
4944                 base64_count = 0;
4945                 mimeout_state.count = 0;
4946             }
4947             if (lastchar==SP) {
4948                 for (i=0;i<mimeout_state.count-1;i++) {
4949                     (*o_mputc)(mimeout_state.buf[i]);
4950                     base64_count++;
4951                 }
4952                 mimeout_state.buf[0] = SP;
4953                 mimeout_state.count = 1;
4954             }
4955             open_mime(output_mode);
4956         }
4957     }else{
4958         /* mimeout_mode == 'B', 1, 2 */
4959         if (c <= DEL && (output_mode==ASCII || output_mode == ISO_8859_1 ||
4960                     output_mode == UTF_8)) {
4961             if (lastchar == CR || lastchar == LF){
4962                 if (nkf_isblank(c)) {
4963                     for (i=0;i<mimeout_state.count;i++) {
4964                         mimeout_addchar(mimeout_state.buf[i]);
4965                     }
4966                     mimeout_state.count = 0;
4967                 } else {
4968                     eof_mime();
4969                     for (i=0;i<mimeout_state.count;i++) {
4970                         (*o_mputc)(mimeout_state.buf[i]);
4971                     }
4972                     base64_count = 0;
4973                     mimeout_state.count = 0;
4974                 }
4975                 mimeout_state.buf[mimeout_state.count++] = (char)c;
4976                 return;
4977             }
4978             if (nkf_isspace(c)) {
4979                 for (i=0;i<mimeout_state.count;i++) {
4980                     if (SP<mimeout_state.buf[i] && mimeout_state.buf[i]<DEL) {
4981                         eof_mime();
4982                         for (i=0;i<mimeout_state.count;i++) {
4983                             (*o_mputc)(mimeout_state.buf[i]);
4984                             base64_count++;
4985                         }
4986                         mimeout_state.count = 0;
4987                     }
4988                 }
4989                 mimeout_state.buf[mimeout_state.count++] = (char)c;
4990                 if (mimeout_state.count>MIMEOUT_BUF_LENGTH) {
4991                     eof_mime();
4992                     for (i=0;i<mimeout_state.count;i++) {
4993                         (*o_mputc)(mimeout_state.buf[i]);
4994                         base64_count++;
4995                     }
4996                     mimeout_state.count = 0;
4997                 }
4998                 return;
4999             }
5000             if (mimeout_state.count>0 && SP<c && c!='=') {
5001                 mimeout_state.buf[mimeout_state.count++] = (char)c;
5002                 if (mimeout_state.count>MIMEOUT_BUF_LENGTH) {
5003                     j = mimeout_state.count;
5004                     mimeout_state.count = 0;
5005                     for (i=0;i<j;i++) {
5006                         mimeout_addchar(mimeout_state.buf[i]);
5007                     }
5008                 }
5009                 return;
5010             }
5011         }
5012     }
5013     if (mimeout_state.count>0) {
5014         j = mimeout_state.count;
5015         mimeout_state.count = 0;
5016         for (i=0;i<j;i++) {
5017             if (mimeout_state.buf[i]==CR || mimeout_state.buf[i]==LF)
5018                 break;
5019             mimeout_addchar(mimeout_state.buf[i]);
5020         }
5021         if (i<j) {
5022             eof_mime();
5023             base64_count=0;
5024             for (;i<j;i++) {
5025                 (*o_mputc)(mimeout_state.buf[i]);
5026             }
5027             open_mime(output_mode);
5028         }
5029     }
5030     mimeout_addchar(c);
5031 }
5032
5033 static void
5034 base64_conv(nkf_char c2, nkf_char c1)
5035 {
5036     mime_prechar(c2, c1);
5037     (*o_base64conv)(c2,c1);
5038 }
5039
5040 #ifdef HAVE_ICONV_H
5041 typedef struct nkf_iconv_t {
5042     iconv_t cd;
5043     char *input_buffer;
5044     size_t input_buffer_size;
5045     char *output_buffer;
5046     size_t output_buffer_size;
5047 }
5048
5049 static nkf_iconv_t
5050 nkf_iconv_new(char *tocode, char *fromcode)
5051 {
5052     nkf_iconv_t converter;
5053
5054     converter->input_buffer_size = IOBUF_SIZE;
5055     converter->input_buffer = nkf_xmalloc(converter->input_buffer_size);
5056     converter->output_buffer_size = IOBUF_SIZE * 2;
5057     converter->output_buffer = nkf_xmalloc(converter->output_buffer_size);
5058     converter->cd = iconv_open(tocode, fromcode);
5059     if (converter->cd == (iconv_t)-1)
5060     {
5061         switch (errno) {
5062         case EINVAL:
5063             perror(fprintf("iconv doesn't support %s to %s conversion.", fromcode, tocode));
5064             return -1;
5065         default:
5066             perror("can't iconv_open");
5067         }
5068     }
5069 }
5070
5071 static size_t
5072 nkf_iconv_convert(nkf_iconv_t *converter, FILE *input)
5073 {
5074     size_t invalid = (size_t)0;
5075     char *input_buffer = converter->input_buffer;
5076     size_t input_length = (size_t)0;
5077     char *output_buffer = converter->output_buffer;
5078     size_t output_length = converter->output_buffer_size;
5079     int c;
5080
5081     do {
5082         if (c != EOF) {
5083             while ((c = (*i_getc)(f)) != EOF) {
5084                 input_buffer[input_length++] = c;
5085                 if (input_length < converter->input_buffer_size) break;
5086             }
5087         }
5088
5089         size_t ret = iconv(converter->cd, &input_buffer, &input_length, &output_buffer, &output_length);
5090         while (output_length-- > 0) {
5091             (*o_putc)(output_buffer[converter->output_buffer_size-output_length]);
5092         }
5093         if (ret == (size_t) - 1) {
5094             switch (errno) {
5095             case EINVAL:
5096                 if (input_buffer != converter->input_buffer)
5097                     memmove(converter->input_buffer, input_buffer, input_length);
5098                 break;
5099             case E2BIG:
5100                 converter->output_buffer_size *= 2;
5101                 output_buffer = realloc(converter->outbuf, converter->output_buffer_size);
5102                 if (output_buffer == NULL) {
5103                     perror("can't realloc");
5104                     return -1;
5105                 }
5106                 converter->output_buffer = output_buffer;
5107                 break;
5108             default:
5109                 perror("can't iconv");
5110                 return -1;
5111             }
5112         } else {
5113             invalid += ret;
5114         }
5115     } while (1);
5116
5117     return invalid;
5118 }
5119
5120
5121 static void
5122 nkf_iconv_close(nkf_iconv_t *convert)
5123 {
5124     nkf_xfree(converter->inbuf);
5125     nkf_xfree(converter->outbuf);
5126     iconv_close(converter->cd);
5127 }
5128 #endif
5129
5130
5131 static void
5132 reinit(void)
5133 {
5134     {
5135         struct input_code *p = input_code_list;
5136         while (p->name){
5137             status_reinit(p++);
5138         }
5139     }
5140     unbuf_f = FALSE;
5141     estab_f = FALSE;
5142     nop_f = FALSE;
5143     binmode_f = TRUE;
5144     rot_f = FALSE;
5145     hira_f = FALSE;
5146     alpha_f = FALSE;
5147     mime_f = MIME_DECODE_DEFAULT;
5148     mime_decode_f = FALSE;
5149     mimebuf_f = FALSE;
5150     broken_f = FALSE;
5151     iso8859_f = FALSE;
5152     mimeout_f = FALSE;
5153     x0201_f = X0201_DEFAULT;
5154     iso2022jp_f = FALSE;
5155 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
5156     ms_ucs_map_f = UCS_MAP_ASCII;
5157 #endif
5158 #ifdef UTF8_INPUT_ENABLE
5159     no_cp932ext_f = FALSE;
5160     no_best_fit_chars_f = FALSE;
5161     encode_fallback = NULL;
5162     unicode_subchar  = '?';
5163     input_endian = ENDIAN_BIG;
5164 #endif
5165 #ifdef UTF8_OUTPUT_ENABLE
5166     output_bom_f = FALSE;
5167     output_endian = ENDIAN_BIG;
5168 #endif
5169 #ifdef UNICODE_NORMALIZATION
5170     nfc_f = FALSE;
5171 #endif
5172 #ifdef INPUT_OPTION
5173     cap_f = FALSE;
5174     url_f = FALSE;
5175     numchar_f = FALSE;
5176 #endif
5177 #ifdef CHECK_OPTION
5178     noout_f = FALSE;
5179     debug_f = FALSE;
5180 #endif
5181     guess_f = 0;
5182 #ifdef EXEC_IO
5183     exec_f = 0;
5184 #endif
5185 #ifdef SHIFTJIS_CP932
5186     cp51932_f = TRUE;
5187     cp932inv_f = TRUE;
5188 #endif
5189 #ifdef X0212_ENABLE
5190     x0212_f = FALSE;
5191     x0213_f = FALSE;
5192 #endif
5193     {
5194         int i;
5195         for (i = 0; i < 256; i++){
5196             prefix_table[i] = 0;
5197         }
5198     }
5199     hold_count = 0;
5200     mimeout_state.count = 0;
5201     mimeout_mode = 0;
5202     base64_count = 0;
5203     f_line = 0;
5204     f_prev = 0;
5205     fold_preserve_f = FALSE;
5206     fold_f = FALSE;
5207     fold_len = 0;
5208     kanji_intro = DEFAULT_J;
5209     ascii_intro = DEFAULT_R;
5210     fold_margin  = FOLD_MARGIN;
5211     o_zconv = no_connection;
5212     o_fconv = no_connection;
5213     o_eol_conv = no_connection;
5214     o_rot_conv = no_connection;
5215     o_hira_conv = no_connection;
5216     o_base64conv = no_connection;
5217     o_iso2022jp_check_conv = no_connection;
5218     o_putc = std_putc;
5219     i_getc = std_getc;
5220     i_ungetc = std_ungetc;
5221     i_bgetc = std_getc;
5222     i_bungetc = std_ungetc;
5223     o_mputc = std_putc;
5224     i_mgetc = std_getc;
5225     i_mungetc  = std_ungetc;
5226     i_mgetc_buf = std_getc;
5227     i_mungetc_buf = std_ungetc;
5228     output_mode = ASCII;
5229     input_mode =  ASCII;
5230     mime_decode_mode = FALSE;
5231     file_out_f = FALSE;
5232     eolmode_f = 0;
5233     input_eol = 0;
5234     prev_cr = 0;
5235     option_mode = 0;
5236     z_prev2=0,z_prev1=0;
5237 #ifdef CHECK_OPTION
5238     iconv_for_check = 0;
5239 #endif
5240     input_codename = NULL;
5241     input_encoding = NULL;
5242     output_encoding = NULL;
5243     nkf_state_init();
5244 #ifdef WIN32DLL
5245     reinitdll();
5246 #endif /*WIN32DLL*/
5247 }
5248
5249 static int
5250 module_connection(void)
5251 {
5252     if (input_encoding) set_input_encoding(input_encoding);
5253     if (!output_encoding) {
5254         output_encoding = nkf_default_encoding();
5255     }
5256     if (!output_encoding) {
5257         if (noout_f || guess_f) output_encoding = nkf_enc_from_index(ISO_2022_JP);
5258         else return -1;
5259     }
5260     set_output_encoding(output_encoding);
5261     oconv = nkf_enc_to_oconv(output_encoding);
5262     o_putc = std_putc;
5263     if (nkf_enc_unicode_p(output_encoding))
5264         output_mode = UTF_8;
5265
5266     /* replace continucation module, from output side */
5267
5268     /* output redicrection */
5269 #ifdef CHECK_OPTION
5270     if (noout_f || guess_f){
5271         o_putc = no_putc;
5272     }
5273 #endif
5274     if (mimeout_f) {
5275         o_mputc = o_putc;
5276         o_putc = mime_putc;
5277         if (mimeout_f == TRUE) {
5278             o_base64conv = oconv; oconv = base64_conv;
5279         }
5280         /* base64_count = 0; */
5281     }
5282
5283     if (eolmode_f || guess_f) {
5284         o_eol_conv = oconv; oconv = eol_conv;
5285     }
5286     if (rot_f) {
5287         o_rot_conv = oconv; oconv = rot_conv;
5288     }
5289     if (iso2022jp_f) {
5290         o_iso2022jp_check_conv = oconv; oconv = iso2022jp_check_conv;
5291     }
5292     if (hira_f) {
5293         o_hira_conv = oconv; oconv = hira_conv;
5294     }
5295     if (fold_f) {
5296         o_fconv = oconv; oconv = fold_conv;
5297         f_line = 0;
5298     }
5299     if (alpha_f || x0201_f) {
5300         o_zconv = oconv; oconv = z_conv;
5301     }
5302
5303     i_getc = std_getc;
5304     i_ungetc = std_ungetc;
5305     /* input redicrection */
5306 #ifdef INPUT_OPTION
5307     if (cap_f){
5308         i_cgetc = i_getc; i_getc = cap_getc;
5309         i_cungetc = i_ungetc; i_ungetc= cap_ungetc;
5310     }
5311     if (url_f){
5312         i_ugetc = i_getc; i_getc = url_getc;
5313         i_uungetc = i_ungetc; i_ungetc= url_ungetc;
5314     }
5315 #endif
5316 #ifdef NUMCHAR_OPTION
5317     if (numchar_f){
5318         i_ngetc = i_getc; i_getc = numchar_getc;
5319         i_nungetc = i_ungetc; i_ungetc= numchar_ungetc;
5320     }
5321 #endif
5322 #ifdef UNICODE_NORMALIZATION
5323     if (nfc_f){
5324         i_nfc_getc = i_getc; i_getc = nfc_getc;
5325         i_nfc_ungetc = i_ungetc; i_ungetc= nfc_ungetc;
5326     }
5327 #endif
5328     if (mime_f && mimebuf_f==FIXED_MIME) {
5329         i_mgetc = i_getc; i_getc = mime_getc;
5330         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
5331     }
5332     if (broken_f & 1) {
5333         i_bgetc = i_getc; i_getc = broken_getc;
5334         i_bungetc = i_ungetc; i_ungetc = broken_ungetc;
5335     }
5336     if (input_encoding) {
5337         set_iconv(-TRUE, nkf_enc_to_iconv(input_encoding));
5338     } else {
5339         set_iconv(FALSE, e_iconv);
5340     }
5341
5342     {
5343         struct input_code *p = input_code_list;
5344         while (p->name){
5345             status_reinit(p++);
5346         }
5347     }
5348     return 0;
5349 }
5350
5351 /*
5352    Conversion main loop. Code detection only.
5353  */
5354
5355 #if !defined(PERL_XS) && !defined(WIN32DLL)
5356 static nkf_char
5357 noconvert(FILE *f)
5358 {
5359     nkf_char    c;
5360
5361     if (nop_f == 2)
5362         module_connection();
5363     while ((c = (*i_getc)(f)) != EOF)
5364         (*o_putc)(c);
5365     (*o_putc)(EOF);
5366     return 1;
5367 }
5368 #endif
5369
5370 #define NEXT continue        /* no output, get next */
5371 #define SKIP c2=0;continue        /* no output, get next */
5372 #define MORE c2=c1;continue  /* need one more byte */
5373 #define SEND ;               /* output c1 and c2, get next */
5374 #define LAST break           /* end of loop, go closing  */
5375 #define set_input_mode(mode) do { \
5376     input_mode = mode; \
5377     shift_mode = 0; \
5378     set_input_codename("ISO-2022-JP"); \
5379     debug("ISO-2022-JP"); \
5380 } while (0)
5381
5382 static int
5383 kanji_convert(FILE *f)
5384 {
5385     nkf_char c1=0, c2=0, c3=0, c4=0;
5386     int shift_mode = 0; /* 0, 1, 2, 3 */
5387     int g2 = 0;
5388     int is_8bit = FALSE;
5389
5390     if (input_encoding && !nkf_enc_asciicompat(input_encoding)) {
5391         is_8bit = TRUE;
5392     }
5393
5394     input_mode = ASCII;
5395     output_mode = ASCII;
5396
5397     if (module_connection() < 0) {
5398 #if !defined(PERL_XS) && !defined(WIN32DLL)
5399         fprintf(stderr, "no output encoding given\n");
5400 #endif
5401         return -1;
5402     }
5403     check_bom(f);
5404
5405 #ifdef UTF8_INPUT_ENABLE
5406     if(iconv == w_iconv32){
5407         while ((c1 = (*i_getc)(f)) != EOF &&
5408                (c2 = (*i_getc)(f)) != EOF &&
5409                (c3 = (*i_getc)(f)) != EOF &&
5410                (c4 = (*i_getc)(f)) != EOF) {
5411             nkf_iconv_utf_32(c1, c2, c3, c4);
5412         }
5413         goto finished;
5414     }
5415     else if (iconv == w_iconv16) {
5416         while ((c1 = (*i_getc)(f)) != EOF &&
5417                (c2 = (*i_getc)(f)) != EOF) {
5418             if (nkf_iconv_utf_16(c1, c2, 0, 0) == -2 &&
5419                 (c3 = (*i_getc)(f)) != EOF &&
5420                 (c4 = (*i_getc)(f)) != EOF) {
5421                 nkf_iconv_utf_16(c1, c2, c3, c4);
5422             }
5423         }
5424         goto finished;
5425     }
5426 #endif
5427
5428     while ((c1 = (*i_getc)(f)) != EOF) {
5429 #ifdef INPUT_CODE_FIX
5430         if (!input_encoding)
5431 #endif
5432             code_status(c1);
5433         if (c2) {
5434             /* second byte */
5435             if (c2 > DEL) {
5436                 /* in case of 8th bit is on */
5437                 if (!estab_f&&!mime_decode_mode) {
5438                     /* in case of not established yet */
5439                     /* It is still ambiguious */
5440                     if (h_conv(f, c2, c1)==EOF) {
5441                         LAST;
5442                     }
5443                     else {
5444                         SKIP;
5445                     }
5446                 }
5447                 else {
5448                     /* in case of already established */
5449                     if (c1 < 0x40) {
5450                         /* ignore bogus code */
5451                         SKIP;
5452                     } else {
5453                         SEND;
5454                     }
5455                 }
5456             }
5457             else {
5458                 /* 2nd byte of 7 bit code or SJIS */
5459                 SEND;
5460             }
5461         }
5462         else if (nkf_char_unicode_p(c1)) {
5463             (*oconv)(0, c1);
5464             NEXT;
5465         }
5466         else {
5467             /* first byte */
5468             if (input_mode == JIS_X_0208 && DEL <= c1 && c1 < 0x92) {
5469                 /* CP5022x */
5470                 MORE;
5471             }else if (input_codename && input_codename[0] == 'I' &&
5472                     0xA1 <= c1 && c1 <= 0xDF) {
5473                 /* JIS X 0201 Katakana in 8bit JIS */
5474                 c2 = JIS_X_0201_1976_K;
5475                 c1 &= 0x7f;
5476                 SEND;
5477             } else if (c1 > DEL) {
5478                 /* 8 bit code */
5479                 if (!estab_f && !iso8859_f) {
5480                     /* not established yet */
5481                     MORE;
5482                 } else { /* estab_f==TRUE */
5483                     if (iso8859_f) {
5484                         c2 = ISO_8859_1;
5485                         c1 &= 0x7f;
5486                         SEND;
5487                     }
5488                     else if ((iconv == s_iconv && 0xA0 <= c1 && c1 <= 0xDF) ||
5489                              (ms_ucs_map_f == UCS_MAP_CP10001 && (c1 == 0xFD || c1 == 0xFE))) {
5490                         /* JIS X 0201 */
5491                         c2 = JIS_X_0201_1976_K;
5492                         c1 &= 0x7f;
5493                         SEND;
5494                     }
5495                     else {
5496                         /* already established */
5497                         MORE;
5498                     }
5499                 }
5500             } else if (SP < c1 && c1 < DEL) {
5501                 /* in case of Roman characters */
5502                 if (shift_mode) {
5503                     /* output 1 shifted byte */
5504                     if (iso8859_f) {
5505                         c2 = ISO_8859_1;
5506                         SEND;
5507                     } else if (nkf_byte_jisx0201_katakana_p(c1)){
5508                         /* output 1 shifted byte */
5509                         c2 = JIS_X_0201_1976_K;
5510                         SEND;
5511                     } else {
5512                         /* look like bogus code */
5513                         SKIP;
5514                     }
5515                 } else if (input_mode == JIS_X_0208 || input_mode == JIS_X_0212 ||
5516                            input_mode == JIS_X_0213_1 || input_mode == JIS_X_0213_2) {
5517                     /* in case of Kanji shifted */
5518                     MORE;
5519                 } else if (c1 == '=' && mime_f && !mime_decode_mode) {
5520                     /* Check MIME code */
5521                     if ((c1 = (*i_getc)(f)) == EOF) {
5522                         (*oconv)(0, '=');
5523                         LAST;
5524                     } else if (c1 == '?') {
5525                         /* =? is mime conversion start sequence */
5526                         if(mime_f == STRICT_MIME) {
5527                             /* check in real detail */
5528                             if (mime_begin_strict(f) == EOF)
5529                                 LAST;
5530                             SKIP;
5531                         } else if (mime_begin(f) == EOF)
5532                             LAST;
5533                         SKIP;
5534                     } else {
5535                         (*oconv)(0, '=');
5536                         (*i_ungetc)(c1,f);
5537                         SKIP;
5538                     }
5539                 } else {
5540                     /* normal ASCII code */
5541                     SEND;
5542                 }
5543             } else if (c1 == SI && (!is_8bit || mime_decode_mode)) {
5544                 shift_mode = 0;
5545                 SKIP;
5546             } else if (c1 == SO && (!is_8bit || mime_decode_mode)) {
5547                 shift_mode = 1;
5548                 SKIP;
5549             } else if (c1 == ESC && (!is_8bit || mime_decode_mode)) {
5550                 if ((c1 = (*i_getc)(f)) == EOF) {
5551                     (*oconv)(0, ESC);
5552                     LAST;
5553                 }
5554                 else if (c1 == '&') {
5555                     /* IRR */
5556                     if ((c1 = (*i_getc)(f)) == EOF) {
5557                         LAST;
5558                     } else {
5559                         SKIP;
5560                     }
5561                 }
5562                 else if (c1 == '$') {
5563                     /* GZDMx */
5564                     if ((c1 = (*i_getc)(f)) == EOF) {
5565                         /* don't send bogus code
5566                            (*oconv)(0, ESC);
5567                            (*oconv)(0, '$'); */
5568                         LAST;
5569                     } else if (c1 == '@' || c1 == 'B') {
5570                         /* JIS X 0208 */
5571                         set_input_mode(JIS_X_0208);
5572                         SKIP;
5573                     } else if (c1 == '(') {
5574                         /* GZDM4 */
5575                         if ((c1 = (*i_getc)(f)) == EOF) {
5576                             /* don't send bogus code
5577                                (*oconv)(0, ESC);
5578                                (*oconv)(0, '$');
5579                                (*oconv)(0, '(');
5580                              */
5581                             LAST;
5582                         } else if (c1 == '@'|| c1 == 'B') {
5583                             /* JIS X 0208 */
5584                             set_input_mode(JIS_X_0208);
5585                             SKIP;
5586 #ifdef X0212_ENABLE
5587                         } else if (c1 == 'D'){
5588                             set_input_mode(JIS_X_0212);
5589                             SKIP;
5590 #endif /* X0212_ENABLE */
5591                         } else if (c1 == 'O' || c1 == 'Q'){
5592                             set_input_mode(JIS_X_0213_1);
5593                             SKIP;
5594                         } else if (c1 == 'P'){
5595                             set_input_mode(JIS_X_0213_2);
5596                             SKIP;
5597                         } else {
5598                             /* could be some special code */
5599                             (*oconv)(0, ESC);
5600                             (*oconv)(0, '$');
5601                             (*oconv)(0, '(');
5602                             (*oconv)(0, c1);
5603                             SKIP;
5604                         }
5605                     } else if (broken_f&0x2) {
5606                         /* accept any ESC-(-x as broken code ... */
5607                         input_mode = JIS_X_0208;
5608                         shift_mode = 0;
5609                         SKIP;
5610                     } else {
5611                         (*oconv)(0, ESC);
5612                         (*oconv)(0, '$');
5613                         (*oconv)(0, c1);
5614                         SKIP;
5615                     }
5616                 } else if (c1 == '(') {
5617                     /* GZD4 */
5618                     if ((c1 = (*i_getc)(f)) == EOF) {
5619                         /* don't send bogus code
5620                            (*oconv)(0, ESC);
5621                            (*oconv)(0, '('); */
5622                         LAST;
5623                     }
5624                     else if (c1 == 'I') {
5625                         /* JIS X 0201 Katakana */
5626                         set_input_mode(JIS_X_0201_1976_K);
5627                         SKIP;
5628                     }
5629                     else if (c1 == 'B' || c1 == 'J' || c1 == 'H') {
5630                         /* ISO-646IRV:1983 or JIS X 0201 Roman or JUNET */
5631                         set_input_mode(ASCII);
5632                         SKIP;
5633                     }
5634                     else if (broken_f&0x2) {
5635                         set_input_mode(ASCII);
5636                         SKIP;
5637                     }
5638                     else {
5639                         (*oconv)(0, ESC);
5640                         (*oconv)(0, '(');
5641                         SEND;
5642                     }
5643                 }
5644                 else if (c1 == '.') {
5645                     /* G2D6 */
5646                     if ((c1 = (*i_getc)(f)) == EOF) {
5647                         LAST;
5648                     }
5649                     else if (c1 == 'A') {
5650                         /* ISO-8859-1 */
5651                         g2 = ISO_8859_1;
5652                         SKIP;
5653                     }
5654                     else {
5655                         (*oconv)(0, ESC);
5656                         (*oconv)(0, '.');
5657                         SEND;
5658                     }
5659                 }
5660                 else if (c1 == 'N') {
5661                     /* SS2 */
5662                     c1 = (*i_getc)(f);
5663                     if (g2 == ISO_8859_1) {
5664                         c2 = ISO_8859_1;
5665                         SEND;
5666                     }else{
5667                         (*i_ungetc)(c1, f);
5668                         /* lonely ESC  */
5669                         (*oconv)(0, ESC);
5670                         SEND;
5671                     }
5672                 }
5673                 else {
5674                     /* lonely ESC  */
5675                     (*oconv)(0, ESC);
5676                     SEND;
5677                 }
5678             } else if (c1 == ESC && iconv == s_iconv) {
5679                 /* ESC in Shift_JIS */
5680                 if ((c1 = (*i_getc)(f)) == EOF) {
5681                     (*oconv)(0, ESC);
5682                     LAST;
5683                 } else if (c1 == '$') {
5684                     /* J-PHONE emoji */
5685                     if ((c1 = (*i_getc)(f)) == EOF) {
5686                         LAST;
5687                     } else if (('E' <= c1 && c1 <= 'G') ||
5688                                ('O' <= c1 && c1 <= 'Q')) {
5689                         /*
5690                            NUM : 0 1 2 3 4 5
5691                            BYTE: G E F O P Q
5692                            C%7 : 1 6 0 2 3 4
5693                            C%7 : 0 1 2 3 4 5 6
5694                            NUM : 2 0 3 4 5 X 1
5695                          */
5696                         static const nkf_char jphone_emoji_first_table[7] =
5697                         {0xE1E0, 0xDFE0, 0xE2E0, 0xE3E0, 0xE4E0, 0xDFE0, 0xE0E0};
5698                         c3 = nkf_char_unicode_new(jphone_emoji_first_table[c1 % 7]);
5699                         if ((c1 = (*i_getc)(f)) == EOF) LAST;
5700                         while (SP <= c1 && c1 <= 'z') {
5701                             (*oconv)(0, c1 + c3);
5702                             if ((c1 = (*i_getc)(f)) == EOF) LAST;
5703                         }
5704                         SKIP;
5705                     }
5706                     else {
5707                         (*oconv)(0, ESC);
5708                         (*oconv)(0, '$');
5709                         SEND;
5710                     }
5711                 }
5712                 else {
5713                     /* lonely ESC  */
5714                     (*oconv)(0, ESC);
5715                     SEND;
5716                 }
5717             } else if (c1 == LF || c1 == CR) {
5718                 if (broken_f&4) {
5719                     input_mode = ASCII; set_iconv(FALSE, 0);
5720                     SEND;
5721                 } else if (mime_decode_f && !mime_decode_mode){
5722                     if (c1 == LF) {
5723                         if ((c1=(*i_getc)(f))!=EOF && c1 == SP) {
5724                             i_ungetc(SP,f);
5725                             continue;
5726                         } else {
5727                             i_ungetc(c1,f);
5728                         }
5729                         c1 = LF;
5730                         SEND;
5731                     } else  { /* if (c1 == CR)*/
5732                         if ((c1=(*i_getc)(f))!=EOF) {
5733                             if (c1==SP) {
5734                                 i_ungetc(SP,f);
5735                                 continue;
5736                             } else if (c1 == LF && (c1=(*i_getc)(f))!=EOF && c1 == SP) {
5737                                 i_ungetc(SP,f);
5738                                 continue;
5739                             } else {
5740                                 i_ungetc(c1,f);
5741                             }
5742                             i_ungetc(LF,f);
5743                         } else {
5744                             i_ungetc(c1,f);
5745                         }
5746                         c1 = CR;
5747                         SEND;
5748                     }
5749                 }
5750             } else
5751                 SEND;
5752         }
5753         /* send: */
5754         switch(input_mode){
5755         case ASCII:
5756             switch ((*iconv)(c2, c1, 0)) {  /* can be EUC / SJIS / UTF-8 */
5757             case -2:
5758                 /* 4 bytes UTF-8 */
5759                 if ((c3 = (*i_getc)(f)) != EOF) {
5760                     code_status(c3);
5761                     c3 <<= 8;
5762                     if ((c4 = (*i_getc)(f)) != EOF) {
5763                         code_status(c4);
5764                         (*iconv)(c2, c1, c3|c4);
5765                     }
5766                 }
5767                 break;
5768             case -1:
5769                 /* 3 bytes EUC or UTF-8 */
5770                 if ((c3 = (*i_getc)(f)) != EOF) {
5771                     code_status(c3);
5772                     (*iconv)(c2, c1, c3);
5773                 }
5774                 break;
5775             }
5776             break;
5777         case JIS_X_0208:
5778         case JIS_X_0213_1:
5779             if (ms_ucs_map_f &&
5780                 0x7F <= c2 && c2 <= 0x92 &&
5781                 0x21 <= c1 && c1 <= 0x7E) {
5782                 /* CP932 UDC */
5783                 c1 = nkf_char_unicode_new((c2 - 0x7F) * 94 + c1 - 0x21 + 0xE000);
5784                 c2 = 0;
5785             }
5786             (*oconv)(c2, c1); /* this is JIS, not SJIS/EUC case */
5787             break;
5788 #ifdef X0212_ENABLE
5789         case JIS_X_0212:
5790             (*oconv)(PREFIX_EUCG3 | c2, c1);
5791             break;
5792 #endif /* X0212_ENABLE */
5793         case JIS_X_0213_2:
5794             (*oconv)(PREFIX_EUCG3 | c2, c1);
5795             break;
5796         default:
5797             (*oconv)(input_mode, c1);  /* other special case */
5798         }
5799
5800         c2 = 0;
5801         c3 = 0;
5802         continue;
5803         /* goto next_word */
5804     }
5805
5806 finished:
5807     /* epilogue */
5808     (*iconv)(EOF, 0, 0);
5809     if (!input_codename)
5810     {
5811         if (is_8bit) {
5812             struct input_code *p = input_code_list;
5813             struct input_code *result = p;
5814             while (p->name){
5815                 if (p->score < result->score) result = p;
5816                 ++p;
5817             }
5818             set_input_codename(result->name);
5819 #ifdef CHECK_OPTION
5820             debug(result->name);
5821 #endif
5822         }
5823     }
5824     return 0;
5825 }
5826
5827 /*
5828  * int options(unsigned char *cp)
5829  *
5830  * return values:
5831  *    0: success
5832  *   -1: ArgumentError
5833  */
5834 static int
5835 options(unsigned char *cp)
5836 {
5837     nkf_char i, j;
5838     unsigned char *p;
5839     unsigned char *cp_back = NULL;
5840     nkf_encoding *enc;
5841
5842     if (option_mode==1)
5843         return 0;
5844     while(*cp && *cp++!='-');
5845     while (*cp || cp_back) {
5846         if(!*cp){
5847             cp = cp_back;
5848             cp_back = NULL;
5849             continue;
5850         }
5851         p = 0;
5852         switch (*cp++) {
5853         case '-':  /* literal options */
5854             if (!*cp || *cp == SP) {        /* ignore the rest of arguments */
5855                 option_mode = 1;
5856                 return 0;
5857             }
5858             for (i=0;i<sizeof(long_option)/sizeof(long_option[0]);i++) {
5859                 p = (unsigned char *)long_option[i].name;
5860                 for (j=0;*p && *p != '=' && *p == cp[j];p++, j++);
5861                 if (*p == cp[j] || cp[j] == SP){
5862                     p = &cp[j] + 1;
5863                     break;
5864                 }
5865                 p = 0;
5866             }
5867             if (p == 0) {
5868 #if !defined(PERL_XS) && !defined(WIN32DLL)
5869                 fprintf(stderr, "unknown long option: --%s\n", cp);
5870 #endif
5871                 return -1;
5872             }
5873             while(*cp && *cp != SP && cp++);
5874             if (long_option[i].alias[0]){
5875                 cp_back = cp;
5876                 cp = (unsigned char *)long_option[i].alias;
5877             }else{
5878 #ifndef PERL_XS
5879                 if (strcmp(long_option[i].name, "help") == 0){
5880                     usage();
5881                     exit(EXIT_SUCCESS);
5882                 }
5883 #endif
5884                 if (strcmp(long_option[i].name, "ic=") == 0){
5885                     enc = nkf_enc_find((char *)p);
5886                     if (!enc) continue;
5887                     input_encoding = enc;
5888                     continue;
5889                 }
5890                 if (strcmp(long_option[i].name, "oc=") == 0){
5891                     enc = nkf_enc_find((char *)p);
5892                     /* if (enc <= 0) continue; */
5893                     if (!enc) continue;
5894                     output_encoding = enc;
5895                     continue;
5896                 }
5897                 if (strcmp(long_option[i].name, "guess=") == 0){
5898                     if (p[0] == '0' || p[0] == '1') {
5899                         guess_f = 1;
5900                     } else {
5901                         guess_f = 2;
5902                     }
5903                     continue;
5904                 }
5905 #ifdef OVERWRITE
5906                 if (strcmp(long_option[i].name, "overwrite") == 0){
5907                     file_out_f = TRUE;
5908                     overwrite_f = TRUE;
5909                     preserve_time_f = TRUE;
5910                     continue;
5911                 }
5912                 if (strcmp(long_option[i].name, "overwrite=") == 0){
5913                     file_out_f = TRUE;
5914                     overwrite_f = TRUE;
5915                     preserve_time_f = TRUE;
5916                     backup_f = TRUE;
5917                     backup_suffix = (char *)p;
5918                     continue;
5919                 }
5920                 if (strcmp(long_option[i].name, "in-place") == 0){
5921                     file_out_f = TRUE;
5922                     overwrite_f = TRUE;
5923                     preserve_time_f = FALSE;
5924                     continue;
5925                 }
5926                 if (strcmp(long_option[i].name, "in-place=") == 0){
5927                     file_out_f = TRUE;
5928                     overwrite_f = TRUE;
5929                     preserve_time_f = FALSE;
5930                     backup_f = TRUE;
5931                     backup_suffix = (char *)p;
5932                     continue;
5933                 }
5934 #endif
5935 #ifdef INPUT_OPTION
5936                 if (strcmp(long_option[i].name, "cap-input") == 0){
5937                     cap_f = TRUE;
5938                     continue;
5939                 }
5940                 if (strcmp(long_option[i].name, "url-input") == 0){
5941                     url_f = TRUE;
5942                     continue;
5943                 }
5944 #endif
5945 #ifdef NUMCHAR_OPTION
5946                 if (strcmp(long_option[i].name, "numchar-input") == 0){
5947                     numchar_f = TRUE;
5948                     continue;
5949                 }
5950 #endif
5951 #ifdef CHECK_OPTION
5952                 if (strcmp(long_option[i].name, "no-output") == 0){
5953                     noout_f = TRUE;
5954                     continue;
5955                 }
5956                 if (strcmp(long_option[i].name, "debug") == 0){
5957                     debug_f = TRUE;
5958                     continue;
5959                 }
5960 #endif
5961                 if (strcmp(long_option[i].name, "cp932") == 0){
5962 #ifdef SHIFTJIS_CP932
5963                     cp51932_f = TRUE;
5964                     cp932inv_f = -TRUE;
5965 #endif
5966 #ifdef UTF8_OUTPUT_ENABLE
5967                     ms_ucs_map_f = UCS_MAP_CP932;
5968 #endif
5969                     continue;
5970                 }
5971                 if (strcmp(long_option[i].name, "no-cp932") == 0){
5972 #ifdef SHIFTJIS_CP932
5973                     cp51932_f = FALSE;
5974                     cp932inv_f = FALSE;
5975 #endif
5976 #ifdef UTF8_OUTPUT_ENABLE
5977                     ms_ucs_map_f = UCS_MAP_ASCII;
5978 #endif
5979                     continue;
5980                 }
5981 #ifdef SHIFTJIS_CP932
5982                 if (strcmp(long_option[i].name, "cp932inv") == 0){
5983                     cp932inv_f = -TRUE;
5984                     continue;
5985                 }
5986 #endif
5987
5988 #ifdef X0212_ENABLE
5989                 if (strcmp(long_option[i].name, "x0212") == 0){
5990                     x0212_f = TRUE;
5991                     continue;
5992                 }
5993 #endif
5994
5995 #ifdef EXEC_IO
5996                 if (strcmp(long_option[i].name, "exec-in") == 0){
5997                     exec_f = 1;
5998                     return 0;
5999                 }
6000                 if (strcmp(long_option[i].name, "exec-out") == 0){
6001                     exec_f = -1;
6002                     return 0;
6003                 }
6004 #endif
6005 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
6006                 if (strcmp(long_option[i].name, "no-cp932ext") == 0){
6007                     no_cp932ext_f = TRUE;
6008                     continue;
6009                 }
6010                 if (strcmp(long_option[i].name, "no-best-fit-chars") == 0){
6011                     no_best_fit_chars_f = TRUE;
6012                     continue;
6013                 }
6014                 if (strcmp(long_option[i].name, "fb-skip") == 0){
6015                     encode_fallback = NULL;
6016                     continue;
6017                 }
6018                 if (strcmp(long_option[i].name, "fb-html") == 0){
6019                     encode_fallback = encode_fallback_html;
6020                     continue;
6021                 }
6022                 if (strcmp(long_option[i].name, "fb-xml") == 0){
6023                     encode_fallback = encode_fallback_xml;
6024                     continue;
6025                 }
6026                 if (strcmp(long_option[i].name, "fb-java") == 0){
6027                     encode_fallback = encode_fallback_java;
6028                     continue;
6029                 }
6030                 if (strcmp(long_option[i].name, "fb-perl") == 0){
6031                     encode_fallback = encode_fallback_perl;
6032                     continue;
6033                 }
6034                 if (strcmp(long_option[i].name, "fb-subchar") == 0){
6035                     encode_fallback = encode_fallback_subchar;
6036                     continue;
6037                 }
6038                 if (strcmp(long_option[i].name, "fb-subchar=") == 0){
6039                     encode_fallback = encode_fallback_subchar;
6040                     unicode_subchar = 0;
6041                     if (p[0] != '0'){
6042                         /* decimal number */
6043                         for (i = 0; i < 7 && nkf_isdigit(p[i]); i++){
6044                             unicode_subchar *= 10;
6045                             unicode_subchar += hex2bin(p[i]);
6046                         }
6047                     }else if(p[1] == 'x' || p[1] == 'X'){
6048                         /* hexadecimal number */
6049                         for (i = 2; i < 8 && nkf_isxdigit(p[i]); i++){
6050                             unicode_subchar <<= 4;
6051                             unicode_subchar |= hex2bin(p[i]);
6052                         }
6053                     }else{
6054                         /* octal number */
6055                         for (i = 1; i < 8 && nkf_isoctal(p[i]); i++){
6056                             unicode_subchar *= 8;
6057                             unicode_subchar += hex2bin(p[i]);
6058                         }
6059                     }
6060                     w16e_conv(unicode_subchar, &i, &j);
6061                     unicode_subchar = i<<8 | j;
6062                     continue;
6063                 }
6064 #endif
6065 #ifdef UTF8_OUTPUT_ENABLE
6066                 if (strcmp(long_option[i].name, "ms-ucs-map") == 0){
6067                     ms_ucs_map_f = UCS_MAP_MS;
6068                     continue;
6069                 }
6070 #endif
6071 #ifdef UNICODE_NORMALIZATION
6072                 if (strcmp(long_option[i].name, "utf8mac-input") == 0){
6073                     nfc_f = TRUE;
6074                     continue;
6075                 }
6076 #endif
6077                 if (strcmp(long_option[i].name, "prefix=") == 0){
6078                     if (nkf_isgraph(p[0])){
6079                         for (i = 1; nkf_isgraph(p[i]); i++){
6080                             prefix_table[p[i]] = p[0];
6081                         }
6082                     }
6083                     continue;
6084                 }
6085 #if !defined(PERL_XS) && !defined(WIN32DLL)
6086                 fprintf(stderr, "unsupported long option: --%s\n", long_option[i].name);
6087 #endif
6088                 return -1;
6089             }
6090             continue;
6091         case 'b':           /* buffered mode */
6092             unbuf_f = FALSE;
6093             continue;
6094         case 'u':           /* non bufferd mode */
6095             unbuf_f = TRUE;
6096             continue;
6097         case 't':           /* transparent mode */
6098             if (*cp=='1') {
6099                 /* alias of -t */
6100                 cp++;
6101                 nop_f = TRUE;
6102             } else if (*cp=='2') {
6103                 /*
6104                  * -t with put/get
6105                  *
6106                  * nkf -t2MB hoge.bin | nkf -t2mB | diff -s - hoge.bin
6107                  *
6108                  */
6109                 cp++;
6110                 nop_f = 2;
6111             } else
6112                 nop_f = TRUE;
6113             continue;
6114         case 'j':           /* JIS output */
6115         case 'n':
6116             output_encoding = nkf_enc_from_index(ISO_2022_JP);
6117             continue;
6118         case 'e':           /* AT&T EUC output */
6119             output_encoding = nkf_enc_from_index(EUCJP_NKF);
6120             continue;
6121         case 's':           /* SJIS output */
6122             output_encoding = nkf_enc_from_index(SHIFT_JIS);
6123             continue;
6124         case 'l':           /* ISO8859 Latin-1 support, no conversion */
6125             iso8859_f = TRUE;  /* Only compatible with ISO-2022-JP */
6126             input_encoding = nkf_enc_from_index(ISO_8859_1);
6127             continue;
6128         case 'i':           /* Kanji IN ESC-$-@/B */
6129             if (*cp=='@'||*cp=='B')
6130                 kanji_intro = *cp++;
6131             continue;
6132         case 'o':           /* ASCII IN ESC-(-J/B/H */
6133             /* ESC ( H was used in initial JUNET messages */
6134             if (*cp=='J'||*cp=='B'||*cp=='H')
6135                 ascii_intro = *cp++;
6136             continue;
6137         case 'h':
6138             /*
6139                bit:1   katakana->hiragana
6140                bit:2   hiragana->katakana
6141              */
6142             if ('9'>= *cp && *cp>='0')
6143                 hira_f |= (*cp++ -'0');
6144             else
6145                 hira_f |= 1;
6146             continue;
6147         case 'r':
6148             rot_f = TRUE;
6149             continue;
6150 #if defined(MSDOS) || defined(__OS2__)
6151         case 'T':
6152             binmode_f = FALSE;
6153             continue;
6154 #endif
6155 #ifndef PERL_XS
6156         case 'V':
6157             show_configuration();
6158             exit(EXIT_SUCCESS);
6159             break;
6160         case 'v':
6161             version();
6162             exit(EXIT_SUCCESS);
6163             break;
6164 #endif
6165 #ifdef UTF8_OUTPUT_ENABLE
6166         case 'w':           /* UTF-8 output */
6167             if (cp[0] == '8') {
6168                 cp++;
6169                 if (cp[0] == '0'){
6170                     cp++;
6171                     output_encoding = nkf_enc_from_index(UTF_8N);
6172                 } else {
6173                     output_bom_f = TRUE;
6174                     output_encoding = nkf_enc_from_index(UTF_8_BOM);
6175                 }
6176             } else {
6177                 int enc_idx;
6178                 if ('1'== cp[0] && '6'==cp[1]) {
6179                     cp += 2;
6180                     enc_idx = UTF_16;
6181                 } else if ('3'== cp[0] && '2'==cp[1]) {
6182                     cp += 2;
6183                     enc_idx = UTF_32;
6184                 } else {
6185                     output_encoding = nkf_enc_from_index(UTF_8);
6186                     continue;
6187                 }
6188                 if (cp[0]=='L') {
6189                     cp++;
6190                     output_endian = ENDIAN_LITTLE;
6191                 } else if (cp[0] == 'B') {
6192                     cp++;
6193                 }
6194                 if (cp[0] == '0'){
6195                     cp++;
6196                     enc_idx = enc_idx == UTF_16
6197                         ? (output_endian == ENDIAN_LITTLE ? UTF_16LE : UTF_16BE)
6198                         : (output_endian == ENDIAN_LITTLE ? UTF_32LE : UTF_32BE);
6199                 } else {
6200                     output_bom_f = TRUE;
6201                     enc_idx = enc_idx == UTF_16
6202                         ? (output_endian == ENDIAN_LITTLE ? UTF_16LE_BOM : UTF_16BE_BOM)
6203                         : (output_endian == ENDIAN_LITTLE ? UTF_32LE_BOM : UTF_32BE_BOM);
6204                 }
6205                 output_encoding = nkf_enc_from_index(enc_idx);
6206             }
6207             continue;
6208 #endif
6209 #ifdef UTF8_INPUT_ENABLE
6210         case 'W':           /* UTF input */
6211             if (cp[0] == '8') {
6212                 cp++;
6213                 input_encoding = nkf_enc_from_index(UTF_8);
6214             }else{
6215                 int enc_idx;
6216                 if ('1'== cp[0] && '6'==cp[1]) {
6217                     cp += 2;
6218                     input_endian = ENDIAN_BIG;
6219                     enc_idx = UTF_16;
6220                 } else if ('3'== cp[0] && '2'==cp[1]) {
6221                     cp += 2;
6222                     input_endian = ENDIAN_BIG;
6223                     enc_idx = UTF_32;
6224                 } else {
6225                     input_encoding = nkf_enc_from_index(UTF_8);
6226                     continue;
6227                 }
6228                 if (cp[0]=='L') {
6229                     cp++;
6230                     input_endian = ENDIAN_LITTLE;
6231                 } else if (cp[0] == 'B') {
6232                     cp++;
6233                     input_endian = ENDIAN_BIG;
6234                 }
6235                 enc_idx = (enc_idx == UTF_16
6236                     ? (input_endian == ENDIAN_LITTLE ? UTF_16LE : UTF_16BE)
6237                     : (input_endian == ENDIAN_LITTLE ? UTF_32LE : UTF_32BE));
6238                 input_encoding = nkf_enc_from_index(enc_idx);
6239             }
6240             continue;
6241 #endif
6242             /* Input code assumption */
6243         case 'J':   /* ISO-2022-JP input */
6244             input_encoding = nkf_enc_from_index(ISO_2022_JP);
6245             continue;
6246         case 'E':   /* EUC-JP input */
6247             input_encoding = nkf_enc_from_index(EUCJP_NKF);
6248             continue;
6249         case 'S':   /* Shift_JIS input */
6250             input_encoding = nkf_enc_from_index(SHIFT_JIS);
6251             continue;
6252         case 'Z':   /* Convert X0208 alphabet to asii */
6253             /* alpha_f
6254                bit:0   Convert JIS X 0208 Alphabet to ASCII
6255                bit:1   Convert Kankaku to one space
6256                bit:2   Convert Kankaku to two spaces
6257                bit:3   Convert HTML Entity
6258                bit:4   Convert JIS X 0208 Katakana to JIS X 0201 Katakana
6259              */
6260             while ('0'<= *cp && *cp <='4') {
6261                 alpha_f |= 1 << (*cp++ - '0');
6262             }
6263             alpha_f |= 1;
6264             continue;
6265         case 'x':   /* Convert X0201 kana to X0208 or X0201 Conversion */
6266             x0201_f = FALSE;    /* No X0201->X0208 conversion */
6267             /* accept  X0201
6268                ESC-(-I     in JIS, EUC, MS Kanji
6269                SI/SO       in JIS, EUC, MS Kanji
6270                SS2         in EUC, JIS, not in MS Kanji
6271                MS Kanji (0xa0-0xdf)
6272                output  X0201
6273                ESC-(-I     in JIS (0x20-0x5f)
6274                SS2         in EUC (0xa0-0xdf)
6275                0xa0-0xd    in MS Kanji (0xa0-0xdf)
6276              */
6277             continue;
6278         case 'X':   /* Convert X0201 kana to X0208 */
6279             x0201_f = TRUE;
6280             continue;
6281         case 'F':   /* prserve new lines */
6282             fold_preserve_f = TRUE;
6283         case 'f':   /* folding -f60 or -f */
6284             fold_f = TRUE;
6285             fold_len = 0;
6286             while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
6287                 fold_len *= 10;
6288                 fold_len += *cp++ - '0';
6289             }
6290             if (!(0<fold_len && fold_len<BUFSIZ))
6291                 fold_len = DEFAULT_FOLD;
6292             if (*cp=='-') {
6293                 fold_margin = 0;
6294                 cp++;
6295                 while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
6296                     fold_margin *= 10;
6297                     fold_margin += *cp++ - '0';
6298                 }
6299             }
6300             continue;
6301         case 'm':   /* MIME support */
6302             /* mime_decode_f = TRUE; */ /* this has too large side effects... */
6303             if (*cp=='B'||*cp=='Q') {
6304                 mime_decode_mode = *cp++;
6305                 mimebuf_f = FIXED_MIME;
6306             } else if (*cp=='N') {
6307                 mime_f = TRUE; cp++;
6308             } else if (*cp=='S') {
6309                 mime_f = STRICT_MIME; cp++;
6310             } else if (*cp=='0') {
6311                 mime_decode_f = FALSE;
6312                 mime_f = FALSE; cp++;
6313             } else {
6314                 mime_f = STRICT_MIME;
6315             }
6316             continue;
6317         case 'M':   /* MIME output */
6318             if (*cp=='B') {
6319                 mimeout_mode = 'B';
6320                 mimeout_f = FIXED_MIME; cp++;
6321             } else if (*cp=='Q') {
6322                 mimeout_mode = 'Q';
6323                 mimeout_f = FIXED_MIME; cp++;
6324             } else {
6325                 mimeout_f = TRUE;
6326             }
6327             continue;
6328         case 'B':   /* Broken JIS support */
6329             /*  bit:0   no ESC JIS
6330                bit:1   allow any x on ESC-(-x or ESC-$-x
6331                bit:2   reset to ascii on NL
6332              */
6333             if ('9'>= *cp && *cp>='0')
6334                 broken_f |= 1<<(*cp++ -'0');
6335             else
6336                 broken_f |= TRUE;
6337             continue;
6338 #ifndef PERL_XS
6339         case 'O':/* for Output file */
6340             file_out_f = TRUE;
6341             continue;
6342 #endif
6343         case 'c':/* add cr code */
6344             eolmode_f = CRLF;
6345             continue;
6346         case 'd':/* delete cr code */
6347             eolmode_f = LF;
6348             continue;
6349         case 'I':   /* ISO-2022-JP output */
6350             iso2022jp_f = TRUE;
6351             continue;
6352         case 'L':  /* line mode */
6353             if (*cp=='u') {         /* unix */
6354                 eolmode_f = LF; cp++;
6355             } else if (*cp=='m') { /* mac */
6356                 eolmode_f = CR; cp++;
6357             } else if (*cp=='w') { /* windows */
6358                 eolmode_f = CRLF; cp++;
6359             } else if (*cp=='0') { /* no conversion  */
6360                 eolmode_f = 0; cp++;
6361             }
6362             continue;
6363 #ifndef PERL_XS
6364         case 'g':
6365             if ('2' <= *cp && *cp <= '9') {
6366                 guess_f = 2;
6367                 cp++;
6368             } else if (*cp == '0' || *cp == '1') {
6369                 guess_f = 1;
6370                 cp++;
6371             } else {
6372                 guess_f = 1;
6373             }
6374             continue;
6375 #endif
6376         case SP:
6377             /* module muliple options in a string are allowed for Perl moudle  */
6378             while(*cp && *cp++!='-');
6379             continue;
6380         default:
6381 #if !defined(PERL_XS) && !defined(WIN32DLL)
6382             fprintf(stderr, "unknown option: -%c\n", *(cp-1));
6383 #endif
6384             /* bogus option but ignored */
6385             return -1;
6386         }
6387     }
6388     return 0;
6389 }
6390
6391 #ifdef WIN32DLL
6392 #include "nkf32dll.c"
6393 #elif defined(PERL_XS)
6394 #else /* WIN32DLL */
6395 int
6396 main(int argc, char **argv)
6397 {
6398     FILE  *fin;
6399     unsigned char  *cp;
6400
6401     char *outfname = NULL;
6402     char *origfname;
6403
6404 #ifdef EASYWIN /*Easy Win */
6405     _BufferSize.y = 400;/*Set Scroll Buffer Size*/
6406 #endif
6407 #ifdef DEFAULT_CODE_LOCALE
6408     setlocale(LC_CTYPE, "");
6409 #endif
6410     nkf_state_init();
6411
6412     for (argc--,argv++; (argc > 0) && **argv == '-'; argc--, argv++) {
6413         cp = (unsigned char *)*argv;
6414         options(cp);
6415 #ifdef EXEC_IO
6416         if (exec_f){
6417             int fds[2], pid;
6418             if (pipe(fds) < 0 || (pid = fork()) < 0){
6419                 abort();
6420             }
6421             if (pid == 0){
6422                 if (exec_f > 0){
6423                     close(fds[0]);
6424                     dup2(fds[1], 1);
6425                 }else{
6426                     close(fds[1]);
6427                     dup2(fds[0], 0);
6428                 }
6429                 execvp(argv[1], &argv[1]);
6430             }
6431             if (exec_f > 0){
6432                 close(fds[1]);
6433                 dup2(fds[0], 0);
6434             }else{
6435                 close(fds[0]);
6436                 dup2(fds[1], 1);
6437             }
6438             argc = 0;
6439             break;
6440         }
6441 #endif
6442     }
6443
6444     if (guess_f) {
6445 #ifdef CHECK_OPTION
6446         int debug_f_back = debug_f;
6447 #endif
6448 #ifdef EXEC_IO
6449         int exec_f_back = exec_f;
6450 #endif
6451 #ifdef X0212_ENABLE
6452         int x0212_f_back = x0212_f;
6453 #endif
6454         int x0213_f_back = x0213_f;
6455         int guess_f_back = guess_f;
6456         reinit();
6457         guess_f = guess_f_back;
6458         mime_f = FALSE;
6459 #ifdef CHECK_OPTION
6460         debug_f = debug_f_back;
6461 #endif
6462 #ifdef EXEC_IO
6463         exec_f = exec_f_back;
6464 #endif
6465         x0212_f = x0212_f_back;
6466         x0213_f = x0213_f_back;
6467     }
6468
6469     if (binmode_f == TRUE)
6470 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6471         if (freopen("","wb",stdout) == NULL)
6472             return (-1);
6473 #else
6474     setbinmode(stdout);
6475 #endif
6476
6477     if (unbuf_f)
6478         setbuf(stdout, (char *) NULL);
6479     else
6480         setvbuffer(stdout, (char *) stdobuf, IOBUF_SIZE);
6481
6482     if (argc == 0) {
6483         if (binmode_f == TRUE)
6484 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6485             if (freopen("","rb",stdin) == NULL) return (-1);
6486 #else
6487         setbinmode(stdin);
6488 #endif
6489         setvbuffer(stdin, (char *) stdibuf, IOBUF_SIZE);
6490         if (nop_f)
6491             noconvert(stdin);
6492         else {
6493             kanji_convert(stdin);
6494             if (guess_f) print_guessed_code(NULL);
6495         }
6496     } else {
6497         int nfiles = argc;
6498         int is_argument_error = FALSE;
6499         while (argc--) {
6500             input_codename = NULL;
6501             input_eol = 0;
6502 #ifdef CHECK_OPTION
6503             iconv_for_check = 0;
6504 #endif
6505             if ((fin = fopen((origfname = *argv++), "r")) == NULL) {
6506                 perror(*(argv-1));
6507                 is_argument_error = TRUE;
6508                 continue;
6509             } else {
6510 #ifdef OVERWRITE
6511                 int fd = 0;
6512                 int fd_backup = 0;
6513 #endif
6514
6515                 /* reopen file for stdout */
6516                 if (file_out_f == TRUE) {
6517 #ifdef OVERWRITE
6518                     if (overwrite_f){
6519                         outfname = nkf_xmalloc(strlen(origfname)
6520                                           + strlen(".nkftmpXXXXXX")
6521                                           + 1);
6522                         strcpy(outfname, origfname);
6523 #ifdef MSDOS
6524                         {
6525                             int i;
6526                             for (i = strlen(outfname); i; --i){
6527                                 if (outfname[i - 1] == '/'
6528                                     || outfname[i - 1] == '\\'){
6529                                     break;
6530                                 }
6531                             }
6532                             outfname[i] = '\0';
6533                         }
6534                         strcat(outfname, "ntXXXXXX");
6535                         mktemp(outfname);
6536                         fd = open(outfname, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
6537                                   S_IREAD | S_IWRITE);
6538 #else
6539                         strcat(outfname, ".nkftmpXXXXXX");
6540                         fd = mkstemp(outfname);
6541 #endif
6542                         if (fd < 0
6543                             || (fd_backup = dup(fileno(stdout))) < 0
6544                             || dup2(fd, fileno(stdout)) < 0
6545                            ){
6546                             perror(origfname);
6547                             return -1;
6548                         }
6549                     }else
6550 #endif
6551                     if(argc == 1) {
6552                         outfname = *argv++;
6553                         argc--;
6554                     } else {
6555                         outfname = "nkf.out";
6556                     }
6557
6558                     if(freopen(outfname, "w", stdout) == NULL) {
6559                         perror (outfname);
6560                         return (-1);
6561                     }
6562                     if (binmode_f == TRUE) {
6563 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6564                         if (freopen("","wb",stdout) == NULL)
6565                             return (-1);
6566 #else
6567                         setbinmode(stdout);
6568 #endif
6569                     }
6570                 }
6571                 if (binmode_f == TRUE)
6572 #if defined(__OS2__) && (defined(__IBMC__) || defined(__IBMCPP__))
6573                     if (freopen("","rb",fin) == NULL)
6574                         return (-1);
6575 #else
6576                 setbinmode(fin);
6577 #endif
6578                 setvbuffer(fin, (char *) stdibuf, IOBUF_SIZE);
6579                 if (nop_f)
6580                     noconvert(fin);
6581                 else {
6582                     char *filename = NULL;
6583                     kanji_convert(fin);
6584                     if (nfiles > 1) filename = origfname;
6585                     if (guess_f) print_guessed_code(filename);
6586                 }
6587                 fclose(fin);
6588 #ifdef OVERWRITE
6589                 if (overwrite_f) {
6590                     struct stat     sb;
6591 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__) && !defined(__WATCOMC__) && !defined(__EMX__) && !defined(__OS2__) && !defined(__DJGPP__)
6592                     time_t tb[2];
6593 #else
6594                     struct utimbuf  tb;
6595 #endif
6596
6597                     fflush(stdout);
6598                     close(fd);
6599                     if (dup2(fd_backup, fileno(stdout)) < 0){
6600                         perror("dup2");
6601                     }
6602                     if (stat(origfname, &sb)) {
6603                         fprintf(stderr, "Can't stat %s\n", origfname);
6604                     }
6605                     /* \e$B%Q!<%_%C%7%g%s$rI|85\e(B */
6606                     if (chmod(outfname, sb.st_mode)) {
6607                         fprintf(stderr, "Can't set permission %s\n", outfname);
6608                     }
6609
6610                     /* \e$B%?%$%`%9%?%s%W$rI|85\e(B */
6611                     if(preserve_time_f){
6612 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__) && !defined(__WATCOMC__) && !defined(__EMX__) && !defined(__OS2__) && !defined(__DJGPP__)
6613                         tb[0] = tb[1] = sb.st_mtime;
6614                         if (utime(outfname, tb)) {
6615                             fprintf(stderr, "Can't set timestamp %s\n", outfname);
6616                         }
6617 #else
6618                         tb.actime  = sb.st_atime;
6619                         tb.modtime = sb.st_mtime;
6620                         if (utime(outfname, &tb)) {
6621                             fprintf(stderr, "Can't set timestamp %s\n", outfname);
6622                         }
6623 #endif
6624                     }
6625                     if(backup_f){
6626                         char *backup_filename = get_backup_filename(backup_suffix, origfname);
6627 #ifdef MSDOS
6628                         unlink(backup_filename);
6629 #endif
6630                         if (rename(origfname, backup_filename)) {
6631                             perror(backup_filename);
6632                             fprintf(stderr, "Can't rename %s to %s\n",
6633                                     origfname, backup_filename);
6634                         }
6635                         nkf_xfree(backup_filename);
6636                     }else{
6637 #ifdef MSDOS
6638                         if (unlink(origfname)){
6639                             perror(origfname);
6640                         }
6641 #endif
6642                     }
6643                     if (rename(outfname, origfname)) {
6644                         perror(origfname);
6645                         fprintf(stderr, "Can't rename %s to %s\n",
6646                                 outfname, origfname);
6647                     }
6648                     nkf_xfree(outfname);
6649                 }
6650 #endif
6651             }
6652         }
6653         if (is_argument_error)
6654             return(-1);
6655     }
6656 #ifdef EASYWIN /*Easy Win */
6657     if (file_out_f == FALSE)
6658         scanf("%d",&end_check);
6659     else
6660         fclose(stdout);
6661 #else /* for Other OS */
6662     if (file_out_f == TRUE)
6663         fclose(stdout);
6664 #endif /*Easy Win */
6665     return (0);
6666 }
6667 #endif /* WIN32DLL */