import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Copy DOM attributes to the result element.
 *
 * @param src Source node with the attributes
 *
 * @throws TransformerException
 */
public static void addAttributes(SerializationHandler handler, int src)
    throws TransformerException
{

    TransformerImpl transformer =
        (TransformerImpl) handler.getTransformer();
    DTM dtm = transformer.getXPathContext().getDTM(src);

    for (int node = dtm.getFirstAttribute(src);
        DTM.NULL != node;
        node = dtm.getNextAttribute(node))
    {
        addAttribute(handler, node);
    }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Returns whether a namespace is defined
 *
 *
 * @param attr Namespace attribute node
 * @param dtm The DTM that owns attr.
 *
 * @return True if the namespace is already defined in
 * list of namespaces
 */
public static boolean isDefinedNSDecl(
    SerializationHandler serializer,
    int attr,
    DTM dtm)
{

    if (DTM.NAMESPACE_NODE == dtm.getNodeType(attr))
    {

        // String prefix = dtm.getPrefix(attr);
        String prefix = dtm.getNodeNameX(attr);
        String uri = serializer.getNamespaceURIFromPrefix(prefix);
        //      String uri = getURI(prefix);

        if ((null != uri) && uri.equals(dtm.getStringValue(attr)))
            return true;
    }

    return false;
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * This function checks to make sure a given prefix is really
 * declared.  It might not be, because it may be an excluded prefix.
 * If it's not, it still needs to be declared at this point.
 * TODO: This needs to be done at an earlier stage in the game... -sb
 *
 * NEEDSDOC @param dtm
 * NEEDSDOC @param namespace
 *
 * @throws org.xml.sax.SAXException
 */
public static void ensureNamespaceDeclDeclared(
    SerializationHandler handler,
    DTM dtm,
    int namespace)
    throws org.xml.sax.SAXException
{

    String uri = dtm.getNodeValue(namespace);
    String prefix = dtm.getNodeNameX(namespace);

    if ((uri != null && uri.length() > 0) && (null != prefix))
    {
        String foundURI;
        NamespaceMappings ns = handler.getNamespaceMappings();
        if (ns != null)
        {

            foundURI = ns.lookupNamespace(prefix);
            if ((null == foundURI) || !foundURI.equals(uri))
            {
                handler.startPrefixMapping(prefix, uri, false);
            }
        }
    }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Resolve the namespace into a prefix.  At this level, if no prefix exists, 
 * then return a manufactured prefix.
 *
 * @param rhandler The current result tree handler.
 * @param prefix The probable prefix if already known.
 * @param nodeNamespace  The namespace, which should not be null.
 *
 * @return The prefix to be used.
 */
protected String resolvePrefix(SerializationHandler rhandler,
                               String prefix, String nodeNamespace)
  throws TransformerException
{

  if (null != prefix && (prefix.length() == 0 || prefix.equals("xmlns")))
  {
    // Since we can't use default namespace, in this case we try and 
    // see if a prefix has already been defined or this namespace.
    prefix = rhandler.getPrefix(nodeNamespace);

    // System.out.println("nsPrefix: "+nsPrefix);           
    if (null == prefix || prefix.length() == 0 || prefix.equals("xmlns"))
    {
      if(nodeNamespace.length() > 0)
      {
          NamespaceMappings prefixMapping = rhandler.getNamespaceMappings();
          prefix = prefixMapping.generateNextPrefix();
      }
      else
        prefix = "";
    }
  }
  return prefix;
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
   * Resolve the namespace into a prefix.  Meant to be
   * overidded by elemAttribute if this class is derived.
   *
   * @param rhandler The current result tree handler.
   * @param prefix The probable prefix if already known.
   * @param nodeNamespace  The namespace.
   *
   * @return The prefix to be used.
   */
  protected String resolvePrefix(SerializationHandler rhandler,
                                 String prefix, String nodeNamespace)
    throws TransformerException
  {

//    if (null != prefix && prefix.length() == 0)
//    {
//      String foundPrefix = rhandler.getPrefix(nodeNamespace);
//
//      // System.out.println("nsPrefix: "+nsPrefix);           
//      if (null == foundPrefix)
//        foundPrefix = "";
//    }
    return prefix;
  }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Send startPrefixMapping events to the result tree handler
 * for all declared prefix mappings in the stylesheet.
 *
 * @param transformer non-null reference to the the current transform-time state.
 * @param ignorePrefix string prefix to not startPrefixMapping
 *
 * @throws TransformerException
 */
void executeNSDecls(TransformerImpl transformer, String ignorePrefix) throws TransformerException
{  
  try
  {
    if (null != m_prefixTable)
    {
      SerializationHandler rhandler = transformer.getResultTreeHandler();
      int n = m_prefixTable.size();

      for (int i = n - 1; i >= 0; i--)
      {
        XMLNSDecl decl = (XMLNSDecl) m_prefixTable.get(i);

        if (!decl.getIsExcluded() && !(null != ignorePrefix && decl.getPrefix().equals(ignorePrefix)))
        {
          rhandler.startPrefixMapping(decl.getPrefix(), decl.getURI(), true);
        }
      }
    }
  }
  catch(org.xml.sax.SAXException se)
  {
    throw new TransformerException(se);
  }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Copy the text literal to the result tree.
 *
 * @param transformer non-null reference to the the current transform-time state.
 *
 * @throws TransformerException
 */
public void execute(
        TransformerImpl transformer)
          throws TransformerException
{
  try
  {
    SerializationHandler rth = transformer.getResultTreeHandler();

      if (m_disableOutputEscaping)
    {
      rth.processingInstruction(javax.xml.transform.Result.PI_DISABLE_OUTPUT_ESCAPING, "");
    }

    rth.characters(m_ch, 0, m_ch.length);

    if (m_disableOutputEscaping)
    {
      rth.processingInstruction(javax.xml.transform.Result.PI_ENABLE_OUTPUT_ESCAPING, "");
    }
  }
  catch(SAXException se)
  {
    throw new TransformerException(se);
  }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
   * Enables the user of the TransformerHandler to set the
   * to set the Result for the transformation.
   *
   * @param result A Result instance, should not be null.
   *
   * @throws IllegalArgumentException if result is invalid for some reason.
   */
  public void setResult(Result result) throws IllegalArgumentException
  {

    if (null == result)
      throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_RESULT_NULL, null)); //"result should not be null");

    try
    {
//      ContentHandler handler =
//        m_transformer.createResultContentHandler(result);
//      m_transformer.setContentHandler(handler);
        SerializationHandler xoh = 
            m_transformer.createSerializationHandler(result);
        m_transformer.setSerializationHandler(xoh);
    }
    catch (javax.xml.transform.TransformerException te)
    {
      throw new IllegalArgumentException(XSLMessages.createMessage(XSLTErrorResources.ER_RESULT_COULD_NOT_BE_SET, null)); //"result could not be set");
    }

    m_result = result;
  }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Copy the String value of a Text node to a SerializationHandler
 */
protected final void copyTextNode(final int nodeID, SerializationHandler handler)
    throws SAXException
{
    if (nodeID != DTM.NULL) {
  	    int dataIndex = m_dataOrQName.elementAt(nodeID);
        if (dataIndex >= 0) {
            m_chars.sendSAXcharacters(handler,
                                      dataIndex >>> TEXT_LENGTH_BITS,
                                      dataIndex & TEXT_LENGTH_MAX);
        } else {
            m_chars.sendSAXcharacters(handler, m_data.elementAt(-dataIndex),
                                      m_data.elementAt(-dataIndex+1));
        }
    }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
@Override
public void trace(TracerEvent ev) {
  if (myTracing) return;
  myTracing = true; // prevents handling of recursive trace() events

  try {
    // init
    if (firstTrace) {
      firstTrace = false;
      final SerializationHandler handler = myTransformer.getSerializationHandler();
      myTransformer.setSerializationHandler(new TracingSerializationHandler(myDebugger, handler));
    }

    super.trace(ev);

    final DTMIterator iterator = myTransformer.getContextNodeList();
    final int node = myTransformer.getMatchedNode();
    final Debugger.SourceFrame sourceFrame = myDebugger.getSourceFrame();
    final boolean withSource;
    if (sourceFrame == null || ((MySourceFrame)sourceFrame).getMatchedNode() != node) {
      myDebugger.pushSource(new MySourceFrame(sourceFrame, iterator.getDTM(node), node));
      withSource = true;
    } else {
      withSource = false;
    }
    myDebugger.enter(new XalanStyleFrame(ev, myDebugger.getCurrentFrame(), withSource));
  } finally {
    myTracing = false;
  }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
public TracingSerializationHandler(LocalDebugger debugger, SerializationHandler handler) {
    myDebugger = debugger;
    mySerializationHandler = handler;

//        final URL location = SerializationHandler.class.getProtectionDomain().getCodeSource().getLocation();
//        System.out.println("location = " + location);
  }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/************************************************************************
    * Multiple output document extension.
    * See compiler/TransletOutput for actual implementation.
    ************************************************************************/

   public SerializationHandler openOutputHandler(String filename, boolean append) 
throws TransletException 
   {
try {
    final TransletOutputHandlerFactory factory 
	= TransletOutputHandlerFactory.newInstance();

           String dirStr = new File(filename).getParent();
           if ((null != dirStr) && (dirStr.length() > 0)) {
              File dir = new File(dirStr);
              dir.mkdirs();
           }

    factory.setEncoding(_encoding);
    factory.setOutputMethod(_method);
    factory.setWriter(new FileWriter(filename, append));
    factory.setOutputType(TransletOutputHandlerFactory.STREAM);

    final SerializationHandler handler 
	= factory.getSerializationHandler();

    transferOutputSettings(handler);
    handler.startDocument();
    return handler;
}
catch (Exception e) {
    throw new TransletException(e);
}
   }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
public void closeOutputHandler(SerializationHandler handler) {
try {
    handler.endDocument();
    handler.close();
}
catch (Exception e) {
    // what can you do?
}
   }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
    * Calls transform() with a given output handler
    */
   public final void transform(DOM document, SerializationHandler handler) 
throws TransletException {
       try {
           transform(document, document.getIterator(), handler);
       } finally {
           _keyIndexes = null;
       }
   }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
    * Used by some compiled code as a shortcut for passing strings to the
    * output handler
    */
   public final void characters(final String string,
			 SerializationHandler handler) 
throws TransletException {
       if (string != null) {
          //final int length = string.length();
          try {
              handler.characters(string);
          } catch (Exception e) {
              throw new TransletException(e);
          }
       }   
   }
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Copy an DOM attribute to the created output element, executing
 * attribute templates as need be, and processing the xsl:use
 * attribute.
 *
 * @param handler SerializationHandler to which the attributes are added.
 * @param attr Attribute node to add to SerializationHandler.
 *
 * @throws TransformerException
 */
public static void addAttribute(SerializationHandler handler, int attr)
    throws TransformerException
{

    TransformerImpl transformer =
        (TransformerImpl) handler.getTransformer();
    DTM dtm = transformer.getXPathContext().getDTM(attr);

    if (SerializerUtils.isDefinedNSDecl(handler, attr, dtm))
        return;

    String ns = dtm.getNamespaceURI(attr);

    if (ns == null)
        ns = "";

    // %OPT% ...can I just store the node handle?
    try
    {
        handler.addAttribute(
            ns,
            dtm.getLocalName(attr),
            dtm.getNodeName(attr),
            "CDATA",
            dtm.getNodeValue(attr), false);
    }
    catch (SAXException e)
    {
        // do something?
    }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Given a result tree fragment, walk the tree and
 * output it to the SerializationHandler.
 *
 * @param obj Result tree fragment object
 * @param support XPath context for the result tree fragment
 *
 * @throws org.xml.sax.SAXException
 */
public static void outputResultTreeFragment(
    SerializationHandler handler,
    XObject obj,
    XPathContext support)
    throws org.xml.sax.SAXException
{

    int doc = obj.rtf();
    DTM dtm = support.getDTM(doc);

    if (null != dtm)
    {
        for (int n = dtm.getFirstChild(doc);
            DTM.NULL != n;
            n = dtm.getNextSibling(n))
        {
            handler.flushPending();

            // I think. . . . This used to have a (true) arg
            // to flush prefixes, will that cause problems ???
            if (dtm.getNodeType(n) == DTM.ELEMENT_NODE
                    && dtm.getNamespaceURI(n) == null)
                handler.startPrefixMapping("", "");
            dtm.dispatchToEvents(n, handler);
        }
    }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Construct a node in the result tree.  This method is overloaded by 
 * xsl:attribute. At this class level, this method creates an element.
 *
 * @param nodeName The name of the node, which may be null.
 * @param prefix The prefix for the namespace, which may be null.
 * @param nodeNamespace The namespace of the node, which may be null.
 * @param transformer non-null reference to the the current transform-time state.
 * @param sourceNode non-null reference to the <a href="http://www.w3.org/TR/xslt#dt-current-node">current source node</a>.
 * @param mode reference, which may be null, to the <a href="http://www.w3.org/TR/xslt#modes">current mode</a>.
 *
 * @throws TransformerException
 */
void constructNode(
        String nodeName, String prefix, String nodeNamespace, TransformerImpl transformer)
          throws TransformerException
{

  if(null != nodeName && nodeName.length() > 0)
  {
    SerializationHandler rhandler = transformer.getSerializationHandler();

    // Evaluate the value of this attribute
    String val = transformer.transformToString(this);
    try 
    {
      // Let the result tree handler add the attribute and its String value.
      String localName = QName.getLocalPart(nodeName);
      if(prefix != null && prefix.length() > 0){
          rhandler.addAttribute(nodeNamespace, localName, nodeName, "CDATA", val, true);
      }else{
          rhandler.addAttribute("", localName, nodeName, "CDATA", val, true);
      }
    }
    catch (SAXException e)
    {
    }
  }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Send endPrefixMapping events to the result tree handler
 * for all declared prefix mappings in the stylesheet.
 *
 * @param transformer non-null reference to the the current transform-time state.
 * @param ignorePrefix string prefix to not endPrefixMapping
 * 
 * @throws TransformerException
 */
void unexecuteNSDecls(TransformerImpl transformer, String ignorePrefix) throws TransformerException
{
 
  try
  {
    if (null != m_prefixTable)
    {
      SerializationHandler rhandler = transformer.getResultTreeHandler();
      int n = m_prefixTable.size();

      for (int i = 0; i < n; i++)
      {
        XMLNSDecl decl = (XMLNSDecl) m_prefixTable.get(i);

        if (!decl.getIsExcluded() && !(null != ignorePrefix && decl.getPrefix().equals(ignorePrefix)))
        {
          rhandler.endPrefixMapping(decl.getPrefix());
        }
      }
    }
  }
  catch(org.xml.sax.SAXException se)
  {
    throw new TransformerException(se);
  }
}
 

import org.apache.xml.serializer.SerializationHandler; //导入依赖的package包/类
/**
 * Process the source tree to the output result.
 * @param xmlSource  The input for the source tree.
 * @param outputTarget The output source target.
 * @param shouldRelease  Flag indicating whether to release DTMManager. 
 *
 * @throws TransformerException
 */
public void transform(Source xmlSource, Result outputTarget, boolean shouldRelease)
        throws TransformerException
{

  synchronized (m_reentryGuard)
  {
    SerializationHandler xoh = createSerializationHandler(outputTarget);
    this.setSerializationHandler(xoh);        

    m_outputTarget = outputTarget;

    transform(xmlSource, shouldRelease);
  }
}