source: icXML/icXML-devel/src/icxercesc/internal/XMLScanner.hpp @ 3157

Last change on this file since 3157 was 3157, checked in by cameron, 6 years ago

Fixes for icXML 0.9

File size: 48.3 KB
RevLine 
[2720]1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: XMLScanner.hpp 882548 2009-11-20 13:44:14Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_XMLSCANNER_HPP)
23#define XERCESC_INCLUDE_GUARD_XMLSCANNER_HPP
24
[3157]25#include <icxercesc/framework/XMLBufferMgr.hpp>
[2720]26#include <xercesc/framework/XMLErrorCodes.hpp>
27#include <xercesc/framework/XMLRefInfo.hpp>
[2721]28#include <icxercesc/util/PlatformUtils.hpp>
[2720]29#include <xercesc/util/NameIdPool.hpp>
[2721]30#include <icxercesc/util/RefHashTableOf.hpp>
[2720]31#include <xercesc/util/SecurityManager.hpp>
[2721]32#include <icxercesc/internal/ReaderMgr.hpp>
33#include <icxercesc/internal/ElemStack.hpp>
[3104]34#include <icxercesc/validators/DTD/DTDEntityDecl.hpp>
[2721]35#include <icxercesc/framework/XMLAttr.hpp>
[2720]36#include <xercesc/framework/ValidationContext.hpp>
[2721]37#include <icxercesc/validators/common/GrammarResolver.hpp>
[2720]38#include <icxmlc/XMLSymbol.hpp>
39#include <icxmlc/XMLConfig.hpp>
40#include <icxmlc/XMLMultiliteral.h>
41#include <icxmlc/XMLNamespaceResolver.hpp>
42#include <icxmlc/XMLAttributeList.hpp>
[3103]43#include <icxmlc/parsers/XMLDocumentAccumulator.hpp>
[3104]44#include <icxercesc/framework/XMLDocumentHandler.hpp>
[2720]45
46#define MOVE_BUFFERS_OUT_OF_XMLSCANNER
47
48#define MOVE_DUPLICATE_ATTRIBUTE_CHECK_OUT_OF_XMLSCANNER
49
50#define XML_SCANNER_CONTAINS_ENTIRE_ATTRLIST
51
52XERCES_CPP_NAMESPACE_BEGIN
53
54class InputSource;
[2807]55// class XMLDocumentHandler;
[2720]56class XMLEntityHandler;
57class ErrorHandler;
58class DocTypeHandler;
59class XMLPScanToken;
60class XMLStringPool;
61class Grammar;
62class XMLValidator;
63class MemoryManager;
64class PSVIHandler;
65class XMLElementDecl;
66class XMLReferenceTable;
[3157]67class SAXParser;
68class SAX2XMLReaderImpl;
69class AbstractDOMParser;
[2720]70
71
72//  This is the mondo scanner class, which does the vast majority of the
73//  work of parsing. It handles reading in input and spitting out events
74//  to installed handlers.
75class XMLPARSER_EXPORT XMLScanner : public XMemory, public XMLBufferFullHandler
76{
77        friend class XMLSymbolTable;
78        friend class XMLReader;
79        template<class XMLScanner> friend class XMLParserImpl;
80        friend class XMLReferenceTable;
81
82public :
83        // -----------------------------------------------------------------------
84        //  Public class types
85        //
86        //  NOTE: These should really be private, but some of the compilers we
87        //  have to deal with are too stupid to understand this.
88        //
89        //  DeclTypes
90        //      Used by scanXMLDecl() to know what type of decl it should scan.
91        //      Text decls have slightly different rules from XMLDecls.
92        //
93        //  EntityExpRes
94        //      These are the values returned from the entity expansion method,
95        //      to indicate how it went.
96        //
97        //  XMLTokens
98        //      These represent the possible types of input we can get while
99        //      scanning content.
100        //
101        //  ValScheme
102        //      This indicates what the scanner should do in terms of validation.
103        //      'Auto' means if there is any int/ext subset, then validate. Else,
104        //      don't.
105        // -----------------------------------------------------------------------
106        enum DeclTypes
107        {
108                Decl_Text
109                , Decl_XML
110        };
111
112        enum EntityExpRes
113        {
114                EntityExp_Pushed
115                , EntityExp_Returned
116                , EntityExp_Failed
117        };
118
119        enum XMLTokens
120        {
121                Token_CData
122                , Token_CharData
123                , Token_Comment
124                , Token_EndTag
125                , Token_EOF
126                , Token_PI
127                , Token_StartTag
128                , Token_Unknown
129        };
130
131        enum ValSchemes
132        {
133                Val_Never
134                , Val_Always
135                , Val_Auto
136        };
137
138
139        // -----------------------------------------------------------------------
140        //  Constructors and Destructor
141        // -----------------------------------------------------------------------
142        XMLScanner
143        (
144                XMLValidator* const valToAdopt
145                , GrammarResolver* const grammarResolver
146                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
147        );
148        XMLScanner
149        (
150                XMLDocumentHandler* const  docHandler
151                , DocTypeHandler* const    docTypeHandler
152                , XMLEntityHandler* const  entityHandler
153                , XMLErrorReporter* const  errReporter
154                , XMLValidator* const      valToAdopt
155                , GrammarResolver* const grammarResolver
156                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
157        );
158        virtual ~XMLScanner();
159
160
161        // -----------------------------------------------------------------------
162        //  Error emitter methods
163        // -----------------------------------------------------------------------
164        bool emitErrorWillThrowException(const XMLErrs::Codes toEmit);
[3103]165
[2720]166        void emitError(const XMLErrs::Codes toEmit);
167
168        void emitError
169        (
170                const XMLErrs::Codes toEmit
171                , const XMLFileLoc line
172                , const XMLFileLoc col
173        );
174
175        void emitError
176        (
177                const   XMLErrs::Codes    toEmit
178                , const XMLCh* const        text1
179                , const XMLCh* const        text2 = 0
180                , const XMLCh* const        text3 = 0
181                , const XMLCh* const        text4 = 0
182        );
[3103]183
[2720]184        void emitError
185        (
186                const   XMLErrs::Codes    toEmit
187                , const char* const         text1
188                , const char* const         text2 = 0
189                , const char* const         text3 = 0
190                , const char* const         text4 = 0
191        );
192        void emitError
193        (
194                const   XMLErrs::Codes    toEmit
195                , const XMLExcepts::Codes   originalErrorCode
196                , const XMLCh* const        text1 = 0
197                , const XMLCh* const        text2 = 0
198                , const XMLCh* const        text3 = 0
199                , const XMLCh* const        text4 = 0
200
201        );
202
203        // -----------------------------------------------------------------------
204        //  Implementation of XMLBufferFullHandler interface
205        // -----------------------------------------------------------------------
206
207        virtual bool bufferFull(XMLBuffer& toSend)
208        {
209                sendCharData(toSend);
210                return true;
211        }
212
213        virtual Grammar::GrammarType getCurrentGrammarType() const;
214
215        // -----------------------------------------------------------------------
216        //  Public pure virtual methods
217        // -----------------------------------------------------------------------
218        virtual const XMLCh* getName() const = 0;
219        virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool() = 0;
220        virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const = 0;
221        virtual void scanDocument
222        (
223                const   InputSource&    src
224        ) = 0;
225        virtual bool scanNext(XMLPScanToken& toFill) = 0;
226        virtual Grammar* loadGrammar
227        (
228                const   InputSource&    src
229                , const short           grammarType
230                , const bool            toCache = false
231        ) = 0;
232
233        virtual void resetCachedGrammar ();
234
235        // -----------------------------------------------------------------------
236        //  Getter methods
237        // -----------------------------------------------------------------------
238        const XMLDocumentHandler* getDocHandler() const;
239        XMLDocumentHandler* getDocHandler();
240        const DocTypeHandler* getDocTypeHandler() const;
241        DocTypeHandler* getDocTypeHandler();
242        bool getDoNamespaces() const;
243        ValSchemes getValidationScheme() const;
244        bool getDoSchema() const;
245        bool getValidationSchemaFullChecking() const;
246        bool getIdentityConstraintChecking() const;
247        const XMLEntityHandler* getEntityHandler() const;
248        XMLEntityHandler* getEntityHandler();
249        const XMLErrorReporter* getErrorReporter() const;
250        XMLErrorReporter* getErrorReporter();
251        const ErrorHandler* getErrorHandler() const;
252        ErrorHandler* getErrorHandler();
253        const PSVIHandler* getPSVIHandler() const;
254        PSVIHandler* getPSVIHandler();
255        bool getExitOnFirstFatal() const;
256        bool getValidationConstraintFatal() const;
257        RefHashTableOf<XMLRefInfo>* getIDRefList();
258        const RefHashTableOf<XMLRefInfo>* getIDRefList() const;
259
260        ValidationContext*   getValidationContext();
261
262        bool getInException() const;
263        /*bool getLastExtLocation
264        (
265                                XMLCh* const    sysIdToFill
266                , const unsigned int    maxSysIdChars
267                ,       XMLCh* const    pubIdToFill
268                , const unsigned int    maxPubIdChars
269                ,       XMLSSize_t&     lineToFill
270                ,       XMLSSize_t&     colToFill
271        ) const;*/
272        const Locator* getLocator() const;
273        const ReaderMgr* getReaderMgr() const;
274        XMLFilePos getSrcOffset() const;
275        bool getStandalone() const;
276        const XMLValidator* getValidator() const;
277        XMLValidator* getValidator();
278        int getErrorCount();
279        const XMLStringPool* getURIStringPool() const;
280        XMLStringPool* getURIStringPool();
281        bool getHasNoDTD() const;
282        XMLCh* getExternalSchemaLocation() const;
283        XMLCh* getExternalNoNamespaceSchemaLocation() const;
284        SecurityManager* getSecurityManager() const;
285        bool getLoadExternalDTD() const;
286        bool getLoadSchema() const;
287        bool getNormalizeData() const;
288        bool isCachingGrammarFromParse() const;
289        bool isUsingCachedGrammarInParse() const;
290        bool getCalculateSrcOfs() const;
291        Grammar* getRootGrammar() const;
292        XMLReader::XMLVersion getXMLVersion() const;
293        MemoryManager* getMemoryManager() const;
[2807]294
[2720]295        unsigned int getPrefixId(const XMLCh* const prefix) const;
296        const XMLCh* getPrefixForId(unsigned int prefId) const;
297
298        // Return is a reference so that we can return it as void* from
299        // getProperty.
300        //
301        const XMLSize_t& getLowWaterMark() const;
302
303        bool getGenerateSyntheticAnnotations() const;
304        bool getValidateAnnotations() const;
305        bool getIgnoreCachedDTD() const;
306        bool getIgnoreAnnotations() const;
307        bool getDisableDefaultEntityResolution() const;
308        bool getSkipDTDValidation() const;
309        bool getHandleMultipleImports() const;
310
[3103]311
[2720]312        // -----------------------------------------------------------------------
313        //  Getter methods
314        // -----------------------------------------------------------------------
315        /**
316          * When an attribute name has no prefix, unlike elements, it is not mapped
317          * to the global namespace. So, in order to have something to map it to
318          * for practical purposes, a id for an empty URL is created and used for
319          * such names.
320          *
321          * @return The URL pool id of the URL for an empty URL "".
322          */
323        unsigned int getEmptyNamespaceId() const;
324
325        /**
326          * When a prefix is found that has not been mapped, an error is issued.
327          * However, if the parser has been instructed not to stop on the first
328          * fatal error, it needs to be able to continue. To do so, it will map
329          * that prefix tot his magic unknown namespace id.
330          *
331          * @return The URL pool id of the URL for the unknown prefix
332          *         namespace.
333          */
334        unsigned int getUnknownNamespaceId() const;
335
336        /**
337          * The prefix 'xml' is a magic prefix, defined by the XML spec and
338          * requiring no prior definition. This method returns the id for the
339          * intrinsically defined URL for this prefix.
340          *
341          * @return The URL pool id of the URL for the 'xml' prefix.
342          */
343        unsigned int getXMLNamespaceId() const;
344
345        /**
346          * The prefix 'xmlns' is a magic prefix, defined by the namespace spec
347          * and requiring no prior definition. This method returns the id for the
348          * intrinsically defined URL for this prefix.
349          *
350          * @return The URL pool id of the URL for the 'xmlns' prefix.
351          */
352        unsigned int getXMLNSNamespaceId() const;
353
354        /**
355          * This method find the passed URI id in its URI pool and
356          * copy the text of that URI into the passed buffer.
357          */
358        bool getURIText
359        (
360                const   unsigned int    uriId
361                ,       XMLBuffer&      uriBufToFill
362        )   const;
363
364        const XMLCh* getURIText(const unsigned int uriId) const;
365
[2774]366    unsigned int getNamespaceURIId(const unsigned int namespaceId) const;
367
368    const XMLCh* getPrefixForNamespaceId(const unsigned int namespaceId) const;
369
[3103]370    unsigned int getURIIdForPrefix(const XMLCh* prefix) const;
371
[2720]372        const XMLCh* getURIForPrefix(const XMLCh* prefix) const;
373
[2807]374    const XMLCh* getURIForQName(const XMLCh* qName, int & colonPos) const;
375
[2774]376    BindingSetIterator getNamespaceIterator() const;
377
[2720]378        bool isPrefixKnown(const XMLCh* prefix) const;
379
380        /* tell if the validator comes from user */
381        bool isValidatorFromUser();
382
383        /* tell if standard URI are forced */
384        bool getStandardUriConformant() const;
385
386        // -----------------------------------------------------------------------
387        //  Setter methods
388        // -----------------------------------------------------------------------
389        void addGlobalPrefix(const XMLCh* const prefix, const unsigned int uriId);
390        void setDocHandler(XMLDocumentHandler* const docHandler);
391        void setDocTypeHandler(DocTypeHandler* const docTypeHandler);
392        void setDoNamespaces(const bool doNamespaces);
393        void setEntityHandler(XMLEntityHandler* const docTypeHandler);
394        void setErrorReporter(XMLErrorReporter* const errHandler);
395        void setErrorHandler(ErrorHandler* const handler);
396        void setPSVIHandler(PSVIHandler* const handler);
397        void setURIStringPool(XMLStringPool* const stringPool);
398        void setExitOnFirstFatal(const bool newValue);
399        void setValidationConstraintFatal(const bool newValue);
400        void setValidationScheme(const ValSchemes newScheme);
401        void setValidator(XMLValidator* const valToAdopt);
402        void setDoSchema(const bool doSchema);
403        void setValidationSchemaFullChecking(const bool schemaFullChecking);
404        void setIdentityConstraintChecking(const bool identityConstraintChecking);
405        void setHasNoDTD(const bool hasNoDTD);
406        void cacheGrammarFromParse(const bool newValue);
407        void useCachedGrammarInParse(const bool newValue);
408        void setRootElemName(XMLCh* rootElemName);
409        void setExternalSchemaLocation(const XMLCh* const schemaLocation);
410        void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
411        void setExternalSchemaLocation(const char* const schemaLocation);
412        void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
413        void setSecurityManager(SecurityManager* const securityManager);
414        void setLoadExternalDTD(const bool loadDTD);
415        void setLoadSchema(const bool loadSchema);
416        void setNormalizeData(const bool normalizeData);
417        void setCalculateSrcOfs(const bool newValue);
418        void setParseSettings(XMLScanner* const refScanner);
419        void setStandardUriConformant(const bool newValue);
420        void setInputBufferSize(const XMLSize_t bufferSize);
421
422        void setLowWaterMark(XMLSize_t newValue);
423
424        void setGenerateSyntheticAnnotations(const bool newValue);
425        void setValidateAnnotations(const bool newValue);
426        void setIgnoredCachedDTD(const bool newValue);
427        void setIgnoreAnnotations(const bool newValue);
428        void setDisableDefaultEntityResolution(const bool newValue);
429        void setSkipDTDValidation(const bool newValue);
430        void setHandleMultipleImports(const bool newValue);
431
[3157]432
[2720]433        // -----------------------------------------------------------------------
434        //  Mutator methods
435        // -----------------------------------------------------------------------
436        void incrementErrorCount(void);                 // For use by XMLValidator
437
438        // -----------------------------------------------------------------------
439        //  Document scanning methods
440        //
441        //  scanDocument() does the entire source document. scanFirst(),
442        //  scanNext(), and scanReset() support a progressive parse.
443        // -----------------------------------------------------------------------
444        void scanDocument
445        (
446                const   XMLCh* const    systemId
447        );
[3157]448
[2720]449        void scanDocument
450        (
451                const   char* const     systemId
452        );
453
454        bool scanFirst
455        (
456                const   InputSource&    src
457                ,       XMLPScanToken&  toFill
458        );
[3157]459
[2720]460        bool scanFirst
461        (
462                const   XMLCh* const    systemId
463                ,       XMLPScanToken&  toFill
464        );
[3157]465
[2720]466        bool scanFirst
467        (
468                const   char* const     systemId
469                ,       XMLPScanToken&  toFill
470        );
471
472        void scanReset(XMLPScanToken& toFill);
473
474        bool checkXMLDecl(bool startWithAngle);
475
476        // -----------------------------------------------------------------------
477        //  Grammar preparsing methods
478        // -----------------------------------------------------------------------
479        Grammar* loadGrammar
480        (
481                const   XMLCh* const    systemId
482                , const short           grammarType
483                , const bool            toCache = false
484        );
485        Grammar* loadGrammar
486        (
487                const   char* const     systemId
488                , const short           grammarType
489                , const bool            toCache = false
490        );
491
492        // -----------------------------------------------------------------------
493        //  Helper methods
494        // -----------------------------------------------------------------------
495        unsigned int resolveQName
496        (
497                const   XMLCh* const        qName
498                ,       XMLBuffer&          prefixBufToFill
499                , const ElemStack::MapModes mode
500                ,       int&                prefixColonPos
501        );
502
503
504        // -----------------------------------------------------------------------
[2807]505    //  DEPRECATED IN ICXML BUT KEPT FOR DLL COMPATIBILITY
[2720]506        // -----------------------------------------------------------------------
507
[2807]508    inline void setAttrDupChkRegistry(const XMLSize_t &, bool &);
[2720]509
[2807]510    ValueVectorOf<PrefMapElem*>* getNamespaceContext() const;
[2720]511
512public:
513
514        // -----------------------------------------------------------------------
515        //  Parabix scanning methods
516        // -----------------------------------------------------------------------
517
[2807]518    IDISA_ALWAYS_INLINE
519    void handleComment
[2720]520        (
521                const XMLCh       *                             comment
522                , const XMLSize_t                               length
[3103]523        , XMLDocumentAccumulator &      parser
[2720]524        );
525
[2807]526    IDISA_ALWAYS_INLINE
527    void handlePI
[2720]528        (
[3103]529        const XMLCh   * const           target
530        , const XMLCh     *             data
531        , const XMLSize_t                               length
532        , XMLDocumentAccumulator &      parser
[2720]533        );
534
[2807]535    IDISA_ALWAYS_INLINE
536    void handleIgnorableWhitespace
[2720]537        (
538                const XMLCh       *                             whitespace
539                , const XMLSize_t                               length
[3103]540        , XMLDocumentAccumulator &      parser
[2720]541        );
542
[2807]543    IDISA_ALWAYS_INLINE
[3103]544    bool preValidateDefaultAttribute(const QName &, const QName &, const bool) const
[2807]545    {
[3103]546        return true;
[2807]547    }
[2720]548
549
[2807]550    inline void loadExternalGrammars();
551
[2720]552        virtual const DTDGrammar * getDTDGrammar() const
553        {
554                return NULL;
555        }
556
[3103]557    virtual bool expandEntityReference
558    (
559        const XMLCh *                   entityReference
560        , const XMLSize_t               length
561        , const bool                    inAttributeValue
562        , XMLBuffer &                   toFill
563        , bool      &                   isPredefined
[3150]564        , bool      &                   isExternal
[3103]565        , XMLFileLoc &                  line
566        , XMLFileLoc &                  column
567    );
[2720]568
[3103]569    inline bool getHasInternalOrExternalDTD() const;
[2720]570
[3103]571    inline void setUriResolver(XMLNamespaceResolver * uriResolver);
[2720]572
573        inline XMLNamespaceResolver * getUriResolver();
574
575        inline void setContextId(const unsigned int contextId);
576
577        inline unsigned int getContextId() const;
578
579protected:
580
581        void handleXMLDecl
582        (
583                XMLCh *                                         decl
584                , const XMLSize_t                       length
585                , const bool                            XMLDecl
586        );
587
[3103]588    virtual void scanFirst() {}
[2720]589
590        // -----------------------------------------------------------------------
591        //  ICXML
592        // -----------------------------------------------------------------------
593
594        inline static int resolveQNameColonPosition
595        (
596                const   XMLCh* const        qName
597                , const XMLSize_t           length
598                ,       int          &      prefixColonPos
599        );
600
601        // -----------------------------------------------------------------------
602        //  Protected pure virtual methods
603        // -----------------------------------------------------------------------
604        virtual void scanCDSection() = 0;
605        virtual void scanCharData(XMLBuffer& toToUse) = 0;
606        virtual EntityExpRes scanEntityRef
607        (
608                const   bool    inAttVal
609                ,       XMLCh&  firstCh
610                ,       XMLCh&  secondCh
611                ,       bool&   escaped
612        ) = 0;
613        virtual void scanDocTypeDecl() = 0;
614        virtual void scanReset(const InputSource& src) = 0;
615        virtual void sendCharData(XMLBuffer& toSend) = 0;
616
617        //return owned by the caller
618        virtual InputSource* resolveSystemId(const XMLCh* const /*sysId*/
[3103]619                                        ,const XMLCh* const /*pubId*/) {return 0;}
[2720]620
621        // -----------------------------------------------------------------------
622        //  Protected scanning methods
623        // -----------------------------------------------------------------------
624        bool scanCharRef(XMLBuffer & toFill);
625        bool scanCharRef(XMLCh& toFill, XMLCh& second);
626        void scanComment();
627        bool scanEq(bool inDecl = false);
628        void scanMiscellaneous();
629        void scanPI();
630        void scanProlog();
631        void scanXMLDecl(const DeclTypes type);
632
[3103]633    // -----------------------------------------------------------------------
634    //  Protected error handling methods
635    // -----------------------------------------------------------------------
636    void reportUndefinedAttribute(unsigned int uriId, const QName * attributeName, const XMLElementDecl & element);
637
638
[2720]639        // -----------------------------------------------------------------------
640        //  Private helper methods
641        // -----------------------------------------------------------------------
642        void checkInternalDTD(bool hasExtSubset, const XMLCh* const sysId, const XMLCh* const pubId);
643        void checkIDRefs();
644        bool isLegalToken(const XMLPScanToken& toCheck);
645        XMLTokens senseNextToken(XMLSize_t& orgReader);
646        void initValidator(XMLValidator* theValidator);
647        inline void resetValidationContext();
648        unsigned int *getNewUIntPtr();
649        void resetUIntPool();
650        void recreateUIntPool();
651
652        unsigned int resolvePrefix
653        (
654                const   XMLCh* const        prefix
655                , const ElemStack::MapModes mode
656        );
657
658        unsigned int resolveQNameWithColon
659        (
660                const   XMLCh* const        qName
661                ,       XMLBuffer&          prefixBufToFill
662                , const ElemStack::MapModes mode
663                , const int                 prefixColonPos
664        );
665
[3150]666    void popReader();
667
[2720]668        // -----------------------------------------------------------------------
669        //  Data members
670        //
671        //  fBufferSize
672        //      Maximum input buffer size
673        //
674        //  fLowWaterMark
675        //      The low water mark for the raw byte buffer.
676        //
677        //  fAttrList
678        //      Every time we get a new element start tag, we have to pass to
679        //      the document handler the attributes found. To make it more
680        //      efficient we keep this ref vector of XMLAttr objects around. We
681        //      just reuse it over and over, allowing it to grow to meet the
682        //      peak need.
683        //
684        //  fBufMgr
685        //      This is a manager for temporary buffers used during scanning.
686        //      For efficiency we must use a set of static buffers, but we have
687        //      to insure that they are not incorrectly reused. So this manager
688        //      provides the smarts to hand out buffers as required.
689        //
690        //  fDocHandler
691        //      The client code's document handler. If zero, then no document
692        //      handler callouts are done. We don't adopt it.
693        //
694        //  fDocTypeHandler
695        //      The client code's document type handler (used by DTD Validator).
696        //
697        //  fDoNamespaces
698        //      This flag indicates whether the client code wants us to do
699        //      namespaces or not. If the installed validator indicates that it
700        //      has to do namespaces, then this is ignored.
701        //
702        //  fEntityHandler
703        //      The client code's entity handler. If zero, then no entity handler
704        //      callouts are done. We don't adopt it.
705        //
706        //  fErrorReporter
707        //      The client code's error reporter. If zero, then no error reporter
708        //      callouts are done. We don't adopt it.
709        //
710        //  fErrorHandler
711        //      The client code's error handler.  Need to store this info for
712        //      Schema parse error handling.
713        //
714        //  fPSVIHandler
715        //      The client code's PSVI handler.
716        //
717        //  fExitOnFirstFatal
718        //      This indicates whether we bail out on the first fatal XML error
719        //      or not. It defaults to true, which is the strict XML way, but it
720        //      can be changed.
721        //
722        //  fValidationConstraintFatal
723        //      This indicates whether we treat validation constraint errors as
724        //      fatal errors or not. It defaults to false, but it can be changed.
725        //
726        //  fIDRefList
727        //      This is a list of XMLRefInfo objects. This member lets us do all
728        //      needed ID-IDREF balancing checks.
729        //
730        //  fInException
731        //      To avoid a circular freakout when we catch an exception and emit
732        //      it, which would normally throw again if the 'fail on first error'
733        //      flag is one.
734        //
735        //  fReaderMgr
736        //      This is the reader manager, from which we get characters. It
737        //      manages the reader stack for us, and provides a lot of convenience
738        //      methods to do specialized checking for chars, sequences of chars,
739        //      skipping chars, etc...
740        //
741        //  fScannerId
742        //  fSequenceId
743        //      These are used for progressive parsing, to make sure that the
744        //      client code does the right thing at the right time.
745        //
746        //  fStandalone
747        //      Indicates whether the document is standalone or not. Defaults to
748        //      no, but can be overridden in the XMLDecl.
749        //
750        //  fHasNoDTD
751        //      Indicates the document has no DTD or has only an internal DTD subset
752        //      which contains no parameter entity references.
753        //
754        //  fValidate
755        //      Indicates whether any validation should be done. This is defined
756        //      by the existence of a Grammar together with fValScheme.
757        //
758        //  fValidator
759        //      The installed validator. We look at them via the abstract
760        //      validator interface, and don't know what it actual is.
761        //      Either point to user's installed validator, or fDTDValidator
762        //      or fSchemaValidator.
763        //
764        //  fValidatorFromUser
765        //      This flag indicates whether the validator was installed from
766        //      user.  If false, then the validator was created by the Scanner.
767        //
768        //  fValScheme
769        //      This is the currently set validation scheme. It defaults to
770        //      'never', but can be set by the client.
771        //
772        //  fErrorCount
773        //              The number of errors we've encountered.
774        //
775        //  fDoSchema
776        //      This flag indicates whether the client code wants Schema to
777        //      be processed or not.
778        //
779        //  fSchemaFullChecking
780        //      This flag indicates whether the client code wants full Schema
781        //      constraint checking.
782        //
783        //  fIdentityConstraintChecking
784        //      This flag indicates whether the client code wants Identity
785        //      Constraint checking, defaulted to true to maintain backward
786        //      compatibility (to minimize supprise)
787        //
788        //  fAttName
789        //  fAttValue
790        //  fCDataBuf
791        //  fNameBuf
792        //  fQNameBuf
793        //  fPrefixBuf
794        //      For the most part, buffers are obtained from the fBufMgr object
795        //      on the fly. However, for the start tag scan, we have a set of
796        //      fixed buffers for performance reasons. These are used a lot and
797        //      there are a number of them, so asking the buffer manager each
798        //      time for new buffers is a bit too much overhead.
799        //
800        //  fEmptyNamespaceId
801        //      This is the id of the empty namespace URI. This is a special one
802        //      because of the xmlns="" type of deal. We have to quickly sense
803        //      that its the empty namespace.
804        //
805        //  fUnknownNamespaceId
806        //      This is the id of the namespace URI which is assigned to the
807        //      global namespace. Its for debug purposes only, since there is no
808        //      real global namespace URI. Its set by the derived class.
809        //
810        //  fXMLNamespaceId
811        //  fXMLNSNamespaceId
812        //      These are the ids of the namespace URIs which are assigned to the
813        //      'xml' and 'xmlns' special prefixes. The former is officially
814        //      defined but the latter is not, so we just provide one for debug
815        //      purposes.
816        //
817        //  fSchemaNamespaceId
818        //      This is the id of the schema namespace URI.
819        //
820        //  fGrammarResolver
821        //      Grammar Pool that stores all the grammars. Key is namespace for
822        //      schema and system id for external DTD. When caching a grammar, if
823        //      a grammar is already in the pool, it will be replaced with the
824        //      new parsed one.
825        //
826        //  fGrammar
827        //      Current Grammar used by the Scanner and Validator
828        //
829        //  fRootGrammar
830        //      The grammar where the root element is declared.
831        //
832        //  fGrammarType
833        //      Current Grammar Type.  Store this value instead of calling getGrammarType
834        //      all the time for faster performance.
835        //
836        //  fURIStringPool
837        //      This is a pool for URIs with unique ids assigned. We use a standard
838        //      string pool class.  This pool is going to be shared by all Grammar.
839        //      Use only if namespace is turned on.
840        //
841        //  fRootElemName
842        //      No matter we are using DTD or Schema Grammar, if a DOCTYPE exists,
843        //      we need to verify the root element name.  So store the rootElement
844        //      that is used in the DOCTYPE in the Scanner instead of in the DTDGrammar
845        //      where it used to
846        //
847        //  fExternalSchemaLocation
848        //      The list of Namespace/SchemaLocation that was specified externally
849        //      using setExternalSchemaLocation.
850        //
851        //  fExternalNoNamespaceSchemaLocation
852        //      The no target namespace XML Schema Location that was specified
853        //      externally using setExternalNoNamespaceSchemaLocation.
854        //
855        //  fSecurityManager
856        //      The SecurityManager instance; as and when set by the application.
857        //
858        //  fEntityExpansionLimit
859        //      The number of entity expansions to be permitted while processing this document
860        //      Only meaningful when fSecurityManager != 0
861        //
862        //  fEntityExpansionCount
863        //      The number of general entities expanded so far in this document.
864        //      Only meaningful when fSecurityManager != null
865        //
866        //  fLoadExternalDTD
867        //      This flag indicates whether the external DTD be loaded or not
868        //
869        //  fLoadSchema
870        //      This flag indicates whether the parser should attempt to load
871        //      schemas if they cannot be found in the grammar pool.
872        //
873        //  fNormalizeData
874        //      This flag indicates whether the parser should perform datatype
875        //      normalization that is defined in the schema.
876        //
877        //  fCalculateSrcOfs
878        //      This flag indicates the parser should calculate the source offset.
879        //      Turning this on may impact performance.
880        //
881        //  fStandardUriConformant
882        //      This flag controls whether we force conformant URI
883        //
884        //  fXMLVersion
885        //      Enum to indicate if the main doc is XML 1.1 or XML 1.0 conformant
886        //  fUIntPool
887        //      pool of unsigned integers to help with duplicate attribute
888        //      detection and filling in default/fixed attributes
889        //  fUIntPoolRow
890        //      current row in fUIntPool
891        //  fUIntPoolCol
892        //      current column in row
893        //  fUIntPoolRowTotal
894        //      total number of rows in table
895        //
896        //  fMemoryManager
897        //      Pluggable memory manager for dynamic allocation/deallocation.
898        //
899        // -----------------------------------------------------------------------
900
901        XMLSize_t                   fLowWaterMark;
902        bool                        fStandardUriConformant;
903        bool                        fCalculateSrcOfs;
904        bool                        fDoNamespaces;
905        bool                        fExitOnFirstFatal;
906        bool                        fValidationConstraintFatal;
907        bool                        fInException;
908        bool                        fStandalone;
909        bool                        fHasNoDTD;
[3103]910    bool                        fHasInternalOrExternalDTD;
[2720]911        bool                        fValidate;
912        bool                        fValidatorFromUser;
913        bool                        fDoSchema;
914        bool                        fSchemaFullChecking;
915        bool                        fIdentityConstraintChecking;
916        bool                        fToCacheGrammar;
917        bool                        fUseCachedGrammar;
918        bool                        fLoadExternalDTD;
919        bool                        fLoadSchema;
920        bool                        fNormalizeData;
921        bool                        fGenerateSyntheticAnnotations;
922        bool                        fValidateAnnotations;
923        bool                        fIgnoreCachedDTD;
924        bool                        fIgnoreAnnotations;
925        bool                        fDisableDefaultEntityResolution;
926        bool                        fSkipDTDValidation;
927        bool                        fHandleMultipleImports;
928        int                         fErrorCount;
929        XMLSize_t                   fEntityExpansionLimit;
930        XMLSize_t                   fEntityExpansionCount;
931        XMLUInt32                   fScannerId;
932        XMLUInt32                   fSequenceId;
933        XMLDocumentHandler*         fDocHandler;
934        DocTypeHandler*             fDocTypeHandler;
935        XMLEntityHandler*           fEntityHandler;
936        XMLErrorReporter*           fErrorReporter;
937        ErrorHandler*               fErrorHandler;
938        PSVIHandler*                fPSVIHandler;
939        ValidationContext           *fValidationContext;
940        bool                        fEntityDeclPoolRetrieved;
941        ReaderMgr                   fReaderMgr;
942        XMLValidator*               fValidator;
943        ValSchemes                  fValScheme;
944        GrammarResolver* const      fGrammarResolver;
945        MemoryManager* const        fGrammarPoolMemoryManager;
946        Grammar*                    fGrammar;
947        Grammar*                    fRootGrammar;
948        XMLNamespaceResolver *          fUriResolver;
949        XMLCh *                                         fRootElemName;
950        XMLCh*                      fExternalSchemaLocation;
951        XMLCh*                      fExternalNoNamespaceSchemaLocation;
952        SecurityManager*            fSecurityManager;
953        XMLReader::XMLVersion       fXMLVersion;
954        MemoryManager*              fMemoryManager;
955        XMLBufferMgr                fBufMgr;
956        ElemStack                   fElemStack;
957        unsigned int                            fContextId;
958
959private :
960        // -----------------------------------------------------------------------
961        //  Unimplemented constructors and operators
962        // -----------------------------------------------------------------------
963        XMLScanner();
964        XMLScanner(const XMLScanner&);
965        XMLScanner& operator=(const XMLScanner&);
966
967        // -----------------------------------------------------------------------
968        //  Private helper methods
969        // -----------------------------------------------------------------------
970        void commonInit();
971        void cleanUp();
972
973        // -----------------------------------------------------------------------
974        //  Private scanning methods
975        // -----------------------------------------------------------------------
976        bool getQuotedString(XMLBuffer& toFill);
977
978        XMLSize_t scanUpToWSOr
979        (
980                                XMLBuffer&  toFill
981                , const XMLCh       chEndChar
982        );
983};
984
985// ---------------------------------------------------------------------------
986//  XMLScanner: Getter methods
987// ---------------------------------------------------------------------------
988inline const XMLDocumentHandler* XMLScanner::getDocHandler() const
989{
990        return fDocHandler;
991}
992
993inline XMLDocumentHandler* XMLScanner::getDocHandler()
994{
995        return fDocHandler;
996}
997
998inline const DocTypeHandler* XMLScanner::getDocTypeHandler() const
999{
1000        return fDocTypeHandler;
1001}
1002
1003inline DocTypeHandler* XMLScanner::getDocTypeHandler()
1004{
1005        return fDocTypeHandler;
1006}
1007
1008inline bool XMLScanner::getDoNamespaces() const
1009{
1010        return fDoNamespaces;
1011}
1012
1013inline const XMLEntityHandler* XMLScanner::getEntityHandler() const
1014{
1015        return fEntityHandler;
1016}
1017
1018inline XMLEntityHandler* XMLScanner::getEntityHandler()
1019{
1020        return fEntityHandler;
1021}
1022
1023inline const XMLErrorReporter* XMLScanner::getErrorReporter() const
1024{
1025        return fErrorReporter;
1026}
1027
1028inline XMLErrorReporter* XMLScanner::getErrorReporter()
1029{
1030        return fErrorReporter;
1031}
1032
1033inline const ErrorHandler* XMLScanner::getErrorHandler() const
1034{
1035        return fErrorHandler;
1036}
1037
1038inline ErrorHandler* XMLScanner::getErrorHandler()
1039{
1040        return fErrorHandler;
1041}
1042
1043inline const PSVIHandler* XMLScanner::getPSVIHandler() const
1044{
1045        return fPSVIHandler;
1046}
1047
1048inline PSVIHandler* XMLScanner::getPSVIHandler()
1049{
1050        return fPSVIHandler;
1051}
1052
1053inline bool XMLScanner::getExitOnFirstFatal() const
1054{
1055        return fExitOnFirstFatal;
1056}
1057
1058inline bool XMLScanner::getValidationConstraintFatal() const
1059{
1060        return fValidationConstraintFatal;
1061}
1062
1063inline bool XMLScanner::getInException() const
1064{
1065        return fInException;
1066}
1067
1068inline RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList()
1069{
1070        return fValidationContext->getIdRefList();
1071}
1072
1073inline const RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList() const
1074{
1075        return fValidationContext->getIdRefList();
1076}
1077
1078inline ValidationContext*  XMLScanner::getValidationContext()
1079{
1080        if (!fEntityDeclPoolRetrieved)
1081        {
1082                fValidationContext->setEntityDeclPool(getEntityDeclPool());
1083                fEntityDeclPoolRetrieved = true;
1084        }
1085
1086        return fValidationContext;
1087}
1088
1089inline const Locator* XMLScanner::getLocator() const
1090{
1091        return &fReaderMgr;
1092}
1093
1094inline const ReaderMgr* XMLScanner::getReaderMgr() const
1095{
1096        return &fReaderMgr;
1097}
1098
1099inline XMLFilePos XMLScanner::getSrcOffset() const
1100{
1101        return fReaderMgr.getSrcOffset();
1102}
1103
1104inline bool XMLScanner::getStandalone() const
1105{
1106        return fStandalone;
1107}
1108
1109inline XMLScanner::ValSchemes XMLScanner::getValidationScheme() const
1110{
1111        return fValScheme;
1112}
1113
1114inline const XMLValidator* XMLScanner::getValidator() const
1115{
1116        return fValidator;
1117}
1118
1119inline XMLValidator* XMLScanner::getValidator()
1120{
1121        return fValidator;
1122}
1123
1124inline bool XMLScanner::getDoSchema() const
1125{
1126        return fDoSchema;
1127}
1128
1129inline bool XMLScanner::getValidationSchemaFullChecking() const
1130{
1131        return fSchemaFullChecking;
1132}
1133
1134inline bool XMLScanner::getIdentityConstraintChecking() const
1135{
1136        return fIdentityConstraintChecking;
1137}
1138
1139inline int XMLScanner::getErrorCount()
1140{
1141        return fErrorCount;
1142}
1143
1144inline bool XMLScanner::isValidatorFromUser()
1145{
1146        return fValidatorFromUser;
1147}
1148
1149inline unsigned int XMLScanner::getEmptyNamespaceId() const
1150{
1151        return XMLNamespaceResolver::fEmptyUriId;
1152}
1153
1154inline unsigned int XMLScanner::getUnknownNamespaceId() const
1155{
1156        return XMLNamespaceResolver::fUnknownUriId;
1157}
1158
1159inline unsigned int XMLScanner::getXMLNamespaceId() const
1160{
1161        return XMLNamespaceResolver::fXMLUriId;
1162}
1163
1164inline bool XMLScanner::getHasNoDTD() const
1165{
1166        return fHasNoDTD;
1167}
1168
[3103]1169inline bool XMLScanner::getHasInternalOrExternalDTD() const
1170{
1171    return fHasInternalOrExternalDTD;
1172}
1173
[2720]1174inline XMLCh* XMLScanner::getExternalSchemaLocation() const
1175{
1176        return fExternalSchemaLocation;
1177}
1178
1179inline XMLCh* XMLScanner::getExternalNoNamespaceSchemaLocation() const
1180{
1181        return fExternalNoNamespaceSchemaLocation;
1182}
1183
1184inline SecurityManager* XMLScanner::getSecurityManager() const
1185{
1186        return fSecurityManager;
1187}
1188
1189inline bool XMLScanner::getLoadExternalDTD() const
1190{
1191        return fLoadExternalDTD;
1192}
1193
1194inline bool XMLScanner::getLoadSchema() const
1195{
1196        return fLoadSchema;
1197}
1198
1199inline bool XMLScanner::getNormalizeData() const
1200{
1201        return fNormalizeData;
1202}
1203
1204inline bool XMLScanner::isCachingGrammarFromParse() const
1205{
1206        return fToCacheGrammar;
1207}
1208
1209inline bool XMLScanner::isUsingCachedGrammarInParse() const
1210{
1211        return fUseCachedGrammar;
1212}
1213
1214inline bool XMLScanner::getCalculateSrcOfs() const
1215{
1216        return fCalculateSrcOfs;
1217}
1218
1219inline Grammar* XMLScanner::getRootGrammar() const
1220{
1221        return fRootGrammar;
1222}
1223
1224inline bool XMLScanner::getStandardUriConformant() const
1225{
1226        return fStandardUriConformant;
1227}
1228
1229inline XMLReader::XMLVersion XMLScanner::getXMLVersion() const
1230{
1231                return fXMLVersion;
1232}
1233
1234inline MemoryManager* XMLScanner::getMemoryManager() const
1235{
1236        return fMemoryManager;
1237}
1238
1239inline unsigned int XMLScanner::getPrefixId(const XMLCh* const prefix) const
1240{
[2807]1241    int colonPos;
1242    return fUriResolver->resolvePrefixId(prefix, colonPos);
[2720]1243}
1244
1245inline const XMLCh* XMLScanner::getPrefixForId(unsigned int prefId) const
1246{
1247        return fUriResolver->getPrefixForId(prefId);
1248}
1249
1250inline bool XMLScanner::getGenerateSyntheticAnnotations() const
1251{
1252        return fGenerateSyntheticAnnotations;
1253}
1254
1255inline bool XMLScanner::getValidateAnnotations() const
1256{
1257        return fValidateAnnotations;
1258}
1259
1260inline const XMLSize_t& XMLScanner::getLowWaterMark() const
1261{
1262        return fLowWaterMark;
1263}
1264
1265inline bool XMLScanner::getIgnoreCachedDTD() const
1266{
1267        return fIgnoreCachedDTD;
1268}
1269
1270inline bool XMLScanner::getIgnoreAnnotations() const
1271{
1272        return fIgnoreAnnotations;
1273}
1274
1275inline bool XMLScanner::getDisableDefaultEntityResolution() const
1276{
1277        return fDisableDefaultEntityResolution;
1278}
1279
1280inline bool XMLScanner::getSkipDTDValidation() const
1281{
1282        return fSkipDTDValidation;
1283}
1284
1285inline bool XMLScanner::getHandleMultipleImports() const
1286{
1287        return fHandleMultipleImports;
1288}
1289
1290// ---------------------------------------------------------------------------
1291//  XMLScanner: Setter methods
1292// ---------------------------------------------------------------------------
1293inline void XMLScanner::addGlobalPrefix(const XMLCh* const prefix, const unsigned int uriId)
1294{
1295        fElemStack.addGlobalPrefix(prefix, uriId);
1296}
1297
1298inline void XMLScanner::setDocHandler(XMLDocumentHandler* const docHandler)
1299{
1300        fDocHandler = docHandler;
1301}
1302
1303inline void XMLScanner::setDocTypeHandler(DocTypeHandler* const docTypeHandler)
1304{
1305        fDocTypeHandler = docTypeHandler;
1306}
1307
1308inline void XMLScanner::setErrorHandler(ErrorHandler* const handler)
1309{
1310        fErrorHandler = handler;
1311}
1312
1313inline void XMLScanner::setPSVIHandler(PSVIHandler* const handler)
1314{
1315        fPSVIHandler = handler;
1316}
1317
1318inline void XMLScanner::setEntityHandler(XMLEntityHandler* const entityHandler)
1319{
1320        fEntityHandler = entityHandler;
1321        fReaderMgr.setEntityHandler(entityHandler);
1322}
1323
1324inline void XMLScanner::setErrorReporter(XMLErrorReporter* const errHandler)
1325{
1326        fErrorReporter = errHandler;
1327}
1328
1329inline void XMLScanner::setExitOnFirstFatal(const bool newValue)
1330{
1331        fExitOnFirstFatal = newValue;
1332}
1333
1334
1335inline void XMLScanner::setValidationConstraintFatal(const bool newValue)
1336{
1337        fValidationConstraintFatal = newValue;
1338}
1339
1340inline void XMLScanner::setValidationScheme(const ValSchemes newScheme)
1341{
1342        fValScheme = newScheme;
1343
1344        // validation flag for Val_Auto is set to false by default,
1345        //   and will be turned to true if a grammar is seen
1346        if (fValScheme == Val_Always)
1347                fValidate = true;
1348        else
1349                fValidate = false;
1350}
1351
1352inline void XMLScanner::setDoSchema(const bool doSchema)
1353{
1354        fDoSchema = doSchema;
1355}
1356
1357inline void XMLScanner::setDoNamespaces(const bool doNamespaces)
1358{
1359        fDoNamespaces = doNamespaces;
1360}
1361
1362inline void XMLScanner::setValidationSchemaFullChecking(const bool schemaFullChecking)
1363{
1364        fSchemaFullChecking = schemaFullChecking;
1365}
1366
1367inline void XMLScanner::setIdentityConstraintChecking(const bool identityConstraintChecking)
1368{
1369        fIdentityConstraintChecking = identityConstraintChecking;
1370}
1371
1372inline void XMLScanner::setHasNoDTD(const bool hasNoDTD)
1373{
1374        fHasNoDTD = hasNoDTD;
1375}
1376
1377inline void XMLScanner::setRootElemName(XMLCh* rootElemName)
1378{
1379        fMemoryManager->deallocate(fRootElemName);
1380        fRootElemName = XMLString::replicate(rootElemName, fMemoryManager);
1381}
1382
1383inline void XMLScanner::setExternalSchemaLocation(const XMLCh* const schemaLocation)
1384{
1385        fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
1386        fExternalSchemaLocation = XMLString::replicate(schemaLocation, fMemoryManager);
1387}
1388
1389inline void XMLScanner::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
1390{
1391        fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
1392        fExternalNoNamespaceSchemaLocation = XMLString::replicate(noNamespaceSchemaLocation, fMemoryManager);
1393}
1394
1395inline void XMLScanner::setExternalSchemaLocation(const char* const schemaLocation)
1396{
1397        fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
1398        fExternalSchemaLocation = XMLString::transcode(schemaLocation, fMemoryManager);
1399}
1400
1401inline void XMLScanner::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
1402{
1403        fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
1404        fExternalNoNamespaceSchemaLocation = XMLString::transcode(noNamespaceSchemaLocation, fMemoryManager);
1405}
1406
1407inline void XMLScanner::setSecurityManager(SecurityManager* const securityManager)
1408{
1409        fSecurityManager = securityManager;
1410        if(securityManager != 0)
1411        {
1412                fEntityExpansionLimit = securityManager->getEntityExpansionLimit();
1413                fEntityExpansionCount = 0;
1414        }
1415}
1416
1417inline void XMLScanner::setLoadExternalDTD(const bool loadDTD)
1418{
1419        fLoadExternalDTD = loadDTD;
1420}
1421
1422inline void XMLScanner::setLoadSchema(const bool loadSchema)
1423{
1424        fLoadSchema = loadSchema;
1425}
1426
1427inline void XMLScanner::setNormalizeData(const bool normalizeData)
1428{
1429        fNormalizeData = normalizeData;
1430}
1431
1432inline void XMLScanner::cacheGrammarFromParse(const bool newValue)
1433{
1434        fToCacheGrammar = newValue;
1435}
1436
1437inline void XMLScanner::useCachedGrammarInParse(const bool newValue)
1438{
1439        fUseCachedGrammar = newValue;
1440}
1441
1442inline void XMLScanner::setCalculateSrcOfs(const bool newValue)
1443{
1444        fCalculateSrcOfs = newValue;
1445}
1446
1447inline void XMLScanner::setStandardUriConformant(const bool newValue)
1448{
1449        fStandardUriConformant = newValue;
1450        fReaderMgr.setStandardUriConformant(newValue);
1451}
1452
1453inline void XMLScanner::setGenerateSyntheticAnnotations(const bool newValue)
1454{
1455        fGenerateSyntheticAnnotations = newValue;
1456}
1457
1458inline void XMLScanner::setValidateAnnotations(const bool newValue)
1459{
1460        fValidateAnnotations = newValue;
1461}
1462
1463inline void XMLScanner::setLowWaterMark(XMLSize_t newValue)
1464{
1465        fLowWaterMark = newValue;
1466}
1467
1468inline void XMLScanner::setIgnoredCachedDTD(const bool newValue)
1469{
1470        fIgnoreCachedDTD = newValue;
1471}
1472
1473inline void XMLScanner::setIgnoreAnnotations(const bool newValue)
1474{
1475        fIgnoreAnnotations = newValue;
1476}
1477
1478inline void XMLScanner::setDisableDefaultEntityResolution(const bool newValue)
1479{
1480        fDisableDefaultEntityResolution = newValue;
1481}
1482
1483inline void XMLScanner::setSkipDTDValidation(const bool newValue)
1484{
1485        fSkipDTDValidation = newValue;
1486}
1487
1488inline void XMLScanner::setHandleMultipleImports(const bool newValue)
1489{
1490        fHandleMultipleImports = newValue;
1491}
1492
1493// ---------------------------------------------------------------------------
1494//  XMLScanner: Mutator methods
1495// ---------------------------------------------------------------------------
1496inline void XMLScanner::incrementErrorCount()
1497{
1498        ++fErrorCount;
1499}
1500
1501inline void XMLScanner::resetValidationContext()
1502{
1503        fValidationContext->clearIdRefList();
1504        fValidationContext->setEntityDeclPool(0);
1505        fEntityDeclPoolRetrieved = false;
1506}
1507
1508inline Grammar::GrammarType XMLScanner::getCurrentGrammarType() const
1509{
1510        return Grammar::UnKnown;
1511}
1512
1513// ---------------------------------------------------------------------------
[2807]1514//  XMLPARSER CALLBACK METHODS
1515// ---------------------------------------------------------------------------
1516
1517void XMLScanner::handlePI
1518(
[3103]1519    const XMLCh   * const           target
1520    , const XMLCh     *             data
1521    , const XMLSize_t               length
1522    , XMLDocumentAccumulator &      parser
[2807]1523)
1524{
1525    // If we have a handler, then call it
[3103]1526    parser.writePI(target, data, length);
[2807]1527}
1528
1529// --------------------------------------------------------------------------------------------------------
1530
1531void XMLScanner::handleComment
1532(
[3103]1533    const XMLCh       *             comment
1534    , const XMLSize_t               length
1535    , XMLDocumentAccumulator &      parser
[2807]1536)
1537{
1538    //mark comment is seen within the current element
[3103]1539    parser.writeComment(comment, length);
[2807]1540}
1541
1542// --------------------------------------------------------------------------------------------------------
1543
1544void XMLScanner::handleIgnorableWhitespace
1545(
[3103]1546    const XMLCh       *             whitespace
1547    , const XMLSize_t               length
1548    , XMLDocumentAccumulator &      parser
[2807]1549)
1550{
[3103]1551    parser.writeIgnorableWhitespace(whitespace, length);
[2807]1552}
1553
1554// --------------------------------------------------------------------------------------------------------
1555
1556void XMLScanner::loadExternalGrammars()
1557{
1558    /* DO NOTHING! */
1559}
1560
1561// ---------------------------------------------------------------------------
[2720]1562//  NAMESPACE HANDLING METHODS
1563// ---------------------------------------------------------------------------
1564inline unsigned int XMLScanner::getXMLNSNamespaceId() const
1565{
1566    return XMLNamespaceResolver::fXMLNSUriId;
1567}
1568
[2774]1569inline unsigned int XMLScanner::getNamespaceURIId(const unsigned int namespaceId) const
1570{
1571    return fUriResolver->getNamespaceUriId(namespaceId);
1572}
1573
1574inline const XMLCh* XMLScanner::getPrefixForNamespaceId(const unsigned int namespaceId) const
1575{
1576    return fUriResolver->getPrefixForNamespaceId(namespaceId);
1577}
1578
[3103]1579inline unsigned int XMLScanner::getURIIdForPrefix(const XMLCh* prefix) const
1580{
1581    return fUriResolver->getUriIdForPrefix(prefix, getContextId());
1582}
1583
[2720]1584inline const XMLCh* XMLScanner::getURIForPrefix(const XMLCh* prefix) const
1585{
[3103]1586    return fUriResolver->getUriForPrefix(prefix, getContextId());
[2720]1587}
1588
[2807]1589inline const XMLCh* XMLScanner::getURIForQName(const XMLCh* qName, int & colonPos) const
1590{
[3103]1591    return fUriResolver->getUriForQName(qName, getContextId(), colonPos);
[2807]1592}
1593
[2720]1594inline bool XMLScanner::isPrefixKnown(const XMLCh* prefix) const
1595{
[3103]1596    return fUriResolver->isPrefixVisible(prefix, getContextId());
[2720]1597}
1598
[2774]1599inline BindingSetIterator XMLScanner::getNamespaceIterator() const
1600{
[3103]1601    return fUriResolver->getNamespaceIterator(getContextId());
[2774]1602}
1603
[2720]1604inline void XMLScanner::setUriResolver(XMLNamespaceResolver * uriResolver)
1605{
1606    fUriResolver = uriResolver;
1607}
1608
1609inline XMLNamespaceResolver * XMLScanner::getUriResolver()
1610{
1611    return fUriResolver;
1612}
1613
1614inline void XMLScanner::setContextId(const unsigned int contextId)
1615{
1616    fContextId = contextId;
1617}
1618
1619inline unsigned int XMLScanner::getContextId() const
1620{
1621    return fContextId;
1622}
1623
[3150]1624inline void XMLScanner::popReader()
1625{
1626    fReaderMgr.popReader();
1627}
1628
[2720]1629// ---------------------------------------------------------------------------
1630//  DEPRECATED BUT KEPT FOR DLL COMPATIBILITY
1631// ---------------------------------------------------------------------------
1632inline void XMLScanner::setAttrDupChkRegistry(const XMLSize_t &, bool &)
1633{
1634        DEPRECATED_FEATURE_IN_ICXML;
1635}
1636
1637inline void XMLScanner::setInputBufferSize(const XMLSize_t bufferSize)
1638{
1639        DEPRECATED_FEATURE_IN_ICXML;
1640}
1641
1642inline const XMLStringPool* XMLScanner::getURIStringPool() const
1643{
1644    DEPRECATED_FEATURE_IN_ICXML;
1645}
1646
1647inline XMLStringPool* XMLScanner::getURIStringPool()
1648{
1649    DEPRECATED_FEATURE_IN_ICXML;
1650}
1651
1652inline ValueVectorOf<PrefMapElem*>* XMLScanner::getNamespaceContext() const
1653{
1654    DEPRECATED_FEATURE_IN_ICXML;
1655}
1656
1657#ifdef USE_SMART_QNAME_MANAGER
1658inline void XMLScanner::setQNameBuilder(QNameBuilder * qNameBuilder)
1659{
1660        fQNameBuilder = qNameBuilder;
1661}
1662
1663inline QNameBuilder * XMLScanner::getQNameBuilder()
1664{
1665        return fQNameBuilder;
1666}
1667#endif
1668
1669XERCES_CPP_NAMESPACE_END
1670
1671#endif
Note: See TracBrowser for help on using the repository browser.