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

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

Updates for various icxercesc modified files.

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