source: icXML/icXML-devel/src/icxercesc/internal/WFXMLScanner.hpp @ 3157

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

Fixes for icXML 0.9

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: WFXMLScanner.hpp 810580 2009-09-02 15:52:22Z amassari $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_WFXMLSCANNER_HPP)
23#define XERCESC_INCLUDE_GUARD_WFXMLSCANNER_HPP
24
25#include <icxercesc/internal/XMLScanner.hpp>
26#include <icxercesc/util/ValueHashTableOf.hpp>
27#include <xercesc/util/ValueVectorOf.hpp>
28#include <icxercesc/validators/DTD/DTDElementDecl.hpp>
29#include <icxercesc/internal/XMLReader.hpp>
30#include <icxmlc/XMLSymbol.hpp>
31#include <icxmlc/XMLParserImpl.hpp>
32#include <icxmlc/parsers/XMLDocumentAccumulator.hpp>
33#include <icxmlc/XMLConfig.hpp>
34
35XERCES_CPP_NAMESPACE_BEGIN
36
37template<class ScannerType> class XMLGrammarValidator;
38
39//  This is a a non-validating scanner. No DOCTYPE or XML Schema processing
40//  will take place.
41class XMLPARSER_EXPORT WFXMLScanner : public XMLScanner
42{
43        friend class XMLReader;
44        template<class WFXMLScanner> friend class XMLParserImpl;
45    template<class WFXMLScanner> friend class XMLGrammarValidator;
46    template<class WFXMLScanner> friend class XMLSchemaLoader;
47
48    typedef DTDElementDecl ElementDeclType;
49
50public :
51        // -----------------------------------------------------------------------
52        //  Constructors and Destructor
53        // -----------------------------------------------------------------------
54        WFXMLScanner
55        (
56                XMLValidator* const       valToAdopt
57                , GrammarResolver* const  grammarResolver
58                , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
59        );
60        WFXMLScanner
61        (
62                XMLDocumentHandler* const docHandler
63                , DocTypeHandler* const   docTypeHandler
64                , XMLEntityHandler* const entityHandler
65                , XMLErrorReporter* const errReporter
66                , XMLValidator* const     valToAdopt
67                , GrammarResolver* const  grammarResolver
68                , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
69        );
70        virtual ~WFXMLScanner();
71
72        // -----------------------------------------------------------------------
73        //  XMLScanner public virtual methods
74        // -----------------------------------------------------------------------
75        virtual const XMLCh* getName() const;
76        virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool();
77        virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const;
78        virtual void scanDocument
79        (
80                const   InputSource&    src
81        );
82        virtual bool scanNext(XMLPScanToken& toFill);
83
84        virtual Grammar* loadGrammar
85        (
86                const   InputSource&    src
87                , const short           grammarType
88                , const bool            toCache = false
89        );
90
91    bool toCheckIdentityConstraint() const;
92
93    // -----------------------------------------------------------------------
94    //  XMLParser Callback Methods
95    // -----------------------------------------------------------------------
96    IDISA_ALWAYS_INLINE
97    void validateContent
98        (
99        const XMLCh       *             content
100        , const XMLSize_t               length
101        , const bool                    doPSVI
102        , const XMLContentFlag          flags
103        , XMLDocumentAccumulator &      parser
104        , const bool                    forceWrite = false
105        );
106
107    IDISA_ALWAYS_INLINE
108    void validateCDATA
109    (
110        const XMLCh       *             cdata
111        , const XMLSize_t               length
112        , XMLDocumentAccumulator &      parser
113    );
114
115    IDISA_ALWAYS_INLINE
116    DTDElementDecl & getElementDecl
117    (
118        XMLSymbol &                     element
119        , const unsigned int            uriId
120        , const bool                    isRoot
121        , const bool                    doPSVI
122        , XMLDocumentAccumulator &      parser
123    );
124
125    IDISA_ALWAYS_INLINE
126    bool validateAttribute
127    (
128        const XMLElementDecl &          elemDecl
129        , const XMLSize_t               elementCount
130        , const XMLSymbol &             attribute
131        , const unsigned int            uriId
132        , const XMLCh *                 value
133        , const XMLSize_t               length
134        , const MarkupType              type
135        , const Grammar::GrammarType    grammarType
136        , const bool                    doPSVI
137        , XMLDocumentAccumulator &      parser
138        , const bool                    write
139    );
140
141    IDISA_ALWAYS_INLINE
142    XMLSize_t postAttributeValidation
143    (
144        const XMLElementDecl &          elemDecl
145        , const QName *                 elemName
146        , const XMLSize_t               elementCount
147        , const XMLSize_t                               attributeCount
148        , const unsigned int            uriId
149        , const bool                                    isRoot
150        , const bool                                    isEmpty
151        , const Grammar::GrammarType    grammarType
152        , const bool                    doPSVI
153        , XMLDocumentAccumulator &      parser
154    );
155
156    IDISA_ALWAYS_INLINE
157    void validateEndTag
158        (
159        XMLElementDecl &                element
160        , const QName *                 elemName
161                , const unsigned int                    uriId
162                , const bool                                    isRoot
163                , XMLElementDecl **                             children
164        , const XMLSize_t                               childCount
165        , const bool                    doPSVI
166        , XMLDocumentAccumulator &      parser
167        );
168
169    IDISA_ALWAYS_INLINE
170        void parseSchemaLocation
171        (
172                const XMLCh* const schemaLocationStr
173                , const XMLSize_t schemaLocationStrLen
174                , bool ignoreLoadSchema = false
175    );
176
177protected:
178
179        virtual void scanFirst();
180
181private :
182
183        // -----------------------------------------------------------------------
184        //  Unimplemented constructors and operators
185        // -----------------------------------------------------------------------
186        WFXMLScanner();
187        WFXMLScanner(const WFXMLScanner&);
188        WFXMLScanner& operator=(const WFXMLScanner&);
189
190        // -----------------------------------------------------------------------
191        //  XMLScanner virtual methods
192        // -----------------------------------------------------------------------
193        virtual void scanCDSection();
194        virtual void scanCharData(XMLBuffer& toToUse);
195        virtual EntityExpRes scanEntityRef
196        (
197                const   bool    inAttVal
198                ,       XMLCh&  firstCh
199                ,       XMLCh&  secondCh
200                ,       bool&   escaped
201        );
202        virtual void scanDocTypeDecl();
203        virtual void scanReset(const InputSource& src);
204        virtual void sendCharData(XMLBuffer& toSend);
205        virtual InputSource* resolveSystemId(const XMLCh* const sysId
206                                                                                ,const XMLCh* const pubId);
207
208        // -----------------------------------------------------------------------
209        //  Private helper methods
210        // -----------------------------------------------------------------------
211        void commonInit();
212        void cleanUp();
213
214
215        // -----------------------------------------------------------------------
216        //  Private ICXML methods
217        // -----------------------------------------------------------------------
218        void resolveSchemaGrammar
219        (
220                const XMLCh* const loc
221                , const XMLCh* const uri
222                , bool ignoreLoadSchema = false
223        )
224        {
225
226        }
227
228        inline void setXsiType
229        (
230        const XMLCh *                           prefix
231        , const XMLCh *             localPart
232        , const unsigned int        uriId
233        )
234        {
235
236        }
237
238        inline void setXsiNil
239        (
240                const XMLCh *                           value
241                , const XMLSize_t                       length
242        )
243        {
244
245        }
246
247        // -----------------------------------------------------------------------
248        //  Private scanning methods
249        // -----------------------------------------------------------------------
250        bool scanAttValue
251        (
252                const   XMLCh* const    attrName
253                ,       XMLBuffer&      toFill
254        );
255
256        bool scanContent();
257
258        void scanEndTag(bool& gotData);
259        bool scanStartTag(bool& gotData);
260        bool scanStartTagNS(bool& gotData);
261
262    IDISA_ALWAYS_INLINE
263    Grammar::GrammarType getGrammarType() const
264    {
265        return Grammar::DTDGrammarType;
266    }
267
268
269private:
270        // -----------------------------------------------------------------------
271        //  Data members
272        //
273        //
274        // -----------------------------------------------------------------------
275
276    RefVectorOf<XMLElementDecl>      fElements;
277};
278
279inline const XMLCh* WFXMLScanner::getName() const
280{
281        return XMLUni::fgWFXMLScanner;
282}
283
284// ---------------------------------------------------------------------------
285//  WFXMLScanner: XMLParser Callback Methods
286// ---------------------------------------------------------------------------
287
288void WFXMLScanner::validateContent
289(
290    const XMLCh       *             content
291    , const XMLSize_t               length
292    , const bool                    doPSVI
293    , const XMLContentFlag          flags
294    , XMLDocumentAccumulator &      parser
295    , const bool                    write
296)
297{
298    if (length)
299    {
300        parser.writeContent(content, length, write);
301    }
302}
303
304// --------------------------------------------------------------------------------------------------------
305
306void WFXMLScanner::validateCDATA
307(
308    const XMLCh       *             cdata
309    , const XMLSize_t               length
310    , XMLDocumentAccumulator &      parser
311)
312{
313
314}
315
316// --------------------------------------------------------------------------------------------------------
317
318DTDElementDecl & WFXMLScanner::getElementDecl
319(
320    XMLSymbol &                             element
321    , const unsigned int                    /* uriId */
322    , const bool                            /* isRoot */
323    , const bool                            doPSVI
324    , XMLDocumentAccumulator &              parser   
325)
326{
327    //  Lets try to look up the element
328    DTDElementDecl * elemDecl = (DTDElementDecl *)element.getElemDecl();
329
330    if (unlikely(elemDecl == 0))
331    {
332        elemDecl = new (fGrammarPoolMemoryManager) DTDElementDecl(element.getQName(), DTDElementDecl::Any, fGrammarPoolMemoryManager);
333        fElements.addElement((XMLElementDecl*)elemDecl);
334        element.setElemDecl(elemDecl);
335    }
336
337    return *elemDecl;
338}
339
340bool WFXMLScanner::validateAttribute
341(
342    const XMLElementDecl &          elemDecl
343    , const XMLSize_t               elementCount
344    , const XMLSymbol &             attribute
345    , const unsigned int            uriId
346    , const XMLCh *                 value
347    , const XMLSize_t               length
348    , const MarkupType              type
349    , const Grammar::GrammarType    grammarType
350    , const bool                    doPSVI
351    , XMLDocumentAccumulator &      parser
352    , const bool                    write
353)
354{
355    // create an attdeflist on the fly for each element?
356    parser.writeAttribute(attribute.getQName(), XMLAttDef::CData, uriId, value, length, type, write);
357    return 1;
358}
359
360XMLSize_t WFXMLScanner::postAttributeValidation
361(
362    const XMLElementDecl &          elemDecl
363    , const QName *                 elemName
364    , const XMLSize_t               /* elementCount */
365    , const XMLSize_t               attributeCount
366    , const unsigned int            uriId
367    , const bool                                        /* isRoot */
368    , const bool                                        isEmpty
369    , const Grammar::GrammarType    /* grammarType */
370    , const bool                    doPSVI
371    , XMLDocumentAccumulator &      parser
372)
373{
374    parser.writeStartTag(elemDecl, elemName, uriId, attributeCount, isEmpty);
375    return attributeCount;
376}
377
378
379// ---------------------------------------------------------------------------
380
381void WFXMLScanner::validateEndTag
382(
383    XMLElementDecl &                element
384    , const QName *                 elemName
385    , const unsigned int                        uriId
386    , const bool                                        isRoot
387    , XMLElementDecl **                         children
388    , const XMLSize_t                           childCount
389    , const bool                    doPSVI
390    , XMLDocumentAccumulator &      parser
391)
392{
393    parser.writeEndTag(element, elemName, uriId);
394}
395
396// ---------------------------------------------------------------------------
397
398void WFXMLScanner::parseSchemaLocation(const XMLCh* const, const XMLSize_t, bool)
399{
400    /* DO NOTHING! NOT DEPRECATED! */
401}
402
403inline bool WFXMLScanner::toCheckIdentityConstraint() const
404{
405    return 0;
406}
407
408
409XERCES_CPP_NAMESPACE_END
410
411#endif
Note: See TracBrowser for help on using the repository browser.