tools/tree/FinallyStatement.java

/*
 * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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 in the LICENSE file that
 * accompanied this code).
 *
 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.tools.tree;

import sun.tools.java.*;
import sun.tools.asm.Assembler;
import sun.tools.asm.Label;
import sun.tools.asm.TryData;
import sun.tools.asm.CatchData;
import java.io.PrintStream;
import java.util.Hashtable;
import java.util.Enumeration;

/**
 * WARNING: The contents of this source file are not part of any
 * supported API.  Code that depends on them does so at its own risk:
 * they are subject to change or removal without notice.
 */
public
class FinallyStatement extends Statement {
    Statement body;
    Statement finalbody;
    boolean finallyCanFinish; // does finalBody never return?
    boolean needReturnSlot;   // set by inner return statement
    Statement init;           // try object expression  or declaration from parser
    LocalMember tryTemp;      // temp holding the try object, if any

    /**
     * Constructor
     */
    public FinallyStatement(long where, Statement body, Statement finalbody) {
        super(FINALLY, where);
        this.body = body;
        this.finalbody = finalbody;
    }

//    /**
//     * Constructor for  try (init) {body}
//     */
//    public FinallyStatement(long where, Statement init, Statement body, int junk) {
//      this(where, body, null);
//      this.init = init;
//    }

    /**
     * Check statement
     */
    Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) {
        vset = reach(env, vset);
        Hashtable newexp = new Hashtable();

        // Handle the proposed 'try (init) { stmts } finally { stmts }' syntax.
        // This feature has not been adopted, and support is presently disabled.
        /*-----------------------------------------------------------*
        if (init != null) {
            ClassDefinition sourceClass = ctx.field.getClassDefinition();
            Expression tryExpr = null;
            DeclarationStatement tryDecl = null;
            long where = init.getWhere();
            // find out whether init is a simple expression or a declaration
            if (init.getOp() == EXPRESSION) {
                tryExpr = ((ExpressionStatement)init).expr;
                init = null;    // restore it below
                vset = tryExpr.checkValue(env, ctx, vset, exp);
            } else if (init.getOp() == DECLARATION) {
                tryDecl = (DeclarationStatement) init;
                init = null;    // restore it below
                vset = tryDecl.checkBlockStatement(env, ctx, vset, exp);
                if (tryDecl.args.length != 1) {
                    env.error(where, "invalid.decl");
                } else {
                    LocalMember field =
                        ((VarDeclarationStatement) tryDecl.args[0]).field;
                    tryExpr = new IdentifierExpression(where, field);
                    tryExpr.type = field.getType();
                }
            } else {
                env.error(where, "invalid.expr");
                vset = init.check(env, ctx, vset, exp);
            }
            Type type = (tryExpr == null) ? Type.tError : tryExpr.getType();

            MemberDefinition tryEnter = null;
            MemberDefinition tryExit = null;
            if (!type.isType(TC_CLASS)) {
                if (!type.isType(TC_ERROR)) {
                    env.error(where, "invalid.method.invoke", type);
                }
            } else {
                Identifier idTryEnter = Identifier.lookup("tryEnter");
                Identifier idTryExit = Identifier.lookup("tryExit");
                Type tTryMethod = Type.tMethod(Type.tVoid);
                try {
                    ClassDefinition tryClass = env.getClassDefinition(type);
                    tryEnter = tryClass.matchMethod(env, sourceClass, idTryEnter);
                    tryExit = tryClass.matchMethod(env, sourceClass, idTryExit);
                    if (tryEnter != null && !tryEnter.getType().equals(tTryMethod)) {
                        tryEnter = null;
                    }
                    if (tryExit != null && !tryExit.getType().equals(tTryMethod)) {
                        tryExit = null;
                    }
                } catch (ClassNotFound ee) {
                    env.error(where, "class.not.found", ee.name, ctx.field);
                } catch (AmbiguousMember ee) {
                    Identifier id = ee.field1.getName();
                    env.error(where, "ambig.field", id, ee.field1, ee.field2);
                }
            }
            if (tryEnter == null || tryExit == null) {
                // Make a better (more didactic) error here!
                env.error(where, "invalid.method.invoke", type);
            } else {
                tryTemp = new LocalMember(where, sourceClass, 0,
                                          type, Identifier.lookup("<try_object>"));
                ctx = new Context(ctx, this);
                ctx.declare(env, tryTemp);

                Expression e;
                e = new IdentifierExpression(where, tryTemp);
                e = new AssignExpression(where, e, tryExpr);
                e = new MethodExpression(where, e, tryEnter, new Expression[0]);
                e.type = Type.tVoid;
                Statement enterCall = new ExpressionStatement(where, e);
                // store it on the init, for code generation
                if (tryDecl != null) {
                    Statement args2[] = { tryDecl.args[0], enterCall };
                    tryDecl.args = args2;
                    init = tryDecl;
                } else {
                    init = enterCall;
                }
                e = new IdentifierExpression(where, tryTemp);
                e = new MethodExpression(where, e, tryExit, new Expression[0]);
                e.type = Type.tVoid;
                Statement exitCall = new ExpressionStatement(where, e);
                finalbody = exitCall;
            }
        }
        *-----------------------------------------------------------*/

        // Check the try part. We reach the end of the try part either by
        // finishing normally, or doing a break to the label of the try/finally.
        // NOTE: I don't think newctx1.vsBreak is ever used -- see TryStatement.
        CheckContext newctx1 = new CheckContext(ctx, this);
        Vset vset1 = body.check(env, newctx1, vset.copy(), newexp)
            .join(newctx1.vsBreak);
        // Check the finally part.
        CheckContext newctx2 = new CheckContext(ctx, this);
        // Should never access this field.  The null indicates the finally part.
        newctx2.vsContinue = null;
        Vset vset2 = finalbody.check(env, newctx2, vset, exp);
        finallyCanFinish = !vset2.isDeadEnd();
        vset2 = vset2.join(newctx2.vsBreak);
        // If !finallyCanFinish, then the only possible exceptions that can
        // occur at this point are the ones preceding the try/finally, or
        // the ones generated by the finally.  Anything in the try is
        // irrelevant. Otherwise, we have to merge in all the exceptions
        // generated by the body into exp.
        if (finallyCanFinish) {
            // Add newexp's back into exp; cf. ThrowStatement.check().
            for (Enumeration e = newexp.keys() ; e.hasMoreElements() ; ) {
                Object def = e.nextElement();
                exp.put(def, newexp.get(def));
            }
        }
        return ctx.removeAdditionalVars(vset1.addDAandJoinDU(vset2));
    }

    /**
     * Inline
     */
    public Statement inline(Environment env, Context ctx) {
        if (tryTemp != null) {
            ctx = new Context(ctx, this);
            ctx.declare(env, tryTemp);
        }
        if (init != null) {
            init = init.inline(env, ctx);
        }
        if (body != null) {
            body = body.inline(env, ctx);
        }
        if (finalbody != null) {
            finalbody = finalbody.inline(env, ctx);
        }
        if (body == null) {
            return eliminate(env, finalbody);
        }
        if (finalbody == null) {
            return eliminate(env, body);
        }
        return this;
    }

    /**
     * Create a copy of the statement for method inlining
     */
    public Statement copyInline(Context ctx, boolean valNeeded) {
        FinallyStatement s = (FinallyStatement)clone();
        if (tryTemp != null) {
            s.tryTemp = tryTemp.copyInline(ctx);
        }
        if (init != null) {
            s.init = init.copyInline(ctx, valNeeded);
        }
        if (body != null) {
            s.body = body.copyInline(ctx, valNeeded);
        }
        if (finalbody != null) {
            s.finalbody = finalbody.copyInline(ctx, valNeeded);
        }
        return s;
     }

    /**
     * Compute cost of inlining this statement
     */
    public int costInline(int thresh, Environment env, Context ctx){
        int cost = 4;
        if (init != null) {
            cost += init.costInline(thresh, env,ctx);
            if (cost >= thresh) return cost;
        }
        if (body != null) {
            cost += body.costInline(thresh, env,ctx);
            if (cost >= thresh) return cost;
        }
        if (finalbody != null) {
            cost += finalbody.costInline(thresh, env,ctx);
        }
        return cost;
    }

    /**
     * Code
     */
    public void code(Environment env, Context ctx, Assembler asm) {
        ctx = new Context(ctx);
        Integer num1 = null, num2 = null;
        Label endLabel = new Label();

        if (tryTemp != null) {
            ctx.declare(env, tryTemp);
        }
        if (init != null) {
            CodeContext exprctx = new CodeContext(ctx, this);
            init.code(env, exprctx, asm);
        }

        if (finallyCanFinish) {
            LocalMember f1, f2;
            ClassDefinition thisClass = ctx.field.getClassDefinition();

            if (needReturnSlot) {
                Type returnType = ctx.field.getType().getReturnType();
                LocalMember localfield = new LocalMember(0, thisClass, 0,
                                                       returnType,
                                                       idFinallyReturnValue);
                ctx.declare(env, localfield);
                env.debugOutput("Assigning return slot to " + localfield.number);
            }

            // allocate space for the exception and return address
            f1 = new LocalMember(where, thisClass, 0, Type.tObject, null);
            f2 = new LocalMember(where, thisClass, 0, Type.tInt, null);
            num1 = new Integer(ctx.declare(env, f1));
            num2 = new Integer(ctx.declare(env, f2));
        }

        TryData td = new TryData();
        td.add(null);

        // Main body
        CodeContext bodyctx = new CodeContext(ctx, this);
        asm.add(where, opc_try, td); // start of protected code
        body.code(env, bodyctx, asm);
        asm.add(bodyctx.breakLabel);
        asm.add(td.getEndLabel());   // end of protected code

        // Cleanup afer body
        if (finallyCanFinish) {
            asm.add(where, opc_jsr, bodyctx.contLabel);
            asm.add(where, opc_goto, endLabel);
        } else {
            // just goto the cleanup code.  It will never return.
            asm.add(where, opc_goto, bodyctx.contLabel);
        }

        // Catch code
        CatchData cd = td.getCatch(0);
        asm.add(cd.getLabel());
        if (finallyCanFinish) {
            asm.add(where, opc_astore, num1); // store exception
            asm.add(where, opc_jsr, bodyctx.contLabel);
            asm.add(where, opc_aload, num1); // rethrow exception
            asm.add(where, opc_athrow);
        } else {
            // pop exception off stack.  Fall through to finally code
            asm.add(where, opc_pop);
        }

        // The finally part, which is marked by the contLabel.  Update
        //    breakLabel: since break's in the finally are different
        //    contLabel:  to null to indicate no longer in the protected code.
        asm.add(bodyctx.contLabel);
        bodyctx.contLabel = null;
        bodyctx.breakLabel = endLabel;
        if (finallyCanFinish) {
            asm.add(where, opc_astore, num2);  // save the return address
            finalbody.code(env, bodyctx, asm); // execute the cleanup code
            asm.add(where, opc_ret, num2);     // return
        } else {
            finalbody.code(env, bodyctx, asm); // execute the cleanup code
        }
        asm.add(endLabel);                     // breaks come here
    }

    /**
     * Print
     */
    public void print(PrintStream out, int indent) {
        super.print(out, indent);
        out.print("try ");
        if (body != null) {
            body.print(out, indent);
        } else {
            out.print("<empty>");
        }
        out.print(" finally ");
        if (finalbody != null) {
            finalbody.print(out, indent);
        } else {
            out.print("<empty>");
        }
    }
}