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