processor.java

jboss规则引擎

/***
 * ASM XML Adapter
 * Copyright (c) 2004, Eugene Kuleshov
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.drools.asm.xml;

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamSource;

import org.drools.asm.ClassReader;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 * Processor is a command line tool that can be used for bytecode waving
 * directed by XSL transformation. <p> In order to use a concrete XSLT engine,
 * system property <tt>javax.xml.transform.TransformerFactory</tt> must be set
 * to one of the following values.
 * 
 * <blockquote> <table border="1" cellspacing="0" cellpadding="3"> <tr> <td>jd.xslt</td>
 * <td>jd.xml.xslt.trax.TransformerFactoryImpl</td> </tr>
 * 
 * <tr> <td>Saxon</td> <td>net.sf.saxon.TransformerFactoryImpl</td> </tr>
 * 
 * <tr> <td>Caucho</td> <td>com.caucho.xsl.Xsl</td> </tr>
 * 
 * <tr> <td>Xalan interpeter</td> <td>org.apache.xalan.processor.TransformerFactory</td>
 * </tr>
 * 
 * <tr> <td>Xalan xsltc</td> <td>org.apache.xalan.xsltc.trax.TransformerFactoryImpl</td>
 * </tr> </table> </blockquote>
 * 
 * @author Eugene Kuleshov
 */
public class Processor {

    public static final int     BYTECODE        = 1;

    public static final int     MULTI_XML       = 2;

    public static final int     SINGLE_XML      = 3;

    private static final String SINGLE_XML_NAME = "classes.xml";

    private int                 inRepresentation;

    private int                 outRepresentation;

    private InputStream         input           = null;

    private OutputStream        output          = null;

    private Source              xslt            = null;

    private boolean             computeMax;

    private int                 n               = 0;

    public Processor(final int inRepresenation,
                     final int outRepresentation,
                     final InputStream input,
                     final OutputStream output,
                     final Source xslt) {
        this.inRepresentation = inRepresenation;
        this.outRepresentation = outRepresentation;
        this.input = input;
        this.output = output;
        this.xslt = xslt;
        this.computeMax = true;
    }

    public int process() throws TransformerException,
                        IOException,
                        SAXException {
        final ZipInputStream zis = new ZipInputStream( this.input );
        final ZipOutputStream zos = new ZipOutputStream( this.output );
        final OutputStreamWriter osw = new OutputStreamWriter( zos );

        Thread.currentThread().setContextClassLoader( getClass().getClassLoader() );

        final TransformerFactory tf = TransformerFactory.newInstance();
        if ( !tf.getFeature( SAXSource.FEATURE ) || !tf.getFeature( SAXResult.FEATURE ) ) {
            return 0;
        }

        final SAXTransformerFactory saxtf = (SAXTransformerFactory) tf;
        Templates templates = null;
        if ( this.xslt != null ) {
            templates = saxtf.newTemplates( this.xslt );
        }

        // configuring outHandlerFactory
        // ///////////////////////////////////////////////////////

        final EntryElement entryElement = getEntryElement( zos );

        ContentHandler outDocHandler = null;
        switch ( this.outRepresentation ) {
            case BYTECODE :
                outDocHandler = new OutputSlicingHandler( new ASMContentHandlerFactory( zos,
                                                                                        this.computeMax ),
                                                          entryElement,
                                                          false );
                break;

            case MULTI_XML :
                outDocHandler = new OutputSlicingHandler( new SAXWriterFactory( osw,
                                                                                true ),
                                                          entryElement,
                                                          true );
                break;

            case SINGLE_XML :
                final ZipEntry outputEntry = new ZipEntry( Processor.SINGLE_XML_NAME );
                zos.putNextEntry( outputEntry );
                outDocHandler = new SAXWriter( osw,
                                               false );
                break;

        }

        // configuring inputDocHandlerFactory
        // /////////////////////////////////////////////////
        ContentHandler inDocHandler = null;
        if ( templates == null ) {
            inDocHandler = outDocHandler;
        } else {
            inDocHandler = new InputSlicingHandler( "class",
                                                    outDocHandler,
                                                    new TransformerHandlerFactory( saxtf,
                                                                                   templates,
                                                                                   outDocHandler ) );
        }
        final ContentHandlerFactory inDocHandlerFactory = new SubdocumentHandlerFactory( inDocHandler );

        if ( inDocHandler != null && this.inRepresentation != Processor.SINGLE_XML ) {
            inDocHandler.startDocument();
            inDocHandler.startElement( "",
                                       "classes",
                                       "classes",
                                       new AttributesImpl() );
        }

        int i = 0;
        ZipEntry ze = null;
        while ( (ze = zis.getNextEntry()) != null ) {
            update( ze.getName(),
                    this.n++ );
            if ( isClassEntry( ze ) ) {
                processEntry( zis,
                              ze,
                              inDocHandlerFactory );
            } else {
                final OutputStream os = entryElement.openEntry( getName( ze ) );
                copyEntry( zis,
                           os );
                entryElement.closeEntry();
            }

            i++;
        }

        if ( inDocHandler != null && this.inRepresentation != Processor.SINGLE_XML ) {
            inDocHandler.endElement( "",
                                     "classes",
                                     "classes" );
            inDocHandler.endDocument();
        }

        if ( this.outRepresentation == Processor.SINGLE_XML ) {
            zos.closeEntry();
        }
        zos.flush();
        zos.close();

        return i;
    }

    private void copyEntry(final InputStream is,
                           final OutputStream os) throws IOException {
        if ( this.outRepresentation == Processor.SINGLE_XML ) {
            return;
        }

        final byte[] buff = new byte[2048];
        int i;
        while ( (i = is.read( buff )) != -1 ) {
            os.write( buff,
                      0,
                      i );
        }
    }

    private boolean isClassEntry(final ZipEntry ze) {
        final String name = ze.getName();
        return this.inRepresentation == Processor.SINGLE_XML && name.equals( Processor.SINGLE_XML_NAME ) || name.endsWith( ".class" ) || name.endsWith( ".class.xml" );
    }

    private void processEntry(final ZipInputStream zis,
                              final ZipEntry ze,
                              final ContentHandlerFactory handlerFactory) {
        final ContentHandler handler = handlerFactory.createContentHandler();
        try {

            // if (CODE2ASM.equals(command)) { // read bytecode and process it
            // // with TraceClassVisitor
            // ClassReader cr = new ClassReader(readEntry(zis, ze));
            // cr.accept(new TraceClassVisitor(null, new PrintWriter(os)),
            // false);
            // }

            final boolean singleInputDocument = this.inRepresentation == Processor.SINGLE_XML;
            if ( this.inRepresentation == Processor.BYTECODE ) { // read bytecode and process it
                // with handler
                final ClassReader cr = new ClassReader( readEntry( zis,
                                                                   ze ) );
                cr.accept( new SAXClassAdapter( handler,
                                                singleInputDocument ),
                           false );

            } else { // read XML and process it with handler
                final XMLReader reader = XMLReaderFactory.createXMLReader();
                reader.setContentHandler( handler );
                reader.parse( new InputSource( singleInputDocument ? (InputStream) new ProtectedInputStream( zis ) : new ByteArrayInputStream( readEntry( zis,
                                                                                                                                                          ze ) ) ) );

            }
        } catch ( final Exception ex ) {
            update( ze.getName(),
                    0 );
            update( ex,
                    0 );
        }
    }

    private EntryElement getEntryElement(final ZipOutputStream zos) {
        if ( this.outRepresentation == Processor.SINGLE_XML ) {
            return new SingleDocElement( zos );
        }
        return new ZipEntryElement( zos );
    }

    // private ContentHandlerFactory getHandlerFactory(
    // OutputStream os,
    // SAXTransformerFactory saxtf,
    // Templates templates)
    // {
    // ContentHandlerFactory factory = null;
    // if (templates == null) {
    // if (outputRepresentation == BYTECODE) { // factory used to write
    // // bytecode
    // factory = new ASMContentHandlerFactory(os, computeMax);
    // } else { // factory used to write XML
    // factory = new SAXWriterFactory(os, true);
    // }
    // } else {
    // if (outputRepresentation == BYTECODE) { // factory used to transform
    // // and then write bytecode
    // factory = new ASMTransformerHandlerFactory(saxtf,
    // templates,
    // os,
    // computeMax);
    // } else { // factory used to transformand then write XML
    // factory = new TransformerHandlerFactory(saxtf,
    // templates,
    // os,
    // outputRepresentation == SINGLE_XML);
    // }
    // }
    // return factory;
    // }

    private String getName(final ZipEntry ze) {
        String name = ze.getName();
        if ( isClassEntry( ze ) ) {
            if ( this.inRepresentation != Processor.BYTECODE && this.outRepresentation == Processor.BYTECODE ) {
                name = name.substring( 0,
                                       name.length() - 4 ); // .class.xml to
                // .class
            } else if ( this.inRepresentation == Processor.BYTECODE && this.outRepresentation != Processor.BYTECODE ) {
                name = name.concat( ".xml" ); // .class to .class.xml
            }
            // } else if( CODE2ASM.equals( command)) {
            // name = name.substring( 0, name.length()-6).concat( ".asm");
        }
        return name;
    }

    private byte[] readEntry(final ZipInputStream zis,
                             final ZipEntry ze) throws IOException {
        final long size = ze.getSize();
        if ( size > -1 ) {
            final byte[] buff = new byte[(int) size];
            int k = 0;
            int n;
            while ( (n = zis.read( buff,
                                   k,
                                   buff.length - k )) > 0 ) {
                k += n;
            }
            return buff;
        }