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