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

Last change on this file since 2720 was 2720, checked in by cameron, 7 years ago

Initial check-in of icXML 0.8 source files

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