source: icXML/icXML-devel/src/icxercesc/validators/schema/TraverseSchema.hpp @ 3153

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

Updates for build

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