codetransformer.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

/*
 *
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 *
 */

/**
 * Transforms an XML file according to given XSL file.
 */
package com.sun.xml.transform;

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

import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.w3c.dom.*;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
import org.xml.sax.SAXException;

/**
 * Represents transformation
 */
class Transformation {
    /** XML file name to apply transformation to */
    public String xmlFileName = "";

    /** XSL files to be applied */
    public String xslFileName = null;

    /** Transformation parameters: names */
    public Vector xslParamNames = new Vector();

    /** Transformation parameters: values */
    public Vector xslparamValues = new Vector();

    /** Output file name */
    public String outFileName = "";

    /** Do input file validation */
    public boolean validate = false;
}


/**
 *  Driver class with main(). Parses command line arguments and invokes
 *  CodeTransformerImpl instance that does all the transformation work.
 */
public class CodeTransformer {
    /** Transformer that does actual transformation */
    private static CodeTransformerImpl transformer = null;

    /** Transformations to perform */
    private static Vector transformations = new Vector();

    /** Print debug output while running */
    private static boolean debug = false;

    /** Print usage info and exit */
    private static boolean printHelp = false;


    /**
     * Main method
     *
     * @param args Command line arguments
     */
    public static void main(String[] args) {
        try {
            parseArgs(args);
            if (printHelp) {
                printHelp();
                return;
            }

            transformer = new CodeTransformerImpl(debug);
            for (int i = 0; i < transformations.size(); ++i) {
                Transformation tr =
                    (Transformation)transformations.elementAt(i);
                transformer.transform(tr);
            }
        } catch (SAXException e) {
            // error was already reported
            e.printStackTrace();
            System.exit(1);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    /**
     * Parse command line arguments, adding Transformation objects to
     * <tt>transformations</tt> vector for each transformation specified.
     *
     * @param args command line arguments
     */
    private static void parseArgs(String[] args)
    {
        Transformation tr = new Transformation();
        for (int i = 0; i < args.length; ++i) {
            String arg = args[i];
            if (debug) {
                System.err.println("arg: " + arg);
            }
            if (arg.equals("-xml")) {
                tr.xmlFileName = args[++i];
            } else if (arg.equals("-xsl")) {
                tr.xslFileName = args[++i];
            } else if (arg.equals("-params")) {
                int j = i + 1;
                for (; j < args.length; j += 2)  {
                    if ('-' == args[j].charAt(0)) {
                        break;
                    }
                    if (debug) {
                       System.err.println("pname : " + (String)args[j]);
                       System.err.println("pvalue: " + (String)args[j + 1]);
                    }
                    tr.xslParamNames.add(args[j]);
                    tr.xslparamValues.add(args[j + 1]);
                }
                i = j - 1;
            } else if (arg.equals("-validate")) {
                tr.validate = true;
            } else if (arg.equals("-out")) {
                tr.outFileName = args[++i];
                // -out ends current transformation arguments,
                // i.e all agruments coming after it belong
                // to next transformation(s)
                transformations.add(tr);
                tr = new Transformation();
            } else if (arg.equals("-debug")) {
                debug = true;
            } else {
                printHelp = true;
            }
        }
    }

    /**
     * Print usage information
     */
    private static void printHelp() {
        /**
         * Following options are recognized:
         * -validate:   Do validation of input XML file.
         * -xml:        XML file to transform.
         * -xsl:        XSL file to apply to given XML file.
         * -out:        Output file. If empty, output will be to stdout.
         * -params:     Transformations parameters in form of "Name"
         *              "Value" pairs.
         * -help:       Print usage information
         * -debug:      Be verbose: print some debug info while running.
         *
         * In order to improve performance, CodeTransformer is capable of
         * doing multiple transformations per invocation. -out option marks
         * the end of arguments for single transformation. All arguments
         * after it belong to next transformation(s).
         */
        System.err.println("Usage: java -jar <code_transformer_jar_file>"
            + "[-validate] "
            + "-xml <localXMLFile> "
            + "-xsl <localXSLFile> "
            + "-params <paramName> <paramValue>... "
            + "-out <localOutputFile> "
            + "-xml <localXMLFile> "
            + "... "
            + "[-debug] "
            + "[-help]");
    }
}


/**
 * Perform the transformation
 */
class CodeTransformerImpl {
    /** Factory constructing Transformer objects */
    private TransformerFactory transformerFactory =
        TransformerFactory.newInstance();

    /**
     * Since most of transformations are applied to the same XML file,
     * we don't want to load it on each transformation, so we cache last
     * used XML file as DOMSource
     */
    /** Last source used */
    private DOMSource lastSource = null;
    /** Last document used */
    private Document lastDoc = null;
    /** File name of the last used source */
    private String lastSourceFileName = null;

    /** Be verbose: print some debug info while running */
    private boolean debug = false;


    /**
     * Constructor
     *
     * @param dbg print some debug output while running
     */
    public CodeTransformerImpl(boolean dbg)
    {
        debug = dbg;
    }

    /**
     * Converts errors.
     */
    class TransformerErrorHandler
        implements ErrorHandler {

        /**
         * Handles errors.
         * @param e the parsing exception
         */
        public void error(SAXParseException e)
            throws SAXParseException {
            reportError(e);
            // rethrow exception to stop processing on first error
            throw e;
        }

        /**
         * Handles fatal errors.
         * @param e the parsing exception
         */
        public void fatalError(SAXParseException e) {
            reportError(e);
        }

        /**
         * Handles warnings.
         * @param e the parsing exception
         */
        public void warning(SAXParseException e) {
            reportError(e);
        }

        /**
         * Outputs diagnostic messages.
         * @param e the parsing exception
         */
        private void reportError(SAXParseException e) {
            String msg = e.getMessage();
            String location = e.getSystemId();
            int line = e.getLineNumber();

            System.err.print("Error: URI=" + location);
            System.err.println(" Line=" + line + ": " + msg);
        }
    }

    /**
     * Do the actual transformation
     *
     * @param tr transformation to perform
     */
    public void transform(Transformation tr)
        throws Exception {

        if (debug) {
            System.err.println("xml file: " + tr.xmlFileName);
            System.err.println("out file: " + tr.outFileName);
            System.err.println("prev xml: " + lastSourceFileName);
        }

        // source XML file
        DOMSource source = null;
        Document doc;
        if (lastSource != null &&
                lastSourceFileName.equals(tr.xmlFileName)) {
            source = lastSource;
            doc = lastDoc;
        } else {
            // load XML file as DOM tree
            DocumentBuilderFactory domFactory =
                DocumentBuilderFactory.newInstance();

            if (tr.validate) {
                domFactory.setValidating(true);
            }
            DocumentBuilder domBuilder = domFactory.newDocumentBuilder();

            domBuilder.setErrorHandler(new TransformerErrorHandler());
            doc = domBuilder.parse(new File(tr.xmlFileName));

            // make source from it
            source = new DOMSource(doc);
        }

        // if output and input files are the same,
        // we can't reuse cached input file since
        // it's going to change
        if ((tr.xmlFileName).equals(tr.outFileName)) {
            lastSource = null;
            lastDoc = null;
            lastSourceFileName = null;
        } else {
            lastSource = source;
            lastDoc = doc;
            lastSourceFileName = tr.xmlFileName;
        }

        // apply XSL stylesheet
        if (debug) {
            System.err.println("xsl file: " + tr.xslFileName);
        }

        // output file
        StreamResult outStream = null;
        if (tr.outFileName.length() == 0) {
            // send transformed output to the stdout
            outStream = new StreamResult(System.out);
        } else  {
            // send transformed output to the file
            makeDirectoryTree(tr.outFileName);
            outStream = new StreamResult(new File(tr.outFileName));
        }

        // create Transformer that will apply stylesheet
        StreamSource xslFile = new
            StreamSource(new File(tr.xslFileName));
        Transformer transformer =
            transformerFactory.newTransformer(xslFile);

        // pass parameters to Transformer
        for (int j = 0; j < tr.xslParamNames.size(); ++j) {
            transformer.setParameter(
                (String)tr.xslParamNames.elementAt(j),
                tr.xslparamValues.elementAt(j));
        }

        // finally, apply the stylesheet
        transformer.transform(source, outStream);
    }

    /**
     * Creates a directory structure.
     *
     * @param fullFileName Full path to the file to be created. If directory
     * in which file is to be created doesn't exists, it will be created
     * @exception IOException is thrown if directory couldn't be created
     */
    private void makeDirectoryTree(String fullFileName) throws IOException {
        if (debug == true) {
            System.out.println("mkdir: " + fullFileName);
        }
        int index = fullFileName.lastIndexOf(File.separatorChar);
        if (index == -1) {
            // To be compatible with MKS-hosted build on win32, which
            // does not translate / to \.
            index = fullFileName.lastIndexOf('/');
        }
        File outputDirectory = new File(fullFileName.substring(0, index));

        if (!(outputDirectory).exists()) {
            if (!(outputDirectory).mkdirs()) {
                throw new IOException("failed to create output directory");
            }
        }
    }
}