source: icXML/icXML-devel/src/icxercesc/internal/SGXMLScanner.hpp @ 3153

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

Updates for build

File size: 15.3 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 <icxercesc/internal/XMLScanner.hpp>
26#include <xercesc/util/KVStringPair.hpp>
27#include <icxercesc/util/ValueHashTableOf.hpp>
28#include <xercesc/util/RefHash2KeysTableOf.hpp>
29#include <xercesc/util/RefHash3KeysIdPool.hpp>
30#include <xercesc/util/Hash2KeysSetOf.hpp>
31#include <icxercesc/validators/common/Grammar.hpp>
32#include <icxercesc/validators/schema/SchemaInfo.hpp>
33#include <icxercesc/validators/schema/SchemaElementDecl.hpp>
34#include <icxmlc/parsers/XMLDocumentAccumulator.hpp>
35#include <icxmlc/XMLSymbol.hpp>
36#include <icxmlc/XMLConfig.hpp>
37
38XERCES_CPP_NAMESPACE_BEGIN
39
40class SchemaGrammar;
41class SchemaValidator;
42class IdentityConstraintHandler;
43class IdentityConstraint;
44class ContentLeafNameTypeVector;
45class SchemaAttDef;
46class XMLContentModel;
47class XSModel;
48class PSVIAttributeList;
49class PSVIElement;
50
51//  This is a scanner class, which process XML Schema grammar.
52class XMLPARSER_EXPORT SGXMLScanner : public XMLScanner
53{
54    template<class SGXMLScanner> friend class XMLSchemaLoader;
55
56    typedef SchemaElementDecl ElementDeclType;
57
58public :
59    // -----------------------------------------------------------------------
60    //  Constructors and Destructor
61    // -----------------------------------------------------------------------
62    SGXMLScanner
63    (
64        XMLValidator* const       valToAdopt
65        , GrammarResolver* const grammarResolver
66        , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
67    );
68    SGXMLScanner
69    (
70        XMLDocumentHandler* const docHandler
71        , DocTypeHandler* const   docTypeHandler
72        , XMLEntityHandler* const entityHandler
73        , XMLErrorReporter* const errReporter
74        , XMLValidator* const     valToAdopt
75        , GrammarResolver* const  grammarResolver
76        , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
77    );
78    virtual ~SGXMLScanner();
79
80    // -----------------------------------------------------------------------
81    //  XMLScanner public virtual methods
82    // -----------------------------------------------------------------------
83    virtual const XMLCh* getName() const;
84    virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool();
85    virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const;
86    virtual void scanDocument
87    (
88        const   InputSource&    src
89    );
90    virtual bool scanNext(XMLPScanToken& toFill);
91    virtual Grammar* loadGrammar
92    (
93        const   InputSource&    src
94        , const short           grammarType
95        , const bool            toCache = false
96    );
97
98    virtual void resetCachedGrammar ();
99    virtual Grammar::GrammarType getCurrentGrammarType() const;
100
101    // -----------------------------------------------------------------------
102    //  XMLParser Callback Methods
103    // -----------------------------------------------------------------------
104
105    IDISA_ALWAYS_INLINE
106    void validateContent
107    (
108        const XMLCh       *             content
109        , const XMLSize_t               contentLength
110        , const bool                    doPSVI
111        , const XMLContentFlag          flags
112        , XMLDocumentAccumulator &      parser
113        , const bool                    forceWrite = false
114    )
115    {
116        DEPRECATED_FEATURE_IN_ICXML;
117    }
118
119    IDISA_ALWAYS_INLINE
120    void validateCDATA
121    (
122        const XMLCh       *             cdata
123        , const XMLSize_t               length
124        , XMLDocumentAccumulator &      parser
125    )
126    {
127        DEPRECATED_FEATURE_IN_ICXML;
128    }
129
130    IDISA_ALWAYS_INLINE
131    XMLElementDecl & getElementDecl
132    (
133        XMLSymbol &                     element
134        , const QName *                 elemName
135        , const unsigned int            uriId
136        , const bool                                    isRoot
137        , const bool                    doPSVI
138        , XMLDocumentAccumulator &      parser
139    )
140    {
141        DEPRECATED_FEATURE_IN_ICXML;
142    }
143
144    IDISA_ALWAYS_INLINE
145    bool validateAttribute
146    (
147        const XMLElementDecl &          elemDecl
148        , const QName *                 elemName
149        , const XMLSize_t               elementCount
150        , const XMLSymbol &             attribute
151        , const unsigned int            uriId
152        , const XMLCh *                 value
153        , const XMLSize_t               length
154        , const MarkupType              type
155        , const Grammar::GrammarType    grammarType
156        , const bool                    error
157        , const bool                    doPSVI
158        , XMLDocumentAccumulator &      parser
159        , const bool                    write
160    )
161    {
162        DEPRECATED_FEATURE_IN_ICXML;
163    }
164
165    IDISA_ALWAYS_INLINE
166    XMLSize_t postAttributeValidation
167    (
168        const XMLElementDecl &          elemDecl
169        , const QName *                 elemName
170        , const XMLSize_t               elementCount
171        , const XMLSize_t                               attributeCount
172        , const unsigned int            uriId
173        , const bool                                    isRoot
174        , const bool                                    isEmpty
175        , const Grammar::GrammarType    grammarType
176        , const bool                    doPSVI
177        , XMLDocumentAccumulator &      parser
178    )
179    {
180        DEPRECATED_FEATURE_IN_ICXML;
181    }
182
183    IDISA_ALWAYS_INLINE
184    void validateEndTag
185    (
186        XMLElementDecl &                element
187        , const QName *                 elemName
188        , const unsigned int                    uriId
189        , const bool                                    isRoot
190        , XMLElementDecl **                             children
191        , const XMLSize_t                               childCount
192        , const bool                    doPSVI
193        , XMLDocumentAccumulator &      parser
194    )
195    {
196        DEPRECATED_FEATURE_IN_ICXML;
197    }
198
199protected:
200    // -----------------------------------------------------------------------
201    //  XMLScanner virtual methods
202    // -----------------------------------------------------------------------
203
204    virtual void scanReset(const InputSource& src);
205
206
207    // -----------------------------------------------------------------------
208    //  SGXMLScanner virtual methods
209    // -----------------------------------------------------------------------
210    virtual bool scanStartTag(bool& gotData);
211    virtual void scanEndTag(bool& gotData);
212
213    // -----------------------------------------------------------------------
214    //  Helper methods
215    // -----------------------------------------------------------------------
216    XMLSize_t buildAttList
217    (
218        const   RefVectorOf<KVStringPair>&  providedAttrs
219        , const XMLSize_t                   attCount
220        ,       XMLElementDecl*             elemDecl
221        ,       RefVectorOf<XMLAttr>&       toFill
222    );
223    bool laxElementValidation(QName* element, ContentLeafNameTypeVector* cv,
224                              const XMLContentModel* const cm,
225                              const XMLSize_t parentElemDepth);
226    XMLSize_t rawAttrScan
227    (
228        const   XMLCh* const                elemName
229        ,       RefVectorOf<KVStringPair>&  toFill
230        ,       bool&                       isEmpty
231    );
232    void updateNSMap
233    (
234        const   XMLCh* const    attrName
235        , const XMLCh* const    attrValue
236    );
237    void resizeElemState();
238
239    void updateNSMap
240    (
241        const   XMLCh* const    attrName
242        , const XMLCh* const    attrValue
243        , const int             colonPosition
244    );
245    void resizeRawAttrColonList();
246    // -----------------------------------------------------------------------
247    //  Data members
248    //
249    //  fRawAttrList
250    //      During the initial scan of the attributes we can only do a raw
251    //      scan for key/value pairs. So this vector is used to store them
252    //      until they can be processed (and put into fAttrList.)
253    //
254    //  fSchemaValidator
255    //      The Schema validator instance.
256    //
257    //  fSeeXsi
258    //      This flag indicates a schema has been seen.
259    //
260    //  fElemState
261    //  fElemLoopState
262    //  fElemStateSize
263    //      Stores an element next state from DFA content model - used for
264    //      wildcard validation
265    //
266    // fElemNonDeclPool
267    //      registry for elements without decls in the grammar
268    // fElemCount
269    //      count of the number of start tags seen so far (starts at 1).
270    //      Used for duplicate attribute detection/processing of required/defaulted attributes
271    // fAttDefRegistry
272    //      mapping from XMLAttDef instances to the count of the last
273    //      start tag where they were utilized.
274    // fUndeclaredAttrRegistry
275    //      set of namespaceId/localName pairs to detect duplicates
276    // fPSVIAttrList
277    //      PSVI attribute list implementation that needs to be
278    //      filled when a PSVIHandler is registered
279    // fSchemaInfoList
280    //      Transient schema info list that is passed to TraverseSchema instances.
281    // fCachedSchemaInfoList
282    //      Cached Schema info list that is passed to TraverseSchema instances.
283    //
284    // -----------------------------------------------------------------------
285    bool                                    fSeeXsi;
286    Grammar::GrammarType                    fGrammarType;
287    unsigned int                            fElemStateSize;
288    unsigned int*                           fElemState;
289    unsigned int*                           fElemLoopState;
290    XMLBuffer                               fContent;
291    ValueHashTableOf<XMLCh>*                fEntityTable;
292    RefVectorOf<KVStringPair>*              fRawAttrList;
293    unsigned int                            fRawAttrColonListSize;
294    int*                                    fRawAttrColonList;
295    SchemaGrammar*                          fSchemaGrammar;
296    SchemaValidator*                        fSchemaValidator;
297    IdentityConstraintHandler*              fICHandler;
298    RefHash3KeysIdPool<SchemaElementDecl>*  fElemNonDeclPool;
299    unsigned int                            fElemCount;
300    RefHashTableOf<unsigned int, PtrHasher>*fAttDefRegistry;
301    Hash2KeysSetOf<StringHasher>*           fUndeclaredAttrRegistry;
302    PSVIAttributeList *                     fPSVIAttrList;
303    XSModel*                                fModel;
304    PSVIElement*                            fPSVIElement;
305    ValueStackOf<bool>*                     fErrorStack;
306    PSVIElemContext                         fPSVIElemContext;
307    RefHash2KeysTableOf<SchemaInfo>*        fSchemaInfoList;
308    RefHash2KeysTableOf<SchemaInfo>*        fCachedSchemaInfoList;
309
310#ifdef MOVE_BUFFERS_OUT_OF_XMLSCANNER
311    XMLBuffer                   fAttNameBuf;
312    XMLBuffer                   fAttValueBuf;
313    XMLBuffer                   fCDataBuf;
314    XMLBuffer                   fQNameBuf;
315    XMLBuffer                   fPrefixBuf;
316    XMLBuffer                   fURIBuf;
317    XMLBuffer                   fWSNormalizeBuf;
318#endif
319
320private :
321    // -----------------------------------------------------------------------
322    //  Unimplemented constructors and operators
323    // -----------------------------------------------------------------------
324    SGXMLScanner();
325    SGXMLScanner(const SGXMLScanner&);
326    SGXMLScanner& operator=(const SGXMLScanner&);
327
328    // -----------------------------------------------------------------------
329    //  XMLScanner virtual methods
330    // -----------------------------------------------------------------------
331    virtual void scanCDSection();
332    virtual void scanCharData(XMLBuffer& toToUse);
333    virtual EntityExpRes scanEntityRef
334    (
335        const   bool    inAttVal
336        ,       XMLCh&  firstCh
337        ,       XMLCh&  secondCh
338        ,       bool&   escaped
339    );
340    virtual void scanDocTypeDecl();
341    virtual void sendCharData(XMLBuffer& toSend);
342    virtual InputSource* resolveSystemId(const XMLCh* const sysId
343                                        ,const XMLCh* const pubId);
344
345    // -----------------------------------------------------------------------
346    //  Private helper methods
347    // -----------------------------------------------------------------------
348    void commonInit();
349    void cleanUp();
350
351    bool normalizeAttValue
352    (
353        const   XMLAttDef* const    attDef
354        , const XMLCh* const        attrName
355        , const XMLCh* const        value
356        ,       XMLBuffer&          toFill
357    );
358    bool normalizeAttRawValue
359    (
360        const   XMLCh* const        attrName
361        , const XMLCh* const        value
362        ,       XMLBuffer&          toFill
363    );
364    void scanRawAttrListforNameSpaces(XMLSize_t attCount);
365    void parseSchemaLocation(const XMLCh* const schemaLocationStr, bool ignoreLoadSchema = false);
366    void resolveSchemaGrammar(const XMLCh* const loc, const XMLCh* const uri, bool ignoreLoadSchema = false);
367    bool switchGrammar(const XMLCh* const newGrammarNameSpace);
368    bool anyAttributeValidation(SchemaAttDef* attWildCard,
369                                unsigned int uriId,
370                                bool& skipThisOne,
371                                bool& laxThisOne);
372
373    // -----------------------------------------------------------------------
374    //  Private scanning methods
375    // -----------------------------------------------------------------------
376    bool basicAttrValueScan
377    (
378        const   XMLCh* const    attrName
379        ,       XMLBuffer&      toFill
380    );
381    bool scanAttValue
382    (
383        const   XMLAttDef* const    attDef
384        ,       XMLBuffer&          toFill
385    );
386    bool scanContent();
387
388    // -----------------------------------------------------------------------
389    //  IdentityConstraints Activation methods
390    // -----------------------------------------------------------------------
391    inline bool toCheckIdentityConstraint()  const;
392
393    // -----------------------------------------------------------------------
394    //  Grammar preparsing methods
395    // -----------------------------------------------------------------------
396    Grammar* loadXMLSchemaGrammar(const InputSource& src, const bool toCache = false);
397
398    // -----------------------------------------------------------------------
399    //  PSVI handling methods
400    // -----------------------------------------------------------------------
401    void endElementPSVI(SchemaElementDecl* const elemDecl,
402                        DatatypeValidator* const memberDV);
403
404    void resetPSVIElemContext();
405};
406
407inline const XMLCh* SGXMLScanner::getName() const
408{
409    return XMLUni::fgSGXMLScanner;
410}
411
412inline bool SGXMLScanner::toCheckIdentityConstraint()  const
413{
414    return fValidate && fIdentityConstraintChecking && fICHandler;
415}
416
417inline Grammar::GrammarType SGXMLScanner::getCurrentGrammarType() const
418{
419    return fGrammarType;
420}
421
422XERCES_CPP_NAMESPACE_END
423
424#endif
Note: See TracBrowser for help on using the repository browser.