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

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

Windows Mobile

开发平台：

Visual C++

Dictionary.cpp：源码内容
  1. /*
  2.  * Copyright (c) 2001,2002,2003 Mike Matsnev.  All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice immediately at the beginning of the file, without modification,
  10.  *    this list of conditions, and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. Absolutely no warranty of function or purpose is made by the author
  15.  *    Mike Matsnev.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  * 
  28.  * $Id: Dictionary.cpp,v 1.23.2.3 2004/07/07 12:04:46 mike Exp $
  29.  * 
  30.  */
  32. #include <afx.h>
  33. #include <afxtempl.h>
  35. #include "ptr.h"
  36. #include "zlib.h"
  37. #include "Unicode.h"
  38. #include "RFile.h"
  39. #include "TextParser.h"
  40. #include "Dictionary.h"
  42. #ifdef _DEBUG
  43. #undef THIS_FILE
  44. static char THIS_FILE[]=__FILE__;
  45. #define new DEBUG_NEW
  46. #endif
  48. class Dict : public IDict
  49. {
  50. public:
  51.   Dict(RFile *fp);
  52.   ~Dict() { }
  54.   int   NumWords() { return m_numwords; }
  55.   Buffer<wchar_t> GetWordW(int index);
  56.   bool   Find(const wchar_t *word,int& index,int& found);
  57.   bool   FindImp(const wchar_t *word,int& index,int *found);
  58.   bool   Valid() { return m_ok; }
  59.   int   GetStartPofWord(int index);
  60.   int   GetWordFromP(int para);
  61.   int   GetNumP() { return m_numpara; }
  62. protected:
  63.   struct Block {
  64.     Buffer<char>  key;     /* key */
  65.     int wordidx;    /* first word index */
  66.     int numwords;   /* number of words in this block */
  67.     int size;     /* uncompressed block size */
  68.     int csize;     /* compressed size */
  69.     int off;     /* offset in the file */
  70.     int numpara;    /* number of paragraphs in this block */
  71.     int paraidx;    /* starting paragraph */
  72.   };
  74.   kilo::auto_ptr<RFile> m_rf;
  75.   DWORD m_numblk;
  76.   DWORD m_numwords;
  77.   int m_curblk;
  78.   CPtrArray m_windex; // words in current block
  79.   CPtrArray m_kindex; // keys
  80.   CUIntArray m_pindex; // paragraphs
  81.   Buffer<char> m_buffer;
  82.   CArray<Block,Block&> m_blocks;
  83.   bool m_ok;
  84.   LCID m_lcid;
  85.   UINT m_ms_codepage;
  86.   int m_codepage;
  87.   int m_numpara;
  89.   bool       GetBlk(int num);
  90.   const char  *GetWordImp(int index);
  91.   bool       OpenOld();
  92.   bool       OpenNew();
  93. };
  95. static DWORD    getdword(RFile *fp) {
  96.   BYTE   b[4];
  97.   int   rd=fp->read2(b,4);
  98.   if (rd!=4)
  99.     return 0;
  100.   return ((DWORD)b[3]<<24)|((DWORD)b[2]<<16)|((DWORD)b[1])<<8|b[0];
  101. }
  103. bool Dict::OpenNew() {
  104.   if ((m_lcid=getdword(m_rf.get()))==0)
  105.     return false;
  106.   if (!IsValidLocale(m_lcid,LCID_INSTALLED))
  107.     m_lcid=GetUserDefaultLCID();
  108.   if ((m_numwords=getdword(m_rf.get()))==0)
  109.     return false;
  110.   if ((m_ms_codepage=getdword(m_rf.get()))==0)
  111.     return false;
  112.   if ((m_codepage=Unicode::GetIntCodePage(m_ms_codepage))<0)
  113.     m_codepage=Unicode::DefaultCodePage();
  114.   DWORD btab=getdword(m_rf.get());
  115.   if (btab==0)
  116.     return false;
  117.   m_rf->seek(btab);
  118.   if ((m_numblk=getdword(m_rf.get()))==0 || m_numblk>m_numwords)
  119.     return false;
  120.   DWORD idx,i,off,maxblock,paraidx;
  121.   for (i=idx=paraidx=maxblock=0,off=20;i<(int)m_numblk;++i) {
  122.     Block   blk;
  123.     int     keylen;
  124.     if ((blk.size=getdword(m_rf.get()))==0)
  125.       return false;
  126.     if ((blk.csize=getdword(m_rf.get()))==0)
  127.       return false;
  128.     if ((keylen=getdword(m_rf.get()))==0)
  129.       return false;
  130.     if ((blk.numwords=getdword(m_rf.get()))==0)
  131.       return false;
  132.     if ((blk.numpara=getdword(m_rf.get()))==0)
  133.       return false;
  134.     blk.numpara+=blk.numwords; // append and empty line after each word
  135.     blk.wordidx=idx;
  136.     blk.paraidx=paraidx;
  137.     blk.off=off;
  138.     idx+=blk.numwords;
  139.     paraidx+=blk.numpara;
  140.     off+=blk.csize;
  141.     blk.key=Buffer<char>(keylen);
  142.     m_blocks.Add(blk);
  143.     if (blk.size>(int)maxblock)
  144.       maxblock=blk.size;
  145.   }
  146.   if (idx!=m_numwords)
  147.     return false;
  148.   m_numpara=paraidx;
  149.   for (i=0;i<(int)m_numblk;++i)
  150.     if ((m_rf->read2(m_blocks[i].key,m_blocks[i].key.size()))!=(DWORD)m_blocks[i].key.size())
  151.       return false;
  152.   m_buffer=Buffer<char>(maxblock);
  153.   return true;
  154. }
  156. Dict::Dict(RFile *fp) :
  157.   m_ok(false), m_numwords(0), m_numpara(0), m_numblk(0), m_curblk(-1), m_rf(fp)
  158. {
  159.   if (!OpenNew())
  160.       goto fail;
  161.   m_ok=true;
  162.   return;
  163. fail:
  164.   m_buffer=Buffer<char>();
  165.   m_blocks.RemoveAll();
  166. }
  168. bool  Dict::GetBlk(int num) {
  169.   if (num<0 || num>=(int)m_numblk)
  170.     return false;
  171.   if (m_curblk==num)
  172.     return true;
  173.   m_curblk=-1;
  174.   m_rf->seek(m_blocks[num].off);
  175.   if (m_blocks[num].size==m_blocks[num].csize) { // uncompressed
  176.     if (m_blocks[num].size!=(int)m_rf->read2(m_buffer,m_blocks[num].size))
  177.       return false;
  178.   } else {
  179.     Buffer<unsigned char>    in(m_blocks[num].csize);
  180.     if (m_blocks[num].csize!=(int)m_rf->read2(in,m_blocks[num].csize))
  181.       return false;
  182.     uLongf  len=m_blocks[num].size;
  183.     int ret=uncompress((unsigned char *)(char *)m_buffer,&len,
  184.       in,m_blocks[num].csize);
  185.     if (ret!=Z_OK || (int)len!=m_blocks[num].size)
  186.       return false;
  187.   }
  188.   char   *p=m_buffer;
  189.   char   *e=p+m_blocks[num].size;
  190.   int   i,pnum;
  191.   m_windex.SetSize(m_blocks[num].numwords);
  192.   m_kindex.SetSize(m_blocks[num].numwords);
  193.   m_pindex.SetSize(m_blocks[num].numwords+1);
  194.   for (i=pnum=0;i<m_blocks[num].numwords && p<e;++i) {
  195.     m_kindex[i]=p;
  196.     m_pindex[i]=pnum;
  197.     while (p<e && *p)
  198.       ++p;
  199.     if (p<e)
  200.       ++p;
  201.     m_windex[i]=p;
  202.     while (p<e && *p) {
  203.       if (*p=='n')
  204. ++pnum;
  205.       ++p;
  206.     }
  207.     if (p<e)
  208.       ++p;
  209.     pnum+=2; // implicit empty line after each word
  210.   }
  211.   if (i!=m_blocks[num].numwords || pnum!=m_blocks[num].numpara)
  212.     return false;
  213.   m_curblk=num;
  214.   m_pindex[m_blocks[num].numwords]=m_blocks[num].numpara;
  215.   return true;
  216. }
  218. Buffer<wchar_t> Dict::GetWordW(int index) {
  219.   const char  *word=GetWordImp(index);
  220.   if (!word)
  221.     return Buffer<wchar_t>();
  222.   return Unicode::ToWCbuf(m_codepage,word,strlen(word));
  223. }
  225. CString   IDict::GetWord(int index) {
  226.   CString     ret(Unicode::ToCS(GetWordW(index)));
  227.   ret.Replace(_T("n"),_T("rn"));
  228.   return ret;
  229. }
  231. const char *Dict::GetWordImp(int index) {
  232.   if (index<0 || index>=(int)m_numwords)
  233.     return NULL;
  234.   if (m_curblk<0 || index<m_blocks[m_curblk].wordidx ||
  235.       index>=m_blocks[m_curblk].wordidx+m_blocks[m_curblk].numwords)
  236.   {
  237.     int low=0;
  238.     int high=m_numblk-1;
  239.     int mid;
  240.     for (int ni=0;;++ni) {
  241.       if (ni>(int)m_numblk) // prevent loops on unsorted invalid data
  242. return NULL;
  243.       if (low>high)
  244. return NULL;
  245.       mid=(low+high)>>1;
  246.       if (index<m_blocks[mid].wordidx)
  247. high=mid-1;
  248.       else if (index>=m_blocks[mid].wordidx+m_blocks[mid].numwords)
  249. low=mid+1;
  250.       else
  251. break;
  252.     }
  253.     if (!GetBlk(mid))
  254.       return NULL;
  255.   }
  256.   return (const char *)m_windex[index-m_blocks[m_curblk].wordidx];
  257. }
  259. static int    compare_buf_str(Buffer<char>& b1,const char *b2,int l2=-1) {
  260.   if (l2<0)
  261.     l2=strlen(b2);
  262.   int res=memcmp(b1,b2,min(b1.size(),l2));
  263.   if (res==0)
  264.     res=b1.size()<l2 ? -1 : b1.size()>l2 ? 1 : 0;
  265.   return res;
  266. }
  268. static int    compare_buf_str_len(Buffer<char>& b1,const char *b2,int l2=-1) {
  269.   if (l2<0)
  270.     l2=strlen(b2);
  271.   if (l2>b1.size())
  272.     l2=b1.size();
  273.   const char *p=b1;
  274.   while (l2-->0 && *p++==*b2++) ;
  275.   return p-b1;
  276. }
  278. static inline int    compare_bufs(Buffer<char>& b1,Buffer<char>& b2) {
  279.   return compare_buf_str(b1,b2,b2.size());
  280. }
  282. bool Dict::FindImp(const wchar_t *word,int& index,int *found) {
  283.   Buffer<char>   sortkey(Unicode::SortKey(m_lcid,word));
  284.   int   low=0;
  285.   int   high=m_numblk-1;
  286.   int   mid;
  287.   for (int ni=0;;++ni) {
  288.     if (ni>(int)m_numblk) // prevent loops on unsorted data
  289.       return false;
  290.     if (low>high) {
  291.       if (low==0) {
  292. index=0;
  293. if (found) {
  294.   *found=0;
  295.   return true;
  296. }
  297.       }
  298.       return false;
  299.     }
  300.     mid=(low+high)>>1;
  301.     int cmp=compare_bufs(sortkey,m_blocks[mid].key);
  302.     if (cmp<0)
  303.       high=mid-1;
  304.     else {
  305.       if (mid==(int)m_numblk-1) // last block, stop search
  306. break;
  307.       cmp=compare_bufs(sortkey,m_blocks[mid+1].key);
  308.       if (cmp<0) // found it
  309. break;
  310.       low=mid+1;
  311.     }
  312.   }
  313.   int blk=mid;
  314.   if (!GetBlk(blk))
  315.     return false;
  316.   low=0;
  317.   high=m_blocks[blk].numwords-1;
  318.   for (int nj=0;;++nj) {
  319.     if (nj>m_blocks[blk].numwords) // prevent loops on invalid data
  320.       return false;
  321.     if (low>high) { // no such word in this block
  322.       if (!found) // shortcut
  323. return false;
  324.       int   idx=m_blocks[blk].wordidx+high;
  325.       if (idx<0)
  326. idx=0;
  327.       if (idx<(int)m_numwords-1) {
  328. if (!GetWordImp(idx))
  329.   return false;
  330. int cur=idx-m_blocks[m_curblk].wordidx;
  331. int l1=compare_buf_str_len(sortkey,(const char *)m_kindex[cur]);
  332. if (++cur>=m_blocks[m_curblk].numwords) {
  333.   if (!GetWordImp(idx+1))
  334.     return false;
  335.   cur=0;
  336. }
  337. if (compare_buf_str_len(sortkey,(const char *)m_kindex[cur])>l1)
  338.   ++idx;
  339.       }
  340.       index=idx;
  341.       *found=2;
  342.       return true;
  343.     }
  344.     mid=(low+high)>>1;
  345.     int cmp=compare_buf_str(sortkey,(const char *)m_kindex[mid]);
  346.     if (cmp<0)
  347.       high=mid-1;
  348.     else if (cmp>0)
  349.       low=mid+1;
  350.     else { // found
  351.       index=m_blocks[blk].wordidx+mid;
  352.       if (found)
  353. *found=1;
  354.       return true;
  355.     }
  356.   }
  357. }
  359. static struct {
  360.   const wchar_t   *pattern;
  361.   const wchar_t   *replacement;
  362. } endings[]={
  363.   { L"s", NULL  },
  364.   { L"se", NULL  },
  365.   { L"sei", L"y"  },
  366.   { L"de", NULL  },
  367.   { L"de", L"e"  },
  368.   { L"dei", L"y"  },
  369.   { L"de.", L"1"  },
  370.   { L"gni", NULL  },
  371.   { L"gni", L"e"  },
  372.   { L"gniy", L"ie" },
  373.   { L"gni.", L"1"  },
  374.   { L"re", NULL  },
  375.   { L"re", L"e"  },
  376.   { L"rei", L"y"  },
  377.   { L"re." L"1"  },
  378.   { L"tse", NULL  },
  379.   { L"tse", L"e"  },
  380.   { L"tsei", L"y"  },
  381.   { L"tse.", L"1"  },
  382.   { NULL, NULL  }
  383. };
  385. bool  Dict::Find(const wchar_t *word,int& index,int& found) {
  386.   if (PRIMARYLANGID(m_lcid)!=LANG_ENGLISH)
  387.     return FindImp(word,index,&found);
  388.   // handle english word endings
  389.   wchar_t tmpbuf[64];
  390.   int wordlen=wcslen(word);
  391.   if (wordlen>=sizeof(tmpbuf)/sizeof(tmpbuf[0]))
  392.     return FindImp(word,index,&found);
  393.   // check exact match
  394.   if (FindImp(word,index,NULL)) {
  395.     found=1;
  396.     return true;
  397.   }
  398.   for (int ending=0;endings[ending].pattern;++ending) {
  399.     const wchar_t   *pattern=endings[ending].pattern;
  400.     for (int i=0;i<wordlen;++i) {
  401.       if (pattern[i]==L'.') { // doubled char here
  402. if (i+1<wordlen && word[wordlen-i-1]==word[wordlen-i-2]) {
  403.   i+=2;
  404.   goto match;
  405. }
  406. break;
  407.       }
  408.       if (!pattern[i]) { // end of pattern, matched
  409. match:
  410. int   k;
  411. for (k=0;k<wordlen-i;++k)
  412.   tmpbuf[k]=word[k];
  413. const wchar_t *replacement=endings[ending].replacement;
  414. if (replacement) {
  415.   if (replacement[0]==L'1')
  416.     tmpbuf[k++]=word[wordlen-i];
  417.   else
  418.     while (*replacement)
  419.       tmpbuf[k++]=*replacement++;
  420. }
  421. tmpbuf[k++]=L'';
  422. // relookup
  423. if (FindImp(tmpbuf,index,NULL)) {
  424.   found=1;
  425.   return true;
  426. }
  427. break;
  428.       }
  429.       if (pattern[i]!=word[wordlen-i-1])
  430. break;
  431.     }
  432.   }
  433.   // still no match, proceed as usual
  434.   return FindImp(word,index,&found);
  435. }
  437. int   Dict::GetWordFromP(int para) {
  438.   if (para<0 || para>=m_numpara)
  439.     return 0;
  440.   int low=0;
  441.   int high=m_numblk-1;
  442.   int mid;
  443.   for (int ni=0;;++ni) {
  444.     if (ni>(int)m_numblk) // prevent loops on unsorted invalid data
  445.       return 0;
  446.     if (low>high)
  447.       return 0;
  448.     mid=(low+high)>>1;
  449.     if (para<m_blocks[mid].paraidx)
  450.       high=mid-1;
  451.     else if (para>=m_blocks[mid].paraidx+m_blocks[mid].numpara)
  452.       low=mid+1;
  453.     else
  454.       break;
  455.   }
  456.   if (!GetBlk(mid))
  457.     return 0;
  458.   low=0;
  459.   high=m_blocks[m_curblk].numwords;
  460.   para-=m_blocks[m_curblk].paraidx;
  461.   for (int ni=0;;++ni) {
  462.     if (ni>m_blocks[m_curblk].numwords)
  463.       return 0;
  464.     if (low>high)
  465.       return 0;
  466.     mid=(low+high)>>1;
  467.     if (para<(int)m_pindex[mid])
  468.       high=mid-1;
  469.     else if (para>=(int)m_pindex[mid+1])
  470.       low=mid+1;
  471.     else
  472.       break;
  473.   }
  474.   return m_blocks[m_curblk].wordidx+mid;
  475. }
  477. int   Dict::GetStartPofWord(int index) {
  478.   if (GetWordImp(index))
  479.     return m_blocks[m_curblk].paraidx+m_pindex[index-m_blocks[m_curblk].wordidx];
  480.   return 0;
  481. }
  483. static class SimpleDictInit: public IDict::DictInit {
  484.   static IDict *create_simple_dict(RFile *fp) { return new Dict(fp); }
  485. public:
  486.   SimpleDictInit() : DictInit("DICq",create_simple_dict) { }
  487. } g_dict_init;
  489. // create a proper dictionary
  490. IDict *IDict::Create(const CString& filename,CString *errmsg) {
  491.   kilo::auto_ptr<RFile>   fp(new RFile(filename));
  493.   if (!fp->Reopen()) {
  494.     if (errmsg)
  495.       *errmsg=FileExceptionInfo(filename,GetLastError());
  496.     return NULL;
  497.   }
  499.   BYTE   sig[SIGSIZE];
  500.   if (fp->read2(sig,SIGSIZE)!=SIGSIZE) {
  501.     if (errmsg)
  502.       errmsg->Format(_T("%s: Ivalid dictionary file"),(const TCHAR*)filename);
  503.     return NULL;
  504.   }
  505.   IDict *d=NULL;
  506.   for (DictInit *di=DictInit::m_head;di;di=di->m_next)
  507.     if (memcmp(sig,di->m_sig,SIGSIZE)==0) {
  508.       d=di->m_create(fp.release());
  509.       break;
  510.     }
  511.   if (d && d->Valid())
  512.     return d;
  513.   delete d;
  514.   if (errmsg)
  515.     errmsg->Format(_T("%s: Ivalid dictionary file"),(const TCHAR*)filename);
  516.   return NULL;
  517. }
  519. IDict::DictInit   *IDict::DictInit::m_head;
  521. IDict::DictInit::DictInit(const char *sig,IDict *(*create)(RFile *)) {
  522.   m_next=m_head;
  523.   m_create=create;
  524.   strncpy(m_sig,sig,sizeof(m_sig));
  525.   m_head=this;
  526. }
  528. Buffer<wchar_t> DictParser::GetParagraphImp(int para,bool& isfirst) {
  529.   int     ws=m_dict->GetWordFromP(para);
  530.   Buffer<wchar_t>   word(m_dict->GetWordW(ws));
  531.   int     ps=m_dict->GetStartPofWord(ws);
  533.   isfirst=ps==para;
  534.   const wchar_t     *wp=word,*we=wp+word.size();
  535.   while (ps!=para && wp<we) {
  536.     while (wp<we && *wp!=L'n')
  537.       ++wp;
  538.     if (wp<we)
  539.       ++wp;
  540.     ++ps;
  541.   }
  542.   const wchar_t     *wq=wp;
  543.   while (wq<we && *wq!=L'n')
  544.     ++wq;
  545.   return Buffer<wchar_t>(wp,wq-wp);
  546. }
  548. Paragraph DictParser::GetParagraph(int docid,int para) {
  549.   bool isfirst;
  550.   Buffer<wchar_t>   txt(GetParagraphImp(para,isfirst));
  551.   Paragraph p(txt.size());
  552.   p.str=txt;
  553.   for (int j=0;j<p.str.size() && p.str[j]==L' ';++j)
  554.     p.str[j]=0xA0; // replace leading spaces with nbsp
  555.   p.cflags.Zero();
  556.   if (isfirst)
  557.     for (int i=0;i<p.str.size()-1;++i) {
  558.       if (p.str[i]==L' ' && p.str[i+1]==L' ')
  559. break;
  560.       p.cflags[i].bold=1;
  561.     }
  563.   return p;
  564. }
  566. int   DictParser::GetPLength(int docid,int para) {
  567.   bool isfirst;
  568.   return GetParagraphImp(para,isfirst).size();
  569. }
  571. DictParser  *DictParser::OpenDict(const CString& path,CString *errmsg) {
  572.   IDict   *d=IDict::Create(path,errmsg);
  573.   if (!d)
  574.     return NULL;
  575.   return new DictParser(kilo::auto_ptr<IDict>(d));
  576. }
  578. bool  DictParser::LookupReference(const wchar_t *rname,FilePos& dest) {
  579.   int   index,found;
  580.   if (m_dict->Find(rname,index,found)) {
  581.     dest.docid=0;
  582.     dest.para=m_dict->GetStartPofWord(index);
  583.     dest.off=0;
  584.     return true;
  585.   }
  586.   return false;
  587. }