/*
* 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.
*/
public
class 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);
}
}