diff options
Diffstat (limited to 'libxerces-c/xercesc/validators/schema/TraverseSchema.cpp')
| -rw-r--r-- | libxerces-c/xercesc/validators/schema/TraverseSchema.cpp | 9466 |
1 files changed, 0 insertions, 9466 deletions
diff --git a/libxerces-c/xercesc/validators/schema/TraverseSchema.cpp b/libxerces-c/xercesc/validators/schema/TraverseSchema.cpp deleted file mode 100644 index 2ade0dc..0000000 --- a/libxerces-c/xercesc/validators/schema/TraverseSchema.cpp +++ /dev/null @@ -1,9466 +0,0 @@ -/* - * 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. - */ - -/* - * $Id$ - */ - -// --------------------------------------------------------------------------- -// Includes -// --------------------------------------------------------------------------- -#include <xercesc/validators/schema/TraverseSchema.hpp> -#include <xercesc/framework/XMLEntityHandler.hpp> -#include <xercesc/framework/XMLValidityCodes.hpp> -#include <xercesc/validators/schema/identity/IC_Key.hpp> -#include <xercesc/validators/schema/identity/IC_KeyRef.hpp> -#include <xercesc/validators/schema/identity/IC_Unique.hpp> -#include <xercesc/validators/schema/identity/IC_Field.hpp> -#include <xercesc/validators/schema/identity/IC_Selector.hpp> -#include <xercesc/validators/schema/identity/XercesXPath.hpp> -#include <xercesc/util/XMLStringTokenizer.hpp> -#include <xercesc/validators/schema/XUtil.hpp> -#include <xercesc/validators/common/GrammarResolver.hpp> -#include <xercesc/internal/XMLReader.hpp> -#include <xercesc/validators/schema/ComplexTypeInfo.hpp> -#include <xercesc/validators/schema/NamespaceScope.hpp> -#include <xercesc/validators/schema/SchemaAttDefList.hpp> -#include <xercesc/internal/XMLScanner.hpp> -#include <xercesc/framework/LocalFileInputSource.hpp> -#include <xercesc/framework/URLInputSource.hpp> -#include <xercesc/framework/XMLGrammarPool.hpp> -#include <xercesc/framework/XMLSchemaDescription.hpp> -#include <xercesc/validators/schema/identity/XPathException.hpp> -#include <xercesc/validators/schema/GeneralAttributeCheck.hpp> -#include <xercesc/validators/schema/XercesGroupInfo.hpp> -#include <xercesc/validators/schema/XercesAttGroupInfo.hpp> -#include <xercesc/validators/schema/XSDLocator.hpp> -#include <xercesc/validators/schema/XSDDOMParser.hpp> -#include <xercesc/dom/DOMNamedNodeMap.hpp> -#include <xercesc/dom/DOMText.hpp> -#include <xercesc/dom/impl/XSDElementNSImpl.hpp> -#include <xercesc/util/OutOfMemoryException.hpp> -#include <xercesc/util/NumberFormatException.hpp> -#include <xercesc/util/XMLEntityResolver.hpp> -#include <xercesc/util/XMLUri.hpp> -#include <xercesc/framework/psvi/XSAnnotation.hpp> -#include <xercesc/framework/MemBufInputSource.hpp> -#include <xercesc/internal/XSAXMLScanner.hpp> - -XERCES_CPP_NAMESPACE_BEGIN - -// --------------------------------------------------------------------------- -// TraverseSchema: Local declaration -// --------------------------------------------------------------------------- - -// This helper class will handle the parsing of namespace prefixes for a given DOMElement, and its winding back -class NamespaceScopeManager -{ -public: - NamespaceScopeManager(const DOMElement* const node, SchemaInfo* info, TraverseSchema* traverser) - { - fScopeAdded=node?traverser->retrieveNamespaceMapping(node):false; - fSchemaInfo=info; - } - ~NamespaceScopeManager() - { - if(fScopeAdded) - fSchemaInfo->getNamespaceScope()->decreaseDepth(); - - } -protected: - bool fScopeAdded; - SchemaInfo* fSchemaInfo; -}; - -// --------------------------------------------------------------------------- -// TraverseSchema: Static member data -// --------------------------------------------------------------------------- - - -// --------------------------------------------------------------------------- -// TraverseSchema: Local const data -// --------------------------------------------------------------------------- -static const XMLCh fgAnonSNamePrefix[] = -{ - chUnderscore, chUnderscore, chLatin_A, chLatin_n, chLatin_o, chLatin_n, chLatin_S, chNull -}; - -static const XMLCh fgAnonCNamePrefix[] = -{ - chUnderscore, chUnderscore, chLatin_A, chLatin_n, chLatin_o, chLatin_n, chLatin_C, chNull -}; - -static const XMLCh fgUnbounded[] = -{ - chLatin_u, chLatin_n, chLatin_b, chLatin_o, chLatin_u, chLatin_n, chLatin_d, - chLatin_e, chLatin_d, chNull -}; - -static const XMLCh fgValueOne[] = -{ - chDigit_1, chNull -}; - -static const XMLCh fgValueZero[] = -{ - chDigit_0, chNull -}; - -static const XMLCh* fgIdentityConstraints[] = -{ - SchemaSymbols::fgELT_UNIQUE, - SchemaSymbols::fgELT_KEY, - SchemaSymbols::fgELT_KEYREF -}; - -static const XMLCh fgSynthetic_Annotation[] = -{ - chLatin_S, chLatin_y, chLatin_n, chLatin_t, chLatin_h, chLatin_e, chLatin_t - , chLatin_i, chLatin_c, chUnderscore - , chLatin_A, chLatin_n, chLatin_n, chLatin_o, chLatin_t, chLatin_a, chLatin_t - , chLatin_i, chLatin_o, chLatin_n, chNull -}; - - -// Flags for global declaration -enum { - ENUM_ELT_SIMPLETYPE, - ENUM_ELT_COMPLEXTYPE, - ENUM_ELT_ELEMENT, - ENUM_ELT_ATTRIBUTE, - ENUM_ELT_ATTRIBUTEGROUP, - ENUM_ELT_GROUP, - ENUM_ELT_SIZE -}; - -typedef JanitorMemFunCall<TraverseSchema> CleanupType; - -// --------------------------------------------------------------------------- -// TraverseSchema: Constructors and Destructor -// --------------------------------------------------------------------------- -TraverseSchema::TraverseSchema( DOMElement* const schemaRoot - , XMLStringPool* const uriStringPool - , SchemaGrammar* const schemaGrammar - , GrammarResolver* const grammarResolver - , RefHash2KeysTableOf<SchemaInfo>* cachedSchemaInfoList - , RefHash2KeysTableOf<SchemaInfo>* schemaInfoList - , XMLScanner* const xmlScanner - , const XMLCh* const schemaURL - , XMLEntityHandler* const entityHandler - , XMLErrorReporter* const errorReporter - , MemoryManager* const manager - , bool multipleImport) - : fFullConstraintChecking(false) - , fTargetNSURI(-1) - , fEmptyNamespaceURI(-1) - , fCurrentScope(Grammar::TOP_LEVEL_SCOPE) - , fScopeCount(schemaGrammar->getScopeCount ()) - , fAnonXSTypeCount(schemaGrammar->getAnonTypeCount ()) - , fCircularCheckIndex(0) - , fTargetNSURIString(0) - , fDatatypeRegistry(0) - , fGrammarResolver(grammarResolver) - , fSchemaGrammar(schemaGrammar) - , fEntityHandler(entityHandler) - , fErrorReporter(errorReporter) - , fURIStringPool(uriStringPool) - , fStringPool(0) - , fBuffer(1023, manager) - , fScanner(xmlScanner) - , fAttributeDeclRegistry(0) - , fComplexTypeRegistry(0) - , fGroupRegistry(0) - , fAttGroupRegistry(0) - , fIC_ElementsNS(0) - , fPreprocessedNodes(0) - , fSchemaInfo(0) - , fCurrentGroupInfo(0) - , fCurrentAttGroupInfo(0) - , fCurrentComplexType(0) - , fCurrentTypeNameStack(0) - , fCurrentGroupStack(0) - , fIC_Elements(0) - , fDeclStack(0) - , fGlobalDeclarations(0) - , fNonXSAttList(0) - , fImportedNSList(0) - , fIC_NodeListNS(0) - , fNotationRegistry(0) - , fRedefineComponents(0) - , fIdentityConstraintNames(0) - , fValidSubstitutionGroups(0) - , fSchemaInfoList(schemaInfoList) - , fCachedSchemaInfoList (cachedSchemaInfoList) - , fParser(0) - , fLocator(0) - , fMemoryManager(manager) - , fGrammarPoolMemoryManager(fGrammarResolver->getGrammarPoolMemoryManager()) - , fAnnotation(0) - , fAttributeCheck(manager) -{ - CleanupType cleanup(this, &TraverseSchema::cleanUp); - - try { - - if (fGrammarResolver && schemaRoot && fURIStringPool) { - - init(); - - if (multipleImport) - { - // If we are working on an existing schema, do some - // intitialization that is otherwise done by preprocessSchema. - // - fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry(); - fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry(); - fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry(); - fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry(); - fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups(); - } - - preprocessSchema(schemaRoot, schemaURL, multipleImport); - doTraverseSchema(schemaRoot); - - // Store the scope and anon type counts in case we need to add - // more to this grammar (multi-import case). schemaGrammar and - // fSchemaGrammar should be the same here. - // - fSchemaGrammar->setScopeCount (fScopeCount); - fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount); - } - - } - catch(const OutOfMemoryException&) - { - cleanup.release(); - - throw; - } - - cleanup.release(); -} - - -TraverseSchema::~TraverseSchema() -{ - cleanUp(); -} - - -// --------------------------------------------------------------------------- -// TraverseSchema: Traversal methods -// --------------------------------------------------------------------------- -void TraverseSchema::doTraverseSchema(const DOMElement* const schemaRoot) { - - // process children nodes - processChildren(schemaRoot); - - // Handle identity constraints - keyref - if (fIC_ElementsNS && fIC_ElementsNS->containsKey(fTargetNSURIString)) { - - fIC_Elements = fIC_ElementsNS->get(fTargetNSURIString); - - XMLSize_t icListSize = fIC_Elements->size(); - - for (XMLSize_t i=0; i < icListSize; i++) { - - SchemaElementDecl* curElem = fIC_Elements->elementAt(i); - ValueVectorOf<DOMElement*>* icNodes = fIC_NodeListNS->get(curElem); - XMLSize_t icNodesSize = icNodes->size(); - - for (XMLSize_t j = 0; j < icNodesSize; j++) { - traverseKeyRef(icNodes->elementAt(j), curElem); - } - } - } - - if (fScanner->getValidateAnnotations() && !fSchemaGrammar->getAnnotations()->isEmpty()) - { - validateAnnotations(); - } - fSchemaInfo->setProcessed(); -} - -void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot, - const XMLCh* const schemaURL, - bool multipleImport) { - if (!multipleImport) { - // Make sure namespace binding is defaulted - const XMLCh* rootPrefix = schemaRoot->getPrefix(); - - if (rootPrefix == 0 || !*rootPrefix) { - - const XMLCh* xmlnsStr = schemaRoot->getAttribute(XMLUni::fgXMLNSString); - - if (!xmlnsStr || !*xmlnsStr) { - schemaRoot->setAttribute(XMLUni::fgXMLNSString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA); - } - } - - // Set schemaGrammar data and add it to GrammarResolver - // For complex type registry, attribute decl registry , group/attGroup - // and namespace mapping, needs to check whether the passed in - // Grammar was a newly instantiated one. - fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry(); - - if (fComplexTypeRegistry == 0 ) { - - fComplexTypeRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<ComplexTypeInfo>(29, fGrammarPoolMemoryManager); - fSchemaGrammar->setComplexTypeRegistry(fComplexTypeRegistry); - } - - fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry(); - - if (fGroupRegistry == 0 ) { - - fGroupRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XercesGroupInfo>(13, fGrammarPoolMemoryManager); - fSchemaGrammar->setGroupInfoRegistry(fGroupRegistry); - } - - fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry(); - - if (fAttGroupRegistry == 0 ) { - - fAttGroupRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XercesAttGroupInfo>(13, fGrammarPoolMemoryManager); - fSchemaGrammar->setAttGroupInfoRegistry(fAttGroupRegistry); - } - - fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry(); - - if (fAttributeDeclRegistry == 0) { - - fAttributeDeclRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XMLAttDef>(29, fGrammarPoolMemoryManager); - fSchemaGrammar->setAttributeDeclRegistry(fAttributeDeclRegistry); - } - - fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups(); - - if (!fValidSubstitutionGroups) { - - fValidSubstitutionGroups = new (fGrammarPoolMemoryManager) RefHash2KeysTableOf<ElemVector>(29, fGrammarPoolMemoryManager); - fSchemaGrammar->setValidSubstitutionGroups(fValidSubstitutionGroups); - } - - //Retrieve the targetnamespace URI information - const XMLCh* targetNSURIStr = schemaRoot->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE); - fSchemaGrammar->setTargetNamespace(targetNSURIStr); - - fCurrentScope = Grammar::TOP_LEVEL_SCOPE; - fTargetNSURIString = fSchemaGrammar->getTargetNamespace(); - fTargetNSURI = fURIStringPool->addOrFind(fTargetNSURIString); - - XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) fSchemaGrammar->getGrammarDescription(); - gramDesc->setTargetNamespace(fTargetNSURIString); - - fGrammarResolver->putGrammar(fSchemaGrammar); - } - else { - fCurrentScope = Grammar::TOP_LEVEL_SCOPE; - - fTargetNSURIString = fSchemaGrammar->getTargetNamespace(); - fTargetNSURI = fURIStringPool->addOrFind(fTargetNSURIString); - } - - SchemaInfo* currInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI, - 0, - schemaURL, - fTargetNSURIString, schemaRoot, - fScanner, - fGrammarPoolMemoryManager); - - currInfo->getNamespaceScope()->reset(fEmptyNamespaceURI); - // Add mapping for the xml prefix - currInfo->getNamespaceScope()->addPrefix(XMLUni::fgXMLString, fURIStringPool->addOrFind(XMLUni::fgXMLURIName)); - - if (fSchemaInfo) - fSchemaInfo->addSchemaInfo(currInfo, SchemaInfo::IMPORT); - - addImportedNS(currInfo->getTargetNSURI()); - - fSchemaInfo = currInfo; - fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(), fSchemaInfo->getTargetNSURI(), fSchemaInfo); - fSchemaInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE); - traverseSchemaHeader(schemaRoot); - - // preprocess chidren - preprocessChildren(schemaRoot); -} - - -void TraverseSchema::traverseSchemaHeader(const DOMElement* const schemaRoot) { - - // Make sure that the root element is <xsd:schema> - if (!XMLString::equals(schemaRoot->getLocalName(), SchemaSymbols::fgELT_SCHEMA)) { - reportSchemaError(schemaRoot, XMLUni::fgXMLErrDomain, XMLErrs::InvalidXMLSchemaRoot); - } - - // Make sure that the targetNamespace value is not empty string - checkForEmptyTargetNamespace(schemaRoot); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - schemaRoot, GeneralAttributeCheck::E_Schema, this - , true, fSchemaInfo->getNonXSAttList() - ); - - retrieveNamespaceMapping(schemaRoot); - // Add mapping for the default namespace - if ((!fTargetNSURIString || !*fTargetNSURIString) && schemaRoot->getAttributeNode(XMLUni::fgXMLNSString)==NULL) - fSchemaInfo->getNamespaceScope()->addPrefix(XMLUni::fgZeroLenString, fEmptyNamespaceURI); - - unsigned short elemAttrDefaultQualified = 0; - - if (XMLString::equals(schemaRoot->getAttribute(SchemaSymbols::fgATT_ELEMENTFORMDEFAULT), - SchemaSymbols::fgATTVAL_QUALIFIED)) { - elemAttrDefaultQualified |= Elem_Def_Qualified; - } - - if (XMLString::equals(schemaRoot->getAttribute(SchemaSymbols::fgATT_ATTRIBUTEFORMDEFAULT), - SchemaSymbols::fgATTVAL_QUALIFIED)) { - elemAttrDefaultQualified |= Attr_Def_Qualified; - } - - fSchemaInfo->setElemAttrDefaultQualified(elemAttrDefaultQualified); - fSchemaInfo->setBlockDefault(parseBlockSet(schemaRoot, ES_Block, true)); - fSchemaInfo->setFinalDefault(parseFinalSet(schemaRoot, ECS_Final, true)); -} - - -XSAnnotation* -TraverseSchema::traverseAnnotationDecl(const DOMElement* const annotationElem, - ValueVectorOf<DOMNode*>* const nonXSAttList, - const bool topLevel) { - - NamespaceScopeManager nsMgr(annotationElem, fSchemaInfo, this); - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - annotationElem, GeneralAttributeCheck::E_Annotation, this, topLevel - ); - - const XMLCh* contents = 0; - DOMElement* child = XUtil::getFirstChildElement(annotationElem); - if (child) { - for (; - child != 0; - child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* name = child->getLocalName(); - - if (XMLString::equals(name, SchemaSymbols::fgELT_APPINFO)) { - - DOMNode* textContent = child->getFirstChild(); - if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE) - contents = ((DOMText*) textContent)->getData(); - - fAttributeCheck.checkAttributes(child, GeneralAttributeCheck::E_Appinfo, this); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_DOCUMENTATION)) { - - DOMNode* textContent = child->getFirstChild(); - if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE) - contents = ((DOMText*) textContent)->getData(); - - fAttributeCheck.checkAttributes(child, GeneralAttributeCheck::E_Documentation, this); - } - else { - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAnnotationContent); - } - } - } - else - { - // If the Annotation has no children, get the text directly - DOMNode* textContent = annotationElem->getFirstChild(); - if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE) - contents = ((DOMText*) textContent)->getData(); - } - - if (contents && !fScanner->getIgnoreAnnotations()) - { - XSAnnotation* theAnnotation = 0; - - XMLSize_t nonXSAttSize = nonXSAttList->size(); - - if (nonXSAttSize) - { - int annotTokenStart = XMLString::patternMatch( - contents, SchemaSymbols::fgELT_ANNOTATION); - - if (annotTokenStart == -1) // something is wrong - return 0; - - // set annotation element - fBuffer.set(contents, annotTokenStart + 10); - - for (XMLSize_t i=0; i<nonXSAttSize; i++) - { - DOMNode* attNode = nonXSAttList->elementAt(i); - - if (!XMLString::equals( - annotationElem->getAttributeNS( - attNode->getNamespaceURI(), attNode->getLocalName()) - , XMLUni::fgZeroLenString) - ) - { - continue; - } - - fBuffer.append(chSpace); - fBuffer.append(attNode->getNodeName()); - fBuffer.append(chEqual); - fBuffer.append(chDoubleQuote); - processAttValue(attNode->getNodeValue(), fBuffer); - fBuffer.append(chDoubleQuote); - } - - // add remaining annotation content - fBuffer.append(contents + annotTokenStart + 10); - - theAnnotation = new (fGrammarPoolMemoryManager) XSAnnotation(fBuffer.getRawBuffer(), fGrammarPoolMemoryManager); - } - else - { - theAnnotation = new (fGrammarPoolMemoryManager) XSAnnotation(contents, fGrammarPoolMemoryManager); - } - - /*** - * set line, col and systemId info - ***/ - theAnnotation->setLineCol( - ((XSDElementNSImpl*)annotationElem)->getLineNo() - , ((XSDElementNSImpl*)annotationElem)->getColumnNo() - ); - theAnnotation->setSystemId(fSchemaInfo->getCurrentSchemaURL()); - - return theAnnotation; - } - - return 0; -} - - -/** - * Traverse include - * - * <include - * id = ID - * schemaLocation = anyURI - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?) - * </include> - */ -void TraverseSchema::preprocessInclude(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Include, this, true, fNonXSAttList); - - // ----------------------------------------------------------------------- - // First, handle any ANNOTATION declaration - // ----------------------------------------------------------------------- - if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - - if (fAnnotation) - fSchemaGrammar->addAnnotation(fAnnotation); - else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - fSchemaGrammar->addAnnotation(fAnnotation); - } - - // ----------------------------------------------------------------------- - // Get 'schemaLocation' attribute - // ----------------------------------------------------------------------- - const XMLCh* schemaLocation = getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI); - - if (!schemaLocation || !*schemaLocation) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNoSchemaLocation, SchemaSymbols::fgELT_INCLUDE); - return; - } - - // ------------------------------------------------------------------ - // Resolve schema location - // ------------------------------------------------------------------ - fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0, - ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - InputSource* srcToFill = resolveSchemaLocation(schemaLocation, - XMLResourceIdentifier::SchemaInclude); - Janitor<InputSource> janSrc(srcToFill); - - // Nothing to do - if (!srcToFill) { - return; - } - - const XMLCh* includeURL = srcToFill->getSystemId(); - SchemaInfo* includeSchemaInfo = fCachedSchemaInfoList->get(includeURL, fTargetNSURI); - - if (!includeSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList) - includeSchemaInfo = fSchemaInfoList->get(includeURL, fTargetNSURI); - - if (includeSchemaInfo) { - - fSchemaInfo->addSchemaInfo(includeSchemaInfo, SchemaInfo::INCLUDE); - return; - } - - // ------------------------------------------------------------------ - // Parse input source - // ------------------------------------------------------------------ - if (!fParser) - fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0, fGrammarPoolMemoryManager, 0); - - fParser->setValidationScheme(XercesDOMParser::Val_Never); - fParser->setDoNamespaces(true); - fParser->setUserEntityHandler(fEntityHandler); - fParser->setUserErrorReporter(fErrorReporter); - - // Should just issue warning if the schema is not found - bool flag = srcToFill->getIssueFatalErrorIfNotFound(); - srcToFill->setIssueFatalErrorIfNotFound(false); - - fParser->parse(*srcToFill); - - // Reset the InputSource - srcToFill->setIssueFatalErrorIfNotFound(flag); - - if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal()) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError); - - // ------------------------------------------------------------------ - // Get root element - // ------------------------------------------------------------------ - DOMDocument* document = fParser->getDocument(); - - if (document) { - - DOMElement* root = document->getDocumentElement(); - - if (root) { - - const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE); - - // check to see if targetNameSpace is right - if (*targetNSURIString - && !XMLString::equals(targetNSURIString,fTargetNSURIString)){ - reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::IncludeNamespaceDifference, - schemaLocation, targetNSURIString); - return; - } - - // if targetNamespace is empty, change it to includ'g schema - // targetNamespace - if (!*targetNSURIString && root->getAttributeNode(XMLUni::fgXMLNSString) == 0 - && fTargetNSURI != fEmptyNamespaceURI) { - root->setAttribute(XMLUni::fgXMLNSString, fTargetNSURIString); - } - - // -------------------------------------------------------- - // Update schema information with included schema - // -------------------------------------------------------- - SchemaInfo* saveInfo = fSchemaInfo; - - fSchemaInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI, - 0, - includeURL, - fTargetNSURIString, root, - fScanner, - fGrammarPoolMemoryManager); - - fSchemaInfo->getNamespaceScope()->reset(fEmptyNamespaceURI); - // Add mapping for the xml prefix - fSchemaInfo->getNamespaceScope()->addPrefix(XMLUni::fgXMLString, fURIStringPool->addOrFind(XMLUni::fgXMLURIName)); - - fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(), - fSchemaInfo->getTargetNSURI(), fSchemaInfo); - fPreprocessedNodes->put((void*) elem, fSchemaInfo); - saveInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE); - traverseSchemaHeader(root); - preprocessChildren(root); - fSchemaInfo = saveInfo; - } - } -} - - -void TraverseSchema::traverseInclude(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - SchemaInfo* includeInfo = fPreprocessedNodes->get(elem); - - if (includeInfo) { - - SchemaInfo* saveInfo = fSchemaInfo; - - fSchemaInfo = includeInfo; - processChildren(includeInfo->getRoot()); - fSchemaInfo = saveInfo; - } -} - - -/** - * Traverse import - * - * <import - * id = ID - * namespace = anyURI - * schemaLocation = anyURI - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?) - * </import> - */ -void TraverseSchema::preprocessImport(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Import, this, true, fNonXSAttList); - - // ----------------------------------------------------------------------- - // First, handle any ANNOTATION declaration - // ----------------------------------------------------------------------- - if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - - if (fAnnotation) - fSchemaGrammar->addAnnotation(fAnnotation); - else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - fSchemaGrammar->addAnnotation(fAnnotation); - } - // ----------------------------------------------------------------------- - // Handle 'namespace' attribute - // ----------------------------------------------------------------------- - const XMLCh* nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE, DatatypeValidator::AnyURI); - const XMLCh* nameSpaceValue = nameSpace ? nameSpace : XMLUni::fgZeroLenString; - - if (XMLString::equals(nameSpaceValue, fTargetNSURIString)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Import_1_1); - return; - } - - if (!*nameSpaceValue && fTargetNSURI == fEmptyNamespaceURI) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Import_1_2); - return; - } - - // ------------------------------------------------------------------ - // Get 'schemaLocation' attribute - // ------------------------------------------------------------------ - const XMLCh* schemaLocation = getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI); - - // ------------------------------------------------------------------ - // Resolve namespace to a grammar - // ------------------------------------------------------------------ - Grammar* aGrammar = 0; - - { - XMLSchemaDescription* gramDesc =fGrammarResolver->getGrammarPool()->createSchemaDescription(nameSpaceValue); - Janitor<XMLSchemaDescription> janName(gramDesc); - gramDesc->setContextType(XMLSchemaDescription::CONTEXT_IMPORT); - gramDesc->setLocationHints(schemaLocation); - aGrammar = fGrammarResolver->getGrammar(gramDesc); - } - - bool grammarFound = (aGrammar && (aGrammar->getGrammarType() == Grammar::SchemaGrammarType)); - - if (grammarFound) { - addImportedNS(fURIStringPool->addOrFind(nameSpaceValue)); - } - - // a bare <xs:import/> doesn't load anything - if(!schemaLocation && !nameSpace) - return; - - // ------------------------------------------------------------------ - // Resolve schema location - // ------------------------------------------------------------------ - fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0, - ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - InputSource* srcToFill = resolveSchemaLocation(schemaLocation, - XMLResourceIdentifier::SchemaImport, nameSpace); - - // Nothing to do - if (!srcToFill) { - if (!grammarFound) { - addImportedNS(fURIStringPool->addOrFind(nameSpaceValue)); - } - - return; - } - - Janitor<InputSource> janSrc(srcToFill); - const XMLCh* importURL = srcToFill->getSystemId(); - unsigned int nameSpaceId = nameSpace ? fURIStringPool->addOrFind(nameSpace) : fEmptyNamespaceURI; - - SchemaInfo* importSchemaInfo = fCachedSchemaInfoList->get(importURL, nameSpaceId); - - if (!importSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList) - importSchemaInfo = fSchemaInfoList->get(importURL, nameSpaceId); - - if (importSchemaInfo) { - fSchemaInfo->addSchemaInfo(importSchemaInfo, SchemaInfo::IMPORT); - addImportedNS(importSchemaInfo->getTargetNSURI()); - return; - } - - if (grammarFound) { - if (!fScanner->getHandleMultipleImports()) - return; - } - - // ------------------------------------------------------------------ - // Parse input source - // ------------------------------------------------------------------ - if (!fParser) - fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0, fGrammarPoolMemoryManager, 0); - - fParser->setValidationScheme(XercesDOMParser::Val_Never); - fParser->setDoNamespaces(true); - fParser->setUserEntityHandler(fEntityHandler); - fParser->setUserErrorReporter(fErrorReporter); - - // Should just issue warning if the schema is not found - bool flag = srcToFill->getIssueFatalErrorIfNotFound(); - srcToFill->setIssueFatalErrorIfNotFound(false); - - fParser->parse(*srcToFill) ; - - // Reset the InputSource - srcToFill->setIssueFatalErrorIfNotFound(flag); - - if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal()) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError); - - // ------------------------------------------------------------------ - // Get root element - // ------------------------------------------------------------------ - DOMDocument* document = fParser->getDocument(); - - if (document) { - - DOMElement* root = document->getDocumentElement(); - - if (!root) { - return; - } - - const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE); - - if (!XMLString::equals(targetNSURIString, nameSpaceValue)) { - reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::ImportNamespaceDifference, - schemaLocation, targetNSURIString, nameSpaceValue); - } - else { - - // -------------------------------------------------------- - // Preprocess new schema - // -------------------------------------------------------- - SchemaInfo* saveInfo = fSchemaInfo; - fSchemaGrammar->setScopeCount (fScopeCount); - fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount); - if (grammarFound) { - fSchemaGrammar = (SchemaGrammar*) aGrammar; - } - else { - fSchemaGrammar = new (fGrammarPoolMemoryManager) SchemaGrammar(fGrammarPoolMemoryManager); - } - fScopeCount = fSchemaGrammar->getScopeCount (); - fAnonXSTypeCount = fSchemaGrammar->getAnonTypeCount (); - - XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) fSchemaGrammar->getGrammarDescription(); - gramDesc->setContextType(XMLSchemaDescription::CONTEXT_IMPORT); - gramDesc->setLocationHints(importURL); - - preprocessSchema(root, importURL, grammarFound); - fPreprocessedNodes->put((void*) elem, fSchemaInfo); - - // -------------------------------------------------------- - // Restore old schema information - // -------------------------------------------------------- - restoreSchemaInfo(saveInfo, SchemaInfo::IMPORT); - } - } -} - - -void TraverseSchema::traverseImport(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - SchemaInfo* importInfo = fPreprocessedNodes->get(elem); - - if (importInfo) { - - // -------------------------------------------------------- - // Traverse new schema - // -------------------------------------------------------- - SchemaInfo* saveInfo = fSchemaInfo; - - restoreSchemaInfo(importInfo, SchemaInfo::IMPORT); - doTraverseSchema(importInfo->getRoot()); - - // -------------------------------------------------------- - // Restore old schema information - // -------------------------------------------------------- - restoreSchemaInfo(saveInfo, SchemaInfo::IMPORT); - } -} - - -/** - * Traverse redefine declaration - * - * <redefine> - * schemaLocation = uriReference - * {any attributes with non-schema namespace . . .}> - * Content: (annotation | ( - * attributeGroup | complexType | group | simpleType))* - * </redefine> - */ -void TraverseSchema::preprocessRedefine(const DOMElement* const redefineElem) { - - NamespaceScopeManager nsMgr(redefineElem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - redefineElem, GeneralAttributeCheck::E_Redefine, this, true - ); - - // First, we look through the children of redefineElem. Each one will - // correspond to an element of the redefined schema that we need to - // redefine. To do this, we rename the element of the redefined schema, - // and rework the base or ref tag of the kid we're working on to refer to - // the renamed group or derive the renamed type. Once we've done this, we - // actually go through the schema being redefined and convert it to a - // grammar. Only then do we run through redefineDecl's kids and put them - // in the grammar. - SchemaInfo* redefiningInfo = fSchemaInfo; - - if (!openRedefinedSchema(redefineElem)) { - - redefiningInfo->addFailedRedefine(redefineElem); - return; - } - - if (!fRedefineComponents) { - fRedefineComponents = new (fMemoryManager) RefHash2KeysTableOf<XMLCh>(13, (bool) false, fMemoryManager); - } - - SchemaInfo* redefinedInfo = fSchemaInfo; - renameRedefinedComponents(redefineElem, redefiningInfo, redefinedInfo); - - // Now we have to preprocess our nicely-renamed schemas. - if (fPreprocessedNodes->containsKey(redefineElem)) { - - fSchemaInfo = redefinedInfo; - preprocessChildren(fSchemaInfo->getRoot()); - } - - fSchemaInfo = redefiningInfo; -} - -void TraverseSchema::traverseRedefine(const DOMElement* const redefineElem) { - - NamespaceScopeManager nsMgr(redefineElem, fSchemaInfo, this); - - SchemaInfo* saveInfo = fSchemaInfo; - SchemaInfo* redefinedInfo = fPreprocessedNodes->get(redefineElem); - - if (redefinedInfo) { - - // Now we have to march through our nicely-renamed schemas. When - // we do these traversals other <redefine>'s may perhaps be - // encountered; we leave recursion to sort this out. - fSchemaInfo = redefinedInfo; - processChildren(fSchemaInfo->getRoot()); - fSchemaInfo = saveInfo; - - // Now traverse our own <redefine> - processChildren(redefineElem); - } -} - - -/** - * Traverse the Choice, Sequence declaration - * - * <choice-sequence - * id = ID - * maxOccurs = (nonNegativeInteger | unbounded) : 1 - * minOccurs = nonNegativeInteger : 1 - * Content: (annotation?, (element | group | choice | sequence | any)*) - * </choice-sequence> - */ -ContentSpecNode* -TraverseSchema::traverseChoiceSequence(const DOMElement* const elem, - const int modelGroupType, - bool& hasChildren) -{ - hasChildren = false; - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Sequence, this, false, fNonXSAttList - ); - - // ----------------------------------------------------------------------- - // Process contents - // ----------------------------------------------------------------------- - DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - Janitor<ContentSpecNode> left(0); - Janitor<ContentSpecNode> right(0); - - bool hadContent = false; - - Janitor<ContentSpecNode> contentSpecNode(0); - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - hasChildren = true; - contentSpecNode.release(); - bool seeParticle = false; - bool wasAny = false; - const XMLCh* childName = child->getLocalName(); - - if (XMLString::equals(childName, SchemaSymbols::fgELT_ELEMENT)) { - - SchemaElementDecl* elemDecl = traverseElementDecl(child); - - if (!elemDecl ) - continue; - - contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode - ( - elemDecl - , fGrammarPoolMemoryManager - )); - seeParticle = true; - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_GROUP)) { - - XercesGroupInfo* grpInfo = traverseGroupDecl(child, false); - - if (!grpInfo) { - continue; - } - - ContentSpecNode* grpContentSpecNode = grpInfo->getContentSpec(); - - if (!grpContentSpecNode) { - continue; - } - - if (grpContentSpecNode->hasAllContent()) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AllContentLimited); - continue; - } - - contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode(*grpContentSpecNode)); - seeParticle = true; - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE)) { - bool hasChild; - contentSpecNode.reset(traverseChoiceSequence(child,ContentSpecNode::Choice, hasChild)); - seeParticle = true; - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE)) { - bool hasChild; - contentSpecNode.reset(traverseChoiceSequence(child,ContentSpecNode::Sequence, hasChild)); - seeParticle = true; - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_ANY)) { - - contentSpecNode.reset(traverseAny(child)); - seeParticle = true; - wasAny = true; - } - else { - reportSchemaError(child, XMLUni::fgValidityDomain, XMLValid::GroupContentRestricted, - childName, - ((ContentSpecNode::NodeTypes) modelGroupType) == ContentSpecNode::Choice?SchemaSymbols::fgELT_CHOICE:SchemaSymbols::fgELT_SEQUENCE); - } - - if (seeParticle) { - checkMinMax(contentSpecNode.get(), child, Not_All_Context); - if (wasAny && contentSpecNode.get()->getMaxOccurs() == 0) { - contentSpecNode.reset(0); - } - } - - if (contentSpecNode.get()) { - hadContent = true; - } - - if (left.get() == 0) { - left.reset(contentSpecNode.release()); - } - else if (right.get() == 0) { - right.reset(contentSpecNode.release()); - } - else { - ContentSpecNode* newNode = - new (fGrammarPoolMemoryManager) ContentSpecNode - ( - (ContentSpecNode::NodeTypes) modelGroupType - , left.get() - , right.get() - , true - , true - , fGrammarPoolMemoryManager - ); - - left.release(); - right.release(); - - left.reset(newNode); - right.reset(contentSpecNode.release()); - } - } - contentSpecNode.release(); - - if (hadContent) - { - ContentSpecNode* newNode = - new (fGrammarPoolMemoryManager) ContentSpecNode - ( - ((ContentSpecNode::NodeTypes) modelGroupType) == ContentSpecNode::Choice - ? ContentSpecNode::ModelGroupChoice : ContentSpecNode::ModelGroupSequence - , left.get() - , right.get() - , true - , true - , fGrammarPoolMemoryManager - ); - - left.release(); - - left.reset(newNode); - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(left.get(), janAnnot.release()); - } - - right.release(); - return left.release(); -} - -/** - * Traverse SimpleType declaration: - * <simpleType - * id = ID - * name = NCName> - * Content: (annotation? , ((list | restriction | union))) - * </simpleType> - * - * traverse <list>|<restriction>|<union> - */ -DatatypeValidator* -TraverseSchema::traverseSimpleTypeDecl(const DOMElement* const childElem, - const bool topLevel, int baseRefContext) -{ - NamespaceScopeManager nsMgr(childElem, fSchemaInfo, this); - - // ------------------------------------------------------------------ - // Process contents - // ------------------------------------------------------------------ - const XMLCh* name = getElementAttValue(childElem,SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - bool nameEmpty = (!name || !*name); - - if (topLevel && nameEmpty) { - reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement, - SchemaSymbols::fgELT_SIMPLETYPE); - return 0; - } - else if(!topLevel && !nameEmpty) { - reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeDisallowedLocal, - SchemaSymbols::fgATT_NAME, childElem->getLocalName()); - return 0; - } - - if (nameEmpty) { // anonymous simpleType - name = genAnonTypeName(fgAnonSNamePrefix); - } - else if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)) ) { - - reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_SIMPLETYPE, name); - return 0; - } - - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(name); - - unsigned int fullTypeNameId = fStringPool->addOrFind(fBuffer.getRawBuffer()); - const XMLCh* fullName = fStringPool->getValueForId(fullTypeNameId); - - //check if we have already traversed the same simpleType decl - DatatypeValidator* dv = fDatatypeRegistry->getDatatypeValidator(fullName); - - if (!dv) { - - // ------------------------------------------------------------------- - // Check attributes - // ------------------------------------------------------------------- - unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_SimpleTypeGlobal - : GeneralAttributeCheck::E_SimpleTypeLocal; - - fAttributeCheck.checkAttributes( - childElem, scope, this, topLevel, fNonXSAttList - ); - - // Circular constraint checking - if (fCurrentTypeNameStack->containsElement(fullTypeNameId)) { - - reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, name); - return 0; - } - - fCurrentTypeNameStack->addElement(fullTypeNameId); - - // Get 'final' values - int finalSet = parseFinalSet(childElem, S_Final); - - // annotation?,(list|restriction|union) - DOMElement* content= checkContent( - childElem, XUtil::getFirstChildElement(childElem), false); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(childElem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - if (content == 0) { - - reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::EmptySimpleTypeContent); - popCurrentTypeNameStack(); - return 0; - } - - const XMLCh* varietyName = content->getLocalName(); - - // Remark: some code will be repeated in list|restriction| union but it - // is cleaner that way - if (XMLString::equals(varietyName, SchemaSymbols::fgELT_LIST)) { //traverse List - if ((baseRefContext & SchemaSymbols::XSD_LIST) != 0) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AtomicItemType); - popCurrentTypeNameStack(); - return 0; - } - - dv = traverseByList(childElem, content, name, fullName, finalSet, &janAnnot); - } - else if (XMLString::equals(varietyName, SchemaSymbols::fgELT_RESTRICTION)) { //traverse Restriction - dv = traverseByRestriction(childElem, content, name, fullName, finalSet, &janAnnot); - } - else if (XMLString::equals(varietyName, SchemaSymbols::fgELT_UNION)) { //traverse union - dv = traverseByUnion(childElem, content, name, fullName, finalSet, baseRefContext, &janAnnot); - } - else { - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::FeatureUnsupported, varietyName); - popCurrentTypeNameStack(); - } - - if (dv) { - if (nameEmpty) - dv->setAnonymous(); - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(dv, janAnnot.release()); - } - } - - return dv; -} - -/** - * Traverse ComplexType Declaration - CR Implementation. - * - * <complexType - * abstract = boolean - * block = #all or (possibly empty) subset of {extension, restriction} - * final = #all or (possibly empty) subset of {extension, restriction} - * id = ID - * mixed = boolean : false - * name = NCName> - * Content: (annotation? , (simpleContent | complexContent | - * ( (group | all | choice | sequence)? , - * ( (attribute | attributeGroup)* , anyAttribute?)))) - * </complexType> - */ -int TraverseSchema::traverseComplexTypeDecl(const DOMElement* const elem, - const bool topLevel, - const XMLCh* const recursingTypeName) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // Get the attributes of the complexType - const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - bool isAnonymous = false; - - if (!name || !*name) { - - if (topLevel) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelNoNameComplexType); - return -1; - } - - if (recursingTypeName) - name = recursingTypeName; - else { - name = genAnonTypeName(fgAnonCNamePrefix); - isAnonymous = true; - } - } - - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)) ) { - - //REVISIT - Should we return or continue and save type with wrong name? - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_COMPLEXTYPE, name); - return -1; - } - - // ------------------------------------------------------------------ - // Check if the type has already been registered - // ------------------------------------------------------------------ - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(name); - - int typeNameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer()); - const XMLCh* fullName = fStringPool->getValueForId(typeNameIndex); - ComplexTypeInfo* typeInfo = 0; - - if (topLevel || recursingTypeName) { - - typeInfo = fComplexTypeRegistry->get(fullName); - - if (typeInfo && !typeInfo->getPreprocessed()) { - return typeNameIndex; - } - } - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - bool preProcessFlag = (typeInfo) ? typeInfo->getPreprocessed() : false; - if (!preProcessFlag) { - fAttributeCheck.checkAttributes( - elem, (topLevel) ? GeneralAttributeCheck::E_ComplexTypeGlobal - : GeneralAttributeCheck::E_ComplexTypeLocal - , this, topLevel, fNonXSAttList - ); - } - - // ----------------------------------------------------------------------- - // Create a new instance - // ----------------------------------------------------------------------- - XMLSize_t previousCircularCheckIndex = fCircularCheckIndex; - unsigned int previousScope = fCurrentScope; - - if (preProcessFlag) { - - fCurrentScope = typeInfo->getScopeDefined(); - typeInfo->setPreprocessed(false); - } - else { - - // ------------------------------------------------------------------ - // Register the type - // ------------------------------------------------------------------ - typeInfo = new (fGrammarPoolMemoryManager) ComplexTypeInfo(fGrammarPoolMemoryManager); - if(isAnonymous) { - typeInfo->setAnonymous(); - } - - fCurrentScope = fScopeCount++; - fComplexTypeRegistry->put((void*) fullName, typeInfo); - typeInfo->setTypeName(fullName); - typeInfo->setScopeDefined(fCurrentScope); - - if (fFullConstraintChecking) { - - XSDLocator* aLocator = new (fGrammarPoolMemoryManager) XSDLocator(); - aLocator->setValues(fStringPool->getValueForId(fStringPool->addOrFind(fSchemaInfo->getCurrentSchemaURL())), - 0, ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - typeInfo->setLocator(aLocator); - } - } - - fCurrentTypeNameStack->addElement(typeNameIndex); - ComplexTypeInfo* saveTypeInfo = fCurrentComplexType; - fCurrentComplexType = typeInfo; - - // ------------------------------------------------------------------ - // First, handle any ANNOTATION declaration and get next child - // ------------------------------------------------------------------ - DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true, !preProcessFlag); - - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - - // ------------------------------------------------------------------ - // Process the content of the complex type declaration - // ------------------------------------------------------------------ - try { - - const XMLCh* mixedVal = getElementAttValue(elem,SchemaSymbols::fgATT_MIXED, DatatypeValidator::Boolean); - bool isMixed = false; - - if ((mixedVal && *mixedVal) - && (XMLString::equals(SchemaSymbols::fgATTVAL_TRUE, mixedVal) - || XMLString::equals(fgValueOne, mixedVal))) { - isMixed = true; - } - - if (child == 0) { - // EMPTY complexType with complexContent - processComplexContent(elem, name, child, typeInfo, 0, isMixed); - } - else { - - const XMLCh* childName = child->getLocalName(); - - if (XMLString::equals(childName, SchemaSymbols::fgELT_SIMPLECONTENT)) { - - // SIMPLE CONTENT element - traverseSimpleContentDecl(name, fullName, child, typeInfo, &janAnnot); - - if (XUtil::getNextSiblingElement(child) != 0) { - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildFollowingSimpleContent); - } - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_COMPLEXCONTENT)) { - - // COMPLEX CONTENT element - traverseComplexContentDecl(name, child, typeInfo, isMixed, &janAnnot); - - if (XUtil::getNextSiblingElement(child) != 0) { - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildFollowingConplexContent); - } - } - else if (fCurrentGroupInfo) { - typeInfo->setPreprocessed(true); - } - else { - // We must have .... - // GROUP, ALL, SEQUENCE or CHOICE, followed by optional attributes - // Note that it's possible that only attributes are specified. - processComplexContent(elem, name, child, typeInfo, 0, isMixed); - } - } - } - catch(const TraverseSchema::ExceptionCodes aCode) { - if (aCode == TraverseSchema::InvalidComplexTypeInfo) - defaultComplexTypeInfo(typeInfo); - else if (aCode == TraverseSchema::RecursingElement) - typeInfo->setPreprocessed(); - } - - // ------------------------------------------------------------------ - // Finish the setup of the typeInfo - // ------------------------------------------------------------------ - if (!preProcessFlag) { - - const XMLCh* abstractAttVal = getElementAttValue(elem, SchemaSymbols::fgATT_ABSTRACT, DatatypeValidator::Boolean); - int blockSet = parseBlockSet(elem, C_Block); - int finalSet = parseFinalSet(elem, EC_Final); - - typeInfo->setBlockSet(blockSet); - typeInfo->setFinalSet(finalSet); - - if ((abstractAttVal && *abstractAttVal) - && (XMLString::equals(abstractAttVal, SchemaSymbols::fgATTVAL_TRUE) - || XMLString::equals(abstractAttVal, fgValueOne))) { - typeInfo->setAbstract(true); - } - else { - typeInfo->setAbstract(false); - } - } - - // Store Annotation - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(typeInfo, janAnnot.release()); - - // ------------------------------------------------------------------ - // Before exiting, restore the scope, mainly for nested anonymous types - // ------------------------------------------------------------------ - popCurrentTypeNameStack(); - fCircularCheckIndex = previousCircularCheckIndex; - fCurrentScope = previousScope; - fCurrentComplexType = saveTypeInfo; - - return typeNameIndex; -} - -/** - * Traverse Group Declaration. - * - * <group - * id = ID - * maxOccurs = string - * minOccurs = nonNegativeInteger - * name = NCName - * ref = QName> - * Content: (annotation? , (all | choice | sequence)?) - * <group/> - * - */ -XercesGroupInfo* -TraverseSchema::traverseGroupDecl(const DOMElement* const elem, - const bool topLevel) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName); - bool nameEmpty = (!name || !*name); - bool refEmpty = (!ref || !*ref); - - if (nameEmpty && topLevel) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement, - SchemaSymbols::fgELT_GROUP); - return 0; - } - - if (nameEmpty && refEmpty) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefGroup); - return 0; - } - - // ------------------------------------------------------------------ - // Check attributes - // ------------------------------------------------------------------ - unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_GroupGlobal - : GeneralAttributeCheck::E_GroupRef; - fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList); - - // ------------------------------------------------------------------ - // Handle "ref=" - // ------------------------------------------------------------------ - if (!topLevel) { - - if (refEmpty) { - return 0; - } - - return processGroupRef(elem, ref); - } - - // name must be a valid NCName - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_GROUP, name); - return 0; - } - - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(name); - - unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer()); - const XMLCh* fullName = fStringPool->getValueForId(nameIndex); - XercesGroupInfo* groupInfo = fGroupRegistry->get(fullName); - - if (groupInfo) { - return groupInfo; - } - - // ------------------------------------------------------------------ - // Check for annotations - // ------------------------------------------------------------------ - DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - // ------------------------------------------------------------------ - // Process contents of global groups - // ------------------------------------------------------------------ - unsigned int saveScope = fCurrentScope; - Janitor<ContentSpecNode> specNode(0); - XercesGroupInfo* saveGroupInfo = fCurrentGroupInfo; - - Janitor<XercesGroupInfo> newGroupInfoJan(new (fGrammarPoolMemoryManager) XercesGroupInfo( - fStringPool->addOrFind(name), fTargetNSURI, fGrammarPoolMemoryManager)); - fCurrentGroupStack->addElement(nameIndex); - XercesGroupInfo* const newGroupInfo = newGroupInfoJan.get(); - fCurrentGroupInfo = newGroupInfo; - - fCurrentScope = fScopeCount++; - fCurrentGroupInfo->setScope(fCurrentScope); - - if (content == 0) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::GroupContentError, name); - } - else { - - if (content->getAttributeNode(SchemaSymbols::fgATT_MINOCCURS) != 0 - || content->getAttributeNode(SchemaSymbols::fgATT_MAXOCCURS) != 0) { - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::MinMaxOnGroupChild); - } - - bool illegalChild = false; - const XMLCh* childName = content->getLocalName(); - bool hasChild; - - - if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE)) { - specNode.reset(traverseChoiceSequence(content, ContentSpecNode::Sequence, hasChild)); - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE)) { - specNode.reset(traverseChoiceSequence(content, ContentSpecNode::Choice, hasChild)); - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_ALL)) { - specNode.reset(traverseAll(content, hasChild)); - } - else { - illegalChild = true; - } - - if (illegalChild || XUtil::getNextSiblingElement(content) != 0) { - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::GroupContentError, name); - } - - // copy local elements to complex type if it exists - if (fCurrentComplexType) - processElements(elem, fCurrentGroupInfo, fCurrentComplexType); - } - - // ------------------------------------------------------------------ - // Set groupInfo and pop group name from stack - // ------------------------------------------------------------------ - XMLSize_t stackSize = fCurrentGroupStack->size(); - - if (stackSize != 0) { - fCurrentGroupStack->removeElementAt(stackSize - 1); - } - - fCurrentGroupInfo->setContentSpec(specNode.release()); - fGroupRegistry->put((void*) fullName, fCurrentGroupInfo); - newGroupInfoJan.release(); - fCurrentGroupInfo = saveGroupInfo; - fCurrentScope = saveScope; - - // Store Annotation - if (!janAnnot.isDataNull()) { - fSchemaGrammar->putAnnotation(newGroupInfo, janAnnot.release()); - } - - if (fFullConstraintChecking) { - - XSDLocator* aLocator = new (fGrammarPoolMemoryManager) XSDLocator(); - - newGroupInfo->setLocator(aLocator); - aLocator->setValues(fStringPool->getValueForId(fStringPool->addOrFind(fSchemaInfo->getCurrentSchemaURL())), - 0, ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - - if (fRedefineComponents && fRedefineComponents->get(SchemaSymbols::fgELT_GROUP, nameIndex)) - { - - fBuffer.set(fullName); - fBuffer.append(SchemaSymbols::fgRedefIdentifier); - unsigned int rdfNameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer()); - - if (fCurrentGroupStack->containsElement(rdfNameIndex)) - { - reportSchemaError(aLocator, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, name); - } - else - { - XercesGroupInfo* baseGroup = fGroupRegistry->get(fBuffer.getRawBuffer()); - if (baseGroup) - { - newGroupInfo->setBaseGroup(baseGroup); - } - else - { - fBuffer.set(name); - fBuffer.append(SchemaSymbols::fgRedefIdentifier); - SchemaInfo* saveInfo = fSchemaInfo; - DOMElement* groupElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Group, - SchemaSymbols::fgELT_GROUP, fBuffer.getRawBuffer(), &fSchemaInfo); - - if (groupElem != 0) { - baseGroup = traverseGroupDecl(groupElem); - newGroupInfo->setBaseGroup(baseGroup); - fSchemaInfo = saveInfo; - } - else - { - reportSchemaError(aLocator, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound, - SchemaSymbols::fgELT_GROUP, fTargetNSURIString, fBuffer.getRawBuffer()); - } - } - } - } - } - - return newGroupInfo; -} - - -/** - * Traverse attributeGroup Declaration. - * - * <attributeGroup - * id = ID - * name = NCName - * ref = QName> - * Content: (annotation? , (attribute|attributeGroup)*, anyAttribute?) - * <attributeGroup/> - * - */ -XercesAttGroupInfo* -TraverseSchema::traverseAttributeGroupDecl(const DOMElement* const elem, - ComplexTypeInfo* const typeInfo, - const bool topLevel) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName); - bool nameEmpty = (!name || !*name) ? true : false; - bool refEmpty = (!ref || !*ref) ? true : false; - - if (nameEmpty && topLevel) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement, - SchemaSymbols::fgELT_ATTRIBUTEGROUP); - return 0; - } - - if (nameEmpty && refEmpty) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttGroup); - return 0; - } - - // ------------------------------------------------------------------ - // Check attributes - // ------------------------------------------------------------------ - unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_AttributeGroupGlobal - : GeneralAttributeCheck::E_AttributeGroupRef; - fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList); - - // ------------------------------------------------------------------ - // Handle "ref=" - // ------------------------------------------------------------------ - XercesAttGroupInfo* attGroupInfo; - Janitor<XercesAttGroupInfo> janAttGroupInfo(0); - if (!topLevel) { - - if (refEmpty) { - return 0; - } - - attGroupInfo = processAttributeGroupRef(elem, ref, typeInfo); - } - else - { - // name must be a valid NCName - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_ATTRIBUTEGROUP, name); - return 0; - } - - // Check for annotations - DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - - // Process contents of global attributeGroups - XercesAttGroupInfo* saveAttGroupInfo = fCurrentAttGroupInfo; - janAttGroupInfo.reset(new (fGrammarPoolMemoryManager) XercesAttGroupInfo( - fStringPool->addOrFind(name), fTargetNSURI, fGrammarPoolMemoryManager)); - - fDeclStack->addElement(elem); - fCurrentAttGroupInfo = janAttGroupInfo.get(); - - for (; content !=0; content = XUtil::getNextSiblingElement(content)) { - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ATTRIBUTE)) { - traverseAttributeDecl(content, typeInfo); - } - else if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ATTRIBUTEGROUP)) { - traverseAttributeGroupDecl(content, typeInfo); - } - else { - break; - } - } - - if (content != 0) { - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ANYATTRIBUTE)) { - - SchemaAttDef* anyAtt = traverseAnyAttribute(content); - - if (anyAtt) { - fCurrentAttGroupInfo->addAnyAttDef(anyAtt); - } - - if (XUtil::getNextSiblingElement(content) != 0) { - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AttGroupContentError, name); - } - } - else { - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AttGroupContentError, name); - } - } - - // Pop declaration - fDeclStack->removeElementAt(fDeclStack->size() - 1); - - fAttGroupRegistry->put((void*) fStringPool->getValueForId(fStringPool->addOrFind(name)), janAttGroupInfo.get()); - // Restore old attGroupInfo - attGroupInfo = janAttGroupInfo.release(); - fCurrentAttGroupInfo = saveAttGroupInfo; - - // Check Attribute Derivation Restriction OK - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(name); - - unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer()); - - if (fRedefineComponents && fRedefineComponents->get(SchemaSymbols::fgELT_ATTRIBUTEGROUP, nameIndex)) { - - fBuffer.set(name); - fBuffer.append(SchemaSymbols::fgRedefIdentifier); - XercesAttGroupInfo* baseAttGroupInfo = fAttGroupRegistry->get(fBuffer.getRawBuffer()); - - if (baseAttGroupInfo) - checkAttDerivationOK(elem, baseAttGroupInfo, attGroupInfo); - } - - // Store annotation - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(attGroupInfo, janAnnot.release()); - } - - // calculate complete wildcard if necessary - if (attGroupInfo) - { - XMLSize_t anyAttCount = attGroupInfo->anyAttributeCount(); - if (anyAttCount && !attGroupInfo->getCompleteWildCard()) - { - SchemaAttDef* attGroupWildCard = new (fGrammarPoolMemoryManager) - SchemaAttDef(attGroupInfo->anyAttributeAt(0)); - - for (XMLSize_t k= 1; k < anyAttCount; k++) - attWildCardIntersection(attGroupWildCard, attGroupInfo->anyAttributeAt(k)); - - attGroupInfo->setCompleteWildCard(attGroupWildCard); - } - } - - return attGroupInfo; -} - - -inline XercesAttGroupInfo* -TraverseSchema::traverseAttributeGroupDeclNS(const DOMElement* const elem, - const XMLCh* const uriStr, - const XMLCh* const name) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ------------------------------------------------------------------ - // Get grammar information - // ------------------------------------------------------------------ - Grammar* aGrammar = fGrammarResolver->getGrammar(uriStr); - - if (!aGrammar || aGrammar->getGrammarType() != Grammar::SchemaGrammarType) { - - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr); - return 0; - } - - XercesAttGroupInfo* attGroupInfo = ((SchemaGrammar*)aGrammar)->getAttGroupInfoRegistry()->get(name); - - return attGroupInfo; -} - -/** - * Traverse Any declaration - * - * <any - * id = ID - * maxOccurs = (nonNegativeInteger | unbounded) : 1 - * minOccurs = nonNegativeInteger : 1 - * namespace = ((##any | ##other) | List of (anyURI | - * (##targetNamespace | ##local)) ) : ##any - * processContents = (lax | skip | strict) : strict - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?) - * </any> - */ -ContentSpecNode* -TraverseSchema::traverseAny(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Any, this, false, fNonXSAttList - ); - - // ------------------------------------------------------------------ - // First, handle any ANNOTATION declaration - // ------------------------------------------------------------------ - if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - - // ------------------------------------------------------------------ - // Get attributes - // ------------------------------------------------------------------ - const XMLCh* const processContents = getElementAttValue(elem, SchemaSymbols::fgATT_PROCESSCONTENTS); - const XMLCh* const nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE); - - // ------------------------------------------------------------------ - // Set default node type based on 'processContents' value - // ------------------------------------------------------------------ - ContentSpecNode::NodeTypes anyType = ContentSpecNode::Any; - ContentSpecNode::NodeTypes anyLocalType = ContentSpecNode::Any_NS; - ContentSpecNode::NodeTypes anyOtherType = ContentSpecNode::Any_Other; - - if ((processContents && *processContents) - && !XMLString::equals(processContents, SchemaSymbols::fgATTVAL_STRICT)) { - - if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_LAX)) { - - anyType = ContentSpecNode::Any_Lax; - anyOtherType = ContentSpecNode::Any_Other_Lax; - anyLocalType = ContentSpecNode::Any_NS_Lax; - } - else if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_SKIP)) { - - anyType = ContentSpecNode::Any_Skip; - anyOtherType = ContentSpecNode::Any_Other_Skip; - anyLocalType = ContentSpecNode::Any_NS_Skip; - } - } - - // ------------------------------------------------------------------ - // Process 'namespace' attribute - // ------------------------------------------------------------------ - ContentSpecNode* retSpecNode = 0; - - if ((!nameSpace || !*nameSpace) - || XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY)) { - retSpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - new (fGrammarPoolMemoryManager) QName - ( - XMLUni::fgZeroLenString - , XMLUni::fgZeroLenString - , fEmptyNamespaceURI - , fGrammarPoolMemoryManager - ) - , false - , fGrammarPoolMemoryManager - ); - retSpecNode->setType(anyType); - } - else if (XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDOTHER)) { - retSpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - new (fGrammarPoolMemoryManager) QName - ( - XMLUni::fgZeroLenString - , XMLUni::fgZeroLenString - , fTargetNSURI, fGrammarPoolMemoryManager - ) - , false - , fGrammarPoolMemoryManager - ); - retSpecNode->setType(anyOtherType); - } - else { - - XMLStringTokenizer nameSpaceTokens(nameSpace, fMemoryManager); - ValueVectorOf<unsigned int> uriList(8, fGrammarPoolMemoryManager); - Janitor<ContentSpecNode> firstNode(0); - Janitor<ContentSpecNode> secondNode(0); - DatatypeValidator* anyURIDV = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYURI); - - while (nameSpaceTokens.hasMoreTokens()) { - - const XMLCh* tokenElem = nameSpaceTokens.nextToken(); - int uriIndex = fEmptyNamespaceURI; - - if (!XMLString::equals(tokenElem,SchemaSymbols::fgATTVAL_TWOPOUNDLOCAL)) { // not ##local - - if (XMLString::equals(tokenElem,SchemaSymbols::fgATTVAL_TWOPOUNDTRAGETNAMESPACE)) { - uriIndex = fTargetNSURI; - } - else { - try { - anyURIDV->validate(tokenElem - , fSchemaInfo->getValidationContext() - , fMemoryManager); - } - catch(const XMLException& excep) { - reportSchemaError(elem, excep); - } - uriIndex = fURIStringPool->addOrFind(tokenElem); - } - } - - if (uriList.containsElement(uriIndex)) { - continue; - } - - uriList.addElement(uriIndex); - - firstNode.release(); - firstNode.reset( new (fGrammarPoolMemoryManager) ContentSpecNode - ( - new (fGrammarPoolMemoryManager) QName - ( - XMLUni::fgZeroLenString - , XMLUni::fgZeroLenString - , uriIndex, fGrammarPoolMemoryManager - ) - , false - , fGrammarPoolMemoryManager - )); - firstNode.get()->setType(anyLocalType); - - if (secondNode.get() == 0) { - secondNode.reset(firstNode.release()); - } - else { - ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - ContentSpecNode::Any_NS_Choice - , secondNode.get() - , firstNode.get() - , true - , true - , fGrammarPoolMemoryManager - ); - secondNode.release(); - secondNode.reset(newNode); - firstNode.release(); - } - } - firstNode.release(); - retSpecNode = secondNode.release(); - } - - // Store annotation - if (retSpecNode && !janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(retSpecNode, janAnnot.release()); - - return retSpecNode; -} - - -/** - * Traverse all - * - * <all - * id = ID - * maxOccurs = 1 : 1 - * minOccurs = (0 | 1) : 1 - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?, element*) - * </all> - */ -ContentSpecNode* -TraverseSchema::traverseAll(const DOMElement* const elem, bool& hasChildren) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - hasChildren = false; - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_All, this, false, fNonXSAttList - ); - - // ----------------------------------------------------------------------- - // Process contents - // ----------------------------------------------------------------------- - DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - - if (child == 0) { - return 0; - } - - Janitor<ContentSpecNode> left(0); - Janitor<ContentSpecNode> right(0); - Janitor<ContentSpecNode> contentSpecNode(0); - bool hadContent = false; - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - hasChildren = true; - contentSpecNode.release(); - const XMLCh* childName = child->getLocalName(); - - if (XMLString::equals(childName, SchemaSymbols::fgELT_ELEMENT)) { - - SchemaElementDecl* elemDecl = traverseElementDecl(child); - - if (!elemDecl) - continue; - - contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode - ( - elemDecl - , fGrammarPoolMemoryManager - )); - checkMinMax(contentSpecNode.get(), child, All_Element); - } - else { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AllContentError, childName); - continue; - } - - hadContent = true; - - if (!left.get()) { - left.reset(contentSpecNode.release()); - } - else if (!right.get()) { - right.reset(contentSpecNode.release()); - } - else { - ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - ContentSpecNode::All - , left.get() - , right.get() - , true - , true - , fGrammarPoolMemoryManager - ); - left.release(); - left.reset(newNode); - right.release(); - right.reset(contentSpecNode.release()); - } - } - contentSpecNode.release(); - - if (hadContent) { - ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - ContentSpecNode::All - , left.get() - , right.get() - , true - , true - , fGrammarPoolMemoryManager - ); - - left.release(); - left.reset(newNode); - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(left.get(), janAnnot.release()); - } - right.release(); - return left.release(); -} - -/** - * Traverses Schema attribute declaration. - * - * <attribute - * fixed = string - * default = string - * form = qualified | unqualified - * id = ID - * name = NCName - * ref = QName - * type = QName - * use = optional | prohibited | required : optional - > - * Content: (annotation? , simpleType?) - * <attribute/> - * - * @param elem: the declaration of the attribute under consideration - * - * @param typeInfo: Contains the complex type info of the element to which - * the attribute declaration is attached. - * - */ -void TraverseSchema::traverseAttributeDecl(const DOMElement* const elem, - ComplexTypeInfo* const typeInfo, - const bool topLevel) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName); - bool nameEmpty = (!name || !*name); - bool refEmpty = (!ref || !*ref); - - if (nameEmpty && refEmpty) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttribute); - return; - } - - if (topLevel && nameEmpty) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelNoNameAttribute); - return; - } - - // ------------------------------------------------------------------ - // Check attributes - // ------------------------------------------------------------------ - unsigned short scope = (topLevel) - ? GeneralAttributeCheck::E_AttributeGlobal - : (refEmpty) ? GeneralAttributeCheck::E_AttributeLocal - : GeneralAttributeCheck::E_AttributeRef; - - fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList); - - const XMLCh* defaultVal = getElementAttValue(elem, SchemaSymbols::fgATT_DEFAULT); - const XMLCh* fixedVal = getElementAttValue(elem, SchemaSymbols::fgATT_FIXED); - const XMLCh* useVal = getElementAttValue(elem, SchemaSymbols::fgATT_USE); - const XMLCh* attForm = getElementAttValue(elem, SchemaSymbols::fgATT_FORM); - const XMLCh* dvType = getElementAttValue(elem, SchemaSymbols::fgATT_TYPE, DatatypeValidator::QName); - DOMElement* simpleType = checkContent(elem, XUtil::getFirstChildElement(elem), true); - Janitor<XSAnnotation> janAnnot(fAnnotation); - bool badContent = false; - - while (simpleType != 0) { - - const XMLCh* contentName = simpleType->getLocalName(); - - if (XMLString::equals(SchemaSymbols::fgELT_SIMPLETYPE, contentName)) { - - if (XUtil::getNextSiblingElement(simpleType) != 0) { - badContent = true; - } - break; - } - - badContent = true; - simpleType = XUtil::getNextSiblingElement(simpleType); - } - - if (badContent) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttributeContent, - (name) ? name : ref); - } - - if (defaultVal) { - - if (fixedVal) { - - fixedVal = 0; - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeDefaultFixedValue, - (name) ? name : ref); - } - - if ((useVal && *useVal) - && !XMLString::equals(useVal, SchemaSymbols::fgATTVAL_OPTIONAL)) { - - useVal = 0; - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NotOptionalDefaultAttValue, - (name) ? name : ref); - } - } - - // processing ref - if (!refEmpty && !topLevel) { - - // Check ref representation OK - 3.2.3::3.2 - if (attForm || dvType || (simpleType != 0)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeRefContentError, - (name) ? name : ref); - } - - processAttributeDeclRef(elem, typeInfo, ref, useVal, defaultVal, fixedVal); - return; - } - - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - janAnnot.reset(fAnnotation); - } - - // processing 'name' - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)) - || XMLString::equals(name, XMLUni::fgXMLNSString)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, SchemaSymbols::fgELT_ATTRIBUTE, name); - return; - } - - // Check for duplicate declaration - const XMLCh* qualified = SchemaSymbols::fgATTVAL_QUALIFIED; - int uriIndex = fEmptyNamespaceURI; - - if ((fTargetNSURIString && *fTargetNSURIString) - && (topLevel || XMLString::equals(attForm, qualified) - || ((fSchemaInfo->getElemAttrDefaultQualified() & Attr_Def_Qualified) - && (!attForm || !*attForm)))) { - uriIndex = fTargetNSURI; - } - - // make sure that attribute namespace is not xsi uri - if (XMLString::equals(fTargetNSURIString, SchemaSymbols::fgURI_XSI)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttTNS, name); - return; - } - - if (typeInfo && typeInfo->getAttDef(name, uriIndex) != 0) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, name); - return; - } - else if (fCurrentAttGroupInfo && fCurrentAttGroupInfo->containsAttribute(name, uriIndex)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, name); - return; - } - - DatatypeValidator* dv = 0; - XMLAttDef::AttTypes attType = XMLAttDef::Simple; - SchemaInfo* saveInfo = fSchemaInfo; - - if (simpleType != 0) { - - if (dvType && *dvType) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeWithTypeAndSimpleType, name); - } - - dv = traverseSimpleTypeDecl(simpleType, false); - } - else if (!dvType || !*dvType) { - dv = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYSIMPLETYPE); - } - else { - - checkEnumerationRequiredNotation(elem, name, dvType); - - const XMLCh* localPart = getLocalPart(dvType); - const XMLCh* prefix = getPrefix(dvType); - const XMLCh* typeURI = resolvePrefixToURI(elem, prefix); - DatatypeValidator* dvBack = 0; - - if (XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - dv = fDatatypeRegistry->getDatatypeValidator(localPart); - dvBack = dv; - } - else { //isn't of the schema for schemas namespace... - - dv = getAttrDatatypeValidatorNS(elem, localPart, typeURI); - dvBack = dv; - - while(dv != 0 && !XMLString::equals(dv->getTypeUri(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - dv = dv->getBaseValidator(); - } - - if(dv) - localPart = dv->getTypeLocalName(); - } - - if(dv) { - if (XMLString::equals(localPart,XMLUni::fgIDString)) { - attType = XMLAttDef::ID; - } - else if (XMLString::equals(localPart,XMLUni::fgIDRefString)) { - attType = XMLAttDef::IDRef; - } - else if (XMLString::equals(localPart,XMLUni::fgIDRefsString)) { - attType = XMLAttDef::IDRefs; - } - else if (XMLString::equals(localPart,XMLUni::fgEntityString)) { - attType = XMLAttDef::Entity; - } - else if (XMLString::equals(localPart,XMLUni::fgEntitiesString)) { - attType = XMLAttDef::Entities; - } - else if (XMLString::equals(localPart,XMLUni::fgNmTokenString)) { - attType = XMLAttDef::NmToken; - } - else if (XMLString::equals(localPart,XMLUni::fgNmTokensString)) { - attType = XMLAttDef::NmTokens; - } - else if (XMLString::equals(localPart,XMLUni::fgNotationString)) { - attType = XMLAttDef::Notation; - } - else { - attType = XMLAttDef::Simple; - } - } - else - attType = XMLAttDef::Simple; - - dv = dvBack; - - if (!dv) { - reportSchemaError - ( - elem - , XMLUni::fgXMLErrDomain - , XMLErrs::AttributeSimpleTypeNotFound - , typeURI - , localPart - , name - ); - } - } - - // restore schema information, if necessary - fSchemaInfo = saveInfo; - - bool required = false; - bool prohibited = false; - - if (useVal && *useVal) { - - if (XMLString::equals(useVal, SchemaSymbols::fgATTVAL_REQUIRED)) { - required = true; - } - else if (XMLString::equals(useVal, SchemaSymbols::fgATTVAL_PROHIBITED)) { - prohibited = true; - } - } - - // validate fixed/default values - const XMLCh* valueToCheck = defaultVal ? defaultVal : fixedVal; - bool ofTypeID = (dv && dv->getType() == DatatypeValidator::ID); - - if (attType == XMLAttDef::Simple && dv && valueToCheck) { - - short wsFacet = dv->getWSFacet(); - if((wsFacet == DatatypeValidator::REPLACE && !XMLString::isWSReplaced(valueToCheck)) || - (wsFacet == DatatypeValidator::COLLAPSE && !XMLString::isWSCollapsed(valueToCheck))) - { - XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager); - ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager); - if(wsFacet == DatatypeValidator::REPLACE) - XMLString::replaceWS(normalizedValue, fMemoryManager); - else if(wsFacet == DatatypeValidator::COLLAPSE) - XMLString::collapseWS(normalizedValue, fMemoryManager); - valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue)); - } - try { - dv->validate(valueToCheck - , fSchemaInfo->getValidationContext() - , fMemoryManager); - } - catch (const XMLException& excep) { - reportSchemaError(elem, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::DatatypeValidationFailure, valueToCheck); - } - } - else if((attType == XMLAttDef::NmTokens || attType==XMLAttDef::IDRefs || attType==XMLAttDef::Entities) && - valueToCheck && !XMLString::isWSCollapsed(valueToCheck)) - { - XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager); - ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager); - XMLString::collapseWS(normalizedValue, fMemoryManager); - valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue)); - } - - if (ofTypeID && valueToCheck) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect3, name); - } - - // check for multiple attributes with type derived from ID - if (!topLevel && ofTypeID) { - - if (fCurrentAttGroupInfo) { - - if (fCurrentAttGroupInfo->containsTypeWithId()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttGrpPropCorrect3, name); - return; - } - - fCurrentAttGroupInfo->setTypeWithId(true); - } - else { - - if (typeInfo->containsAttWithTypeId()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect5, name); - return; - } - - typeInfo->setAttWithTypeId(true); - } - } - - // create SchemaAttDef - SchemaAttDef* attDef = new (fGrammarPoolMemoryManager) SchemaAttDef - ( - XMLUni::fgZeroLenString - , name - , uriIndex - , attType - , XMLAttDef::Implied - , fGrammarPoolMemoryManager - ); - - attDef->setDatatypeValidator(dv); - - if (prohibited) { - attDef->setDefaultType(XMLAttDef::Prohibited); - } - else if (required) { - - if (fixedVal) { - attDef->setDefaultType(XMLAttDef::Required_And_Fixed); - } - else { - attDef->setDefaultType(XMLAttDef::Required); - } - } - else { - - if (fixedVal) { - attDef->setDefaultType(XMLAttDef::Fixed); - } - else if (defaultVal) { - attDef->setDefaultType(XMLAttDef::Default); - } - } - - if (valueToCheck) { - attDef->setValue(valueToCheck); - } - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(attDef, janAnnot.release()); - - if (topLevel) - { - fAttributeDeclRegistry->put((void*) fStringPool->getValueForId(fStringPool->addOrFind(name)), attDef); - attDef->setPSVIScope(PSVIDefs::SCP_GLOBAL); - } - else - { - if (typeInfo) - { - typeInfo->addAttDef(attDef); - if (!fCurrentAttGroupInfo) - attDef->setPSVIScope(PSVIDefs::SCP_LOCAL); - } - - if (fCurrentAttGroupInfo) { - fCurrentAttGroupInfo->addAttDef(attDef, (typeInfo != 0)); - } - } -} - - -/** - * Traverses Schema element declaration. - * - * <element - * abstract = boolean : false - * block = (#all | List of (substitution | extension | restriction - * | list | union)) - * default = string - * final = (#all | List of (extension | restriction)) - * fixed = string - * form = (qualified | unqualified) - * id = ID - * maxOccurs = (nonNegativeInteger | unbounded) : 1 - * minOccurs = nonNegativeInteger : 1 - * name = NCName - * nillable = boolean : false - * ref = QName - * substitutionGroup = QName - * type = QName - * Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*)) - * </element> - * - * @param elem: the declaration of the element under consideration - */ -SchemaElementDecl* -TraverseSchema::traverseElementDecl(const DOMElement* const elem, - const bool topLevel) -{ - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // if local element and ref attribute exists - if (!topLevel) - { - const XMLCh* refName = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName); - if (refName) - return processElementDeclRef(elem, refName); - } - - // check for empty name - const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - if (!name || !*name) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefElement); - return 0; - } - - // make sure that name is a valid NCName - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, - XMLErrs::InvalidDeclarationName, SchemaSymbols::fgELT_ELEMENT, name); - return 0; - } - - // if element already exists, just return --- revisit, it should not happen - if (topLevel) - { - SchemaElementDecl* retDecl = (SchemaElementDecl*) fSchemaGrammar->getElemDecl(fTargetNSURI, name, 0, Grammar::TOP_LEVEL_SCOPE); - if (retDecl) - return retDecl; - } - - // Check attributes - unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_ElementGlobal - : GeneralAttributeCheck::E_ElementLocal; - - fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList); - - // check annotation - const DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true); - // Put annotations on all elements for the situation where there is a group of - // elements and not all have annotations. - //if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - if (!fAnnotation && fScanner->getGenerateSyntheticAnnotations()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - - // Create element decl - bool isDuplicate = false; - const XMLCh* valueConstraint = 0; - SchemaElementDecl* elemDecl = - createSchemaElementDecl(elem, name, isDuplicate, valueConstraint, topLevel); - - if (!isDuplicate) { - - fSchemaGrammar->putElemDecl(elemDecl); - - if (valueConstraint) - elemDecl->setDefaultValue(valueConstraint); - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(elemDecl, janAnnot.release()); - - if (fCurrentComplexType && - elemDecl->getEnclosingScope() == fCurrentComplexType->getScopeDefined()) { - fCurrentComplexType->addElement(elemDecl); - elemDecl->setPSVIScope(PSVIDefs::SCP_LOCAL); - } - - if (fCurrentGroupInfo && - elemDecl->getEnclosingScope() == fCurrentGroupInfo->getScope()) { - fCurrentGroupInfo->addElement(elemDecl); - elemDecl->setPSVIScope(PSVIDefs::SCP_ABSENT); - } - } - else { - if (fAnnotation) { - XSAnnotation* xsAnnot = fSchemaGrammar->getAnnotation(elemDecl); - if (!xsAnnot) { - fSchemaGrammar->putAnnotation(elemDecl, janAnnot.release()); - } - else { - xsAnnot->setNext(janAnnot.release()); - } - } - } - - // Process children - bool anonymousType = false; - ComplexTypeInfo* typeInfo = 0; - DatatypeValidator* validator = 0; - - if (content != 0) - { - const XMLCh* contentName = content->getLocalName(); - - if (XMLString::equals(contentName, SchemaSymbols::fgELT_COMPLEXTYPE)) - { - const XMLCh* temp = content->getAttribute(SchemaSymbols::fgATT_NAME); - - if (temp && *temp) - { - // REVISIT - we are bypassing the complex type declaration. - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AnonComplexTypeWithName, name); - } - else - { - typeInfo = checkForComplexTypeInfo(content); - - if (typeInfo) - { - validator = typeInfo->getDatatypeValidator(); - - if (!isDuplicate) { - - //Recursing element - if (typeInfo->getPreprocessed()) { - - const XMLCh* typeInfoName = typeInfo->getTypeName(); - fSchemaInfo->addRecursingType(content, typeInfoName + XMLString::indexOf(typeInfoName, chComma) + 1); - } - } - } - } - - anonymousType = true; - content = XUtil::getNextSiblingElement(content); - } - else if (XMLString::equals(contentName, SchemaSymbols::fgELT_SIMPLETYPE)) - { - const XMLCh* temp = content->getAttribute(SchemaSymbols::fgATT_NAME); - if (temp && *temp) - // REVISIT - we are bypassing the simple type declaration. - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AnonSimpleTypeWithName, name); - else - validator = checkForSimpleTypeValidator(content); - - anonymousType = true; - content = XUtil::getNextSiblingElement(content); - } - - // Check for identity constraints - if (content != 0) - { - content = checkIdentityConstraintContent(content); - if (content != 0) - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::InvalidElementContent); - } - } - - // Handle 'type' attribute - const XMLCh* typeStr = getElementAttValue(elem, SchemaSymbols::fgATT_TYPE, DatatypeValidator::QName); - if (typeStr) - { - if (anonymousType) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::ElementWithTypeAndAnonType, name); - } - else if (*typeStr) - { - const XMLCh* typeLocalPart = getLocalPart(typeStr); - const XMLCh* typePrefix = getPrefix(typeStr); - const XMLCh* typeURI = resolvePrefixToURI(elem, typePrefix); - - if (!XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - || !XMLString::equals(typeLocalPart, SchemaSymbols::fgATTVAL_ANYTYPE)) - { - checkEnumerationRequiredNotation(elem, name, typeStr); - - bool noErrorFound = true; - const XMLCh* anotherSchemaURI = checkTypeFromAnotherSchema(elem, typeStr); - - // get complex type info - typeInfo = getElementComplexTypeInfo(elem, typeStr, anotherSchemaURI); - - // get simple type validtor - if not a complex type - if (typeInfo) - validator = typeInfo->getDatatypeValidator(); - else - validator = getElementTypeValidator(elem, typeStr, noErrorFound, anotherSchemaURI); - } - } - } - - // check for duplicate elements with different types. - if (isDuplicate) - { - DatatypeValidator* eltDV = elemDecl->getDatatypeValidator(); - ComplexTypeInfo* eltTypeInfo = elemDecl->getComplexTypeInfo(); - - if ( (eltTypeInfo != typeInfo) || (eltDV != validator)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateElementDeclaration, name); - } - } - // Set element declararion type information - else - { - elemDecl->setDatatypeValidator(validator); - elemDecl->setComplexTypeInfo(typeInfo); - - if (validator) - elemDecl->setModelType(SchemaElementDecl::Simple); - else if (typeInfo) - elemDecl->setModelType((SchemaElementDecl::ModelTypes)typeInfo->getContentType()); - - if (topLevel) { - - // Handle the substitutionGroup - const XMLCh* subsGroupName = getElementAttValue(elem, SchemaSymbols::fgATT_SUBSTITUTIONGROUP, DatatypeValidator::QName); - if (subsGroupName && *subsGroupName) - processSubstitutionGroup(elem, elemDecl, typeInfo, validator, subsGroupName); - } - - // process identity constraints - DOMElement* ic = XUtil::getFirstChildElementNS( - elem, fgIdentityConstraints, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, 3); - - if (ic) - processElemDeclIC(ic, elemDecl); - } - - if (!typeInfo && !validator) - { - if (!isDuplicate) - { - elemDecl->setModelType(SchemaElementDecl::Any); - elemDecl->setAttWildCard( - new (fGrammarPoolMemoryManager) SchemaAttDef( - XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, - fEmptyNamespaceURI, XMLAttDef::Any_Any, - XMLAttDef::ProcessContents_Lax, fGrammarPoolMemoryManager - ) - ); - } - } - else if (valueConstraint) - { - if (!checkElemDeclValueConstraint(elem, elemDecl, valueConstraint, typeInfo, validator) - && !isDuplicate) - { - int miscFlags = elemDecl->getMiscFlags(); - miscFlags &= ~ SchemaSymbols::XSD_FIXED; - elemDecl->setDefaultValue(0); - elemDecl->setMiscFlags(miscFlags); - } - } - - return elemDecl; -} - -/** - * Traverses Schema notation declaration. - * - * <notation - * id = ID - * name = NCName - * public = token - * system = anyURI - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?) - * </notation> - * - * @param elem: the declaration of the element under consideration - */ -const XMLCh* TraverseSchema::traverseNotationDecl(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Notation, this, true, fNonXSAttList - ); - - // ----------------------------------------------------------------------- - // Process notation attributes/elements - // ----------------------------------------------------------------------- - const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - bool nameEmpty = (!name || !*name) ? true : false; - - if (nameEmpty) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement, - SchemaSymbols::fgELT_NOTATION); - return 0; - } - - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_NOTATION, name); - return 0; - } - - if (fNotationRegistry->containsKey(name, fTargetNSURI)) { - return name; - } - - if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - - const XMLCh* publicId = getElementAttValue(elem, SchemaSymbols::fgATT_PUBLIC); - const XMLCh* systemId = getElementAttValue(elem, SchemaSymbols::fgATT_SYSTEM, DatatypeValidator::AnyURI); - - fNotationRegistry->put((void*) fStringPool->getValueForId(fStringPool->addOrFind(name)), - fTargetNSURI, 0); - - // for PSVI we need to store the notational decl - XMLNotationDecl* decl = new (fGrammarPoolMemoryManager) XMLNotationDecl - ( - name, - publicId, - systemId, - 0, - fGrammarPoolMemoryManager - ); - decl->setNameSpaceId(fTargetNSURI); - fSchemaGrammar->putNotationDecl(decl); - - if (fAnnotation) - fSchemaGrammar->putAnnotation(decl, fAnnotation); - else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - fSchemaGrammar->putAnnotation(decl, fAnnotation); - } - return name; -} - -const XMLCh* TraverseSchema::traverseNotationDecl(const DOMElement* const elem, - const XMLCh* const name, - const XMLCh* const uriStr) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - SchemaInfo* saveInfo = fSchemaInfo; - - if (fTargetNSURI != (int) uriId) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, uriStr); - return 0; - } - - Grammar* grammar = fGrammarResolver->getGrammar(uriStr); - - if (grammar == 0 || grammar->getGrammarType() != Grammar::SchemaGrammarType) { - - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr); - return 0; - } - - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(uriId); - - if (!impInfo || impInfo->getProcessed()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, uriStr, name); - return 0; - } - - fSchemaInfo = impInfo; - fTargetNSURI = fSchemaInfo->getTargetNSURI(); - } - - DOMElement* notationElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Notation, - SchemaSymbols::fgELT_NOTATION, name, &fSchemaInfo); - - if (notationElem == 0) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Notation_DeclNotFound, uriStr, name); - return 0; - } - - const XMLCh* notationName = traverseNotationDecl(notationElem); - - fSchemaInfo = saveInfo; - fTargetNSURI = fSchemaInfo->getTargetNSURI(); - - return notationName; -} - -/** - * Traverses Schema list simple type declaration. - * - * <list - * id = ID - * itemType = QName - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?, simpleType?) - * </list> - * - */ -DatatypeValidator* -TraverseSchema::traverseByList(const DOMElement* const rootElem, - const DOMElement* const contentElem, - const XMLCh* const typeName, - const XMLCh* const qualifiedName, - const int finalSet, - Janitor<XSAnnotation>* const janAnnot) { - - NamespaceScopeManager nsMgr(contentElem, fSchemaInfo, this); - - DatatypeValidator* baseValidator = 0; - const XMLCh* baseTypeName = getElementAttValue(contentElem, SchemaSymbols::fgATT_ITEMTYPE, DatatypeValidator::QName); - - fAttributeCheck.checkAttributes( - contentElem, GeneralAttributeCheck::E_List, this, false, fNonXSAttList - ); - - const DOMElement* tempEl = XUtil::getNextSiblingElement(contentElem); - if (tempEl != 0) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::SimpleTypeContentError, tempEl->getLocalName()); - } - - DOMElement* content = 0; - - if (!baseTypeName || !*baseTypeName) { // must 'see' <simpleType> - - content = checkContent(rootElem, XUtil::getFirstChildElement(contentElem), false); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentElem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - if (!content) { - - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::ExpectedSimpleTypeInList, typeName); - popCurrentTypeNameStack(); - return 0; - } - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_SIMPLETYPE)) { - baseValidator = checkForSimpleTypeValidator(content, SchemaSymbols::XSD_LIST); - } - else { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::ListUnionRestrictionError, typeName); - popCurrentTypeNameStack(); - return 0; - } - - content = XUtil::getNextSiblingElement(content); - } - else { // base was provided - get proper validator - - baseValidator = findDTValidator(contentElem, typeName, baseTypeName, SchemaSymbols::XSD_LIST); - content = checkContent(rootElem, XUtil::getFirstChildElement(contentElem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentElem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - } - - DatatypeValidator* newDV = 0; - - if (baseValidator) { - - if (!baseValidator->isAtomic()) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::AtomicItemType, baseTypeName); - } - else { - - // 'content' should be empty - // If an annotation was encountered we have already traversed it in - // checkContent in the case of a base provided (only allowed child is - // an annotation). - if (content != 0) { // report an error and continue - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::SimpleTypeDerivationByListError, typeName); - } - - // create & register validator for "generated" type - try { - newDV = fDatatypeRegistry->createDatatypeValidator( - qualifiedName, baseValidator, 0, 0, true, finalSet, true, fGrammarPoolMemoryManager); - } - catch (const XMLException& excep) { - reportSchemaError(contentElem, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, - XMLErrs::DatatypeValidatorCreationError, typeName); - } - } - } - - popCurrentTypeNameStack(); - return newDV; -} - -/** - * Traverses Schema restriction simple type declaration. - * - * <restriction - * base = QName - * id = ID - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?, (simpleType?, - * (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)) - * </restriction> - * - */ -DatatypeValidator* -TraverseSchema::traverseByRestriction(const DOMElement* const rootElem, - const DOMElement* const contentElem, - const XMLCh* const typeName, - const XMLCh* const qualifiedName, - const int finalSet, - Janitor<XSAnnotation>* const janAnnot) { - - NamespaceScopeManager nsMgr(contentElem, fSchemaInfo, this); - - DatatypeValidator* baseValidator = 0; - DatatypeValidator* newDV = 0; - const XMLCh* baseTypeName = getElementAttValue(contentElem, SchemaSymbols::fgATT_BASE, DatatypeValidator::QName); - - fAttributeCheck.checkAttributes( - contentElem, GeneralAttributeCheck::E_Restriction, this, false, fNonXSAttList - ); - - const DOMElement* tempEl = XUtil::getNextSiblingElement(contentElem); - if (tempEl != 0) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::SimpleTypeContentError, tempEl->getLocalName()); - } - - DOMElement* content = 0; - - if (!baseTypeName || !*baseTypeName) { // must 'see' <simpleType> - - content = checkContent(rootElem, XUtil::getFirstChildElement(contentElem), false); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentElem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - if (content == 0) { - - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::ExpectedSimpleTypeInRestriction); - popCurrentTypeNameStack(); - return 0; - } - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_SIMPLETYPE)) { - baseValidator = checkForSimpleTypeValidator(content); - } - else { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::ListUnionRestrictionError, typeName); - popCurrentTypeNameStack(); - return 0; - } - - // Check for facets - content = XUtil::getNextSiblingElement(content); - } - else { // base was provided - get proper validator - - baseValidator = findDTValidator(contentElem, typeName, baseTypeName, SchemaSymbols::XSD_RESTRICTION); - content = checkContent(rootElem, XUtil::getFirstChildElement(contentElem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentElem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - } - - if (baseValidator) { - - // Get facets if any existing - typedef RefHashTableOf<KVStringPair> KVRefHash; - Janitor<KVRefHash> janFacets(0); - //RefHashTableOf<KVStringPair>* facets = 0; - typedef RefArrayVectorOf<XMLCh> XMLChRefArray; - Janitor<XMLChRefArray> enums(0); - //RefArrayVectorOf<XMLCh>* enums = 0; - XMLBuffer pattern(128, fGrammarPoolMemoryManager); - Janitor<XSAnnotation> janEnumAnnot(0); - Janitor<XSAnnotation> janPatternAnnot(0); - XMLCh fixedFlagStr[16]; - unsigned int fixedFlag = 0; - unsigned short scope = 0; - bool isFirstPattern = true; - bool sawPattern = false; - - - while (content != 0) { - - if (content->getNodeType() == DOMNode::ELEMENT_NODE) { - - NamespaceScopeManager nsMgr(content, fSchemaInfo, this); - - const XMLCh* facetName = content->getLocalName(); - - bool bContinue=false; // workaround for Borland bug with 'continue' in 'catch' - try { - scope = fAttributeCheck.getFacetId(facetName, fMemoryManager); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch (...) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::InvalidFacetName, facetName); - content = XUtil::getNextSiblingElement(content); - bContinue=true; - } - if(bContinue) - continue; - - fAttributeCheck.checkAttributes( - content, scope, this, false, fNonXSAttList - ); - if (checkContent(rootElem, XUtil::getFirstChildElement(content), true) != 0) - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - - const XMLCh* attValue = content->getAttribute(SchemaSymbols::fgATT_VALUE); - if (janFacets.get() == 0) { - janFacets.reset(new (fGrammarPoolMemoryManager) RefHashTableOf<KVStringPair>(29, true, fGrammarPoolMemoryManager)); - - } - - if (XMLString::equals(facetName, SchemaSymbols::fgELT_ENUMERATION)) { - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(content, fNonXSAttList); - } - if (fAnnotation) { - if (janEnumAnnot.isDataNull()) - janEnumAnnot.reset(fAnnotation); - else - janEnumAnnot.get()->setNext(fAnnotation); - } - - // REVISIT - // if validator is a notation datatype validator, we need - // to get the qualified name first before adding it to the - // enum buffer - if (!enums.get()) { - enums.reset(new (fGrammarPoolMemoryManager) RefArrayVectorOf<XMLCh>(8, true, fGrammarPoolMemoryManager)); - } - - if (baseValidator->getType() == DatatypeValidator::NOTATION) { - - const XMLCh* localPart = getLocalPart(attValue); - const XMLCh* prefix = getPrefix(attValue); - const XMLCh* uriStr = (prefix && *prefix) ? resolvePrefixToURI(content, prefix) : fTargetNSURIString; - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - - if (!fNotationRegistry->containsKey(localPart, uriId)) { - traverseNotationDecl(content, localPart, uriStr); - } - - if (uriStr && *uriStr) { - fBuffer.set(uriStr); - fBuffer.append(chColon); - fBuffer.append(localPart); - enums.get()->addElement(XMLString::replicate(fBuffer.getRawBuffer(), fGrammarPoolMemoryManager)); - } - else { - enums.get()->addElement(XMLString::replicate(localPart, fGrammarPoolMemoryManager)); - } - - } - else if (baseValidator->getType() == DatatypeValidator::QName) { - // We need the URI string for the prefix to determine - // if that matches the value in the instance document. - // Code was just comparing the string of prefix:localname - // and if the schema and instance document had different - // prefixes with the same URI string then we were giving an error. - const XMLCh* prefix = getPrefix(attValue); - const XMLCh* uriStr = (prefix && *prefix) ? resolvePrefixToURI(content, prefix) : fTargetNSURIString; - - enums.get()->addElement(XMLString::replicate(attValue, fGrammarPoolMemoryManager)); - enums.get()->addElement(XMLString::replicate(uriStr, fGrammarPoolMemoryManager)); - } - else { - enums.get()->addElement(XMLString::replicate(attValue, fGrammarPoolMemoryManager)); - } - } - else if (XMLString::equals(facetName, SchemaSymbols::fgELT_PATTERN)) { - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(content, fNonXSAttList); - } - if (fAnnotation) { - if (janPatternAnnot.isDataNull()) - janPatternAnnot.reset(fAnnotation); - else - janPatternAnnot.get()->setNext(fAnnotation); - } - sawPattern = true; - if (isFirstPattern) { // fBuffer.isEmpty() - overhead call - - isFirstPattern = false; - pattern.set(attValue); - } - else { //datatypes: 5.2.4 pattern - - pattern.append(chPipe); - pattern.append(attValue); - } - } - else { - - if (janFacets.get()->containsKey(facetName)) { - - if (fAnnotation) - delete fAnnotation; - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateFacet, facetName); - } - else { - - if (XMLString::equals(facetName, SchemaSymbols::fgELT_WHITESPACE) - && baseValidator->getType() != DatatypeValidator::String - && !XMLString::equals(attValue, SchemaSymbols::fgWS_COLLAPSE)) { - - if (fAnnotation) - delete fAnnotation; - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::WS_CollapseExpected, attValue); - } - else { - - const XMLCh* facetStr = fStringPool->getValueForId(fStringPool->addOrFind(facetName)); - KVStringPair* kv = new (fGrammarPoolMemoryManager) KVStringPair(facetStr, attValue, fGrammarPoolMemoryManager); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(content, fNonXSAttList); - } - if (fAnnotation) - fSchemaGrammar->putAnnotation(kv, fAnnotation); - - janFacets.get()->put((void*) facetStr, kv); - checkFixedFacet(content, facetStr, baseValidator, fixedFlag); - } - } - } - } - - content = XUtil::getNextSiblingElement(content); - } // end while - - if (sawPattern) { - - KVStringPair* kv = new (fGrammarPoolMemoryManager) KVStringPair(SchemaSymbols::fgELT_PATTERN, pattern.getRawBuffer(), pattern.getLen(), fGrammarPoolMemoryManager); - if (!janPatternAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(kv, janPatternAnnot.release()); - janFacets.get()->put((void*) SchemaSymbols::fgELT_PATTERN, kv); - } - - if (fixedFlag) { - - XMLString::binToText(fixedFlag, fixedFlagStr, 15, 10, fGrammarPoolMemoryManager); - janFacets.get()->put((void*) SchemaSymbols::fgATT_FIXED, - new (fGrammarPoolMemoryManager) KVStringPair(SchemaSymbols::fgATT_FIXED, fixedFlagStr, fGrammarPoolMemoryManager)); - } - - if (enums.get() && !janEnumAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(enums.get(), janEnumAnnot.release()); - - try { - newDV = fDatatypeRegistry->createDatatypeValidator(qualifiedName, baseValidator, janFacets.release(), enums.release(), false, finalSet, true, fGrammarPoolMemoryManager); - } - catch (const XMLException& excep) { - reportSchemaError(contentElem, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, - XMLErrs::DatatypeValidatorCreationError, typeName); - } - } - popCurrentTypeNameStack(); - return newDV; -} - -/** - * Traverses Schema union simple type declaration. - * - * <union - * id = ID - * memberTypes = List of QName - * {any attributes with non-schema namespace . . .}> - * Content: (annotation?, simpleType*) - * </union> - * - */ -DatatypeValidator* -TraverseSchema::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) { - - NamespaceScopeManager nsMgr(contentElem, fSchemaInfo, this); - - fAttributeCheck.checkAttributes( - contentElem, GeneralAttributeCheck::E_Union, this, false, fNonXSAttList - ); - - const DOMElement* tempEl = XUtil::getNextSiblingElement(contentElem); - if (tempEl != 0) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::SimpleTypeContentError, tempEl->getLocalName()); - } - - const XMLCh* baseTypeName = getElementAttValue(contentElem, SchemaSymbols::fgATT_MEMBERTYPES); - DatatypeValidator* baseValidator = 0; - RefVectorOf<DatatypeValidator>* validators = new (fGrammarPoolMemoryManager) RefVectorOf<DatatypeValidator>(4, false, fGrammarPoolMemoryManager); - Janitor<RefVectorOf<DatatypeValidator> > janValidators(validators); - DOMElement* content = 0; - - if (baseTypeName && *baseTypeName) { //base was provided - get proper validator. - - XMLStringTokenizer unionMembers(baseTypeName, fGrammarPoolMemoryManager); - int tokCount = unionMembers.countTokens(); - - for (int i = 0; i < tokCount; i++) { - - const XMLCh* memberTypeName = unionMembers.nextToken(); - - baseValidator = findDTValidator(contentElem, typeName, memberTypeName, SchemaSymbols::XSD_UNION); - - if (baseValidator == 0) { - - popCurrentTypeNameStack(); - return 0; - } - - validators->addElement(baseValidator); - } - - content = checkContent(rootElem, XUtil::getFirstChildElement(contentElem), true); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentElem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - } - else { // must 'see' <simpleType> - - content = checkContent(rootElem, XUtil::getFirstChildElement(contentElem), false); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentElem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - if (content == 0) { - - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::ExpectedSimpleTypeInUnion, typeName); - popCurrentTypeNameStack(); - return 0; - } - - if (!XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_SIMPLETYPE)) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::ListUnionRestrictionError, typeName); - popCurrentTypeNameStack(); - return 0; - } - } - - // process union content of simpleType children if any - while (content != 0) { - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_SIMPLETYPE)) { - - baseValidator = checkForSimpleTypeValidator(content, baseRefContext | SchemaSymbols::XSD_UNION); - - if (baseValidator == 0) { - - popCurrentTypeNameStack(); - return 0; - } - - validators->addElement(baseValidator); - } - else { - // REVISIT - should we break. For now, we will continue and move to - // the next sibling - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::ListUnionRestrictionError, typeName); - } - - content = XUtil::getNextSiblingElement(content); - } // end while - - DatatypeValidator* newDV = 0; - janValidators.orphan(); - - try { - newDV = fDatatypeRegistry->createDatatypeValidator(qualifiedName, validators, finalSet, true, fGrammarPoolMemoryManager); - } - catch (const XMLException& excep) { - reportSchemaError(contentElem, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, - XMLErrs::DatatypeValidatorCreationError, typeName); - } - - popCurrentTypeNameStack(); - return newDV; -} - - -/** - * Traverse SimpleContent Declaration - * - * <simpleContent - * id = ID - * {any attributes with non-schema namespace...}> - * - * Content: (annotation? , (restriction | extension)) - * </simpleContent> - * - * <restriction - * base = QNAME - * id = ID - * {any attributes with non-schema namespace...}> - * - * Content: (annotation?, (simpleType?, (minExclusive | minInclusive - * | maxExclusive | maxInclusive | totalDigits | fractionDigits - * | length | minLength | maxLength | enumeration | pattern - * | whiteSpace)*)?, ((attribute | attributeGroup)* , anyAttribute?)) - * </restriction> - * - * <extension - * base = QNAME - * id = ID - * {any attributes with non-schema namespace...}> - * Content: (annotation? , ((attribute | attributeGroup)* , anyAttribute?)) - * </extension> - * - */ -void TraverseSchema::traverseSimpleContentDecl(const XMLCh* const typeName, - const XMLCh* const qualifiedName, - const DOMElement* const contentDecl, - ComplexTypeInfo* const typeInfo, - Janitor<XSAnnotation>* const janAnnot) -{ - NamespaceScopeManager nsMgr(contentDecl, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - bool preProcessFlag = typeInfo->getPreprocessed(); - - if (!preProcessFlag) { - fAttributeCheck.checkAttributes( - contentDecl, GeneralAttributeCheck::E_SimpleContent - , this, false, fNonXSAttList - ); - } - - // ----------------------------------------------------------------------- - // Set the content type to be simple, and initialize content spec handle - // ----------------------------------------------------------------------- - typeInfo->setContentType(SchemaElementDecl::Simple); - - // ----------------------------------------------------------------------- - // Process annotation if any - // ----------------------------------------------------------------------- - DOMElement* simpleContent = checkContent(contentDecl, XUtil::getFirstChildElement(contentDecl), false, !preProcessFlag); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentDecl, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - // If there are no children, return - if (simpleContent == 0) { - - reportSchemaError(contentDecl, XMLUni::fgXMLErrDomain, XMLErrs::EmptySimpleTypeContent); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - NamespaceScopeManager nsMgr2(simpleContent, fSchemaInfo, this); - // ----------------------------------------------------------------------- - // The content should be either "restriction" or "extension" - // ----------------------------------------------------------------------- - if (!preProcessFlag) { - const XMLCh* const contentName = simpleContent->getLocalName(); - - if (XMLString::equals(contentName, SchemaSymbols::fgATTVAL_RESTRICTION)) { - - fAttributeCheck.checkAttributes( - simpleContent, GeneralAttributeCheck::E_Restriction - , this, false, fNonXSAttList - ); - typeInfo->setDerivedBy(SchemaSymbols::XSD_RESTRICTION); - } - else if (XMLString::equals(contentName, SchemaSymbols::fgATTVAL_EXTENSION)) { - - fAttributeCheck.checkAttributes( - simpleContent, GeneralAttributeCheck::E_Extension - , this, false, fNonXSAttList - ); - typeInfo->setDerivedBy(SchemaSymbols::XSD_EXTENSION); - } - else { - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidSimpleContent); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - - //Skip over any annotations in the restriction or extension elements - DOMElement* content = checkContent(simpleContent, XUtil::getFirstChildElement(simpleContent), true, !preProcessFlag); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(simpleContent, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - // ----------------------------------------------------------------------- - // Handle the base type name - // ----------------------------------------------------------------------- - const XMLCh* baseName = getElementAttValue(simpleContent, SchemaSymbols::fgATT_BASE, DatatypeValidator::QName); - - if (!baseName || !*baseName) { - - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::UnspecifiedBase); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - const XMLCh* prefix = getPrefix(baseName); - const XMLCh* localPart = getLocalPart(baseName); - const XMLCh* uri = resolvePrefixToURI(simpleContent, prefix); - - // check for 'anyType' - if (XMLString::equals(uri, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - && XMLString::equals(localPart, SchemaSymbols::fgATTVAL_ANYTYPE)) { - - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidSimpleContentBase, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - processBaseTypeInfo(simpleContent, baseName, localPart, uri, typeInfo); - - ComplexTypeInfo* baseTypeInfo = typeInfo->getBaseComplexTypeInfo(); - DatatypeValidator* baseValidator = typeInfo->getBaseDatatypeValidator(); - - if (baseValidator != 0 && baseTypeInfo == 0) { - - // check that the simpleType does not preclude derivation by extension - if ((baseValidator->getFinalSet() & SchemaSymbols::XSD_EXTENSION) == typeInfo->getDerivedBy()) { - - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::DisallowedSimpleTypeExtension, - baseName, typeName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - //Schema Spec: 5.11: Complex Type Definition Properties Correct: 2 - if (typeInfo->getDerivedBy() == SchemaSymbols::XSD_RESTRICTION) { - - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidComplexTypeBase, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - - // check that the base isn't a complex type with complex content - // and that derivation method is not included in 'final' - bool simpleTypeRequired = false; - - if (baseTypeInfo) { - - if (baseTypeInfo->getContentType() != SchemaElementDecl::Simple) { - - // Schema Errata: E1-27 - if (typeInfo->getDerivedBy() == SchemaSymbols::XSD_RESTRICTION - && ((baseTypeInfo->getContentType() == SchemaElementDecl::Mixed_Simple - || baseTypeInfo->getContentType() == SchemaElementDecl::Mixed_Complex) - && emptiableParticle(baseTypeInfo->getContentSpec()))) { - simpleTypeRequired = true; - } - else { - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidSimpleContentBase, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - - if ((baseTypeInfo->getFinalSet() & typeInfo->getDerivedBy()) != 0) { - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::ForbiddenDerivation, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - - // ----------------------------------------------------------------------- - // Process the content of the derivation - // ----------------------------------------------------------------------- - if (typeInfo->getDerivedBy() == SchemaSymbols::XSD_RESTRICTION) { - - if(baseTypeInfo) - typeInfo->setBaseDatatypeValidator(baseTypeInfo->getDatatypeValidator()); - - if (content != 0) { - - // --------------------------------------------------------------- - // There may be a simple type definition in the restriction - // element. The data type validator will be based on it, if - // specified - // --------------------------------------------------------------- - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_SIMPLETYPE)) { - - DatatypeValidator* simpleTypeDV = traverseSimpleTypeDecl(content, false); - - if (simpleTypeDV) { - - // Check that the simpleType validator is validly derived - // from base - DatatypeValidator* baseDV = typeInfo->getBaseDatatypeValidator(); - - if (baseDV && !baseDV->isSubstitutableBy(simpleTypeDV)) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::InvalidContentRestriction); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - typeInfo->setBaseDatatypeValidator(simpleTypeDV); - content = XUtil::getNextSiblingElement(content); - } - else { - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - // Schema Errata E1-27 - // Complex Type Definition Restriction OK: 2.2 - else if (simpleTypeRequired) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::CT_SimpleTypeChildRequired); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - // --------------------------------------------------------------- - // Build up the facet info - // --------------------------------------------------------------- - RefHashTableOf<KVStringPair>* facets = 0; - RefArrayVectorOf<XMLCh>* enums = 0; - XMLBuffer pattern(128, fGrammarPoolMemoryManager); - XMLCh fixedFlagStr[16]; - unsigned int fixedFlag = 0; - unsigned short scope = 0; - bool isFirstPattern = true; - - while (content != 0) { - - const XMLCh* facetName = content->getLocalName(); - - bool bDoBreak=false; // workaround for Borland bug with 'break' in 'catch' - // if not a valid facet, break from the loop - try { - scope = fAttributeCheck.getFacetId(facetName, fMemoryManager); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) { - bDoBreak=true; - } - if(bDoBreak) - break; - - if (content->getNodeType() == DOMNode::ELEMENT_NODE) { - - fAttributeCheck.checkAttributes(content, scope, this); - - const XMLCh* attValue = content->getAttribute(SchemaSymbols::fgATT_VALUE); - - if (facets == 0) { - facets = new (fGrammarPoolMemoryManager) RefHashTableOf<KVStringPair>(29, true, fGrammarPoolMemoryManager); - } - - if (XMLString::equals(facetName, SchemaSymbols::fgELT_ENUMERATION)) { - - if (!enums) { - enums = new (fGrammarPoolMemoryManager) RefArrayVectorOf<XMLCh>(8, true, fGrammarPoolMemoryManager); - } - - enums->addElement(XMLString::replicate(attValue, fGrammarPoolMemoryManager)); - } - else if (XMLString::equals(facetName, SchemaSymbols::fgELT_PATTERN)) { - - if (isFirstPattern) { // fBuffer.isEmpty() - overhead call - - isFirstPattern = false; - pattern.set(attValue); - } - else { //datatypes: 5.2.4 pattern - - pattern.append(chPipe); - pattern.append(attValue); - } - } - else { - - if (facets->containsKey(facetName)) { - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateFacet, facetName); - } - else { - - const XMLCh* facetNameStr = - fStringPool->getValueForId(fStringPool->addOrFind(facetName)); - - facets->put((void*) facetNameStr, new (fGrammarPoolMemoryManager) KVStringPair(facetNameStr, attValue, fGrammarPoolMemoryManager)); - checkFixedFacet(content, facetNameStr, typeInfo->getBaseDatatypeValidator(), fixedFlag); - } - } - } - - content = XUtil::getNextSiblingElement(content); - } - - if (facets) { - - if (!pattern.isEmpty()) { - facets->put - ( - (void*) SchemaSymbols::fgELT_PATTERN, - new (fGrammarPoolMemoryManager) KVStringPair - ( - SchemaSymbols::fgELT_PATTERN - , pattern.getRawBuffer() - , pattern.getLen() - , fGrammarPoolMemoryManager - ) - ); - } - - if (fixedFlag) { - - XMLString::binToText(fixedFlag, fixedFlagStr, 15, 10, fGrammarPoolMemoryManager); - facets->put((void*) SchemaSymbols::fgATT_FIXED, - new (fGrammarPoolMemoryManager) KVStringPair(SchemaSymbols::fgATT_FIXED, fixedFlagStr, fGrammarPoolMemoryManager)); - } - - try { - - DatatypeValidator* simpleDV = - fDatatypeRegistry->createDatatypeValidator - ( - qualifiedName, - typeInfo->getBaseDatatypeValidator(), - facets, enums, false, 0, true, fGrammarPoolMemoryManager - ); - simpleDV->setAnonymous(); - typeInfo->setDatatypeValidator(simpleDV); - } - catch (const XMLException& excep) { - reportSchemaError(simpleContent, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) { - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::DatatypeValidatorCreationError, typeName); - } - } - else { - typeInfo->setDatatypeValidator(typeInfo->getBaseDatatypeValidator()); - } - } - else { - - // Schema Errata E1-27 - // Complex Type Definition Restriction OK: 2.2 - if (simpleTypeRequired) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::CT_SimpleTypeChildRequired); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - typeInfo->setDatatypeValidator(typeInfo->getBaseDatatypeValidator()); - } - } // end RESTRICTION - else { // EXTENSION - - ComplexTypeInfo* baseTypeInfo = typeInfo->getBaseComplexTypeInfo(); - - if (baseTypeInfo!= 0) { - - typeInfo->setBaseDatatypeValidator(baseTypeInfo->getDatatypeValidator()); - } - - typeInfo->setDatatypeValidator(typeInfo->getBaseDatatypeValidator()); - } - - // ----------------------------------------------------------------------- - // Process attributes if any - // ----------------------------------------------------------------------- - processAttributes(simpleContent, content, typeInfo); - - if (XUtil::getNextSiblingElement(simpleContent) != 0) { - reportSchemaError(simpleContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildInSimpleContent); - } - -} // End of function traverseSimpleContentDecl - -/** - * Traverse complexContent Declaration - * - * <complexContent - * id = ID - * mixed = boolean - * {any attributes with non-schema namespace...}> - * - * Content: (annotation? , (restriction | extension)) - * </complexContent> - * - * <restriction - * base = QNAME - * id = ID - * {any attributes with non-schema namespace...}> - * - * Content: (annotation? , (group | all | choice | sequence)?, - * ((attribute | attributeGroup)* , anyAttribute?)) - * </restriction> - * - * <extension - * base = QNAME - * id = ID - * {any attributes with non-schema namespace...}> - * Content: (annotation? , (group | all | choice | sequence)?, - * ((attribute | attributeGroup)* , anyAttribute?)) - * </extension> - */ -void TraverseSchema::traverseComplexContentDecl(const XMLCh* const typeName, - const DOMElement* const contentDecl, - ComplexTypeInfo* const typeInfo, - const bool isMixed, - Janitor<XSAnnotation>* const janAnnot) -{ - NamespaceScopeManager nsMgr(contentDecl, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check attributes - // ----------------------------------------------------------------------- - bool preProcessFlag = typeInfo->getPreprocessed(); - - if (!preProcessFlag) { - fAttributeCheck.checkAttributes( - contentDecl, GeneralAttributeCheck::E_ComplexContent - , this, false, fNonXSAttList - ); - } - - // ----------------------------------------------------------------------- - // Determine whether the content is mixed, or element-only - // Setting here overrides any setting on the complex type decl - // ----------------------------------------------------------------------- - const XMLCh* const mixed = getElementAttValue(contentDecl, SchemaSymbols::fgATT_MIXED, DatatypeValidator::Boolean); - bool mixedContent = isMixed; - - if (mixed) { - if (XMLString::equals(mixed, SchemaSymbols::fgATTVAL_TRUE) - || XMLString::equals(mixed, fgValueOne)) { - mixedContent = true; - } - else if (XMLString::equals(mixed, SchemaSymbols::fgATTVAL_FALSE) - || XMLString::equals(mixed, fgValueZero)) { - mixedContent = false; - } - } - - // ----------------------------------------------------------------------- - // Since the type must have complex content, set the simple type validators - // to null - // ----------------------------------------------------------------------- - typeInfo->setDatatypeValidator(0); - typeInfo->setBaseDatatypeValidator(0); - - DOMElement* complexContent = checkContent(contentDecl,XUtil::getFirstChildElement(contentDecl),false, !preProcessFlag); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(contentDecl, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - // If there are no children, return - if (complexContent == 0) { - throw TraverseSchema::InvalidComplexTypeInfo; - } - - NamespaceScopeManager nsMgr2(complexContent, fSchemaInfo, this); - // ----------------------------------------------------------------------- - // The content should be either "restriction" or "extension" - // ----------------------------------------------------------------------- - const XMLCh* const complexContentName = complexContent->getLocalName(); - - if (XMLString::equals(complexContentName, SchemaSymbols::fgELT_RESTRICTION)) { - typeInfo->setDerivedBy(SchemaSymbols::XSD_RESTRICTION); - } - else if (XMLString::equals(complexContentName, SchemaSymbols::fgELT_EXTENSION)) { - typeInfo->setDerivedBy(SchemaSymbols::XSD_EXTENSION); - } - else { - - reportSchemaError(complexContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidComplexContent); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - // ----------------------------------------------------------------------- - // Handle the base type name - // ----------------------------------------------------------------------- - const XMLCh* baseName = getElementAttValue(complexContent, SchemaSymbols::fgATT_BASE, DatatypeValidator::QName); - - if (!baseName || !*baseName) { - - reportSchemaError(complexContent, XMLUni::fgXMLErrDomain, XMLErrs::UnspecifiedBase); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - const XMLCh* prefix = getPrefix(baseName); - const XMLCh* localPart = getLocalPart(baseName); - const XMLCh* uri = resolvePrefixToURI(complexContent, prefix); - bool isBaseAnyType = false; - - // ------------------------------------------------------------- - // check if the base is "anyType" - // ------------------------------------------------------------- - if (XMLString::equals(uri, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) && - XMLString::equals(localPart, SchemaSymbols::fgATTVAL_ANYTYPE)) { - isBaseAnyType = true; - } - else { - - processBaseTypeInfo(complexContent, baseName, localPart, uri, typeInfo); - - //Check that the base is a complex type - if (typeInfo->getBaseComplexTypeInfo() == 0) { - - reportSchemaError(complexContent, XMLUni::fgXMLErrDomain, XMLErrs::BaseNotComplexType); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - - if (fCurrentGroupInfo) // defer processing until later - throw TraverseSchema::RecursingElement; - - // ----------------------------------------------------------------------- - // Process the content of the derivation - // ----------------------------------------------------------------------- - //Skip over any annotations in the restriction or extension elements - DOMElement* content = checkContent(complexContent, XUtil::getFirstChildElement(complexContent), true); - if (fAnnotation) - { - if (janAnnot->isDataNull()) - janAnnot->reset(fAnnotation); - else - janAnnot->get()->setNext(fAnnotation); - } - - processComplexContent(complexContent, typeName, content, typeInfo, localPart, - mixedContent, isBaseAnyType); - - if (XUtil::getNextSiblingElement(complexContent) != 0) { - reportSchemaError(complexContent, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildInComplexContent); - } -} - - -/** - * <anyAttribute - * id = ID - * namespace = ((##any | ##other) | list of (anyURI | (##targetNamespace | ##local)))> - * processContents = (lax | skip | strict) : strict - * Content: (annotation?) - * </anyAttribute> - */ -SchemaAttDef* TraverseSchema::traverseAnyAttribute(const DOMElement* const elem) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_AnyAttribute, this, false, fNonXSAttList - ); - - // ------------------------------------------------------------------ - // First, handle any ANNOTATION declaration - // ------------------------------------------------------------------ - if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AnyAttributeContentError); - } - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - // ------------------------------------------------------------------ - // Get attributes - // ------------------------------------------------------------------ - const XMLCh* const processContents = getElementAttValue(elem, SchemaSymbols::fgATT_PROCESSCONTENTS); - const XMLCh* const nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE); - - // ------------------------------------------------------------------ - // Set default att type based on 'processContents' value - // ------------------------------------------------------------------ - XMLAttDef::DefAttTypes attDefType = XMLAttDef::ProcessContents_Strict; - - if ((!processContents || !*processContents) - || XMLString::equals(processContents, SchemaSymbols::fgATTVAL_STRICT)) { - // Do nothing - defaulted already - } - else if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_SKIP)) { - attDefType = XMLAttDef::ProcessContents_Skip; - } - else if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_LAX)) { - attDefType = XMLAttDef::ProcessContents_Lax; - } - - // ------------------------------------------------------------------ - // Process 'namespace' attribute - // ------------------------------------------------------------------ - int uriIndex = fEmptyNamespaceURI; - XMLAttDef::AttTypes attType = XMLAttDef::Any_Any; - ValueVectorOf<unsigned int> namespaceList(8, fGrammarPoolMemoryManager); - - if ((!nameSpace || !*nameSpace) - || XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY)) { - // Do nothing - defaulted already - } - else if (XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDOTHER)) { - - attType = XMLAttDef::Any_Other; - uriIndex = fTargetNSURI; - } - else { - - XMLStringTokenizer tokenizer(nameSpace, fGrammarPoolMemoryManager); - DatatypeValidator* anyURIDV = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYURI); - - attType = XMLAttDef::Any_List; - - while (tokenizer.hasMoreTokens()) { - - const XMLCh* token = tokenizer.nextToken(); - - if (XMLString::equals(token, SchemaSymbols::fgATTVAL_TWOPOUNDLOCAL)) { - uriIndex = fEmptyNamespaceURI; - } - else if (XMLString::equals(token, SchemaSymbols::fgATTVAL_TWOPOUNDTRAGETNAMESPACE)) { - uriIndex = fTargetNSURI; - } - else { - - try { - anyURIDV->validate(token - , fSchemaInfo->getValidationContext() - , fMemoryManager); - } - catch(const XMLException& excep) { - reportSchemaError(elem, excep); - } - uriIndex = fURIStringPool->addOrFind(token); - } - - if (!namespaceList.containsElement(uriIndex)) { - namespaceList.addElement(uriIndex); - } - } - - uriIndex = fEmptyNamespaceURI; - } - - // ------------------------------------------------------------------ - // Create wildcard attribute - // ------------------------------------------------------------------ - SchemaAttDef* attDef = new (fGrammarPoolMemoryManager) SchemaAttDef(XMLUni::fgZeroLenString, - XMLUni::fgZeroLenString, - uriIndex, attType, attDefType, - fGrammarPoolMemoryManager); - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(attDef, janAnnot.release()); - - if (namespaceList.size()) { - attDef->setNamespaceList(&namespaceList); - } - - return attDef; -} - -/** - * <key - * id = ID - * name = NCName - * Content: (annotation?, (selector, field+)) - * </key> - */ -void TraverseSchema::traverseKey(const DOMElement* const icElem, - SchemaElementDecl* const elemDecl) { - - NamespaceScopeManager nsMgr(icElem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - icElem, GeneralAttributeCheck::E_Key, this, false, fNonXSAttList - ); - - // ----------------------------------------------------------------------- - // Create identity constraint - // ----------------------------------------------------------------------- - const XMLCh* name = getElementAttValue(icElem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) { - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_KEY, name); - return; - } - - - if (!fIdentityConstraintNames) { - fIdentityConstraintNames = new (fMemoryManager) RefHash2KeysTableOf<IdentityConstraint>(29, (bool) false, fMemoryManager); - } - else if (fIdentityConstraintNames->containsKey(name, fTargetNSURI)) { - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_DuplicateDecl, name); - return; - } - - IC_Key* icKey = new (fGrammarPoolMemoryManager) IC_Key(name, elemDecl->getBaseName(), fGrammarPoolMemoryManager); - Janitor<IC_Key> janKey(icKey); - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, icKey); - - // ----------------------------------------------------------------------- - // Get selector and fields - // ----------------------------------------------------------------------- - if (!traverseIdentityConstraint(icKey, icElem)) { - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, 0); - return; - } - - // ----------------------------------------------------------------------- - // Add key to element declaration - // ----------------------------------------------------------------------- - elemDecl->addIdentityConstraint(icKey); - icKey->setNamespaceURI(fTargetNSURI); - janKey.orphan(); -} - -/** - * <unique - * id = ID - * name = NCName - * Content: (annotation?, (selector, field+)) - * </unique> - */ -void TraverseSchema::traverseUnique(const DOMElement* const icElem, - SchemaElementDecl* const elemDecl) { - - NamespaceScopeManager nsMgr(icElem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - icElem, GeneralAttributeCheck::E_Unique, this, false, fNonXSAttList - ); - - // ----------------------------------------------------------------------- - // Create identity constraint - // ----------------------------------------------------------------------- - const XMLCh* name = getElementAttValue(icElem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) { - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_UNIQUE, name); - return; - } - - if (!fIdentityConstraintNames) { - fIdentityConstraintNames = new (fGrammarPoolMemoryManager) RefHash2KeysTableOf<IdentityConstraint>(29, (bool) false, fGrammarPoolMemoryManager); - } - else if (fIdentityConstraintNames->containsKey(name, fTargetNSURI)) { - - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_DuplicateDecl, name); - return; - } - - IC_Unique* icUnique = new (fGrammarPoolMemoryManager) IC_Unique(name, elemDecl->getBaseName(), fGrammarPoolMemoryManager); - Janitor<IC_Unique> janUnique(icUnique); - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, icUnique); - - // ----------------------------------------------------------------------- - // Get selector and fields - // ----------------------------------------------------------------------- - if (!traverseIdentityConstraint(icUnique, icElem)) { - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, 0); - return; - } - - // ----------------------------------------------------------------------- - // Add identity cosntraints to element declaration - // ----------------------------------------------------------------------- - elemDecl->addIdentityConstraint(icUnique); - icUnique->setNamespaceURI(fTargetNSURI); - janUnique.orphan(); -} - -/** - * <keyref - * id = ID - * name = NCName - * refer = QName - * Content: (annotation?, (selector, field+)) - * </keyref> - */ -void TraverseSchema::traverseKeyRef(const DOMElement* const icElem, - SchemaElementDecl* const elemDecl) { - - NamespaceScopeManager nsMgr(icElem, fSchemaInfo, this); - - // ----------------------------------------------------------------------- - // Check Attributes - // ----------------------------------------------------------------------- - fAttributeCheck.checkAttributes( - icElem, GeneralAttributeCheck::E_KeyRef, this, false, fNonXSAttList - ); - - // ----------------------------------------------------------------------- - // Verify that key reference "refer" attribute is valid - // ----------------------------------------------------------------------- - const XMLCh* name = getElementAttValue(icElem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - const XMLCh* refer = getElementAttValue(icElem, SchemaSymbols::fgATT_REFER, DatatypeValidator::QName); - - if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) { - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, - SchemaSymbols::fgELT_KEYREF, name); - return; - } - - const XMLCh* prefix = getPrefix(refer); - const XMLCh* localPart = getLocalPart(refer); - - // we use the DOM API, as the NamespaceScope is now pointing to a different place - const XMLCh* uriStr = icElem->lookupNamespaceURI(*prefix==0?NULL:prefix); - if ((!uriStr || !*uriStr) && (prefix && *prefix)) - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::UnresolvedPrefix, prefix); - if(!uriStr) - uriStr=XMLUni::fgZeroLenString; - - IdentityConstraint* icKey = (fIdentityConstraintNames) - ? fIdentityConstraintNames->get(localPart, fURIStringPool->addOrFind(uriStr)) : 0; - - if (!icKey) { - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_KeyRefReferNotFound, name, localPart); - return; - } - - // ----------------------------------------------------------------------- - // Create identity constraint - // ----------------------------------------------------------------------- - if(fIdentityConstraintNames->containsKey(name, fTargetNSURI)) { - - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_DuplicateDecl, name); - return; - } - - IC_KeyRef* icKeyRef = new (fGrammarPoolMemoryManager) IC_KeyRef(name, elemDecl->getBaseName(), icKey, fGrammarPoolMemoryManager); - Janitor<IC_KeyRef> janKeyRef(icKeyRef); - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, icKeyRef); - - // ----------------------------------------------------------------------- - // Get selector and fields - // ----------------------------------------------------------------------- - if (!traverseIdentityConstraint(icKeyRef, icElem)) { - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, 0); - return; - } - - // ----------------------------------------------------------------------- - // Add key reference to element decl - // ----------------------------------------------------------------------- - if (icKeyRef->getFieldCount() != icKey->getFieldCount()) { - - fIdentityConstraintNames->put((void*) name, fTargetNSURI, 0); - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_KeyRefCardinality, - name, icKey->getIdentityConstraintName()); - } - else { - - elemDecl->addIdentityConstraint(icKeyRef); - icKeyRef->setNamespaceURI(fTargetNSURI); - janKeyRef.orphan(); - } -} - - -bool TraverseSchema::traverseIdentityConstraint(IdentityConstraint* const ic, - const DOMElement* const icElem) { - - NamespaceScopeManager nsMgr(icElem, fSchemaInfo, this); - - // ------------------------------------------------------------------ - // First, handle any ANNOTATION declaration - // ------------------------------------------------------------------ - DOMElement* elem = checkContent(icElem, XUtil::getFirstChildElement(icElem), false); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(icElem, fNonXSAttList); - } - Janitor<XSAnnotation> janAnnot(fAnnotation); - - // ------------------------------------------------------------------ - // Get selector - // ------------------------------------------------------------------ - if (elem == 0) { - -// reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_BadContent); - return false; - } - - if (!XMLString::equals(elem->getLocalName(), SchemaSymbols::fgELT_SELECTOR)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::IC_BadContent); - return false; - } - - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Selector, this, false, fNonXSAttList - ); - if (checkContent(icElem, XUtil::getFirstChildElement(elem), true) != 0) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot.isDataNull()) - janAnnot.reset(fAnnotation); - else - janAnnot.get()->setNext(fAnnotation); - } - - // ------------------------------------------------------------------ - // Get xpath attribute - // ------------------------------------------------------------------ - const XMLCh* xpathExpr = getElementAttValue(elem, SchemaSymbols::fgATT_XPATH); - XMLSize_t xpathLen = XMLString::stringLen(xpathExpr); - - if (!xpathExpr || !xpathLen) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::IC_XPathExprMissing); - return false; - } - - // ------------------------------------------------------------------ - // Parse xpath expression - // ------------------------------------------------------------------ - try { - - XercesXPath* sXPath = new (fGrammarPoolMemoryManager) XercesXPath(xpathExpr, fStringPool, fSchemaInfo->getNamespaceScope(), fEmptyNamespaceURI, true, fGrammarPoolMemoryManager); - IC_Selector* icSelector = new (fGrammarPoolMemoryManager) IC_Selector(sXPath, ic); - ic->setSelector(icSelector); - } - catch (const XPathException& e) { - - reportSchemaError(elem, e); - return false; - } - - // ------------------------------------------------------------------ - // Get fields - // ------------------------------------------------------------------ - elem = XUtil::getNextSiblingElement(elem); - - if (elem == 0) { - - reportSchemaError(icElem, XMLUni::fgXMLErrDomain, XMLErrs::IC_BadContent); - return false; - } - - while (elem != 0) { - - if (!XMLString::equals(elem->getLocalName(), SchemaSymbols::fgELT_FIELD)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::IC_BadContent); - } - else { - // General Attribute Checking - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_Field, this, false, fNonXSAttList - ); - if (checkContent(icElem, XUtil::getFirstChildElement(elem), true) != 0) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected); - if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size()) - { - fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList); - } - if (fAnnotation) - { - if (janAnnot.isDataNull()) - janAnnot.reset(fAnnotation); - else - janAnnot.get()->setNext(fAnnotation); - } - - // xpath expression parsing - xpathExpr = getElementAttValue(elem, SchemaSymbols::fgATT_XPATH); - - if (!xpathExpr || !*xpathExpr) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::IC_XPathExprMissing); - return false; - } - - try { - - XercesXPath* fieldXPath = new (fGrammarPoolMemoryManager) XercesXPath - ( - xpathExpr - , fStringPool - , fSchemaInfo->getNamespaceScope() - , fEmptyNamespaceURI - , false - , fGrammarPoolMemoryManager - ); - IC_Field* icField = new (fGrammarPoolMemoryManager) IC_Field(fieldXPath, ic); - ic->addField(icField); - } - catch (const XPathException& e) { - - reportSchemaError(elem, e); - return false; - } - } - - elem = XUtil::getNextSiblingElement(elem); - } - - if (!janAnnot.isDataNull()) - fSchemaGrammar->putAnnotation(ic, janAnnot.release()); - - if (ic->getFieldCount() == 0) { - return false; - } - - return true; -} - -// --------------------------------------------------------------------------- -// TraverseSchema: Helper methods -// --------------------------------------------------------------------------- -bool TraverseSchema::retrieveNamespaceMapping(const DOMElement* const elem) { - - DOMNamedNodeMap* eltAttrs = elem->getAttributes(); - bool seenNS=false; - const XMLSize_t attrCount = eltAttrs->getLength(); - - for (XMLSize_t i = 0; i < attrCount; i++) { - - DOMNode* attribute = eltAttrs->item(i); - - if (!attribute) { - break; - } - - const XMLCh* attName = attribute->getNodeName(); - - // starts with 'xmlns:' - if (XMLString::startsWith(attName, XMLUni::fgXMLNSColonString)) { - if(!seenNS) - fSchemaInfo->getNamespaceScope()->increaseDepth(); - seenNS=true; - - int offsetIndex = XMLString::indexOf(attName, chColon); - const XMLCh* attValue = attribute->getNodeValue(); - - fSchemaInfo->getNamespaceScope()->addPrefix(attName + offsetIndex + 1, fURIStringPool->addOrFind(attValue)); - } - else if (XMLString::equals(attName, XMLUni::fgXMLNSString)) { // == 'xmlns' - if(!seenNS) - fSchemaInfo->getNamespaceScope()->increaseDepth(); - seenNS=true; - - const XMLCh* attValue = attribute->getNodeValue(); - fSchemaInfo->getNamespaceScope()->addPrefix(XMLUni::fgZeroLenString, fURIStringPool->addOrFind(attValue)); - } - } // end for - return seenNS; -} - -void TraverseSchema::processChildren(const DOMElement* const root) { - - NamespaceScopeManager nsMgr(root, fSchemaInfo, this); - - bool sawAnnotation = false; - // process <redefine>, <include> and <import> info items. - DOMElement* child = XUtil::getFirstChildElement(root); - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* name = child->getLocalName(); - - if (XMLString::equals(name, SchemaSymbols::fgELT_ANNOTATION)) { - XSAnnotation* annot = traverseAnnotationDecl( - child, fSchemaInfo->getNonXSAttList(), true); - if (annot) { - fSchemaGrammar->addAnnotation(annot); - sawAnnotation = true; - } - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_INCLUDE)) { - traverseInclude(child); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_IMPORT)) { - traverseImport(child); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_REDEFINE)) { - traverseRedefine(child); - } - else - break; - } - - // child refers to the first info item which is not <annotation> or - // one of the schema inclusion/importation declarations. - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* name = child->getLocalName(); - const XMLCh* typeName = getElementAttValue(child, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - int fullNameId = 0; - - if (typeName) { - - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(typeName); - fullNameId = fStringPool->addOrFind(fBuffer.getRawBuffer()); - } - - if (XMLString::equals(name, SchemaSymbols::fgELT_ANNOTATION)) { - XSAnnotation* annot = traverseAnnotationDecl( - child, fSchemaInfo->getNonXSAttList(), true); - if (annot) { - fSchemaGrammar->addAnnotation(annot); - sawAnnotation = true; - } - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_SIMPLETYPE)) { - - if (typeName && *typeName) { - if (fGlobalDeclarations[ENUM_ELT_SIMPLETYPE]->containsElement(fullNameId) - || fGlobalDeclarations[ENUM_ELT_COMPLEXTYPE]->containsElement(fullNameId)) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateGlobalType, - SchemaSymbols::fgELT_SIMPLETYPE, typeName, SchemaSymbols::fgELT_COMPLEXTYPE); - continue; - } - else { - fGlobalDeclarations[ENUM_ELT_SIMPLETYPE]->addElement(fullNameId); - } - } - - traverseSimpleTypeDecl(child); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_COMPLEXTYPE)) { - - if (typeName && *typeName) { - if (fGlobalDeclarations[ENUM_ELT_SIMPLETYPE]->containsElement(fullNameId) - || fGlobalDeclarations[ENUM_ELT_COMPLEXTYPE]->containsElement(fullNameId)) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateGlobalType, - SchemaSymbols::fgELT_COMPLEXTYPE, typeName, SchemaSymbols::fgELT_SIMPLETYPE); - continue; - } - else { - fGlobalDeclarations[ENUM_ELT_COMPLEXTYPE]->addElement(fullNameId); - } - } - - traverseComplexTypeDecl(child); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_ELEMENT)) { - - if (typeName && *typeName) { - if (fGlobalDeclarations[ENUM_ELT_ELEMENT]->containsElement(fullNameId)) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateGlobalDeclaration, - SchemaSymbols::fgELT_ELEMENT, typeName); - continue; - } - else { - fGlobalDeclarations[ENUM_ELT_ELEMENT]->addElement(fullNameId); - } - } - - traverseElementDecl(child, true); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_ATTRIBUTEGROUP)) { - - if (typeName && *typeName) { - if (fGlobalDeclarations[ENUM_ELT_ATTRIBUTEGROUP]->containsElement(fullNameId)) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateGlobalDeclaration, - SchemaSymbols::fgELT_ATTRIBUTEGROUP, typeName); - continue; - } - else { - fGlobalDeclarations[ENUM_ELT_ATTRIBUTEGROUP]->addElement(fullNameId); - } - } - - if (!typeName || !fAttGroupRegistry->containsKey(typeName)) { - traverseAttributeGroupDecl(child, 0, true); - } - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_ATTRIBUTE)) { - - if (typeName && *typeName) { - if (fGlobalDeclarations[ENUM_ELT_ATTRIBUTE]->containsElement(fullNameId)) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, typeName); - continue; - } - else { - fGlobalDeclarations[ENUM_ELT_ATTRIBUTE]->addElement(fullNameId); - } - } - - if (!typeName || !fAttributeDeclRegistry->containsKey(typeName)) { - traverseAttributeDecl( child, 0, true); - } - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_GROUP)) { - - if (typeName && *typeName) { - if (fGlobalDeclarations[ENUM_ELT_GROUP]->containsElement(fullNameId)) { - - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateGlobalDeclaration, - SchemaSymbols::fgELT_GROUP, typeName); - continue; - } - else { - fGlobalDeclarations[ENUM_ELT_GROUP]->addElement(fullNameId); - } - } - - if (!typeName || !fGroupRegistry->containsKey(fBuffer.getRawBuffer())) { - traverseGroupDecl(child); - } - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_NOTATION)) { - traverseNotationDecl(child); - } - else { - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::SchemaElementContentError); - } - } // for each child node - - - if (fScanner->getGenerateSyntheticAnnotations() && fSchemaInfo->getNonXSAttList()->size() && !sawAnnotation) - { - // synthesize a global annotation here. - fSchemaGrammar->addAnnotation( - generateSyntheticAnnotation(root, fSchemaInfo->getNonXSAttList()) - ); - } - - // Handle recursing elements - if any - ValueVectorOf<const DOMElement*>* recursingAnonTypes = fSchemaInfo->getRecursingAnonTypes(); - - if (recursingAnonTypes) { - - ValueVectorOf<const XMLCh*>* recursingTypeNames = fSchemaInfo->getRecursingTypeNames(); - XMLSize_t recurseSize = recursingAnonTypes->size(); - - for (XMLSize_t i=0; i < recurseSize; i++) { - traverseComplexTypeDecl(recursingAnonTypes->elementAt(i), false, - recursingTypeNames->elementAt(i)); - } - - recursingAnonTypes->removeAllElements(); - recursingTypeNames->removeAllElements(); - } -} - -void TraverseSchema::preprocessChildren(const DOMElement* const root) { - - NamespaceScopeManager nsMgr(root, fSchemaInfo, this); - - // process <redefine>, <include> and <import> info items. - DOMElement* child = XUtil::getFirstChildElement(root); - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* name = child->getLocalName(); - - if (XMLString::equals(name, SchemaSymbols::fgELT_ANNOTATION)) { - continue; - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_INCLUDE)) { - preprocessInclude(child); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_IMPORT)) { - preprocessImport(child); - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_REDEFINE)) { - preprocessRedefine(child); - } - else - break; - } -} - -DOMElement* TraverseSchema::checkContent( const DOMElement* const rootElem - , DOMElement* const contentElem - , const bool isEmpty - , const bool processAnnot) -{ - DOMElement* content = contentElem; - const XMLCh* name = getElementAttValue(rootElem,SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - - fAnnotation = 0; - Janitor<XSAnnotation> janAnnot(0); - if (!content) { - - if (!isEmpty) { - reportSchemaError(rootElem, XMLUni::fgXMLErrDomain, XMLErrs::ContentError, name); - } - - return 0; - } - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ANNOTATION)) { - - if (processAnnot) { - janAnnot.reset(traverseAnnotationDecl(content, fNonXSAttList)); - } - content = XUtil::getNextSiblingElement(content); - - if (!content) { // must be followed by content - - if (!isEmpty) { - reportSchemaError(contentElem, XMLUni::fgXMLErrDomain, XMLErrs::ContentError, name); - } - fAnnotation = janAnnot.release(); - return 0; - } - - if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ANNOTATION)) { - - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AnnotationError, name); - return 0; - } - fAnnotation = janAnnot.release(); - } - return content; -} - - -DatatypeValidator* -TraverseSchema::getDatatypeValidator(const XMLCh* const uriStr, - const XMLCh* const localPartStr) { - - DatatypeValidator* dv = 0; - - if (XMLString::equals(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - dv = fDatatypeRegistry->getDatatypeValidator(localPartStr); - } - else { - - fBuffer.set(uriStr); - fBuffer.append(chComma); - fBuffer.append(localPartStr); - - if ((uriStr) && !XMLString::equals(uriStr, fTargetNSURIString)) { - - Grammar* grammar = fGrammarResolver->getGrammar(uriStr); - - if (grammar && grammar->getGrammarType() == Grammar::SchemaGrammarType) { - dv = ((SchemaGrammar*) grammar)->getDatatypeRegistry()->getDatatypeValidator(fBuffer.getRawBuffer()); - } - } - else { - dv = fDatatypeRegistry->getDatatypeValidator(fBuffer.getRawBuffer()); - } - } - - return dv; -} - - -DatatypeValidator* -TraverseSchema::checkForSimpleTypeValidator(const DOMElement* const content, - int baseRefContext) { - - DatatypeValidator* baseValidator = traverseSimpleTypeDecl(content, false, baseRefContext); - - if (!baseValidator) { - - const XMLCh* name = getElementAttValue(content,SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::UnknownSimpleType, name); - } - - return baseValidator; -} - -ComplexTypeInfo* -TraverseSchema::checkForComplexTypeInfo(const DOMElement* const content) { - - int typeNameIndex = traverseComplexTypeDecl(content, false); - ComplexTypeInfo* baseTypeInfo = 0; - - if (typeNameIndex != -1) { - baseTypeInfo = fComplexTypeRegistry->get(fStringPool->getValueForId(typeNameIndex)); - } - - if (typeNameIndex == -1 || baseTypeInfo == 0) { - - const XMLCh* name = getElementAttValue(content,SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::UnknownComplexType, name); - } - - return baseTypeInfo; -} - -DatatypeValidator* -TraverseSchema::findDTValidator(const DOMElement* const elem, - const XMLCh* const derivedTypeName, - const XMLCh* const baseTypeName, - const int baseRefContext) { - - const XMLCh* prefix = getPrefix(baseTypeName); - const XMLCh* localPart = getLocalPart(baseTypeName); - const XMLCh* uri = resolvePrefixToURI(elem, prefix); - DatatypeValidator* baseValidator = getDatatypeValidator(uri, localPart); - - if (baseValidator == 0) { - - // Check if the base is from the schema for schema namespace - // - if (XMLString::equals(uri, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, uri, localPart); - return 0; - } - - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - SchemaInfo* saveInfo = fSchemaInfo; - unsigned int saveScope = fCurrentScope; - - if (!XMLString::equals(uri, fTargetNSURIString) && (uri && *uri)) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(uri); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, uri); - return 0; - } - - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(uriId); - - if (!impInfo || impInfo->getProcessed()) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, uri, localPart); - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - - DOMElement* baseTypeNode = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_SimpleType, - SchemaSymbols::fgELT_SIMPLETYPE, localPart, &fSchemaInfo); - - if (baseTypeNode != 0) { - - baseValidator = traverseSimpleTypeDecl(baseTypeNode); - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - } - } - - if (baseValidator == 0) { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::UnknownBaseDatatype, baseTypeName, derivedTypeName); - } - else if ((baseValidator->getFinalSet() & baseRefContext) != 0) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DisallowedBaseDerivation, baseTypeName); - return 0; - } - - return baseValidator; -} - - -const XMLCh* TraverseSchema::resolvePrefixToURI(const DOMElement* const elem, - const XMLCh* const prefix) { - - unsigned int nameSpaceIndex = fSchemaInfo->getNamespaceScope()->getNamespaceForPrefix(prefix); - const XMLCh* uriStr = fURIStringPool->getValueForId(nameSpaceIndex); - - if ((!uriStr || !*uriStr) && (prefix && *prefix)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::UnresolvedPrefix, prefix); - return XMLUni::fgZeroLenString; - } - - return uriStr; -} - -SchemaElementDecl* -TraverseSchema::processElementDeclRef(const DOMElement* const elem, - const XMLCh* const refName) -{ - // check attributes - fAttributeCheck.checkAttributes( - elem, GeneralAttributeCheck::E_ElementRef, this, false, fNonXSAttList - ); - - // handle annotation - DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true); - Janitor<XSAnnotation> janAnnot(fAnnotation); - - // do not generate synthetic annotation for element reference... - - if (content != 0) - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::NoContentForRef, SchemaSymbols::fgELT_ELEMENT); - - SchemaElementDecl* refElemDecl = getGlobalElemDecl(elem, refName); - - if (!refElemDecl) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::RefElementNotFound, refName); - } - else - { - if (fCurrentComplexType) - fCurrentComplexType->addElement(refElemDecl); - - if (fCurrentGroupInfo) - fCurrentGroupInfo->addElement(refElemDecl); - } - - return refElemDecl; -} - -int TraverseSchema::parseBlockSet(const DOMElement* const elem, - const int blockType, const bool isRoot) { - - const XMLCh* blockVal = (isRoot) ? getElementAttValue(elem, SchemaSymbols::fgATT_BLOCKDEFAULT) - : getElementAttValue(elem, SchemaSymbols::fgATT_BLOCK); - - // blockVal == 0 means 'block attribute is missing'; *blockVal == 0 means 'block="" found' - if (blockVal == 0) - return fSchemaInfo->getBlockDefault(); - - int blockSet = 0; - - if (XMLString::equals(blockVal, SchemaSymbols::fgATTVAL_POUNDALL)) { - - blockSet = SchemaSymbols::XSD_EXTENSION + SchemaSymbols::XSD_RESTRICTION + SchemaSymbols::XSD_SUBSTITUTION; - return blockSet; - } - - XMLStringTokenizer tokenizer(blockVal, fGrammarPoolMemoryManager); - - while (tokenizer.hasMoreTokens()) { - - XMLCh* token = tokenizer.nextToken(); - - if (XMLString::equals(token, SchemaSymbols::fgATTVAL_SUBSTITUTION) - && blockType == ES_Block) { - - if ((blockSet & SchemaSymbols::XSD_SUBSTITUTION) == 0 ) { - blockSet += SchemaSymbols::XSD_SUBSTITUTION; - } - } - else if (XMLString::equals(token, SchemaSymbols::fgATTVAL_EXTENSION)) { - - if ((blockSet & SchemaSymbols::XSD_EXTENSION) == 0) { - blockSet += SchemaSymbols::XSD_EXTENSION; - } - } - else if (XMLString::equals(token, SchemaSymbols::fgATTVAL_RESTRICTION)) { - - if ((blockSet & SchemaSymbols::XSD_RESTRICTION) == 0 ) { - blockSet += SchemaSymbols::XSD_RESTRICTION; - } - } - else { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidBlockValue, blockVal); - } - } //end while - - return blockSet; -} - -int TraverseSchema::parseFinalSet(const DOMElement* const elem, - const int finalType, const bool isRoot) { - - const XMLCh* finalVal = (isRoot) ? getElementAttValue(elem, SchemaSymbols::fgATT_FINALDEFAULT) - : getElementAttValue(elem, SchemaSymbols::fgATT_FINAL); - - // finalVal == 0 means 'final attribute is missing'; *finalVal == 0 means 'final="" found' - if (finalVal == 0) - return fSchemaInfo->getFinalDefault(); - - int finalSet = 0; - - if (XMLString::equals(finalVal, SchemaSymbols::fgATTVAL_POUNDALL)) { - - finalSet = SchemaSymbols::XSD_RESTRICTION + SchemaSymbols::XSD_LIST + - SchemaSymbols::XSD_UNION + SchemaSymbols::XSD_EXTENSION; - return finalSet; - } - - XMLStringTokenizer tokenizer(finalVal, fGrammarPoolMemoryManager); - - while (tokenizer.hasMoreTokens()) { - - XMLCh* token = tokenizer.nextToken(); - - if (XMLString::equals(token, SchemaSymbols::fgELT_UNION) - && (finalType == S_Final || finalType == ECS_Final)) { - - if ((finalSet & SchemaSymbols::XSD_UNION) == 0) { - finalSet += SchemaSymbols::XSD_UNION; - } - } - else if (XMLString::equals(token, SchemaSymbols::fgATTVAL_EXTENSION) - && (finalType == EC_Final || finalType == ECS_Final)) { - - if ((finalSet & SchemaSymbols::XSD_EXTENSION) == 0) { - finalSet += SchemaSymbols::XSD_EXTENSION; - } - } - else if (XMLString::equals(token, SchemaSymbols::fgELT_LIST) - && (finalType == S_Final || finalType == ECS_Final)) { - - if ((finalSet & SchemaSymbols::XSD_LIST) == 0 ) { - finalSet += SchemaSymbols::XSD_LIST; - } - } - else if (XMLString::equals(token, SchemaSymbols::fgATTVAL_RESTRICTION)) { - - if ((finalSet & SchemaSymbols::XSD_RESTRICTION) == 0 ) { - finalSet += SchemaSymbols::XSD_RESTRICTION; - } - } - else { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidFinalValue, finalVal); - } - } //end while - - return finalSet; -} - - -const DOMElement* -TraverseSchema::checkIdentityConstraintContent(const DOMElement* const content) { - - const DOMElement* child = content; - - if (child != 0) { - - do { - - if (!isIdentityConstraintName(child->getLocalName())) { - break; - } - - child = XUtil::getNextSiblingElement(child); - - } while (child != 0); - } - - return child; -} - -bool TraverseSchema::isIdentityConstraintName(const XMLCh* const name) { - - return (XMLString::equals(name, SchemaSymbols::fgELT_KEY) - || XMLString::equals(name, SchemaSymbols::fgELT_KEYREF) - || XMLString::equals(name, SchemaSymbols::fgELT_UNIQUE)); -} - -const XMLCh* -TraverseSchema::checkTypeFromAnotherSchema(const DOMElement* const elem, - const XMLCh* const typeStr) { - - const XMLCh* prefix = getPrefix(typeStr); - const XMLCh* typeURI = resolvePrefixToURI(elem, prefix); - - if (!XMLString::equals(typeURI, fTargetNSURIString) - && !XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - ) { - return typeURI; - } - - return 0; -} - -DatatypeValidator* -TraverseSchema::getElementTypeValidator(const DOMElement* const elem, - const XMLCh* const typeStr, - bool& noErrorDetected, - const XMLCh* const otherSchemaURI) -{ - const XMLCh* localPart = getLocalPart(typeStr); - const XMLCh* typeURI = otherSchemaURI; - DatatypeValidator* dv = 0; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - SchemaInfo* saveInfo = fSchemaInfo; - unsigned int saveScope = fCurrentScope; - - if (otherSchemaURI && *otherSchemaURI) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(otherSchemaURI); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, otherSchemaURI); - return 0; - } - - dv = getDatatypeValidator(typeURI, localPart); - - if (dv) { - return dv; - } - - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(uriId); - - if (!impInfo || impInfo->getProcessed()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, typeURI, localPart); - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - else { - const XMLCh* prefix = getPrefix(typeStr); - - typeURI = resolvePrefixToURI(elem, prefix); - dv = getDatatypeValidator(typeURI, localPart); - } - - if (!dv) { - - if (!XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - || XMLString::equals(fTargetNSURIString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - - DOMElement* typeElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_SimpleType, - SchemaSymbols::fgELT_SIMPLETYPE, localPart, &fSchemaInfo); - - if (typeElem) { - traverseSimpleTypeDecl(typeElem); - dv = getDatatypeValidator(typeURI, localPart); - } - } - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - - if (!dv) { - - noErrorDetected = false; - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, typeURI, localPart); - } - } - - return dv; -} - - -DatatypeValidator* -TraverseSchema::getAttrDatatypeValidatorNS(const DOMElement* const elem, - const XMLCh* localPart, - const XMLCh* typeURI) -{ - DatatypeValidator* dv = getDatatypeValidator(typeURI, localPart); - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - SchemaInfo* saveInfo = fSchemaInfo; - unsigned int saveScope = fCurrentScope; - - if (!XMLString::equals(typeURI, fTargetNSURIString) - && (typeURI && *typeURI)) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(typeURI); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, typeURI); - return 0; - } - - if (!dv) { - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(uriId); - - if (!impInfo || impInfo->getProcessed()) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, typeURI, localPart); - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - } - - if (!dv) { - - DOMElement* typeElem = fSchemaInfo->getTopLevelComponent - ( - SchemaInfo::C_SimpleType - , SchemaSymbols::fgELT_SIMPLETYPE - , localPart - , &fSchemaInfo - ); - - if (typeElem) - dv = traverseSimpleTypeDecl(typeElem); - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - } - - return dv; -} - -ComplexTypeInfo* -TraverseSchema::getElementComplexTypeInfo(const DOMElement* const elem, - const XMLCh* const typeStr, - const XMLCh* const otherSchemaURI) -{ - const XMLCh* localPart = getLocalPart(typeStr); - const XMLCh* prefix = getPrefix(typeStr); - const XMLCh* typeURI = (otherSchemaURI) ? otherSchemaURI : resolvePrefixToURI(elem, prefix); - ComplexTypeInfo* typeInfo = 0; - SchemaInfo* saveInfo = fSchemaInfo; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - unsigned int saveScope = fCurrentScope; - - fBuffer.set(typeURI); - fBuffer.append(chComma); - fBuffer.append(localPart); - - if (otherSchemaURI != 0) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(typeURI); - - if (!isImportingNS(uriId)) - return 0; - - Grammar* aGrammar = fGrammarResolver->getGrammar(typeURI); - - if (!aGrammar || aGrammar->getGrammarType() != Grammar::SchemaGrammarType) { - return 0; - } - - typeInfo = ((SchemaGrammar*)aGrammar)->getComplexTypeRegistry()->get(fBuffer.getRawBuffer()); - - if (typeInfo) { - return typeInfo; - } - - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(uriId); - - if (!impInfo || impInfo->getProcessed()) { - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - else { - typeInfo = fComplexTypeRegistry->get(fBuffer.getRawBuffer()); - } - - if (!typeInfo) { - if (!XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) || - XMLString::equals(fTargetNSURIString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - - DOMElement* typeNode = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_ComplexType, - SchemaSymbols::fgELT_COMPLEXTYPE, localPart, &fSchemaInfo); - - if (typeNode) { - // fBuffer is reused by traverseComplexTypeDecl, so we have to store its current value - XMLBuffer buffCopy(fBuffer.getLen()+1, fMemoryManager); - buffCopy.set(fBuffer.getRawBuffer()); - traverseComplexTypeDecl(typeNode); - typeInfo = fComplexTypeRegistry->get(buffCopy.getRawBuffer()); - } - } - } - - // restore schema information - restoreSchemaInfo(saveInfo, infoType, saveScope); - return typeInfo; -} - - -SchemaElementDecl* -TraverseSchema::getGlobalElemDecl(const DOMElement* const elem, - const XMLCh* const qName) -{ - const XMLCh* nameURI = resolvePrefixToURI(elem, getPrefix(qName)); - const XMLCh* localPart = getLocalPart(qName); - SchemaElementDecl* elemDecl = 0; - SchemaInfo* saveInfo = fSchemaInfo; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - unsigned int saveScope = fCurrentScope; - unsigned int uriId = fURIStringPool->addOrFind(nameURI); - - if (fSchemaInfo->getTargetNSURI() != (int) uriId) - { - //if (!XMLString::equals(nameURI, fTargetNSURIString)) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - if (!isImportingNS(uriId)) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, nameURI); - return 0; - } - - Grammar* grammar = fGrammarResolver->getGrammar(nameURI); - - if (grammar && grammar->getGrammarType() == Grammar::SchemaGrammarType) - { - elemDecl = (SchemaElementDecl*) grammar->getElemDecl( - uriId, localPart, 0, Grammar::TOP_LEVEL_SCOPE); - } - else - { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, nameURI); - return 0; - } - - if (!elemDecl) - { - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(uriId); - if (!impInfo || impInfo->getProcessed()) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, nameURI, localPart); - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - } - else - { - elemDecl = (SchemaElementDecl*) - fSchemaGrammar->getElemDecl(fTargetNSURI, localPart, 0, Grammar::TOP_LEVEL_SCOPE); - } - - if (!elemDecl) - { - DOMElement* subsGroupElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Element, - SchemaSymbols::fgELT_ELEMENT,localPart, &fSchemaInfo); - - if (subsGroupElem) - elemDecl = traverseElementDecl(subsGroupElem, true); - - if (!elemDecl) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, nameURI, localPart); - } - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - - return elemDecl; -} - -bool -TraverseSchema::isSubstitutionGroupValid(const DOMElement* const elem, - const SchemaElementDecl* const subsElemDecl, - const ComplexTypeInfo* const typeInfo, - const DatatypeValidator* const validator, - const XMLCh* const elemName, - const bool toEmit) { - - // here we must do two things: - // 1. Make sure there actually *is* a relation between the types of - // the element being nominated and the element doing the nominating; - // (see PR 3.3.6 point #3 in the first tableau, for instance; this - // and the corresponding tableaux from 3.4.6 and 3.14.6 rule out the nominated - // element having an anonymous type declaration. - // 2. Make sure the nominated element allows itself to be nominated by - // an element with the given type-relation. - // Note: we assume that (complex|simple)Type processing checks - // whether the type in question allows itself to - // be modified as this element desires. - - // if substitution element has any as content model type, return true - bool subsRestricted = false; - if (subsElemDecl->getModelType() == SchemaElementDecl::Any) { - - if ((subsElemDecl->getFinalSet() & SchemaSymbols::XSD_RESTRICTION) == 0 - || (typeInfo == 0 && validator == 0)) - return true; - else - subsRestricted = true; - } - // Check for type relationship; - // that is, make sure that the type we're deriving has some relatoinship - // to substitutionGroupElt's type. - else if (typeInfo) { // do complexType case ...need testing - - ComplexTypeInfo* subsTypeInfo = subsElemDecl->getComplexTypeInfo(); - - if (subsTypeInfo == typeInfo) - return true; - - int derivationMethod = typeInfo->getDerivedBy(); - - if (subsTypeInfo == 0) { // take care of complexType based on simpleType case... - - DatatypeValidator* elemDV = typeInfo->getDatatypeValidator(); - DatatypeValidator* subsValidator = subsElemDecl->getDatatypeValidator(); - - if (elemDV == subsValidator) { - return true; - } - else if (subsValidator && subsValidator->isSubstitutableBy(elemDV)) { - if ((subsElemDecl->getFinalSet() & derivationMethod) == 0) { - return true; - } - else { - subsRestricted = true; - } - } - } - else { // complex content - - const ComplexTypeInfo* elemTypeInfo = typeInfo; - - for (; elemTypeInfo && elemTypeInfo != subsTypeInfo; - elemTypeInfo = elemTypeInfo->getBaseComplexTypeInfo()) { - } - - if (elemTypeInfo) { - if ((subsElemDecl->getFinalSet() & derivationMethod) == 0) { - return true; - } - else { - subsRestricted = true; - } - } - } - } - else if (validator) { // do simpleType case... - - if (!subsElemDecl->getComplexTypeInfo()) { - // first, check for type relation. - DatatypeValidator* subsValidator = subsElemDecl->getDatatypeValidator(); - - if (subsValidator == validator) { - return true; - } - else if (subsValidator && subsValidator->isSubstitutableBy(validator) - && ((subsElemDecl->getFinalSet() & SchemaSymbols::XSD_RESTRICTION) == 0)) { - return true; - } - } - } - else // validator==0 && typeInfo==0 -- no checking - return true; - - if (toEmit) { - if (subsRestricted) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidSubstitutionGroupElement, - elemName, subsElemDecl->getBaseName()); - } - else { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SubstitutionGroupTypeMismatch, elemName); - } - } - - return false; -} - - -SchemaElementDecl* -TraverseSchema::createSchemaElementDecl(const DOMElement* const elem, - const XMLCh* const name, - bool& isDuplicate, - const XMLCh*& valConstraint, - const bool topLevel) -{ - unsigned int enclosingScope = fCurrentScope; - int uriIndex = fEmptyNamespaceURI; - - if (topLevel) { - - uriIndex = fTargetNSURI; - enclosingScope = Grammar::TOP_LEVEL_SCOPE; - } - else - { - const XMLCh* elemForm = getElementAttValue(elem, SchemaSymbols::fgATT_FORM); - - if (((!elemForm || !*elemForm) && - (fSchemaInfo->getElemAttrDefaultQualified() & Elem_Def_Qualified)) - || XMLString::equals(elemForm,SchemaSymbols::fgATTVAL_QUALIFIED)) - uriIndex = fTargetNSURI; - - // Check for duplicate elements - SchemaElementDecl* other = (SchemaElementDecl*) - fSchemaGrammar->getElemDecl(uriIndex, name, 0, enclosingScope); - - if (other != 0) - { - isDuplicate = true; - return other; - } - } - - // create element decl and add it to the grammar - Janitor<SchemaElementDecl> elemDecl(new (fGrammarPoolMemoryManager) SchemaElementDecl( - XMLUni::fgZeroLenString , name, uriIndex , SchemaElementDecl::Any - , enclosingScope , fGrammarPoolMemoryManager - )); - - elemDecl->setCreateReason(XMLElementDecl::Declared); - - if (topLevel) - elemDecl->setPSVIScope(PSVIDefs::SCP_GLOBAL); - - // process attributes - processElemDeclAttrs(elem, elemDecl.get(), valConstraint, topLevel); - - return elemDecl.release(); -} - - -void TraverseSchema::processAttributeDeclRef(const DOMElement* const elem, - ComplexTypeInfo* const typeInfo, - const XMLCh* const refName, - const XMLCh* const useAttr, - const XMLCh* const defaultVal, - const XMLCh* const fixedVal) { - - if (!typeInfo && !fCurrentAttGroupInfo) { - return; - } - - const XMLCh* prefix = getPrefix(refName); - const XMLCh* localPart = getLocalPart(refName); - const XMLCh* uriStr = resolvePrefixToURI(elem, prefix); - unsigned int attURI = fURIStringPool->addOrFind(uriStr); - - // Check for duplicate references - if (typeInfo && typeInfo->getAttDef(localPart, attURI)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateRefAttribute, uriStr, localPart); - return; - } - else if (fCurrentAttGroupInfo && fCurrentAttGroupInfo->containsAttribute(localPart, attURI)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateRefAttribute, uriStr, localPart); - return; - } - - // check for different namespace - SchemaInfo* saveInfo = fSchemaInfo; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - SchemaAttDef* refAttDef = 0; - unsigned int saveScope = fCurrentScope; - - if (!XMLString::equals(uriStr, fTargetNSURIString)) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, uriStr); - return; - } - - Grammar* grammar = fGrammarResolver->getGrammar(uriStr); - - if (grammar == 0 || grammar->getGrammarType() != Grammar::SchemaGrammarType) { - - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr); - return; - } - - refAttDef = (SchemaAttDef*) ((SchemaGrammar*) grammar)->getAttributeDeclRegistry()->get(localPart); - - if (!refAttDef) { - - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(attURI); - - if (!impInfo || impInfo->getProcessed()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelAttributeNotFound, refName); - return; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - } - - // if Global attribute registry does not contain the ref attribute, get - // the referred attribute declaration and traverse it. - if (!refAttDef) { - - if (fAttributeDeclRegistry->containsKey(localPart) == false) { - - DOMElement* referredAttribute = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Attribute, - SchemaSymbols::fgELT_ATTRIBUTE, localPart, &fSchemaInfo); - - if (referredAttribute != 0) { - traverseAttributeDecl(referredAttribute, 0, true); - } - } - - refAttDef = (SchemaAttDef*) fAttributeDeclRegistry->get(localPart); - } - - // restore schema information, if necessary - if (fSchemaInfo != saveInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - - if (!refAttDef) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelAttributeNotFound, refName); - return; - } - - XMLAttDef::DefAttTypes refAttDefType = refAttDef->getDefaultType(); - const XMLCh* refAttValue = refAttDef->getValue(); - bool invalidAttUse = false; - - if (refAttDefType == XMLAttDef::Fixed && - (defaultVal || (fixedVal && !XMLString::equals(fixedVal, refAttValue)))) { - - invalidAttUse = true; - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttUseCorrect, refName); - } - - DatatypeValidator* attDV = refAttDef->getDatatypeValidator(); - - //check for multiple attributes with type derived from ID - if (attDV && attDV->getType() == DatatypeValidator::ID) { - - if (fCurrentAttGroupInfo) { - - if (fCurrentAttGroupInfo->containsTypeWithId()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttGrpPropCorrect3, refName); - return; - } - - fCurrentAttGroupInfo->setTypeWithId(true); - } - else { - - if (typeInfo->containsAttWithTypeId()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect5, refName); - return; - } - - typeInfo->setAttWithTypeId(true); - } - } - - bool required = XMLString::equals(useAttr,SchemaSymbols::fgATTVAL_REQUIRED); - bool prohibited = XMLString::equals(useAttr,SchemaSymbols::fgATTVAL_PROHIBITED); - QName* attQName = refAttDef->getAttName(); - SchemaAttDef* attDef = new (fGrammarPoolMemoryManager) SchemaAttDef(attQName->getPrefix(), - attQName->getLocalPart(), - attQName->getURI(), - refAttValue, - refAttDef->getType(), - refAttDefType, - 0, fGrammarPoolMemoryManager); - - attDef->setBaseAttDecl(refAttDef); - attDef->setPSVIScope(PSVIDefs::SCP_GLOBAL); - - if (refAttDefType == XMLAttDef::Fixed) { - if (required && !invalidAttUse) { - attDef->setDefaultType(XMLAttDef::Required_And_Fixed); - } - } - else { - - if (prohibited) { - attDef->setDefaultType(XMLAttDef::Prohibited); - } - else { - - const XMLCh* valueConstraint = defaultVal; - - if (required){ - - if (fixedVal) { - - attDef->setDefaultType(XMLAttDef::Required_And_Fixed); - valueConstraint = fixedVal; - } - else { - attDef->setDefaultType(XMLAttDef::Required); - } - } - else - { - if (fixedVal) { - attDef->setDefaultType(XMLAttDef::Fixed); - valueConstraint = fixedVal; - } - else if (defaultVal) { - attDef->setDefaultType(XMLAttDef::Default); - } - } - - if (valueConstraint) { - - // validate content of value constraint - if (attDV) { - - if (attDV->getType() == DatatypeValidator::ID) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect3, refName); - } - else { - try { - attDV->validate(valueConstraint - , fSchemaInfo->getValidationContext() - , fMemoryManager); - } - catch(const XMLException& excep) { - reportSchemaError(elem, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch (...) { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::DatatypeValidationFailure, valueConstraint); - } - } - } - - attDef->setValue(valueConstraint); - } - } - } - - attDef->setDatatypeValidator(attDV); - - bool toClone = false; - - if (typeInfo) { - - toClone = true; - typeInfo->addAttDef(attDef); - } - - if (fCurrentAttGroupInfo) { - fCurrentAttGroupInfo->addAttDef(attDef, toClone); - } -} - - -int TraverseSchema::checkMinMax(ContentSpecNode* const specNode, - const DOMElement* const elem, - const int allContextFlag) { - - int minOccurs = 1; - int maxOccurs = 1; - const XMLCh* minOccursStr = getElementAttValue(elem, SchemaSymbols::fgATT_MINOCCURS, DatatypeValidator::Decimal); - const XMLCh* maxOccursStr = getElementAttValue(elem, SchemaSymbols::fgATT_MAXOCCURS, DatatypeValidator::Decimal); - - if (!minOccursStr || !*minOccursStr) { - if (specNode) - minOccurs = specNode->getMinOccurs(); - } - else { - try { - minOccurs = XMLString::parseInt(minOccursStr, fMemoryManager); - } - catch(const NumberFormatException& e) - { - // REVISIT: report a warning that we replaced a number too big? - if(e.getCode()==XMLExcepts::Str_ConvertOverflow) - minOccurs = 500; - else - minOccurs = 1; - } - catch(const OutOfMemoryException&) - { - throw; - } - - if (specNode) - specNode->setMinOccurs(minOccurs); - } - - bool isMaxUnbounded = XMLString::equals(maxOccursStr, fgUnbounded); - - if (isMaxUnbounded) { - maxOccurs = SchemaSymbols::XSD_UNBOUNDED; - if (specNode) - specNode->setMaxOccurs(maxOccurs); - } - else { - if (!maxOccursStr || !*maxOccursStr) { - if (specNode) - maxOccurs = specNode->getMaxOccurs(); - } - else { - try { - maxOccurs = XMLString::parseInt(maxOccursStr, fMemoryManager); - } - catch(const NumberFormatException& e) - { - // REVISIT: report a warning that we replaced a number too big? - if(e.getCode()==XMLExcepts::Str_ConvertOverflow && minOccurs < 500) - maxOccurs = 500; - else - maxOccurs = minOccurs; - } - catch(const OutOfMemoryException&) - { - throw; - } - - if (specNode) - specNode->setMaxOccurs(maxOccurs); - } - } - - if (minOccurs == 0 && maxOccurs == 0){ - return minOccurs; - } - - // Constraint checking for min/max value - if (!isMaxUnbounded) { - - XMLCh tmpMinStr[128]; - XMLCh tmpMaxStr[128]; - - XMLString::binToText(minOccurs, tmpMinStr, 127, 10, fMemoryManager); - XMLString::binToText(maxOccurs, tmpMaxStr, 127, 10, fMemoryManager); - - if (maxOccurs < 1) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttValue, - tmpMaxStr, SchemaSymbols::fgATT_MAXOCCURS); - if (specNode) - specNode->setMaxOccurs(minOccurs); - } - else if (maxOccurs < minOccurs) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidMin2MaxOccurs, - tmpMinStr, tmpMaxStr); - if (specNode) - specNode->setMaxOccurs(minOccurs); - } - } - - // Constraint checking for 'all' content - bool isAllElement = (allContextFlag == All_Element); - bool isAllGroup = (allContextFlag == All_Group); - bool isGroupRefAll = (allContextFlag == Group_Ref_With_All); - - if (isAllElement || isAllGroup || isGroupRefAll) { - - if (maxOccurs != 1 || minOccurs > 1) { - - // set back correct value in order to carry on - if (specNode) { - - specNode->setMaxOccurs(1); - - if (minOccurs > 1) - specNode->setMinOccurs(1); - } - - if (isAllElement) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadMinMaxAllElem); - } - else { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadMinMaxAllCT); - } - } - } - return minOccurs; -} - - -void TraverseSchema::processComplexContent(const DOMElement* const ctElem, - const XMLCh* const typeName, - const DOMElement* const childElem, - ComplexTypeInfo* const typeInfo, - const XMLCh* const baseLocalPart, - const bool isMixed, - const bool isBaseAnyType) { - - NamespaceScopeManager nsMgr(childElem, fSchemaInfo, this); - - Janitor<ContentSpecNode> specNodeJan(0); - ContentSpecNode* specNode = specNodeJan.get(); - const DOMElement* attrNode = 0; - int typeDerivedBy = typeInfo->getDerivedBy(); - ComplexTypeInfo* baseTypeInfo = typeInfo->getBaseComplexTypeInfo(); - int baseContentType = (baseTypeInfo) ? baseTypeInfo->getContentType() : SchemaElementDecl::Empty; - - if (baseTypeInfo) { - - if (typeDerivedBy == SchemaSymbols::XSD_RESTRICTION) { - - // check to see if the baseType permits derivation by restriction - if((baseTypeInfo->getFinalSet() & typeDerivedBy) != 0) { - - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::ForbiddenDerivationByRestriction, - baseLocalPart); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - else { - - // check to see if the baseType permits derivation by extension - if((baseTypeInfo->getFinalSet() & typeDerivedBy) != 0) { - - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::ForbiddenDerivationByExtension, baseLocalPart); - throw TraverseSchema::InvalidComplexTypeInfo; // REVISIT - should we continue - } - - processElements(ctElem, baseTypeInfo, typeInfo); - } - } - - bool effectiveContent_hasChild = false; - - if (childElem != 0) { - - fCircularCheckIndex = fCurrentTypeNameStack->size(); - - // -------------------------------------------------------------------- - // GROUP, ALL, SEQUENCE or CHOICE, followed by attributes, if specified. - // Note that it's possible that only attributes are specified. - // -------------------------------------------------------------------- - const XMLCh* childName = childElem->getLocalName(); - - if (XMLString::equals(childName, SchemaSymbols::fgELT_GROUP)) { - - XercesGroupInfo* grpInfo = traverseGroupDecl(childElem, false); - - if (grpInfo) { - - ContentSpecNode* const groupSpecNode = grpInfo->getContentSpec(); - - if (groupSpecNode) { - - int contentContext = groupSpecNode->hasAllContent() ? Group_Ref_With_All : Not_All_Context; - specNodeJan.reset(new (fGrammarPoolMemoryManager) ContentSpecNode(*groupSpecNode)); - specNode = specNodeJan.get(); - checkMinMax(specNode, childElem, contentContext); - } - } - - attrNode = XUtil::getNextSiblingElement(childElem); - - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE)) { - - specNodeJan.reset(traverseChoiceSequence(childElem, ContentSpecNode::Sequence, effectiveContent_hasChild)); - specNode = specNodeJan.get(); - checkMinMax(specNode, childElem); - attrNode = XUtil::getNextSiblingElement(childElem); - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE)) { - - specNodeJan.reset(traverseChoiceSequence(childElem, ContentSpecNode::Choice, effectiveContent_hasChild)); - specNode = specNodeJan.get(); - int minOccurs = checkMinMax(specNode, childElem); - if (!effectiveContent_hasChild && minOccurs != 0) { - effectiveContent_hasChild = true; - } - - attrNode = XUtil::getNextSiblingElement(childElem); - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_ALL)) { - - specNodeJan.reset(traverseAll(childElem, effectiveContent_hasChild)); - specNode = specNodeJan.get(); - checkMinMax(specNode, childElem, All_Group); - attrNode = XUtil::getNextSiblingElement(childElem); - } - else if (isAttrOrAttrGroup(childElem)) { - // reset the contentType - typeInfo->setContentType(SchemaElementDecl::Any); - attrNode = childElem; - } - else { - reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildInComplexType, childName); - } - } - - typeInfo->setContentSpec(specNode); - typeInfo->setAdoptContentSpec(true); - specNodeJan.release(); - bool specNodeWasNull = false; - - // ----------------------------------------------------------------------- - // Merge in information from base, if it exists - // ----------------------------------------------------------------------- - if (baseTypeInfo) { - - ContentSpecNode* baseSpecNode = baseTypeInfo->getContentSpec(); - - if (typeDerivedBy == SchemaSymbols::XSD_RESTRICTION) { - - //check derivation valid - content type is empty (5.2) - if (!typeInfo->getContentSpec()) { - - if (baseContentType != SchemaElementDecl::Empty - && !emptiableParticle(baseSpecNode)) { - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::EmptyComplexRestrictionDerivation); - } - } - - // Delay particle constraint checking (5.3) until we have processed - // the whole schema. - } - else { - - // Compose the final content model by concatenating the base and - // the current in sequence - if (!specNode) { - specNodeWasNull = true; - if (isMixed) { - if (baseSpecNode && baseSpecNode->hasAllContent()) { - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::NotAllContent); - throw TraverseSchema::InvalidComplexTypeInfo; // REVISIT - should we continue - } - } - if (baseSpecNode) { - specNodeJan.reset(new (fGrammarPoolMemoryManager) ContentSpecNode(*baseSpecNode)); - specNode = specNodeJan.get(); - typeInfo->setContentSpec(specNode); - typeInfo->setAdoptContentSpec(true); - specNodeJan.release(); - } - } - else if (baseSpecNode) { - - if (specNode->hasAllContent() || baseSpecNode->hasAllContent()) { - - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::NotAllContent); - throw TraverseSchema::InvalidComplexTypeInfo; // REVISIT - should we continue - } - - // Check for derivation valid (extension) - 1.4.3.2.2.1 - if ((isMixed && baseContentType == SchemaElementDecl::Children) - || (!isMixed && baseContentType != SchemaElementDecl::Children)) { - - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::MixedOrElementOnly, baseLocalPart, typeName); - throw TraverseSchema::InvalidComplexTypeInfo; //REVISIT - should we continue - } - - typeInfo->setAdoptContentSpec(false); - typeInfo->setContentSpec - ( - new (fGrammarPoolMemoryManager) ContentSpecNode - ( - ContentSpecNode::ModelGroupSequence - , new (fGrammarPoolMemoryManager) ContentSpecNode(*baseSpecNode) - , specNode - , true - , true - , fGrammarPoolMemoryManager - ) - ); - typeInfo->setAdoptContentSpec(true); - } - } - } - else { - typeInfo->setDerivedBy(0); - } - - // ------------------------------------------------------------- - // Set the content type - // ------------------------------------------------------------- - if (isBaseAnyType && typeDerivedBy == SchemaSymbols::XSD_EXTENSION) { - - ContentSpecNode* anySpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - new (fGrammarPoolMemoryManager) QName - ( - XMLUni::fgZeroLenString - , XMLUni::fgZeroLenString - , fEmptyNamespaceURI, fGrammarPoolMemoryManager - ) - , false - , fGrammarPoolMemoryManager - ); - - anySpecNode->setType(ContentSpecNode::Any_Lax); - anySpecNode->setMinOccurs(0); - anySpecNode->setMaxOccurs(SchemaSymbols::XSD_UNBOUNDED); - - if (!specNode) { - typeInfo->setContentSpec(anySpecNode); - typeInfo->setDerivedBy(typeDerivedBy); - } - else { - - typeInfo->setAdoptContentSpec(false); - typeInfo->setContentSpec - ( - new (fGrammarPoolMemoryManager) ContentSpecNode - ( - ContentSpecNode::ModelGroupSequence - , anySpecNode - , specNode - , true - , true - , fGrammarPoolMemoryManager - ) - ); - typeInfo->setAdoptContentSpec(true); - - if (!isMixed) { - - reportSchemaError(ctElem, XMLUni::fgXMLErrDomain, XMLErrs::MixedOrElementOnly, baseLocalPart, typeName); - throw TraverseSchema::InvalidComplexTypeInfo; //REVISIT - should we continue - } - } - - typeInfo->setContentType(SchemaElementDecl::Mixed_Complex); - } - else if (isMixed) { - - if (specNode != 0) { - typeInfo->setContentType(SchemaElementDecl::Mixed_Complex); - } - else { - // add #PCDATA leaf and set its minOccurs to 0 - ContentSpecNode* pcdataNode = new (fGrammarPoolMemoryManager) ContentSpecNode - ( - new (fGrammarPoolMemoryManager) QName - ( - XMLUni::fgZeroLenString - , XMLUni::fgZeroLenString - , XMLElementDecl::fgPCDataElemId - , fGrammarPoolMemoryManager - ) - , false - , fGrammarPoolMemoryManager - ); - - pcdataNode->setMinOccurs(0); - typeInfo->setContentSpec(pcdataNode); - typeInfo->setAdoptContentSpec(true); - typeInfo->setContentType(SchemaElementDecl::Mixed_Simple); - } - } - else if (specNodeWasNull && - (typeDerivedBy == SchemaSymbols::XSD_EXTENSION) && - baseTypeInfo) { - typeInfo->setBaseDatatypeValidator(baseTypeInfo->getBaseDatatypeValidator()); - typeInfo->setDatatypeValidator(baseTypeInfo->getDatatypeValidator()); - typeInfo->setContentType(baseTypeInfo->getContentType()); - } - else if (typeInfo->getContentSpec() == 0) { - if (!effectiveContent_hasChild) { - typeInfo->setContentType(SchemaElementDecl::Empty); - } - else { - typeInfo->setContentType(SchemaElementDecl::ElementOnlyEmpty); - } - } - else { - typeInfo->setContentType(SchemaElementDecl::Children); - } - - // ------------------------------------------------------------- - // Now, check attributes and handle - // ------------------------------------------------------------- - if (attrNode != 0) { - - if (!isAttrOrAttrGroup(attrNode)) { - reportSchemaError(attrNode, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildInComplexType, - attrNode->getLocalName()); - } - else { - processAttributes(ctElem, attrNode, typeInfo, isBaseAnyType); - } - } - else if (baseTypeInfo != 0 || isBaseAnyType) { - processAttributes(ctElem, 0, typeInfo, isBaseAnyType); - } -} - - -void TraverseSchema::processBaseTypeInfo(const DOMElement* const elem, - const XMLCh* const baseName, - const XMLCh* const localPart, - const XMLCh* const uriStr, - ComplexTypeInfo* const typeInfo) { - - SchemaInfo* saveInfo = fSchemaInfo; - ComplexTypeInfo* baseComplexTypeInfo = 0; - DatatypeValidator* baseDTValidator = 0; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - unsigned int saveScope = fCurrentScope; - - // check if the base type is from another schema - if (!XMLString::equals(uriStr, fTargetNSURIString)) { - - // check for datatype validator if it's schema for schema URI - if (XMLString::equals(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - - baseDTValidator = getDatatypeValidator(uriStr, localPart); - - if (!baseDTValidator) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BaseTypeNotFound, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - else { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, uriStr); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - baseComplexTypeInfo = getTypeInfoFromNS(elem, uriStr, localPart); - - if (!baseComplexTypeInfo) { - - baseDTValidator = getDatatypeValidator(uriStr, localPart); - - if (!baseDTValidator) - { - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(fURIStringPool->addOrFind(uriStr)); - - if (!impInfo || impInfo->getProcessed()) - { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BaseTypeNotFound, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - } - } - } - else { - - fBuffer.set(uriStr); - fBuffer.append(chComma); - fBuffer.append(localPart); - - // assume the base is a complexType and try to locate the base type first - const XMLCh* fullBaseName = fBuffer.getRawBuffer(); - baseComplexTypeInfo = fComplexTypeRegistry->get(fullBaseName); - - // Circular check - if (baseComplexTypeInfo) { - - if (fCurrentTypeNameStack->containsElement(fStringPool->addOrFind(fullBaseName), fCircularCheckIndex)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, fullBaseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - else if (fCurrentTypeNameStack->containsElement(fStringPool->addOrFind(fullBaseName))) { - - typeInfo->setBaseComplexTypeInfo(baseComplexTypeInfo); - throw TraverseSchema::RecursingElement; - } - else if (baseComplexTypeInfo->getPreprocessed()) { - baseComplexTypeInfo = 0; - } - } - } - - // if not found, 2 possibilities: - // 1: ComplexType in question has not been compiled yet; - // 2: base is SimpleType; - if (!baseComplexTypeInfo && !baseDTValidator) { - - baseDTValidator = getDatatypeValidator(uriStr, localPart); - - if (baseDTValidator == 0) { - - DOMElement* baseTypeNode = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_ComplexType, - SchemaSymbols::fgELT_COMPLEXTYPE, localPart, &fSchemaInfo); - - if (baseTypeNode != 0) { - - int baseTypeSymbol = traverseComplexTypeDecl(baseTypeNode); - baseComplexTypeInfo = fComplexTypeRegistry->get(fStringPool->getValueForId(baseTypeSymbol)); - } - else { - - baseTypeNode = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_SimpleType, - SchemaSymbols::fgELT_SIMPLETYPE, localPart, &fSchemaInfo); - - if (baseTypeNode != 0) { - - baseDTValidator = traverseSimpleTypeDecl(baseTypeNode); - - if (baseDTValidator == 0) { - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TypeNotFound, uriStr, localPart, uriStr); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - else { - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BaseTypeNotFound, baseName); - throw TraverseSchema::InvalidComplexTypeInfo; - } - } - } - } // end if - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - - typeInfo->setBaseComplexTypeInfo(baseComplexTypeInfo); - typeInfo->setBaseDatatypeValidator(baseDTValidator); -} - - -ComplexTypeInfo* TraverseSchema::getTypeInfoFromNS(const DOMElement* const elem, - const XMLCh* const uriStr, - const XMLCh* const localPart) -{ - - Grammar* grammar = fGrammarResolver->getGrammar(uriStr); - - if (grammar != 0 && grammar->getGrammarType() == Grammar::SchemaGrammarType) { - - fBuffer.set(uriStr); - fBuffer.append(chComma); - fBuffer.append(localPart); - - ComplexTypeInfo* typeInfo = - ((SchemaGrammar*)grammar)->getComplexTypeRegistry()->get(fBuffer.getRawBuffer()); - - return typeInfo; - } - else { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr); - } - - return 0; -} - - -void TraverseSchema::processAttributes(const DOMElement* const elem, - const DOMElement* const attElem, - ComplexTypeInfo* const typeInfo, - const bool isBaseAnyType) { - - // If we do not have a complexTypeInfo, then what is the point of - // processing. - if (typeInfo == 0) { - return; - } - - ComplexTypeInfo* baseTypeInfo = typeInfo->getBaseComplexTypeInfo(); - if (baseTypeInfo && baseTypeInfo->getPreprocessed()) - throw TraverseSchema::RecursingElement; - - const DOMElement* child = attElem; - SchemaAttDef* attWildCard = 0; - Janitor<SchemaAttDef> janAttWildCard(0); - XercesAttGroupInfo* attGroupInfo = 0; - ValueVectorOf<XercesAttGroupInfo*> attGroupList(4, fGrammarPoolMemoryManager); - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* childName = child->getLocalName(); - - if (XMLString::equals(childName, SchemaSymbols::fgELT_ATTRIBUTE)) { - if(attWildCard) - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AnyAttributeBeforeAttribute); - - traverseAttributeDecl(child, typeInfo); - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_ATTRIBUTEGROUP)) { - if(attWildCard) - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AnyAttributeBeforeAttribute); - - attGroupInfo = traverseAttributeGroupDecl(child, typeInfo); - if (attGroupInfo && !attGroupList.containsElement(attGroupInfo)) { - attGroupList.addElement(attGroupInfo); - } - } - else if (XMLString::equals(childName, SchemaSymbols::fgELT_ANYATTRIBUTE) ) { - if(attWildCard) - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAnyAttribute); - - attWildCard = traverseAnyAttribute(child); - janAttWildCard.reset(attWildCard); - } - else { - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildInComplexType, childName); - } - } - - // ------------------------------------------------------------- - // Handle wild card/any attribute - // ------------------------------------------------------------- - int derivedBy = typeInfo->getDerivedBy(); - XMLSize_t attGroupListSize = attGroupList.size(); - - if (attGroupListSize) { - - SchemaAttDef* completeWildCard = 0; - Janitor<SchemaAttDef> janCompleteWildCard(0); - XMLAttDef::DefAttTypes defAttType = XMLAttDef::Default; - bool defAttTypeSet = false; - - for (XMLSize_t i=0; i < attGroupListSize; i++) { - - attGroupInfo = attGroupList.elementAt(i); - XMLSize_t anyAttCount = attGroupInfo->anyAttributeCount(); - - if (anyAttCount) { - - if (!defAttTypeSet) { - - defAttType = (attWildCard) ? attWildCard->getDefaultType() - : attGroupInfo->anyAttributeAt(0)->getDefaultType(); - defAttTypeSet = true; - } - - SchemaAttDef* attGroupWildCard = attGroupInfo->getCompleteWildCard(); - if (completeWildCard) { - attWildCardIntersection(completeWildCard, attGroupWildCard); - } - else { - completeWildCard = new (fGrammarPoolMemoryManager) SchemaAttDef(attGroupWildCard); - janCompleteWildCard.reset(completeWildCard); - } - } - - } - - if (completeWildCard) { - - if (attWildCard) { - attWildCardIntersection(attWildCard, completeWildCard); - } - else { - - attWildCard = completeWildCard; - janCompleteWildCard.orphan(); - janAttWildCard.reset(attWildCard); - } - - attWildCard->setDefaultType(defAttType); - } - } - - SchemaAttDef* baseAttWildCard = (baseTypeInfo) ? baseTypeInfo->getAttWildCard() : 0; - Janitor<SchemaAttDef> janBaseAttWildCard(0); - - if (derivedBy == SchemaSymbols::XSD_EXTENSION) { - - if (isBaseAnyType) { - - baseAttWildCard = new (fGrammarPoolMemoryManager) SchemaAttDef(XMLUni::fgZeroLenString, - XMLUni::fgZeroLenString, - fEmptyNamespaceURI, XMLAttDef::Any_Any, - XMLAttDef::ProcessContents_Lax, - fGrammarPoolMemoryManager); - janBaseAttWildCard.reset(baseAttWildCard); - } - - if (baseAttWildCard && attWildCard) { - - XMLAttDef::DefAttTypes saveDefType = attWildCard->getDefaultType(); - attWildCardUnion(attWildCard, baseAttWildCard); - attWildCard->setDefaultType(saveDefType); - } - } - - // ------------------------------------------------------------- - // insert wildcard attribute - // ------------------------------------------------------------- - if (attWildCard) { - - typeInfo->setAttWildCard(attWildCard); - janAttWildCard.orphan(); - - if (attWildCard->getType() == XMLAttDef::AttTypes_Unknown) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NotExpressibleWildCardIntersection); - } - } - else if (baseAttWildCard && derivedBy == SchemaSymbols::XSD_EXTENSION) { - - if (isBaseAnyType) { - - typeInfo->setAttWildCard(baseAttWildCard); - janBaseAttWildCard.orphan(); - } - else { - - SchemaAttDef* newWildCard = new (fGrammarPoolMemoryManager) SchemaAttDef(baseAttWildCard); - typeInfo->setAttWildCard(newWildCard); - } - } - - // ------------------------------------------------------------- - // Check attributes derivation OK - // ------------------------------------------------------------- - bool baseWithAttributes = (baseTypeInfo && baseTypeInfo->hasAttDefs()); - bool childWithAttributes = (typeInfo->hasAttDefs() || typeInfo->getAttWildCard()); - - if (derivedBy == SchemaSymbols::XSD_RESTRICTION && childWithAttributes) { - - if (!baseWithAttributes && !baseAttWildCard) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_1); - } - else { - checkAttDerivationOK(elem, baseTypeInfo, typeInfo); - } - } - - // ------------------------------------------------------------- - // merge in base type's attribute decls - // ------------------------------------------------------------- - if (baseTypeInfo && baseTypeInfo->hasAttDefs()) { - - SchemaAttDefList& baseAttList = (SchemaAttDefList&) - baseTypeInfo->getAttDefList(); - - for (XMLSize_t i=0; i<baseAttList.getAttDefCount(); i++) { - - SchemaAttDef& attDef = (SchemaAttDef&) baseAttList.getAttDef(i); - QName* attName = attDef.getAttName(); - const XMLCh* localPart = attName->getLocalPart(); - - // if found a duplicate, then skip the one from the base type - if (typeInfo->getAttDef(localPart, attName->getURI()) != 0) { - - if (derivedBy == SchemaSymbols::XSD_EXTENSION) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttInDerivation, localPart); - } - - continue; - } - - if (attDef.getDefaultType() != XMLAttDef::Prohibited) { - - SchemaAttDef* newAttDef = new (fGrammarPoolMemoryManager) SchemaAttDef(attName->getPrefix(), - attName->getLocalPart(), - attName->getURI(), - attDef.getValue(), - attDef.getType(), - attDef.getDefaultType(), - attDef.getEnumeration(), - fGrammarPoolMemoryManager); - - newAttDef->setDatatypeValidator(attDef.getDatatypeValidator()); - typeInfo->addAttDef(newAttDef); - - if (attDef.getBaseAttDecl()) - newAttDef->setBaseAttDecl(attDef.getBaseAttDecl()); - else - newAttDef->setBaseAttDecl(&attDef); - } - } - } -} - - -void TraverseSchema::defaultComplexTypeInfo(ComplexTypeInfo* const typeInfo) { - - if (typeInfo) { - - typeInfo->setDerivedBy(0); - typeInfo->setContentType(SchemaElementDecl::Any); - typeInfo->setDatatypeValidator(0); - typeInfo->setContentSpec(0); - typeInfo->setBaseComplexTypeInfo(0); - typeInfo->setBaseDatatypeValidator(0); - } -} - - -InputSource* TraverseSchema::resolveSchemaLocation(const XMLCh* const loc, - const XMLResourceIdentifier::ResourceIdentifierType resourceIdentitiferType, - const XMLCh* const nameSpace) { - - // ------------------------------------------------------------------ - // Create an input source - // ------------------------------------------------------------------ - InputSource* srcToFill = 0; - XMLCh* normalizedURI = 0; - if (loc) { - XMLString::removeChar(loc, 0xFFFF, fBuffer); - normalizedURI = fBuffer.getRawBuffer(); - } - - if (fEntityHandler){ - XMLResourceIdentifier resourceIdentifier(resourceIdentitiferType, - normalizedURI, nameSpace, 0, fSchemaInfo->getCurrentSchemaURL(), fLocator); - srcToFill = fEntityHandler->resolveEntity(&resourceIdentifier); - } - - // If they didn't create a source via the entity resolver, then we - // have to create one on our own if we have the schemaLocation (with - // the update resolveEntity accepting nameSpace, a schemImport could - // pass a null schemaLocation) - if (!srcToFill && loc) { - if (fScanner->getDisableDefaultEntityResolution()) - return 0; - - XMLURL urlTmp(fMemoryManager); - if ((!urlTmp.setURL(fSchemaInfo->getCurrentSchemaURL(), normalizedURI, urlTmp)) || - (urlTmp.isRelative())) - { - if (!fScanner->getStandardUriConformant()) - { - XMLCh* tempURI = XMLString::replicate(normalizedURI, fMemoryManager); - ArrayJanitor<XMLCh> tempURIName(tempURI, fMemoryManager); - XMLUri::normalizeURI(tempURI, fBuffer); - - srcToFill = new (fMemoryManager) LocalFileInputSource - ( fSchemaInfo->getCurrentSchemaURL() - , fBuffer.getRawBuffer() - , fMemoryManager - ); - } - else - ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager); - } - else - { - if (fScanner->getStandardUriConformant() && urlTmp.hasInvalidChar()) - ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager); - srcToFill = new (fMemoryManager) URLInputSource(urlTmp, fMemoryManager); - } - } - - return srcToFill; -} - - -void TraverseSchema::restoreSchemaInfo(SchemaInfo* const toRestore, - SchemaInfo::ListType const aListType, - const unsigned int saveScope) { - - - if (aListType == SchemaInfo::IMPORT) { // restore grammar info - - int targetNSURI = toRestore->getTargetNSURI(); - - fSchemaGrammar->setScopeCount (fScopeCount); - fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount); - - fSchemaGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(toRestore->getTargetNSURIString()); - fScopeCount = fSchemaGrammar->getScopeCount (); - fAnonXSTypeCount = fSchemaGrammar->getAnonTypeCount (); - - fTargetNSURI = targetNSURI; - fCurrentScope = saveScope; - fDatatypeRegistry = fSchemaGrammar->getDatatypeRegistry(); - fTargetNSURIString = fSchemaGrammar->getTargetNamespace(); - fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry(); - fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry(); - fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry(); - fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry(); - fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups(); - - } - - fSchemaInfo = toRestore; -} - - -bool -TraverseSchema::emptiableParticle(const ContentSpecNode* const specNode) { - - if (!fFullConstraintChecking || !specNode || (specNode->getMinTotalRange() == 0)) { - return true; - } - - return false; -} - -void TraverseSchema::checkFixedFacet(const DOMElement* const elem, - const XMLCh* const facetName, - const DatatypeValidator* const baseDV, - unsigned int& flags) -{ - const XMLCh* fixedFacet = getElementAttValue(elem, SchemaSymbols::fgATT_FIXED); - - if ((fixedFacet && *fixedFacet) && - (XMLString::equals(fixedFacet, SchemaSymbols::fgATTVAL_TRUE) - || XMLString::equals(fixedFacet, fgValueOne))) { - - if (XMLString::equals(SchemaSymbols::fgELT_LENGTH, facetName)) { - flags |= DatatypeValidator::FACET_LENGTH; - } - if (XMLString::equals(SchemaSymbols::fgELT_MINLENGTH, facetName)) { - flags |= DatatypeValidator::FACET_MINLENGTH; - } - else if (XMLString::equals(SchemaSymbols::fgELT_MAXLENGTH, facetName)) { - flags |= DatatypeValidator::FACET_MAXLENGTH; - } - else if (XMLString::equals(SchemaSymbols::fgELT_MAXEXCLUSIVE, facetName)) { - flags |= DatatypeValidator::FACET_MAXEXCLUSIVE; - } - else if (XMLString::equals(SchemaSymbols::fgELT_MAXINCLUSIVE, facetName)) { - flags |= DatatypeValidator::FACET_MAXINCLUSIVE; - } - else if (XMLString::equals(SchemaSymbols::fgELT_MINEXCLUSIVE, facetName)) { - flags |= DatatypeValidator::FACET_MINEXCLUSIVE; - } - else if (XMLString::equals(SchemaSymbols::fgELT_MININCLUSIVE, facetName)) { - flags |= DatatypeValidator::FACET_MININCLUSIVE; - } - else if (XMLString::equals(SchemaSymbols::fgELT_TOTALDIGITS, facetName)) { - flags |= DatatypeValidator::FACET_TOTALDIGITS; - } - else if (XMLString::equals(SchemaSymbols::fgELT_FRACTIONDIGITS, facetName)) { - flags |= DatatypeValidator::FACET_FRACTIONDIGITS; - } - else if ((XMLString::equals(SchemaSymbols::fgELT_WHITESPACE, facetName)) && - baseDV->getType() == DatatypeValidator::String) { - flags |= DatatypeValidator::FACET_WHITESPACE; - } - } -} - -void -TraverseSchema::buildValidSubstitutionListB(const DOMElement* const elem, - SchemaElementDecl* const elemDecl, - SchemaElementDecl* const subsElemDecl) { - - SchemaElementDecl* chainElemDecl = subsElemDecl->getSubstitutionGroupElem(); - - while (chainElemDecl) { - - int chainElemURI = chainElemDecl->getURI(); - XMLCh* chainElemName = chainElemDecl->getBaseName(); - ValueVectorOf<SchemaElementDecl*>* validSubsElements = - fValidSubstitutionGroups->get(chainElemName, chainElemURI); - - if (!validSubsElements) { - - if (fTargetNSURI == chainElemURI) { - break; // an error must have occured - } - - SchemaGrammar* aGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(fURIStringPool->getValueForId(chainElemURI)); - - if (!aGrammar) - break; - - validSubsElements = aGrammar->getValidSubstitutionGroups()->get(chainElemName, chainElemURI); - - if (!validSubsElements) { - break; - } - - validSubsElements = new (fGrammarPoolMemoryManager) ValueVectorOf<SchemaElementDecl*>(*validSubsElements); - fValidSubstitutionGroups->put((void*) chainElemName, chainElemURI, validSubsElements); - } - - if (validSubsElements->containsElement(elemDecl) || - !isSubstitutionGroupValid(elem, chainElemDecl, elemDecl->getComplexTypeInfo(), - elemDecl->getDatatypeValidator(), 0, false)) { - break; - } - - validSubsElements->addElement(elemDecl); - - // update related subs. info in case of circular import - BaseRefVectorEnumerator<SchemaInfo> importingEnum = fSchemaInfo->getImportingListEnumerator(); - - while (importingEnum.hasMoreElements()) { - - const SchemaInfo& curRef = importingEnum.nextElement(); - SchemaGrammar* aGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(curRef.getTargetNSURIString()); - ValueVectorOf<SchemaElementDecl*>* subsElemList = - aGrammar->getValidSubstitutionGroups()->get(chainElemName, chainElemURI); - - if (subsElemList && !subsElemList->containsElement(elemDecl)) { - subsElemList->addElement(elemDecl); - } - } - - chainElemDecl = chainElemDecl->getSubstitutionGroupElem(); - } -} - -void -TraverseSchema::buildValidSubstitutionListF(const DOMElement* const elem, - SchemaElementDecl* const elemDecl, - SchemaElementDecl* const subsElemDecl) { - - int elemURI = elemDecl->getURI(); - XMLCh* elemName = elemDecl->getBaseName(); - ValueVectorOf<SchemaElementDecl*>* validSubsElements =fValidSubstitutionGroups->get(elemName, elemURI); - - if (validSubsElements) { - - int subsElemURI = subsElemDecl->getURI(); - XMLCh* subsElemName = subsElemDecl->getBaseName(); - ValueVectorOf<SchemaElementDecl*>* validSubs = fValidSubstitutionGroups->get(subsElemName, subsElemURI); - - if (!validSubs) { - - if (fTargetNSURI == subsElemURI) { - return; // an error must have occured - } - - SchemaGrammar* aGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(fURIStringPool->getValueForId(subsElemURI)); - - if (!aGrammar) - return; - - validSubs = aGrammar->getValidSubstitutionGroups()->get(subsElemName, subsElemURI); - - if (!validSubs) { - return; - } - - validSubs = new (fGrammarPoolMemoryManager) ValueVectorOf<SchemaElementDecl*>(*validSubs); - fValidSubstitutionGroups->put((void*) subsElemName, subsElemURI, validSubs); - } - - XMLSize_t elemSize = validSubsElements->size(); - for (XMLSize_t i=0; i<elemSize; i++) { - - SchemaElementDecl* chainElem = validSubsElements->elementAt(i); - - if (validSubs->containsElement(chainElem)) { - continue; - } - - if (isSubstitutionGroupValid(elem, subsElemDecl, chainElem->getComplexTypeInfo(), - chainElem->getDatatypeValidator(), 0, false)) { - validSubs->addElement(chainElem); - buildValidSubstitutionListB(elem, chainElem, subsElemDecl); - } - } - } -} - -void TraverseSchema::checkEnumerationRequiredNotation(const DOMElement* const elem, - const XMLCh* const name, - const XMLCh* const type) { - - const XMLCh* localPart = getLocalPart(type); - - if (XMLString::equals(localPart, XMLUni::fgNotationString)) { - const XMLCh* prefix = getPrefix(type); - const XMLCh* typeURI = resolvePrefixToURI(elem, prefix); - - if (XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNotationType, name); - } - } -} - -XercesGroupInfo* TraverseSchema::processGroupRef(const DOMElement* const elem, - const XMLCh* const refName) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true); - Janitor<XSAnnotation> janAnnot(fAnnotation); - if (content != 0) { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::NoContentForRef, SchemaSymbols::fgELT_GROUP); - } - - const XMLCh* prefix = getPrefix(refName); - const XMLCh* localPart = getLocalPart(refName); - const XMLCh* uriStr = resolvePrefixToURI(elem, prefix); - - fBuffer.set(uriStr); - fBuffer.append(chComma); - fBuffer.append(localPart); - - unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer()); - - if (fCurrentGroupStack->containsElement(nameIndex)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, localPart); - return 0; - } - - XercesGroupInfo* groupInfo = 0; - SchemaInfo* saveInfo = fSchemaInfo; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - unsigned int saveScope = fCurrentScope; - - //if from another target namespace - if (!XMLString::equals(uriStr, fTargetNSURIString)) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, uriStr); - return 0; - } - - Grammar* aGrammar = fGrammarResolver->getGrammar(uriStr); - - if (!aGrammar || aGrammar->getGrammarType() != Grammar::SchemaGrammarType) { - - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr); - return 0; - } - - groupInfo = ((SchemaGrammar*)aGrammar)->getGroupInfoRegistry()->get(fStringPool->getValueForId(nameIndex)); - - if (!groupInfo) { - - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(fURIStringPool->addOrFind(uriStr)); - - if (!impInfo || impInfo->getProcessed()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound, - SchemaSymbols::fgELT_GROUP, uriStr, localPart); - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - } - else { - groupInfo = fGroupRegistry->get(fStringPool->getValueForId(nameIndex)); - } - - if (!groupInfo) { - - DOMElement* groupElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Group, - SchemaSymbols::fgELT_GROUP, localPart, &fSchemaInfo); - - if (groupElem != 0) { - - groupInfo = traverseGroupDecl(groupElem); - - // restore schema information - restoreSchemaInfo(saveInfo, infoType, saveScope); - - if (groupInfo && (fCurrentGroupInfo || infoType == SchemaInfo::IMPORT)) { - copyGroupElements(elem, groupInfo, fCurrentGroupInfo, - (infoType == SchemaInfo::IMPORT) ? fCurrentComplexType : 0); - } - - return groupInfo; - } - else { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound, - SchemaSymbols::fgELT_GROUP, uriStr, localPart); - } - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - } - else { - copyGroupElements(elem, groupInfo, fCurrentGroupInfo, fCurrentComplexType); - } - - return groupInfo; -} - - -XercesAttGroupInfo* -TraverseSchema::processAttributeGroupRef(const DOMElement* const elem, - const XMLCh* const refName, - ComplexTypeInfo* const typeInfo) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0) { - reportSchemaError(elem ,XMLUni::fgValidityDomain, XMLValid::NoContentForRef, SchemaSymbols::fgELT_ATTRIBUTEGROUP); - } - - Janitor<XSAnnotation> janAnnot(fAnnotation); - const XMLCh* prefix = getPrefix(refName); - const XMLCh* localPart = getLocalPart(refName); - const XMLCh* uriStr = resolvePrefixToURI(elem, prefix); - XercesAttGroupInfo* attGroupInfo = 0; - SchemaInfo* saveInfo = fSchemaInfo; - SchemaInfo::ListType infoType = SchemaInfo::INCLUDE; - unsigned int saveScope = fCurrentScope; - - if (!XMLString::equals(uriStr, fTargetNSURIString)) { - - // Make sure that we have an explicit import statement. - // Clause 4 of Schema Representation Constraint: - // http://www.w3.org/TR/xmlschema-1/#src-resolve - unsigned int uriId = fURIStringPool->addOrFind(uriStr); - - if (!isImportingNS(uriId)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidNSReference, uriStr); - return 0; - } - - attGroupInfo = traverseAttributeGroupDeclNS(elem, uriStr, localPart); - - if (!attGroupInfo) { - SchemaInfo* impInfo = fSchemaInfo->getImportInfo(fURIStringPool->addOrFind(uriStr)); - - if (!impInfo || impInfo->getProcessed()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound, - SchemaSymbols::fgELT_ATTRIBUTEGROUP, uriStr, localPart); - return 0; - } - - infoType = SchemaInfo::IMPORT; - restoreSchemaInfo(impInfo, infoType); - } - } - else { - - attGroupInfo = fAttGroupRegistry->get(localPart); - } - - if (!attGroupInfo) { - - // traverse top level attributeGroup - if found - DOMElement* attGroupElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_AttributeGroup, - SchemaSymbols::fgELT_ATTRIBUTEGROUP, localPart, &fSchemaInfo); - - if (attGroupElem != 0) { - - // circular attribute check - if (fDeclStack->containsElement(attGroupElem)) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, refName); - return 0; - } - - attGroupInfo = traverseAttributeGroupDecl(attGroupElem, typeInfo, true); - - if (attGroupInfo && fCurrentAttGroupInfo) { - copyAttGroupAttributes(elem, attGroupInfo, fCurrentAttGroupInfo, 0); - } - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType, saveScope); - } - - return attGroupInfo; - } - else { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound, - SchemaSymbols::fgELT_ATTRIBUTEGROUP, uriStr, localPart); - } - } - - if (attGroupInfo) { - copyAttGroupAttributes(elem, attGroupInfo, fCurrentAttGroupInfo, typeInfo); - } - - // restore schema information, if necessary - if (saveInfo != fSchemaInfo) { - restoreSchemaInfo(saveInfo, infoType); - } - - return attGroupInfo; -} - -void TraverseSchema::processElements(const DOMElement* const elem, - ComplexTypeInfo* const baseTypeInfo, - ComplexTypeInfo* const newTypeInfo) { - - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - XMLSize_t elemCount = baseTypeInfo->elementCount(); - - if (elemCount) { - - int newTypeScope = newTypeInfo->getScopeDefined(); - int schemaURI = fURIStringPool->addOrFind(SchemaSymbols::fgURI_SCHEMAFORSCHEMA); - - for (XMLSize_t i=0; i < elemCount; i++) { - - SchemaGrammar* aGrammar = fSchemaGrammar; - SchemaElementDecl* elemDecl = baseTypeInfo->elementAt(i); - int elemURI = elemDecl->getURI(); - unsigned int elemScope = elemDecl->getEnclosingScope(); - - if (elemScope != Grammar::TOP_LEVEL_SCOPE) { - - if (elemURI != fTargetNSURI && elemURI != schemaURI && elemURI != fEmptyNamespaceURI) { - Grammar* aGrammar = fGrammarResolver->getGrammar(fURIStringPool->getValueForId(elemURI)); - - if (!aGrammar || aGrammar->getGrammarType() != Grammar::SchemaGrammarType) { - continue; // REVISIT - error message - } - } - - const XMLCh* localPart = elemDecl->getBaseName(); - const SchemaElementDecl* other = (SchemaElementDecl*) - aGrammar->getElemDecl(elemURI, localPart, 0, newTypeScope); - - if (other) { - - if (elemDecl->getComplexTypeInfo() != other->getComplexTypeInfo() - || elemDecl->getDatatypeValidator() != other->getDatatypeValidator()) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateElementDeclaration, localPart); - } - - continue; - } - elemDecl->setEnclosingScope(newTypeScope); - ((SchemaGrammar*) aGrammar)->putGroupElemDecl(elemDecl); - elemDecl->setEnclosingScope(elemScope); - } - - newTypeInfo->addElement(elemDecl); - } - } -} - -void TraverseSchema::processElements(const DOMElement* const elem, - XercesGroupInfo* const fromGroup, - ComplexTypeInfo* const typeInfo) -{ - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - XMLSize_t elemCount = fromGroup->elementCount(); - int newScope = typeInfo->getScopeDefined(); - - for (XMLSize_t i = 0; i < elemCount; i++) { - - SchemaElementDecl* elemDecl = fromGroup->elementAt(i); - unsigned int elemScope = elemDecl->getEnclosingScope(); - - if (elemScope != Grammar::TOP_LEVEL_SCOPE) - { - int elemURI = elemDecl->getURI(); - const XMLCh* localPart = elemDecl->getBaseName(); - const SchemaElementDecl* other = (SchemaElementDecl*) - fSchemaGrammar->getElemDecl(elemURI, localPart, 0, newScope); - - if (other) - { - if (elemDecl->getComplexTypeInfo() != other->getComplexTypeInfo() - || elemDecl->getDatatypeValidator() != other->getDatatypeValidator()) - { - reportSchemaError( - elem, XMLUni::fgXMLErrDomain - , XMLErrs::DuplicateElementDeclaration, localPart); - } - - continue; - } - - elemDecl->setEnclosingScope(newScope); - fSchemaGrammar->putGroupElemDecl(elemDecl); - elemDecl->setEnclosingScope(elemScope); - typeInfo->addElement(elemDecl); - } - } -} - - -void TraverseSchema::copyGroupElements(const DOMElement* const elem, - XercesGroupInfo* const fromGroup, - XercesGroupInfo* const toGroup, - ComplexTypeInfo* const typeInfo) { - - XMLSize_t elemCount = fromGroup->elementCount(); - int newScope = (typeInfo) ? typeInfo->getScopeDefined() : 0; - - if (typeInfo) - fromGroup->setCheckElementConsistency(false); - - for (XMLSize_t i = 0; i < elemCount; i++) { - - SchemaElementDecl* elemDecl = fromGroup->elementAt(i); - - if (typeInfo) { - - unsigned int elemScope = elemDecl->getEnclosingScope(); - - if (elemScope != Grammar::TOP_LEVEL_SCOPE) { - - int elemURI = elemDecl->getURI(); - const XMLCh* localPart = elemDecl->getBaseName(); - const SchemaElementDecl* other = (SchemaElementDecl*) - fSchemaGrammar->getElemDecl(elemURI, localPart, 0, newScope); - - if (other) { - - if (elemDecl->getComplexTypeInfo() != other->getComplexTypeInfo() - || elemDecl->getDatatypeValidator() != other->getDatatypeValidator()) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateElementDeclaration, localPart); - } - - continue; - } - - elemDecl->setEnclosingScope(newScope); - fSchemaGrammar->putGroupElemDecl(elemDecl); - elemDecl->setEnclosingScope(elemScope); - } - - typeInfo->addElement(elemDecl); - } - - if (toGroup) { - toGroup->addElement(elemDecl); - } - } -} - -void TraverseSchema::copyAttGroupAttributes(const DOMElement* const elem, - XercesAttGroupInfo* const fromAttGroup, - XercesAttGroupInfo* const toAttGroup, - ComplexTypeInfo* const typeInfo) { - - XMLSize_t attCount = fromAttGroup->attributeCount(); - - for (XMLSize_t i=0; i < attCount; i++) { - - SchemaAttDef* attDef = fromAttGroup->attributeAt(i); - QName* attName = attDef->getAttName(); - const XMLCh* localPart = attName->getLocalPart(); - DatatypeValidator* attDV = attDef->getDatatypeValidator(); - - if (typeInfo) { - - if (typeInfo->getAttDef(localPart, attName->getURI())) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, localPart); - continue; - } - - if (attDV && attDV->getType() == DatatypeValidator::ID) { - - if (typeInfo->containsAttWithTypeId()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect5, localPart); - continue; - } - - typeInfo->setAttWithTypeId(true); - } - - SchemaAttDef* clonedAttDef = new (fGrammarPoolMemoryManager) SchemaAttDef(attDef); - typeInfo->addAttDef(clonedAttDef); - - if (!clonedAttDef->getBaseAttDecl()) - clonedAttDef->setBaseAttDecl(attDef); - - if (toAttGroup) { - toAttGroup->addAttDef(attDef, true); - } - } - else { - - if (toAttGroup->containsAttribute(localPart, attName->getURI())) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, localPart); - continue; - } - - if (attDV && attDV->getType() == DatatypeValidator::ID) { - - if (toAttGroup->containsTypeWithId()) { - - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttGrpPropCorrect3, localPart); - continue; - } - - toAttGroup->setTypeWithId(true); - } - - toAttGroup->addAttDef(attDef, true); - } - } - - if (toAttGroup) { - XMLSize_t anyAttCount = fromAttGroup->anyAttributeCount(); - - for (XMLSize_t j=0; j < anyAttCount; j++) { - toAttGroup->addAnyAttDef(fromAttGroup->anyAttributeAt(j), true); - } - } -} - -void -TraverseSchema::attWildCardIntersection(SchemaAttDef* const resultWildCard, - const SchemaAttDef* const compareWildCard) { - - XMLAttDef::AttTypes typeR = resultWildCard->getType(); - XMLAttDef::AttTypes typeC = compareWildCard->getType(); - - //If either O1 or O2 is any, then the other must be the value. - if (typeC == XMLAttDef::Any_Any || - typeR == XMLAttDef::AttTypes_Unknown) { - return; - } - - if (typeR == XMLAttDef::Any_Any || - typeC == XMLAttDef::AttTypes_Unknown) { - - resultWildCard->resetNamespaceList(); - copyWildCardData(compareWildCard, resultWildCard); - return; - } - - // If either O1 or O2 is a pair of not and a namespace name and the other - // is a set, then that set, minus the negated namespace name if it was in - // is the value - if ((typeC == XMLAttDef::Any_Other && typeR == XMLAttDef::Any_List) || - (typeR == XMLAttDef::Any_Other && typeC == XMLAttDef::Any_List)) { - - unsigned int compareURI = 0; - ValueVectorOf<unsigned int>* nameURIList = 0; - - if (typeC == XMLAttDef::Any_List) { - nameURIList = compareWildCard->getNamespaceList(); - compareURI = resultWildCard->getAttName()->getURI(); - } - else { - nameURIList = resultWildCard->getNamespaceList(); - compareURI = compareWildCard->getAttName()->getURI(); - } - - XMLSize_t listSize = (nameURIList) ? nameURIList->size() : 0; - - if (listSize) { - - bool found = false; - ValueVectorOf<unsigned int> tmpURIList(listSize, fGrammarPoolMemoryManager); - - for (XMLSize_t i=0; i < listSize; i++) { - - unsigned int nameURI = nameURIList->elementAt(i); - - if (nameURI != compareURI && - nameURI != (unsigned int) fEmptyNamespaceURI) { - tmpURIList.addElement(nameURI); - } - else { - found = true; - } - } - - if (found || typeC == XMLAttDef::Any_List) { - resultWildCard->setNamespaceList(&tmpURIList); - } - } - - if (typeC == XMLAttDef::Any_List) { - copyWildCardData(compareWildCard, resultWildCard); - } - - return; - } - - // If both O1 and O2 are sets, then the intersection of those sets must be - // the value. - if (typeR == XMLAttDef::Any_List && typeC == XMLAttDef::Any_List) { - - ValueVectorOf<unsigned int>* uriListR = resultWildCard->getNamespaceList(); - ValueVectorOf<unsigned int>* uriListC = compareWildCard->getNamespaceList(); - XMLSize_t listSize = (uriListC) ? uriListC->size() : 0; - - if (listSize) { - - ValueVectorOf<unsigned int> tmpURIList(listSize, fGrammarPoolMemoryManager); - - for (XMLSize_t i=0; i < listSize; i++) { - - unsigned int uriName = uriListC->elementAt(i); - - if (uriListR && uriListR->containsElement(uriName)) { - tmpURIList.addElement(uriName); - } - } - - resultWildCard->setNamespaceList(&tmpURIList); - } - else { - resultWildCard->resetNamespaceList(); - } - - return; - } - - // If the two are negations of different namespace names, then: - // if one is a negation of absent, then result is negation of namespace - // else intersection is not expressible. - if (typeR == XMLAttDef::Any_Other && typeC == XMLAttDef::Any_Other) { - - QName* qnameR = resultWildCard->getAttName(); - - if (qnameR->getURI() != compareWildCard->getAttName()->getURI()) { - - if (qnameR->getURI() == (unsigned int)fEmptyNamespaceURI) { - qnameR->setURI(compareWildCard->getAttName()->getURI()); - } - else if (compareWildCard->getAttName()->getURI() != (unsigned int)fEmptyNamespaceURI) { - - qnameR->setURI(fEmptyNamespaceURI); - resultWildCard->setType(XMLAttDef::AttTypes_Unknown); - } - } - } -} - - -void -TraverseSchema::attWildCardUnion(SchemaAttDef* const resultWildCard, - const SchemaAttDef* const compareWildCard) { - - XMLAttDef::AttTypes typeR = resultWildCard->getType(); - XMLAttDef::AttTypes typeC = compareWildCard->getType(); - - //If either O1 or O2 is any, then the other must be the value. - if (typeR == XMLAttDef::Any_Any || - typeR == XMLAttDef::AttTypes_Unknown) { - return; - } - - if (typeC == XMLAttDef::Any_Any || - typeC == XMLAttDef::AttTypes_Unknown) { - - resultWildCard->resetNamespaceList(); - copyWildCardData(compareWildCard, resultWildCard); - return; - } - - // If both O1 and O2 are sets, then the union of those sets must be - // the value. - if (typeR == XMLAttDef::Any_List && typeC == XMLAttDef::Any_List) { - - ValueVectorOf<unsigned int>* uriListR = resultWildCard->getNamespaceList(); - ValueVectorOf<unsigned int>* uriListC = compareWildCard->getNamespaceList(); - XMLSize_t listSizeC = (uriListC) ? uriListC->size() : 0; - - if (listSizeC) { - - if (!uriListR || !uriListR->size()) { - - resultWildCard->setNamespaceList(uriListC); - return; - } - - ValueVectorOf<unsigned int> tmpURIList(*uriListR); - - for (XMLSize_t i = 0; i < listSizeC; i++) { - - unsigned int uriName = uriListC->elementAt(i); - - if (!uriListR->containsElement(uriName)) { - tmpURIList.addElement(uriName); - } - } - - resultWildCard->setNamespaceList(&tmpURIList); - } - - return; - } - - // If the two are negations of different namespace names, then not and - // absent must be the value - if (typeR == XMLAttDef::Any_Other && typeC == XMLAttDef::Any_Other) { - - QName* qnameR = resultWildCard->getAttName(); - - if (qnameR->getURI() != compareWildCard->getAttName()->getURI()) { - - qnameR->setURI(fEmptyNamespaceURI); - resultWildCard->setType(XMLAttDef::Any_Other); - } - } - - // 5. If either O1 or O2 is a pair of not and a namespace name and the - // other is a set, then: - // 1. If the set includes both the negated namespace name and absent - // then any must be the value. - // 2. If the set includes the negated namespace name but not absent, - // then a pair of not and absent must be the value. - // 3. If the set includes absent but not the negated namespace name, - // then the union is not expressible. - // 4. If the set does not include either the negated namespace or - // absent, then whichever of O1 or O2 is a pair of not and a - // namespace name. - // - // 6. If either O1 or O2 is a pair of not and absent and the other is a - // set, then: - // 1. If the set includes absent then any must be the value. - // 2. If the set does not include absent, then a pair of not and - // absent. - if ((typeC == XMLAttDef::Any_Other && typeR == XMLAttDef::Any_List) || - (typeR == XMLAttDef::Any_Other && typeC == XMLAttDef::Any_List)) { - - ValueVectorOf<unsigned int>* nameURIList = 0; - QName* attNameR = resultWildCard->getAttName(); - unsigned int compareURI = 0; - - if (typeC == XMLAttDef::Any_List) { - nameURIList = compareWildCard->getNamespaceList(); - compareURI = attNameR->getURI(); - } - else { - nameURIList = resultWildCard->getNamespaceList(); - compareURI = compareWildCard->getAttName()->getURI(); - } - - // 6. not and absent - if (compareURI == (unsigned int) fEmptyNamespaceURI) { - - if (nameURIList) { - - // 6.1 result is any - if (nameURIList->containsElement(compareURI)) { - - resultWildCard->setType(XMLAttDef::Any_Any); - attNameR->setURI(fEmptyNamespaceURI); - } - // 6.2 result is not and absent - else if (typeR == XMLAttDef::Any_List){ - - resultWildCard->setType(XMLAttDef::Any_Other); - attNameR->setURI(fEmptyNamespaceURI); - } - } - // 6.2 result is not and absent - else if (typeR == XMLAttDef::Any_List) { - - resultWildCard->setType(XMLAttDef::Any_Other); - attNameR->setURI(fEmptyNamespaceURI); - } - } - // 5. not and namespace - else { - - // 5.3 result is not expressible - if (!nameURIList) { - resultWildCard->setType(XMLAttDef::AttTypes_Unknown); - attNameR->setURI(fEmptyNamespaceURI); - } - else { - bool containsAbsent = - nameURIList->containsElement(fEmptyNamespaceURI); - bool containsNamespace = - nameURIList->containsElement(compareURI); - - // 5.1 result is any - if (containsAbsent && containsNamespace) { - - resultWildCard->setType(XMLAttDef::Any_Any); - attNameR->setURI(fEmptyNamespaceURI); - } - // 5.2 result is not and absent - else if (containsNamespace) { - - resultWildCard->setType(XMLAttDef::Any_Other); - attNameR->setURI(fEmptyNamespaceURI); - } - // 5.3 result is not expressible - else if (containsAbsent) { - - resultWildCard->setType(XMLAttDef::AttTypes_Unknown); - attNameR->setURI(fEmptyNamespaceURI); - } - // 5.4. whichever is not and namespace - else if (typeR == XMLAttDef::Any_List) { - - resultWildCard->setType(XMLAttDef::Any_Other); - attNameR->setURI(compareURI); - } - } - } - - resultWildCard->resetNamespaceList(); - } -} - - -void TraverseSchema::checkAttDerivationOK(const DOMElement* const elem, - const ComplexTypeInfo* const baseTypeInfo, - const ComplexTypeInfo* const childTypeInfo) { - - SchemaAttDefList& childAttList = (SchemaAttDefList&) childTypeInfo->getAttDefList(); - const SchemaAttDef* baseAttWildCard = baseTypeInfo->getAttWildCard(); - - for (XMLSize_t i=0; i<childAttList.getAttDefCount(); i++) { - - SchemaAttDef& childAttDef = (SchemaAttDef&) childAttList.getAttDef(i); - QName* childAttName = childAttDef.getAttName(); - const XMLCh* childLocalPart = childAttName->getLocalPart(); - const SchemaAttDef* baseAttDef = baseTypeInfo->getAttDef(childLocalPart, childAttName->getURI()); - - if (baseAttDef) { - - XMLAttDef::DefAttTypes baseAttDefType = baseAttDef->getDefaultType(); - XMLAttDef::DefAttTypes childAttDefType = childAttDef.getDefaultType(); - - // Constraint 2.1.1 & 3 + check for prohibited base attribute - if (baseAttDefType == XMLAttDef::Prohibited - && childAttDefType != XMLAttDef::Prohibited) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_8, childLocalPart); - } - - if ((baseAttDefType & XMLAttDef::Required) - && !(childAttDefType & XMLAttDef::Required)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_2, childLocalPart); - } - - // if the attribute in the derived type is prohibited, and it didn't try to override a required attribute, - // it's ok and shouldn't be tested for data type or fixed value - if (childAttDefType == XMLAttDef::Prohibited) - continue; - - // Constraint 2.1.2 - DatatypeValidator* baseDV = baseAttDef->getDatatypeValidator(); - DatatypeValidator* childDV = childAttDef.getDatatypeValidator(); - if (!baseDV || !baseDV->isSubstitutableBy(childDV)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_3, childLocalPart); - } - - // Constraint 2.1.3 - if ((baseAttDefType & XMLAttDef::Fixed) && - (!(childAttDefType & XMLAttDef::Fixed) || - !XMLString::equals(baseAttDef->getValue(), childAttDef.getValue()))) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_4, childLocalPart); - } - } - // Constraint 2.2 - else if (!baseAttWildCard || - !wildcardAllowsNamespace(baseAttWildCard, childAttName->getURI())) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_5, childLocalPart); - } - } - - // Constraint 4 - const SchemaAttDef* childAttWildCard = childTypeInfo->getAttWildCard(); - - if (childAttWildCard) { - - if (!baseAttWildCard) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_6); - } - else if (!isWildCardSubset(baseAttWildCard, childAttWildCard)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_7); - } - else if (childAttWildCard->getDefaultType() < baseAttWildCard->getDefaultType()) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_9); - } - } -} - -void TraverseSchema::checkAttDerivationOK(const DOMElement* const elem, - const XercesAttGroupInfo* const baseAttGrpInfo, - const XercesAttGroupInfo* const childAttGrpInfo) { - - XMLSize_t baseAttCount = baseAttGrpInfo->attributeCount(); - XMLSize_t baseAnyAttCount = baseAttGrpInfo->anyAttributeCount(); - XMLSize_t childAttCount = childAttGrpInfo->attributeCount(); - XMLSize_t childAnyAttCount = childAttGrpInfo->anyAttributeCount(); - - if ((childAttCount || childAnyAttCount) && (!baseAttCount && !baseAnyAttCount)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_1); - } - - const SchemaAttDef* baseAttWildCard = (baseAnyAttCount) ? baseAttGrpInfo->anyAttributeAt(0) : 0; - - for (XMLSize_t i=0; i<childAttCount; i++) { - - const SchemaAttDef* childAttDef = childAttGrpInfo->attributeAt(i); - QName* childAttName = childAttDef->getAttName(); - const XMLCh* childLocalPart = childAttName->getLocalPart(); - const SchemaAttDef* baseAttDef = baseAttGrpInfo->getAttDef(childLocalPart, childAttName->getURI()); - - if (baseAttDef) { - - XMLAttDef::DefAttTypes baseAttDefType = baseAttDef->getDefaultType(); - XMLAttDef::DefAttTypes childAttDefType = childAttDef->getDefaultType(); - - // Constraint 2.1.1 & 3 + check for prohibited base attribute - if (baseAttDefType == XMLAttDef::Prohibited - && childAttDefType != XMLAttDef::Prohibited) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_8, childLocalPart); - } - - if ((baseAttDefType & XMLAttDef::Required) - && !(childAttDefType & XMLAttDef::Required)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_2, childLocalPart); - } - - // if the attribute in the derived type is prohibited, and it didn't try to override a required attribute, - // it's ok and shouldn't be tested for data type or fixed value - if (childAttDefType == XMLAttDef::Prohibited) - continue; - - // Constraint 2.1.2 - DatatypeValidator* baseDV = baseAttDef->getDatatypeValidator(); - DatatypeValidator* childDV = childAttDef->getDatatypeValidator(); - if (!baseDV || !baseDV->isSubstitutableBy(childDV)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_3, childLocalPart); - } - - // Constraint 2.1.3 - if ((baseAttDefType & XMLAttDef::Fixed) && - (!(childAttDefType & XMLAttDef::Fixed) || - !XMLString::equals(baseAttDef->getValue(), childAttDef->getValue()))) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_4, childLocalPart); - } - } - // Constraint 2.2 - else if (!baseAttWildCard || - !wildcardAllowsNamespace(baseAttWildCard, childAttName->getURI())) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_5, childLocalPart); - } - } - - // Constraint 4 - const SchemaAttDef* childAttWildCard = (childAnyAttCount) ? childAttGrpInfo->anyAttributeAt(0) : 0; - - if (childAttWildCard) { - - if (!baseAttWildCard) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_6); - } - else if (!isWildCardSubset(baseAttWildCard, childAttWildCard)) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_7); - } - else if (childAttWildCard->getDefaultType() < baseAttWildCard->getDefaultType()) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::BadAttDerivation_9); - } - } -} - -bool TraverseSchema::wildcardAllowsNamespace(const SchemaAttDef* const wildCard, - const unsigned int nameURI) { - - XMLAttDef::AttTypes wildCardType = wildCard->getType(); - - // The constraint must be any - if (wildCardType == XMLAttDef::Any_Any) { - return true; - } - - // All of the following must be true: - // 2.1 The constraint is a pair of not and a namespace name or absent - // 2.2 The value must not be identical to the namespace test. - // 2.3 The value must not be absent. - if (wildCardType == XMLAttDef::Any_Other && - ((int) nameURI) != fEmptyNamespaceURI && - wildCard->getAttName()->getURI() != nameURI) { - return true; - } - - // The constraint is a set, and the value is identical to one of the - // members of the set - if (wildCardType == XMLAttDef::Any_List) { - - ValueVectorOf<unsigned int>* nameURIList = wildCard->getNamespaceList(); - - if (nameURIList->containsElement(nameURI)) { - return true; - } - } - - return false; -} - -bool TraverseSchema::isWildCardSubset(const SchemaAttDef* const baseAttWildCard, - const SchemaAttDef* const childAttWildCard) { - - XMLAttDef::AttTypes baseWildCardType = baseAttWildCard->getType(); - XMLAttDef::AttTypes childWildCardType = childAttWildCard->getType(); - - if (baseWildCardType == XMLAttDef::AttTypes_Unknown || - childWildCardType == XMLAttDef::AttTypes_Unknown) { - return false; - } - - // 1 super must be any. - if (baseWildCardType == XMLAttDef::Any_Any) { - return true; - } - - // 2 All of the following must be true: - // 2.1 sub must be a pair of not and a namespace name or absent. - // 2.2 super must be a pair of not and the same value. - if (childWildCardType == XMLAttDef::Any_Other && baseWildCardType == XMLAttDef::Any_Other && - childAttWildCard->getAttName()->getURI() == baseAttWildCard->getAttName()->getURI()) { - return true; - } - - // 3 All of the following must be true: - // 3.1 sub must be a set whose members are either namespace names or absent. - // 3.2 One of the following must be true: - // 3.2.1 super must be the same set or a superset thereof. - // 3.2.2 super must be a pair of not and a namespace name or absent and - // that value must not be in sub's set. - if (childWildCardType == XMLAttDef::Any_List) { - - ValueVectorOf<unsigned int>* childURIList = childAttWildCard->getNamespaceList(); - - if (baseWildCardType == XMLAttDef::Any_List) { - - ValueVectorOf<unsigned int>* baseURIList = baseAttWildCard->getNamespaceList(); - XMLSize_t childListSize = (childURIList) ? childURIList->size() : 0; - - for (XMLSize_t i=0; i<childListSize; i++) { - if (!baseURIList->containsElement(childURIList->elementAt(i))) { - return false; - } - } - - return true; - } - else if (baseWildCardType == XMLAttDef::Any_Other) { - if (!childURIList->containsElement(baseAttWildCard->getAttName()->getURI())) { - return true; - } - } - } - - return false; -} - -bool TraverseSchema::openRedefinedSchema(const DOMElement* const redefineElem) { - - if (fPreprocessedNodes->containsKey(redefineElem)) { - - restoreSchemaInfo(fPreprocessedNodes->get(redefineElem)); - return true; - } - - // ------------------------------------------------------------------ - // Get 'schemaLocation' attribute - // ------------------------------------------------------------------ - const XMLCh* schemaLocation = getElementAttValue(redefineElem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI); - - if (!schemaLocation || !*schemaLocation) { - reportSchemaError(redefineElem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNoSchemaLocation, SchemaSymbols::fgELT_REDEFINE); - return false; - } - - // ------------------------------------------------------------------ - // Resolve schema location - // ------------------------------------------------------------------ - fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0, - ((XSDElementNSImpl*) redefineElem)->getLineNo(), - ((XSDElementNSImpl*) redefineElem)->getColumnNo()); - InputSource* srcToFill = resolveSchemaLocation(schemaLocation, - XMLResourceIdentifier::SchemaRedefine); - Janitor<InputSource> janSrc(srcToFill); - - // Nothing to do - if (!srcToFill) { - return false; - } - - const XMLCh* includeURL = srcToFill->getSystemId(); - - if (XMLString::equals(includeURL, fSchemaInfo->getCurrentSchemaURL())) { - return false; - } - - SchemaInfo* redefSchemaInfo = fCachedSchemaInfoList->get(includeURL, fTargetNSURI); - - if (!redefSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList) - redefSchemaInfo = fSchemaInfoList->get(includeURL, fTargetNSURI); - - if (redefSchemaInfo) { - - reportSchemaError(redefineElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidRedefine, includeURL); - return false; - } - - // ------------------------------------------------------------------ - // Parse input source - // ------------------------------------------------------------------ - if (!fParser) - fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0,fGrammarPoolMemoryManager, 0); - - fParser->setValidationScheme(XercesDOMParser::Val_Never); - fParser->setDoNamespaces(true); - fParser->setUserEntityHandler(fEntityHandler); - fParser->setUserErrorReporter(fErrorReporter); - - // Should just issue warning if the schema is not found - bool flag = srcToFill->getIssueFatalErrorIfNotFound(); - srcToFill->setIssueFatalErrorIfNotFound(false); - - fParser->parse(*srcToFill) ; - - // Reset the InputSource - srcToFill->setIssueFatalErrorIfNotFound(flag); - - if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal()) - reportSchemaError(redefineElem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError); - - // ------------------------------------------------------------------ - // Get root element - // ------------------------------------------------------------------ - DOMDocument* document = fParser->getDocument(); - - if (!document) { - return false; - } - else { - - DOMElement* root = document->getDocumentElement(); - - if (root == 0) { - return false; - } - - const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE); - - // check to see if targetNameSpace is right - if (*targetNSURIString - && !XMLString::equals(targetNSURIString,fTargetNSURIString)){ - reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::RedefineNamespaceDifference, - schemaLocation, targetNSURIString); - return false; - } - - // if targetNamespace is empty, change it to redefin'g schema - // targetNamespace - if (!*targetNSURIString && root->getAttributeNode(XMLUni::fgXMLNSString) == 0 - && fTargetNSURI != fEmptyNamespaceURI) { - root->setAttribute(XMLUni::fgXMLNSString, fTargetNSURIString); - } - - // -------------------------------------------------------- - // Update schema information with redefined schema - // -------------------------------------------------------- - redefSchemaInfo = fSchemaInfo; - Janitor<SchemaInfo> newSchemaInfo(new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI, - 0, - includeURL, - fTargetNSURIString, root, - fScanner, - fGrammarPoolMemoryManager)); - fSchemaInfo = newSchemaInfo.get(); - - fSchemaInfo->getNamespaceScope()->reset(fEmptyNamespaceURI); - // Add mapping for the xml prefix - fSchemaInfo->getNamespaceScope()->addPrefix(XMLUni::fgXMLString, fURIStringPool->addOrFind(XMLUni::fgXMLURIName)); - - traverseSchemaHeader(root); - fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(), fSchemaInfo->getTargetNSURI(), fSchemaInfo); - newSchemaInfo.release(); - redefSchemaInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE); - fPreprocessedNodes->put((void*) redefineElem, fSchemaInfo); - } - - return true; -} - -void TraverseSchema::renameRedefinedComponents(const DOMElement* const redefineElem, - SchemaInfo* const redefiningSchemaInfo, - SchemaInfo* const redefinedSchemaInfo) { - - DOMElement* child = XUtil::getFirstChildElement(redefineElem); - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* childName = child->getLocalName(); - - if (XMLString::equals(childName, SchemaSymbols::fgELT_ANNOTATION)) { - continue; - } - - // if component already redefined skip - const XMLCh* typeName = getElementAttValue(child, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(typeName); - - if (fRedefineComponents->containsKey(childName, fStringPool->addOrFind(fBuffer.getRawBuffer()))) { - continue; - } - - // Rename - const XMLCh* tmpChildName = fStringPool->getValueForId(fStringPool->addOrFind(childName)); - - if (validateRedefineNameChange(child, tmpChildName, typeName, 1, redefiningSchemaInfo)) { - fixRedefinedSchema(child, redefinedSchemaInfo, tmpChildName, typeName, 1); - } - else { - redefiningSchemaInfo->addFailedRedefine(child); - } - } -} - -bool TraverseSchema::validateRedefineNameChange(const DOMElement* const redefineChildElem, - const XMLCh* const redefineChildComponentName, - const XMLCh* const redefineChildTypeName, - const int redefineNameCounter, - SchemaInfo* const redefiningSchemaInfo) { - - const XMLCh* baseTypeName = 0; - unsigned int typeNameId = fStringPool->addOrFind(redefineChildTypeName); - - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(redefineChildTypeName); - - int fullTypeNameId = fStringPool->addOrFind(fBuffer.getRawBuffer()); - const XMLCh* typeNameStr = fStringPool->getValueForId(fullTypeNameId); - - restoreSchemaInfo(redefiningSchemaInfo); - - if (XMLString::equals(redefineChildComponentName,SchemaSymbols::fgELT_SIMPLETYPE)) { - - if (fDatatypeRegistry->getDatatypeValidator(typeNameStr)) { - return false; - } - - DOMElement* grandKid = XUtil::getFirstChildElement(redefineChildElem); - - if (grandKid && XMLString::equals(grandKid->getLocalName(), SchemaSymbols::fgELT_ANNOTATION)) { - grandKid = XUtil::getNextSiblingElement(grandKid); - } - - if (grandKid == 0) { - - reportSchemaError(redefineChildElem, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidSimpleType); - return false; - } - else if(!XMLString::equals(grandKid->getLocalName(), SchemaSymbols::fgELT_RESTRICTION)) { - - reportSchemaError(grandKid, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidSimpleType); - return false; - } - - baseTypeName = getElementAttValue(grandKid, SchemaSymbols::fgATT_BASE, DatatypeValidator::QName); - const XMLCh* prefix = getPrefix(baseTypeName); - const XMLCh* localPart = getLocalPart(baseTypeName); - const XMLCh* uriStr = resolvePrefixToURI(grandKid, prefix); - - if (fTargetNSURI != (int) fURIStringPool->addOrFind(uriStr) - || fStringPool->addOrFind(localPart) != typeNameId) { - reportSchemaError(grandKid, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidSimpleTypeBase); - return false; - } - - // now we have to do the renaming... - getRedefineNewTypeName(baseTypeName, redefineNameCounter, fBuffer); - grandKid->setAttribute(SchemaSymbols::fgATT_BASE, fBuffer.getRawBuffer()); - fRedefineComponents->put((void*) SchemaSymbols::fgELT_SIMPLETYPE, - fullTypeNameId, 0); - } - else if (XMLString::equals(redefineChildComponentName,SchemaSymbols::fgELT_COMPLEXTYPE)) { - - if (fComplexTypeRegistry->containsKey(typeNameStr)) { - return false; - } - - DOMElement* grandKid = XUtil::getFirstChildElement(redefineChildElem); - - if (grandKid && XMLString::equals(grandKid->getLocalName(), SchemaSymbols::fgELT_ANNOTATION)) { - grandKid = XUtil::getNextSiblingElement(grandKid); - } - - if (grandKid == 0) { - reportSchemaError(redefineChildElem, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidComplexType); - return false; - } else { - - // have to go one more level down; let another pass worry whether complexType is valid. - DOMElement* greatGrandKid = XUtil::getFirstChildElement(grandKid); - - if (greatGrandKid != 0 && - XMLString::equals(greatGrandKid->getLocalName(), SchemaSymbols::fgELT_ANNOTATION)) { - greatGrandKid = XUtil::getNextSiblingElement(greatGrandKid); - } - - if (greatGrandKid == 0) { - - reportSchemaError(grandKid, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidComplexType); - return false; - } else { - - const XMLCh* greatGrandKidName = greatGrandKid->getLocalName(); - - if (!XMLString::equals(greatGrandKidName, SchemaSymbols::fgELT_RESTRICTION) - && !XMLString::equals(greatGrandKidName, SchemaSymbols::fgELT_EXTENSION)) { - - reportSchemaError(greatGrandKid, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidComplexType); - return false; - } - - baseTypeName = getElementAttValue(greatGrandKid, SchemaSymbols::fgATT_BASE, DatatypeValidator::QName); - const XMLCh* prefix = getPrefix(baseTypeName); - const XMLCh* localPart = getLocalPart(baseTypeName); - const XMLCh* uriStr = resolvePrefixToURI(greatGrandKid, prefix); - - if (fTargetNSURI != (int) fURIStringPool->addOrFind(uriStr) - || fStringPool->addOrFind(localPart) != typeNameId) { - reportSchemaError(greatGrandKid, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidComplexTypeBase); - return false; - } - - // now we have to do the renaming... - getRedefineNewTypeName(baseTypeName, redefineNameCounter, fBuffer); - greatGrandKid->setAttribute(SchemaSymbols::fgATT_BASE, fBuffer.getRawBuffer()); - fRedefineComponents->put((void*) SchemaSymbols::fgELT_COMPLEXTYPE, - fullTypeNameId, 0); - } - } - } - else if (XMLString::equals(redefineChildComponentName, SchemaSymbols::fgELT_GROUP)) { - - if (fGroupRegistry->containsKey(typeNameStr)) { - return false; - } - - int groupRefCount = changeRedefineGroup(redefineChildElem, redefineChildComponentName, - redefineChildTypeName, redefineNameCounter); - - if (groupRefCount > 1) { - - reportSchemaError(redefineChildElem, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_GroupRefCount); - return false; - } - else if (groupRefCount == 0) { - // put a dummy value, default is null. - // when processing groups, we will check that table, if a value - // is found, we need to do a particle derivation check. - fRedefineComponents->put((void*) SchemaSymbols::fgELT_GROUP, - fullTypeNameId, fSchemaInfo->getCurrentSchemaURL()); - } - else { - fRedefineComponents->put((void*) SchemaSymbols::fgELT_GROUP, fullTypeNameId, 0); - } - } - else if (XMLString::equals(redefineChildComponentName, SchemaSymbols::fgELT_ATTRIBUTEGROUP)) { - - if (fAttGroupRegistry->containsKey(redefineChildTypeName)) { - return false; - } - - int attGroupRefCount = changeRedefineGroup(redefineChildElem, redefineChildComponentName, - redefineChildTypeName, redefineNameCounter); - - if (attGroupRefCount > 1) { - - reportSchemaError(redefineChildElem, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_AttGroupRefCount); - return false; - } - else if (attGroupRefCount == 0) { - // put a dummy value, default is null. - // when processing attributeGroups, we will check that table, if - // a value is found, we need to check for attribute derivation ok - // (by restriction) - fRedefineComponents->put((void*) SchemaSymbols::fgELT_ATTRIBUTEGROUP, - fullTypeNameId, fSchemaInfo->getCurrentSchemaURL()); - } - else { - fRedefineComponents->put((void*) SchemaSymbols::fgELT_ATTRIBUTEGROUP, fullTypeNameId, 0); - } - } - else { - reportSchemaError - ( - redefineChildElem - , XMLUni::fgXMLErrDomain - , XMLErrs::Redefine_InvalidChild - , redefineChildComponentName - ); - return false; - } - - return true; -} - -int TraverseSchema::changeRedefineGroup(const DOMElement* const redefineChildElem, - const XMLCh* const redefineChildComponentName, - const XMLCh* const redefineChildTypeName, - const int redefineNameCounter) { - int result = 0; - DOMElement* child = XUtil::getFirstChildElement(redefineChildElem); - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* name = child->getLocalName(); - - if (XMLString::equals(name, SchemaSymbols::fgELT_ANNOTATION)) { - continue; - } - - if (!XMLString::equals(name, redefineChildComponentName)) { - result += changeRedefineGroup(child, redefineChildComponentName, redefineChildTypeName, redefineNameCounter); - } else { - const XMLCh* refName = getElementAttValue(child, SchemaSymbols::fgATT_REF, DatatypeValidator::QName); - - if (refName && *refName) { - - const XMLCh* prefix = getPrefix(refName); - const XMLCh* localPart = getLocalPart(refName); - const XMLCh* uriStr = resolvePrefixToURI(child, prefix); - - if (fTargetNSURI == (int) fURIStringPool->addOrFind(uriStr) - && fStringPool->addOrFind(localPart) == fStringPool->addOrFind(redefineChildTypeName)) { - - // now we have to do the renaming... - getRedefineNewTypeName(refName, redefineNameCounter, fBuffer); - child->setAttribute(SchemaSymbols::fgATT_REF, fBuffer.getRawBuffer()); - result++; - - if(XMLString::equals(redefineChildComponentName, SchemaSymbols::fgELT_GROUP)) { - - const XMLCh* minOccurs = getElementAttValue(child, SchemaSymbols::fgATT_MINOCCURS, DatatypeValidator::Decimal); - const XMLCh* maxOccurs = getElementAttValue(child, SchemaSymbols::fgATT_MAXOCCURS, DatatypeValidator::Decimal); - - if (((maxOccurs && *maxOccurs) && !XMLString::equals(maxOccurs, fgValueOne)) - || ((minOccurs && *minOccurs) && !XMLString::equals(minOccurs, fgValueOne))) { - reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_InvalidGroupMinMax, redefineChildTypeName); - } - } - } - } // if ref was null some other stage of processing will flag the error - } - } - - return result; -} - - -void TraverseSchema::fixRedefinedSchema(const DOMElement* const elem, - SchemaInfo* const redefinedSchemaInfo, - const XMLCh* const redefineChildComponentName, - const XMLCh* const redefineChildTypeName, - const int redefineNameCounter) { - - bool foundIt = false; - DOMElement* child = XUtil::getFirstChildElement(redefinedSchemaInfo->getRoot()); - - restoreSchemaInfo(redefinedSchemaInfo); - - for (; child != 0; child = XUtil::getNextSiblingElement(child)) { - - const XMLCh* name = child->getLocalName(); - - if (XMLString::equals(name, redefineChildComponentName)) { - - const XMLCh* infoItemName = getElementAttValue(child, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - - if(!XMLString::equals(infoItemName, redefineChildTypeName)) { - continue; - } - else { // found it! - - // now we have to do the renaming... - foundIt = true; - getRedefineNewTypeName(infoItemName, redefineNameCounter, fBuffer); - child->setAttribute(SchemaSymbols::fgATT_NAME, fBuffer.getRawBuffer()); - break; - } - } - else if (XMLString::equals(name, SchemaSymbols::fgELT_REDEFINE)) { // need to search the redefine decl... - - for (DOMElement* redefChild = XUtil::getFirstChildElement(child); - redefChild != 0; - redefChild = XUtil::getNextSiblingElement(redefChild)) { - - const XMLCh* redefName = redefChild->getLocalName(); - - if (XMLString::equals(redefName, redefineChildComponentName)) { - - const XMLCh* infoItemName = getElementAttValue(redefChild, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName); - - if(!XMLString::equals(infoItemName, redefineChildTypeName)) { - continue; - } - else { // found it! - - if (!openRedefinedSchema(child)) { - - redefinedSchemaInfo->addFailedRedefine(child); - return; - } - - foundIt = true; - - SchemaInfo* reRedefinedSchemaInfo = fSchemaInfo; - - if (validateRedefineNameChange(redefChild, redefineChildComponentName, redefineChildTypeName, redefineNameCounter + 1, redefinedSchemaInfo)) { - - fixRedefinedSchema(redefChild, reRedefinedSchemaInfo, redefineChildComponentName, redefineChildTypeName, redefineNameCounter + 1); - - // now we have to do the renaming... - getRedefineNewTypeName(infoItemName, redefineNameCounter, fBuffer); - const XMLCh* newInfoItemName = fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer())); - redefChild->setAttribute(SchemaSymbols::fgATT_NAME, newInfoItemName); - - // and we now know we will traverse this, so set fRedefineComponents appropriately... - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(newInfoItemName); - } - else { - - fixRedefinedSchema(redefChild, reRedefinedSchemaInfo, redefineChildComponentName, redefineChildTypeName, redefineNameCounter); - redefinedSchemaInfo->addFailedRedefine(redefChild); - - // and we now know we will traverse this, so set fRedefineComponents appropriately... - fBuffer.set(fTargetNSURIString); - fBuffer.append(chComma); - fBuffer.append(infoItemName); - } - - unsigned int infoItemNameId = fStringPool->addOrFind(fBuffer.getRawBuffer()); - - if (!fRedefineComponents->containsKey(redefineChildComponentName, infoItemNameId)) { - fRedefineComponents->put((void*) redefineChildComponentName, infoItemNameId, 0); - } - - break; - } - } - } //for - - if (foundIt) { - break; - } - } - } //for - - if(!foundIt) { - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Redefine_DeclarationNotFound, redefineChildTypeName); - } -} - -bool TraverseSchema::isSubstitutionGroupCircular(SchemaElementDecl* const elemDecl, - SchemaElementDecl* const subsElemDecl) -{ - - if (elemDecl == subsElemDecl) - return true; - - SchemaElementDecl* tmpElemDecl = subsElemDecl->getSubstitutionGroupElem(); - - while (tmpElemDecl) - { - if (tmpElemDecl == elemDecl) - return true; - - tmpElemDecl = tmpElemDecl->getSubstitutionGroupElem(); - } - - return false; -} - -// --------------------------------------------------------------------------- -// TraverseSchema: Error reporting methods -// --------------------------------------------------------------------------- -void TraverseSchema::reportSchemaError(const XSDLocator* const aLocator, - const XMLCh* const msgDomain, - const int errorCode) { - - fXSDErrorReporter.emitError(errorCode, msgDomain, aLocator); -} - -void TraverseSchema::reportSchemaError(const XSDLocator* const aLocator, - const XMLCh* const msgDomain, - const int errorCode, - const XMLCh* const text1, - const XMLCh* const text2, - const XMLCh* const text3, - const XMLCh* const text4) { - - fXSDErrorReporter.emitError(errorCode, msgDomain, aLocator, text1, text2, text3, text4, fMemoryManager); -} - -void TraverseSchema::reportSchemaError(const DOMElement* const elem, - const XMLCh* const msgDomain, - const int errorCode) { - - fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0, - ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - - fXSDErrorReporter.emitError(errorCode, msgDomain, fLocator); -} - -void TraverseSchema::reportSchemaError(const DOMElement* const elem, - const XMLCh* const msgDomain, - const int errorCode, - const XMLCh* const text1, - const XMLCh* const text2, - const XMLCh* const text3, - const XMLCh* const text4) { - - fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0, - ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - - fXSDErrorReporter.emitError(errorCode, msgDomain, fLocator, text1, text2, text3, text4, fMemoryManager); -} - -void TraverseSchema::reportSchemaError(const DOMElement* const elem, - const XMLException& except) -{ - fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0, - ((XSDElementNSImpl*) elem)->getLineNo(), - ((XSDElementNSImpl*) elem)->getColumnNo()); - - fXSDErrorReporter.emitError(except, fLocator); -} -// --------------------------------------------------------------------------- -// TraverseSchema: Init/CleanUp methods -// --------------------------------------------------------------------------- -void TraverseSchema::init() { - - fXSDErrorReporter.setErrorReporter(fErrorReporter); - fXSDErrorReporter.setExitOnFirstFatal(fScanner->getExitOnFirstFatal()); - - fFullConstraintChecking = fScanner->getValidationSchemaFullChecking(); - - fDatatypeRegistry = fSchemaGrammar->getDatatypeRegistry(); - fStringPool = fGrammarResolver->getStringPool(); - fEmptyNamespaceURI = fScanner->getEmptyNamespaceId(); - fCurrentTypeNameStack = new (fMemoryManager) ValueVectorOf<unsigned int>(8, fMemoryManager); - fCurrentGroupStack = new (fMemoryManager) ValueVectorOf<unsigned int>(8, fMemoryManager); - - fGlobalDeclarations = (ValueVectorOf<unsigned int>**) fMemoryManager->allocate - ( - ENUM_ELT_SIZE * sizeof(ValueVectorOf<unsigned int>*) - );//new ValueVectorOf<unsigned int>*[ENUM_ELT_SIZE]; - memset(fGlobalDeclarations, 0, ENUM_ELT_SIZE * sizeof(ValueVectorOf<unsigned int>*)); - for(unsigned int i=0; i < ENUM_ELT_SIZE; i++) - fGlobalDeclarations[i] = new (fMemoryManager) ValueVectorOf<unsigned int>(8, fMemoryManager); - - fNonXSAttList = new (fMemoryManager) ValueVectorOf<DOMNode*>(4, fMemoryManager); - fNotationRegistry = new (fMemoryManager) RefHash2KeysTableOf<XMLCh>(13, (bool) false, fMemoryManager); - fPreprocessedNodes = new (fMemoryManager) RefHashTableOf<SchemaInfo, PtrHasher> - ( - 29 - , false - , fMemoryManager - ); - fLocator = new (fMemoryManager) XSDLocator(); - fDeclStack = new (fMemoryManager) ValueVectorOf<const DOMElement*>(16, fMemoryManager); -} - -void TraverseSchema::cleanUp() { - - delete fCurrentTypeNameStack; - delete fCurrentGroupStack; - - if (fGlobalDeclarations) - { - for(unsigned int i=0; i < ENUM_ELT_SIZE; i++) - delete fGlobalDeclarations[i]; - fMemoryManager->deallocate(fGlobalDeclarations);//delete [] fGlobalDeclarations; - } - - delete fNonXSAttList; - delete fImportedNSList; - delete fNotationRegistry; - delete fRedefineComponents; - delete fIdentityConstraintNames; - delete fDeclStack; - delete fIC_ElementsNS; - delete fIC_NodeListNS; - delete fPreprocessedNodes; - delete fLocator; - delete fParser; -} - -void TraverseSchema::processElemDeclAttrs(const DOMElement* const elem, - SchemaElementDecl* const elemDecl, - const XMLCh*& valueConstraint, - bool isTopLevel) -{ - int elementMiscFlags = 0; - const XMLCh* fixedVal = getElementAttValue(elem, SchemaSymbols::fgATT_FIXED); - const XMLCh* nillable = getElementAttValue(elem, SchemaSymbols::fgATT_NILLABLE, DatatypeValidator::Boolean); - - // check constraint value - valueConstraint = getElementAttValue(elem, SchemaSymbols::fgATT_DEFAULT); - if (fixedVal) - { - elementMiscFlags |= SchemaSymbols::XSD_FIXED; - - // if both default and fixed, emit an error - if (valueConstraint) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::ElementWithFixedAndDefault, getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName)); - - // set constraint value to the fixed one - valueConstraint = fixedVal; - } - - // check nillable - if (nillable && *nillable) { - - if (XMLString::equals(nillable, SchemaSymbols::fgATTVAL_TRUE) - || XMLString::equals(nillable, fgValueOne)) { - elementMiscFlags |= SchemaSymbols::XSD_NILLABLE; - } - } - - if (isTopLevel) - { - const XMLCh* bAbstract = getElementAttValue(elem, SchemaSymbols::fgATT_ABSTRACT, DatatypeValidator::Boolean); - if (bAbstract && *bAbstract) { - - if (XMLString::equals(bAbstract, SchemaSymbols::fgATTVAL_TRUE) - || XMLString::equals(bAbstract, fgValueOne)) { - elementMiscFlags |= SchemaSymbols::XSD_ABSTRACT; - } - } - - elemDecl->setFinalSet(parseFinalSet(elem, EC_Final)); - } - - elemDecl->setBlockSet(parseBlockSet(elem, ES_Block)); - elemDecl->setMiscFlags(elementMiscFlags); -} - -void TraverseSchema::processElemDeclIC(DOMElement* const icElem, - SchemaElementDecl* const elemDecl) -{ - // key/keyref/unique processing - ValueVectorOf<DOMElement*>* icNodes = 0; - DOMElement* ic = icElem; - while (ic != 0) { - - if (XMLString::equals(ic->getLocalName(), SchemaSymbols::fgELT_KEY)) { - traverseKey(ic, elemDecl); - } - else if (XMLString::equals(ic->getLocalName(), SchemaSymbols::fgELT_UNIQUE)) { - traverseUnique(ic, elemDecl); - } - else { - - if (!icNodes) { - icNodes = new (fGrammarPoolMemoryManager) ValueVectorOf<DOMElement*>(8, fGrammarPoolMemoryManager); - } - - icNodes->addElement(ic); - } - - ic = XUtil::getNextSiblingElementNS( - ic, fgIdentityConstraints, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, 3); - } - - if (icNodes) { - - if (!fIC_ElementsNS) { - - fIC_ElementsNS = new (fMemoryManager) RefHashTableOf<ElemVector>(13, fMemoryManager); - fIC_NodeListNS = new (fMemoryManager) RefHashTableOf<ValueVectorOf<DOMElement*>, PtrHasher>(29, true, fMemoryManager); - } - - fIC_Elements = fIC_ElementsNS->get(fTargetNSURIString); - if (!fIC_Elements) { - fIC_Elements = new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(8, fMemoryManager); - fIC_ElementsNS->put((void*) fTargetNSURIString, fIC_Elements); - } - - fIC_NodeListNS->put(elemDecl, icNodes); - fIC_Elements->addElement(elemDecl); - } -} - -bool -TraverseSchema::checkElemDeclValueConstraint(const DOMElement* const elem, - SchemaElementDecl* const elemDecl, - const XMLCh* const valConstraint, - ComplexTypeInfo* const typeInfo, - DatatypeValidator* const validator) -{ - bool isValid = false; - if (validator) - { - if (validator->getType() == DatatypeValidator::ID) - reportSchemaError( - elem, XMLUni::fgXMLErrDomain, XMLErrs::ElemIDValueConstraint - , elemDecl->getBaseName(), valConstraint - ); - - try - { - const XMLCh* valueToCheck = valConstraint; - short wsFacet = validator->getWSFacet(); - if((wsFacet == DatatypeValidator::REPLACE && !XMLString::isWSReplaced(valueToCheck)) || - (wsFacet == DatatypeValidator::COLLAPSE && !XMLString::isWSCollapsed(valueToCheck))) - { - XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager); - ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager); - if(wsFacet == DatatypeValidator::REPLACE) - XMLString::replaceWS(normalizedValue, fMemoryManager); - else if(wsFacet == DatatypeValidator::COLLAPSE) - XMLString::collapseWS(normalizedValue, fMemoryManager); - valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue)); - } - - validator->validate(valueToCheck,0,fMemoryManager); - - XMLCh* canonical = (XMLCh*) validator->getCanonicalRepresentation(valueToCheck, fMemoryManager); - ArrayJanitor<XMLCh> tempCanonical(canonical, fMemoryManager); - - if(!XMLString::equals(canonical, valueToCheck)) - { - validator->validate(canonical, 0, fMemoryManager); - valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(canonical)); - } - - elemDecl->setDefaultValue(valueToCheck); - - isValid = true; - } - catch(const XMLException& excep) - { - reportSchemaError(elem, excep); - } - catch(const OutOfMemoryException&) - { - throw; - } - catch(...) - { - reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::DatatypeValidationFailure, valConstraint); - } - } - - if (typeInfo) - { - int contentSpecType = typeInfo->getContentType(); - - if (contentSpecType != SchemaElementDecl::Simple && - contentSpecType != SchemaElementDecl::Mixed_Simple && - contentSpecType != SchemaElementDecl::Mixed_Complex) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NotSimpleOrMixedElement, elemDecl->getBaseName()); - - if (((contentSpecType == SchemaElementDecl::Mixed_Complex - || contentSpecType == SchemaElementDecl::Mixed_Simple) - && !emptiableParticle(typeInfo->getContentSpec()))) - reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::EmptiableMixedContent, elemDecl->getBaseName()); - } - - return isValid; -} - -void TraverseSchema::processSubstitutionGroup(const DOMElement* const elem, - SchemaElementDecl* const elemDecl, - ComplexTypeInfo*& typeInfo, - DatatypeValidator*& validator, - const XMLCh* const subsElemQName) -{ - NamespaceScopeManager nsMgr(elem, fSchemaInfo, this); - - SchemaElementDecl* subsElemDecl = getGlobalElemDecl(elem, subsElemQName); - if (subsElemDecl) - { - if (isSubstitutionGroupCircular(elemDecl, subsElemDecl)) - { - reportSchemaError( - elem , XMLUni::fgXMLErrDomain , XMLErrs::CircularSubsGroup, elemDecl->getBaseName()); - } - else - { - // Check for substitution validity constraint - // Substitution allowed (block and blockDefault) && same type - if (isSubstitutionGroupValid(elem, subsElemDecl, typeInfo, validator, elemDecl->getBaseName())) - { - elemDecl->setSubstitutionGroupElem(subsElemDecl); - - // if type information is missing, use subsGroup one - if (!typeInfo && !validator) - { - typeInfo = subsElemDecl->getComplexTypeInfo(); - validator = subsElemDecl->getDatatypeValidator(); - - if (validator) - { - elemDecl->setDatatypeValidator(validator); - elemDecl->setModelType(SchemaElementDecl::Simple); - } - else if (typeInfo) - { - elemDecl->setComplexTypeInfo(typeInfo); - elemDecl->setModelType((SchemaElementDecl::ModelTypes)typeInfo->getContentType()); - } - } - - XMLCh* subsElemBaseName = subsElemDecl->getBaseName(); - int subsElemURI = subsElemDecl->getURI(); - ValueVectorOf<SchemaElementDecl*>* subsElements = - fValidSubstitutionGroups->get(subsElemBaseName, subsElemURI); - - if (!subsElements && fTargetNSURI != subsElemURI) - { - SchemaGrammar* aGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(fURIStringPool->getValueForId(subsElemURI)); - - if (aGrammar) - { - subsElements = aGrammar->getValidSubstitutionGroups()->get(subsElemBaseName, subsElemURI); - - if (subsElements) - { - subsElements = new (fGrammarPoolMemoryManager) ValueVectorOf<SchemaElementDecl*>(*subsElements); - fValidSubstitutionGroups->put(subsElemBaseName, subsElemURI, subsElements); - } - else if (fSchemaInfo->circularImportExist(subsElemURI)) - { - aGrammar->getValidSubstitutionGroups()->put( - subsElemBaseName, subsElemURI, new (fGrammarPoolMemoryManager) ValueVectorOf<SchemaElementDecl*>(8, fGrammarPoolMemoryManager)); - } - } - } - - if (!subsElements) - { - subsElements = new (fGrammarPoolMemoryManager) ValueVectorOf<SchemaElementDecl*>(8, fGrammarPoolMemoryManager); - fValidSubstitutionGroups->put(subsElemBaseName, subsElemURI, subsElements); - } - - subsElements->addElement(elemDecl); - - // update related subs. info in case of circular import - BaseRefVectorEnumerator<SchemaInfo> importingEnum = fSchemaInfo->getImportingListEnumerator(); - - while (importingEnum.hasMoreElements()) - { - const SchemaInfo& curRef = importingEnum.nextElement(); - SchemaGrammar* aGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(curRef.getTargetNSURIString()); - ValueVectorOf<SchemaElementDecl*>* subsElemList = - aGrammar->getValidSubstitutionGroups()->get(subsElemBaseName, subsElemURI); - - if (subsElemList && !subsElemList->containsElement(elemDecl)) - subsElemList->addElement(elemDecl); - } - - buildValidSubstitutionListB(elem, elemDecl, subsElemDecl); - buildValidSubstitutionListF(elem, elemDecl, subsElemDecl); - } - } - } -} - -void TraverseSchema::processAttValue(const XMLCh* const attVal, - XMLBuffer& aBuf) -{ - // REVISIT-KN: assuming that attVal is not NULL - // - // normally, nothing will happen - const XMLCh* srcVal = attVal; - XMLCh nextCh = *srcVal; - while (nextCh) - { - if (nextCh <= chCloseAngle) { - switch (nextCh) { - case chDoubleQuote: - aBuf.append(chAmpersand); - aBuf.append(XMLUni::fgQuot); - aBuf.append(chSemiColon); - break; - case chSingleQuote: - aBuf.append(chAmpersand); - aBuf.append(XMLUni::fgApos); - aBuf.append(chSemiColon); - break; - case chCloseAngle: - aBuf.append(chAmpersand); - aBuf.append(XMLUni::fgGT); - aBuf.append(chSemiColon); - break; - case chOpenAngle: - aBuf.append(chAmpersand); - aBuf.append(XMLUni::fgLT); - aBuf.append(chSemiColon); - break; - case chAmpersand: - aBuf.append(chAmpersand); - aBuf.append(XMLUni::fgAmp); - aBuf.append(chSemiColon); - break; - default: - aBuf.append(nextCh); - break; - } // end switch - } - else - aBuf.append(nextCh); - - nextCh = *++srcVal; - } -} - -XSAnnotation* TraverseSchema::generateSyntheticAnnotation(const DOMElement* const elem - , ValueVectorOf<DOMNode*>* nonXSAttList) -{ - const XMLCh* prefix = elem->getPrefix(); - ValueHashTableOf<unsigned int>* listOfURIs = new (fMemoryManager) ValueHashTableOf<unsigned int>(29, fMemoryManager); - bool sawXMLNS = false; - - fBuffer.reset(); - fBuffer.append(chOpenAngle); - if (prefix) - { - fBuffer.append(prefix); - fBuffer.append(chColon); - } - fBuffer.append(SchemaSymbols::fgELT_ANNOTATION); - - // next is the nonXSAttList names & values - XMLSize_t nonXSAttSize = nonXSAttList->size(); - - for (XMLSize_t i=0; i<nonXSAttSize; i++) - { - DOMNode* attNode = nonXSAttList->elementAt(i); - - fBuffer.append(chSpace); - fBuffer.append(attNode->getNodeName()); - fBuffer.append(chEqual); - fBuffer.append(chDoubleQuote); - processAttValue(attNode->getNodeValue(), fBuffer); - fBuffer.append(chDoubleQuote); - } - - // next is the namespaces on the elem - DOMElement* currentElem = (DOMElement*) elem; - DOMNamedNodeMap* eltAttrs; - XMLSize_t attrCount; - do { - eltAttrs = currentElem->getAttributes(); - attrCount = eltAttrs->getLength(); - for (XMLSize_t j = 0; j < attrCount; j++) - { - DOMNode* attribute = eltAttrs->item(j); - const XMLCh* attName = attribute->getNodeName(); - - if (XMLString::startsWith(attName, XMLUni::fgXMLNSColonString)) - { - if (!listOfURIs->containsKey((void*) attName)) { - listOfURIs->put((void*) attName, 0); - fBuffer.append(chSpace); - fBuffer.append(attName); - fBuffer.append(chEqual); - fBuffer.append(chDoubleQuote); - processAttValue(attribute->getNodeValue(), fBuffer); - fBuffer.append(chDoubleQuote); - } - } - else if (!sawXMLNS && XMLString::equals(attName, XMLUni::fgXMLNSString)) - { - fBuffer.append(chSpace); - fBuffer.append(attName); - fBuffer.append(chEqual); - fBuffer.append(chDoubleQuote); - processAttValue(attribute->getNodeValue(), fBuffer); - fBuffer.append(chDoubleQuote); - sawXMLNS = true; - } - } - currentElem = (DOMElement*) currentElem->getParentNode(); - } - while (currentElem != fSchemaInfo->getRoot()->getParentNode()); - delete listOfURIs; - - fBuffer.append(chCloseAngle); - fBuffer.append(chLF); - fBuffer.append(chOpenAngle); - if (prefix) - { - fBuffer.append(prefix); - fBuffer.append(chColon); - } - fBuffer.append(SchemaSymbols::fgELT_DOCUMENTATION); - fBuffer.append(chCloseAngle); - fBuffer.append(fgSynthetic_Annotation); - fBuffer.append(chOpenAngle); - fBuffer.append(chForwardSlash); - if (prefix) - { - fBuffer.append(prefix); - fBuffer.append(chColon); - } - fBuffer.append(SchemaSymbols::fgELT_DOCUMENTATION); - fBuffer.append(chCloseAngle); - fBuffer.append(chLF); - fBuffer.append(chOpenAngle); - fBuffer.append(chForwardSlash); - if (prefix) - { - fBuffer.append(prefix); - fBuffer.append(chColon); - } - fBuffer.append(SchemaSymbols::fgELT_ANNOTATION); - fBuffer.append(chCloseAngle); - - XSAnnotation* annot = new (fGrammarPoolMemoryManager) XSAnnotation(fBuffer.getRawBuffer(), fGrammarPoolMemoryManager); - annot->setLineCol( ((XSDElementNSImpl*)elem)->getLineNo() - , ((XSDElementNSImpl*)elem)->getColumnNo() ); - annot->setSystemId(fSchemaInfo->getCurrentSchemaURL()); - return annot; -} - -class AnnotationErrorReporter : public XMLErrorReporter -{ -public: - AnnotationErrorReporter(XMLErrorReporter* chainedErrorReporter) - { - fErrorReporter = chainedErrorReporter; - setSystemIdAndPosition(NULL, 0, 0); - } - - void setSystemIdAndPosition(const XMLCh* systemId, XMLFileLoc line, XMLFileLoc column) - { - fSystemId=systemId; - fLine=line; - fColumn=column; - } - - virtual void error - ( - const unsigned int errCode - , const XMLCh* const errDomain - , const ErrTypes type - , const XMLCh* const errorText - , const XMLCh* const /*systemId*/ - , const XMLCh* const publicId - , const XMLFileLoc lineNum - , const XMLFileLoc colNum - ) - { - if(fErrorReporter) - fErrorReporter->error(errCode, errDomain, type, errorText, fSystemId, publicId, fLine+lineNum-1, lineNum==1?fColumn+colNum:colNum); - } - - virtual void resetErrors() {} - -protected: - XMLErrorReporter* fErrorReporter; - const XMLCh* fSystemId; - XMLFileLoc fLine, fColumn; -}; - -void TraverseSchema::validateAnnotations() { - - MemoryManager *memMgr = fMemoryManager; - RefHashTableOfEnumerator<XSAnnotation, PtrHasher> xsAnnotationEnum = RefHashTableOfEnumerator<XSAnnotation, PtrHasher> (fSchemaGrammar->getAnnotations(), false, memMgr); - XSAnnotation& xsAnnot = xsAnnotationEnum.nextElement(); - XSAnnotation* nextAnnot; - - // create schema grammar - SchemaGrammar *grammar = new (memMgr) SchemaGrammar(memMgr); - grammar->setComplexTypeRegistry(new (memMgr) RefHashTableOf<ComplexTypeInfo>(29, memMgr)); - grammar->setGroupInfoRegistry(new (memMgr) RefHashTableOf<XercesGroupInfo>(13, memMgr)); - grammar->setAttGroupInfoRegistry(new (memMgr) RefHashTableOf<XercesAttGroupInfo>(13, memMgr)); - grammar->setAttributeDeclRegistry(new (memMgr) RefHashTableOf<XMLAttDef>(29, memMgr)); - grammar->setValidSubstitutionGroups(new (memMgr) RefHash2KeysTableOf<ElemVector>(29, memMgr)); - grammar->setTargetNamespace(SchemaSymbols::fgURI_SCHEMAFORSCHEMA); - XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) grammar->getGrammarDescription(); - gramDesc->setTargetNamespace(SchemaSymbols::fgURI_SCHEMAFORSCHEMA); - - // setup components of annotation grammar - SchemaElementDecl* annotElemDecl = new (memMgr) SchemaElementDecl - ( - XMLUni::fgZeroLenString , SchemaSymbols::fgELT_ANNOTATION - , fURIStringPool->addOrFind(SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - , SchemaElementDecl::Mixed_Complex, Grammar::TOP_LEVEL_SCOPE , memMgr - ); - annotElemDecl->setCreateReason(XMLElementDecl::Declared); - grammar->putElemDecl(annotElemDecl); - - ComplexTypeInfo* complexType = new (memMgr) ComplexTypeInfo(memMgr); - complexType->setAnonymous(); - complexType->setContentType(SchemaElementDecl::Mixed_Complex); - annotElemDecl->setComplexTypeInfo(complexType); - - fBuffer.set(SchemaSymbols::fgURI_SCHEMAFORSCHEMA); - fBuffer.append(chComma); - fBuffer.append(chLatin_C); - fBuffer.append(chDigit_0); - const XMLCh* fullName = fStringPool->getValueForId(fStringPool->addOrFind(fBuffer.getRawBuffer())); - grammar->getComplexTypeRegistry()->put((void*) fullName, complexType); - complexType->setTypeName(fullName); - complexType->setAttWildCard - ( - new (memMgr) SchemaAttDef - ( - XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, - fEmptyNamespaceURI, XMLAttDef::Any_Any, - XMLAttDef::ProcessContents_Lax, memMgr - ) - ); - - SchemaElementDecl* appInfoElemDecl = new (memMgr) SchemaElementDecl - ( - XMLUni::fgZeroLenString , SchemaSymbols::fgELT_APPINFO - , fURIStringPool->addOrFind(SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - , SchemaElementDecl::Any, Grammar::TOP_LEVEL_SCOPE , memMgr - ); - - appInfoElemDecl->setCreateReason(XMLElementDecl::Declared); - appInfoElemDecl->setAttWildCard - ( - new (memMgr) SchemaAttDef - ( - XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, - fEmptyNamespaceURI, XMLAttDef::Any_Any, - XMLAttDef::ProcessContents_Lax, memMgr - ) - ); - grammar->putElemDecl(appInfoElemDecl); - complexType->addElement(appInfoElemDecl); - - SchemaElementDecl* docElemDecl = new (memMgr) SchemaElementDecl - ( - XMLUni::fgZeroLenString , SchemaSymbols::fgELT_DOCUMENTATION - , fURIStringPool->addOrFind(SchemaSymbols::fgURI_SCHEMAFORSCHEMA) - , SchemaElementDecl::Any, Grammar::TOP_LEVEL_SCOPE , memMgr - ); - - docElemDecl->setCreateReason(XMLElementDecl::Declared); - docElemDecl->setAttWildCard - ( - new (memMgr) SchemaAttDef - ( - XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, - fEmptyNamespaceURI, XMLAttDef::Any_Any, - XMLAttDef::ProcessContents_Lax, memMgr - ) - ); - grammar->putElemDecl(docElemDecl); - complexType->addElement(docElemDecl); - - ContentSpecNode* left = new (memMgr) ContentSpecNode(appInfoElemDecl, memMgr); - ContentSpecNode* right = new (memMgr) ContentSpecNode(docElemDecl, memMgr); - ContentSpecNode* root = new (memMgr) ContentSpecNode(ContentSpecNode::ModelGroupChoice - , left - , right - , true - , true - , memMgr); - root->setMinOccurs(0); - root->setMaxOccurs(SchemaSymbols::XSD_UNBOUNDED); - complexType->setContentSpec(root); - - // create input source to scan - MemBufInputSource* memBufIS = new (memMgr) MemBufInputSource - ( - (const XMLByte*)xsAnnot.getAnnotationString() - , XMLString::stringLen(xsAnnot.getAnnotationString())*sizeof(XMLCh) - , SchemaSymbols::fgELT_ANNOTATION - , false - , memMgr - ); - Janitor<MemBufInputSource> janMemBuf(memBufIS); - memBufIS->setEncoding(XMLUni::fgXMLChEncodingString); - memBufIS->setCopyBufToStream(false); - - XSAXMLScanner *scanner = new (memMgr) XSAXMLScanner - ( - fGrammarResolver, fURIStringPool, grammar, memMgr - ); - Janitor<XSAXMLScanner> janScanner(scanner); - - AnnotationErrorReporter annErrReporter(fErrorReporter); - scanner->setErrorReporter(&annErrReporter); - - XMLFileLoc line, col; - xsAnnot.getLineCol(line, col); - annErrReporter.setSystemIdAndPosition(xsAnnot.getSystemId(), line, col); - scanner->scanDocument(*memBufIS); - - nextAnnot = xsAnnot.getNext(); - - while (nextAnnot || xsAnnotationEnum.hasMoreElements()) - { - if (nextAnnot) { - memBufIS->resetMemBufInputSource((const XMLByte*)nextAnnot->getAnnotationString() - , XMLString::stringLen(nextAnnot->getAnnotationString())*sizeof(XMLCh)); - nextAnnot->getLineCol(line, col); - annErrReporter.setSystemIdAndPosition(nextAnnot->getSystemId(), line, col); - nextAnnot = nextAnnot->getNext(); - } - else { - XSAnnotation& xsAnnot = xsAnnotationEnum.nextElement(); - memBufIS->resetMemBufInputSource((const XMLByte*)xsAnnot.getAnnotationString() - , XMLString::stringLen(xsAnnot.getAnnotationString())*sizeof(XMLCh)); - xsAnnot.getLineCol(line, col); - annErrReporter.setSystemIdAndPosition(xsAnnot.getSystemId(), line, col); - nextAnnot = xsAnnot.getNext(); - } - scanner->scanDocument(*memBufIS); - } - -} - -const XMLCh* TraverseSchema::getElementAttValue(const DOMElement* const elem, - const XMLCh* const attName, - const DatatypeValidator::ValidatorType attType /* = UnKnown */) { - - DOMAttr* attNode = elem->getAttributeNode(attName); - - if (attNode == 0) { - return 0; - } - - const XMLCh* attValue = attNode->getValue(); - - if (attType < DatatypeValidator::ID) { - static bool bInitialized = false; - static short wsFacets[DatatypeValidator::ID] = {0}; - if(!bInitialized) - { - bInitialized=true; - DVHashTable* registry = DatatypeValidatorFactory::getBuiltInRegistry(); - wsFacets[DatatypeValidator::String] = registry->get(SchemaSymbols::fgDT_STRING)->getWSFacet(); - wsFacets[DatatypeValidator::AnyURI] = registry->get(SchemaSymbols::fgDT_ANYURI)->getWSFacet(); - wsFacets[DatatypeValidator::QName] = registry->get(SchemaSymbols::fgDT_QNAME)->getWSFacet(); - wsFacets[DatatypeValidator::Name] = registry->get(SchemaSymbols::fgDT_NAME)->getWSFacet(); - wsFacets[DatatypeValidator::NCName] = registry->get(SchemaSymbols::fgDT_NCNAME)->getWSFacet(); - wsFacets[DatatypeValidator::Boolean] = registry->get(SchemaSymbols::fgDT_BOOLEAN)->getWSFacet(); - wsFacets[DatatypeValidator::Float] = registry->get(SchemaSymbols::fgDT_FLOAT)->getWSFacet(); - wsFacets[DatatypeValidator::Double] = registry->get(SchemaSymbols::fgDT_DOUBLE)->getWSFacet(); - wsFacets[DatatypeValidator::Decimal] = registry->get(SchemaSymbols::fgDT_DECIMAL)->getWSFacet(); - wsFacets[DatatypeValidator::HexBinary] = registry->get(SchemaSymbols::fgDT_HEXBINARY)->getWSFacet(); - wsFacets[DatatypeValidator::Base64Binary]= registry->get(SchemaSymbols::fgDT_BASE64BINARY)->getWSFacet(); - wsFacets[DatatypeValidator::Duration] = registry->get(SchemaSymbols::fgDT_DURATION)->getWSFacet(); - wsFacets[DatatypeValidator::DateTime] = registry->get(SchemaSymbols::fgDT_DATETIME)->getWSFacet(); - wsFacets[DatatypeValidator::Date] = registry->get(SchemaSymbols::fgDT_DATE)->getWSFacet(); - wsFacets[DatatypeValidator::Time] = registry->get(SchemaSymbols::fgDT_TIME)->getWSFacet(); - wsFacets[DatatypeValidator::MonthDay] = registry->get(SchemaSymbols::fgDT_MONTHDAY)->getWSFacet(); - wsFacets[DatatypeValidator::YearMonth] = registry->get(SchemaSymbols::fgDT_YEARMONTH)->getWSFacet(); - wsFacets[DatatypeValidator::Year] = registry->get(SchemaSymbols::fgDT_YEAR)->getWSFacet(); - wsFacets[DatatypeValidator::Month] = registry->get(SchemaSymbols::fgDT_MONTH)->getWSFacet(); - wsFacets[DatatypeValidator::Day] = registry->get(SchemaSymbols::fgDT_DAY)->getWSFacet(); - } - short wsFacet = wsFacets[attType]; - if((wsFacet == DatatypeValidator::REPLACE && !XMLString::isWSReplaced(attValue)) || - (wsFacet == DatatypeValidator::COLLAPSE && !XMLString::isWSCollapsed(attValue))) - { - XMLCh* normalizedValue=XMLString::replicate(attValue, fMemoryManager); - ArrayJanitor<XMLCh> tempName(normalizedValue, fMemoryManager); - if(wsFacet == DatatypeValidator::REPLACE) - XMLString::replaceWS(normalizedValue, fMemoryManager); - else if(wsFacet == DatatypeValidator::COLLAPSE) - XMLString::collapseWS(normalizedValue, fMemoryManager); - if (!*normalizedValue) - return XMLUni::fgZeroLenString; - return fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue)); - } - } - - return attValue; -} - -XERCES_CPP_NAMESPACE_END - -/** - * End of file TraverseSchema.cpp - */ |