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