-o <output>
   Specifies the name of the generated translet class.
   If you omit this argument, the translet class is
   named <stylesheet>. Translets are written as 
   .class files.

-d <directory>
   Specifies the destination directory. If you omit
   this argument, the translet class files are placed
   in the current working directory.

-j <jarfile>
   Outputs the generated translet class files into a 
   jar file named <jarfile>.jar. When this option is 
   used, only the jar file is output.

-p <package name>
   Specifies a package name for the generated translet
   classes.

-n Enables template inlining (default behavior better on average).

-x Turns on additional debugging messages.

-s Disables calling System.exit

-u  <stylesheet>
  Specifies the stylesheet with a URI such as 
  'http://myserver/stylesheet1.xsl'.

   <stylesheet>
   (No flag) The pathname of the stylesheet file.

-i Force input to be read from stdin

-v Prints version of compiler

-h Prints usage statement

-j Specifies <jarfile> from which to load translet.

-x Turns on debugging messages.

-s Disables calling System.exit

-u Specifies the XML input <document> with a URI,
   such as 'http://myserver/hamlet.xml'.		

Arguments wirhout flags:

   <document>     		
   Filename of the XML input document. 
   
   <document_url>     	
   URI of the XML input document (see the -u flag above). 

   <class>
   The translet that performs the transformation. The translet
   may take a set of stylesheet parameters specified as
   name-value pairs. The format for a name-value pair is
   <name>=<value>.

import java.util.Properties;
import javax.xml.transform.Transformer;
import java.io.FileOutputStream;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Templates;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
...
// Set the TransformerFactory system property.
// Note: For more flexibility, load properties from a properties file.
String key = "javax.xml.transform.TransformerFactory";
String value = "org.apache.xalan.xsltc.trax.TransformerFactoryImpl";
Properties props = System.getProperties();
props.put(key, value);
System.setProperties(props);
...
String xslInURI;
// Instantiate the TransformerFactory, and use it along with a SteamSource
// XSL stylesheet to create a translet as a Templates object.
TransformerFactory tFactory = TransformerFactory.newInstance();
Templates translet = tFactory.newTemplates(new StreamSource(xslInURI));
...
String xmlInURI;
String htmlOutURI;
...
// For each transformation, instantiate a new Transformer, and perform
// the transformation from a StreamSource to a StreamResult;
Transformer transformer = translet.newTransformer();
transformer.transform(new StreamSource(xmlInURI),
                      new StreamResult(new FileOutputStream(htmlOutURI)));
...

import java.util.Properties;
import javax.xml.transform.TransformerFactory;
import java.io.FileOutputStream;
import javax.xml.transform.Transformer;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
...
// Set the TransformerFactory system property.
// Note: For more flexibility, load properties from a properties file.
String key = "javax.xml.transform.TransformerFactory";
String value = "org.apache.xalan.xsltc.trax.TransformerFactoryImpl";
Properties props = System.getProperties();
props.put(key, value);
System.setProperties(props);
...
String xslInURI;
String xmlInURI;
String htmlOutURI;
// Instantiate the TransformerFactory, and use it along with a SteamSource
// XSL stylesheet to create a Transformer.
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer(new StreamSource(xslInURI));
// Perform the transformation from a StreamSource to a StreamResult;
transformer.transform(new StreamSource(xmlInURI),
                      new StreamResult(new FileOutputStream(htmlOutURI)));

import org.apache.xalan.xsltc.Translet;
import org.apache.xalan.xsltc.dom.DOMImpl;

public class XsltApp {
  public static void main(String[] args) {
    XsltApp proc = new XsltApp();
    proc.run(args);
  }

  public void run(String[] args) {
    if (args.length != 2) {
      System.err.println("Usage:\n\tprocessor <xmlfile> <xslfile>" +
            "\n\n\twhere <xmlfile> = xml input filename, and" +
            "\n\t      <xslfile> = stylesheet filename.");
      System.exit(1);
    }
    String xmldocFilename     = args[0];
    String stylesheetFilename = args[1];

    // Compile the stylesheet to a translet
    Translet translet = compileStylesheet(stylesheetFilename);

    // Parse the input XML document
    DOMImpl dom = getDOM(xmldocFilename);

    // Transform the XML document against the translet
    doTransform(translet, dom);
    System.exit(0);
  }
  
  // compile the stylesheet [Empty shell: see below]
  private Translet compileStylesheet(String stylesheetName) { return null; }

  // parse the input XML document [Empty shell: see below]
  private DOMImpl getDOM(String xmldocname) { return null; }

  // transform the XML document [Empty shell: see below]
  private void doTransform(Translet translet, DOMImpl dom) { }
}

import java.io.File;
import java.net.MalformedURLException; 
import org.apache.xalan.xsltc.compiler.XSLTC;
...
  private Translet compileStylesheet(String stylesheetName) {
    Translet retval = null;
    String transletName = stylesheetName.substring(0,
                              stylesheetName.indexOf('.'));
    try {
      XSLTC xsltc = new XSLTC();
      xsltc.init();
      File stylesheet = new File(stylesheetName);
      xsltc.compile(stylesheet.toURL());
      Class clazz = Class.forName(transletName);
      retval = (Translet)clazz.newInstance();
    } 
    catch (MalformedURLException e) {
      System.err.println("Could not create URL to stylesheet file: " +
                          stylesheetName + ".\n" + e.getMessage());
      System.exit(1);
    } 
    catch (ClassNotFoundException e) {
      System.err.println("Could not find class file: " +
                          transletName + ".class .\n" + e.getMessage());
      System.exit(1);
    } 
    catch (InstantiationException e) {
      System.err.println("Could not instantiate class file: " +
                          transletName + ".class .\n" + e.getMessage());
      System.exit(1);
    } 
    catch (IllegalAccessException e) {
      System.err.println("Could not instantiate class file: " +
            transletName + ".class, illegal access.\n" + e.getMessage());
      System.exit(1);
    }
    return retval;
  }

import java.io.IOException;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.xalan.xsltc.compiler.Constants;
import org.apache.xalan.xsltc.dom.DTDMonitor;
import org.xml.sax.XMLReader;
import org.xml.sax.SAXException;
...
  private DTDMonitor _dtdMonitor = null;

  private DOMImpl getDOM(String xmldocname) {
    final SAXParserFactory factory = SAXParserFactory.newInstance();
    try {
      factory.setFeature(Constants.NAMESPACE_FEATURE, true);
    } 
    catch (Exception e) {
      factory.setNamespaceAware(true);
    }
    final DOMImpl dom = new DOMImpl();
    dom.setDocumentURI(xmldocname);
    XMLReader reader = null;
    SAXParser parser = null;
    _dtdMonitor = new DTDMonitor();
    try {
      parser = factory.newSAXParser();
      reader = parser.getXMLReader();
      reader.setContentHandler(dom.getBuilder());
      _dtdMonitor.handleDTD(reader);
      reader.parse(xmldocname);
    } 
    catch (ParserConfigurationException e) {
      System.err.println("SAX Parser is not configured properly.\n"+
                          e.getMessage());
      System.exit(1);
    } 
    catch (SAXException e ) {
      System.err.println("SAX Parser could not be created.\n"+
                          e.getMessage());
      System.exit(1);
    } 
    catch (IOException e ) {
      System.err.println("XML Reader could not read xml document '"+
                          xmldocname + "'," + e.getMessage());
      System.exit(1);
    }
    return dom;
  }

import java.io.IOException;
import org.apache.xalan.xsltc.runtime.DefaultSAXOutputHandler;
import org.apache.xalan.xsltc.runtime.TextOutput;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import org.apache.xalan.xsltc.TransletException;
...
  private void doTransform(Translet translet, DOMImpl dom) {
    DefaultSAXOutputHandler outputhandlr = null;
    TextOutput textoutput = null;
    try {
      outputhandlr= new DefaultSAXOutputHandler(System.out, "utf-8");
      textoutput = new TextOutput(outputhandlr, "utf-8");
    } 
    catch (IOException e) {
      System.err.println("Could not create SAX Output Handler."+
                          e.getMessage());
      System.exit(1);
    }
  
    // for XSL keys
    AbstractTranslet absTranslet = (AbstractTranslet)translet;
    absTranslet.setIndexSize(dom.getSize());
    _dtdMonitor.buildIdIndex(dom, 0, absTranslet);

    try {
      absTranslet.transform(dom, textoutput);
    } 
    catch (TransletException e) {
      System.err.println("Could not transform XML document."+
                          e.getMessage());
      System.exit(1);
    }
  }