OSDN Git Service

Fix: didn't follow eolmode_f on MIME encode. [nkf-forum:47807]
[nkf/nkf.git] / 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-15"
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 static void
3360 put_newline(void (*func)(nkf_char))
3361 {
3362     switch (eolmode_f ? eolmode_f : DEFAULT_NEWLINE) {
3363       case CRLF:
3364         (*func)(0x0D);
3365         (*func)(0x0A);
3366         break;
3367       case CR:
3368         (*func)(0x0D);
3369         break;
3370       case LF:
3371         (*func)(0x0A);
3372         break;
3373     }
3374 }
3375
3376 static void
3377 oconv_newline(void (*func)(nkf_char, nkf_char))
3378 {
3379     switch (eolmode_f ? eolmode_f : DEFAULT_NEWLINE) {
3380       case CRLF:
3381         (*func)(0, 0x0D);
3382         (*func)(0, 0x0A);
3383         break;
3384       case CR:
3385         (*func)(0, 0x0D);
3386         break;
3387       case LF:
3388         (*func)(0, 0x0A);
3389         break;
3390     }
3391 }
3392
3393 /*
3394    Return value of fold_conv()
3395
3396    LF  add newline  and output char
3397    CR  add newline  and output nothing
3398    SP  space
3399    0   skip
3400    1   (or else) normal output
3401
3402    fold state in prev (previous character)
3403
3404    >0x80 Japanese (X0208/X0201)
3405    <0x80 ASCII
3406    LF    new line
3407    SP    space
3408
3409    This fold algorthm does not preserve heading space in a line.
3410    This is the main difference from fmt.
3411  */
3412
3413 #define char_size(c2,c1) (c2?2:1)
3414
3415 static void
3416 fold_conv(nkf_char c2, nkf_char c1)
3417 {
3418     nkf_char prev0;
3419     nkf_char fold_state;
3420
3421     if (c1== CR && !fold_preserve_f) {
3422         fold_state=0;  /* ignore cr */
3423     }else if (c1== LF&&f_prev==CR && fold_preserve_f) {
3424         f_prev = LF;
3425         fold_state=0;  /* ignore cr */
3426     } else if (c1== BS) {
3427         if (f_line>0) f_line--;
3428         fold_state =  1;
3429     } else if (c2==EOF && f_line != 0) {    /* close open last line */
3430         fold_state = LF;
3431     } else if ((c1==LF && !fold_preserve_f)
3432                || ((c1==CR||(c1==LF&&f_prev!=CR))
3433                    && fold_preserve_f)) {
3434         /* new line */
3435         if (fold_preserve_f) {
3436             f_prev = c1;
3437             f_line = 0;
3438             fold_state =  CR;
3439         } else if ((f_prev == c1 && !fold_preserve_f)
3440                    || (f_prev == LF && fold_preserve_f)
3441                   ) {        /* duplicate newline */
3442             if (f_line) {
3443                 f_line = 0;
3444                 fold_state =  LF;    /* output two newline */
3445             } else {
3446                 f_line = 0;
3447                 fold_state =  1;
3448             }
3449         } else  {
3450             if (f_prev&0x80) {     /* Japanese? */
3451                 f_prev = c1;
3452                 fold_state =  0;       /* ignore given single newline */
3453             } else if (f_prev==SP) {
3454                 fold_state =  0;
3455             } else {
3456                 f_prev = c1;
3457                 if (++f_line<=fold_len)
3458                     fold_state =  SP;
3459                 else {
3460                     f_line = 0;
3461                     fold_state =  CR;        /* fold and output nothing */
3462                 }
3463             }
3464         }
3465     } else if (c1=='\f') {
3466         f_prev = LF;
3467         f_line = 0;
3468         fold_state =  LF;            /* output newline and clear */
3469     } else if ((c2==0 && nkf_isblank(c1)) || (c2 == '!' && c1 == '!')) {
3470         /* X0208 kankaku or ascii space */
3471         if (f_prev == SP) {
3472             fold_state = 0;         /* remove duplicate spaces */
3473         } else {
3474             f_prev = SP;
3475             if (++f_line<=fold_len)
3476                 fold_state = SP;         /* output ASCII space only */
3477             else {
3478                 f_prev = SP; f_line = 0;
3479                 fold_state = CR;        /* fold and output nothing */
3480             }
3481         }
3482     } else {
3483         prev0 = f_prev; /* we still need this one... , but almost done */
3484         f_prev = c1;
3485         if (c2 || c2 == JIS_X_0201_1976_K)
3486             f_prev |= 0x80;  /* this is Japanese */
3487         f_line += char_size(c2,c1);
3488         if (f_line<=fold_len) {   /* normal case */
3489             fold_state = 1;
3490         } else {
3491             if (f_line>fold_len+fold_margin) { /* too many kinsoku suspension */
3492                 f_line = char_size(c2,c1);
3493                 fold_state =  LF;       /* We can't wait, do fold now */
3494             } else if (c2 == JIS_X_0201_1976_K) {
3495                 /* simple kinsoku rules  return 1 means no folding  */
3496                 if (c1==(0xde&0x7f)) fold_state = 1; /* \e$B!+\e(B*/
3497                 else if (c1==(0xdf&0x7f)) fold_state = 1; /* \e$B!,\e(B*/
3498                 else if (c1==(0xa4&0x7f)) fold_state = 1; /* \e$B!#\e(B*/
3499                 else if (c1==(0xa3&0x7f)) fold_state = 1; /* \e$B!$\e(B*/
3500                 else if (c1==(0xa1&0x7f)) fold_state = 1; /* \e$B!W\e(B*/
3501                 else if (c1==(0xb0&0x7f)) fold_state = 1; /* - */
3502                 else if (SP<=c1 && c1<=(0xdf&0x7f)) {      /* X0201 */
3503                     f_line = 1;
3504                     fold_state = LF;/* add one new f_line before this character */
3505                 } else {
3506                     f_line = 1;
3507                     fold_state = LF;/* add one new f_line before this character */
3508                 }
3509             } else if (c2==0) {
3510                 /* kinsoku point in ASCII */
3511                 if (  c1==')'||    /* { [ ( */
3512                     c1==']'||
3513                     c1=='}'||
3514                     c1=='.'||
3515                     c1==','||
3516                     c1=='!'||
3517                     c1=='?'||
3518                     c1=='/'||
3519                     c1==':'||
3520                     c1==';') {
3521                     fold_state = 1;
3522                     /* just after special */
3523                 } else if (!is_alnum(prev0)) {
3524                     f_line = char_size(c2,c1);
3525                     fold_state = LF;
3526                 } else if ((prev0==SP) ||   /* ignored new f_line */
3527                            (prev0==LF)||        /* ignored new f_line */
3528                            (prev0&0x80)) {        /* X0208 - ASCII */
3529                     f_line = char_size(c2,c1);
3530                     fold_state = LF;/* add one new f_line before this character */
3531                 } else {
3532                     fold_state = 1;  /* default no fold in ASCII */
3533                 }
3534             } else {
3535                 if (c2=='!') {
3536                     if (c1=='"')  fold_state = 1; /* \e$B!"\e(B */
3537                     else if (c1=='#')  fold_state = 1; /* \e$B!#\e(B */
3538                     else if (c1=='W')  fold_state = 1; /* \e$B!W\e(B */
3539                     else if (c1=='K')  fold_state = 1; /* \e$B!K\e(B */
3540                     else if (c1=='$')  fold_state = 1; /* \e$B!$\e(B */
3541                     else if (c1=='%')  fold_state = 1; /* \e$B!%\e(B */
3542                     else if (c1=='\'') fold_state = 1; /* \e$B!\\e(B */
3543                     else if (c1=='(')  fold_state = 1; /* \e$B!(\e(B */
3544                     else if (c1==')')  fold_state = 1; /* \e$B!)\e(B */
3545                     else if (c1=='*')  fold_state = 1; /* \e$B!*\e(B */
3546                     else if (c1=='+')  fold_state = 1; /* \e$B!+\e(B */
3547                     else if (c1==',')  fold_state = 1; /* \e$B!,\e(B */
3548                     /* default no fold in kinsoku */
3549                     else {
3550                         fold_state = LF;
3551                         f_line = char_size(c2,c1);
3552                         /* add one new f_line before this character */
3553                     }
3554                 } else {
3555                     f_line = char_size(c2,c1);
3556                     fold_state = LF;
3557                     /* add one new f_line before this character */
3558                 }
3559             }
3560         }
3561     }
3562     /* terminator process */
3563     switch(fold_state) {
3564     case LF:
3565         oconv_newline(o_fconv);
3566         (*o_fconv)(c2,c1);
3567         break;
3568     case 0:
3569         return;
3570     case CR:
3571         oconv_newline(o_fconv);
3572         break;
3573     case TAB:
3574     case SP:
3575         (*o_fconv)(0,SP);
3576         break;
3577     default:
3578         (*o_fconv)(c2,c1);
3579     }
3580 }
3581
3582 static nkf_char z_prev2=0,z_prev1=0;
3583
3584 static void
3585 z_conv(nkf_char c2, nkf_char c1)
3586 {
3587
3588     /* if (c2) c1 &= 0x7f; assertion */
3589
3590     if (c2 == JIS_X_0201_1976_K && (c1 == 0x20 || c1 == 0x7D || c1 == 0x7E)) {
3591         (*o_zconv)(c2,c1);
3592         return;
3593     }
3594
3595     if (x0201_f) {
3596         if (z_prev2 == JIS_X_0201_1976_K) {
3597             if (c2 == JIS_X_0201_1976_K) {
3598                 if (c1 == (0xde&0x7f)) { /* \e$BByE@\e(B */
3599                     z_prev2 = 0;
3600                     (*o_zconv)(dv[(z_prev1-SP)*2], dv[(z_prev1-SP)*2+1]);
3601                     return;
3602                 } else if (c1 == (0xdf&0x7f) && ev[(z_prev1-SP)*2]) {  /* \e$BH>ByE@\e(B */
3603                     z_prev2 = 0;
3604                     (*o_zconv)(ev[(z_prev1-SP)*2], ev[(z_prev1-SP)*2+1]);
3605                     return;
3606                 }
3607             }
3608             z_prev2 = 0;
3609             (*o_zconv)(cv[(z_prev1-SP)*2], cv[(z_prev1-SP)*2+1]);
3610         }
3611         if (c2 == JIS_X_0201_1976_K) {
3612             if (dv[(c1-SP)*2] || ev[(c1-SP)*2]) {
3613                 /* wait for \e$BByE@\e(B or \e$BH>ByE@\e(B */
3614                 z_prev1 = c1;
3615                 z_prev2 = c2;
3616                 return;
3617             } else {
3618                 (*o_zconv)(cv[(c1-SP)*2], cv[(c1-SP)*2+1]);
3619                 return;
3620             }
3621         }
3622     }
3623
3624     if (c2 == EOF) {
3625         (*o_zconv)(c2, c1);
3626         return;
3627     }
3628
3629     if (alpha_f&1 && c2 == 0x23) {
3630         /* JISX0208 Alphabet */
3631         c2 = 0;
3632     } else if (c2 == 0x21) {
3633         /* JISX0208 Kigou */
3634         if (0x21==c1) {
3635             if (alpha_f&2) {
3636                 c2 = 0;
3637                 c1 = SP;
3638             } else if (alpha_f&4) {
3639                 (*o_zconv)(0, SP);
3640                 (*o_zconv)(0, SP);
3641                 return;
3642             }
3643         } else if (alpha_f&1 && 0x20<c1 && c1<0x7f && fv[c1-0x20]) {
3644             c2 =  0;
3645             c1 = fv[c1-0x20];
3646         }
3647     }
3648
3649     if (alpha_f&8 && c2 == 0) {
3650         /* HTML Entity */
3651         const char *entity = 0;
3652         switch (c1){
3653         case '>': entity = "&gt;"; break;
3654         case '<': entity = "&lt;"; break;
3655         case '\"': entity = "&quot;"; break;
3656         case '&': entity = "&amp;"; break;
3657         }
3658         if (entity){
3659             while (*entity) (*o_zconv)(0, *entity++);
3660             return;
3661         }
3662     }
3663
3664     if (alpha_f & 16) {
3665         /* JIS X 0208 Katakana to JIS X 0201 Katakana */
3666         if (c2 == 0x21) {
3667             nkf_char c = 0;
3668             switch (c1) {
3669             case 0x23:
3670                 /* U+3002 (0x8142) Ideographic Full Stop -> U+FF61 (0xA1) Halfwidth Ideographic Full Stop */
3671                 c = 0xA1;
3672                 break;
3673             case 0x56:
3674                 /* U+300C (0x8175) Left Corner Bracket -> U+FF62 (0xA2) Halfwidth Left Corner Bracket */
3675                 c = 0xA2;
3676                 break;
3677             case 0x57:
3678                 /* U+300D (0x8176) Right Corner Bracket -> U+FF63 (0xA3) Halfwidth Right Corner Bracket */
3679                 c = 0xA3;
3680                 break;
3681             case 0x22:
3682                 /* U+3001 (0x8141) Ideographic Comma -> U+FF64 (0xA4) Halfwidth Ideographic Comma */
3683                 c = 0xA4;
3684                 break;
3685             case 0x26:
3686                 /* U+30FB (0x8145) Katakana Middle Dot -> U+FF65 (0xA5) Halfwidth Katakana Middle Dot */
3687                 c = 0xA5;
3688                 break;
3689             case 0x3C:
3690                 /* U+30FC (0x815B) Katakana-Hiragana Prolonged Sound Mark -> U+FF70 (0xB0) Halfwidth Katakana-Hiragana Prolonged Sound Mark */
3691                 c = 0xB0;
3692                 break;
3693             case 0x2B:
3694                 /* U+309B (0x814A) Katakana-Hiragana Voiced Sound Mark -> U+FF9E (0xDE) Halfwidth Katakana Voiced Sound Mark */
3695                 c = 0xDE;
3696                 break;
3697             case 0x2C:
3698                 /* U+309C (0x814B) Katakana-Hiragana Semi-Voiced Sound Mark -> U+FF9F (0xDF) Halfwidth Katakana Semi-Voiced Sound Mark */
3699                 c = 0xDF;
3700                 break;
3701             }
3702             if (c) {
3703                 (*o_zconv)(JIS_X_0201_1976_K, c);
3704                 return;
3705             }
3706         } else if (c2 == 0x25) {
3707             /* JISX0208 Katakana */
3708             static const int fullwidth_to_halfwidth[] =
3709             {
3710                 0x0000, 0x2700, 0x3100, 0x2800, 0x3200, 0x2900, 0x3300, 0x2A00,
3711                 0x3400, 0x2B00, 0x3500, 0x3600, 0x365E, 0x3700, 0x375E, 0x3800,
3712                 0x385E, 0x3900, 0x395E, 0x3A00, 0x3A5E, 0x3B00, 0x3B5E, 0x3C00,
3713                 0x3C5E, 0x3D00, 0x3D5E, 0x3E00, 0x3E5E, 0x3F00, 0x3F5E, 0x4000,
3714                 0x405E, 0x4100, 0x415E, 0x2F00, 0x4200, 0x425E, 0x4300, 0x435E,
3715                 0x4400, 0x445E, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00,
3716                 0x4A5E, 0x4A5F, 0x4B00, 0x4B5E, 0x4B5F, 0x4C00, 0x4C5E, 0x4C5F,
3717                 0x4D00, 0x4D5E, 0x4D5F, 0x4E00, 0x4E5E, 0x4E5F, 0x4F00, 0x5000,
3718                 0x5100, 0x5200, 0x5300, 0x2C00, 0x5400, 0x2D00, 0x5500, 0x2E00,
3719                 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x0000, 0x5C00,
3720                 0x0000, 0x0000, 0x2600, 0x5D00, 0x335E, 0x0000, 0x0000, 0x0000,
3721                 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
3722             };
3723             if (fullwidth_to_halfwidth[c1-0x20]){
3724                 c2 = fullwidth_to_halfwidth[c1-0x20];
3725                 (*o_zconv)(JIS_X_0201_1976_K, c2>>8);
3726                 if (c2 & 0xFF) {
3727                     (*o_zconv)(JIS_X_0201_1976_K, c2&0xFF);
3728                 }
3729                 return;
3730             }
3731         }
3732     }
3733     (*o_zconv)(c2,c1);
3734 }
3735
3736
3737 #define rot13(c)  ( \
3738                    ( c < 'A') ? c: \
3739                    (c <= 'M')  ? (c + 13): \
3740                    (c <= 'Z')  ? (c - 13): \
3741                    (c < 'a')   ? (c): \
3742                    (c <= 'm')  ? (c + 13): \
3743                    (c <= 'z')  ? (c - 13): \
3744                    (c) \
3745                   )
3746
3747 #define  rot47(c) ( \
3748                    ( c < '!') ? c: \
3749                    ( c <= 'O') ? (c + 47) : \
3750                    ( c <= '~') ?  (c - 47) : \
3751                    c \
3752                   )
3753
3754 static void
3755 rot_conv(nkf_char c2, nkf_char c1)
3756 {
3757     if (c2 == 0 || c2 == JIS_X_0201_1976_K || c2 == ISO_8859_1) {
3758         c1 = rot13(c1);
3759     } else if (c2) {
3760         c1 = rot47(c1);
3761         c2 = rot47(c2);
3762     }
3763     (*o_rot_conv)(c2,c1);
3764 }
3765
3766 static void
3767 hira_conv(nkf_char c2, nkf_char c1)
3768 {
3769     if (hira_f & 1) {
3770         if (c2 == 0x25) {
3771             if (0x20 < c1 && c1 < 0x74) {
3772                 c2 = 0x24;
3773                 (*o_hira_conv)(c2,c1);
3774                 return;
3775             } else if (c1 == 0x74 && nkf_enc_unicode_p(output_encoding)) {
3776                 c2 = 0;
3777                 c1 = nkf_char_unicode_new(0x3094);
3778                 (*o_hira_conv)(c2,c1);
3779                 return;
3780             }
3781         } else if (c2 == 0x21 && (c1 == 0x33 || c1 == 0x34)) {
3782             c1 += 2;
3783             (*o_hira_conv)(c2,c1);
3784             return;
3785         }
3786     }
3787     if (hira_f & 2) {
3788         if (c2 == 0 && c1 == nkf_char_unicode_new(0x3094)) {
3789             c2 = 0x25;
3790             c1 = 0x74;
3791         } else if (c2 == 0x24 && 0x20 < c1 && c1 < 0x74) {
3792             c2 = 0x25;
3793         } else if (c2 == 0x21 && (c1 == 0x35 || c1 == 0x36)) {
3794             c1 -= 2;
3795         }
3796     }
3797     (*o_hira_conv)(c2,c1);
3798 }
3799
3800
3801 static void
3802 iso2022jp_check_conv(nkf_char c2, nkf_char c1)
3803 {
3804 #define RANGE_NUM_MAX 18
3805     static const nkf_char range[RANGE_NUM_MAX][2] = {
3806         {0x222f, 0x2239,},
3807         {0x2242, 0x2249,},
3808         {0x2251, 0x225b,},
3809         {0x226b, 0x2271,},
3810         {0x227a, 0x227d,},
3811         {0x2321, 0x232f,},
3812         {0x233a, 0x2340,},
3813         {0x235b, 0x2360,},
3814         {0x237b, 0x237e,},
3815         {0x2474, 0x247e,},
3816         {0x2577, 0x257e,},
3817         {0x2639, 0x2640,},
3818         {0x2659, 0x267e,},
3819         {0x2742, 0x2750,},
3820         {0x2772, 0x277e,},
3821         {0x2841, 0x287e,},
3822         {0x4f54, 0x4f7e,},
3823         {0x7425, 0x747e},
3824     };
3825     nkf_char i;
3826     nkf_char start, end, c;
3827
3828     if(c2 >= 0x00 && c2 <= 0x20 && c1 >= 0x7f && c1 <= 0xff) {
3829         c2 = GETA1;
3830         c1 = GETA2;
3831     }
3832     if((c2 >= 0x29 && c2 <= 0x2f) || (c2 >= 0x75 && c2 <= 0x7e)) {
3833         c2 = GETA1;
3834         c1 = GETA2;
3835     }
3836
3837     for (i = 0; i < RANGE_NUM_MAX; i++) {
3838         start = range[i][0];
3839         end   = range[i][1];
3840         c     = (c2 << 8) + c1;
3841         if (c >= start && c <= end) {
3842             c2 = GETA1;
3843             c1 = GETA2;
3844         }
3845     }
3846     (*o_iso2022jp_check_conv)(c2,c1);
3847 }
3848
3849
3850 /* This converts  =?ISO-2022-JP?B?HOGE HOGE?= */
3851
3852 static const unsigned char *mime_pattern[] = {
3853     (const unsigned char *)"\075?EUC-JP?B?",
3854     (const unsigned char *)"\075?SHIFT_JIS?B?",
3855     (const unsigned char *)"\075?ISO-8859-1?Q?",
3856     (const unsigned char *)"\075?ISO-8859-1?B?",
3857     (const unsigned char *)"\075?ISO-2022-JP?B?",
3858     (const unsigned char *)"\075?ISO-2022-JP?B?",
3859     (const unsigned char *)"\075?ISO-2022-JP?Q?",
3860 #if defined(UTF8_INPUT_ENABLE)
3861     (const unsigned char *)"\075?UTF-8?B?",
3862     (const unsigned char *)"\075?UTF-8?Q?",
3863 #endif
3864     (const unsigned char *)"\075?US-ASCII?Q?",
3865     NULL
3866 };
3867
3868
3869 /* \e$B3:Ev$9$k%3!<%I$NM%@hEY$r>e$2$k$?$a$NL\0u\e(B */
3870 nkf_char (*mime_priority_func[])(nkf_char c2, nkf_char c1, nkf_char c0) = {
3871     e_iconv, s_iconv, 0, 0, 0, 0,
3872 #if defined(UTF8_INPUT_ENABLE)
3873     w_iconv, w_iconv,
3874 #endif
3875     0,
3876 };
3877
3878 static const nkf_char mime_encode[] = {
3879     EUC_JP, SHIFT_JIS, ISO_8859_1, ISO_8859_1, JIS_X_0208, JIS_X_0201_1976_K, JIS_X_0201_1976_K,
3880 #if defined(UTF8_INPUT_ENABLE)
3881     UTF_8, UTF_8,
3882 #endif
3883     ASCII,
3884     0
3885 };
3886
3887 static const nkf_char mime_encode_method[] = {
3888     'B', 'B','Q', 'B', 'B', 'B', 'Q',
3889 #if defined(UTF8_INPUT_ENABLE)
3890     'B', 'Q',
3891 #endif
3892     'Q',
3893     0
3894 };
3895
3896
3897 /* MIME preprocessor fifo */
3898
3899 #define MIME_BUF_SIZE   (1024)    /* 2^n ring buffer */
3900 #define MIME_BUF_MASK   (MIME_BUF_SIZE-1)
3901 #define mime_input_buf(n)        mime_input_state.buf[(n)&MIME_BUF_MASK]
3902 static struct {
3903     unsigned char buf[MIME_BUF_SIZE];
3904     unsigned int  top;
3905     unsigned int  last;  /* decoded */
3906     unsigned int  input; /* undecoded */
3907 } mime_input_state;
3908 static nkf_char (*mime_iconv_back)(nkf_char c2,nkf_char c1,nkf_char c0) = NULL;
3909
3910 #define MAXRECOVER 20
3911
3912 static void
3913 mime_input_buf_unshift(nkf_char c)
3914 {
3915     mime_input_buf(--mime_input_state.top) = (unsigned char)c;
3916 }
3917
3918 static nkf_char
3919 mime_ungetc(nkf_char c, FILE *f)
3920 {
3921     mime_input_buf_unshift(c);
3922     return c;
3923 }
3924
3925 static nkf_char
3926 mime_ungetc_buf(nkf_char c, FILE *f)
3927 {
3928     if (mimebuf_f)
3929         (*i_mungetc_buf)(c,f);
3930     else
3931         mime_input_buf(--mime_input_state.input) = (unsigned char)c;
3932     return c;
3933 }
3934
3935 static nkf_char
3936 mime_getc_buf(FILE *f)
3937 {
3938     /* we don't keep eof of mime_input_buf, becase it contains ?= as
3939        a terminator. It was checked in mime_integrity. */
3940     return ((mimebuf_f)?
3941             (*i_mgetc_buf)(f):mime_input_buf(mime_input_state.input++));
3942 }
3943
3944 static void
3945 switch_mime_getc(void)
3946 {
3947     if (i_getc!=mime_getc) {
3948         i_mgetc = i_getc; i_getc = mime_getc;
3949         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
3950         if(mime_f==STRICT_MIME) {
3951             i_mgetc_buf = i_mgetc; i_mgetc = mime_getc_buf;
3952             i_mungetc_buf = i_mungetc; i_mungetc = mime_ungetc_buf;
3953         }
3954     }
3955 }
3956
3957 static void
3958 unswitch_mime_getc(void)
3959 {
3960     if(mime_f==STRICT_MIME) {
3961         i_mgetc = i_mgetc_buf;
3962         i_mungetc = i_mungetc_buf;
3963     }
3964     i_getc = i_mgetc;
3965     i_ungetc = i_mungetc;
3966     if(mime_iconv_back)set_iconv(FALSE, mime_iconv_back);
3967     mime_iconv_back = NULL;
3968 }
3969
3970 static nkf_char
3971 mime_integrity(FILE *f, const unsigned char *p)
3972 {
3973     nkf_char c,d;
3974     unsigned int q;
3975     /* In buffered mode, read until =? or NL or buffer full
3976      */
3977     mime_input_state.input = mime_input_state.top;
3978     mime_input_state.last = mime_input_state.top;
3979
3980     while(*p) mime_input_buf(mime_input_state.input++) = *p++;
3981     d = 0;
3982     q = mime_input_state.input;
3983     while((c=(*i_getc)(f))!=EOF) {
3984         if (((mime_input_state.input-mime_input_state.top)&MIME_BUF_MASK)==0) {
3985             break;   /* buffer full */
3986         }
3987         if (c=='=' && d=='?') {
3988             /* checked. skip header, start decode */
3989             mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3990             /* mime_last_input = mime_input_state.input; */
3991             mime_input_state.input = q;
3992             switch_mime_getc();
3993             return 1;
3994         }
3995         if (!( (c=='+'||c=='/'|| c=='=' || c=='?' || is_alnum(c))))
3996             break;
3997         /* Should we check length mod 4? */
3998         mime_input_buf(mime_input_state.input++) = (unsigned char)c;
3999         d=c;
4000     }
4001     /* In case of Incomplete MIME, no MIME decode  */
4002     mime_input_buf(mime_input_state.input++) = (unsigned char)c;
4003     mime_input_state.last = mime_input_state.input;     /* point undecoded buffer */
4004     mime_decode_mode = 1;              /* no decode on mime_input_buf last in mime_getc */
4005     switch_mime_getc();         /* anyway we need buffered getc */
4006     return 1;
4007 }
4008
4009 static nkf_char
4010 mime_begin_strict(FILE *f)
4011 {
4012     nkf_char c1 = 0;
4013     int i,j,k;
4014     const unsigned char *p,*q;
4015     nkf_char r[MAXRECOVER];    /* recovery buffer, max mime pattern length */
4016
4017     mime_decode_mode = FALSE;
4018     /* =? has been checked */
4019     j = 0;
4020     p = mime_pattern[j];
4021     r[0]='='; r[1]='?';
4022
4023     for(i=2;p[i]>SP;i++) {                   /* start at =? */
4024         if (((r[i] = c1 = (*i_getc)(f))==EOF) || nkf_toupper(c1) != p[i]) {
4025             /* pattern fails, try next one */
4026             q = p;
4027             while (mime_pattern[++j]) {
4028                 p = mime_pattern[j];
4029                 for(k=2;k<i;k++)              /* assume length(p) > i */
4030                     if (p[k]!=q[k]) break;
4031                 if (k==i && nkf_toupper(c1)==p[k]) break;
4032             }
4033             p = mime_pattern[j];
4034             if (p) continue;  /* found next one, continue */
4035             /* all fails, output from recovery buffer */
4036             (*i_ungetc)(c1,f);
4037             for(j=0;j<i;j++) {
4038                 (*oconv)(0,r[j]);
4039             }
4040             return c1;
4041         }
4042     }
4043     mime_decode_mode = p[i-2];
4044
4045     mime_iconv_back = iconv;
4046     set_iconv(FALSE, mime_priority_func[j]);
4047     clr_code_score(find_inputcode_byfunc(mime_priority_func[j]), SCORE_iMIME);
4048
4049     if (mime_decode_mode=='B') {
4050         mimebuf_f = unbuf_f;
4051         if (!unbuf_f) {
4052             /* do MIME integrity check */
4053             return mime_integrity(f,mime_pattern[j]);
4054         }
4055     }
4056     switch_mime_getc();
4057     mimebuf_f = TRUE;
4058     return c1;
4059 }
4060
4061 static nkf_char
4062 mime_begin(FILE *f)
4063 {
4064     nkf_char c1;
4065     int i,k;
4066
4067     /* In NONSTRICT mode, only =? is checked. In case of failure, we  */
4068     /* re-read and convert again from mime_buffer.  */
4069
4070     /* =? has been checked */
4071     k = mime_input_state.last;
4072     mime_input_buf(mime_input_state.last++)='='; mime_input_buf(mime_input_state.last++)='?';
4073     for(i=2;i<MAXRECOVER;i++) {                   /* start at =? */
4074         /* We accept any character type even if it is breaked by new lines */
4075         c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4076         if (c1==LF||c1==SP||c1==CR||
4077             c1=='-'||c1=='_'||is_alnum(c1)) continue;
4078         if (c1=='=') {
4079             /* Failed. But this could be another MIME preemble */
4080             (*i_ungetc)(c1,f);
4081             mime_input_state.last--;
4082             break;
4083         }
4084         if (c1!='?') break;
4085         else {
4086             /* c1=='?' */
4087             c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4088             if (!(++i<MAXRECOVER) || c1==EOF) break;
4089             if (c1=='b'||c1=='B') {
4090                 mime_decode_mode = 'B';
4091             } else if (c1=='q'||c1=='Q') {
4092                 mime_decode_mode = 'Q';
4093             } else {
4094                 break;
4095             }
4096             c1 = (*i_getc)(f); mime_input_buf(mime_input_state.last++) = (unsigned char)c1;
4097             if (!(++i<MAXRECOVER) || c1==EOF) break;
4098             if (c1!='?') {
4099                 mime_decode_mode = FALSE;
4100             }
4101             break;
4102         }
4103     }
4104     switch_mime_getc();
4105     if (!mime_decode_mode) {
4106         /* false MIME premble, restart from mime_buffer */
4107         mime_decode_mode = 1;  /* no decode, but read from the mime_buffer */
4108         /* Since we are in MIME mode until buffer becomes empty,    */
4109         /* we never go into mime_begin again for a while.           */
4110         return c1;
4111     }
4112     /* discard mime preemble, and goto MIME mode */
4113     mime_input_state.last = k;
4114     /* do no MIME integrity check */
4115     return c1;   /* used only for checking EOF */
4116 }
4117
4118 #ifdef CHECK_OPTION
4119 static void
4120 no_putc(nkf_char c)
4121 {
4122     ;
4123 }
4124
4125 static void
4126 debug(const char *str)
4127 {
4128     if (debug_f){
4129         fprintf(stderr, "%s\n", str ? str : "NULL");
4130     }
4131 }
4132 #endif
4133
4134 static void
4135 set_input_codename(const char *codename)
4136 {
4137     if (!input_codename) {
4138         input_codename = codename;
4139     } else if (strcmp(codename, input_codename) != 0) {
4140         input_codename = "";
4141     }
4142 }
4143
4144 static const char*
4145 get_guessed_code(void)
4146 {
4147     if (input_codename && !*input_codename) {
4148         input_codename = "BINARY";
4149     } else {
4150         struct input_code *p = find_inputcode_byfunc(iconv);
4151         if (!input_codename) {
4152             input_codename = "ASCII";
4153         } else if (strcmp(input_codename, "Shift_JIS") == 0) {
4154             if (p->score & (SCORE_DEPEND|SCORE_CP932))
4155                 input_codename = "CP932";
4156         } else if (strcmp(input_codename, "EUC-JP") == 0) {
4157             if (p->score & (SCORE_X0212))
4158                 input_codename = "EUCJP-MS";
4159             else if (p->score & (SCORE_DEPEND|SCORE_CP932))
4160                 input_codename = "CP51932";
4161         } else if (strcmp(input_codename, "ISO-2022-JP") == 0) {
4162             if (p->score & (SCORE_KANA))
4163                 input_codename = "CP50221";
4164             else if (p->score & (SCORE_DEPEND|SCORE_CP932))
4165                 input_codename = "CP50220";
4166         }
4167     }
4168     return input_codename;
4169 }
4170
4171 #if !defined(PERL_XS) && !defined(WIN32DLL)
4172 static void
4173 print_guessed_code(char *filename)
4174 {
4175     if (filename != NULL) printf("%s: ", filename);
4176     if (input_codename && !*input_codename) {
4177         printf("BINARY\n");
4178     } else {
4179         input_codename = get_guessed_code();
4180         if (guess_f == 1) {
4181             printf("%s\n", input_codename);
4182         } else {
4183             printf("%s%s\n",
4184                    input_codename,
4185                    input_eol == CR   ? " (CR)" :
4186                    input_eol == LF   ? " (LF)" :
4187                    input_eol == CRLF ? " (CRLF)" :
4188                    input_eol == EOF  ? " (MIXED NL)" :
4189                    "");
4190         }
4191     }
4192 }
4193 #endif /*WIN32DLL*/
4194
4195 #ifdef INPUT_OPTION
4196
4197 static nkf_char
4198 hex_getc(nkf_char ch, FILE *f, nkf_char (*g)(FILE *f), nkf_char (*u)(nkf_char c, FILE *f))
4199 {
4200     nkf_char c1, c2, c3;
4201     c1 = (*g)(f);
4202     if (c1 != ch){
4203         return c1;
4204     }
4205     c2 = (*g)(f);
4206     if (!nkf_isxdigit(c2)){
4207         (*u)(c2, f);
4208         return c1;
4209     }
4210     c3 = (*g)(f);
4211     if (!nkf_isxdigit(c3)){
4212         (*u)(c2, f);
4213         (*u)(c3, f);
4214         return c1;
4215     }
4216     return (hex2bin(c2) << 4) | hex2bin(c3);
4217 }
4218
4219 static nkf_char
4220 cap_getc(FILE *f)
4221 {
4222     return hex_getc(':', f, i_cgetc, i_cungetc);
4223 }
4224
4225 static nkf_char
4226 cap_ungetc(nkf_char c, FILE *f)
4227 {
4228     return (*i_cungetc)(c, f);
4229 }
4230
4231 static nkf_char
4232 url_getc(FILE *f)
4233 {
4234     return hex_getc('%', f, i_ugetc, i_uungetc);
4235 }
4236
4237 static nkf_char
4238 url_ungetc(nkf_char c, FILE *f)
4239 {
4240     return (*i_uungetc)(c, f);
4241 }
4242 #endif
4243
4244 #ifdef NUMCHAR_OPTION
4245 static nkf_char
4246 numchar_getc(FILE *f)
4247 {
4248     nkf_char (*g)(FILE *) = i_ngetc;
4249     nkf_char (*u)(nkf_char c ,FILE *f) = i_nungetc;
4250     int i = 0, j;
4251     nkf_char buf[12];
4252     long c = -1;
4253
4254     buf[i] = (*g)(f);
4255     if (buf[i] == '&'){
4256         buf[++i] = (*g)(f);
4257         if (buf[i] == '#'){
4258             c = 0;
4259             buf[++i] = (*g)(f);
4260             if (buf[i] == 'x' || buf[i] == 'X'){
4261                 for (j = 0; j < 7; j++){
4262                     buf[++i] = (*g)(f);
4263                     if (!nkf_isxdigit(buf[i])){
4264                         if (buf[i] != ';'){
4265                             c = -1;
4266                         }
4267                         break;
4268                     }
4269                     c <<= 4;
4270                     c |= hex2bin(buf[i]);
4271                 }
4272             }else{
4273                 for (j = 0; j < 8; j++){
4274                     if (j){
4275                         buf[++i] = (*g)(f);
4276                     }
4277                     if (!nkf_isdigit(buf[i])){
4278                         if (buf[i] != ';'){
4279                             c = -1;
4280                         }
4281                         break;
4282                     }
4283                     c *= 10;
4284                     c += hex2bin(buf[i]);
4285                 }
4286             }
4287         }
4288     }
4289     if (c != -1){
4290         return nkf_char_unicode_new(c);
4291     }
4292     while (i > 0){
4293         (*u)(buf[i], f);
4294         --i;
4295     }
4296     return buf[0];
4297 }
4298
4299 static nkf_char
4300 numchar_ungetc(nkf_char c, FILE *f)
4301 {
4302     return (*i_nungetc)(c, f);
4303 }
4304 #endif
4305
4306 #ifdef UNICODE_NORMALIZATION
4307
4308 static nkf_char
4309 nfc_getc(FILE *f)
4310 {
4311     nkf_char (*g)(FILE *f) = i_nfc_getc;
4312     nkf_char (*u)(nkf_char c ,FILE *f) = i_nfc_ungetc;
4313     nkf_buf_t *buf = nkf_state->nfc_buf;
4314     const unsigned char *array;
4315     int lower=0, upper=NORMALIZATION_TABLE_LENGTH-1;
4316     nkf_char c = (*g)(f);
4317
4318     if (c == EOF || c > 0xFF || (c & 0xc0) == 0x80) return c;
4319
4320     nkf_buf_push(buf, c);
4321     do {
4322         while (lower <= upper) {
4323             int mid = (lower+upper) / 2;
4324             int len;
4325             array = normalization_table[mid].nfd;
4326             for (len=0; len < NORMALIZATION_TABLE_NFD_LENGTH && array[len]; len++) {
4327                 if (len >= nkf_buf_length(buf)) {
4328                     c = (*g)(f);
4329                     if (c == EOF) {
4330                         len = 0;
4331                         lower = 1, upper = 0;
4332                         break;
4333                     }
4334                     nkf_buf_push(buf, c);
4335                 }
4336                 if (array[len] != nkf_buf_at(buf, len)) {
4337                     if (array[len] < nkf_buf_at(buf, len)) lower = mid + 1;
4338                     else  upper = mid - 1;
4339                     len = 0;
4340                     break;
4341                 }
4342             }
4343             if (len > 0) {
4344                 int i;
4345                 array = normalization_table[mid].nfc;
4346                 nkf_buf_clear(buf);
4347                 for (i=0; i < NORMALIZATION_TABLE_NFC_LENGTH && array[i]; i++)
4348                     nkf_buf_push(buf, array[i]);
4349                 break;
4350             }
4351         }
4352     } while (lower <= upper);
4353
4354     while (nkf_buf_length(buf) > 1) (*u)(nkf_buf_pop(buf), f);
4355     c = nkf_buf_pop(buf);
4356
4357     return c;
4358 }
4359
4360 static nkf_char
4361 nfc_ungetc(nkf_char c, FILE *f)
4362 {
4363     return (*i_nfc_ungetc)(c, f);
4364 }
4365 #endif /* UNICODE_NORMALIZATION */
4366
4367
4368 static nkf_char
4369 base64decode(nkf_char c)
4370 {
4371     int             i;
4372     if (c > '@') {
4373         if (c < '[') {
4374             i = c - 'A';                        /* A..Z 0-25 */
4375         } else if (c == '_') {
4376             i = '?'         /* 63 */ ;          /* _  63 */
4377         } else {
4378             i = c - 'G'     /* - 'a' + 26 */ ;  /* a..z 26-51 */
4379         }
4380     } else if (c > '/') {
4381         i = c - '0' + '4'   /* - '0' + 52 */ ;  /* 0..9 52-61 */
4382     } else if (c == '+' || c == '-') {
4383         i = '>'             /* 62 */ ;          /* + and -  62 */
4384     } else {
4385         i = '?'             /* 63 */ ;          /* / 63 */
4386     }
4387     return (i);
4388 }
4389
4390 static nkf_char
4391 mime_getc(FILE *f)
4392 {
4393     nkf_char c1, c2, c3, c4, cc;
4394     nkf_char t1, t2, t3, t4, mode, exit_mode;
4395     nkf_char lwsp_count;
4396     char *lwsp_buf;
4397     char *lwsp_buf_new;
4398     nkf_char lwsp_size = 128;
4399
4400     if (mime_input_state.top != mime_input_state.last) {  /* Something is in FIFO */
4401         return  mime_input_buf(mime_input_state.top++);
4402     }
4403     if (mime_decode_mode==1 ||mime_decode_mode==FALSE) {
4404         mime_decode_mode=FALSE;
4405         unswitch_mime_getc();
4406         return (*i_getc)(f);
4407     }
4408
4409     if (mimebuf_f == FIXED_MIME)
4410         exit_mode = mime_decode_mode;
4411     else
4412         exit_mode = FALSE;
4413     if (mime_decode_mode == 'Q') {
4414         if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
4415       restart_mime_q:
4416         if (c1=='_' && mimebuf_f != FIXED_MIME) return SP;
4417         if (c1<=SP || DEL<=c1) {
4418             mime_decode_mode = exit_mode; /* prepare for quit */
4419             return c1;
4420         }
4421         if (c1!='=' && (c1!='?' || mimebuf_f == FIXED_MIME)) {
4422             return c1;
4423         }
4424
4425         mime_decode_mode = exit_mode; /* prepare for quit */
4426         if ((c2 = (*i_mgetc)(f)) == EOF) return (EOF);
4427         if (c1=='?'&&c2=='=' && mimebuf_f != FIXED_MIME) {
4428             /* end Q encoding */
4429             input_mode = exit_mode;
4430             lwsp_count = 0;
4431             lwsp_buf = nkf_xmalloc((lwsp_size+5)*sizeof(char));
4432             while ((c1=(*i_getc)(f))!=EOF) {
4433                 switch (c1) {
4434                 case LF:
4435                 case CR:
4436                     if (c1==LF) {
4437                         if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4438                             i_ungetc(SP,f);
4439                             continue;
4440                         } else {
4441                             i_ungetc(c1,f);
4442                         }
4443                         c1 = LF;
4444                     } else {
4445                         if ((c1=(*i_getc)(f))!=EOF && c1 == LF) {
4446                             if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4447                                 i_ungetc(SP,f);
4448                                 continue;
4449                             } else {
4450                                 i_ungetc(c1,f);
4451                             }
4452                             i_ungetc(LF,f);
4453                         } else {
4454                             i_ungetc(c1,f);
4455                         }
4456                         c1 = CR;
4457                     }
4458                     break;
4459                 case SP:
4460                 case TAB:
4461                     lwsp_buf[lwsp_count] = (unsigned char)c1;
4462                     if (lwsp_count++>lwsp_size){
4463                         lwsp_size <<= 1;
4464                         lwsp_buf_new = nkf_xrealloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4465                         lwsp_buf = lwsp_buf_new;
4466                     }
4467                     continue;
4468                 }
4469                 break;
4470             }
4471             if (lwsp_count > 0 && (c1 != '=' || (lwsp_buf[lwsp_count-1] != SP && lwsp_buf[lwsp_count-1] != TAB))) {
4472                 i_ungetc(c1,f);
4473                 for(lwsp_count--;lwsp_count>0;lwsp_count--)
4474                     i_ungetc(lwsp_buf[lwsp_count],f);
4475                 c1 = lwsp_buf[0];
4476             }
4477             nkf_xfree(lwsp_buf);
4478             return c1;
4479         }
4480         if (c1=='='&&c2<SP) { /* this is soft wrap */
4481             while((c1 =  (*i_mgetc)(f)) <=SP) {
4482                 if (c1 == EOF) return (EOF);
4483             }
4484             mime_decode_mode = 'Q'; /* still in MIME */
4485             goto restart_mime_q;
4486         }
4487         if (c1=='?') {
4488             mime_decode_mode = 'Q'; /* still in MIME */
4489             (*i_mungetc)(c2,f);
4490             return c1;
4491         }
4492         if ((c3 = (*i_mgetc)(f)) == EOF) return (EOF);
4493         if (c2<=SP) return c2;
4494         mime_decode_mode = 'Q'; /* still in MIME */
4495         return ((hex2bin(c2)<<4) + hex2bin(c3));
4496     }
4497
4498     if (mime_decode_mode != 'B') {
4499         mime_decode_mode = FALSE;
4500         return (*i_mgetc)(f);
4501     }
4502
4503
4504     /* Base64 encoding */
4505     /*
4506        MIME allows line break in the middle of
4507        Base64, but we are very pessimistic in decoding
4508        in unbuf mode because MIME encoded code may broken by
4509        less or editor's control sequence (such as ESC-[-K in unbuffered
4510        mode. ignore incomplete MIME.
4511      */
4512     mode = mime_decode_mode;
4513     mime_decode_mode = exit_mode;  /* prepare for quit */
4514
4515     while ((c1 = (*i_mgetc)(f))<=SP) {
4516         if (c1==EOF)
4517             return (EOF);
4518     }
4519   mime_c2_retry:
4520     if ((c2 = (*i_mgetc)(f))<=SP) {
4521         if (c2==EOF)
4522             return (EOF);
4523         if (mime_f != STRICT_MIME) goto mime_c2_retry;
4524         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;
4525         return c2;
4526     }
4527     if ((c1 == '?') && (c2 == '=')) {
4528         input_mode = ASCII;
4529         lwsp_count = 0;
4530         lwsp_buf = nkf_xmalloc((lwsp_size+5)*sizeof(char));
4531         while ((c1=(*i_getc)(f))!=EOF) {
4532             switch (c1) {
4533             case LF:
4534             case CR:
4535                 if (c1==LF) {
4536                     if ((c1=(*i_getc)(f))!=EOF && nkf_isblank(c1)) {
4537                         i_ungetc(SP,f);
4538                         continue;
4539                     } else {
4540               &n