ReaderMgr.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:19k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: ReaderMgr.hpp,v $
  58.  * Revision 1.9  2003/05/16 21:36:57  knoaman
  59.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  60.  *
  61.  * Revision 1.8  2003/05/15 18:26:29  knoaman
  62.  * Partial implementation of the configurable memory manager.
  63.  *
  64.  * Revision 1.7  2003/01/03 20:08:39  tng
  65.  * New feature StandardUriConformant to force strict standard uri conformance.
  66.  *
  67.  * Revision 1.6  2002/12/20 22:09:56  tng
  68.  * XML 1.1
  69.  *
  70.  * Revision 1.5  2002/12/03 15:31:19  knoaman
  71.  * Enable/disable calculation of src offset.
  72.  *
  73.  * Revision 1.4  2002/11/04 14:58:18  tng
  74.  * C++ Namespace Support.
  75.  *
  76.  * Revision 1.3  2002/08/22 19:28:11  tng
  77.  * [Bug 11448] DomCount has problems with XHTML1.1 DTD.
  78.  *
  79.  * Revision 1.2  2002/05/27 18:42:14  tng
  80.  * To get ready for 64 bit large file, use XMLSSize_t to represent line and column number.
  81.  *
  82.  * Revision 1.1.1.1  2002/02/01 22:21:58  peiyongz
  83.  * sane_include
  84.  *
  85.  * Revision 1.13  2001/07/12 18:50:08  tng
  86.  * Some performance modification regarding standalone check and xml decl check.
  87.  *
  88.  * Revision 1.12  2000/09/09 00:18:18  andyh
  89.  * Reordered member variables in ThrowEOEJanitor.  Patch submitted
  90.  * by Kirk Wylie.
  91.  *
  92.  * Revision 1.11  2000/07/08 00:17:13  andyh
  93.  * Cleanup of yesterday's speedup changes.  Merged new bit into the
  94.  * scanner character properties table.
  95.  *
  96.  * Revision 1.10  2000/07/07 01:08:44  andyh
  97.  * Parser speed up in scan of XML content.
  98.  *
  99.  * Revision 1.9  2000/03/02 19:54:29  roddey
  100.  * This checkin includes many changes done while waiting for the
  101.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  102.  * available elsewhere.
  103.  *
  104.  * Revision 1.8  2000/02/24 20:18:07  abagchi
  105.  * Swat for removing Log from API docs
  106.  *
  107.  * Revision 1.7  2000/02/24 02:12:53  aruna1
  108.  * ReaderMgr:;getReaderDepth() added
  109.  *
  110.  * Revision 1.6  2000/02/06 07:47:53  rahulj
  111.  * Year 2K copyright swat.
  112.  *
  113.  * Revision 1.5  2000/01/25 01:04:21  roddey
  114.  * Fixes a bogus error about ]]> in char data.
  115.  *
  116.  * Revision 1.4  2000/01/24 20:40:43  roddey
  117.  * Exposed the APIs to get to the byte offset in the source XML buffer. This stuff
  118.  * is not tested yet, but I wanted to get the API changes in now so that the API
  119.  * can be stablized.
  120.  *
  121.  * Revision 1.3  2000/01/12 00:15:04  roddey
  122.  * Changes to deal with multiply nested, relative pathed, entities and to deal
  123.  * with the new URL class changes.
  124.  *
  125.  * Revision 1.2  1999/12/15 19:48:03  roddey
  126.  * Changed to use new split of transcoder interfaces into XML transcoders and
  127.  * LCP transcoders, and implementation of intrinsic transcoders as pluggable
  128.  * transcoders, and addition of Latin1 intrinsic support.
  129.  *
  130.  * Revision 1.1.1.1  1999/11/09 01:08:13  twl
  131.  * Initial checkin
  132.  *
  133.  * Revision 1.4  1999/11/08 20:56:54  droddey
  134.  * If the main xml entity does not exist, we need to get the error handling for that
  135.  * inside the main XMLScanner::scanDocument() try block so that it gets reported
  136.  * in the normal way. We have to add a little extra safety code because, when this
  137.  * happens, there is no reader on the reader stack to get position ino from.
  138.  *
  139.  * Revision 1.3  1999/11/08 20:44:43  rahul
  140.  * Swat for adding in Product name and CVS comment log variable.
  141.  *
  142.  */
  143. #if !defined(READERMGR_HPP)
  144. #define READERMGR_HPP
  145. #include <xercesc/internal/XMLReader.hpp>
  146. #include <xercesc/util/PlatformUtils.hpp>
  147. #include <xercesc/util/RefStackOf.hpp>
  148. #include <xercesc/sax/Locator.hpp>
  149. #include <xercesc/framework/XMLBuffer.hpp>
  150. XERCES_CPP_NAMESPACE_BEGIN
  151. class XMLEntityDecl;
  152. class XMLEntityHandler;
  153. class XMLDocumentHandler;
  154. class XMLScanner;
  155. // ---------------------------------------------------------------------------
  156. //  This class is used by the scanner. The scanner must deal with expansion
  157. //  of entities, some of which are totally different files (external parsed
  158. //  entities.) It does so by pushing readers onto a stack. The top reader is
  159. //  the one it wants to read out of, but that one must be popped when it is
  160. //  empty. To keep that logic from being all over the place, the scanner
  161. //  talks to the reader manager, which handles the stack and popping off
  162. //  used up readers.
  163. // ---------------------------------------------------------------------------
  164. class XMLPARSER_EXPORT ReaderMgr :   public XMemory 
  165.                                    , public Locator
  166. {
  167. public :
  168.     // -----------------------------------------------------------------------
  169.     //  Class specific types
  170.     // -----------------------------------------------------------------------
  171.     struct LastExtEntityInfo : public XMemory
  172.     {
  173.         const   XMLCh*          systemId;
  174.         const   XMLCh*          publicId;
  175.                 XMLSSize_t      lineNumber;
  176.                 XMLSSize_t      colNumber;
  177.     };
  178.     // -----------------------------------------------------------------------
  179.     //  Constructors and Destructor
  180.     // -----------------------------------------------------------------------
  181.     ReaderMgr(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
  182.     ~ReaderMgr();
  183.     // -----------------------------------------------------------------------
  184.     //  Convenience scanning methods
  185.     //
  186.     //  This are all convenience methods that work in terms of the core
  187.     //  character spooling methods.
  188.     // -----------------------------------------------------------------------
  189.     bool atEOF() const;
  190.     bool getName(XMLBuffer& toFill);
  191.     bool getNameToken(XMLBuffer& toFill);
  192.     XMLCh getNextChar();
  193.     bool getNextCharIfNot(const XMLCh chNotToGet, XMLCh& chGotten);
  194.     void movePlainContentChars(XMLBuffer &dest);
  195.     void getSpaces(XMLBuffer& toFill);
  196.     void getUpToCharOrWS(XMLBuffer& toFill, const XMLCh toCheck);
  197.     bool isEmpty() const;
  198.     bool lookingAtChar(const XMLCh toCheck);
  199.     bool lookingAtSpace();
  200.     XMLCh peekNextChar();
  201.     bool skipIfQuote(XMLCh& chGotten);
  202.     void skipPastChar(const XMLCh toSkip);
  203.     bool skipPastSpaces();
  204.     void skipToChar(const XMLCh toSkipTo);
  205.     bool skippedChar(const XMLCh toSkip);
  206.     bool skippedSpace();
  207.     bool skippedString(const XMLCh* const toSkip);
  208.     void skipQuotedString(const XMLCh quoteCh);
  209.     XMLCh skipUntilIn(const XMLCh* const listToSkip);
  210.     XMLCh skipUntilInOrWS(const XMLCh* const listToSkip);
  211.     bool peekString(const XMLCh* const toPeek);
  212.     // -----------------------------------------------------------------------
  213.     //  Control methods
  214.     // -----------------------------------------------------------------------
  215.     void cleanStackBackTo(const unsigned int readerNum);
  216.     XMLReader* createReader
  217.     (
  218.         const   InputSource&        src
  219.         , const bool                xmlDecl
  220.         , const XMLReader::RefFrom  refFrom
  221.         , const XMLReader::Types    type
  222.         , const XMLReader::Sources  source
  223.         , const bool                calcSrsOfs = true
  224.     );
  225.     XMLReader* createReader
  226.     (
  227.         const   XMLCh* const        sysId
  228.         , const XMLCh* const        pubId
  229.         , const bool                xmlDecl
  230.         , const XMLReader::RefFrom  refFrom
  231.         , const XMLReader::Types    type
  232.         , const XMLReader::Sources  source
  233.         ,       InputSource*&       srcToFill
  234.         , const bool                calcSrcOfs = true
  235.     );
  236.     XMLReader* createReader
  237.     (
  238.         const   XMLCh* const        baseURI
  239.         , const XMLCh* const        sysId
  240.         , const XMLCh* const        pubId
  241.         , const bool                xmlDecl
  242.         , const XMLReader::RefFrom  refFrom
  243.         , const XMLReader::Types    type
  244.         , const XMLReader::Sources  source
  245.         ,       InputSource*&       srcToFill
  246.         , const bool                calcSrcOfs = true
  247.     );
  248.     XMLReader* createIntEntReader
  249.     (
  250.         const   XMLCh* const        sysId
  251.         , const XMLReader::RefFrom  refFrom
  252.         , const XMLReader::Types    type
  253.         , const XMLCh* const        dataBuf
  254.         , const unsigned int        dataLen
  255.         , const bool                copyBuf
  256.         , const bool                calcSrcOfs = true
  257.     );
  258.     bool isScanningPERefOutOfLiteral() const;
  259.     bool pushReader
  260.     (
  261.                 XMLReader* const        reader
  262.         ,       XMLEntityDecl* const    entity
  263.     );
  264.     void reset();
  265.     // -----------------------------------------------------------------------
  266.     //  Getter methods
  267.     // -----------------------------------------------------------------------
  268.     const XMLCh* getCurrentEncodingStr() const;
  269.     const XMLEntityDecl* getCurrentEntity() const;
  270.     XMLEntityDecl* getCurrentEntity();
  271.     const XMLReader* getCurrentReader() const;
  272.     XMLReader* getCurrentReader();
  273.     unsigned int getCurrentReaderNum() const;
  274.     unsigned int getReaderDepth() const;
  275.     void getLastExtEntityInfo(LastExtEntityInfo& lastInfo) const;
  276.     unsigned int getSrcOffset() const;
  277.     bool getThrowEOE() const;
  278.     // -----------------------------------------------------------------------
  279.     //  Setter methods
  280.     // -----------------------------------------------------------------------
  281.     void setEntityHandler(XMLEntityHandler* const newHandler);
  282.     void setThrowEOE(const bool newValue);
  283.     void setXMLVersion(const XMLReader::XMLVersion version);
  284.     void setStandardUriConformant(const bool newValue);
  285.     // -----------------------------------------------------------------------
  286.     //  Implement the SAX Locator interface
  287.     // -----------------------------------------------------------------------
  288.     virtual const XMLCh* getPublicId() const;
  289.     virtual const XMLCh* getSystemId() const;
  290.     virtual XMLSSize_t getLineNumber() const;
  291.     virtual XMLSSize_t getColumnNumber() const;
  292. private :
  293.     // -----------------------------------------------------------------------
  294.     //  Private helper methods
  295.     // -----------------------------------------------------------------------
  296.     const XMLReader* getLastExtEntity(const XMLEntityDecl*& itsEntity) const;
  297.     bool popReader();
  298.     // -----------------------------------------------------------------------
  299.     //  Private data members
  300.     //
  301.     //  fCurEntity
  302.     //      This is the current top of stack entity. We pull it off the stack
  303.     //      and store it here for efficiency.
  304.     //
  305.     //  fCurReader
  306.     //      This is the current top of stack reader. We pull it off the
  307.     //      stack and store it here for efficiency.
  308.     //
  309.     //  fEntityHandler
  310.     //      This is the installed entity handler. Its installed via the
  311.     //      scanner but he passes it on to us since we need it the most, in
  312.     //      process of creating external entity readers.
  313.     //
  314.     //  fEntityStack
  315.     //      We need to keep up with which of the pushed readers are pushed
  316.     //      entity values that are being spooled. This is done to avoid the
  317.     //      problem of recursive definitions. This stack consists of refs to
  318.     //      EntityDecl objects for the pushed entities.
  319.     //
  320.     //  fNextReaderNum
  321.     //      This is the reader serial number value. Each new reader that is
  322.     //      created from this reader is given a successive number. This lets
  323.     //      us catch things like partial markup errors and such.
  324.     //
  325.     //  fReaderStack
  326.     //      This is the stack of reader references. We own all the readers
  327.     //      and destroy them when they are used up.
  328.     //
  329.     //  fThrowEOE
  330.     //      This flag controls whether we throw an exception when we hit an
  331.     //      end of entity. The scanner doesn't really need to know about ends
  332.     //      of entities in the int/ext subsets, so it will turn this flag off
  333.     //      until it gets into the content usually.
  334.     //
  335.     //  fXMLVersion
  336.     //      Enum to indicate if each Reader should be created as XML 1.1 or
  337.     //      XML 1.0 conformant
  338.     //
  339.     //  fStandardUriConformant
  340.     //      This flag controls whether we force conformant URI
  341.     // -----------------------------------------------------------------------
  342.     XMLEntityDecl*              fCurEntity;
  343.     XMLReader*                  fCurReader;
  344.     XMLEntityHandler*           fEntityHandler;
  345.     RefStackOf<XMLEntityDecl>*  fEntityStack;
  346.     unsigned int                fNextReaderNum;
  347.     RefStackOf<XMLReader>*      fReaderStack;
  348.     bool                        fThrowEOE;
  349.     XMLReader::XMLVersion       fXMLVersion;
  350.     bool                        fStandardUriConformant;
  351.     MemoryManager*              fMemoryManager;
  352. };
  353. // ---------------------------------------------------------------------------
  354. //  ReaderMgr: Inlined methods
  355. //
  356. //  NOTE: We cannot put these in alphabetical and type order as we usually
  357. //  do because some of the compilers we have to support are too stupid to
  358. //  understand out of order inlines!
  359. // ---------------------------------------------------------------------------
  360. inline unsigned int ReaderMgr::getCurrentReaderNum() const
  361. {
  362.     return fCurReader->getReaderNum();
  363. }
  364. inline bool ReaderMgr::getName(XMLBuffer& toFill)
  365. {
  366.     toFill.reset();
  367.     return fCurReader->getName(toFill, false);
  368. }
  369. inline bool ReaderMgr::getNameToken(XMLBuffer& toFill)
  370. {
  371.     toFill.reset();
  372.     return fCurReader->getName(toFill, true);
  373. }
  374. inline bool ReaderMgr::getNextCharIfNot(const XMLCh chNotToGet, XMLCh& chGotten)
  375. {
  376.     return fCurReader->getNextCharIfNot(chNotToGet, chGotten);
  377. }
  378. inline void ReaderMgr::movePlainContentChars(XMLBuffer &dest)
  379. {
  380.     fCurReader->movePlainContentChars(dest);
  381. }
  382. inline bool ReaderMgr::getThrowEOE() const
  383. {
  384.     return fThrowEOE;
  385. }
  386. inline unsigned int ReaderMgr::getSrcOffset() const
  387. {
  388.     return fCurReader->getSrcOffset();
  389. }
  390. inline bool ReaderMgr::lookingAtChar(const XMLCh chToCheck)
  391. {
  392.     return (chToCheck == peekNextChar());
  393. }
  394. inline bool ReaderMgr::lookingAtSpace()
  395. {
  396.     XMLCh c = peekNextChar();
  397.     return fCurReader->isWhitespace(c);
  398. }
  399. inline void ReaderMgr::setThrowEOE(const bool newValue)
  400. {
  401.     fThrowEOE = newValue;
  402. }
  403. inline void ReaderMgr::setStandardUriConformant(const bool newValue)
  404. {
  405.     fStandardUriConformant = newValue;
  406. }
  407. inline bool ReaderMgr::skippedString(const XMLCh* const toSkip)
  408. {
  409.     return fCurReader->skippedString(toSkip);
  410. }
  411. inline void ReaderMgr::skipToChar(const XMLCh toSkipTo)
  412. {
  413.     while (true)
  414.     {
  415.         // Get chars until we find the one to skip
  416.         const XMLCh nextCh = getNextChar();
  417.         // Break out at end of input or the char to skip
  418.         if ((nextCh == toSkipTo) || !nextCh)
  419.             break;
  420.     }
  421. }
  422. inline void ReaderMgr::skipPastChar(const XMLCh toSkipPast)
  423. {
  424.     while (true)
  425.     {
  426.         // Get chars until we find the one to skip
  427.         const XMLCh nextCh = getNextChar();
  428.         if ((nextCh == toSkipPast) || !nextCh)
  429.             break;
  430.     }
  431. }
  432. inline bool ReaderMgr::peekString(const XMLCh* const toPeek)
  433. {
  434.     return fCurReader->peekString(toPeek);
  435. }
  436. inline void ReaderMgr::setEntityHandler(XMLEntityHandler* const newHandler)
  437. {
  438.     fEntityHandler = newHandler;
  439. }
  440. inline void ReaderMgr::setXMLVersion(const XMLReader::XMLVersion version)
  441. {
  442.     fXMLVersion = version;
  443.     fCurReader->setXMLVersion(version);
  444. }
  445. //
  446. //  This is a simple class to temporarily change the 'throw at end of entity'
  447. //  flag of the reader manager. There are some places where we need to
  448. //  turn this on and off on a scoped basis.
  449. //
  450. class XMLPARSER_EXPORT ThrowEOEJanitor
  451. {
  452. public :
  453.     // -----------------------------------------------------------------------
  454.     //  Constructors and destructor
  455.     // -----------------------------------------------------------------------
  456.     ThrowEOEJanitor(ReaderMgr* mgrTarget, const bool newValue) :
  457.         fOld(mgrTarget->getThrowEOE())
  458.         , fMgr(mgrTarget)
  459.     {
  460.         mgrTarget->setThrowEOE(newValue);
  461.     }
  462.     ~ThrowEOEJanitor()
  463.     {
  464.         fMgr->setThrowEOE(fOld);
  465.     };
  466. private :
  467.     // -----------------------------------------------------------------------
  468.     //  Private data members
  469.     //
  470.     //  fOld
  471.     //      The previous value of the flag, which we replaced during ctor,
  472.     //      and will replace during dtor.
  473.     //
  474.     //  fMgr
  475.     //      A pointer to the reader manager we are going to set/reset the
  476.     //      flag on.
  477.     // -----------------------------------------------------------------------
  478.     bool        fOld;
  479.     ReaderMgr*  fMgr;
  480. };
  481. XERCES_CPP_NAMESPACE_END
  482. #endif