diff options
Diffstat (limited to 'libjava/classpath/gnu/xml/validation/xmlschema/XMLSchemaBuilder.java')
| -rw-r--r-- | libjava/classpath/gnu/xml/validation/xmlschema/XMLSchemaBuilder.java | 839 |
1 files changed, 839 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/xml/validation/xmlschema/XMLSchemaBuilder.java b/libjava/classpath/gnu/xml/validation/xmlschema/XMLSchemaBuilder.java new file mode 100644 index 000000000..a7bad3129 --- /dev/null +++ b/libjava/classpath/gnu/xml/validation/xmlschema/XMLSchemaBuilder.java @@ -0,0 +1,839 @@ +/* XMLSchemaBuilder.java -- + Copyright (C) 2006 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.xml.validation.xmlschema; + +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.StringTokenizer; +import javax.xml.XMLConstants; +import javax.xml.namespace.QName; +import org.relaxng.datatype.DatatypeException; +import org.relaxng.datatype.DatatypeLibrary; +import org.relaxng.datatype.helpers.DatatypeLibraryLoader; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import gnu.xml.validation.datatype.Annotation; +import gnu.xml.validation.datatype.SimpleType; +import gnu.xml.validation.datatype.Type; + +/** + * Parses an XML Schema DOM tree, constructing a compiled internal + * representation. + * + * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a> + */ +class XMLSchemaBuilder +{ + + XMLSchema schema; + final DatatypeLibrary typeLibrary; + + XMLSchemaBuilder() + { + final String ns = XMLConstants.W3C_XML_SCHEMA_NS_URI; + typeLibrary = new DatatypeLibraryLoader().createDatatypeLibrary(ns); + } + + void parseSchema(Node node) + throws DatatypeException + { + String uri = node.getNamespaceURI(); + String name = node.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + node.getNodeType() == Node.ELEMENT_NODE) + { + if ("schema".equals(name)) + { + NamedNodeMap attrs = node.getAttributes(); + String targetNamespace = getAttribute(attrs, "targetNamespace"); + String version = getAttribute(attrs, "version"); + String fd = getAttribute(attrs, "finalDefault"); + int finalDefault = parseFullDerivationSet(fd); + String bd = getAttribute(attrs, "blockDefault"); + int blockDefault = parseBlockSet(bd); + String afd = getAttribute(attrs, "attributeFormDefault"); + boolean attributeFormQualified = "qualified".equals(afd); + String efd = getAttribute(attrs, "elementFormDefault"); + boolean elementFormQualified = "qualified".equals(efd); + schema = new XMLSchema(targetNamespace, version, + finalDefault, blockDefault, + attributeFormQualified, + elementFormQualified); + for (Node child = node.getFirstChild(); child != null; + child = child.getNextSibling()) + { + parseTopLevelElement(child); + } + return; + } + } + // TODO throw schema exception + } + + void parseTopLevelElement(Node node) + throws DatatypeException + { + String uri = node.getNamespaceURI(); + String name = node.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + node.getNodeType() == Node.ELEMENT_NODE) + { + if ("element".equals(name)) + { + ElementDeclaration ed = + (ElementDeclaration) parseElement(node, null); + schema.elementDeclarations.put(ed.name, ed); + // TODO + } + else if ("attribute".equals(name)) + { + AttributeDeclaration ad = + (AttributeDeclaration) parseAttribute(node, true); + schema.attributeDeclarations.put(ad.name, ad); + // TODO + } + else if ("type".equals(name)) + { + // TODO + } + else if ("group".equals(name)) + { + // TODO + } + else if ("attributeGroup".equals(name)) + { + // TODO + } + else if ("notation".equals(name)) + { + // TODO + } + else if ("identityConstraint".equals(name)) + { + // TODO + } + } + // TODO throw schema exception + } + + Object parseAttribute(Node node, boolean scope) + throws DatatypeException + { + NamedNodeMap attrs = node.getAttributes(); + String def = getAttribute(attrs, "default"); + String fixed = getAttribute(attrs, "fixed"); + int constraintType = AttributeDeclaration.NONE; + String constraintValue = null; + if (def != null) + { + constraintType = AttributeDeclaration.DEFAULT; + constraintValue = def; + } + else if (fixed != null) + { + constraintType = AttributeDeclaration.FIXED; + constraintValue = fixed; + } + // TODO form = (qualified | unqualified) + String attrName = getAttribute(attrs, "name"); + String attrNamespace = getAttribute(attrs, "targetNamespace"); + String ref = getAttribute(attrs, "ref"); + String use = getAttribute(attrs, "use"); + String type = getAttribute(attrs, "type"); + SimpleType datatype = (type == null) ? null : + parseSimpleType(asQName(type, node)); + Annotation annotation = null; + for (Node child = node.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + annotation = parseAnnotation(child); + } + else if ("simpleType".equals(name)) + { + datatype = parseSimpleType(child); + } + else + { + // TODO throw schema exception + } + } + } + if (scope) + { + return new AttributeDeclaration(scope, + constraintType, + constraintValue, + new QName(attrNamespace, attrName), + datatype, + annotation); + } + else + { + boolean required = "required".equals(use); + // TODO ref + AttributeDeclaration decl = (ref == null) ? + new AttributeDeclaration(scope, + AttributeDeclaration.NONE, + null, + new QName(attrNamespace, attrName), + datatype, + annotation) : + /*schema.getAttributeDeclaration(ref)*/ null; + return new AttributeUse(required, + constraintType, + constraintValue, + decl); + } + } + + int parseFullDerivationSet(String value) + { + int ret = XMLSchema.FINAL_NONE; + if ("#all".equals(value)) + { + ret = XMLSchema.FINAL_ALL; + } + else + { + StringTokenizer st = new StringTokenizer(value, " "); + while (st.hasMoreTokens()) + { + String token = st.nextToken(); + if ("extension".equals(token)) + { + ret |= XMLSchema.FINAL_EXTENSION; + } + else if ("restriction".equals(token)) + { + ret |= XMLSchema.FINAL_RESTRICTION; + } + else if ("list".equals(token)) + { + ret |= XMLSchema.FINAL_LIST; + } + else if ("union".equals(token)) + { + ret |= XMLSchema.FINAL_UNION; + } + } + } + return ret; + } + + int parseSimpleTypeDerivationSet(String value) + { + int ret = XMLSchema.FINAL_NONE; + if ("#all".equals(value)) + { + ret = XMLSchema.FINAL_LIST | + XMLSchema.FINAL_UNION | + XMLSchema.FINAL_RESTRICTION; + } + else + { + StringTokenizer st = new StringTokenizer(value, " "); + while (st.hasMoreTokens()) + { + String token = st.nextToken(); + if ("list".equals(token)) + { + ret |= XMLSchema.FINAL_LIST; + } + else if ("union".equals(token)) + { + ret |= XMLSchema.FINAL_UNION; + } + else if ("restriction".equals(token)) + { + ret |= XMLSchema.FINAL_RESTRICTION; + } + } + } + return ret; + } + + int parseComplexTypeDerivationSet(String value) + { + int ret = XMLSchema.FINAL_NONE; + if ("#all".equals(value)) + { + ret = XMLSchema.FINAL_EXTENSION | XMLSchema.FINAL_RESTRICTION; + } + else + { + StringTokenizer st = new StringTokenizer(value, " "); + while (st.hasMoreTokens()) + { + String token = st.nextToken(); + if ("extension".equals(token)) + { + ret |= XMLSchema.FINAL_EXTENSION; + } + else if ("restriction".equals(token)) + { + ret |= XMLSchema.FINAL_RESTRICTION; + } + } + } + return ret; + } + + int parseBlockSet(String value) + { + int ret = XMLSchema.BLOCK_NONE; + if ("#all".equals(value)) + { + ret = XMLSchema.BLOCK_ALL; + } + else + { + StringTokenizer st = new StringTokenizer(value, " "); + while (st.hasMoreTokens()) + { + String token = st.nextToken(); + if ("extension".equals(token)) + { + ret |= XMLSchema.BLOCK_EXTENSION; + } + else if ("restriction".equals(token)) + { + ret |= XMLSchema.BLOCK_RESTRICTION; + } + else if ("substitution".equals(token)) + { + ret |= XMLSchema.BLOCK_SUBSTITUTION; + } + } + } + return ret; + } + + int parseComplexTypeBlockSet(String value) + { + int ret = XMLSchema.BLOCK_NONE; + if ("#all".equals(value)) + { + ret = XMLSchema.BLOCK_EXTENSION | XMLSchema.BLOCK_RESTRICTION; + } + else + { + StringTokenizer st = new StringTokenizer(value, " "); + while (st.hasMoreTokens()) + { + String token = st.nextToken(); + if ("extension".equals(token)) + { + ret |= XMLSchema.BLOCK_EXTENSION; + } + else if ("restriction".equals(token)) + { + ret |= XMLSchema.BLOCK_RESTRICTION; + } + } + } + return ret; + } + + Object parseElement(Node node, ElementDeclaration parent) + throws DatatypeException + { + NamedNodeMap attrs = node.getAttributes(); + Integer minOccurs = null; + Integer maxOccurs = null; + Node parentNode = node.getParentNode(); + boolean notTopLevel = !"schema".equals(parentNode.getLocalName()); + if (notTopLevel) + { + String ref = getAttribute(attrs, "ref"); + if (ref != null) + { + minOccurs = getOccurrence(getAttribute(attrs, "minOccurs")); + maxOccurs = getOccurrence(getAttribute(attrs, "maxOccurs")); + // TODO resolve top-level element declaration + ElementDeclaration ad = null; + return new Particle(minOccurs, maxOccurs, ad); + } + } + String elementName = getAttribute(attrs, "name"); + String elementNamespace = getAttribute(attrs, "targetNamespace"); + String type = getAttribute(attrs, "type"); + Type datatype = (type != null) ? + parseSimpleType(asQName(type, node)) : null; + int scope = (parent == null) ? + XMLSchema.GLOBAL : + XMLSchema.LOCAL; + String def = getAttribute(attrs, "default"); + String fixed = getAttribute(attrs, "fixed"); + int constraintType = AttributeDeclaration.NONE; + String constraintValue = null; + if (def != null) + { + constraintType = AttributeDeclaration.DEFAULT; + constraintValue = def; + } + else if (fixed != null) + { + constraintType = AttributeDeclaration.FIXED; + constraintValue = fixed; + } + String sg = getAttribute(attrs, "substitutionGroup"); + QName substitutionGroup = QName.valueOf(sg); + String sgPrefix = substitutionGroup.getPrefix(); + if (sgPrefix != null && !"".equals(sgPrefix)) + { + String sgName = substitutionGroup.getLocalPart(); + String sgNamespace = node.lookupNamespaceURI(sgPrefix); + substitutionGroup = new QName(sgNamespace, sgName); + } + + String block = getAttribute(attrs, "block"); + int substitutionGroupExclusions = (block == null) ? + schema.blockDefault : + parseBlockSet(block); + String final_ = getAttribute(attrs, "final"); + int disallowedSubstitutions = (final_ == null) ? + schema.finalDefault : + parseFullDerivationSet(final_); + + boolean nillable = "true".equals(getAttribute(attrs, "nillable")); + boolean isAbstract = "true".equals(getAttribute(attrs, "abstract")); + + if (notTopLevel) + { + minOccurs = getOccurrence(getAttribute(attrs, "minOccurs")); + maxOccurs = getOccurrence(getAttribute(attrs, "maxOccurs")); + String form = getAttribute(attrs, "form"); + if (form != null) + { + if ("qualified".equals(form)) + { + elementNamespace = schema.targetNamespace; + } + } + else if (schema.elementFormQualified) + { + elementNamespace = schema.targetNamespace; + } + } + ElementDeclaration ed = + new ElementDeclaration(new QName(elementNamespace, elementName), + datatype, + scope, parent, + constraintType, constraintValue, + nillable, + substitutionGroup, + substitutionGroupExclusions, + disallowedSubstitutions, + isAbstract); + + for (Node child = node.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + ed.annotation = parseAnnotation(child); + } + else if ("simpleType".equals(name) && datatype == null) + { + ed.datatype = parseSimpleType(child); + } + else if ("complexType".equals(name) && datatype == null) + { + ed.datatype = parseComplexType(child, ed); + } + else + { + // throw schema exception + } + } + } + + if (notTopLevel) + { + return new Particle(minOccurs, maxOccurs, ed); + } + else + { + return ed; + } + } + + Integer getOccurrence(String value) + { + if (value == null) + { + return new Integer(1); + } + else if ("unbounded".equals(value)) + { + return null; + } + else + { + return new Integer(value); + } + } + + SimpleType parseSimpleType(QName typeName) + throws DatatypeException + { + SimpleType type = (SimpleType) schema.types.get(typeName); + if (!XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(typeName.getNamespaceURI())) + return null; + String localName = typeName.getLocalPart(); + return (SimpleType) typeLibrary.createDatatype(localName); + } + + SimpleType parseSimpleType(Node simpleType) + throws DatatypeException + { + NamedNodeMap attrs = simpleType.getAttributes(); + String typeFinal = getAttribute(attrs, "final"); + if (typeFinal == null) + { + Node schema = simpleType.getParentNode(); + while (schema != null && !"schema".equals(schema.getLocalName())) + { + schema = schema.getParentNode(); + } + if (schema != null) + { + NamedNodeMap schemaAttrs = schema.getAttributes(); + typeFinal = getAttribute(schemaAttrs, "finalDefault"); + } + } + int typeFinality = parseSimpleTypeDerivationSet(typeFinal); + QName typeName = asQName(getAttribute(attrs, "name"), simpleType); + int variety = 0; + Set facets = new LinkedHashSet(); + int fundamentalFacets = 0; // TODO + SimpleType baseType = null; // TODO + Annotation annotation = null; + // TODO use DatatypeBuilder + for (Node child = simpleType.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + annotation = parseAnnotation(child); + } + else if ("restriction".equals(name)) + { + // TODO + } + else if ("list".equals(name)) + { + variety = SimpleType.LIST; + // TODO + } + else if ("union".equals(name)) + { + variety = SimpleType.UNION; + // TODO + } + } + } + return new SimpleType(typeName, variety, facets, fundamentalFacets, + baseType, annotation); + } + + Type parseComplexType(Node complexType, ElementDeclaration parent) + throws DatatypeException + { + NamedNodeMap attrs = complexType.getAttributes(); + QName typeName = asQName(getAttribute(attrs, "name"), complexType); + boolean isAbstract = "true".equals(getAttribute(attrs, "abstract")); + String block = getAttribute(attrs, "block"); + int prohibitedSubstitutions = (block == null) ? + schema.blockDefault : + parseComplexTypeBlockSet(block); + String final_ = getAttribute(attrs, "final"); + int finality = (final_ == null) ? + schema.finalDefault : + parseComplexTypeDerivationSet(final_); + ComplexType type = new ComplexType(typeName, isAbstract, + prohibitedSubstitutions, finality); + boolean mixed = "true".equals(getAttribute(attrs, "mixed")); + for (Node child = complexType.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("simpleContent".equals(name)) + { + parseSimpleContent(child, type); + } + } + } + if (mixed) + { + type.contentType = XMLSchema.CONTENT_MIXED; + } + return type; + } + + void parseSimpleContent(Node simpleContent, ComplexType type) + throws DatatypeException + { + for (Node child = simpleContent.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + type.annotations.add(parseAnnotation(child)); + } + else if ("restriction".equals(name)) + { + type.derivationMethod = XMLSchema.FINAL_RESTRICTION; + parseRestriction(child, type); + } + else if ("extension".equals(name)) + { + type.derivationMethod = XMLSchema.FINAL_EXTENSION; + parseExtension(child, type); + } + } + } + } + + void parseRestriction(Node restriction, ComplexType type) + throws DatatypeException + { + NamedNodeMap attrs = restriction.getAttributes(); + String base = getAttribute(attrs, "base"); + QName baseType = asQName(base, restriction); + SimpleType simpleType = null; + for (Node child = restriction.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + type.annotations.add(parseAnnotation(child)); + } + else if ("simpleType".equals(name)) + { + type.contentType = XMLSchema.CONTENT_SIMPLE; + simpleType = parseSimpleType(child); + } + else if ("minExclusive".equals(name)) + { + } + else if ("minInclusive".equals(name)) + { + } + else if ("maxExclusive".equals(name)) + { + } + else if ("maxInclusive".equals(name)) + { + } + else if ("totalDigits".equals(name)) + { + } + else if ("fractionDigits".equals(name)) + { + } + else if ("length".equals(name)) + { + } + else if ("minLength".equals(name)) + { + } + else if ("maxLength".equals(name)) + { + } + else if ("enumeration".equals(name)) + { + } + else if ("whiteSpace".equals(name)) + { + } + else if ("pattern".equals(name)) + { + } + else if ("attribute".equals(name)) + { + AttributeUse use = + (AttributeUse) parseAttribute(child, false); + schema.attributeDeclarations.put(use.declaration.name, + use.declaration); + type.attributeUses.add(use); + } + else if ("attributeGroup".equals(name)) + { + NamedNodeMap agAttrs = child.getAttributes(); + String ref = getAttribute(agAttrs, "ref"); + QName ag = asQName(ref, child); + type.attributeUses.add(ag); + } + else if ("anyAttribute".equals(name)) + { + type.attributeWildcard = parseAnyAttribute(child); + } + } + } + } + + void parseExtension(Node extension, ComplexType type) + throws DatatypeException + { + NamedNodeMap attrs = extension.getAttributes(); + String base = getAttribute(attrs, "base"); + QName baseType = asQName(base, extension); + for (Node child = extension.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + type.annotations.add(parseAnnotation(child)); + } + else if ("attribute".equals(name)) + { + AttributeUse use = + (AttributeUse) parseAttribute(child, false); + schema.attributeDeclarations.put(use.declaration.name, + use.declaration); + type.attributeUses.add(use); + } + else if ("attributeGroup".equals(name)) + { + NamedNodeMap agAttrs = child.getAttributes(); + String ref = getAttribute(agAttrs, "ref"); + QName ag = asQName(ref, child); + type.attributeUses.add(ag); + } + else if ("anyAttribute".equals(name)) + { + type.attributeWildcard = parseAnyAttribute(child); + } + } + } + } + + AnyAttribute parseAnyAttribute(Node node) + { + NamedNodeMap attrs = node.getAttributes(); + String namespace = getAttribute(attrs, "namespace"); + String pc = getAttribute(attrs, "processContents"); + int processContents = AnyAttribute.STRICT; + if ("lax".equals(pc)) + { + processContents = AnyAttribute.LAX; + } + else if ("skip".equals(pc)) + { + processContents = AnyAttribute.SKIP; + } + AnyAttribute ret = new AnyAttribute(namespace, processContents); + for (Node child = node.getFirstChild(); child != null; + child = child.getNextSibling()) + { + String uri = child.getNamespaceURI(); + String name = child.getLocalName(); + if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(uri) && + child.getNodeType() == Node.ELEMENT_NODE) + { + if ("annotation".equals(name)) + { + ret.annotation = parseAnnotation(child); + } + } + } + return ret; + } + + Annotation parseAnnotation(Node node) + { + // TODO + return null; + } + + private static String getAttribute(NamedNodeMap attrs, String name) + { + Node attr = attrs.getNamedItem(name); + return (attr == null) ? null : attr.getNodeValue(); + } + + private static QName asQName(String text, Node resolver) + { + QName name = QName.valueOf(text); + String prefix = name.getPrefix(); + if (prefix != null && prefix.length() > 0) + { + String uri = resolver.lookupNamespaceURI(prefix); + name = new QName(uri, name.getLocalPart()); + } + return name; + } + +} |