child = DOMUtil.getNextSiblingElement(child);
}
element.fAnnotation = annotation;
// get 'type definition'
XSTypeDefinition elementType = null;
boolean haveAnonType = false;
// Handle Anonymous type if there is one
if (child != null) {
String childName = DOMUtil.getLocalName(child);
if (childName.equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
elementType = fSchemaHandler.fComplexTypeTraverser.traverseLocal(child, schemaDoc, grammar);
haveAnonType = true;
child = DOMUtil.getNextSiblingElement(child);
}
else if (childName.equals(SchemaSymbols.ELT_SIMPLETYPE)) {
elementType = fSchemaHandler.fSimpleTypeTraverser.traverseLocal(child, schemaDoc, grammar);
haveAnonType = true;
child = DOMUtil.getNextSiblingElement(child);
}
}
// Handler type attribute
if (elementType == null && typeAtt != null) {
elementType = (XSTypeDefinition)fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.TYPEDECL_TYPE, typeAtt, elmDecl);
}
// Get it from the substitutionGroup declaration
if (elementType == null && element.fSubGroup != null) {
elementType = element.fSubGroup.fType;
}
if (elementType == null) {
elementType = SchemaGrammar.fAnyType;
}
element.fType = elementType;
// get 'identity constraint'
// see if there's something here; it had better be key, keyref or unique.
if (child != null) {
String childName = DOMUtil.getLocalName(child);
while (child != null &&
(childName.equals(SchemaSymbols.ELT_KEY) ||
childName.equals(SchemaSymbols.ELT_KEYREF) ||
childName.equals(SchemaSymbols.ELT_UNIQUE))) {
if (childName.equals(SchemaSymbols.ELT_KEY) ||
childName.equals(SchemaSymbols.ELT_UNIQUE)) {
// need to set <key>/<unique> to hidden before traversing it,
// because it has global scope
DOMUtil.setHidden(child);
fSchemaHandler.fUniqueOrKeyTraverser.traverse(child, element, schemaDoc, grammar);
if(DOMUtil.getAttrValue(child, SchemaSymbols.ATT_NAME).length() != 0 ) {
fSchemaHandler.checkForDuplicateNames(
(schemaDoc.fTargetNamespace == null) ? ","+DOMUtil.getAttrValue(child, SchemaSymbols.ATT_NAME)
: schemaDoc.fTargetNamespace+","+ DOMUtil.getAttrValue(child, SchemaSymbols.ATT_NAME),
fSchemaHandler.getIDRegistry(),
child, schemaDoc);
}
} else if (childName.equals(SchemaSymbols.ELT_KEYREF)) {
fSchemaHandler.storeKeyRef(child, schemaDoc, element);
}
child = DOMUtil.getNextSiblingElement(child);
if (child != null) {
childName = DOMUtil.getLocalName(child);
}
}
}
// Step 2: register the element decl to the grammar
if (isGlobal && nameAtt != null)
grammar.addGlobalElementDecl(element);
// Step 3: check against schema for schemas
// required attributes
if (nameAtt == null) {
if (isGlobal)
reportSchemaError("s4s-att-must-appear", new Object[]{SchemaSymbols.ELT_ELEMENT, SchemaSymbols.ATT_NAME}, elmDecl);
else
reportSchemaError("src-element.2.1", null, elmDecl);
nameAtt = NO_NAME;
}
// element
if (child != null) {
reportSchemaError("s4s-elt-must-match.1", new Object[]{nameAtt, "(annotation?, (simpleType | complexType)?, (unique | key | keyref)*))", DOMUtil.getLocalName(child)}, child);
}
// Step 4: check 3.3.3 constraints
// src-element
// 1 default and fixed must not both be present.
if (defaultAtt != null && fixedAtt != null) {
reportSchemaError("src-element.1", new Object[]{nameAtt}, elmDecl);
}
// 2 If the item's parent is not <schema>, then all of the following must be true:
// 2.1 One of ref or name must be present, but not both.
// This is checked in XSAttributeChecker
// 2.2 If ref is present, then all of <complexType>, <simpleType>, <key>, <keyref>, <unique>, nillable, default, fixed, form, block and type must be absent, i.e. only minOccurs, maxOccurs, id are allowed in addition to ref, along with <annotation>.
// Attributes are checked in XSAttributeChecker, elements are checked in "traverse" method
// 3 type and either <simpleType> or <complexType> are mutually exclusive.
if (haveAnonType && (typeAtt != null)) {
reportSchemaError("src-element.3", new Object[]{nameAtt}, elmDecl);
}
// Step 5: check 3.3.6 constraints
// check for NOTATION type
checkNotationType(nameAtt, elementType, elmDecl);
// e-props-correct
// 2 If there is a {value constraint}, the canonical lexical representation of its value must be valid with respect to the {type definition} as defined in Element Default Valid (Immediate) (3.3.6).
if (element.fDefault != null) {
fValidationState.setNamespaceSupport(schemaDoc.fNamespaceSupport);
if (XSConstraints.ElementDefaultValidImmediate(element.fType, element.fDefault.normalizedValue, fValidationState, element.fDefault) == null) {
reportSchemaError ("e-props-correct.2", new Object[]{nameAtt, element.fDefault.normalizedValue}, elmDecl);
element.setConstraintType(XSConstants.VC_NONE);
}
}
// 4 If there is an {substitution group affiliation}, the {type definition} of the element declaration must be validly derived from the {type definition} of the {substitution group affiliation}, given the value of the {substitution group exclusions} of the {substitution group affiliation}, as defined in Type Derivation OK (Complex) (3.4.6) (if the {type definition} is complex) or as defined in Type Derivation OK (Simple) (3.14.6) (if the {type definition} is simple).
if (element.fSubGroup != null) {
if (!XSConstraints.checkTypeDerivationOk(element.fType, element.fSubGroup.fType, element.fSubGroup.fFinal)) {
reportSchemaError ("e-props-correct.4", new Object[]{nameAtt, subGroupAtt.prefix+":"+subGroupAtt.localpart}, elmDecl);
}
}
// 5 If the {type definition} or {type definition}'s {content type} is or is derived from ID then there must not be a {value constraint}.
if (element.fDefault != null) {
if ((elementType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE &&
((XSSimpleType)elementType).isIDType()) ||
(elementType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE &&
((XSComplexTypeDecl)elementType).containsTypeID())) {
reportSchemaError ("e-props-correct.5", new Object[]{element.fName}, elmDecl);
}
}