transformerimpl.java

gcc的组建

        if (ex != null)
          {
            if (errorListener != null)
              {
                errorListener.error(new TransformerException(ex));
              }
            else
              {
                ex.printStackTrace(System.err);
              }
          }
      }
    else if (outputTarget instanceof SAXResult)
      {
        SAXResult sr = (SAXResult) outputTarget;
        try
          {
            ContentHandler ch = sr.getHandler();
            LexicalHandler lh = sr.getLexicalHandler();
            if (lh == null && ch instanceof LexicalHandler)
              {
                lh = (LexicalHandler) ch;
              }
            SAXSerializer serializer = new SAXSerializer();
            serializer.serialize(parent, ch, lh);
          }
        catch (SAXException e)
          {
            if (errorListener != null)
              {
                errorListener.error(new TransformerException(e));
              }
            else
              {
                e.printStackTrace(System.err);
              }
          }
      }
  }

  /**
   * Strip whitespace from the source tree.
   */
  void strip(Node node)
    throws TransformerConfigurationException
  {
    short nt = node.getNodeType();
    if (nt == Node.ENTITY_REFERENCE_NODE)
      {
        // Replace entity reference with its content
        Node parent = node.getParentNode();
        Node child = node.getFirstChild();
        if (child != null)
          {
            strip(child);
          }
        while (child != null)
          {
            Node next = child.getNextSibling();
            node.removeChild(child);
            parent.insertBefore(child, node);
            child = next;
          }
        parent.removeChild(node);
      }
    if (nt == Node.TEXT_NODE || nt == Node.CDATA_SECTION_NODE)
      {
        if (!stylesheet.isPreserved((Text) node))
          {
            node.getParentNode().removeChild(node);
          }
        else
          {
            String text = node.getNodeValue();
            String stripped = text.trim();
            if (!text.equals(stripped))
              {
                node.setNodeValue(stripped);
              }
          }
      }
    else
      {
        for (Node child = node.getFirstChild(); child != null;
             child = child.getNextSibling())
          {
            strip(child);
          }
      }
  }

  /**
   * Obtain a suitable output stream for writing the result to,
   * and use the StreamSerializer to write the result tree to the stream.
   */
  void writeStreamResult(Node node, StreamResult sr, int outputMethod,
                         String encoding)
    throws IOException
  {
    OutputStream out = null;
    boolean created = false;
    try
      {
        out = sr.getOutputStream();
        if (out == null)
          {
            Writer writer = sr.getWriter();
            if (writer != null)
              {
                out = new WriterOutputStream(writer);
              }
          }
        if (out == null)
          {
            String systemId = sr.getSystemId();
            try
              {
                URL url = new URL(systemId);
                URLConnection connection = url.openConnection();
                // We need to call setDoInput(false), because our
                // implementation of the file protocol allows writing
                // (unlike Sun), but it will fail with a FileNotFoundException
                // if we also open the connection for input and the output
                // file doesn't yet exist.
                connection.setDoInput(false);
                connection.setDoOutput(true);
                out = connection.getOutputStream();
              }
            catch (MalformedURLException e)
              {
                out = new FileOutputStream(systemId);
              }
            catch (UnknownServiceException e)
              {
                URL url = new URL(systemId);
                out = new FileOutputStream(url.getPath());
              }
            created = true;
          }
        out = new BufferedOutputStream(out);
        StreamSerializer serializer =
          new StreamSerializer(outputMethod, encoding, null);
        if (stylesheet != null)
          {
            Collection celem = stylesheet.outputCdataSectionElements;
            serializer.setCdataSectionElements(celem);
          }
        serializer.serialize(node, out);
        out.flush();
      }
    finally
      {
        try
          {
            if (out != null && created)
              {
                out.close();
              }
          }
        catch (IOException e)
          {
          }
      }
  }

  void copyChildren(Document dstDoc, Node src, Node dst)
  {
    Node srcChild = src.getFirstChild();
    while (srcChild != null)
      {
        Node dstChild = dstDoc.adoptNode(srcChild);
        dst.appendChild(dstChild);
        srcChild = srcChild.getNextSibling();
      }
  }

  public void setParameter(String name, Object value)
  {
    if (stylesheet != null)
      {
        stylesheet.bindings.set(new QName(null, name), value, Bindings.PARAM);
      }
  }

  public Object getParameter(String name)
  {
    if (stylesheet != null)
      {
        return stylesheet.bindings.get(new QName(null, name), null, 1, 1);
      }
    return null;
  }

  public void clearParameters()
  {
    if (stylesheet != null)
      {
        stylesheet.bindings.pop(Bindings.PARAM);
        stylesheet.bindings.push(Bindings.PARAM);
      }
  }

  public void setURIResolver(URIResolver resolver)
  {
    uriResolver = resolver;
  }

  public URIResolver getURIResolver()
  {
    return uriResolver;
  }

  public void setOutputProperties(Properties oformat)
    throws IllegalArgumentException
  {
    if (oformat == null)
      {
        outputProperties.clear();
      }
    else
      {
        outputProperties.putAll(oformat);
      }
  }

  public Properties getOutputProperties()
  {
    return (Properties) outputProperties.clone();
  }

  public void setOutputProperty(String name, String value)
    throws IllegalArgumentException
  {
    outputProperties.put(name, value);
  }

  public String getOutputProperty(String name)
    throws IllegalArgumentException
  {
    return outputProperties.getProperty(name);
  }

  public void setErrorListener(ErrorListener listener)
  {
    errorListener = listener;
  }

  public ErrorListener getErrorListener()
  {
    return errorListener;
  }

  static final String INDENT_WHITESPACE = "  ";

  /*
   * Apply indent formatting to the given tree.
   */
  void reindent(Document doc, Node node, int offset)
  {
    if (node.hasChildNodes())
      {
        boolean markupContent = false;
        boolean textContent = false;
        List children = new LinkedList();
        Node ctx = node.getFirstChild();
        while (ctx != null)
          {
            switch (ctx.getNodeType())
              {
              case Node.ELEMENT_NODE:
              case Node.PROCESSING_INSTRUCTION_NODE:
              case Node.DOCUMENT_TYPE_NODE:
                markupContent = true;
                break;
              case Node.TEXT_NODE:
              case Node.CDATA_SECTION_NODE:
              case Node.ENTITY_REFERENCE_NODE:
              case Node.COMMENT_NODE:
                textContent = true;
                break;
              }
            children.add(ctx);
            ctx = ctx.getNextSibling();
          }
        if (markupContent)
          {
            if (textContent)
              {
                // XXX handle mixed content differently?
              }
            int nodeType = node.getNodeType();
            if (nodeType == Node.DOCUMENT_NODE)
              {
                for (Iterator i = children.iterator(); i.hasNext(); )
                  {
                    ctx = (Node) i.next();
                    reindent(doc, ctx, offset + 1);
                  }
              }
            else
              {
                StringBuffer buf = new StringBuffer();
                buf.append('\n');
                for (int i = 0; i < offset + 1; i++)
                  {
                    buf.append(INDENT_WHITESPACE);
                  }
                String ws = buf.toString();
                for (Iterator i = children.iterator(); i.hasNext(); )
                  {
                    ctx = (Node) i.next();
                    node.insertBefore(doc.createTextNode(ws), ctx);
                    reindent(doc, ctx, offset + 1);
                  }
                buf = new StringBuffer();
                buf.append('\n');
                ws = buf.toString();
                for (int i = 0; i < offset; i++)
                  {
                    buf.append(INDENT_WHITESPACE);
                  }
                node.appendChild(doc.createTextNode(ws));
              }
          }
      }
  }

  /**
   * Converts the text node children of any cdata-section-elements in the
   * tree to CDATA section nodes.
   */
  void convertCdataSectionElements(Document doc, Node node, List list)
  {
    if (node.getNodeType() == Node.ELEMENT_NODE)
      {
        boolean match = false;
        for (Iterator i = list.iterator(); i.hasNext(); )
          {
            QName qname = (QName) i.next();
            if (match(qname, node))
              {
                match = true;
                break;
              }
          }
        if (match)
          {
            Node ctx = node.getFirstChild();
            while (ctx != null)
              {
                if (ctx.getNodeType() == Node.TEXT_NODE)
                  {
                    Node cdata = doc.createCDATASection(ctx.getNodeValue());
                    node.replaceChild(cdata, ctx);
                    ctx = cdata;
                  }
                ctx = ctx.getNextSibling();
              }
          }
      }
    Node ctx = node.getFirstChild();
    while (ctx != null)
      {
        if (ctx.hasChildNodes())
          {
            convertCdataSectionElements(doc, ctx, list);
          }
        ctx = ctx.getNextSibling();
      }
  }

  boolean match(QName qname, Node node)
  {
    String ln1 = qname.getLocalPart();
    String ln2 = node.getLocalName();
    if (ln2 == null)
      {
        return ln1.equals(node.getNodeName());
      }
    else
      {
        String uri1 = qname.getNamespaceURI();
        String uri2 = node.getNamespaceURI();
        return (uri1.equals(uri2) && ln1.equals(ln2));
      }
  }

}