nkf32dll.c

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