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 1"
  10 /* DLL\82ª\95Ô\82· */
  11 #define DLL_VERSIONW L"2.0.8.0 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
  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 int CALLBACK SetNkfOption(LPSTR optStr)
 324 {
 325     LPSTR p;
 326
 327     if ( *optStr == '-' ) {
 328         reinit();
 329         options(optStr);
 330     } else {
 331         p = malloc(strlen(optStr) + 2);
 332         if ( p == NULL ) return -1;
 333         *p = '-';
 334         strcpy(p + 1,optStr);
 335         reinit();
 336         options(p);
 337         free(p);
 338     }
 339     return 0;
 340 }
 341
 342 void CALLBACK NkfConvert(LPSTR outStr, LPCSTR inStr)
 343 {
 344     std_putc_mode = 2;
 345     cout = outStr;
 346     noutmax = -1;
 347     nout = -1;
 348     std_getc_mode = 2;
 349     cin = inStr;
 350     ninmax = -1;
 351     nin = -1;
 352     kanji_convert(NULL);
 353     *cout = 0;
 354 }
 355
 356 BOOL WINAPI NkfConvertSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/, LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/){
 357     if ( inStr == NULL ) return FALSE;
 358     std_putc_mode = 6;
 359     cout = outStr;
 360     noutmax = nOutBufferLength;
 361     nout = 0;
 362     std_getc_mode = 2;
 363     cin = inStr;
 364     ninmax = nInBufferLength;
 365     nin = 0;
 366     kanji_convert(NULL);
 367     *lpBytesReturned = nout;
 368     if ( nout < noutmax ) *cout = 0;
 369     return TRUE;
 370 }
 371
 372 void CALLBACK ToHankaku(LPSTR inStr)
 373 {
 374     unsigned char *p;
 375     int len;
 376
 377     len = strlen(inStr) + 1;
 378     p = malloc(len);
 379     if ( p == NULL ) return;
 380     memcpy(p,inStr,len);
 381     reinit();
 382     options("-ZSs");
 383     NkfConvert(inStr,p);
 384     free(p);
 385 }
 386
 387 BOOL WINAPI ToHankakuSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
 388 {
 389     reinit();
 390     options("-ZSs");
 391     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
 392 }
 393
 394 void CALLBACK ToZenkakuKana(LPSTR outStr, LPCSTR inStr)
 395 {
 396     reinit();
 397     options("-Ss");
 398     NkfConvert(outStr, inStr);
 399 }
 400
 401 BOOL WINAPI ToZenkakuKanaSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
 402 {
 403     reinit();
 404     options("-Ss");
 405     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
 406 }
 407
 408 void CALLBACK EncodeSubject(LPSTR outStr ,LPCSTR inStr){
 409     reinit();
 410     options("-jM");
 411     NkfConvert(outStr, inStr);
 412 }
 413
 414 BOOL WINAPI EncodeSubjectSafe(LPSTR outStr,DWORD nOutBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/,LPCSTR inStr,DWORD nInBufferLength /*in Bytes*/)
 415 {
 416     reinit();
 417     options("-jM");
 418     return NkfConvertSafe(outStr,nOutBufferLength,lpBytesReturned,inStr,nInBufferLength);
 419 }
 420
 421 #ifdef TOMIME
 422 void CALLBACK ToMime(LPSTR outStr ,LPCSTR inStr)
 423 {
 424     EncodeSubject(outStr,inStr);
 425 }
 426 #endif /*TOMIME*/
 427
 428 #ifdef GETKANJICODE
 429 int CALLBACK NkfGetKanjiCode(VOID)
 430 {
 431     int iCode=0;
 432     /* if(iconv == s_iconv)iCode=0; */ /* 0:\83V\83t\83gJIS */
 433     if(iconv == w_iconv)iCode=3; /* UTF-8 */
 434     else if(iconv == w_iconv16){
 435         if(input_endian == ENDIAN_BIG)iCode=5; /* 5:UTF-16BE */
 436         else iCode=4; /* 4:UTF-16LE */
 437     }else if(iconv == e_iconv){
 438         if(estab_f == FALSE)iCode=2; /* 2:ISO-2022-JP */
 439         else iCode=1; /* 1:EUC */
 440     }
 441     return iCode;
 442 }
 443 #endif /*GETKANJICODE*/
 444
 445 #ifdef FILECONVERT1
 446 void CALLBACK NkfFileConvert1(LPCSTR fName)
 447 {
 448     FILE *fin;
 449     char *tempdname;
 450     char tempfname[MAX_PATH];
 451     char d[4];
 452     DWORD len;
 453     BOOL sts;
 454
 455     len = GetTempPath(sizeof d,d);
 456     tempdname = malloc(len + 1);
 457     if ( tempdname == NULL ) return;
 458     len = GetTempPath(len + 1,tempdname);
 459     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
 460     if ( sts != 0 )  {
 461         sts = CopyFileA(fName,tempfname,FALSE);
 462          if ( sts ) {
 463              if ((fin = fopen(tempfname, "rb")) != NULL) {
 464                  if ((fout = fopen(fName, "wb")) != NULL) {
 465                      cin = NULL;
 466                      nin = -1;
 467                      ninmax = -1;
 468                      std_getc_mode = 1;
 469                      cout = NULL;
 470                      nout = -1;
 471                      noutmax = -1;
 472                      std_putc_mode = 1;
 473                      kanji_convert(fin);
 474                      fclose(fin);
 475                  }
 476                  fclose(fout);
 477              }
 478         DeleteFile(tempfname);
 479         }
 480     }
 481     free(tempdname);
 482 }
 483 #endif /*FILECONVERT1*/
 484
 485 BOOL WINAPI NkfFileConvert1SafeA(LPCSTR fName,DWORD nBufferLength /*in TCHARs*/)
 486 {
 487     FILE *fin;
 488     char *tempdname;
 489     char tempfname[MAX_PATH];
 490     char d[4];
 491     DWORD len;
 492     BOOL sts;
 493     BOOL ret;
 494     LPCSTR p;
 495
 496     ret = FALSE;
 497     p = fName;
 498     for ( ;; ) {
 499         if ( nBufferLength == 0 ) return ret;
 500         if ( *p == 0 ) break;
 501         p++;
 502         --nBufferLength;
 503     }
 504     if ( chmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
 505     len = GetTempPath(sizeof d,d);
 506     tempdname = malloc(len + 1);
 507     if ( tempdname == NULL ) return FALSE;
 508     len = GetTempPath(len + 1,tempdname);
 509     sts = GetTempFileName(tempdname,"NKF",0,tempfname);
 510     if ( sts != 0 )  {
 511         sts = CopyFileA(fName,tempfname,FALSE);
 512         if ( sts ) {
 513             if ((fin = fopen(tempfname, "rb")) != NULL) {
 514                 if ((fout = fopen(fName, "wb")) != NULL) {
 515                     cin = NULL;
 516                     nin = -1;
 517                     ninmax = -1;
 518                     std_getc_mode = 1;
 519                     cout = NULL;
 520                     nout = -1;
 521                     noutmax = -1;
 522                     std_putc_mode = 1;
 523                     kanji_convert(fin);
 524                     fclose(fin);
 525                     ret = TRUE;
 526                 }
 527                 fclose(fout);
 528             }
 529             DeleteFileA(tempfname);
 530         }
 531     }
 532     free(tempdname);
 533     return ret;
 534 }
 535
 536 BOOL WINAPI NkfFileConvert1SafeW(LPCWSTR fName,DWORD nBufferLength /*in TCHARs*/)
 537 {
 538 #ifdef UNICODESUPPORT
 539     FILE *fin;
 540     wchar_t *tempdname;
 541     wchar_t tempfname[MAX_PATH];
 542     wchar_t d[2];
 543     DWORD len;
 544     BOOL sts;
 545     BOOL ret;
 546     LPCWSTR p;
 547
 548     ret = FALSE;
 549     p = fName;
 550     for ( ;; ) {
 551         if ( nBufferLength == 0 ) return ret;
 552         if ( *p == 0 ) break;
 553         p++;
 554         --nBufferLength;
 555     }
 556     if ( _wchmod(fName,_S_IREAD | _S_IWRITE) == -1 ) return ret;
 557     len = GetTempPathW(sizeof d / sizeof(WCHAR),d);
 558     tempdname = malloc((len + 1) * sizeof(WCHAR));
 559     if ( tempdname == NULL ) return FALSE;
 560     len = GetTempPathW(len + 1,tempdname);
 561     sts = GetTempFileNameW(tempdname,L"NKF",0,tempfname);
 562     if ( sts != 0 )  {
 563         sts = CopyFileW(fName,tempfname,FALSE);
 564         if ( sts ) {
 565             if ((fin = _wfopen(tempfname,L"rb")) != NULL) {
 566                 if ((fout = _wfopen(fName,L"wb")) != NULL) {
 567                     cin = NULL;
 568                     nin = -1;
 569                     ninmax = -1;
 570                     std_getc_mode = 1;
 571                     cout = NULL;
 572                     nout = -1;
 573                     noutmax = -1;
 574                     std_putc_mode = 1;
 575                     kanji_convert(fin);
 576                     fclose(fin);
 577                     ret = TRUE;
 578                 }
 579                 fclose(fout);
 580             }
 581             DeleteFileW(tempfname);
 582         }
 583     }
 584     free(tempdname);
 585     return ret;
 586 #else /*UNICODESUPPORT*/
 587     return FALSE;
 588 #endif /*UNICODESUPPORT*/
 589 }
 590
 591 #ifdef FILECONVERT2
 592 void CALLBACK NkfFileConvert2(LPCSTR fInName,LPCSTR fOutName)
 593 {
 594     FILE *fin;
 595
 596     if ((fin = fopen(fInName, "rb")) == NULL) return;
 597     if((fout=fopen(fOutName, "wb")) == NULL) {
 598         fclose(fin);
 599         return;
 600     }
 601     cin = NULL;
 602     nin = -1;
 603     ninmax = -1;
 604     std_getc_mode = 1;
 605     cout = NULL;
 606     nout = -1;
 607     noutmax = -1;
 608     std_putc_mode = 1;
 609     kanji_convert(fin);
 610     fclose(fin);
 611     fclose(fout);
 612 }
 613 #endif /*FILECONVERT2*/
 614
 615 BOOL WINAPI NkfFileConvert2SafeA(LPCSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
 616 {
 617     FILE *fin;
 618     BOOL sts;
 619     BOOL ret;
 620     LPCSTR p;
 621
 622     ret = FALSE;
 623     p = fInName;
 624     for ( ;; ) {
 625         if ( fInBufferLength == 0 ) return ret;
 626         if ( *p == 0 ) break;
 627         p++;
 628         --fInBufferLength;
 629     }
 630     p = fOutName;
 631     for ( ;; ) {
 632         if ( fOutBufferLength == 0 ) return ret;
 633         if ( *p == 0 ) break;
 634         p++;
 635         --fOutBufferLength;
 636     }
 637     if ((fin = fopen(fInName, "rb")) != NULL) {
 638         if((fout=fopen(fOutName, "wb")) != NULL) {
 639             cin = NULL;
 640             nin = -1;
 641             ninmax = -1;
 642             std_getc_mode = 1;
 643             cout = NULL;
 644             nout = -1;
 645             noutmax = -1;
 646             std_putc_mode = 1;
 647             kanji_convert(fin);
 648             fclose(fin);
 649             ret = TRUE;
 650         }
 651         fclose(fout);
 652     }
 653     return ret;
 654 }
 655
 656 BOOL WINAPI NkfFileConvert2SafeW(LPCWSTR fInName,DWORD fInBufferLength /*in TCHARs*/,LPCWSTR fOutName,DWORD fOutBufferLength /*in TCHARs*/)
 657 {
 658 #ifdef UNICODESUPPORT
 659     FILE *fin;
 660     BOOL sts;
 661     BOOL ret;
 662     LPCWSTR p;
 663
 664     ret = FALSE;
 665     p = fInName;
 666     for ( ;; ) {
 667         if ( fInBufferLength == 0 ) return ret;
 668         if ( *p == 0 ) break;
 669         p++;
 670         --fInBufferLength;
 671     }
 672     p = fOutName;
 673     for ( ;; ) {
 674         if ( fOutBufferLength == 0 ) return ret;
 675         if ( *p == 0 ) break;
 676         p++;
 677         --fOutBufferLength;
 678     }
 679     if ( (fin = _wfopen(fInName,L"rb")) != NULL) {
 680         if( (fout = _wfopen(fOutName,L"wb")) != NULL) {
 681             cin = NULL;
 682             nin = -1;
 683             ninmax = -1;
 684             std_getc_mode = 1;
 685             cout = NULL;
 686             nout = -1;
 687             noutmax = -1;
 688             std_putc_mode = 1;
 689             kanji_convert(fin);
 690             fclose(fin);
 691             ret = TRUE;
 692         }
 693         fclose(fout);
 694     }
 695     return ret;
 696 #else /*UNICODESUPPORT*/
 697     return FALSE;
 698 #endif /*UNICODESUPPORT*/
 699 }
 700
 701 BOOL WINAPI GetNkfGuessA(LPSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
 702 {
 703     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
 704     print_guessed_code(NULL);
 705     *lpTCHARsReturned = strlen(guessbuffA) + 1;
 706     return scp(outStr,guessbuffA,nBufferLength);
 707 }
 708
 709 BOOL WINAPI GetNkfGuessW(LPWSTR outStr,DWORD nBufferLength /*in TCHARs*/,LPDWORD lpTCHARsReturned /*in TCHARs*/)
 710 {
 711 #ifdef UNICODESUPPORT
 712     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
 713     print_guessed_codeW(NULL);
 714     *lpTCHARsReturned = wcslen(guessbuffW) + 1;
 715     return wscp(outStr,guessbuffW,nBufferLength);
 716 #else /*UNICODESUPPORT*/
 717     return FALSE;
 718 #endif /*UNICODESUPPORT*/
 719 }
 720
 721 static struct {
 722 DWORD size;
 723 LPCSTR copyrightA;
 724 LPCSTR versionA;
 725 LPCSTR dateA;
 726 DWORD functions;
 727 } NkfSupportFunctions = {
 728 sizeof(NkfSupportFunctions),
 729 NULL,
 730 NKF_VERSION,
 731 NKF_RELEASE_DATE,
 732 1 /* nkf32103a.lzh uminchu 1.03 */
 733 /* | 2 */ /* nkf32dll.zip 0.91 */
 734 #if defined(TOMIME) && defined(GETKANJICODE) && defined(FILECONVERT1) && defined(FILECONVERT2)
 735 | 4 /* nkf32204.zip Kaneto 2.0.4.0 */
 736 #endif
 737 | 8 /* this */
 738 #ifdef UNICODESUPPORT
 739 | 0x80000000
 740 #endif /*UNICODESUPPORT*/
 741 ,
 742 };
 743
 744 BOOL WINAPI GetNkfSupportFunctions(void *outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
 745 {
 746     *lpBytesReturned = sizeof NkfSupportFunctions;
 747     if ( outStr == NULL || nBufferLength == 0 ) return FALSE;
 748     NkfSupportFunctions.copyrightA = COPY_RIGHT;
 749     memcpy(outStr,&NkfSupportFunctions,sizeof NkfSupportFunctions > nBufferLength ? nBufferLength : sizeof NkfSupportFunctions);
 750     return TRUE;
 751 }
 752
 753 BOOL WINAPI NkfUsage(LPSTR outStr,DWORD nBufferLength /*in Bytes*/,LPDWORD lpBytesReturned /*in Bytes*/)
 754 {
 755     ubuff = outStr;
 756     ulen = nBufferLength;
 757     uret = TRUE;
 758     usage();
 759     if ( uret == TRUE ) {
 760         *lpBytesReturned = nBufferLength - ulen;
 761     }
 762     return uret;
 763 }
 764
 765 /* nkf32.dll main end */
 766
 767 #ifdef DLLDBG /* DLLDBG @@*/
 768 /* dbg.exe */
 769 unsigned char buff[65536];
 770 unsigned char buff2[65536];
 771 unsigned char buff3[65536];
 772 unsigned char buff4[65536];
 773 char *code[] = {"\83V\83t\83gJIS","EUC","ISO-2022-JP","UTF-8","UTF-16LE","UTF-16BE"};
 774
 775     int n;
 776     BOOL sts;
 777     DWORD len;
 778
 779 void mimeencode(unsigned char *buff2)
 780 {
 781     memset(buff,0,sizeof buff);
 782     EncodeSubject(buff,buff2);
 783     printf("EncodeSubject(%s)=%s\n",buff2,buff);
 784         memset(buff,0,sizeof buff);
 785         ToMime(buff,buff2);
 786         printf("ToMime(%s)=%s\n",buff2,buff);
 787         memset(buff,0,sizeof buff);
 788         sts = EncodeSubjectSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
 789         printf("EncodeSubjectSafe(%s)=%d len=%d '%s'\n",buff,sts,len,buff);
 790         dumpn(buff2,strlen(buff2));
 791         dumpn(buff,len);
 792 }
 793
 794 void convert(char *arg,unsigned char *buff2)
 795 {
 796     sts = SetNkfOption(arg);
 797     printf("SetNkfOption(%s)=%d\n",arg,sts);
 798     memset(buff,0,sizeof buff);
 799     NkfConvert(buff,buff2);
 800     printf("NkfConvert(%s)=%s\n",buff2,buff);
 801     n = NkfGetKanjiCode();
 802     printf("NkfGetKanjiCode()=%d\n",n);
 803         sts = SetNkfOption(arg);
 804         printf("SetNkfOption(%s)=%d\n",arg,sts);
 805         memset(buff,0,sizeof buff);
 806         sts = NkfConvertSafe(buff,sizeof buff,&len,buff2,strlen(buff2));
 807         printf("NkfConvertSafe(%s)=%d len=%d '%s'\n",buff2,sts,len,buff);
 808         dumpn(buff2,strlen(buff2));
 809         dumpn(buff,len);
 810         n = NkfGetKanjiCode();
 811         printf("NkfGetKanjiCode()=%d\n",n);
 812 }
 813
 814 void guess(unsigned char *buff2)
 815 {
 816     char *g = "--guess";
 817
 818         sts = SetNkfOption(g);
 819         printf("SetNkfOption(%s)=%d\n",g,sts);
 820         memset(buff,0,sizeof buff);
 821         NkfConvert(buff,buff2);
 822         printf("NkfConvert(%s)=%s\n",buff2,buff);
 823         dumpn(buff2,strlen(buff2));
 824         n = NkfGetKanjiCode();
 825         printf("NkfGetKanjiCode()=%d %s\n",n,code[n]);
 826         memset(buff,0,sizeof buff);
 827         sts = GetNkfGuessA(buff,sizeof buff,&len);
 828         printf("GetNkfGuessA()=%d len=%d '%s'\n",sts,len,buff);
 829         dumpn(buff,len);
 830         memset(buff,0,sizeof buff);
 831         sts = GetNkfGuessW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
 832         printf("GetNkfGuessW()=%d len=%d\n",sts,len);
 833         dumpn(buff,len * sizeof(WCHAR));
 834 }
 835
 836 void dumpf(char *f)
 837 {
 838     FILE *fp;
 839     unsigned int n;
 840
 841     fp = fopen(f,"rb");
 842     if ( fp == NULL ) return;
 843     n = fread(buff,1,sizeof buff,fp);
 844     fclose(fp);
 845     printf("dumpf(%s,%d)\n",f,n);
 846     dumpn(buff,n);
 847 }
 848
 849 void mkfile(char *f,char *p)
 850 {
 851     FILE *fp;
 852
 853     fp = fopen(f,"w");
 854     if ( fp == NULL ) return;
 855     fputs(p,fp);
 856     fclose(fp);
 857     dumpf(f);
 858 }
 859
 860 void file(char *arg2,char *arg3,unsigned char *buf)
 861 {
 862             sts = SetNkfOption(arg2);
 863             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 864             mkfile(arg3,buf);
 865             NkfFileConvert1(arg3);
 866             printf("NkfFileConvert1(%s)\n",arg3);
 867             dumpf(arg3);
 868             sts = SetNkfOption(arg2);
 869             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 870             mkfile(arg3,buf);
 871             sts = NkfFileConvert1SafeA(arg3,strlen(arg3) + 1);
 872             printf("NkfFileConvert1SafeA(%s)=%d\n",arg3,sts);
 873             dumpf(arg3);
 874             sts = SetNkfOption(arg2);
 875             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 876             mkfile(arg3,buf);
 877             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
 878             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
 879             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
 880             sts = NkfFileConvert1SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) /*wcslen((wchar_t *)buff) + 1*/);
 881             printf("NkfFileConvert1SafeW()=%d\n",sts);
 882             dumpf(arg3);
 883 }
 884
 885 void file2(char *arg2,char *arg3,char *arg4,unsigned char *buf)
 886 {
 887             sts = SetNkfOption(arg2);
 888             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 889             mkfile(arg3,buf);
 890             NkfFileConvert2(arg3,arg4);
 891             printf("NkfFileConvert1(%s,%s)\n",arg3,arg4);
 892             dumpf(arg3);
 893             dumpf(arg4);
 894             sts = SetNkfOption(arg2);
 895             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 896             mkfile(arg3,buf);
 897             sts = NkfFileConvert2SafeA(arg3,strlen(arg3) + 1,arg4,strlen(arg4) + 1);
 898             printf("NkfFileConvert2SafeA(%s,%s)=%d\n",arg3,arg4,sts);
 899             dumpf(arg3);
 900             dumpf(arg4);
 901             sts = SetNkfOption(arg2);
 902             printf("SetNkfOption(%s)=%d\n",arg2,sts);
 903             mkfile(arg3,buf);
 904             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg3,-1,(wchar_t *)buff,sizeof(buff) / sizeof(wchar_t));
 905             printf("MultiByteToWideChar(%s)=%d\n",arg3,sts);
 906             dumpn(buff,(wcslen((wchar_t *)buff) + 1) * sizeof(wchar_t));
 907             sts = MultiByteToWideChar(CP_OEMCP,MB_PRECOMPOSED,arg4,-1,(wchar_t *)buff4,sizeof(buff4) / sizeof(wchar_t));
 908             printf("MultiByteToWideChar(%s)=%d\n",arg4,sts);
 909             dumpn(buff4,(wcslen((wchar_t *)buff4) + 1) * sizeof(wchar_t));
 910             sts = NkfFileConvert2SafeW((wchar_t *)buff,sizeof buff / sizeof(wchar_t) ,(wchar_t *)buff4,sizeof buff4 / sizeof(wchar_t));
 911             printf("NkfFileConvert2SafeW()=%d\n",sts);
 912             dumpf(arg3);
 913             dumpf(arg4);
 914 }
 915
 916 int main(int argc,char **argv)
 917 {
 918     struct NKFSUPPORTFUNCTIONS fnc;
 919
 920     if ( argc < 2 ) return 0;
 921     switch ( *argv[1] ) {
 922       case 'v':
 923         memset(buff,0,sizeof buff);
 924         GetNkfVersion(buff);
 925         printf("GetNkfVersion() '%s'\n",buff);
 926             sts = GetNkfVersionSafeA(buff,sizeof buff,&len);
 927             printf("GetNkfVersionSafeA()=%d len=%d '%s'\n",sts,len,buff);
 928             sts = GetNkfVersionSafeW((LPWSTR)buff,sizeof buff / sizeof(WCHAR),&len);
 929             printf("GetNkfVersionSafeW()=%d len=%d\n",sts,len);
 930             dumpn(buff,len * sizeof(WCHAR));
 931             sts = GetNkfSupportFunctions(&fnc,sizeof fnc,&len);
 932             printf("GetNkfSupportFunctions()=%d len=%d\n",sts,len);
 933             printf("size=%d\n",fnc.size);
 934             printf("copyrightA='%s'\n",fnc.copyrightA);
 935             printf("versionA='%s'\n",fnc.versionA);
 936             printf("dateA='%s'\n",fnc.dateA);
 937             printf("functions=%d %x\n",fnc.functions,fnc.functions);
 938         break;
 939       case 'm':
 940         if ( argc < 3 ) return 0;
 941         mimeencode(argv[2]);
 942         break;
 943       case 'M':
 944         if ( argc < 2 ) return 0;
 945         gets(buff2);
 946         mimeencode(buff2);
 947         break;
 948       case 'c':
 949         if ( argc < 4 ) return 0;
 950         convert(argv[2],argv[3]);
 951         break;
 952       case 'C':
 953         if ( argc < 3 ) return 0;
 954         gets(buff2);
 955         convert(argv[2],buff2);
 956         break;
 957       case 'g':
 958         if ( argc < 3 ) return 0;
 959         guess(argv[2]);
 960         break;
 961       case 'G':
 962         if ( argc < 2 ) return 0;
 963         gets(buff2);
 964         guess(buff2);
 965         break;
 966       case 'f':
 967         if ( argc < 5 ) return 0;
 968         file(argv[2],argv[3],argv[4]);
 969         break;
 970       case 'F':
 971         if ( argc < 4 ) return 0;
 972         gets(buff3);
 973         file(argv[2],argv[3],buff3);
 974         break;
 975       case '2':
 976         if ( argc < 6 ) return 0;
 977         file2(argv[2],argv[3],argv[4],argv[5]);
 978         break;
 979       case '#':
 980         if ( argc < 5 ) return 0;
 981         gets(buff3);
 982         file2(argv[2],argv[3],argv[4],buff3);
 983         break;
 984       case 'u':
 985         sts = NkfUsage(buff,sizeof buff,&len);
 986         printf("strlen(buff)=%d\n",strlen(buff));
 987         printf("NkfUsage()=%d len=%d \n%s",sts,len,buff);
 988         break;
 989     }
 990     return 0;
 991 }
 992 /* dbg.exe end */
 993 #endif /* DLLDBG @@*/
 994 /*WIN32DLL*/