source: icXML/icXML-devel/src/icxercesc/internal/SGXMLScanner.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: 12.1 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: SGXMLScanner.hpp 882548 2009-11-20 13:44:14Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_SGXMLSCANNER_HPP)
23#define XERCESC_INCLUDE_GUARD_SGXMLSCANNER_HPP
24
25#include <xercesc/internal/XMLScanner.hpp>
26#include <xercesc/util/KVStringPair.hpp>
27#include <xercesc/util/ValueHashTableOf.hpp>
28#include <xercesc/util/RefHash2KeysTableOf.hpp>
29#include <xercesc/util/RefHash3KeysIdPool.hpp>
30#include <xercesc/util/Hash2KeysSetOf.hpp>
31#include <xercesc/validators/common/Grammar.hpp>
32#include <xercesc/validators/schema/SchemaInfo.hpp>
33#include <xercesc/validators/schema/SchemaElementDecl.hpp>
34
35
36XERCES_CPP_NAMESPACE_BEGIN
37
38class SchemaGrammar;
39class SchemaValidator;
40class IdentityConstraintHandler;
41class IdentityConstraint;
42class ContentLeafNameTypeVector;
43class SchemaAttDef;
44class XMLContentModel;
45class XSModel;
46class PSVIAttributeList;
47class PSVIElement;
48
49//  This is a scanner class, which process XML Schema grammar.
50class XMLPARSER_EXPORT SGXMLScanner : public XMLScanner
51{
52public :
53    // -----------------------------------------------------------------------
54    //  Constructors and Destructor
55    // -----------------------------------------------------------------------
56    SGXMLScanner
57    (
58        XMLValidator* const       valToAdopt
59        , GrammarResolver* const grammarResolver
60        , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
61    );
62    SGXMLScanner
63    (
64        XMLDocumentHandler* const docHandler
65        , DocTypeHandler* const   docTypeHandler
66        , XMLEntityHandler* const entityHandler
67        , XMLErrorReporter* const errReporter
68        , XMLValidator* const     valToAdopt
69        , GrammarResolver* const  grammarResolver
70        , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
71    );
72    virtual ~SGXMLScanner();
73
74    // -----------------------------------------------------------------------
75    //  XMLScanner public virtual methods
76    // -----------------------------------------------------------------------
77    virtual const XMLCh* getName() const;
78    virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool();
79    virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const;
80    virtual void scanDocument
81    (
82        const   InputSource&    src
83    );
84    virtual bool scanNext(XMLPScanToken& toFill);
85    virtual Grammar* loadGrammar
86    (
87        const   InputSource&    src
88        , const short           grammarType
89        , const bool            toCache = false
90    );
91
92    virtual void resetCachedGrammar ();
93    virtual Grammar::GrammarType getCurrentGrammarType() const;
94
95protected:
96    // -----------------------------------------------------------------------
97    //  XMLScanner virtual methods
98    // -----------------------------------------------------------------------
99
100    virtual void scanReset(const InputSource& src);
101
102
103    // -----------------------------------------------------------------------
104    //  SGXMLScanner virtual methods
105    // -----------------------------------------------------------------------
106    virtual bool scanStartTag(bool& gotData);
107    virtual void scanEndTag(bool& gotData);
108
109    // -----------------------------------------------------------------------
110    //  Helper methods
111    // -----------------------------------------------------------------------
112    XMLSize_t buildAttList
113    (
114        const   RefVectorOf<KVStringPair>&  providedAttrs
115        , const XMLSize_t                   attCount
116        ,       XMLElementDecl*             elemDecl
117        ,       RefVectorOf<XMLAttr>&       toFill
118    );
119    bool laxElementValidation(QName* element, ContentLeafNameTypeVector* cv,
120                              const XMLContentModel* const cm,
121                              const XMLSize_t parentElemDepth);
122    XMLSize_t rawAttrScan
123    (
124        const   XMLCh* const                elemName
125        ,       RefVectorOf<KVStringPair>&  toFill
126        ,       bool&                       isEmpty
127    );
128    void updateNSMap
129    (
130        const   XMLCh* const    attrName
131        , const XMLCh* const    attrValue
132    );
133    void resizeElemState();
134
135    void updateNSMap
136    (
137        const   XMLCh* const    attrName
138        , const XMLCh* const    attrValue
139        , const int             colonPosition
140    );
141    void resizeRawAttrColonList();
142    // -----------------------------------------------------------------------
143    //  Data members
144    //
145    //  fRawAttrList
146    //      During the initial scan of the attributes we can only do a raw
147    //      scan for key/value pairs. So this vector is used to store them
148    //      until they can be processed (and put into fAttrList.)
149    //
150    //  fSchemaValidator
151    //      The Schema validator instance.
152    //
153    //  fSeeXsi
154    //      This flag indicates a schema has been seen.
155    //
156    //  fElemState
157    //  fElemLoopState
158    //  fElemStateSize
159    //      Stores an element next state from DFA content model - used for
160    //      wildcard validation
161    //
162    // fElemNonDeclPool
163    //      registry for elements without decls in the grammar
164    // fElemCount
165    //      count of the number of start tags seen so far (starts at 1).
166    //      Used for duplicate attribute detection/processing of required/defaulted attributes
167    // fAttDefRegistry
168    //      mapping from XMLAttDef instances to the count of the last
169    //      start tag where they were utilized.
170    // fUndeclaredAttrRegistry
171    //      set of namespaceId/localName pairs to detect duplicates
172    // fPSVIAttrList
173    //      PSVI attribute list implementation that needs to be
174    //      filled when a PSVIHandler is registered
175    // fSchemaInfoList
176    //      Transient schema info list that is passed to TraverseSchema instances.
177    // fCachedSchemaInfoList
178    //      Cached Schema info list that is passed to TraverseSchema instances.
179    //
180    // -----------------------------------------------------------------------
181    bool                                    fSeeXsi;
182    Grammar::GrammarType                    fGrammarType;
183    unsigned int                            fElemStateSize;
184    unsigned int*                           fElemState;
185    unsigned int*                           fElemLoopState;
186    XMLBuffer                               fContent;
187    ValueHashTableOf<XMLCh>*                fEntityTable;
188    RefVectorOf<KVStringPair>*              fRawAttrList;
189    unsigned int                            fRawAttrColonListSize;
190    int*                                    fRawAttrColonList;
191    SchemaGrammar*                          fSchemaGrammar;
192    SchemaValidator*                        fSchemaValidator;
193    IdentityConstraintHandler*              fICHandler;
194    RefHash3KeysIdPool<SchemaElementDecl>*  fElemNonDeclPool;
195    unsigned int                            fElemCount;
196    RefHashTableOf<unsigned int, PtrHasher>*fAttDefRegistry;
197    Hash2KeysSetOf<StringHasher>*           fUndeclaredAttrRegistry;
198    PSVIAttributeList *                     fPSVIAttrList;
199    XSModel*                                fModel;
200    PSVIElement*                            fPSVIElement;
201    ValueStackOf<bool>*                     fErrorStack;
202    PSVIElemContext                         fPSVIElemContext;
203    RefHash2KeysTableOf<SchemaInfo>*        fSchemaInfoList;
204    RefHash2KeysTableOf<SchemaInfo>*        fCachedSchemaInfoList;
205
206#ifdef MOVE_BUFFERS_OUT_OF_XMLSCANNER
207    XMLBuffer                   fAttNameBuf;
208    XMLBuffer                   fAttValueBuf;
209    XMLBuffer                   fCDataBuf;
210    XMLBuffer                   fQNameBuf;
211    XMLBuffer                   fPrefixBuf;
212    XMLBuffer                   fURIBuf;
213    XMLBuffer                   fWSNormalizeBuf;
214#endif
215
216private :
217    // -----------------------------------------------------------------------
218    //  Unimplemented constructors and operators
219    // -----------------------------------------------------------------------
220    SGXMLScanner();
221    SGXMLScanner(const SGXMLScanner&);
222    SGXMLScanner& operator=(const SGXMLScanner&);
223
224    // -----------------------------------------------------------------------
225    //  XMLScanner virtual methods
226    // -----------------------------------------------------------------------
227    virtual void scanCDSection();
228    virtual void scanCharData(XMLBuffer& toToUse);
229    virtual EntityExpRes scanEntityRef
230    (
231        const   bool    inAttVal
232        ,       XMLCh&  firstCh
233        ,       XMLCh&  secondCh
234        ,       bool&   escaped
235    );
236    virtual void scanDocTypeDecl();
237    virtual void sendCharData(XMLBuffer& toSend);
238    virtual InputSource* resolveSystemId(const XMLCh* const sysId
239                                        ,const XMLCh* const pubId);
240
241    // -----------------------------------------------------------------------
242    //  Private helper methods
243    // -----------------------------------------------------------------------
244    void commonInit();
245    void cleanUp();
246
247    bool normalizeAttValue
248    (
249        const   XMLAttDef* const    attDef
250        , const XMLCh* const        attrName
251        , const XMLCh* const        value
252        ,       XMLBuffer&          toFill
253    );
254    bool normalizeAttRawValue
255    (
256        const   XMLCh* const        attrName
257        , const XMLCh* const        value
258        ,       XMLBuffer&          toFill
259    );
260    void scanRawAttrListforNameSpaces(XMLSize_t attCount);
261    void parseSchemaLocation(const XMLCh* const schemaLocationStr, bool ignoreLoadSchema = false);
262    void resolveSchemaGrammar(const XMLCh* const loc, const XMLCh* const uri, bool ignoreLoadSchema = false);
263    bool switchGrammar(const XMLCh* const newGrammarNameSpace);
264    bool anyAttributeValidation(SchemaAttDef* attWildCard,
265                                unsigned int uriId,
266                                bool& skipThisOne,
267                                bool& laxThisOne);
268
269    // -----------------------------------------------------------------------
270    //  Private scanning methods
271    // -----------------------------------------------------------------------
272    bool basicAttrValueScan
273    (
274        const   XMLCh* const    attrName
275        ,       XMLBuffer&      toFill
276    );
277    bool scanAttValue
278    (
279        const   XMLAttDef* const    attDef
280        ,       XMLBuffer&          toFill
281    );
282    bool scanContent();
283
284    // -----------------------------------------------------------------------
285    //  IdentityConstraints Activation methods
286    // -----------------------------------------------------------------------
287    inline bool toCheckIdentityConstraint()  const;
288
289    // -----------------------------------------------------------------------
290    //  Grammar preparsing methods
291    // -----------------------------------------------------------------------
292    Grammar* loadXMLSchemaGrammar(const InputSource& src, const bool toCache = false);
293
294    // -----------------------------------------------------------------------
295    //  PSVI handling methods
296    // -----------------------------------------------------------------------
297    void endElementPSVI(SchemaElementDecl* const elemDecl,
298                        DatatypeValidator* const memberDV);
299
300    void resetPSVIElemContext();
301};
302
303inline const XMLCh* SGXMLScanner::getName() const
304{
305    return XMLUni::fgSGXMLScanner;
306}
307
308inline bool SGXMLScanner::toCheckIdentityConstraint()  const
309{
310    return fValidate && fIdentityConstraintChecking && fICHandler;
311}
312
313inline Grammar::GrammarType SGXMLScanner::getCurrentGrammarType() const
314{
315    return fGrammarType;
316}
317
318XERCES_CPP_NAMESPACE_END
319
320#endif
Note: See TracBrowser for help on using the repository browser.