/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 2001, International
* Business Machines, Inc., http://www.apache.org. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.xerces.impl.xs.traversers;
import org.apache.xerces.impl.dv.XSSimpleType;
import org.apache.xerces.impl.dv.ValidatedInfo;
import org.apache.xerces.impl.dv.InvalidDatatypeValueException;
import org.apache.xerces.impl.validation.ValidationContext;
import org.apache.xerces.util.SymbolTable;
import org.apache.xerces.impl.xs.SchemaGrammar;
import org.apache.xerces.impl.xs.SchemaSymbols;
import org.apache.xerces.impl.xs.XSAttributeDecl;
import org.apache.xerces.impl.xs.XSAttributeUse;
import org.apache.xerces.impl.xs.XSElementDecl;
import org.apache.xerces.impl.xs.XSTypeDecl;
import org.apache.xerces.xni.QName;
import org.apache.xerces.impl.XMLErrorReporter;
import org.apache.xerces.util.DOMUtil;
import org.apache.xerces.util.SymbolTable;
import org.apache.xerces.impl.xs.util.XInt;
import org.apache.xerces.impl.validation.ValidationState;
import org.w3c.dom.Element;
/**
* The attribute declaration schema component traverser.
*
* <attribute
* default = string
* fixed = string
* form = (qualified | unqualified)
* id = ID
* name = NCName
* ref = QName
* type = QName
* use = (optional | prohibited | required) : optional
* {any attributes with non-schema namespace . . .}>
* Content: (annotation?, (simpleType?))
* </attribute>
*
* @author Sandy Gao, IBM
* @author Neeraj Bajaj, Sun Microsystems, inc.
* @version $Id: XSDAttributeTraverser.java,v 1.7 2001/12/14 20:04:16 sandygao Exp $
*/
class XSDAttributeTraverser extends XSDAbstractTraverser {
public XSDAttributeTraverser (XSDHandler handler,
XSAttributeChecker gAttrCheck) {
super(handler, gAttrCheck);
}
protected XSAttributeUse traverseLocal(Element attrDecl,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar) {
// General Attribute Checking
Object[] attrValues = fAttrChecker.checkAttributes(attrDecl, false, schemaDoc);
String defaultAtt = (String) attrValues[XSAttributeChecker.ATTIDX_DEFAULT];
String fixedAtt = (String) attrValues[XSAttributeChecker.ATTIDX_FIXED];
String nameAtt = (String) attrValues[XSAttributeChecker.ATTIDX_NAME];
QName refAtt = (QName) attrValues[XSAttributeChecker.ATTIDX_REF];
XInt useAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_USE];
// get 'attribute declaration'
XSAttributeDecl attribute = null;
if (attrDecl.getAttributeNode(SchemaSymbols.ATT_REF) != null) {
if (refAtt != null) {
attribute = (XSAttributeDecl)fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.ATTRIBUTE_TYPE, refAtt);
Element child = DOMUtil.getFirstChildElement(attrDecl);
if(child != null && DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
traverseAnnotationDecl(child, attrValues, false, schemaDoc);
child = DOMUtil.getNextSiblingElement(child);
}
if (child != null) {
reportSchemaError("src-attribute.3.2", new Object[]{refAtt});
}
// for error reporting
nameAtt = refAtt.localpart;
} else {
attribute = null;
}
} else {
attribute = traverseNamedAttr(attrDecl, attrValues, schemaDoc, grammar, false);
}
// get 'value constraint'
short consType = XSAttributeDecl.NO_CONSTRAINT;
if (defaultAtt != null) {
consType = XSAttributeDecl.DEFAULT_VALUE;
} else if (fixedAtt != null) {
consType = XSAttributeDecl.FIXED_VALUE;
defaultAtt = fixedAtt;
fixedAtt = null;
}
XSAttributeUse attrUse = null;
if (attribute != null) {
attrUse = new XSAttributeUse();
attrUse.fAttrDecl = attribute;
attrUse.fUse = useAtt.shortValue();
attrUse.fConstraintType = consType;
if (defaultAtt != null) {
attrUse.fDefault = new ValidatedInfo();
attrUse.fDefault.normalizedValue = defaultAtt;
}
}
fAttrChecker.returnAttrArray(attrValues, schemaDoc);
//src-attribute
// 1 default and fixed must not both be present.
if (defaultAtt != null && fixedAtt != null) {
reportSchemaError("src-attribute.1", new Object[]{nameAtt});
}
// 2 If default and use are both present, use must have the actual value optional.
if (consType == XSAttributeDecl.DEFAULT_VALUE &&
useAtt != null && useAtt.intValue() != SchemaSymbols.USE_OPTIONAL) {
reportSchemaError("src-attribute.2", new Object[]{nameAtt});
}
// a-props-correct
if (defaultAtt != null && attrUse != null) {
// 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 String Valid (3.14.4).
fValidationState.setNamespaceSupport(schemaDoc.fNamespaceSupport);
if (!checkDefaultValid(attrUse)) {
reportSchemaError ("a-props-correct.2", new Object[]{nameAtt, defaultAtt});
}
// 3 If the {type definition} is or is derived from ID then there must not be a {value constraint}.
if (attribute.fType.isIDType() ) {
reportSchemaError ("a-props-correct.3", new Object[]{nameAtt});
}
// check 3.5.6 constraint
// Attribute Use Correct
// 2 If the {attribute declaration} has a fixed {value constraint}, then if the attribute use itself has a {value constraint}, it must also be fixed and its value must match that of the {attribute declaration}'s {value constraint}.
if (attrUse.fAttrDecl.getConstraintType() == XSAttributeDecl.FIXED_VALUE &&
attrUse.fConstraintType != XSAttributeDecl.NO_CONSTRAINT) {
if (attrUse.fConstraintType != XSAttributeDecl.FIXED_VALUE ||
attrUse.fAttrDecl.fType.isEqual(attrUse.fAttrDecl.fDefault.actualValue,
attrUse.fDefault.actualValue)) {
reportSchemaError ("au-props-correct.2", new Object[]{nameAtt});
}
}
}
return attrUse;
}
protected XSAttributeDecl traverseGlobal(Element attrDecl,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar) {
// General Attribute Checking
Object[] attrValues = fAttrChecker.checkAttributes(attrDecl, true, schemaDoc);
XSAttributeDecl attribute = traverseNamedAttr(attrDecl, attrValues, schemaDoc, grammar, true);
fAttrChecker.returnAttrArray(attrValues, schemaDoc);
if (attribute != null)
attribute.setIsGlobal();
return attribute;
}
/**
* Traverse a globally declared attribute.
*
* @param attrDecl
* @param attrValues
* @param schemaDoc
* @param grammar
* @param isGlobal
* @return the attribute declaration index
*/
XSAttributeDecl traverseNamedAttr(Element attrDecl,
Object[] attrValues,
XSDocumentInfo schemaDoc,
SchemaGrammar grammar,
boolean isGlobal) {
String defaultAtt = (String) attrValues[XSAttributeChecker.ATTIDX_DEFAULT];
String fixedAtt = (String) attrValues[XSAttributeChecker.ATTIDX_FIXED];
XInt formAtt = (XInt) attrValues[XSAttributeChecker.ATTIDX_FORM];
String nameAtt = (String) attrValues[XSAttributeChecker.ATTIDX_NAME];
QName typeAtt = (QName) attrValues[XSAttributeChecker.ATTIDX_TYPE];
// Step 1: get declaration information
XSAttributeDecl attribute = new XSAttributeDecl();
// get 'name'
if (nameAtt != null)
attribute.fName = fSymbolTable.addSymbol(nameAtt);
// get 'target namespace'
if (isGlobal) {
attribute.fTargetNamespace = schemaDoc.fTargetNamespace;
}
else if (formAtt != null) {
if (formAtt.intValue() == SchemaSymbols.FORM_QUALIFIED)
attribute.fTargetNamespace = schemaDoc.fTargetNamespace;
else
attribute.fTargetNamespace = null;
} else if (schemaDoc.fAreLocalAttributesQualified) {
attribute.fTargetNamespace = schemaDoc.fTargetNamespace;
} else {
attribute.fTargetNamespace = null;
}
// get 'value constraint'
// for local named attribute, value constraint is absent
if (isGlobal) {
if (fixedAtt != null) {
attribute.fDefault = new ValidatedInfo();
attribute.fDefault.normalizedValue = fixedAtt;
attribute.setConstraintType(XSElementDecl.FIXED_VALUE);
} else if (defaultAtt != null) {
attribute.fDefault = new ValidatedInfo();
attribute.fDefault.normalizedValue = defaultAtt;
attribute.setConstraintType(XSElementDecl.DEFAULT_VALUE);
} else {
attribute.setConstraintType(XSElementDecl.NO_CONSTRAINT);
}
}
// get 'annotation'
Element child = DOMUtil.getFirstChildElement(attrDecl);
if(child != null && DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
traverseAnnotationDecl(child, attrValues, false, schemaDoc);
child = DOMUtil.getNextSiblingElement(child);
}
// get 'type definition'
XSSimpleType attrType = null;
boolean haveAnonType = false;
// Handle Anonymous type if there is one
if (child != null) {
String childName = DOMUtil.getLocalName(child);
if (childName.equals(SchemaSymbols.ELT_SIMPLETYPE)) {
attrType = fSchemaHandler.fSimpleTypeTraverser.traverseLocal(child, schemaDoc, grammar);
haveAnonType = true;
child = DOMUtil.getNextSiblingElement(child);
}
}
// Handler type attribute
if (attrType == null && typeAtt != null) {
XSTypeDecl type = (XSTypeDecl)fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.TYPEDECL_TYPE, typeAtt);
if (type != null && type.getXSType() == XSTypeDecl.SIMPLE_TYPE)
attrType = (XSSimpleType)type;
else
// REVISIT: what should be the error code here
reportGenericSchemaError("the type for attribute '"+nameAtt+"' must be a simpleType");
}
if (attrType == null) {
attrType = SchemaGrammar.fAnySimpleType;
}
attribute.fType = attrType;
// Step 2: register attribute decl to the grammar
if (isGlobal && nameAtt != null)
grammar.addGlobalAttributeDecl(attribute);
// Step 3: check against schema for schemas
// required attributes
if (nameAtt == null) {
if (isGlobal)
reportSchemaError("s4s-att-must-appear", new Object[]{SchemaSymbols.ELT_ATTRIBUTE, SchemaSymbols.ATT_NAME});
else
reportSchemaError("src-attribute.3.1", null);
nameAtt = NO_NAME;
}
// element
if (child != null) {
reportSchemaError("s4s-elt-must-match", new Object[]{nameAtt, "(annotation?, (simpleType?))"});
}
// Step 4: check 3.2.3 constraints
// src-attribute
// 1 default and fixed must not both be present.
if (defaultAtt != null && fixedAtt != null) {
reportSchemaError("src-attribute.1", new Object[]{nameAtt});
}
// 2 If default and use are both present, use must have the actual value optional.
// This is checked in "traverse" method
// 3 If the item's parent is not <schema>, then all of the following must be true:
// 3.1 One of ref or name must be present, but not both.
// This is checked in XSAttributeChecker
// 3.2 If ref is present, then all of <simpleType>, form and type must be absent.
// Attributes are checked in XSAttributeChecker, elements are checked in "traverse" method
// 4 type and <simpleType> must not both be present.
if (haveAnonType && (typeAtt != null)) {
reportSchemaError( "src-attribute.4", new Object[]{nameAtt});
}
// Step 5: check 3.2.6 constraints
// check for NOTATION type
checkNotationType(nameAtt, attrType);
// a-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 String Valid (3.14.4).
if (attribute.fDefault != null) {
fValidationState.setNamespaceSupport(schemaDoc.fNamespaceSupport);
if (!checkDefaultValid(attribute)) {
reportSchemaError ("a-props-correct.2", new Object[]{nameAtt, defaultAtt});
}
}
// 3 If the {type definition} is or is derived from ID then there must not be a {value constraint}.
if (attribute.fDefault != null) {
if (attrType.isIDType() ) {
reportSchemaError ("a-props-correct.3", new Object[]{nameAtt});
}
}
// no-xmlns
// The {name} of an attribute declaration must not match xmlns.
if (nameAtt != null && nameAtt.equals(SchemaSymbols.XMLNS)) {
reportSchemaError("no-xmlns", null);
}
// no-xsi
// The {target namespace} of an attribute declaration, whether local or top-level, must not match http://www.w3.org/2001/XMLSchema-instance (unless it is one of the four built-in declarations given in the next section).
if (attribute.fTargetNamespace != null && attribute.fTargetNamespace.equals(SchemaSymbols.URI_XSI)) {
reportSchemaError("no-xsi", new Object[]{SchemaSymbols.URI_XSI});
}
return attribute;
}
// return whether the constraint value is valid for the given type
boolean checkDefaultValid(XSAttributeDecl attribute) {
boolean ret = true;
try {
//set the actual value
attribute.fType.validate(attribute.fDefault.normalizedValue, fValidationState, attribute.fDefault);
} catch (InvalidDatatypeValueException ide) {
ret = false;
}
return ret;
}
// return whether the constraint value is valid for the given type
boolean checkDefaultValid(XSAttributeUse attrUse) {
boolean ret = true;
try {
//set the actual value
attrUse.fAttrDecl.fType.validate(attrUse.fDefault.normalizedValue, fValidationState, attrUse.fDefault);
} catch (InvalidDatatypeValueException ide) {
ret = false;
}
return ret;
}
}