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

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

Various fixes

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