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