OSDN Git Service

version strings
[nkf/nkf.git] / nkf32dll.c
1 /* nkf32.dll nfk32dll.c */
2 // e-mail:tkaneto@nifty.com
3 // URL: http://www1.ttcn.ne.jp/~kaneto
4
5 /*WIN32DLL*/
6 /* \82±\82¿\82ç\82Ì\83o\81[\83W\83\87\83\93\82à\8dX\90V\82µ\82Ä\82­\82¾\82³\82¢\81B */
7 #define NKF_VERSIONW L"2.0.4"
8 /* NKF_VERSION \82Ì\83\8f\83C\83h\95\8e\9a */
9 #define DLL_VERSION   "2.0.4.1 1"
10 /* DLL\82ª\95Ô\82· */
11 #define DLL_VERSIONW L"2.0.4.1 1"
12 /* DLL\82ª\95Ô\82· DLL_VERSION \82Ì\83\8f\83C\83h\95\8e\9a */
13
14 /* nkf32.dll main */
15 #include <windows.h>
16 #include <tchar.h>
17 #include <stdarg.h>
18 #include "nkf.h"
19
20 #ifdef DLLDBG /* DLLDBG @@*/
21 void dumpn(unsigned char *buff,unsigned n)
22 {
23     int i;
24
25     i = 0;
26     while ( n ) {
27         if ( i == 0 ) {
28             printf(":%x  ",buff);
29         }
30         printf("%02x ",*buff++);
31         i++;
32         if ( i == 16 ) {
33             printf("\n");
34             i = 0;
35         }
36         n--;
37     }
38     printf("\n");
39 }
40
41 void dumpf(char *f);
42 void mkfile(char *f,char *p);
43 #endif /* DLLDBG @@*/
44
45 #ifndef GUESS
46 #define GUESS 64
47 #endif /*GUESS*/
48
49 char guessbuffA[MAX_PATH + GUESS];
50 #ifdef UNICODESUPPORT
51 wchar_t guessbuffW[MAX_PATH + GUESS];
52 UINT guessCodePage = CP_OEMCP;
53 DWORD guessdwFlags = MB_PRECOMPOSED;
54
55 wchar_t *tounicode(char *p)
56 {
57 static wchar_t buff[GUESS];
58     int sts;
59
60     sts = MultiByteToWideChar(guessCodePage,guessdwFlags,p,-1,buff,sizeof(buff) / sizeof(wchar_t));
61     if ( sts ) {
62         return buff;
63     } else {
64         return L"(NULL)";
65     }
66 }
67 #endif /*UNICODESUPPORT*/
68
69 char *ubuff;
70 int ulen;
71 int uret;
72
73 int dllprintf(FILE *fp,char *fmt,...)
74 {
75     va_list argp;
76     int sts;
77
78     if ( uret != FALSE && ulen >= 1 && fmt != NULL && *fmt != 0 ) {
79         va_start(argp, fmt);
80         sts = _vsnprintf(ubuff,ulen - 1,fmt,argp);
81         va_end(argp);
82         if ( sts >= 0 ) {
83             ubuff += sts;
84             ulen -= sts;
85         } else {
86             uret = FALSE;
87         }
88         return sts;
89     } else return 0;
90 }
91
92 /** Network Kanji Filter. (PDS Version)
93 ************************************************************************
94 ** Copyright (C) 1987, Fujitsu LTD. (Itaru ICHIKAWA)
95 ** \98A\97\8d\90æ\81\81i\8a\94\81j\95x\8em\92Ê\8c¤\8b\86\8f\8a\81@\83\\83t\83g\82R\8c¤\81@\8es\90ì\81@\8e\8a 
96 ** \81iE-Mail Address: ichikawa@flab.fujitsu.co.jp\81j
97 ** Copyright (C) 1996,1998
98 ** Copyright (C) 2002
99 ** \98A\97\8d\90æ\81\97®\8b\85\91å\8aw\8fî\95ñ\8dH\8aw\89È \89Í\96ì \90^\8e¡  mime/X0208 support
100 ** \81iE-Mail Address: kono@ie.u-ryukyu.ac.jp\81j
101 ** \98A\97\8d\90æ\81F COW for DOS & Win16 & Win32 & OS/2
102 ** \81iE-Mail Address: GHG00637@niftyserve.or.p\81j
103 **
104 **    \82±\82Ì\83\\81[\83X\82Ì\82¢\82©\82È\82é\95¡\8eÊ\81C\89ü\95Ï\81C\8fC\90³\82à\8b\96\91ø\82µ\82Ü\82·\81B\82½\82¾\82µ\81A
105 **    \82»\82Ì\8dÛ\82É\82Í\81A\92N\82ª\8dv\8c£\82µ\82½\82ð\8e¦\82·\82±\82Ì\95\94\95ª\82ð\8ec\82·\82±\82Æ\81B
106 **    \8dÄ\94z\95z\82â\8eG\8e\8f\82Ì\95t\98^\82È\82Ç\82Ì\96â\82¢\8d\87\82í\82¹\82à\95K\97v\82 \82è\82Ü\82¹\82ñ\81B
107 **    \89c\97\98\97\98\97p\82à\8fã\8bL\82É\94½\82µ\82È\82¢\94Í\88Í\82Å\8b\96\89Â\82µ\82Ü\82·\81B
108 **    \83o\83C\83i\83\8a\82Ì\94z\95z\82Ì\8dÛ\82É\82Íversion message\82ð\95Û\91\82·\82é\82±\82Æ\82ð\8fð\8c\8f\82Æ\82µ\82Ü\82·\81B
109 **    \82±\82Ì\83v\83\8d\83O\83\89\83\80\82É\82Â\82¢\82Ä\82Í\93Á\82É\89½\82Ì\95Û\8fØ\82à\82µ\82È\82¢\81A\88«\82µ\82©\82ç\82¸\81B
110 **
111 **    Everyone is permitted to do anything on this program 
112 **    including copying, modifying, improving,
113 **    as long as you don't try to pretend that you wrote it.
114 **    i.e., the above copyright notice has to appear in all copies.  
115 **    Binary distribution requires original version messages.
116 **    You don't have to ask before copying, redistribution or publishing.
117 **    THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE.
118 ***********************************************************************/
119
120 static const unsigned char *cin = NULL;
121 static int nin = -1;
122 static int ninmax = -1;
123 static int std_getc_mode = 1;
124
125 int 
126 std_getc(f)
127 FILE *f;
128 {
129     if (std_gc_ndx){
130         return std_gc_buf[--std_gc_ndx];
131     } else {
132         if ( std_getc_mode == 1 ) {
133             return getc(f);
134         }
135         if ( std_getc_mode == 2 && cin != NULL ) {
136             if ( ninmax >= 0 ) {
137                 if ( nin >= ninmax ) {
138                     return EOF;
139                 } else {
140                     nin++;
141                     return *cin++;
142                 }
143             } else {
144                 if ( *cin ) {
145                     return *cin++;
146                 } else {
147                     return EOF;
148                 }
149             }
150         }
151     }
152     return EOF;
153 }
154
155 static FILE *fout = stdout;
156 static unsigned char *cout = NULL;
157 static int nout = -1;
158 static int noutmax = -1;
159 static int std_putc_mode = 1;
160
161 void 
162 std_putc(c)
163 int c;
164 {
165     if(c!=EOF)
166     {
167         if ( (std_putc_mode & 1) && fout != NULL ) {
168             putc(c,fout);
169         }
170         if ( (std_putc_mode & 4) && nout != -1 ) {
171             if ( noutmax >= 0 && nout >= noutmax ) std_putc_mode &= ~2;
172             nout++;
173         }
174         if ( (std_putc_mode & 2) && cout != NULL ) {
175             *cout++ = c;
176         }
177     }
178 }
179
180 void
181 print_guessed_code (filename)
182     char *filename;
183 {
184     char *codename = "BINARY";
185     if (!is_inputcode_mixed) {
186         if (strcmp(input_codename, "") == 0) {
187             codename = "ASCII";
188         } else {
189             codename = input_codename;
190         }
191     }
192     if (filename != NULL) {
193         sprintf(guessbuffA,"%s:%s", filename,codename);
194 #ifdef UNICODESUPPORT
195         swprintf(guessbuffW,L"%s:%s",filename,tounicode(codename));
196 #endif /*UNICODESUPPORT*/
197     } else {
198         sprintf(guessbuffA,"%s", codename);
199 #ifdef UNICODESUPPORT
200         swprintf(guessbuffW,L"%s",tounicode(codename));
201 #endif /*UNICODESUPPORT*/
202     }
203 }
204
205 /**
206  ** \83p\83b\83`\90§\8dì\8eÒ
207  **  void@merope.pleiades.or.jp (Kusakabe Youichi)
208  **  NIDE Naoyuki <nide@ics.nara-wu.ac.jp>
209  **  ohta@src.ricoh.co.jp (Junn Ohta)
210  **  inouet@strl.nhk.or.jp (Tomoyuki Inoue)
211  **  kiri@pulser.win.or.jp (Tetsuaki Kiriyama)
212  **  Kimihiko Sato <sato@sail.t.u-tokyo.ac.jp>
213  **  a_kuroe@kuroe.aoba.yokohama.jp (Akihiko Kuroe)
214  **  kono@ie.u-ryukyu.ac.jp (Shinji Kono)
215  **  GHG00637@nifty-serve.or.jp (COW)
216  **
217  **/
218
219 void 
220 reinitdll()
221 {
222     cin = NULL;
223     nin = -1;
224     ninmax = -1;
225     std_getc_mode = 1;
226     fout = stdout;
227     cout = NULL;
228     nout = -1;
229     noutmax = -1;
230     std_putc_mode = 1;
231 }
232
233 #ifndef DLLDBG /* DLLDBG @@*/
234 int WINAPI DllEntryPoint(HINSTANCE hinst,unsigned long reason,void* lpReserved)
235 {
236         return 1;
237 }
238 #endif /* DLLDBG @@*/
239
240 static LPSTR nkfverA = NKF_VERSION;
241 static LPSTR dllverA = DLL_VERSION;
242 #ifdef UNICODESUPPORT
243 static LPWSTR nkfverW = NKF_VERSIONW;
244 static LPWSTR dllverW = DLL_VERSIONW;
245 #endif /*UNICODESUPPORT*/
246
247 BOOL scp(LPSTR s,LPSTR t,DWORD n)
248 {
249     while ( n ) {
250         if ( (*s = *t) == 0 ) return TRUE;
251         if ( --n == 0 ) {
252             *s = 0;
253             break;
254         }
255         s++;
256         t++;
257     }
258     return FALSE;
259 }
260
261 #ifdef UNICODESUPPORT
262 BOOL wscp(LPWSTR s,LPWSTR t,DWORD n)
263 {
264     while ( n ) {
265         if ( (*s = *t) == 0 ) return TRUE;
266         if ( --n == 0 ) {
267             *s = 0;
268             break;
269         }
270         s++;
271         t++;
272     }
273     return FALSE;
274 }
275 #endif /*UNICODESUPPORT*/
276
277 void CALLBACK GetNkfVersion(LPSTR verStr){
278     strcpy(verStr,dllverA);
279 }
280
281 BOOL WINAPI GetNkfVersionSafeA(LPSTR verStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
282 {
283     *lpTCHARsReturned = strlen(dllverA) + 1;
284     if ( verStr == NULL || nBufferLength == 0 ) return FALSE;
285     return scp(verStr,dllverA,nBufferLength);
286 }
287
288 BOOL WINAPI GetNkfVersionSafeW(LPWSTR verStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
289 {
290 #ifdef UNICODESUPPORT
291     *lpTCHARsReturned = wcslen(dllverW) + 1;
292     if ( verStr == NULL || nBufferLength == 0 ) return FALSE;
293     wcsncpy(verStr,dllverW,nBufferLength);
294     if ( wcslen(dllverW) >= nBufferLength )  {
295         *(verStr + nBufferLength - 1) = 0;
296         return FALSE;
297     }
298     return TRUE;
299 #else /*UNICODESUPPORT*/
300     return FALSE;
301 #endif /*UNICODESUPPORT*/
302 }
303
304 int CALLBACK SetNkfOption(LPCSTR optStr)
305 {
306     LPSTR p;
307
308     if ( *optStr == '-' ) {
309         reinit();
310         options(optStr);
311     } else {
312         p = malloc(strlen(optStr) + 2);
313         if ( p == NULL ) return -1;
314         *p = '-';
315         strcpy(p + 1,optStr);
316         reinit();
317         options(p);
318         free(p);
319     }
320     return 0;
321 }
322
323 void CALLBACK NkfConvert(LPSTR outStr, LPCSTR inStr)
324 {
325     std_putc_mode = 2;
326     cout = outStr;
327     noutmax = -1;
328     nout = -1;
329     std_getc_mode = 2;
330     cin = inStr;
331     ninmax = -1;
332     nin = -1;
333     kanji_convert(NULL);
334     *cout = 0;
335 }
336
337 BOOL WINAPI NkfConvertSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/, LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/){
338     if ( inStr == NULL ) return FALSE;
339     std_putc_mode = 6;
340     cout = outStr;
341     noutmax = nOutBufferLength;
342     nout = 0;
343     std_getc_mode = 2;
344     cin = inStr;
345     ninmax = nInBufferLength;
346     nin = 0;
347     kanji_convert(NULL);
348     *lpBytesReturned = nout;
349     if ( nout < noutmax ) *cout = 0;
350     return TRUE;
351 }
352
353 void CALLBACK ToHankaku(LPSTR inStr)
354 {
355     unsigned char *p;
356     int len;
357
358     len = strlen(inStr) + 1;
359     p = malloc(len);
360     if ( p == NULL ) return;
361     memcpy(p,inStr,len);
362     reinit();
363     options("-ZSs");
364     NkfConvert(inStr,p);
365     free(p);
366 }
367
368 BOOL WINAPI ToHankakuSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
369 {
370     reinit();
371     options("-ZSs");
372     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
373 }
374
375 void CALLBACK ToZenkakuKana(LPSTR outStr, LPCSTR inStr)
376 {
377     reinit();
378     options("-Ss");
379     NkfConvert(outStr, inStr);
380 }
381
382 BOOL WINAPI ToZenkakuKanaSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
383 {
384     reinit();
385     options("-Ss");
386     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
387 }
388
389 void CALLBACK EncodeSubject(LPSTR outStr ,LPCSTR inStr){
390     reinit();
391     options("-jM");
392     NkfConvert(outStr, inStr);
393 }
394
395 BOOL WINAPI EncodeSubjectSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
396 {
397     reinit();
398     options("-jM");
399     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
400 }
401
402 #ifdef TOMIME
403 void CALLBACK ToMime(LPSTR outStr ,LPCSTR inStr)
404 {
405     EncodeSubject(outStr,inStr);
406 }
407 #endif /*TOMIME*/
408
409 #ifdef GETKANJICODE
410 int CALLBACK NkfGetKanjiCode(VOID)
411 {
412     int iCode=0;
413     //if(iconv == s_iconv)iCode=0; /* 0:\83V\83t\83gJIS */
414     if(iconv == w_iconv)iCode=3; /* UTF-8 */
415     else if(iconv == w_iconv16){
416         if(utf16_mode == UTF16LE_INPUT)iCode=5; /* 5:UTF-16BE */
417         else iCode=4; /* 4:UTF-16LE */
418     }else if(iconv == e_iconv){
419         if(estab_f == FALSE)iCode=2; /* 2:ISO-2022-JP */
420         else iCode=1; /* 1:EUC */
421     }
422     return iCode;
423 }
424 #endif /*GETKANJICODE*/
425
426 #ifdef FILECONVERT1
427 void CALLBACK NkfFileConvert1(LPCSTR fName)
428 {
429     FILE *fin;
430     char *tempdname;
431     char tempfname[MAX_PATH];
432     char d[4];
433     DWORD len;
434     BOOL sts;
435
436     len = GetTempPath(sizeof d,d);
437     tempdname = malloc(len + 1);
438     if ( tempdname == NULL ) return;
439     len = GetTempPath(len + 1,tempdname);
440     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
441     if ( sts != 0 )  {
442         sts = CopyFileA(fName,tempfname,FALSE);
443          if ( sts ) {
444              if ((fin = fopen(tempfname, "rb")) != NULL) {
445                  if ((fout = fopen(fName, "wb")) != NULL) {
446                      cin = NULL;
447                      nin = -1;
448                      ninmax = -1;
449                      std_getc_mode = 1;
450                      cout = NULL;
451                      nout = -1;
452                      noutmax = -1;
453                      std_putc_mode = 1;
454                      kanji_convert(fin);
455                      fclose(fin);
456                  }
457                  fclose(fout);
458              }
459         DeleteFile(tempfname);
460         }
461     }
462     free(tempdname);
463 }
464 #endif /*FILECONVERT1*/
465
466 BOOL WINAPI NkfFileConvert1SafeA(LPCSTR fName,DWORD nBufferLength /*in TCHARs*/)
467 {
468     FILE *fin;
469     char *tempdname;
470     char tempfname[MAX_PATH];
471     char d[4];
472     DWORD len;
473     BOOL sts;
474     BOOL ret;
475     LPCSTR p;
476
477     ret = FALSE;
478     p = fName;
479     for ( ;; ) {
480         if ( nBufferLength == 0 ) return ret;
481         if ( *p == 0 ) break;
482         p++;
483         --nBufferLength;
484     }
485     if ( chmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
486     len = GetTempPath(sizeof d,d);
487     tempdname = malloc(len + 1);
488     if ( tempdname == NULL ) return FALSE;
489     len = GetTempPath(len + 1,tempdname);
490     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
491     if ( sts != 0 )  {
492         sts = CopyFileA(fName,tempfname,FALSE);
493         if ( sts ) {
494             if ((fin = fopen(tempfname, "rb")) != NULL) {
495                 if ((fout = fopen(fName, "wb")) != NULL) {
496                     cin = NULL;
497                     nin = -1;
498                     ninmax = -1;
499                     std_getc_mode = 1;
500                     cout = NULL;
501                     nout = -1;
502                     noutmax = -1;
503                     std_putc_mode = 1;
504                     kanji_convert(fin);
505                     fclose(fin);
506                     ret = TRUE;
507                 }
508                 fclose(fout);
509             }
510             DeleteFileA(tempfname);
511         }
512     }
513     free(tempdname);
514     return ret;
515 }
516
517 BOOL WINAPI NkfFileConvert1SafeW(LPCWSTR fName,DWORD nBufferLength /*in TCHARs*/)
518 {
519 #ifdef UNICODESUPPORT
520     FILE *fin;
521     wchar_t *tempdname;
522     wchar_t tempfname[MAX_PATH];
523     wchar_t d[2];
524     DWORD len;
525     BOOL sts;
526     BOOL ret;
527     LPCWSTR p;
528
529     ret = FALSE;
530     p = fName;
531     for ( ;; ) {
532         if ( nBufferLength == 0 ) return ret;
533         if ( *p == 0 ) break;
534         p++;
535         --nBufferLength;
536     }
537     if ( _wchmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
538     len = GetTempPathW(sizeof d / sizeof(WCHAR),d);
539     tempdname = malloc((len + 1) * sizeof(WCHAR));
540     if ( tempdname == NULL ) return FALSE;
541     len = GetTempPathW(len + 1,tempdname);
542     sts = GetTempFileNameW(tempdname,L"NKF",0,tempfname);
543     if ( sts != 0 )  {
544         sts = CopyFileW(fName,tempfname,FALSE);
545         if ( sts ) {
546             if ((fin = _wfopen(tempfname,L"rb")) != NULL) {
547                 if ((fout = _wfopen(fName,L"wb")) != NULL) {
548                     cin = NULL;
549                     nin = -1;
550                     ninmax = -1;
551                     std_getc_mode = 1;
552                     cout = NULL;
553                     nout = -1;
554                     noutmax = -1;
555                     std_putc_mode = 1;
556                     kanji_convert(fin);
557                     fclose(fin);
558                     ret = TRUE;
559                 }
560                 fclose(fout);
561             }
562             DeleteFileW(tempfname);
563         }
564     }
565     free(tempdname);
566     return ret;
567 #else /*UNICODESUPPORT*/
568     return FALSE;
569 #endif /*UNICODESUPPORT*/
570 }
571
572 #ifdef FILECONVERT2
573 void CALLBACK NkfFileConvert2(LPCSTR fInName,LPCSTR fOutName)
574 {
575     FILE *fin;
576
577     if ((fin = fopen(fInName, "rb")) == NULL) return;
578     if((fout=fopen(fOutName, "wb")) == NULL) {
579         fclose(fin);
580         return;
581     }
582     cin = NULL;
583     nin = -1;
584     ninmax = -1;
585     std_getc_mode = 1;
586     cout = NULL;
587     nout = -1;
588     noutmax = -1;
589     std_putc_mode = 1;
590     kanji_convert(fin);
591     fclose(fin);
592     fclose(fout);
593 }
594 #endif /*FILECONVERT2*/
595
596 BOOL WINAPI NkfFileConvert2SafeA(LPCSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
597 {
598     FILE *fin;
599     BOOL sts;
600     BOOL ret;
601     LPCSTR p;
602
603     ret = FALSE;
604     p = fInName;
605     for ( ;; ) {
606         if ( fInBufferLength == 0 ) return ret;
607         if ( *p == 0 ) break;
608         p++;
609         --fInBufferLength;
610     }
611     p = fOutName;
612     for ( ;; ) {
613         if ( fOutBufferLength == 0 ) return ret;
614         if ( *p == 0 ) break;
615         p++;
616         --fOutBufferLength;
617     }
618     if ((fin = fopen(fInName, "rb")) != NULL) {
619         if((fout=fopen(fOutName, "wb")) != NULL) {
620             cin = NULL;
621             nin = -1;
622             ninmax = -1;
623             std_getc_mode = 1;
624             cout = NULL;
625             nout = -1;
626             noutmax = -1;
627             std_putc_mode = 1;
628             kanji_convert(fin);
629             fclose(fin);
630             ret = TRUE;
631         }
632         fclose(fout);
633     }
634     return ret;
635 }
636
637 BOOL WINAPI NkfFileConvert2SafeW(LPCWSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCWSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
638 {
639 #ifdef UNICODESUPPORT
640     FILE *fin;
641     BOOL sts;
642     BOOL ret;
643     LPCWSTR p;
644
645     ret = FALSE;
646     p = fInName;
647     for ( ;; ) {
648         if ( fInBufferLength == 0 ) return ret;
649         if ( *p == 0 ) break;
650         p++;
651         --fInBufferLength;
652     }
653     p = fOutName;
654     for ( ;; ) {
655         if ( fOutBufferLength == 0 ) return ret;
656         if ( *p == 0 ) break;
657         p++;
658         --fOutBufferLength;
659     }
660     if ( (fin = _wfopen(fInName,L"rb")) != NULL) {
661         if( (fout = _wfopen(fOutName,L"wb")) != NULL) {
662             cin = NULL;
663             nin = -1;
664             ninmax = -1;
665             std_getc_mode = 1;
666             cout = NULL;
667             nout = -1;
668             noutmax = -1;
669             std_putc_mode = 1;
670             kanji_convert(fin);
671             fclose(fin);
672             ret = TRUE;
673         }
674         fclose(fout);
675     }
676     return ret;
677 #else /*UNICODESUPPORT*/
678     return FALSE;
679 #endif /*UNICODESUPPORT*/
680 }
681
682 BOOL WINAPI GetNkfGuessA(LPSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
683 {
684     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
685     print_guessed_code(NULL);
686     *lpTCHARsReturned = strlen(guessbuffA) + 1;
687     return scp(outStr,guessbuffA,nBufferLength);
688 }
689
690 BOOL WINAPI GetNkfGuessW(LPWSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
691 {
692 #ifdef UNICODESUPPORT
693     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
694     print_guessed_code(NULL);
695     *lpTCHARsReturned = wcslen(guessbuffW) + 1;
696     return wscp(outStr,guessbuffW,nBufferLength);
697 #else /*UNICODESUPPORT*/
698     return FALSE;
699 #endif /*UNICODESUPPORT*/
700 }
701
702 static struct NKFSUPPORTFUNCTIONS NkfSupportFunctions = {
703 sizeof(struct NKFSUPPORTFUNCTIONS),
704 NULL,
705 NKF_VERSION,
706 NKF_RELEASE_DATE,
707 1 /* nkf32103a.lzh uminchu 1.03 */
708 /* | 2 */ /* nkf32dll.zip 0.91 */
709 #if defined(TOMIME) && defined(GETKANJICODE) && defined(FILECONVERT1) && defined(FILECONVERT2) 
710 | 4 /* nkf32204.zip Kaneto 2.0.4.0 */
711 #endif
712 | 8 /* this */
713 #ifdef UNICODESUPPORT
714 | 0x80000000
715 #endif /*UNICODESUPPORT*/
716 ,
717 };
718
719 BOOL WINAPI GetNkfSupportFunctions(void *outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
720 {
721     *lpBytesReturned = sizeof NkfSupportFunctions;
722     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
723     NkfSupportFunctions.copyrightA = CopyRight;
724     memcpy(outStr,&NkfSupportFunctions,sizeof NkfSupportFunctions > nBufferLength ? nBufferLength : sizeof NkfSupportFunctions);
725     return TRUE;
726 }
727
728 BOOL WINAPI NkfUsage(LPSTR outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
729 {
730     ubuff = outStr;
731     ulen = nBufferLength;
732     uret = TRUE;
733     usage();
734     if ( uret == TRUE ) {
735         *lpBytesReturned = nBufferLength - ulen;
736     }
737     return uret;
738 }
739
740 /* nkf32.dll main end */
741
742 #ifdef DLLDBG /* DLLDBG @@*/
743 /* dbg.exe */
744 unsigned char buff[65536];
745 unsigned char buff2[65536];
746 unsigned char buff3[65536];
747 unsigned char buff4[65536];
748 char *code[] = {"\83V\83t\83gJIS","EUC","ISO-2022-JP","UTF-8","UTF-16LE","UTF-16BE"};
749
750     int n;
751     BOOL sts;
752     DWORD len;
753
754 void mimeencode(unsigned char *buff2)
755 {
756     memset(buff,0,sizeof buff);
757     EncodeSubject(buff,buff2);
758     printf("EncodeSubject(%s)=%s\n",buff2,buff);
759         memset(buff,0,sizeof buff);
760         ToMime(buff,buff2);
761         printf("ToMime(%s)=%s\n",buff2,buff);
762         memset(buff,0,sizeof buff);
763         sts = EncodeSubjectSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
764         printf("EncodeSubjectSafe(%s)=%d len=%d '%s'\n",buff,sts,len,buff);
765         dumpn(buff2,strlen(buff2));
766         dumpn(buff,len);
767 }
768
769 void convert(char *arg,unsigned char *buff2)
770 {
771     sts = SetNkfOption(arg);
772     printf("SetNkfOption(%s)=%d\n",arg,sts);
773     memset(buff,0,sizeof buff);
774     NkfConvert(buff,buff2);
775     printf("NkfConvert(%s)=%s\n",buff2,buff);
776     n = NkfGetKanjiCode();
777     printf("NkfGetKanjiCode()=%d\n",n);
778         sts = SetNkfOption(arg);
779         printf("SetNkfOption(%s)=%d\n",arg,sts);
780         memset(buff,0,sizeof buff);
781         sts = NkfConvertSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
782         printf("NkfConvertSafe(%s)=%d len=%d '%s'\n",buff2,sts,len,buff);
783         dumpn(buff2,strlen(buff2));
784         dumpn(buff,len);
785         n = NkfGetKanjiCode();
786         printf("NkfGetKanjiCode()=%d\n",n);
787 }
788
789 void guess(unsigned char *buff2)
790 {
791     char *g = "--guess";
792
793         sts = SetNkfOption(g);
794         printf("SetNkfOption(%s)=%d\n",g,sts);
795         memset(buff,0,sizeof buff);
796         NkfConvert(buff,buff2);
797         printf("NkfConvert(%s)=%s\n",buff2,buff);
798         dumpn(buff2,strlen(buff2));
799         n = NkfGetKanjiCode();
800         printf("NkfGetKanjiCode()=%d %s\n",n,code[n]);
801         memset(buff,0,sizeof buff);
802         sts = GetNkfGuessA(buff,sizeof buff,&len);
803         printf("GetNkfGuessA()=%d len=%d '%s'\n",sts,len,buff);
804         dumpn(buff,len);
805         memset(buff,0,sizeof buff);
806         sts = GetNkfGuessW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
807         printf("GetNkfGuessW()=%d len=%d\n",sts,len);
808         dumpn(buff,len * sizeof(WCHAR));
809 }
810
811 void dumpf(char *f)
812 {
813     FILE *fp;
814     unsigned int n;
815
816     fp = fopen(f,"rb");
817     if ( fp == NULL ) return;
818     n = fread(buff,1,sizeof buff,fp);
819     fclose(fp);
820     printf("dumpf(%s,%d)\n",f,n);
821     dumpn(buff,n);
822 }
823
824 void mkfile(char *f,char *p)
825 {
826     FILE *fp;
827
828     fp = fopen(f,"w");
829     if ( fp == NULL ) return;
830     fputs(p,fp);
831     fclose(fp);
832     dumpf(f);
833 }
834
835 void file(char *arg2,char *arg3,unsigned char *buf)
836 {
837             sts = SetNkfOption(arg2);
838             printf("SetNkfOption(%s)=%d\n",arg2,sts);
839             mkfile(arg3,buf);
840             NkfFileConvert1(arg3);
841             printf("NkfFileConvert1(%s)\n",arg3);
842             dumpf(arg3);
843             sts = SetNkfOption(arg2);
844             printf("SetNkfOption(%s)=%d\n",arg2,sts);
845             mkfile(arg3,buf);
846             sts = NkfFileConvert1SafeA(arg3,strlen(arg3) + 1);
847             printf("NkfFileConvert1SafeA(%s)=%d\n",arg3,sts);
848             dumpf(arg3);
849             sts = SetNkfOption(arg2);
850             printf("SetNkfOption(%s)=%d\n",arg2,sts);
851             mkfile(arg3,buf);
852             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
853             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
854             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
855             sts = NkfFileConvert1SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) /*wcslen((wchar_t *)buff) + 1*/);
856             printf("NkfFileConvert1SafeW()=%d\n",sts);
857             dumpf(arg3);
858 }
859
860 void file2(char *arg2,char *arg3,char *arg4,unsigned char *buf)
861 {
862             sts = SetNkfOption(arg2);
863             printf("SetNkfOption(%s)=%d\n",arg2,sts);
864             mkfile(arg3,buf);
865             NkfFileConvert2(arg3,arg4);
866             printf("NkfFileConvert1(%s,%s)\n",arg3,arg4);
867             dumpf(arg3);
868             dumpf(arg4);
869             sts = SetNkfOption(arg2);
870             printf("SetNkfOption(%s)=%d\n",arg2,sts);
871             mkfile(arg3,buf);
872             sts = NkfFileConvert2SafeA(arg3,strlen(arg3) + 1,arg4,strlen(arg4) + 1);
873             printf("NkfFileConvert2SafeA(%s,%s)=%d\n",arg3,arg4,sts);
874             dumpf(arg3);
875             dumpf(arg4);
876             sts = SetNkfOption(arg2);
877             printf("SetNkfOption(%s)=%d\n",arg2,sts);
878             mkfile(arg3,buf);
879             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
880             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
881             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
882             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg4,-1,(wchar_t *)buff4,sizeof(buff4) / sizeof(wchar_t));
883             printf("MultiByteToWideChar(%s)=%d\n",arg4,sts);
884             dumpn(buff4,(wcslen((wchar_t *)buff4) + 1) * sizeof(wchar_t));
885             sts = NkfFileConvert2SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) ,(wchar_t *)buff4,sizeof buff4 / sizeof(wchar_t));
886             printf("NkfFileConvert2SafeW()=%d\n",sts);
887             dumpf(arg3);
888             dumpf(arg4);
889 }
890
891 int main(int argc,char **argv)
892 {
893     struct NKFSUPPORTFUNCTIONS fnc;
894
895     if ( argc < 2 ) return 0;
896     switch ( *argv[1] ) {
897       case 'v':
898         memset(buff,0,sizeof buff);
899         GetNkfVersion(buff);
900         printf("GetNkfVersion() '%s'\n",buff);
901             sts = GetNkfVersionSafeA(buff,sizeof buff,&len);
902             printf("GetNkfVersionSafeA()=%d len=%d '%s'\n",sts,len,buff);
903             sts = GetNkfVersionSafeW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
904             printf("GetNkfVersionSafeW()=%d len=%d\n",sts,len);
905             dumpn(buff,len * sizeof(WCHAR));
906             sts = GetNkfSupportFunctions(&fnc,sizeof fnc,&len);
907             printf("GetNkfSupportFunctions()=%d len=%d\n",sts,len);
908             printf("size=%d\n",fnc.size);
909             printf("copyrightA='%s'\n",fnc.copyrightA);
910             printf("versionA='%s'\n",fnc.versionA);
911             printf("dateA='%s'\n",fnc.dateA);
912             printf("functions=%d %x\n",fnc.functions,fnc.functions);
913         break;
914       case 'm':
915         if ( argc < 3 ) return 0;
916         mimeencode(argv[2]);
917         break;
918       case 'M':
919         if ( argc < 2 ) return 0;
920         gets(buff2);
921         mimeencode(buff2);
922         break;
923       case 'c':
924         if ( argc < 4 ) return 0;
925         convert(argv[2],argv[3]);
926         break;
927       case 'C':
928         if ( argc < 3 ) return 0;
929         gets(buff2);
930         convert(argv[2],buff2);
931         break;
932       case 'g':
933         if ( argc < 3 ) return 0;
934         guess(argv[2]);
935         break;
936       case 'G':
937         if ( argc < 2 ) return 0;
938         gets(buff2);
939         guess(buff2);
940         break;
941       case 'f':
942         if ( argc < 5 ) return 0;
943         file(argv[2],argv[3],argv[4]);
944         break;
945       case 'F':
946         if ( argc < 4 ) return 0;
947         gets(buff3);
948         file(argv[2],argv[3],buff3);
949         break;
950       case '2':
951         if ( argc < 6 ) return 0;
952         file2(argv[2],argv[3],argv[4],argv[5]);
953         break;
954       case '#':
955         if ( argc < 5 ) return 0;
956         gets(buff3);
957         file2(argv[2],argv[3],argv[4],buff3);
958         break;
959       case 'u':
960         sts = NkfUsage(buff,sizeof buff * 0 + 2073,&len);
961         printf("strlen(buff)=%d\n",strlen(buff));
962         printf("NkfUsage()=%d len=%d \n%s",sts,len,buff);
963         break;
964     }
965     return 0;
966 }
967 /* dbg.exe end */
968 #endif /* DLLDBG @@*/
969 /*WIN32DLL*/