nokogiri 1.5.6.rc3-java → 1.5.7-java

data/ext/java/nokogiri/XmlReader.java

@@ -17,10 +17,10 @@
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -35,39 +35,51 @@ package nokogiri;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.stringOrBlank;
 
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
-import java.util.ArrayDeque;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Stack;
 
 import nokogiri.internals.NokogiriEntityResolver;
 import nokogiri.internals.ParserContext;
 import nokogiri.internals.ParserContext.Options;
 import nokogiri.internals.ReaderNode;
+import nokogiri.internals.ReaderNode.ClosingNode;
 import nokogiri.internals.ReaderNode.ElementNode;
-
+import nokogiri.internals.ReaderNode.TextNode;
+import nokogiri.internals.UncloseableInputStream;
+
+import org.apache.xerces.impl.Constants;
+import org.apache.xerces.impl.xs.opti.DefaultXMLDocumentHandler;
+import org.apache.xerces.parsers.StandardParserConfiguration;
+import org.apache.xerces.util.EntityResolver2Wrapper;
+import org.apache.xerces.xni.Augmentations;
+import org.apache.xerces.xni.NamespaceContext;
+import org.apache.xerces.xni.QName;
+import org.apache.xerces.xni.XMLAttributes;
+import org.apache.xerces.xni.XMLLocator;
+import org.apache.xerces.xni.XMLResourceIdentifier;
+import org.apache.xerces.xni.XMLString;
+import org.apache.xerces.xni.XNIException;
+import org.apache.xerces.xni.parser.XMLErrorHandler;
+import org.apache.xerces.xni.parser.XMLInputSource;
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.apache.xerces.xni.parser.XMLPullParserConfiguration;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyBoolean;
 import org.jruby.RubyClass;
 import org.jruby.RubyFixnum;
 import org.jruby.RubyObject;
-import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
-import org.jruby.javasupport.util.RuntimeHelpers;
-import org.jruby.lexer.yacc.SyntaxException;
+import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.util.ByteList;
-import org.xml.sax.Attributes;
+import org.jruby.util.IOInputStream;
 import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
-import org.xml.sax.SAXParseException;
-import org.xml.sax.XMLReader;
-import org.xml.sax.ext.DefaultHandler2;
-import org.xml.sax.helpers.XMLReaderFactory;
 
 /**
  * Class for Nokogiri:XML::Reader
@@ -85,13 +97,16 @@ public class XmlReader extends RubyObject {
     private static final int XML_TEXTREADER_MODE_CLOSED = 4;
     private static final int XML_TEXTREADER_MODE_READING = 5;
 
-    ArrayDeque<ReaderNode> nodeQueue;
+    List<ReaderNode> nodeQueue;
     private int state;
-    
+    private int position = 0;
+    private XMLPullParserConfiguration config;
+    private boolean continueParsing = true;
+
     public XmlReader(Ruby runtime, RubyClass klazz) {
         super(runtime, klazz);
     }
-    
+
     /**
      * Create and return a copy of this object.
      *
@@ -103,81 +118,77 @@ public class XmlReader extends RubyObject {
     }
 
     public void init(Ruby runtime) {
-        nodeQueue = new ArrayDeque<ReaderNode>();
+        nodeQueue = new LinkedList<ReaderNode>();
         nodeQueue.add(new ReaderNode.EmptyNode(runtime));
     }
 
-    private void parseRubyString(ThreadContext context, RubyString content, IRubyObject url, Options options){
-        Ruby ruby = context.getRuntime();
+    private void setInput(ThreadContext context, InputStream in, IRubyObject url, Options options){
+        this.setState(XML_TEXTREADER_MODE_READING);
+        config = this.createReader(context.getRuntime(), options);
+        InputSource inputSource = new InputSource();
+        ParserContext.setUrl(context, inputSource, url);
+        XMLInputSource xmlInputSource = new XMLInputSource(inputSource.getPublicId(),
+            inputSource.getSystemId(), null, in, null);
         try {
-            this.setState(XML_TEXTREADER_MODE_READING);
-            XMLReader reader = this.createReader(ruby, options);
-            ByteList byteList = content.getByteList();
-            ByteArrayInputStream bais = new ByteArrayInputStream(byteList.unsafeBytes(), byteList.begin(), byteList.length());
-            InputSource inputSource = new InputSource(bais);
-            ParserContext.setUrl(context, inputSource, url);
-            reader.parse(inputSource);
-            this.setState(XML_TEXTREADER_MODE_CLOSED);
-        } catch (SAXParseException spe) {
-            this.setState(XML_TEXTREADER_MODE_ERROR);
-            this.nodeQueue.add(new ReaderNode.ExceptionNode(ruby, spe));
-        } catch (IOException ioe) {
-            throw RaiseException.createNativeRaiseException(ruby, ioe);
-        } catch (SAXException saxe) {
-            throw RaiseException.createNativeRaiseException(ruby, saxe);
+          config.setInputSource(xmlInputSource);
+        } catch (IOException e) {
+          throw context.getRuntime().newRuntimeError(e.getMessage());
         }
+        this.setState(XML_TEXTREADER_MODE_CLOSED);
     }
 
     private void setState(int state) { this.state = state; }
 
     @JRubyMethod
     public IRubyObject attribute(ThreadContext context, IRubyObject name) {
-        return nodeQueue.peek().getAttributeByName(name);
+        return currentNode().getAttributeByName(name);
     }
 
     @JRubyMethod
     public IRubyObject attribute_at(ThreadContext context, IRubyObject index) {
-        return nodeQueue.peek().getAttributeByIndex(index);
+        return currentNode().getAttributeByIndex(index);
     }
 
     @JRubyMethod
     public IRubyObject attribute_count(ThreadContext context) {
-        return nodeQueue.peek().getAttributeCount();
+        return currentNode().getAttributeCount();
     }
 
     @JRubyMethod
     public IRubyObject attribute_nodes(ThreadContext context) {
-        return nodeQueue.peek().getAttributesNodes();
+        return currentNode().getAttributesNodes();
     }
 
     @JRubyMethod
     public IRubyObject attr_nodes(ThreadContext context) {
-        return nodeQueue.peek().getAttributesNodes();
+        return currentNode().getAttributesNodes();
     }
 
     @JRubyMethod(name = "attributes?")
     public IRubyObject attributes_p(ThreadContext context) {
-        return nodeQueue.peek().hasAttributes();
+        return currentNode().hasAttributes();
     }
-    
+
     @JRubyMethod
     public IRubyObject base_uri(ThreadContext context) {
-        return nodeQueue.peek().getXmlBase();
+        return currentNode().getXmlBase();
     }
 
     @JRubyMethod(name="default?")
     public IRubyObject default_p(ThreadContext context){
-        return nodeQueue.peek().isDefault();
+        return currentNode().isDefault();
     }
 
     @JRubyMethod
     public IRubyObject depth(ThreadContext context) {
-        return nodeQueue.peek().getDepth();
+        return currentNode().getDepth();
     }
-    
+
     @JRubyMethod(name = {"empty_element?", "self_closing?"})
     public IRubyObject empty_element_p(ThreadContext context) {
-        ReaderNode readerNode = nodeQueue.peek();
+        ReaderNode readerNode = currentNode();
+        ensureNodeClosed(context);
+
         if (readerNode == null) return context.getRuntime().getNil();
         if (!(readerNode instanceof ElementNode)) context.getRuntime().getFalse();
         return RubyBoolean.newBoolean(context.getRuntime(), !readerNode.hasChildren);
@@ -198,8 +209,6 @@ public class XmlReader extends RubyObject {
         if (args.length > 1) url = args[1];
         if (args.length > 2) reader.setInstanceVariable("@encoding", args[2]);
 
-        RubyString content = RuntimeHelpers.invoke(context, args[0], "read").convertToString();
-
         Options options;
         if (args.length > 3) {
           options = new ParserContext.Options((Long)args[3].toJava(Long.class));
@@ -207,7 +216,9 @@ public class XmlReader extends RubyObject {
           // use the default options RECOVER | NONET
           options = new ParserContext.Options(2048 | 1);
         }
-        reader.parseRubyString(context, content, url, options);
+
+        InputStream in = new UncloseableInputStream(new IOInputStream(args[0]));
+        reader.setInput(context, in, url, options);
         return reader;
     }
 
@@ -233,109 +244,136 @@ public class XmlReader extends RubyObject {
           // use the default options RECOVER | NONET
           options = new ParserContext.Options(2048 | 1);
         }
-        reader.parseRubyString(context, args[0].convertToString(), url, options);
+        IRubyObject stringIO = NokogiriService.nokogiriClassCache.get("StringIO").newInstance(context, args[0], Block.NULL_BLOCK);
+        InputStream in = new UncloseableInputStream(new IOInputStream(stringIO));
+        reader.setInput(context, in, url, options);
         return reader;
     }
 
     @JRubyMethod
     public IRubyObject node_type(ThreadContext context) {
-        IRubyObject node_type = nodeQueue.peek().getNodeType();
+        IRubyObject node_type = currentNode().getNodeType();
         return node_type == null ? RubyFixnum.zero(context.getRuntime()) : node_type;
     }
 
     @JRubyMethod
     public IRubyObject inner_xml(ThreadContext context) {
-        return stringOrBlank(context.getRuntime(), getInnerXml(nodeQueue, nodeQueue.peek()));
+        ensureNodeClosed(context);
+        return stringOrBlank(context.getRuntime(), getInnerXml(currentNode()));
     }
-    
-    private String getInnerXml(ArrayDeque<ReaderNode> nodeQueue, ReaderNode current) {
+
+    private String getInnerXml(ReaderNode current) {
         if (current.depth < 0) return null;
         if (!current.hasChildren) return null;
         StringBuffer sb = new StringBuffer();
-        int currentDepth = current.depth;
-        int inner = 0;
-        for (ReaderNode node : nodeQueue) {
-            if (node.depth == currentDepth && node.getName().equals(current.getName())) {
-                inner++;
-            }
-            if (node.depth > currentDepth) {
-                sb.append(node.getString());
-            }
-            if (inner == 2) break;
+        for (int i = current.startOffset + 1; i <= current.endOffset - 1; i++) {
+          sb.append(nodeQueue.get(i).getString());
         }
         return new String(sb);
     }
-    
+
     @JRubyMethod
     public IRubyObject outer_xml(ThreadContext context) {
-        return stringOrBlank(context.getRuntime(), getOuterXml(nodeQueue, nodeQueue.peek()));
+        ensureNodeClosed(context);
+        return stringOrBlank(context.getRuntime(), getOuterXml());
     }
-    
-    private String getOuterXml(ArrayDeque<ReaderNode> nodeQueue, ReaderNode current) {
+
+    private String getOuterXml() {
+        ReaderNode current = currentNode();
         if (current.depth < 0) return null;
+
+        if (current instanceof ClosingNode) {
+          return "<" + current.name + "/>";
+        }
+
         StringBuffer sb = new StringBuffer();
-        int initialDepth = current.depth;
-        int inner = 0;
-        for (ReaderNode node : nodeQueue) {
-            if (node.depth >= initialDepth) {
-                if (node.depth == initialDepth && node.getName().equals(current.getName())) {
-                    inner++;
-                }
-
-                sb.append(node.getString());
-            }
-            if (inner == 2) break;
+        for (int i = position; i <= current.endOffset; i++) {
+          sb.append(nodeQueue.get(i).getString());
         }
         return new String(sb);
     }
 
     @JRubyMethod
     public IRubyObject lang(ThreadContext context) {
-        return nodeQueue.peek().getLang();
+        return currentNode().getLang();
     }
 
     @JRubyMethod
     public IRubyObject local_name(ThreadContext context) {
-        return nodeQueue.peek().getLocalName();
+        return currentNode().getLocalName();
     }
 
     @JRubyMethod
     public IRubyObject name(ThreadContext context) {
-        return nodeQueue.peek().getName();
+        return currentNode().getName();
     }
 
     @JRubyMethod
     public IRubyObject namespace_uri(ThreadContext context) {
-        return nodeQueue.peek().getUri();
+        return currentNode().getUri();
     }
 
     @JRubyMethod
     public IRubyObject namespaces(ThreadContext context) {
-        return nodeQueue.peek().getNamespaces(context);
+        return currentNode().getNamespaces(context);
     }
 
     @JRubyMethod
     public IRubyObject prefix(ThreadContext context) {
-        return nodeQueue.peek().getPrefix();
+        return currentNode().getPrefix();
+    }
+
+    private void readMoreData(ThreadContext context) {
+      if (!continueParsing) {
+        throw context.runtime.newRuntimeError("Cannot parse more data");
+      }
+      try {
+        continueParsing = config.parse(false);
+      } catch (XNIException e) {
+        Ruby ruby = context.runtime;
+        XmlSyntaxError exception = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(ruby, getNokogiriClass(ruby, "Nokogiri::XML::SyntaxError"));
+        throw new RaiseException(exception);
+      } catch (IOException e) {
+        throw context.getRuntime().newRuntimeError("Received IOException: " + e.getMessage());
+      }
+    }
+
+    private void ensureNodeClosed(ThreadContext context) {
+      ReaderNode node = currentNode();
+      if (node instanceof TextNode) {
+        return;
+      }
+      while (node.endOffset < 1) {
+        readMoreData(context);
+      }
     }
 
     @JRubyMethod
     public IRubyObject read(ThreadContext context) {
-        this.nodeQueue.poll();
-        if(nodeQueue.peek() == null) {
-            return context.getRuntime().getNil();
-        } else if(nodeQueue.peek().isError()) {
+        position++;
+        while (nodeQueue.size() <= position && continueParsing) {
+          readMoreData(context);
+        }
+        if(currentNode() == null) {
+            return context.nil;
+        } else if(currentNode().isError()) {
             RubyArray errors = (RubyArray) this.getInstanceVariable("@errors");
-            errors.append(nodeQueue.peek().toSyntaxError());
+            errors.append(currentNode().toSyntaxError());
 
             this.setInstanceVariable("@errors", errors);
 
-            throw new RaiseException((XmlSyntaxError) nodeQueue.peek().toSyntaxError());
+            throw new RaiseException((XmlSyntaxError) currentNode().toSyntaxError());
         } else {
             return this;
         }
     }
 
+    private ReaderNode currentNode() {
+      if (position >= nodeQueue.size())
+        return null;
+      return nodeQueue.get(position);
+    }
+
     @JRubyMethod
     public IRubyObject state(ThreadContext context) {
         return context.getRuntime().newFixnum(this.state);
@@ -343,114 +381,152 @@ public class XmlReader extends RubyObject {
 
     @JRubyMethod
     public IRubyObject value(ThreadContext context) {
-        return nodeQueue.peek().getValue();
+        return currentNode().getValue();
     }
 
     @JRubyMethod(name = "value?")
     public IRubyObject value_p(ThreadContext context) {
-        return nodeQueue.peek().hasValue();
+        return currentNode().hasValue();
     }
 
     @JRubyMethod
     public IRubyObject xml_version(ThreadContext context) {
-        return nodeQueue.peek().getXmlVersion();
+        return currentNode().getXmlVersion();
     }
 
-    protected XMLReader createReader(final Ruby ruby, Options options) {
-        DefaultHandler2 handler = new DefaultHandler2() {
+    protected XMLPullParserConfiguration createReader(Ruby ruby, Options options) {
+        StandardParserConfiguration config = new StandardParserConfiguration();
+        DocumentHandler handler = new DocumentHandler(ruby);
+        // XMLReader reader = XMLReaderFactory.createXMLReader();
+        config.setDocumentHandler(handler);
+        config.setDTDHandler(handler);
+        config.setErrorHandler(handler);
+        config.setEntityResolver(new EntityResolver2Wrapper(new NokogiriEntityResolver(ruby, null, options)));
+        // config.setFeature("http://xml.org/sax/features/xmlns-uris", true);
+        // config.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
+        config.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", options.dtdLoad || options.dtdValid);
+        return config;
+    }
 
-            Stack<String> langStack;
-            int depth;
-            Stack<String> xmlBaseStack;
-            Stack<ReaderNode.ElementNode> elementStack;
+    private class DocumentHandler extends DefaultXMLDocumentHandler implements XMLErrorHandler {
 
-            @Override
-            public void characters(char[] chars, int start, int length) {
-                ReaderNode.TextNode node = ReaderNode.createTextNode(ruby, new String(chars, start, length), depth, langStack, xmlBaseStack);
-                nodeQueue.add(node);
-            }
-            
-            @Override
-            public void endDocument() throws SAXException {
-                langStack = null;
-                xmlBaseStack = null;
-                elementStack = null;
-            }
+        Stack<String> langStack;
+        int depth;
+        Stack<String> xmlBaseStack;
+        Stack<ReaderNode.ElementNode> elementStack;
+        private final Ruby ruby;
 
-            @Override
-            public void endElement(String uri, String localName, String qName) {
-                depth--;     
-                ReaderNode previous = nodeQueue.getLast();
-                ElementNode startElementNode = elementStack.pop();
-                if (previous instanceof ReaderNode.ElementNode && qName.equals(previous.name)) {
-                    previous.hasChildren = false;
-                } else {
-                    ReaderNode node = ReaderNode.createClosingNode(ruby, uri, localName, qName, depth, langStack, xmlBaseStack);
-                    if (startElementNode != null) {
-                        node.attributeList = startElementNode.attributeList;
-                        node.namespaces = startElementNode.namespaces;
-                    }
-                    nodeQueue.add(node);
-                }
-                if (!langStack.isEmpty()) langStack.pop();
-                if (!xmlBaseStack.isEmpty()) xmlBaseStack.pop();
-            }
+        public DocumentHandler(Ruby ruby) {
+          this.ruby = ruby;
+        }
 
-            @Override
-            public void error(SAXParseException ex) throws SAXParseException {
-                nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
-                throw ex;
-            }
 
-            @Override
-            public void fatalError(SAXParseException ex) throws SAXParseException {
-                nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
-                throw ex;
-            }
 
-            @Override
-            public void startDocument() {
-                depth = 0;
-                langStack = new Stack<String>();
-                xmlBaseStack = new Stack<String>();
-                elementStack = new Stack<ReaderNode.ElementNode>();
-            }
+        @Override
+        public void startGeneralEntity(String name, XMLResourceIdentifier identifier, String encoding,
+            Augmentations augs) throws XNIException {
+          Object entitySkipped;
+          if (augs != null && (entitySkipped = augs.getItem(Constants.ENTITY_SKIPPED)) != null && ((Boolean) entitySkipped) == true) {
+            nodeQueue.add(new ReaderNode.ExceptionNode(ruby, null));
+          }
+        }
+
 
-            @Override
-            public void startElement(String uri, String localName, String qName, Attributes attrs) {
-                ReaderNode readerNode = ReaderNode.createElementNode(ruby, uri, localName, qName, attrs, depth, langStack, xmlBaseStack);
-                nodeQueue.add(readerNode);
-                depth++;
-                if (readerNode.lang != null) langStack.push(readerNode.lang);
-                if (readerNode.xmlBase != null) xmlBaseStack.push(readerNode.xmlBase);
-                elementStack.push((ReaderNode.ElementNode)readerNode);
-            }
 
-            @Override
-            public void skippedEntity(String name) {
-              XmlSyntaxError error = XmlSyntaxError.createNokogiriXmlSyntaxError(ruby);
-              error.setException(new Exception("Unknown entity " + name));
-              throw new RaiseException(error);
+        @Override
+        public void startDocument(XMLLocator locator, String encoding, NamespaceContext context, Augmentations augs) {
+            depth = 0;
+            langStack = new Stack<String>();
+            xmlBaseStack = new Stack<String>();
+            elementStack = new Stack<ReaderNode.ElementNode>();
+        }
+
+        @Override
+        public void endDocument(Augmentations augs) {
+            langStack = null;
+            xmlBaseStack = null;
+            elementStack = null;
+        }
+
+        @Override
+        public void startElement(QName element, XMLAttributes attrs, Augmentations augs) {
+          commonElement(element, attrs, false);
+        }
+
+        @Override
+        public void endElement(QName element, Augmentations augs) {
+            String uri = element.uri;
+            String localName = element.localpart;
+            String qName = element.rawname;
+            depth--;
+            ElementNode startElementNode = elementStack.pop();
+            ReaderNode node = ReaderNode.createClosingNode(ruby, uri, localName, qName, depth, langStack, xmlBaseStack);
+
+            startElementNode.endOffset = nodeQueue.size() - 1;
+
+            if (startElementNode.endOffset != startElementNode.startOffset) {
+              // this node isn't empty
+              node.attributeList = startElementNode.attributeList;
+              node.namespaces = startElementNode.namespaces;
+              node.startOffset = startElementNode.startOffset;
+              node.endOffset = ++startElementNode.endOffset;
+              node.hasChildren = startElementNode.hasChildren = true;
+              nodeQueue.add(node);
             }
+            if (!langStack.isEmpty()) langStack.pop();
+            if (!xmlBaseStack.isEmpty()) xmlBaseStack.pop();
+        }
 
-            @Override
-            public void warning(SAXParseException ex) throws SAXParseException {
-                nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
-                throw ex;
+        @Override
+        public void emptyElement(QName element, XMLAttributes attrs, Augmentations augs) {
+          commonElement(element, attrs, true);
+        }
+
+        private void commonElement(QName element, XMLAttributes attrs, boolean isEmpty) {
+            String qName = element.rawname;
+            String uri = element.uri;
+            String localName = element.localpart;
+            ReaderNode readerNode = ReaderNode.createElementNode(ruby, uri, localName, qName, attrs, depth, langStack, xmlBaseStack);
+            if (!elementStack.isEmpty()) {
+              ElementNode parent = elementStack.peek();
+              parent.hasChildren = true;
+            }
+            nodeQueue.add(readerNode);
+            readerNode.startOffset = nodeQueue.size() - 1;
+            if (!isEmpty) {
+              depth++;
+              if (readerNode.lang != null) langStack.push(readerNode.lang);
+              if (readerNode.xmlBase != null) xmlBaseStack.push(readerNode.xmlBase);
+              elementStack.push((ReaderNode.ElementNode)readerNode);
+            } else {
+              readerNode.endOffset = readerNode.startOffset;
+              readerNode.hasChildren = false;
             }
-        };
-        try {
-            XMLReader reader = XMLReaderFactory.createXMLReader();
-            reader.setContentHandler(handler);
-            reader.setDTDHandler(handler);
-            reader.setErrorHandler(handler);
-            reader.setEntityResolver(new NokogiriEntityResolver(ruby, null, options));
-            reader.setFeature("http://xml.org/sax/features/xmlns-uris", true);
-            reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
-            reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", options.dtdLoad || options.dtdValid);
-            return reader;
-        } catch (SAXException saxe) {
-            throw RaiseException.createNativeRaiseException(ruby, saxe);
         }
-    }
+
+        @Override
+        public void characters(XMLString string, Augmentations augs) {
+            ReaderNode.TextNode node = ReaderNode.createTextNode(ruby, string.toString(), depth, langStack, xmlBaseStack);
+            nodeQueue.add(node);
+            node.startOffset = node.endOffset = nodeQueue.size() - 1;
+        }
+
+        @Override
+        public void error(String domain, String key, XMLParseException ex) {
+            nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
+            throw ex;
+        }
+
+        @Override
+        public void fatalError(String domain, String key, XMLParseException ex) {
+            nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
+            throw ex;
+        }
+
+        @Override
+        public void warning(String domain, String key, XMLParseException ex) {
+            nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
+            throw ex;
+        }
+    };
 }