OSDN Git Service

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