This patch provides a very rough and ready XInclude filter to provide
XInclude-aware XML processing in the StAX implementation. Extensions to
the XPath implementation will be required in order to be conformant.
2005-12-13 Chris Burdess <[EMAIL PROTECTED]>
* gnu/xml/stream/SAXParser.java,
gnu/xml/stream/XIncludeFilter.java,
gnu/xml/stream/XMLInputFactoryImpl.java,
gnu/xml/stream/XMLParser.java: Addition of XInclude filter.
--
Chris Burdess
Index: gnu/xml/stream/SAXParser.java
===================================================================
RCS file: /cvsroot/classpath/classpath/gnu/xml/stream/SAXParser.java,v
retrieving revision 1.1
diff -u -r1.1 SAXParser.java
--- gnu/xml/stream/SAXParser.java 12 Dec 2005 19:53:05 -0000 1.1
+++ gnu/xml/stream/SAXParser.java 13 Dec 2005 17:12:56 -0000
@@ -92,6 +92,7 @@
boolean stringInterning = true;
XMLParser parser;
+ XMLStreamReader reader;
String encoding;
String xmlVersion;
boolean xmlStandalone;
@@ -256,9 +257,9 @@
parser = new XMLParser(in, systemId);
else
{
- Reader reader = input.getCharacterStream();
- if (reader != null)
- parser = new XMLParser(reader, systemId);
+ Reader r = input.getCharacterStream();
+ if (r != null)
+ parser = new XMLParser(r, systemId);
}
if (parser == null)
{
@@ -268,13 +269,17 @@
in = new URL(systemId).openStream();
parser = new XMLParser(in, systemId);
}
+ reader = parser;
parser.setValidating(validating);
parser.setNamespaceAware(namespaceAware);
- parser.setXIncludeAware(xIncludeAware);
parser.setStringInterning(stringInterning);
parser.setResolver(this);
parser.setReporter(this);
+
+ if (xIncludeAware)
+ reader = new XIncludeFilter(parser, systemId, namespaceAware,
+ validating, true);
if (contentHandler != null)
contentHandler.setDocumentLocator(this);
@@ -287,14 +292,14 @@
case XMLStreamConstants.CHARACTERS:
if (contentHandler != null)
{
- char[] b = parser.getTextCharacters();
+ char[] b = reader.getTextCharacters();
contentHandler.characters(b, 0, b.length);
}
break;
case XMLStreamConstants.SPACE:
if (contentHandler != null)
{
- char[] b = parser.getTextCharacters();
+ char[] b = reader.getTextCharacters();
// TODO determine whether whitespace is ignorable
contentHandler.characters(b, 0, b.length);
}
@@ -304,7 +309,7 @@
lexicalHandler.startCDATA();
if (contentHandler != null)
{
- char[] b = parser.getTextCharacters();
+ char[] b = reader.getTextCharacters();
// TODO determine whether whitespace and ignorable
contentHandler.characters(b, 0, b.length);
}
@@ -314,7 +319,7 @@
case XMLStreamConstants.START_ELEMENT:
if (contentHandler != null)
{
- QName name = parser.getName();
+ QName name = reader.getName();
String uri = name.getNamespaceURI();
String localName = name.getLocalPart();
String prefix = name.getPrefix();
@@ -332,7 +337,7 @@
case XMLStreamConstants.END_ELEMENT:
if (contentHandler != null)
{
- QName name = parser.getName();
+ QName name = reader.getName();
String uri = name.getNamespaceURI();
String localName = name.getLocalPart();
String prefix = name.getPrefix();
@@ -350,22 +355,22 @@
case XMLStreamConstants.COMMENT:
if (lexicalHandler != null)
{
- char[] b = parser.getTextCharacters();
+ char[] b = reader.getTextCharacters();
lexicalHandler.comment(b, 0, b.length);
}
break;
case XMLStreamConstants.PROCESSING_INSTRUCTION:
if (contentHandler != null)
{
- String target = parser.getPITarget();
- String data = parser.getPIData();
+ String target = reader.getPITarget();
+ String data = reader.getPIData();
contentHandler.processingInstruction(target, data);
}
break;
case XMLStreamConstants.START_DOCUMENT:
- encoding = parser.getEncoding();
- xmlVersion = parser.getVersion();
- xmlStandalone = parser.isStandalone();
+ encoding = reader.getEncoding();
+ xmlVersion = reader.getVersion();
+ xmlStandalone = reader.isStandalone();
if (contentHandler != null)
contentHandler.startDocument();
break;
@@ -449,10 +454,10 @@
public int getIndex(String qName)
{
- int len = parser.getAttributeCount();
+ int len = reader.getAttributeCount();
for (int i = 0; i < len; i++)
{
- QName q = parser.getAttributeQName(i);
+ QName q = reader.getAttributeQName(i);
String localName = q.getLocalPart();
String prefix = q.getPrefix();
String qn = ("".equals(prefix)) ? localName : prefix + ":" + localName;
@@ -464,10 +469,10 @@
public int getIndex(String uri, String localName)
{
- int len = parser.getAttributeCount();
+ int len = reader.getAttributeCount();
for (int i = 0; i < len; i++)
{
- QName q = parser.getAttributeQName(i);
+ QName q = reader.getAttributeQName(i);
String ln = q.getLocalPart();
String u = q.getNamespaceURI();
if (u == null && uri != null)
@@ -482,17 +487,17 @@
public int getLength()
{
- return parser.getAttributeCount();
+ return reader.getAttributeCount();
}
public String getLocalName(int index)
{
- return parser.getAttributeName(index);
+ return reader.getAttributeName(index);
}
public String getQName(int index)
{
- QName q = parser.getAttributeQName(index);
+ QName q = reader.getAttributeQName(index);
String localName = q.getLocalPart();
String prefix = q.getPrefix();
return ("".equals(prefix)) ? localName : prefix + ":" + localName;
@@ -500,7 +505,7 @@
public String getType(int index)
{
- return parser.getAttributeType(index);
+ return reader.getAttributeType(index);
}
public String getType(String qName)
@@ -517,12 +522,12 @@
public String getURI(int index)
{
- return parser.getAttributeNamespace(index);
+ return reader.getAttributeNamespace(index);
}
public String getValue(int index)
{
- return parser.getAttributeValue(index);
+ return reader.getAttributeValue(index);
}
public String getValue(String qName)
@@ -556,7 +561,7 @@
public boolean isSpecified(int index)
{
- return parser.isAttributeSpecified(index);
+ return reader.isAttributeSpecified(index);
}
public boolean isSpecified(String qName)
@@ -575,12 +580,14 @@
public int getColumnNumber()
{
- return parser.getColumnNumber();
+ Location l = reader.getLocation();
+ return l.getColumnNumber();
}
public int getLineNumber()
{
- return parser.getLineNumber();
+ Location l = reader.getLocation();
+ return l.getLineNumber();
}
public String getPublicId()
@@ -590,7 +597,8 @@
public String getSystemId()
{
- return parser.getLocationURI();
+ Location l = reader.getLocation();
+ return l.getLocationURI();
}
public String getEncoding()
Index: gnu/xml/stream/XIncludeFilter.java
===================================================================
RCS file: gnu/xml/stream/XIncludeFilter.java
diff -N gnu/xml/stream/XIncludeFilter.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ gnu/xml/stream/XIncludeFilter.java 13 Dec 2005 17:12:56 -0000
@@ -0,0 +1,897 @@
+/* XIncludeFilter.java --
+ Copyright (C) 2005 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.stream;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.HashSet;
+import java.util.StringTokenizer;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.util.ReaderDelegate;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.DOMImplementation;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.ProcessingInstruction;
+import org.w3c.dom.TypeInfo;
+import org.w3c.dom.traversal.DocumentTraversal;
+import org.w3c.dom.traversal.NodeFilter;
+import org.w3c.dom.traversal.TreeWalker;
+import org.w3c.dom.xpath.XPathEvaluator;
+import org.w3c.dom.xpath.XPathNSResolver;
+import org.w3c.dom.xpath.XPathResult;
+import org.xml.sax.SAXException;
+
+/**
+ * StAX filter for performing XInclude processing.
+ *
+ * @author <a href='mailto:[EMAIL PROTECTED]'>Chris Burdess</a>
+ */
+class XIncludeFilter
+ extends ReaderDelegate
+{
+
+ static final String XINCLUDE_NS_URI = "http://www.w3.org/2001/XInclude";;
+ static final int SHOW_FLAGS =
+ NodeFilter.SHOW_CDATA_SECTION |
+ NodeFilter.SHOW_COMMENT |
+ NodeFilter.SHOW_ELEMENT |
+ NodeFilter.SHOW_ENTITY_REFERENCE |
+ NodeFilter.SHOW_PROCESSING_INSTRUCTION |
+ NodeFilter.SHOW_TEXT;
+
+ final String systemId;
+ final boolean namespaceAware;
+ final boolean validating;
+ final boolean expandERefs;
+ String href;
+ int event;
+ boolean included;
+ XPathResult result;
+ int snapshotIndex;
+ Node current;
+ TreeWalker walker;
+ HashSet seen = new HashSet();
+
+ Reader includedText;
+ char[] buf;
+ int len = -1;
+ boolean inInclude, inFallback, seenFallback;
+
+ DocumentBuilder builder;
+
+ XIncludeFilter(XMLStreamReader reader, String systemId,
+ boolean namespaceAware, boolean validating,
+ boolean expandERefs)
+ {
+ super(reader);
+ this.systemId = XMLParser.absolutize(null, systemId);
+ this.namespaceAware = namespaceAware;
+ this.validating = validating;
+ this.expandERefs = expandERefs;
+ }
+
+ public int getAttributeCount()
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ return (attrs == null) ? 0 : attrs.getLength();
+ }
+ return super.getAttributeCount();
+ }
+
+ public String getAttributeName(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Node attr = attrs.item(index);
+ return attr.getLocalName();
+ }
+ return super.getAttributeName(index);
+ }
+
+ public String getAttributeNamespace(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Node attr = attrs.item(index);
+ return attr.getNamespaceURI();
+ }
+ return super.getAttributeNamespace(index);
+ }
+
+ public String getAttributePrefix(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Node attr = attrs.item(index);
+ return attr.getPrefix();
+ }
+ return super.getAttributePrefix(index);
+ }
+
+ public QName getAttributeQName(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Node attr = attrs.item(index);
+ String localName = attr.getLocalName();
+ String uri = attr.getNamespaceURI();
+ String prefix = attr.getPrefix();
+ return new QName(uri, localName, prefix);
+ }
+ return super.getAttributeQName(index);
+ }
+
+ public String getAttributeType(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Attr attr = (Attr) attrs.item(index);
+ TypeInfo ti = attr.getSchemaTypeInfo();
+ return (ti == null) ? "CDATA" : ti.getTypeName();
+ }
+ return super.getAttributeType(index);
+ }
+
+ public boolean isAttributeSpecified(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return false;
+ Attr attr = (Attr) attrs.item(index);
+ return attr.getSpecified();
+ }
+ return super.isAttributeSpecified(index);
+ }
+
+ public String getAttributeValue(int index)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Node attr = attrs.item(index);
+ return attr.getNodeValue();
+ }
+ return super.getAttributeValue(index);
+ }
+
+ public String getAttributeValue(String uri, String localName)
+ {
+ if (current != null)
+ {
+ NamedNodeMap attrs = current.getAttributes();
+ if (attrs == null)
+ return null;
+ Node attr = attrs.getNamedItemNS(uri, localName);
+ return (attr == null) ? null : attr.getNodeValue();
+ }
+ return super.getAttributeValue(uri, localName);
+ }
+
+ public String getElementText()
+ throws XMLStreamException
+ {
+ if (current != null)
+ return current.getTextContent();
+ return super.getElementText();
+ }
+
+ public int getEventType()
+ {
+ return event;
+ }
+
+ public String getLocalName()
+ {
+ if (current != null)
+ return current.getLocalName();
+ return super.getLocalName();
+ }
+
+ public QName getName()
+ {
+ if (current != null)
+ {
+ String localName = current.getLocalName();
+ String uri = current.getNamespaceURI();
+ String prefix = current.getPrefix();
+ return new QName(uri, localName, prefix);
+ }
+ return super.getName();
+ }
+
+ // TODO namespaces
+
+ public String getPIData()
+ {
+ if (current != null)
+ return ((ProcessingInstruction) current).getData();
+ return super.getPIData();
+ }
+
+ public String getPITarget()
+ {
+ if (current != null)
+ return ((ProcessingInstruction) current).getTarget();
+ return super.getPITarget();
+ }
+
+ public String getPrefix()
+ {
+ if (current != null)
+ return current.getPrefix();
+ return super.getPrefix();
+ }
+
+ public String getText()
+ {
+ if (current != null)
+ return current.getNodeValue();
+ if (walker != null)
+ {
+ Node n = walker.getCurrentNode();
+ if (n != null)
+ return n.getTextContent();
+ }
+ if (buf != null)
+ return new String(buf, 0, len);
+ return super.getText();
+ }
+
+ public char[] getTextCharacters()
+ {
+ if (current != null)
+ {
+ buf = current.getNodeValue().toCharArray();
+ len = buf.length;
+ }
+ if (buf != null)
+ return buf;
+ return super.getTextCharacters();
+ }
+
+ public int getTextCharacters(int sourceStart, char[] target,
+ int targetStart, int length)
+ throws XMLStreamException
+ {
+ if (current != null)
+ {
+ buf = current.getNodeValue().toCharArray();
+ len = buf.length;
+ }
+ if (buf != null)
+ {
+ int max = Math.min(len - sourceStart, length);
+ if (max > 0)
+ System.arraycopy(buf, sourceStart, target, targetStart, max);
+ return max;
+ }
+ return super.getTextCharacters(sourceStart, target, targetStart, length);
+ }
+
+ public int getTextLength()
+ {
+ if (current != null)
+ {
+ buf = current.getNodeValue().toCharArray();
+ len = buf.length;
+ }
+ if (buf != null)
+ return len;
+ return super.getTextLength();
+ }
+
+ public int getTextStart()
+ {
+ if (current != null)
+ {
+ buf = current.getNodeValue().toCharArray();
+ len = buf.length;
+ }
+ if (buf != null)
+ return 0;
+ return super.getTextStart();
+ }
+
+ public boolean hasNext()
+ throws XMLStreamException
+ {
+ if (current != null)
+ return true;
+ if (walker != null)
+ {
+ Node n = walker.getCurrentNode();
+ if (n.getNodeType() == Node.ELEMENT_NODE)
+ return true;
+ Node next = walker.nextNode();
+ walker.setCurrentNode(n);
+ if (next != null)
+ return true;
+ }
+ if (result != null)
+ {
+ switch (result.getResultType())
+ {
+ case XPathResult.BOOLEAN_TYPE:
+ case XPathResult.NUMBER_TYPE:
+ case XPathResult.STRING_TYPE:
+ return true;
+ case XPathResult.ANY_UNORDERED_NODE_TYPE:
+ case XPathResult.FIRST_ORDERED_NODE_TYPE:
+ return result.getSingleNodeValue() != null;
+ case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
+ case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
+ return !result.getInvalidIteratorState();
+ case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
+ case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
+ return snapshotIndex < result.getSnapshotLength();
+ }
+ }
+ if (includedText != null)
+ return true;
+ return super.hasNext();
+ }
+
+ public int next()
+ throws XMLStreamException
+ {
+ if (walker != null)
+ {
+ Node c = walker.getCurrentNode();
+ boolean isStartElement = seen.contains(c);
+ seen.add(c);
+ if (isStartElement)
+ return (event = XMLStreamConstants.START_ELEMENT);
+ Node n = walker.firstChild();
+ if (n == null)
+ n = walker.nextSibling();
+ if (n == null)
+ {
+ if (c.getNodeType() == Node.ELEMENT_NODE)
+ {
+ // end-element
+ seen.remove(c);
+ do
+ {
+ n = walker.parentNode();
+ if (n == null)
+ {
+ walker = null;
+ break;
+ }
+ n = walker.nextSibling();
+ }
+ while (n == null);
+ current = c;
+ return (event = XMLStreamConstants.END_ELEMENT);
+ }
+ else
+ current = null;
+ }
+ else
+ {
+ current = n;
+ switch (n.getNodeType())
+ {
+ case Node.ELEMENT_NODE:
+ return next();
+ case Node.TEXT_NODE:
+ String text = n.getNodeValue();
+ buf = text.toCharArray();
+ len = buf.length;
+ return (event = isSpace(buf, len) ?
+ XMLStreamConstants.SPACE :
+ XMLStreamConstants.CHARACTERS);
+ case Node.CDATA_SECTION_NODE:
+ return (event = XMLStreamConstants.CDATA);
+ case Node.COMMENT_NODE:
+ return (event = XMLStreamConstants.COMMENT);
+ case Node.PROCESSING_INSTRUCTION_NODE:
+ return (event = XMLStreamConstants.PROCESSING_INSTRUCTION);
+ case Node.ENTITY_REFERENCE_NODE:
+ return (event = XMLStreamConstants.ENTITY_REFERENCE);
+ }
+ }
+ }
+ if (result != null)
+ {
+ switch (result.getResultType())
+ {
+ case XPathResult.BOOLEAN_TYPE:
+ boolean bval = result.getBooleanValue();
+ String btext = bval ? "true" : "false";
+ buf = btext.toCharArray();
+ len = buf.length;
+ result = null;
+ return (event = XMLStreamConstants.CHARACTERS);
+ case XPathResult.NUMBER_TYPE:
+ double nval = result.getNumberValue();
+ String ntext = new Double(nval).toString();
+ buf = ntext.toCharArray();
+ len = buf.length;
+ result = null;
+ return (event = XMLStreamConstants.CHARACTERS);
+ case XPathResult.STRING_TYPE:
+ String stext = result.getStringValue();
+ buf = stext.toCharArray();
+ len = buf.length;
+ result = null;
+ return (event = isSpace(buf, len) ?
+ XMLStreamConstants.SPACE :
+ XMLStreamConstants.CHARACTERS);
+ case XPathResult.ANY_UNORDERED_NODE_TYPE:
+ case XPathResult.FIRST_ORDERED_NODE_TYPE:
+ Node n1 = result.getSingleNodeValue();
+ Document d1 = getDocument(n1);
+ walker = getDocumentTraversal(d1)
+ .createTreeWalker(n1, SHOW_FLAGS, null, expandERefs);
+ result = null;
+ return next();
+ case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
+ case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
+ Node n2 = result.iterateNext();
+ if (n2 == null)
+ {
+ result = null;
+ return next();
+ }
+ Document d2 = getDocument(n2);
+ walker = getDocumentTraversal(d2)
+ .createTreeWalker(n2, SHOW_FLAGS, null, expandERefs);
+ return next();
+ case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
+ case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
+ Node n3 = result.snapshotItem(snapshotIndex++);
+ if (n3 == null)
+ {
+ result = null;
+ return next();
+ }
+ Document d3 = getDocument(n3);
+ walker = getDocumentTraversal(d3)
+ .createTreeWalker(n3, SHOW_FLAGS, null, expandERefs);
+ return next();
+ }
+ }
+ if (includedText != null)
+ {
+ // fill buffer
+ if (buf == null)
+ buf = new char[2048];
+ try
+ {
+ len = includedText.read(buf, 0, buf.length);
+ if (len == -1)
+ {
+ includedText = null;
+ buf = null;
+ return next();
+ }
+ // chars or space?
+ return (event = isSpace(buf, len) ?
+ XMLStreamConstants.SPACE :
+ XMLStreamConstants.CHARACTERS);
+ }
+ catch (IOException e)
+ {
+ XMLStreamException e2 = new XMLStreamException(e.getMessage());
+ e2.initCause(e);
+ throw e2;
+ }
+ }
+ event = super.next();
+ switch (event)
+ {
+ case XMLStreamConstants.START_ELEMENT:
+ String uri = getNamespaceURI();
+ if (XINCLUDE_NS_URI.equals(uri))
+ {
+ String localName = getLocalName();
+ if ("include".equals(localName))
+ {
+ href = getAttributeValue(null, "href");
+ String parse = getAttributeValue(null, "parse");
+ String xpointer = getAttributeValue(null, "xpointer");
+ String encoding = getAttributeValue(null, "encoding");
+ String accept = getAttributeValue(null, "accept");
+ String acceptLanguage = getAttributeValue(null,
"accept-language");
+ if (includeResource(href, parse, xpointer, encoding,
+ accept, acceptLanguage))
+ {
+ // Skip to xi:include end-element event
+ int depth = 0;
+ while (depth >= 0)
+ {
+ event = super.next();
+ switch (event)
+ {
+ case XMLStreamConstants.START_ELEMENT:
+ depth++;
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ depth--;
+ }
+ }
+ // Return next event
+ return next();
+ }
+ else
+ {
+ inInclude = true;
+ }
+ }
+ else if (inInclude && "fallback".equals(localName))
+ {
+ if (!seenFallback)
+ inFallback = seenFallback = true;
+ else
+ throw new XMLStreamException("duplicate xi:fallback
element");
+ }
+ else if (inInclude)
+ {
+ throw new XMLStreamException("illegal xi element '" +
+ localName + "'");
+ }
+ }
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ String uri2 = getNamespaceURI();
+ if (XINCLUDE_NS_URI.equals(uri2))
+ {
+ String localName = getLocalName();
+ if ("include".equals(localName))
+ {
+ if (!seenFallback && included)
+ {
+ String msg = "Unable to read " + href +
+ " and no xi:fallback element present";
+ throw new XMLStreamException(msg);
+ }
+ included = false;
+ href = null;
+ inInclude = inFallback = seenFallback = false;
+ }
+ else if ("fallback".equals(localName))
+ inFallback = false;
+ }
+ break;
+ }
+ if (inInclude && !inFallback)
+ return next();
+ return event;
+ }
+
+ boolean isSpace(char[] text, int len)
+ {
+ boolean space = true;
+ for (int i = 0; i < len; i++)
+ {
+ char c = text[i];
+ if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
+ {
+ space = false;
+ break;
+ }
+ }
+ return space;
+ }
+
+ boolean includeResource(String href, String parse, String xpointer,
+ String encoding, String accept,
+ String acceptLanguage)
+ {
+ included = false;
+ try
+ {
+ if (xpointer != null)
+ throw new XMLStreamException("xpointer attribute not yet supported");
+ if (href == null || "".equals(href))
+ href = systemId;
+ else
+ href = XMLParser.absolutize(systemId, href);
+ if (parse == null || "xml".equals(parse))
+ {
+ seen.clear();
+ result = null;
+ snapshotIndex = 0;
+ walker = null;
+ current = null;
+
+ URLConnection connection = getURLConnection(href, accept,
+ acceptLanguage);
+ InputStream in = connection.getInputStream();
+ Document doc = getDocumentBuilder().parse(in, href);
+ DocumentTraversal dt = getDocumentTraversal(doc);
+ if (xpointer == null)
+ {
+ result = null;
+ Node item = doc.getDocumentElement();
+ walker = dt.createTreeWalker(item, SHOW_FLAGS, null,
+ expandERefs);
+ }
+ else
+ {
+ result = null;
+ snapshotIndex = 0;
+ walker = null;
+ // shorthand or scheme-based?
+ int lpi = xpointer.indexOf('(');
+ int rpi = xpointer.indexOf(')', lpi);
+ if (lpi != -1 && rpi != -1)
+ {
+ String scheme = xpointer.substring(0, lpi);
+ if ("element".equals(scheme))
+ {
+ // element() scheme
+ String elementSchemeData =
+ xpointer.substring(lpi + 1, rpi);
+ Node item = doc;
+ int si = elementSchemeData.indexOf('/');
+ if (si == -1)
+ {
+ if (elementSchemeData.length() > 0)
+ item = doc.getElementById(elementSchemeData);
+ }
+ else
+ {
+ if (si > 0)
+ {
+ String context =
+ elementSchemeData.substring(0, si);
+ item = doc.getElementById(context);
+ elementSchemeData =
+ elementSchemeData.substring(si + 1);
+ }
+ StringTokenizer st =
+ new StringTokenizer(elementSchemeData, "/");
+ while (st.hasMoreTokens() && item != null)
+ {
+ int n = Integer.parseInt(st.nextToken());
+ Node ctx = item.getFirstChild();
+ int count = 1;
+ while (ctx != null && count++ < n)
+ ctx = ctx.getNextSibling();
+ item = ctx;
+ }
+ }
+ walker = dt.createTreeWalker(item, SHOW_FLAGS, null,
+ expandERefs);
+ included = true;
+ }
+ else if ("xpointer".equals(scheme))
+ {
+ xpointer = xpointer.substring(lpi + 1, rpi);
+ XPathEvaluator eval = getXPathEvaluator(doc);
+ XPathNSResolver resolver = eval.createNSResolver(doc);
+ result =
+ (XPathResult) eval.evaluate(xpointer, doc,
+ resolver,
+ XPathResult.ANY_TYPE,
+ null);
+ // TODO xpointer() scheme functions
+ included = true;
+ }
+ else
+ {
+ String msg = "Unknown XPointer scheme: " + scheme;
+ throw new XMLStreamException(msg);
+ }
+ }
+ else
+ {
+ Node item = doc.getElementById(xpointer);
+ walker = dt.createTreeWalker(item, SHOW_FLAGS, null,
+ expandERefs);
+ included = true;
+ }
+ }
+ }
+ else if ("text".equals(parse))
+ {
+ URLConnection connection = getURLConnection(href, accept,
+ acceptLanguage);
+ InputStream in = connection.getInputStream();
+ if (encoding == null)
+ {
+ encoding = connection.getContentEncoding();
+ if (encoding == null)
+ {
+ String contentType = connection.getContentType();
+ if (contentType != null)
+ encoding = getParameter(contentType, "charset");
+ }
+ }
+ if (encoding == null)
+ includedText = new InputStreamReader(in, "UTF-8");
+ else
+ includedText = new InputStreamReader(in, encoding);
+ included = true;
+ }
+ else
+ throw new XMLStreamException("value of 'parse' attribute must be "+
+ "'xml' or 'text'");
+ return true;
+ }
+ catch (IOException e)
+ {
+ return false;
+ }
+ catch (XMLStreamException e)
+ {
+ return false;
+ }
+ catch (SAXException e)
+ {
+ return false;
+ }
+ }
+
+ URLConnection getURLConnection(String href, String accept,
+ String acceptLanguage)
+ throws IOException
+ {
+ URL url = new URL(href);
+ URLConnection connection = url.openConnection();
+ if (connection instanceof HttpURLConnection)
+ {
+ HttpURLConnection http = (HttpURLConnection) connection;
+ http.setInstanceFollowRedirects(true);
+ if (accept != null)
+ http.setRequestProperty("Accept", accept);
+ if (acceptLanguage != null)
+ http.setRequestProperty("Accept-Language", acceptLanguage);
+ }
+ return connection;
+ }
+
+ Document getDocument(Node node)
+ {
+ if (node.getNodeType() == Node.DOCUMENT_NODE)
+ return (Document) node;
+ return node.getOwnerDocument();
+ }
+
+ DocumentBuilder getDocumentBuilder()
+ throws XMLStreamException
+ {
+ if (builder == null)
+ {
+ try
+ {
+ DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
+ f.setXIncludeAware(true);
+ f.setNamespaceAware(namespaceAware);
+ f.setValidating(validating);
+ builder = f.newDocumentBuilder();
+ }
+ catch (ParserConfigurationException e)
+ {
+ XMLStreamException e2 = new XMLStreamException(e.getMessage());
+ e2.initCause(e);
+ throw e2;
+ }
+ }
+ builder.reset();
+ return builder;
+ }
+
+ DocumentTraversal getDocumentTraversal(Document doc)
+ throws XMLStreamException
+ {
+ DOMImplementation dom = doc.getImplementation();
+ if (!dom.hasFeature("Traversal", "2.0"))
+ throw new XMLStreamException("Traversal not supported");
+ return (DocumentTraversal) doc;
+ }
+
+ XPathEvaluator getXPathEvaluator(Document doc)
+ throws XMLStreamException
+ {
+ DOMImplementation dom = doc.getImplementation();
+ if (!dom.hasFeature("XPath", "3.0"))
+ throw new XMLStreamException("XPath not supported");
+ return (XPathEvaluator) doc;
+ }
+
+ static String getParameter(String contentType, String name)
+ {
+ StringTokenizer st = new StringTokenizer(contentType, " ;");
+ if (st.hasMoreTokens())
+ st.nextToken();
+ while (st.hasMoreTokens())
+ {
+ String token = st.nextToken();
+ int ei = token.indexOf('=');
+ if (ei != -1)
+ {
+ String key = token.substring(0, ei);
+ if (key.equals(name))
+ {
+ String value = token.substring(ei + 1);
+ int len = value.length();
+ if (len > 1 &&
+ value.charAt(0) == '"' &&
+ value.charAt(len - 1) == '"')
+ value = value.substring(1, len - 1);
+ else if (len > 1 &&
+ value.charAt(0) == '\'' &&
+ value.charAt(len - 1) == '\'')
+ value = value.substring(1, len - 1);
+ return value;
+ }
+ }
+ }
+ return null;
+ }
+
+}
Index: gnu/xml/stream/XMLInputFactoryImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/gnu/xml/stream/XMLInputFactoryImpl.java,v
retrieving revision 1.3
diff -u -r1.3 XMLInputFactoryImpl.java
--- gnu/xml/stream/XMLInputFactoryImpl.java 12 Dec 2005 11:35:38 -0000
1.3
+++ gnu/xml/stream/XMLInputFactoryImpl.java 13 Dec 2005 17:12:56 -0000
@@ -77,6 +77,7 @@
protected boolean replacingEntityReferences = true;
protected boolean externalEntities = true;
protected boolean supportDTD = true;
+ protected boolean xIncludeAware = false;
public XMLInputFactoryImpl()
{
@@ -107,6 +108,9 @@
*/
XMLParser ret = new XMLParser(reader, null);
configureXMLParser(ret);
+ if (xIncludeAware)
+ return new XIncludeFilter(ret, null, namespaceAware, validating,
+ replacingEntityReferences);
return ret;
}
@@ -122,6 +126,9 @@
externalEntities, supportDTD);*/
XMLParser ret = new XMLParser(in, systemId);
configureXMLParser(ret);
+ if (xIncludeAware)
+ return new XIncludeFilter(ret, systemId, namespaceAware, validating,
+ replacingEntityReferences);
return ret;
}
@@ -135,6 +142,9 @@
externalEntities, supportDTD);*/
XMLParser ret = new XMLParser(in, null);
configureXMLParser(ret);
+ if (xIncludeAware)
+ return new XIncludeFilter(ret, null, namespaceAware, validating,
+ replacingEntityReferences);
return ret;
}
Index: gnu/xml/stream/XMLParser.java
===================================================================
RCS file: /cvsroot/classpath/classpath/gnu/xml/stream/XMLParser.java,v
retrieving revision 1.2
diff -u -r1.2 XMLParser.java
--- gnu/xml/stream/XMLParser.java 12 Dec 2005 19:53:05 -0000 1.2
+++ gnu/xml/stream/XMLParser.java 13 Dec 2005 17:12:56 -0000
@@ -140,7 +140,6 @@
private boolean externalEntities = false;
private boolean supportDTD = true;
private boolean namespaceAware = true;
- private boolean xIncludeAware = true;
private XMLReporter reporter;
private XMLResolver resolver;
@@ -207,11 +206,6 @@
supportDTD = flag;
}
- public void setXIncludeAware(boolean flag)
- {
- xIncludeAware = flag;
- }
-
public void setReporter(XMLReporter reporter)
{
this.reporter = reporter;
@@ -582,7 +576,6 @@
if (XMLInputFactory.SUPPORT_DTD.equals(name))
return supportDTD ? Boolean.TRUE : Boolean.FALSE;
// TODO stringInterning
- // TODO xIncludeAware
return null;
}
_______________________________________________
Classpath-patches mailing list
[email protected]
http://lists.gnu.org/mailman/listinfo/classpath-patches
