1 /* nkf32.dll nfk32dll.c */
2 /* e-mail:tkaneto@nifty.com */
3 /* URL: http://www1.ttcn.ne.jp/~kaneto */
4 
5 /*WIN32DLL*/
6 /* ������̃o�[�W�������X�V���Ă��������B */
7 #define NKF_VERSIONW L"2.1.4"
8 /* NKF_VERSION �̃��C�h���� */
9 #define DLL_VERSION   "2.1.4.0 2"
10 /* DLL���Ԃ� */
11 #define DLL_VERSIONW L"2.1.4.0 2"
12 /* DLL���Ԃ� DLL_VERSION �̃��C�h���� */
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 
dumpn(unsigned char * buff,unsigned n)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 
tounicode(const char * p)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 
dllprintf(FILE * fp,char * fmt,...)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 ** �A����F �i���j�x�m�ʌ������@�\�t�g�R���@�s��@��
97 ** �iE-Mail Address: ichikawa@flab.fujitsu.co.jp�j
98 ** Copyright (C) 1996,1998
99 ** Copyright (C) 2002
100 ** �A����F ������w���H�w�� �͖� �^��  mime/X0208 support
101 ** �iE-Mail Address: kono@ie.u-ryukyu.ac.jp�j
102 ** �A����F COW for DOS & Win16 & Win32 & OS/2
103 ** �iE-Mail Address: GHG00637@niftyserve.or.p�j
104 **
105 **    ���̃\�[�X�̂����Ȃ镡�ʁC���ρC�C�����������܂��B�������A
106 **    ���̍ۂɂ́A�N���v���������������̕������c�����ƁB
107 **    �Ĕz�z��G���̕t�^�Ȃǂ̖₢���킹���K�v����܂���B
108 **    �c�����p����L�ɔ����Ȃ��͈͂ŋ��‚��܂��B
109 **    �o�C�i���̔z�z�̍ۂɂ�version message��ۑ����邱�Ƃ������Ƃ��܂��B
110 **    ���̃v���O�����ɂ‚��Ă͓��ɉ��̕ۏ؂����Ȃ��A�������炸�B
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
std_getc(f)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
std_putc(c)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
print_guessed_code(filename)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
print_guessed_codeW(filename)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  ** �p�b�`�����
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
reinitdll(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 @@*/
DllEntryPoint(HINSTANCE hinst,unsigned long reason,void * lpReserved)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 
scp(LPSTR s,LPSTR t,DWORD n)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
wscp(LPWSTR s,LPWSTR t,DWORD n)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 
GetNkfVersion(LPSTR verStr)296 void CALLBACK GetNkfVersion(LPSTR verStr){
297     strcpy(verStr,dllverA);
298 }
299 
GetNkfVersionSafeA(LPSTR verStr,DWORD nBufferLength,LPDWORD lpTCHARsReturned)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 
GetNkfVersionSafeW(LPWSTR verStr,DWORD nBufferLength,LPDWORD lpTCHARsReturned)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 
SetNkfOption(LPSTR optStr)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 
findspace(const char * str)344 int findspace(const char* str)
345 {
346 	int find_n = 0;
347 	while (*str != 0) {
348 		if (*str == ' ') {
349 			find_n++;
350 		}
351 		str++;
352 	}
353 	return find_n;
354 }
355 // �I�v�V������ ���ŋ�؂��Ă���ꍇ�� options �����Ăяo��
callOptions()356 void callOptions()
357 {
358 	char *work = strdup(optStr0);
359 	int len = strlen(optStr0);
360 	for (int i = 0; i < len; i++) {
361 		if (work[i] == ' ') {
362 			work[i] = '\0';
363 		}
364 	}
365 	int i = 0;
366 	while (i < len)
367 	{
368 		// ������T��
369 		if (work[i] != '\0') {
370 			// options �Ăяo��
371 			options(&work[i]);
372 
373 			// �����̏I�[��T��
374 			while (work[i] != '\0' && i < len) {
375 				i++;
376 			}
377 		}
378 		else {
379 			i++;
380 		}
381 	}
382 	free(work);
383 }
384 
options0(void)385 void options0(void)
386 {
387     reinit();
388     if ( optStr0 != NULL ) {
389 		// option �̒��� �����������ꍇ options �������ČĂяo��
390 		if (findspace(optStr0) > 0) {
391 			callOptions();
392 		}
393 		else {
394 			options(optStr0);
395 		}
396     }
397 }
398 
NkfConvert(LPSTR outStr,LPCSTR inStr)399 void CALLBACK NkfConvert(LPSTR outStr, LPCSTR inStr)
400 {
401     options0();
402     std_putc_mode = 2;
403     cout = outStr;
404     noutmax = -1;
405     nout = -1;
406     std_getc_mode = 2;
407     cin = inStr;
408     ninmax = -1;
409     nin = -1;
410     kanji_convert(NULL);
411     *cout = 0;
412 }
413 
NkfConvertSafe(LPSTR outStr,DWORD nOutBufferLength,LPDWORD lpBytesReturned,LPCSTR inStr,DWORD nInBufferLength)414 BOOL WINAPI NkfConvertSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/, LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/){
415     if ( inStr == NULL ) return FALSE;
416     options0();
417     std_putc_mode = 6;
418     cout = outStr;
419     noutmax = nOutBufferLength;
420     nout = 0;
421     std_getc_mode = 2;
422     cin = inStr;
423     ninmax = nInBufferLength;
424     nin = 0;
425     kanji_convert(NULL);
426     *lpBytesReturned = nout;
427     if ( nout < noutmax ) *cout = 0;
428     return TRUE;
429 }
430 
ToHankaku(LPSTR inStr)431 void CALLBACK ToHankaku(LPSTR inStr)
432 {
433     unsigned char *p;
434     int len;
435 
436     len = strlen(inStr) + 1;
437     p = malloc(len);
438     if ( p == NULL ) return;
439     memcpy(p,inStr,len);
440     options("-ZSs");
441     NkfConvert(inStr,p);
442     free(p);
443 }
444 
ToHankakuSafe(LPSTR outStr,DWORD nOutBufferLength,LPDWORD lpBytesReturned,LPCSTR inStr,DWORD nInBufferLength)445 BOOL WINAPI ToHankakuSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
446 {
447     options("-ZSs");
448     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
449 }
450 
ToZenkakuKana(LPSTR outStr,LPCSTR inStr)451 void CALLBACK ToZenkakuKana(LPSTR outStr, LPCSTR inStr)
452 {
453     options("-Ss");
454     NkfConvert(outStr, inStr);
455 }
456 
ToZenkakuKanaSafe(LPSTR outStr,DWORD nOutBufferLength,LPDWORD lpBytesReturned,LPCSTR inStr,DWORD nInBufferLength)457 BOOL WINAPI ToZenkakuKanaSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
458 {
459     options("-Ss");
460     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
461 }
462 
EncodeSubject(LPSTR outStr,LPCSTR inStr)463 void CALLBACK EncodeSubject(LPSTR outStr ,LPCSTR inStr){
464     options("-jM");
465     NkfConvert(outStr, inStr);
466 }
467 
EncodeSubjectSafe(LPSTR outStr,DWORD nOutBufferLength,LPDWORD lpBytesReturned,LPCSTR inStr,DWORD nInBufferLength)468 BOOL WINAPI EncodeSubjectSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
469 {
470     options("-jM");
471     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
472 }
473 
474 #ifdef TOMIME
ToMime(LPSTR outStr,LPCSTR inStr)475 void CALLBACK ToMime(LPSTR outStr ,LPCSTR inStr)
476 {
477     EncodeSubject(outStr,inStr);
478 }
479 #endif /*TOMIME*/
480 
481 #ifdef GETKANJICODE
NkfGetKanjiCode(VOID)482 int CALLBACK NkfGetKanjiCode(VOID)
483 {
484     int iCode=0;
485     /* if(iconv == s_iconv)iCode=0; */ /* 0:�V�t�gJIS */
486     if(iconv == w_iconv)iCode=3; /* UTF-8 */
487     else if(iconv == w_iconv16){
488         if(input_endian == ENDIAN_BIG)iCode=5; /* 5:UTF-16BE */
489         else iCode=4; /* 4:UTF-16LE */
490     }else if(iconv == e_iconv){
491         if(estab_f == FALSE)iCode=2; /* 2:ISO-2022-JP */
492         else iCode=1; /* 1:EUC */
493     }
494     return iCode;
495 }
496 #endif /*GETKANJICODE*/
497 
498 #ifdef FILECONVERT1
NkfFileConvert1(LPCSTR fName)499 void CALLBACK NkfFileConvert1(LPCSTR fName)
500 {
501     FILE *fin;
502     char *tempdname;
503     char tempfname[MAX_PATH];
504     char d[4];
505     DWORD len;
506     BOOL sts;
507 
508     options0();
509     len = GetTempPath(sizeof d,d);
510     tempdname = malloc(len + 1);
511     if ( tempdname == NULL ) return;
512     len = GetTempPath(len + 1,tempdname);
513     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
514     if ( sts != 0 )  {
515         sts = CopyFileA(fName,tempfname,FALSE);
516          if ( sts ) {
517              if ((fin = fopen(tempfname, "rb")) != NULL) {
518                  if ((fout = fopen(fName, "wb")) != NULL) {
519                      cin = NULL;
520                      nin = -1;
521                      ninmax = -1;
522                      std_getc_mode = 1;
523                      cout = NULL;
524                      nout = -1;
525                      noutmax = -1;
526                      std_putc_mode = 1;
527                      kanji_convert(fin);
528                      fclose(fin);
529                  }
530                  fclose(fout);
531              }
532         DeleteFile(tempfname);
533         }
534     }
535     free(tempdname);
536 }
537 #endif /*FILECONVERT1*/
538 
NkfFileConvert1SafeA(LPCSTR fName,DWORD nBufferLength)539 BOOL WINAPI NkfFileConvert1SafeA(LPCSTR fName,DWORD nBufferLength /*in TCHARs*/)
540 {
541     FILE *fin;
542     char *tempdname;
543     char tempfname[MAX_PATH];
544     char d[4];
545     DWORD len;
546     BOOL sts;
547     BOOL ret;
548     LPCSTR p;
549 
550     options0();
551     ret = FALSE;
552     p = fName;
553     for ( ;; ) {
554         if ( nBufferLength == 0 ) return ret;
555         if ( *p == 0 ) break;
556         p++;
557         --nBufferLength;
558     }
559     if ( chmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
560     len = GetTempPath(sizeof d,d);
561     tempdname = malloc(len + 1);
562     if ( tempdname == NULL ) return FALSE;
563     len = GetTempPath(len + 1,tempdname);
564     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
565     if ( sts != 0 )  {
566         sts = CopyFileA(fName,tempfname,FALSE);
567         if ( sts ) {
568             if ((fin = fopen(tempfname, "rb")) != NULL) {
569                 if ((fout = fopen(fName, "wb")) != NULL) {
570                     cin = NULL;
571                     nin = -1;
572                     ninmax = -1;
573                     std_getc_mode = 1;
574                     cout = NULL;
575                     nout = -1;
576                     noutmax = -1;
577                     std_putc_mode = 1;
578                     kanji_convert(fin);
579                     fclose(fin);
580                     ret = TRUE;
581                 }
582                 fclose(fout);
583             }
584             DeleteFileA(tempfname);
585         }
586     }
587     free(tempdname);
588     return ret;
589 }
590 
NkfFileConvert1SafeW(LPCWSTR fName,DWORD nBufferLength)591 BOOL WINAPI NkfFileConvert1SafeW(LPCWSTR fName,DWORD nBufferLength /*in TCHARs*/)
592 {
593 #ifdef UNICODESUPPORT
594     FILE *fin;
595     wchar_t *tempdname;
596     wchar_t tempfname[MAX_PATH];
597     wchar_t d[2];
598     DWORD len;
599     BOOL sts;
600     BOOL ret;
601     LPCWSTR p;
602 
603     options0();
604     ret = FALSE;
605     p = fName;
606     for ( ;; ) {
607         if ( nBufferLength == 0 ) return ret;
608         if ( *p == 0 ) break;
609         p++;
610         --nBufferLength;
611     }
612     if ( _wchmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
613     len = GetTempPathW(sizeof d / sizeof(WCHAR),d);
614     tempdname = malloc((len + 1) * sizeof(WCHAR));
615     if ( tempdname == NULL ) return FALSE;
616     len = GetTempPathW(len + 1,tempdname);
617     sts = GetTempFileNameW(tempdname,L"NKF",0,tempfname);
618     if ( sts != 0 )  {
619         sts = CopyFileW(fName,tempfname,FALSE);
620         if ( sts ) {
621             if ((fin = _wfopen(tempfname,L"rb")) != NULL) {
622                 if ((fout = _wfopen(fName,L"wb")) != NULL) {
623                     cin = NULL;
624                     nin = -1;
625                     ninmax = -1;
626                     std_getc_mode = 1;
627                     cout = NULL;
628                     nout = -1;
629                     noutmax = -1;
630                     std_putc_mode = 1;
631                     kanji_convert(fin);
632                     fclose(fin);
633                     ret = TRUE;
634                 }
635                 fclose(fout);
636             }
637             DeleteFileW(tempfname);
638         }
639     }
640     free(tempdname);
641     return ret;
642 #else /*UNICODESUPPORT*/
643     return FALSE;
644 #endif /*UNICODESUPPORT*/
645 }
646 
647 #ifdef FILECONVERT2
NkfFileConvert2(LPCSTR fInName,LPCSTR fOutName)648 void CALLBACK NkfFileConvert2(LPCSTR fInName,LPCSTR fOutName)
649 {
650     FILE *fin;
651 
652     options0();
653     if ((fin = fopen(fInName, "rb")) == NULL) return;
654     if((fout=fopen(fOutName, "wb")) == NULL) {
655         fclose(fin);
656         return;
657     }
658     cin = NULL;
659     nin = -1;
660     ninmax = -1;
661     std_getc_mode = 1;
662     cout = NULL;
663     nout = -1;
664     noutmax = -1;
665     std_putc_mode = 1;
666     kanji_convert(fin);
667     fclose(fin);
668     fclose(fout);
669 }
670 #endif /*FILECONVERT2*/
671 
NkfFileConvert2SafeA(LPCSTR fInName,DWORD fInBufferLength,LPCSTR fOutName,DWORD fOutBufferLength)672 BOOL WINAPI NkfFileConvert2SafeA(LPCSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
673 {
674     FILE *fin;
675     BOOL sts;
676     BOOL ret;
677     LPCSTR p;
678 
679     options0();
680     ret = FALSE;
681     p = fInName;
682     for ( ;; ) {
683         if ( fInBufferLength == 0 ) return ret;
684         if ( *p == 0 ) break;
685         p++;
686         --fInBufferLength;
687     }
688     p = fOutName;
689     for ( ;; ) {
690         if ( fOutBufferLength == 0 ) return ret;
691         if ( *p == 0 ) break;
692         p++;
693         --fOutBufferLength;
694     }
695     if ((fin = fopen(fInName, "rb")) != NULL) {
696         if((fout=fopen(fOutName, "wb")) != NULL) {
697             cin = NULL;
698             nin = -1;
699             ninmax = -1;
700             std_getc_mode = 1;
701             cout = NULL;
702             nout = -1;
703             noutmax = -1;
704             std_putc_mode = 1;
705             kanji_convert(fin);
706             fclose(fin);
707             ret = TRUE;
708         }
709         fclose(fout);
710     }
711     return ret;
712 }
713 
NkfFileConvert2SafeW(LPCWSTR fInName,DWORD fInBufferLength,LPCWSTR fOutName,DWORD fOutBufferLength)714 BOOL WINAPI NkfFileConvert2SafeW(LPCWSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCWSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
715 {
716 #ifdef UNICODESUPPORT
717     FILE *fin;
718     BOOL sts;
719     BOOL ret;
720     LPCWSTR p;
721 
722     options0();
723     ret = FALSE;
724     p = fInName;
725     for ( ;; ) {
726         if ( fInBufferLength == 0 ) return ret;
727         if ( *p == 0 ) break;
728         p++;
729         --fInBufferLength;
730     }
731     p = fOutName;
732     for ( ;; ) {
733         if ( fOutBufferLength == 0 ) return ret;
734         if ( *p == 0 ) break;
735         p++;
736         --fOutBufferLength;
737     }
738     if ( (fin = _wfopen(fInName,L"rb")) != NULL) {
739         if( (fout = _wfopen(fOutName,L"wb")) != NULL) {
740             cin = NULL;
741             nin = -1;
742             ninmax = -1;
743             std_getc_mode = 1;
744             cout = NULL;
745             nout = -1;
746             noutmax = -1;
747             std_putc_mode = 1;
748             kanji_convert(fin);
749             fclose(fin);
750             ret = TRUE;
751         }
752         fclose(fout);
753     }
754     return ret;
755 #else /*UNICODESUPPORT*/
756     return FALSE;
757 #endif /*UNICODESUPPORT*/
758 }
759 
GetNkfGuessA(LPSTR outStr,DWORD nBufferLength,LPDWORD lpTCHARsReturned)760 BOOL WINAPI GetNkfGuessA(LPSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
761 {
762     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
763     print_guessed_code(NULL);
764     *lpTCHARsReturned = strlen(guessbuffA) + 1;
765     return scp(outStr,guessbuffA,nBufferLength);
766 }
767 
GetNkfGuessW(LPWSTR outStr,DWORD nBufferLength,LPDWORD lpTCHARsReturned)768 BOOL WINAPI GetNkfGuessW(LPWSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
769 {
770 #ifdef UNICODESUPPORT
771     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
772     print_guessed_codeW(NULL);
773     *lpTCHARsReturned = wcslen(guessbuffW) + 1;
774     return wscp(outStr,guessbuffW,nBufferLength);
775 #else /*UNICODESUPPORT*/
776     return FALSE;
777 #endif /*UNICODESUPPORT*/
778 }
779 
780 static struct {
781 DWORD size;
782 LPCSTR copyrightA;
783 LPCSTR versionA;
784 LPCSTR dateA;
785 DWORD functions;
786 } NkfSupportFunctions = {
787 sizeof(NkfSupportFunctions),
788 NULL,
789 NKF_VERSION,
790 NKF_RELEASE_DATE,
791 1 /* nkf32103a.lzh uminchu 1.03 */
792 /* | 2 */ /* nkf32dll.zip 0.91 */
793 #if defined(TOMIME) && defined(GETKANJICODE) && defined(FILECONVERT1) && defined(FILECONVERT2)
794 | 4 /* nkf32204.zip Kaneto 2.0.4.0 */
795 #endif
796 | 8 /* this */
797 #ifdef UNICODESUPPORT
798 | 0x80000000
799 #endif /*UNICODESUPPORT*/
800 ,
801 };
802 
GetNkfSupportFunctions(void * outStr,DWORD nBufferLength,LPDWORD lpBytesReturned)803 BOOL WINAPI GetNkfSupportFunctions(void *outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
804 {
805     *lpBytesReturned = sizeof NkfSupportFunctions;
806     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
807     NkfSupportFunctions.copyrightA = COPY_RIGHT;
808     memcpy(outStr,&NkfSupportFunctions,sizeof NkfSupportFunctions > nBufferLength ? nBufferLength : sizeof NkfSupportFunctions);
809     return TRUE;
810 }
811 
NkfUsage(LPSTR outStr,DWORD nBufferLength,LPDWORD lpBytesReturned)812 BOOL WINAPI NkfUsage(LPSTR outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
813 {
814     ubuff = outStr;
815     ulen = nBufferLength;
816     uret = TRUE;
817     usage();
818     if ( uret == TRUE ) {
819         *lpBytesReturned = nBufferLength - ulen;
820     }
821     return uret;
822 }
823 
824 /* nkf32.dll main end */
825 
826 #ifdef DLLDBG /* DLLDBG @@*/
827 /* dbg.exe */
828 unsigned char buff[65536];
829 unsigned char buff2[65536];
830 unsigned char buff3[65536];
831 unsigned char buff4[65536];
832 char *code[] = {"�V�t�gJIS","EUC","ISO-2022-JP","UTF-8","UTF-16LE","UTF-16BE"};
833 
834     int n;
835     BOOL sts;
836     DWORD len;
837 
mimeencode(unsigned char * buff2)838 void mimeencode(unsigned char *buff2)
839 {
840     memset(buff,0,sizeof buff);
841     EncodeSubject(buff,buff2);
842     printf("EncodeSubject(%s)=%s\n",buff2,buff);
843         memset(buff,0,sizeof buff);
844         ToMime(buff,buff2);
845         printf("ToMime(%s)=%s\n",buff2,buff);
846         memset(buff,0,sizeof buff);
847         sts = EncodeSubjectSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
848         printf("EncodeSubjectSafe(%s)=%d len=%d '%s'\n",buff,sts,len,buff);
849         dumpn(buff2,strlen(buff2));
850         dumpn(buff,len);
851 }
852 
convert(char * arg,unsigned char * buff2)853 void convert(char *arg,unsigned char *buff2)
854 {
855     sts = SetNkfOption(arg);
856     printf("SetNkfOption(%s)=%d\n",arg,sts);
857     memset(buff,0,sizeof buff);
858     NkfConvert(buff,buff2);
859     printf("NkfConvert(%s)=%s\n",buff2,buff);
860     n = NkfGetKanjiCode();
861     printf("NkfGetKanjiCode()=%d\n",n);
862         sts = SetNkfOption(arg);
863         printf("SetNkfOption(%s)=%d\n",arg,sts);
864         memset(buff,0,sizeof buff);
865         sts = NkfConvertSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
866         printf("NkfConvertSafe(%s)=%d len=%d '%s'\n",buff2,sts,len,buff);
867         dumpn(buff2,strlen(buff2));
868         dumpn(buff,len);
869         n = NkfGetKanjiCode();
870         printf("NkfGetKanjiCode()=%d\n",n);
871 }
872 
guess(unsigned char * buff2)873 void guess(unsigned char *buff2)
874 {
875     char *g = "--guess";
876 
877         sts = SetNkfOption(g);
878         printf("SetNkfOption(%s)=%d\n",g,sts);
879         memset(buff,0,sizeof buff);
880         NkfConvert(buff,buff2);
881         printf("NkfConvert(%s)=%s\n",buff2,buff);
882         dumpn(buff2,strlen(buff2));
883         n = NkfGetKanjiCode();
884         printf("NkfGetKanjiCode()=%d %s\n",n,code[n]);
885         memset(buff,0,sizeof buff);
886         sts = GetNkfGuessA(buff,sizeof buff,&len);
887         printf("GetNkfGuessA()=%d len=%d '%s'\n",sts,len,buff);
888         dumpn(buff,len);
889         memset(buff,0,sizeof buff);
890         sts = GetNkfGuessW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
891         printf("GetNkfGuessW()=%d len=%d\n",sts,len);
892         dumpn(buff,len * sizeof(WCHAR));
893 }
894 
dumpf(char * f)895 void dumpf(char *f)
896 {
897     FILE *fp;
898     unsigned int n;
899 
900     fp = fopen(f,"rb");
901     if ( fp == NULL ) return;
902     n = fread(buff,1,sizeof buff,fp);
903     fclose(fp);
904     printf("dumpf(%s,%d)\n",f,n);
905     dumpn(buff,n);
906 }
907 
mkfile(char * f,char * p)908 void mkfile(char *f,char *p)
909 {
910     FILE *fp;
911 
912     fp = fopen(f,"w");
913     if ( fp == NULL ) return;
914     fputs(p,fp);
915     fclose(fp);
916     dumpf(f);
917 }
918 
file(char * arg2,char * arg3,unsigned char * buf)919 void file(char *arg2,char *arg3,unsigned char *buf)
920 {
921             sts = SetNkfOption(arg2);
922             printf("SetNkfOption(%s)=%d\n",arg2,sts);
923             mkfile(arg3,buf);
924             NkfFileConvert1(arg3);
925             printf("NkfFileConvert1(%s)\n",arg3);
926             dumpf(arg3);
927             sts = SetNkfOption(arg2);
928             printf("SetNkfOption(%s)=%d\n",arg2,sts);
929             mkfile(arg3,buf);
930             sts = NkfFileConvert1SafeA(arg3,strlen(arg3) + 1);
931             printf("NkfFileConvert1SafeA(%s)=%d\n",arg3,sts);
932             dumpf(arg3);
933             sts = SetNkfOption(arg2);
934             printf("SetNkfOption(%s)=%d\n",arg2,sts);
935             mkfile(arg3,buf);
936             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
937             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
938             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
939             sts = NkfFileConvert1SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) /*wcslen((wchar_t *)buff) + 1*/);
940             printf("NkfFileConvert1SafeW()=%d\n",sts);
941             dumpf(arg3);
942 }
943 
file2(char * arg2,char * arg3,char * arg4,unsigned char * buf)944 void file2(char *arg2,char *arg3,char *arg4,unsigned char *buf)
945 {
946             sts = SetNkfOption(arg2);
947             printf("SetNkfOption(%s)=%d\n",arg2,sts);
948             mkfile(arg3,buf);
949             NkfFileConvert2(arg3,arg4);
950             printf("NkfFileConvert1(%s,%s)\n",arg3,arg4);
951             dumpf(arg3);
952             dumpf(arg4);
953             sts = SetNkfOption(arg2);
954             printf("SetNkfOption(%s)=%d\n",arg2,sts);
955             mkfile(arg3,buf);
956             sts = NkfFileConvert2SafeA(arg3,strlen(arg3) + 1,arg4,strlen(arg4) + 1);
957             printf("NkfFileConvert2SafeA(%s,%s)=%d\n",arg3,arg4,sts);
958             dumpf(arg3);
959             dumpf(arg4);
960             sts = SetNkfOption(arg2);
961             printf("SetNkfOption(%s)=%d\n",arg2,sts);
962             mkfile(arg3,buf);
963             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
964             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
965             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
966             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg4,-1,(wchar_t *)buff4,sizeof(buff4) / sizeof(wchar_t));
967             printf("MultiByteToWideChar(%s)=%d\n",arg4,sts);
968             dumpn(buff4,(wcslen((wchar_t *)buff4) + 1) * sizeof(wchar_t));
969             sts = NkfFileConvert2SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) ,(wchar_t *)buff4,sizeof buff4 / sizeof(wchar_t));
970             printf("NkfFileConvert2SafeW()=%d\n",sts);
971             dumpf(arg3);
972             dumpf(arg4);
973 }
974 
main(int argc,char ** argv)975 int main(int argc,char **argv)
976 {
977     struct NKFSUPPORTFUNCTIONS fnc;
978 
979     if ( argc < 2 ) return 0;
980     switch ( *argv[1] ) {
981       case 'v':
982         memset(buff,0,sizeof buff);
983         GetNkfVersion(buff);
984         printf("GetNkfVersion() '%s'\n",buff);
985             sts = GetNkfVersionSafeA(buff,sizeof buff,&len);
986             printf("GetNkfVersionSafeA()=%d len=%d '%s'\n",sts,len,buff);
987             sts = GetNkfVersionSafeW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
988             printf("GetNkfVersionSafeW()=%d len=%d\n",sts,len);
989             dumpn(buff,len * sizeof(WCHAR));
990             sts = GetNkfSupportFunctions(&fnc,sizeof fnc,&len);
991             printf("GetNkfSupportFunctions()=%d len=%d\n",sts,len);
992             printf("size=%d\n",fnc.size);
993             printf("copyrightA='%s'\n",fnc.copyrightA);
994             printf("versionA='%s'\n",fnc.versionA);
995             printf("dateA='%s'\n",fnc.dateA);
996             printf("functions=%d %x\n",fnc.functions,fnc.functions);
997         break;
998       case 'm':
999         if ( argc < 3 ) return 0;
1000         mimeencode(argv[2]);
1001         break;
1002       case 'M':
1003         if ( argc < 2 ) return 0;
1004         gets(buff2);
1005         mimeencode(buff2);
1006         break;
1007       case 'c':
1008         if ( argc < 4 ) return 0;
1009         convert(argv[2],argv[3]);
1010         break;
1011       case 'C':
1012         if ( argc < 3 ) return 0;
1013         gets(buff2);
1014         convert(argv[2],buff2);
1015         break;
1016       case 'g':
1017         if ( argc < 3 ) return 0;
1018         guess(argv[2]);
1019         break;
1020       case 'G':
1021         if ( argc < 2 ) return 0;
1022         gets(buff2);
1023         guess(buff2);
1024         break;
1025       case 'f':
1026         if ( argc < 5 ) return 0;
1027         file(argv[2],argv[3],argv[4]);
1028         break;
1029       case 'F':
1030         if ( argc < 4 ) return 0;
1031         gets(buff3);
1032         file(argv[2],argv[3],buff3);
1033         break;
1034       case '2':
1035         if ( argc < 6 ) return 0;
1036         file2(argv[2],argv[3],argv[4],argv[5]);
1037         break;
1038       case '#':
1039         if ( argc < 5 ) return 0;
1040         gets(buff3);
1041         file2(argv[2],argv[3],argv[4],buff3);
1042         break;
1043       case 'u':
1044         sts = NkfUsage(buff,sizeof buff,&len);
1045         printf("strlen(buff)=%d\n",strlen(buff));
1046         printf("NkfUsage()=%d len=%d \n%s",sts,len,buff);
1047         break;
1048     }
1049     return 0;
1050 }
1051 /* dbg.exe end */
1052 #endif /* DLLDBG @@*/
1053 /*WIN32DLL*/
1054