OSDN Git Service

b247ee2153bb2881b444c5919d81096d45d14439
[nkf/nkf.git] / nkf.c
1 /** Network Kanji Filter. (PDS Version)
2 ************************************************************************
3 ** Copyright (C) 1987, Fujitsu LTD. (Itaru ICHIKAWA)
4 ** \e$BO"Mm@h!'\e(B \e$B!J3t!KIY;NDL8&5f=j!!%=%U%H#38&!!;T@n!!;j\e(B 
5 ** \e$B!J\e(BE-Mail Address: ichikawa@flab.fujitsu.co.jp\e$B!K\e(B
6 ** Copyright (C) 1996,1998
7 ** Copyright (C) 2002
8 ** \e$BO"Mm@h!'\e(B \e$BN05eBg3X>pJs9)3X2J\e(B \e$B2OLn\e(B \e$B??<#\e(B  mime/X0208 support
9 ** \e$B!J\e(BE-Mail Address: kono@ie.u-ryukyu.ac.jp\e$B!K\e(B
10 ** \e$BO"Mm@h!'\e(B COW for DOS & Win16 & Win32 & OS/2
11 ** \e$B!J\e(BE-Mail Address: GHG00637@niftyserve.or.p\e$B!K\e(B
12 **
13 **    \e$B$3$N%=!<%9$N$$$+$J$kJ#<L!$2~JQ!$=$@5$b5vBz$7$^$9!#$?$@$7!"\e(B
14 **    \e$B$=$N:]$K$O!"C/$,9W8%$7$?$r<($9$3$NItJ,$r;D$9$3$H!#\e(B
15 **    \e$B:FG[I[$d;(;o$NIUO?$J$I$NLd$$9g$o$;$bI,MW$"$j$^$;$s!#\e(B
16 **    \e$B1DMxMxMQ$b>e5-$KH?$7$J$$HO0O$G5v2D$7$^$9!#\e(B
17 **    \e$B%P%$%J%j$NG[I[$N:]$K$O\e(Bversion message\e$B$rJ]B8$9$k$3$H$r>r7o$H$7$^$9!#\e(B
18 **    \e$B$3$N%W%m%0%i%`$K$D$$$F$OFC$K2?$NJ]>Z$b$7$J$$!"0-$7$+$i$:!#\e(B
19 **
20 **    Everyone is permitted to do anything on this program 
21 **    including copying, modifying, improving,
22 **    as long as you don't try to pretend that you wrote it.
23 **    i.e., the above copyright notice has to appear in all copies.  
24 **    Binary distribution requires original version messages.
25 **    You don't have to ask before copying, redistribution or publishing.
26 **    THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE.
27 ***********************************************************************/
28
29 /***********************************************************************
30 ** UTF-8 \e$B%5%]!<%H$K$D$$$F\e(B
31 **    \e$B=>Mh$N\e(B nkf \e$B$HF~$l$+$($F$=$N$^$^;H$($k$h$&$K$J$C$F$$$^$9\e(B
32 **    nkf -e \e$B$J$I$H$7$F5/F0$9$k$H!"<+F0H=JL$G\e(B UTF-8 \e$B$HH=Dj$5$l$l$P!"\e(B
33 **    \e$B$=$N$^$^\e(B euc-jp \e$B$KJQ49$5$l$^$9\e(B
34 **
35 **    \e$B$^$@%P%0$,$"$k2DG=@-$,9b$$$G$9!#\e(B
36 **    (\e$BFC$K<+F0H=JL!"%3!<%I:.:_!"%(%i!<=hM}7O\e(B)
37 **
38 **    \e$B2?$+LdBj$r8+$D$1$?$i!"\e(B
39 **        E-Mail: furukawa@tcp-ip.or.jp
40 **    \e$B$^$G8fO"Mm$r$*4j$$$7$^$9!#\e(B
41 ***********************************************************************/
42 #include "config.h"
43
44 static char *CopyRight =
45       "Copyright (C) 1987, FUJITSU LTD. (I.Ichikawa),2000 S. Kono, COW, 2002 Kono, Furukawa";
46 static char *Version =
47       "2.0";
48 static char *Patchlevel =
49       "1/0209/Shinji Kono";
50
51 /*
52 **
53 **
54 **
55 ** USAGE:       nkf [flags] [file] 
56 **
57 ** Flags:
58 ** b    Output is bufferred             (DEFAULT)
59 ** u    Output is unbufferred
60 **
61 ** t    no operation
62 **
63 ** j    Outout code is JIS 7 bit        (DEFAULT SELECT) 
64 ** s    Output code is MS Kanji         (DEFAULT SELECT) 
65 ** e    Output code is AT&T JIS         (DEFAULT SELECT) 
66 ** w    Output code is AT&T JIS         (DEFAULT SELECT) 
67 ** l    Output code is JIS 7bit and ISO8859-1 Latin-1
68 **
69 ** m    MIME conversion for ISO-2022-JP
70 ** I    Convert non ISO-2022-JP charactor to GETA by Pekoe <pekoe@lair.net>
71 ** i_ Output sequence to designate JIS-kanji (DEFAULT_J)
72 ** o_ Output sequence to designate single-byte roman characters (DEFAULT_R)
73 ** M    MIME output conversion 
74 **
75 ** r  {de/en}crypt ROT13/47
76 **
77 ** v  display Version
78 **
79 ** T  Text mode output        (for MS-DOS)
80 **
81 ** x    Do not convert X0201 kana into X0208
82 ** Z    Convert X0208 alphabet to ASCII
83 **
84 ** f60  fold option
85 **
86 ** m    MIME decode
87 ** B    try to fix broken JIS, missing Escape
88 ** B[1-9]  broken level
89 **
90 ** O   Output to 'nkf.out' file or last file name
91 ** d   Delete \r in line feed 
92 ** c   Add \r in line feed 
93 ** -- other long option
94 ** -- ignore following option (don't use with -O )
95 **
96 **/
97
98 #if (defined(__TURBOC__) || defined(LSI_C)) && !defined(MSDOS)
99 #define MSDOS
100 #endif
101
102 #ifdef PERL_XS
103 #undef OVERWRITE
104 #endif
105
106 #ifndef PERL_XS
107 #include <stdio.h>
108 #endif
109
110 #include <stdlib.h>
111 #include <string.h>
112
113 #if defined(MSDOS) || defined(__OS2__) 
114 #include <fcntl.h>
115 #include <io.h>
116 #endif
117
118 #ifdef MSDOS
119 #ifdef LSI_C
120 #define setbinmode(fp) fsetbin(fp)
121 #else /* Microsoft C, Turbo C */
122 #define setbinmode(fp) setmode(fileno(fp), O_BINARY)
123 #endif
124 #else /* UNIX,OS/2 */
125 #define setbinmode(fp)
126 #endif
127
128 #ifdef _IOFBF /* SysV and MSDOS */
129 #define       setvbuffer(fp, buf, size)       setvbuf(fp, buf, _IOFBF, size)
130 #else /* BSD */
131 #define       setvbuffer(fp, buf, size)       setbuffer(fp, buf, size)
132 #endif
133
134 /*Borland C++ 4.5 EasyWin*/
135 #if defined(__TURBOC__) && defined(_Windows) && !defined(__WIN32__) /*Easy Win */
136 #define         EASYWIN
137 #include <windows.h>
138 #endif
139
140 #ifdef OVERWRITE
141 /* added by satoru@isoternet.org */
142 #include <sys/stat.h>
143 #ifndef MSDOS
144 #include <unistd.h>
145 #include <utime.h>
146 #endif
147 #endif 
148
149 #define         FALSE   0
150 #define         TRUE    1
151
152 /* state of output_mode and input_mode  
153
154    c2           0 means ASCII
155                 X0201
156                 ISO8859_1
157                 X0208
158                 EOF      all termination
159    c1           32bit data
160
161  */
162
163 #define         ASCII           0
164 #define         X0208           1
165 #define         X0201           2
166 #define         ISO8859_1       8
167 #define         NO_X0201        3
168
169 /* Input Assumption */
170
171 #define         JIS_INPUT       4
172 #define         SJIS_INPUT      5
173 #define         LATIN1_INPUT    6
174 #define         FIXED_MIME      7
175 #define         STRICT_MIME     8
176
177 /* MIME ENCODE */
178
179 #define         ISO2022JP       9
180 #define         JAPANESE_EUC   10
181 #define         SHIFT_JIS      11
182
183 #define         UTF8           12
184 #define         UTF8_INPUT     13
185 #define         UTF16_INPUT    14
186 #define         UTF16BE_INPUT  15
187
188 #define         WISH_TRUE      15
189
190 /* ASCII CODE */
191
192 #define         BS      0x08
193 #define         NL      0x0a
194 #define         CR      0x0d
195 #define         ESC     0x1b
196 #define         SPACE   0x20
197 #define         AT      0x40
198 #define         SSP     0xa0
199 #define         DEL     0x7f
200 #define         SI      0x0f
201 #define         SO      0x0e
202 #define         SSO     0x8e
203
204 #define         is_alnum(c)  \
205             (('a'<=c && c<='z')||('A'<= c && c<='Z')||('0'<=c && c<='9'))
206
207 #define         HOLD_SIZE       1024
208 #define         IOBUF_SIZE      16384
209
210 #define         DEFAULT_J       'B'
211 #define         DEFAULT_R       'B'
212
213 #define         SJ0162  0x00e1          /* 01 - 62 ku offset */
214 #define         SJ6394  0x0161          /* 63 - 94 ku offset */
215
216 #define         RANGE_NUM_MAX   18
217 #define         GETA1   0x22
218 #define         GETA2   0x2e
219
220
221 #if defined( UTF8_OUTPUT_ENABLE ) || defined( UTF8_INPUT_ENABLE )
222 #define sizeof_euc_utf8 94
223 #define sizeof_euc_to_utf8_1byte 94
224 #define sizeof_euc_to_utf8_2bytes 94
225 #define sizeof_utf8_to_euc_C2 64
226 #define sizeof_utf8_to_euc_E5B8 64
227 #define sizeof_utf8_to_euc_2bytes 112
228 #define sizeof_utf8_to_euc_3bytes 112
229 #endif
230
231 /* MIME preprocessor */
232
233
234 #ifdef EASYWIN /*Easy Win */
235 extern POINT _BufferSize;
236 #endif
237
238 /*      function prototype  */
239
240 #ifdef ANSI_C_PROTOTYPE
241 #define PROTO(x)  x 
242 #define STATIC static
243 #else
244 #define PROTO(x)  ()
245 #define STATIC
246 #endif
247
248 struct input_code{
249     char *name;
250     int stat;
251     int score;
252     int index;
253     int buf[3];
254     void (*status_func)PROTO((struct input_code *, int));
255     int (*iconv_func)PROTO((int c2, int c1, int c0));
256 };
257
258 STATIC  int     noconvert PROTO((FILE *f));
259 STATIC  int     kanji_convert PROTO((FILE *f));
260 STATIC  int     h_conv PROTO((FILE *f,int c2,int c1));
261 STATIC  int     push_hold_buf PROTO((int c2));
262 STATIC  void    set_iconv PROTO((int f, int (*iconv_func)()));
263 STATIC  int     s_iconv PROTO((int c2,int c1,int c0));
264 STATIC  int     s2e_conv PROTO((int c2, int c1, int *p2, int *p1));
265 STATIC  int     e_iconv PROTO((int c2,int c1,int c0));
266 #ifdef UTF8_INPUT_ENABLE
267 STATIC  int     w2e_conv PROTO((int c2,int c1,int c0,int *p2,int *p1));
268 STATIC  int     w_iconv PROTO((int c2,int c1,int c0));
269 STATIC  int     w_iconv16 PROTO((int c2,int c1,int c0));
270 STATIC  int     w_iconv_common PROTO((int c1,int c0,unsigned short **pp,int psize,int *p2,int *p1));
271 #endif
272 #ifdef UTF8_OUTPUT_ENABLE
273 STATIC  int     e2w_conv PROTO((int c2,int c1));
274 STATIC  void    w_oconv PROTO((int c2,int c1));
275 STATIC  void    w_oconv16 PROTO((int c2,int c1));
276 #endif
277 STATIC  void    e_oconv PROTO((int c2,int c1));
278 STATIC  void    s_oconv PROTO((int c2,int c1));
279 STATIC  void    j_oconv PROTO((int c2,int c1));
280 STATIC  void    fold_conv PROTO((int c2,int c1));
281 STATIC  void    cr_conv PROTO((int c2,int c1));
282 STATIC  void    z_conv PROTO((int c2,int c1));
283 STATIC  void    rot_conv PROTO((int c2,int c1));
284 STATIC  void    hira_conv PROTO((int c2,int c1));
285 STATIC  void    base64_conv PROTO((int c2,int c1));
286 STATIC  void    iso2022jp_check_conv PROTO((int c2,int c1));
287 STATIC  void    no_connection PROTO((int c2,int c1));
288 STATIC  int     no_connection2 PROTO((int c2,int c1,int c0));
289
290 STATIC  void    code_score PROTO((struct input_code *ptr));
291 STATIC  void    code_status PROTO((int c));
292
293 STATIC  void    std_putc PROTO((int c));
294 STATIC  int     std_getc PROTO((FILE *f));
295 STATIC  int     std_ungetc PROTO((int c,FILE *f));
296
297 STATIC  int     broken_getc PROTO((FILE *f));
298 STATIC  int     broken_ungetc PROTO((int c,FILE *f));
299
300 STATIC  int     mime_begin PROTO((FILE *f));
301 STATIC  int     mime_getc PROTO((FILE *f));
302 STATIC  int     mime_ungetc PROTO((int c,FILE *f));
303
304 STATIC  int     mime_begin_strict PROTO((FILE *f));
305 STATIC  int     mime_getc_buf PROTO((FILE *f));
306 STATIC  int     mime_ungetc_buf  PROTO((int c,FILE *f));
307 STATIC  int     mime_integrity PROTO((FILE *f,unsigned char *p));
308
309 STATIC  int     base64decode PROTO((int c));
310 STATIC  void    mime_putc PROTO((int c));
311 STATIC  void    open_mime PROTO((int c));
312 STATIC  void    close_mime PROTO(());
313 STATIC  void    usage PROTO(());
314 STATIC  void    version PROTO(());
315 STATIC  void    options PROTO((unsigned char *c));
316 #ifdef PERL_XS
317 STATIC  void    reinit PROTO(());
318 #endif
319
320 /* buffers */
321
322 static unsigned char   stdibuf[IOBUF_SIZE];
323 static unsigned char   stdobuf[IOBUF_SIZE];
324 static unsigned char   hold_buf[HOLD_SIZE*2];
325 static int             hold_count;
326
327 /* MIME preprocessor fifo */
328
329 #define MIME_BUF_SIZE   (1024)    /* 2^n ring buffer */
330 #define MIME_BUF_MASK   (MIME_BUF_SIZE-1)   
331 #define Fifo(n)         mime_buf[(n)&MIME_BUF_MASK]
332 static unsigned char           mime_buf[MIME_BUF_SIZE];
333 static unsigned int            mime_top = 0;
334 static unsigned int            mime_last = 0;  /* decoded */
335 static unsigned int            mime_input = 0; /* undecoded */
336
337 /* flags */
338 static int             unbuf_f = FALSE;
339 static int             estab_f = FALSE;
340 static int             nop_f = FALSE;
341 static int             binmode_f = TRUE;       /* binary mode */
342 static int             rot_f = FALSE;          /* rot14/43 mode */
343 static int             hira_f = FALSE;          /* hira/kata henkan */
344 static int             input_f = FALSE;        /* non fixed input code  */
345 static int             alpha_f = FALSE;        /* convert JIx0208 alphbet to ASCII */
346 static int             mime_f = STRICT_MIME;   /* convert MIME B base64 or Q */
347 static int             mimebuf_f = FALSE;      /* MIME buffered input */
348 static int             broken_f = FALSE;       /* convert ESC-less broken JIS */
349 static int             iso8859_f = FALSE;      /* ISO8859 through */
350 static int             mimeout_f = FALSE;       /* base64 mode */
351 #if defined(MSDOS) || defined(__OS2__) 
352 static int             x0201_f = TRUE;         /* Assume JISX0201 kana */
353 #else
354 static int             x0201_f = NO_X0201;     /* Assume NO JISX0201 */
355 #endif
356 static int             iso2022jp_f = FALSE;    /* convert ISO-2022-JP */
357 #ifdef UTF8_OUTPUT_ENABLE
358 static int             w_oconv16_begin_f= 0;   /* utf-16 header */
359 #endif
360
361
362 #ifdef CAP_URL_OPTION
363 static int cap_f = FALSE;
364 static int (*i_cgetc)PROTO((FILE *)) = std_getc; /* input of cgetc */
365 static int (*i_cungetc)PROTO((int c ,FILE *f)) = std_ungetc;
366 STATIC int cap_getc PROTO((FILE *f));
367 STATIC int cap_ungetc PROTO((int c,FILE *f));
368
369 static int url_f = FALSE;
370 static int (*i_ugetc)PROTO((FILE *)) = std_getc; /* input of ugetc */
371 static int (*i_uungetc)PROTO((int c ,FILE *f)) = std_ungetc;
372 STATIC int url_getc PROTO((FILE *f));
373 STATIC int url_ungetc PROTO((int c,FILE *f));
374 #endif
375
376 #ifdef CHECK_OPTION
377 static int noout_f = FALSE;
378 STATIC void no_putc PROTO((int c));
379 static int debug_f = FALSE;
380 STATIC void debug PROTO((char *str));
381 #endif
382
383 STATIC void e_status PROTO((struct input_code *, int));
384 STATIC void s_status PROTO((struct input_code *, int));
385
386 #ifdef UTF8_INPUT_ENABLE
387 STATIC void w_status PROTO((struct input_code *, int));
388 static int             utf16_mode = UTF16_INPUT;
389 #endif
390
391 struct input_code input_code_list[] = {
392     {"EUC-JP",    0, 0, 0, {0, 0, 0}, e_status, e_iconv},
393     {"Shift_JIS", 0, 0, 0, {0, 0, 0}, s_status, s_iconv},
394     {"UTF-8",     0, 0, 0, {0, 0, 0}, w_status, w_iconv},
395     {0}
396 };
397
398 static int              mimeout_mode = 0;
399 static int              base64_count = 0;
400
401 /* X0208 -> ASCII converter */
402
403 /* fold parameter */
404 static int             f_line = 0;    /* chars in line */
405 static int             f_prev = 0;
406 static int             fold_preserve_f = FALSE; /* preserve new lines */
407 static int             fold_f  = FALSE;
408 static int             fold_len  = 0;
409
410 /* options */
411 static unsigned char   kanji_intro = DEFAULT_J,
412                        ascii_intro = DEFAULT_R;
413
414 /* Folding */
415
416 #define FOLD_MARGIN  10
417 #define DEFAULT_FOLD 60
418
419 static int             fold_margin  = FOLD_MARGIN;
420
421 /* converters */
422
423 #ifdef DEFAULT_CODE_JIS
424 #   define  DEFAULT_CONV j_oconv
425 #endif
426 #ifdef DEFAULT_CODE_SJIS
427 #   define  DEFAULT_CONV s_oconv
428 #endif
429 #ifdef DEFAULT_CODE_EUC
430 #   define  DEFAULT_CONV e_oconv
431 #endif
432 #ifdef DEFAULT_CODE_UTF8
433 #   define  DEFAULT_CONV w_oconv
434 #endif
435
436 /* process default */
437 static void (*output_conv)PROTO((int c2,int c1)) = DEFAULT_CONV;   
438
439 static void (*oconv)PROTO((int c2,int c1)) = no_connection; 
440 /* s_iconv or oconv */
441 static int (*iconv)PROTO((int c2,int c1,int c0)) = no_connection2;   
442
443 static void (*o_zconv)PROTO((int c2,int c1)) = no_connection; 
444 static void (*o_fconv)PROTO((int c2,int c1)) = no_connection; 
445 static void (*o_crconv)PROTO((int c2,int c1)) = no_connection; 
446 static void (*o_rot_conv)PROTO((int c2,int c1)) = no_connection; 
447 static void (*o_hira_conv)PROTO((int c2,int c1)) = no_connection; 
448 static void (*o_base64conv)PROTO((int c2,int c1)) = no_connection;
449 static void (*o_iso2022jp_check_conv)PROTO((int c2,int c1)) = no_connection;
450
451 /* static redirections */
452
453 static  void   (*o_putc)PROTO((int c)) = std_putc;
454
455 static  int    (*i_getc)PROTO((FILE *f)) = std_getc; /* general input */
456 static  int    (*i_ungetc)PROTO((int c,FILE *f)) =std_ungetc;
457
458 static  int    (*i_bgetc)PROTO((FILE *)) = std_getc; /* input of mgetc */
459 static  int    (*i_bungetc)PROTO((int c ,FILE *f)) = std_ungetc;
460
461 static  void   (*o_mputc)PROTO((int c)) = std_putc ; /* output of mputc */
462
463 static  int    (*i_mgetc)PROTO((FILE *)) = std_getc; /* input of mgetc */
464 static  int    (*i_mungetc)PROTO((int c ,FILE *f)) = std_ungetc;
465
466 /* for strict mime */
467 static  int    (*i_mgetc_buf)PROTO((FILE *)) = std_getc; /* input of mgetc_buf */
468 static  int    (*i_mungetc_buf)PROTO((int c,FILE *f)) = std_ungetc;
469
470 /* Global states */
471 static int output_mode = ASCII,    /* output kanji mode */
472            input_mode =  ASCII,    /* input kanji mode */
473            shift_mode =  FALSE;    /* TRUE shift out, or X0201  */
474 static int mime_decode_mode =   FALSE;    /* MIME mode B base64, Q hex */
475
476 /* X0201 / X0208 conversion tables */
477
478 /* X0201 kana conversion table */
479 /* 90-9F A0-DF */
480 static
481 unsigned char cv[]= {
482     0x21,0x21,0x21,0x23,0x21,0x56,0x21,0x57,
483     0x21,0x22,0x21,0x26,0x25,0x72,0x25,0x21,
484     0x25,0x23,0x25,0x25,0x25,0x27,0x25,0x29,
485     0x25,0x63,0x25,0x65,0x25,0x67,0x25,0x43,
486     0x21,0x3c,0x25,0x22,0x25,0x24,0x25,0x26,
487     0x25,0x28,0x25,0x2a,0x25,0x2b,0x25,0x2d,
488     0x25,0x2f,0x25,0x31,0x25,0x33,0x25,0x35,
489     0x25,0x37,0x25,0x39,0x25,0x3b,0x25,0x3d,
490     0x25,0x3f,0x25,0x41,0x25,0x44,0x25,0x46,
491     0x25,0x48,0x25,0x4a,0x25,0x4b,0x25,0x4c,
492     0x25,0x4d,0x25,0x4e,0x25,0x4f,0x25,0x52,
493     0x25,0x55,0x25,0x58,0x25,0x5b,0x25,0x5e,
494     0x25,0x5f,0x25,0x60,0x25,0x61,0x25,0x62,
495     0x25,0x64,0x25,0x66,0x25,0x68,0x25,0x69,
496     0x25,0x6a,0x25,0x6b,0x25,0x6c,0x25,0x6d,
497     0x25,0x6f,0x25,0x73,0x21,0x2b,0x21,0x2c,
498     0x00,0x00};
499
500
501 /* X0201 kana conversion table for daguten */
502 /* 90-9F A0-DF */
503 static
504 unsigned char dv[]= { 
505     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
506     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
507     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
508     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
509     0x00,0x00,0x00,0x00,0x00,0x00,0x25,0x74,
510     0x00,0x00,0x00,0x00,0x25,0x2c,0x25,0x2e,
511     0x25,0x30,0x25,0x32,0x25,0x34,0x25,0x36,
512     0x25,0x38,0x25,0x3a,0x25,0x3c,0x25,0x3e,
513     0x25,0x40,0x25,0x42,0x25,0x45,0x25,0x47,
514     0x25,0x49,0x00,0x00,0x00,0x00,0x00,0x00,
515     0x00,0x00,0x00,0x00,0x25,0x50,0x25,0x53,
516     0x25,0x56,0x25,0x59,0x25,0x5c,0x00,0x00,
517     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
518     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
519     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
520     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
521     0x00,0x00};
522
523 /* X0201 kana conversion table for han-daguten */
524 /* 90-9F A0-DF */
525 static
526 unsigned char ev[]= { 
527     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
528     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
529     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
530     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
531     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
532     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
533     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
534     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
535     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
536     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
537     0x00,0x00,0x00,0x00,0x25,0x51,0x25,0x54,
538     0x25,0x57,0x25,0x5a,0x25,0x5d,0x00,0x00,
539     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
540     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
541     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
542     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
543     0x00,0x00};
544
545
546 /* X0208 kigou conversion table */
547 /* 0x8140 - 0x819e */
548 static
549 unsigned char fv[] = {
550
551     0x00,0x00,0x00,0x00,0x2c,0x2e,0x00,0x3a,
552     0x3b,0x3f,0x21,0x00,0x00,0x27,0x60,0x00,
553     0x5e,0x00,0x5f,0x00,0x00,0x00,0x00,0x00,
554     0x00,0x00,0x00,0x00,0x00,0x2d,0x00,0x2f,
555     0x5c,0x00,0x00,0x7c,0x00,0x00,0x60,0x27,
556     0x22,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,
557     0x7b,0x7d,0x3c,0x3e,0x00,0x00,0x00,0x00,
558     0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,
559     0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,
560     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
561     0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40,
562     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
563 } ;
564
565
566 #define    CRLF      1
567
568 static int             file_out = FALSE;
569 #ifdef OVERWRITE
570 static int             overwrite = FALSE;
571 #endif
572
573 static int             crmode_f = 0;   /* CR, NL, CRLF */
574 #ifdef EASYWIN /*Easy Win */
575 static int             end_check;
576 #endif /*Easy Win */
577
578 #ifndef PERL_XS
579 int
580 main(argc, argv)
581     int             argc;
582     char          **argv;
583 {
584     FILE  *fin;
585     unsigned char  *cp;
586
587 #ifdef EASYWIN /*Easy Win */
588     _BufferSize.y = 400;/*Set Scroll Buffer Size*/
589 #endif
590
591     for (argc--,argv++; (argc > 0) && **argv == '-'; argc--, argv++) {
592         cp = (unsigned char *)*argv;
593         options(cp);
594     }
595     if(x0201_f == WISH_TRUE)
596          x0201_f = ((!iso2022jp_f)? TRUE : NO_X0201);
597
598     if (binmode_f == TRUE)
599 #ifdef __OS2__
600     if (freopen("","wb",stdout) == NULL) 
601         return (-1);
602 #else
603     setbinmode(stdout);
604 #endif
605
606     if (unbuf_f)
607       setbuf(stdout, (char *) NULL);
608     else
609       setvbuffer(stdout, stdobuf, IOBUF_SIZE);
610
611     if (argc == 0) {
612       if (binmode_f == TRUE)
613 #ifdef __OS2__
614       if (freopen("","rb",stdin) == NULL) return (-1);
615 #else
616       setbinmode(stdin);
617 #endif
618       setvbuffer(stdin, stdibuf, IOBUF_SIZE);
619       if (nop_f)
620           noconvert(stdin);
621       else
622           kanji_convert(stdin);
623     } else {
624       while (argc--) {
625           char *outfname;
626           char *origfname;
627
628           if ((fin = fopen((origfname = *argv++), "r")) == NULL) {
629               perror(*--argv);
630               return(-1);
631           } else {
632 #ifdef OVERWRITE
633               int fd;
634               int fd_backup;
635 #endif
636
637 /* reopen file for stdout */
638               if (file_out == TRUE) {
639 #ifdef OVERWRITE
640                   if (overwrite){
641                       outfname = malloc(strlen(origfname)
642                                         + strlen(".nkftmpXXXXXX")
643                                         + 1);
644                       if (!outfname){
645                           perror(origfname);
646                           return -1;
647                       }
648                       strcpy(outfname, origfname);
649 #ifdef MSDOS
650                       {
651                           int i;
652                           for (i = strlen(outfname); i; --i){
653                               if (outfname[i - 1] == '/'
654                                   || outfname[i - 1] == '\\'){
655                                   break;
656                               }
657                           }
658                           outfname[i] = '\0';
659                       }
660                       strcat(outfname, "ntXXXXXX");
661                       mktemp(outfname);
662                       fd = open(outfname, O_WRONLY | O_CREAT | O_TRUNC,
663                                 S_IREAD | S_IWRITE);
664 #else
665                       strcat(outfname, ".nkftmpXXXXXX");
666                       fd = mkstemp(outfname);
667 #endif
668                       if (fd < 0
669                           || (fd_backup = dup(fileno(stdout))) < 0
670                           || dup2(fd, fileno(stdout)) < 0
671                           ){
672                           perror(origfname);
673                           return -1;
674                       }
675                   }else
676 #endif
677                   if(argc == 1 ) {
678                       outfname = *argv++;
679                       argc--;
680                   } else {
681                       outfname = "nkf.out";
682                   }
683
684                   if(freopen(outfname, "w", stdout) == NULL) {
685                       perror (outfname);
686                       return (-1);
687                   }
688                   if (binmode_f == TRUE) {
689 #ifdef __OS2__
690                       if (freopen("","wb",stdout) == NULL) 
691                            return (-1);
692 #else
693                       setbinmode(stdout);
694 #endif
695                   }
696               }
697               if (binmode_f == TRUE)
698 #ifdef __OS2__
699                  if (freopen("","rb",fin) == NULL) 
700                     return (-1);
701 #else
702                  setbinmode(fin);
703 #endif 
704               setvbuffer(fin, stdibuf, IOBUF_SIZE);
705               if (nop_f)
706                   noconvert(fin);
707               else
708                   kanji_convert(fin);
709               fclose(fin);
710 #ifdef OVERWRITE
711               if (overwrite) {
712                   struct stat     sb;
713 #ifdef MSDOS
714                   time_t tb[2];
715 #else
716                   struct utimbuf  tb;
717 #endif
718
719                   fflush(stdout);
720                   close(fd);
721                   if (dup2(fd_backup, fileno(stdout)) < 0){
722                       perror("dup2");
723                   }
724                   if (stat(origfname, &sb)) {
725                       fprintf(stderr, "Can't stat %s\n", origfname);
726                   }
727                   /* \e$B%Q!<%_%C%7%g%s$rI|85\e(B */
728                   if (chmod(outfname, sb.st_mode)) {
729                       fprintf(stderr, "Can't set permission %s\n", outfname);
730                   }
731 #ifdef MSDOS
732                   tb[0] = tb[1] = sb.st_mtime;
733                   /* \e$B%?%$%`%9%?%s%W$rI|85\e(B */
734                   if (utime(outfname, tb)) {
735                       fprintf(stderr, "Can't set timestamp %s\n", outfname);
736                   }
737
738                   if (unlink(origfname)){
739                       perror(origfname);
740                   }
741 #else
742                   tb.actime  = sb.st_atime;
743                   tb.modtime = sb.st_mtime;
744                   /* \e$B%?%$%`%9%?%s%W$rI|85\e(B */
745                   if (utime(outfname, &tb)) {
746                       fprintf(stderr, "Can't set timestamp %s\n", outfname);
747                   }
748 #endif
749                   if (rename(outfname, origfname)) {
750                       perror(origfname);
751                       fprintf(stderr, "Can't rename %s to %s\n",
752                               outfname, origfname);
753                   }
754                   free(outfname);
755               }
756 #endif
757           }
758       }
759     }
760 #ifdef EASYWIN /*Easy Win */
761     if (file_out == FALSE) 
762         scanf("%d",&end_check);
763     else 
764         fclose(stdout);
765 #else /* for Other OS */
766     if (file_out == TRUE) 
767         fclose(stdout);
768 #endif 
769     return (0);
770 }
771 #endif
772
773 static 
774 struct {
775     char *name;
776     char *alias;
777 } long_option[] = {
778     {"base64","jMB"},
779     {"euc","e"},
780     {"euc-input","E"},
781     {"fj","jm"},
782     {"help","v"},
783     {"jis","j"},
784     {"jis-input","J"},
785     {"mac","sLm"},
786     {"mime","jM"},
787     {"mime-input","m"},
788     {"msdos","sLw"},
789     {"sjis","s"},
790     {"sjis-input","S"},
791     {"unix","eLu"},
792     {"version","V"},
793     {"windows","sLw"},
794     {"hiragana","h1"},
795     {"katakana","h2"},
796     {"katakana-hiragana","h3"},
797 #ifdef UTF8_OUTPUT_ENABLE
798     {"utf8", "w"},
799     {"utf16", "w16"},
800 #endif
801 #ifdef UTF8_INPUT_ENABLE
802     {"utf8-input", "W"},
803     {"utf16-input", "W16"},
804 #endif
805 #ifdef OVERWRITE
806     {"overwrite", ""},
807 #endif
808 #ifdef CAP_URL_OPTION
809     {"cap-input", ""},
810     {"url-input", ""},
811 #endif
812 #ifdef CHECK_OPTION
813     {"no-output", ""},
814     {"debug", ""},
815 #endif
816 };
817
818 static int option_mode;
819
820 void
821 options(cp) 
822      unsigned char *cp;
823 {
824     int i;
825     unsigned char *p;
826
827     if (option_mode==1)
828         return;
829     if (*cp++ != '-') 
830         return;
831     while (*cp) {
832         switch (*cp++) {
833         case '-':  /* literal options */
834             if (!*cp) {        /* ignore the rest of arguments */
835                 option_mode = 1;
836                 return;
837             }
838             for (i=0;i<sizeof(long_option)/sizeof(long_option[0]);i++) {
839                 int j;
840                 p = (unsigned char *)long_option[i].name;
841                 for (j=0;*p && *p++ == cp[j];j++);
842                 if (! *p && !cp[j]) break;
843             }
844             if (*p) return;
845             cp = (unsigned char *)long_option[i].alias;
846             if (!*cp){
847 #ifdef OVERWRITE
848                 if (strcmp(long_option[i].name, "overwrite") == 0){
849                     file_out = TRUE;
850                     overwrite = TRUE;
851                     continue;
852                 }
853 #endif
854 #ifdef CAP_URL_OPTION
855                 if (strcmp(long_option[i].name, "cap-input") == 0){
856                     cap_f = TRUE;
857                     continue;
858                 }
859                 if (strcmp(long_option[i].name, "url-input") == 0){
860                     url_f = TRUE;
861                     continue;
862                 }
863 #endif
864 #ifdef CHECK_OPTION
865                 if (strcmp(long_option[i].name, "no-output") == 0){
866                     noout_f = TRUE;
867                     continue;
868                 }
869                 if (strcmp(long_option[i].name, "debug") == 0){
870                     debug_f = TRUE;
871                     continue;
872                 }
873 #endif
874             }
875             continue;
876         case 'b':           /* buffered mode */
877             unbuf_f = FALSE;
878             continue;
879         case 'u':           /* non bufferd mode */
880             unbuf_f = TRUE;
881             continue;
882         case 't':           /* transparent mode */
883             nop_f = TRUE;
884             continue;
885         case 'j':           /* JIS output */
886         case 'n':
887             output_conv = j_oconv;
888             continue;
889         case 'e':           /* AT&T EUC output */
890             output_conv = e_oconv;
891             continue;
892         case 's':           /* SJIS output */
893             output_conv = s_oconv;
894             continue;
895         case 'l':           /* ISO8859 Latin-1 support, no conversion */
896             iso8859_f = TRUE;  /* Only compatible with ISO-2022-JP */
897             input_f = LATIN1_INPUT;
898             continue;
899         case 'i':           /* Kanji IN ESC-$-@/B */
900             if (*cp=='@'||*cp=='B') 
901                 kanji_intro = *cp++;
902             continue;
903         case 'o':           /* ASCII IN ESC-(-J/B */
904             if (*cp=='J'||*cp=='B'||*cp=='H') 
905                 ascii_intro = *cp++;
906             continue;
907         case 'h':
908             /*  
909                 bit:1   hira -> kata
910                 bit:2   kata -> hira
911             */
912             if ('9'>= *cp && *cp>='0') 
913                 hira_f |= (*cp++ -'0');
914             else 
915                 hira_f |= 1;
916             continue;
917         case 'r':
918             rot_f = TRUE;
919             continue;
920 #if defined(MSDOS) || defined(__OS2__) 
921         case 'T':
922             binmode_f = FALSE;
923             continue;
924 #endif
925 #ifndef PERL_XS
926         case 'V':
927             version();
928             exit(1);
929             break;
930         case 'v':
931             usage();
932             exit(1);
933             break;
934 #endif
935 #ifdef UTF8_OUTPUT_ENABLE
936         case 'w':           /* UTF-8 output */
937             if ('1'== cp[0] && '6'==cp[1]) {
938                 output_conv = w_oconv16; cp+=2;
939                 if (cp[0]=='L') {
940                     w_oconv16_begin_f=2; cp++;
941                 }
942             } else
943                 output_conv = w_oconv;
944             continue;
945 #endif
946 #ifdef UTF8_INPUT_ENABLE
947         case 'W':           /* UTF-8 input */
948             if ('1'== cp[0] && '6'==cp[1]) {
949                 input_f = UTF16_INPUT;
950             } else
951                 input_f = UTF8_INPUT;
952             continue;
953 #endif
954         /* Input code assumption */
955         case 'J':   /* JIS input */
956         case 'E':   /* AT&T EUC input */
957             input_f = JIS_INPUT;
958             continue;
959         case 'S':   /* MS Kanji input */
960             input_f = SJIS_INPUT;
961             if (x0201_f==NO_X0201) x0201_f=TRUE;
962             continue;
963         case 'Z':   /* Convert X0208 alphabet to asii */
964             /*  bit:0   Convert X0208
965                 bit:1   Convert Kankaku to one space
966                 bit:2   Convert Kankaku to two spaces
967                 bit:3   Convert HTML Entity
968             */
969             if ('9'>= *cp && *cp>='0') 
970                 alpha_f |= 1<<(*cp++ -'0');
971             else 
972                 alpha_f |= TRUE;
973             continue;
974         case 'x':   /* Convert X0201 kana to X0208 or X0201 Conversion */
975             x0201_f = FALSE;    /* No X0201->X0208 conversion */
976             /* accept  X0201
977                     ESC-(-I     in JIS, EUC, MS Kanji
978                     SI/SO       in JIS, EUC, MS Kanji
979                     SSO         in EUC, JIS, not in MS Kanji
980                     MS Kanji (0xa0-0xdf) 
981                output  X0201
982                     ESC-(-I     in JIS (0x20-0x5f)
983                     SSO         in EUC (0xa0-0xdf)
984                     0xa0-0xd    in MS Kanji (0xa0-0xdf) 
985             */
986             continue;
987         case 'X':   /* Assume X0201 kana */
988             /* Default value is NO_X0201 for EUC/MS-Kanji mix */
989             x0201_f = TRUE;
990             continue;
991         case 'F':   /* prserve new lines */
992             fold_preserve_f = TRUE;
993         case 'f':   /* folding -f60 or -f */
994             fold_f = TRUE;
995             fold_len = 0;
996             while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
997                 fold_len *= 10;
998                 fold_len += *cp++ - '0';
999             }
1000             if (!(0<fold_len && fold_len<BUFSIZ)) 
1001                 fold_len = DEFAULT_FOLD;
1002             if (*cp=='-') {
1003                 fold_margin = 0;
1004                 cp++;
1005                 while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
1006                     fold_margin *= 10;
1007                     fold_margin += *cp++ - '0';
1008                 }
1009             }
1010             continue;
1011         case 'm':   /* MIME support */
1012             if (*cp=='B'||*cp=='Q') {
1013                 mime_decode_mode = *cp++;
1014                 mimebuf_f = FIXED_MIME;
1015             } else if (*cp=='N') {
1016                 mime_f = TRUE; cp++;
1017             } else if (*cp=='S') {
1018                 mime_f = STRICT_MIME; cp++;
1019             } else if (*cp=='0') {
1020                 mime_f = FALSE; cp++;
1021             }
1022             continue;
1023         case 'M':   /* MIME output */
1024             if (*cp=='B') {
1025                 mimeout_mode = 'B';
1026                 mimeout_f = FIXED_MIME; cp++;
1027             } else if (*cp=='Q') {
1028                 mimeout_mode = 'Q';
1029                 mimeout_f = FIXED_MIME; cp++;
1030             } else {
1031                 mimeout_f = TRUE;
1032             }
1033             continue;
1034         case 'B':   /* Broken JIS support */
1035             /*  bit:0   no ESC JIS
1036                 bit:1   allow any x on ESC-(-x or ESC-$-x
1037                 bit:2   reset to ascii on NL
1038             */
1039             if ('9'>= *cp && *cp>='0') 
1040                 broken_f |= 1<<(*cp++ -'0');
1041             else 
1042                 broken_f |= TRUE;
1043             continue;
1044 #ifndef PERL_XS
1045         case 'O':/* for Output file */
1046             file_out = TRUE;
1047             continue;
1048 #endif
1049         case 'c':/* add cr code */
1050             crmode_f = CRLF;
1051             continue;
1052         case 'd':/* delete cr code */
1053             crmode_f = NL;
1054             continue;
1055         case 'I':   /* ISO-2022-JP output */
1056             iso2022jp_f = TRUE;
1057             continue;
1058         case 'L':  /* line mode */
1059             if (*cp=='u') {         /* unix */
1060                 crmode_f = NL; cp++;
1061             } else if (*cp=='m') { /* mac */
1062                 crmode_f = CR; cp++;
1063             } else if (*cp=='w') { /* windows */
1064                 crmode_f = CRLF; cp++;
1065             } else if (*cp=='0') { /* no conversion  */
1066                 crmode_f = 0; cp++;
1067             }
1068             continue;
1069         case ' ':    
1070         /* module muliple options in a string are allowed for Perl moudle  */
1071             while(*cp && *cp!='-') cp++;
1072             if(*cp=='-') cp++;
1073             continue;
1074         default:
1075             /* bogus option but ignored */
1076             continue;
1077         }
1078     }
1079 }
1080
1081 #ifdef ANSI_C_PROTOTYPE
1082 void set_iconv(int f, int (*iconv_func)(int c2,int c1,int c0))
1083 #else
1084 void set_iconv(f, iconv_func)
1085      int f;
1086      int (*iconv_func)();
1087 #endif
1088 {
1089 #ifdef CHECK_OPTION
1090     static int (*iconv_for_check)() = 0;
1091 #endif
1092 #ifdef INPUT_CODE_FIX
1093     if (f || !input_f)
1094 #endif
1095         if (estab_f != f){
1096             estab_f = f;
1097         }
1098
1099     if (iconv_func
1100 #ifdef INPUT_CODE_FIX
1101         && (f == -TRUE || !input_f) /* -TRUE means "FORCE" */
1102 #endif
1103         ){
1104         iconv = iconv_func;
1105     }
1106 #ifdef CHECK_OPTION
1107     if (estab_f && iconv_for_check != iconv){
1108 #ifdef UTF8_INPUT_ENABLE
1109         if (iconv == w_iconv) debug("UTF-8\n");
1110         if (iconv == w_iconv16) debug("UTF-16\n");
1111 #endif
1112         if (iconv == s_iconv) debug("Shift_JIS\n");
1113         if (iconv == e_iconv) debug("EUC-JP\n");
1114         iconv_for_check = iconv;
1115     }
1116 #endif
1117 }
1118
1119 #define SCORE_KANA     (1)                      /* \e$B$$$o$f$kH>3Q%+%J\e(B */
1120 #define SCORE_DEPEND   (SCORE_KANA << 1)        /* \e$B5!<o0MB8J8;z\e(B */
1121 #define SCORE_NO_EXIST (SCORE_DEPEND << 1)      /* \e$BB8:_$7$J$$J8;z\e(B */
1122 #define SCORE_ERROR    (SCORE_NO_EXIST << 1)    /* \e$B%(%i!<\e(B */
1123 int score_table_A0[] = {
1124     0, 0, 0, 0,
1125     0, 0, 0, 0,
1126     0, SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND,
1127     SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND, SCORE_NO_EXIST,
1128 };
1129
1130 int score_table_F0[] = {
1131     0, 0, 0, 0,
1132     0, SCORE_DEPEND, SCORE_NO_EXIST, SCORE_NO_EXIST,
1133     SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND,
1134     SCORE_DEPEND, SCORE_NO_EXIST, SCORE_NO_EXIST, SCORE_ERROR,
1135 };
1136
1137 void code_score(ptr)
1138      struct input_code *ptr;
1139 {
1140     int s = ptr->score;
1141     int c2 = ptr->buf[0];
1142     int c1 = ptr->buf[1];
1143     if (c2 < 0){
1144         s |= SCORE_ERROR;
1145     }else if ((c2 & 0xf0) == 0xa0){
1146         s |= score_table_A0[c2 & 0x0f];
1147     }else if ((c2 & 0xf0) == 0xf0){
1148         s |= score_table_F0[c2 & 0x0f];
1149     }else if (c2 == SSO){
1150         s |= SCORE_KANA;
1151     }
1152 #ifdef UTF8_OUTPUT_ENABLE
1153     else if (!e2w_conv(c2, c1)){
1154         s |= SCORE_NO_EXIST;
1155     }
1156 #endif
1157     ptr->score = s;
1158 }
1159
1160 void status_disable(ptr)
1161 struct input_code *ptr;
1162 {
1163     ptr->stat = -1;
1164     ptr->buf[0] = -1;
1165     code_score(ptr);
1166     if (iconv == ptr->iconv_func) set_iconv(FALSE, 0);
1167 }
1168
1169 void status_push_ch(ptr, c)
1170      struct input_code *ptr;
1171      int c;
1172 {
1173     ptr->buf[ptr->index++] = c;
1174 }
1175
1176 void status_reset(ptr)
1177      struct input_code *ptr;
1178 {
1179     ptr->stat = 0;
1180     ptr->score = 0;
1181     ptr->index = 0;
1182 }
1183
1184 void status_check(ptr, c)
1185      struct input_code *ptr;
1186      int c;
1187 {
1188     if (c <= DEL && estab_f){
1189         status_reset(ptr);
1190     }
1191 }
1192
1193 void s_status(ptr, c)
1194      struct input_code *ptr;
1195      int c;
1196 {
1197     switch(ptr->stat){
1198       case -1:
1199           status_check(ptr, c);
1200           break;
1201       case 0:
1202           if (c <= DEL){
1203               break;
1204           }else if (0xa1 <= c && c <= 0xef){
1205               status_push_ch(ptr, SSO);
1206               status_push_ch(ptr, c);
1207               code_score(ptr);
1208               status_reset(ptr);
1209           }else if ((0x81 <= c && c < 0xa0) || (0xe0 <= c && c <= 0xea)){
1210               ptr->stat = 1;
1211               status_push_ch(ptr, c);
1212           }else{
1213               status_disable(ptr);
1214           }
1215           break;
1216       case 1:
1217           if ((0x40 <= c && c <= 0x7e) || (0x80 <= c && c <= 0xfd)){
1218               status_push_ch(ptr, c);
1219               s2e_conv(ptr->buf[0], ptr->buf[1], &ptr->buf[0], &ptr->buf[1]);
1220               code_score(ptr);
1221               status_reset(ptr);
1222           }else{
1223               status_disable(ptr);
1224           }
1225           break;
1226     }
1227 }
1228
1229 void e_status(ptr, c)
1230      struct input_code *ptr;
1231      int c;
1232 {
1233     switch (ptr->stat){
1234       case -1:
1235           status_check(ptr, c);
1236           break;
1237       case 0:
1238           if (c <= DEL){
1239               break;
1240           }else if (SSO == c || (0xa1 <= c && c <= 0xfe)){
1241               ptr->stat = 1;
1242               status_push_ch(ptr, c);
1243           }else{
1244               status_disable(ptr);
1245           }
1246           break;
1247       case 1:
1248           if (0xa1 <= c && c <= 0xfe){
1249               status_push_ch(ptr, c);
1250               code_score(ptr);
1251               status_reset(ptr);
1252           }else{
1253               status_disable(ptr);
1254           }
1255           break;
1256     }
1257 }
1258
1259 #ifdef UTF8_INPUT_ENABLE
1260 void w_status(ptr, c)
1261      struct input_code *ptr;
1262      int c;
1263 {
1264     switch (ptr->stat){
1265       case -1:
1266           status_check(ptr, c);
1267           break;
1268       case 0:
1269           if (c <= DEL){
1270               break;
1271           }else if (0xc0 <= c && c <= 0xdf){
1272               ptr->stat = 1;
1273               status_push_ch(ptr, c);
1274           }else if (0xe0 <= c && c <= 0xef){
1275               ptr->stat = 2;
1276               status_push_ch(ptr, c);
1277           }else{
1278               status_disable(ptr);
1279           }
1280           break;
1281       case 1:
1282       case 2:
1283           if (0x80 <= c && c <= 0xbf){
1284               status_push_ch(ptr, c);
1285               if (ptr->index > ptr->stat){
1286                   w2e_conv(ptr->buf[0], ptr->buf[1], ptr->buf[2],
1287                            &ptr->buf[0], &ptr->buf[1]);
1288                   code_score(ptr);
1289                   status_reset(ptr);
1290               }
1291           }else{
1292               status_disable(ptr);
1293           }
1294           break;
1295     }
1296 }
1297 #endif
1298
1299 void
1300 code_status(c)
1301      int c;
1302 {
1303     int action_flag = 1;
1304     struct input_code *result = 0;
1305     struct input_code *p = input_code_list;
1306     while (p->name){
1307         (p->status_func)(p, c);
1308         if (p->stat > 0){
1309             action_flag = 0;
1310         }else if(p->stat == 0){
1311             if (result){
1312                 action_flag = 0;
1313             }else{
1314                 result = p;
1315             }
1316         }
1317         ++p;
1318     }
1319
1320     if (action_flag){
1321         if (result){
1322             set_iconv(TRUE, result->iconv_func);
1323         }else if (c <= DEL){
1324             struct input_code *ptr = input_code_list;
1325             while (ptr->name){
1326                 status_reset(ptr);
1327                 ++ptr;
1328             }
1329         }
1330     }
1331 }
1332
1333 int 
1334 std_getc(f)
1335 FILE *f;
1336 {
1337     return getc(f);
1338 }
1339
1340 int 
1341 std_ungetc(c,f)
1342 int c;
1343 FILE *f;
1344 {
1345     return ungetc(c,f);
1346 }
1347
1348 void 
1349 std_putc(c)
1350 int c;
1351 {
1352     if(c!=EOF)
1353       putchar(c);
1354 }
1355
1356 int
1357 noconvert(f)
1358     FILE  *f;
1359 {
1360     int    c;
1361
1362     while ((c = (*i_getc)(f)) != EOF)
1363       (*o_putc)(c);
1364     return 1;
1365 }
1366
1367
1368 void
1369 module_connection()
1370 {
1371     oconv = output_conv; 
1372     o_putc = std_putc;
1373
1374     /* replace continucation module, from output side */
1375
1376     /* output redicrection */
1377 #ifdef CHECK_OPTION
1378     if (noout_f){
1379         o_putc = no_putc;
1380     }
1381 #endif
1382     if (mimeout_f) {
1383         o_mputc = o_putc;
1384         o_putc = mime_putc;
1385         if (mimeout_f == TRUE) {
1386             o_base64conv = oconv; oconv = base64_conv;
1387         }
1388         /* base64_count = 0; */
1389     }
1390
1391     if (crmode_f) {
1392         o_crconv = oconv; oconv = cr_conv;
1393     }
1394     if (rot_f) {
1395         o_rot_conv = oconv; oconv = rot_conv;
1396     }
1397     if (iso2022jp_f) {
1398         o_iso2022jp_check_conv = oconv; oconv = iso2022jp_check_conv;
1399     }
1400     if (hira_f) {
1401         o_hira_conv = oconv; oconv = hira_conv;
1402     }
1403     if (fold_f) {
1404         o_fconv = oconv; oconv = fold_conv;
1405         f_line = 0;
1406     }
1407     if (alpha_f || x0201_f) {
1408         o_zconv = oconv; oconv = z_conv;
1409     }
1410
1411     i_getc = std_getc;
1412     /* input redicrection */
1413 #ifdef CAP_URL_OPTION
1414     if (cap_f){
1415         i_cgetc = i_getc; i_getc = cap_getc;
1416         i_cungetc = i_ungetc; i_ungetc= cap_ungetc;
1417     }
1418     if (url_f){
1419         i_ugetc = i_getc; i_getc = url_getc;
1420         i_uungetc = i_ungetc; i_ungetc= url_ungetc;
1421     }
1422 #endif
1423     if (mime_f && mimebuf_f==FIXED_MIME) {
1424         i_mgetc = i_getc; i_getc = mime_getc;
1425         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
1426     }
1427     if (broken_f & 1) {
1428         i_bgetc = i_getc; i_getc = broken_getc;
1429         i_bungetc = i_ungetc; i_ungetc = broken_ungetc;
1430     }
1431     if (input_f == JIS_INPUT || input_f == LATIN1_INPUT) {
1432         set_iconv(-TRUE, e_iconv);
1433     } else if (input_f == SJIS_INPUT) {
1434         set_iconv(-TRUE, s_iconv);
1435 #ifdef UTF8_INPUT_ENABLE
1436     } else if (input_f == UTF8_INPUT) {
1437         set_iconv(-TRUE, w_iconv);
1438     } else if (input_f == UTF16_INPUT) {
1439         set_iconv(-TRUE, w_iconv16);
1440 #endif
1441     } else {
1442         set_iconv(FALSE, e_iconv);
1443     }
1444
1445     {
1446         struct input_code *p = input_code_list;
1447         while (p->name){
1448             status_reset(p++);
1449         }
1450     }
1451 }
1452
1453 /*
1454    Conversion main loop. Code detection only. 
1455  */
1456
1457 int
1458 kanji_convert(f)
1459     FILE  *f;
1460 {
1461     int    c1,
1462                     c2;
1463
1464     module_connection();
1465     c2 = 0;
1466
1467
1468     input_mode = ASCII;
1469     output_mode = ASCII;
1470     shift_mode = FALSE;
1471
1472 #define NEXT continue      /* no output, get next */
1473 #define SEND ;             /* output c1 and c2, get next */
1474 #define LAST break         /* end of loop, go closing  */
1475
1476     while ((c1 = (*i_getc)(f)) != EOF) {
1477         code_status(c1);
1478         if (c2) {
1479             /* second byte */
1480             if (c2 > DEL) {
1481                 /* in case of 8th bit is on */
1482                 if (!estab_f) {
1483                     /* in case of not established yet */
1484                     /* It is still ambiguious */
1485                     if (h_conv(f, c2, c1)==EOF) 
1486                         LAST;
1487                     else 
1488                         c2 = 0;
1489                     NEXT;
1490                 } else
1491                     /* in case of already established */
1492                     if (c1 < AT) {
1493                         /* ignore bogus code */
1494                         c2 = 0;
1495                         NEXT;
1496                     } else
1497                         SEND;
1498             } else
1499                 /* second byte, 7 bit code */
1500                 /* it might be kanji shitfted */
1501                 if ((c1 == DEL) || (c1 <= SPACE)) {
1502                     /* ignore bogus first code */
1503                     c2 = 0;
1504                     NEXT;
1505                 } else
1506                     SEND;
1507         } else {
1508             /* first byte */
1509             if (
1510 #ifdef UTF8_INPUT_ENABLE
1511                 iconv == w_iconv16
1512 #else
1513                 0
1514 #endif
1515                 ) {
1516                 c2 = c1;
1517                 c1 = (*i_getc)(f);
1518                 SEND;
1519             } else if (c1 > DEL) {
1520                 /* 8 bit code */
1521                 if (!estab_f && !iso8859_f) {
1522                     /* not established yet */
1523                     c2 = c1;
1524                     NEXT;
1525                 } else { /* estab_f==TRUE */
1526                     if (iso8859_f) {
1527                         c2 = ISO8859_1;
1528                         c1 &= 0x7f;
1529                         SEND;
1530                     } else if (SSP<=c1 && c1<0xe0 && iconv == s_iconv) {
1531                         /* SJIS X0201 Case... */
1532                         if(iso2022jp_f && x0201_f==NO_X0201) {
1533                             (*oconv)(GETA1, GETA2);
1534                             NEXT;
1535                         } else {
1536                             c2 = X0201;
1537                             c1 &= 0x7f;
1538                             SEND;
1539                         }
1540                     } else if (c1==SSO && iconv != s_iconv) {
1541                         /* EUC X0201 Case */
1542                         c1 = (*i_getc)(f);  /* skip SSO */
1543                         code_status(c1);
1544                         if (SSP<=c1 && c1<0xe0) {
1545                             if(iso2022jp_f &&  x0201_f==NO_X0201) {
1546                                 (*oconv)(GETA1, GETA2);
1547                                 NEXT;
1548                             } else {
1549                                 c2 = X0201;
1550                                 c1 &= 0x7f;
1551                                 SEND;
1552                             }
1553                         } else  { /* bogus code, skip SSO and one byte */
1554                             NEXT;
1555                         }
1556                     } else {
1557                        /* already established */
1558                        c2 = c1;
1559                        NEXT;
1560                     }
1561                 }
1562             } else if ((c1 > SPACE) && (c1 != DEL)) {
1563                 /* in case of Roman characters */
1564                 if (shift_mode) { 
1565                     /* output 1 shifted byte */
1566                     if (iso8859_f) {
1567                         c2 = ISO8859_1;
1568                         SEND;
1569                     } else if (SPACE<=c1 && c1<(0xe0&0x7f) ){
1570                       /* output 1 shifted byte */
1571                         if(iso2022jp_f && x0201_f==NO_X0201) {
1572                             (*oconv)(GETA1, GETA2);
1573                             NEXT;
1574                         } else {
1575                             c2 = X0201;
1576                             SEND;
1577                         }
1578                     } else {
1579                         /* look like bogus code */
1580                         NEXT;
1581                     }
1582                 } else if (input_mode == X0208) {
1583                     /* in case of Kanji shifted */
1584                     c2 = c1;
1585                     NEXT;
1586                 } else if (c1 == '=' && mime_f && !mime_decode_mode ) {
1587                     /* Check MIME code */
1588                     if ((c1 = (*i_getc)(f)) == EOF) {
1589                         (*oconv)(0, '=');
1590                         LAST;
1591                     } else if (c1 == '?') {
1592                         /* =? is mime conversion start sequence */
1593                         if(mime_f == STRICT_MIME) {
1594                             /* check in real detail */
1595                             if (mime_begin_strict(f) == EOF) 
1596                                 LAST;
1597                             else
1598                                 NEXT;
1599                         } else if (mime_begin(f) == EOF) 
1600                             LAST;
1601                         else
1602                             NEXT;
1603                     } else {
1604                         (*oconv)(0, '=');
1605                         (*i_ungetc)(c1,f);
1606                         NEXT;
1607                     }
1608                 } else {
1609                     /* normal ASCII code */ 
1610                     SEND;
1611                 }
1612             } else if (c1 == SI) {
1613                 shift_mode = FALSE; 
1614                 NEXT;
1615             } else if (c1 == SO) {
1616                 shift_mode = TRUE; 
1617                 NEXT;
1618             } else if (c1 == ESC ) {
1619                 if ((c1 = (*i_getc)(f)) == EOF) {
1620                     /*  (*oconv)(0, ESC); don't send bogus code */
1621                     LAST;
1622                 } else if (c1 == '$') {
1623                     if ((c1 = (*i_getc)(f)) == EOF) {
1624                         /*
1625                         (*oconv)(0, ESC); don't send bogus code 
1626                         (*oconv)(0, '$'); */
1627                         LAST;
1628                     } else if (c1 == '@'|| c1 == 'B') {
1629                         /* This is kanji introduction */
1630                         input_mode = X0208;
1631                         shift_mode = FALSE;
1632                         NEXT;
1633                     } else if (c1 == '(') {
1634                         if ((c1 = (*i_getc)(f)) == EOF) {
1635                             /* don't send bogus code 
1636                             (*oconv)(0, ESC);
1637                             (*oconv)(0, '$');
1638                             (*oconv)(0, '(');
1639                                 */
1640                             LAST;
1641                         } else if (c1 == '@'|| c1 == 'B') {
1642                             /* This is kanji introduction */
1643                             input_mode = X0208;
1644                             shift_mode = FALSE;
1645                             NEXT;
1646                         } else {
1647                             /* could be some special code */
1648                             (*oconv)(0, ESC);
1649                             (*oconv)(0, '$');
1650                             (*oconv)(0, '(');
1651                             (*oconv)(0, c1);
1652                             NEXT;
1653                         }
1654                     } else if (broken_f&0x2) {
1655                         /* accept any ESC-(-x as broken code ... */
1656                         input_mode = X0208;
1657                         shift_mode = FALSE;
1658                         NEXT;
1659                     } else {
1660                         (*oconv)(0, ESC);
1661                         (*oconv)(0, '$');
1662                         (*oconv)(0, c1);
1663                         NEXT;
1664                     }
1665                 } else if (c1 == '(') {
1666                     if ((c1 = (*i_getc)(f)) == EOF) {
1667                         /* don't send bogus code 
1668                         (*oconv)(0, ESC);
1669                         (*oconv)(0, '('); */
1670                         LAST;
1671                     } else {
1672                         if (c1 == 'I') {
1673                             /* This is X0201 kana introduction */
1674                             input_mode = X0201; shift_mode = X0201;
1675                             NEXT;
1676                         } else if (c1 == 'B' || c1 == 'J' || c1 == 'H') {
1677                             /* This is X0208 kanji introduction */
1678                             input_mode = ASCII; shift_mode = FALSE;
1679                             NEXT;
1680                         } else if (broken_f&0x2) {
1681                             input_mode = ASCII; shift_mode = FALSE;
1682                             NEXT;
1683                         } else {
1684                             (*oconv)(0, ESC);
1685                             (*oconv)(0, '(');
1686                             /* maintain various input_mode here */
1687                             SEND;
1688                         }
1689                     }
1690                } else if ( c1 == 'N' || c1 == 'n' ){
1691                    /* SS2 */
1692                    c1 = (*i_getc)(f);  /* skip SS2 */
1693                    if ( SPACE<=c1 && c1 < 0xe0 ) {
1694                        c2 = X0201;
1695                        SEND;
1696                    }
1697                 } else {
1698                     /* lonely ESC  */
1699                     (*oconv)(0, ESC);
1700                     SEND;
1701                 }
1702             } else if ((c1 == NL || c1 == CR) && broken_f&4) {
1703                 input_mode = ASCII; set_iconv(FALSE, 0);
1704                 SEND;
1705             } else 
1706                 SEND;
1707         }
1708         /* send: */
1709         if (input_mode == X0208) 
1710             (*oconv)(c2, c1);  /* this is JIS, not SJIS/EUC case */
1711         else if (input_mode) 
1712             (*oconv)(input_mode, c1);  /* other special case */
1713         else if ((*iconv)(c2, c1, 0) < 0){  /* can be EUC/SJIS */
1714             int c0 = (*i_getc)(f);
1715             if (c0 != EOF){
1716                 code_status(c0);
1717                 (*iconv)(c2, c1, c0);
1718             }
1719         }
1720
1721         c2 = 0;
1722         continue;
1723         /* goto next_word */
1724     }
1725
1726     /* epilogue */
1727     (*iconv)(EOF, 0, 0);
1728     return 1;
1729 }
1730
1731 int
1732 h_conv(f, c2, c1)
1733     FILE  *f;
1734     int    c1,
1735                     c2;
1736 {
1737     int    wc,c3;
1738
1739
1740     /** it must NOT be in the kanji shifte sequence      */
1741     /** it must NOT be written in JIS7                   */
1742     /** and it must be after 2 byte 8bit code            */
1743
1744     hold_count = 0;
1745     push_hold_buf(c2);
1746     push_hold_buf(c1);
1747     c2 = 0;
1748
1749     while ((c1 = (*i_getc)(f)) != EOF) {
1750         if (c1 == ESC){
1751             (*i_ungetc)(c1,f);
1752             break;
1753         }
1754         code_status(c1);
1755         if (push_hold_buf(c1) == EOF || estab_f){
1756             break;
1757         }
1758     }
1759
1760     if (!estab_f){
1761         struct input_code *p = input_code_list;
1762         struct input_code *result = p;
1763         while (p->name){
1764             if (p->score < result->score){
1765                 result = p;
1766             }
1767             ++p;
1768         }
1769         set_iconv(FALSE, p->iconv_func);
1770     }
1771
1772
1773     /** now,
1774      ** 1) EOF is detected, or
1775      ** 2) Code is established, or
1776      ** 3) Buffer is FULL (but last word is pushed)
1777      **
1778      ** in 1) and 3) cases, we continue to use
1779      ** Kanji codes by oconv and leave estab_f unchanged.
1780      **/
1781
1782     wc = 0;
1783     while (wc < hold_count){
1784         c2 = hold_buf[wc++];
1785         if (c2 <= DEL){
1786             (*iconv)(0, c2, 0);
1787             continue;
1788         }else if (iconv == s_iconv && 0xa1 <= c2 && c2 <= 0xdf){
1789             (*iconv)(X0201, c2, 0);
1790             continue;
1791         }
1792         if (wc < hold_count){
1793             c1 = hold_buf[wc++];
1794         }else{
1795             c1 = (*i_getc)(f);
1796             if (c1 == EOF) break;
1797             code_status(c1);
1798         }
1799         if ((*iconv)(c2, c1, 0) < 0){
1800             int c0;
1801             if (wc < hold_count){
1802                 c0 = hold_buf[wc++];
1803             }else{
1804                 c0 = (*i_getc)(f);
1805                 if (c0 == EOF) break;
1806                 code_status(c0);
1807             }
1808             (*iconv)(c2, c1, c0);
1809             c1 = c0;
1810         }
1811     }
1812     c3=c1;
1813     return c3;
1814 }
1815
1816
1817
1818 int
1819 push_hold_buf(c2)
1820      int             c2;
1821 {
1822     if (hold_count >= HOLD_SIZE*2)
1823         return (EOF);
1824     hold_buf[hold_count++] = c2;
1825     return ((hold_count >= HOLD_SIZE*2) ? EOF : hold_count);
1826 }
1827
1828 int s2e_conv(c2, c1, p2, p1)
1829      int c2, c1;
1830      int *p2, *p1;
1831 {
1832     c2 = c2 + c2 - ((c2 <= 0x9f) ? SJ0162 : SJ6394);
1833     if (c1 < 0x9f)
1834         c1 = c1 - ((c1 > DEL) ? SPACE : 0x1f);
1835     else {
1836         c1 = c1 - 0x7e;
1837         c2++;
1838     }
1839     if (p2) *p2 = c2;
1840     if (p1) *p1 = c1;
1841     return (c2 << 8) | c1;
1842 }
1843
1844 int
1845 s_iconv(c2, c1, c0)
1846     int    c2,
1847                     c1, c0;
1848 {
1849     if (c2 == X0201) {
1850         c1 &= 0x7f;
1851     } else if ((c2 == EOF) || (c2 == 0) || c2 < SPACE) {
1852         /* NOP */
1853     } else {
1854         s2e_conv(c2, c1, &c2, &c1);
1855     }
1856     (*oconv)(c2, c1);
1857     return 0;
1858 }
1859
1860 int
1861 e_iconv(c2, c1, c0)
1862     int    c2,
1863                     c1, c0;
1864 {
1865     if (c2 == X0201) {
1866         c1 &= 0x7f;
1867     } else if ((c2 == EOF) || (c2 == 0) || c2 < SPACE) {
1868         /* NOP */
1869     } else {
1870         c1 &= 0x7f;
1871         c2 &= 0x7f;
1872     }
1873     (*oconv)(c2, c1);
1874     return 0;
1875 }
1876
1877 #ifdef UTF8_INPUT_ENABLE
1878 int
1879 w2e_conv(c2, c1, c0, p2, p1)
1880     int    c2, c1, c0;
1881     int *p2, *p1;
1882 {
1883     extern unsigned short * utf8_to_euc_2bytes[];
1884     extern unsigned short ** utf8_to_euc_3bytes[];
1885
1886     if (0xc0 <= c2 && c2 <= 0xef) {
1887         unsigned short **pp;
1888
1889         if (0xe0 <= c2) {
1890             if (c0 == 0) return -1;
1891             pp = utf8_to_euc_3bytes[c2 - 0x80];
1892             return w_iconv_common(c1, c0, pp, sizeof_utf8_to_euc_C2, p2, p1);
1893         } else {
1894             return w_iconv_common(c2, c1, utf8_to_euc_2bytes, sizeof_utf8_to_euc_2bytes, p2, p1);
1895         }
1896     } else if (c2 == X0201) {
1897         c1 &= 0x7f;
1898     }
1899     if (p2) *p2 = c2;
1900     if (p1) *p1 = c1;
1901     return 0;
1902 }
1903
1904 int
1905 w_iconv(c2, c1, c0)
1906     int    c2,
1907                     c1, c0;
1908 {
1909     int ret = w2e_conv(c2, c1, c0, &c2, &c1);
1910     if (ret == 0){
1911         (*oconv)(c2, c1);
1912     }
1913     return ret;
1914 }
1915
1916 int
1917 w_iconv16(c2, c1, c0)
1918     int    c2, c1,c0;
1919 {
1920     extern unsigned short * utf8_to_euc_2bytes[];
1921     extern unsigned short ** utf8_to_euc_3bytes[];
1922     unsigned short **pp;
1923     unsigned short val;
1924     int psize;
1925     int ret;
1926
1927     if (c2==0376 && c1==0377){
1928         utf16_mode = UTF16_INPUT;
1929         return 0;    
1930     } else if (c2==0377 && c1==0376){
1931         utf16_mode = UTF16BE_INPUT;
1932         return 0;    
1933     }
1934     if (utf16_mode == UTF16BE_INPUT) {
1935         int tmp;
1936         tmp=c1; c1=c2; c2=tmp;
1937     }
1938     if (c2==0 || c2==EOF) {
1939         (*oconv)(c2, c1);
1940         return 0;
1941     }
1942     val = ((c2<<8)&0xff00) + c1;
1943     if (c2 < 0x8){
1944         c0 = (0x80 | (c1 & 0x3f));
1945         c1 = (0xc0 | (val >> 6));
1946         pp = utf8_to_euc_2bytes;
1947         psize = sizeof_utf8_to_euc_2bytes;
1948     }else{
1949         c0 = (0x80 | (c1 & 0x3f));
1950         c2 = (0xe0 | (val >> 12));
1951         c1 = (0x80 | ((val >> 6) & 0x3f));
1952         if (c0 == 0) return -1;
1953         if (0<=c2-0x80 && c2-0x80 <sizeof_utf8_to_euc_3bytes){
1954             pp = utf8_to_euc_3bytes[c2 - 0x80];
1955             psize = sizeof_utf8_to_euc_C2;
1956         }else{
1957             return 0;
1958         }
1959     }
1960     ret = w_iconv_common(c1, c0, pp, psize, &c2, &c1);
1961     if (ret) return ret;
1962     (*oconv)(c2, c1);
1963     return 0;
1964 }
1965
1966 int
1967 w_iconv_common(c1, c0, pp, psize, p2, p1)
1968     int    c1,c0;
1969     unsigned short **pp;
1970     int psize;
1971     int *p2, *p1;
1972 {
1973     int c2;
1974     unsigned short *p ;
1975     unsigned short val;
1976
1977     if (pp == 0) return 1;
1978
1979     c1 -= 0x80;
1980     if (c1 < 0 || psize <= c1) return 1;
1981     p = pp[c1];
1982     if (p == 0)  return 1;
1983
1984     c0 -= 0x80;
1985     if (c0 < 0 || sizeof_utf8_to_euc_E5B8 <= c0) return 1;
1986     val = p[c0];
1987     if (val == 0) return 1;
1988
1989     c2 = val >> 8;
1990     if (c2 == SO) c2 = X0201;
1991     c1 = val & 0x7f;
1992     if (p2) *p2 = c2;
1993     if (p1) *p1 = c1;
1994     return 0;
1995 }
1996
1997 #endif
1998
1999 #ifdef UTF8_OUTPUT_ENABLE
2000 int
2001 e2w_conv(c2, c1)
2002     int    c2, c1;
2003 {
2004     extern unsigned short euc_to_utf8_1byte[];
2005     extern unsigned short * euc_to_utf8_2bytes[];
2006     unsigned short *p;
2007
2008     if (c2 == X0201) {
2009         p = euc_to_utf8_1byte;
2010     } else {
2011         c2 &= 0x7f;
2012         c2 = (c2&0x7f) - 0x21;
2013         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
2014             p = euc_to_utf8_2bytes[c2];
2015         else
2016             return 0;
2017     }
2018     if (!p) return 0;
2019     c1 = (c1 & 0x7f) - 0x21;
2020     if (0<=c1 && c1<sizeof_euc_to_utf8_1byte)
2021         return p[c1];
2022     return 0;
2023 }
2024
2025 void
2026 w_oconv(c2, c1)
2027     int    c2,
2028                     c1;
2029 {
2030     if (c2 == EOF) {
2031         (*o_putc)(EOF);
2032         return;
2033     } else if (c2 == 0) { 
2034         output_mode = ASCII;
2035         (*o_putc)(c1);
2036     } else if (c2 == ISO8859_1) {
2037         output_mode = ISO8859_1;
2038         (*o_putc)(c1 | 0x080);
2039     } else {
2040         unsigned short val = (unsigned short)e2w_conv(c2, c1);
2041         output_mode = UTF8;
2042
2043         if (0 < val && val < 0x80){
2044             (*o_putc)(val);
2045         }else if (val < 0x800){
2046             (*o_putc)(0xc0 | (val >> 6));
2047             (*o_putc)(0x80 | (val & 0x3f));
2048         }else{
2049             (*o_putc)(0xe0 | (val >> 12));
2050             (*o_putc)(0x80 | ((val >> 6) & 0x3f));
2051             (*o_putc)(0x80 | (val & 0x3f));
2052         }
2053     }
2054 }
2055
2056 void
2057 w_oconv16(c2, c1)
2058     int    c2,
2059                     c1;
2060 {
2061     
2062     if (w_oconv16_begin_f==2) {
2063         (*o_putc)('\376');
2064         (*o_putc)('\377');
2065         w_oconv16_begin_f=1;
2066     }
2067     if (c2 == EOF) {
2068         (*o_putc)(EOF);
2069         return;
2070     } else if (c2 == 0) { 
2071         (*o_putc)(0);
2072         (*o_putc)(c1);
2073     } else if (c2 == ISO8859_1) {
2074         (*o_putc)(0);
2075         (*o_putc)(c1 | 0x080);
2076     } else {
2077         unsigned short val = (unsigned short)e2w_conv(c2, c1);
2078         (*o_putc)((val&0xff00)>>8);
2079         (*o_putc)(val&0xff);
2080     }
2081 }
2082
2083 #endif
2084
2085 void
2086 e_oconv(c2, c1)
2087     int    c2,
2088                     c1;
2089 {
2090     if (c2 == EOF) {
2091         (*o_putc)(EOF);
2092         return;
2093     } else if (c2 == 0) { 
2094         output_mode = ASCII;
2095         (*o_putc)(c1);
2096     } else if (c2 == X0201) {
2097         output_mode = JAPANESE_EUC;
2098         (*o_putc)(SSO); (*o_putc)(c1|0x80);
2099     } else if (c2 == ISO8859_1) {
2100         output_mode = ISO8859_1;
2101         (*o_putc)(c1 | 0x080);
2102     } else {
2103         if ((c1<0x20 || 0x7e<c1) ||
2104            (c2<0x20 || 0x7e<c2)) {
2105             set_iconv(FALSE, 0);
2106             return; /* too late to rescue this char */
2107         }
2108         output_mode = JAPANESE_EUC;
2109         (*o_putc)(c2 | 0x080);
2110         (*o_putc)(c1 | 0x080);
2111     }
2112 }
2113
2114
2115
2116 void
2117 s_oconv(c2, c1)
2118     int    c2,
2119                     c1;
2120 {
2121     if (c2 == EOF) {
2122         (*o_putc)(EOF);
2123         return;
2124     } else if (c2 == 0) {
2125         output_mode = ASCII;
2126         (*o_putc)(c1);
2127     } else if (c2 == X0201) {
2128         output_mode = SHIFT_JIS;
2129         (*o_putc)(c1|0x80);
2130     } else if (c2 == ISO8859_1) {
2131         output_mode = ISO8859_1;
2132         (*o_putc)(c1 | 0x080);
2133     } else {
2134         if ((c1<0x20 || 0x7e<c1) ||
2135            (c2<0x20 || 0x7e<c2)) {
2136             set_iconv(FALSE, 0);
2137             return; /* too late to rescue this char */
2138         }
2139         output_mode = SHIFT_JIS;
2140         (*o_putc)((((c2 - 1) >> 1) + ((c2 <= 0x5e) ? 0x71 : 0xb1)));
2141         (*o_putc)((c1 + ((c2 & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e)));
2142     }
2143 }
2144
2145 void
2146 j_oconv(c2, c1)
2147     int    c2,
2148                     c1;
2149 {
2150     if (c2 == EOF) {
2151         if (output_mode !=ASCII && output_mode!=ISO8859_1) {
2152             (*o_putc)(ESC);
2153             (*o_putc)('(');
2154             (*o_putc)(ascii_intro);
2155             output_mode = ASCII;
2156         }
2157         (*o_putc)(EOF);
2158     } else if (c2==X0201) {
2159         if (output_mode!=X0201) {
2160             output_mode = X0201;
2161             (*o_putc)(ESC);
2162             (*o_putc)('(');
2163             (*o_putc)('I');
2164         }
2165         (*o_putc)(c1);
2166     } else if (c2==ISO8859_1) {
2167             /* iso8859 introduction, or 8th bit on */
2168             /* Can we convert in 7bit form using ESC-'-'-A ? 
2169                Is this popular? */
2170         output_mode = ISO8859_1;
2171         (*o_putc)(c1|0x80);
2172     } else if (c2 == 0) {
2173         if (output_mode !=ASCII && output_mode!=ISO8859_1) {
2174             (*o_putc)(ESC);
2175             (*o_putc)('(');
2176             (*o_putc)(ascii_intro);
2177             output_mode = ASCII;
2178         }
2179         (*o_putc)(c1);
2180     } else {
2181         if (output_mode != X0208) {
2182             output_mode = X0208;
2183             (*o_putc)(ESC);
2184             (*o_putc)('$');
2185             (*o_putc)(kanji_intro);
2186         }
2187         if (c1<0x20 || 0x7e<c1) 
2188             return;
2189         if (c2<0x20 || 0x7e<c2) 
2190             return;
2191         (*o_putc)(c2);
2192         (*o_putc)(c1);
2193     }
2194 }
2195
2196 void
2197 base64_conv(c2, c1)
2198     int    c2,
2199                     c1;
2200 {
2201     if (base64_count>50 && !mimeout_mode && c2==0 && c1==SPACE) {
2202         (*o_putc)(NL);
2203     } else if (base64_count>66 && mimeout_mode) {
2204         (*o_base64conv)(EOF,0);
2205         (*o_putc)(NL);
2206         (*o_putc)('\t'); base64_count += 7;
2207     }
2208     (*o_base64conv)(c2,c1);
2209 }
2210
2211
2212 static int broken_buf[3];
2213 static int broken_counter = 0;
2214 static int broken_last = 0;
2215 int
2216 broken_getc(f)
2217 FILE *f;
2218 {
2219     int c,c1;
2220
2221     if (broken_counter>0) {
2222         return broken_buf[--broken_counter];
2223     }
2224     c= (*i_bgetc)(f);
2225     if (c=='$' && broken_last != ESC 
2226             && (input_mode==ASCII || input_mode==X0201)) {
2227         c1= (*i_bgetc)(f);
2228         broken_last = 0;
2229         if (c1=='@'|| c1=='B') {
2230             broken_buf[0]=c1; broken_buf[1]=c; 
2231             broken_counter=2;
2232             return ESC;
2233         } else {
2234             (*i_bungetc)(c1,f);
2235             return c;
2236         }
2237     } else if (c=='(' && broken_last != ESC 
2238             && (input_mode==X0208 || input_mode==X0201)) { /* ) */
2239         c1= (*i_bgetc)(f);
2240         broken_last = 0;
2241         if (c1=='J'|| c1=='B') {
2242             broken_buf[0]=c1; broken_buf[1]=c;
2243             broken_counter=2;
2244             return ESC;
2245         } else {
2246             (*i_bungetc)(c1,f);
2247             return c;
2248         }
2249     } else {
2250         broken_last = c;
2251         return c;
2252     }
2253 }
2254
2255 int
2256 broken_ungetc(c,f)
2257 int c;
2258 FILE *f;
2259 {
2260     if (broken_counter<2)
2261         broken_buf[broken_counter++]=c;
2262     return c;
2263 }
2264
2265 static int prev_cr = 0;
2266
2267 void
2268 cr_conv(c2,c1) 
2269 int c2,c1;
2270 {
2271     if (prev_cr) {
2272         prev_cr = 0;
2273         if (! (c2==0&&c1==NL) ) {
2274             cr_conv(0,'\n');
2275         }
2276     }
2277     if (c2) {
2278         (*o_crconv)(c2,c1);
2279     } else if (c1=='\r') {
2280         prev_cr = c1;
2281     } else if (c1=='\n') {
2282         if (crmode_f==CRLF) {
2283             (*o_crconv)(0,'\r');
2284         } else if (crmode_f==CR) {
2285             (*o_crconv)(0,'\r');
2286             return;
2287         } 
2288         (*o_crconv)(0,NL);
2289     } else if (c1!='\032' || crmode_f!=NL){
2290         (*o_crconv)(c2,c1);
2291     }
2292 }
2293
2294 /* 
2295   Return value of fold_conv()
2296
2297        \n  add newline  and output char
2298        \r  add newline  and output nothing
2299        ' ' space
2300        0   skip  
2301        1   (or else) normal output 
2302
2303   fold state in prev (previous character)
2304
2305       >0x80 Japanese (X0208/X0201)
2306       <0x80 ASCII
2307       \n    new line 
2308       ' '   space
2309
2310   This fold algorthm does not preserve heading space in a line.
2311   This is the main difference from fmt.
2312 */
2313
2314 #define char_size(c2,c1) (c2?2:1)
2315
2316 void
2317 fold_conv(c2,c1) 
2318 int c2,c1;
2319
2320     int prev0;
2321     int fold_state=0;
2322
2323     if (c1== '\r' && !fold_preserve_f) {
2324         fold_state=0;  /* ignore cr */
2325     }else if (c1== '\n'&&f_prev=='\r' && fold_preserve_f) {
2326         f_prev = '\n';
2327         fold_state=0;  /* ignore cr */
2328     } else if (c1== BS) {
2329         if (f_line>0) f_line--;
2330         fold_state =  1;
2331     } else if (c2==EOF && f_line != 0) {    /* close open last line */
2332             fold_state = '\n';
2333     } else if ((c1=='\n' && !fold_preserve_f)
2334                || ((c1=='\r'||(c1=='\n'&&f_prev!='\r'))
2335                    && fold_preserve_f)) {
2336         /* new line */
2337         if (fold_preserve_f) { 
2338             f_prev = c1;
2339             f_line = 0;
2340             fold_state =  '\r';
2341         } else if ((f_prev == c1 && !fold_preserve_f)
2342                    || (f_prev == '\n' && fold_preserve_f)
2343                    ) {        /* duplicate newline */
2344             if (f_line) {
2345                 f_line = 0;
2346                 fold_state =  '\n';    /* output two newline */
2347             } else {
2348                 f_line = 0;
2349                 fold_state =  1;
2350             }
2351         } else  {
2352             if (f_prev&0x80) {     /* Japanese? */
2353                 f_prev = c1;
2354                 fold_state =  0;       /* ignore given single newline */
2355             } else if (f_prev==' ') {
2356                 fold_state =  0;
2357             } else {
2358                 f_prev = c1;
2359                 if (++f_line<=fold_len) 
2360                     fold_state =  ' ';
2361                 else {
2362                     f_line = 0;
2363                     fold_state =  '\r';        /* fold and output nothing */
2364                 }
2365             }
2366         }
2367     } else if (c1=='\f') {
2368         f_prev = '\n';
2369         if (f_line==0)
2370             fold_state =  1;
2371         f_line = 0;
2372         fold_state =  '\n';            /* output newline and clear */
2373     } else if ( (c2==0  && c1==' ')||
2374                (c2==0  && c1=='\t')||
2375                (c2=='!'&& c1=='!')) {
2376         /* X0208 kankaku or ascii space */
2377             if (f_prev == ' ') {
2378                 fold_state = 0;         /* remove duplicate spaces */
2379             } else {
2380                 f_prev = ' ';    
2381                 if (++f_line<=fold_len) 
2382                     fold_state = ' ';         /* output ASCII space only */
2383                 else {
2384                     f_prev = ' '; f_line = 0;
2385                     fold_state = '\r';        /* fold and output nothing */
2386                 }
2387             }
2388     } else {
2389         prev0 = f_prev; /* we still need this one... , but almost done */
2390         f_prev = c1;
2391         if (c2 || c2==X0201) 
2392             f_prev |= 0x80;  /* this is Japanese */
2393         f_line += char_size(c2,c1);
2394         if (f_line<=fold_len) {   /* normal case */
2395             fold_state = 1;
2396         } else {
2397             if (f_line>=fold_len+fold_margin) { /* too many kinsou suspension */
2398                 f_line = char_size(c2,c1);
2399                 fold_state =  '\n';       /* We can't wait, do fold now */
2400             } else if (c2==X0201) {
2401             /* simple kinsoku rules  return 1 means no folding  */
2402                 if (c1==(0xde&0x7f)) fold_state = 1; /* \e$B!+\e(B*/
2403                 else if (c1==(0xdf&0x7f)) fold_state = 1; /* \e$B!,\e(B*/
2404                 else if (c1==(0xa4&0x7f)) fold_state = 1; /* \e$B!#\e(B*/
2405                 else if (c1==(0xa3&0x7f)) fold_state = 1; /* \e$B!$\e(B*/
2406                 else if (c1==(0xa1&0x7f)) fold_state = 1; /* \e$B!W\e(B*/
2407                 else if (c1==(0xb0&0x7f)) fold_state = 1; /* - */
2408                 else if (SPACE<=c1 && c1<=(0xdf&0x7f)) {      /* X0201 */
2409                     f_line = 1;
2410                     fold_state = '\n';/* add one new f_line before this character */
2411                 } else {
2412                     f_line = 1;
2413                     fold_state = '\n';/* add one new f_line before this character */
2414                 }
2415             } else if (c2==0) {
2416                 /* kinsoku point in ASCII */ 
2417                 if (  c1==')'||    /* { [ ( */
2418                      c1==']'||
2419                      c1=='}'||
2420                      c1=='.'||
2421                      c1==','||
2422                      c1=='!'||
2423                      c1=='?'||
2424                      c1=='/'||
2425                      c1==':'||
2426                      c1==';' ) {
2427                     fold_state = 1;
2428                 /* just after special */
2429                 } else if (!is_alnum(prev0)) {
2430                     f_line = char_size(c2,c1);
2431                     fold_state = '\n';
2432                 } else if ((prev0==' ') ||   /* ignored new f_line */
2433                       (prev0=='\n')||        /* ignored new f_line */
2434                       (prev0&0x80)) {        /* X0208 - ASCII */
2435                     f_line = char_size(c2,c1);
2436                     fold_state = '\n';/* add one new f_line before this character */
2437                 } else {
2438                     fold_state = 1;  /* default no fold in ASCII */
2439                 }
2440             } else {
2441                 if (c2=='!') {
2442                     if (c1=='"')  fold_state = 1; /* \e$B!"\e(B */
2443                     else if (c1=='#')  fold_state = 1; /* \e$B!#\e(B */
2444                     else if (c1=='W')  fold_state = 1; /* \e$B!W\e(B */
2445                     else if (c1=='K')  fold_state = 1; /* \e$B!K\e(B */
2446                     else if (c1=='$')  fold_state = 1; /* \e$B!$\e(B */
2447                     else if (c1=='%')  fold_state = 1; /* \e$B!%\e(B */
2448                     else if (c1=='\'') fold_state = 1; /* \e$B!\\e(B */
2449                     else if (c1=='(')  fold_state = 1; /* \e$B!(\e(B */
2450                     else if (c1==')')  fold_state = 1; /* \e$B!)\e(B */
2451                     else if (c1=='*')  fold_state = 1; /* \e$B!*\e(B */
2452                     else if (c1=='+')  fold_state = 1; /* \e$B!+\e(B */
2453                     else if (c1==',')  fold_state = 1; /* \e$B!,\e(B */
2454                          /* default no fold in kinsoku */
2455                     else { 
2456                         fold_state = '\n';
2457                         f_line = char_size(c2,c1);
2458                         /* add one new f_line before this character */
2459                     }
2460                 } else {
2461                     f_line = char_size(c2,c1);
2462                     fold_state = '\n'; 
2463                     /* add one new f_line before this character */
2464                 }
2465             }
2466         }
2467     }
2468     /* terminator process */
2469     switch(fold_state) {
2470         case '\n': 
2471             (*o_fconv)(0,'\n');
2472             (*o_fconv)(c2,c1);
2473             break;
2474         case 0:    
2475             return;
2476         case '\r': 
2477             (*o_fconv)(0,'\n');
2478             break;
2479         case '\t': 
2480         case ' ': 
2481             (*o_fconv)(0,' ');
2482             break;
2483         default:
2484             (*o_fconv)(c2,c1);
2485     }
2486 }
2487
2488 int z_prev2=0,z_prev1=0;
2489
2490 void
2491 z_conv(c2,c1)
2492 int c2,c1;
2493 {
2494
2495     /* if (c2) c1 &= 0x7f; assertion */
2496
2497     if (x0201_f && z_prev2==X0201) {  /* X0201 */
2498         if (c1==(0xde&0x7f)) { /* \e$BByE@\e(B */
2499             z_prev2=0;
2500             (*o_zconv)(dv[(z_prev1-SPACE)*2],dv[(z_prev1-SPACE)*2+1]);
2501             return;
2502         } else if (c1==(0xdf&0x7f)&&ev[(z_prev1-SPACE)*2]) {  /* \e$BH>ByE@\e(B */
2503             z_prev2=0;
2504             (*o_zconv)(ev[(z_prev1-SPACE)*2],ev[(z_prev1-SPACE)*2+1]);
2505             return;
2506         } else {
2507             z_prev2=0;
2508             (*o_zconv)(cv[(z_prev1-SPACE)*2],cv[(z_prev1-SPACE)*2+1]);
2509         }
2510     }
2511
2512     if (c2==EOF) {
2513         (*o_zconv)(c2,c1);
2514         return;
2515     }
2516
2517     if (x0201_f && c2==X0201) {
2518         if (dv[(c1-SPACE)*2]||ev[(c1-SPACE)*2]) {
2519             /* wait for \e$BByE@\e(B or \e$BH>ByE@\e(B */
2520             z_prev1 = c1; z_prev2 = c2;
2521             return;
2522         } else {
2523             (*o_zconv)(cv[(c1-SPACE)*2],cv[(c1-SPACE)*2+1]);
2524             return;
2525         }
2526     }
2527
2528     /* JISX0208 Alphabet */
2529     if (alpha_f && c2 == 0x23 ) {
2530         c2 = 0;
2531     } else if (alpha_f && c2 == 0x21 ) { 
2532     /* JISX0208 Kigou */
2533        if (0x21==c1) {
2534            if (alpha_f&0x2) {
2535                c1 = ' ';
2536                c2 = 0;
2537            } else if (alpha_f&0x4) {
2538                 (*o_zconv)(0,' ');
2539                 (*o_zconv)(0,' ');
2540                 return;
2541            } 
2542        } else if (0x20<c1 && c1<0x7f && fv[c1-0x20]) {
2543            c1 = fv[c1-0x20];
2544            c2 =  0;
2545            if (alpha_f&0x8) {
2546                char *entity = 0;
2547                switch (c1){
2548                  case '>': entity = "&gt;"; break;
2549                  case '<': entity = "&lt;"; break;
2550                  case '\"': entity = "&quot;"; break;
2551                  case '&': entity = "&amp;"; break;
2552                }
2553                if (entity){
2554                    while (*entity) (*o_zconv)(0, *entity++);
2555                    return;
2556                }
2557            }
2558        } 
2559     }
2560     (*o_zconv)(c2,c1);
2561 }
2562
2563
2564 #define rot13(c)  ( \
2565       ( c < 'A' ) ? c: \
2566       (c <= 'M')  ? (c + 13): \
2567       (c <= 'Z')  ? (c - 13): \
2568       (c < 'a')   ? (c): \
2569       (c <= 'm')  ? (c + 13): \
2570       (c <= 'z')  ? (c - 13): \
2571       (c) \
2572 )
2573
2574 #define  rot47(c) ( \
2575       ( c < '!' ) ? c: \
2576       ( c <= 'O' ) ? (c + 47) : \
2577       ( c <= '~' ) ?  (c - 47) : \
2578       c \
2579 )
2580
2581 void
2582 rot_conv(c2,c1)
2583 int c2,c1;
2584 {
2585     if (c2==0 || c2==X0201 || c2==ISO8859_1) {
2586         c1 = rot13(c1);
2587     } else if (c2) {
2588         c1 = rot47(c1);
2589         c2 = rot47(c2);
2590     }
2591     (*o_rot_conv)(c2,c1);
2592 }
2593
2594 void
2595 hira_conv(c2,c1)
2596 int c2,c1;
2597 {
2598     if ((hira_f & 1) && c2==0x25 && 0x20<c1 && c1<0x74) {
2599         c2 = 0x24;
2600     } else if ((hira_f & 2) && c2==0x24 && 0x20<c1 && c1<0x74) {
2601         c2 = 0x25;
2602     } 
2603     (*o_hira_conv)(c2,c1);
2604 }
2605
2606
2607 void
2608 iso2022jp_check_conv(c2,c1)
2609 int    c2, c1;
2610 {
2611     static int range[RANGE_NUM_MAX][2] = {
2612         {0x222f, 0x2239,},
2613         {0x2242, 0x2249,},
2614         {0x2251, 0x225b,},
2615         {0x226b, 0x2271,},
2616         {0x227a, 0x227d,},
2617         {0x2321, 0x232f,},
2618         {0x233a, 0x2340,},
2619         {0x235b, 0x2360,},
2620         {0x237b, 0x237e,},
2621         {0x2474, 0x247e,},
2622         {0x2577, 0x257e,},
2623         {0x2639, 0x2640,},
2624         {0x2659, 0x267e,},
2625         {0x2742, 0x2750,},
2626         {0x2772, 0x277e,},
2627         {0x2841, 0x287e,},
2628         {0x4f54, 0x4f7e,},
2629         {0x7425, 0x747e},
2630     };
2631     int i;
2632     int start, end, c;
2633
2634     if(c2 >= 0x00 && c2 <= 0x20 && c1 >= 0x7f && c1 <= 0xff) {
2635         c2 = GETA1;
2636         c1 = GETA2;
2637     }
2638     if((c2 >= 0x29 && c2 <= 0x2f) || (c2 >= 0x75 && c2 <= 0x7e)) {
2639         c2 = GETA1;
2640         c1 = GETA2;
2641     }
2642
2643     for (i = 0; i < RANGE_NUM_MAX; i++) {
2644         start = range[i][0];
2645         end   = range[i][1];
2646         c     = (c2 << 8) + c1;
2647         if (c >= start && c <= end) {
2648             c2 = GETA1;
2649             c1 = GETA2;
2650         }
2651     }
2652     (*o_iso2022jp_check_conv)(c2,c1);
2653 }
2654
2655
2656 /* This converts  =?ISO-2022-JP?B?HOGE HOGE?= */
2657
2658 unsigned char *mime_pattern[] = {
2659    (unsigned char *)"\075?EUC-JP?B?",
2660    (unsigned char *)"\075?SHIFT_JIS?B?",
2661    (unsigned char *)"\075?ISO-8859-1?Q?",
2662    (unsigned char *)"\075?ISO-2022-JP?B?",
2663    (unsigned char *)"\075?ISO-2022-JP?Q?",
2664 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
2665    (unsigned char *)"\075?UTF-8?B?",
2666 #endif
2667    NULL
2668 };
2669
2670 int      mime_encode[] = {
2671     JAPANESE_EUC, SHIFT_JIS,ISO8859_1, X0208, X0201,
2672 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
2673     UTF8,
2674 #endif
2675     0
2676 };
2677
2678 int      mime_encode_method[] = {
2679     'B', 'B','Q', 'B', 'Q',
2680 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
2681     'B',
2682 #endif
2683     0
2684 };
2685
2686
2687 #define MAXRECOVER 20
2688
2689 /* I don't trust portablity of toupper */
2690 #define nkf_toupper(c)  (('a'<=c && c<='z')?(c-('a'-'A')):c)
2691 #define nkf_isdigit(c)  ('0'<=c && c<='9')
2692 #define nkf_isxdigit(c)  (nkf_isdigit(c) || ('a'<=c && c<='f') || ('A'<=c && c <= 'F'))
2693
2694 void
2695 switch_mime_getc()
2696 {
2697     if (i_getc!=mime_getc) {
2698         i_mgetc = i_getc; i_getc = mime_getc;
2699         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
2700         if(mime_f==STRICT_MIME) {
2701             i_mgetc_buf = i_mgetc; i_mgetc = mime_getc_buf;
2702             i_mungetc_buf = i_mungetc; i_mungetc = mime_ungetc_buf;
2703         }
2704     }
2705 }
2706
2707 void
2708 unswitch_mime_getc()
2709 {
2710     if(mime_f==STRICT_MIME) {
2711         i_mgetc = i_mgetc_buf;
2712         i_mungetc = i_mungetc_buf;
2713     }
2714     i_getc = i_mgetc;
2715     i_ungetc = i_mungetc;
2716 }
2717
2718 int
2719 mime_begin_strict(f)
2720 FILE *f;
2721 {
2722     int c1 = 0;
2723     int i,j,k;
2724     unsigned char *p,*q;
2725     int r[MAXRECOVER];    /* recovery buffer, max mime pattern lenght */
2726
2727     mime_decode_mode = FALSE;
2728     /* =? has been checked */
2729     j = 0;
2730     p = mime_pattern[j];
2731     r[0]='='; r[1]='?';
2732
2733     for(i=2;p[i]>' ';i++) {                   /* start at =? */
2734         if ( ((r[i] = c1 = (*i_getc)(f))==EOF) || nkf_toupper(c1) != p[i] ) {
2735             /* pattern fails, try next one */
2736             q = p;
2737             while ((p = mime_pattern[++j])) {
2738                 for(k=2;k<i;k++)              /* assume length(p) > i */
2739                     if (p[k]!=q[k]) break;
2740                 if (k==i && nkf_toupper(c1)==p[k]) break;
2741             }
2742             if (p) continue;  /* found next one, continue */
2743             /* all fails, output from recovery buffer */
2744             (*i_ungetc)(c1,f);
2745             for(j=0;j<i;j++) {
2746                 (*oconv)(0,r[j]);
2747             }
2748             return c1;
2749         }
2750     }
2751     mime_decode_mode = p[i-2];
2752     if (mime_decode_mode=='B') {
2753         mimebuf_f = unbuf_f;
2754         if (!unbuf_f) {
2755             /* do MIME integrity check */
2756             return mime_integrity(f,mime_pattern[j]);
2757         } 
2758     }
2759     switch_mime_getc();
2760     mimebuf_f = TRUE;
2761     return c1;
2762 }
2763
2764 int
2765 mime_getc_buf(f) 
2766 FILE *f;
2767 {
2768     /* we don't keep eof of Fifo, becase it contains ?= as
2769        a terminator. It was checked in mime_integrity. */
2770     return ((mimebuf_f)?
2771         (*i_mgetc_buf)(f):Fifo(mime_input++));
2772 }
2773
2774 int
2775 mime_ungetc_buf(c,f) 
2776 FILE *f;
2777 int c;
2778 {
2779     if (mimebuf_f)
2780         (*i_mungetc_buf)(c,f);
2781     else 
2782         Fifo(--mime_input)=c;
2783     return c;
2784 }
2785
2786 int
2787 mime_begin(f)
2788 FILE *f;
2789 {
2790     int c1;
2791     int i,k;
2792
2793     /* In NONSTRICT mode, only =? is checked. In case of failure, we  */
2794     /* re-read and convert again from mime_buffer.  */
2795
2796     /* =? has been checked */
2797     k = mime_last;
2798     Fifo(mime_last++)='='; Fifo(mime_last++)='?';
2799     for(i=2;i<MAXRECOVER;i++) {                   /* start at =? */
2800         /* We accept any character type even if it is breaked by new lines */
2801         c1 = (*i_getc)(f); Fifo(mime_last++)= c1 ;
2802         if (c1=='\n'||c1==' '||c1=='\r'||
2803                 c1=='-'||c1=='_'||is_alnum(c1) ) continue;
2804         if (c1=='=') {
2805             /* Failed. But this could be another MIME preemble */
2806             (*i_ungetc)(c1,f);
2807             mime_last--;
2808             break;
2809         }
2810         if (c1!='?') break;
2811         else {
2812             /* c1=='?' */
2813             c1 = (*i_getc)(f); Fifo(mime_last++) = c1;
2814             if (!(++i<MAXRECOVER) || c1==EOF) break;
2815             if (c1=='b'||c1=='B') {
2816                 mime_decode_mode = 'B';
2817             } else if (c1=='q'||c1=='Q') {
2818                 mime_decode_mode = 'Q';
2819             } else {
2820                 break;
2821             }
2822             c1 = (*i_getc)(f); Fifo(mime_last++) = c1;
2823             if (!(++i<MAXRECOVER) || c1==EOF) break;
2824             if (c1!='?') {
2825                 mime_decode_mode = FALSE;
2826             }
2827             break;
2828         }
2829     }
2830     switch_mime_getc();
2831     if (!mime_decode_mode) {
2832         /* false MIME premble, restart from mime_buffer */
2833         mime_decode_mode = 1;  /* no decode, but read from the mime_buffer */
2834         /* Since we are in MIME mode until buffer becomes empty,    */
2835         /* we never go into mime_begin again for a while.           */
2836         return c1;
2837     }
2838     /* discard mime preemble, and goto MIME mode */
2839     mime_last = k;
2840     /* do no MIME integrity check */
2841     return c1;   /* used only for checking EOF */
2842 }
2843
2844 #ifdef CHECK_OPTION
2845 void
2846 no_putc(c)
2847      int c;
2848 {
2849     ;
2850 }
2851
2852 void debug(str)
2853      char *str;
2854 {
2855     if (debug_f){
2856         fputs(str, stderr);
2857     }
2858 }
2859 #endif
2860
2861 #ifdef CAP_URL_OPTION
2862 int
2863 hex2bin(x)
2864      int x;
2865 {
2866     if (nkf_isdigit(x)) return x - '0';
2867     return nkf_toupper(x) - 'A' + 10;
2868 }
2869
2870 #ifdef ANSI_C_PROTOTYPE
2871 int hex_getc(int ch, FILE *f, int (*g)(FILE *f), int (*u)(int c, FILE *f))
2872 #else
2873 int
2874 hex_getc(ch, f, g, u)
2875      int ch;
2876      FILE *f;
2877      int (*g)();
2878      int (*u)();
2879 #endif
2880 {
2881     int c1, c2, c3;
2882     c1 = (*g)(f);
2883     if (c1 != ch){
2884         return c1;
2885     }
2886     c2 = (*g)(f);
2887     if (!nkf_isxdigit(c2) == EOF){
2888         (*u)(c2, f);
2889         return c1;
2890     }
2891     c3 = (*g)(f);
2892     if (!nkf_isxdigit(c3) == EOF){
2893         (*u)(c2, f);
2894         (*u)(c3, f);
2895         return c1;
2896     }
2897     return (hex2bin(c2) << 4) | hex2bin(c3);
2898 }
2899
2900 int
2901 cap_getc(f)
2902      FILE *f;
2903 {
2904     return hex_getc(':', f, i_cgetc, i_cungetc);
2905 }
2906
2907 int
2908 cap_ungetc(c, f)
2909      int c;
2910      FILE *f;
2911 {
2912     return (*i_cungetc)(c, f);
2913 }
2914
2915 int
2916 url_getc(f)
2917      FILE *f;
2918 {
2919     return hex_getc('%', f, i_ugetc, i_uungetc);
2920 }
2921
2922 int
2923 url_ungetc(c, f)
2924      int c;
2925      FILE *f;
2926 {
2927     return (*i_uungetc)(c, f);
2928 }
2929 #endif
2930
2931
2932 int 
2933 mime_getc(f)
2934 FILE *f;
2935 {
2936     int c1, c2, c3, c4, cc;
2937     int t1, t2, t3, t4, mode, exit_mode;
2938
2939     if (mime_top != mime_last) {  /* Something is in FIFO */
2940         return  Fifo(mime_top++);
2941     }
2942     if (mime_decode_mode==1 ||mime_decode_mode==FALSE) {
2943         mime_decode_mode=FALSE;
2944         unswitch_mime_getc();
2945         return (*i_getc)(f);
2946     }
2947
2948     if (mimebuf_f == FIXED_MIME)
2949         exit_mode = mime_decode_mode;
2950     else
2951         exit_mode = FALSE;
2952     if (mime_decode_mode == 'Q') {
2953         if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
2954 restart_mime_q:
2955         if (c1=='_') return ' ';
2956         if (c1!='=' && c1!='?') {
2957             return c1;
2958         }
2959                 
2960         mime_decode_mode = exit_mode; /* prepare for quit */
2961         if (c1<=' ') return c1;
2962         if ((c2 = (*i_mgetc)(f)) == EOF) return (EOF);
2963         if (c1=='?'&&c2=='=' && mimebuf_f != FIXED_MIME) {
2964             /* end Q encoding */
2965             input_mode = exit_mode;
2966             while((c1=(*i_getc)(f))!=EOF && c1==SPACE 
2967                         /* && (c1==NL||c1==TAB||c1=='\r') */ ) ;
2968             return c1;
2969         }
2970         if (c1=='='&&c2<' ') { /* this is soft wrap */
2971             while((c1 =  (*i_mgetc)(f)) <=' ') {
2972                 if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
2973             }
2974             mime_decode_mode = 'Q'; /* still in MIME */
2975             goto restart_mime_q;
2976         }
2977         if (c1=='?') {
2978             mime_decode_mode = 'Q'; /* still in MIME */
2979             (*i_mungetc)(c2,f);
2980             return c1;
2981         }
2982         if ((c3 = (*i_mgetc)(f)) == EOF) return (EOF);
2983         if (c2<=' ') return c2;
2984         mime_decode_mode = 'Q'; /* still in MIME */
2985 #define hex(c)   (('0'<=c&&c<='9')?(c-'0'):\
2986      ('A'<=c&&c<='F')?(c-'A'+10):('a'<=c&&c<='f')?(c-'a'+10):0)
2987         return ((hex(c2)<<4) + hex(c3));
2988     }
2989
2990     if (mime_decode_mode != 'B') {
2991         mime_decode_mode = FALSE;
2992         return (*i_mgetc)(f);
2993     }
2994
2995
2996     /* Base64 encoding */
2997     /* 
2998         MIME allows line break in the middle of 
2999         Base64, but we are very pessimistic in decoding
3000         in unbuf mode because MIME encoded code may broken by 
3001         less or editor's control sequence (such as ESC-[-K in unbuffered
3002         mode. ignore incomplete MIME.
3003     */
3004     mode = mime_decode_mode;
3005     mime_decode_mode = exit_mode;  /* prepare for quit */
3006
3007     while ((c1 = (*i_mgetc)(f))<=' ') {
3008         if (c1==EOF)
3009             return (EOF);
3010     }
3011 mime_c2_retry:
3012     if ((c2 = (*i_mgetc)(f))<=' ') {
3013         if (c2==EOF)
3014             return (EOF);
3015         if (mime_f != STRICT_MIME) goto mime_c2_retry;
3016         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;  
3017         return c2;
3018     }
3019     if ((c1 == '?') && (c2 == '=')) {
3020         input_mode = ASCII;
3021         while((c1=(*i_getc)(f))!=EOF && c1==SPACE 
3022                     /* && (c1==NL||c1==TAB||c1=='\r') */ ) ;
3023         return c1;
3024     }
3025 mime_c3_retry:
3026     if ((c3 = (*i_mgetc)(f))<=' ') {
3027         if (c3==EOF)
3028             return (EOF);
3029         if (mime_f != STRICT_MIME) goto mime_c3_retry;
3030         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;  
3031         return c3;
3032     }
3033 mime_c4_retry:
3034     if ((c4 = (*i_mgetc)(f))<=' ') {
3035         if (c4==EOF)
3036             return (EOF);
3037         if (mime_f != STRICT_MIME) goto mime_c4_retry;
3038         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;  
3039         return c4;
3040     }
3041
3042     mime_decode_mode = mode; /* still in MIME sigh... */
3043
3044     /* BASE 64 decoding */
3045
3046     t1 = 0x3f & base64decode(c1);
3047     t2 = 0x3f & base64decode(c2);
3048     t3 = 0x3f & base64decode(c3);
3049     t4 = 0x3f & base64decode(c4);
3050     cc = ((t1 << 2) & 0x0fc) | ((t2 >> 4) & 0x03);
3051     if (c2 != '=') {
3052         Fifo(mime_last++) = cc;
3053         cc = ((t2 << 4) & 0x0f0) | ((t3 >> 2) & 0x0f);
3054         if (c3 != '=') {
3055             Fifo(mime_last++) = cc;
3056             cc = ((t3 << 6) & 0x0c0) | (t4 & 0x3f);
3057             if (c4 != '=') 
3058                 Fifo(mime_last++) = cc;
3059         }
3060     } else {
3061         return c1;
3062     }
3063     return  Fifo(mime_top++);
3064 }
3065
3066 int
3067 mime_ungetc(c,f) 
3068 int   c;
3069 FILE  *f;
3070 {
3071     Fifo(--mime_top) = c;
3072     return c;
3073 }
3074
3075 int
3076 mime_integrity(f,p)
3077 FILE *f;
3078 unsigned char *p;
3079 {
3080     int c,d;
3081     unsigned int q;
3082     /* In buffered mode, read until =? or NL or buffer full
3083      */
3084     mime_input = mime_top;
3085     mime_last = mime_top;
3086     while(*p) Fifo(mime_input++) = *p++;
3087     d = 0;
3088     q = mime_input;
3089     while((c=(*i_getc)(f))!=EOF) {
3090         if (((mime_input-mime_top)&MIME_BUF_MASK)==0) {
3091             break;   /* buffer full */
3092         }
3093         if (c=='=' && d=='?') {
3094             /* checked. skip header, start decode */
3095             Fifo(mime_input++) = c;
3096             /* mime_last_input = mime_input; */
3097             mime_input = q; 
3098             switch_mime_getc();
3099             return 1;
3100         }
3101         if (!( (c=='+'||c=='/'|| c=='=' || c=='?' || is_alnum(c))))
3102             break;
3103         /* Should we check length mod 4? */
3104         Fifo(mime_input++) = c;
3105         d=c;
3106     }
3107     /* In case of Incomplete MIME, no MIME decode  */
3108     Fifo(mime_input++) = c;
3109     mime_last = mime_input;     /* point undecoded buffer */
3110     mime_decode_mode = 1;              /* no decode on Fifo last in mime_getc */
3111     switch_mime_getc();         /* anyway we need buffered getc */
3112     return 1;
3113 }
3114
3115 int
3116 base64decode(c)
3117     int            c;
3118 {
3119     int             i;
3120     if (c > '@') {
3121         if (c < '[') {
3122             i = c - 'A';                        /* A..Z 0-25 */
3123         } else {
3124             i = c - 'G'     /* - 'a' + 26 */ ;  /* a..z 26-51 */
3125         }
3126     } else if (c > '/') {
3127         i = c - '0' + '4'   /* - '0' + 52 */ ;  /* 0..9 52-61 */
3128     } else if (c == '+') {
3129         i = '>'             /* 62 */ ;          /* +  62 */
3130     } else {
3131         i = '?'             /* 63 */ ;          /* / 63 */
3132     }
3133     return (i);
3134 }
3135
3136 static char basis_64[] =
3137    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
3138
3139 static int b64c;
3140
3141 void
3142 open_mime(mode)
3143 int mode;
3144 {
3145     unsigned char *p;
3146     int i;
3147     p  = mime_pattern[0];
3148     for(i=0;mime_encode[i];i++) {
3149         if (mode == mime_encode[i]) {
3150             p = mime_pattern[i];
3151                 break;
3152         }
3153     }
3154     mimeout_mode = mime_encode_method[i];
3155             
3156     /* (*o_mputc)(' '); */
3157     while(*p) {
3158         (*o_mputc)(*p++);
3159         base64_count ++;
3160     }
3161 }
3162
3163 void
3164 close_mime()
3165 {
3166     (*o_mputc)('?');
3167     (*o_mputc)('=');
3168     (*o_mputc)(' ');
3169     base64_count += 3;
3170     mimeout_mode = 0;
3171 }
3172
3173 #define itoh4(c)   (c>=10?c+'A'-10:c+'0')
3174
3175 void
3176 mime_putc(c)
3177     int            c;
3178 {
3179     if (mimeout_f==FIXED_MIME) {
3180         if (base64_count>71) {
3181             (*o_mputc)('\n');
3182             base64_count=0;
3183         }
3184     } else if (c==NL) {
3185         base64_count=0;
3186     } 
3187     if (c!=EOF) {
3188         if ( c<=DEL &&(output_mode==ASCII ||output_mode == ISO8859_1 )
3189                 && mimeout_f!=FIXED_MIME) {
3190             if (mimeout_mode=='Q') {
3191                 if (c<=SPACE) {
3192                     close_mime();
3193                 }
3194                 (*o_mputc)(c);
3195                 return;
3196             }
3197             if (mimeout_mode!='B' || c!=SPACE) {
3198                 if (mimeout_mode) {
3199                     mime_putc(EOF);
3200                     mimeout_mode=0;
3201                 }
3202                 (*o_mputc)(c);
3203                 base64_count ++;
3204                 return;
3205             }
3206         } else if (!mimeout_mode && mimeout_f!=FIXED_MIME) {
3207             open_mime(output_mode);
3208         }
3209     } else { /* c==EOF */
3210         switch(mimeout_mode) {
3211         case 'Q':
3212         case 'B':
3213             break;
3214         case 2:
3215             (*o_mputc)(basis_64[((b64c & 0x3)<< 4)]);
3216             (*o_mputc)('=');
3217             (*o_mputc)('=');
3218             base64_count += 3;
3219             break;
3220         case 1:
3221             (*o_mputc)(basis_64[((b64c & 0xF) << 2)]);
3222             (*o_mputc)('=');
3223             base64_count += 2;
3224             break;
3225         }
3226         if (mimeout_mode) {
3227             if (mimeout_f!=FIXED_MIME) {
3228                 close_mime(); 
3229             } else if (mimeout_mode != 'Q')
3230                 mimeout_mode = 'B';
3231         }
3232         return;
3233     }
3234     switch(mimeout_mode) {
3235     case 'Q':
3236         if(c>=DEL) {
3237             (*o_mputc)('=');
3238             (*o_mputc)(itoh4(((c>>4)&0xf)));
3239             (*o_mputc)(itoh4((c&0xf)));
3240         } else {
3241             (*o_mputc)(c);
3242         }
3243         break;
3244     case 'B':
3245         b64c=c;
3246         (*o_mputc)(basis_64[c>>2]);
3247         mimeout_mode=2;
3248         base64_count ++;
3249         break;
3250     case 2:
3251         (*o_mputc)(basis_64[((b64c & 0x3)<< 4) | ((c & 0xF0) >> 4)]);
3252         b64c=c;
3253         mimeout_mode=1;
3254         base64_count ++;
3255         break;
3256     case 1:
3257         (*o_mputc)(basis_64[((b64c & 0xF) << 2) | ((c & 0xC0) >>6)]);
3258         (*o_mputc)(basis_64[c & 0x3F]);
3259         mimeout_mode='B';
3260         base64_count += 2;
3261         break;
3262     }
3263 }
3264
3265
3266 #ifdef PERL_XS
3267 void 
3268 reinit()
3269 {
3270     unbuf_f = FALSE;
3271     estab_f = FALSE;
3272     nop_f = FALSE;
3273     binmode_f = TRUE;       
3274     rot_f = FALSE;         
3275     hira_f = FALSE;         
3276     input_f = FALSE;      
3277     alpha_f = FALSE;     
3278     mime_f = STRICT_MIME; 
3279     mimebuf_f = FALSE; 
3280     broken_f = FALSE;  
3281     iso8859_f = FALSE; 
3282 #if defined(MSDOS) || defined(__OS2__) 
3283      x0201_f = TRUE;   
3284 #else
3285      x0201_f = NO_X0201;
3286 #endif
3287     iso2022jp_f = FALSE;
3288
3289     kanji_intro = DEFAULT_J;
3290     ascii_intro = DEFAULT_R;
3291
3292     output_conv = DEFAULT_CONV; 
3293     oconv = DEFAULT_CONV; 
3294
3295     i_mgetc  = std_getc; 
3296     i_mungetc  = std_ungetc;
3297     i_mgetc_buf = std_getc; 
3298     i_mungetc_buf = std_ungetc;
3299
3300     i_getc= std_getc; 
3301     i_ungetc=std_ungetc;
3302
3303     i_bgetc= std_getc;
3304     i_bungetc= std_ungetc;
3305
3306     o_putc = std_putc;
3307     o_mputc = std_putc;
3308     o_crconv = no_connection; 
3309     o_rot_conv = no_connection; 
3310     o_iso2022jp_check_conv = no_connection;
3311     o_hira_conv = no_connection; 
3312     o_fconv = no_connection; 
3313     o_zconv = no_connection;
3314
3315     i_getc = std_getc;
3316     i_ungetc = std_ungetc;
3317     i_mgetc = std_getc; 
3318     i_mungetc = std_ungetc; 
3319
3320     output_mode = ASCII;
3321     input_mode =  ASCII;
3322     shift_mode =  FALSE;
3323     mime_decode_mode =   FALSE;
3324     file_out = FALSE;
3325     mimeout_mode = 0;
3326     mimeout_f = FALSE;
3327     base64_count = 0;
3328     option_mode = 0;
3329     crmode_f = 0;
3330
3331     e_stat = 0;
3332     s_stat = 0;
3333 #ifdef UTF8_INPUT_ENABLE
3334     w_stat = 0;
3335 #else
3336     w_stat = -1;
3337 #endif
3338 #ifdef UTF8_OUTPUT_ENABLE
3339     if (w_oconv16_begin_f) {
3340         w_oconv16_begin_f = 2;
3341     }
3342 #endif
3343     f_line = 0;    
3344     f_prev = 0;
3345     fold_preserve_f = FALSE; 
3346     fold_f  = FALSE;
3347     fold_len  = 0;
3348     fold_margin  = FOLD_MARGIN;
3349     broken_counter = 0;
3350     broken_last = 0;
3351     z_prev2=0,z_prev1=0;
3352
3353 }
3354 #endif
3355
3356 void 
3357 no_connection(c2,c1) 
3358 int c2,c1;
3359 {
3360     no_connection2(c2,c1,0);
3361 }
3362
3363 int
3364 no_connection2(c2,c1,c0) 
3365 int c2,c1,c0;
3366 {
3367     fprintf(stderr,"nkf internal module connection failure.\n");
3368     exit(1);
3369 }
3370
3371 #ifndef PERL_XS
3372 void 
3373 usage()   
3374 {
3375     fprintf(stderr,"USAGE:  nkf(nkf32,wnkf,nkf2) -[flags] [in file] .. [out file for -O flag]\n");
3376     fprintf(stderr,"Flags:\n");
3377     fprintf(stderr,"b,u      Output is bufferred (DEFAULT),Output is unbufferred\n");
3378 #ifdef DEFAULT_CODE_SJIS
3379     fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS (DEFAULT), AT&T JIS (EUC), UTF-8\n");
3380 #endif
3381 #ifdef DEFAULT_CODE_JIS
3382     fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit (DEFAULT), Shift JIS, AT&T JIS (EUC), UTF-8\n");
3383 #endif
3384 #ifdef DEFAULT_CODE_EUC
3385     fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS, AT&T JIS (EUC) (DEFAULT), UTF-8\n");
3386 #endif
3387 #ifdef DEFAULT_CODE_UTF8
3388     fprintf(stderr,"j,s,e,w  Outout code is JIS 7 bit, Shift JIS, AT&T JIS (EUC), UTF-8 (DEFAULT)\n");
3389 #endif
3390     fprintf(stderr,"J,S,E,W  Input assumption is JIS 7 bit , Shift JIS, AT&T JIS (EUC), UTF-8\n");
3391     fprintf(stderr,"t        no conversion\n");
3392     fprintf(stderr,"i_/o_    Output sequence to designate JIS-kanji/ASCII (DEFAULT B)\n");
3393     fprintf(stderr,"r        {de/en}crypt ROT13/47\n");
3394     fprintf(stderr,"h        1 hirakana->katakana, 2 katakana->hirakana,3 both\n");
3395     fprintf(stderr,"v        Show this usage. V: show version\n");
3396     fprintf(stderr,"m[BQN0]  MIME decode [B:base64,Q:quoted,N:non-strict,0:no decode]\n");
3397     fprintf(stderr,"M[BQ]    MIME encode [B:base64 Q:quoted]\n");
3398     fprintf(stderr,"l        ISO8859-1 (Latin-1) support\n");
3399     fprintf(stderr,"f/F      Folding: -f60 or -f or -f60-10 (fold margin 10) F preserve nl\n");
3400     fprintf(stderr,"Z[0-3]   Convert X0208 alphabet to ASCII  1: Kankaku to space,2: 2 spaces,\n");
3401     fprintf(stderr,"                                          3: Convert HTML Entity\n");
3402     fprintf(stderr,"X,x      Assume X0201 kana in MS-Kanji, -x preserves X0201\n");
3403     fprintf(stderr,"B[0-2]   Broken input  0: missing ESC,1: any X on ESC-[($]-X,2: ASCII on NL\n");
3404 #ifdef MSDOS
3405     fprintf(stderr,"T        Text mode output\n");
3406 #endif
3407     fprintf(stderr,"O        Output to File (DEFAULT 'nkf.out')\n");
3408     fprintf(stderr,"d,c      Delete \\r in line feed and \\032, Add \\r in line feed\n");
3409     fprintf(stderr,"I        Convert non ISO-2022-JP charactor to GETA\n");
3410     fprintf(stderr,"-L[uwm]  line mode u:LF w:CRLF m:CR (DEFAULT noconversion)\n");
3411     fprintf(stderr,"long name options\n");
3412     fprintf(stderr," --fj,--unix,--mac,--windows                convert for the system\n");
3413     fprintf(stderr," --jis,--euc,--sjis,--utf8,--utf16,--mime,--base64  convert for the code\n");
3414     fprintf(stderr," --help,--version\n");
3415     version();
3416 }
3417
3418 void
3419 version()
3420 {
3421     fprintf(stderr,"Network Kanji Filter Version %s (%s) "
3422 #if defined(MSDOS) && !defined(_Windows)
3423                   "for DOS"
3424 #endif
3425 #if !defined(__WIN32__) && defined(_Windows)
3426                   "for Win16"
3427 #endif
3428 #if defined(__WIN32__) && defined(_Windows)
3429                   "for Win32"
3430 #endif
3431 #ifdef __OS2__
3432                   "for OS/2"
3433 #endif
3434                   ,Version,Patchlevel);
3435     fprintf(stderr,"\n%s\n",CopyRight);
3436 }
3437 #endif
3438
3439 /**
3440  ** \e$B%Q%C%A@):n<T\e(B
3441  **  void@merope.pleiades.or.jp (Kusakabe Youichi)
3442  **  NIDE Naoyuki <nide@ics.nara-wu.ac.jp>
3443  **  ohta@src.ricoh.co.jp (Junn Ohta)
3444  **  inouet@strl.nhk.or.jp (Tomoyuki Inoue)
3445  **  kiri@pulser.win.or.jp (Tetsuaki Kiriyama)
3446  **  Kimihiko Sato <sato@sail.t.u-tokyo.ac.jp>
3447  **  a_kuroe@kuroe.aoba.yokohama.jp (Akihiko Kuroe)
3448  **  kono@ie.u-ryukyu.ac.jp (Shinji Kono)
3449  **  GHG00637@nifty-serve.or.jp (COW)
3450  **
3451  ** \e$B:G=*99?7F|\e(B
3452  **  2002.9.24
3453  **/
3454
3455 /* end */