in src/org/apache/xerces/impl/xs/traversers/XSDComplexTypeTraverser.java [352:680]
private void traverseSimpleContent(Element simpleContentElement,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar)
throws ComplexTypeRecoverableError {
Object[] simpleContentAttrValues = fAttrChecker.checkAttributes(simpleContentElement, false,
schemaDoc);
// -----------------------------------------------------------------------
// Set content type
// -----------------------------------------------------------------------
fContentType = XSComplexTypeDecl.CONTENTTYPE_SIMPLE;
fParticle = null;
Element simpleContent = DOMUtil.getFirstChildElement(simpleContentElement);
if (simpleContent != null && DOMUtil.getLocalName(simpleContent).equals(SchemaSymbols.ELT_ANNOTATION)) {
addAnnotation(traverseAnnotationDecl(simpleContent, simpleContentAttrValues, false, schemaDoc));
simpleContent = DOMUtil.getNextSiblingElement(simpleContent);
}
else {
String text = DOMUtil.getSyntheticAnnotation(simpleContentElement);
if (text != null) {
addAnnotation(traverseSyntheticAnnotation(simpleContentElement, text, simpleContentAttrValues, false, schemaDoc));
}
}
// If there are no children, return
if (simpleContent==null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.2",
new Object[]{fName,SchemaSymbols.ELT_SIMPLECONTENT},
simpleContentElement);
}
// -----------------------------------------------------------------------
// The content should be either "restriction" or "extension"
// -----------------------------------------------------------------------
String simpleContentName = DOMUtil.getLocalName(simpleContent);
if (simpleContentName.equals(SchemaSymbols.ELT_RESTRICTION))
fDerivedBy = XSConstants.DERIVATION_RESTRICTION;
else if (simpleContentName.equals(SchemaSymbols.ELT_EXTENSION))
fDerivedBy = XSConstants.DERIVATION_EXTENSION;
else {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,simpleContentName},
simpleContent);
}
Element elemTmp = DOMUtil.getNextSiblingElement(simpleContent);
if (elemTmp != null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
String siblingName = DOMUtil.getLocalName(elemTmp);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,siblingName},
elemTmp);
}
Object [] derivationTypeAttrValues = fAttrChecker.checkAttributes(simpleContent, false,
schemaDoc);
QName baseTypeName = (QName) derivationTypeAttrValues[XSAttributeChecker.ATTIDX_BASE];
// -----------------------------------------------------------------------
// Need a base type.
// -----------------------------------------------------------------------
if (baseTypeName==null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-att-must-appear",
new Object[]{simpleContentName, "base"}, simpleContent);
}
XSTypeDefinition type = (XSTypeDefinition)fSchemaHandler.getGlobalDecl(schemaDoc,
XSDHandler.TYPEDECL_TYPE, baseTypeName,
simpleContent);
if (type==null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError();
}
fBaseType = type;
XSSimpleType baseValidator = null;
XSComplexTypeDecl baseComplexType = null;
int baseFinalSet = 0;
// If the base type is complex, it must have simpleContent
if ((type.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE)) {
baseComplexType = (XSComplexTypeDecl)type;
baseFinalSet = baseComplexType.getFinal();
// base is a CT with simple content (both restriction and extension are OK)
if (baseComplexType.getContentType() == XSComplexTypeDecl.CONTENTTYPE_SIMPLE) {
baseValidator = (XSSimpleType)baseComplexType.getSimpleType();
}
// base is a CT with mixed/emptiable content (only restriction is OK)
else if (fDerivedBy == XSConstants.DERIVATION_RESTRICTION &&
baseComplexType.getContentType() == XSComplexTypeDecl.CONTENTTYPE_MIXED &&
((XSParticleDecl)baseComplexType.getParticle()).emptiable()) {
}
else {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("src-ct.2.1",
new Object[]{fName, baseComplexType.getName()}, simpleContent);
}
}
else {
baseValidator = (XSSimpleType)type;
// base is a ST (only extension is OK)
if (fDerivedBy == XSConstants.DERIVATION_RESTRICTION) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("src-ct.2.1",
new Object[]{fName, baseValidator.getName()}, simpleContent);
}
baseFinalSet=baseValidator.getFinal();
}
// -----------------------------------------------------------------------
// Check that the base permits the derivation
// -----------------------------------------------------------------------
if ((baseFinalSet & fDerivedBy)!=0) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
String errorKey = (fDerivedBy==XSConstants.DERIVATION_EXTENSION) ?
"cos-ct-extends.1.1" : "derivation-ok-restriction.1";
throw new ComplexTypeRecoverableError(errorKey,
new Object[]{fName, fBaseType.getName()}, simpleContent);
}
// -----------------------------------------------------------------------
// Skip over any potential annotations
// -----------------------------------------------------------------------
Element scElement = simpleContent;
simpleContent = DOMUtil.getFirstChildElement(simpleContent);
if (simpleContent != null) {
// traverse annotation if any
if (DOMUtil.getLocalName(simpleContent).equals(SchemaSymbols.ELT_ANNOTATION)) {
addAnnotation(traverseAnnotationDecl(simpleContent, derivationTypeAttrValues, false, schemaDoc));
simpleContent = DOMUtil.getNextSiblingElement(simpleContent);
}
else {
String text = DOMUtil.getSyntheticAnnotation(scElement);
if (text != null) {
addAnnotation(traverseSyntheticAnnotation(scElement, text, derivationTypeAttrValues, false, schemaDoc));
}
}
if (simpleContent !=null &&
DOMUtil.getLocalName(simpleContent).equals(SchemaSymbols.ELT_ANNOTATION)){
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,SchemaSymbols.ELT_ANNOTATION},
simpleContent);
}
}
else {
String text = DOMUtil.getSyntheticAnnotation(scElement);
if (text != null) {
addAnnotation(traverseSyntheticAnnotation(scElement, text, derivationTypeAttrValues, false, schemaDoc));
}
}
// -----------------------------------------------------------------------
// Process a RESTRICTION
// -----------------------------------------------------------------------
if (fDerivedBy == XSConstants.DERIVATION_RESTRICTION) {
// -----------------------------------------------------------------------
// There may be a simple type definition in the restriction element
// The data type validator will be based on it, if specified
// -----------------------------------------------------------------------
if (simpleContent !=null &&
DOMUtil.getLocalName(simpleContent).equals(SchemaSymbols.ELT_SIMPLETYPE )) {
XSSimpleType dv = fSchemaHandler.fSimpleTypeTraverser.traverseLocal(
simpleContent, schemaDoc, grammar);
if (dv == null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError();
}
//check that this datatype validator is validly derived from the base
//according to derivation-ok-restriction 5.1.2.1
if (baseValidator != null &&
!XSConstraints.checkSimpleDerivationOk(dv, baseValidator,
baseValidator.getFinal())) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("derivation-ok-restriction.5.2.2.1",
new Object[]{fName, dv.getName(), baseValidator.getName()},
simpleContent);
}
baseValidator = dv;
simpleContent = DOMUtil.getNextSiblingElement(simpleContent);
}
// this only happens when restricting a mixed/emptiable CT
// but there is no <simpleType>, which is required
if (baseValidator == null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("src-ct.2.2",
new Object[]{fName}, simpleContent);
}
// -----------------------------------------------------------------------
// Traverse any facets
// -----------------------------------------------------------------------
Element attrNode = null;
XSFacets facetData = null;
short presentFacets = 0 ;
short fixedFacets = 0 ;
if (simpleContent!=null) {
FacetInfo fi = traverseFacets(simpleContent, fComplexTypeDecl, baseValidator, schemaDoc);
attrNode = fi.nodeAfterFacets;
facetData = fi.facetdata;
presentFacets = fi.fPresentFacets;
fixedFacets = fi.fFixedFacets;
}
String name = genAnonTypeName(simpleContentElement);
fXSSimpleType = fSchemaHandler.fDVFactory.createTypeRestriction(name,schemaDoc.fTargetNamespace,(short)0,baseValidator,null);
try{
fValidationState.setNamespaceSupport(schemaDoc.fNamespaceSupport);
fXSSimpleType.applyFacets(facetData, presentFacets, fixedFacets, fValidationState);
}catch(InvalidDatatypeFacetException ex){
reportSchemaError(ex.getKey(), ex.getArgs(), simpleContent);
// Recreate the type, ignoring the facets
fXSSimpleType = fSchemaHandler.fDVFactory.createTypeRestriction(name,schemaDoc.fTargetNamespace,(short)0,baseValidator,null);
}
if (fXSSimpleType instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl)fXSSimpleType).setAnonymous(true);
}
// -----------------------------------------------------------------------
// Traverse any attributes
// -----------------------------------------------------------------------
if (attrNode != null) {
if (!isAttrOrAttrGroup(attrNode)) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,DOMUtil.getLocalName(attrNode)},
attrNode);
}
Element node=traverseAttrsAndAttrGrps(attrNode,fAttrGrp,
schemaDoc,grammar,fComplexTypeDecl);
if (node!=null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,DOMUtil.getLocalName(node)},
node);
}
}
try {
mergeAttributes(baseComplexType.getAttrGrp(), fAttrGrp, fName, false, simpleContentElement);
} catch (ComplexTypeRecoverableError e) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw e;
}
// Prohibited uses must be removed after merge for RESTRICTION
fAttrGrp.removeProhibitedAttrs();
Object[] errArgs=fAttrGrp.validRestrictionOf(fName, baseComplexType.getAttrGrp());
if (errArgs != null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError((String)errArgs[errArgs.length-1],
errArgs, attrNode);
}
}
// -----------------------------------------------------------------------
// Process a EXTENSION
// -----------------------------------------------------------------------
else {
fXSSimpleType = baseValidator;
if (simpleContent != null) {
// -----------------------------------------------------------------------
// Traverse any attributes
// -----------------------------------------------------------------------
Element attrNode = simpleContent;
if (!isAttrOrAttrGroup(attrNode)) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,DOMUtil.getLocalName(attrNode)},
attrNode);
}
Element node=traverseAttrsAndAttrGrps(attrNode,fAttrGrp,
schemaDoc,grammar,fComplexTypeDecl);
if (node!=null) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw new ComplexTypeRecoverableError("s4s-elt-invalid-content.1",
new Object[]{fName,DOMUtil.getLocalName(node)},
node);
}
// Remove prohibited uses. Should be done prior to any merge.
fAttrGrp.removeProhibitedAttrs();
}
if (baseComplexType != null) {
try {
mergeAttributes(baseComplexType.getAttrGrp(), fAttrGrp, fName, true, simpleContentElement);
} catch (ComplexTypeRecoverableError e) {
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
throw e;
}
}
}
// and finally, since we've nothing more to traverse, we can
// return the attributes (and thereby reset the namespace support)
fAttrChecker.returnAttrArray(simpleContentAttrValues, schemaDoc);
fAttrChecker.returnAttrArray(derivationTypeAttrValues, schemaDoc);
}