Back to index...

	/*
	* 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.Label;
	import sun.tools.asm.Assembler;
	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 Expression extends Node {
	Type type;

	/**
	* Constructor
	*/
	Expression(int op, long where, Type type) {
	super(op, where);
	this.type = type;
	}

	/**
	* Type checking may assign a more complex implementation
	* to an innocuous-looking expression (like an identifier).
	* Return that implementation, or the original expression itself
	* if there is no special implementation.
	* <p>
	* This appears at present to be dead code, and is not called
	* from within javac. Access to the implementation generally
	* occurs within the same class, and thus uses the underlying
	* field directly.
	*/
	public Expression getImplementation() {
	return this;
	}

	public Type getType() {
	return type;
	}

	/**
	* Return the precedence of the operator
	*/
	int precedence() {
	return (op < opPrecedence.length) ? opPrecedence[op] : 100;
	}

	/**
	* Order the expression based on precedence
	*/
	public Expression order() {
	return this;
	}

	/**
	* Return true if constant, according to JLS 15.27.
	* A constant expression must inline away to a literal constant.
	*/
	public boolean isConstant() {
	return false;
	}

	/**
	* Return the constant value.
	*/
	public Object getValue() {
	return null;
	}

	/**
	* Check if the expression is known to be equal to a given value.
	* Returns false for any expression other than a literal constant,
	* thus should be called only after simplification (inlining) has
	* been performed.
	*/
	public boolean equals(int i) {
	return false;
	}
	public boolean equals(boolean b) {
	return false;
	}
	public boolean equals(Identifier id) {
	return false;
	}
	public boolean equals(String s) {
	return false;
	}

	/**
	* Check if the expression must be a null reference.
	*/
	public boolean isNull() {
	return false;
	}

	/**
	* Check if the expression cannot be a null reference.
	*/
	public boolean isNonNull() {
	return false;
	}

	/**
	* Check if the expression is equal to its default static value
	*/
	public boolean equalsDefault() {
	return false;
	}


	/**
	* Convert an expresion to a type
	*/
	Type toType(Environment env, Context ctx) {
	env.error(where, "invalid.type.expr");
	return Type.tError;
	}

	/**
	* Convert an expresion to a type in a context where a qualified
	* type name is expected, e.g., in the prefix of a qualified type
	* name.
	*/
	/-----------------------------------------------------
	Type toQualifiedType(Environment env, Context ctx) {
	env.error(where, "invalid.type.expr");
	return Type.tError;
	}
	-----------------------------------------------------/

	/**
	* See if this expression fits in the given type.
	* This is useful because some larger numbers fit into
	* smaller types.
	* <p>
	* If it is an "int" constant expression, inline it, if necessary,
	* to examine its numerical value. See JLS 5.2 and 15.24.
	*/
	public boolean fitsType(Environment env, Context ctx, Type t) {
	try {
	if (env.isMoreSpecific(this.type, t)) {
	return true;
	}
	if (this.type.isType(TC_INT) && this.isConstant() && ctx != null) {
	// Tentative inlining is harmless for constant expressions.
	Expression n = this.inlineValue(env, ctx);
	if (n != this && n instanceof ConstantExpression) {
	return n.fitsType(env, ctx, t);
	}
	}
	return false;
	} catch (ClassNotFound e) {
	return false;
	}
	}

	/** @deprecated (for backward compatibility) */
	@Deprecated
	public boolean fitsType(Environment env, Type t) {
	return fitsType(env, (Context) null, t);
	}

	/**
	* Check an expression
	*/
	public Vset checkValue(Environment env, Context ctx, Vset vset, Hashtable exp) {
	return vset;
	}
	public Vset checkInitializer(Environment env, Context ctx, Vset vset, Type t, Hashtable exp) {
	return checkValue(env, ctx, vset, exp);
	}
	public Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) {
	throw new CompilerError("check failed");
	}

	public Vset checkLHS(Environment env, Context ctx,
	Vset vset, Hashtable exp) {
	env.error(where, "invalid.lhs.assignment");
	type = Type.tError;
	return vset;
	}

	/**
	* Return a <code>FieldUpdater</code> object to be used in updating the
	* value of the location denoted by <code>this</code>, which must be an
	* expression suitable for the left-hand side of an assignment.
	* This is used for implementing assignments to private fields for which
	* an access method is required. Returns null if no access method is
	* needed, in which case the assignment is handled in the usual way, by
	* direct access. Only simple assignment expressions are handled here
	* Assignment operators and pre/post increment/decrement operators are
	* are handled by 'getUpdater' below.
	* <p>
	* Called during the checking phase.
	*/

	public FieldUpdater getAssigner(Environment env, Context ctx) {
	throw new CompilerError("getAssigner lhs");
	}

	/**
	* Return a <code>FieldUpdater</code> object to be used in updating the value of the
	* location denoted by <code>this</code>, which must be an expression suitable for the
	* left-hand side of an assignment. This is used for implementing the assignment
	* operators and the increment/decrement operators on private fields that require an
	* access method, e.g., uplevel from an inner class. Returns null if no access method
	* is needed.
	* <p>
	* Called during the checking phase.
	*/

	public FieldUpdater getUpdater(Environment env, Context ctx) {
	throw new CompilerError("getUpdater lhs");
	}

	public Vset checkAssignOp(Environment env, Context ctx,
	Vset vset, Hashtable exp, Expression outside) {
	if (outside instanceof IncDecExpression)
	env.error(where, "invalid.arg", opNames[outside.op]);
	else
	env.error(where, "invalid.lhs.assignment");
	type = Type.tError;
	return vset;
	}

	/**
	* Check something that might be an AmbiguousName (refman 6.5.2).
	* A string of dot-separated identifiers might be, in order of preference:
	* <nl>
	* <li> a variable name followed by fields or types
	* <li> a type name followed by fields or types
	* <li> a package name followed a type and then fields or types
	* </nl>
	* If a type name is found, it rewrites itself as a <tt>TypeExpression</tt>.
	* If a node decides it can only be a package prefix, it sets its
	* type to <tt>Type.tPackage</tt>. The caller must detect this
	* and act appropriately to verify the full package name.
	* @arg loc the expression containing the ambiguous expression
	*/
	public Vset checkAmbigName(Environment env, Context ctx, Vset vset, Hashtable exp,
	UnaryExpression loc) {
	return checkValue(env, ctx, vset, exp);
	}

	/**
	* Check a condition. Return a ConditionVars(), which indicates when
	* which variables are set if the condition is true, and which are set if
	* the condition is false.
	*/
	public ConditionVars checkCondition(Environment env, Context ctx,
	Vset vset, Hashtable exp) {
	ConditionVars cvars = new ConditionVars();
	checkCondition(env, ctx, vset, exp, cvars);
	return cvars;
	}

	/*
	* Check a condition.
	*
	* cvars is modified so that
	* cvar.vsTrue indicates variables with a known value if result = true
	* cvars.vsFalse indicates variables with a known value if !result
	*
	* The default action is to simply call checkValue on the expression, and
	* to see both vsTrue and vsFalse to the result.
	*/

	public void checkCondition(Environment env, Context ctx,
	Vset vset, Hashtable exp, ConditionVars cvars) {
	cvars.vsTrue = cvars.vsFalse = checkValue(env, ctx, vset, exp);
	// unshare side effects:
	cvars.vsFalse = cvars.vsFalse.copy();
	}

	/**
	* Evaluate.
	*
	* Attempt to compute the value of an expression node. If all operands are
	* literal constants of the same kind (e.g., IntegerExpression nodes), a
	* new constant node of the proper type is returned representing the value
	* as computed at compile-time. Otherwise, the original node 'this' is
	* returned.
	*/
	Expression eval() {
	return this;
	}

	/**
	* Simplify.
	*
	* Attempt to simplify an expression node by returning a semantically-
	* equivalent expression that is presumably less costly to execute. There
	* is some overlap with the intent of 'eval', as compile-time evaluation of
	* conditional expressions and the short-circuit boolean operators is
	* performed here. Other simplifications include logical identities
	* involving logical negation and comparisons. If no simplification is
	* possible, the original node 'this' is returned. It is assumed that the
	* children of the node have previously been recursively simplified and
	* evaluated. A result of 'null' indicates that the expression may be
	* elided entirely.
	*/
	Expression simplify() {
	return this;
	}

	/**
	* Inline.
	*
	* Recursively simplify each child of an expression node, destructively
	* replacing the child with the simplified result. Also attempts to
	* simplify the current node 'this', and returns the simplified result.
	*
	* The name 'inline' is somthing of a misnomer, as these methods are
	* responsible for compile-time expression simplification in general.
	* The 'eval' and 'simplify' methods apply to a single expression node
	* only -- it is 'inline' and 'inlineValue' that drive the simplification
	* of entire expressions.
	*/
	public Expression inline(Environment env, Context ctx) {
	return null;
	}
	public Expression inlineValue(Environment env, Context ctx) {
	return this;
	}

	/**
	* Attempt to evaluate this expression. If this expression
	* yields a value, append it to the StringBuffer `buffer'.
	* If this expression cannot be evaluated at this time (for
	* example if it contains a division by zero, a non-constant
	* subexpression, or a subexpression which "refuses" to evaluate)
	* then return `null' to indicate failure.
	*
	* It is anticipated that this method will be called to evaluate
	* concatenations of compile-time constant strings. The call
	* originates from AddExpression#inlineValue().
	*
	* See AddExpression#inlineValueSB() for detailed comments.
	*/
	protected StringBuffer inlineValueSB(Environment env,
	Context ctx,
	StringBuffer buffer) {
	Expression inlined = inlineValue(env, ctx);
	Object val = inlined.getValue();

	if (val == null && !inlined.isNull()){
	// This (supposedly constant) expression refuses to yield
	// a value. This can happen, in particular, when we are
	// trying to evaluate a division by zero. It can also
	// happen in cases where isConstant() is able to classify
	// expressions as constant that the compiler's inlining
	// mechanisms aren't able to evaluate; this is rare,
	// and all such cases that we have found so far
	// (e.g. 4082814, 4106244) have been plugged up.
	//
	// We return a null to indicate that we have failed to
	// evaluate the concatenation.
	return null;
	}

	// For boolean and character expressions, getValue() returns
	// an Integer. We need to take care, when appending the result
	// of getValue(), that we preserve the type.
	// Fix for 4103959, 4102672.
	if (type == Type.tChar) {
	buffer.append((char)((Integer)val).intValue());
	} else if (type == Type.tBoolean) {
	buffer.append(((Integer)val).intValue() != 0);
	} else {
	buffer.append(val);
	}

	return buffer;
	}

	public Expression inlineLHS(Environment env, Context ctx) {
	return null;
	}

	/**
	* The cost of inlining this expression.
	* This cost controls the inlining of methods, and does not determine
	* the compile-time simplifications performed by 'inline' and friends.
	*/
	public int costInline(int thresh, Environment env, Context ctx) {
	return 1;
	}

	/**
	* Code
	*/
	void codeBranch(Environment env, Context ctx, Assembler asm, Label lbl, boolean whenTrue) {
	if (type.isType(TC_BOOLEAN)) {
	codeValue(env, ctx, asm);
	asm.add(where, whenTrue ? opc_ifne : opc_ifeq, lbl, whenTrue);
	} else {
	throw new CompilerError("codeBranch " + opNames[op]);
	}
	}
	public void codeValue(Environment env, Context ctx, Assembler asm) {
	if (type.isType(TC_BOOLEAN)) {
	Label l1 = new Label();
	Label l2 = new Label();

	codeBranch(env, ctx, asm, l1, true);
	asm.add(true, where, opc_ldc, new Integer(0));
	asm.add(true, where, opc_goto, l2);
	asm.add(l1);
	asm.add(true, where, opc_ldc, new Integer(1));
	asm.add(l2);
	} else {
	throw new CompilerError("codeValue");
	}
	}
	public void code(Environment env, Context ctx, Assembler asm) {
	codeValue(env, ctx, asm);

	switch (type.getTypeCode()) {
	case TC_VOID:
	break;

	case TC_DOUBLE:
	case TC_LONG:
	asm.add(where, opc_pop2);
	break;

	default:
	asm.add(where, opc_pop);
	break;
	}
	}
	int codeLValue(Environment env, Context ctx, Assembler asm) {
	print(System.out);
	throw new CompilerError("invalid lhs");
	}
	void codeLoad(Environment env, Context ctx, Assembler asm) {
	print(System.out);
	throw new CompilerError("invalid load");
	}
	void codeStore(Environment env, Context ctx, Assembler asm) {
	print(System.out);
	throw new CompilerError("invalid store");
	}

	/**
	* Convert this expression to a string.
	*/
	void ensureString(Environment env, Context ctx, Assembler asm)
	throws ClassNotFound, AmbiguousMember
	{
	if (type == Type.tString && isNonNull()) {
	return;
	}
	// Make sure it's a non-null string.
	ClassDefinition sourceClass = ctx.field.getClassDefinition();
	ClassDeclaration stClass = env.getClassDeclaration(Type.tString);
	ClassDefinition stClsDef = stClass.getClassDefinition(env);
	// FIX FOR 4071548
	// We use 'String.valueOf' to do the conversion, in order to
	// correctly handle null references and efficiently handle
	// primitive types. For reference types, we force the argument
	// to be interpreted as of 'Object' type, thus avoiding the
	// the special-case overloading of 'valueOf' for character arrays.
	// This special treatment would conflict with JLS 15.17.1.1.
	if (type.inMask(TM_REFERENCE)) {
	// Reference type
	if (type != Type.tString) {
	// Convert non-string object to string. If object is
	// a string, we don't need to convert it, except in the
	// case that it is null, which is handled below.
	Type argType1[] = {Type.tObject};
	MemberDefinition f1 =
	stClsDef.matchMethod(env, sourceClass, idValueOf, argType1);
	asm.add(where, opc_invokestatic, f1);
	}
	// FIX FOR 4030173
	// If the argument was null, then value is "null", but if the
	// argument was not null, 'toString' was called and could have
	// returned null. We call 'valueOf' again to make sure that
	// the result is a non-null string. See JLS 15.17.1.1. The
	// approach taken here minimizes code size -- open code would
	// be faster. The 'toString' method for an array class cannot
	// be overridden, thus we know that it will never return null.
	if (!type.inMask(TM_ARRAY\|TM_NULL)) {
	Type argType2[] = {Type.tString};
	MemberDefinition f2 =
	stClsDef.matchMethod(env, sourceClass, idValueOf, argType2);
	asm.add(where, opc_invokestatic, f2);
	}
	} else {
	// Primitive type
	Type argType[] = {type};
	MemberDefinition f =
	stClsDef.matchMethod(env, sourceClass, idValueOf, argType);
	asm.add(where, opc_invokestatic, f);
	}
	}

	/**
	* Convert this expression to a string and append it to the string
	* buffer on the top of the stack.
	* If the needBuffer argument is true, the string buffer needs to be
	* created, initialized, and pushed on the stack, first.
	*/
	void codeAppend(Environment env, Context ctx, Assembler asm,
	ClassDeclaration sbClass, boolean needBuffer)
	throws ClassNotFound, AmbiguousMember
	{
	ClassDefinition sourceClass = ctx.field.getClassDefinition();
	ClassDefinition sbClsDef = sbClass.getClassDefinition(env);
	MemberDefinition f;
	if (needBuffer) {
	// need to create the string buffer
	asm.add(where, opc_new, sbClass); // create the class
	asm.add(where, opc_dup);
	if (equals("")) {
	// make an empty string buffer
	f = sbClsDef.matchMethod(env, sourceClass, idInit);
	} else {
	// optimize by initializing the buffer with the string
	codeValue(env, ctx, asm);
	ensureString(env, ctx, asm);
	Type argType[] = {Type.tString};
	f = sbClsDef.matchMethod(env, sourceClass, idInit, argType);
	}
	asm.add(where, opc_invokespecial, f);
	} else {
	// append this item to the string buffer
	codeValue(env, ctx, asm);
	// FIX FOR 4071548
	// 'StringBuffer.append' converts its argument as if by
	// 'valueOf', treating character arrays specially. This
	// violates JLS 15.17.1.1, which requires that concatenation
	// convert non-primitive arguments using 'toString'. We force
	// the treatment of all reference types as type 'Object', thus
	// invoking an overloading of 'append' that has the required
	// semantics.
	Type argType[] =
	{ (type.inMask(TM_REFERENCE) && type != Type.tString)
	? Type.tObject
	: type };
	f = sbClsDef.matchMethod(env, sourceClass, idAppend, argType);
	asm.add(where, opc_invokevirtual, f);
	}
	}

	/**
	* Code
	*/
	void codeDup(Environment env, Context ctx, Assembler asm, int items, int depth) {
	switch (items) {
	case 0:
	return;

	case 1:
	switch (depth) {
	case 0:
	asm.add(where, opc_dup);
	return;
	case 1:
	asm.add(where, opc_dup_x1);
	return;
	case 2:
	asm.add(where, opc_dup_x2);
	return;

	}
	break;
	case 2:
	switch (depth) {
	case 0:
	asm.add(where, opc_dup2);
	return;
	case 1:
	asm.add(where, opc_dup2_x1);
	return;
	case 2:
	asm.add(where, opc_dup2_x2);
	return;

	}
	break;
	}
	throw new CompilerError("can't dup: " + items + ", " + depth);
	}

	void codeConversion(Environment env, Context ctx, Assembler asm, Type f, Type t) {
	int from = f.getTypeCode();
	int to = t.getTypeCode();

	switch (to) {
	case TC_BOOLEAN:
	if (from != TC_BOOLEAN) {
	break;
	}
	return;
	case TC_BYTE:
	if (from != TC_BYTE) {
	codeConversion(env, ctx, asm, f, Type.tInt);
	asm.add(where, opc_i2b);
	}
	return;
	case TC_CHAR:
	if (from != TC_CHAR) {
	codeConversion(env, ctx, asm, f, Type.tInt);
	asm.add(where, opc_i2c);
	}
	return;
	case TC_SHORT:
	if (from != TC_SHORT) {
	codeConversion(env, ctx, asm, f, Type.tInt);
	asm.add(where, opc_i2s);
	}
	return;
	case TC_INT:
	switch (from) {
	case TC_BYTE:
	case TC_CHAR:
	case TC_SHORT:
	case TC_INT:
	return;
	case TC_LONG:
	asm.add(where, opc_l2i);
	return;
	case TC_FLOAT:
	asm.add(where, opc_f2i);
	return;
	case TC_DOUBLE:
	asm.add(where, opc_d2i);
	return;
	}
	break;
	case TC_LONG:
	switch (from) {
	case TC_BYTE:
	case TC_CHAR:
	case TC_SHORT:
	case TC_INT:
	asm.add(where, opc_i2l);
	return;
	case TC_LONG:
	return;
	case TC_FLOAT:
	asm.add(where, opc_f2l);
	return;
	case TC_DOUBLE:
	asm.add(where, opc_d2l);
	return;
	}
	break;
	case TC_FLOAT:
	switch (from) {
	case TC_BYTE:
	case TC_CHAR:
	case TC_SHORT:
	case TC_INT:
	asm.add(where, opc_i2f);
	return;
	case TC_LONG:
	asm.add(where, opc_l2f);
	return;
	case TC_FLOAT:
	return;
	case TC_DOUBLE:
	asm.add(where, opc_d2f);
	return;
	}
	break;
	case TC_DOUBLE:
	switch (from) {
	case TC_BYTE:
	case TC_CHAR:
	case TC_SHORT:
	case TC_INT:
	asm.add(where, opc_i2d);
	return;
	case TC_LONG:
	asm.add(where, opc_l2d);
	return;
	case TC_FLOAT:
	asm.add(where, opc_f2d);
	return;
	case TC_DOUBLE:
	return;
	}
	break;

	case TC_CLASS:
	switch (from) {
	case TC_NULL:
	return;
	case TC_CLASS:
	case TC_ARRAY:
	try {
	if (!env.implicitCast(f, t)) {
	asm.add(where, opc_checkcast, env.getClassDeclaration(t));
	}
	} catch (ClassNotFound e) {
	throw new CompilerError(e);
	}
	return;
	}

	break;

	case TC_ARRAY:
	switch (from) {
	case TC_NULL:
	return;
	case TC_CLASS:
	case TC_ARRAY:
	try {
	if (!env.implicitCast(f, t)) {
	asm.add(where, opc_checkcast, t);
	}
	return;
	} catch (ClassNotFound e) {
	throw new CompilerError(e);
	}
	}
	break;
	}
	throw new CompilerError("codeConversion: " + from + ", " + to);
	}

	/**
	* Check if the first thing is a constructor invocation
	*/
	public Expression firstConstructor() {
	return null;
	}

	/**
	* Create a copy of the expression for method inlining
	*/
	public Expression copyInline(Context ctx) {
	return (Expression)clone();
	}

	/**
	* Print
	*/
	public void print(PrintStream out) {
	out.print(opNames[op]);
	}
	}

Back to index...