开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Windows Mobile > 查看源码
mkdict.c
资源名称：TextViewNG.rar　[点击查看]
上传用户：hmc_gdtv
上传日期：2013-08-04
资源大小：798k
文件大小：23k
源码类别：

Windows Mobile

开发平台：

Visual C++

mkdict.c：源码内容
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <locale.h>
  4. #include <tchar.h>
  6. #include "zlib.h"
  8. #define BLOCK 65536
  10. // global stuff
  11. const TCHAR *progname;
  12. int src_codepage_num;
  13. int src_locale_num;
  14. int dest_codepage_num;
  15. UINT src_cp;
  16. LCID src_lcid;
  17. UINT dest_cp;
  18. int decode;
  20. // memory allocation
  21. void nomem(void) {
  22.   _ftprintf(stderr,_T("%s: Out of memory!n"),progname);
  23.   exit(1);
  24. }
  26. void *xmalloc(size_t size) {
  27.   void *p=malloc(size);
  28.   if (p==NULL)
  29.     nomem();
  30.   return p;
  31. }
  33. void *xrealloc(void *m,size_t size) {
  34.   void *p=realloc(m,size);
  35.   if (size>0 && p==NULL)
  36.     nomem();
  37.   return p;
  38. }
  40. TCHAR *xstrdup(const TCHAR *s) {
  41.   TCHAR *n=_tcsdup(s);
  42.   if (n==NULL)
  43.     nomem();
  44.   return n;
  45. }
  47. // error handling
  48. void  syserror(const TCHAR *msg) {
  49.   DWORD   code=GetLastError();
  50.   LPTSTR  *errmsg;
  51.   if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
  52.       NULL,code,0,(LPTSTR)&errmsg,0,NULL))
  53.     _ftprintf(stderr,_T("%s: %s: %sn"),progname,msg,errmsg);
  54.   else
  55.     _ftprintf(stderr,_T("%s: %s: %sn"),progname,msg,_T("Unknown error"));
  56.   exit(1);
  57. }
  59. void  liberr(const TCHAR *msg) {
  60.   _ftprintf(stderr,
  61. #ifdef UNICODE
  62.       _T("%s: %s: %S"),
  63. #else
  64.       _T("%s: %s: %s"),
  65. #endif
  66.       progname,msg,strerror(errno));
  67.   exit(1);
  68. }
  70. TCHAR *tchar(const char *s) {
  71. #ifdef UNICODE
  72.   int srclen=strlen(s);
  73.   int wclen;
  74.   TCHAR *ws;
  75.   if (!srclen)
  76.     return xstrdup(_T(""));
  77.   wclen=MultiByteToWideChar(CP_OEMCP,0,s,srclen,NULL,0);
  78.   if (wclen==0)
  79.     syserror(_T("Can't convert string"));
  80.   ws=xmalloc((wclen+1)*sizeof(TCHAR));
  81.   MultiByteToWideChar(CP_OEMCP,0,s,srclen,ws,wclen);
  82.   ws[wclen]='';
  83.   return ws;
  84. #else
  85.   return xstrdup(s);
  86. #endif
  87. }
  89. // custom getopt
  90. int   xgetopt(int *argc,char ***argv,const char *ospec,
  91.       const char **state,const char **arg)
  92. {
  93.   const char   *cp;
  94.   char   opt;
  96.   if (!*state || !(*state)[0]) { // look a the next arg
  97.     if (!*argc || !(*argv)[0] || (*argv)[0][0]!='-') // no more options
  98.       return 0;
  99.     if (!(*argv)[0][1]) // a lone '-', treat as an end of list
  100.       return 0;
  101.     if ((*argv)[0][1]=='-') { // '--', ignore rest of text and stop
  102.       --*argc; ++*argv;
  103.       return 0;
  104.     }
  105.     *state=(*argv)[0]+1;
  106.     --*argc;
  107.     ++*argv;
  108.   }
  109.   // we are in a middle of an arg
  110.   opt=*(*state)++;
  111.   for (cp=ospec;*cp;++cp) {
  112.     if (*cp==opt)
  113.       goto found;
  114.     if (cp[1]==':')
  115.       ++cp;
  116.   }
  117.   _ftprintf(stderr,_T("%s: Invalid option: '%c'n"),progname,opt);
  118.   exit(1);
  119. found:
  120.   if (cp[1]==':') { // option requires an argument
  121.     if (**state) { // use rest of string
  122.       *arg=*state;
  123.       *state=NULL;
  124.       return (unsigned char)opt;
  125.     }
  126.     // use next arg if available
  127.     if (*argc) {
  128.       *arg=(*argv)[0];
  129.       --*argc;
  130.       ++*argv;
  131.       return (unsigned char)opt;
  132.     }
  133.     // barf about missing args
  134.     _ftprintf(stderr,_T("%s: Option '%c' requires an argumentn"),progname,opt);
  135.     exit(1);
  136.   }
  137.   // just return current option
  138.   return (unsigned char)opt;
  139. }
  141. // hexdump
  142. void  hexdump(const wchar_t *str) {
  143.   int len=wcslen(str);
  144.   int i;
  146.   while (len>0) {
  147.     printf("  ");
  148.     for (i=0;i<8 && len>0;--i,--len,++str)
  149.       printf("%04x ",*str);
  150.     printf("n");
  151.   }
  152. }
  154. // generic arrays support
  155. void   growarray(void **arr,int itemsize,int *maxitems) {
  156.   int mi=*maxitems;
  158.   mi+=mi ? (mi>8192 ? 8192 : mi) : 32;
  159.   *arr=xrealloc(*arr,mi*itemsize);
  160.   *maxitems=mi;
  161. }
  163. #define CHECKADD(ptr,cur,max) do { 
  164. if ((cur)>=(max)) 
  165.   growarray((void **)&(ptr), 
  166.       sizeof((ptr)[0]),&(max)); 
  167.       } while (0)
  169. // languages support
  170. struct lang {
  171.   LCID   lcid;
  172.   TCHAR   *country;
  173.   TCHAR   *lang;
  174. };
  176. struct lang   *languages;
  177. int       curlang,maxlang;
  179. void addlang(LCID lcid,const TCHAR *country,const TCHAR *lang) {
  180.   CHECKADD(languages,curlang,maxlang);
  181.   languages[curlang].lcid=lcid;
  182.   languages[curlang].country=xstrdup(country);
  183.   languages[curlang].lang=xstrdup(lang);
  184.   ++curlang;
  185. }
  187. BOOL CALLBACK EnumLocalesProc(LPTSTR name) {
  188.   LCID     lcid;
  189.   TCHAR     country[1024],lang[1024];
  190.   int     ret;
  192.   if (_stscanf(name,_T("%x"),&lcid)==1) {
  193.     ret=GetLocaleInfo(lcid,LOCALE_SENGCOUNTRY,country,sizeof(country)/sizeof(TCHAR)-1);
  194.     if (ret==0)
  195.       return TRUE;
  196.     country[ret]='';
  197.     ret=GetLocaleInfo(lcid,LOCALE_SENGLANGUAGE,lang,sizeof(lang)/sizeof(TCHAR));
  198.     lang[ret]='';
  199.     addlang(lcid,country,lang);
  200.   }
  201.   return TRUE;
  202. }
  204. int   langcmp(const void *v1,const void *v2) {
  205.   const struct lang *l1=v1;
  206.   const struct lang *l2=v2;
  207.   int     val;
  209.   val=_tcsicmp(l1->lang,l2->lang);
  210.   if (val==0)
  211.     val=_tcsicmp(l1->country,l2->country);
  212.   return val;
  213. }
  215. int   langcmp_lcid(const void *v1,const void *v2) {
  216.   const struct lang *l1=v1;
  217.   const struct lang *l2=v2;
  218.   int     val;
  220.   val=_tcsicmp(l1->lang,l2->lang);
  221.   if (val==0)
  222.     val=l1->lcid<l2->lcid ? -1 : l1->lcid==l2->lcid ? 0 : 1;
  223.   return val;
  224. }
  226. #define LANGFMT1 "  %6s %-30s %-30sn"
  227. #define LANGFMT2 "  %6x %-30s %-30sn"
  229. void  showlocales(void) {
  230.   int i;
  231.   LCID deflcid;
  232.   
  233.   qsort(languages,curlang,sizeof(struct lang),langcmp);
  234.   _tprintf(_T("Installed locales:n"));
  235.   _tprintf(_T(LANGFMT1),_T("LCID"),_T("Language"),_T("Country"));
  236.   for (i=0;i<70;++i)
  237.     putc('-',stdout);
  238.   putc('n',stdout);
  239.   deflcid=GetUserDefaultLCID();
  240.   for (i=0;i<curlang;++i)
  241.     _tprintf(_T(LANGFMT2),
  242. languages[i].lcid,
  243. languages[i].lang,
  244. languages[i].country);
  245.   exit(0);
  246. }
  248. int  find_locale(const char *l) {
  249.   TCHAR   *wl=tchar(l);
  250.   LCID   id;
  251.   int   i;
  252.   TCHAR   *country;
  253.   
  254.   country=_tcschr(wl,_T('.'));
  255.   if (country)
  256.     *country++='';
  257.   for (i=0;i<curlang;++i)
  258.     if (!_tcsicmp(wl,languages[i].lang) &&
  259. (!country || !_tcsicmp(country,languages[i].country)))
  260.       goto found;
  261.   if (_stscanf(wl,_T("%x"),&id)==1)
  262.     for (i=0;i<curlang;++i)
  263.       if (languages[i].lcid==id)
  264. goto found;
  265.   _ftprintf(stderr,_T("%s: Language '%s' not found.n"),progname,wl);
  266.   exit(1);
  267. found:
  268.   free(wl);
  269.   return i;
  270. }
  272. // code pages support
  273. struct codepage {
  274.   UINT       cp;
  275.   const TCHAR *name;
  276. };
  278. struct codepage   *codepages;
  279. int   curcodepage,maxcodepage;
  281. void  addcodepage(UINT id,const TCHAR *name) {
  282.   CHECKADD(codepages,curcodepage,maxcodepage);
  283.   codepages[curcodepage].cp=id;
  284.   codepages[curcodepage].name=xstrdup(name);
  285.   ++curcodepage;
  286. }
  288. BOOL CALLBACK EnumCodePagesProc(LPTSTR name) {
  289.   UINT id;
  290.   CPINFOEX iex;
  292.   if (_stscanf(name,_T("%d"),&id)==1 && GetCPInfoEx(id,0,&iex)) {
  293.     TCHAR   *rbr,*lbr=_tcschr(iex.CodePageName,_T('('));
  294.     if (lbr) {
  295.       ++lbr;
  296.       rbr=_tcschr(lbr,_T(')'));
  297.       if (rbr)
  298. *rbr='';
  299.       else
  300. lbr=iex.CodePageName;
  301.     }
  302.     addcodepage(iex.CodePage,lbr);
  303.   }
  304.   return TRUE;
  305. }
  307. int   codepagecmp(const void *v1,const void *v2) {
  308.   const struct codepage *c1=v1;
  309.   const struct codepage *c2=v2;
  311.   return c1->cp<c2->cp ? -1 : c1->cp>c2->cp ? 1 : 0;
  312. }
  314. void  showcodepages(void) {
  315.   int i;
  317.   qsort(codepages,curcodepage,sizeof(struct codepage),codepagecmp);
  318.   _tprintf(_T("Installed code pages:n"));
  319.   for (i=0;i<curcodepage;++i)
  320.     _tprintf(_T("  %5d  %sn"),codepages[i].cp,codepages[i].name);
  321.   exit(1);
  322. }
  324. int  find_codepage(const char *cp) {
  325.   TCHAR   *wcp=tchar(cp);
  326.   UINT   ucp;
  327.   int   i;
  329.   if (sscanf(cp,"%d",&ucp)==1) { // looks like a numeric codepage
  330.     for (i=0;i<curcodepage;++i)
  331.       if (codepages[i].cp==ucp)
  332. goto found;
  333.   } else {
  334.     for (i=0;i<curcodepage;++i)
  335.       if (!_tcsicmp(wcp,codepages[i].name))
  336. goto found;
  337.   }
  338.   _ftprintf(stderr,_T("%s: Codepage '%s' not found.n"),progname,wcp);
  339.   exit(1);
  340. found:
  341.   free(wcp);
  342.   return i;
  343. }
  345. // usage
  346. void  usage(void) {
  347.   _tprintf(_T("Usage: %s [options] source destinationn")
  348.          _T("  Options:n")
  349.  _T("    -L              list available languagesn")
  350.  _T("    -C              list available code pagesn")
  351.  _T("    -l <language>   specify the language for dictionary keysn")
  352.  _T("    -c <code page>  specify source code pagen")
  353.  _T("    -o <code page>  specify output code pagen")
  354.  _T("    -d              unpack a compiled dictionaryn"),
  355.  progname
  356.       );
  357.   exit(1);
  358. }
  360. // word entry
  361. struct word {
  362.   const char   *entry; // utf8 text
  363.   int   elen; // entry length
  364.   const char   *key; // unicode sort key
  365.   int   klen; // key length
  366. };
  368. struct word   *words;
  369. int       curword,maxword;
  371. void  addword(const char *entry,int mblen,int line) {
  372.   int   wclen;
  373.   int   ulen;
  374.   wchar_t *wentry;
  375.   char   *sortkey;
  376.   char   *uentry;
  377.   int   sortkeylen;
  378.   int   i;
  380.   if (mblen==0) // ignore empty words
  381.     return;
  382.   wclen=MultiByteToWideChar(src_cp,0,entry,mblen,NULL,0);
  383.   if (wclen==0)
  384.     syserror(_T("Can't convert string to unicode"));
  385.   wentry=xmalloc((wclen+1)*sizeof(wchar_t));
  386.   MultiByteToWideChar(src_cp,0,entry,mblen,wentry,wclen);
  387.   wentry[wclen]='';
  388.   for (i=1;i<wclen-1;++i)
  389.     if (wentry[i]==' ' && wentry[i+1]==' ')
  390.       goto found;
  391.   _ftprintf(stderr,_T("%s: Invalid entry: '%s' at line %d (%d,%d)n"),progname,wentry,line,mblen,wclen);
  392.   exit(1);
  393. found:
  394.   sortkeylen=LCMapStringW(src_lcid,LCMAP_SORTKEY|NORM_IGNORECASE,
  395.       wentry,i,NULL,0);
  396.   if (sortkeylen==0)
  397.     syserror(_T("Can't get sort key"));
  398.   sortkey=xmalloc(sortkeylen);
  399.   LCMapStringW(src_lcid,LCMAP_SORTKEY|NORM_IGNORECASE,
  400.       wentry,i,(wchar_t *)sortkey,sortkeylen);
  401.   --sortkeylen; // we don't want an extra NUL byte
  402.   // replace tabs with 'n'
  403.   for (i=0;i<wclen;++i)
  404.     if (wentry[i]=='t')
  405.       wentry[i]='n';
  406.   // convert to utf8
  407.   ulen=WideCharToMultiByte(dest_cp,0,wentry,wclen,NULL,0,NULL,NULL);
  408.   if (ulen==0)
  409.     syserror(_T("Can't convert string to multibyte"));
  410.   uentry=xmalloc(ulen+1);
  411.   WideCharToMultiByte(dest_cp,0,wentry,wclen,uentry,ulen,NULL,NULL);
  412.   uentry[ulen]='';
  413.   free(wentry);
  414.   // add word
  415.   CHECKADD(words,curword,maxword);
  416.   words[curword].entry=uentry;
  417.   words[curword].elen=ulen;
  418.   words[curword].key=sortkey;
  419.   words[curword].klen=sortkeylen;
  420.   ++curword;
  421. }
  423. void  readfile(const char *filename) {
  424.   FILE   *fp;
  425.   char   inbuf[65536];
  426.   int   line=1;
  428.   _tprintf(_T("Loading... ")); fflush(stdout);
  429.   if ((fp=fopen(filename,"r"))==NULL)
  430.     liberr(_T("Can't open file"));
  431.   setvbuf(fp,NULL,_IOFBF,65536);
  432.   while (fgets(inbuf,sizeof(inbuf),fp)) {
  433.     int   len=strlen(inbuf);
  434.     while (len>0 && (inbuf[len-1]=='r' || inbuf[len-1]=='n'))
  435.       --len;
  436.     inbuf[len]='';
  437.     if (len)
  438.       addword(inbuf,len,line);
  439.     ++line;
  440.   }
  441.   fclose(fp);
  442.   _tprintf(_T("done (%d entries).n"),curword);
  443. }
  445. int   wordcmp(const void *v1,const void *v2) {
  446.   return strcmp(((const struct word *)v1)->key,((const struct word *)v2)->key);
  447. }
  449. void  sortwords(void) {
  450.   _tprintf(_T("Sorting... ")); fflush(stdout);
  451.   qsort(words,curword,sizeof(struct word),wordcmp);
  452.   _tprintf(_T("done.n"));
  453. }
  455. void  mergewords(void) {
  456.   struct word *nwords;
  457.   int nwp;
  458.   int cur,end,totlen;
  459.   char *ne,*cp;
  460.   int merged;
  462.   _tprintf(_T("Merging... ")); fflush(stdout);
  463.   nwords=xmalloc(curword*sizeof(struct word));
  464.   for (cur=nwp=merged=0;cur<curword;)
  465.     if (cur<curword-1 && !strcmp(words[cur].key,words[cur+1].key)) {
  466.       totlen=words[cur].elen+words[cur+1].elen+1;
  467.       for (end=cur+2;end<curword&&!strcmp(words[cur].key,words[end].key);++end)
  468.       {
  469. totlen+=words[end].elen;
  470. totlen++;
  471.       }
  472.       merged+=end-cur-1;
  473.       ne=xmalloc(totlen+1);
  474.       memcpy(ne,words[cur].entry,words[cur].elen);
  475.       nwords[nwp].key=words[cur].key;
  476.       nwords[nwp].klen=words[cur].klen;
  477.       nwords[nwp].elen=totlen;
  478.       nwords[nwp].entry=ne;
  479.       ++nwp;
  480.       cp=ne+words[cur].elen;
  481.       free((void*)words[cur].entry);
  482.       ++cur;
  483.       while (cur<end) {
  484. *cp++='n';
  485. memcpy(cp,words[cur].entry,words[cur].elen);
  486. cp+=words[cur].elen;
  487. free((void*)words[cur].entry);
  488. free((void*)words[cur].key);
  489. ++cur;
  490.       }
  491.       *cp='';
  492.     } else {
  493.       nwords[nwp].entry=words[cur].entry;
  494.       nwords[nwp].elen=words[cur].elen;
  495.       nwords[nwp].key=words[cur].key;
  496.       nwords[nwp].klen=words[cur].klen;
  497.       ++nwp;
  498.       ++cur;
  499.     }
  500.   free(words);
  501.   words=nwords;
  502.   maxword=curword=nwp;
  503.   _tprintf(_T("done (%d merged).n"),merged);
  504. }
  506. // blocks
  507. struct block {
  508.   int       size;
  509.   int       compressed_size;
  510.   char       *key;
  511.   int       keylen;
  512.   int       nent;
  513.   int         npara;
  514. };
  515. struct block *blocks;
  516. int curblock,maxblock;
  518. void  putblock(const char *block,int blen,int nent,FILE *fp) {
  519.   char   compressed[BLOCK];
  520.   int     res;
  521.   uLongf  dsize=sizeof(compressed);
  522.   int   docomp=0;
  523.   const char *bend;
  525.   CHECKADD(blocks,curblock,maxblock);
  526.   res=compress2((Bytef *)compressed,&dsize,(Bytef *)block,blen,9);
  527.   if (res==Z_MEM_ERROR) // don't want to compress this
  528.     fwrite(block,blen,1,fp);
  529.   else if (res==Z_OK) {
  530.     if (dsize>=(unsigned)blen) // write uncompressed
  531.       fwrite(block,blen,1,fp);
  532.     else {
  533.       docomp=1;
  534.       fwrite(compressed,dsize,1,fp);
  535.     }
  536.   } else {
  537.     _ftprintf(stderr,_T("%s: zlib error: %dn"),progname,res);
  538.     exit(1);
  539.   }
  540.   blocks[curblock].size=blen;
  541.   blocks[curblock].compressed_size=docomp ? dsize : blen;
  542.   blocks[curblock].keylen=strlen(block);
  543.   blocks[curblock].key=xmalloc(blocks[curblock].keylen+1);
  544.   memcpy(blocks[curblock].key,block,blocks[curblock].keylen+1);
  545.   blocks[curblock].nent=nent;
  546.   for (bend=block+blen;block<bend;) {
  547.     while (block<bend && *block)
  548.       ++block;
  549.     if (block<bend)
  550.       ++block;
  551.     while (block<bend && *block) {
  552.       if (*block=='n')
  553. ++nent;
  554.       ++block;
  555.     }
  556.     if (block<bend)
  557.       ++block;
  558.   }
  559.   blocks[curblock].npara=nent;
  560.   ++curblock;
  561. }
  563. void  putword(WORD w,FILE *fp) {
  564.   putc(w&0xff,fp);
  565.   putc(w>>8,fp);
  566. }
  568. void  putdword(DWORD d,FILE *fp) {
  569.   putc(d&0xff,fp);
  570.   putc((d>>8)&0xff,fp);
  571.   putc((d>>16)&0xff,fp);
  572.   putc(d>>24,fp);
  573. }
  575. DWORD  getdword(FILE *fp) {
  576.   BYTE b1,b2,b3,b4;
  577.   b1=getc(fp); b2=getc(fp); b3=getc(fp); b4=getc(fp);
  578.   return (DWORD)b4<<24|(DWORD)b3<<16|(DWORD)b2<<8|b1;
  579. }
  581. WORD  getword(FILE *fp) {
  582.   BYTE b1,b2;
  583.   b1=getc(fp); b2=getc(fp);
  584.   return (WORD)b2<<8|b1;
  585. }
  587. void  writewords(const char *filename) {
  588.   FILE   *fp;
  589.   int   i;
  590.   char   block[BLOCK];
  591.   int   blen,nent;
  592.   long   tboff,size;
  594.   _tprintf(_T("Writing... ")); fflush(stdout);
  595.   if ((fp=fopen(filename,"wb"))==NULL)
  596.     liberr(_T("Can't open file"));
  597.   setvbuf(fp,NULL,_IOFBF,65536);
  598.   // write header
  599.   fputs("DICq",fp);
  600.   putdword(src_lcid,fp); // key locale
  601.   putdword(curword,fp); // total number of entries
  602.   putdword(dest_cp,fp); // encoding
  603.   putdword(0,fp); // block table offset
  604.   // write blocks
  605.   for (i=blen=nent=0;i<curword;++i) {
  606.     if (words[i].klen+words[i].elen+2>BLOCK) {
  607.       _ftprintf(stderr,_T("%s: Entry too long.n"),progname);
  608.       exit(1);
  609.     }
  610.     if (blen+words[i].klen+1+words[i].elen+1>BLOCK) { // flush block
  611.       putblock(block,blen,nent,fp);
  612.       blen=nent=0;
  613.       if ((curblock&7)==0) {
  614. putc('.',stdout);
  615. fflush(stdout);
  616.       }
  617.     }
  618.     memcpy(block+blen,words[i].key,words[i].klen+1);
  619.     blen+=words[i].klen+1;
  620.     memcpy(block+blen,words[i].entry,words[i].elen+1);
  621.     blen+=words[i].elen+1;
  622.     ++nent;
  623.   }
  624.   if (nent>0)
  625.     putblock(block,blen,nent,fp);
  626.   tboff=ftell(fp);
  627.   // write block table
  628.   putdword(curblock,fp); // number of blocks
  629.   for (i=0;i<curblock;++i) {
  630.     putdword(blocks[i].size,fp); // uncompressed size
  631.     putdword(blocks[i].compressed_size,fp); // compressed size
  632.     putdword(blocks[i].keylen,fp); // key length
  633.     putdword(blocks[i].nent,fp); // number of words in this block
  634.     putdword(blocks[i].npara,fp); // number of "paragraphs" in this block
  635.   }
  636.   for (i=0;i<curblock;++i) // keys
  637.     fwrite(blocks[i].key,blocks[i].keylen,1,fp);
  638.   fflush(fp);
  639.   size=ftell(fp);
  640.   // write block table offset
  641.   fseek(fp,16,SEEK_SET);
  642.   putdword(tboff,fp);
  643.   fclose(fp);
  644.   _tprintf(_T(" done (%d block(s), %ld byte(s)).n"),curblock,size);
  645. }
  647. // convert string and write
  648. void  write_str(const char *s,int len,UINT srccp,UINT dstcp,FILE *fp) {
  649.   wchar_t   *wcs;
  650.   int     wclen;
  651.   char     *dcs;
  652.   int     dclen;
  653.   int     j;
  655.   if (srccp==dstcp) {
  656.     for (j=0;j<len;++j)
  657.       if (s[j]=='n')
  658. putc('t',fp);
  659.       else
  660. putc(s[j],fp);
  661.     putc('n',fp);
  662.     return;
  663.   }
  664.   if (len==0) {
  665.     putc('n',fp);
  666.     return;
  667.   }
  668.   wclen=MultiByteToWideChar(srccp,0,s,len,NULL,0);
  669.   if (wclen==0)
  670.     syserror(_T("Can't convert string"));
  671.   wcs=xmalloc(wclen*sizeof(wchar_t));
  672.   MultiByteToWideChar(srccp,0,s,len,wcs,wclen);
  673.   dclen=WideCharToMultiByte(dstcp,0,wcs,wclen,NULL,0,NULL,NULL);
  674.   if (dclen==0)
  675.     syserror(_T("Can't convert string"));
  676.   dcs=xmalloc(dclen);
  677.   WideCharToMultiByte(dstcp,0,wcs,wclen,dcs,dclen,NULL,NULL);
  678.   for (j=0;j<dclen;++j)
  679.     if (dcs[j]=='n')
  680.       dcs[j]='t';
  681.   fwrite(dcs,dclen,1,fp);
  682.   putc('n',fp);
  683.   free(wcs);
  684.   free(dcs);
  685. }
  687. // find code page names
  688. void  get_cp_name(void) {
  689.   int i;
  691.   if (src_codepage_num<0) {
  692.     CPINFOEX  iex;
  693.     if (GetCPInfoEx(src_cp,0,&iex)) {
  694.       for (i=0;i<curcodepage;++i)
  695. if (codepages[i].cp==iex.CodePage) {
  696.   src_codepage_num=i;
  697.   break;
  698. }
  699.     }
  700.   }
  701.   if (dest_codepage_num<0) {
  702.     CPINFOEX  iex;
  703.     if (GetCPInfoEx(dest_cp,0,&iex)) {
  704.       for (i=0;i<curcodepage;++i)
  705. if (codepages[i].cp==iex.CodePage) {
  706.   dest_codepage_num=i;
  707.   break;
  708. }
  709.     }
  710.   }
  711. }
  713. // find locale name
  714. void  get_locale_name(void) {
  715.   int i;
  717.   if (src_locale_num<0) {
  718.     for (i=0;i<curlang;++i)
  719.       if (src_lcid==languages[i].lcid) {
  720. src_locale_num=i;
  721. break;
  722.       }
  723.   }
  724. }
  726. // print codepage info
  727. void  print_cp_lang_info(void) {
  728.   if (src_locale_num>=0)
  729.     _tprintf(_T("Source language: %x %s.%sn"),
  730. languages[src_locale_num].lcid,languages[src_locale_num].lang,
  731. languages[src_locale_num].country);
  732.   if (src_codepage_num>=0)
  733.     _tprintf(_T("Source code page: %d %sn"),
  734. codepages[src_codepage_num].cp,codepages[src_codepage_num].name);
  735.   if (dest_codepage_num>=0)
  736.     _tprintf(_T("Output code page: %d %sn"),
  737. codepages[dest_codepage_num].cp,codepages[dest_codepage_num].name);
  738. }
  740. // decompile an existing dictionary
  741. void  decode_words(const char *ifile,const char *ofile) {
  742.   FILE   *ifp,*ofp;
  743.   char   buf[5];
  744.   int   *csizes;
  745.   int   *sizes;
  746.   long   *offs;
  747.   int   nblk;
  748.   int   totwords,nwords;
  749.   long   blocktaboff,boff;
  750.   int   i;
  751.   char   *cblk,*blk;
  752.   char   *cp,*ep,*pp;
  753.   int   mode;
  755.   if ((ifp=fopen(ifile,"rb"))==NULL)
  756.     liberr(_T("Can't open file"));
  757.   setvbuf(ifp,NULL,_IOFBF,65536);
  758.   if ((ofp=fopen(ofile,"w"))==NULL)
  759.     liberr(_T("Can't open file"));
  760.   setvbuf(ofp,NULL,_IOFBF,65536);
  761.   fread(buf,4,1,ifp);
  762.   buf[4]='';
  763.   if (strcmp(buf,"DICq")==0)
  764.     mode=0;
  765.   else if (strcmp(buf,"DICt")==0)
  766.     mode=1;
  767.   else
  768.     goto invalid;
  769.   src_lcid=getdword(ifp);
  770.   totwords=getdword(ifp);
  771.   src_cp=getdword(ifp);
  772.   if (dest_codepage_num<0)
  773.     dest_cp=src_cp;
  774.   get_cp_name();
  775.   get_locale_name();
  776.   print_cp_lang_info();
  777.   _tprintf(_T("Unpacking... ")); fflush(stdout);
  778.   blocktaboff=getdword(ifp);
  779.   fseek(ifp,blocktaboff,SEEK_SET);
  780.   nblk=getdword(ifp);
  781.   csizes=xmalloc(nblk*sizeof(int));
  782.   sizes=xmalloc(nblk*sizeof(int));
  783.   offs=xmalloc(nblk*sizeof(int));
  784.   // read block table
  785.   for (i=0,boff=20;i<nblk;++i) {
  786.     sizes[i]=getdword(ifp);
  787.     csizes[i]=getdword(ifp);
  788.     offs[i]=boff;
  789.     boff+=csizes[i];
  790.     getdword(ifp); // skip key length
  791.     getdword(ifp); // skip number of words in block
  792.     if (mode==0)
  793.       getdword(ifp); // skip number of paragraphs in block
  794.   }
  795.   // read blocks
  796.   for (i=nwords=0;i<nblk;++i) {
  797.     fseek(ifp,offs[i],SEEK_SET);
  798.     cblk=xmalloc(csizes[i]);
  799.     fread(cblk,csizes[i],1,ifp);
  800.     if (csizes[i]<sizes[i]) { // decompress
  801.       uLongf  dlen=sizes[i];
  802.       int     res;
  803.       blk=xmalloc(sizes[i]);
  804.       res=uncompress((Bytef*)blk,&dlen,(Bytef*)cblk,csizes[i]);
  805.       if (res!=Z_OK) {
  806. _ftprintf(stderr,_T("%s: zlib error: %dn"),progname,res);
  807. goto error;
  808.       }
  809.       if (dlen!=(unsigned)sizes[i])
  810. goto invalid;
  811.     } else {
  812.       blk=cblk;
  813.       cblk=NULL;
  814.     }
  815.     // write entries
  816.     for (cp=blk,ep=blk+sizes[i];cp<ep;) {
  817.       // skip key
  818.       while (cp<ep && *cp)
  819. ++cp;
  820.       if (cp<ep)
  821. pp=++cp;
  822.       // skip entry
  823.       while (cp<ep && *cp)
  824. ++cp;
  825.       if (pp!=cp)
  826. write_str(pp,cp-pp,src_cp,dest_cp,ofp);
  827.       if (cp<ep)
  828. ++cp;
  829.       ++nwords;
  830.     }
  831.     // cleanup
  832.     free(blk);
  833.     free(cblk);
  834.   }
  835.   if (nwords!=totwords)
  836.     goto invalid;
  837.   fclose(ifp);
  838.   fclose(ofp);
  839.   _tprintf(_T("done (%d entries).n"),nwords);
  840.   return;
  841. invalid:
  842.   _ftprintf(stderr,_T("%s: Invalid dictionary file.n"),progname);
  843. error:
  844.   fclose(ofp);
  845.   remove(ofile);
  846.   exit(1);
  847. }
  849. int   main(int argc,char **argv) {
  850.   char *state=NULL,*arg;
  851.   int opt;
  853.   // setup default locale
  854.   _tsetlocale(LC_ALL,_T(""));
  855.   // fetch the list of installed locales and code pages
  856.   EnumSystemLocales(EnumLocalesProc,LCID_INSTALLED|LCID_ALTERNATE_SORTS);
  857.   EnumSystemCodePages(EnumCodePagesProc,CP_INSTALLED);
  858.   qsort(languages,curlang,sizeof(struct lang),langcmp_lcid);
  859.   // set program name
  860.   if (argc>0)
  861.     progname=tchar(argv[0]);
  862.   if (progname==NULL)
  863.     progname=_T("mkdict");
  864.   // setup defaults
  865.   src_locale_num=-1;
  866.   src_lcid=GetUserDefaultLCID();
  867.   src_codepage_num=-1;
  868.   dest_codepage_num=-1;
  869.   src_cp=CP_OEMCP;
  870.   dest_cp=CP_UTF8;
  871.   // process options
  872.   if (argc<2)
  873.     usage();
  874.   --argc; ++argv; // skip program name
  875.   while ((opt=xgetopt(&argc,&argv,"LCl:c:o:d",&state,&arg)))
  876.     switch (opt) {
  877.       case 'L':
  878. showlocales();
  879. break;
  880.       case 'C':
  881. showcodepages();
  882. break;
  883.       case 'c':
  884. src_codepage_num=find_codepage(arg);
  885. src_cp=codepages[src_codepage_num].cp;
  886. if (dest_codepage_num<0) { // also set output cp
  887.   dest_codepage_num=src_codepage_num;
  888.   dest_cp=src_cp;
  889. }
  890. break;
  891.       case 'l':
  892. src_locale_num=find_locale(arg);
  893. src_lcid=languages[src_locale_num].lcid;
  894. break;
  895.       case 'o':
  896. dest_codepage_num=find_codepage(arg);
  897. dest_cp=codepages[dest_codepage_num].cp;
  898. break;
  899.       case 'd':
  900. decode=1;
  901. break;
  902.     }
  903.   if (argc<2) // at least source and destination files is required
  904.     usage();
  905.   // try to find locale and code page ids
  906.   // print locale and code page info
  907.   // do the work
  908.   if (decode) {
  909.     decode_words(argv[0],argv[1]);
  910.   } else {
  911.     get_locale_name();
  912.     get_cp_name();
  913.     print_cp_lang_info();
  914.     readfile(argv[0]);
  915.     sortwords();
  916.     mergewords();
  917.     writewords(argv[1]);
  918.   }
  919.   return 0;
  920. }