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

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

Windows Mobile

开发平台：

Visual C++

TextParser.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: TextParser.cpp,v 1.53.2.4 2003/10/21 23:26:24 mike Exp $
  29.  * 
  30.  */
  32. #include <afxtempl.h>
  33. #include <afxcmn.h>
  35. #include "TextParser.h"
  36. #include "XMLParser.h"
  37. #include "Unicode.h"
  38. #include "FastArray.h"
  39. #include "Image.h"
  41. #ifdef _DEBUG
  42. #undef THIS_FILE
  43. static char THIS_FILE[]=__FILE__;
  44. #define new DEBUG_NEW
  45. #endif
  47. struct Para { // paragraph reference
  48.   DWORD     off; // offset into file
  49.   DWORD     start; // start of parsed para
  50.   DWORD     rlen; // raw length
  51. };
  53. typedef FastArray<Para> PArray;
  55. struct SimpleFormat {
  56.   const TCHAR *name;
  57.   DWORD mask,cmp;
  58. };
  60. #define MAXPLEN 4096
  62. // soft hyphen
  63. #define SHY 0x00AD
  65. // Moshkov's formatting
  66. #define STARTBOLD 20
  67. #define ENDBOLD 21
  69. // formats list
  70. static SimpleFormat g_simple_formats[]={
  71.   { _T("Line per paragraph"), 0xff, 0x0a },
  72.   { _T("Indented first line"), 0xffff, 0x0a20 },
  73.   { _T("MAC Line per paragraph"), 0xff, 0x0d },
  74.   { _T("MAC Indented first line"), 0xffff, 0x0d20 }
  75. };
  76. #define NUM_SIMPLE_FORMATS  (sizeof(g_simple_formats)/sizeof(g_simple_formats[0]))
  78. static const TCHAR *g_ext_formats[]={
  79.   _T("XML"),
  80.   _T("PNG"),
  81.   _T("JPEG")
  82. };
  83. #define NUM_EXT_FORMATS  (sizeof(g_ext_formats)/sizeof(g_ext_formats[0]))
  85. #define XML_FORMAT  (NUM_SIMPLE_FORMATS)
  86. #define PNG_FORMAT  (NUM_SIMPLE_FORMATS+1)
  87. #define JPEG_FORMAT  (NUM_SIMPLE_FORMATS+2)
  89. TextParser::~TextParser() {
  90.   if (m_heap)
  91.     HeapDestroy(m_heap);
  92. }
  94. class SimpleTextParser : public TextParser {
  95. protected:
  96.   PArray m_pp; // paragraph list
  97.   SimpleFormat *m_sf;
  99.   void     GenericFileParse(CBufFile *fp,PArray& pp,DWORD mask,DWORD cmp);
  100.   Paragraph GenericBufParse(CBufFile *fp,const Para& p,int len);
  101. public:
  102.   SimpleTextParser(Meter *m,CBufFile *fp,HANDLE heap,int format,int encoding,Bookmarks *bmk) :
  103.       TextParser(m,fp,heap,bmk), m_sf(&g_simple_formats[format]), m_pp(heap)
  104.   {
  105.     m_format=format;
  106.     m_encoding=encoding;
  107.     if (m_encoding<0) {
  108.       char    tmp[1024];
  109.       DWORD   sp=m_fp->pos();
  110.       int nb=m_fp->read(tmp,sizeof(tmp));
  111.       m_encoding=Unicode::DetectCodePage(tmp,nb);
  112.   m_fp->seek(sp);
  113.     }
  114.     GenericFileParse(m_fp,m_pp,m_sf->mask,m_sf->cmp);
  115.     if (bmk) {
  116.       for (int i=0;i<Length(0)-1;++i)
  117. if ((i==0 || GetPLength(0,i-1)==0) && GetPLength(0,i+1)==0 &&
  118.     GetPLength(0,i)>0 && GetPLength(0,i)<90)
  119.   bmk->AddTocEnt(i,1,0,FilePos(i,0,0),0);
  120.     }
  121.   }
  123.   // paragraphs
  124.   virtual int Length(int docid) { return m_pp.GetSize()-1; } // in paragraphs
  125.   virtual Paragraph GetParagraph(int docid,int para) {
  126.     if (para>=0 && para<m_pp.GetSize()-1)
  127.       return GenericBufParse(m_fp,m_pp[para],m_pp[para+1].start-m_pp[para].start);
  128.     return Paragraph();
  129.   }
  130.   virtual int GetPLength(int docid,int para) {
  131.     if (para<0 || para>=m_pp.GetSize()-1)
  132.       return 0;
  133.     return m_pp[para+1].start-m_pp[para].start;
  134.   }
  135.   virtual int GetPStart(int docid,int para) {
  136.     if (para<0)
  137.       return 0;
  138.     if (para>=m_pp.GetSize()-1)
  139.       return m_pp[m_pp.GetSize()-1].start;
  140.     return m_pp[para].start;
  141.   }
  142.   virtual int GetTotalLength(int docid) {
  143.     return m_pp[m_pp.GetSize()-1].start;
  144.   }
  145.   virtual int LookupParagraph(int docid,int charpos);
  146. };
  148. int   SimpleTextParser::LookupParagraph(int docid,int charpos) {
  149.   if (charpos<0 || charpos>(int)m_pp[m_pp.GetSize()-1].start)
  150.     return 0;
  151.   if (charpos==(int)m_pp[m_pp.GetSize()-1].start)
  152.     return m_pp.GetSize()-1;
  153.   int i=0,j=m_pp.GetSize()-1;
  154.   while (i<=j) {
  155.     int   m=(i+j)>>1;
  156.     if (charpos<(int)m_pp[m].start)
  157.       j=m-1;
  158.     else if (charpos>=(int)m_pp[m+1].start)
  159.       i=m+1;
  160.     else
  161.       return m;
  162.   }
  163.   return 0;
  164. }
  166. #define RSPACE(x)   ((x)<=32)
  167. #define SPACE(x)    (RSPACE(x) || (x)==SHY)
  169. static void Addpara(int enc,PArray& pp,Buffer<char>& b,
  170.     int& parsed_start,int len,DWORD start)
  171. {
  172.   // convert to unicode
  173.   int     wclen=Unicode::WCLength(enc,b,len);
  174.   Buffer<wchar_t>   wb(wclen);
  175.   Unicode::ToWC(enc,b,len,wb,wclen);
  176.   // now count length
  177.   int     i,plen=0;
  178.   // skip leading spaces
  179.   for (i=0;i<wclen && SPACE(wb[i]);++i);
  180.   // count length
  181.   while (i<wclen) {
  182.     // word
  183.     while (i<wclen && !RSPACE(wb[i])) {
  184.       if (wb[i]!=SHY)
  185. ++plen;
  186.       ++i;
  187.     }
  188.     // spaces
  189.     while (i<wclen && SPACE(wb[i]))
  190.       ++i;
  191.     if (i<wclen) // this was not trailing space
  192.       ++plen;
  193.   }
  194.   Para p;
  195.   p.start=parsed_start;
  196.   p.rlen=len;
  197.   p.off=start;
  198.   pp.Add(p);
  199.   parsed_start+=plen;
  200. }
  202. void   SimpleTextParser::GenericFileParse(CBufFile *fp,PArray& pp,DWORD mask,DWORD cmp) {
  203.   int   ch;
  204.   DWORD   hist=0;
  205.   Buffer<char>   b(MAXPLEN);
  206.   int   rlen=0;
  207.   DWORD   start=fp->pos();
  208.   int   parsed_start=0;
  209.   for (;;) {
  210.     if ((ch=fp->ch())==BEOF) {
  211.       Addpara(m_encoding,pp,b,parsed_start,rlen,start);
  212.       break;
  213.     }
  214.     hist=hist<<8|ch;
  215.     if ((hist&0xffff)==0x0a0a || hist==0x0d0a0d0a || (hist&0xffff)==0x0d0d ||
  216. (hist&mask)==cmp || rlen>=MAXPLEN)
  217.     {
  218.       bool f=rlen>=MAXPLEN;
  219.       ProgSetCur(fp->pos());
  220.       Addpara(m_encoding,pp,b,parsed_start,rlen,start);
  221.       rlen=0;
  222.       start=m_fp->pos();
  223.       if (f)
  224. b[rlen++]=ch;
  225.     } else
  226.       b[rlen++]=ch;
  227.   }
  228.   Para p;
  229.   p.off=0;
  230.   p.rlen=0;
  231.   p.start=parsed_start;
  232.   pp.Add(p);
  233. }
  235. // generic buffer parser for all simple formats
  236. Paragraph  SimpleTextParser::GenericBufParse(CBufFile *fp,const Para& p,int len) {
  238.   if (!len)
  239.     return Paragraph();
  241.   // read entire buffer
  242.   Buffer<char>   mbbuf(p.rlen);
  243.   fp->seek(p.off);
  244.   int   nread=fp->read(mbbuf,p.rlen);
  245.   ASSERT(nread==(int)p.rlen);
  246.   // convert to unicode here
  247.   int   wclen=Unicode::WCLength(m_encoding,mbbuf,nread);
  248.   Buffer<wchar_t> wcbuf(wclen);
  249.   Unicode::ToWC(m_encoding,mbbuf,nread,wcbuf,wclen);
  250.   // strip whitespace and soft hyphens
  251.   Paragraph   ret(len);
  252.   wchar_t   *bp=ret.str;
  253.   Attr   *cfp=ret.cflags;
  254.   Attr   fmt;
  255.   int   count=0;
  256.   int   i;
  258.   ret.cflags.Zero();
  259.   fmt.wa=0;
  260.   // skip leading spaces
  261.   for (i=0;i<wclen && SPACE(wcbuf[i]);++i);
  262.   // copy text
  263.   while (i<wclen && count<len) {
  264.     // copy word
  265.     while (i<wclen && count<len && !RSPACE(wcbuf[i])) {
  266.       if (wcbuf[i]!=SHY)
  267. bp[count++]=wcbuf[i];
  268.       else { // handle hyphenation
  269. // XXX
  270.       }
  271.       ++i;
  272.     }
  273.     // skip spaces
  274.     while (i<wclen && SPACE(wcbuf[i]))
  275.       ++i;
  276.     if (i<wclen && count<len) // not a trailing space
  277.       bp[count++]=' ';
  278.   }
  279.   ASSERT(len==count);
  280.   //p.len=count; // update paragraph length
  281.   ret.str.setsize(len);
  282.   ret.len=len;
  283.   ret.findent=3; // XXX
  284.   return ret;
  285. }
  287. // XXX depends on the order of records in g_simple_formats
  288. int TextParser::DetectFormat(CBufFile *fp) {
  289.   int lines,ws,chars,check=_T('n'),base=0;
  290.   Buffer<BYTE> buf(2048);
  291.   int nb;
  293.   fp->seek(0);
  294.   nb=fp->read(buf,2048);
  295.   /* check if this is some sort of xml */
  296.   if (nb>8 && (memcmp("<?xml",buf,5)==0 || memcmp("xefxbbxbf<?xml",buf,8)==0))
  297.     return XML_FORMAT;
  298.   /* check for png */
  299.   if (nb>=4 && memcmp("x89PNG",buf,4)==0)
  300.     return PNG_FORMAT;
  301.   /* check for jpeg */
  302.   if (nb>=10 && buf[0]==0xff && buf[1]==0xd8 &&
  303.       (memcmp("JFIF",buf+6,4)==0 || memcmp("Exif",buf+6,4)==0))
  304.     return JPEG_FORMAT;
  305.   /* check if this is macintosh crap with their CR madness */
  306.   for (chars=0;chars<nb;++chars) {
  307.     if (buf[chars]=='n')
  308.       goto ok;
  309.   }
  310.   check='r';
  311.   base=2;
  312. ok:
  313.   /* we read first 50 lines and if more than 3 of them start with spaces,
  314.   and there are no lines longer than 80 chars, then this a spaced format */
  315.   int n=0;
  316.   for (lines=ws=0;lines<50;++lines) {
  317.     for (chars=0;;++chars) {
  318.       if (n>=nb) {
  319. ++lines;
  320. goto done;
  321.       }
  322.       int     ch=buf[n++];
  323.       if (chars==0 && ch==_T(' '))
  324. ++ws;
  325.       if (ch==check)
  326. break;
  327.     }
  328.     if (chars>80 && lines>5) /* got a long line, but after the first five */
  329.       return base;
  330.   }
  331. done:
  332.   if (lines>10 && ws>3)
  333.     return base+1;
  334.   return base;
  335. }
  337. int TextParser::GetNumFormats() {
  338.   return NUM_SIMPLE_FORMATS+1;
  339. }
  341. const TCHAR *TextParser::GetFormatName(int format) {
  342.   if (format<0 || format>=NUM_SIMPLE_FORMATS+NUM_EXT_FORMATS)
  343.     return _T("Invalid format ID");
  344.   if (format>=NUM_SIMPLE_FORMATS)
  345.     return g_ext_formats[format-NUM_SIMPLE_FORMATS];
  346.   return g_simple_formats[format].name;
  347. }
  349. /* Image parser */
  350. class ImageParser : public TextParser, public ImageLoader::BinReader {
  351. protected:
  352.   Image   m_cache;
  353.   int   m_crot,m_cmaxw,m_cmaxh;
  354. public:
  355.   ImageParser(Meter *m,CBufFile *fp,HANDLE heap,int format,int encoding,Bookmarks *bmk) :
  356.       TextParser(m,fp,heap,bmk)
  357.   {
  358.     m_format=format;
  359.     m_encoding=encoding;
  360.     m_cache.hBmp=0;
  361.   }
  362.   ~ImageParser() {
  363.     if (m_cache.hBmp)
  364.       DeleteObject(m_cache.hBmp);
  365.   }
  367.   // paragraphs
  368.   virtual int Length(int docid) { return 1; } // in paragraphs
  369.   virtual Paragraph GetParagraph(int docid,int para);
  370.   virtual int GetPLength(int docid,int para) { return para==0 ? 32 : 0; }
  371.   virtual int GetPStart(int docid,int para) { return 0; }
  372.   virtual int GetTotalLength(int docid) { return 32; }
  373.   virtual int LookupParagraph(int docid,int charpos) { return 0; }
  375.   // images
  376.   virtual bool GetImage(const wchar_t *name,HDC hDC,
  377.   int maxwidth,int maxheight,int rotation,Image& img);
  378.   virtual void InvalidateImageCache() {
  379.     if (m_cache.hBmp) {
  380.       DeleteObject(m_cache.hBmp);
  381.       m_cache.hBmp=0;
  382.     }
  383.   }
  384.   virtual bool IsImage() { return true; }
  386.   // BinReader interface
  387.   virtual int Read(void *buffer,int count) {
  388.     return m_fp->read(buffer,count);
  389.   }
  390. };
  392. Paragraph ImageParser::GetParagraph(int docid,int para) {
  393.   if (para!=0)
  394.     return Paragraph();
  395.   Paragraph p(ImageLoader::IMAGE_VSIZE);
  396.   p.lindent=p.rindent=p.findent=0;
  397.   for (int i=0;i<ImageLoader::IMAGE_VSIZE;++i) {
  398.     p.str[i]=L' ';
  399.     p.cflags[i].wa=0;
  400.   }
  401.   // abuse links for image href
  402.   p.links=Buffer<Paragraph::Link>(1);
  403.   p.links[0].off=0;
  404.   p.links[0].len=ImageLoader::IMAGE_VSIZE;
  405.   p.links[0].target=L"1";
  406.   p.flags=Paragraph::image;
  407.   return p;
  408. }
  410. bool ImageParser::GetImage(const wchar_t *name,HDC hDC,
  411.   int maxwidth,int maxheight,int rotation,Image& img)
  412. {
  413.   if (!name || wcscmp(name,L"1"))
  414.     return false;
  415.   if (m_cache.hBmp &&
  416.       (m_cmaxw==maxwidth || (m_cache.width<m_cmaxw && m_cache.width<maxwidth)) &&
  417.       (m_cmaxh==maxheight || (m_cache.height<m_cmaxh && m_cache.height<maxheight)) &&
  418.       m_crot==rotation)
  419.   {
  420.     img=m_cache;
  421.     return true;
  422.   }
  423.   if (m_cache.hBmp) {
  424.     DeleteObject(m_cache.hBmp);
  425.     m_cache.hBmp=0;
  426.   }
  427.   m_fp->seek(0);
  428.   bool ret=ImageLoader::Load(hDC,
  429.     m_format==PNG_FORMAT ? L"image/png" : L"image/jpeg",
  430.     this,maxwidth,maxheight,rotation,
  431.     m_cache.hBmp,m_cache.width,m_cache.height);
  432.   if (ret) {
  433.     img=m_cache;
  434.     m_crot=rotation;
  435.     m_cmaxh=maxheight;
  436.     m_cmaxw=maxwidth;
  437.   } else
  438.     m_cache.hBmp=0;
  439.   return ret;
  440. }
  443. TextParser *TextParser::Create(Meter *m,CBufFile *fp,int format,int encoding,Bookmarks *bmk) {
  444.   if (format<0)
  445.     return NULL;
  446.   HANDLE    heap;
  448.   heap=HeapCreate(HEAP_NO_SERIALIZE,1048576*4,0); // reserve up to 4 megs of ram
  449.   if (!heap)
  450.     return NULL;
  451.   TRY {
  452.     if (format<NUM_SIMPLE_FORMATS) {
  453.       fp->seek(0);
  454.       return new SimpleTextParser(m,fp,heap,format,encoding,bmk);
  455.     } else if (format==XML_FORMAT) { /* XML */
  456.       XMLParser *p=XMLParser::MakeParser(m,fp,bmk,heap);
  457.       p->m_format=NUM_SIMPLE_FORMATS;
  458.       if (p->ParseFile(encoding))
  459. return p;
  460.       delete p;
  461.     } else if (format==PNG_FORMAT || format==JPEG_FORMAT) { /* Images */
  462.       return new ImageParser(m,fp,heap,format,encoding,bmk);
  463.     }
  464.   } CATCH_ALL(e) {
  465.     HeapDestroy(heap);
  466.     THROW_LAST();
  467.   }
  468.   END_CATCH_ALL
  469.   return NULL;
  470. }
  472. // hyphenation code by Mark Lipsman, modified my Mike
  474. static BYTE   vlist[0x92]={
  475. //0 1 2 3 4 5 6 7 8 9 a b c d e f
  476.   0,1,0,0,1,0,1,1,0,0,0,0,0,0,1,0, // 0x400-0x40f
  477.   1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0, // 0x410-0x41f
  478.   0,0,0,1,0,0,0,0,0,0,2,1,3,1,1,1, // 0x420-0x42f
  479.   1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0, // 0x430-0x43f
  480.   0,0,0,1,0,0,0,0,0,0,2,1,3,1,1,1, // 0x440-0x44f
  481.   0,1,0,0,1,0,1,1,0,0,0,0,0,0,1,0, // 0x450-0x45f
  482. };
  484. #define isLetter(ch) ((ch)>=0x0401 && (ch)<=0x0491)
  485. #define isVowel(ch) (vlist[(ch)-0x400]==1)
  486. #define isHardSign(ch) (vlist[(ch)-0x400]==2) 
  487. #define isSoftSign(ch) (vlist[(ch)-0x400]==3)
  488. #define isConsonant(ch) (vlist[(ch)-0x400]==0)
  490. void  Paragraph::Hyphenate() {
  491.   if (flags&hypdone)
  492.     return;
  493.   flags|=hypdone;
  495.   DWORD len=str.size();
  496.   if (!len)
  497.     return;
  498.   const wchar_t *s=str;
  499.   Attr *a=cflags;
  500.   DWORD start,end,i,j;
  502.   for (start=0;start<len;) {
  503.     // find start of word
  504.     while (start<len && !isLetter(s[start]))
  505.       ++start;
  506.     // find end of word
  507.     for (end=start+1;end<len && isLetter(s[end]);++end) ;
  508.     // now look over word, placing hyphens
  509.     if (end-start>3) // word must be long enough
  510.       for (i=start;i<end-3;++i)
  511. if (isVowel(s[i]))
  512.   for (j=i+1;j<end;++j)
  513.     if (isVowel(s[j])) {
  514.       if (isConsonant(s[i+1]) && isConsonant(s[i+2]))
  515. ++i;
  516.       else if (isConsonant(s[i+1]) && 
  517. (isHardSign(s[i+2]) || isSoftSign(s[i+2])))
  518. i+=2;
  519.       if (i-start>1 && end-i>2)
  520. a[i+1].hyphen=true;
  521.       break;
  522.     }
  523.     start=end;
  524.   }
  525. }