Java JAXP, Implementing Default XSLT Behavior in Java

#document DOCUMENT_NODE
  top DOCUMENT_TYPE_NODE
  #comment COMMENT_NODE
  #comment COMMENT_NODE
  dummy-target PROCESSING_INSTRUCTION_NODE
  xml-stylesheet PROCESSING_INSTRUCTION_NODE
  false-target PROCESSING_INSTRUCTION_NODE
  top ELEMENT_NODE
    theData ELEMENT_NODE
        Attribute: attr=Dummy Attr Value
      title ELEMENT_NODE
        #text Java

        subtitle ELEMENT_NODE
            Attribute: position=Low
          #text really
        #text rules

      author ELEMENT_NODE
        #text R.Baldwin
      price ELEMENT_NODE
        #text $9.95
    theData ELEMENT_NODE
      title ELEMENT_NODE
        #text Python
      author ELEMENT_NODE
        #text R.Baldwin
      price ELEMENT_NODE
        #text $15.42
    theData ELEMENT_NODE
      title ELEMENT_NODE
        #text XML
      author ELEMENT_NODE
        #text R.Baldwin
      price ELEMENT_NODE
        #text $19.60

Figure 1

#document DOCUMENT_NODE
  xsl:stylesheet ELEMENT_NODE
      Attribute: xmlns:xsl=http:
                 //www.w3.org/1999/XSL/Transform
      Attribute: version=1.0

    xsl:template ELEMENT_NODE
        Attribute: match=*|/
      xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=text()|@*
      xsl:value-of ELEMENT_NODE
          Attribute: select=.

Figure 2

  <xsl:template match="*|/">
    <xsl:apply-templates/>
  </xsl:template>

Listing 1

  <xsl:template match="text()|@*">
    <xsl:value-of select="."/>
  </xsl:template>

Listing 2

<?xml version="1.0" encoding="UTF-8"?>
Java
reallyrules
R.Baldwin$9.95PythonR.Baldwin$15.42XMLR.Baldwin
$19.60

Figure 3

<title>Java
<subtitle position="Low">really</subtitle>rules
</title>

Listing 3

#document DOCUMENT_NODE
  xsl:stylesheet ELEMENT_NODE
      Attribute: xmlns:xsl=http:
                 //www.w3.org/1999/XSL/Transform
      Attribute: version=1.0

Figure 4

public class Dom11{

  PrintWriter out;//output stream
  //Save processing instruction nodes here
  static Vector procInstr = new Vector();

  public static void main(String argv[]){
    if (argv.length != 3){
      System.err.println(
        "usage: java Dom11 "
        + "xmlFileIn "
        + "xformFileOut "
        + "codeFileOut");
      System.exit(0);
    }//end if

Listing 4

    try{
      //Get a factory object for DocumentBuilder
      // objects
      DocumentBuilderFactory factory =
            DocumentBuilderFactory.newInstance();

      //Configure the factory object.  Change
      // the following parameter to false for a
      // non-validating parser.
      factory.setValidating(true);
      factory.setNamespaceAware(false);
      //The following statement causes the parser
      // to ignore cosmetic whitespace between
      // elements.
      factory.
       setIgnoringElementContentWhitespace(true);

      //Get a DocumentBuilder (parser) object
      DocumentBuilder builder =
                    factory.newDocumentBuilder();

      //Parse the XML input file to create a
      // Document object that represents the
      // input XML file.
      Document document = builder.parse(
                              new File(argv[0]));

Listing 5

      Dom11 thisObj = new Dom11();

      thisObj.out = new PrintWriter(
                  new FileOutputStream(argv[2]));

Listing 6

      thisObj.processDocumentNode(document);

Listing 7

  void processDocumentNode(Node node){
    //Write one line of text into the output.
    out.println("<?xml version=\"1.0\" "
                       + "encoding=\"UTF-8\"?>");

    processNode(node);

    out.flush();
  }//end processDocumentNode

Listing 8

  void processNode(Node node){

    try{
      if (node == null){
        System.err.println(
                  "Nothing to do, node is null");
        return;
      }//end if

      //Process the incoming node based on its
      // type.
      int type = node.getNodeType();


Listing 9

      switch (type){
        case Node.DOCUMENT_NODE:{
          if(false){
            //cannot be reached in this example
          }else{//invoke default behavior
            defElOrRtNodeTemp(node);
          }//end else
          break;
        }//end case DOCUMENT_NODE

Listing 10

        case Node.ELEMENT_NODE:{
          if(false){
            //unreachable in this example
          }else{//invoke default behavior
            defElOrRtNodeTemp(node);
          }//end else
          break;
        }//end case ELEMENT_NODE

Listing 11

  void defElOrRtNodeTemp(Node node)
                                throws Exception{
    int nodeType = node.getNodeType();
    if((nodeType == Node.ELEMENT_NODE) ||
               (nodeType == Node.DOCUMENT_NODE)){

      applyTemplates(node,null);
    }else{
      throw new Exception(
                "Bad call to defElOrRtNodeTemp");
    }//end else
  }//end defElOrRtNodeTemp

Listing 12

  <xsl:template match="*|/">
    <xsl:apply-templates/>
  </xsl:template>

Figure 5

  void applyTemplates(Node node,String select){
    NodeList children = node.getChildNodes();
    if (children != null){
      int len = children.getLength();
      //Iterate on NodeList of child nodes.
      for (int i = 0; i < len; i++){
        if((select == null) ||
              (select.equals(children.item(i).
                                getNodeName()))){

          //Recursive method call
          processNode(children.item(i));

        }//end if
      }//end for loop
    }//end if children != null

  }//end applyTemplates

Listing 13

<xsl:apply-templates
  optional attribute select="..."
  optional attribute mode="..."
/>

Figure 6

        case Node.TEXT_NODE:{
          if(false){
            //unreachable in this program
          }else{//invoke default behavior
            out.print(defTextOrAttrTemp(node));
          }//end else
          break;
        }//end case Node.TEXT_NODE

        case Node.ATTRIBUTE_NODE:{
          if(false){
            //unreachable in this program
          }else{//invoke default behavior
            out.print(defTextOrAttrTemp(node));
          }//end else
          break;
        }//end case Node.ATTRIBUTE_NODE

Listing 14

  String defTextOrAttrTemp(Node node)
                                throws Exception{
    int nodeType = node.getNodeType();
    if((nodeType == Node.ATTRIBUTE_NODE)
                || (nodeType == Node.TEXT_NODE)){

      //Get and return value of context node.
      return valueOf(node,".");
    }else{
      throw new Exception(
         "Bad call to defaultTextOrAttr method");
    }//end else
  }//end defaultTextOrAttr

Listing 15

  <xsl:template match="text()|@*">
    <xsl:value-of select="."/>
  </xsl:template>

Figure 7

  public String valueOf(Node node,String select){

    //code deleted for brevity

    else if(select != null
                          && select.equals(".")){

      int nodeType = node.getNodeType();
      if(nodeType == Node.ELEMENT_NODE){
        //Process the context node as an element
        // node.

Listing 16

        NodeList childNodes =
                            node.getChildNodes();
        int listLen = childNodes.getLength();

        String nodeTextValue = "";//result

Listing 17

        for(int j = 0; j < listLen; j++){
          nodeTextValue +=
               valueOf(childNodes.item(j),".");
        }//end for loop

        return nodeTextValue;

Listing 18

      }else if(nodeType == Node.TEXT_NODE){
        return node.getNodeValue();

Listing 19

      }else{
        //ignore all other context node types
      }//end else
    }//end if for context node

    //code deleted for brevity

    return "";//empty string
  }//end method valueOf

Listing 20

        case Node.COMMENT_NODE:{
          if(false){
            //unreachable in this program
          }else{//invoke default behavior
            defComOrProcInstrTemp(node);
          }//end else
          break;
        }//end case COMMENT_NODE

        case Node.PROCESSING_INSTRUCTION_NODE:{
          if(false){
            //unreachable in this program
          }else{//invoke default behavior
            //First save proc instr for later
            // use.
            procInstr.add(node);
            //Now invoke default behavior.
            defComOrProcInstrTemp(node);
          }//end else
          break;
        }//end case PROCESSING_INSTRUCTION_NODE

Listing 21

<?dummy-target dummy-data="def"?>
<?xml-stylesheet 
  type="text/xsl" href="Dom11.xsl"?>
<?false-target false-data="ghi"?>

Listing 22

  String defComOrProcInstrTemp(Node node)
                                throws Exception{
    int nodeType = node.getNodeType();
    if((nodeType == Node.COMMENT_NODE) ||
            (nodeType ==
              Node.PROCESSING_INSTRUCTION_NODE)){

      return "";//empty string
    }else{
      throw new Exception("Bad call to " +
            "defalutCommentOrProcInstrTemplate");
    }//end else
  }//end defComOrProcInstrTemp

Listing 23

<xsl:template
  match="processing-instruction()|comment()"

Figure 8

        default:{
          //Ignore all other node types.
        }//end default

      }//end switch

Listing 24

      thisObj.doXslTransform(
                     document,argv[1],procInstr);

Listing 25

  void doXslTransform(Document document,
                      String outFile,
                      Vector procInstr)
                                throws Exception{
    try{
      //Get stylesheet ID from proc instr.
      ProcessingInstruction pi = null;
      boolean piFlag = false;
      int size = procInstr.size();

      //Search for a stylesheet in the Vector
      // containing processing instruction nodes.
      for(int i = 0; i < size; i++){
        pi = (ProcessingInstruction)procInstr.
                                          get(i);
        if(pi.getTarget().startsWith(
               "xml-stylesheet") && pi.getData().
                startsWith("type=\"text/xsl\"")){
          //Looks like a good stylesheet.
          piFlag = true;
          break;
        }//end if
      }//end for loop
      if(piFlag == false){//still false?
        throw new Exception(
                          "No valid stylesheet");
      }//end if

Listing 26

<?xml-stylesheet 
  type="text/xsl" href="Dom11.xsl"?>

Figure 9

      String xslFile = pi.getData().
                  substring(pi.getData().indexOf(
                                     "href=")+6);
      //Eliminate the quotation mark at the end
      xslFile = xslFile.substring(
                           0,xslFile.length()-1);

Listing 27

      //Get a TransformerFactory object
      TransformerFactory xformFactory =
                TransformerFactory.newInstance();

      //Get an XSL Transformer object based on
      // the XSL file discovered above.
      Transformer transformer =
                     xformFactory.newTransformer(
                         new StreamSource(
                             new File(xslFile)));

      //Get a DOMSource object that represents
      // the DOM tree.
      DOMSource source = new DOMSource(document);

      //Get an output stream for the output
      // file.
      PrintWriter xformStream = new PrintWriter(
                  new FileOutputStream(outFile));

      //Get a StreamResult object that points to
      // the output file.  Then transform the DOM
      // sending text to the output file.
      StreamResult xformResult =
                   new StreamResult(xformStream);

      //Do the transform
      transformer.transform(source,xformResult);
    }catch(Exception e){
      e.printStackTrace(System.err);
    }//end catch

  }//end doXslTransform

Listing 28

<?xml version="1.0"?>

<!DOCTYPE top [
<!ELEMENT top (theData)*>
<!ELEMENT theData (title,author,price)*>
<!ELEMENT title (#PCDATA | subtitle)*>
<!ELEMENT author (#PCDATA)>
<!ELEMENT price (#PCDATA)>
<!ELEMENT subtitle (#PCDATA)>
<!ATTLIST theData attr CDATA #IMPLIED>
<!ATTLIST subtitle position CDATA #IMPLIED>
]>

<!-- File Dom11.xml
Copyright 2003 R. G. Baldwin
Illustrates built-in template rules.
-->

<!--Two of the following proc instr were included
to test the ability of the program to find the
actual stylesheet proc instr.-->
<?dummy-target dummy-data="def"?>
<?xml-stylesheet 
  type="text/xsl" href="Dom11.xsl"?>
<?false-target false-data="ghi"?>

<top>

<theData attr="Dummy Attr Value">
<title>Java
<subtitle position="Low">really</subtitle>rules
</title>
<author>R.Baldwin</author>
<price>$9.95</price>
</theData>

<theData>
<title>Python</title>
<author>R.Baldwin</author>
<price>$15.42</price>
</theData>

<theData>
<title>XML</title>
<author>R.Baldwin</author>
<price>$19.60</price>
</theData>

</top>

Listing 29

<?xml version='1.0'?>
<!-- File Dom11.xsl
Copyright 2003 R. G. Baldwin
Illustrates extraction of text from an XML file.

This version specifies a template rule that
guarantees that the root and all child nodes
are processed.

It also specifies a template rule that copies
the value of text and attribute nodes into the
output.  However, attribute nodes are not copied.
See Nutshell page 147 for the reason.
-->
<xsl:stylesheet 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">

  <!--According to Nutshell, this matches a
  default template.-->
  <xsl:template match="*|/">
    <xsl:apply-templates/>
  </xsl:template>
  
  <!--According to Nutshell, this matches a
  default template.-->
  <xsl:template match="text()|@*">
    <xsl:value-of select="."/>
  </xsl:template>

</xsl:stylesheet>

Listing 30

/*File Dom11.java
Copyright 2003 R.G.Baldwin

This program implements all six built-in default
template rules for an XML processor.  In
addition, it implements a couple of other
template rules that are required to support
the built-in rules, such as xsl:value-of.

As such, the program serves as the skeleton for
the definition of custom template rules.

To create a custom temtlate rule:
1.  Go to the processNode method.
2.  Identify the node type.
3.  Change the conditional clause in the if
    statement to implement the match.
4.  Write code in the body of the if statement to
    implement the custom rule.

If the modified conditional clause evaluates to
true, the custom rule will be executed.  If
false,the default rule will be executed.

As written, this program extracts and
concatenates all text values from a specified
XML file, and writes that text into a result
file, using two different approaches:

1. An XSLT style sheet and transformation.
2. Program code that emulates the behavior of the
   XSL transformation.

In particular, this program illustrates Java code
that emulates the XSLT templates in the files
named Dom11.xsl and Dom11.xsl.  These two XSL
files differ in terms of their dependence on the
built-in templates.

Dom11.xsl explicitly includes template rules that
replicate the built-in rules for text, nodes, and
documents.

Dom11.xsl doesn't explicitly include any
template rules, but depends entirely on built-in
rules for proper operation.

Both XSL files produce the same result when
processed against the XML files named Doc11.xml
and Dom11.xml, demonstrating the behavior of
the built-in template rules.

The execution of these template rules causes the
explicit template rules, or the built-in template
rules to be executed on every node, thereby
causing the contents of every text node to be
concatenated and written into the result file.


The program requires three command line
parameters in the following order:
1, The name of the input XML file - must be
   Dom11.xml or Dom11.xml.
2. The name of the output file to be
   produced by the XSL transformation.
3. The name of the output file to be
   produced by the program code that emulates
   the XSL transformation.

The name of the XSL stylesheet file is extracted
from the processing instruction in the XML file.

The program begins by executing code to transform
the incoming XML file in a way that mimics the
XSL Transformation.  Along the way, it saves the
processing instructions containing the ID of the
stylesheet file for use by the XSLT process
later.  Otherwise, the code that performs the
XSL transformation later would have to search the
DOM tree for the XSL stylesheet file.

Then the program uses the XSLT style sheet to
transform the XML file into a result file.

No effort was made to provide meaningful
information about errors and exceptions.

Tested with SDK 1.4.2 under WinXP.
************************************************/

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;

import org.w3c.dom.*;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.*;

import java.util.*;
import java.io.*;

public class Dom11{

  PrintWriter out;//output stream
  //Save processing instruction nodes here
  static Vector procInstr = new Vector();

  public static void main(String argv[]){
    if (argv.length != 3){
      System.err.println(
        "usage: java Dom11 "
        + "xmlFileIn "
        + "xformFileOut "
        + "codeFileOut");
      System.exit(0);
    }//end if

    try{
      //Get a factory object for DocumentBuilder
      // objects
      ///
      DocumentBuilderFactory factory =
            DocumentBuilderFactory.newInstance();

      //Configure the factory object.  Change
      // the following parameter to false for a
      // non-validating parser.
      ///
      factory.setValidating(true);
      factory.setNamespaceAware(false);
      //The following statement causes the parser
      // to ignore cosmetic whitespace between
      // elements.
      ///
      factory.
       setIgnoringElementContentWhitespace(true);

      //Get a DocumentBuilder (parser) object
      ///
      DocumentBuilder builder =
                    factory.newDocumentBuilder();

      //Parse the XML input file to create a
      // Document object that represents the
      // input XML file.
      ///
      Document document = builder.parse(
                              new File(argv[0]));

      //Instantiate an object of this class
      ///
      Dom11 thisObj = new Dom11();

      //TRANSFORMATION THROUGH PROGRAM CODE
      //Use program code to transform the
      // DOM tree into an output file.
      //
      //Get an output stream for the output
      // produced by the program code.  This
      // stream object is used by several
      // methods, so it was instantiated at this
      // point and saved as an instance variable
      // of the object.
      ///
      thisObj.out = new PrintWriter(
                  new FileOutputStream(argv[2]));

      //Process the DOM tree, beginning with the
      // Document node to produce the output.
      // Invocation of processDocumentNode starts
      // a recursive process that processes the
      // entire DOM tree.
      ///
      thisObj.processDocumentNode(document);


      //XSLT TRANSFORMATION
      //Use XSLT to transform the DOM tree into
      // an output file.  Note that the success
      // of this method call depends on the
      // stylesheet processing instruction having
      // been saved while the transformation was
      // being performed using program code
      // above.  Otherwise, it would be necessary
      // to include the code in this method to
      // search the DOM tree for the stylesheet
      // processing instruction. All processing
      // instructions are saved in a Vector
      // object, which is passed as the third
      // parameter to this method.
      ///
      thisObj.doXslTransform(
                     document,argv[1],procInstr);

    }catch(Exception e){
      //Note that no effort was made to provide
      // meaningful results in the event of an
      // exception or error.
      ///
      e.printStackTrace(System.err);
    }//end catch
  }// end main()
  //-------------------------------------------//

  //This method is used to produce any text
  // required in the output at the document
  // level, such as the XML declaration for an
  // XML document.
  ///
  void processDocumentNode(Node node){
    //Write one line of text into the output.
    ///
    out.println("<?xml version=\"1.0\" "
                       + "encoding=\"UTF-8\"?>");

    //Go process the root (document) node. This
    // method call triggers a recursive process
    // that processes the entire DOM tree.
    ///
    processNode(node);

    out.flush();
  }//end processDocumentNode
  //-------------------------------------------//

  //There are seven kinds of nodes:
  // root or document
  // element
  // attribute
  // text
  // comment
  // processing instruction
  // namespace
  //
  //This method handles the first six.
  // Apparently it is not possible to handle
  // namespace nodes in Java because there is
  // no constant in the Node class to identify
  // namespace nodes
  ///
  void processNode(Node node){

    try{
      if (node == null){
        System.err.println(
                  "Nothing to do, node is null");
        return;
      }//end if

      //Process the incoming node based on its
      // type.
      ///
      int type = node.getNodeType();

      //To define an overriding template rule,
      // insert the matching condition in the
      // conditional clause of the if statement,
      // and provide code to implement the rule
      // in the body of the if statement.  If the
      // conditional clause evaluates to true,
      // the default rule for that element type
      // will not be processed.
      ///
      switch (type){
        case Node.TEXT_NODE:{
          if(false){
            //Change conditional and write
            // overriding handler here
            ///
          }else{//invoke default behavior
            out.print(defTextOrAttrTemp(node));
          }//end else
          break;
        }//end case Node.TEXT_NODE

        case Node.ATTRIBUTE_NODE:{
          if(false){
            //Change conditional and write
            // overriding handler here
            ///
          }else{//invoke default behavior
            out.print(defTextOrAttrTemp(node));
          }//end else
          break;
        }//end case Node.ATTRIBUTE_NODE

        case Node.ELEMENT_NODE:{
          if(false){
            //Change conditional and write
            // overriding handler here
            ///
          }else{//invoke default behavior
            defElOrRtNodeTemp(node);
          }//end else
          break;
        }//end case ELEMENT_NODE

        case Node.DOCUMENT_NODE:{
          if(false){
            //Change conditional and write
            // overriding handler here
            ///
          }else{//invoke default behavior
            defElOrRtNodeTemp(node);
          }//end else
          break;
        }//end case DOCUMENT_NODE

        case Node.COMMENT_NODE:{
          if(false){
            //Change conditional and write
            // overriding handler here
            ///
          }else{//invoke default behavior
            defComOrProcInstrTemp(node);
          }//end else
          break;
        }//end case COMMENT_NODE

        case Node.PROCESSING_INSTRUCTION_NODE:{
          if(false){
            //Change conditional and write
            // overriding handler here
            ///
            //Save proc instr for later use
            procInstr.add(node);
          }else{//invoke default behavior
            //First save proc instr for later
            // use.
            ///
            procInstr.add(node);
            //Now invoke default behavior.
            ///
            defComOrProcInstrTemp(node);
          }//end else
          break;
        }//end case PROCESSING_INSTRUCTION_NODE

        default:{
          //Ignore all other node types.
        }//end default

      }//end switch

    }catch(Exception e){
      e.printStackTrace(System.err);
    }//end catch
  }//end processNode(Node)
  //-------------------------------------------//

  //This method emulates the following default
  // template rule:
  //  <xsl:template match="text()|@*">
  //   <xsl:value-of select="."/>
  //  </xsl:template>
  ///
  String defTextOrAttrTemp(Node node)
                                throws Exception{
    int nodeType = node.getNodeType();
    if((nodeType == Node.ATTRIBUTE_NODE)
                || (nodeType == Node.TEXT_NODE)){
      //Get and return the value of the context
      // node.
      ///
      return valueOf(node,".");
    }else{
      throw new Exception(
         "Bad call to defaultTextOrAttr method");
    }//end else
  }//end defaultTextOrAttr
  //-------------------------------------------//

  //This method emulates the following default
  // template rule:
  //  <xsl:template match="*|/">
  //   <xsl:apply-templates/>
  //  </xsl:template>
  ///
  void defElOrRtNodeTemp(Node node)
                                throws Exception{
    int nodeType = node.getNodeType();
    if((nodeType == Node.ELEMENT_NODE) ||
               (nodeType == Node.DOCUMENT_NODE)){
      //Note that the following is a recursive
      // method call.
      ///
      applyTemplates(node,null);
    }else{
      throw new Exception(
                "Bad call to defElOrRtNodeTemp");
    }//end else
  }//end defElOrRtNodeTemp
  //-------------------------------------------//

  //This method emulates the following default
  // template rule:
  // <xsl:template
  //   match="processing-instruction()|comment()"
  ///
  String defComOrProcInstrTemp(Node node)
                                throws Exception{
    int nodeType = node.getNodeType();
    if((nodeType == Node.COMMENT_NODE) ||
            (nodeType ==
              Node.PROCESSING_INSTRUCTION_NODE)){
      //According to page Nutshell pg 148, the
      // default rule for comments and processing
      // instructions doesn't output anything
      // into the result tree.
      ///
      return "";//empty string
    }else{
      throw new Exception("Bad call to " +
            "defalutCommentOrProcInstrTemplate");
    }//end else
  }//end defComOrProcInstrTemp
  //-------------------------------------------//

  //See Nutshell, pg 148 for an explanation as to
  // why it is not possible to write a Java
  // method that emulates the default namespace
  // template.
  ///
  void defaultNamespaceTemplate(Node node)
                                throws Exception{
    throw new Exception("See Nutshell pg 148" +
              "regarding default behavior for " +
              "namespace template.");
  }//end defaultNamespaceTemplate
  //-------------------------------------------//

  //Simulates an XSLT apply-templates rule.
  //  <xsl:apply-templates
  //    optional select = "..."
  //    optional mode = "..."
  //   >
  //Note that the mode attribute is not supported
  // in this version.
  //If the select parameter is null, all child
  // nodes are processed.
  void applyTemplates(Node node,String select){
    NodeList children = node.getChildNodes();
    if (children != null){
      int len = children.getLength();
      //Iterate on NodeList of child nodes.
      for (int i = 0; i < len; i++){
        if((select == null) ||
              (select.equals(children.item(i).
                                getNodeName()))){
          //Note that the following is a
          // recursive method call.
          ///
          processNode(children.item(i));
        }//end if
      }//end for loop
    }//end if children != null

  }//end applyTemplates
  //-------------------------------------------//

  //This method simulates an XSLT
  //   <xsl:value-of select="???"/>
  // The general form of the method call is
  //   valueOf(Node theNode,String select)
  //
  //The method recognizes three forms of call:
  //  valueOf(Node theNode,String "@attrName")
  //  valueOf(Node theNode,String ".")
  //  valueOf(Node theNode,String "nodeName")
  //
  //In the first form, the method returns the
  // text value of the named attribute of
  // theNode.  An attribute is specified by a
  // select value that begins with @.  If the
  // attribute doesn't exist, the method returns
  // an empty string.
  //
  //In the second form, the method returns the
  // concatenated text values of descendants of
  // the context node.
  //
  //In the third form, the method returns the
  // concatenated text values of all descendants
  // of a specified child node of the context
  // node.  If the context node has more than one
  // child node with the specified name, only the
  // first one found is processed.  The others
  // are ignored.
  //
  //The method does not support the following,
  // which are standard features of xsl:value-of:
  //   disable-output-escaping
  //   processing instruction nodes
  //   comment nodes
  //   namespace nodes
  ///

  public String valueOf(Node node,String select){

    if(select != null
                     && select.charAt(0) == '@'){
      //This is a request for the value of an
      // attribute. Returns empty string if the
      // attribute doesn't exist on the element.
      String attrName = select.substring(1);
      NamedNodeMap attrList =
                            node.getAttributes();
      Node attrNode = attrList.getNamedItem(
                                       attrName);
      if(attrNode != null){
        return attrNode.getNodeValue();
      }else{
        return "";//empty string
      }//end else
    }//end if on @

    else if(select != null
                          && select.equals(".")){
      //This is a request to process the context
      // node
      int nodeType = node.getNodeType();
      if(nodeType == Node.ELEMENT_NODE){
        //Process the context node as an element
        // node.  Return the concatenated text
        // values of all descendants of the
        // context node.
        NodeList childNodes =
                            node.getChildNodes();
        int listLen = childNodes.getLength();
        String nodeTextValue = "";//result

        for(int j = 0; j < listLen; j++){
          nodeTextValue +=
               valueOf(childNodes.item(j),".");
        }//end for loop
        return nodeTextValue;
      }else if(nodeType == Node.TEXT_NODE){
        //Process the context node as a text
        // node.  Simply get and return its
        // value.
        return node.getNodeValue();
      }else{
        //ignore all other context node types
      }//end else
    }//end if for context node

    else if(select != null){
      //Process a child node whose name is
      // specified by the value of the incoming
      // parameter named select.  Get and return
      // the concatenated text values of all
      // descendants of the specified child node.
      //This process assumes that there is only
      // one child node with the specified name
      // and processes the first one that it
      // finds.
      NodeList children = node.getChildNodes();
      int len = children.getLength();
      for (int i = 0; i < len; i++){
        //Trap the specified child node
        if(children.item(i).getNodeName().
                                 equals(select)){
          //Make a recursive call and let
          // existing code do the work.
          return valueOf(children.item(i),".");
          //The above return statement causes any
          // additional child nodes having the
          // same name to be ignored.
        }//end if getNodeName == select
      }//end for loop on all child nodes
    }//end else if(select != null)
    //Will reach here only if value of select
    // is null.
    ///
    return "";//empty string
  }//end method valueOf
  //-------------------------------------------//

  //This method uses an incoming XSLT stylesheet
  // file to transform an incoming Document
  // object into an output file.  Note that the
  // successful invocation of this method depends
  // on the processing instruction containing the
  // stylesheet having been saved in a Vector
  // object that is received as an incoming
  // parameter.  Otherwise, this method would
  // have to search the DOM for the stylesheet
  // processing instruction.
  ///
  void doXslTransform(Document document,
                      String outFile,
                      Vector procInstr)
                                throws Exception{
    try{
      //Get stylesheet ID from proc instr.
      ProcessingInstruction pi = null;
      boolean piFlag = false;
      int size = procInstr.size();
      //Search for a stylesheet in the Vector
      // containing processing instruction nodes.
      ///
      for(int i = 0; i < size; i++){
        pi = (ProcessingInstruction)procInstr.
                                          get(i);
        if(pi.getTarget().startsWith(
               "xml-stylesheet") && pi.getData().
                startsWith("type=\"text/xsl\"")){
          //Looks like a good stylesheet.
          ///
          piFlag = true;
          break;
        }//end if
      }//end for loop
      if(piFlag == false){//still false?
        throw new Exception(
                          "No valid stylesheet");
      }//end if
      //Get the stylesheet file reference
      ///
      String xslFile = pi.getData().
                  substring(pi.getData().indexOf(
                                     "href=")+6);
      //Eliminate the quotation mark at the end
      ///
      xslFile = xslFile.substring(
                           0,xslFile.length()-1);

      //Get a TransformerFactory object
      ///
      TransformerFactory xformFactory =
                TransformerFactory.newInstance();
      //Get an XSL Transformer object based on
      // the XSL file discovered above.
      ///
      Transformer transformer =
                     xformFactory.newTransformer(
                         new StreamSource(
                             new File(xslFile)));
      //Get a DOMSource object that represents
      // the DOM tree.
      ///
      DOMSource source = new DOMSource(document);

      //Get an output stream for the output
      // file.
      ///
      PrintWriter xformStream = new PrintWriter(
                  new FileOutputStream(outFile));

      //Get a StreamResult object that points to
      // the output file.  Then transform the DOM
      // sending text to the output file.
      ///
      StreamResult xformResult =
                   new StreamResult(xformStream);

      //Do the transform
      ///
      transformer.transform(source,xformResult);
    }catch(Exception e){
      e.printStackTrace(System.err);
    }//end catch

  }//end doXslTransform

}// class Dom11

Listing 31

<?xml version="1.0"?>

<!DOCTYPE top [
<!ELEMENT top (theData)*>
<!ELEMENT theData (title,author,price)*>
<!ELEMENT title (#PCDATA | subtitle)*>
<!ELEMENT author (#PCDATA)>
<!ELEMENT price (#PCDATA)>
<!ELEMENT subtitle (#PCDATA)>
<!ATTLIST theData attr CDATA #IMPLIED>
<!ATTLIST subtitle position CDATA #IMPLIED>
]>

<!-- File Dom11a.xml
Copyright 2003 R. G. Baldwin
Illustrates built-in template rules.
Same as Dom11.xml except for stylesheet 
specification.
-->

<!--Two of the following proc instr were included
to test the ability of the program to find the
actual stylesheet proc instr.-->
<?dummy-target dummy-data="def"?>
<?xml-stylesheet 
  type="text/xsl" href="Dom11a.xsl"?>
<?false-target false-data="ghi"?>

<top>

<theData attr="Dummy Attr Value">
<title>Java
<subtitle position="Low">really</subtitle>rules
</title>
<author>R.Baldwin</author>
<price>$9.95</price>
</theData>

<theData>
<title>Python</title>
<author>R.Baldwin</author>
<price>$15.42</price>
</theData>

<theData>
<title>XML</title>
<author>R.Baldwin</author>
<price>$19.60</price>
</theData>

</top>

Listing 32

<?xml version='1.0'?>
<!-- File Dom11a.xsl
Copyright 2003 R. G. Baldwin
Illustrates extraction of text from an XML file.

This version accepts a built-in template rule 
that guarantees that the root and all child nodes
are processed.

It also accepts the built-in template rule
that copies the value of text and attribute nodes
into the output.  However, attribute nodes are
not copied.  See Nutshell page 147 for the 
reason.

As a result, the stylesheet is completely
empty.
-->
<xsl:stylesheet 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">

</xsl:stylesheet>

Listing 33