javacclassgenerator.java

Groovy动态语言 运行在JVM中的动态语言 可以方便的处理业务逻辑变化大的业务

/*
 * $Id: JavacClassGenerator.java 2223 2005-05-27 10:13:49Z russel $
 *
 * Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
 *
 * Redistribution and use of this software and associated documentation
 * ("Software"), with or without modification, are permitted provided that the
 * following conditions are met: 1. Redistributions of source code must retain
 * copyright statements and notices. Redistributions must also contain a copy
 * of this document. 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.
 * The name "groovy" must not be used to endorse or promote products derived
 * from this Software without prior written permission of The Codehaus. For
 * written permission, please contact [e-mail]. 4. Products derived
 * from this Software may not be called "groovy" nor may "groovy" appear in
 * their names without prior written permission of The Codehaus. "groovy" is a
 * registered trademark of The Codehaus. 5. Due credit should be given to The
 * Codehaus - http://groovy.codehaus.org/
 *
 * THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS ``AS IS'' AND ANY
 * EXPRESSED 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 CODEHAUS OR ITS 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.codehaus.groovy.classgen;

import groovy.lang.Closure;
import groovy.lang.GString;
import groovy.lang.GroovyRuntimeException;
import groovy.lang.MissingClassException;
import groovy.lang.Reference;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.AccessControlException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;

import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.ClassNode;
//import org.codehaus.groovy.ast.CodeVisitorSupport;
import org.codehaus.groovy.ast.CompileUnit;
import org.codehaus.groovy.ast.ConstructorNode;
import org.codehaus.groovy.ast.FieldNode;
//import org.codehaus.groovy.ast.GroovyClassVisitor;
//import org.codehaus.groovy.ast.GroovyCodeVisitor;
import org.codehaus.groovy.ast.InnerClassNode;
import org.codehaus.groovy.ast.MethodNode;
import org.codehaus.groovy.ast.Parameter;
import org.codehaus.groovy.ast.PropertyNode;
import org.codehaus.groovy.ast.Type;
import org.codehaus.groovy.ast.VariableScope;
import org.codehaus.groovy.ast.expr.ArgumentListExpression;
import org.codehaus.groovy.ast.expr.ArrayExpression;
import org.codehaus.groovy.ast.expr.BinaryExpression;
import org.codehaus.groovy.ast.expr.BooleanExpression;
import org.codehaus.groovy.ast.expr.CastExpression;
import org.codehaus.groovy.ast.expr.ClassExpression;
import org.codehaus.groovy.ast.expr.ClosureExpression;
import org.codehaus.groovy.ast.expr.ConstantExpression;
import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.ExpressionTransformer;
import org.codehaus.groovy.ast.expr.FieldExpression;
import org.codehaus.groovy.ast.expr.GStringExpression;
import org.codehaus.groovy.ast.expr.ListExpression;
import org.codehaus.groovy.ast.expr.MapEntryExpression;
import org.codehaus.groovy.ast.expr.MapExpression;
import org.codehaus.groovy.ast.expr.MethodCallExpression;
import org.codehaus.groovy.ast.expr.NegationExpression;
import org.codehaus.groovy.ast.expr.NotExpression;
import org.codehaus.groovy.ast.expr.PostfixExpression;
import org.codehaus.groovy.ast.expr.PrefixExpression;
import org.codehaus.groovy.ast.expr.PropertyExpression;
import org.codehaus.groovy.ast.expr.RangeExpression;
import org.codehaus.groovy.ast.expr.RegexExpression;
import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
import org.codehaus.groovy.ast.expr.TernaryExpression;
import org.codehaus.groovy.ast.expr.TupleExpression;
import org.codehaus.groovy.ast.expr.VariableExpression;
import org.codehaus.groovy.ast.stmt.AssertStatement;
import org.codehaus.groovy.ast.stmt.BlockStatement;
import org.codehaus.groovy.ast.stmt.BreakStatement;
import org.codehaus.groovy.ast.stmt.CaseStatement;
import org.codehaus.groovy.ast.stmt.CatchStatement;
import org.codehaus.groovy.ast.stmt.ContinueStatement;
import org.codehaus.groovy.ast.stmt.DoWhileStatement;
import org.codehaus.groovy.ast.stmt.ExpressionStatement;
import org.codehaus.groovy.ast.stmt.ForStatement;
import org.codehaus.groovy.ast.stmt.IfStatement;
import org.codehaus.groovy.ast.stmt.ReturnStatement;
import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.ast.stmt.SwitchStatement;
import org.codehaus.groovy.ast.stmt.SynchronizedStatement;
import org.codehaus.groovy.ast.stmt.ThrowStatement;
import org.codehaus.groovy.ast.stmt.TryCatchStatement;
import org.codehaus.groovy.ast.stmt.WhileStatement;
import org.codehaus.groovy.runtime.InvokerHelper;
import org.codehaus.groovy.syntax.Token;
import org.codehaus.groovy.syntax.Types;
import org.codehaus.groovy.syntax.parser.RuntimeParserException;
//import org.objectweb.asm.ClassVisitor;
//import org.objectweb.asm.MethodVisitor;
//import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Label;
import com.sun.tools.javac.v8.tree.Tree;
import com.sun.tools.javac.v8.tree.TreeMaker;
import com.sun.tools.javac.v8.util.Name;
import com.sun.tools.javac.v8.util.List;
import com.sun.tools.javac.v8.code.Symbol;
import com.sun.tools.javac.v8.code.Scope;

/**
 * Generates Java class versions of Groovy classes using Sun's Javac Java AST model
 *
 * @author <a href="mailto:[e-mail]">James Strachan</a>
 * @version $Revision: 2223 $
 */
public abstract class JavacClassGenerator extends ClassGenerator {

    private Logger log = Logger.getLogger(getClass().getName());

    private Tree.Factory factory;
    private Tree.TopLevel topLevel;
    private Name.Table nameTable = new Name.Table();
    private Name sourceFileName;

    public JavacClassGenerator(GeneratorContext context, ClassLoader classLoader, String sourceFile) {
        super(classLoader);
        sourceFileName = nameTable.fromString(sourceFile);
    }


    // GroovyClassVisitor interface
    //-------------------------------------------------------------------------
//
//    public void visitClass(ClassNode classNode) {
//
//        //className = nameTable.fromString(classNode.getName());
//
//        Tree pid = null;
//        List defs = new List();
//        Symbol.PackageSymbol packageSymbol = null;
//
//        Symbol owner = null; /// new Symbol.ClassSymbol()
//        Scope namedImportScope = new Scope(owner);
//        Scope starImportScope = new Scope(owner);
//
//        topLevel = new Tree.TopLevel(pid, defs, sourceFileName, packageSymbol, namedImportScope, starImportScope);
//        factory = new TreeMaker(topLevel);
//
//
//
//        try {
//            syntheticStaticFields.clear();
//            this.classNode = classNode;
//            this.outermostClass = null;
//
//            //System.out.println("Generating class: " + classNode.getName());
//
//            // lets check that the classes are all valid
//            classNode.setSuperClass(checkValidType(classNode.getSuperClass(), classNode, "Must be a valid base class"));
//            String[] interfaces = classNode.getInterfaces();
//            for (int i = 0; i < interfaces.length; i++ ) {
//                interfaces[i] = checkValidType(interfaces[i], classNode, "Must be a valid interface name");
//            }
//
//
//            classNode.visitContents(this);
//
//            createSyntheticStaticFields();
//
//
//            factory.ClassDef();
//
//            for (Iterator iter = innerClasses.iterator(); iter.hasNext();) {
//                ClassNode innerClass = (ClassNode) iter.next();
//
//                /** TODO process innner classes */
//            }
//        }
//        catch (GroovyRuntimeException e) {
//            e.setModule(classNode.getModule());
//            throw e;
//        }
//    }
//
//    public void visitConstructor(ConstructorNode node) {
//        this.constructorNode = node;
//        this.methodNode = null;
//        this.variableScope = null;
//
//        visitParameters(node, node.getParameters());
//
//        findMutableVariables();
//        resetVariableStack(node.getParameters());
//
//        Statement code = node.getCode();
//        if (code != null) {
//            code.visit(this);
//        }
//        factory.MethodDef();
//    }
//
//    public void visitMethod(MethodNode node) {
//        this.constructorNode = null;
//        this.methodNode = node;
//        this.variableScope = null;
//
//        visitParameters(node, node.getParameters());
//
//        node.setReturnType(checkValidType(node.getReturnType(), node, "Must be a valid return type"));
//
//        findMutableVariables();
//        resetVariableStack(node.getParameters());
//
//        node.getCode().visit(this);
//        factory.MethodDef();
//    }
//
//    protected void visitParameters(ASTNode node, Parameter[] parameters) {
//        for (int i = 0, size = parameters.length; i < size; i++ ) {
//            visitParameter(node, parameters[i]);
//        }
//    }
//
//    protected void visitParameter(ASTNode node, Parameter parameter) {
//        if (! parameter.isDynamicType()) {
//            parameter.setType(checkValidType(parameter.getType(), node, "Must be a valid parameter class"));
//        }
//    }
//
//    public void visitField(FieldNode fieldNode) {
//        onLineNumber(fieldNode);
//
//        // lets check that the classes are all valid
//        fieldNode.setType(checkValidType(fieldNode.getType(), fieldNode, "Must be a valid field class for field: " + fieldNode.getName()));
//
//        //System.out.println("Visiting field: " + fieldNode.getName() + " on
//        // class: " + classNode.getName());
//
//        Object fieldValue = null;
//        Expression expression = fieldNode.getInitialValueExpression();
//        if (expression instanceof ConstantExpression) {
//            ConstantExpression constantExp = (ConstantExpression) expression;
//            Object value = constantExp.getValue();
//            if (isPrimitiveFieldType(fieldNode.getType())) {
//                // lets convert any primitive types
//                Class type = null;
//                try {
//                    type = loadClass(fieldNode.getType());
//                    fieldValue = InvokerHelper.asType(value, type);
//                }
//                catch (Exception e) {
//                    log.warning("Caught unexpected: " + e);
//                }
//            }
//        }
//
//    }
//
//    /**
//     * Creates a getter, setter and field
//     */
//    public void visitProperty(PropertyNode statement) {
//        onLineNumber(statement);
//        //this.propertyNode = statement;
//        this.methodNode = null;
//    }
//
//    // GroovyCodeVisitor interface
//    //-------------------------------------------------------------------------
//
//    // Statements
//    //-------------------------------------------------------------------------
//
//    public void visitForLoop(ForStatement loop) {
//        onLineNumber(loop);
//
//
//        factory.ForLoop()
//
//        //
//        // Declare the loop counter.
//
//        Type variableType = checkValidType(loop.getVariableType(), loop, "for loop variable");
//        Variable variable = defineVariable(loop.getVariable(), variableType, true);
//
//        if( isInScriptBody() ) {
//            variable.setProperty( true );
//        }
//
//
//        //
//        // Then initialize the iterator and generate the loop control
//
//        loop.getCollectionExpression().visit(this);
//
//        asIteratorMethod.call(cv);
//
//        final int iteratorIdx = defineVariable(createVariableName("iterator"), "java.util.Iterator", false).getIndex();
//        cv.visitVarInsn(ASTORE, iteratorIdx);
//
//        pushBlockScope();
//
//        Label continueLabel = scope.getContinueLabel();
//        cv.visitJumpInsn(GOTO, continueLabel);
//        Label label2 = new Label();
//        cv.visitLabel(label2);
//
//        BytecodeExpression expression = new BytecodeExpression() {
//            public void visit(GroovyCodeVisitor visitor) {
//                cv.visitVarInsn(ALOAD, iteratorIdx);
//
//                iteratorNextMethod.call(cv);
//            }
//        };
//
//        evaluateEqual( BinaryExpression.newAssignmentExpression(loop.getVariable(), expression) );
//
//
//        //
//        // Generate the loop body
//
//        loop.getLoopBlock().visit(this);
//
//
//        //
//        // Generate the loop tail
//
//        cv.visitLabel(continueLabel);
//        cv.visitVarInsn(ALOAD, iteratorIdx);
//
//        iteratorHasNextMethod.call(cv);
//
//        cv.visitJumpInsn(IFNE, label2);
//
//        cv.visitLabel(scope.getBreakLabel());
//        popScope();
//    }
//
//    public void visitWhileLoop(WhileStatement loop) {
//        onLineNumber(loop);
//
//        /*
//         * // quick hack if (!methodNode.isStatic()) { cv.visitVarInsn(ALOAD,
//         * 0); }
//         */
//
//        pushBlockScope();
//
//        Label continueLabel = scope.getContinueLabel();
//
//        cv.visitJumpInsn(GOTO, continueLabel);
//        Label l1 = new Label();
//        cv.visitLabel(l1);
//
//        loop.getLoopBlock().visit(this);
//
//        cv.visitLabel(continueLabel);
//        //cv.visitVarInsn(ALOAD, 0);
//
//        loop.getBooleanExpression().visit(this);
//
//        cv.visitJumpInsn(IFNE, l1);
//
//        cv.visitLabel(scope.getBreakLabel());
//        popScope();
//    }
//
//    public void visitDoWhileLoop(DoWhileStatement loop) {
//        onLineNumber(loop);
//
//        pushBlockScope();
//
//        Label breakLabel = scope.getBreakLabel();
//
//        Label continueLabel = scope.getContinueLabel();
//        cv.visitLabel(continueLabel);
//        Label l1 = new Label();
//
//        loop.getLoopBlock().visit(this);
//
//        cv.visitLabel(l1);
//
//        loop.getBooleanExpression().visit(this);
//
//        cv.visitJumpInsn(IFNE, continueLabel);
//
//        cv.visitLabel(breakLabel);
//        popScope();
//    }