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

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

Windows Mobile

开发平台：

Visual C++

XMLParser.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: XMLParser.cpp,v 1.106.2.12 2004/10/13 13:50:55 mike Exp $
  29.  * 
  30.  */
  32. #include <afxwin.h>
  33. #include <afxtempl.h>
  34. #include <setjmp.h>
  36. #include "FastArray.h"
  37. #include "TextParser.h"
  38. #include "XMLParser.h"
  39. #include "TextViewNG.h"
  40. #include "Unicode.h"
  41. #include "StrBuf.h"
  42. #include "WMap.h"
  43. #include "Image.h"
  45. #include "xscanf.h"
  47. #include "expat.h"
  49. #define FB_NS   L"http://www.gribuser.ru/xml/fictionbook/2.0"
  50. #define FB_NS_LEN (sizeof(FB_NS)/sizeof(wchar_t)-1)
  51. #define XLINK_NS  L"http://www.w3.org/1999/xlink"
  52. #define HR_STYLE  L"text/css"
  54. enum {
  55.   CDATA=0x1000000,
  56.   LEADSP=0x2000000,
  57.   LOCAL=0x4000000,
  58.   REALLYLOCAL = 0x8000000,
  59.   TRAILSP = 0x10000000,
  61.   // PE flags
  62.   PE_IMAGE=0x80000000,
  63. };
  64. enum { MAX_CONTENTS_LEN=80 };
  66. enum {
  67.   ERR_NOTFB2=1
  68. };
  70. struct CFMT {
  71.   Attr   attr;
  72.   int   lindent;
  73.   int   rindent;
  74.   int   findent;
  75.   BYTE   flags;
  76. };
  78. struct CachedImage {
  79.   CachedImage       *next;
  80.   HBITMAP       hBmp;
  81.   int       width;
  82.   int       height;
  83.   int       maxwidth;
  84.   int       maxheight;
  85.   int       rotation;
  86.   const wchar_t     *name;
  87.   CachedImage() : hBmp(NULL), name(NULL), next(NULL) { }
  88.   void       Release() { if (hBmp) DeleteObject(hBmp); name=NULL; hBmp=NULL; }
  89. };
  91. class ImageCache {
  92.   CachedImage       *m_head,*m_tail;
  93.   int       m_count;
  94.   int       m_max;
  95. public:
  96.   ImageCache(int max=4) : m_head(NULL), m_tail(NULL), m_count(0), m_max(max) { }
  97.   ~ImageCache() { RemoveAll(); }
  99.   CachedImage       *Lookup(const wchar_t *name,bool& alloc);
  100.   void       Remove(CachedImage *img);
  101.   void       RemoveAll() {
  102.     while (m_head) {
  103.       CachedImage *next=m_head->next;
  104.       m_head->Release();
  105.       delete m_head;
  106.       m_head=next;
  107.     }
  108.     m_count=0;
  109.     m_head=m_tail=NULL;
  110.   }
  111. };
  113. CachedImage   *ImageCache::Lookup(const wchar_t *name,bool& alloc) {
  114.   CachedImage *img;
  116.   alloc=false;
  117.   for (img=m_head;img;img=img->next)
  118.     if (!wcscmp(name,img->name))
  119.       return img;
  121.   alloc=true;
  122.   // not found, try to allocate new
  123.   if (m_count<m_max) {
  124.     img=new CachedImage;
  125.     ++m_count;
  126.     img->name=name;
  127.     if (m_tail) {
  128.       m_tail->next=img;
  129.       m_tail=img;
  130.     } else
  131.       m_head=m_tail=img;
  132.     return img;
  133.   }
  134.   // too many entries, reuse head
  135.   ASSERT(m_head!=NULL);
  136.   img=m_head;
  137.   if (m_head!=m_tail)
  138.     m_head=m_head->next;
  139.   img->Release();
  140.   img->name=name;
  141.   img->next=NULL;
  142.   if (img!=m_tail)
  143.     m_tail->next=img;
  144.   m_tail=img;
  145.   return img;
  146. }
  148. void  ImageCache::Remove(CachedImage *img) {
  149.   img->Release();
  150.   if (img==m_head) {
  151.     m_head=m_head->next;
  152.     if (img==m_tail)
  153.       m_tail=NULL;
  154.   } else { // tough, will have to traverse the list
  155.     CachedImage *tmp=NULL;
  156.     for (tmp=m_head;tmp;tmp=tmp->next)
  157.       if (tmp->next==img)
  158. break;
  159.     tmp->next=img->next;
  160.     if (img==m_tail)
  161.       m_tail=tmp;
  162.   }
  163.   delete img;
  164.   --m_count;
  165. }
  167. class XMLParserImp: public XMLParser {
  168. public:
  170.   struct SP_State {
  171.     enum {
  172.       START,
  173.       NAME,
  174.       FLAGS,
  175.       FM,LM,RM,SIZE,COLOR
  176.     };
  177.     wchar_t stylename[128];
  178.     int stylenameptr;
  179.     ElemFmt format;
  180.     int state;
  181.     int num;
  182.     bool sign;
  183.     void Init() { stylenameptr=0; format.Clear(); state=START; }
  184.     void NAdd(wchar_t ch) {
  185.       if (stylenameptr<sizeof(stylename)/sizeof(wchar_t)-1)
  186. stylename[stylenameptr++]=ch;
  187.     }
  188.   };
  190.   struct ParseState {
  191.     enum { MAX_NEST=64 };
  192.     int len; // current len
  193.     int start;
  194.     DWORD attr;
  195.     Attr last_frag_fmt;
  196.     bool last_frag_trailsp;
  197.     bool root_element;
  198.     CFMT cfmt;
  199.     CFMT attr_stack[MAX_NEST];
  200.     int attr_stack_ptr;
  201.     int acch_lev,in_stylesheet;
  202.     int enable;
  203.     int section_nest;
  204.     int title_start;
  205.     int link_start;
  206.     const wchar_t *link_name;
  207.     int pf_start,pl_start,numfrags;
  208.     int binary;
  209.     FmtArray *styles;
  210.     WMap *stylemap;
  211.     jmp_buf jout;
  213.     void PushA() {
  214.       if (attr_stack_ptr<MAX_NEST)
  215. attr_stack[attr_stack_ptr++]=cfmt;
  216.     }
  217.     void PopA() {
  218.       if (attr_stack_ptr>0)
  219. cfmt=attr_stack[--attr_stack_ptr];
  220.     }
  221.     DWORD Att() { return attr|cfmt.attr.wa; }
  222.     void  ApplyFmt(ElemFmt *e,int nest=0);
  223.   };
  225.   struct Frag {    // smallest element - character data
  226.     union {
  227.       DWORD     fpos;    // offset into the file
  228.       const wchar_t *str;    // pointer to a cached value
  229.       wchar_t     local[2]; // cached right here
  230.     };
  231.     DWORD   len;    // raw char count
  232.     DWORD   attr;   // attributes of this run
  233.   };
  234.   struct PE { // paragraph
  235.     enum {
  236.       FRAGBITS=10,
  237.       MAXFRAGS=1<<FRAGBITS,
  238.       FRAGSHIFT=32-FRAGBITS,
  239.       IDXMASK=(1<<FRAGSHIFT)-1
  240.     };
  241.     union {
  242.       DWORD   idx_nf; // offset into m_frags
  243.       const wchar_t   *name; // on an image name
  244.     };
  245.     int   start; // start of parsed paragraph
  246.     DWORD   linkidx_nl; // offset into m_links
  247.     DWORD   indent; // left, right and first line indentation
  248.     DWORD   flags;
  250.     DWORD   nfrags() { return idx_nf>>FRAGSHIFT; }
  251.     DWORD   idx() { return idx_nf&IDXMASK; }
  253.     DWORD   nlinks() { return linkidx_nl>>FRAGSHIFT; }
  254.     DWORD   lidx() { return linkidx_nl&IDXMASK; }
  256.     DWORD   li() { return (indent>>10)&0x2ff; }
  257.     DWORD   ri() { return indent&0x2ff; }
  258.     DWORD   fi() { return (indent>>20)&0x2ff; }
  260.     void   setidx_nf(DWORD idx,DWORD nf) { idx_nf=(idx&IDXMASK)|(nf<<FRAGSHIFT); }
  261.     void   setidx_nl(DWORD idx,DWORD nf) { linkidx_nl=(idx&IDXMASK)|(nf<<FRAGSHIFT); }
  262.     void   setindent(DWORD l,DWORD r,DWORD f) { indent=((f&0x2ff)<<20)|((l&0x2ff)<<10)|(r&0x2ff); }
  263.     void   Zero() { memset(this,0,sizeof(*this)); }
  264.   };
  266.   struct Document { // subdocument
  267.     int     start; // start paragraph
  268.     int     length; // length in paragraphs
  269.     CString name;
  270.   };
  272.   struct Link {
  273.     int   start;
  274.     int   length;
  275.     const wchar_t *target;
  276.   };
  278.   struct Binary {
  279.     wchar_t       *id;
  280.     wchar_t       *type;
  281.     int       numfrags;
  282.     int       startfrag;
  283.   };
  285.   friend class Base64BinReader;
  287.   FastArray<Frag> m_frags;
  288.   FastArray<PE> m_pp;
  289.   FastArray<Link> m_links;
  290.   FastArray<Binary> m_binarystorage;
  291.   FastArray<const wchar_t *> m_inline_images;
  292.   StrBuf m_buffer;
  293.   XML_Parser m_parser;
  294.   CArray<Document,Document&> m_docs;
  295.   WMap m_references;
  296.   WMap m_binaries;
  297.   ParseState *m_ps;
  298.   SP_State *m_sps;
  299.   CString m_cover;
  300.   ImageCache m_imcache;
  302.   Paragraph GetParagraphImp(int idx);
  304.   // paragraphs
  305.   virtual Paragraph GetParagraph(int docid,int para);
  306.   virtual int Length(int docid); // in paragraphs
  307.   virtual int GetPLength(int docid,int para);
  308.   virtual int GetPStart(int docid,int para);
  309.   virtual int GetTotalLength(int docid);
  310.   virtual int LookupParagraph(int docid,int charpos);
  312.   // documents
  313.   virtual int GetSubDocCount() { return m_docs.GetSize(); }
  314.   virtual CString GetSubDocName(int docid);
  316.   // links
  317.   virtual bool LookupReference(const wchar_t *name,FilePos& dest);
  319.   // images
  320.   virtual bool GetImage(const wchar_t *name,HDC hDC,int maxwidth,
  321.     int maxheight,int rotation,Image& img);
  322.   virtual void InvalidateImageCache() { m_imcache.RemoveAll(); }
  324.   // construction and destruction
  325. XMLParserImp(Meter *m,CBufFile *fp,Bookmarks *bmk,
  326.      HANDLE heap);
  327.   virtual ~XMLParserImp();
  329.   virtual bool ParseFile(int encoding);
  331.   // paragraphs
  332.   void AddP(int pstart,int lstart,int start,int len,CFMT& fmt);
  333.   void AddImage(const wchar_t *href,int start,CFMT& fmt);
  334.   void AddQ(int start);
  335.   void AddToc(FilePos pos,int level);
  336.   void PushWS(); // check for leading spaces/format flags
  338.   // stylesheet
  339.   void ParseStylesheet(const wchar_t *text,int len);
  341.   // callbacks
  342.   void StartElement(const wchar_t *name,const wchar_t **attr);
  343.   void EndElement(const wchar_t *name);
  344.   void CharData(const wchar_t *text,int len);
  346.   // expat callacks
  347.   static void StartElementCB(void *udata,const wchar_t *name,
  348.        const wchar_t **attr);
  349.   static void EndElementCB(void *udata,const wchar_t *name);
  350.   static void CharDataCB(void *udata,const wchar_t *text,int len);
  351.   static int UnknownEncodingCB(void *data,const wchar_t *name,
  352.   XML_Encoding *info);
  353.   static void StartCDataCB(void *udata);
  354.   static void EndCDataCB(void *udata);
  356.   // binary access
  357.   ImageLoader::BinReader *OpenBinary(const wchar_t *name,const wchar_t **type,
  358.     const wchar_t **vname);
  359. };
  361. const TCHAR   *XMLParser::ElemFmt::flag_names=_T("apofestcdlqxrivbgh");
  364. XMLParserImp::XMLParserImp(Meter *m,CBufFile *fp,Bookmarks *bmk,HANDLE heap) :
  365.   XMLParser(m,fp,heap,bmk), m_parser(NULL), m_pp(heap), m_frags(heap),
  366.   m_links(heap), m_buffer(heap), m_references(heap), m_binaries(heap),
  367.   m_binarystorage(heap), m_inline_images(heap)
  368. {
  369. }
  371. XMLParserImp::~XMLParserImp() {
  372.   // destroy parser, if any
  373.   if (m_parser)
  374.     XML_ParserFree((XML_Parser)m_parser);
  375.   // destroy image cache if any
  376. }
  378. int   XMLParserImp::Length(int docid) {
  379.   return docid<0 || docid>=m_docs.GetSize() ? 0 : m_docs[docid].length;
  380. }
  382. #define   SHY 0xAD
  384. Paragraph XMLParserImp::GetParagraph(int docid,int para) {
  385.   if (docid<0 || docid>=m_docs.GetSize() ||
  386.       para<0 || para>=m_docs[docid].length)
  387.     return Paragraph();
  388.   return GetParagraphImp(m_docs[docid].start+para);
  389. }
  391. CString XMLParserImp::GetSubDocName(int docid) {
  392.   if (docid<0 || docid>=m_docs.GetSize())
  393.     return CString();
  394.   if (docid==0 && m_docs[docid].name.GetLength()==0)
  395.     return _T("Main");
  396.   return m_docs[docid].name;
  397. }
  399. static int  RClamp(int v,int min,int max) {
  400.   if (v<min)
  401.     return min;
  402.   if (v>max)
  403.     return max;
  404.   return v;
  405. }
  407. Paragraph XMLParserImp::GetParagraphImp(int idx) {
  408.   if (m_pp[idx].flags&PE_IMAGE) { // a very special case
  409.     Paragraph p(ImageLoader::IMAGE_VSIZE);
  410.     p.flags=(BYTE)m_pp[idx].flags;
  411.     p.lindent=m_pp[idx].li();
  412.     p.rindent=m_pp[idx].ri();
  413.     p.findent=m_pp[idx].fi();
  414.     for (int i=0;i<ImageLoader::IMAGE_VSIZE;++i) {
  415.       p.str[i]=L' ';
  416.       p.cflags[i].wa=0;
  417.     }
  418.     // abuse links for image href
  419.     p.links=Buffer<Paragraph::Link>(1);
  420.     p.links[0].off=0;
  421.     p.links[0].len=ImageLoader::IMAGE_VSIZE;
  422.     p.links[0].target=m_pp[idx].name;
  423.     p.flags|=Paragraph::image;
  424.     return p;
  425.   }
  426.   // here we have to read the paragraphs from file
  427.   int       len=m_pp[idx+1].start-m_pp[idx].start,np=m_pp[idx].nfrags();
  428.   int       fragbase=m_pp[idx].idx();
  429.   Paragraph   p(len);
  430.   p.flags=(BYTE)m_pp[idx].flags;
  431.   p.lindent=m_pp[idx].li();
  432.   p.rindent=m_pp[idx].ri();
  433.   p.findent=m_pp[idx].fi();
  435.   // check for inline images
  436.   int ilinks=0;
  437.   for (int ii=0;ii<np;++ii)
  438.     if (m_frags[ii+fragbase].attr & PE_IMAGE)
  439.       ++ilinks;
  441.   // add links if any
  442.   int nlinks=m_pp[idx].nlinks();
  443.   if (nlinks+ilinks) {
  444.     int       off=m_pp[idx].lidx();
  445.     Buffer<Paragraph::Link>   links(nlinks+ilinks);
  446.     for (int link=0;link<nlinks;++link) {
  447.       links[link].off=m_links[off+link].start;
  448.       links[link].len=m_links[off+link].length;
  449.       links[link].target=m_links[off+link].target;
  450.     }
  451.     p.links=links;
  452.   }
  453.   ilinks=0;
  455.   // add character data
  456.   wchar_t     *bp=p.str;
  457.   wchar_t     *be=bp+len;
  458.   wchar_t     *bs=bp;
  459.   Attr       *ap=p.cflags;
  460.   for (int f=0;f<np && bp<be;++f) {
  461.     Frag    *fp=&m_frags[f+fragbase];
  462.     // add a space if needed
  463.     if (fp->attr&LEADSP) {
  464.       *bp++=' ';
  465.       (*ap++).wa=(WORD)fp->attr;
  466.     }
  467.     if (fp->attr&PE_IMAGE) { // inline image
  468.       int     globidx=fp->local[0] | ((unsigned int)fp->local[1]<<16);
  469.       p.links[nlinks+ilinks].off=p.links[nlinks+ilinks].len=0;
  470.       p.links[nlinks+ilinks].target=m_inline_images[globidx];
  471.       if (bp<be) {
  472. *bp++=nlinks+ilinks;
  473. (*ap++).wa=(WORD)fp->attr;
  474.       }
  475.       ++ilinks;
  476.     } else if (fp->attr&(LOCAL|REALLYLOCAL)) { // cached value
  477.       const wchar_t   *wp=fp->attr & REALLYLOCAL ? fp->local : fp->str;
  478.       const wchar_t   *we=wp+fp->len;
  479.       while (bp<be && wp<we) {
  480. *bp++=*wp++;
  481. (*ap++).wa=(WORD)fp->attr;
  482.       }
  483.     } else {
  484.       Buffer<char>    buf(fp->len);
  485.       m_fp->seek(fp->fpos);
  486.       if (m_fp->read(buf,fp->len)!=(int)fp->len) {
  487. ASSERT(0);
  488. break;
  489.       }
  490.       Buffer<wchar_t> wbuf(fp->len);
  491.       char     *cp=buf;
  492.       int ul;
  493.       if (fp->attr&CDATA)
  494. ul=XML_ConvertCharacterData((XML_Parser)m_parser,&cp,fp->len,wbuf,fp->len);
  495.       else
  496. ul=XML_ParseCharacterData((XML_Parser)m_parser,&cp,fp->len,wbuf,fp->len);
  497.       if (ul<0) // xml parser returned an error
  498. break;
  499.       wchar_t     *wp=wbuf,*we=wbuf+ul;
  500.       // skip leading ws
  501.       while (wp<we && (*wp<=32 || *wp==SHY))
  502. ++wp;
  503.       goto in;
  504.       while (bp<be && wp<we) { // copy, compacting whitespace
  505. // add a space
  506. *bp++=L' ';
  507. (*ap++).wa=(WORD)fp->attr;
  508.   in:
  509. // copy non-ws
  510. while (bp<be && wp<we && *wp>32)
  511.   if (*wp==SHY) {
  512.     if (bp>bs)
  513.       ap[-1].hyphen=true;
  514.     ++wp;
  515.   } else {
  516.     *bp++=*wp++;
  517.     (*ap++).wa=(WORD)fp->attr;
  518.   }
  519. // skip over spaces
  520. while (wp<we && (*wp<=32 || *wp==SHY))
  521.   ++wp;
  522.       }
  523.     }
  524.     // add a trailing space if required
  525.     if (fp->attr&TRAILSP && bp<be) {
  526.       *bp++=L' ';
  527.       (*ap++).wa=(WORD)fp->attr;
  528.     }
  529.   }
  530.   // to avoid endless loops later, we have to pad the paragraph up to the
  531.   // advertised length
  532.   while (bp-bs<len) {
  533.     *bp++=L' ';
  534.     (*ap++).wa=0;
  535.   }
  536.   p.str.setsize(len);
  537.   p.cflags.setsize(len);
  538.   p.len=len;
  540.   p.links.setsize(nlinks+ilinks);
  542.   return p;
  543. }
  545. int   XMLParserImp::GetPStart(int docid,int para) {
  546.   if (docid<0 || docid>=m_docs.GetSize() || para<0)
  547.     return 0;
  548.   if (para>=m_docs[docid].length)
  549.     return m_pp[m_docs[docid].start+m_docs[docid].length].start;
  550.   return m_pp[m_docs[docid].start+para].start;
  551. }
  553. int   XMLParserImp::GetPLength(int docid,int para) {
  554.   if (docid<0 || docid>=m_docs.GetSize() || para<0 || para>=m_docs[docid].length)
  555.     return 0;
  556.   int idx=m_docs[docid].start+para;
  557.   return m_pp[idx+1].start-m_pp[idx].start;
  558. }
  560. int   XMLParserImp::GetTotalLength(int docid) {
  561.   if (docid<0 || docid>=m_docs.GetSize())
  562.     return 0;
  563.   return m_pp[m_docs[docid].start+m_docs[docid].length].start;
  564. }
  566. int   XMLParserImp::LookupParagraph(int docid,int charpos) {
  567.   if (docid<0 || docid>=m_docs.GetSize())
  568.     return 0;
  569.   int i=m_docs[docid].start,j=i+m_docs[docid].length;
  570.   if (charpos<0 || charpos>m_pp[j].start)
  571.     return 0;
  572.   if (charpos==m_pp[j].start)
  573.     return j-i;
  574.   --j;
  575.   while (i<=j) {
  576.     int   m=(i+j)>>1;
  577.     if (charpos<m_pp[m].start)
  578.       j=m-1;
  579.     else if (charpos>=m_pp[m+1].start)
  580.       i=m+1;
  581.     else
  582.       return m-m_docs[docid].start;
  583.   }
  584.   return 0;
  585. }
  587. bool   XMLParserImp::LookupReference(const wchar_t *name,FilePos& dest) {
  588.   void   *data;
  590.   if (!m_references.Lookup(name,data))
  591.     return false;
  592.   int   para=(int)data;
  593.   // find the docid
  594.   for (int docid=0;docid<m_docs.GetSize();++docid)
  595.     if (para>=m_docs[docid].start && para<m_docs[docid].start+m_docs[docid].length) {
  596.       dest.para=para-m_docs[docid].start;
  597.       dest.off=0;
  598.       dest.docid=docid;
  599.       return true;
  600.     }
  601.   // should not happen
  602.   return false;
  603. }
  605. bool   XMLParserImp::GetImage(const wchar_t *name,HDC hDC,int maxwidth,
  606.  int maxheight,int rotation,Image& img)
  607. {
  608.   bool alloc;
  609.   CachedImage *cim=m_imcache.Lookup(name,alloc);
  610.   if (!alloc && cim->hBmp && (cim->maxwidth==maxwidth ||
  611.       (cim->width<cim->maxwidth && cim->width<maxwidth)) &&
  612.       (cim->maxheight==maxheight || (cim->height<cim->maxheight &&
  613.       cim->height<maxheight)) &&
  614.     cim->rotation==rotation)
  615.   {
  616.     img.hBmp=cim->hBmp;
  617.     img.height=cim->height;
  618.     img.width=cim->width;
  619.     return true;
  620.   }
  621.   const wchar_t   *type,*vname;
  622.   ImageLoader::BinReader  *rdr;
  623.   if (rdr=OpenBinary(name,&type,&vname)) {
  624.     int   width,height;
  625.     HBITMAP  hBmp;
  626.     bool ret=ImageLoader::Load(hDC,type,rdr,maxwidth,maxheight,rotation,hBmp,width,height);
  627.     delete rdr;
  628.     if (ret) {
  629.       cim->maxwidth=maxwidth;
  630.       cim->maxheight=maxheight;
  631.       cim->rotation=rotation;
  632.       cim->width=width;
  633.       cim->height=height;
  634.       cim->hBmp=hBmp;
  635.       cim->name=vname;
  636.       img.hBmp=hBmp;
  637.       img.width=width;
  638.       img.height=height;
  639.       return true;
  640.     }
  641.   }
  642.   m_imcache.Remove(cim);
  643.   return false;
  644. }
  646. void   XMLParserImp::AddQ(int start) {
  647.   PE pe;
  648.   pe.Zero();
  649.   pe.start=start;
  650.   m_pp.Add(pe);
  651. }
  653. void   XMLParserImp::AddToc(FilePos pos,int level) {
  654.   if (m_bmk) {
  655.     FilePos ref(pos);
  656.     ref.off=0;
  657.     m_bmk->AddTocEnt(pos.para,pos.off,pos.docid,ref,level);
  658.   }
  659. }
  661. void   XMLParserImp::AddP(int pstart,int lstart,int start,int len,CFMT& fmt)
  662. {
  663.   if (pstart==m_frags.GetSize() || len==0) {
  664.     AddQ(start);
  665.     return;
  666.   }
  667.   PE pe;
  668.   pe.setidx_nf(pstart,m_frags.GetSize()-pstart);
  669.   pe.setidx_nl(lstart,m_links.GetSize()-lstart);
  670.   pe.start=start;
  671.   pe.flags=fmt.flags;
  672.   pe.setindent(RClamp(fmt.lindent,0,500),RClamp(fmt.rindent,0,500),
  673.     RClamp(fmt.findent,0,500));
  674.   m_pp.Add(pe);
  675. }
  677. void   XMLParserImp::AddImage(const wchar_t *href,int start,CFMT& fmt)
  678. {
  679.   PE pe;
  680.   pe.name=m_buffer.Append(href,wcslen(href)+1);
  681.   pe.flags=fmt.flags|PE_IMAGE;
  682.   pe.setidx_nl(0,0);
  683.   pe.start=start;
  684.   pe.setindent(RClamp(fmt.lindent,0,500),RClamp(fmt.rindent,0,500),
  685.     RClamp(fmt.findent,0,500));
  686.   m_pp.Add(pe);
  687. }
  689. void   XMLParserImp::PushWS() {
  690.   Frag    f;
  691.   // if we already have a leading space, but its charformat differs from current
  692.   // we have to create a fully whitespace frag
  693.   if (m_ps->attr&LEADSP && m_ps->last_frag_fmt!=m_ps->cfmt.attr) {
  694.     f.attr=m_ps->last_frag_fmt.wa|REALLYLOCAL;
  695.     f.len=1;
  696.     f.local[0]=L' ';
  697.     m_frags.Add(f);
  698.     m_ps->numfrags++;
  699.     m_ps->len++;
  700.     m_ps->attr&=~LEADSP;
  701.   }
  702. }
  704. class Base64BinReader: public ImageLoader::BinReader {
  705.   enum { FEOF=65535 };
  707.   XMLParserImp   *m_parser;
  708.   Buffer<wchar_t> m_fragbuf;
  709.   int   m_maxfragsize;
  710.   int   m_ptr;
  711.   int   m_fragptr;
  712.   int   m_fragtop;
  714.   unsigned int   m_chunk;
  715.   int   m_chunkbytes;
  717.   bool   NextFrag();
  718.   wchar_t   NextFragChar();
  719.   wchar_t   Char() { return m_ptr<m_fragbuf.size() ?
  720.     m_fragbuf[m_ptr++] : NextFragChar(); }
  721. public:
  722.   Base64BinReader(XMLParserImp *xp,XMLParserImp::Binary *b) :
  723.       m_parser(xp), m_maxfragsize(0), m_ptr(0),
  724.       m_fragptr(b->startfrag), m_fragtop(b->startfrag+b->numfrags),
  725.       m_chunk(0), m_chunkbytes(0) { }
  726.   virtual int   Read(void *buffer,int count);
  727. };
  729. ImageLoader::BinReader *XMLParserImp::OpenBinary(const wchar_t *name,
  730.   const wchar_t **type,
  731.   const wchar_t **vname) {
  732.   void       *ptr;
  733.   if (!m_binaries.Lookup(name,ptr))
  734.     return NULL;
  735.   Binary      *b=(Binary*)ptr;
  736.   if (type)
  737.     *type=b->type;
  738.   if (vname)
  739.     *vname=b->id;
  740.   // we only support base64
  741.   return new Base64BinReader(this,b);
  742. }
  744. bool  Base64BinReader::NextFrag() {
  745.   if (m_fragptr>=m_fragtop)
  746.     return false;
  747.   XMLParserImp::Frag    *fp=&m_parser->m_frags[m_fragptr];
  748.   if ((int)fp->len>m_maxfragsize) {
  749.     m_maxfragsize=fp->len;
  750.     m_fragbuf=Buffer<wchar_t>(m_maxfragsize);
  751.   }
  752.   if (fp->attr&REALLYLOCAL) {
  753.     m_fragbuf.setsize(fp->len);
  754.     memcpy(m_fragbuf,fp->local,fp->len*sizeof(wchar_t));
  755.   } else if (fp->attr&LOCAL) {
  756.     m_fragbuf.setsize(fp->len);
  757.     memcpy(m_fragbuf,fp->str,fp->len*sizeof(wchar_t));
  758.   } else {
  759.     Buffer<char>    buf(fp->len);
  760.     m_parser->m_fp->seek(fp->fpos);
  761.     if (m_parser->m_fp->read(buf,fp->len)!=(int)fp->len) {
  762.       ASSERT(0);
  763.       return false;
  764.     }
  765.     char     *cp=buf;
  766.     int ul;
  767.     if (fp->attr&CDATA)
  768.       ul=XML_ConvertCharacterData((XML_Parser)m_parser->m_parser,&cp,fp->len,m_fragbuf,fp->len);
  769.     else
  770.       ul=XML_ParseCharacterData((XML_Parser)m_parser->m_parser,&cp,fp->len,m_fragbuf,fp->len);
  771.     if (ul<0) // xml parser returned an error
  772.       return false;
  773.     m_fragbuf.setsize(ul);
  774.   }
  775.   ++m_fragptr;
  776.   m_ptr=0;
  777.   return true;
  778. }
  780. wchar_t Base64BinReader::NextFragChar() {
  781.   if (!NextFrag())
  782.     return FEOF;
  783.   return m_ptr<m_fragbuf.size() ? m_fragbuf[m_ptr++] : FEOF;
  784. }
  786. int   Base64BinReader::Read(void *buffer,int count) {
  787.   char *dest=(char*)buffer;
  788.   char *de=dest+count,*ds=dest;
  790.   do {
  791.     // store accumulated bytes
  792.     while (m_chunkbytes>0 && ds<de) {
  793.       *ds++=((char*)&m_chunk)[2];
  794.       m_chunkbytes--;
  795.       m_chunk<<=8;
  796.     }
  797.     if (ds>=de)
  798.       break;
  799.     // fill in three more octets
  800.     m_chunk=0; m_chunkbytes=3;
  801.     int i=18;
  802.     do {
  803.       wchar_t c=Char();
  804.       if (c==FEOF) {
  805. m_chunkbytes=0;
  806. break;
  807.       }
  808.       if (c>='A' && c<='Z')
  809. m_chunk|=(unsigned int)(c-'A')<<i;
  810.       else if (c>='a' && c<='z')
  811. m_chunk|=(unsigned int)(c-'a'+26)<<i;
  812.       else if (c>='0' && c<='9')
  813. m_chunk|=(unsigned int)(c-'0'+52)<<i;
  814.       else if (c=='+')
  815. m_chunk|=62<<i;
  816.       else if (c=='/')
  817. m_chunk|=63<<i;
  818.       else if (c=='=') {
  819. if (i==6)
  820.   m_chunkbytes=1;
  821. else if (i==0)
  822.   m_chunkbytes=2;
  823. // force eof
  824. m_fragtop=m_fragptr;
  825. m_fragbuf.setsize(0);
  826. break;
  827.       } else
  828. continue; // silently ignore all other chars
  829.       i-=6;
  830.     } while (i>=0);
  831.     if (!m_chunkbytes) // EOF
  832.       break;
  833.   } while (ds<de);
  834.   return ds-dest;
  835. }
  837. static void   *my_malloc(void *priv,size_t size) {
  838.   return HeapAlloc((HANDLE)priv,HEAP_NO_SERIALIZE,size);
  839. }
  841. static void   *my_realloc(void *priv,void *ptr,size_t size) {
  842.   return HeapReAlloc((HANDLE)priv,HEAP_NO_SERIALIZE,ptr,size);
  843. }
  845. static void   my_free(void *priv,void *ptr) {
  846.   HeapFree((HANDLE)priv,HEAP_NO_SERIALIZE,ptr);
  847. }
  849. static void normalize_space(wchar_t *dest,int dlen,const wchar_t *s,int len)
  850. {
  851.   wchar_t *q=dest+dlen;
  852.   const wchar_t *e=s+len;
  853.   while (s<e && *s<=32)
  854.       ++s;
  855.   goto in;
  856.   while (s<e && dest<q) {
  857.     while (s<e && *s<=32)
  858.       ++s;
  859.     if (s<e)
  860.       *dest++=L' ';
  861. in:
  862.     while (s<e && dest<q && *s>32)
  863.       *dest++=*s++;
  864.   }
  865. }
  867. static int    normalized_length(const wchar_t *s,int len) {
  868.   const wchar_t *e=s+len;
  869.   int       nl=0;
  870.   while (s<e && *s<=32)
  871.     ++s;
  872.   goto in;
  873.   while (s<e) {
  874.     while (s<e && *s<=32)
  875.       ++s;
  876.     if (s<e)
  877.       ++nl;
  878. in:
  879.     while (s<e && *s>32)
  880.       ++nl,++s;
  881.   }
  882.   return nl;
  883. }
  885. static bool iswhitespace(const wchar_t *text,int len) {
  886.   const wchar_t *end=text+len;
  887.   while (text<end) {
  888.     if (*text!=0x0d && *text!=0x0a && *text!=0x20 && *text!=0x09)
  889.       return false;
  890.     ++text;
  891.   }
  892.   return true;
  893. }
  895. static XMLParser::FmtArray g_eformat;
  896. static WMap *g_elements;
  898. static struct Cleaner {
  899.   ~Cleaner() { delete g_elements; }
  900. } g_cleaner;
  902. static XMLParser::ElemFmt    *LookupElem(const wchar_t *name) {
  903.   void *data;
  904.   if (name && g_elements->Lookup(name,data))
  905.     return &g_eformat[(int)data];
  906.   return &g_eformat[0]; // default
  907. }
  909. static const wchar_t       *LocalName(const wchar_t *name) {
  910.   const wchar_t   *end=wcschr(name,L'|');
  911.   return end ? end+1 : name;
  912. }
  914. void XMLParserImp::ParseState::ApplyFmt(ElemFmt *e,int nest) {
  915.   PushA();
  916.   if (e->fsz!=XMLParser::ElemFmt::NOCHG)
  917.     cfmt.attr.fsize=nest ? max(e->fsz-nest,1) : e->fsz;
  918.   if (e->bold!=XMLParser::ElemFmt::NOCHG)
  919.     cfmt.attr.bold=e->bold;
  920.   if (e->italic!=XMLParser::ElemFmt::NOCHG)
  921.     cfmt.attr.italic=e->italic;
  922.   if (e->underline!=XMLParser::ElemFmt::NOCHG)
  923.     cfmt.attr.underline=e->underline;
  924.   if (e->color!=XMLParser::ElemFmt::NOCHG)
  925.     cfmt.attr.color=e->color;
  926.   if (e->align!=XMLParser::ElemFmt::NOCHG)
  927.     cfmt.flags=(cfmt.flags & ~Paragraph::align_mask) | (e->align & Paragraph::align_mask);
  928.   if (e->lindent!=XMLParser::ElemFmt::NOCHG) {
  929.     if (e->lindent<0)
  930.       cfmt.lindent-=e->lindent;
  931.     else
  932.       cfmt.lindent=e->lindent;
  933.   }
  934.   if (e->rindent!=XMLParser::ElemFmt::NOCHG) {
  935.     if (e->rindent<0)
  936.       cfmt.rindent-=e->rindent;
  937.     else
  938.       cfmt.rindent=e->rindent;
  939.   }
  940.   if (e->findent!=XMLParser::ElemFmt::NOCHG) {
  941.     if (e->findent<0)
  942.       cfmt.findent-=e->findent;
  943.     else
  944.       cfmt.findent=e->findent;
  945.   }
  946. }
  948. const wchar_t *GetAttr(const wchar_t **attr,const wchar_t *name,const wchar_t *def=NULL)
  949. {
  950.   while (*attr) {
  951.     if (!wcscmp(name,*attr))
  952.       return attr[1];
  953.     attr+=2;
  954.   }
  955.   return def;
  956. }
  958. void XMLParserImp::StartElement(const wchar_t *ns_name,const wchar_t **attr) {
  959.   if (!m_ps->root_element) { // special case for root
  960.     const wchar_t *p = ns_name;
  961.     const wchar_t *q = FB_NS;
  962.     const wchar_t *e = q + FB_NS_LEN - 1;
  963.     while (*p && q < e)
  964.       if (*p++ != *q++)
  965. longjmp(m_ps->jout,ERR_NOTFB2);
  966.     if (!p[0] || wcscmp(p+1,L"|FictionBook")!=0)
  967.       longjmp(m_ps->jout,ERR_NOTFB2);
  968.     m_ps->root_element=true;
  969.   }
  970.   ElemFmt *elem=LookupElem(ns_name);
  971.   if (elem->flags&ElemFmt::DOCUMENT) {
  972.     if (m_docs.GetSize()==0)
  973.       AddQ(m_ps->start);
  974.     Document  d;
  975.     d.start=m_pp.GetSize();
  976.     d.length=0;
  977.     d.name=GetAttr(attr,L"name",L"");
  978.     m_docs.Add(d);
  979.     m_ps->start=0;
  980.     // add a cover page if it was present
  981.     if (m_docs.GetSize()==1 && m_cover.GetLength()>0) {
  982.       AddImage(m_cover,m_ps->start,m_ps->cfmt);
  983.       m_ps->start+=ImageLoader::IMAGE_VSIZE;
  984.     }
  985.   }
  986.   if (elem->flags&ElemFmt::ENABLE)
  987.     ++m_ps->enable;
  988.   if (elem->flags&ElemFmt::SECTION)
  989.     m_ps->section_nest++;
  990.   if (elem->flags&ElemFmt::ELINE)
  991.     AddQ(m_ps->start);
  992.   if (elem->flags&ElemFmt::FMT) // apply formatting
  993.     m_ps->ApplyFmt(elem);
  994.   if (elem->flags&ElemFmt::STYLE) {
  995.     const wchar_t   *style=GetAttr(attr,L"name");
  996.     void     *val;
  997.     if (style && m_ps->stylemap->Lookup(style,val))
  998.       m_ps->ApplyFmt(&m_ps->styles->operator[]((int)val));
  999.     else
  1000.       m_ps->PushA();
  1001.   }
  1002.   if (elem->flags&ElemFmt::HEADER) {
  1003.     m_ps->PushA();
  1004.     m_ps->cfmt.flags |= Paragraph::header;
  1005.   }
  1006.   if (elem->flags&ElemFmt::STYLESHEET) {
  1007.     const wchar_t *type=GetAttr(attr,L"type");
  1008.     if (m_ps->in_stylesheet || (type && !wcscmp(type,HR_STYLE)))
  1009.       if (!m_ps->in_stylesheet++)
  1010. m_sps->Init();
  1011.   }
  1012.   if (elem->flags&ElemFmt::TITLE) // start a toc entry
  1013.     m_ps->title_start=m_pp.GetSize();
  1014.   if (elem->flags&ElemFmt::LINKDEST) { // link destination
  1015.     const wchar_t *id=GetAttr(attr,L"id");
  1016.     if (id) {
  1017.       wchar_t *copy=m_buffer.Append(id,wcslen(id)+1);
  1018.       m_references.Add(copy,(void*)m_pp.GetSize());
  1019.     }
  1020.   }
  1021.   if (elem->flags&ElemFmt::LINK) { // link
  1022.     const wchar_t   *dest=GetAttr(attr,XLINK_NS L"|href");
  1023.     const wchar_t   *type=GetAttr(attr,L"type");
  1024.     ElemFmt     *linkformat;
  1025.     if (type && !wcscmp(type,L"note"))
  1026.       linkformat=LookupElem(L"|>footnote");
  1027.     else
  1028.       linkformat=LookupElem(L"|>link");
  1029.     m_ps->ApplyFmt(linkformat);
  1030.     if (dest) {
  1031.       m_ps->link_start=m_ps->len;
  1032.       m_ps->link_name=m_buffer.Append(dest,wcslen(dest)+1);
  1033.     } else
  1034.       m_ps->link_name=NULL;
  1035.   }
  1036.   if ((m_ps->enable && elem->flags&ElemFmt::PARA) ||
  1037.       elem->flags&ElemFmt::DESCCAT)
  1038.   { // start a new paragraph
  1039.     m_ps->attr&=~(LEADSP|TRAILSP);
  1040.     m_ps->acch_lev++;
  1041.     m_ps->pf_start=m_frags.GetSize();
  1042.     m_ps->pl_start=m_links.GetSize();
  1043.     m_ps->numfrags=0;
  1044.     m_ps->len=0;
  1045.     m_ps->last_frag_trailsp=false;
  1046.     m_ps->last_frag_fmt=m_ps->cfmt.attr;
  1047.   }
  1048.   if (elem->flags&(ElemFmt::DESCCAT|ElemFmt::DESCITEM)) {
  1049.     Frag   f;
  1050.     if (elem->flags&ElemFmt::DESCITEM) { // add a few nbsps
  1051.       f.attr=m_ps->Att()|REALLYLOCAL;
  1052.       f.len=2;
  1053.       f.local[0]=f.local[1]=0xa0; // nbsp
  1054.       m_frags.Add(f);
  1055.       ++m_ps->numfrags;
  1056.       m_ps->len+=f.len;
  1057.     }
  1058.     // add an element name
  1059.     m_ps->ApplyFmt(LookupElem(L">keyword"));
  1060.     const wchar_t   *ln=LocalName(ns_name);
  1061.     f.len=wcslen(ln);
  1062.     f.attr=m_ps->Att()|LOCAL;
  1063.     f.str=m_buffer.Append(ln,f.len);
  1064.     m_frags.Add(f);
  1065.     ++m_ps->numfrags;
  1066.     m_ps->len+=f.len;
  1067.     m_ps->PopA();
  1068.     if (elem->flags&ElemFmt::DESCITEM && attr && *attr) { // print attributes as well
  1069.       // add " ("
  1070.       f.attr=m_ps->Att()|REALLYLOCAL;
  1071.       f.len=2;
  1072.       f.local[0]=L' '; f.local[1]=L'(';
  1073.       m_frags.Add(f);
  1074.       ++m_ps->numfrags;
  1075.       m_ps->len+=f.len;
  1076.       // iterate over attrbutes
  1077.       while (*attr) {
  1078. //attr name
  1079. f.attr=m_ps->Att()|LOCAL;
  1080. ln=LocalName(*attr);
  1081. f.len=wcslen(ln);
  1082. f.str=m_buffer.Append(ln,f.len);
  1083. m_frags.Add(f);
  1084. ++m_ps->numfrags;
  1085. m_ps->len+=f.len;
  1086. // "="
  1087. f.attr=m_ps->Att()|REALLYLOCAL;
  1088. f.len=1;
  1089. f.local[0]=L'=';
  1090. m_frags.Add(f);
  1091. ++m_ps->numfrags;
  1092. ++m_ps->len;
  1093. // value
  1094. f.attr=m_ps->Att()|LOCAL;
  1095. f.len=wcslen(attr[1]);
  1096. f.str=m_buffer.Append(attr[1],f.len);
  1097. m_frags.Add(f);
  1098. ++m_ps->numfrags;
  1099. m_ps->len+=f.len;
  1100. attr+=2;
  1101.       }
  1102.       // add ")"
  1103.       f.attr=m_ps->Att()|REALLYLOCAL;
  1104.       f.len=1;
  1105.       f.local[0]=L')';
  1106.       m_frags.Add(f);
  1107.       ++m_ps->numfrags;
  1108.       m_ps->len+=f.len;
  1109.     }
  1110.     if (elem->flags&ElemFmt::DESCCAT) {
  1111.       // if last frag is a trailsp, then discard the last space
  1112.       if (m_ps->last_frag_trailsp) {
  1113. m_ps->len--;
  1114. m_frags[m_frags.GetSize()-1].attr&=~TRAILSP;
  1115.       }
  1116.       AddP(m_ps->pf_start,m_ps->pl_start,m_ps->start,m_ps->len,m_ps->cfmt);
  1117.       m_ps->start+=m_ps->len;
  1118.       m_ps->acch_lev--;
  1119.     } else { // add a ": "
  1120.       f.attr=m_ps->Att()|REALLYLOCAL;
  1121.       f.len=2;
  1122.       f.local[0]=L':'; f.local[1]=L' ';
  1123.       m_frags.Add(f);
  1124.       ++m_ps->numfrags;
  1125.       m_ps->len+=f.len;
  1126.     }
  1127.   }
  1128.   if (elem->flags&ElemFmt::BINARY) {
  1129.     const wchar_t *id=GetAttr(attr,L"id");
  1130.     const wchar_t *type=GetAttr(attr,L"content-type");
  1131.     if (id && type) {
  1132.       m_ps->binary=1;
  1133.       Binary  *b=m_binarystorage.Get();
  1134.       b->id=m_buffer.Append(id,wcslen(id)+1);
  1135.       b->type=m_buffer.Append(type,wcslen(type)+1);
  1136.       b->startfrag=m_frags.GetSize();
  1137.       b->numfrags=0;
  1138.       m_binaries.Add(b->id,(void*)b);
  1139.     }
  1140.   }
  1141.   if (elem->flags&ElemFmt::IMAGE) {
  1142.     const wchar_t *href=GetAttr(attr,XLINK_NS L"|href");
  1143.     if (href && href[0]==L'#') {
  1144.       if (m_ps->acch_lev) { // inline image
  1145. const wchar_t *hcopy=m_buffer.Append(href+1,wcslen(href));
  1146. int       index=m_inline_images.GetSize();
  1147. m_inline_images.Add(hcopy);
  1148. PushWS();
  1149. if (m_ps->attr&LEADSP)
  1150.   ++m_ps->len;
  1151. Frag    f;
  1152. m_ps->cfmt.attr.img=1;
  1153. f.attr=m_ps->Att()|PE_IMAGE;
  1154. m_ps->cfmt.attr.img=0;
  1155. f.len=1;
  1156. f.local[0]=index;
  1157. f.local[1]=index>>16;
  1158. m_frags.Add(f);
  1159. ++m_ps->numfrags;
  1160. ++m_ps->len;
  1161. m_ps->last_frag_trailsp=0;
  1162. m_ps->attr&=~(LEADSP|TRAILSP);
  1163. m_ps->last_frag_fmt=m_ps->cfmt.attr;
  1164.       } else {
  1165. AddImage(href+1,m_ps->start,m_ps->cfmt);
  1166. // image virtual size is always the same
  1167. m_ps->start+=ImageLoader::IMAGE_VSIZE;
  1169. if (m_docs.GetSize() == 0)
  1170.   m_cover = href+1;
  1171.       }
  1172.     }
  1173.   }
  1174. }
  1176. void XMLParserImp::EndElement(const wchar_t *ns_name) {
  1177.   ProgSetCur(XML_GetCurrentByteIndex(m_parser));
  1178.   ElemFmt   *elem=LookupElem(ns_name);
  1180.   if (m_ps->enable && elem->flags&ElemFmt::PARA) { // end a paragraph
  1181.     // if last frag is a trailsp, then discard the last space
  1182.     if (m_ps->last_frag_trailsp) {
  1183.       m_ps->len--;
  1184.       m_frags[m_frags.GetSize()-1].attr&=~TRAILSP;
  1185.     }
  1186.     AddP(m_ps->pf_start,m_ps->pl_start,m_ps->start,m_ps->len,m_ps->cfmt);
  1187.     m_ps->start+=m_ps->len;
  1188.     m_ps->acch_lev--;
  1189.   }
  1190.   if (elem->flags&ElemFmt::HEADER)
  1191.     m_ps->PopA();
  1192.   if (elem->flags&ElemFmt::STYLE)
  1193.     m_ps->PopA();
  1194.   if (elem->flags&ElemFmt::STYLESHEET && m_ps->in_stylesheet)
  1195.       --m_ps->in_stylesheet;
  1196.   if (elem->flags&ElemFmt::FMT) // apply formatting
  1197.     m_ps->PopA();
  1198.   if (elem->flags&ElemFmt::LINK) { // link
  1199.     if (m_ps->link_name) {
  1200.       XMLParserImp::Link link;
  1201.       link.start=m_ps->link_start;
  1202.       link.length=m_ps->len-m_ps->link_start;
  1203.       link.target=m_ps->link_name;
  1204.       m_links.Add(link);
  1205.     }
  1206.     m_ps->PopA();
  1207.   }
  1208.   if (elem->flags&ElemFmt::SECTION) // snag title attribute
  1209.     m_ps->section_nest--;
  1210.   if (elem->flags&ElemFmt::SPACE) // add spaces after this element
  1211.     m_ps->attr|=LEADSP;
  1212.   if (elem->flags&ElemFmt::TITLE) {
  1213.     if (m_docs.GetSize()>0 && m_ps->section_nest)
  1214.       AddToc(
  1215. FilePos(
  1216.   m_ps->title_start-m_docs[m_docs.GetSize()-1].start,
  1217.   m_pp.GetSize()-m_ps->title_start,
  1218.   m_docs.GetSize()-1
  1219. ),
  1220. m_ps->section_nest
  1221.       );
  1222.   }
  1223.   if (elem->flags&ElemFmt::AELINE) // add an empty line after the element
  1224.     AddQ(m_ps->start);
  1225.   if (elem->flags&ElemFmt::ENABLE)
  1226.     --m_ps->enable;
  1227.   if (elem->flags&ElemFmt::DOCUMENT) {
  1228.     if (m_docs.GetSize()>0)
  1229.       m_docs[m_docs.GetSize()-1].length=
  1230. m_pp.GetSize()-m_docs[m_docs.GetSize()-1].start;
  1231.     AddQ(m_ps->start);
  1232.   }
  1233.   if (elem->flags&ElemFmt::BINARY && m_ps->binary) {
  1234.     m_ps->binary=0;
  1235.     int   idx=m_binarystorage.GetSize()-1;
  1236.     m_binarystorage[idx].numfrags=m_frags.GetSize()-m_binarystorage[idx].startfrag;
  1237.   }
  1238. }
  1240. void XMLParserImp::CharData(const wchar_t *text,int len) {
  1241.   if (m_ps->acch_lev && len) {
  1242.     int l=normalized_length(text,len);
  1243.     if (!l) { // whitespace frag, try to add a leading space to the next frag
  1244.       if (m_ps->numfrags) {
  1245. m_ps->attr|=LEADSP;
  1246. m_ps->last_frag_fmt=m_ps->cfmt.attr;
  1247.       }
  1248.       return;
  1249.     }
  1251.     PushWS();
  1253.     if (*text<=32 && m_ps->numfrags)
  1254.       m_ps->attr|=LEADSP;
  1255.     if (text[len-1]<=32) {
  1256.       m_ps->attr|=TRAILSP;
  1257.       m_ps->len++;
  1258.     }
  1259.     m_ps->len+=l;
  1260.     if (m_ps->attr&LEADSP)
  1261.       m_ps->len++;
  1262.     // here we check the previous frag and if it has TRAILSP and this has a LEADSP,
  1263.     // and their charformats are the same, then we can discard current LEADSP
  1264.     if (m_ps->numfrags && m_ps->last_frag_trailsp && m_ps->attr&LEADSP &&
  1265. m_ps->last_frag_fmt==m_ps->cfmt.attr)
  1266.     {
  1267.       m_ps->attr&=~LEADSP;
  1268.       m_ps->len--;
  1269.     }
  1270.     Frag    f;
  1271.     f.attr=m_ps->Att();
  1272.     if (l<5 || XML_IsExpanding(m_parser)) { // cache short fragments
  1273.       wchar_t *buf;
  1274.       if (l <= sizeof(f.local)/sizeof(wchar_t)) {
  1275. f.attr|=REALLYLOCAL;
  1276. buf=f.local;
  1277.       } else {
  1278. f.attr|=LOCAL;
  1279. buf=m_buffer.Get(l);
  1280.       }
  1281.       f.str=buf;
  1282.       f.len=l;
  1283.       normalize_space(buf,l,text,len);
  1284.     } else {
  1285.       f.len=XML_GetCurrentByteCount(m_parser);
  1286.       f.fpos=XML_GetCurrentByteIndex(m_parser);
  1287.     }
  1288.     m_frags.Add(f);
  1289.     ++m_ps->numfrags;
  1290.     m_ps->last_frag_trailsp=(m_ps->attr&TRAILSP)!=0;
  1291.     m_ps->attr&=~(LEADSP|TRAILSP);
  1292.     m_ps->last_frag_fmt=m_ps->cfmt.attr;
  1293.   }
  1294.   if (m_ps->in_stylesheet && len)
  1295.     ParseStylesheet(text,len);
  1296.   if (m_ps->binary && len && !iswhitespace(text,len)) {
  1297.     Frag  f;
  1298.     f.attr=m_ps->attr&CDATA; // text attrs are not needed in this context
  1299.     if (XML_IsExpanding(m_parser)) {
  1300.       f.str=m_buffer.Get(len);
  1301.       memcpy((wchar_t*)f.str,text,len*sizeof(wchar_t));
  1302.       f.attr|=LOCAL;
  1303.     } else {
  1304.       f.len=XML_GetCurrentByteCount(m_parser);
  1305.       f.fpos=XML_GetCurrentByteIndex(m_parser);
  1306.     }
  1307.     m_frags.Add(f);
  1308.   }
  1309. }
  1311. // expat callbacks
  1312. void   XMLParserImp::StartElementCB(void *udata,const wchar_t *name,
  1313.        const wchar_t **attr)
  1314. {
  1315.   ((XMLParserImp*)udata)->StartElement(name,attr);
  1316. }
  1318. void   XMLParserImp::EndElementCB(void *udata,const wchar_t *name) {
  1319.   ((XMLParserImp*)udata)->EndElement(name);
  1320. }
  1322. void   XMLParserImp::CharDataCB(void *udata,const wchar_t *text,int len) {
  1323.   ((XMLParserImp*)udata)->CharData(text,len);
  1324. }
  1326. void   XMLParserImp::StartCDataCB(void *udata) {
  1327.   ((XMLParserImp*)udata)->m_ps->attr|=CDATA;
  1328. }
  1330. void   XMLParserImp::EndCDataCB(void *udata) {
  1331.   ((XMLParserImp*)udata)->m_ps->attr&=~CDATA;
  1332. }
  1334. int XMLParserImp::UnknownEncodingCB(void *data,const wchar_t *name,
  1335.     XML_Encoding *info)
  1336. {
  1337.   int cp=Unicode::FindCodePage(Unicode::ToCS(name,wcslen(name)));
  1338.   const wchar_t *tab=NULL;
  1339.   if (cp>=0)
  1340.     tab=Unicode::GetTable(cp);
  1341.   if (!tab)
  1342.     return 0;
  1343.   info->data=NULL;
  1344.   info->convert=NULL;
  1345.   info->release=NULL;
  1346.   for (int i=0;i<256;++i)
  1347.     info->map[i]=tab[i];
  1348.   ((XMLParserImp*)data)->m_encoding=cp;
  1349.   return 1;
  1350. }
  1352. bool   XMLParserImp::ParseFile(int encoding) {
  1353.   XML_Memory_Handling_Suite  xmm={ my_malloc, my_realloc, my_free };
  1354.   xmm.priv=(void*)m_heap;
  1356.   ParseState     pstate;
  1357.   memset(&pstate,0,sizeof(pstate));
  1358.   m_ps=&pstate;
  1359.   FmtArray     docstyles;
  1360.   docstyles.SetSize(0,64);
  1361.   WMap     docstylemap(m_heap,true);
  1362.   pstate.styles=&docstyles;
  1363.   pstate.stylemap=&docstylemap;
  1365.   SP_State     spstate;
  1366.   m_sps=&spstate;
  1368.   const wchar_t *enc=NULL;
  1369.   if (encoding>=0) {
  1370.     enc=Unicode::GetCodePageNameW(encoding);
  1371.     if (!enc)
  1372.       encoding=-1;
  1373.   }
  1374.   if (!(m_parser=XML_ParserCreate_MM(enc,&xmm,L"|")))
  1375.     return false;
  1376.   XML_SetElementHandler(m_parser,XMLParserImp::StartElementCB,
  1377.     XMLParserImp::EndElementCB);
  1378.   XML_SetCharacterDataHandler(m_parser,XMLParserImp::CharDataCB);
  1379.   XML_SetCdataSectionHandler(m_parser,StartCDataCB,EndCDataCB);
  1380.   XML_SetUnknownEncodingHandler(m_parser,XMLParserImp::UnknownEncodingCB,this);
  1381.   XML_SetUserData(m_parser,this);
  1382.   m_encoding=-1;
  1383.   // now suck in the file
  1384.   m_fp->seek(0);
  1385.   switch (setjmp(pstate.jout)) {
  1386.   case 0:
  1387.     for (;;) {
  1388.       void    *buf=(char*)XML_GetBuffer(m_parser,RFile::BSZ);
  1389.       if (!buf) {
  1390. CTVApp::Barf(_T("XML parser: Out of memory"));
  1391. goto fail;
  1392.       }
  1393.       int     nr=m_fp->read(buf,RFile::BSZ);
  1394.       if (!XML_ParseBuffer(m_parser,nr,nr<RFile::BSZ)) {
  1395. CTVApp::Barf(
  1396.   #ifdef UNICODE
  1397.   _T("XML parse error: %s at line %d, column %d"),
  1398.   #else
  1399.   _T("XML parse error: %S at line %d, column %d"),
  1400.   #endif
  1401.   XML_ErrorString(XML_GetErrorCode(m_parser)),
  1402.   XML_GetCurrentLineNumber(m_parser),XML_GetCurrentColumnNumber(m_parser)+1);
  1403. goto fail;
  1404.       }
  1405.       if (nr<RFile::BSZ)
  1406. break;
  1407.     }
  1408.     break;
  1409.   case ERR_NOTFB2:
  1410.     CTVApp::Barf(_T("Not a FictionBook2 document"));
  1411.     goto fail;
  1412.   }
  1413.   if (m_docs.GetSize()>0) {
  1414.     Document    d;
  1415.     d.start=0;
  1416.     d.length=m_docs[0].start-1;
  1417.     d.name=_T("#Description");
  1418.     m_docs.Add(d);
  1419.   }
  1420.   return true;
  1421. fail:
  1422.   //XML_ParserFree(m_parser);
  1423.   // parser is now destroyed in the XMLParserImp destructor
  1424.   return false;
  1425. }
  1427. XMLParser *XMLParser::MakeParser(Meter *m,CBufFile *fp,Bookmarks *bmk,HANDLE heap) {
  1428.   return new XMLParserImp(m,fp,bmk,heap);
  1429. }
  1431. void   XMLParserImp::ParseStylesheet(const wchar_t *text,int len) {
  1432.   wchar_t   ch;
  1433.   while (len--) {
  1434.     ch=*text++;
  1435.     switch (m_sps->state) {
  1436.     case SP_State::START:
  1437.       if (!iswspace(ch)) {
  1438. m_sps->NAdd(ch);
  1439. m_sps->state=SP_State::NAME;
  1440.       }
  1441.       break;
  1442.     case SP_State::NAME:
  1443.       if (!iswspace(ch))
  1444. m_sps->NAdd(ch);
  1445.       else
  1446. m_sps->state=SP_State::FLAGS;
  1447.       break;
  1448.     case SP_State::FLAGS:
  1449. flags:
  1450.       switch (ch) {
  1451.       case L'b':
  1452. m_sps->format.bold=1;
  1453. break;
  1454.       case L'B':
  1455. m_sps->format.bold=0;
  1456. break;
  1457.       case L'i':
  1458. m_sps->format.italic=1;
  1459. break;
  1460.       case L'I':
  1461. m_sps->format.italic=0;
  1462. break;
  1463.       case L'u':
  1464. m_sps->format.underline=1;
  1465. break;
  1466.       case L'U':
  1467. m_sps->format.underline=0;
  1468. break;
  1469.       case L'r':
  1470. m_sps->format.align=Paragraph::right;
  1471. break;
  1472.       case L'c':
  1473. m_sps->format.align=Paragraph::center;
  1474. break;
  1475.       case L'j':
  1476. m_sps->format.align=Paragraph::justify;
  1477. break;
  1478.       case L'l':
  1479. m_sps->format.align=0;
  1480. break;
  1481.       case L'h':
  1482. m_sps->state=SP_State::COLOR;
  1483. m_sps->num=0; m_sps->sign=false;
  1484. break;
  1485.       case L'L':
  1486. m_sps->state=SP_State::LM;
  1487. m_sps->num=0; m_sps->sign=false;
  1488. break;
  1489.       case L'R':
  1490. m_sps->state=SP_State::RM;
  1491. m_sps->num=0; m_sps->sign=false;
  1492. break;
  1493.       case L'F':
  1494. m_sps->state=SP_State::FM;
  1495. m_sps->num=0; m_sps->sign=false;
  1496. break;
  1497.       case L'S':
  1498. m_sps->state=SP_State::SIZE;
  1499. m_sps->num=0; m_sps->sign=false;
  1500. break;
  1501.       case L';':
  1502. m_sps->stylename[m_sps->stylenameptr]=L'';
  1503. m_ps->stylemap->AddCopy(m_sps->stylename,(void*)m_ps->styles->GetSize());
  1504. m_ps->styles->Add(m_sps->format);
  1505. m_sps->Init();
  1506. break;
  1507.       }
  1508.       break;
  1509.     case SP_State::FM:
  1510.     case SP_State::LM:
  1511.     case SP_State::RM:
  1512.     case SP_State::SIZE:
  1513.     case SP_State::COLOR:
  1514.       if (iswdigit(ch)) {
  1515. m_sps->num=m_sps->num*10+ch-L'0';
  1516.       } else if (ch=='-') 
  1517. m_sps->sign=1;
  1518.       else { // end of spec
  1519. int   val=m_sps->num;
  1520. if (m_sps->sign)
  1521.   val=-val;
  1522. switch (m_sps->state) {
  1523. case SP_State::FM:
  1524.   val=RClamp(val,-100,100);
  1525.   m_sps->format.findent=val;
  1526.   break;
  1527. case SP_State::LM:
  1528.   val=RClamp(val,-100,100);
  1529.   m_sps->format.lindent=val;
  1530.   break;
  1531. case SP_State::RM:
  1532.   val=RClamp(val,-100,100);
  1533.   m_sps->format.rindent=val;
  1534.   break;
  1535. case SP_State::COLOR:
  1536.   val=RClamp(val,0,7);
  1537.   m_sps->format.color=val;
  1538.   break;
  1539. case SP_State::SIZE:
  1540.   val=RClamp(val,-100,100);
  1541.   m_sps->format.fsz=val;
  1542.   break;
  1543. }
  1544. m_sps->state=SP_State::FLAGS;
  1545. goto flags;
  1546.       }
  1547.       break;
  1548.     }
  1549.   }
  1550. }
  1552. void XMLParser::SaveStyles() {
  1553.   for (int i=0;i<g_eformat.GetSize();++i)
  1554.     if (g_eformat[i].name.GetLength() && g_eformat[i].name[0]!=_T('*')) {
  1555.       CString str;
  1556.       str.Format(_T("%d,%d,%d,%d,%d,%d,%d,%d,%d"),
  1557. g_eformat[i].fsz,
  1558. g_eformat[i].bold,
  1559. g_eformat[i].italic,
  1560. g_eformat[i].underline,
  1561. g_eformat[i].color,
  1562. g_eformat[i].align,
  1563. g_eformat[i].lindent,
  1564. g_eformat[i].rindent,
  1565. g_eformat[i].findent);
  1566.       AfxGetApp()->WriteProfileString(_T("Styles"),g_eformat[i].name,str);
  1567.     }
  1568. }
  1571. static void AddElement(const wchar_t *name,int namelen,int id) {
  1572.   wchar_t   buf[128];
  1573.   wcscpy(buf,FB_NS);
  1574.   buf[FB_NS_LEN]=L'|';
  1575.   if (namelen>sizeof(buf)/sizeof(wchar_t)-2-FB_NS_LEN)
  1576.     namelen=sizeof(buf)/sizeof(wchar_t)-2-FB_NS_LEN;
  1577.   wcsncpy(buf+FB_NS_LEN+1,name,namelen);
  1578.   buf[FB_NS_LEN+1+namelen]=L'';
  1579.   g_elements->AddCopy(buf,(void*)id);
  1580.   g_elements->AddCopy(buf+FB_NS_LEN,(void*)id);
  1581.   g_elements->AddCopy(buf+FB_NS_LEN+1,(void*)id);
  1582. }
  1584. static inline int FLAG(wchar_t x) {
  1585.   return x==L'+' ? 1 : x==L'-' ? 0 : XMLParser::ElemFmt::NOCHG;
  1586. }
  1588. static void ParseXMLSettings(const wchar_t *fmt,DWORD sz) {
  1589.   const wchar_t  *p=fmt;
  1590.   const wchar_t  *e=fmt+sz;
  1591.   const wchar_t  *le;
  1592.   wchar_t  *q;
  1594.   if (p<e && *p==0xFEFF)
  1595.     ++p;
  1596.   while (p<e) {
  1597.     for (le=p;le<e && *le!=L'r' && *le!=L'n';++le) ;
  1598.     // process line here
  1599.     if (p!=le && *p!=L'#' && *p!=L' ' && *p!=L't') {
  1600.       XMLParser::ElemFmt fe;
  1601.       wchar_t *name=NULL;
  1602.       int size;
  1603.       wchar_t bold,italic,underline;
  1604.       int color;
  1605.       wchar_t align;
  1606.       int leftm,rightm,firstm;
  1607.       wchar_t *action=NULL,*elements=NULL;
  1608.       int fields;
  1609.       if (Scan::xscanf(p,le-p,L"%S %-100,100,127d "
  1610. L"%c %c %c %0,8,127d %c %-100,100,127d "
  1611. L"%-100,100,127d %-100,100,127d %S %S",NULL,&fields,
  1612. &name,&size,&bold,&italic,&underline,
  1613. &color,&align,&leftm,&rightm,&firstm,
  1614. &action,&elements)==0 && fields==12)
  1615.       {
  1616. for (q=name;*q;++q)
  1617.   if (*q==L'_')
  1618.     *q=L' ';
  1619. fe.name=name;
  1620. fe.fsz=size;
  1621. fe.bold=FLAG(bold);
  1622. fe.italic=FLAG(italic);
  1623. fe.underline=FLAG(underline);
  1624. fe.color=color;
  1625. switch (align) {
  1626. case 'R':
  1627.   fe.align=Paragraph::right;
  1628.   break;
  1629. case 'C':
  1630.   fe.align=Paragraph::center;
  1631.   break;
  1632. case 'J':
  1633.   fe.align=Paragraph::justify;
  1634.   break;
  1635. default:
  1636.   fe.align=XMLParser::ElemFmt::NOCHG;
  1637.   break;
  1638. }
  1639. fe.lindent=leftm;
  1640. fe.rindent=rightm;
  1641. fe.findent=firstm;
  1642. fe.flags=0;
  1643. for (q=action;*q;++q) {
  1644.   const TCHAR *fp=XMLParser::ElemFmt::flag_names;
  1645.   for (int flags=1;*fp;flags<<=1,++fp)
  1646.     if (*fp==*q) {
  1647.       fe.flags|=flags;
  1648.       break;
  1649.     }
  1650. }
  1651. for (p=elements;*p;) {
  1652.   const wchar_t *q; // XXX
  1653.   for (q=p;*q && *q!=L',';++q) ;
  1654.   if (q!=p)
  1655.     AddElement(p,q-p,g_eformat.GetSize());
  1656.   p=q;
  1657.   if (*p==L',')
  1658.     ++p;
  1659. }
  1660. // ok, insert it now
  1661. g_eformat.Add(fe);
  1662.       }
  1663.       delete[] name;
  1664.       delete[] action;
  1665.       delete[] elements;
  1666.     }
  1667.     // skip end of line
  1668.     for (p=le;p<e && (*p=='r' || *p=='n');++p) ;
  1669.   }
  1670. }
  1672. void XMLParser::LoadStyles() {
  1673.   ElemFmt ef;
  1674.   // delete all elements
  1675.   g_eformat.RemoveAll();
  1676.   delete g_elements;
  1677.   g_elements=new WMap(GetProcessHeap(),true);
  1678.   // always initialize a default element
  1679.   ef.Clear();
  1680.   g_eformat.Add(ef);
  1681.   // read parser settings from a resource
  1682.   HMODULE hMod=AfxGetResourceHandle();
  1683.   HRSRC   hRes=FindResource(hMod,_T("xml_elements"),RT_RCDATA);
  1684.   if (hRes) {
  1685.     DWORD   rsize=SizeofResource(hMod,hRes);
  1686.     HGLOBAL hGlob=LoadResource(hMod,hRes);
  1687.     if (hGlob) {
  1688.       void  *res=LockResource(hGlob);
  1689.       if (res) {
  1690. ParseXMLSettings((const wchar_t *)res,rsize/sizeof(wchar_t));
  1691. UnlockResource(hGlob);
  1692.       }
  1693.       FreeResource(hGlob);
  1694.     }
  1695.   }
  1696.   // adjust formatting from registry
  1697.   for (int fnum=0;fnum<g_eformat.GetSize();++fnum)
  1698.     if (g_eformat[fnum].name.GetLength()>0 && g_eformat[fnum].name[0]!=_T('*')) {
  1699.       CString str=AfxGetApp()->GetProfileString(_T("Styles"),g_eformat[fnum].name);
  1700.       int f,b,i,c,a,li,ri,fi,u;
  1701.       if (_stscanf(str,_T("%d,%d,%d,%d,%d,%d,%d,%d,%d"),&f,&b,&i,&u,&c,&a,&li,&ri,&fi)==9) {
  1702. g_eformat[fnum].fsz=f;
  1703. g_eformat[fnum].bold=b;
  1704. g_eformat[fnum].italic=i;
  1705. g_eformat[fnum].underline=u;
  1706. g_eformat[fnum].color=c;
  1707. g_eformat[fnum].align=a;
  1708. g_eformat[fnum].lindent=li;
  1709. g_eformat[fnum].rindent=ri;
  1710. g_eformat[fnum].findent=fi;
  1711.       }
  1712.     }
  1713. }
  1715. XMLParser::FmtArray&  XMLParser::GetXMLStyles() {
  1716.   return g_eformat;
  1717. }
  1719. void XMLParser::ElemFmt::Clear() {
  1720.     fsz=NOCHG;
  1721.     bold=NOCHG;
  1722.     italic=NOCHG;
  1723.     color=NOCHG;
  1724.     align=NOCHG;
  1725.     underline=NOCHG;
  1726.     flags=0;
  1727.     lindent=NOCHG;
  1728.     rindent=NOCHG;
  1729.     findent=NOCHG;
  1730.     name.Empty();
  1731. }