OSDN Git Service

* supported CP932/CP51932/eucJP-ms
[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 /* $Id: nkf.c,v 1.78 2005/10/27 23:44:23 naruse Exp $ */
43 #define NKF_VERSION "2.0.5"
44 #define NKF_RELEASE_DATE "2005-10-28"
45 #include "config.h"
46
47 #define COPY_RIGHT \
48     "Copyright (C) 1987, FUJITSU LTD. (I.Ichikawa),2000 S. Kono, COW, 2002-2005 Kono, Furukawa, Naruse"
49
50
51 /*
52 **
53 **
54 **
55 ** USAGE:       nkf [flags] [file] 
56 **
57 ** Flags:
58 ** b    Output is buffered             (DEFAULT)
59 ** u    Output is unbuffered
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(_MSC_VER) || defined(LSI_C) || defined(__MINGW32__)) && !defined(MSDOS)
99 #define MSDOS
100 #if (defined(__Win32__) || defined(_WIN32)) && !defined(__WIN32__)
101 #define __WIN32__
102 #endif
103 #endif
104
105 #ifdef PERL_XS
106 #undef OVERWRITE
107 #endif
108
109 #ifndef PERL_XS
110 #include <stdio.h>
111 #endif
112
113 #include <stdlib.h>
114 #include <string.h>
115
116 #if defined(MSDOS) || defined(__OS2__) 
117 #include <fcntl.h>
118 #include <io.h>
119 #endif
120
121 #ifdef MSDOS
122 #ifdef LSI_C
123 #define setbinmode(fp) fsetbin(fp)
124 #else /* Microsoft C, Turbo C */
125 #define setbinmode(fp) setmode(fileno(fp), O_BINARY)
126 #endif
127 #else /* UNIX,OS/2 */
128 #define setbinmode(fp)
129 #endif
130
131 #ifdef _IOFBF /* SysV and MSDOS, Windows */
132 #define       setvbuffer(fp, buf, size)       setvbuf(fp, buf, _IOFBF, size)
133 #else /* BSD */
134 #define       setvbuffer(fp, buf, size)       setbuffer(fp, buf, size)
135 #endif
136
137 /*Borland C++ 4.5 EasyWin*/
138 #if defined(__TURBOC__) && defined(_Windows) && !defined(__WIN32__) /*Easy Win */
139 #define         EASYWIN
140 #ifndef __WIN16__
141 #define __WIN16__
142 #endif
143 #include <windows.h>
144 #endif
145
146 #ifdef OVERWRITE
147 /* added by satoru@isoternet.org */
148 #include <sys/stat.h>
149 #ifndef MSDOS /* UNIX, OS/2 */
150 #include <unistd.h>
151 #include <utime.h>
152 #else /* defined(MSDOS) */
153 #ifdef __WIN32__
154 #ifdef __BORLANDC__ /* BCC32 */
155 #include <utime.h>
156 #else /* !defined(__BORLANDC__) */
157 #include <sys/utime.h>
158 #endif /* (__BORLANDC__) */
159 #else /* !defined(__WIN32__) */
160 #if defined(_MSC_VER) || defined(__MINGW32__) /* VC++, MinGW */
161 #include <sys/utime.h>
162 #elif defined(__TURBOC__) /* BCC */
163 #include <utime.h>
164 #elif defined(LSI_C) /* LSI C */
165 #endif /* (__WIN32__) */
166 #endif
167 #endif
168 #endif 
169
170 #ifdef INT_IS_SHORT
171 #define int long
172 #endif
173
174 #define         FALSE   0
175 #define         TRUE    1
176
177 /* state of output_mode and input_mode  
178
179    c2           0 means ASCII
180                 X0201
181                 ISO8859_1
182                 X0208
183                 EOF      all termination
184    c1           32bit data
185
186  */
187
188 #define         ASCII           0
189 #define         X0208           1
190 #define         X0201           2
191 #define         ISO8859_1       8
192 #define         NO_X0201        3
193 #define         X0212           16
194
195 /* Input Assumption */
196
197 #define         JIS_INPUT       4
198 #define         SJIS_INPUT      5
199 #define         LATIN1_INPUT    6
200 #define         FIXED_MIME      7
201 #define         STRICT_MIME     8
202
203 /* MIME ENCODE */
204
205 #define         ISO2022JP       9
206 #define         JAPANESE_EUC   10
207 #define         SHIFT_JIS      11
208
209 #define         UTF8           12
210 #define         UTF8_INPUT     13
211 #define         UTF16BE_INPUT  14
212 #define         UTF16LE_INPUT  15
213
214 #define         WISH_TRUE      15
215
216 /* ASCII CODE */
217
218 #define         BS      0x08
219 #define         TAB     0x09
220 #define         NL      0x0a
221 #define         CR      0x0d
222 #define         ESC     0x1b
223 #define         SPACE   0x20
224 #define         AT      0x40
225 #define         SSP     0xa0
226 #define         DEL     0x7f
227 #define         SI      0x0f
228 #define         SO      0x0e
229 #define         SSO     0x8e
230 #define         SS3     0x8f
231
232 #define         is_alnum(c)  \
233             (('a'<=c && c<='z')||('A'<= c && c<='Z')||('0'<=c && c<='9'))
234
235 #define         HOLD_SIZE       1024
236 #define         IOBUF_SIZE      16384
237
238 #define         DEFAULT_J       'B'
239 #define         DEFAULT_R       'B'
240
241 #define         SJ0162  0x00e1          /* 01 - 62 ku offset */
242 #define         SJ6394  0x0161          /* 63 - 94 ku offset */
243
244 #define         RANGE_NUM_MAX   18
245 #define         GETA1   0x22
246 #define         GETA2   0x2e
247
248
249 #if defined(UTF8_OUTPUT_ENABLE) || defined(UTF8_INPUT_ENABLE)
250 #define sizeof_euc_utf8 94
251 #define sizeof_euc_to_utf8_1byte 94
252 #define sizeof_euc_to_utf8_2bytes 94
253 #define sizeof_utf8_to_euc_C2 64
254 #define sizeof_utf8_to_euc_E5B8 64
255 #define sizeof_utf8_to_euc_2bytes 112
256 #define sizeof_utf8_to_euc_3bytes 112
257 #endif
258
259 /* MIME preprocessor */
260
261 #ifdef EASYWIN /*Easy Win */
262 extern POINT _BufferSize;
263 #endif
264
265 /*      function prototype  */
266
267 #ifdef ANSI_C_PROTOTYPE
268 #define PROTO(x)  x 
269 #define STATIC static
270 #define CONST const
271 #else
272 #define PROTO(x)  ()
273 #define STATIC
274 #define CONST
275 #endif
276
277 struct input_code{
278     char *name;
279     int stat;
280     int score;
281     int index;
282     int buf[3];
283     void (*status_func)PROTO((struct input_code *, int));
284     int (*iconv_func)PROTO((int c2, int c1, int c0));
285     int _file_stat;
286 };
287
288 STATIC char *input_codename = "";
289
290 #ifndef PERL_XS
291 STATIC const char *CopyRight = COPY_RIGHT;
292 #endif
293 #if !defined(PERL_XS) && !defined(WIN32DLL)
294 STATIC  int     noconvert PROTO((FILE *f));
295 #endif
296 STATIC  int     kanji_convert PROTO((FILE *f));
297 STATIC  int     h_conv PROTO((FILE *f,int c2,int c1));
298 STATIC  int     push_hold_buf PROTO((int c2));
299 STATIC  void    set_iconv PROTO((int f, int (*iconv_func)(int c2,int c1,int c0)));
300 STATIC  int     s_iconv PROTO((int c2,int c1,int c0));
301 STATIC  int     s2e_conv PROTO((int c2, int c1, int *p2, int *p1));
302 STATIC  int     e_iconv PROTO((int c2,int c1,int c0));
303 #ifdef UTF8_INPUT_ENABLE
304 STATIC  int     w2e_conv PROTO((int c2,int c1,int c0,int *p2,int *p1));
305 STATIC  int     w_iconv PROTO((int c2,int c1,int c0));
306 STATIC  int     w_iconv16 PROTO((int c2,int c1,int c0));
307 STATIC  int     w_iconv_common PROTO((int c1,int c0,const unsigned short *const *pp,int psize,int *p2,int *p1));
308 STATIC  int     ww16_conv PROTO((int c2, int c1, int c0));
309 #endif
310 #ifdef UTF8_OUTPUT_ENABLE
311 STATIC  int     e2w_conv PROTO((int c2,int c1));
312 STATIC  void    w_oconv PROTO((int c2,int c1));
313 STATIC  void    w_oconv16 PROTO((int c2,int c1));
314 #endif
315 STATIC  void    e_oconv PROTO((int c2,int c1));
316 STATIC  int     e2s_conv PROTO((int c2, int c1, int *p2, int *p1));
317 STATIC  void    s_oconv PROTO((int c2,int c1));
318 STATIC  void    j_oconv PROTO((int c2,int c1));
319 STATIC  void    fold_conv PROTO((int c2,int c1));
320 STATIC  void    cr_conv PROTO((int c2,int c1));
321 STATIC  void    z_conv PROTO((int c2,int c1));
322 STATIC  void    rot_conv PROTO((int c2,int c1));
323 STATIC  void    hira_conv PROTO((int c2,int c1));
324 STATIC  void    base64_conv PROTO((int c2,int c1));
325 STATIC  void    iso2022jp_check_conv PROTO((int c2,int c1));
326 STATIC  void    no_connection PROTO((int c2,int c1));
327 STATIC  int     no_connection2 PROTO((int c2,int c1,int c0));
328
329 STATIC  void    code_score PROTO((struct input_code *ptr));
330 STATIC  void    code_status PROTO((int c));
331
332 STATIC  void    std_putc PROTO((int c));
333 STATIC  int     std_getc PROTO((FILE *f));
334 STATIC  int     std_ungetc PROTO((int c,FILE *f));
335
336 STATIC  int     broken_getc PROTO((FILE *f));
337 STATIC  int     broken_ungetc PROTO((int c,FILE *f));
338
339 STATIC  int     mime_begin PROTO((FILE *f));
340 STATIC  int     mime_getc PROTO((FILE *f));
341 STATIC  int     mime_ungetc PROTO((int c,FILE *f));
342
343 STATIC  int     mime_begin_strict PROTO((FILE *f));
344 STATIC  int     mime_getc_buf PROTO((FILE *f));
345 STATIC  int     mime_ungetc_buf  PROTO((int c,FILE *f));
346 STATIC  int     mime_integrity PROTO((FILE *f,const unsigned char *p));
347
348 STATIC  int     base64decode PROTO((int c));
349 STATIC  void    mime_prechar PROTO((int c2, int c1));
350 STATIC  void    mime_putc PROTO((int c));
351 STATIC  void    open_mime PROTO((int c));
352 STATIC  void    close_mime PROTO(());
353 #ifndef PERL_XS
354 STATIC  void    usage PROTO(());
355 STATIC  void    version PROTO(());
356 #endif
357 STATIC  void    options PROTO((unsigned char *c));
358 #if defined(PERL_XS) || defined(WIN32DLL)
359 STATIC  void    reinit PROTO(());
360 #endif
361
362 /* buffers */
363
364 #if !defined(PERL_XS) && !defined(WIN32DLL)
365 STATIC unsigned char   stdibuf[IOBUF_SIZE];
366 STATIC unsigned char   stdobuf[IOBUF_SIZE];
367 #endif
368 STATIC unsigned char   hold_buf[HOLD_SIZE*2];
369 STATIC int             hold_count;
370
371 /* MIME preprocessor fifo */
372
373 #define MIME_BUF_SIZE   (1024)    /* 2^n ring buffer */
374 #define MIME_BUF_MASK   (MIME_BUF_SIZE-1)   
375 #define Fifo(n)         mime_buf[(n)&MIME_BUF_MASK]
376 STATIC unsigned char           mime_buf[MIME_BUF_SIZE];
377 STATIC unsigned int            mime_top = 0;
378 STATIC unsigned int            mime_last = 0;  /* decoded */
379 STATIC unsigned int            mime_input = 0; /* undecoded */
380 STATIC int (*mime_iconv_back)PROTO((int c2,int c1,int c0)) = NULL;
381
382 /* flags */
383 STATIC int             unbuf_f = FALSE;
384 STATIC int             estab_f = FALSE;
385 STATIC int             nop_f = FALSE;
386 STATIC int             binmode_f = TRUE;       /* binary mode */
387 STATIC int             rot_f = FALSE;          /* rot14/43 mode */
388 STATIC int             hira_f = FALSE;          /* hira/kata henkan */
389 STATIC int             input_f = FALSE;        /* non fixed input code  */
390 STATIC int             alpha_f = FALSE;        /* convert JIx0208 alphbet to ASCII */
391 STATIC int             mime_f = STRICT_MIME;   /* convert MIME B base64 or Q */
392 STATIC int             mime_decode_f = FALSE;  /* mime decode is explicitly on */
393 STATIC int             mimebuf_f = FALSE;      /* MIME buffered input */
394 STATIC int             broken_f = FALSE;       /* convert ESC-less broken JIS */
395 STATIC int             iso8859_f = FALSE;      /* ISO8859 through */
396 STATIC int             mimeout_f = FALSE;       /* base64 mode */
397 #if defined(MSDOS) || defined(__OS2__) 
398 STATIC int             x0201_f = TRUE;         /* Assume JISX0201 kana */
399 #else
400 STATIC int             x0201_f = NO_X0201;     /* Assume NO JISX0201 */
401 #endif
402 STATIC int             iso2022jp_f = FALSE;    /* convert ISO-2022-JP */
403 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
404 STATIC int             internal_unicode_f = FALSE;   /* Internal Unicode Processing */
405 #endif
406 #ifdef UTF8_OUTPUT_ENABLE
407 STATIC int             unicode_bom_f= 0;   /* Output Unicode BOM */
408 STATIC int             w_oconv16_LE = 0;   /* utf-16 little endian */
409 STATIC int             ms_ucs_map_f = FALSE;   /* Microsoft UCS Mapping Compatible */
410 #endif
411
412 #ifdef UNICODE_NORMALIZATION
413 STATIC int nfc_f = FALSE;
414 STATIC int (*i_nfc_getc)PROTO((FILE *)) = std_getc; /* input of ugetc */
415 STATIC int (*i_nfc_ungetc)PROTO((int c ,FILE *f)) = std_ungetc;
416 STATIC int nfc_getc PROTO((FILE *f));
417 STATIC int nfc_ungetc PROTO((int c,FILE *f));
418 #endif
419
420 #ifdef INPUT_OPTION
421 STATIC int cap_f = FALSE;
422 STATIC int (*i_cgetc)PROTO((FILE *)) = std_getc; /* input of cgetc */
423 STATIC int (*i_cungetc)PROTO((int c ,FILE *f)) = std_ungetc;
424 STATIC int cap_getc PROTO((FILE *f));
425 STATIC int cap_ungetc PROTO((int c,FILE *f));
426
427 STATIC int url_f = FALSE;
428 STATIC int (*i_ugetc)PROTO((FILE *)) = std_getc; /* input of ugetc */
429 STATIC int (*i_uungetc)PROTO((int c ,FILE *f)) = std_ungetc;
430 STATIC int url_getc PROTO((FILE *f));
431 STATIC int url_ungetc PROTO((int c,FILE *f));
432 #endif
433
434 #ifdef NUMCHAR_OPTION
435 #define CLASS_MASK  0x0f000000
436 #define CLASS_UTF16 0x01000000
437 STATIC int numchar_f = FALSE;
438 STATIC int (*i_ngetc)PROTO((FILE *)) = std_getc; /* input of ugetc */
439 STATIC int (*i_nungetc)PROTO((int c ,FILE *f)) = std_ungetc;
440 STATIC int numchar_getc PROTO((FILE *f));
441 STATIC int numchar_ungetc PROTO((int c,FILE *f));
442 #endif
443
444 #ifdef CHECK_OPTION
445 STATIC int noout_f = FALSE;
446 STATIC void no_putc PROTO((int c));
447 STATIC int debug_f = FALSE;
448 STATIC void debug PROTO((const char *str));
449 STATIC int (*iconv_for_check)() = 0;
450 #endif
451
452 STATIC int guess_f = FALSE;
453 #if !defined PERL_XS
454 STATIC  void    print_guessed_code PROTO((char *filename));
455 #endif
456 STATIC  void    set_input_codename PROTO((char *codename));
457 STATIC int is_inputcode_mixed = FALSE;
458 STATIC int is_inputcode_set   = FALSE;
459
460 #ifdef EXEC_IO
461 STATIC int exec_f = 0;
462 #endif
463
464 #ifdef SHIFTJIS_CP932
465 STATIC int cp932_f = TRUE;
466 #define CP932_TABLE_BEGIN (0xfa)
467 #define CP932_TABLE_END   (0xfc)
468
469 STATIC int cp932inv_f = TRUE;
470 #define CP932INV_TABLE_BEGIN (0xed)
471 #define CP932INV_TABLE_END   (0xee)
472
473 /* STATIC int cp932_conv PROTO((int c2, int c1)); */
474 #endif /* SHIFTJIS_CP932 */
475
476 #ifdef X0212_ENABLE
477 STATIC int x0212_f = FALSE;
478 STATIC int x0212_shift PROTO((int c));
479 STATIC int x0212_unshift PROTO((int c));
480 #endif
481
482 STATIC unsigned char prefix_table[256];
483
484 STATIC void e_status PROTO((struct input_code *, int));
485 STATIC void s_status PROTO((struct input_code *, int));
486
487 #ifdef UTF8_INPUT_ENABLE
488 STATIC void w_status PROTO((struct input_code *, int));
489 STATIC void w16_status PROTO((struct input_code *, int));
490 STATIC int             utf16_mode = UTF16BE_INPUT;
491 #endif
492
493 struct input_code input_code_list[] = {
494     {"EUC-JP",    0, 0, 0, {0, 0, 0}, e_status, e_iconv, 0},
495     {"Shift_JIS", 0, 0, 0, {0, 0, 0}, s_status, s_iconv, 0},
496 #ifdef UTF8_INPUT_ENABLE
497     {"UTF-8",     0, 0, 0, {0, 0, 0}, w_status, w_iconv, 0},
498     {"UTF-16",    0, 0, 0, {0, 0, 0}, w16_status, w_iconv16, 0},
499 #endif
500     {0}
501 };
502
503 STATIC int              mimeout_mode = 0;
504 STATIC int              base64_count = 0;
505
506 /* X0208 -> ASCII converter */
507
508 /* fold parameter */
509 STATIC int             f_line = 0;    /* chars in line */
510 STATIC int             f_prev = 0;
511 STATIC int             fold_preserve_f = FALSE; /* preserve new lines */
512 STATIC int             fold_f  = FALSE;
513 STATIC int             fold_len  = 0;
514
515 /* options */
516 STATIC unsigned char   kanji_intro = DEFAULT_J;
517 STATIC unsigned char   ascii_intro = DEFAULT_R;
518
519 /* Folding */
520
521 #define FOLD_MARGIN  10
522 #define DEFAULT_FOLD 60
523
524 STATIC int             fold_margin  = FOLD_MARGIN;
525
526 /* converters */
527
528 #ifdef DEFAULT_CODE_JIS
529 #   define  DEFAULT_CONV j_oconv
530 #endif
531 #ifdef DEFAULT_CODE_SJIS
532 #   define  DEFAULT_CONV s_oconv
533 #endif
534 #ifdef DEFAULT_CODE_EUC
535 #   define  DEFAULT_CONV e_oconv
536 #endif
537 #ifdef DEFAULT_CODE_UTF8
538 #   define  DEFAULT_CONV w_oconv
539 #endif
540
541 /* process default */
542 STATIC void (*output_conv)PROTO((int c2,int c1)) = DEFAULT_CONV;   
543
544 STATIC void (*oconv)PROTO((int c2,int c1)) = no_connection; 
545 /* s_iconv or oconv */
546 STATIC int (*iconv)PROTO((int c2,int c1,int c0)) = no_connection2;   
547
548 STATIC void (*o_zconv)PROTO((int c2,int c1)) = no_connection; 
549 STATIC void (*o_fconv)PROTO((int c2,int c1)) = no_connection; 
550 STATIC void (*o_crconv)PROTO((int c2,int c1)) = no_connection; 
551 STATIC void (*o_rot_conv)PROTO((int c2,int c1)) = no_connection; 
552 STATIC void (*o_hira_conv)PROTO((int c2,int c1)) = no_connection; 
553 STATIC void (*o_base64conv)PROTO((int c2,int c1)) = no_connection;
554 STATIC void (*o_iso2022jp_check_conv)PROTO((int c2,int c1)) = no_connection;
555
556 /* STATIC redirections */
557
558 STATIC  void   (*o_putc)PROTO((int c)) = std_putc;
559
560 STATIC  int    (*i_getc)PROTO((FILE *f)) = std_getc; /* general input */
561 STATIC  int    (*i_ungetc)PROTO((int c,FILE *f)) =std_ungetc;
562
563 STATIC  int    (*i_bgetc)PROTO((FILE *)) = std_getc; /* input of mgetc */
564 STATIC  int    (*i_bungetc)PROTO((int c ,FILE *f)) = std_ungetc;
565
566 STATIC  void   (*o_mputc)PROTO((int c)) = std_putc ; /* output of mputc */
567
568 STATIC  int    (*i_mgetc)PROTO((FILE *)) = std_getc; /* input of mgetc */
569 STATIC  int    (*i_mungetc)PROTO((int c ,FILE *f)) = std_ungetc;
570
571 /* for strict mime */
572 STATIC  int    (*i_mgetc_buf)PROTO((FILE *)) = std_getc; /* input of mgetc_buf */
573 STATIC  int    (*i_mungetc_buf)PROTO((int c,FILE *f)) = std_ungetc;
574
575 /* Global states */
576 STATIC int output_mode = ASCII,    /* output kanji mode */
577            input_mode =  ASCII,    /* input kanji mode */
578            shift_mode =  FALSE;    /* TRUE shift out, or X0201  */
579 STATIC int mime_decode_mode =   FALSE;    /* MIME mode B base64, Q hex */
580
581 /* X0201 / X0208 conversion tables */
582
583 /* X0201 kana conversion table */
584 /* 90-9F A0-DF */
585 STATIC const
586 unsigned char cv[]= {
587     0x21,0x21,0x21,0x23,0x21,0x56,0x21,0x57,
588     0x21,0x22,0x21,0x26,0x25,0x72,0x25,0x21,
589     0x25,0x23,0x25,0x25,0x25,0x27,0x25,0x29,
590     0x25,0x63,0x25,0x65,0x25,0x67,0x25,0x43,
591     0x21,0x3c,0x25,0x22,0x25,0x24,0x25,0x26,
592     0x25,0x28,0x25,0x2a,0x25,0x2b,0x25,0x2d,
593     0x25,0x2f,0x25,0x31,0x25,0x33,0x25,0x35,
594     0x25,0x37,0x25,0x39,0x25,0x3b,0x25,0x3d,
595     0x25,0x3f,0x25,0x41,0x25,0x44,0x25,0x46,
596     0x25,0x48,0x25,0x4a,0x25,0x4b,0x25,0x4c,
597     0x25,0x4d,0x25,0x4e,0x25,0x4f,0x25,0x52,
598     0x25,0x55,0x25,0x58,0x25,0x5b,0x25,0x5e,
599     0x25,0x5f,0x25,0x60,0x25,0x61,0x25,0x62,
600     0x25,0x64,0x25,0x66,0x25,0x68,0x25,0x69,
601     0x25,0x6a,0x25,0x6b,0x25,0x6c,0x25,0x6d,
602     0x25,0x6f,0x25,0x73,0x21,0x2b,0x21,0x2c,
603     0x00,0x00};
604
605
606 /* X0201 kana conversion table for daguten */
607 /* 90-9F A0-DF */
608 STATIC const
609 unsigned char dv[]= { 
610     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
611     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
612     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
613     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
614     0x00,0x00,0x00,0x00,0x00,0x00,0x25,0x74,
615     0x00,0x00,0x00,0x00,0x25,0x2c,0x25,0x2e,
616     0x25,0x30,0x25,0x32,0x25,0x34,0x25,0x36,
617     0x25,0x38,0x25,0x3a,0x25,0x3c,0x25,0x3e,
618     0x25,0x40,0x25,0x42,0x25,0x45,0x25,0x47,
619     0x25,0x49,0x00,0x00,0x00,0x00,0x00,0x00,
620     0x00,0x00,0x00,0x00,0x25,0x50,0x25,0x53,
621     0x25,0x56,0x25,0x59,0x25,0x5c,0x00,0x00,
622     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
623     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
624     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
625     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
626     0x00,0x00};
627
628 /* X0201 kana conversion table for han-daguten */
629 /* 90-9F A0-DF */
630 STATIC const
631 unsigned char ev[]= { 
632     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
633     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
634     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
635     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
636     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
637     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
638     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
639     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
640     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
641     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
642     0x00,0x00,0x00,0x00,0x25,0x51,0x25,0x54,
643     0x25,0x57,0x25,0x5a,0x25,0x5d,0x00,0x00,
644     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
645     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
646     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
647     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
648     0x00,0x00};
649
650
651 /* X0208 kigou conversion table */
652 /* 0x8140 - 0x819e */
653 STATIC const
654 unsigned char fv[] = {
655
656     0x00,0x00,0x00,0x00,0x2c,0x2e,0x00,0x3a,
657     0x3b,0x3f,0x21,0x00,0x00,0x27,0x60,0x00,
658     0x5e,0x00,0x5f,0x00,0x00,0x00,0x00,0x00,
659     0x00,0x00,0x00,0x00,0x00,0x2d,0x00,0x2f,
660     0x5c,0x00,0x00,0x7c,0x00,0x00,0x60,0x27,
661     0x22,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,
662     0x7b,0x7d,0x3c,0x3e,0x00,0x00,0x00,0x00,
663     0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,
664     0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,
665     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
666     0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40,
667     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
668 } ;
669
670
671 #define    CRLF      1
672
673 STATIC int             file_out = FALSE;
674 #ifdef OVERWRITE
675 STATIC int             overwrite = FALSE;
676 #endif
677
678 STATIC int             crmode_f = 0;   /* CR, NL, CRLF */
679 #ifdef EASYWIN /*Easy Win */
680 STATIC int             end_check;
681 #endif /*Easy Win */
682
683 #define STD_GC_BUFSIZE (256)
684 int std_gc_buf[STD_GC_BUFSIZE];
685 int std_gc_ndx;
686
687 #ifdef WIN32DLL
688 #include "nkf32dll.c"
689 #elif defined(PERL_XS)
690 #else /* WIN32DLL */
691 int
692 main(argc, argv)
693     int             argc;
694     char          **argv;
695 {
696     FILE  *fin;
697     unsigned char  *cp;
698
699     char *outfname = NULL;
700     char *origfname;
701
702 #ifdef EASYWIN /*Easy Win */
703     _BufferSize.y = 400;/*Set Scroll Buffer Size*/
704 #endif
705
706     for (argc--,argv++; (argc > 0) && **argv == '-'; argc--, argv++) {
707         cp = (unsigned char *)*argv;
708         options(cp);
709 #ifdef EXEC_IO
710         if (exec_f){
711             int fds[2], pid;
712             if (pipe(fds) < 0 || (pid = fork()) < 0){
713                 abort();
714             }
715             if (pid == 0){
716                 if (exec_f > 0){
717                     close(fds[0]);
718                     dup2(fds[1], 1);
719                 }else{
720                     close(fds[1]);
721                     dup2(fds[0], 0);
722                 }
723                 execvp(argv[1], &argv[1]);
724             }
725             if (exec_f > 0){
726                 close(fds[1]);
727                 dup2(fds[0], 0);
728             }else{
729                 close(fds[0]);
730                 dup2(fds[1], 1);
731             }
732             argc = 0;
733             break;
734         }
735 #endif
736     }
737     if(x0201_f == WISH_TRUE)
738          x0201_f = ((!iso2022jp_f)? TRUE : NO_X0201);
739
740     if (binmode_f == TRUE)
741 #ifdef __OS2__
742     if (freopen("","wb",stdout) == NULL) 
743         return (-1);
744 #else
745     setbinmode(stdout);
746 #endif
747
748     if (unbuf_f)
749       setbuf(stdout, (char *) NULL);
750     else
751       setvbuffer(stdout, stdobuf, IOBUF_SIZE);
752
753     if (argc == 0) {
754       if (binmode_f == TRUE)
755 #ifdef __OS2__
756       if (freopen("","rb",stdin) == NULL) return (-1);
757 #else
758       setbinmode(stdin);
759 #endif
760       setvbuffer(stdin, stdibuf, IOBUF_SIZE);
761       if (nop_f)
762           noconvert(stdin);
763       else {
764           kanji_convert(stdin);
765           if (guess_f) print_guessed_code(NULL);
766       }
767     } else {
768       int nfiles = argc;
769       while (argc--) {
770             is_inputcode_mixed = FALSE;
771             is_inputcode_set   = FALSE;
772             input_codename = "";
773 #ifdef CHECK_OPTION
774             iconv_for_check = 0;
775 #endif
776           if ((fin = fopen((origfname = *argv++), "r")) == NULL) {
777               perror(*--argv);
778               return(-1);
779           } else {
780 #ifdef OVERWRITE
781               int fd = 0;
782               int fd_backup = 0;
783 #endif
784
785 /* reopen file for stdout */
786               if (file_out == TRUE) {
787 #ifdef OVERWRITE
788                   if (overwrite){
789                       outfname = malloc(strlen(origfname)
790                                         + strlen(".nkftmpXXXXXX")
791                                         + 1);
792                       if (!outfname){
793                           perror(origfname);
794                           return -1;
795                       }
796                       strcpy(outfname, origfname);
797 #ifdef MSDOS
798                       {
799                           int i;
800                           for (i = strlen(outfname); i; --i){
801                               if (outfname[i - 1] == '/'
802                                   || outfname[i - 1] == '\\'){
803                                   break;
804                               }
805                           }
806                           outfname[i] = '\0';
807                       }
808                       strcat(outfname, "ntXXXXXX");
809                       mktemp(outfname);
810                       fd = open(outfname, O_WRONLY | O_CREAT | O_TRUNC,
811                                 S_IREAD | S_IWRITE);
812 #else
813                       strcat(outfname, ".nkftmpXXXXXX");
814                       fd = mkstemp(outfname);
815 #endif
816                       if (fd < 0
817                           || (fd_backup = dup(fileno(stdout))) < 0
818                           || dup2(fd, fileno(stdout)) < 0
819                           ){
820                           perror(origfname);
821                           return -1;
822                       }
823                   }else
824 #endif
825                   if(argc == 1 ) {
826                       outfname = *argv++;
827                       argc--;
828                   } else {
829                       outfname = "nkf.out";
830                   }
831
832                   if(freopen(outfname, "w", stdout) == NULL) {
833                       perror (outfname);
834                       return (-1);
835                   }
836                   if (binmode_f == TRUE) {
837 #ifdef __OS2__
838                       if (freopen("","wb",stdout) == NULL) 
839                            return (-1);
840 #else
841                       setbinmode(stdout);
842 #endif
843                   }
844               }
845               if (binmode_f == TRUE)
846 #ifdef __OS2__
847                  if (freopen("","rb",fin) == NULL) 
848                     return (-1);
849 #else
850                  setbinmode(fin);
851 #endif 
852               setvbuffer(fin, stdibuf, IOBUF_SIZE);
853               if (nop_f)
854                   noconvert(fin);
855               else {
856                   char *filename = NULL;
857                   kanji_convert(fin);
858                   if (nfiles > 1) filename = origfname;
859                   if (guess_f) print_guessed_code(filename);
860               }
861               fclose(fin);
862 #ifdef OVERWRITE
863               if (overwrite) {
864                   struct stat     sb;
865 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__)
866                   time_t tb[2];
867 #else
868                   struct utimbuf  tb;
869 #endif
870
871                   fflush(stdout);
872                   close(fd);
873                   if (dup2(fd_backup, fileno(stdout)) < 0){
874                       perror("dup2");
875                   }
876                   if (stat(origfname, &sb)) {
877                       fprintf(stderr, "Can't stat %s\n", origfname);
878                   }
879                   /* \e$B%Q!<%_%C%7%g%s$rI|85\e(B */
880                   if (chmod(outfname, sb.st_mode)) {
881                       fprintf(stderr, "Can't set permission %s\n", outfname);
882                   }
883
884                   /* \e$B%?%$%`%9%?%s%W$rI|85\e(B */
885 #if defined(MSDOS) && !defined(__MINGW32__) && !defined(__WIN32__)
886                   tb[0] = tb[1] = sb.st_mtime;
887                   if (utime(outfname, tb)) {
888                       fprintf(stderr, "Can't set timestamp %s\n", outfname);
889                   }
890 #else
891                   tb.actime  = sb.st_atime;
892                   tb.modtime = sb.st_mtime;
893                   if (utime(outfname, &tb)) {
894                       fprintf(stderr, "Can't set timestamp %s\n", outfname);
895                   }
896 #endif
897 #ifdef MSDOS
898                   if (unlink(origfname)){
899                       perror(origfname);
900                   }
901 #endif
902                   if (rename(outfname, origfname)) {
903                       perror(origfname);
904                       fprintf(stderr, "Can't rename %s to %s\n",
905                               outfname, origfname);
906                   }
907                   free(outfname);
908               }
909 #endif
910           }
911       }
912     }
913 #ifdef EASYWIN /*Easy Win */
914     if (file_out == FALSE) 
915         scanf("%d",&end_check);
916     else 
917         fclose(stdout);
918 #else /* for Other OS */
919     if (file_out == TRUE) 
920         fclose(stdout);
921 #endif /*Easy Win */
922     return (0);
923 }
924 #endif /* WIN32DLL */
925
926 STATIC const
927 struct {
928     const char *name;
929     const char *alias;
930 } long_option[] = {
931     {"base64","jMB"},
932     {"euc","e"},
933     {"euc-input","E"},
934     {"fj","jm"},
935     {"help","v"},
936     {"jis","j"},
937     {"jis-input","J"},
938     {"mac","sLm"},
939     {"mime","jM"},
940     {"mime-input","m"},
941     {"msdos","sLw"},
942     {"sjis","s"},
943     {"sjis-input","S"},
944     {"unix","eLu"},
945     {"version","V"},
946     {"windows","sLw"},
947     {"hiragana","h1"},
948     {"katakana","h2"},
949     {"katakana-hiragana","h3"},
950     {"guess", "g"},
951     {"cp932", ""},
952     {"no-cp932", ""},
953 #ifdef X0212_ENABLE
954     {"x0212", ""},
955 #endif
956 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
957     {"internal-unicode", ""},
958 #endif
959 #ifdef UTF8_OUTPUT_ENABLE
960     {"utf8", "w"},
961     {"utf16", "w16"},
962     {"ms-ucs-map", ""},
963 #endif
964 #ifdef UTF8_INPUT_ENABLE
965     {"utf8-input", "W"},
966     {"utf16-input", "W16"},
967 #endif
968 #ifdef UNICODE_NORMALIZATION
969     {"utf8mac-input", ""},
970 #endif
971 #ifdef OVERWRITE
972     {"overwrite", ""},
973 #endif
974 #ifdef INPUT_OPTION
975     {"cap-input", ""},
976     {"url-input", ""},
977 #endif
978 #ifdef NUMCHAR_OPTION
979     {"numchar-input", ""},
980 #endif
981 #ifdef CHECK_OPTION
982     {"no-output", ""},
983     {"debug", ""},
984 #endif
985 #ifdef SHIFTJIS_CP932
986     {"cp932inv", ""},
987 #endif
988 #ifdef EXEC_IO
989     {"exec-in", ""},
990     {"exec-out", ""},
991 #endif
992     {"prefix=", ""},
993 };
994
995 STATIC int option_mode = 0;
996
997 void
998 options(cp) 
999      unsigned char *cp;
1000 {
1001     int i;
1002     unsigned char *p = NULL;
1003
1004     if (option_mode==1)
1005         return;
1006     while(*cp && *cp++!='-');
1007     while (*cp) {
1008         p = 0;
1009         switch (*cp++) {
1010         case '-':  /* literal options */
1011             if (!*cp) {        /* ignore the rest of arguments */
1012                 option_mode = 1;
1013                 return;
1014             }
1015             for (i=0;i<sizeof(long_option)/sizeof(long_option[0]);i++) {
1016                 int j;
1017                 p = (unsigned char *)long_option[i].name;
1018                 for (j=0;*p && *p != '=' && *p == cp[j];p++, j++);
1019                 if (*p == cp[j] || cp[j] == ' '){
1020                     p = &cp[j];
1021                     break;
1022                 }
1023                 p = 0;
1024             }
1025             if (p == 0) return;
1026             cp = (unsigned char *)long_option[i].alias;
1027             if (!*cp){
1028                 cp = p;
1029 #ifdef OVERWRITE
1030                 if (strcmp(long_option[i].name, "overwrite") == 0){
1031                     file_out = TRUE;
1032                     overwrite = TRUE;
1033                     continue;
1034                 }
1035 #endif
1036 #ifdef INPUT_OPTION
1037                 if (strcmp(long_option[i].name, "cap-input") == 0){
1038                     cap_f = TRUE;
1039                     continue;
1040                 }
1041                 if (strcmp(long_option[i].name, "url-input") == 0){
1042                     url_f = TRUE;
1043                     continue;
1044                 }
1045 #endif
1046 #ifdef NUMCHAR_OPTION
1047                 if (strcmp(long_option[i].name, "numchar-input") == 0){
1048                     numchar_f = TRUE;
1049                     continue;
1050                 }
1051 #endif
1052 #ifdef CHECK_OPTION
1053                 if (strcmp(long_option[i].name, "no-output") == 0){
1054                     noout_f = TRUE;
1055                     continue;
1056                 }
1057                 if (strcmp(long_option[i].name, "debug") == 0){
1058                     debug_f = TRUE;
1059                     continue;
1060                 }
1061 #endif
1062                 if (strcmp(long_option[i].name, "cp932") == 0){
1063 #ifdef SHIFTJIS_CP932
1064                     cp932_f = TRUE;
1065                     cp932inv_f = TRUE;
1066 #endif
1067 #ifdef UTF8_OUTPUT_ENABLE
1068                     ms_ucs_map_f = TRUE;
1069 #endif
1070                     continue;
1071                 }
1072                 if (strcmp(long_option[i].name, "no-cp932") == 0){
1073 #ifdef SHIFTJIS_CP932
1074                     cp932_f = FALSE;
1075                     cp932inv_f = FALSE;
1076 #endif
1077 #ifdef UTF8_OUTPUT_ENABLE
1078                     ms_ucs_map_f = FALSE;
1079 #endif
1080                     continue;
1081                 }
1082 #ifdef SHIFTJIS_CP932
1083                 if (strcmp(long_option[i].name, "cp932inv") == 0){
1084                     cp932inv_f = TRUE;
1085                     continue;
1086                 }
1087 #endif
1088
1089 #ifdef X0212_ENABLE
1090                 if (strcmp(long_option[i].name, "x0212") == 0){
1091                     x0212_f = TRUE;
1092                     continue;
1093                 }
1094 #endif
1095
1096 #ifdef EXEC_IO
1097                   if (strcmp(long_option[i].name, "exec-in") == 0){
1098                       exec_f = 1;
1099                       return;
1100                   }
1101                   if (strcmp(long_option[i].name, "exec-out") == 0){
1102                       exec_f = -1;
1103                       return;
1104                   }
1105 #endif
1106 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
1107                 if (strcmp(long_option[i].name, "internal-unicode") == 0){
1108                     internal_unicode_f = TRUE;
1109                     continue;
1110                 }
1111 #endif
1112 #ifdef UTF8_OUTPUT_ENABLE
1113                 if (strcmp(long_option[i].name, "ms-ucs-map") == 0){
1114                     ms_ucs_map_f = TRUE;
1115                     continue;
1116                 }
1117 #endif
1118 #ifdef UNICODE_NORMALIZATION
1119                 if (strcmp(long_option[i].name, "utf8mac-input") == 0){
1120                     input_f = UTF8_INPUT;
1121                     nfc_f = TRUE;
1122                     continue;
1123                 }
1124 #endif
1125                 if (strcmp(long_option[i].name, "prefix=") == 0){
1126                     if (*p == '=' && ' ' < p[1] && p[1] < 128){
1127                         for (i = 2; ' ' < p[i] && p[i] < 128; i++){
1128                             prefix_table[p[i]] = p[1];
1129                         }
1130                     }
1131                     continue;
1132                 }
1133             }
1134             continue;
1135         case 'b':           /* buffered mode */
1136             unbuf_f = FALSE;
1137             continue;
1138         case 'u':           /* non bufferd mode */
1139             unbuf_f = TRUE;
1140             continue;
1141         case 't':           /* transparent mode */
1142             nop_f = TRUE;
1143             continue;
1144         case 'j':           /* JIS output */
1145         case 'n':
1146             output_conv = j_oconv;
1147             continue;
1148         case 'e':           /* AT&T EUC output */
1149             output_conv = e_oconv;
1150             continue;
1151         case 's':           /* SJIS output */
1152             output_conv = s_oconv;
1153             continue;
1154         case 'l':           /* ISO8859 Latin-1 support, no conversion */
1155             iso8859_f = TRUE;  /* Only compatible with ISO-2022-JP */
1156             input_f = LATIN1_INPUT;
1157             continue;
1158         case 'i':           /* Kanji IN ESC-$-@/B */
1159             if (*cp=='@'||*cp=='B') 
1160                 kanji_intro = *cp++;
1161             continue;
1162         case 'o':           /* ASCII IN ESC-(-J/B */
1163             if (*cp=='J'||*cp=='B'||*cp=='H') 
1164                 ascii_intro = *cp++;
1165             continue;
1166         case 'h':
1167             /*  
1168                 bit:1   katakana->hiragana
1169                 bit:2   hiragana->katakana
1170             */
1171             if ('9'>= *cp && *cp>='0') 
1172                 hira_f |= (*cp++ -'0');
1173             else 
1174                 hira_f |= 1;
1175             continue;
1176         case 'r':
1177             rot_f = TRUE;
1178             continue;
1179 #if defined(MSDOS) || defined(__OS2__) 
1180         case 'T':
1181             binmode_f = FALSE;
1182             continue;
1183 #endif
1184 #ifndef PERL_XS
1185         case 'V':
1186             version();
1187             exit(1);
1188             break;
1189         case 'v':
1190             usage();
1191             exit(1);
1192             break;
1193 #endif
1194 #ifdef UTF8_OUTPUT_ENABLE
1195         case 'w':           /* UTF-8 output */
1196             if ('1'== cp[0] && '6'==cp[1]) {
1197                 output_conv = w_oconv16; cp+=2;
1198                 if (cp[0]=='L') {
1199                     unicode_bom_f=2; cp++;
1200                     w_oconv16_LE = 1;
1201                     if (cp[0] == '0'){
1202                         unicode_bom_f=1; cp++;
1203                     }
1204                 } else if (cp[0] == 'B') {
1205                     unicode_bom_f=2; cp++;
1206                     if (cp[0] == '0'){
1207                         unicode_bom_f=1; cp++;
1208                     }
1209                 } 
1210             } else if (cp[0] == '8') {
1211                 output_conv = w_oconv; cp++;
1212                 unicode_bom_f=2;
1213                 if (cp[0] == '0'){
1214                     unicode_bom_f=1; cp++;
1215                 }
1216             } else
1217                 output_conv = w_oconv;
1218             continue;
1219 #endif
1220 #ifdef UTF8_INPUT_ENABLE
1221         case 'W':           /* UTF-8 input */
1222             if ('1'== cp[0] && '6'==cp[1]) {
1223                 input_f = UTF16BE_INPUT;
1224                 utf16_mode = UTF16BE_INPUT;
1225                 cp += 2;
1226                 if (cp[0]=='L') {
1227                     cp++;
1228                     input_f = UTF16LE_INPUT;
1229                     utf16_mode = UTF16LE_INPUT;
1230                 } else if (cp[0] == 'B') {
1231                     cp++;
1232                     input_f = UTF16BE_INPUT;
1233                     utf16_mode = UTF16BE_INPUT;
1234                 }
1235             } else if (cp[0] == '8') {
1236                 cp++;
1237                 input_f = UTF8_INPUT;
1238             } else
1239                 input_f = UTF8_INPUT;
1240             continue;
1241 #endif
1242         /* Input code assumption */
1243         case 'J':   /* JIS input */
1244         case 'E':   /* AT&T EUC input */
1245             input_f = JIS_INPUT;
1246             continue;
1247         case 'S':   /* MS Kanji input */
1248             input_f = SJIS_INPUT;
1249             if (x0201_f==NO_X0201) x0201_f=TRUE;
1250             continue;
1251         case 'Z':   /* Convert X0208 alphabet to asii */
1252             /*  bit:0   Convert X0208
1253                 bit:1   Convert Kankaku to one space
1254                 bit:2   Convert Kankaku to two spaces
1255                 bit:3   Convert HTML Entity
1256             */
1257             if ('9'>= *cp && *cp>='0') 
1258                 alpha_f |= 1<<(*cp++ -'0');
1259             else 
1260                 alpha_f |= TRUE;
1261             continue;
1262         case 'x':   /* Convert X0201 kana to X0208 or X0201 Conversion */
1263             x0201_f = FALSE;    /* No X0201->X0208 conversion */
1264             /* accept  X0201
1265                     ESC-(-I     in JIS, EUC, MS Kanji
1266                     SI/SO       in JIS, EUC, MS Kanji
1267                     SSO         in EUC, JIS, not in MS Kanji
1268                     MS Kanji (0xa0-0xdf) 
1269                output  X0201
1270                     ESC-(-I     in JIS (0x20-0x5f)
1271                     SSO         in EUC (0xa0-0xdf)
1272                     0xa0-0xd    in MS Kanji (0xa0-0xdf) 
1273             */
1274             continue;
1275         case 'X':   /* Assume X0201 kana */
1276             /* Default value is NO_X0201 for EUC/MS-Kanji mix */
1277             x0201_f = TRUE;
1278             continue;
1279         case 'F':   /* prserve new lines */
1280             fold_preserve_f = TRUE;
1281         case 'f':   /* folding -f60 or -f */
1282             fold_f = TRUE;
1283             fold_len = 0;
1284             while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
1285                 fold_len *= 10;
1286                 fold_len += *cp++ - '0';
1287             }
1288             if (!(0<fold_len && fold_len<BUFSIZ)) 
1289                 fold_len = DEFAULT_FOLD;
1290             if (*cp=='-') {
1291                 fold_margin = 0;
1292                 cp++;
1293                 while('0'<= *cp && *cp <='9') { /* we don't use atoi here */
1294                     fold_margin *= 10;
1295                     fold_margin += *cp++ - '0';
1296                 }
1297             }
1298             continue;
1299         case 'm':   /* MIME support */
1300             /* mime_decode_f = TRUE; */ /* this has too large side effects... */
1301             if (*cp=='B'||*cp=='Q') {
1302                 mime_decode_mode = *cp++;
1303                 mimebuf_f = FIXED_MIME;
1304             } else if (*cp=='N') {
1305                 mime_f = TRUE; cp++;
1306             } else if (*cp=='S') {
1307                 mime_f = STRICT_MIME; cp++;
1308             } else if (*cp=='0') {
1309                 mime_decode_f = FALSE;
1310                 mime_f = FALSE; cp++;
1311             }
1312             continue;
1313         case 'M':   /* MIME output */
1314             if (*cp=='B') {
1315                 mimeout_mode = 'B';
1316                 mimeout_f = FIXED_MIME; cp++;
1317             } else if (*cp=='Q') {
1318                 mimeout_mode = 'Q';
1319                 mimeout_f = FIXED_MIME; cp++;
1320             } else {
1321                 mimeout_f = TRUE;
1322             }
1323             continue;
1324         case 'B':   /* Broken JIS support */
1325             /*  bit:0   no ESC JIS
1326                 bit:1   allow any x on ESC-(-x or ESC-$-x
1327                 bit:2   reset to ascii on NL
1328             */
1329             if ('9'>= *cp && *cp>='0') 
1330                 broken_f |= 1<<(*cp++ -'0');
1331             else 
1332                 broken_f |= TRUE;
1333             continue;
1334 #ifndef PERL_XS
1335         case 'O':/* for Output file */
1336             file_out = TRUE;
1337             continue;
1338 #endif
1339         case 'c':/* add cr code */
1340             crmode_f = CRLF;
1341             continue;
1342         case 'd':/* delete cr code */
1343             crmode_f = NL;
1344             continue;
1345         case 'I':   /* ISO-2022-JP output */
1346             iso2022jp_f = TRUE;
1347             continue;
1348         case 'L':  /* line mode */
1349             if (*cp=='u') {         /* unix */
1350                 crmode_f = NL; cp++;
1351             } else if (*cp=='m') { /* mac */
1352                 crmode_f = CR; cp++;
1353             } else if (*cp=='w') { /* windows */
1354                 crmode_f = CRLF; cp++;
1355             } else if (*cp=='0') { /* no conversion  */
1356                 crmode_f = 0; cp++;
1357             }
1358             continue;
1359         case 'g':
1360 #ifndef PERL_XS
1361             guess_f = TRUE;
1362 #endif
1363             continue;
1364         case ' ':    
1365         /* module muliple options in a string are allowed for Perl moudle  */
1366             while(*cp && *cp++!='-');
1367             continue;
1368         default:
1369             /* bogus option but ignored */
1370             continue;
1371         }
1372     }
1373 }
1374
1375 #ifdef ANSI_C_PROTOTYPE
1376 struct input_code * find_inputcode_byfunc(int (*iconv_func)(int c2,int c1,int c0))
1377 #else
1378 struct input_code * find_inputcode_byfunc(iconv_func)
1379      int (*iconv_func)();
1380 #endif
1381 {
1382     if (iconv_func){
1383         struct input_code *p = input_code_list;
1384         while (p->name){
1385             if (iconv_func == p->iconv_func){
1386                 return p;
1387             }
1388             p++;
1389         }
1390     }
1391     return 0;
1392 }
1393
1394 #ifdef ANSI_C_PROTOTYPE
1395 void set_iconv(int f, int (*iconv_func)(int c2,int c1,int c0))
1396 #else
1397 void set_iconv(f, iconv_func)
1398      int f;
1399      int (*iconv_func)();
1400 #endif
1401 {
1402 #ifdef INPUT_CODE_FIX
1403     if (f || !input_f)
1404 #endif
1405         if (estab_f != f){
1406             estab_f = f;
1407         }
1408
1409     if (iconv_func
1410 #ifdef INPUT_CODE_FIX
1411         && (f == -TRUE || !input_f) /* -TRUE means "FORCE" */
1412 #endif
1413         ){
1414         iconv = iconv_func;
1415     }
1416 #ifdef CHECK_OPTION
1417     if (estab_f && iconv_for_check != iconv){
1418         struct input_code *p = find_inputcode_byfunc(iconv);
1419         if (p){
1420             set_input_codename(p->name);
1421             debug(input_codename);
1422         }
1423         iconv_for_check = iconv;
1424     }
1425 #endif
1426 }
1427
1428 #define SCORE_L2       (1)                   /* \e$BBh\e(B2\e$B?e=`4A;z\e(B */
1429 #define SCORE_KANA     (SCORE_L2 << 1)       /* \e$B$$$o$f$kH>3Q%+%J\e(B */
1430 #define SCORE_DEPEND   (SCORE_KANA << 1)     /* \e$B5!<o0MB8J8;z\e(B */
1431 #ifdef SHIFTJIS_CP932
1432 #define SCORE_CP932    (SCORE_DEPEND << 1)   /* CP932 \e$B$K$h$kFI$_49$(\e(B */
1433 #define SCORE_NO_EXIST (SCORE_CP932 << 1)    /* \e$BB8:_$7$J$$J8;z\e(B */
1434 #else
1435 #define SCORE_NO_EXIST (SCORE_DEPEND << 1)   /* \e$BB8:_$7$J$$J8;z\e(B */
1436 #endif
1437 #define SCORE_iMIME    (SCORE_NO_EXIST << 1) /* MIME \e$B$K$h$k;XDj\e(B */
1438 #define SCORE_ERROR    (SCORE_iMIME << 1) /* \e$B%(%i!<\e(B */
1439
1440 #define SCORE_INIT (SCORE_iMIME)
1441
1442 const int score_table_A0[] = {
1443     0, 0, 0, 0,
1444     0, 0, 0, 0,
1445     0, SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND,
1446     SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND, SCORE_NO_EXIST,
1447 };
1448
1449 const int score_table_F0[] = {
1450     SCORE_L2, SCORE_L2, SCORE_L2, SCORE_L2,
1451     SCORE_L2, SCORE_DEPEND, SCORE_NO_EXIST, SCORE_NO_EXIST,
1452     SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND, SCORE_DEPEND,
1453     SCORE_DEPEND, SCORE_NO_EXIST, SCORE_NO_EXIST, SCORE_ERROR,
1454 };
1455
1456 void set_code_score(ptr, score)
1457      struct input_code *ptr;
1458      int score;
1459 {
1460     if (ptr){
1461         ptr->score |= score;
1462     }
1463 }
1464
1465 void clr_code_score(ptr, score)
1466      struct input_code *ptr;
1467      int score;
1468 {
1469     if (ptr){
1470         ptr->score &= ~score;
1471     }
1472 }
1473
1474 void code_score(ptr)
1475      struct input_code *ptr;
1476 {
1477     int c2 = ptr->buf[0];
1478 #ifdef UTF8_OUTPUT_ENABLE
1479     int c1 = ptr->buf[1];
1480 #endif
1481     if (c2 < 0){
1482         set_code_score(ptr, SCORE_ERROR);
1483     }else if (c2 == SSO){
1484         set_code_score(ptr, SCORE_KANA);
1485 #ifdef UTF8_OUTPUT_ENABLE
1486     }else if (!e2w_conv(c2, c1)){
1487         set_code_score(ptr, SCORE_NO_EXIST);
1488 #endif
1489     }else if ((c2 & 0x70) == 0x20){
1490         set_code_score(ptr, score_table_A0[c2 & 0x0f]);
1491     }else if ((c2 & 0x70) == 0x70){
1492         set_code_score(ptr, score_table_F0[c2 & 0x0f]);
1493     }else if ((c2 & 0x70) >= 0x50){
1494         set_code_score(ptr, SCORE_L2);
1495     }
1496 }
1497
1498 void status_disable(ptr)
1499 struct input_code *ptr;
1500 {
1501     ptr->stat = -1;
1502     ptr->buf[0] = -1;
1503     code_score(ptr);
1504     if (iconv == ptr->iconv_func) set_iconv(FALSE, 0);
1505 }
1506
1507 void status_push_ch(ptr, c)
1508      struct input_code *ptr;
1509      int c;
1510 {
1511     ptr->buf[ptr->index++] = c;
1512 }
1513
1514 void status_clear(ptr)
1515      struct input_code *ptr;
1516 {
1517     ptr->stat = 0;
1518     ptr->index = 0;
1519 }
1520
1521 void status_reset(ptr)
1522      struct input_code *ptr;
1523 {
1524     status_clear(ptr);
1525     ptr->score = SCORE_INIT;
1526 }
1527
1528 void status_reinit(ptr)
1529      struct input_code *ptr;
1530 {
1531     status_reset(ptr);
1532     ptr->_file_stat = 0;
1533 }
1534
1535 void status_check(ptr, c)
1536      struct input_code *ptr;
1537      int c;
1538 {
1539     if (c <= DEL && estab_f){
1540         status_reset(ptr);
1541     }
1542 }
1543
1544 void s_status(ptr, c)
1545      struct input_code *ptr;
1546      int c;
1547 {
1548     switch(ptr->stat){
1549       case -1:
1550           status_check(ptr, c);
1551           break;
1552       case 0:
1553           if (c <= DEL){
1554               break;
1555 #ifdef NUMCHAR_OPTION
1556           }else if ((c & CLASS_MASK) == CLASS_UTF16){
1557               break;
1558 #endif
1559           }else if (0xa1 <= c && c <= 0xdf){
1560               status_push_ch(ptr, SSO);
1561               status_push_ch(ptr, c);
1562               code_score(ptr);
1563               status_clear(ptr);
1564           }else if ((0x81 <= c && c < 0xa0) || (0xe0 <= c && c <= 0xef)){
1565               ptr->stat = 1;
1566               status_push_ch(ptr, c);
1567 #ifdef SHIFTJIS_CP932
1568           }else if (cp932_f
1569                     && CP932_TABLE_BEGIN <= c && c <= CP932_TABLE_END){
1570               ptr->stat = 2;
1571               status_push_ch(ptr, c);
1572 #endif /* SHIFTJIS_CP932 */
1573 #ifdef X0212_ENABLE
1574           }else if (x0212_f && 0xf0 <= c && c <= 0xfc){
1575               ptr->stat = 1;
1576               status_push_ch(ptr, c);
1577 #endif /* X0212_ENABLE */
1578           }else{
1579               status_disable(ptr);
1580           }
1581           break;
1582       case 1:
1583           if ((0x40 <= c && c <= 0x7e) || (0x80 <= c && c <= 0xfc)){
1584               status_push_ch(ptr, c);
1585               s2e_conv(ptr->buf[0], ptr->buf[1], &ptr->buf[0], &ptr->buf[1]);
1586               code_score(ptr);
1587               status_clear(ptr);
1588           }else{
1589               status_disable(ptr);
1590           }
1591           break;
1592       case 2:
1593 #ifdef SHIFTJIS_CP932
1594           if ((0x40 <= c && c <= 0x7e) || (0x80 <= c && c <= 0xfc)){
1595               status_push_ch(ptr, c);
1596               if (s2e_conv(ptr->buf[0], ptr->buf[1], &ptr->buf[0], &ptr->buf[1]) == 0){
1597                   set_code_score(ptr, SCORE_CP932);
1598                   status_clear(ptr);
1599                   break;
1600               }
1601           }
1602 #endif /* SHIFTJIS_CP932 */
1603 #ifndef X0212_ENABLE
1604           status_disable(ptr);
1605           break;
1606 #endif
1607     }
1608 }
1609
1610 void e_status(ptr, c)
1611      struct input_code *ptr;
1612      int c;
1613 {
1614     switch (ptr->stat){
1615       case -1:
1616           status_check(ptr, c);
1617           break;
1618       case 0:
1619           if (c <= DEL){
1620               break;
1621 #ifdef NUMCHAR_OPTION
1622           }else if ((c & CLASS_MASK) == CLASS_UTF16){
1623               break;
1624 #endif
1625           }else if (SSO == c || (0xa1 <= c && c <= 0xfe)){
1626               ptr->stat = 1;
1627               status_push_ch(ptr, c);
1628 #ifdef X0212_ENABLE
1629           }else if (0x8f == c){
1630               ptr->stat = 2;
1631               status_push_ch(ptr, c);
1632 #endif /* X0212_ENABLE */
1633           }else{
1634               status_disable(ptr);
1635           }
1636           break;
1637       case 1:
1638           if (0xa1 <= c && c <= 0xfe){
1639               status_push_ch(ptr, c);
1640               code_score(ptr);
1641               status_clear(ptr);
1642           }else{
1643               status_disable(ptr);
1644           }
1645           break;
1646 #ifdef X0212_ENABLE
1647       case 2:
1648           if (0xa1 <= c && c <= 0xfe){
1649               ptr->stat = 1;
1650               status_push_ch(ptr, c);
1651           }else{
1652               status_disable(ptr);
1653           }
1654 #endif /* X0212_ENABLE */
1655     }
1656 }
1657
1658 #ifdef UTF8_INPUT_ENABLE
1659 void w16_status(ptr, c)
1660      struct input_code *ptr;
1661      int c;
1662 {
1663     switch (ptr->stat){
1664       case -1:
1665           break;
1666       case 0:
1667           if (ptr->_file_stat == 0){
1668               if (c == 0xfe || c == 0xff){
1669                   ptr->stat = c;
1670                   status_push_ch(ptr, c);
1671                   ptr->_file_stat = 1;
1672               }else{
1673                   status_disable(ptr);
1674                   ptr->_file_stat = -1;
1675               }
1676           }else if (ptr->_file_stat > 0){
1677               ptr->stat = 1;
1678               status_push_ch(ptr, c);
1679           }else if (ptr->_file_stat < 0){
1680               status_disable(ptr);
1681           }
1682           break;
1683
1684       case 1:
1685           if (c == EOF){
1686               status_disable(ptr);
1687               ptr->_file_stat = -1;
1688           }else{
1689               status_push_ch(ptr, c);
1690               status_clear(ptr);
1691           }
1692           break;
1693
1694       case 0xfe:
1695       case 0xff:
1696           if (ptr->stat != c && (c == 0xfe || c == 0xff)){
1697               status_push_ch(ptr, c);
1698               status_clear(ptr);
1699           }else{
1700               status_disable(ptr);
1701               ptr->_file_stat = -1;
1702           }
1703           break;
1704     }
1705 }
1706
1707 void w_status(ptr, c)
1708      struct input_code *ptr;
1709      int c;
1710 {
1711     switch (ptr->stat){
1712       case -1:
1713           status_check(ptr, c);
1714           break;
1715       case 0:
1716           if (c <= DEL){
1717               break;
1718 #ifdef NUMCHAR_OPTION
1719           }else if ((c & CLASS_MASK) == CLASS_UTF16){
1720               break;
1721 #endif
1722           }else if (0xc0 <= c && c <= 0xdf){
1723               ptr->stat = 1;
1724               status_push_ch(ptr, c);
1725           }else if (0xe0 <= c && c <= 0xef){
1726               ptr->stat = 2;
1727               status_push_ch(ptr, c);
1728           }else{
1729               status_disable(ptr);
1730           }
1731           break;
1732       case 1:
1733       case 2:
1734           if (0x80 <= c && c <= 0xbf){
1735               status_push_ch(ptr, c);
1736               if (ptr->index > ptr->stat){
1737                   int bom = (ptr->buf[0] == 0xef && ptr->buf[1] == 0xbb
1738                              && ptr->buf[2] == 0xbf);
1739                   w2e_conv(ptr->buf[0], ptr->buf[1], ptr->buf[2],
1740                            &ptr->buf[0], &ptr->buf[1]);
1741                   if (!bom){
1742                       code_score(ptr);
1743                   }
1744                   status_clear(ptr);
1745               }
1746           }else{
1747               status_disable(ptr);
1748           }
1749           break;
1750     }
1751 }
1752 #endif
1753
1754 void
1755 code_status(c)
1756      int c;
1757 {
1758     int action_flag = 1;
1759     struct input_code *result = 0;
1760     struct input_code *p = input_code_list;
1761     while (p->name){
1762         (p->status_func)(p, c);
1763         if (p->stat > 0){
1764             action_flag = 0;
1765         }else if(p->stat == 0){
1766             if (result){
1767                 action_flag = 0;
1768             }else{
1769                 result = p;
1770             }
1771         }
1772         ++p;
1773     }
1774
1775     if (action_flag){
1776         if (result && !estab_f){
1777             set_iconv(TRUE, result->iconv_func);
1778         }else if (c <= DEL){
1779             struct input_code *ptr = input_code_list;
1780             while (ptr->name){
1781                 status_reset(ptr);
1782                 ++ptr;
1783             }
1784         }
1785     }
1786 }
1787
1788 #ifndef WIN32DLL
1789 int 
1790 std_getc(f)
1791 FILE *f;
1792 {
1793     if (std_gc_ndx){
1794         return std_gc_buf[--std_gc_ndx];
1795     }
1796     return getc(f);
1797 }
1798 #endif /*WIN32DLL*/
1799
1800 int 
1801 std_ungetc(c,f)
1802 int c;
1803 FILE *f;
1804 {
1805     if (std_gc_ndx == STD_GC_BUFSIZE){
1806         return EOF;
1807     }
1808     std_gc_buf[std_gc_ndx++] = c;
1809     return c;
1810 }
1811
1812 #ifndef WIN32DLL
1813 void 
1814 std_putc(c)
1815 int c;
1816 {
1817     if(c!=EOF)
1818       putchar(c);
1819 }
1820 #endif /*WIN32DLL*/
1821
1822 #if !defined(PERL_XS) && !defined(WIN32DLL)
1823 int
1824 noconvert(f)
1825     FILE  *f;
1826 {
1827     int    c;
1828
1829     while ((c = (*i_getc)(f)) != EOF)
1830       (*o_putc)(c);
1831     return 1;
1832 }
1833 #endif
1834
1835 void
1836 module_connection()
1837 {
1838     oconv = output_conv; 
1839     o_putc = std_putc;
1840
1841     /* replace continucation module, from output side */
1842
1843     /* output redicrection */
1844 #ifdef CHECK_OPTION
1845     if (noout_f || guess_f){
1846         o_putc = no_putc;
1847     }
1848 #endif
1849     if (mimeout_f) {
1850         o_mputc = o_putc;
1851         o_putc = mime_putc;
1852         if (mimeout_f == TRUE) {
1853             o_base64conv = oconv; oconv = base64_conv;
1854         }
1855         /* base64_count = 0; */
1856     }
1857
1858     if (crmode_f) {
1859         o_crconv = oconv; oconv = cr_conv;
1860     }
1861     if (rot_f) {
1862         o_rot_conv = oconv; oconv = rot_conv;
1863     }
1864     if (iso2022jp_f) {
1865         o_iso2022jp_check_conv = oconv; oconv = iso2022jp_check_conv;
1866     }
1867     if (hira_f) {
1868         o_hira_conv = oconv; oconv = hira_conv;
1869     }
1870     if (fold_f) {
1871         o_fconv = oconv; oconv = fold_conv;
1872         f_line = 0;
1873     }
1874     if (alpha_f || x0201_f) {
1875         o_zconv = oconv; oconv = z_conv;
1876     }
1877
1878     i_getc = std_getc;
1879     i_ungetc = std_ungetc;
1880     /* input redicrection */
1881 #ifdef INPUT_OPTION
1882     if (cap_f){
1883         i_cgetc = i_getc; i_getc = cap_getc;
1884         i_cungetc = i_ungetc; i_ungetc= cap_ungetc;
1885     }
1886     if (url_f){
1887         i_ugetc = i_getc; i_getc = url_getc;
1888         i_uungetc = i_ungetc; i_ungetc= url_ungetc;
1889     }
1890 #endif
1891 #ifdef NUMCHAR_OPTION
1892     if (numchar_f){
1893         i_ngetc = i_getc; i_getc = numchar_getc;
1894         i_nungetc = i_ungetc; i_ungetc= numchar_ungetc;
1895     }
1896 #endif
1897 #ifdef UNICODE_NORMALIZATION
1898     if (nfc_f && input_f == UTF8_INPUT){
1899         i_nfc_getc = i_getc; i_getc = nfc_getc;
1900         i_nfc_ungetc = i_ungetc; i_ungetc= nfc_ungetc;
1901     }
1902 #endif
1903     if (mime_f && mimebuf_f==FIXED_MIME) {
1904         i_mgetc = i_getc; i_getc = mime_getc;
1905         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
1906     }
1907     if (broken_f & 1) {
1908         i_bgetc = i_getc; i_getc = broken_getc;
1909         i_bungetc = i_ungetc; i_ungetc = broken_ungetc;
1910     }
1911     if (input_f == JIS_INPUT || input_f == LATIN1_INPUT) {
1912         set_iconv(-TRUE, e_iconv);
1913     } else if (input_f == SJIS_INPUT) {
1914         set_iconv(-TRUE, s_iconv);
1915 #ifdef UTF8_INPUT_ENABLE
1916     } else if (input_f == UTF8_INPUT) {
1917         set_iconv(-TRUE, w_iconv);
1918     } else if (input_f == UTF16BE_INPUT) {
1919         set_iconv(-TRUE, w_iconv16);
1920     } else if (input_f == UTF16LE_INPUT) {
1921         set_iconv(-TRUE, w_iconv16);
1922 #endif
1923     } else {
1924         set_iconv(FALSE, e_iconv);
1925     }
1926
1927     {
1928         struct input_code *p = input_code_list;
1929         while (p->name){
1930             status_reinit(p++);
1931         }
1932     }
1933 }
1934
1935 /*
1936    Conversion main loop. Code detection only. 
1937  */
1938
1939 int
1940 kanji_convert(f)
1941     FILE  *f;
1942 {
1943     int    c1,
1944                     c2, c3;
1945     int is_8bit = FALSE;
1946
1947     module_connection();
1948     c2 = 0;
1949
1950
1951     input_mode = ASCII;
1952     output_mode = ASCII;
1953     shift_mode = FALSE;
1954
1955 #define NEXT continue      /* no output, get next */
1956 #define SEND ;             /* output c1 and c2, get next */
1957 #define LAST break         /* end of loop, go closing  */
1958
1959     while ((c1 = (*i_getc)(f)) != EOF) {
1960         code_status(c1);
1961         if (c2) {
1962             /* second byte */
1963             if (c2 > DEL) {
1964                 /* in case of 8th bit is on */
1965                 if (!estab_f&&!mime_decode_mode) {
1966                     /* in case of not established yet */
1967                     /* It is still ambiguious */
1968                     if (h_conv(f, c2, c1)==EOF) 
1969                         LAST;
1970                     else 
1971                         c2 = 0;
1972                     NEXT;
1973                 } else
1974                     /* in case of already established */
1975                     if (c1 < AT) {
1976                         /* ignore bogus code */
1977                         c2 = 0;
1978                         NEXT;
1979                     } else
1980                         SEND;
1981             } else
1982                 /* second byte, 7 bit code */
1983                 /* it might be kanji shitfted */
1984                 if ((c1 == DEL) || (c1 <= SPACE)) {
1985                     /* ignore bogus first code */
1986                     c2 = 0;
1987                     NEXT;
1988                 } else
1989                     SEND;
1990         } else {
1991             /* first byte */
1992             if (
1993 #ifdef UTF8_INPUT_ENABLE
1994                 iconv == w_iconv16
1995 #else
1996                 0
1997 #endif
1998                 ) {
1999                 c2 = c1;
2000                 c1 = (*i_getc)(f);
2001                 SEND;
2002 #ifdef NUMCHAR_OPTION
2003             } else if ((c1 & CLASS_MASK) == CLASS_UTF16){
2004                 SEND;
2005 #endif
2006             } else if (c1 > DEL) {
2007                 /* 8 bit code */
2008                 if (!estab_f && !iso8859_f) {
2009                     /* not established yet */
2010                     if (!is_8bit) is_8bit = TRUE;
2011                     c2 = c1;
2012                     NEXT;
2013                 } else { /* estab_f==TRUE */
2014                     if (iso8859_f) {
2015                         c2 = ISO8859_1;
2016                         c1 &= 0x7f;
2017                         SEND;
2018                     } else if (SSP<=c1 && c1<0xe0 && iconv == s_iconv) {
2019                         /* SJIS X0201 Case... */
2020                         if(iso2022jp_f && x0201_f==NO_X0201) {
2021                             (*oconv)(GETA1, GETA2);
2022                             NEXT;
2023                         } else {
2024                             c2 = X0201;
2025                             c1 &= 0x7f;
2026                             SEND;
2027                         }
2028                     } else if (c1==SSO && iconv != s_iconv) {
2029                         /* EUC X0201 Case */
2030                         c1 = (*i_getc)(f);  /* skip SSO */
2031                         code_status(c1);
2032                         if (SSP<=c1 && c1<0xe0) {
2033                             if(iso2022jp_f &&  x0201_f==NO_X0201) {
2034                                 (*oconv)(GETA1, GETA2);
2035                                 NEXT;
2036                             } else {
2037                                 c2 = X0201;
2038                                 c1 &= 0x7f;
2039                                 SEND;
2040                             }
2041                         } else  { /* bogus code, skip SSO and one byte */
2042                             NEXT;
2043                         }
2044                     } else {
2045                        /* already established */
2046                        c2 = c1;
2047                        NEXT;
2048                     }
2049                 }
2050             } else if ((c1 > SPACE) && (c1 != DEL)) {
2051                 /* in case of Roman characters */
2052                 if (shift_mode) { 
2053                     /* output 1 shifted byte */
2054                     if (iso8859_f) {
2055                         c2 = ISO8859_1;
2056                         SEND;
2057                     } else if (SPACE<=c1 && c1<(0xe0&0x7f) ){
2058                       /* output 1 shifted byte */
2059                         if(iso2022jp_f && x0201_f==NO_X0201) {
2060                             (*oconv)(GETA1, GETA2);
2061                             NEXT;
2062                         } else {
2063                             c2 = X0201;
2064                             SEND;
2065                         }
2066                     } else {
2067                         /* look like bogus code */
2068                         NEXT;
2069                     }
2070                 } else if (input_mode == X0208) {
2071                     /* in case of Kanji shifted */
2072                     c2 = c1;
2073                     NEXT;
2074                 } else if (c1 == '=' && mime_f && !mime_decode_mode ) {
2075                     /* Check MIME code */
2076                     if ((c1 = (*i_getc)(f)) == EOF) {
2077                         (*oconv)(0, '=');
2078                         LAST;
2079                     } else if (c1 == '?') {
2080                         /* =? is mime conversion start sequence */
2081                         if(mime_f == STRICT_MIME) {
2082                             /* check in real detail */
2083                             if (mime_begin_strict(f) == EOF) 
2084                                 LAST;
2085                             else
2086                                 NEXT;
2087                         } else if (mime_begin(f) == EOF) 
2088                             LAST;
2089                         else
2090                             NEXT;
2091                     } else {
2092                         (*oconv)(0, '=');
2093                         (*i_ungetc)(c1,f);
2094                         NEXT;
2095                     }
2096                 } else {
2097                     /* normal ASCII code */ 
2098                     SEND;
2099                 }
2100             } else if (c1 == SI) {
2101                 shift_mode = FALSE; 
2102                 NEXT;
2103             } else if (c1 == SO) {
2104                 shift_mode = TRUE; 
2105                 NEXT;
2106             } else if (c1 == ESC ) {
2107                 if ((c1 = (*i_getc)(f)) == EOF) {
2108                     /*  (*oconv)(0, ESC); don't send bogus code */
2109                     LAST;
2110                 } else if (c1 == '$') {
2111                     if ((c1 = (*i_getc)(f)) == EOF) {
2112                         /*
2113                         (*oconv)(0, ESC); don't send bogus code 
2114                         (*oconv)(0, '$'); */
2115                         LAST;
2116                     } else if (c1 == '@'|| c1 == 'B') {
2117                         /* This is kanji introduction */
2118                         input_mode = X0208;
2119                         shift_mode = FALSE;
2120                         set_input_codename("ISO-2022-JP");
2121 #ifdef CHECK_OPTION
2122                         debug(input_codename);
2123 #endif
2124                         NEXT;
2125                     } else if (c1 == '(') {
2126                         if ((c1 = (*i_getc)(f)) == EOF) {
2127                             /* don't send bogus code 
2128                             (*oconv)(0, ESC);
2129                             (*oconv)(0, '$');
2130                             (*oconv)(0, '(');
2131                                 */
2132                             LAST;
2133                         } else if (c1 == '@'|| c1 == 'B') {
2134                             /* This is kanji introduction */
2135                             input_mode = X0208;
2136                             shift_mode = FALSE;
2137                             NEXT;
2138 #ifdef X0212_ENABLE
2139                         } else if (c1 == 'D'){
2140                             input_mode = X0212;
2141                             shift_mode = FALSE;
2142                             NEXT;
2143 #endif /* X0212_ENABLE */
2144                         } else {
2145                             /* could be some special code */
2146                             (*oconv)(0, ESC);
2147                             (*oconv)(0, '$');
2148                             (*oconv)(0, '(');
2149                             (*oconv)(0, c1);
2150                             NEXT;
2151                         }
2152                     } else if (broken_f&0x2) {
2153                         /* accept any ESC-(-x as broken code ... */
2154                         input_mode = X0208;
2155                         shift_mode = FALSE;
2156                         NEXT;
2157                     } else {
2158                         (*oconv)(0, ESC);
2159                         (*oconv)(0, '$');
2160                         (*oconv)(0, c1);
2161                         NEXT;
2162                     }
2163                 } else if (c1 == '(') {
2164                     if ((c1 = (*i_getc)(f)) == EOF) {
2165                         /* don't send bogus code 
2166                         (*oconv)(0, ESC);
2167                         (*oconv)(0, '('); */
2168                         LAST;
2169                     } else {
2170                         if (c1 == 'I') {
2171                             /* This is X0201 kana introduction */
2172                             input_mode = X0201; shift_mode = X0201;
2173                             NEXT;
2174                         } else if (c1 == 'B' || c1 == 'J' || c1 == 'H') {
2175                             /* This is X0208 kanji introduction */
2176                             input_mode = ASCII; shift_mode = FALSE;
2177                             NEXT;
2178                         } else if (broken_f&0x2) {
2179                             input_mode = ASCII; shift_mode = FALSE;
2180                             NEXT;
2181                         } else {
2182                             (*oconv)(0, ESC);
2183                             (*oconv)(0, '(');
2184                             /* maintain various input_mode here */
2185                             SEND;
2186                         }
2187                     }
2188                } else if ( c1 == 'N' || c1 == 'n' ){
2189                    /* SS2 */
2190                    c3 = (*i_getc)(f);  /* skip SS2 */
2191                    if ( (SPACE<=c3 && c3 < 0x60) || (0xa0<=c3 && c3 < 0xe0)){
2192                        c1 = c3;
2193                        c2 = X0201;
2194                        SEND;
2195                    }else{
2196                        (*i_ungetc)(c3, f);
2197                        /* lonely ESC  */
2198                        (*oconv)(0, ESC);
2199                        SEND;
2200                    }
2201                 } else {
2202                     /* lonely ESC  */
2203                     (*oconv)(0, ESC);
2204                     SEND;
2205                 }
2206             } else if ((c1 == NL || c1 == CR) && broken_f&4) {
2207                 input_mode = ASCII; set_iconv(FALSE, 0);
2208                 SEND;
2209             } else if (c1 == NL && mime_decode_f && !mime_decode_mode ) {
2210                 if ((c1=(*i_getc)(f))!=EOF && c1 == SPACE) {
2211                     i_ungetc(SPACE,f);
2212                     continue;
2213                 } else {
2214                     i_ungetc(c1,f);
2215                 }
2216                 c1 = NL;
2217                 SEND;
2218             } else if (c1 == CR && mime_decode_f && !mime_decode_mode ) {
2219                 if ((c1=(*i_getc)(f))!=EOF) {
2220                     if (c1==SPACE) {
2221                         i_ungetc(SPACE,f);
2222                         continue;
2223                     } else if (c1 == NL && (c1=(*i_getc)(f))!=EOF && c1 == SPACE) {
2224                         i_ungetc(SPACE,f);
2225                         continue;
2226                     } else {
2227                         i_ungetc(c1,f);
2228                     }
2229                     i_ungetc(NL,f);
2230                 } else {
2231                     i_ungetc(c1,f);
2232                 }
2233                 c1 = CR;
2234                 SEND;
2235             } else 
2236                 SEND;
2237         }
2238         /* send: */
2239         if (input_mode == X0208) 
2240             (*oconv)(c2, c1);  /* this is JIS, not SJIS/EUC case */
2241 #ifdef X0212_ENABLE
2242         else if (input_mode == X0212) 
2243             (*oconv)((0x8f << 8) | c2, c1);
2244 #endif /* X0212_ENABLE */
2245         else if (input_mode) 
2246             (*oconv)(input_mode, c1);  /* other special case */
2247         else if ((*iconv)(c2, c1, 0) < 0){  /* can be EUC/SJIS */
2248             int c0 = (*i_getc)(f);
2249             if (c0 != EOF){
2250                 code_status(c0);
2251                 (*iconv)(c2, c1, c0);
2252             }
2253         }
2254
2255         c2 = 0;
2256         continue;
2257         /* goto next_word */
2258     }
2259
2260     /* epilogue */
2261     (*iconv)(EOF, 0, 0);
2262     if (!is_inputcode_set)
2263     {
2264         if (is_8bit) {
2265             struct input_code *p = input_code_list;
2266             struct input_code *result = p;
2267             while (p->name){
2268                 if (p->score < result->score) result = p;
2269                 ++p;
2270             }
2271             set_input_codename(result->name);
2272         }
2273     }
2274     return 1;
2275 }
2276
2277 int
2278 h_conv(f, c2, c1)
2279     FILE  *f;
2280     int    c1,
2281                     c2;
2282 {
2283     int    wc,c3;
2284
2285
2286     /** it must NOT be in the kanji shifte sequence      */
2287     /** it must NOT be written in JIS7                   */
2288     /** and it must be after 2 byte 8bit code            */
2289
2290     hold_count = 0;
2291     push_hold_buf(c2);
2292     push_hold_buf(c1);
2293     c2 = 0;
2294
2295     while ((c1 = (*i_getc)(f)) != EOF) {
2296         if (c1 == ESC){
2297             (*i_ungetc)(c1,f);
2298             break;
2299         }
2300         code_status(c1);
2301         if (push_hold_buf(c1) == EOF || estab_f){
2302             break;
2303         }
2304     }
2305
2306     if (!estab_f){
2307         struct input_code *p = input_code_list;
2308         struct input_code *result = p;
2309         if (c1 == EOF){
2310             code_status(c1);
2311         }
2312         while (p->name){
2313             if (p->score < result->score){
2314                 result = p;
2315             }
2316             ++p;
2317         }
2318         set_iconv(FALSE, result->iconv_func);
2319     }
2320
2321
2322     /** now,
2323      ** 1) EOF is detected, or
2324      ** 2) Code is established, or
2325      ** 3) Buffer is FULL (but last word is pushed)
2326      **
2327      ** in 1) and 3) cases, we continue to use
2328      ** Kanji codes by oconv and leave estab_f unchanged.
2329      **/
2330
2331     c3=c1;
2332     wc = 0;
2333     while (wc < hold_count){
2334         c2 = hold_buf[wc++];
2335         if (c2 <= DEL
2336 #ifdef NUMCHAR_OPTION
2337             || (c2 & CLASS_MASK) == CLASS_UTF16
2338 #endif
2339             ){
2340             (*iconv)(0, c2, 0);
2341             continue;
2342         }else if (iconv == s_iconv && 0xa1 <= c2 && c2 <= 0xdf){
2343             (*iconv)(X0201, c2, 0);
2344             continue;
2345         }
2346         if (wc < hold_count){
2347             c1 = hold_buf[wc++];
2348         }else{
2349             c1 = (*i_getc)(f);
2350             if (c1 == EOF){
2351                 c3 = EOF;
2352                 break;
2353             }
2354             code_status(c1);
2355         }
2356         if ((*iconv)(c2, c1, 0) < 0){
2357             int c0;
2358             if (wc < hold_count){
2359                 c0 = hold_buf[wc++];
2360             }else{
2361                 c0 = (*i_getc)(f);
2362                 if (c0 == EOF){
2363                     c3 = EOF;
2364                     break;
2365                 }
2366                 code_status(c0);
2367             }
2368             (*iconv)(c2, c1, c0);
2369             c1 = c0;
2370         }
2371     }
2372     return c3;
2373 }
2374
2375
2376
2377 int
2378 push_hold_buf(c2)
2379      int             c2;
2380 {
2381     if (hold_count >= HOLD_SIZE*2)
2382         return (EOF);
2383     hold_buf[hold_count++] = c2;
2384     return ((hold_count >= HOLD_SIZE*2) ? EOF : hold_count);
2385 }
2386
2387 int s2e_conv(c2, c1, p2, p1)
2388      int c2, c1;
2389      int *p2, *p1;
2390 {
2391 #if defined(SHIFTJIS_CP932) || defined(X0212_ENABLE)
2392     int val;
2393 #endif
2394 #ifdef SHIFTJIS_CP932
2395     if (cp932_f && CP932_TABLE_BEGIN <= c2 && c2 <= CP932_TABLE_END){
2396         extern const unsigned short shiftjis_cp932[3][189];
2397         val = shiftjis_cp932[c2 - CP932_TABLE_BEGIN][c1 - 0x40];
2398         if (val){
2399             c2 = val >> 8;
2400             c1 = val & 0xff;
2401         }
2402     }
2403 #endif /* SHIFTJIS_CP932 */
2404 #ifdef X0212_ENABLE
2405     if (x0212_f && 0xfa <= c2 && c2 <= 0xfc){
2406         extern const unsigned short shiftjis_x0212[3][189];
2407         val = shiftjis_x0212[c2 - 0xfa][c1 - 0x40];
2408         if (val){
2409             if (val & 0x8000){
2410                 c2 = (0x8f << 8) | (val >> 8);
2411                 c1 = val & 0xff;
2412             }else{
2413                 c2 = val >> 8;
2414                 c1 = val & 0xff;
2415             }
2416             if (p2) *p2 = c2;
2417             if (p1) *p1 = c1;
2418             return 0;
2419         }
2420     }
2421 #endif
2422     if(c2 >= 0x80){
2423         c2 = c2 + c2 - ((c2 <= 0x9f) ? SJ0162 : SJ6394);
2424         if (c1 < 0x9f)
2425             c1 = c1 - ((c1 > DEL) ? SPACE : 0x1f);
2426         else {
2427             c1 = c1 - 0x7e;
2428             c2++;
2429         }
2430     }
2431
2432 #ifdef X0212_ENABLE
2433     if (x0212_f){
2434         c2 = x0212_unshift(c2);
2435     }
2436 #endif
2437     if (p2) *p2 = c2;
2438     if (p1) *p1 = c1;
2439     return 0;
2440 }
2441
2442 int
2443 s_iconv(c2, c1, c0)
2444     int    c2,
2445                     c1, c0;
2446 {
2447     if (c2 == X0201) {
2448         c1 &= 0x7f;
2449     } else if ((c2 == EOF) || (c2 == 0) || c2 < SPACE) {
2450         /* NOP */
2451     } else {
2452         int ret = s2e_conv(c2, c1, &c2, &c1);
2453         if (ret) return ret;
2454     }
2455     (*oconv)(c2, c1);
2456     return 0;
2457 }
2458
2459 int
2460 e_iconv(c2, c1, c0)
2461     int    c2,
2462                     c1, c0;
2463 {
2464     if (c2 == X0201) {
2465         c1 &= 0x7f;
2466 #ifdef X0212_ENABLE
2467     }else if (c2 == 0x8f){
2468         if (c0 == 0){
2469             return -1;
2470         }
2471         c2 = (c2 << 8) | (c1 & 0x7f);
2472         c1 = c0 & 0x7f;
2473 #ifdef SHIFTJIS_CP932
2474         if (cp932_f){
2475             int s2, s1;
2476             if (e2s_conv(c2, c1, &s2, &s1) == 0){
2477                 s2e_conv(s2, s1, &c2, &c1);
2478                 if ((c2 & 0xff00) == 0){
2479                     c1 &= 0x7f;
2480                     c2 &= 0x7f;
2481                 }
2482             }
2483         }
2484 #endif /* SHIFTJIS_CP932 */
2485 #endif /* X0212_ENABLE */
2486     } else if (c2 == SSO){
2487         c2 = X0201;
2488         c1 &= 0x7f;
2489     } else if ((c2 == EOF) || (c2 == 0) || c2 < SPACE) {
2490         /* NOP */
2491     } else {
2492         c1 &= 0x7f;
2493         c2 &= 0x7f;
2494     }
2495     (*oconv)(c2, c1);
2496     return 0;
2497 }
2498
2499 #ifdef UTF8_INPUT_ENABLE
2500 int
2501 w2e_conv(c2, c1, c0, p2, p1)
2502     int    c2, c1, c0;
2503     int *p2, *p1;
2504 {
2505     extern const unsigned short *const utf8_to_euc_2bytes[];
2506     extern const unsigned short *const *const utf8_to_euc_3bytes[];
2507     int ret = 0;
2508
2509     if (0xc0 <= c2 && c2 <= 0xef) {
2510         const unsigned short *const *pp;
2511
2512         if (0xe0 <= c2) {
2513             if (c0 == 0) return -1;
2514             pp = utf8_to_euc_3bytes[c2 - 0x80];
2515             ret = w_iconv_common(c1, c0, pp, sizeof_utf8_to_euc_C2, p2, p1);
2516         } else {
2517             ret =  w_iconv_common(c2, c1, utf8_to_euc_2bytes, sizeof_utf8_to_euc_2bytes, p2, p1);
2518         }
2519 #ifdef NUMCHAR_OPTION
2520         if (ret){
2521             if (p2) *p2 = 0;
2522             if (p1) *p1 = CLASS_UTF16 | ww16_conv(c2, c1, c0);
2523             ret = 0;
2524         }
2525 #endif
2526         return ret;
2527     } else if (c2 == X0201) {
2528         c1 &= 0x7f;
2529     }
2530     if (p2) *p2 = c2;
2531     if (p1) *p1 = c1;
2532     return ret;
2533 }
2534
2535 int
2536 w_iconv(c2, c1, c0)
2537     int    c2,
2538                     c1, c0;
2539 {
2540     int ret = 0;
2541     
2542     if (c0 == 0){
2543         if (c2 == 0) /* 0x00-0x7f */
2544             ; /* 1byte */
2545         else if ((c2 & 0xe0) == 0xc0) /* 0xc0-0xdf */
2546             ; /* 2ytes */
2547         else if ((c2 & 0xf0) == 0xe0) /* 0xe0-0xef */
2548             return -1; /* 3bytes */
2549 #ifdef __COMMENT__
2550         else if (0xf0 <= c2)
2551             return 0; /* 4,5,6bytes */
2552         else if ((c2 & 0xc0) == 0x80) /* 0x80-0xbf */
2553             return 0; /* trail byte */
2554 #endif
2555         else return 0;
2556     }
2557     if (c2 == EOF);
2558     else if (c2 == 0xef && c1 == 0xbb && c0 == 0xbf) {
2559         return 0; /* throw BOM */
2560 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
2561     } else if (internal_unicode_f && (output_conv == w_oconv || output_conv == w_oconv16)){
2562         unsigned short val = 0;
2563         if(c2 == 0){
2564             c2 = c1;
2565             c1 = 0;
2566         }
2567         val = ww16_conv(c2, c1, c0);
2568         c2 = (val >> 8) & 0xff;
2569         c1 = val & 0xff;
2570 #endif
2571     } else {
2572         ret = w2e_conv(c2, c1, c0, &c2, &c1);
2573     }
2574     if (ret == 0){
2575         (*oconv)(c2, c1);
2576     }
2577     return ret;
2578 }
2579
2580 void
2581 w16w_conv(val, p2, p1, p0)
2582      unsigned short val;
2583      int *p2, *p1, *p0;
2584 {
2585     if (val < 0x80){
2586         *p2 = val;
2587         *p1 = 0;
2588         *p0 = 0;
2589     }else if (val < 0x800){
2590         *p2 = 0xc0 | (val >> 6);
2591         *p1 = 0x80 | (val & 0x3f);
2592         *p0 = 0;
2593     }else{
2594         *p2 = 0xe0 | (val >> 12);
2595         *p1 = 0x80 | ((val >> 6) & 0x3f);
2596         *p0 = 0x80 | (val        & 0x3f);
2597     }
2598 }
2599
2600 int
2601 ww16_conv(c2, c1, c0)
2602      int c2, c1, c0;
2603 {
2604     unsigned short val;
2605     if (c2 >= 0xe0){
2606         val = (c2 & 0x0f) << 12;
2607         val |= (c1 & 0x3f) << 6;
2608         val |= (c0 & 0x3f);
2609     }else if (c2 >= 0xc0){
2610         val = (c2 & 0x1f) << 6;
2611         val |= (c1 & 0x3f);
2612     }else{
2613         val = c2;
2614     }
2615     return val;
2616 }
2617
2618 int
2619 w16e_conv(val, p2, p1)
2620      unsigned short val;
2621      int *p2, *p1;
2622 {
2623     extern const unsigned short *const utf8_to_euc_2bytes[];
2624     extern const unsigned short *const *const utf8_to_euc_3bytes[];
2625     int c2, c1, c0;
2626     const unsigned short *const *pp;
2627     int psize;
2628     int ret = 0;
2629
2630     w16w_conv(val, &c2, &c1, &c0);
2631     if (c1){
2632         if (c0){
2633             pp = utf8_to_euc_3bytes[c2 - 0x80];
2634             psize = sizeof_utf8_to_euc_C2;
2635             ret =  w_iconv_common(c1, c0, pp, psize, p2, p1);
2636         }else{
2637             pp = utf8_to_euc_2bytes;
2638             psize = sizeof_utf8_to_euc_2bytes;
2639             ret =  w_iconv_common(c2, c1, pp, psize, p2, p1);
2640         }
2641 #ifdef NUMCHAR_OPTION
2642         if (ret){
2643             *p2 = 0;
2644             *p1 = CLASS_UTF16 | val;
2645             ret = 0;
2646         }
2647 #endif
2648     }else{
2649         *p2 = 0;
2650         *p1 = c2;
2651     }
2652     return ret;
2653 }
2654
2655 int
2656 w_iconv16(c2, c1, c0)
2657     int    c2, c1,c0;
2658 {
2659     int ret = 0;
2660
2661     if (c2==0376 && c1==0377){
2662         utf16_mode = UTF16BE_INPUT;
2663         return 0;    
2664     } else if (c2==0377 && c1==0376){
2665         utf16_mode = UTF16LE_INPUT;
2666         return 0;    
2667     }
2668     if (c2 != EOF && utf16_mode == UTF16LE_INPUT) {
2669         int tmp;
2670         tmp=c1; c1=c2; c2=tmp;
2671     }
2672     if ((c2==0 && c1 < 0x80) || c2==EOF) {
2673         (*oconv)(c2, c1);
2674         return 0;
2675     }
2676 #if defined(UTF8_OUTPUT_ENABLE) && defined(UTF8_INPUT_ENABLE)
2677     if (internal_unicode_f && (output_conv == w_oconv || output_conv == w_oconv16));
2678 #endif
2679     else ret = w16e_conv(((c2<<8)&0xff00) + c1, &c2, &c1);
2680     if (ret) return ret;
2681     (*oconv)(c2, c1);
2682     return 0;
2683 }
2684
2685 int
2686 w_iconv_common(c1, c0, pp, psize, p2, p1)
2687     int    c1,c0;
2688     const unsigned short *const *pp;
2689     int psize;
2690     int *p2, *p1;
2691 {
2692     int c2;
2693     const unsigned short *p;
2694     unsigned short val;
2695
2696     /* CP932/CP51932: U+00A6 (BROKEN BAR) -> not 0x8fa2c3, but 0x7c */
2697     if (cp932_f && c1 == 0xC2 && c0 == 0xA6){
2698         if (p2) *p2 = 0;
2699         if (p1) *p1 = 0x7C;
2700         return 0;
2701     }
2702
2703     if (pp == 0) return 1;
2704
2705     c1 -= 0x80;
2706     if (c1 < 0 || psize <= c1) return 1;
2707     p = pp[c1];
2708     if (p == 0)  return 1;
2709
2710     c0 -= 0x80;
2711     if (c0 < 0 || sizeof_utf8_to_euc_E5B8 <= c0) return 1;
2712     val = p[c0];
2713     if (val == 0) return 1;
2714
2715     c2 = val >> 8;
2716     if (val & 0x8000){
2717         c2 &= 0x7f;
2718         c2 |= 0x8f00;
2719     }
2720     if (c2 == SO) c2 = X0201;
2721     c1 = val & 0x7f;
2722     if (p2) *p2 = c2;
2723     if (p1) *p1 = c1;
2724     return 0;
2725 }
2726
2727 #endif
2728
2729 #ifdef UTF8_OUTPUT_ENABLE
2730 int
2731 e2w_conv(c2, c1)
2732     int    c2, c1;
2733 {
2734     extern const unsigned short euc_to_utf8_1byte[];
2735     extern const unsigned short *const euc_to_utf8_2bytes[];
2736     extern const unsigned short *const euc_to_utf8_2bytes_ms[];
2737     const unsigned short *p;
2738
2739     if (c2 == X0201) {
2740         p = euc_to_utf8_1byte;
2741 #ifdef X0212_ENABLE
2742     } else if (c2 >> 8 == 0x8f){
2743         extern const unsigned short *const x0212_to_utf8_2bytes[];
2744         c2 = (c2&0x7f) - 0x21;
2745         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
2746             p = x0212_to_utf8_2bytes[c2];
2747         else
2748             return 0;
2749 #endif
2750     } else {
2751         c2 &= 0x7f;
2752         c2 = (c2&0x7f) - 0x21;
2753         if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
2754             p = ms_ucs_map_f ? euc_to_utf8_2bytes_ms[c2] : euc_to_utf8_2bytes[c2];
2755         else
2756             return 0;
2757     }
2758     if (!p) return 0;
2759     c1 = (c1 & 0x7f) - 0x21;
2760     if (0<=c1 && c1<sizeof_euc_to_utf8_1byte)
2761         return p[c1];
2762     return 0;
2763 }
2764
2765 void
2766 w_oconv(c2, c1)
2767     int    c2,
2768                     c1;
2769 {
2770     int c0;
2771     unsigned short val;
2772     if (c2 == EOF) {
2773         (*o_putc)(EOF);
2774         return;
2775     }
2776
2777     if (unicode_bom_f==2) {
2778         (*o_putc)('\357');
2779         (*o_putc)('\273');
2780         (*o_putc)('\277');
2781         unicode_bom_f=1;
2782     }
2783
2784 #ifdef NUMCHAR_OPTION
2785     if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
2786         w16w_conv(c1, &c2, &c1, &c0);
2787         (*o_putc)(c2);
2788         if (c1){
2789             (*o_putc)(c1);
2790             if (c0) (*o_putc)(c0);
2791         }
2792         return;
2793     }
2794 #endif
2795
2796     if (c2 == 0) { 
2797         output_mode = ASCII;
2798         (*o_putc)(c1);
2799     } else if (c2 == ISO8859_1) {
2800         output_mode = ISO8859_1;
2801         (*o_putc)(c1 | 0x080);
2802     } else {
2803         output_mode = UTF8;
2804         if (internal_unicode_f && (iconv == w_iconv || iconv == w_iconv16))
2805             val = ((c2<<8)&0xff00) + c1;
2806         else val = e2w_conv(c2, c1);
2807         if (val){
2808             w16w_conv(val, &c2, &c1, &c0);
2809             (*o_putc)(c2);
2810             if (c1){
2811                 (*o_putc)(c1);
2812                 if (c0) (*o_putc)(c0);
2813             }
2814         }
2815     }
2816 }
2817
2818 void
2819 w_oconv16(c2, c1)
2820     int    c2,
2821                     c1;
2822 {
2823     if (c2 == EOF) {
2824         (*o_putc)(EOF);
2825         return;
2826     }    
2827
2828     if (unicode_bom_f==2) {
2829         if (w_oconv16_LE){
2830             (*o_putc)((unsigned char)'\377');
2831             (*o_putc)('\376');
2832         }else{
2833             (*o_putc)('\376');
2834             (*o_putc)((unsigned char)'\377');
2835         }
2836         unicode_bom_f=1;
2837     }
2838
2839     if (internal_unicode_f && (iconv == w_iconv || iconv == w_iconv16)){
2840     } else if (c2 == ISO8859_1) {
2841         c2 = 0;
2842         c1 |= 0x80;
2843 #ifdef NUMCHAR_OPTION
2844     } else if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16) {
2845         c2 = (c1 >> 8) & 0xff;
2846         c1 &= 0xff;
2847 #endif
2848     } else if (c2) {
2849         unsigned short val = e2w_conv(c2, c1);
2850         c2 = (val >> 8) & 0xff;
2851         c1 = val & 0xff;
2852     }
2853     if (w_oconv16_LE){
2854         (*o_putc)(c1);
2855         (*o_putc)(c2);
2856     }else{
2857         (*o_putc)(c2);
2858         (*o_putc)(c1);
2859     }
2860 }
2861
2862 #endif
2863
2864 void
2865 e_oconv(c2, c1)
2866     int    c2,
2867                     c1;
2868 {
2869 #ifdef NUMCHAR_OPTION
2870     if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
2871         w16e_conv(c1, &c2, &c1);
2872         if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
2873             return;
2874         }
2875     }
2876 #endif
2877     if (c2 == EOF) {
2878         (*o_putc)(EOF);
2879         return;
2880     } else if (c2 == 0) { 
2881         output_mode = ASCII;
2882         (*o_putc)(c1);
2883     } else if (c2 == X0201) {
2884         output_mode = JAPANESE_EUC;
2885         (*o_putc)(SSO); (*o_putc)(c1|0x80);
2886     } else if (c2 == ISO8859_1) {
2887         output_mode = ISO8859_1;
2888         (*o_putc)(c1 | 0x080);
2889 #ifdef X0212_ENABLE
2890     } else if ((c2 & 0xff00) >> 8 == 0x8f){
2891         output_mode = JAPANESE_EUC;
2892 #ifdef SHIFTJIS_CP932
2893         if (cp932_f){
2894             int s2, s1;
2895             if (e2s_conv(c2, c1, &s2, &s1) == 0){
2896                 s2e_conv(s2, s1, &c2, &c1);
2897             }
2898         }
2899 #endif
2900         if (c2 == 0) {
2901             output_mode = ASCII;
2902             (*o_putc)(c1);
2903         }else if ((c2 & 0xff00) >> 8 == 0x8f){
2904             if (x0212_f){
2905                 (*o_putc)(0x8f);
2906                 (*o_putc)((c2 & 0x7f) | 0x080);
2907                 (*o_putc)(c1 | 0x080);
2908             }
2909         }else{
2910             (*o_putc)((c2 & 0x7f) | 0x080);
2911             (*o_putc)(c1 | 0x080);
2912         }
2913 #endif
2914     } else {
2915         if ((c1<0x21 || 0x7e<c1) ||
2916            (c2<0x21 || 0x7e<c2)) {
2917             set_iconv(FALSE, 0);
2918             return; /* too late to rescue this char */
2919         }
2920         output_mode = JAPANESE_EUC;
2921         (*o_putc)(c2 | 0x080);
2922         (*o_putc)(c1 | 0x080);
2923     }
2924 }
2925
2926 #ifdef X0212_ENABLE
2927 int x0212_shift(c)
2928      int c;
2929 {
2930     int ret = c;
2931     c &= 0x7f;
2932     if ((ret & 0xff00) == 0x8f00){
2933         if (0x75 <= c && c <= 0x7f){
2934             ret = c + (0x109 - 0x75);
2935         }
2936     }else{
2937         if (0x75 <= c && c <= 0x7f){
2938             ret = c + (0x113 - 0x75);
2939         }
2940     }
2941     return ret;
2942 }
2943
2944
2945 int x0212_unshift(c)
2946      int c;
2947 {
2948     int ret = c;
2949     if (0x7f <= c && c <= 0x88){
2950         ret = c + (0x75 - 0x7f);
2951     }else if (0x89 <= c && c <= 0x92){
2952         ret = (0x8f << 8) | 0x80 | (c + (0x75 - 0x89));
2953     }
2954     return ret;
2955 }
2956 #endif /* X0212_ENABLE */
2957
2958 int
2959 e2s_conv(c2, c1, p2, p1)
2960      int c2, c1, *p2, *p1;
2961 {
2962 #ifdef X0212_ENABLE
2963     int val = 0;
2964     const unsigned short *ptr;
2965     int ndx;
2966     extern const unsigned short *const x0212_shiftjis[];
2967     if ((c2 & 0xff00) == 0x8f00){
2968         ndx = c2 & 0x7f;
2969         if (0x21 <= ndx && ndx <= 0x7e){
2970             ptr = x0212_shiftjis[ndx - 0x21];
2971             if (ptr){
2972                 val = ptr[(c1 & 0x7f) - 0x21];
2973             }
2974             if (val){
2975                 c2 = val >> 8;
2976                 c1 = val & 0xff;
2977                 if (p2) *p2 = c2;
2978                 if (p1) *p1 = c1;
2979                 return 0;
2980             }
2981         }
2982         c2 = x0212_shift(c2);
2983     }
2984 #endif /* X0212_ENABLE */
2985     if ((c2 & 0xff00) == 0x8f00){
2986         return 1;
2987     }
2988     if (p2) *p2 = ((c2 - 1) >> 1) + ((c2 <= 0x5e) ? 0x71 : 0xb1);
2989     if (p1) *p1 = c1 + ((c2 & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
2990     return 0;
2991 }
2992
2993 void
2994 s_oconv(c2, c1)
2995     int    c2,
2996                     c1;
2997 {
2998 #ifdef NUMCHAR_OPTION
2999     if (c2 == 0 && (c1 & CLASS_MASK) == CLASS_UTF16){
3000         w16e_conv(c1, &c2, &c1);
3001     }
3002 #endif
3003     if (c2 == EOF) {
3004         (*o_putc)(EOF);
3005         return;
3006     } else if (c2 == 0) {
3007         output_mode = ASCII;
3008         (*o_putc)(c1);
3009     } else if (c2 == X0201) {
3010         output_mode = SHIFT_JIS;
3011         (*o_putc)(c1|0x80);
3012     } else if (c2 == ISO8859_1) {
3013         output_mode = ISO8859_1;
3014         (*o_putc)(c1 | 0x080);
3015 #ifdef X0212_ENABLE
3016     } else if ((c2 & 0xff00) >> 8 == 0x8f){
3017         output_mode = SHIFT_JIS;
3018         if (e2s_conv(c2, c1, &c2, &c1) == 0){
3019             (*o_putc)(c2);
3020             (*o_putc)(c1);
3021         }
3022 #endif
3023     } else {
3024         if ((c1<0x20 || 0x7e<c1) ||
3025            (c2<0x20 || 0x7e<c2)) {
3026             set_iconv(FALSE, 0);
3027             return; /* too late to rescue this char */
3028         }
3029         output_mode = SHIFT_JIS;
3030         e2s_conv(c2, c1, &c2, &c1);
3031
3032 #ifdef SHIFTJIS_CP932
3033         if (cp932inv_f
3034             && CP932INV_TABLE_BEGIN <= c2 && c2 <= CP932INV_TABLE_END){
3035             extern const unsigned short cp932inv[2][189];
3036             int c = cp932inv[c2 - CP932INV_TABLE_BEGIN][c1 - 0x40];
3037             if (c){
3038                 c2 = c >> 8;
3039                 c1 = c & 0xff;
3040             }
3041         }
3042 #endif /* SHIFTJIS_CP932 */
3043
3044         (*o_putc)(c2);
3045         if (prefix_table[(unsigned char)c1]){
3046             (*o_putc)(prefix_table[(unsigned char)c1]);
3047         }
3048         (*o_putc)(c1);
3049     }
3050 }
3051
3052 void
3053 j_oconv(c2, c1)
3054     int    c2,
3055                     c1;
3056 {
3057 #ifdef NUMCHAR_OPTION
3058     if ((c1 & CLASS_MASK) == CLASS_UTF16){
3059         w16e_conv(c1, &c2, &c1);
3060     }
3061 #endif
3062     if (c2 == EOF) {
3063         if (output_mode !=ASCII && output_mode!=ISO8859_1) {
3064             (*o_putc)(ESC);
3065             (*o_putc)('(');
3066             (*o_putc)(ascii_intro);
3067             output_mode = ASCII;
3068         }
3069         (*o_putc)(EOF);
3070 #ifdef X0212_ENABLE
3071     } else if ((c2 & 0xff00) >> 8 == 0x8f){
3072         if (output_mode!=X0212) {
3073             output_mode = X0212;
3074             (*o_putc)(ESC);
3075             (*o_putc)('$');
3076             (*o_putc)('(');
3077             (*o_putc)('D');
3078         }
3079         (*o_putc)(c2 & 0x7f);
3080         (*o_putc)(c1);
3081 #endif
3082     } else if (c2==X0201) {
3083         if (output_mode!=X0201) {
3084             output_mode = X0201;
3085             (*o_putc)(ESC);
3086             (*o_putc)('(');
3087             (*o_putc)('I');
3088         }
3089         (*o_putc)(c1);
3090     } else if (c2==ISO8859_1) {
3091             /* iso8859 introduction, or 8th bit on */
3092             /* Can we convert in 7bit form using ESC-'-'-A ? 
3093                Is this popular? */
3094         output_mode = ISO8859_1;
3095         (*o_putc)(c1|0x80);
3096     } else if (c2 == 0) {
3097         if (output_mode !=ASCII && output_mode!=ISO8859_1) {
3098             (*o_putc)(ESC);
3099             (*o_putc)('(');
3100             (*o_putc)(ascii_intro);
3101             output_mode = ASCII;
3102         }
3103         (*o_putc)(c1);
3104     } else {
3105         if (output_mode != X0208) {
3106             output_mode = X0208;
3107             (*o_putc)(ESC);
3108             (*o_putc)('$');
3109             (*o_putc)(kanji_intro);
3110         }
3111         if (c1<0x20 || 0x7e<c1) 
3112             return;
3113         if (c2<0x20 || 0x7e<c2) 
3114             return;
3115         (*o_putc)(c2);
3116         (*o_putc)(c1);
3117     }
3118 }
3119
3120 void
3121 base64_conv(c2, c1)
3122     int    c2,
3123                     c1;
3124 {
3125     mime_prechar(c2, c1);
3126     (*o_base64conv)(c2,c1);
3127 }
3128
3129
3130 STATIC int broken_buf[3];
3131 STATIC int broken_counter = 0;
3132 STATIC int broken_last = 0;
3133 int
3134 broken_getc(f)
3135 FILE *f;
3136 {
3137     int c,c1;
3138
3139     if (broken_counter>0) {
3140         return broken_buf[--broken_counter];
3141     }
3142     c= (*i_bgetc)(f);
3143     if (c=='$' && broken_last != ESC 
3144             && (input_mode==ASCII || input_mode==X0201)) {
3145         c1= (*i_bgetc)(f);
3146         broken_last = 0;
3147         if (c1=='@'|| c1=='B') {
3148             broken_buf[0]=c1; broken_buf[1]=c; 
3149             broken_counter=2;
3150             return ESC;
3151         } else {
3152             (*i_bungetc)(c1,f);
3153             return c;
3154         }
3155     } else if (c=='(' && broken_last != ESC 
3156             && (input_mode==X0208 || input_mode==X0201)) { /* ) */
3157         c1= (*i_bgetc)(f);
3158         broken_last = 0;
3159         if (c1=='J'|| c1=='B') {
3160             broken_buf[0]=c1; broken_buf[1]=c;
3161             broken_counter=2;
3162             return ESC;
3163         } else {
3164             (*i_bungetc)(c1,f);
3165             return c;
3166         }
3167     } else {
3168         broken_last = c;
3169         return c;
3170     }
3171 }
3172
3173 int
3174 broken_ungetc(c,f)
3175 int c;
3176 FILE *f;
3177 {
3178     if (broken_counter<2)
3179         broken_buf[broken_counter++]=c;
3180     return c;
3181 }
3182
3183 STATIC int prev_cr = 0;
3184
3185 void
3186 cr_conv(c2,c1) 
3187 int c2,c1;
3188 {
3189     if (prev_cr) {
3190         prev_cr = 0;
3191         if (! (c2==0&&c1==NL) ) {
3192             cr_conv(0,'\n');
3193         }
3194     }
3195     if (c2) {
3196         (*o_crconv)(c2,c1);
3197     } else if (c1=='\r') {
3198         prev_cr = c1;
3199     } else if (c1=='\n') {
3200         if (crmode_f==CRLF) {
3201             (*o_crconv)(0,'\r');
3202         } else if (crmode_f==CR) {
3203             (*o_crconv)(0,'\r');
3204             return;
3205         } 
3206         (*o_crconv)(0,NL);
3207     } else if (c1!='\032' || crmode_f!=NL){
3208         (*o_crconv)(c2,c1);
3209     }
3210 }
3211
3212 /* 
3213   Return value of fold_conv()
3214
3215        \n  add newline  and output char
3216        \r  add newline  and output nothing
3217        ' ' space
3218        0   skip  
3219        1   (or else) normal output 
3220
3221   fold state in prev (previous character)
3222
3223       >0x80 Japanese (X0208/X0201)
3224       <0x80 ASCII
3225       \n    new line 
3226       ' '   space
3227
3228   This fold algorthm does not preserve heading space in a line.
3229   This is the main difference from fmt.
3230 */
3231
3232 #define char_size(c2,c1) (c2?2:1)
3233
3234 void
3235 fold_conv(c2,c1) 
3236 int c2,c1;
3237
3238     int prev0;
3239     int fold_state=0;
3240
3241     if (c1== '\r' && !fold_preserve_f) {
3242         fold_state=0;  /* ignore cr */
3243     }else if (c1== '\n'&&f_prev=='\r' && fold_preserve_f) {
3244         f_prev = '\n';
3245         fold_state=0;  /* ignore cr */
3246     } else if (c1== BS) {
3247         if (f_line>0) f_line--;
3248         fold_state =  1;
3249     } else if (c2==EOF && f_line != 0) {    /* close open last line */
3250             fold_state = '\n';
3251     } else if ((c1=='\n' && !fold_preserve_f)
3252                || ((c1=='\r'||(c1=='\n'&&f_prev!='\r'))
3253                    && fold_preserve_f)) {
3254         /* new line */
3255         if (fold_preserve_f) { 
3256             f_prev = c1;
3257             f_line = 0;
3258             fold_state =  '\r';
3259         } else if ((f_prev == c1 && !fold_preserve_f)
3260                    || (f_prev == '\n' && fold_preserve_f)
3261                    ) {        /* duplicate newline */
3262             if (f_line) {
3263                 f_line = 0;
3264                 fold_state =  '\n';    /* output two newline */
3265             } else {
3266                 f_line = 0;
3267                 fold_state =  1;
3268             }
3269         } else  {
3270             if (f_prev&0x80) {     /* Japanese? */
3271                 f_prev = c1;
3272                 fold_state =  0;       /* ignore given single newline */
3273             } else if (f_prev==' ') {
3274                 fold_state =  0;
3275             } else {
3276                 f_prev = c1;
3277                 if (++f_line<=fold_len) 
3278                     fold_state =  ' ';
3279                 else {
3280                     f_line = 0;
3281                     fold_state =  '\r';        /* fold and output nothing */
3282                 }
3283             }
3284         }
3285     } else if (c1=='\f') {
3286         f_prev = '\n';
3287         if (f_line==0)
3288             fold_state =  1;
3289         f_line = 0;
3290         fold_state =  '\n';            /* output newline and clear */
3291     } else if ( (c2==0  && c1==' ')||
3292                (c2==0  && c1=='\t')||
3293                (c2=='!'&& c1=='!')) {
3294         /* X0208 kankaku or ascii space */
3295             if (f_prev == ' ') {
3296                 fold_state = 0;         /* remove duplicate spaces */
3297             } else {
3298                 f_prev = ' ';    
3299                 if (++f_line<=fold_len) 
3300                     fold_state = ' ';         /* output ASCII space only */
3301                 else {
3302                     f_prev = ' '; f_line = 0;
3303                     fold_state = '\r';        /* fold and output nothing */
3304                 }
3305             }
3306     } else {
3307         prev0 = f_prev; /* we still need this one... , but almost done */
3308         f_prev = c1;
3309         if (c2 || c2==X0201) 
3310             f_prev |= 0x80;  /* this is Japanese */
3311         f_line += char_size(c2,c1);
3312         if (f_line<=fold_len) {   /* normal case */
3313             fold_state = 1;
3314         } else {
3315             if (f_line>fold_len+fold_margin) { /* too many kinsoku suspension */
3316                 f_line = char_size(c2,c1);
3317                 fold_state =  '\n';       /* We can't wait, do fold now */
3318             } else if (c2==X0201) {
3319             /* simple kinsoku rules  return 1 means no folding  */
3320                 if (c1==(0xde&0x7f)) fold_state = 1; /* \e$B!+\e(B*/
3321                 else if (c1==(0xdf&0x7f)) fold_state = 1; /* \e$B!,\e(B*/
3322                 else if (c1==(0xa4&0x7f)) fold_state = 1; /* \e$B!#\e(B*/
3323                 else if (c1==(0xa3&0x7f)) fold_state = 1; /* \e$B!$\e(B*/
3324                 else if (c1==(0xa1&0x7f)) fold_state = 1; /* \e$B!W\e(B*/
3325                 else if (c1==(0xb0&0x7f)) fold_state = 1; /* - */
3326                 else if (SPACE<=c1 && c1<=(0xdf&0x7f)) {      /* X0201 */
3327                     f_line = 1;
3328                     fold_state = '\n';/* add one new f_line before this character */
3329                 } else {
3330                     f_line = 1;
3331                     fold_state = '\n';/* add one new f_line before this character */
3332                 }
3333             } else if (c2==0) {
3334                 /* kinsoku point in ASCII */ 
3335                 if (  c1==')'||    /* { [ ( */
3336                      c1==']'||
3337                      c1=='}'||
3338                      c1=='.'||
3339                      c1==','||
3340                      c1=='!'||
3341                      c1=='?'||
3342                      c1=='/'||
3343                      c1==':'||
3344                      c1==';' ) {
3345                     fold_state = 1;
3346                 /* just after special */
3347                 } else if (!is_alnum(prev0)) {
3348                     f_line = char_size(c2,c1);
3349                     fold_state = '\n';
3350                 } else if ((prev0==' ') ||   /* ignored new f_line */
3351                       (prev0=='\n')||        /* ignored new f_line */
3352                       (prev0&0x80)) {        /* X0208 - ASCII */
3353                     f_line = char_size(c2,c1);
3354                     fold_state = '\n';/* add one new f_line before this character */
3355                 } else {
3356                     fold_state = 1;  /* default no fold in ASCII */
3357                 }
3358             } else {
3359                 if (c2=='!') {
3360                     if (c1=='"')  fold_state = 1; /* \e$B!"\e(B */
3361                     else if (c1=='#')  fold_state = 1; /* \e$B!#\e(B */
3362                     else if (c1=='W')  fold_state = 1; /* \e$B!W\e(B */
3363                     else if (c1=='K')  fold_state = 1; /* \e$B!K\e(B */
3364                     else if (c1=='$')  fold_state = 1; /* \e$B!$\e(B */
3365                     else if (c1=='%')  fold_state = 1; /* \e$B!%\e(B */
3366                     else if (c1=='\'') fold_state = 1; /* \e$B!\\e(B */
3367                     else if (c1=='(')  fold_state = 1; /* \e$B!(\e(B */
3368                     else if (c1==')')  fold_state = 1; /* \e$B!)\e(B */
3369                     else if (c1=='*')  fold_state = 1; /* \e$B!*\e(B */
3370                     else if (c1=='+')  fold_state = 1; /* \e$B!+\e(B */
3371                     else if (c1==',')  fold_state = 1; /* \e$B!,\e(B */
3372                          /* default no fold in kinsoku */
3373                     else { 
3374                         fold_state = '\n';
3375                         f_line = char_size(c2,c1);
3376                         /* add one new f_line before this character */
3377                     }
3378                 } else {
3379                     f_line = char_size(c2,c1);
3380                     fold_state = '\n'; 
3381                     /* add one new f_line before this character */
3382                 }
3383             }
3384         }
3385     }
3386     /* terminator process */
3387     switch(fold_state) {
3388         case '\n': 
3389             (*o_fconv)(0,'\n');
3390             (*o_fconv)(c2,c1);
3391             break;
3392         case 0:    
3393             return;
3394         case '\r': 
3395             (*o_fconv)(0,'\n');
3396             break;
3397         case '\t': 
3398         case ' ': 
3399             (*o_fconv)(0,' ');
3400             break;
3401         default:
3402             (*o_fconv)(c2,c1);
3403     }
3404 }
3405
3406 int z_prev2=0,z_prev1=0;
3407
3408 void
3409 z_conv(c2,c1)
3410 int c2,c1;
3411 {
3412
3413     /* if (c2) c1 &= 0x7f; assertion */
3414
3415     if (x0201_f && z_prev2==X0201) {  /* X0201 */
3416         if (c1==(0xde&0x7f)) { /* \e$BByE@\e(B */
3417             z_prev2=0;
3418             (*o_zconv)(dv[(z_prev1-SPACE)*2],dv[(z_prev1-SPACE)*2+1]);
3419             return;
3420         } else if (c1==(0xdf&0x7f)&&ev[(z_prev1-SPACE)*2]) {  /* \e$BH>ByE@\e(B */
3421             z_prev2=0;
3422             (*o_zconv)(ev[(z_prev1-SPACE)*2],ev[(z_prev1-SPACE)*2+1]);
3423             return;
3424         } else {
3425             z_prev2=0;
3426             (*o_zconv)(cv[(z_prev1-SPACE)*2],cv[(z_prev1-SPACE)*2+1]);
3427         }
3428     }
3429
3430     if (c2==EOF) {
3431         (*o_zconv)(c2,c1);
3432         return;
3433     }
3434
3435     if (x0201_f && c2==X0201) {
3436         if (dv[(c1-SPACE)*2]||ev[(c1-SPACE)*2]) {
3437             /* wait for \e$BByE@\e(B or \e$BH>ByE@\e(B */
3438             z_prev1 = c1; z_prev2 = c2;
3439             return;
3440         } else {
3441             (*o_zconv)(cv[(c1-SPACE)*2],cv[(c1-SPACE)*2+1]);
3442             return;
3443         }
3444     }
3445
3446     /* JISX0208 Alphabet */
3447     if (alpha_f && c2 == 0x23 ) {
3448         c2 = 0;
3449     } else if (alpha_f && c2 == 0x21 ) { 
3450     /* JISX0208 Kigou */
3451        if (0x21==c1) {
3452            if (alpha_f&0x2) {
3453                c1 = ' ';
3454                c2 = 0;
3455            } else if (alpha_f&0x4) {
3456                 (*o_zconv)(0,' ');
3457                 (*o_zconv)(0,' ');
3458                 return;
3459            } 
3460        } else if (0x20<c1 && c1<0x7f && fv[c1-0x20]) {
3461            c1 = fv[c1-0x20];
3462            c2 =  0;
3463            if (alpha_f&0x8) {
3464                char *entity = 0;
3465                switch (c1){
3466                  case '>': entity = "&gt;"; break;
3467                  case '<': entity = "&lt;"; break;
3468                  case '\"': entity = "&quot;"; break;
3469                  case '&': entity = "&amp;"; break;
3470                }
3471                if (entity){
3472                    while (*entity) (*o_zconv)(0, *entity++);
3473                    return;
3474                }
3475            }
3476        } 
3477     }
3478     (*o_zconv)(c2,c1);
3479 }
3480
3481
3482 #define rot13(c)  ( \
3483       ( c < 'A' ) ? c: \
3484       (c <= 'M')  ? (c + 13): \
3485       (c <= 'Z')  ? (c - 13): \
3486       (c < 'a')   ? (c): \
3487       (c <= 'm')  ? (c + 13): \
3488       (c <= 'z')  ? (c - 13): \
3489       (c) \
3490 )
3491
3492 #define  rot47(c) ( \
3493       ( c < '!' ) ? c: \
3494       ( c <= 'O' ) ? (c + 47) : \
3495       ( c <= '~' ) ?  (c - 47) : \
3496       c \
3497 )
3498
3499 void
3500 rot_conv(c2,c1)
3501 int c2,c1;
3502 {
3503     if (c2==0 || c2==X0201 || c2==ISO8859_1) {
3504         c1 = rot13(c1);
3505     } else if (c2) {
3506         c1 = rot47(c1);
3507         c2 = rot47(c2);
3508     }
3509     (*o_rot_conv)(c2,c1);
3510 }
3511
3512 void
3513 hira_conv(c2,c1)
3514 int c2,c1;
3515 {
3516     if ((hira_f & 1) && c2==0x25 && 0x20<c1 && c1<0x74) {
3517         c2 = 0x24;
3518     } else if ((hira_f & 2) && c2==0x24 && 0x20<c1 && c1<0x74) {
3519         c2 = 0x25;
3520     } 
3521     (*o_hira_conv)(c2,c1);
3522 }
3523
3524
3525 void
3526 iso2022jp_check_conv(c2,c1)
3527 int    c2, c1;
3528 {
3529     STATIC const int range[RANGE_NUM_MAX][2] = {
3530         {0x222f, 0x2239,},
3531         {0x2242, 0x2249,},
3532         {0x2251, 0x225b,},
3533         {0x226b, 0x2271,},
3534         {0x227a, 0x227d,},
3535         {0x2321, 0x232f,},
3536         {0x233a, 0x2340,},
3537         {0x235b, 0x2360,},
3538         {0x237b, 0x237e,},
3539         {0x2474, 0x247e,},
3540         {0x2577, 0x257e,},
3541         {0x2639, 0x2640,},
3542         {0x2659, 0x267e,},
3543         {0x2742, 0x2750,},
3544         {0x2772, 0x277e,},
3545         {0x2841, 0x287e,},
3546         {0x4f54, 0x4f7e,},
3547         {0x7425, 0x747e},
3548     };
3549     int i;
3550     int start, end, c;
3551
3552     if(c2 >= 0x00 && c2 <= 0x20 && c1 >= 0x7f && c1 <= 0xff) {
3553         c2 = GETA1;
3554         c1 = GETA2;
3555     }
3556     if((c2 >= 0x29 && c2 <= 0x2f) || (c2 >= 0x75 && c2 <= 0x7e)) {
3557         c2 = GETA1;
3558         c1 = GETA2;
3559     }
3560
3561     for (i = 0; i < RANGE_NUM_MAX; i++) {
3562         start = range[i][0];
3563         end   = range[i][1];
3564         c     = (c2 << 8) + c1;
3565         if (c >= start && c <= end) {
3566             c2 = GETA1;
3567             c1 = GETA2;
3568         }
3569     }
3570     (*o_iso2022jp_check_conv)(c2,c1);
3571 }
3572
3573
3574 /* This converts  =?ISO-2022-JP?B?HOGE HOGE?= */
3575
3576 const unsigned char *mime_pattern[] = {
3577     (const unsigned char *)"\075?EUC-JP?B?",
3578     (const unsigned char *)"\075?SHIFT_JIS?B?",
3579     (const unsigned char *)"\075?ISO-8859-1?Q?",
3580     (const unsigned char *)"\075?ISO-8859-1?B?",
3581     (const unsigned char *)"\075?ISO-2022-JP?B?",
3582     (const unsigned char *)"\075?ISO-2022-JP?Q?",
3583 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
3584     (const unsigned char *)"\075?UTF-8?B?",
3585     (const unsigned char *)"\075?UTF-8?Q?",
3586 #endif
3587     (const unsigned char *)"\075?US-ASCII?Q?",
3588     NULL
3589 };
3590
3591
3592 /* \e$B3:Ev$9$k%3!<%I$NM%@hEY$r>e$2$k$?$a$NL\0u\e(B */
3593 int (*mime_priority_func[])PROTO((int c2, int c1, int c0)) = {
3594     e_iconv, s_iconv, 0, 0, 0, 0,
3595 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
3596     w_iconv, w_iconv,
3597 #endif
3598     0,
3599 };
3600
3601 const int mime_encode[] = {
3602     JAPANESE_EUC, SHIFT_JIS,ISO8859_1, ISO8859_1, X0208, X0201,
3603 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
3604     UTF8, UTF8,
3605 #endif
3606     ASCII,
3607     0
3608 };
3609
3610 const int mime_encode_method[] = {
3611     'B', 'B','Q', 'B', 'B', 'Q',
3612 #if defined(UTF8_INPUT_ENABLE) || defined(UTF8_OUTPUT_ENABLE)
3613     'B', 'Q',
3614 #endif
3615     'Q',
3616     0
3617 };
3618
3619
3620 #define MAXRECOVER 20
3621
3622 /* I don't trust portablity of toupper */
3623 #define nkf_toupper(c)  (('a'<=c && c<='z')?(c-('a'-'A')):c)
3624 #define nkf_isdigit(c)  ('0'<=c && c<='9')
3625 #define nkf_isxdigit(c)  (nkf_isdigit(c) || ('a'<=c && c<='f') || ('A'<=c && c <= 'F'))
3626 #define nkf_isblank(c) (c == SPACE || c == TAB)
3627 #define nkf_isspace(c) (nkf_isblank(c) || c == CR || c == NL)
3628 #define nkf_isalpha(c) (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
3629 #define nkf_isalnum(c) (nkf_isdigit(c) || nkf_isalpha(c))
3630
3631 void
3632 switch_mime_getc()
3633 {
3634     if (i_getc!=mime_getc) {
3635         i_mgetc = i_getc; i_getc = mime_getc;
3636         i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
3637         if(mime_f==STRICT_MIME) {
3638             i_mgetc_buf = i_mgetc; i_mgetc = mime_getc_buf;
3639             i_mungetc_buf = i_mungetc; i_mungetc = mime_ungetc_buf;
3640         }
3641     }
3642 }
3643
3644 void
3645 unswitch_mime_getc()
3646 {
3647     if(mime_f==STRICT_MIME) {
3648         i_mgetc = i_mgetc_buf;
3649         i_mungetc = i_mungetc_buf;
3650     }
3651     i_getc = i_mgetc;
3652     i_ungetc = i_mungetc;
3653     if(mime_iconv_back)set_iconv(FALSE, mime_iconv_back);
3654     mime_iconv_back = NULL;
3655 }
3656
3657 int
3658 mime_begin_strict(f)
3659 FILE *f;
3660 {
3661     int c1 = 0;
3662     int i,j,k;
3663     const unsigned char *p,*q;
3664     int r[MAXRECOVER];    /* recovery buffer, max mime pattern lenght */
3665
3666     mime_decode_mode = FALSE;
3667     /* =? has been checked */
3668     j = 0;
3669     p = mime_pattern[j];
3670     r[0]='='; r[1]='?';
3671
3672     for(i=2;p[i]>' ';i++) {                   /* start at =? */
3673         if ( ((r[i] = c1 = (*i_getc)(f))==EOF) || nkf_toupper(c1) != p[i] ) {
3674             /* pattern fails, try next one */
3675             q = p;
3676             while ((p = mime_pattern[++j])) {
3677                 for(k=2;k<i;k++)              /* assume length(p) > i */
3678                     if (p[k]!=q[k]) break;
3679                 if (k==i && nkf_toupper(c1)==p[k]) break;
3680             }
3681             if (p) continue;  /* found next one, continue */
3682             /* all fails, output from recovery buffer */
3683             (*i_ungetc)(c1,f);
3684             for(j=0;j<i;j++) {
3685                 (*oconv)(0,r[j]);
3686             }
3687             return c1;
3688         }
3689     }
3690     mime_decode_mode = p[i-2];
3691
3692     mime_iconv_back = iconv;
3693     set_iconv(FALSE, mime_priority_func[j]);
3694     clr_code_score(find_inputcode_byfunc(mime_priority_func[j]), SCORE_iMIME);
3695
3696     if (mime_decode_mode=='B') {
3697         mimebuf_f = unbuf_f;
3698         if (!unbuf_f) {
3699             /* do MIME integrity check */
3700             return mime_integrity(f,mime_pattern[j]);
3701         } 
3702     }
3703     switch_mime_getc();
3704     mimebuf_f = TRUE;
3705     return c1;
3706 }
3707
3708 int
3709 mime_getc_buf(f) 
3710 FILE *f;
3711 {
3712     /* we don't keep eof of Fifo, becase it contains ?= as
3713        a terminator. It was checked in mime_integrity. */
3714     return ((mimebuf_f)?
3715         (*i_mgetc_buf)(f):Fifo(mime_input++));
3716 }
3717
3718 int
3719 mime_ungetc_buf(c,f) 
3720 FILE *f;
3721 int c;
3722 {
3723     if (mimebuf_f)
3724         (*i_mungetc_buf)(c,f);
3725     else 
3726         Fifo(--mime_input)=c;
3727     return c;
3728 }
3729
3730 int
3731 mime_begin(f)
3732 FILE *f;
3733 {
3734     int c1;
3735     int i,k;
3736
3737     /* In NONSTRICT mode, only =? is checked. In case of failure, we  */
3738     /* re-read and convert again from mime_buffer.  */
3739
3740     /* =? has been checked */
3741     k = mime_last;
3742     Fifo(mime_last++)='='; Fifo(mime_last++)='?';
3743     for(i=2;i<MAXRECOVER;i++) {                   /* start at =? */
3744         /* We accept any character type even if it is breaked by new lines */
3745         c1 = (*i_getc)(f); Fifo(mime_last++)= c1 ;
3746         if (c1=='\n'||c1==' '||c1=='\r'||
3747                 c1=='-'||c1=='_'||is_alnum(c1) ) continue;
3748         if (c1=='=') {
3749             /* Failed. But this could be another MIME preemble */
3750             (*i_ungetc)(c1,f);
3751             mime_last--;
3752             break;
3753         }
3754         if (c1!='?') break;
3755         else {
3756             /* c1=='?' */
3757             c1 = (*i_getc)(f); Fifo(mime_last++) = c1;
3758             if (!(++i<MAXRECOVER) || c1==EOF) break;
3759             if (c1=='b'||c1=='B') {
3760                 mime_decode_mode = 'B';
3761             } else if (c1=='q'||c1=='Q') {
3762                 mime_decode_mode = 'Q';
3763             } else {
3764                 break;
3765             }
3766             c1 = (*i_getc)(f); Fifo(mime_last++) = c1;
3767             if (!(++i<MAXRECOVER) || c1==EOF) break;
3768             if (c1!='?') {
3769                 mime_decode_mode = FALSE;
3770             }
3771             break;
3772         }
3773     }
3774     switch_mime_getc();
3775     if (!mime_decode_mode) {
3776         /* false MIME premble, restart from mime_buffer */
3777         mime_decode_mode = 1;  /* no decode, but read from the mime_buffer */
3778         /* Since we are in MIME mode until buffer becomes empty,    */
3779         /* we never go into mime_begin again for a while.           */
3780         return c1;
3781     }
3782     /* discard mime preemble, and goto MIME mode */
3783     mime_last = k;
3784     /* do no MIME integrity check */
3785     return c1;   /* used only for checking EOF */
3786 }
3787
3788 #ifdef CHECK_OPTION
3789 void
3790 no_putc(c)
3791      int c;
3792 {
3793     ;
3794 }
3795
3796 void debug(str)
3797     const char *str;
3798 {
3799     if (debug_f){
3800         fprintf(stderr, "%s\n", str);
3801     }
3802 }
3803 #endif
3804
3805 void
3806 set_input_codename (codename)
3807     char *codename;
3808 {
3809     if (guess_f && 
3810         is_inputcode_set &&
3811         strcmp(codename, "") != 0 && 
3812         strcmp(codename, input_codename) != 0)
3813     {
3814         is_inputcode_mixed = TRUE;
3815     }
3816     input_codename = codename;
3817     is_inputcode_set = TRUE;
3818 }
3819
3820 #if !defined(PERL_XS) && !defined(WIN32DLL)
3821 void
3822 print_guessed_code (filename)
3823     char *filename;
3824 {
3825     char *codename = "BINARY";
3826     if (!is_inputcode_mixed) {
3827         if (strcmp(input_codename, "") == 0) {
3828             codename = "ASCII";
3829         } else {
3830             codename = input_codename;
3831         }
3832     }
3833     if (filename != NULL) printf("%s:", filename);
3834     printf("%s\n", codename);
3835 }
3836 #endif /*WIN32DLL*/
3837
3838 int
3839 hex2bin(x)
3840      int x;
3841 {
3842     if (nkf_isdigit(x)) return x - '0';
3843     return nkf_toupper(x) - 'A' + 10;
3844 }
3845
3846 #ifdef INPUT_OPTION 
3847
3848 #ifdef ANSI_C_PROTOTYPE
3849 int hex_getc(int ch, FILE *f, int (*g)(FILE *f), int (*u)(int c, FILE *f))
3850 #else
3851 int
3852 hex_getc(ch, f, g, u)
3853      int ch;
3854      FILE *f;
3855      int (*g)();
3856      int (*u)();
3857 #endif
3858 {
3859     int c1, c2, c3;
3860     c1 = (*g)(f);
3861     if (c1 != ch){
3862         return c1;
3863     }
3864     c2 = (*g)(f);
3865     if (!nkf_isxdigit(c2)){
3866         (*u)(c2, f);
3867         return c1;
3868     }
3869     c3 = (*g)(f);
3870     if (!nkf_isxdigit(c3)){
3871         (*u)(c2, f);
3872         (*u)(c3, f);
3873         return c1;
3874     }
3875     return (hex2bin(c2) << 4) | hex2bin(c3);
3876 }
3877
3878 int
3879 cap_getc(f)
3880      FILE *f;
3881 {
3882     return hex_getc(':', f, i_cgetc, i_cungetc);
3883 }
3884
3885 int
3886 cap_ungetc(c, f)
3887      int c;
3888      FILE *f;
3889 {
3890     return (*i_cungetc)(c, f);
3891 }
3892
3893 int
3894 url_getc(f)
3895      FILE *f;
3896 {
3897     return hex_getc('%', f, i_ugetc, i_uungetc);
3898 }
3899
3900 int
3901 url_ungetc(c, f)
3902      int c;
3903      FILE *f;
3904 {
3905     return (*i_uungetc)(c, f);
3906 }
3907 #endif
3908
3909 #ifdef NUMCHAR_OPTION
3910 int
3911 numchar_getc(f)
3912      FILE *f;
3913 {
3914     int (*g)() = i_ngetc;
3915     int (*u)() = i_nungetc;
3916     int i = 0, j;
3917     int buf[8];
3918     long c = -1;
3919
3920     buf[i] = (*g)(f);
3921     if (buf[i] == '&'){
3922         buf[++i] = (*g)(f);
3923         if (buf[i] == '#'){
3924             c = 0;
3925             buf[++i] = (*g)(f);
3926             if (buf[i] == 'x' || buf[i] == 'X'){
3927                 for (j = 0; j < 5; j++){
3928                     buf[++i] = (*g)(f);
3929                     if (!nkf_isxdigit(buf[i])){
3930                         if (buf[i] != ';'){
3931                             c = -1;
3932                         }
3933                         break;
3934                     }
3935                     c <<= 4;
3936                     c |= hex2bin(buf[i]);
3937                 }
3938             }else{
3939                 for (j = 0; j < 6; j++){
3940                     if (j){
3941                         buf[++i] = (*g)(f);
3942                     }
3943                     if (!nkf_isdigit(buf[i])){
3944                         if (buf[i] != ';'){
3945                             c = -1;
3946                         }
3947                         break;
3948                     }
3949                     c *= 10;
3950                     c += hex2bin(buf[i]);
3951                 }
3952             }
3953         }
3954     }
3955     if (c != -1){
3956         return CLASS_UTF16 | c;
3957     }
3958     while (i > 0){
3959         (*u)(buf[i], f);
3960         --i;
3961     }
3962     return buf[0];
3963 }
3964
3965 int
3966 numchar_ungetc(c, f)
3967      int c;
3968      FILE *f;
3969 {
3970     return (*i_nungetc)(c, f);
3971 }
3972 #endif
3973
3974 #ifdef UNICODE_NORMALIZATION
3975
3976 /* Normalization Form C */
3977 int
3978 nfc_getc(f)
3979      FILE *f;
3980 {
3981     int (*g)() = i_nfc_getc;
3982     int (*u)() = i_nfc_ungetc;
3983     int i=0, j, k=1, lower, upper;
3984     int buf[9];
3985     const int *array = NULL;
3986     extern const struct normalization_pair normalization_table[];
3987     
3988     buf[i] = (*g)(f);
3989     while (k > 0 && ((buf[i] & 0xc0) != 0x80)){
3990         lower=0, upper=NORMALIZATION_TABLE_LENGTH-1;
3991         while (upper >= lower) {
3992             j = (lower+upper) / 2;
3993             array = normalization_table[j].nfd;
3994             for (k=0; k < NORMALIZATION_TABLE_NFD_LENGTH && array[k]; k++){
3995                 if (array[k] != buf[k]){
3996                     array[k] < buf[k] ? (lower = j + 1) : (upper = j - 1);
3997                     k = 0;
3998                     break;
3999                 } else if (k >= i)
4000                     buf[++i] = (*g)(f);
4001             }
4002             if (k > 0){
4003                 array = normalization_table[j].nfc;
4004                 for (i=0; i < NORMALIZATION_TABLE_NFC_LENGTH && array[i]; i++)
4005                     buf[i] = array[i];
4006                 i--;
4007                 break;
4008             }
4009         }
4010         while (i > 0)
4011             (*u)(buf[i--], f);
4012     }
4013     return buf[0];
4014 }
4015
4016 int
4017 nfc_ungetc(c, f)
4018      int c;
4019      FILE *f;
4020 {
4021     return (*i_nfc_ungetc)(c, f);
4022 }
4023 #endif /* UNICODE_NORMALIZATION */
4024
4025
4026 int 
4027 mime_getc(f)
4028 FILE *f;
4029 {
4030     int c1, c2, c3, c4, cc;
4031     int t1, t2, t3, t4, mode, exit_mode;
4032     int lwsp_count;
4033     char *lwsp_buf;
4034     char *lwsp_buf_new;
4035     int lwsp_size = 128;
4036
4037     if (mime_top != mime_last) {  /* Something is in FIFO */
4038         return  Fifo(mime_top++);
4039     }
4040     if (mime_decode_mode==1 ||mime_decode_mode==FALSE) {
4041         mime_decode_mode=FALSE;
4042         unswitch_mime_getc();
4043         return (*i_getc)(f);
4044     }
4045
4046     if (mimebuf_f == FIXED_MIME)
4047         exit_mode = mime_decode_mode;
4048     else
4049         exit_mode = FALSE;
4050     if (mime_decode_mode == 'Q') {
4051         if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
4052 restart_mime_q:
4053         if (c1=='_') return ' ';
4054         if (c1<=' ' || DEL<=c1) {
4055             mime_decode_mode = exit_mode; /* prepare for quit */
4056             return c1;
4057         }
4058         if (c1!='=' && c1!='?') {
4059             return c1;
4060         }
4061                 
4062         mime_decode_mode = exit_mode; /* prepare for quit */
4063         if ((c2 = (*i_mgetc)(f)) == EOF) return (EOF);
4064         if (c1=='?'&&c2=='=' && mimebuf_f != FIXED_MIME) {
4065             /* end Q encoding */
4066             input_mode = exit_mode;
4067             lwsp_count = 0;
4068             lwsp_buf = malloc((lwsp_size+5)*sizeof(char));
4069             if (lwsp_buf==NULL) {
4070                 perror("can't malloc");
4071                 return -1;
4072             }
4073             while ((c1=(*i_getc)(f))!=EOF) {
4074                 switch (c1) {
4075                 case NL:
4076                 case CR:
4077                     if (c1==NL) {
4078                         if ((c1=(*i_getc)(f))!=EOF && (c1==SPACE||c1==TAB)) {
4079                             i_ungetc(SPACE,f);
4080                             continue;
4081                         } else {
4082                             i_ungetc(c1,f);
4083                         }
4084                         c1 = NL;
4085                     } else {
4086                         if ((c1=(*i_getc)(f))!=EOF && c1 == NL) {
4087                             if ((c1=(*i_getc)(f))!=EOF && (c1==SPACE||c1==TAB)) {
4088                                 i_ungetc(SPACE,f);
4089                                 continue;
4090                             } else {
4091                                 i_ungetc(c1,f);
4092                             }
4093                             i_ungetc(NL,f);
4094                         } else {
4095                             i_ungetc(c1,f);
4096                         }
4097                         c1 = CR;
4098                     }
4099                     break;
4100                 case SPACE:
4101                 case TAB:
4102                     lwsp_buf[lwsp_count] = c1;
4103                     if (lwsp_count++>lwsp_size){
4104                         lwsp_size *= 2;
4105                         lwsp_buf_new = realloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4106                         if (lwsp_buf_new==NULL) {
4107                             free(lwsp_buf);
4108                             lwsp_buf = NULL;
4109                             perror("can't realloc");
4110                             return -1;
4111                         }
4112                         lwsp_buf = lwsp_buf_new;
4113                     }
4114                     continue;
4115                 }
4116                 break;
4117             }
4118             if (lwsp_count > 0) {
4119                 if (c1=='=' && (lwsp_buf[lwsp_count-1]==SPACE||lwsp_buf[lwsp_count-1]==TAB)) {
4120                     lwsp_count = 0;
4121                 } else {
4122                     i_ungetc(c1,f);
4123                     for(lwsp_count--;lwsp_count>0;lwsp_count--)
4124                         i_ungetc(lwsp_buf[lwsp_count],f);
4125                     c1 = lwsp_buf[0];
4126                 }
4127             }
4128             free(lwsp_buf);
4129             lwsp_buf = NULL;
4130             return c1;
4131         }
4132         if (c1=='='&&c2<' ') { /* this is soft wrap */
4133             while((c1 =  (*i_mgetc)(f)) <=' ') {
4134                 if ((c1 = (*i_mgetc)(f)) == EOF) return (EOF);
4135             }
4136             mime_decode_mode = 'Q'; /* still in MIME */
4137             goto restart_mime_q;
4138         }
4139         if (c1=='?') {
4140             mime_decode_mode = 'Q'; /* still in MIME */
4141             (*i_mungetc)(c2,f);
4142             return c1;
4143         }
4144         if ((c3 = (*i_mgetc)(f)) == EOF) return (EOF);
4145         if (c2<=' ') return c2;
4146         mime_decode_mode = 'Q'; /* still in MIME */
4147 #define hex(c)   (('0'<=c&&c<='9')?(c-'0'):\
4148      ('A'<=c&&c<='F')?(c-'A'+10):('a'<=c&&c<='f')?(c-'a'+10):0)
4149         return ((hex(c2)<<4) + hex(c3));
4150     }
4151
4152     if (mime_decode_mode != 'B') {
4153         mime_decode_mode = FALSE;
4154         return (*i_mgetc)(f);
4155     }
4156
4157
4158     /* Base64 encoding */
4159     /* 
4160         MIME allows line break in the middle of 
4161         Base64, but we are very pessimistic in decoding
4162         in unbuf mode because MIME encoded code may broken by 
4163         less or editor's control sequence (such as ESC-[-K in unbuffered
4164         mode. ignore incomplete MIME.
4165     */
4166     mode = mime_decode_mode;
4167     mime_decode_mode = exit_mode;  /* prepare for quit */
4168
4169     while ((c1 = (*i_mgetc)(f))<=' ') {
4170         if (c1==EOF)
4171             return (EOF);
4172     }
4173 mime_c2_retry:
4174     if ((c2 = (*i_mgetc)(f))<=' ') {
4175         if (c2==EOF)
4176             return (EOF);
4177         if (mime_f != STRICT_MIME) goto mime_c2_retry;
4178         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;  
4179         return c2;
4180     }
4181     if ((c1 == '?') && (c2 == '=')) {
4182         input_mode = ASCII;
4183         lwsp_count = 0;
4184         lwsp_buf = malloc((lwsp_size+5)*sizeof(char));
4185         if (lwsp_buf==NULL) {
4186             perror("can't malloc");
4187             return -1;
4188         }
4189         while ((c1=(*i_getc)(f))!=EOF) {
4190             switch (c1) {
4191             case NL:
4192             case CR:
4193                 if (c1==NL) {
4194                     if ((c1=(*i_getc)(f))!=EOF && (c1==SPACE||c1==TAB)) {
4195                         i_ungetc(SPACE,f);
4196                         continue;
4197                     } else {
4198                         i_ungetc(c1,f);
4199                     }
4200                     c1 = NL;
4201                 } else {
4202                     if ((c1=(*i_getc)(f))!=EOF) {
4203                         if (c1==SPACE) {
4204                             i_ungetc(SPACE,f);
4205                             continue;
4206                         } else if ((c1=(*i_getc)(f))!=EOF && (c1==SPACE||c1==TAB)) {
4207                             i_ungetc(SPACE,f);
4208                             continue;
4209                         } else {
4210                             i_ungetc(c1,f);
4211                         }
4212                         i_ungetc(NL,f);
4213                     } else {
4214                         i_ungetc(c1,f);
4215                     }
4216                     c1 = CR;
4217                 }
4218                 break;
4219             case SPACE:
4220             case TAB:
4221                 lwsp_buf[lwsp_count] = c1;
4222                 if (lwsp_count++>lwsp_size){
4223                     lwsp_size *= 2;
4224                     lwsp_buf_new = realloc(lwsp_buf, (lwsp_size+5)*sizeof(char));
4225                     if (lwsp_buf_new==NULL) {
4226                         free(lwsp_buf);
4227                         lwsp_buf = NULL;
4228                         perror("can't realloc");
4229                         return -1;
4230                     }
4231                     lwsp_buf = lwsp_buf_new;
4232                 }
4233                 continue;
4234             }
4235             break;
4236         }
4237         if (lwsp_count > 0) {
4238             if (c1=='=' && (lwsp_buf[lwsp_count-1]==SPACE||lwsp_buf[lwsp_count-1]==TAB)) {
4239                 lwsp_count = 0;
4240             } else {
4241                 i_ungetc(c1,f);
4242                 for(lwsp_count--;lwsp_count>0;lwsp_count--)
4243                     i_ungetc(lwsp_buf[lwsp_count],f);
4244                 c1 = lwsp_buf[0];
4245             }
4246         }
4247         free(lwsp_buf);
4248         lwsp_buf = NULL;
4249         return c1;
4250     }
4251 mime_c3_retry:
4252     if ((c3 = (*i_mgetc)(f))<=' ') {
4253         if (c3==EOF)
4254             return (EOF);
4255         if (mime_f != STRICT_MIME) goto mime_c3_retry;
4256         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;  
4257         return c3;
4258     }
4259 mime_c4_retry:
4260     if ((c4 = (*i_mgetc)(f))<=' ') {
4261         if (c4==EOF)
4262             return (EOF);
4263         if (mime_f != STRICT_MIME) goto mime_c4_retry;
4264         if (mimebuf_f!=FIXED_MIME) input_mode = ASCII;  
4265         return c4;
4266     }
4267
4268     mime_decode_mode = mode; /* still in MIME sigh... */
4269
4270     /* BASE 64 decoding */
4271
4272     t1 = 0x3f & base64decode(c1);
4273     t2 = 0x3f & base64decode(c2);
4274     t3 = 0x3f & base64decode(c3);
4275     t4 = 0x3f & base64decode(c4);
4276     cc = ((t1 << 2) & 0x0fc) | ((t2 >> 4) & 0x03);
4277     if (c2 != '=') {
4278         Fifo(mime_last++) = cc;
4279         cc = ((t2 << 4) & 0x0f0) | ((t3 >> 2) & 0x0f);
4280         if (c3 != '=') {
4281             Fifo(mime_last++) = cc;
4282             cc = ((t3 << 6) & 0x0c0) | (t4 & 0x3f);
4283             if (c4 != '=') 
4284                 Fifo(mime_last++) = cc;
4285         }
4286     } else {
4287         return c1;
4288     }
4289     return  Fifo(mime_top++);
4290 }
4291
4292 int
4293 mime_ungetc(c,f) 
4294 int   c;
4295 FILE  *f;
4296 {
4297     Fifo(--mime_top) = c;
4298     return c;
4299 }
4300
4301 int
4302 mime_integrity(f,p)
4303     FILE *f;
4304     const unsigned char *p;
4305 {
4306     int c,d;
4307     unsigned int q;
4308     /* In buffered mode, read until =? or NL or buffer full
4309      */
4310     mime_input = mime_top;
4311     mime_last = mime_top;
4312     
4313     while(*p) Fifo(mime_input++) = *p++;
4314     d = 0;
4315     q = mime_input;
4316     while((c=(*i_getc)(f))!=EOF) {
4317         if (((mime_input-mime_top)&MIME_BUF_MASK)==0) {
4318             break;   /* buffer full */
4319         }
4320         if (c=='=' && d=='?') {
4321             /* checked. skip header, start decode */
4322             Fifo(mime_input++) = c;
4323             /* mime_last_input = mime_input; */
4324             mime_input = q; 
4325             switch_mime_getc();
4326             return 1;
4327         }
4328         if (!( (c=='+'||c=='/'|| c=='=' || c=='?' || is_alnum(c))))
4329             break;
4330         /* Should we check length mod 4? */
4331         Fifo(mime_input++) = c;
4332         d=c;
4333     }
4334     /* In case of Incomplete MIME, no MIME decode  */
4335     Fifo(mime_input++) = c;
4336     mime_last = mime_input;     /* point undecoded buffer */
4337     mime_decode_mode = 1;              /* no decode on Fifo last in mime_getc */
4338     switch_mime_getc();         /* anyway we need buffered getc */
4339     return 1;
4340 }
4341
4342 int
4343 base64decode(c)
4344     int            c;
4345 {
4346     int             i;
4347     if (c > '@') {
4348         if (c < '[') {
4349             i = c - 'A';                        /* A..Z 0-25 */
4350         } else {
4351             i = c - 'G'     /* - 'a' + 26 */ ;  /* a..z 26-51 */
4352         }
4353     } else if (c > '/') {
4354         i = c - '0' + '4'   /* - '0' + 52 */ ;  /* 0..9 52-61 */
4355     } else if (c == '+') {
4356         i = '>'             /* 62 */ ;          /* +  62 */
4357     } else {
4358         i = '?'             /* 63 */ ;          /* / 63 */
4359     }
4360     return (i);
4361 }
4362
4363 STATIC const char basis_64[] =
4364    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4365
4366 STATIC int b64c;
4367 #define MIMEOUT_BUF_LENGTH (60)
4368 char mimeout_buf[MIMEOUT_BUF_LENGTH+1];
4369 int mimeout_buf_count = 0;
4370 int mimeout_preserve_space = 0;
4371 #define itoh4(c)   (c>=10?c+'A'-10:c+'0')
4372
4373 void
4374 open_mime(mode)
4375 int mode;
4376 {
4377     const unsigned char *p;
4378     int i;
4379     int j;
4380     p  = mime_pattern[0];
4381     for(i=0;mime_encode[i];i++) {
4382         if (mode == mime_encode[i]) {
4383             p = mime_pattern[i];
4384             break;
4385         }
4386     }
4387     mimeout_mode = mime_encode_method[i];
4388     
4389     i = 0;
4390     if (base64_count>45) {
4391         if (mimeout_buf_count>0 && nkf_isblank(mimeout_buf[i])){
4392             (*o_mputc)(mimeout_buf[i]);
4393             i++;
4394         }
4395         (*o_mputc)(NL);
4396         (*o_mputc)(SPACE);
4397         base64_count = 1;
4398         if (!mimeout_preserve_space && mimeout_buf_count>0
4399             && (mimeout_buf[i]==SPACE || mimeout_buf[i]==TAB
4400                 || mimeout_buf[i]==CR || mimeout_buf[i]==NL )) {
4401             i++;
4402         }
4403     }
4404     if (!mimeout_preserve_space) {
4405         for (;i<mimeout_buf_count;i++) {
4406             if (mimeout_buf[i]==SPACE || mimeout_buf[i]==TAB
4407                 || mimeout_buf[i]==CR || mimeout_buf[i]==NL ) {
4408                 (*o_mputc)(mimeout_buf[i]);
4409                 base64_count ++;
4410             } else {
4411                 break;
4412             }
4413         }
4414     }
4415     mimeout_preserve_space = FALSE;
4416     
4417     while(*p) {
4418         (*o_mputc)(*p++);
4419         base64_count ++;
4420     }
4421     j = mimeout_buf_count;
4422     mimeout_buf_count = 0;
4423     for (;i<j;i++) {
4424         mime_putc(mimeout_buf[i]);
4425     }
4426 }
4427
4428 void
4429 close_mime()
4430 {
4431     (*o_mputc)('?');
4432     (*o_mputc)('=');
4433     base64_count += 2;
4434     mimeout_mode = 0;
4435 }
4436
4437 void
4438 eof_mime()
4439 {
4440     switch(mimeout_mode) {
4441     case 'Q':
4442     case 'B':
4443         break;
4444     case 2:
4445         (*o_mputc)(basis_64[((b64c & 0x3)<< 4)]);
4446         (*o_mputc)('=');
4447         (*o_mputc)('=');
4448         base64_count += 3;
4449         break;
4450     case 1:
4451         (*o_mputc)(basis_64[((b64c & 0xF) << 2)]);
4452         (*o_mputc)('=');
4453         base64_count += 2;
4454         break;
4455     }
4456     if (mimeout_mode) {
4457         if (mimeout_f!=FIXED_MIME) {
4458             close_mime(); 
4459         } else if (mimeout_mode != 'Q')
4460