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.5"
   8 /* NKF_VERSION \82Ì\83\8f\83C\83h\95¶\8e\9a */
   9 #define DLL_VERSION   "2.0.5.0 2"
  10 /* DLL\82ª\95Ô\82· */
  11 #define DLL_VERSIONW L"2.0.5.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(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 = stdout;
 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     char *codename = "BINARY";
 186     if (!is_inputcode_mixed) {
 187         if (strcmp(input_codename, "") == 0) {
 188             codename = "ASCII";
 189         } else {
 190             codename = input_codename;
 191         }
 192     }
 193     if (filename != NULL) {
 194         guessbuffA = realloc(guessbuffA,(strlen(filename) + GUESS + 1) * sizeof (char) );
 195         sprintf(guessbuffA,"%s:%s", filename,codename);
 196     } else {
 197         guessbuffA = realloc(guessbuffA,(GUESS + 1) * sizeof (char) );
 198         sprintf(guessbuffA,"%s", codename);
 199     }
 200 }
 201
 202 #ifdef UNICODESUPPORT
 203 void
 204 print_guessed_codeW (filename)
 205     wchar_t *filename;
 206 {
 207     char *codename = "BINARY";
 208     if (!is_inputcode_mixed) {
 209         if (strcmp(input_codename, "") == 0) {
 210             codename = "ASCII";
 211         } else {
 212             codename = input_codename;
 213         }
 214     }
 215     if (filename != NULL) {
 216         guessbuffW = realloc(guessbuffW,(wcslen(filename) + GUESS + 1) * sizeof (wchar_t) );
 217         swprintf(guessbuffW,L"%s:%s",filename,tounicode(codename));
 218     } else {
 219         guessbuffW = realloc(guessbuffW,(GUESS + 1) * sizeof (wchar_t));
 220         swprintf(guessbuffW,L"%s",tounicode(codename));
 221     }
 222 }
 223 #endif /*UNICODESUPPORT*/
 224
 225 /**
 226  ** \83p\83b\83`\90§\8dì\8eÒ
 227  **  void@merope.pleiades.or.jp (Kusakabe Youichi)
 228  **  NIDE Naoyuki <nide@ics.nara-wu.ac.jp>
 229  **  ohta@src.ricoh.co.jp (Junn Ohta)
 230  **  inouet@strl.nhk.or.jp (Tomoyuki Inoue)
 231  **  kiri@pulser.win.or.jp (Tetsuaki Kiriyama)
 232  **  Kimihiko Sato <sato@sail.t.u-tokyo.ac.jp>
 233  **  a_kuroe@kuroe.aoba.yokohama.jp (Akihiko Kuroe)
 234  **  kono@ie.u-ryukyu.ac.jp (Shinji Kono)
 235  **  GHG00637@nifty-serve.or.jp (COW)
 236  **
 237  **/
 238
 239 void
 240 reinitdll()
 241 {
 242     cin = NULL;
 243     nin = -1;
 244     ninmax = -1;
 245     std_getc_mode = 1;
 246     fout = stdout;
 247     cout = NULL;
 248     nout = -1;
 249     noutmax = -1;
 250     std_putc_mode = 1;
 251     if ( guessbuffA ) {
 252         free(guessbuffA);
 253         guessbuffA = NULL;
 254     }
 255 #ifdef UNICODESUPPORT
 256     if ( guessbuffW ) {
 257         free(guessbuffW);
 258         guessbuffW = NULL;
 259     }
 260 #endif /*UNICODESUPPORT*/
 261 }
 262
 263 #ifndef DLLDBG /* DLLDBG @@*/
 264 int WINAPI DllEntryPoint(HINSTANCE hinst,unsigned long reason,void* lpReserved)
 265 {
 266         return 1;
 267 }
 268 #endif /* DLLDBG @@*/
 269
 270 static LPSTR nkfverA = NKF_VERSION;
 271 static LPSTR dllverA = DLL_VERSION;
 272 #ifdef UNICODESUPPORT
 273 static LPWSTR nkfverW = NKF_VERSIONW;
 274 static LPWSTR dllverW = DLL_VERSIONW;
 275 #endif /*UNICODESUPPORT*/
 276
 277 BOOL scp(LPSTR s,LPSTR t,DWORD n)
 278 {
 279     while ( n ) {
 280         if ( (*s = *t) == 0 ) return TRUE;
 281         if ( --n == 0 ) {
 282             *s = 0;
 283             break;
 284         }
 285         s++;
 286         t++;
 287     }
 288     return FALSE;
 289 }
 290
 291 #ifdef UNICODESUPPORT
 292 BOOL wscp(LPWSTR s,LPWSTR t,DWORD n)
 293 {
 294     while ( n ) {
 295         if ( (*s = *t) == 0 ) return TRUE;
 296         if ( --n == 0 ) {
 297             *s = 0;
 298             break;
 299         }
 300         s++;
 301         t++;
 302     }
 303     return FALSE;
 304 }
 305 #endif /*UNICODESUPPORT*/
 306
 307 void CALLBACK GetNkfVersion(LPSTR verStr){
 308     strcpy(verStr,dllverA);
 309 }
 310
 311 BOOL WINAPI GetNkfVersionSafeA(LPSTR verStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
 312 {
 313     *lpTCHARsReturned = strlen(dllverA) + 1;
 314     if ( verStr == NULL || nBufferLength == 0 ) return FALSE;
 315     return scp(verStr,dllverA,nBufferLength);
 316 }
 317
 318 BOOL WINAPI GetNkfVersionSafeW(LPWSTR verStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
 319 {
 320 #ifdef UNICODESUPPORT
 321     *lpTCHARsReturned = wcslen(dllverW) + 1;
 322     if ( verStr == NULL || nBufferLength == 0 ) return FALSE;
 323     wcsncpy(verStr,dllverW,nBufferLength);
 324     if ( wcslen(dllverW) >= nBufferLength )  {
 325         *(verStr + nBufferLength - 1) = 0;
 326         return FALSE;
 327     }
 328     return TRUE;
 329 #else /*UNICODESUPPORT*/
 330     return FALSE;
 331 #endif /*UNICODESUPPORT*/
 332 }
 333
 334 int CALLBACK SetNkfOption(LPCSTR optStr)
 335 {
 336     LPSTR p;
 337
 338     if ( *optStr == '-' ) {
 339         reinit();
 340         options(optStr);
 341     } else {
 342         p = malloc(strlen(optStr) + 2);
 343         if ( p == NULL ) return -1;
 344         *p = '-';
 345         strcpy(p + 1,optStr);
 346         reinit();
 347         options(p);
 348         free(p);
 349     }
 350     return 0;
 351 }
 352
 353 void CALLBACK NkfConvert(LPSTR outStr, LPCSTR inStr)
 354 {
 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     std_putc_mode = 6;
 370     cout = outStr;
 371     noutmax = nOutBufferLength;
 372     nout = 0;
 373     std_getc_mode = 2;
 374     cin = inStr;
 375     ninmax = nInBufferLength;
 376     nin = 0;
 377     kanji_convert(NULL);
 378     *lpBytesReturned = nout;
 379     if ( nout < noutmax ) *cout = 0;
 380     return TRUE;
 381 }
 382
 383 void CALLBACK ToHankaku(LPSTR inStr)
 384 {
 385     unsigned char *p;
 386     int len;
 387
 388     len = strlen(inStr) + 1;
 389     p = malloc(len);
 390     if ( p == NULL ) return;
 391     memcpy(p,inStr,len);
 392     reinit();
 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     reinit();
 401     options("-ZSs");
 402     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
 403 }
 404
 405 void CALLBACK ToZenkakuKana(LPSTR outStr, LPCSTR inStr)
 406 {
 407     reinit();
 408     options("-Ss");
 409     NkfConvert(outStr, inStr);
 410 }
 411
 412 BOOL WINAPI ToZenkakuKanaSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
 413 {
 414     reinit();
 415     options("-Ss");
 416     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
 417 }
 418
 419 void CALLBACK EncodeSubject(LPSTR outStr ,LPCSTR inStr){
 420     reinit();
 421     options("-jM");
 422     NkfConvert(outStr, inStr);
 423 }
 424
 425 BOOL WINAPI EncodeSubjectSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
 426 {
 427     reinit();
 428     options("-jM");
 429     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
 430 }
 431
 432 #ifdef TOMIME
 433 void CALLBACK ToMime(LPSTR outStr ,LPCSTR inStr)
 434 {
 435     EncodeSubject(outStr,inStr);
 436 }
 437 #endif /*TOMIME*/
 438
 439 #ifdef GETKANJICODE
 440 int CALLBACK NkfGetKanjiCode(VOID)
 441 {
 442     int iCode=0;
 443     //if(iconv == s_iconv)iCode=0; /* 0:\83V\83t\83gJIS */
 444     if(iconv == w_iconv)iCode=3; /* UTF-8 */
 445     else if(iconv == w_iconv16){
 446         if(utf16_mode == UTF16BE_INPUT)iCode=5; /* 5:UTF-16BE */
 447         else iCode=4; /* 4:UTF-16LE */
 448     }else if(iconv == e_iconv){
 449         if(estab_f == FALSE)iCode=2; /* 2:ISO-2022-JP */
 450         else iCode=1; /* 1:EUC */
 451     }
 452     return iCode;
 453 }
 454 #endif /*GETKANJICODE*/
 455
 456 #ifdef FILECONVERT1
 457 void CALLBACK NkfFileConvert1(LPCSTR fName)
 458 {
 459     FILE *fin;
 460     char *tempdname;
 461     char tempfname[MAX_PATH];
 462     char d[4];
 463     DWORD len;
 464     BOOL sts;
 465
 466     len = GetTempPath(sizeof d,d);
 467     tempdname = malloc(len + 1);
 468     if ( tempdname == NULL ) return;
 469     len = GetTempPath(len + 1,tempdname);
 470     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
 471     if ( sts != 0 )  {
 472         sts = CopyFileA(fName,tempfname,FALSE);
 473          if ( sts ) {
 474              if ((fin = fopen(tempfname, "rb")) != NULL) {
 475                  if ((fout = fopen(fName, "wb")) != NULL) {
 476                      cin = NULL;
 477                      nin = -1;
 478                      ninmax = -1;
 479                      std_getc_mode = 1;
 480                      cout = NULL;
 481                      nout = -1;
 482                      noutmax = -1;
 483                      std_putc_mode = 1;
 484                      kanji_convert(fin);
 485                      fclose(fin);
 486                  }
 487                  fclose(fout);
 488              }
 489         DeleteFile(tempfname);
 490         }
 491     }
 492     free(tempdname);
 493 }
 494 #endif /*FILECONVERT1*/
 495
 496 BOOL WINAPI NkfFileConvert1SafeA(LPCSTR fName,DWORD nBufferLength /*in TCHARs*/)
 497 {
 498     FILE *fin;
 499     char *tempdname;
 500     char tempfname[MAX_PATH];
 501     char d[4];
 502     DWORD len;
 503     BOOL sts;
 504     BOOL ret;
 505     LPCSTR p;
 506
 507     ret = FALSE;
 508     p = fName;
 509     for ( ;; ) {
 510         if ( nBufferLength == 0 ) return ret;
 511         if ( *p == 0 ) break;
 512         p++;
 513         --nBufferLength;
 514     }
 515     if ( chmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
 516     len = GetTempPath(sizeof d,d);
 517     tempdname = malloc(len + 1);
 518     if ( tempdname == NULL ) return FALSE;
 519     len = GetTempPath(len + 1,tempdname);
 520     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
 521     if ( sts != 0 )  {
 522         sts = CopyFileA(fName,tempfname,FALSE);
 523         if ( sts ) {
 524             if ((fin = fopen(tempfname, "rb")) != NULL) {
 525                 if ((fout = fopen(fName, "wb")) != NULL) {
 526                     cin = NULL;
 527                     nin = -1;
 528                     ninmax = -1;
 529                     std_getc_mode = 1;
 530                     cout = NULL;
 531                     nout = -1;
 532                     noutmax = -1;
 533                     std_putc_mode = 1;
 534                     kanji_convert(fin);
 535                     fclose(fin);
 536                     ret = TRUE;
 537                 }
 538                 fclose(fout);
 539             }
 540             DeleteFileA(tempfname);
 541         }
 542     }
 543     free(tempdname);
 544     return ret;
 545 }
 546
 547 BOOL WINAPI NkfFileConvert1SafeW(LPCWSTR fName,DWORD nBufferLength /*in TCHARs*/)
 548 {
 549 #ifdef UNICODESUPPORT
 550     FILE *fin;
 551     wchar_t *tempdname;
 552     wchar_t tempfname[MAX_PATH];
 553     wchar_t d[2];
 554     DWORD len;
 555     BOOL sts;
 556     BOOL ret;
 557     LPCWSTR p;
 558
 559     ret = FALSE;
 560     p = fName;
 561     for ( ;; ) {
 562         if ( nBufferLength == 0 ) return ret;
 563         if ( *p == 0 ) break;
 564         p++;
 565         --nBufferLength;
 566     }
 567     if ( _wchmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
 568     len = GetTempPathW(sizeof d / sizeof(WCHAR),d);
 569     tempdname = malloc((len + 1) * sizeof(WCHAR));
 570     if ( tempdname == NULL ) return FALSE;
 571     len = GetTempPathW(len + 1,tempdname);
 572     sts = GetTempFileNameW(tempdname,L"NKF",0,tempfname);
 573     if ( sts != 0 )  {
 574         sts = CopyFileW(fName,tempfname,FALSE);
 575         if ( sts ) {
 576             if ((fin = _wfopen(tempfname,L"rb")) != NULL) {
 577                 if ((fout = _wfopen(fName,L"wb")) != NULL) {
 578                     cin = NULL;
 579                     nin = -1;
 580                     ninmax = -1;
 581                     std_getc_mode = 1;
 582                     cout = NULL;
 583                     nout = -1;
 584                     noutmax = -1;
 585                     std_putc_mode = 1;
 586                     kanji_convert(fin);
 587                     fclose(fin);
 588                     ret = TRUE;
 589                 }
 590                 fclose(fout);
 591             }
 592             DeleteFileW(tempfname);
 593         }
 594     }
 595     free(tempdname);
 596     return ret;
 597 #else /*UNICODESUPPORT*/
 598     return FALSE;
 599 #endif /*UNICODESUPPORT*/
 600 }
 601
 602 #ifdef FILECONVERT2
 603 void CALLBACK NkfFileConvert2(LPCSTR fInName,LPCSTR fOutName)
 604 {
 605     FILE *fin;
 606
 607     if ((fin = fopen(fInName, "rb")) == NULL) return;
 608     if((fout=fopen(fOutName, "wb")) == NULL) {
 609         fclose(fin);
 610         return;
 611     }
 612     cin = NULL;
 613     nin = -1;
 614     ninmax = -1;
 615     std_getc_mode = 1;
 616     cout = NULL;
 617     nout = -1;
 618     noutmax = -1;
 619     std_putc_mode = 1;
 620     kanji_convert(fin);
 621     fclose(fin);
 622     fclose(fout);
 623 }
 624 #endif /*FILECONVERT2*/
 625
 626 BOOL WINAPI NkfFileConvert2SafeA(LPCSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
 627 {
 628     FILE *fin;
 629     BOOL sts;
 630     BOOL ret;
 631     LPCSTR p;
 632
 633     ret = FALSE;
 634     p = fInName;
 635     for ( ;; ) {
 636         if ( fInBufferLength == 0 ) return ret;
 637         if ( *p == 0 ) break;
 638         p++;
 639         --fInBufferLength;
 640     }
 641     p = fOutName;
 642     for ( ;; ) {
 643         if ( fOutBufferLength == 0 ) return ret;
 644         if ( *p == 0 ) break;
 645         p++;
 646         --fOutBufferLength;
 647     }
 648     if ((fin = fopen(fInName, "rb")) != NULL) {
 649         if((fout=fopen(fOutName, "wb")) != NULL) {
 650             cin = NULL;
 651             nin = -1;
 652             ninmax = -1;
 653             std_getc_mode = 1;
 654             cout = NULL;
 655             nout = -1;
 656             noutmax = -1;
 657             std_putc_mode = 1;
 658             kanji_convert(fin);
 659             fclose(fin);
 660             ret = TRUE;
 661         }
 662         fclose(fout);
 663     }
 664     return ret;
 665 }
 666
 667 BOOL WINAPI NkfFileConvert2SafeW(LPCWSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCWSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
 668 {
 669 #ifdef UNICODESUPPORT
 670     FILE *fin;
 671     BOOL sts;
 672     BOOL ret;
 673     LPCWSTR p;
 674
 675     ret = FALSE;
 676     p = fInName;
 677     for ( ;; ) {
 678         if ( fInBufferLength == 0 ) return ret;
 679         if ( *p == 0 ) break;
 680         p++;
 681         --fInBufferLength;
 682     }
 683     p = fOutName;
 684     for ( ;; ) {
 685         if ( fOutBufferLength == 0 ) return ret;
 686         if ( *p == 0 ) break;
 687         p++;
 688         --fOutBufferLength;
 689     }
 690     if ( (fin = _wfopen(fInName,L"rb")) != NULL) {
 691         if( (fout = _wfopen(fOutName,L"wb")) != NULL) {
 692             cin = NULL;
 693             nin = -1;
 694             ninmax = -1;
 695             std_getc_mode = 1;
 696             cout = NULL;
 697             nout = -1;
 698             noutmax = -1;
 699             std_putc_mode = 1;
 700             kanji_convert(fin);
 701             fclose(fin);
 702             ret = TRUE;
 703         }
 704         fclose(fout);
 705     }
 706     return ret;
 707 #else /*UNICODESUPPORT*/
 708     return FALSE;
 709 #endif /*UNICODESUPPORT*/
 710 }
 711
 712 BOOL WINAPI GetNkfGuessA(LPSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
 713 {
 714     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
 715     print_guessed_code(NULL);
 716     *lpTCHARsReturned = strlen(guessbuffA) + 1;
 717     return scp(outStr,guessbuffA,nBufferLength);
 718 }
 719
 720 BOOL WINAPI GetNkfGuessW(LPWSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
 721 {
 722 #ifdef UNICODESUPPORT
 723     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
 724     print_guessed_codeW(NULL);
 725     *lpTCHARsReturned = wcslen(guessbuffW) + 1;
 726     return wscp(outStr,guessbuffW,nBufferLength);
 727 #else /*UNICODESUPPORT*/
 728     return FALSE;
 729 #endif /*UNICODESUPPORT*/
 730 }
 731
 732 static struct {
 733 DWORD size;
 734 LPCSTR copyrightA;
 735 LPCSTR versionA;
 736 LPCSTR dateA;
 737 DWORD functions;
 738 } NkfSupportFunctions = {
 739 sizeof(NkfSupportFunctions),
 740 NULL,
 741 NKF_VERSION,
 742 NKF_RELEASE_DATE,
 743 1 /* nkf32103a.lzh uminchu 1.03 */
 744 /* | 2 */ /* nkf32dll.zip 0.91 */
 745 #if defined(TOMIME) && defined(GETKANJICODE) && defined(FILECONVERT1) && defined(FILECONVERT2)
 746 | 4 /* nkf32204.zip Kaneto 2.0.4.0 */
 747 #endif
 748 | 8 /* this */
 749 #ifdef UNICODESUPPORT
 750 | 0x80000000
 751 #endif /*UNICODESUPPORT*/
 752 ,
 753 };
 754
 755 BOOL WINAPI GetNkfSupportFunctions(void *outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
 756 {
 757     *lpBytesReturned = sizeof NkfSupportFunctions;
 758     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
 759     NkfSupportFunctions.copyrightA = CopyRight;
 760     memcpy(outStr,&NkfSupportFunctions,sizeof NkfSupportFunctions > nBufferLength ? nBufferLength : sizeof NkfSupportFunctions);
 761     return TRUE;
 762 }
 763
 764 BOOL WINAPI NkfUsage(LPSTR outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
 765 {
 766     ubuff = outStr;
 767     ulen = nBufferLength;
 768     uret = TRUE;
 769     usage();
 770     if ( uret == TRUE ) {
 771         *lpBytesReturned = nBufferLength - ulen;
 772     }
 773     return uret;
 774 }
 775
 776 /* nkf32.dll main end */
 777
 778 #ifdef DLLDBG /* DLLDBG @@*/
 779 /* dbg.exe */
 780 unsigned char buff[65536];
 781 unsigned char buff2[65536];
 782 unsigned char buff3[65536];
 783 unsigned char buff4[65536];
 784 char *code[] = {"\83V\83t\83gJIS","EUC","ISO-2022-JP","UTF-8","UTF-16LE","UTF-16BE"};
 785
 786     int n;
 787     BOOL sts;
 788     DWORD len;
 789
 790 void mimeencode(unsigned char *buff2)
 791 {
 792     memset(buff,0,sizeof buff);
 793     EncodeSubject(buff,buff2);
 794     printf("EncodeSubject(%s)=%s\n",buff2,buff);
 795         memset(buff,0,sizeof buff);
 796         ToMime(buff,buff2);
 797         printf("ToMime(%s)=%s\n",buff2,buff);
 798         memset(buff,0,sizeof buff);
 799         sts = EncodeSubjectSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
 800         printf("EncodeSubjectSafe(%s)=%d len=%d '%s'\n",buff,sts,len,buff);
 801         dumpn(buff2,strlen(buff2));
 802         dumpn(buff,len);
 803 }
 804
 805 void convert(char *arg,unsigned char *buff2)
 806 {
 807     sts = SetNkfOption(arg);
 808     printf("SetNkfOption(%s)=%d\n",arg,sts);
 809     memset(buff,0,sizeof buff);
 810     NkfConvert(buff,buff2);
 811     printf("NkfConvert(%s)=%s\n",buff2,buff);
 812     n = NkfGetKanjiCode();
 813     printf("NkfGetKanjiCode()=%d\n",n);
 814         sts = SetNkfOption(arg);
 815         printf("SetNkfOption(%s)=%d\n",arg,sts);
 816         memset(buff,0,sizeof buff);
 817         sts = NkfConvertSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
 818         printf("NkfConvertSafe(%s)=%d len=%d '%s'\n",buff2,sts,len,buff);
 819         dumpn(buff2,strlen(buff2));
 820         dumpn(buff,len);
 821         n = NkfGetKanjiCode();
 822         printf("NkfGetKanjiCode()=%d\n",n);
 823 }
 824
 825 void guess(unsigned char *buff2)
 826 {
 827     char *g = "--guess";
 828
 829         sts = SetNkfOption(g);
 830         printf("SetNkfOption(%s)=%d\n",g,sts);
 831         memset(buff,0,sizeof buff);
 832         NkfConvert(buff,buff2);
 833         printf("NkfConvert(%s)=%s\n",buff2,buff);
 834         dumpn(buff2,strlen(buff2));
 835         n = NkfGetKanjiCode();
 836         printf("NkfGetKanjiCode()=%d %s\n",n,code[n]);
 837         memset(buff,0,sizeof buff);
 838         sts = GetNkfGuessA(buff,sizeof buff,&len);
 839         printf("GetNkfGuessA()=%d len=%d '%s'\n",sts,len,buff);
 840         dumpn(buff,len);
 841         memset(buff,0,sizeof buff);
 842         sts = GetNkfGuessW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
 843         printf("GetNkfGuessW()=%d len=%d\n",sts,len);
 844         dumpn(buff,len * sizeof(WCHAR));
 845 }
 846
 847 void dumpf(char *f)
 848 {
 849     FILE *fp;
 850     unsigned int n;
 851
 852     fp = fopen(f,"rb");
 853     if ( fp == NULL ) return;
 854     n = fread(buff,1,sizeof buff,fp);
 855     fclose(fp);
 856     printf("dumpf(%s,%d)\n",f,n);
 857     dumpn(buff,n);
 858 }
 859
 860 void mkfile(char *f,char *p)
 861 {
 862     FILE *fp;
 863
 864     fp = fopen(f,"w");
 865     if ( fp == NULL ) return;
 866     fputs(p,fp);
 867     fclose(fp);
 868     dumpf(f);
 869 }
 870
 871 void file(char *arg2,char *arg3,unsigned char *buf)
 872 {
 873             sts = SetNkfOption(arg2);
 874             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 875             mkfile(arg3,buf);
 876             NkfFileConvert1(arg3);
 877             printf("NkfFileConvert1(%s)\n",arg3);
 878             dumpf(arg3);
 879             sts = SetNkfOption(arg2);
 880             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 881             mkfile(arg3,buf);
 882             sts = NkfFileConvert1SafeA(arg3,strlen(arg3) + 1);
 883             printf("NkfFileConvert1SafeA(%s)=%d\n",arg3,sts);
 884             dumpf(arg3);
 885             sts = SetNkfOption(arg2);
 886             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 887             mkfile(arg3,buf);
 888             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
 889             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
 890             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
 891             sts = NkfFileConvert1SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) /*wcslen((wchar_t *)buff) + 1*/);
 892             printf("NkfFileConvert1SafeW()=%d\n",sts);
 893             dumpf(arg3);
 894 }
 895
 896 void file2(char *arg2,char *arg3,char *arg4,unsigned char *buf)
 897 {
 898             sts = SetNkfOption(arg2);
 899             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 900             mkfile(arg3,buf);
 901             NkfFileConvert2(arg3,arg4);
 902             printf("NkfFileConvert1(%s,%s)\n",arg3,arg4);
 903             dumpf(arg3);
 904             dumpf(arg4);
 905             sts = SetNkfOption(arg2);
 906             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 907             mkfile(arg3,buf);
 908             sts = NkfFileConvert2SafeA(arg3,strlen(arg3) + 1,arg4,strlen(arg4) + 1);
 909             printf("NkfFileConvert2SafeA(%s,%s)=%d\n",arg3,arg4,sts);
 910             dumpf(arg3);
 911             dumpf(arg4);
 912             sts = SetNkfOption(arg2);
 913             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 914             mkfile(arg3,buf);
 915             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
 916             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
 917             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
 918             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg4,-1,(wchar_t *)buff4,sizeof(buff4) / sizeof(wchar_t));
 919             printf("MultiByteToWideChar(%s)=%d\n",arg4,sts);
 920             dumpn(buff4,(wcslen((wchar_t *)buff4) + 1) * sizeof(wchar_t));
 921             sts = NkfFileConvert2SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) ,(wchar_t *)buff4,sizeof buff4 / sizeof(wchar_t));
 922             printf("NkfFileConvert2SafeW()=%d\n",sts);
 923             dumpf(arg3);
 924             dumpf(arg4);
 925 }
 926
 927 int main(int argc,char **argv)
 928 {
 929     struct NKFSUPPORTFUNCTIONS fnc;
 930
 931     if ( argc < 2 ) return 0;
 932     switch ( *argv[1] ) {
 933       case 'v':
 934         memset(buff,0,sizeof buff);
 935         GetNkfVersion(buff);
 936         printf("GetNkfVersion() '%s'\n",buff);
 937             sts = GetNkfVersionSafeA(buff,sizeof buff,&len);
 938             printf("GetNkfVersionSafeA()=%d len=%d '%s'\n",sts,len,buff);
 939             sts = GetNkfVersionSafeW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
 940             printf("GetNkfVersionSafeW()=%d len=%d\n",sts,len);
 941             dumpn(buff,len * sizeof(WCHAR));
 942             sts = GetNkfSupportFunctions(&fnc,sizeof fnc,&len);
 943             printf("GetNkfSupportFunctions()=%d len=%d\n",sts,len);
 944             printf("size=%d\n",fnc.size);
 945             printf("copyrightA='%s'\n",fnc.copyrightA);
 946             printf("versionA='%s'\n",fnc.versionA);
 947             printf("dateA='%s'\n",fnc.dateA);
 948             printf("functions=%d %x\n",fnc.functions,fnc.functions);
 949         break;
 950       case 'm':
 951         if ( argc < 3 ) return 0;
 952         mimeencode(argv[2]);
 953         break;
 954       case 'M':
 955         if ( argc < 2 ) return 0;
 956         gets(buff2);
 957         mimeencode(buff2);
 958         break;
 959       case 'c':
 960         if ( argc < 4 ) return 0;
 961         convert(argv[2],argv[3]);
 962         break;
 963       case 'C':
 964         if ( argc < 3 ) return 0;
 965         gets(buff2);
 966         convert(argv[2],buff2);
 967         break;
 968       case 'g':
 969         if ( argc < 3 ) return 0;
 970         guess(argv[2]);
 971         break;
 972       case 'G':
 973         if ( argc < 2 ) return 0;
 974         gets(buff2);
 975         guess(buff2);
 976         break;
 977       case 'f':
 978         if ( argc < 5 ) return 0;
 979         file(argv[2],argv[3],argv[4]);
 980         break;
 981       case 'F':
 982         if ( argc < 4 ) return 0;
 983         gets(buff3);
 984         file(argv[2],argv[3],buff3);
 985         break;
 986       case '2':
 987         if ( argc < 6 ) return 0;
 988         file2(argv[2],argv[3],argv[4],argv[5]);
 989         break;
 990       case '#':
 991         if ( argc < 5 ) return 0;
 992         gets(buff3);
 993         file2(argv[2],argv[3],argv[4],buff3);
 994         break;
 995       case 'u':
 996         sts = NkfUsage(buff,sizeof buff,&len);
 997         printf("strlen(buff)=%d\n",strlen(buff));
 998         printf("NkfUsage()=%d len=%d \n%s",sts,len,buff);
 999         break;
1000     }
1001     return 0;
1002 }
1003 /* dbg.exe end */
1004 #endif /* DLLDBG @@*/
1005 /*WIN32DLL*/