vtd_xml 0.0.3-java

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/java/nokogiri/internals/NokogiriNamespaceCache.java

@@ -0,0 +1,180 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import nokogiri.XmlNamespace;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+/**
+ * Cache of namespages of each node. XmlDocument has one cache of this class.
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNamespaceCache {
+
+    private List<Long> keys;  // order matters.
+    private Map<Integer, CacheEntry> cache;  // pair of the index of a given key and entry
+    private XmlNamespace defaultNamespace = null;
+
+    public NokogiriNamespaceCache() {
+        keys = new ArrayList<Long>();
+        cache = new LinkedHashMap<Integer, CacheEntry>();
+    }
+    
+    private Long hashCode(String prefix, String href) {
+        long prefix_hash = prefix.hashCode();
+        long href_hash = href.hashCode();
+        return prefix_hash << 31 | href_hash;
+    }
+
+    public XmlNamespace get(String prefix, String href) {
+        // prefix should not be null.
+        // In case of a default namespace, an empty string should be given to prefix argument.
+        if (prefix == null || href == null) return null;
+        Long hash = hashCode(prefix, href);
+        Integer index = keys.indexOf(hash);
+        if (index != -1) return cache.get(index).namespace;
+        return null;
+    }
+    
+    public XmlNamespace getDefault() {
+        return defaultNamespace;
+    }
+    
+    public XmlNamespace get(String prefix) {
+        if (prefix == null) return defaultNamespace;
+        long h = prefix.hashCode();
+        Long hash = h << 31;
+        Long mask = 0xFF00L;
+        for (int i=0; i < keys.size(); i++) {
+            if ((keys.get(i) & mask) == hash) {
+                return cache.get(i).namespace;
+            }
+        }
+        return null;
+    }
+    
+    public List<XmlNamespace> get(Node node) {
+        List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+        for (int i=0; i < keys.size(); i++) {
+            CacheEntry entry = cache.get(i);
+            if (entry.isOwner(node)) {
+                namespaces.add(entry.namespace);
+            }
+        }
+        return namespaces;
+    }
+
+    public void put(XmlNamespace namespace, Node ownerNode) {
+        // prefix should not be null.
+        // In case of a default namespace, an empty string should be given to prefix argument.
+        String prefixString = namespace.getPrefix();
+        String hrefString = namespace.getHref();
+        Long hash = hashCode(prefixString, hrefString);
+        Integer index;
+        if ((index = keys.indexOf(hash)) != -1) {
+            return;
+        } else {
+            keys.add(hash);
+            index = keys.size() - 1;
+            CacheEntry entry = new CacheEntry(namespace, ownerNode);
+            cache.put(index, entry);
+            if ("".equals(prefixString)) defaultNamespace = namespace;
+        }
+    }
+
+    public void remove(String prefix, String href) {
+        if (prefix == null || href == null) return;
+        Long hash = hashCode(prefix, href);
+        Integer index = keys.indexOf(hash);
+        if (index != -1) {
+            cache.remove(index);
+        }
+        keys.remove(index);
+    }
+    
+    public void clear() {
+        // removes namespace declarations from node
+        for (int i=0; i < keys.size(); i++) {
+            CacheEntry entry = cache.get(i);
+            NamedNodeMap attributes = entry.ownerNode.getAttributes();
+            for (int j=0; j<attributes.getLength(); j++) {
+                String name = ((Attr)attributes.item(j)).getName();
+                if (isNamespace(name)) {
+                    attributes.removeNamedItem(name);
+                }
+            }
+        }
+        keys.clear();
+        cache.clear();
+        defaultNamespace = null;
+    }
+    
+    public void replaceNode(Node oldNode, Node newNode) {
+        for (int i=0; i < keys.size(); i++) {
+            CacheEntry entry = cache.get(i);
+            if (entry.isOwner(oldNode)) {
+                entry.replaceOwner(newNode);
+            }
+        }
+    }
+
+    private class CacheEntry {
+        private XmlNamespace namespace;
+        private Node ownerNode;
+        
+        CacheEntry(XmlNamespace namespace, Node ownerNode) {
+            this.namespace = namespace;
+            this.ownerNode = ownerNode;
+        }
+
+        public Boolean isOwner(Node n) {
+            return this.ownerNode.isSameNode(n);
+        }
+
+        public void replaceOwner(Node newNode) {
+            this.ownerNode = newNode;
+        }
+    }
+}

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/java/nokogiri/internals/NokogiriNamespaceContext.java

@@ -0,0 +1,130 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+
+/**
+ * Holder of each node's namespace.
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ *
+ */
+
+public class NokogiriNamespaceContext implements NamespaceContext {
+    private static NokogiriNamespaceContext namespaceContext;
+	public static final String NOKOGIRI_PREFIX = "nokogiri";
+    public static final String NOKOGIRI_URI = "http://www.nokogiri.org/default_ns/ruby/extensions_functions";
+    public static final String NOKOGIRI_TEMPORARY_ROOT_TAG = "nokogiri-temporary-root-tag";
+    
+    private Hashtable<String,String> register;
+
+    public static NokogiriNamespaceContext create() {
+        if (namespaceContext == null) namespaceContext = new NokogiriNamespaceContext();
+        try {
+            NokogiriNamespaceContext clone = (NokogiriNamespaceContext) namespaceContext.clone();
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriNamespaceContext freshContext = new NokogiriNamespaceContext();
+            return freshContext;
+        }
+    }
+    
+    private NokogiriNamespaceContext() {
+        this.register = new Hashtable<String,String>();
+        register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
+        register.put("xml", "http://www.w3.org/XML/1998/namespace");
+        register.put("xhtml", "http://www.w3.org/1999/xhtml");
+    }
+
+    public String getNamespaceURI(String prefix) {
+    	if (prefix == null) {
+            throw new IllegalArgumentException();
+        }
+        String uri = this.register.get(prefix);
+        if (uri != null) {
+            return uri;
+        }
+
+        if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE)) {
+            uri = this.register.get(XMLConstants.XMLNS_ATTRIBUTE);
+            return (uri == null) ? XMLConstants.XMLNS_ATTRIBUTE_NS_URI : uri;
+        }
+
+        return XMLConstants.NULL_NS_URI;
+    }
+
+    public String getPrefix(String uri) {
+    	if (uri == null) {
+            throw new IllegalArgumentException("uri is null");
+        } else {
+            Set<Entry<String, String>> entries = register.entrySet();
+            for (Entry<String, String> entry : entries) {
+                if (uri.equals(entry.getValue())) {
+                    return entry.getKey();
+                }
+            }
+        }
+        return null;
+    }
+
+    public Iterator<String> getPrefixes(String uri) {
+        if (register == null) return null;
+        Set<Entry<String, String>> entries = register.entrySet();
+        List<String> list = new ArrayList<String>();
+        for (Entry<String, String> entry : entries) {
+            if (uri.equals(entry.getValue())) {
+                list.add(entry.getKey());
+            }
+        }
+        return list.iterator();
+    }
+    
+    public Set<String> getAllPrefixes() {
+        if (register == null) return null;
+        return register.keySet();
+    }
+
+    public void registerNamespace(String prefix, String uri) {
+        if("xmlns".equals(prefix)) prefix = "";
+        this.register.put(prefix, uri);
+    }
+}

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java

@@ -0,0 +1,98 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Error Handler for XML document when recover is true (default).
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler{
+    public NokogiriNonStrictErrorHandler(boolean noerror, boolean nowarning) {
+        super(noerror, nowarning);
+    }
+
+    public void warning(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        // fix #837
+        // Xerces won't skip the reference entity (and other invalid) constructs
+        // found in the prolog, instead it will keep calling this method and we'll
+        // keep inserting the error in the document errors array until we run
+        // out of memory
+        errors.add(ex);
+        String message = ex.getMessage();
+
+        // The problem with Xerces is that some errors will cause the
+        // parser not to advance the reader and it will keep reporting
+        // the same error over and over, which will cause the parser
+        // to enter an infinite loop unless we throw the exception.
+        if (message != null && isFatal(message)) {
+          throw ex;
+        }
+    }
+
+    public void error(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    public void warning(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    /*
+     * Determine whether this is a fatal error that should cause
+     * the parsing to stop, or an error that can be ignored.
+     */
+    private static boolean isFatal(String msg) {
+        return
+          msg.toLowerCase().contains("in prolog") ||
+          msg.toLowerCase().contains("limit") ||
+          msg.toLowerCase().contains("preceding the root element must be well-formed");
+    }
+}

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java

@@ -0,0 +1,121 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Non-strict error handler for NekoHtml.
+ * 
+ * NekoHtml adds too many warnings, which makes later processing hard. For example,
+ * Nokogiri wants to know whether number of errors have been increased or not to judge 
+ * availability of creating NodeSet from a given fragment. When the fragment nodes 
+ * are to be created from HTML document, which means NekoHtml is used, always errors
+ * increases. As a result, even though the given fragment is correct HTML, NodeSet
+ * base on the given fragment won't be created. This is why all warnings are eliminated.
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler {
+    
+    public NokogiriNonStrictErrorHandler4NekoHtml(boolean nowarning) {
+        super(false, nowarning);
+    }
+    
+    public NokogiriNonStrictErrorHandler4NekoHtml(boolean noerror, boolean nowarning) {
+        super(noerror, nowarning);
+    }
+
+    public void warning(SAXParseException ex) throws SAXException {
+        //noop. NekoHtml adds too many warnings.
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    /**
+     * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+     * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+     * 
+     * @param domain The domain of the error. The domain can be any string but is 
+     *               suggested to be a valid URI. The domain can be used to conveniently
+     *               specify a web site location of the relevant specification or 
+     *               document pertaining to this warning.
+     * @param key The error key. This key can be any string and is implementation
+     *            dependent.
+     * @param e Exception.
+     */
+    public void error(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    /**
+     * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+     * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+     * 
+     * @param domain The domain of the fatal error. The domain can be any string but is 
+     *               suggested to be a valid URI. The domain can be used to conveniently
+     *               specify a web site location of the relevant specification or 
+     *               document pertaining to this warning.
+     * @param key The fatal error key. This key can be any string and is implementation
+     *            dependent.
+     * @param e Exception.
+     */
+    public void fatalError(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    /**
+     * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+     * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+     * 
+     * @param domain The domain of the warning. The domain can be any string but is 
+     *               suggested to be a valid URI. The domain can be used to conveniently
+     *               specify a web site location of the relevant specification or 
+     *               document pertaining to this warning.
+     * @param key The warning key. This key can be any string and is implementation
+     *            dependent.
+     * @param e Exception.
+     */
+    public void warning(String domain, String key, XMLParseException e) {
+        //noop. NekoHtml adds too many warnings.
+    }
+
+}

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java

@@ -0,0 +1,79 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * 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.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Strict error handler. Even though strict is specified, Nokogiri allows to go further
+ * when NOERROR or/both NOWARNING is/are true.
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriStrictErrorHandler extends NokogiriErrorHandler {
+    public NokogiriStrictErrorHandler(boolean noerror, boolean nowarning) {
+        super(noerror, nowarning);
+    }
+
+    public void warning(SAXParseException spex) throws SAXException {
+        if (!nowarning) throw spex;
+        else errors.add(spex);
+    }
+
+    public void error(SAXParseException spex) throws SAXException {
+        if (!noerror) throw spex;
+        else errors.add(spex);
+    }
+
+    public void fatalError(SAXParseException spex) throws SAXException {
+        throw spex;
+    }
+
+    public void error(String domain, String key, XMLParseException e) throws XMLParseException {
+        if (!noerror) throw e;
+        else errors.add(e);
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e) throws XMLParseException {
+        throw e;
+    }
+
+    public void warning(String domain, String key, XMLParseException e) throws XMLParseException {
+        if (!nowarning) throw e;
+        if (!usesNekoHtml(domain)) errors.add(e);
+    }
+
+}