| /* Copyright 2004 The Apache Software Foundation |
| * |
| * Licensed 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. |
| */ |
| |
| package org.apache.xmlbeans.impl.schema; |
| |
| import java.math.BigInteger; |
| import java.util.*; |
| import java.util.List; |
| |
| import org.apache.xmlbeans.impl.xb.xsdschema.*; |
| import org.apache.xmlbeans.impl.xb.xsdschema.SchemaDocument.Schema; |
| import org.apache.xmlbeans.impl.xb.xsdschema.AnyDocument.Any; |
| import javax.xml.namespace.QName; |
| import org.apache.xmlbeans.XmlErrorCodes; |
| import org.apache.xmlbeans.impl.common.QNameHelper; |
| import org.apache.xmlbeans.XmlObject; |
| import org.apache.xmlbeans.QNameSetBuilder; |
| import org.apache.xmlbeans.XmlInteger; |
| import org.apache.xmlbeans.SchemaField; |
| import org.apache.xmlbeans.SchemaType; |
| import org.apache.xmlbeans.SchemaParticle; |
| import org.apache.xmlbeans.XmlCursor; |
| import org.apache.xmlbeans.SchemaAttributeModel; |
| import org.apache.xmlbeans.SchemaProperty; |
| import org.apache.xmlbeans.QNameSet; |
| import org.apache.xmlbeans.XmlNonNegativeInteger; |
| import org.apache.xmlbeans.SchemaLocalAttribute; |
| import org.apache.xmlbeans.SchemaLocalElement; |
| import org.apache.xmlbeans.QNameSetSpecification; |
| |
| public class StscComplexTypeResolver |
| { |
| public static Group getContentModel(ComplexType parseCt) |
| { |
| if (parseCt.getAll() != null) |
| return parseCt.getAll(); |
| |
| if (parseCt.getSequence() != null) |
| return parseCt.getSequence(); |
| |
| if (parseCt.getChoice() != null) |
| return parseCt.getChoice(); |
| |
| if (parseCt.getGroup() != null) |
| return parseCt.getGroup(); |
| |
| return null; |
| } |
| |
| public static Group getContentModel(ComplexRestrictionType parseRest) |
| { |
| if (parseRest.getAll() != null) |
| return parseRest.getAll(); |
| |
| if (parseRest.getSequence() != null) |
| return parseRest.getSequence(); |
| |
| if (parseRest.getChoice() != null) |
| return parseRest.getChoice(); |
| |
| if (parseRest.getGroup() != null) |
| return parseRest.getGroup(); |
| |
| return null; |
| |
| } |
| |
| public static Group getContentModel(ExtensionType parseExt) |
| { |
| if (parseExt.getAll() != null) |
| return parseExt.getAll(); |
| |
| if (parseExt.getSequence() != null) |
| return parseExt.getSequence(); |
| |
| if (parseExt.getChoice() != null) |
| return parseExt.getChoice(); |
| |
| if (parseExt.getGroup() != null) |
| return parseExt.getGroup(); |
| |
| return null; |
| |
| } |
| |
| static Schema getSchema(XmlObject o) |
| { |
| XmlCursor c = o.newCursor(); |
| |
| try |
| { |
| while ( c.toParent() ) |
| { |
| o = c.getObject(); |
| |
| if (o.schemaType().equals(Schema.type)) |
| return (Schema) o; |
| } |
| } |
| finally |
| { |
| c.dispose(); |
| } |
| |
| return null; |
| } |
| |
| public static void resolveComplexType(SchemaTypeImpl sImpl) |
| { |
| ComplexType parseCt = (ComplexType)sImpl.getParseObject(); |
| StscState state = StscState.get(); |
| Schema schema = getSchema(parseCt); |
| |
| // Set abstract & final flags |
| boolean abs = parseCt.isSetAbstract() ? parseCt.getAbstract() : false; |
| boolean finalExt = false; |
| boolean finalRest = false; |
| boolean finalList = false; |
| boolean finalUnion = false; |
| |
| Object ds = null; |
| if (parseCt.isSetFinal()) |
| { |
| ds = parseCt.getFinal(); |
| } |
| // Inspect the final default attribute on the schema |
| else if (schema != null && schema.isSetFinalDefault()) |
| { |
| ds = schema.getFinalDefault(); |
| } |
| |
| if (ds != null) |
| { |
| if (ds instanceof String && ds.equals("#all")) |
| { |
| // #ALL value |
| finalExt = finalRest = finalList = finalUnion = true; |
| } |
| else if (ds instanceof List) |
| { |
| if (((List)ds).contains("extension")) |
| finalExt = true; |
| |
| if (((List)ds).contains("restriction")) |
| finalRest = true; |
| |
| // Since complex types don't participate in list and unions, these can remain |
| // false. Perhaps we should throw an error. |
| |
| // if (((List)ds).contains("list")) |
| // finalList = true; |
| // |
| // if (((List)ds).contains("union")) |
| // finalUnion = true; |
| } |
| } |
| |
| sImpl.setAbstractFinal(abs, finalExt, finalRest, finalList, finalUnion); |
| |
| // Set block flags |
| boolean blockExt = false; |
| boolean blockRest = false; |
| Object block = null; |
| |
| if (parseCt.isSetBlock()) |
| block = parseCt.getBlock(); |
| else if (schema != null && schema.isSetBlockDefault()) |
| block = schema.getBlockDefault(); |
| |
| if (block != null) |
| { |
| if (block instanceof String && block.equals("#all")) |
| { |
| // #ALL value |
| blockExt = blockRest = true; |
| } |
| else if (block instanceof List) |
| { |
| if (((List)block).contains("extension")) |
| blockExt = true; |
| if (((List)block).contains("restriction")) |
| blockRest = true; |
| } |
| } |
| |
| sImpl.setBlock(blockExt, blockRest); |
| |
| // Verify: have simpleContent, complexContent, or direct stuff |
| ComplexContentDocument.ComplexContent parseCc = parseCt.getComplexContent(); |
| SimpleContentDocument.SimpleContent parseSc = parseCt.getSimpleContent(); |
| Group parseGroup = getContentModel(parseCt); |
| int count = |
| (parseCc != null ? 1 : 0) + |
| (parseSc != null ? 1 : 0) + |
| (parseGroup != null ? 1 : 0); |
| if (count > 1) |
| { |
| // KHK: s4s should catch this? |
| state.error("A complex type must define either a content model, " + |
| "or a simpleContent or complexContent derivation: " + |
| "more than one found.", |
| XmlErrorCodes.REDUNDANT_CONTENT_MODEL, parseCt); |
| // recovery: treat it as the first of complexContent, simpleContent, model |
| parseGroup = null; |
| if (parseCc != null && parseSc != null) |
| parseSc = null; |
| } |
| |
| if (parseCc != null) |
| { |
| // KHK: s4s should catch this? |
| if (parseCc.getExtension() != null && parseCc.getRestriction() != null) |
| state.error("Restriction conflicts with extension", XmlErrorCodes.REDUNDANT_CONTENT_MODEL, parseCc.getRestriction()); |
| |
| // Mixed can be specified in two places: the rules are that Cc wins over Ct if present |
| // http://www.w3.org/TR/xmlschema-1/#c-mve |
| boolean mixed = parseCc.isSetMixed() ? parseCc.getMixed() : parseCt.getMixed(); |
| |
| if (parseCc.getExtension() != null) |
| resolveCcExtension(sImpl, parseCc.getExtension(), mixed); |
| else if (parseCc.getRestriction() != null) |
| resolveCcRestriction(sImpl, parseCc.getRestriction(), mixed); |
| else |
| { |
| // KHK: s4s should catch this? |
| state.error("Missing restriction or extension", XmlErrorCodes.MISSING_RESTRICTION_OR_EXTENSION, parseCc); |
| resolveErrorType(sImpl); |
| } |
| return; |
| } |
| else if (parseSc != null) |
| { |
| // KHK: s4s should catch this? |
| if (parseSc.getExtension() != null && parseSc.getRestriction() != null) |
| state.error("Restriction conflicts with extension", XmlErrorCodes.REDUNDANT_CONTENT_MODEL, parseSc.getRestriction()); |
| |
| if (parseSc.getExtension() != null) |
| resolveScExtension(sImpl, parseSc.getExtension()); |
| else if (parseSc.getRestriction() != null) |
| resolveScRestriction(sImpl, parseSc.getRestriction()); |
| else |
| { |
| // KHK: s4s should catch this? |
| state.error("Missing restriction or extension", XmlErrorCodes.MISSING_RESTRICTION_OR_EXTENSION, parseSc); |
| resolveErrorType(sImpl); |
| } |
| return; |
| } |
| else |
| resolveBasicComplexType(sImpl); |
| } |
| |
| static void resolveErrorType(SchemaTypeImpl sImpl) |
| { |
| throw new RuntimeException("This type of error recovery not yet implemented."); |
| } |
| |
| private static SchemaType.Ref[] makeRefArray(Collection typeList) |
| { |
| SchemaType.Ref[] result = new SchemaType.Ref[typeList.size()]; |
| int j = 0; |
| for (Iterator i = typeList.iterator(); i.hasNext(); j++) |
| result[j] = ((SchemaType)i.next()).getRef(); |
| return result; |
| } |
| |
| |
| static void resolveBasicComplexType(SchemaTypeImpl sImpl) |
| { |
| List anonymousTypes = new ArrayList(); |
| ComplexType parseTree = (ComplexType)sImpl.getParseObject(); |
| String targetNamespace = sImpl.getTargetNamespace(); |
| boolean chameleon = (sImpl.getChameleonNamespace() != null); |
| Group parseGroup = getContentModel(parseTree); |
| |
| if (sImpl.isRedefinition()) |
| { |
| StscState.get().error(XmlErrorCodes.SCHEMA_REDEFINE$EXTEND_OR_RESTRICT, |
| new Object[] { "<complexType>" }, parseTree); |
| // recovery: oh well. |
| } |
| |
| int particleCode = translateParticleCode(parseGroup); |
| |
| // used to ensure consistency (doesn't become part of the result) |
| Map elementModel = new LinkedHashMap(); |
| |
| // build content model and anonymous types |
| SchemaParticle contentModel = translateContentModel(sImpl, |
| parseGroup, targetNamespace, chameleon, |
| sImpl.getElemFormDefault(), sImpl.getAttFormDefault(), |
| particleCode, anonymousTypes, elementModel, false, null); |
| |
| // detect the nonempty "all" case (empty <all> doesn't count - it needs to be eliminated to match XSD test cases) |
| boolean isAll = contentModel != null && contentModel.getParticleType() == SchemaParticle.ALL; |
| |
| // build attr model and anonymous types |
| SchemaAttributeModelImpl attrModel = new SchemaAttributeModelImpl(); |
| translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(), |
| anonymousTypes, sImpl, null, attrModel, null, true, null); |
| |
| // summarize wildcard information |
| WildcardResult wcElt = summarizeEltWildcards(contentModel); |
| WildcardResult wcAttr = summarizeAttrWildcards(attrModel); |
| |
| // build state machine and verify that content model is deterministic |
| if (contentModel != null) |
| { |
| buildStateMachine(contentModel); |
| if (!StscState.get().noUpa() && !((SchemaParticleImpl)contentModel).isDeterministic()) |
| StscState.get().error(XmlErrorCodes.UNIQUE_PARTICLE_ATTRIBUTION, null, parseGroup); |
| } |
| |
| // build property model |
| // emitDBG("Building content Model for " + sImpl); |
| Map elementPropertyModel = buildContentPropertyModelByQName(contentModel, sImpl); |
| |
| // add attribute property model |
| Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl); |
| |
| // figure out content type |
| int complexVariety = |
| parseTree.getMixed() |
| ? SchemaType.MIXED_CONTENT |
| : contentModel == null |
| ? SchemaType.EMPTY_CONTENT |
| : SchemaType.ELEMENT_CONTENT; |
| |
| // now fill in the actual schema type implementation |
| sImpl.setBaseTypeRef(BuiltinSchemaTypeSystem.ST_ANY_TYPE.getRef()); |
| sImpl.setBaseDepth(BuiltinSchemaTypeSystem.ST_ANY_TYPE.getBaseDepth() + 1); |
| sImpl.setDerivationType(SchemaType.DT_EXTENSION); |
| sImpl.setComplexTypeVariety(complexVariety); |
| sImpl.setContentModel(contentModel, attrModel, elementPropertyModel, attributePropertyModel, isAll); |
| sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes)); |
| sImpl.setWildcardSummary(wcElt.typedWildcards, wcElt.hasWildcards, wcAttr.typedWildcards, wcAttr.hasWildcards); |
| } |
| |
| static void resolveCcRestriction(SchemaTypeImpl sImpl, ComplexRestrictionType parseTree, boolean mixed) |
| { |
| StscState state = StscState.get(); |
| String targetNamespace = sImpl.getTargetNamespace(); |
| boolean chameleon = (sImpl.getChameleonNamespace() != null); |
| |
| // BUGBUG: NOT YET REALLY IMPLEMENTED |
| // throw new RuntimeException("Not yet implemented."); |
| |
| SchemaType baseType; |
| if (parseTree.getBase() == null) |
| { |
| // KHK: s4s |
| state.error("A complexContent must define a base type", XmlErrorCodes.MISSING_BASE, parseTree); |
| baseType = null; // recovery: no inheritance. |
| } |
| else |
| { |
| if (sImpl.isRedefinition()) |
| { |
| baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl); |
| if (baseType != null && !baseType.getName().equals(sImpl.getName())) |
| { |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE, |
| new Object[] { "<complexType>", |
| QNameHelper.pretty(baseType.getName()), |
| QNameHelper.pretty(sImpl.getName()) |
| }, |
| parseTree); |
| } |
| } |
| else |
| { |
| baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace); |
| } |
| |
| if (baseType == null) |
| state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true); |
| } |
| |
| if (baseType == null) |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_TYPE; |
| |
| if (baseType != null && baseType.finalRestriction()) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$FINAL, |
| new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) }, |
| parseTree.xgetBase()); |
| // recovery: just keep going |
| } |
| |
| // Recursion |
| if (baseType != null) |
| { |
| if (!StscResolver.resolveType((SchemaTypeImpl)baseType)) |
| baseType = null; // circular dependency: no inheritance |
| } |
| |
| List anonymousTypes = new ArrayList(); |
| Group parseEg = getContentModel(parseTree); |
| |
| // detect the "all" case |
| int particleCode = translateParticleCode(parseEg); |
| |
| // used to ensure consistency (doesn't become part of the result) |
| Map elementModel = new LinkedHashMap(); |
| |
| // build content model and anonymous types |
| SchemaParticle contentModel = translateContentModel( sImpl, |
| parseEg, targetNamespace, chameleon, |
| sImpl.getElemFormDefault(), sImpl.getAttFormDefault(), |
| particleCode, anonymousTypes, elementModel, false, null); |
| |
| // detect the nonempty "all" case (empty <all> doesn't count - it needs to be eliminated to match XSD test cases) |
| boolean isAll = contentModel != null && contentModel.getParticleType() == SchemaParticle.ALL; |
| |
| // build attr model and anonymous types |
| SchemaAttributeModelImpl attrModel; |
| if (baseType == null) |
| attrModel = new SchemaAttributeModelImpl(); |
| else |
| attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel()); |
| translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(), |
| anonymousTypes, sImpl, null, attrModel, baseType, false, null); |
| |
| // summarize wildcard information |
| WildcardResult wcElt = summarizeEltWildcards(contentModel); |
| WildcardResult wcAttr = summarizeAttrWildcards(attrModel); |
| |
| // build state machine and verify that content model is deterministic |
| if (contentModel != null) |
| { |
| buildStateMachine(contentModel); |
| if (!StscState.get().noUpa() && !((SchemaParticleImpl)contentModel).isDeterministic()) |
| StscState.get().error(XmlErrorCodes.UNIQUE_PARTICLE_ATTRIBUTION, null, parseEg); |
| } |
| |
| // build property model |
| // emitDBG("Building content Model for " + sImpl); |
| Map elementPropertyModel = buildContentPropertyModelByQName(contentModel, sImpl); |
| |
| // add attribute property model |
| Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl); |
| |
| // compute empty/element/mixed |
| // fix for XMLBEANS-414 |
| int complexVariety = (mixed ? SchemaType.MIXED_CONTENT : |
| (contentModel == null ? SchemaType.EMPTY_CONTENT : SchemaType.ELEMENT_CONTENT)); |
| |
| // now fill in the actual schema type implementation |
| sImpl.setBaseTypeRef(baseType.getRef()); |
| sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1); |
| sImpl.setDerivationType(SchemaType.DT_RESTRICTION); |
| sImpl.setComplexTypeVariety(complexVariety); |
| sImpl.setContentModel(contentModel, attrModel, elementPropertyModel, attributePropertyModel, isAll); |
| sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes)); |
| sImpl.setWildcardSummary(wcElt.typedWildcards, wcElt.hasWildcards, wcAttr.typedWildcards, wcAttr.hasWildcards); |
| } |
| |
| static Map extractElementModel(SchemaType sType) |
| { |
| Map elementModel = new HashMap(); |
| if (sType != null) |
| { |
| SchemaProperty[] sProps = sType.getProperties(); |
| for (int i = 0; i < sProps.length; i++) |
| { |
| if (sProps[i].isAttribute()) |
| continue; |
| elementModel.put(sProps[i].getName(), |
| sProps[i].getType()); |
| } |
| } |
| return elementModel; |
| } |
| |
| static void resolveCcExtension(SchemaTypeImpl sImpl, ExtensionType parseTree, boolean mixed) |
| { |
| SchemaType baseType; |
| StscState state = StscState.get(); |
| String targetNamespace = sImpl.getTargetNamespace(); |
| boolean chameleon = (sImpl.getChameleonNamespace() != null); |
| |
| if (parseTree.getBase() == null) |
| { |
| // KHK: s4s |
| state.error("A complexContent must define a base type", XmlErrorCodes.MISSING_BASE, parseTree); |
| baseType = null; // recovery: no inheritance. |
| } |
| else |
| { |
| if (sImpl.isRedefinition()) |
| { |
| baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl); |
| if (baseType != null && !baseType.getName().equals(sImpl.getName())) |
| { |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE, |
| new Object[] { "<complexType>", |
| QNameHelper.pretty(baseType.getName()), |
| QNameHelper.pretty(sImpl.getName()) |
| }, |
| parseTree); |
| } |
| } |
| else |
| { |
| baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace); |
| } |
| if (baseType == null) |
| state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true); |
| } |
| |
| // Recursion |
| if (baseType != null) |
| { |
| if (!StscResolver.resolveType((SchemaTypeImpl)baseType)) |
| baseType = null; // circular dependency: no inheritance |
| } |
| |
| if (baseType != null && baseType.isSimpleType()) |
| { |
| state.recover(XmlErrorCodes.SCHEMA_COMPLEX_TYPE$COMPLEX_CONTENT, |
| new Object[] { QNameHelper.pretty(baseType.getName()) }, |
| parseTree.xgetBase()); |
| baseType = null; // recovery: no inheritance. |
| } |
| |
| if (baseType != null && baseType.finalExtension()) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$FINAL, |
| new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) }, |
| parseTree.xgetBase()); |
| // recovery: just keep going |
| } |
| |
| // get base content model |
| SchemaParticle baseContentModel = (baseType == null ? null : baseType.getContentModel()); |
| // TODO: attribute model also |
| |
| List anonymousTypes = new ArrayList(); |
| Map baseElementModel = extractElementModel(baseType); |
| Group parseEg = getContentModel(parseTree); |
| |
| if (baseType != null && |
| (baseType.getContentType() == SchemaType.SIMPLE_CONTENT)) |
| if (parseEg != null) |
| { |
| // if this type has complexContent, baseType is complexType |
| // but with non-empty simpleContent then this type cannot |
| // add extra elements |
| state.recover(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$EXTENDING_SIMPLE_CONTENT, |
| new Object[] { QNameHelper.pretty(baseType.getName()) }, |
| parseTree.xgetBase()); |
| baseType = null; // recovery: no inheritance. |
| } |
| else |
| { |
| // No extra elements, the type is a complex type with simple content |
| resolveScExtensionPart2(sImpl, baseType, parseTree, targetNamespace, chameleon); |
| return; |
| } |
| |
| // build extension model |
| SchemaParticle extensionModel = translateContentModel(sImpl, |
| parseEg, targetNamespace, chameleon, |
| sImpl.getElemFormDefault(), sImpl.getAttFormDefault(), |
| translateParticleCode(parseEg), anonymousTypes, baseElementModel, false, null); |
| |
| // apply rule #2 near http://www.w3.org/TR/xmlschema-1/#c-mve: empty ext model -> mixed taken from base |
| if (extensionModel == null && !mixed) |
| mixed = (baseType != null && baseType.getContentType() == SchemaType.MIXED_CONTENT); |
| |
| // apply Derivation Valid (Extension) rule 1.4.2.2 |
| if (baseType != null && (baseType.getContentType() != SchemaType.EMPTY_CONTENT) && |
| ((baseType.getContentType() == SchemaType.MIXED_CONTENT) != mixed)) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$BOTH_ELEMEMENT_OR_MIXED, null, parseTree.xgetBase()); |
| // recovery: just keep going |
| } |
| |
| // detect the "all" base case |
| if (baseType != null && baseType.hasAllContent() && extensionModel != null) |
| { |
| // KHK: which rule? cos-particle-extend.2 or cos-all-limited.1.2. I think the limited one. |
| state.error("Cannot extend a type with 'all' content model", XmlErrorCodes.CANNOT_EXTEND_ALL, parseTree.xgetBase()); |
| extensionModel = null; // recovery: drop extension |
| } |
| |
| // build content model and anonymous types |
| SchemaParticle contentModel = extendContentModel(baseContentModel, extensionModel, parseTree); |
| |
| // detect the nonempty "all" case (empty <all> doesn't count - it needs to be eliminated to match XSD test cases) |
| boolean isAll = contentModel != null && contentModel.getParticleType() == SchemaParticle.ALL; |
| |
| // build attr model and anonymous types |
| SchemaAttributeModelImpl attrModel; |
| if (baseType == null) |
| attrModel = new SchemaAttributeModelImpl(); |
| else |
| attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel()); |
| translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(), |
| anonymousTypes, sImpl, null, attrModel, baseType, true, null); |
| |
| // summarize wildcard information |
| WildcardResult wcElt = summarizeEltWildcards(contentModel); |
| WildcardResult wcAttr = summarizeAttrWildcards(attrModel); |
| |
| // build state machine and verify that content model is deterministic |
| if (contentModel != null) |
| { |
| buildStateMachine(contentModel); |
| if (!StscState.get().noUpa() && !((SchemaParticleImpl)contentModel).isDeterministic()) |
| StscState.get().error(XmlErrorCodes.UNIQUE_PARTICLE_ATTRIBUTION, null, parseEg); |
| } |
| |
| // build property model |
| // emitDBG("Building content Model for " + sImpl); |
| Map elementPropertyModel = buildContentPropertyModelByQName(contentModel, sImpl); |
| |
| // add attribute property model |
| Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl); |
| |
| // compute empty/element/mixed |
| int complexVariety; |
| if (contentModel == null && baseType != null && |
| baseType.getContentType() == SchemaType.SIMPLE_CONTENT) |
| { |
| complexVariety = SchemaType.SIMPLE_CONTENT; |
| sImpl.setContentBasedOnTypeRef(baseType.getContentBasedOnType().getRef()); |
| } |
| else |
| complexVariety = ( mixed ? SchemaType.MIXED_CONTENT : |
| (contentModel == null ? SchemaType.EMPTY_CONTENT : SchemaType.ELEMENT_CONTENT)); |
| |
| // now fill in the actual schema type implementation |
| if (baseType == null) |
| baseType = XmlObject.type; |
| sImpl.setBaseTypeRef(baseType.getRef()); |
| sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1); |
| sImpl.setDerivationType(SchemaType.DT_EXTENSION); |
| sImpl.setComplexTypeVariety(complexVariety); |
| sImpl.setContentModel(contentModel, attrModel, elementPropertyModel, attributePropertyModel, isAll); |
| sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes)); |
| sImpl.setWildcardSummary(wcElt.typedWildcards, wcElt.hasWildcards, wcAttr.typedWildcards, wcAttr.hasWildcards); |
| } |
| |
| static void resolveScRestriction(SchemaTypeImpl sImpl, SimpleRestrictionType parseTree) |
| { |
| SchemaType baseType; |
| SchemaType contentType = null; |
| StscState state = StscState.get(); |
| String targetNamespace = sImpl.getTargetNamespace(); |
| boolean chameleon = (sImpl.getChameleonNamespace() != null); |
| List anonymousTypes = new ArrayList(); |
| if (parseTree.getSimpleType() != null) |
| { |
| LocalSimpleType typedef = parseTree.getSimpleType(); |
| SchemaTypeImpl anonType = StscTranslator. |
| translateAnonymousSimpleType(typedef, targetNamespace, chameleon, |
| sImpl.getElemFormDefault(), sImpl.getAttFormDefault(), |
| anonymousTypes, sImpl); |
| contentType = anonType; |
| } |
| if (parseTree.getBase() == null) |
| { |
| state.error("A simpleContent restriction must define a base type", XmlErrorCodes.MISSING_BASE, parseTree); |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| else |
| { |
| if (sImpl.isRedefinition()) |
| { |
| baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl); |
| if (baseType != null && !baseType.getName().equals(sImpl.getName())) |
| { |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE, |
| new Object[] { "<simpleType>", |
| QNameHelper.pretty(baseType.getName()), |
| QNameHelper.pretty(sImpl.getName()) |
| }, |
| parseTree); |
| } |
| } |
| else |
| { |
| baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace); |
| } |
| if (baseType == null) |
| { |
| state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true); |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| } |
| |
| // Recursion |
| StscResolver.resolveType((SchemaTypeImpl)baseType); |
| if (contentType != null) |
| StscResolver.resolveType((SchemaTypeImpl)contentType); |
| else |
| contentType = baseType; |
| |
| if (baseType.isSimpleType()) |
| { |
| // src-ct.2: complex types with simple content cannot restrict simple types |
| state.recover(XmlErrorCodes.COMPLEX_TYPE_PROPERTIES$SIMPLE_TYPE_EXTENSION, |
| new Object[] { QNameHelper.pretty(baseType.getName()) }, |
| parseTree); |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| else if (baseType.getContentType() != SchemaType.SIMPLE_CONTENT && |
| contentType == null) |
| { |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| |
| if (baseType != null && baseType.finalRestriction()) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$FINAL, |
| new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) }, |
| parseTree.xgetBase()); |
| // recovery: just keep going |
| } |
| |
| // build attr model and anonymous types |
| SchemaAttributeModelImpl attrModel; |
| if (baseType == null) |
| attrModel = new SchemaAttributeModelImpl(); |
| else |
| attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel()); |
| translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(), |
| anonymousTypes, sImpl, null, attrModel, baseType, false, null); |
| |
| // summarize wildcard information |
| WildcardResult wcAttr = summarizeAttrWildcards(attrModel); |
| |
| // add attribute property model |
| Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl); |
| |
| // now fill in the actual schema type implementation |
| sImpl.setBaseTypeRef(baseType.getRef()); |
| sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1); |
| sImpl.setContentBasedOnTypeRef(contentType.getRef()); |
| sImpl.setDerivationType(SchemaType.DT_RESTRICTION); |
| sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes)); |
| sImpl.setWildcardSummary(QNameSet.EMPTY, false, wcAttr.typedWildcards, wcAttr.hasWildcards); |
| sImpl.setComplexTypeVariety(SchemaType.SIMPLE_CONTENT); |
| sImpl.setContentModel(null, attrModel, null, attributePropertyModel, false); |
| sImpl.setSimpleTypeVariety(contentType.getSimpleVariety()); |
| sImpl.setPrimitiveTypeRef(contentType.getPrimitiveType() == null ? null : contentType.getPrimitiveType().getRef()); |
| switch (sImpl.getSimpleVariety()) |
| { |
| case SchemaType.LIST: |
| sImpl.setListItemTypeRef(contentType.getListItemType().getRef()); |
| break; |
| |
| case SchemaType.UNION: |
| sImpl.setUnionMemberTypeRefs(makeRefArray(Arrays.asList(contentType.getUnionMemberTypes()))); |
| break; |
| } |
| |
| // deal with facets |
| StscSimpleTypeResolver.resolveFacets(sImpl, parseTree, (SchemaTypeImpl) contentType); |
| |
| // now compute our intrinsic properties |
| StscSimpleTypeResolver.resolveFundamentalFacets(sImpl); |
| } |
| |
| static void resolveScExtension(SchemaTypeImpl sImpl, SimpleExtensionType parseTree) |
| { |
| SchemaType baseType; |
| StscState state = StscState.get(); |
| String targetNamespace = sImpl.getTargetNamespace(); |
| boolean chameleon = (sImpl.getChameleonNamespace() != null); |
| if (parseTree.getBase() == null) |
| { |
| state.error("A simpleContent extension must define a base type", XmlErrorCodes.MISSING_BASE, parseTree); |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| else |
| { |
| if (sImpl.isRedefinition()) |
| { |
| baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl); |
| if (baseType != null && !baseType.getName().equals(sImpl.getName())) |
| { |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE, |
| new Object[] { "<simpleType>", |
| QNameHelper.pretty(baseType.getName()), |
| QNameHelper.pretty(sImpl.getName()) |
| }, |
| parseTree); |
| } |
| } |
| else |
| { |
| baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace); |
| } |
| if (baseType == null) |
| { |
| state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true); |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| } |
| |
| // Recursion |
| StscResolver.resolveType((SchemaTypeImpl)baseType); |
| |
| if (!baseType.isSimpleType() && baseType.getContentType() != SchemaType.SIMPLE_CONTENT) |
| { |
| // src-ct.2: complex types with simple content can only extend simple types |
| state.error(XmlErrorCodes.SCHEMA_COMPLEX_TYPE$SIMPLE_CONTENT, |
| new Object[] { QNameHelper.pretty(baseType.getName()) } , |
| parseTree); |
| // recovery: extends ANY_SIMPLE type |
| baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE; |
| } |
| |
| if (baseType != null && baseType.finalExtension()) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$FINAL, |
| new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) }, |
| parseTree.xgetBase()); |
| // recovery: just keep going |
| } |
| |
| resolveScExtensionPart2(sImpl, baseType, parseTree, targetNamespace, chameleon); |
| } |
| |
| static void resolveScExtensionPart2(SchemaTypeImpl sImpl, SchemaType baseType, ExtensionType parseTree, |
| String targetNamespace, boolean chameleon) |
| { |
| // build attr model and anonymous types |
| List anonymousTypes = new ArrayList(); |
| SchemaAttributeModelImpl attrModel; |
| attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel()); |
| translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(), anonymousTypes, sImpl, null, attrModel, baseType, true, null); |
| |
| // summarize wildcard information |
| WildcardResult wcAttr = summarizeAttrWildcards(attrModel); |
| |
| // add attribute property model |
| Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl); |
| |
| // now fill in the actual schema type implementation |
| sImpl.setBaseTypeRef(baseType.getRef()); |
| sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1); |
| sImpl.setContentBasedOnTypeRef(baseType.getRef()); |
| sImpl.setDerivationType(SchemaType.DT_EXTENSION); |
| sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes)); |
| sImpl.setWildcardSummary(QNameSet.EMPTY, false, wcAttr.typedWildcards, wcAttr.hasWildcards); |
| sImpl.setComplexTypeVariety(SchemaType.SIMPLE_CONTENT); |
| sImpl.setContentModel(null, attrModel, null, attributePropertyModel, false); |
| sImpl.setSimpleTypeVariety(baseType.getSimpleVariety()); |
| sImpl.setPrimitiveTypeRef(baseType.getPrimitiveType() == null ? null : baseType.getPrimitiveType().getRef()); |
| switch (sImpl.getSimpleVariety()) |
| { |
| case SchemaType.LIST: |
| sImpl.setListItemTypeRef(baseType.getListItemType().getRef()); |
| break; |
| |
| case SchemaType.UNION: |
| sImpl.setUnionMemberTypeRefs(makeRefArray(Arrays.asList(baseType.getUnionMemberTypes()))); |
| break; |
| } |
| |
| // deal with facets |
| StscSimpleTypeResolver.resolveFacets(sImpl, null, (SchemaTypeImpl)baseType); |
| |
| // now compute our intrinsic properties |
| StscSimpleTypeResolver.resolveFundamentalFacets(sImpl); |
| } |
| |
| static class WildcardResult |
| { |
| WildcardResult(QNameSet typedWildcards, boolean hasWildcards) |
| { |
| this.typedWildcards = typedWildcards; |
| this.hasWildcards = hasWildcards; |
| } |
| QNameSet typedWildcards; |
| boolean hasWildcards; |
| } |
| |
| static WildcardResult summarizeAttrWildcards(SchemaAttributeModel attrModel) |
| { |
| if (attrModel.getWildcardProcess() == SchemaAttributeModel.NONE) |
| return new WildcardResult(QNameSet.EMPTY, false); |
| if (attrModel.getWildcardProcess() == SchemaAttributeModel.SKIP) |
| return new WildcardResult(QNameSet.EMPTY, true); |
| return new WildcardResult(attrModel.getWildcardSet(), true); |
| } |
| |
| static WildcardResult summarizeEltWildcards(SchemaParticle contentModel) |
| { |
| if (contentModel == null) |
| { |
| return new WildcardResult(QNameSet.EMPTY, false); |
| } |
| |
| switch (contentModel.getParticleType()) |
| { |
| case SchemaParticle.ALL: |
| case SchemaParticle.SEQUENCE: |
| case SchemaParticle.CHOICE: |
| QNameSetBuilder set = new QNameSetBuilder(); |
| boolean hasWildcards = false; |
| for (int i = 0; i < contentModel.countOfParticleChild(); i++) |
| { |
| WildcardResult inner = summarizeEltWildcards(contentModel.getParticleChild(i)); |
| set.addAll(inner.typedWildcards); |
| hasWildcards |= inner.hasWildcards; |
| } |
| return new WildcardResult(set.toQNameSet(), hasWildcards); |
| case SchemaParticle.WILDCARD: |
| return new WildcardResult( |
| (contentModel.getWildcardProcess() == SchemaParticle.SKIP) ? |
| QNameSet.EMPTY : contentModel.getWildcardSet(), true); |
| // otherwise fallthrough |
| |
| default: |
| return new WildcardResult(QNameSet.EMPTY, false); |
| } |
| } |
| |
| static void translateAttributeModel(XmlObject parseTree, |
| String targetNamespace, boolean chameleon, String formDefault, |
| List anonymousTypes, SchemaType outerType, |
| Set seenAttributes, SchemaAttributeModelImpl result, |
| SchemaType baseType, boolean extension, |
| SchemaAttributeGroupImpl redefinitionFor) |
| { |
| StscState state = StscState.get(); |
| if (seenAttributes == null) |
| seenAttributes = new HashSet(); |
| boolean seenWildcard = false; |
| boolean seenRedefinition = false; |
| SchemaAttributeModel baseModel = null; |
| if (baseType != null) |
| baseModel = baseType.getAttributeModel(); |
| |
| XmlCursor cur = parseTree.newCursor(); |
| |
| for (boolean more = cur.toFirstChild(); more; more = cur.toNextSibling()) |
| { |
| switch (translateAttributeCode(cur.getName())) |
| { |
| case ATTRIBUTE_CODE: |
| { |
| Attribute xsdattr = (Attribute)cur.getObject(); |
| |
| SchemaLocalAttribute sAttr = StscTranslator.translateAttribute(xsdattr, targetNamespace, formDefault, chameleon, anonymousTypes, outerType, baseModel, true); |
| if (sAttr == null) |
| continue; |
| |
| if (seenAttributes.contains(sAttr.getName())) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_PROPERTIES$DUPLICATE_ATTRIBUTE, |
| new Object[] { QNameHelper.pretty(sAttr.getName()), QNameHelper.pretty(outerType.getName()) }, |
| xsdattr.xgetName()); |
| continue; // ignore the duplicate attr |
| } |
| |
| seenAttributes.add(sAttr.getName()); |
| |
| if (baseModel != null) |
| { |
| SchemaLocalAttribute baseAttr = baseModel.getAttribute(sAttr.getName()); |
| if (baseAttr == null) |
| { |
| if (!extension) |
| { |
| if (!baseModel.getWildcardSet().contains(sAttr.getName())) |
| state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ATTR_IN_BASE_WILDCARD_SET, |
| new Object[] { QNameHelper.pretty(sAttr.getName()), QNameHelper.pretty(outerType.getName()) }, xsdattr); |
| } |
| } |
| else |
| { |
| if (extension) |
| { |
| // KHK: cos-ct-extends.1.2? |
| if (sAttr.getUse() == SchemaLocalAttribute.PROHIBITED) |
| state.error("An extension cannot prohibit an attribute from the base type; use restriction instead.", XmlErrorCodes.DUPLICATE_ATTRIBUTE_NAME, xsdattr.xgetUse()); |
| } |
| else |
| { |
| if (sAttr.getUse() != SchemaLocalAttribute.REQUIRED) |
| { |
| if (baseAttr.getUse() == SchemaLocalAttribute.REQUIRED) |
| state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ATTR_REQUIRED, |
| new Object[] { QNameHelper.pretty(sAttr.getName()), QNameHelper.pretty(outerType.getName()) }, xsdattr); |
| |
| if (sAttr.getUse() == SchemaLocalAttribute.PROHIBITED) |
| result.removeProhibitedAttribute(sAttr.getName()); |
| } |
| } |
| } |
| } |
| |
| if (sAttr.getUse() != SchemaLocalAttribute.PROHIBITED) |
| { |
| result.addAttribute(sAttr); |
| } |
| else |
| { |
| // attribute is prohibited. If it has an anonymous type remove |
| // it from the list (this will prevent inclusion of any anonymous |
| // types defined within the prohibited attribute which would |
| // otherwise attempt to refer to the prohibited attribute at |
| // save() time) |
| SchemaType attrType = sAttr.getType(); |
| if (anonymousTypes != null && anonymousTypes.contains(attrType)) |
| { |
| anonymousTypes.remove(attrType); |
| } |
| } |
| |
| if (sAttr.getDefaultText() != null && !sAttr.isFixed()) |
| { |
| if (sAttr.getUse() != SchemaLocalAttribute.OPTIONAL) |
| state.error(XmlErrorCodes.SCHEMA_ATTR$DEFAULT_AND_USE_OPTIONAL, |
| new Object[] { QNameHelper.pretty(sAttr.getName()) }, xsdattr); |
| } |
| |
| |
| break; |
| } |
| case ANY_ATTRIBUTE_CODE: |
| { |
| Wildcard xsdwc = (Wildcard)cur.getObject(); |
| if (seenWildcard) |
| { |
| // KHK: ? |
| state.error("Only one attribute wildcard allowed", XmlErrorCodes.DUPLICATE_ANY_ATTRIBUTE, xsdwc); |
| continue; // ignore the extra wildcard |
| } |
| seenWildcard = true; |
| NamespaceList nsList = xsdwc.xgetNamespace(); |
| String nsText; |
| if (nsList == null) |
| nsText = "##any"; |
| else |
| nsText = nsList.getStringValue(); |
| QNameSet wcset = QNameSet.forWildcardNamespaceString(nsText, targetNamespace); |
| |
| if (baseModel != null && !extension) |
| { |
| if (baseModel.getWildcardSet() == null) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$BASE_HAS_ATTR_WILDCARD, null, xsdwc); |
| continue; // ignore the extra wildcard |
| } |
| else if (!baseModel.getWildcardSet().containsAll(wcset)) |
| { |
| state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ATTR_WILDCARD_SUBSET, |
| new Object[] { nsText }, xsdwc); |
| continue; // ignore the restriction |
| } |
| } |
| |
| int wcprocess = translateWildcardProcess(xsdwc.xgetProcessContents()); |
| if (result.getWildcardProcess() == SchemaAttributeModel.NONE) |
| { |
| result.setWildcardSet(wcset); |
| result.setWildcardProcess(wcprocess); |
| } |
| else |
| { |
| if (extension) |
| { |
| result.setWildcardSet(wcset.union(result.getWildcardSet())); |
| result.setWildcardProcess(wcprocess); |
| } |
| else |
| { |
| result.setWildcardSet(wcset.intersect(result.getWildcardSet())); |
| // keep old process |
| } |
| } |
| break; |
| } |
| case ATTRIBUTE_GROUP_CODE: |
| { |
| AttributeGroupRef xsdag = (AttributeGroupRef)cur.getObject(); |
| QName ref = xsdag.getRef(); |
| if (ref == null) |
| { |
| // KHK: s4s |
| state.error("Attribute group reference must have a ref attribute", XmlErrorCodes.ATTRIBUTE_GROUP_MISSING_REF, xsdag); |
| continue; |
| } |
| SchemaAttributeGroupImpl group; |
| if (redefinitionFor != null) |
| { |
| group = state.findRedefinedAttributeGroup(ref, chameleon ? targetNamespace : null, redefinitionFor); |
| if (group != null && |
| redefinitionFor.getName().equals(group.getName())) |
| { |
| if (seenRedefinition) |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$ATTR_GROUP_SELF_REF, |
| new Object[] { QNameHelper.pretty(redefinitionFor.getName()) }, xsdag); |
| seenRedefinition = true; |
| } |
| } |
| else |
| { |
| group = state.findAttributeGroup(ref, chameleon ? targetNamespace : null, targetNamespace); |
| } |
| if (group == null) |
| { |
| state.notFoundError(ref, SchemaType.ATTRIBUTE_GROUP, xsdag.xgetRef(), true); |
| continue; |
| } |
| if (state.isProcessing(group)) |
| { |
| state.error(XmlErrorCodes.SCHEMA_ATTR_GROUP$SELF_REF, |
| new Object[] { QNameHelper.pretty(group.getName()) },group.getParseObject()); |
| continue; |
| } |
| String subTargetNamespace = targetNamespace; |
| if (group.getTargetNamespace() != null) |
| { |
| subTargetNamespace = group.getTargetNamespace(); |
| chameleon = group.getChameleonNamespace() != null; |
| } |
| |
| state.startProcessing(group); |
| SchemaAttributeGroupImpl nestedRedefinitionFor = null; |
| if (group.isRedefinition()) |
| nestedRedefinitionFor = group; |
| translateAttributeModel(group.getParseObject(), subTargetNamespace, chameleon, |
| group.getFormDefault(), |
| anonymousTypes, outerType, seenAttributes, result, baseType, |
| extension, nestedRedefinitionFor); |
| state.finishProcessing(group); |
| break; |
| } |
| default: |
| { |
| continue; // skip things that are not part of the attribute model. |
| } |
| } |
| } |
| // If this is restriction and no wildcard was present, then |
| // we have to erase the inherited wildcards |
| if (!extension && !seenWildcard) |
| { |
| result.setWildcardSet(null); |
| result.setWildcardProcess(SchemaAttributeModel.NONE); |
| } |
| } |
| |
| static SchemaParticle extendContentModel(SchemaParticle baseContentModel, SchemaParticle extendedContentModel, XmlObject parseTree) |
| { |
| // http://www.w3.org/TR/xmlschema-1/#element-complexContent::extension |
| |
| // 2.1 If the explicit content is empty, then the {content type} of the type definition resolved to by the �actual value� of the base [attribute] |
| if (extendedContentModel == null) |
| return baseContentModel; |
| |
| // 2.2 If the type definition resolved to by the actual value of the base [attribute] has a {content type} of empty, then a pair of mixed or elementOnly (determined as per clause 1.2.1 above) and the explicit content itself; |
| if (baseContentModel == null) |
| return extendedContentModel; |
| |
| // 2.3 otherwise a pair of mixed or elementOnly (determined as per clause 1.2.1 above) and a particle whose properties are as follows: |
| SchemaParticleImpl sPart = new SchemaParticleImpl(); |
| sPart.setParticleType(SchemaParticle.SEQUENCE); |
| |
| List accumulate = new ArrayList(); |
| addMinusPointlessParticles(accumulate, baseContentModel, SchemaParticle.SEQUENCE); |
| addMinusPointlessParticles(accumulate, extendedContentModel, SchemaParticle.SEQUENCE); |
| sPart.setMinOccurs(BigInteger.ONE); |
| sPart.setMaxOccurs(BigInteger.ONE); |
| sPart.setParticleChildren((SchemaParticle[]) |
| accumulate.toArray(new SchemaParticle[accumulate.size()])); |
| |
| return filterPointlessParticlesAndVerifyAllParticles(sPart, parseTree); |
| } |
| |
| static BigInteger extractMinOccurs(XmlNonNegativeInteger nni) |
| { |
| if (nni == null) |
| return BigInteger.ONE; |
| BigInteger result = nni.getBigIntegerValue(); |
| if (result == null) |
| return BigInteger.ONE; |
| return result; |
| } |
| |
| static BigInteger extractMaxOccurs(AllNNI allNNI) |
| { |
| if (allNNI == null) |
| return BigInteger.ONE; |
| |
| if (allNNI.instanceType().getPrimitiveType().getBuiltinTypeCode() == SchemaType.BTC_DECIMAL) |
| return ((XmlInteger)allNNI).getBigIntegerValue(); |
| else |
| return null; |
| } |
| |
| private static class RedefinitionForGroup |
| { |
| private SchemaModelGroupImpl group; |
| private boolean seenRedefinition = false; |
| |
| public RedefinitionForGroup(SchemaModelGroupImpl group) |
| { |
| this.group = group; |
| } |
| |
| public SchemaModelGroupImpl getGroup() |
| { |
| return group; |
| } |
| |
| public boolean isSeenRedefinition() |
| { |
| return seenRedefinition; |
| } |
| |
| public void setSeenRedefinition(boolean seenRedefinition) |
| { |
| this.seenRedefinition = seenRedefinition; |
| } |
| } |
| |
| static SchemaParticle translateContentModel( |
| SchemaType outerType, |
| XmlObject parseTree, String targetNamespace, boolean chameleon, |
| String elemFormDefault, String attFormDefault, |
| int particleCode, List anonymousTypes, Map elementModel, |
| boolean allowElt, RedefinitionForGroup redefinitionFor) |
| { |
| if (parseTree == null || particleCode == 0) |
| return null; |
| |
| StscState state = StscState.get(); |
| |
| // emitDBG("Translating content model for " + outerType); |
| // indentDBG(); |
| assert(particleCode != 0); |
| |
| boolean hasChildren = false; |
| BigInteger minOccurs; |
| BigInteger maxOccurs; |
| SchemaModelGroupImpl group = null; |
| |
| SchemaParticleImpl sPart; |
| |
| if (particleCode == SchemaParticle.ELEMENT) |
| { |
| if (!allowElt) |
| state.error("Must be a sequence, choice or all here", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, parseTree); |
| |
| // TODO: detect substitution group for this element and construct a choice |
| |
| LocalElement parseElt = (LocalElement)parseTree; |
| sPart = StscTranslator.translateElement(parseElt, targetNamespace, chameleon, |
| elemFormDefault, attFormDefault, anonymousTypes, outerType); |
| if (sPart == null) |
| return null; |
| minOccurs = extractMinOccurs(parseElt.xgetMinOccurs()); |
| maxOccurs = extractMaxOccurs(parseElt.xgetMaxOccurs()); |
| |
| SchemaType oldType = (SchemaType)elementModel.get(sPart.getName()); |
| if (oldType == null) |
| { |
| elementModel.put(sPart.getName(), sPart.getType()); |
| } |
| else if (!sPart.getType().equals(oldType)) |
| { |
| state.error(XmlErrorCodes.ELEM_CONSISTANT, new Object[] { QNameHelper.pretty(sPart.getName()) }, parseTree); |
| return null; |
| } |
| } |
| else if (particleCode == SchemaParticle.WILDCARD) |
| { |
| if (!allowElt) |
| state.error("Must be a sequence, choice or all here", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, parseTree); |
| Any parseAny = (Any)parseTree; |
| sPart = new SchemaParticleImpl(); |
| sPart.setParticleType(SchemaParticle.WILDCARD); |
| QNameSet wcset; |
| NamespaceList nslist = parseAny.xgetNamespace(); |
| if (nslist == null) |
| wcset = QNameSet.ALL; |
| else |
| wcset = QNameSet.forWildcardNamespaceString(nslist.getStringValue(), targetNamespace); |
| sPart.setWildcardSet(wcset); |
| sPart.setWildcardProcess(translateWildcardProcess(parseAny.xgetProcessContents())); |
| minOccurs = extractMinOccurs(parseAny.xgetMinOccurs()); |
| maxOccurs = extractMaxOccurs(parseAny.xgetMaxOccurs()); |
| } |
| else |
| { |
| Group parseGroup = (Group)parseTree; |
| sPart = new SchemaParticleImpl(); |
| |
| // grab min/maxOccurs before dereferencign group ref |
| minOccurs = extractMinOccurs(parseGroup.xgetMinOccurs()); |
| maxOccurs = extractMaxOccurs(parseGroup.xgetMaxOccurs()); |
| |
| if (particleCode == MODEL_GROUP_CODE) |
| { |
| QName ref = parseGroup.getRef(); |
| if (ref == null) |
| { |
| // KHK: s4s |
| state.error("Group reference must have a ref attribute", XmlErrorCodes.GROUP_MISSING_REF, parseTree); |
| return null; |
| } |
| |
| if (redefinitionFor != null) |
| { |
| group = state.findRedefinedModelGroup(ref, chameleon ? targetNamespace : null, redefinitionFor.getGroup()); |
| if (group != null && group.getName().equals(redefinitionFor.getGroup().getName())) |
| { |
| if (redefinitionFor.isSeenRedefinition()) |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$GROUP_SELF_REF, |
| new Object[] { QNameHelper.pretty(group.getName()) }, parseTree); |
| if (!BigInteger.ONE.equals(maxOccurs) || !BigInteger.ONE.equals(minOccurs)) |
| state.error(XmlErrorCodes.SCHEMA_REDEFINE$GROUP_SELF_REF_MIN_MAX_1, |
| new Object[] { QNameHelper.pretty(group.getName()) }, parseTree); |
| redefinitionFor.setSeenRedefinition(true); |
| } |
| } |
| else |
| { |
| group = state.findModelGroup(ref, chameleon ? targetNamespace : null, targetNamespace); |
| } |
| if (group == null) |
| { |
| state.notFoundError(ref, SchemaType.MODEL_GROUP, ((Group)parseTree).xgetRef(), true); |
| return null; |
| } |
| if (state.isProcessing(group)) |
| { |
| state.error(XmlErrorCodes.MODEL_GROUP_PROPERTIES$CIRCULAR, |
| new Object[] { QNameHelper.pretty(group.getName()) }, group.getParseObject()); |
| return null; |
| } |
| |
| // no go to the child. |
| XmlCursor cur = group.getParseObject().newCursor(); |
| for (boolean more = cur.toFirstChild(); more; more = cur.toNextSibling()) |
| { |
| particleCode = translateParticleCode(cur.getName()); |
| if (particleCode != 0) |
| { |
| parseTree = parseGroup = (Group)cur.getObject(); |
| break; |
| } |
| } |
| if (particleCode == 0) |
| { |
| // KHK: s4s |
| state.error("Model group " + QNameHelper.pretty(group.getName()) + " is empty", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, group.getParseObject()); |
| return null; |
| } |
| if (particleCode != SchemaParticle.ALL && particleCode != SchemaParticle.SEQUENCE && particleCode != SchemaParticle.CHOICE) |
| { |
| // KHK: s4s |
| state.error("Model group " + QNameHelper.pretty(group.getName()) + " is not a sequence, all, or choice", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, group.getParseObject()); |
| } |
| |
| String newTargetNamespace = group.getTargetNamespace(); |
| if (newTargetNamespace != null) |
| targetNamespace = newTargetNamespace; |
| elemFormDefault = group.getElemFormDefault(); |
| attFormDefault = group.getAttFormDefault(); |
| chameleon = group.getChameleonNamespace() != null; |
| } |
| |
| switch (particleCode) |
| { |
| case SchemaParticle.ALL: |
| case SchemaParticle.SEQUENCE: |
| case SchemaParticle.CHOICE: |
| sPart.setParticleType(particleCode); |
| hasChildren = true; |
| break; |
| |
| default: |
| assert(false); |
| throw new IllegalStateException(); |
| } |
| } |
| |
| if (maxOccurs != null && minOccurs.compareTo(maxOccurs) > 0) |
| { |
| state.error(XmlErrorCodes.PARTICLE_PROPERTIES$MIN_LTE_MAX, null, parseTree); |
| maxOccurs = minOccurs; // remedy: pin max up to min |
| } |
| |
| if (maxOccurs != null && maxOccurs.compareTo(BigInteger.ONE) < 0) |
| { |
| state.warning(XmlErrorCodes.PARTICLE_PROPERTIES$MAX_GTE_1, null, parseTree); |
| |
| // remove from the list of anonymous types if it was added |
| anonymousTypes.remove(sPart.getType()); |
| return null; // maxOccurs == minOccurs == 0, same as no particle at all. |
| } |
| |
| sPart.setMinOccurs(minOccurs); |
| sPart.setMaxOccurs(maxOccurs); |
| |
| if (group != null) |
| { |
| state.startProcessing(group); |
| redefinitionFor = null; |
| if (group.isRedefinition()) |
| redefinitionFor = new RedefinitionForGroup(group); |
| } |
| |
| if (hasChildren) |
| { |
| XmlCursor cur = parseTree.newCursor(); |
| List accumulate = new ArrayList(); |
| for (boolean more = cur.toFirstChild(); more; more = cur.toNextSibling()) |
| { |
| int code = translateParticleCode(cur.getName()); |
| if (code == 0) |
| continue; |
| addMinusPointlessParticles(accumulate, |
| translateContentModel(outerType, |
| cur.getObject(), targetNamespace, chameleon, |
| elemFormDefault, attFormDefault, code, |
| anonymousTypes, elementModel, true, redefinitionFor), |
| sPart.getParticleType()); |
| } |
| sPart.setParticleChildren((SchemaParticle[]) |
| accumulate.toArray(new SchemaParticle[accumulate.size()])); |
| cur.dispose(); |
| } |
| |
| |
| SchemaParticle result = filterPointlessParticlesAndVerifyAllParticles(sPart, parseTree); |
| |
| if (group != null) |
| { |
| state.finishProcessing(group); |
| } |
| // outdentDBG(); |
| return result; |
| } |
| |
| static int translateWildcardProcess(Any.ProcessContents process) |
| { |
| if (process == null) |
| return SchemaParticle.STRICT; |
| |
| String processValue = process.getStringValue(); |
| |
| if ("lax".equals(processValue)) |
| return SchemaParticle.LAX; |
| |
| if ("skip".equals(processValue)) |
| return SchemaParticle.SKIP; |
| |
| return SchemaParticle.STRICT; |
| } |
| |
| static SchemaParticle filterPointlessParticlesAndVerifyAllParticles(SchemaParticle part, XmlObject parseTree) |
| { |
| if (part.getMaxOccurs() != null && part.getMaxOccurs().signum() == 0) |
| return null; |
| |
| switch (part.getParticleType()) |
| { |
| case SchemaParticle.SEQUENCE: |
| case SchemaParticle.ALL: |
| if (part.getParticleChildren().length == 0) |
| return null; |
| if (part.isSingleton() && part.countOfParticleChild() == 1) |
| return part.getParticleChild(0); |
| break; |
| |
| case SchemaParticle.CHOICE: |
| if (part.getParticleChildren().length == 0 && |
| part.getMinOccurs().compareTo(BigInteger.ZERO) == 0) |
| return null; |
| if (part.isSingleton() && part.countOfParticleChild() == 1) |
| return part.getParticleChild(0); |
| break; |
| |
| case SchemaParticle.ELEMENT: |
| case SchemaParticle.WILDCARD: |
| return part; |
| |
| default: |
| assert(false); |
| throw new IllegalStateException(); |
| } |
| |
| boolean isAll = part.getParticleType() == SchemaParticle.ALL; |
| |
| if (isAll) |
| { |
| // http://www.w3.org/TR/xmlschema-1/#cos-all-limited |
| if (part.getMaxOccurs() == null || part.getMaxOccurs().compareTo(BigInteger.ONE) > 0) |
| { |
| // An all group must have maxOccurs <= 1 |
| // KHK: review |
| StscState.get().error(XmlErrorCodes.ALL_GROUP_LIMITED$IN_MIN_MAX_1_PARTICLE, null, parseTree); |
| } |
| } |
| |
| for (int i = 0; i < part.countOfParticleChild(); i++) |
| { |
| SchemaParticle child = part.getParticleChild(i); |
| if (child.getParticleType() == SchemaParticle.ALL) |
| { |
| // An all group is only allowed at the top level of the content model |
| // KHK: review |
| StscState.get().error(XmlErrorCodes.ALL_GROUP_LIMITED$IN_COMPLEX_TYPE_DEF_PARTICLE, null, parseTree); |
| } |
| else if (isAll && (child.getParticleType() != SchemaParticle.ELEMENT || child.getMaxOccurs() == null || child.getMaxOccurs().compareTo(BigInteger.ONE) > 0)) |
| { |
| // An all group can contain only element particles with maxOccurs <= 1 |
| // KHK: review |
| StscState.get().error(XmlErrorCodes.ALL_GROUP_LIMITED$CHILD_PARTICLES_MAX_LTE_1, null, parseTree); |
| } |
| } |
| |
| return part; |
| } |
| |
| static void addMinusPointlessParticles( |
| List list, SchemaParticle part, int parentParticleType) |
| { |
| if (part == null) |
| return; |
| |
| switch (part.getParticleType()) |
| { |
| case SchemaParticle.SEQUENCE: |
| if (parentParticleType == SchemaParticle.SEQUENCE && part.isSingleton()) |
| { |
| // emitDBG("dropping redundant sequence"); |
| list.addAll(Arrays.asList(part.getParticleChildren())); |
| return; |
| } |
| break; |
| |
| case SchemaParticle.CHOICE: |
| if (parentParticleType == SchemaParticle.CHOICE && part.isSingleton()) |
| { |
| // emitDBG("dropping redundant choice"); |
| list.addAll(Arrays.asList(part.getParticleChildren())); |
| return; |
| } |
| break; |
| |
| case SchemaParticle.ALL: |
| default: |
| } |
| list.add(part); |
| } |
| |
| static Map buildAttributePropertyModelByQName(SchemaAttributeModel attrModel, SchemaType owner) |
| { |
| Map result = new LinkedHashMap(); |
| SchemaLocalAttribute[] attruses = attrModel.getAttributes(); |
| |
| for (int i = 0; i < attruses.length; i++) |
| result.put(attruses[i].getName(), buildUseProperty(attruses[i], owner)); |
| |
| return result; |
| } |
| |
| static Map buildContentPropertyModelByQName(SchemaParticle part, SchemaType owner) |
| { |
| if (part == null) |
| return Collections.EMPTY_MAP; |
| |
| boolean asSequence = false; |
| Map model = null; |
| |
| switch (part.getParticleType()) |
| { |
| case SchemaParticle.ALL: |
| case SchemaParticle.SEQUENCE: |
| asSequence = true; |
| break; |
| case SchemaParticle.CHOICE: |
| asSequence = false; |
| break; |
| case SchemaParticle.ELEMENT: |
| model = buildElementPropertyModel((SchemaLocalElement)part, owner); |
| break; |
| case SchemaParticle.WILDCARD: |
| model = Collections.EMPTY_MAP; |
| break; |
| default: |
| assert(false); |
| throw new IllegalStateException(); |
| } |
| |
| if (model == null) |
| { |
| // build model for children |
| model = new LinkedHashMap(); |
| SchemaParticle[] children = part.getParticleChildren(); |
| |
| for (int i = 0; i < children.length; i++) |
| { |
| // indentDBG(); |
| Map childModel = buildContentPropertyModelByQName(children[i], owner); |
| // outdentDBG(); |
| for (Iterator j = childModel.values().iterator(); j.hasNext(); ) |
| { |
| SchemaProperty iProp = (SchemaProperty)j.next(); |
| SchemaPropertyImpl oProp = (SchemaPropertyImpl)model.get(iProp.getName()); |
| if (oProp == null) |
| { |
| if (!asSequence) |
| ((SchemaPropertyImpl)iProp).setMinOccurs(BigInteger.ZERO); |
| model.put(iProp.getName(), iProp); |
| continue; |
| } |
| // consistency verified in an earlier step |
| assert(oProp.getType().equals(iProp.getType())); |
| |
| mergeProperties(oProp, iProp, asSequence); |
| } |
| } |
| |
| // finally deal with minOccurs, maxOccurs over whole group |
| BigInteger min = part.getMinOccurs(); |
| BigInteger max = part.getMaxOccurs(); |
| |
| for (Iterator j = model.values().iterator(); j.hasNext(); ) |
| { |
| SchemaProperty oProp = (SchemaProperty)j.next(); |
| BigInteger minOccurs = oProp.getMinOccurs(); |
| BigInteger maxOccurs = oProp.getMaxOccurs(); |
| |
| minOccurs = minOccurs.multiply(min); |
| if (max != null && max.equals(BigInteger.ZERO)) |
| maxOccurs = BigInteger.ZERO; |
| else if (maxOccurs != null && !maxOccurs.equals(BigInteger.ZERO)) |
| maxOccurs = max == null ? null : maxOccurs.multiply(max); |
| |
| ((SchemaPropertyImpl)oProp).setMinOccurs(minOccurs); |
| ((SchemaPropertyImpl)oProp).setMaxOccurs(maxOccurs); |
| } |
| } |
| |
| return model; |
| } |
| |
| static Map buildElementPropertyModel(SchemaLocalElement epart, SchemaType owner) |
| { |
| Map result = new HashMap(1); |
| |
| SchemaProperty sProp = buildUseProperty(epart, owner); |
| result.put(sProp.getName(), sProp); |
| return result; |
| } |
| |
| static SchemaProperty buildUseProperty(SchemaField use, SchemaType owner) |
| { |
| SchemaPropertyImpl sPropImpl = new SchemaPropertyImpl(); |
| sPropImpl.setName(use.getName()); |
| sPropImpl.setContainerTypeRef(owner.getRef()); |
| sPropImpl.setTypeRef(use.getType().getRef()); |
| sPropImpl.setAttribute(use.isAttribute()); |
| sPropImpl.setDefault(use.isDefault() ? SchemaProperty.CONSISTENTLY : SchemaProperty.NEVER); |
| sPropImpl.setFixed(use.isFixed() ? SchemaProperty.CONSISTENTLY : SchemaProperty.NEVER); |
| sPropImpl.setNillable(use.isNillable() ? SchemaProperty.CONSISTENTLY : SchemaProperty.NEVER); |
| sPropImpl.setDefaultText(use.getDefaultText()); |
| sPropImpl.setMinOccurs(use.getMinOccurs()); |
| sPropImpl.setMaxOccurs(use.getMaxOccurs()); |
| |
| if (use instanceof SchemaLocalElementImpl) |
| { |
| SchemaLocalElementImpl elt = (SchemaLocalElementImpl)use; |
| sPropImpl.setAcceptedNames(elt.acceptedStartNames()); |
| } |
| |
| return sPropImpl; |
| } |
| |
| static void mergeProperties(SchemaPropertyImpl into, SchemaProperty from, boolean asSequence) |
| { |
| // minoccur, maxoccur |
| BigInteger minOccurs = into.getMinOccurs(); |
| BigInteger maxOccurs = into.getMaxOccurs(); |
| if (asSequence) |
| { |
| minOccurs = minOccurs.add(from.getMinOccurs()); |
| if (maxOccurs != null) |
| maxOccurs = (from.getMaxOccurs() == null ? null : |
| maxOccurs.add(from.getMaxOccurs())); |
| } |
| else |
| { |
| minOccurs = minOccurs.min(from.getMinOccurs()); |
| if (maxOccurs != null) |
| maxOccurs = (from.getMaxOccurs() == null ? null : |
| maxOccurs.max(from.getMaxOccurs())); |
| } |
| into.setMinOccurs(minOccurs); |
| into.setMaxOccurs(maxOccurs); |
| |
| // nillable, default, fixed |
| if (from.hasNillable() != into.hasNillable()) |
| into.setNillable(SchemaProperty.VARIABLE); |
| if (from.hasDefault() != into.hasDefault()) |
| into.setDefault(SchemaProperty.VARIABLE); |
| if (from.hasFixed() != into.hasFixed()) |
| into.setFixed(SchemaProperty.VARIABLE); |
| |
| // default value |
| if (into.getDefaultText() != null) |
| { |
| if (from.getDefaultText() == null || |
| !into.getDefaultText().equals(from.getDefaultText())) |
| into.setDefaultText(null); |
| } |
| } |
| |
| static SchemaParticle[] ensureStateMachine(SchemaParticle[] children) |
| { |
| for (int i = 0; i < children.length; i++) |
| { |
| buildStateMachine(children[i]); |
| } |
| return children; |
| } |
| |
| static void buildStateMachine(SchemaParticle contentModel) |
| { |
| if (contentModel == null) |
| return; |
| |
| SchemaParticleImpl partImpl = (SchemaParticleImpl)contentModel; |
| if (partImpl.hasTransitionNotes()) |
| return; |
| |
| QNameSetBuilder start = new QNameSetBuilder(); |
| QNameSetBuilder excludenext = new QNameSetBuilder(); |
| boolean deterministic = true; |
| SchemaParticle[] children = null; |
| boolean canskip = (partImpl.getMinOccurs().signum() == 0); |
| |
| switch (partImpl.getParticleType()) |
| { |
| case SchemaParticle.ELEMENT: |
| // compute start and excludeNext; canskip is already correct |
| if (partImpl.hasTransitionRules()) |
| start.addAll(partImpl.acceptedStartNames()); |
| else |
| start.add(partImpl.getName()); |
| |
| break; |
| |
| case SchemaParticle.WILDCARD: |
| // compute start and excludeNext; canskip is already correct |
| start.addAll(partImpl.getWildcardSet()); |
| break; |
| |
| case SchemaParticle.SEQUENCE: |
| children = ensureStateMachine(partImpl.getParticleChildren()); |
| |
| // adjust canskip if all children are skippable |
| canskip = true; |
| for (int i = 0; canskip && i < children.length; i++) |
| { |
| if (!(children[i]).isSkippable()) |
| canskip = false; |
| } |
| |
| // bubble up nondeterministic bit |
| for (int i = 0; deterministic && i < children.length; i++) |
| { |
| if (!((SchemaParticleImpl)children[i]).isDeterministic()) |
| deterministic = false; |
| } |
| |
| // verify deterministic and compute excludeNext set |
| for (int i = 1; i < children.length; i++) |
| { |
| excludenext.addAll(((SchemaParticleImpl)children[i - 1]).getExcludeNextSet()); |
| if (deterministic && !excludenext.isDisjoint((children[i]).acceptedStartNames())) |
| deterministic = false; |
| if ((children[i]).isSkippable()) |
| excludenext.addAll((children[i]).acceptedStartNames()); |
| else |
| excludenext.clear(); |
| } |
| |
| // next, compute start set |
| for (int i = 0; i < children.length; i++) |
| { |
| start.addAll((children[i]).acceptedStartNames()); |
| if (!(children[i]).isSkippable()) |
| break; |
| } |
| break; |
| |
| case SchemaParticle.CHOICE: |
| children = ensureStateMachine(partImpl.getParticleChildren()); |
| |
| // adjust canskip if any children are skippable |
| canskip = false; |
| for (int i = 0; !canskip && i < children.length; i++) |
| { |
| if ((children[i]).isSkippable()) |
| canskip = true; |
| } |
| |
| // bubble up nondeterministic bit |
| for (int i = 0; deterministic && i < children.length; i++) |
| { |
| if (!((SchemaParticleImpl)children[i]).isDeterministic()) |
| deterministic = false; |
| } |
| |
| // compute start and excludeNext sets, verify deterministic |
| for (int i = 0; i < children.length; i++) |
| { |
| if (deterministic && !start.isDisjoint((children[i]).acceptedStartNames())) |
| deterministic = false; |
| start.addAll((children[i]).acceptedStartNames()); |
| excludenext.addAll(((SchemaParticleImpl)children[i]).getExcludeNextSet()); |
| } |
| |
| break; |
| |
| case SchemaParticle.ALL: |
| children = ensureStateMachine(partImpl.getParticleChildren()); |
| |
| // adjust canskip if all children are skippable |
| canskip = true; |
| for (int i = 0; !canskip && i < children.length; i++) |
| { |
| if (!(children[i]).isSkippable()) |
| canskip = false; |
| } |
| |
| // bubble up nondeterministic bit |
| for (int i = 0; deterministic && i < children.length; i++) |
| { |
| if (!((SchemaParticleImpl)children[i]).isDeterministic()) |
| deterministic = false; |
| } |
| |
| // compute start and excludeNext sets, verify deterministic |
| for (int i = 0; i < children.length; i++) |
| { |
| if (deterministic && !start.isDisjoint((children[i]).acceptedStartNames())) |
| deterministic = false; |
| start.addAll((children[i]).acceptedStartNames()); |
| excludenext.addAll(((SchemaParticleImpl)children[i]).getExcludeNextSet()); |
| } |
| if (canskip) |
| excludenext.addAll(start); |
| |
| break; |
| |
| default: |
| throw new IllegalStateException("Unrecognized schema particle"); |
| } |
| |
| // apply looping logic |
| |
| BigInteger minOccurs = partImpl.getMinOccurs(); |
| BigInteger maxOccurs = partImpl.getMaxOccurs(); |
| boolean canloop = (maxOccurs == null || maxOccurs.compareTo(BigInteger.ONE) > 0); |
| boolean varloop = (maxOccurs == null || minOccurs.compareTo(maxOccurs) < 0); |
| |
| if (canloop && deterministic && !excludenext.isDisjoint(start)) |
| { |
| // we have a possible looping nondeterminism. |
| // let's take some time now to see if it's actually caused |
| // by non-unique-particle-attribute or not. |
| QNameSet suspectSet = excludenext.intersect(start); |
| |
| // compute the set of all particles that could start this group |
| Map startMap = new HashMap(); |
| particlesMatchingStart(partImpl, suspectSet, startMap, new QNameSetBuilder()); |
| |
| // compute the set of all particles that could have been repeated rather than ending this group |
| Map afterMap = new HashMap(); |
| particlesMatchingAfter(partImpl, suspectSet, afterMap, new QNameSetBuilder(), true); |
| |
| // see if we can find a member of after that is not a member of start |
| // if we can, then particle attribution is not unique |
| deterministic = afterMapSubsumedByStartMap(startMap, afterMap); |
| } |
| |
| if (varloop) |
| excludenext.addAll(start); |
| |
| canskip = canskip || minOccurs.signum() == 0; |
| |
| partImpl.setTransitionRules(start.toQNameSet(), canskip); |
| partImpl.setTransitionNotes(excludenext.toQNameSet(), deterministic); |
| } |
| |
| private static boolean afterMapSubsumedByStartMap(Map startMap, Map afterMap) |
| { |
| if (afterMap.size() > startMap.size()) |
| return false; |
| |
| if (afterMap.isEmpty()) |
| return true; |
| |
| for (Iterator i = startMap.keySet().iterator(); i.hasNext(); ) |
| { |
| SchemaParticle part = (SchemaParticle)i.next(); |
| if (part.getParticleType() == SchemaParticle.WILDCARD) |
| { |
| if (afterMap.containsKey(part)) |
| { |
| QNameSet startSet = (QNameSet)startMap.get(part); |
| QNameSet afterSet = (QNameSet)afterMap.get(part); |
| if (!startSet.containsAll(afterSet)) |
| return false; |
| } |
| } |
| afterMap.remove(part); |
| if (afterMap.isEmpty()) |
| return true; |
| } |
| return (afterMap.isEmpty()); |
| } |
| |
| private static void particlesMatchingStart(SchemaParticle part, QNameSetSpecification suspectSet, Map result, QNameSetBuilder eliminate) |
| { |
| switch (part.getParticleType()) |
| { |
| case SchemaParticle.ELEMENT: |
| if (!suspectSet.contains(part.getName())) |
| return; |
| result.put(part, null); |
| eliminate.add(part.getName()); |
| return; |
| |
| case SchemaParticle.WILDCARD: |
| if (suspectSet.isDisjoint(part.getWildcardSet())) |
| return; |
| result.put(part, part.getWildcardSet().intersect(suspectSet)); |
| eliminate.addAll(part.getWildcardSet()); |
| return; |
| |
| case SchemaParticle.CHOICE: |
| case SchemaParticle.ALL: |
| { |
| SchemaParticle[] children = part.getParticleChildren(); |
| for (int i = 0; i < children.length; i++) |
| particlesMatchingStart(children[i], suspectSet, result, eliminate); |
| return; |
| } |
| |
| case SchemaParticle.SEQUENCE: |
| { |
| SchemaParticle[] children = part.getParticleChildren(); |
| if (children.length == 0) |
| return; |
| if (!children[0].isSkippable()) |
| { |
| particlesMatchingStart(children[0], suspectSet, result, eliminate); |
| return; |
| } |
| QNameSetBuilder remainingSuspects = new QNameSetBuilder(suspectSet); |
| QNameSetBuilder suspectsToEliminate = new QNameSetBuilder(); |
| for (int i = 0; i < children.length; i++) |
| { |
| particlesMatchingStart(children[i], remainingSuspects, result, suspectsToEliminate); |
| eliminate.addAll(suspectsToEliminate); |
| if (!children[i].isSkippable()) |
| return; |
| remainingSuspects.removeAll(suspectsToEliminate); |
| if (remainingSuspects.isEmpty()) |
| return; |
| suspectsToEliminate.clear(); |
| } |
| return; |
| } |
| } |
| } |
| |
| private static void particlesMatchingAfter(SchemaParticle part, QNameSetSpecification suspectSet, Map result, QNameSetBuilder eliminate, boolean top) |
| { |
| recurse: switch (part.getParticleType()) |
| { |
| case SchemaParticle.CHOICE: |
| case SchemaParticle.ALL: |
| { |
| SchemaParticle[] children = part.getParticleChildren(); |
| for (int i = 0; i < children.length; i++) |
| particlesMatchingAfter(children[i], suspectSet, result, eliminate, false); |
| break recurse; |
| } |
| |
| case SchemaParticle.SEQUENCE: |
| { |
| SchemaParticle[] children = part.getParticleChildren(); |
| if (children.length == 0) |
| break recurse; |
| if (!children[children.length - 1].isSkippable()) |
| { |
| particlesMatchingAfter(children[0], suspectSet, result, eliminate, false); |
| break recurse; |
| } |
| QNameSetBuilder remainingSuspects = new QNameSetBuilder(suspectSet); |
| QNameSetBuilder suspectsToEliminate = new QNameSetBuilder(); |
| for (int i = children.length - 1; i >= 0; i--) |
| { |
| particlesMatchingAfter(children[i], remainingSuspects, result, suspectsToEliminate, false); |
| eliminate.addAll(suspectsToEliminate); |
| if (!children[i].isSkippable()) |
| break recurse; |
| remainingSuspects.removeAll(suspectsToEliminate); |
| if (remainingSuspects.isEmpty()) |
| break recurse; |
| suspectsToEliminate.clear(); |
| } |
| break recurse; |
| } |
| } |
| |
| if (!top) |
| { |
| BigInteger minOccurs = part.getMinOccurs(); |
| BigInteger maxOccurs = part.getMaxOccurs(); |
| boolean varloop = (maxOccurs == null || minOccurs.compareTo(maxOccurs) < 0); |
| if (varloop) |
| { |
| particlesMatchingStart(part, suspectSet, result, eliminate); |
| } |
| } |
| } |
| |
| private static class CodeForNameEntry |
| { |
| CodeForNameEntry(QName name, int code) |
| { this.name = name; this.code = code; } |
| public QName name; |
| public int code; |
| } |
| |
| private static final int MODEL_GROUP_CODE = 100; |
| |
| private static CodeForNameEntry[] particleCodes = new CodeForNameEntry[] |
| { |
| new CodeForNameEntry(QNameHelper.forLNS("all", "http://www.w3.org/2001/XMLSchema"), SchemaParticle.ALL), |
| new CodeForNameEntry(QNameHelper.forLNS("sequence", "http://www.w3.org/2001/XMLSchema"), SchemaParticle.SEQUENCE), |
| new CodeForNameEntry(QNameHelper.forLNS("choice", "http://www.w3.org/2001/XMLSchema"), SchemaParticle.CHOICE), |
| new CodeForNameEntry(QNameHelper.forLNS("element", "http://www.w3.org/2001/XMLSchema"), SchemaParticle.ELEMENT), |
| new CodeForNameEntry(QNameHelper.forLNS("any", "http://www.w3.org/2001/XMLSchema"), SchemaParticle.WILDCARD), |
| new CodeForNameEntry(QNameHelper.forLNS("group", "http://www.w3.org/2001/XMLSchema"), MODEL_GROUP_CODE), |
| }; |
| |
| private static Map particleCodeMap = buildParticleCodeMap(); |
| |
| private static Map buildParticleCodeMap() |
| { |
| Map result = new HashMap(); |
| for (int i = 0; i < particleCodes.length; i++) |
| result.put(particleCodes[i].name, new Integer(particleCodes[i].code)); |
| return result; |
| } |
| |
| private static int translateParticleCode(Group parseEg) |
| { |
| if (parseEg == null) |
| return 0; |
| return translateParticleCode(parseEg.newCursor().getName()); |
| } |
| |
| private static int translateParticleCode(QName name) |
| { |
| Integer result = (Integer)particleCodeMap.get(name); |
| if (result == null) |
| return 0; |
| return result.intValue(); |
| } |
| |
| private static final int ATTRIBUTE_CODE = 100; |
| private static final int ATTRIBUTE_GROUP_CODE = 101; |
| private static final int ANY_ATTRIBUTE_CODE = 102; |
| |
| private static CodeForNameEntry[] attributeCodes = new CodeForNameEntry[] |
| { |
| new CodeForNameEntry(QNameHelper.forLNS("attribute", "http://www.w3.org/2001/XMLSchema"), ATTRIBUTE_CODE), |
| new CodeForNameEntry(QNameHelper.forLNS("attributeGroup", "http://www.w3.org/2001/XMLSchema"), ATTRIBUTE_GROUP_CODE), |
| new CodeForNameEntry(QNameHelper.forLNS("anyAttribute", "http://www.w3.org/2001/XMLSchema"), ANY_ATTRIBUTE_CODE), |
| }; |
| |
| private static Map attributeCodeMap = buildAttributeCodeMap(); |
| |
| private static Map buildAttributeCodeMap() |
| { |
| Map result = new HashMap(); |
| for (int i = 0; i < attributeCodes.length; i++) |
| result.put(attributeCodes[i].name, new Integer(attributeCodes[i].code)); |
| return result; |
| } |
| |
| static int translateAttributeCode(QName currentName) |
| { |
| Integer result = (Integer)attributeCodeMap.get(currentName); |
| if (result == null) |
| return 0; |
| return result.intValue(); |
| } |
| |
| |
| } |
