source: icXML/icXML-devel/src/xercesc/validators/schema/TraverseSchema.hpp @ 2722

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

Original Xerces files with import mods for icxercesc

File size: 40.0 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: TraverseSchema.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_TRAVERSESCHEMA_HPP)
23#define XERCESC_INCLUDE_GUARD_TRAVERSESCHEMA_HPP
24
25/**
26  * Instances of this class get delegated to Traverse the Schema and
27  * to populate the SchemaGrammar internal representation.
28  */
29
30// ---------------------------------------------------------------------------
31//  Includes
32// ---------------------------------------------------------------------------
33#include <xercesc/util/XMLUniDefs.hpp>
34#include <xercesc/dom/DOMElement.hpp>
35#include <xercesc/dom/DOMAttr.hpp>
36#include <icxercesc/framework/XMLBuffer.hpp>
37#include <xercesc/framework/XMLErrorCodes.hpp>
38#include <xercesc/validators/schema/SchemaSymbols.hpp>
39#include <xercesc/util/ValueVectorOf.hpp>
40#include <xercesc/util/RefHash2KeysTableOf.hpp>
41#include <xercesc/validators/common/ContentSpecNode.hpp>
42#include <xercesc/validators/schema/SchemaGrammar.hpp>
43#include <xercesc/validators/schema/SchemaInfo.hpp>
44#include <xercesc/validators/schema/GeneralAttributeCheck.hpp>
45#include <xercesc/validators/schema/XSDErrorReporter.hpp>
46#include <xercesc/util/XMLResourceIdentifier.hpp>
47
48XERCES_CPP_NAMESPACE_BEGIN
49
50// ---------------------------------------------------------------------------
51//  Forward Declarations
52// ---------------------------------------------------------------------------
53class GrammarResolver;
54class XMLEntityHandler;
55class XMLScanner;
56class DatatypeValidator;
57class DatatypeValidatorFactory;
58class QName;
59class ComplexTypeInfo;
60class XMLAttDef;
61class NamespaceScope;
62class SchemaAttDef;
63class InputSource;
64class XercesGroupInfo;
65class XercesAttGroupInfo;
66class IdentityConstraint;
67class XSDLocator;
68class XSDDOMParser;
69class XMLErrorReporter;
70
71
72class VALIDATORS_EXPORT TraverseSchema : public XMemory
73{
74public:
75    // -----------------------------------------------------------------------
76    //  Public Constructors/Destructor
77    // -----------------------------------------------------------------------
78    TraverseSchema
79    (
80          DOMElement* const       schemaRoot
81        , XMLStringPool* const    uriStringPool
82        , SchemaGrammar* const    schemaGrammar
83        , GrammarResolver* const  grammarResolver
84        , RefHash2KeysTableOf<SchemaInfo>* cachedSchemaInfoList
85        , RefHash2KeysTableOf<SchemaInfo>* schemaInfoList
86        , XMLScanner* const       xmlScanner
87        , const XMLCh* const      schemaURL
88        , XMLEntityHandler* const entityHandler
89        , XMLErrorReporter* const errorReporter
90        , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
91        , bool multipleImport = false
92    );
93
94    ~TraverseSchema();
95
96private:
97         // This enumeration is defined here for compatibility with the CodeWarrior
98         // compiler, which apparently doesn't like to accept default parameter
99         // arguments that it hasn't yet seen. The Not_All_Context argument is
100         // used in the declaration of checkMinMax, below.
101         //
102    // Flags indicate any special restrictions on minOccurs and maxOccurs
103    // relating to "all".
104    //    Not_All_Context    - not processing an <all>
105    //    All_Element        - processing an <element> in an <all>
106    //    Group_Ref_With_All - processing <group> reference that contained <all>
107    //    All_Group          - processing an <all> group itself
108    enum
109        {
110        Not_All_Context = 0
111        , All_Element = 1
112        , Group_Ref_With_All = 2
113        , All_Group = 4
114    };
115
116    // -----------------------------------------------------------------------
117    //  Unimplemented constructors and operators
118    // -----------------------------------------------------------------------
119    TraverseSchema(const TraverseSchema&);
120    TraverseSchema& operator=(const TraverseSchema&);
121
122    // -----------------------------------------------------------------------
123    //  Init/CleanUp methods
124    // -----------------------------------------------------------------------
125    void init();
126    void cleanUp();
127
128    // -----------------------------------------------------------------------
129    //  Traversal methods
130    // -----------------------------------------------------------------------
131    /**
132      * Traverse the Schema DOM tree
133      */
134    void                doTraverseSchema(const DOMElement* const schemaRoot);
135    void                preprocessSchema(DOMElement* const schemaRoot,
136                                         const XMLCh* const schemaURL,
137                                         bool  multipleImport = false);
138    void                traverseSchemaHeader(const DOMElement* const schemaRoot);
139    XSAnnotation*       traverseAnnotationDecl(const DOMElement* const childElem,
140                                               ValueVectorOf<DOMNode*>* const nonXSAttList,
141                                               const bool topLevel = false);
142    void                traverseInclude(const DOMElement* const childElem);
143    void                traverseImport(const DOMElement* const childElem);
144    void                traverseRedefine(const DOMElement* const childElem);
145    void                traverseAttributeDecl(const DOMElement* const childElem,
146                                              ComplexTypeInfo* const typeInfo,
147                                              const bool topLevel = false);
148    void                traverseSimpleContentDecl(const XMLCh* const typeName,
149                                                  const XMLCh* const qualifiedName,
150                                                  const DOMElement* const contentDecl,
151                                                  ComplexTypeInfo* const typeInfo,
152                                                  Janitor<XSAnnotation>* const janAnnot);
153    void                traverseComplexContentDecl(const XMLCh* const typeName,
154                                                  const DOMElement* const contentDecl,
155                                                  ComplexTypeInfo* const typeInfo,
156                                                  const bool isMixed,
157                                                  Janitor<XSAnnotation>* const janAnnot);
158    DatatypeValidator*  traverseSimpleTypeDecl(const DOMElement* const childElem,
159                                               const bool topLevel = true,
160                                               int baseRefContext = SchemaSymbols::XSD_EMPTYSET);
161    int                 traverseComplexTypeDecl(const DOMElement* const childElem,
162                                                const bool topLevel = true,
163                                                const XMLCh* const recursingTypeName = 0);
164    DatatypeValidator*  traverseByList(const DOMElement* const rootElem,
165                                       const DOMElement* const contentElem,
166                                       const XMLCh* const typeName,
167                                       const XMLCh* const qualifiedName,
168                                       const int finalSet,
169                                       Janitor<XSAnnotation>* const janAnnot);
170    DatatypeValidator*  traverseByRestriction(const DOMElement* const rootElem,
171                                              const DOMElement* const contentElem,
172                                              const XMLCh* const typeName,
173                                              const XMLCh* const qualifiedName,
174                                              const int finalSet,
175                                              Janitor<XSAnnotation>* const janAnnot);
176    DatatypeValidator*  traverseByUnion(const DOMElement* const rootElem,
177                                        const DOMElement* const contentElem,
178                                        const XMLCh* const typeName,
179                                        const XMLCh* const qualifiedName,
180                                        const int finalSet,
181                                        int baseRefContext,
182                                        Janitor<XSAnnotation>* const janAnnot);
183    SchemaElementDecl*    traverseElementDecl(const DOMElement* const childElem,
184                                            const bool topLevel = false);
185    const XMLCh*        traverseNotationDecl(const DOMElement* const childElem);
186    const XMLCh*        traverseNotationDecl(const DOMElement* const childElem,
187                                             const XMLCh* const name,
188                                             const XMLCh* const uriStr);
189    ContentSpecNode*    traverseChoiceSequence(const DOMElement* const elemDecl,
190                                               const int modelGroupType,
191                                               bool& hasChildren);
192    ContentSpecNode*    traverseAny(const DOMElement* const anyDecl);
193    ContentSpecNode*    traverseAll(const DOMElement* const allElem,
194                                    bool& hasChildren);
195    XercesGroupInfo*    traverseGroupDecl(const DOMElement* const childElem,
196                                          const bool topLevel = true);
197    XercesAttGroupInfo* traverseAttributeGroupDecl(const DOMElement* const elem,
198                                                   ComplexTypeInfo* const typeInfo,
199                                                   const bool topLevel = false);
200    XercesAttGroupInfo* traverseAttributeGroupDeclNS(const DOMElement* const elem,
201                                                     const XMLCh* const uriStr,
202                                                     const XMLCh* const name);
203    SchemaAttDef*       traverseAnyAttribute(const DOMElement* const elem);
204    void                traverseKey(const DOMElement* const icElem,
205                                    SchemaElementDecl* const elemDecl);
206    void                traverseUnique(const DOMElement* const icElem,
207                                       SchemaElementDecl* const elemDecl);
208    void                traverseKeyRef(const DOMElement* const icElem,
209                                       SchemaElementDecl* const elemDecl);
210    bool                traverseIdentityConstraint(IdentityConstraint* const ic,
211                                                   const DOMElement* const icElem);
212
213    // -----------------------------------------------------------------------
214    //  Error Reporting methods
215    // -----------------------------------------------------------------------
216    void reportSchemaError(const XSDLocator* const aLocator,
217                           const XMLCh* const msgDomain,
218                           const int errorCode);
219    void reportSchemaError(const XSDLocator* const aLocator,
220                           const XMLCh* const msgDomain,
221                           const int errorCode,
222                           const XMLCh* const text1,
223                           const XMLCh* const text2 = 0,
224                           const XMLCh* const text3 = 0,
225                           const XMLCh* const text4 = 0);
226    void reportSchemaError(const DOMElement* const elem,
227                           const XMLCh* const msgDomain,
228                           const int errorCode);
229    void reportSchemaError(const DOMElement* const elem,
230                           const XMLCh* const msgDomain,
231                           const int errorCode,
232                           const XMLCh* const text1,
233                           const XMLCh* const text2 = 0,
234                           const XMLCh* const text3 = 0,
235                           const XMLCh* const text4 = 0);
236    void reportSchemaError(const DOMElement* const elem,
237                           const XMLException&     except);
238
239    // -----------------------------------------------------------------------
240    //  Private Helper methods
241    // -----------------------------------------------------------------------
242    /**
243      * Keep track of the xs:import found
244      */
245    bool isImportingNS(const int namespaceURI);
246    void addImportedNS(const int namespaceURI);
247
248    /**
249      * Retrieved the Namespace mapping from the schema element
250      */
251    bool retrieveNamespaceMapping(const DOMElement* const elem);
252
253    /**
254      * Loop through the children, and traverse the corresponding schema type
255      * type declaration (simpleType, complexType, import, ....)
256      */
257    void processChildren(const DOMElement* const root);
258    void preprocessChildren(const DOMElement* const root);
259
260    void preprocessImport(const DOMElement* const elemNode);
261    void preprocessInclude(const DOMElement* const elemNode);
262    void preprocessRedefine(const DOMElement* const elemNode);
263
264    /**
265      * Parameters:
266      *   rootElem - top element for a given type declaration
267      *   contentElem - content must be annotation? or some other simple content
268      *   isEmpty: - true if (annotation?, smth_else), false if (annotation?)
269      *   processAnnot - default is true, false if reprocessing a complex type
270      *                  since we have already processed the annotation.
271      *
272      * Check for Annotation if it is present, traverse it. If a sibling is
273      * found and it is not an annotation return it, otherwise return 0.
274      * Used by traverseSimpleTypeDecl.
275      */
276    DOMElement* checkContent(const DOMElement* const rootElem,
277                               DOMElement* const contentElem,
278                               const bool isEmpty, bool processAnnot = true);
279
280    /**
281      * Parameters:
282      *   contentElem - content element to check
283      *
284      * Check for identity constraints content.
285      */
286    const DOMElement* checkIdentityConstraintContent(const DOMElement* const contentElem);
287
288    DatatypeValidator* getDatatypeValidator(const XMLCh* const uriStr,
289                                            const XMLCh* const localPartStr);
290
291    /**
292      * Process simpleType content of a list|restriction|union
293      * Return a dataype validator if valid type, otherwise 0.
294      */
295    DatatypeValidator* checkForSimpleTypeValidator(const DOMElement* const content,
296                                                   int baseRefContext = SchemaSymbols::XSD_EMPTYSET);
297
298    /**
299      * Process complexType content of an element
300      * Return a ComplexTypeInfo if valid type, otherwise 0.
301      */
302    ComplexTypeInfo* checkForComplexTypeInfo(const DOMElement* const content);
303
304    /**
305      * Return DatatypeValidator available for the baseTypeStr.
306      */
307    DatatypeValidator* findDTValidator(const DOMElement* const elem,
308                                       const XMLCh* const derivedTypeName,
309                                       const XMLCh* const baseTypeName,
310                                       const int baseRefContext);
311
312    const XMLCh* resolvePrefixToURI(const DOMElement* const elem,
313                                    const XMLCh* const prefix);
314
315    /**
316      * Return the prefix for a given rawname string
317      *
318      * Function allocated, caller managed (facm) - pointer to be deleted by
319      * caller.
320      */
321    const XMLCh* getPrefix(const XMLCh* const rawName);
322
323    /**
324      * Return the local for a given rawname string
325      *
326      * caller allocated, caller managed (cacm)
327      */
328    const XMLCh* getLocalPart(const XMLCh* const rawName);
329
330    /**
331      * Process a 'ref' of an Element declaration
332      */
333    SchemaElementDecl* processElementDeclRef(const DOMElement* const elem,
334                                             const XMLCh* const refName);
335    void processElemDeclAttrs(const DOMElement* const elem,
336                              SchemaElementDecl* const elemDecl,
337                              const XMLCh*& valConstraint,
338                              bool isTopLevel = false);
339    void processElemDeclIC(DOMElement* const elem,
340                           SchemaElementDecl* const elemDecl);
341    bool checkElemDeclValueConstraint(const DOMElement* const elem,
342                                      SchemaElementDecl* const elemDecl,
343                                      const XMLCh* const valConstraint,
344                                      ComplexTypeInfo* const typeInfo,
345                                      DatatypeValidator* const validator);
346
347    /**
348      * Process a 'ref' of an Attribute declaration
349      */
350    void processAttributeDeclRef(const DOMElement* const elem,
351                                 ComplexTypeInfo* const typeInfo,
352                                 const XMLCh* const refName,
353                                 const XMLCh* const useVal,
354                                 const XMLCh* const defaultVal,
355                                 const XMLCh* const fixedVal);
356
357    /**
358      * Process a 'ref' on a group
359      */
360    XercesGroupInfo* processGroupRef(const DOMElement* const elem,
361                                     const XMLCh* const refName);
362
363    /**
364      * Process a 'ref' on a attributeGroup
365      */
366    XercesAttGroupInfo* processAttributeGroupRef(const DOMElement* const elem,
367                                                 const XMLCh* const refName,
368                                                 ComplexTypeInfo* const typeInfo);
369
370    /**
371      * Parse block & final items
372      */
373    int parseBlockSet(const DOMElement* const elem, const int blockType, const bool isRoot = false);
374    int parseFinalSet(const DOMElement* const elem, const int finalType, const bool isRoot = false);
375
376    /**
377      * Return true if a name is an identity constraint, otherwise false
378      */
379    bool isIdentityConstraintName(const XMLCh* const constraintName);
380
381    /**
382      * If 'typeStr' belongs to a different schema, return that schema URI,
383      * otherwise return 0;
384      */
385    const XMLCh* checkTypeFromAnotherSchema(const DOMElement* const elem,
386                                            const XMLCh* const typeStr);
387
388    /**
389      * Return the datatype validator for a given element type attribute if
390      * the type is a simple type
391      */
392    DatatypeValidator* getElementTypeValidator(const DOMElement* const elem,
393                                               const XMLCh* const typeStr,
394                                               bool& noErrorDetected,
395                                               const XMLCh* const otherSchemaURI);
396
397    /**
398      * Return the complexType info for a given element type attribute if
399      * the type is a complex type
400      */
401    ComplexTypeInfo* getElementComplexTypeInfo(const DOMElement* const elem,
402                                               const XMLCh* const typeStr,
403                                               const XMLCh* const otherSchemaURI);
404
405    /**
406      * Return global schema element declaration for a given element name
407      */
408    SchemaElementDecl* getGlobalElemDecl(const DOMElement* const elem,
409                                         const XMLCh* const name);
410
411    /**
412      * Check validity constraint of a substitutionGroup attribute in
413      * an element declaration
414      */
415    bool isSubstitutionGroupValid(const DOMElement* const elem,
416                                  const SchemaElementDecl* const elemDecl,
417                                  const ComplexTypeInfo* const typeInfo,
418                                  const DatatypeValidator* const validator,
419                                  const XMLCh* const elemName,
420                                  const bool toEmit = true);
421
422    bool isSubstitutionGroupCircular(SchemaElementDecl* const elemDecl,
423                                     SchemaElementDecl* const subsElemDecl);
424
425    void processSubstitutionGroup(const DOMElement* const elem,
426                                  SchemaElementDecl* const elemDecl,
427                                  ComplexTypeInfo*& typeInfo,
428                                  DatatypeValidator*& validator,
429                                  const XMLCh* const subsElemQName);
430
431    /**
432      * Create a 'SchemaElementDecl' object and add it to SchemaGrammar
433      */
434    SchemaElementDecl* createSchemaElementDecl(const DOMElement* const elem,
435                                               const XMLCh* const name,
436                                               bool& isDuplicate,
437                                               const XMLCh*& valConstraint,
438                                               const bool topLevel);
439
440    /**
441      * Return the value of a given attribute name from an element node
442      */
443    const XMLCh* getElementAttValue(const DOMElement* const elem,
444                                    const XMLCh* const attName,
445                                    const DatatypeValidator::ValidatorType attType = DatatypeValidator::UnKnown);
446
447    /* return minOccurs */
448    int checkMinMax(ContentSpecNode* const specNode,
449                     const DOMElement* const elem,
450                     const int allContext = Not_All_Context);
451
452    /**
453      * Process complex content for a complexType
454      */
455    void processComplexContent(const DOMElement* const elem,
456                               const XMLCh* const typeName,
457                               const DOMElement* const childElem,
458                               ComplexTypeInfo* const typeInfo,
459                               const XMLCh* const baseLocalPart,
460                               const bool isMixed,
461                               const bool isBaseAnyType = false);
462
463    /**
464      * Process "base" information for a complexType
465      */
466    void processBaseTypeInfo(const DOMElement* const elem,
467                             const XMLCh* const baseName,
468                             const XMLCh* const localPart,
469                             const XMLCh* const uriStr,
470                             ComplexTypeInfo* const typeInfo);
471
472    /**
473      * Check if base is from another schema
474      */
475    bool isBaseFromAnotherSchema(const XMLCh* const baseURI);
476
477    /**
478      * Get complexType infp from another schema
479      */
480    ComplexTypeInfo* getTypeInfoFromNS(const DOMElement* const elem,
481                                       const XMLCh* const uriStr,
482                                       const XMLCh* const localPart);
483
484    DatatypeValidator*
485    getAttrDatatypeValidatorNS(const DOMElement* const elem,
486                               const XMLCh* localPart,
487                               const XMLCh* typeURI);
488
489    /**
490      * Returns true if a DOM Element is an attribute or attribute group
491      */
492    bool isAttrOrAttrGroup(const DOMElement* const elem);
493
494    /**
495      * Process attributes of a complex type
496      */
497    void processAttributes(const DOMElement* const elem,
498                           const DOMElement* const attElem,
499                           ComplexTypeInfo* const typeInfo,
500                           const bool isBaseAnyType = false);
501
502    /**
503      * Generate a name for an anonymous type
504      */
505    const XMLCh* genAnonTypeName(const XMLCh* const prefix);
506
507    void defaultComplexTypeInfo(ComplexTypeInfo* const typeInfo);
508
509    /**
510      * Resolve a schema location attribute value to an input source.
511      * Caller to delete the returned object.
512      */
513    InputSource* resolveSchemaLocation
514    (
515        const XMLCh* const loc
516        , const XMLResourceIdentifier::ResourceIdentifierType resourceIdentitiferType
517        , const XMLCh* const nameSpace=0
518    );
519
520    void restoreSchemaInfo(SchemaInfo* const toRestore,
521                           SchemaInfo::ListType const aListType = SchemaInfo::INCLUDE,
522                           const unsigned int saveScope = Grammar::TOP_LEVEL_SCOPE);
523    void  popCurrentTypeNameStack();
524
525    /**
526      * Check whether a mixed content is emptiable or not.
527      * Needed to validate element constraint values (defualt, fixed)
528      */
529    bool emptiableParticle(const ContentSpecNode* const specNode);
530
531    void checkFixedFacet(const DOMElement* const, const XMLCh* const,
532                         const DatatypeValidator* const, unsigned int&);
533    void buildValidSubstitutionListF(const DOMElement* const elem,
534                                     SchemaElementDecl* const,
535                                     SchemaElementDecl* const);
536    void buildValidSubstitutionListB(const DOMElement* const elem,
537                                     SchemaElementDecl* const,
538                                     SchemaElementDecl* const);
539
540    void checkEnumerationRequiredNotation(const DOMElement* const elem,
541                                          const XMLCh* const name,
542                                          const XMLCh* const typeStr);
543
544    void processElements(const DOMElement* const elem,
545                         ComplexTypeInfo* const baseTypeInfo,
546                         ComplexTypeInfo* const newTypeInfo);
547
548    void processElements(const DOMElement* const elem,
549                         XercesGroupInfo* const fromGroup,
550                         ComplexTypeInfo* const typeInfo);
551
552    void copyGroupElements(const DOMElement* const elem,
553                           XercesGroupInfo* const fromGroup,
554                           XercesGroupInfo* const toGroup,
555                           ComplexTypeInfo* const typeInfo);
556
557    void copyAttGroupAttributes(const DOMElement* const elem,
558                                XercesAttGroupInfo* const fromAttGroup,
559                                XercesAttGroupInfo* const toAttGroup,
560                                ComplexTypeInfo* const typeInfo);
561
562    void checkForEmptyTargetNamespace(const DOMElement* const elem);
563
564    /**
565      * Attribute wild card intersection.
566      *
567      * Note:
568      *    The first parameter will be the result of the intersection, so
569      *    we need to make sure that first parameter is a copy of the
570      *    actual attribute definition we need to intersect with.
571      *
572      *    What we need to wory about is: type, defaultType, namespace,
573      *    and URI. All remaining data members should be the same.
574      */
575    void attWildCardIntersection(SchemaAttDef* const resultWildCart,
576                                 const SchemaAttDef* const toCompareWildCard);
577
578    /**
579      * Attribute wild card union.
580      *
581      * Note:
582      *    The first parameter will be the result of the union, so
583      *    we need to make sure that first parameter is a copy of the
584      *    actual attribute definition we need to intersect with.
585      *
586      *    What we need to wory about is: type, defaultType, namespace,
587      *    and URI. All remaining data members should be the same.
588      */
589    void attWildCardUnion(SchemaAttDef* const resultWildCart,
590                          const SchemaAttDef* const toCompareWildCard);
591
592    void copyWildCardData(const SchemaAttDef* const srcWildCard,
593                          SchemaAttDef* const destWildCard);
594
595    /**
596      * Check that the attributes of a type derived by restriction satisfy
597      * the constraints of derivation valid restriction
598      */
599    void checkAttDerivationOK(const DOMElement* const elem,
600                              const ComplexTypeInfo* const baseTypeInfo,
601                              const ComplexTypeInfo* const childTypeInfo);
602    void checkAttDerivationOK(const DOMElement* const elem,
603                              const XercesAttGroupInfo* const baseAttGrpInfo,
604                              const XercesAttGroupInfo* const childAttGrpInfo);
605
606    /**
607      * Check whether a namespace value is valid with respect to wildcard
608      * constraint
609      */
610    bool wildcardAllowsNamespace(const SchemaAttDef* const baseAttWildCard,
611                                 const unsigned int nameURI);
612
613    /**
614      * Check whether a namespace constraint is an intensional subset of
615      * another namespace constraint
616      */
617    bool isWildCardSubset(const SchemaAttDef* const baseAttWildCard,
618                          const SchemaAttDef* const childAttWildCard);
619
620    bool openRedefinedSchema(const DOMElement* const redefineElem);
621
622    /**
623      * The purpose of this method is twofold:
624      * 1. To find and appropriately modify all information items
625      * in redefinedSchema with names that are redefined by children of
626      * redefineElem.
627      * 2.  To make sure the redefine element represented by
628      * redefineElem is valid as far as content goes and with regard to
629      * properly referencing components to be redefined.
630      *
631      * No traversing is done here!
632      * This method also takes actions to find and, if necessary, modify
633      * the names of elements in <redefine>'s in the schema that's being
634      * redefined.
635      */
636    void renameRedefinedComponents(const DOMElement* const redefineElem,
637                                   SchemaInfo* const redefiningSchemaInfo,
638                                   SchemaInfo* const redefinedSchemaInfo);
639
640    /**
641      * This method returns true if the redefine component is valid, and if
642      * it was possible to revise it correctly.
643      */
644    bool validateRedefineNameChange(const DOMElement* const redefineChildElem,
645                                    const XMLCh* const redefineChildElemName,
646                                    const XMLCh* const redefineChildDeclName,
647                                    const int redefineNameCounter,
648                                    SchemaInfo* const redefiningSchemaInfo);
649
650        /**
651      * This function looks among the children of 'redefineChildElem' for a
652      * component of type 'redefineChildComponentName'. If it finds one, it
653      * evaluates whether its ref attribute contains a reference to
654      * 'refChildTypeName'. If it does, it returns 1 + the value returned by
655      * calls to itself on all other children.  In all other cases it returns
656      * 0 plus the sum of the values returned by calls to itself on
657      * redefineChildElem's children. It also resets the value of ref so that
658      * it will refer to the renamed type from the schema being redefined.
659      */
660    int changeRedefineGroup(const DOMElement* const redefineChildElem,
661                            const XMLCh* const redefineChildComponentName,
662                            const XMLCh* const redefineChildTypeName,
663                            const int redefineNameCounter);
664
665    /** This simple function looks for the first occurrence of a
666      * 'redefineChildTypeName' item in the redefined schema and appropriately
667      * changes the value of its name. If it turns out that what we're looking
668      * for is in a <redefine> though, then we just rename it--and it's
669      * reference--to be the same.
670      */
671    void fixRedefinedSchema(const DOMElement* const elem,
672                            SchemaInfo* const redefinedSchemaInfo,
673                            const XMLCh* const redefineChildComponentName,
674                            const XMLCh* const redefineChildTypeName,
675                            const int redefineNameCounter);
676
677    void getRedefineNewTypeName(const XMLCh* const oldTypeName,
678                                const int redefineCounter,
679                                XMLBuffer& newTypeName);
680
681    /**
682      * This purpose of this method is threefold:
683      * 1. To extract the schema information of included/redefined schema.
684      * 2. Rename redefined components.
685      * 3. Process components of included/redefined schemas
686      */
687    void preprocessRedefineInclude(SchemaInfo* const currSchemaInfo);
688
689    /**
690      * Update the list of valid substitution groups in the case of circular
691      * import.
692      */
693    void updateCircularSubstitutionList(SchemaInfo* const aSchemaInfo);
694
695    void processKeyRefFor(SchemaInfo* const aSchemaInfo,
696                          ValueVectorOf<SchemaInfo*>* const infoList);
697
698    void processAttValue(const XMLCh* const attVal, XMLBuffer& aBuf);
699
700    // routine to generate synthetic annotations
701    XSAnnotation* generateSyntheticAnnotation(const DOMElement* const elem
702                                             , ValueVectorOf<DOMNode*>* nonXSAttList);
703
704    // routine to validate annotations
705    void validateAnnotations();
706
707    // -----------------------------------------------------------------------
708    //  Private constants
709    // -----------------------------------------------------------------------
710    enum
711    {
712        ES_Block
713        , C_Block
714        , S_Final
715        , EC_Final
716        , ECS_Final
717    };
718
719    enum ExceptionCodes
720    {
721        NoException = 0,
722        InvalidComplexTypeInfo = 1,
723        RecursingElement = 2
724    };
725
726    enum
727    {
728        Elem_Def_Qualified = 1,
729        Attr_Def_Qualified = 2
730    };
731
732    // -----------------------------------------------------------------------
733    //  Private data members
734    // -----------------------------------------------------------------------
735    bool                                           fFullConstraintChecking;
736    int                                            fTargetNSURI;
737    int                                            fEmptyNamespaceURI;
738    unsigned int                                   fCurrentScope;
739    unsigned int                                   fScopeCount;
740    unsigned int                                   fAnonXSTypeCount;
741    XMLSize_t                                      fCircularCheckIndex;
742    const XMLCh*                                   fTargetNSURIString;
743    DatatypeValidatorFactory*                      fDatatypeRegistry;
744    GrammarResolver*                               fGrammarResolver;
745    SchemaGrammar*                                 fSchemaGrammar;
746    XMLEntityHandler*                              fEntityHandler;
747    XMLErrorReporter*                              fErrorReporter;
748    XMLStringPool*                                 fURIStringPool;
749    XMLStringPool*                                 fStringPool;
750    XMLBuffer                                      fBuffer;
751    XMLScanner*                                    fScanner;
752    RefHashTableOf<XMLAttDef>*                     fAttributeDeclRegistry;
753    RefHashTableOf<ComplexTypeInfo>*               fComplexTypeRegistry;
754    RefHashTableOf<XercesGroupInfo>*               fGroupRegistry;
755    RefHashTableOf<XercesAttGroupInfo>*            fAttGroupRegistry;
756    RefHashTableOf<ElemVector>*                    fIC_ElementsNS;
757    RefHashTableOf<SchemaInfo, PtrHasher>*         fPreprocessedNodes;
758    SchemaInfo*                                    fSchemaInfo;
759    XercesGroupInfo*                               fCurrentGroupInfo;
760    XercesAttGroupInfo*                            fCurrentAttGroupInfo;
761    ComplexTypeInfo*                               fCurrentComplexType;
762    ValueVectorOf<unsigned int>*                   fCurrentTypeNameStack;
763    ValueVectorOf<unsigned int>*                   fCurrentGroupStack;
764    ValueVectorOf<SchemaElementDecl*>*             fIC_Elements;
765    ValueVectorOf<const DOMElement*>*              fDeclStack;
766    ValueVectorOf<unsigned int>**                  fGlobalDeclarations;
767    ValueVectorOf<DOMNode*>*                       fNonXSAttList;
768    ValueVectorOf<int>*                            fImportedNSList;
769    RefHashTableOf<ValueVectorOf<DOMElement*>, PtrHasher>* fIC_NodeListNS;
770    RefHash2KeysTableOf<XMLCh>*                    fNotationRegistry;
771    RefHash2KeysTableOf<XMLCh>*                    fRedefineComponents;
772    RefHash2KeysTableOf<IdentityConstraint>*       fIdentityConstraintNames;
773    RefHash2KeysTableOf<ElemVector>*               fValidSubstitutionGroups;
774    RefHash2KeysTableOf<SchemaInfo>*               fSchemaInfoList;
775    RefHash2KeysTableOf<SchemaInfo>*               fCachedSchemaInfoList;
776    XSDDOMParser*                                  fParser;
777    XSDErrorReporter                               fXSDErrorReporter;
778    XSDLocator*                                    fLocator;
779    MemoryManager*                                 fMemoryManager;
780    MemoryManager*                                 fGrammarPoolMemoryManager;
781    XSAnnotation*                                  fAnnotation;
782    GeneralAttributeCheck                          fAttributeCheck;
783
784    friend class GeneralAttributeCheck;
785    friend class NamespaceScopeManager;
786};
787
788
789// ---------------------------------------------------------------------------
790//  TraverseSchema: Helper methods
791// ---------------------------------------------------------------------------
792inline const XMLCh* TraverseSchema::getPrefix(const XMLCh* const rawName) {
793
794    int colonIndex = XMLString::indexOf(rawName, chColon);
795
796    if (colonIndex == -1 || colonIndex == 0) {
797        return XMLUni::fgZeroLenString;
798    }
799
800    fBuffer.set(rawName, colonIndex);
801
802    return fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer()));
803}
804
805inline const XMLCh* TraverseSchema::getLocalPart(const XMLCh* const rawName) {
806
807    int    colonIndex = XMLString::indexOf(rawName, chColon);
808    XMLSize_t rawNameLen = XMLString::stringLen(rawName);
809
810    if (XMLSize_t(colonIndex + 1) == rawNameLen) {
811        return XMLUni::fgZeroLenString;
812    }
813
814    if (colonIndex == -1) {
815        fBuffer.set(rawName, rawNameLen);
816    }
817    else {
818
819        fBuffer.set(rawName + colonIndex + 1, rawNameLen - colonIndex - 1);
820    }
821
822    return fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer()));
823}
824
825inline void
826TraverseSchema::checkForEmptyTargetNamespace(const DOMElement* const elem) {
827
828    const XMLCh* targetNS = getElementAttValue(elem, SchemaSymbols::fgATT_TARGETNAMESPACE);
829
830    if (targetNS && !*targetNS) {
831        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidTargetNSValue);
832    }
833}
834
835inline bool TraverseSchema::isBaseFromAnotherSchema(const XMLCh* const baseURI)
836{
837    if (!XMLString::equals(baseURI,fTargetNSURIString)
838        && !XMLString::equals(baseURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)
839        && (baseURI && *baseURI)) {
840        //REVISIT, !!!! a hack: for schema that has no
841        //target namespace, e.g. personal-schema.xml
842        return true;
843    }
844
845    return false;
846}
847
848inline bool TraverseSchema::isAttrOrAttrGroup(const DOMElement* const elem) {
849
850    const XMLCh* elementName = elem->getLocalName();
851
852    if (XMLString::equals(elementName, SchemaSymbols::fgELT_ATTRIBUTE) ||
853        XMLString::equals(elementName, SchemaSymbols::fgELT_ATTRIBUTEGROUP) ||
854        XMLString::equals(elementName, SchemaSymbols::fgELT_ANYATTRIBUTE)) {
855        return true;
856    }
857
858    return false;
859}
860
861inline const XMLCh* TraverseSchema::genAnonTypeName(const XMLCh* const prefix) {
862
863    XMLCh anonCountStr[16]; // a count of 15 digits should be enough
864
865    XMLString::sizeToText(fAnonXSTypeCount++, anonCountStr, 15, 10, fMemoryManager);
866    fBuffer.set(prefix);
867    fBuffer.append(anonCountStr);
868
869    return fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer()));
870}
871
872inline void TraverseSchema::popCurrentTypeNameStack() {
873
874    XMLSize_t stackSize = fCurrentTypeNameStack->size();
875
876    if (stackSize != 0) {
877        fCurrentTypeNameStack->removeElementAt(stackSize - 1);
878    }
879}
880
881inline void
882TraverseSchema::copyWildCardData(const SchemaAttDef* const srcWildCard,
883                                 SchemaAttDef* const destWildCard) {
884
885    destWildCard->getAttName()->setURI(srcWildCard->getAttName()->getURI());
886    destWildCard->setType(srcWildCard->getType());
887    destWildCard->setDefaultType(srcWildCard->getDefaultType());
888}
889
890inline void TraverseSchema::getRedefineNewTypeName(const XMLCh* const oldTypeName,
891                                                   const int redefineCounter,
892                                                   XMLBuffer& newTypeName) {
893
894    newTypeName.set(oldTypeName);
895
896    for (int i=0; i < redefineCounter; i++) {
897        newTypeName.append(SchemaSymbols::fgRedefIdentifier);
898    }
899}
900
901inline bool TraverseSchema::isImportingNS(const int namespaceURI) {
902
903    if (!fImportedNSList)
904        return false;
905
906    return (fImportedNSList->containsElement(namespaceURI));
907}
908
909inline void TraverseSchema::addImportedNS(const int namespaceURI) {
910
911    if (!fImportedNSList) {
912        fImportedNSList = new (fMemoryManager) ValueVectorOf<int>(4, fMemoryManager);
913    }
914
915    if (!fImportedNSList->containsElement(namespaceURI))
916        fImportedNSList->addElement(namespaceURI);
917}
918
919XERCES_CPP_NAMESPACE_END
920
921#endif
922
923/**
924  * End of file TraverseSchema.hpp
925  */
Note: See TracBrowser for help on using the repository browser.