/* * Copyright (c) 1994, 2003, 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 java.io.PrintStream;import java.util.Hashtable; /** * 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. */publicclass Statement extends Node {    public static final Vset DEAD_END = Vset.DEAD_END;    Identifier labels[] = null;     /**     * Constructor     */    Statement(int op, long where) {        super(op, where);    }     /**     * An empty statement.  Its costInline is infinite.     */    public static final Statement empty = new Statement(STAT, 0);     /**     * The largest possible interesting inline cost value.     */    public static final int MAXINLINECOST =                      Integer.getInteger("javac.maxinlinecost",                                         30).intValue();     /**     * Insert a bit of code at the front of a statement.     * Side-effect s2, if it is a CompoundStatement.     */    public static Statement insertStatement(Statement s1, Statement s2) {        if (s2 == null) {            s2 = s1;        } else if (s2 instanceof CompoundStatement) {            // Do not add another level of block nesting.            ((CompoundStatement)s2).insertStatement(s1);        } else {            Statement body[] = { s1, s2 };            s2 = new CompoundStatement(s1.getWhere(), body);        }        return s2;    }     /**     * Set the label of a statement     */    public void setLabel(Environment env, Expression e) {        if (e.op == IDENT) {            if (labels == null) {                labels = new Identifier[1];            } else {                // this should almost never happen.  Multiple labels on                // the same statement.  But handle it gracefully.                Identifier newLabels[] = new Identifier[labels.length + 1];                System.arraycopy(labels, 0, newLabels, 1, labels.length);                labels = newLabels;            }            labels[0] = ((IdentifierExpression)e).id;        } else {            env.error(e.where, "invalid.label");        }    }     /**     * Check a statement     */    public Vset checkMethod(Environment env, Context ctx, Vset vset, Hashtable exp) {        // Set up ctx.getReturnContext() for the sake of ReturnStatement.check().        CheckContext mctx = new CheckContext(ctx, new Statement(METHOD, 0));        ctx = mctx;         vset = check(env, ctx, vset, exp);         // Check for return        if (!ctx.field.getType().getReturnType().isType(TC_VOID)) {            // In general, we suppress further error messages due to            // unreachable statements after reporting the first error            // along a flow path (using 'clearDeadEnd').   Here, we            // report an error anyway, because the end of the method            // should be unreachable despite the earlier error.  The            // difference in treatment is due to the fact that, in this            // case, the error is reachability, not unreachability.            // NOTE: In addition to this subtle difference in the quality            // of the error diagnostics, this treatment is essential to            // preserve the correctness of using 'clearDeadEnd' to implement            // the special-case reachability rules for if-then and if-then-else.            if (!vset.isDeadEnd()) {                env.error(ctx.field.getWhere(), "return.required.at.end", ctx.field);            }        }         // Simulate a return at the end.        vset = vset.join(mctx.vsBreak);         return vset;    }    Vset checkDeclaration(Environment env, Context ctx, Vset vset, int mod, Type t, Hashtable exp) {        throw new CompilerError("checkDeclaration");    }     /**     * Make sure the labels on this statement do not duplicate the     * labels on any enclosing statement.  Provided as a convenience     * for subclasses.     */    protected void checkLabel(Environment env, Context ctx) {        if (labels != null) {            loop: for (int i = 0; i < labels.length; i++) {                // Make sure there is not a double label on this statement.                for (int j = i+1; j < labels.length; j++) {                    if (labels[i] == labels[j]) {                        env.error(where, "nested.duplicate.label", labels[i]);                        continue loop;                    }                }                 // Make sure no enclosing statement has the same label.                CheckContext destCtx =                    (CheckContext) ctx.getLabelContext(labels[i]);                 if (destCtx != null) {                    // Check to make sure the label is in not uplevel.                    if (destCtx.frameNumber == ctx.frameNumber) {                        env.error(where, "nested.duplicate.label", labels[i]);                    }                }            } // end loop        }    }     Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) {        throw new CompilerError("check");    }     /** This is called in contexts where declarations are valid. */    Vset checkBlockStatement(Environment env, Context ctx, Vset vset, Hashtable exp) {        return check(env, ctx, vset, exp);    }     Vset reach(Environment env, Vset vset) {        if (vset.isDeadEnd()) {            env.error(where, "stat.not.reached");            vset = vset.clearDeadEnd();        }        return vset;    }     /**     * Inline     */    public Statement inline(Environment env, Context ctx) {        return this;    }     /**     * Eliminate this statement, which is only possible if it has no label.     */    public Statement eliminate(Environment env, Statement s) {        if ((s != null) && (labels != null)) {            Statement args[] = {s};            s = new CompoundStatement(where, args);            s.labels = labels;        }        return s;    }      /**     * Code     */    public void code(Environment env, Context ctx, Assembler asm) {        throw new CompilerError("code");    }     /**     * Generate the code to call all finally's for a break, continue, or     * return statement.  We must call "jsr" on all the cleanup code between     * the current context "ctx", and the destination context "stopctx".     * If 'save' isn't null, there is also a value on the top of the stack     */    void codeFinally(Environment env, Context ctx, Assembler asm,                        Context stopctx, Type save) {        Integer num = null;        boolean haveCleanup = false; // there is a finally or synchronize;        boolean haveNonLocalFinally = false; // some finally doesn't return;         for (Context c = ctx; (c != null) && (c != stopctx); c = c.prev) {            if (c.node == null)                continue;            if (c.node.op == SYNCHRONIZED) {                haveCleanup = true;            } else if (c.node.op == FINALLY                          && ((CodeContext)c).contLabel != null) {                // c.contLabel == null indicates we're in the "finally" part                haveCleanup = true;                FinallyStatement st = ((FinallyStatement)(c.node));                if (!st.finallyCanFinish) {                    haveNonLocalFinally = true;                    // after hitting a non-local finally, no need generating                    // further code, because it won't get executed.                    break;                }            }        }        if (!haveCleanup) {            // there is no cleanup that needs to be done.  Just quit.            return;        }        if (save != null) {            // This statement has a return value on the stack.            ClassDefinition def = ctx.field.getClassDefinition();            if (!haveNonLocalFinally) {                // Save the return value in the register which should have                // been reserved.                LocalMember lf = ctx.getLocalField(idFinallyReturnValue);                num = new Integer(lf.number);                asm.add(where, opc_istore + save.getTypeCodeOffset(), num);            } else {                // Pop the return value.                switch(ctx.field.getType().getReturnType().getTypeCode()) {                    case TC_VOID:                        break;                    case TC_DOUBLE: case TC_LONG:                        asm.add(where, opc_pop2); break;                    default:                        asm.add(where, opc_pop); break;                }            }        }        // Call each of the cleanup functions, as necessary.        for (Context c = ctx ; (c != null)  && (c != stopctx) ; c = c.prev) {            if (c.node == null)                continue;            if (c.node.op == SYNCHRONIZED) {                asm.add(where, opc_jsr, ((CodeContext)c).contLabel);            } else if (c.node.op == FINALLY                          && ((CodeContext)c).contLabel != null) {                FinallyStatement st = ((FinallyStatement)(c.node));                Label label = ((CodeContext)c).contLabel;                if (st.finallyCanFinish) {                    asm.add(where, opc_jsr, label);                } else {                    // the code never returns, so we're done.                    asm.add(where, opc_goto, label);                    break;                }            }        }        // Move the return value from the register back to the stack.        if (num != null) {            asm.add(where, opc_iload + save.getTypeCodeOffset(), num);        }    }     /*     * Return true if the statement has the given label     */    public boolean hasLabel (Identifier lbl) {        Identifier labels[] = this.labels;        if (labels != null) {            for (int i = labels.length; --i >= 0; ) {                if (labels[i].equals(lbl)) {                    return true;                }            }        }        return false;    }     /**     * Check if the first thing is a constructor invocation     */    public Expression firstConstructor() {        return null;    }     /**     * Create a copy of the statement for method inlining     */    public Statement copyInline(Context ctx, boolean valNeeded) {        return (Statement)clone();    }     public int costInline(int thresh, Environment env, Context ctx) {        return thresh;    }      /**     * Print     */    void printIndent(PrintStream out, int indent) {        for (int i = 0 ; i < indent ; i++) {            out.print("    ");        }    }    public void print(PrintStream out, int indent) {        if (labels != null) {            for (int i = labels.length; --i >= 0; )                out.print(labels[i] + ": ");        }    }    public void print(PrintStream out) {        print(out, 0);    }}