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

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

Changes to icxercesc files

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