xincludefilter.java

linux下建立JAVA虚拟机的源码KAFFE

              case Node.ELEMENT_NODE:
                return next();
              case Node.TEXT_NODE:
                String text = n.getNodeValue();
                buf = text.toCharArray();
                len = buf.length;
                event = isSpace(buf, len) ?
                  XMLStreamConstants.SPACE :
                  XMLStreamConstants.CHARACTERS;
                return event;
              case Node.CDATA_SECTION_NODE:
                event = XMLStreamConstants.CDATA;
                return event;
              case Node.COMMENT_NODE:
                event = XMLStreamConstants.COMMENT;
                return event;
              case Node.PROCESSING_INSTRUCTION_NODE:
                event = XMLStreamConstants.PROCESSING_INSTRUCTION;
                return event;
              case Node.ENTITY_REFERENCE_NODE:
                event = XMLStreamConstants.ENTITY_REFERENCE;
                return event;
              default:
                throw new IllegalStateException();
              }
          }
      }
    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;
            event = XMLStreamConstants.CHARACTERS;
            return event;
          case XPathResult.NUMBER_TYPE:
            double nval = result.getNumberValue();
            String ntext = new Double(nval).toString();
            buf = ntext.toCharArray();
            len = buf.length;
            result = null;
            event = XMLStreamConstants.CHARACTERS;
            return event;
          case XPathResult.STRING_TYPE:
            String stext = result.getStringValue();
            buf = stext.toCharArray();
            len = buf.length;
            result = null;
            event = isSpace(buf, len) ?
              XMLStreamConstants.SPACE :
              XMLStreamConstants.CHARACTERS;
            return event;
          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();
          default:
            throw new IllegalStateException();
          }
      }
    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--;
                          }
                      }
                  }
                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 + "'");
              }
            return next();
          }
        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;
            return next();
          }
        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;
  }

  String getBaseURI()
  {
    String base = (String) getParent().getProperty("gnu.xml.stream.baseURI");
    return (base == null) ? systemId : base;
  }
  
  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");
        String base = getBaseURI();
        if (href == null || "".equals(href))
          href = base;
        else
          href = XMLParser.absolutize(base, href);
        if (parse == null || "xml".equals(parse))
          {
            seen.clear();
            result = null;
            snapshotIndex = 0;
            walker = null;
            current = null;
            backtracking = false;
            
            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;
  }
  
}