| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #if !defined(TRAVERSESCHEMA_HPP) |
| #define TRAVERSESCHEMA_HPP |
| |
| /** |
| * Instances of this class get delegated to Traverse the Schema and |
| * to populate the SchemaGrammar internal representation. |
| */ |
| |
| // --------------------------------------------------------------------------- |
| // Includes |
| // --------------------------------------------------------------------------- |
| #include <xercesc/util/XMLUniDefs.hpp> |
| #include <xercesc/dom/DOMElement.hpp> |
| #include <xercesc/dom/DOMAttr.hpp> |
| #include <xercesc/framework/XMLBuffer.hpp> |
| #include <xercesc/framework/XMLErrorCodes.hpp> |
| #include <xercesc/validators/schema/SchemaSymbols.hpp> |
| #include <xercesc/util/ValueVectorOf.hpp> |
| #include <xercesc/util/RefHash2KeysTableOf.hpp> |
| #include <xercesc/validators/common/ContentSpecNode.hpp> |
| #include <xercesc/validators/schema/SchemaGrammar.hpp> |
| #include <xercesc/validators/schema/SchemaInfo.hpp> |
| #include <xercesc/validators/schema/GeneralAttributeCheck.hpp> |
| #include <xercesc/validators/schema/XSDErrorReporter.hpp> |
| #include <xercesc/util/XMLResourceIdentifier.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| // --------------------------------------------------------------------------- |
| // Forward Declarations |
| // --------------------------------------------------------------------------- |
| class GrammarResolver; |
| class XMLEntityHandler; |
| class XMLScanner; |
| class DatatypeValidator; |
| class DatatypeValidatorFactory; |
| class QName; |
| class ComplexTypeInfo; |
| class XMLAttDef; |
| class NamespaceScope; |
| class SchemaAttDef; |
| class InputSource; |
| class XercesGroupInfo; |
| class XercesAttGroupInfo; |
| class IdentityConstraint; |
| class XSDLocator; |
| class XSDDOMParser; |
| class XMLErrorReporter; |
| |
| |
| class VALIDATORS_EXPORT TraverseSchema : public XMemory |
| { |
| public: |
| // ----------------------------------------------------------------------- |
| // Public Constructors/Destructor |
| // ----------------------------------------------------------------------- |
| TraverseSchema |
| ( |
| DOMElement* const schemaRoot |
| , XMLStringPool* const uriStringPool |
| , SchemaGrammar* const schemaGrammar |
| , GrammarResolver* const grammarResolver |
| , XMLScanner* const xmlScanner |
| , const XMLCh* const schemaURL |
| , XMLEntityHandler* const entityHandler |
| , XMLErrorReporter* const errorReporter |
| , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager |
| ); |
| |
| ~TraverseSchema(); |
| |
| private: |
| // This enumeration is defined here for compatibility with the CodeWarrior |
| // compiler, which apparently doesn't like to accept default parameter |
| // arguments that it hasn't yet seen. The Not_All_Context argument is |
| // used in the declaration of checkMinMax, below. |
| // |
| // Flags indicate any special restrictions on minOccurs and maxOccurs |
| // relating to "all". |
| // Not_All_Context - not processing an <all> |
| // All_Element - processing an <element> in an <all> |
| // Group_Ref_With_All - processing <group> reference that contained <all> |
| // All_Group - processing an <all> group itself |
| enum |
| { |
| Not_All_Context = 0 |
| , All_Element = 1 |
| , Group_Ref_With_All = 2 |
| , All_Group = 4 |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // Unimplemented constructors and operators |
| // ----------------------------------------------------------------------- |
| TraverseSchema(const TraverseSchema&); |
| TraverseSchema& operator=(const TraverseSchema&); |
| |
| // ----------------------------------------------------------------------- |
| // Init/CleanUp methods |
| // ----------------------------------------------------------------------- |
| void init(); |
| void cleanUp(); |
| |
| // ----------------------------------------------------------------------- |
| // Traversal methods |
| // ----------------------------------------------------------------------- |
| /** |
| * Traverse the Schema DOM tree |
| */ |
| void doTraverseSchema(const DOMElement* const schemaRoot); |
| void preprocessSchema(DOMElement* const schemaRoot, |
| const XMLCh* const schemaURL); |
| void traverseSchemaHeader(const DOMElement* const schemaRoot); |
| XSAnnotation* traverseAnnotationDecl(const DOMElement* const childElem, |
| ValueVectorOf<DOMNode*>* const nonXSAttList, |
| const bool topLevel = false); |
| void traverseInclude(const DOMElement* const childElem); |
| void traverseImport(const DOMElement* const childElem); |
| void traverseRedefine(const DOMElement* const childElem); |
| void traverseAttributeDecl(const DOMElement* const childElem, |
| ComplexTypeInfo* const typeInfo, |
| const bool topLevel = false); |
| void traverseSimpleContentDecl(const XMLCh* const typeName, |
| const XMLCh* const qualifiedName, |
| const DOMElement* const contentDecl, |
| ComplexTypeInfo* const typeInfo, |
| Janitor<XSAnnotation>* const janAnnot); |
| void traverseComplexContentDecl(const XMLCh* const typeName, |
| const DOMElement* const contentDecl, |
| ComplexTypeInfo* const typeInfo, |
| const bool isMixed, |
| Janitor<XSAnnotation>* const janAnnot); |
| DatatypeValidator* traverseSimpleTypeDecl(const DOMElement* const childElem, |
| const bool topLevel = true, |
| int baseRefContext = SchemaSymbols::XSD_EMPTYSET); |
| int traverseComplexTypeDecl(const DOMElement* const childElem, |
| const bool topLevel = true, |
| const XMLCh* const recursingTypeName = 0); |
| DatatypeValidator* traverseByList(const DOMElement* const rootElem, |
| const DOMElement* const contentElem, |
| const XMLCh* const typeName, |
| const XMLCh* const qualifiedName, |
| const int finalSet, |
| Janitor<XSAnnotation>* const janAnnot); |
| DatatypeValidator* traverseByRestriction(const DOMElement* const rootElem, |
| const DOMElement* const contentElem, |
| const XMLCh* const typeName, |
| const XMLCh* const qualifiedName, |
| const int finalSet, |
| Janitor<XSAnnotation>* const janAnnot); |
| DatatypeValidator* traverseByUnion(const DOMElement* const rootElem, |
| const DOMElement* const contentElem, |
| const XMLCh* const typeName, |
| const XMLCh* const qualifiedName, |
| const int finalSet, |
| int baseRefContext, |
| Janitor<XSAnnotation>* const janAnnot); |
| SchemaElementDecl* traverseElementDecl(const DOMElement* const childElem, |
| const bool topLevel = false); |
| const XMLCh* traverseNotationDecl(const DOMElement* const childElem); |
| const XMLCh* traverseNotationDecl(const DOMElement* const childElem, |
| const XMLCh* const name, |
| const XMLCh* const uriStr); |
| ContentSpecNode* traverseChoiceSequence(const DOMElement* const elemDecl, |
| const int modelGroupType); |
| ContentSpecNode* traverseAny(const DOMElement* const anyDecl); |
| ContentSpecNode* traverseAll(const DOMElement* const allElem); |
| XercesGroupInfo* traverseGroupDecl(const DOMElement* const childElem, |
| const bool topLevel = true); |
| XercesAttGroupInfo* traverseAttributeGroupDecl(const DOMElement* const elem, |
| ComplexTypeInfo* const typeInfo, |
| const bool topLevel = false); |
| XercesAttGroupInfo* traverseAttributeGroupDeclNS(const DOMElement* const elem, |
| const XMLCh* const uriStr, |
| const XMLCh* const name); |
| SchemaAttDef* traverseAnyAttribute(const DOMElement* const elem); |
| void traverseKey(const DOMElement* const icElem, |
| SchemaElementDecl* const elemDecl); |
| void traverseUnique(const DOMElement* const icElem, |
| SchemaElementDecl* const elemDecl); |
| void traverseKeyRef(const DOMElement* const icElem, |
| SchemaElementDecl* const elemDecl, |
| const unsigned int namespaceDepth); |
| bool traverseIdentityConstraint(IdentityConstraint* const ic, |
| const DOMElement* const icElem); |
| |
| // ----------------------------------------------------------------------- |
| // Error Reporting methods |
| // ----------------------------------------------------------------------- |
| void reportSchemaError(const XSDLocator* const aLocator, |
| const XMLCh* const msgDomain, |
| const int errorCode); |
| void reportSchemaError(const XSDLocator* const aLocator, |
| const XMLCh* const msgDomain, |
| const int errorCode, |
| const XMLCh* const text1, |
| const XMLCh* const text2 = 0, |
| const XMLCh* const text3 = 0, |
| const XMLCh* const text4 = 0); |
| void reportSchemaError(const DOMElement* const elem, |
| const XMLCh* const msgDomain, |
| const int errorCode); |
| void reportSchemaError(const DOMElement* const elem, |
| const XMLCh* const msgDomain, |
| const int errorCode, |
| const XMLCh* const text1, |
| const XMLCh* const text2 = 0, |
| const XMLCh* const text3 = 0, |
| const XMLCh* const text4 = 0); |
| void reportSchemaError(const DOMElement* const elem, |
| const XMLException& except); |
| |
| // ----------------------------------------------------------------------- |
| // Private Helper methods |
| // ----------------------------------------------------------------------- |
| /** |
| * Retrived the Namespace mapping from the schema element |
| */ |
| void retrieveNamespaceMapping(const DOMElement* const schemaRoot); |
| |
| /** |
| * Loop through the children, and traverse the corresponding schema type |
| * type declaration (simpleType, complexType, import, ....) |
| */ |
| void processChildren(const DOMElement* const root); |
| void preprocessChildren(const DOMElement* const root); |
| |
| void preprocessImport(const DOMElement* const elemNode); |
| void preprocessInclude(const DOMElement* const elemNode); |
| void preprocessRedefine(const DOMElement* const elemNode); |
| |
| /** |
| * Parameters: |
| * rootElem - top element for a given type declaration |
| * contentElem - content must be annotation? or some other simple content |
| * isEmpty: - true if (annotation?, smth_else), false if (annotation?) |
| * processAnnot - default is true, false if reprocessing a complex type |
| * since we have already processed the annotation. |
| * |
| * Check for Annotation if it is present, traverse it. If a sibling is |
| * found and it is not an annotation return it, otherwise return 0. |
| * Used by traverseSimpleTypeDecl. |
| */ |
| DOMElement* checkContent(const DOMElement* const rootElem, |
| DOMElement* const contentElem, |
| const bool isEmpty, bool processAnnot = true); |
| |
| /** |
| * Parameters: |
| * contentElem - content element to check |
| * |
| * Check for identity constraints content. |
| */ |
| const DOMElement* checkIdentityConstraintContent(const DOMElement* const contentElem); |
| |
| DatatypeValidator* getDatatypeValidator(const XMLCh* const uriStr, |
| const XMLCh* const localPartStr); |
| |
| /** |
| * Process simpleType content of a list|restriction|union |
| * Return a dataype validator if valid type, otherwise 0. |
| */ |
| DatatypeValidator* checkForSimpleTypeValidator(const DOMElement* const content, |
| int baseRefContext = SchemaSymbols::XSD_EMPTYSET); |
| |
| /** |
| * Process complexType content of an element |
| * Return a ComplexTypeInfo if valid type, otherwise 0. |
| */ |
| ComplexTypeInfo* checkForComplexTypeInfo(const DOMElement* const content); |
| |
| /** |
| * Return DatatypeValidator available for the baseTypeStr. |
| */ |
| DatatypeValidator* findDTValidator(const DOMElement* const elem, |
| const XMLCh* const derivedTypeName, |
| const XMLCh* const baseTypeName, |
| const int baseRefContext); |
| |
| const XMLCh* resolvePrefixToURI(const DOMElement* const elem, |
| const XMLCh* const prefix); |
| const XMLCh* resolvePrefixToURI(const DOMElement* const elem, |
| const XMLCh* const prefix, |
| const unsigned int namespaceDepth); |
| |
| /** |
| * Return the prefix for a given rawname string |
| * |
| * Function allocated, caller managed (facm) - pointer to be deleted by |
| * caller. |
| */ |
| const XMLCh* getPrefix(const XMLCh* const rawName); |
| |
| /** |
| * Return the local for a given rawname string |
| * |
| * caller allocated, caller managed (cacm) |
| */ |
| const XMLCh* getLocalPart(const XMLCh* const rawName); |
| |
| /** |
| * Process a 'ref' of an Element declaration |
| */ |
| SchemaElementDecl* processElementDeclRef(const DOMElement* const elem, |
| const XMLCh* const refName); |
| void processElemDeclAttrs(const DOMElement* const elem, |
| SchemaElementDecl* const elemDecl, |
| const XMLCh*& valConstraint, |
| bool isTopLevel = false); |
| void processElemDeclIC(DOMElement* const elem, |
| SchemaElementDecl* const elemDecl); |
| bool checkElemDeclValueConstraint(const DOMElement* const elem, |
| SchemaElementDecl* const elemDecl, |
| const XMLCh* const valConstraint, |
| ComplexTypeInfo* const typeInfo, |
| DatatypeValidator* const validator); |
| |
| /** |
| * Process a 'ref' of an Attribute declaration |
| */ |
| void processAttributeDeclRef(const DOMElement* const elem, |
| ComplexTypeInfo* const typeInfo, |
| const XMLCh* const refName, |
| const XMLCh* const useVal, |
| const XMLCh* const defaultVal, |
| const XMLCh* const fixedVal); |
| |
| /** |
| * Process a 'ref' on a group |
| */ |
| XercesGroupInfo* processGroupRef(const DOMElement* const elem, |
| const XMLCh* const refName); |
| |
| /** |
| * Process a 'ref' on a attributeGroup |
| */ |
| XercesAttGroupInfo* processAttributeGroupRef(const DOMElement* const elem, |
| const XMLCh* const refName, |
| ComplexTypeInfo* const typeInfo); |
| |
| /** |
| * Parse block & final items |
| */ |
| int parseBlockSet(const DOMElement* const elem, const int blockType, const bool isRoot = false); |
| int parseFinalSet(const DOMElement* const elem, const int finalType, const bool isRoot = false); |
| |
| /** |
| * Return true if a name is an identity constraint, otherwise false |
| */ |
| bool isIdentityConstraintName(const XMLCh* const constraintName); |
| |
| /** |
| * If 'typeStr' belongs to a different schema, return that schema URI, |
| * otherwise return 0; |
| */ |
| const XMLCh* checkTypeFromAnotherSchema(const DOMElement* const elem, |
| const XMLCh* const typeStr); |
| |
| /** |
| * Return the datatype validator for a given element type attribute if |
| * the type is a simple type |
| */ |
| DatatypeValidator* getElementTypeValidator(const DOMElement* const elem, |
| const XMLCh* const typeStr, |
| bool& noErrorDetected, |
| const XMLCh* const otherSchemaURI); |
| |
| /** |
| * Return the complexType info for a given element type attribute if |
| * the type is a complex type |
| */ |
| ComplexTypeInfo* getElementComplexTypeInfo(const DOMElement* const elem, |
| const XMLCh* const typeStr, |
| const XMLCh* const otherSchemaURI); |
| |
| /** |
| * Return global schema element declaration for a given element name |
| */ |
| SchemaElementDecl* getGlobalElemDecl(const DOMElement* const elem, |
| const XMLCh* const name); |
| |
| /** |
| * Check validity constraint of a substitutionGroup attribute in |
| * an element declaration |
| */ |
| bool isSubstitutionGroupValid(const DOMElement* const elem, |
| const SchemaElementDecl* const elemDecl, |
| const ComplexTypeInfo* const typeInfo, |
| const DatatypeValidator* const validator, |
| const XMLCh* const elemName, |
| const bool toEmit = true); |
| |
| bool isSubstitutionGroupCircular(SchemaElementDecl* const elemDecl, |
| SchemaElementDecl* const subsElemDecl); |
| |
| void processSubstitutionGroup(const DOMElement* const elem, |
| SchemaElementDecl* const elemDecl, |
| ComplexTypeInfo*& typeInfo, |
| DatatypeValidator*& validator, |
| const XMLCh* const subsElemQName); |
| |
| /** |
| * Create a 'SchemaElementDecl' object and add it to SchemaGrammar |
| */ |
| SchemaElementDecl* createSchemaElementDecl(const DOMElement* const elem, |
| const XMLCh* const name, |
| bool& isDuplicate, |
| const XMLCh*& valConstraint, |
| const bool topLevel); |
| |
| /** |
| * Return the value of a given attribute name from an element node |
| */ |
| const XMLCh* getElementAttValue(const DOMElement* const elem, |
| const XMLCh* const attName, |
| const bool toTrim = false); |
| |
| void checkMinMax(ContentSpecNode* const specNode, |
| const DOMElement* const elem, |
| const int allContext = Not_All_Context); |
| |
| /** |
| * Process complex content for a complexType |
| */ |
| void processComplexContent(const DOMElement* const elem, |
| const XMLCh* const typeName, |
| const DOMElement* const childElem, |
| ComplexTypeInfo* const typeInfo, |
| const XMLCh* const baseLocalPart, |
| const bool isMixed, |
| const bool isBaseAnyType = false); |
| |
| /** |
| * Process "base" information for a complexType |
| */ |
| void processBaseTypeInfo(const DOMElement* const elem, |
| const XMLCh* const baseName, |
| const XMLCh* const localPart, |
| const XMLCh* const uriStr, |
| ComplexTypeInfo* const typeInfo); |
| |
| /** |
| * Check if base is from another schema |
| */ |
| bool isBaseFromAnotherSchema(const XMLCh* const baseURI); |
| |
| /** |
| * Get complexType infp from another schema |
| */ |
| ComplexTypeInfo* getTypeInfoFromNS(const DOMElement* const elem, |
| const XMLCh* const uriStr, |
| const XMLCh* const localPart); |
| |
| DatatypeValidator* |
| getAttrDatatypeValidatorNS(const DOMElement* const elem, |
| const XMLCh* localPart, |
| const XMLCh* typeURI); |
| |
| /** |
| * Returns true if a DOM Element is an attribute or attribute group |
| */ |
| bool isAttrOrAttrGroup(const DOMElement* const elem); |
| |
| /** |
| * Process attributes of a complex type |
| */ |
| void processAttributes(const DOMElement* const elem, |
| const DOMElement* const attElem, |
| ComplexTypeInfo* const typeInfo, |
| const bool isBaseAnyType = false); |
| |
| /** |
| * Generate a name for an anonymous type |
| */ |
| const XMLCh* genAnonTypeName(const XMLCh* const prefix); |
| |
| void defaultComplexTypeInfo(ComplexTypeInfo* const typeInfo); |
| |
| /** |
| * Resolve a schema location attribute value to an input source. |
| * Caller to delete the returned object. |
| */ |
| InputSource* resolveSchemaLocation |
| ( |
| const XMLCh* const loc |
| , const XMLResourceIdentifier::ResourceIdentifierType resourceIdentitiferType |
| , const XMLCh* const nameSpace=0 |
| ); |
| |
| void restoreSchemaInfo(SchemaInfo* const toRestore, |
| SchemaInfo::ListType const aListType = SchemaInfo::INCLUDE, |
| const int saveScope = Grammar::TOP_LEVEL_SCOPE); |
| void popCurrentTypeNameStack(); |
| |
| /** |
| * Check whether a mixed content is emptiable or not. |
| * Needed to validate element constraint values (defualt, fixed) |
| */ |
| bool emptiableParticle(const ContentSpecNode* const specNode); |
| |
| void checkFixedFacet(const DOMElement* const, const XMLCh* const, |
| const DatatypeValidator* const, unsigned int&); |
| void buildValidSubstitutionListF(const DOMElement* const elem, |
| SchemaElementDecl* const, |
| SchemaElementDecl* const); |
| void buildValidSubstitutionListB(const DOMElement* const elem, |
| SchemaElementDecl* const, |
| SchemaElementDecl* const); |
| |
| void checkEnumerationRequiredNotation(const DOMElement* const elem, |
| const XMLCh* const name, |
| const XMLCh* const typeStr); |
| |
| void processElements(const DOMElement* const elem, |
| ComplexTypeInfo* const baseTypeInfo, |
| ComplexTypeInfo* const newTypeInfo); |
| |
| void processElements(const DOMElement* const elem, |
| XercesGroupInfo* const fromGroup, |
| ComplexTypeInfo* const typeInfo); |
| |
| void copyGroupElements(const DOMElement* const elem, |
| XercesGroupInfo* const fromGroup, |
| XercesGroupInfo* const toGroup, |
| ComplexTypeInfo* const typeInfo); |
| |
| void copyAttGroupAttributes(const DOMElement* const elem, |
| XercesAttGroupInfo* const fromAttGroup, |
| XercesAttGroupInfo* const toAttGroup, |
| ComplexTypeInfo* const typeInfo); |
| |
| void checkForEmptyTargetNamespace(const DOMElement* const elem); |
| |
| /** |
| * Attribute wild card intersection. |
| * |
| * Note: |
| * The first parameter will be the result of the intersection, so |
| * we need to make sure that first parameter is a copy of the |
| * actual attribute definition we need to intersect with. |
| * |
| * What we need to wory about is: type, defaultType, namespace, |
| * and URI. All remaining data members should be the same. |
| */ |
| void attWildCardIntersection(SchemaAttDef* const resultWildCart, |
| const SchemaAttDef* const toCompareWildCard); |
| |
| /** |
| * Attribute wild card union. |
| * |
| * Note: |
| * The first parameter will be the result of the union, so |
| * we need to make sure that first parameter is a copy of the |
| * actual attribute definition we need to intersect with. |
| * |
| * What we need to wory about is: type, defaultType, namespace, |
| * and URI. All remaining data members should be the same. |
| */ |
| void attWildCardUnion(SchemaAttDef* const resultWildCart, |
| const SchemaAttDef* const toCompareWildCard); |
| |
| void copyWildCardData(const SchemaAttDef* const srcWildCard, |
| SchemaAttDef* const destWildCard); |
| |
| /** |
| * Check that the attributes of a type derived by restriction satisfy |
| * the constraints of derivation valid restriction |
| */ |
| void checkAttDerivationOK(const DOMElement* const elem, |
| const ComplexTypeInfo* const baseTypeInfo, |
| const ComplexTypeInfo* const childTypeInfo); |
| void checkAttDerivationOK(const DOMElement* const elem, |
| const XercesAttGroupInfo* const baseAttGrpInfo, |
| const XercesAttGroupInfo* const childAttGrpInfo); |
| |
| /** |
| * Check whether a namespace value is valid with respect to wildcard |
| * constraint |
| */ |
| bool wildcardAllowsNamespace(const SchemaAttDef* const baseAttWildCard, |
| const unsigned int nameURI); |
| |
| /** |
| * Check whether a namespace constraint is an intensional subset of |
| * another namespace constraint |
| */ |
| bool isWildCardSubset(const SchemaAttDef* const baseAttWildCard, |
| const SchemaAttDef* const childAttWildCard); |
| |
| bool openRedefinedSchema(const DOMElement* const redefineElem); |
| |
| /** |
| * The purpose of this method is twofold: |
| * 1. To find and appropriately modify all information items |
| * in redefinedSchema with names that are redefined by children of |
| * redefineElem. |
| * 2. To make sure the redefine element represented by |
| * redefineElem is valid as far as content goes and with regard to |
| * properly referencing components to be redefined. |
| * |
| * No traversing is done here! |
| * This method also takes actions to find and, if necessary, modify |
| * the names of elements in <redefine>'s in the schema that's being |
| * redefined. |
| */ |
| void renameRedefinedComponents(const DOMElement* const redefineElem, |
| SchemaInfo* const redefiningSchemaInfo, |
| SchemaInfo* const redefinedSchemaInfo); |
| |
| /** |
| * This method returns true if the redefine component is valid, and if |
| * it was possible to revise it correctly. |
| */ |
| bool validateRedefineNameChange(const DOMElement* const redefineChildElem, |
| const XMLCh* const redefineChildElemName, |
| const XMLCh* const redefineChildDeclName, |
| const int redefineNameCounter, |
| SchemaInfo* const redefiningSchemaInfo); |
| |
| /** |
| * This function looks among the children of 'redefineChildElem' for a |
| * component of type 'redefineChildComponentName'. If it finds one, it |
| * evaluates whether its ref attribute contains a reference to |
| * 'refChildTypeName'. If it does, it returns 1 + the value returned by |
| * calls to itself on all other children. In all other cases it returns |
| * 0 plus the sum of the values returned by calls to itself on |
| * redefineChildElem's children. It also resets the value of ref so that |
| * it will refer to the renamed type from the schema being redefined. |
| */ |
| int changeRedefineGroup(const DOMElement* const redefineChildElem, |
| const XMLCh* const redefineChildComponentName, |
| const XMLCh* const redefineChildTypeName, |
| const int redefineNameCounter); |
| |
| /** This simple function looks for the first occurrence of a |
| * 'redefineChildTypeName' item in the redefined schema and appropriately |
| * changes the value of its name. If it turns out that what we're looking |
| * for is in a <redefine> though, then we just rename it--and it's |
| * reference--to be the same. |
| */ |
| void fixRedefinedSchema(const DOMElement* const elem, |
| SchemaInfo* const redefinedSchemaInfo, |
| const XMLCh* const redefineChildComponentName, |
| const XMLCh* const redefineChildTypeName, |
| const int redefineNameCounter); |
| |
| void getRedefineNewTypeName(const XMLCh* const oldTypeName, |
| const int redefineCounter, |
| XMLBuffer& newTypeName); |
| |
| /** |
| * This purpose of this method is threefold: |
| * 1. To extract the schema information of included/redefined schema. |
| * 2. Rename redefined components. |
| * 3. Process components of included/redefined schemas |
| */ |
| void preprocessRedefineInclude(SchemaInfo* const currSchemaInfo); |
| |
| /** |
| * Update the list of valid substitution groups in the case of circular |
| * import. |
| */ |
| void updateCircularSubstitutionList(SchemaInfo* const aSchemaInfo); |
| |
| void processKeyRefFor(SchemaInfo* const aSchemaInfo, |
| ValueVectorOf<SchemaInfo*>* const infoList); |
| |
| void processAttValue(const XMLCh* const attVal, XMLBuffer& aBuf); |
| |
| // routine to generate synthetic annotations |
| XSAnnotation* generateSyntheticAnnotation(const DOMElement* const elem |
| , ValueVectorOf<DOMNode*>* nonXSAttList); |
| |
| // routine to validate annotations |
| void validateAnnotations(); |
| |
| // ----------------------------------------------------------------------- |
| // Private constants |
| // ----------------------------------------------------------------------- |
| enum |
| { |
| ES_Block |
| , C_Block |
| , S_Final |
| , EC_Final |
| , ECS_Final |
| }; |
| |
| enum ExceptionCodes |
| { |
| NoException = 0, |
| InvalidComplexTypeInfo = 1, |
| RecursingElement = 2 |
| }; |
| |
| enum |
| { |
| Elem_Def_Qualified = 1, |
| Attr_Def_Qualified = 2 |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // Private data members |
| // ----------------------------------------------------------------------- |
| bool fFullConstraintChecking; |
| int fTargetNSURI; |
| int fEmptyNamespaceURI; |
| int fCurrentScope; |
| int fScopeCount; |
| unsigned int fAnonXSTypeCount; |
| unsigned int fCircularCheckIndex; |
| const XMLCh* fTargetNSURIString; |
| DatatypeValidatorFactory* fDatatypeRegistry; |
| GrammarResolver* fGrammarResolver; |
| SchemaGrammar* fSchemaGrammar; |
| XMLEntityHandler* fEntityHandler; |
| XMLErrorReporter* fErrorReporter; |
| XMLStringPool* fURIStringPool; |
| XMLStringPool* fStringPool; |
| XMLBuffer fBuffer; |
| XMLScanner* fScanner; |
| NamespaceScope* fNamespaceScope; |
| RefHashTableOf<XMLAttDef>* fAttributeDeclRegistry; |
| RefHashTableOf<ComplexTypeInfo>* fComplexTypeRegistry; |
| RefHashTableOf<XercesGroupInfo>* fGroupRegistry; |
| RefHashTableOf<XercesAttGroupInfo>* fAttGroupRegistry; |
| RefHashTableOf<ElemVector>* fIC_ElementsNS; |
| RefHashTableOf<SchemaInfo>* fPreprocessedNodes; |
| SchemaInfo* fSchemaInfo; |
| XercesGroupInfo* fCurrentGroupInfo; |
| XercesAttGroupInfo* fCurrentAttGroupInfo; |
| ComplexTypeInfo* fCurrentComplexType; |
| ValueVectorOf<unsigned int>* fCurrentTypeNameStack; |
| ValueVectorOf<unsigned int>* fCurrentGroupStack; |
| ValueVectorOf<unsigned int>* fIC_NamespaceDepth; |
| ValueVectorOf<SchemaElementDecl*>* fIC_Elements; |
| ValueVectorOf<const DOMElement*>* fDeclStack; |
| ValueVectorOf<unsigned int>** fGlobalDeclarations; |
| ValueVectorOf<DOMNode*>* fNonXSAttList; |
| RefHashTableOf<ValueVectorOf<DOMElement*> >* fIC_NodeListNS; |
| RefHashTableOf<ValueVectorOf<unsigned int> >* fIC_NamespaceDepthNS; |
| RefHash2KeysTableOf<XMLCh>* fNotationRegistry; |
| RefHash2KeysTableOf<XMLCh>* fRedefineComponents; |
| RefHash2KeysTableOf<IdentityConstraint>* fIdentityConstraintNames; |
| RefHash2KeysTableOf<ElemVector>* fValidSubstitutionGroups; |
| RefHash2KeysTableOf<SchemaInfo>* fSchemaInfoList; |
| XSDDOMParser* fParser; |
| XSDErrorReporter fXSDErrorReporter; |
| XSDLocator* fLocator; |
| MemoryManager* fMemoryManager; |
| MemoryManager* fGrammarPoolMemoryManager; |
| XSAnnotation* fAnnotation; |
| GeneralAttributeCheck fAttributeCheck; |
| |
| friend class GeneralAttributeCheck; |
| }; |
| |
| |
| // --------------------------------------------------------------------------- |
| // TraverseSchema: Helper methods |
| // --------------------------------------------------------------------------- |
| inline const XMLCh* TraverseSchema::getPrefix(const XMLCh* const rawName) { |
| |
| int colonIndex = XMLString::indexOf(rawName, chColon); |
| |
| if (colonIndex == -1 || colonIndex == 0) { |
| return XMLUni::fgZeroLenString; |
| } |
| |
| fBuffer.set(rawName, colonIndex); |
| |
| return fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer())); |
| } |
| |
| inline const XMLCh* TraverseSchema::getLocalPart(const XMLCh* const rawName) { |
| |
| int colonIndex = XMLString::indexOf(rawName, chColon); |
| int rawNameLen = XMLString::stringLen(rawName); |
| |
| if (colonIndex + 1 == rawNameLen) { |
| return XMLUni::fgZeroLenString; |
| } |
| |
| if (colonIndex == -1) { |
| fBuffer.set(rawName, rawNameLen); |
| } |
| else { |
| |
| fBuffer.set(rawName + colonIndex + 1, rawNameLen - colonIndex - 1); |
| } |
| |
| return fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer())); |
| } |
| |
| inline |
| const XMLCh* TraverseSchema::getElementAttValue(const DOMElement* const elem, |
| const XMLCh* const attName, |
| const bool toTrim) { |
| |
| DOMAttr* attNode = elem->getAttributeNode(attName); |
| |
| if (attNode == 0) { |
| return 0; |
| } |
| |
| const XMLCh* attValue = attNode->getValue(); |
| |
| if (toTrim) { |
| |
| fBuffer.set(attValue); |
| XMLCh* bufValue = fBuffer.getRawBuffer(); |
| XMLString::trim(bufValue); |
| |
| if (!bufValue || !*bufValue) { |
| return XMLUni::fgZeroLenString; |
| } |
| |
| return fStringPool->getValueForId(fStringPool->addOrFind(bufValue)); |
| } |
| |
| return attValue; |
| } |
| |
| inline void |
| TraverseSchema::checkForEmptyTargetNamespace(const DOMElement* const elem) { |
| |
| const XMLCh* targetNS = getElementAttValue(elem, SchemaSymbols::fgATT_TARGETNAMESPACE); |
| |
| if (targetNS && !*targetNS) { |
| reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidTargetNSValue); |
| } |
| } |
| |
| inline bool TraverseSchema::isBaseFromAnotherSchema(const XMLCh* const baseURI) |
| { |
| if (!XMLString::equals(baseURI,fTargetNSURIString) |
| && !XMLString::equals(baseURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) |
| && (baseURI && *baseURI)) { |
| //REVISIT, !!!! a hack: for schema that has no |
| //target namespace, e.g. personal-schema.xml |
| return true; |
| } |
| |
| return false; |
| } |
| |
| inline bool TraverseSchema::isAttrOrAttrGroup(const DOMElement* const elem) { |
| |
| const XMLCh* elementName = elem->getLocalName(); |
| |
| if (XMLString::equals(elementName, SchemaSymbols::fgELT_ATTRIBUTE) || |
| XMLString::equals(elementName, SchemaSymbols::fgELT_ATTRIBUTEGROUP) || |
| XMLString::equals(elementName, SchemaSymbols::fgELT_ANYATTRIBUTE)) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| inline const XMLCh* TraverseSchema::genAnonTypeName(const XMLCh* const prefix) { |
| |
| XMLCh anonCountStr[16]; // a count of 15 digits should be enough |
| |
| XMLString::binToText(fAnonXSTypeCount++, anonCountStr, 15, 10, fMemoryManager); |
| fBuffer.set(prefix); |
| fBuffer.append(anonCountStr); |
| |
| return fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer())); |
| } |
| |
| inline void TraverseSchema::popCurrentTypeNameStack() { |
| |
| unsigned int stackSize = fCurrentTypeNameStack->size(); |
| |
| if (stackSize != 0) { |
| fCurrentTypeNameStack->removeElementAt(stackSize - 1); |
| } |
| } |
| |
| inline void |
| TraverseSchema::copyWildCardData(const SchemaAttDef* const srcWildCard, |
| SchemaAttDef* const destWildCard) { |
| |
| destWildCard->getAttName()->setURI(srcWildCard->getAttName()->getURI()); |
| destWildCard->setType(srcWildCard->getType()); |
| destWildCard->setDefaultType(srcWildCard->getDefaultType()); |
| } |
| |
| inline void TraverseSchema::getRedefineNewTypeName(const XMLCh* const oldTypeName, |
| const int redefineCounter, |
| XMLBuffer& newTypeName) { |
| |
| newTypeName.set(oldTypeName); |
| |
| for (int i=0; i < redefineCounter; i++) { |
| newTypeName.append(SchemaSymbols::fgRedefIdentifier); |
| } |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
| |
| #endif |
| |
| /** |
| * End of file TraverseSchema.hpp |
| */ |
| |
