| java.lang.Object
 sun.tools.tree.Node
sun.tools.tree.Expression
All known Subclasses: sun.tools.tree.ThisExpression, sun.tools.tree.InlineNewInstanceExpression, sun.tools.tree.UnaryExpression, sun.tools.tree.TypeExpression, sun.tools.tree.InlineMethodExpression, sun.tools.tree.IdentifierExpression, sun.tools.tree.ConstantExpression,
| Expression | | public class Expression extends Node (Code) | | 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.
|
| Method Summary | |
| public Vset | check(Environment env, Context ctx, Vset vset, Hashtable exp)
| | public Vset | checkAmbigName(Environment env, Context ctx, Vset vset, Hashtable exp, UnaryExpression loc)
Check something that might be an AmbiguousName (refman 6.5.2).
A string of dot-separated identifiers might be, in order of preference:
a variable name followed by fields or types
a type name followed by fields or types
a package name followed a type and then fields or types
If a type name is found, it rewrites itself as a TypeExpression.
If a node decides it can only be a package prefix, it sets its
type to Type.tPackage. | | public Vset | checkAssignOp(Environment env, Context ctx, Vset vset, Hashtable exp, Expression outside)
| | public ConditionVars | checkCondition(Environment env, Context ctx, Vset vset, Hashtable exp)
Check a condition. | | public void | checkCondition(Environment env, Context ctx, Vset vset, Hashtable exp, ConditionVars cvars)
| | public Vset | checkInitializer(Environment env, Context ctx, Vset vset, Type t, Hashtable exp)
| | public Vset | checkLHS(Environment env, Context ctx, Vset vset, Hashtable exp)
| | public Vset | checkValue(Environment env, Context ctx, Vset vset, Hashtable exp)
| | public void | code(Environment env, Context ctx, Assembler asm)
| | void | codeAppend(Environment env, Context ctx, Assembler asm, ClassDeclaration sbClass, boolean needBuffer)
Convert this expression to a string and append it to the string
buffer on the top of the stack. | | void | codeBranch(Environment env, Context ctx, Assembler asm, Label lbl, boolean whenTrue)
| | void | codeConversion(Environment env, Context ctx, Assembler asm, Type f, Type t)
| | void | codeDup(Environment env, Context ctx, Assembler asm, int items, int depth)
| | int | codeLValue(Environment env, Context ctx, Assembler asm)
| | void | codeLoad(Environment env, Context ctx, Assembler asm)
| | void | codeStore(Environment env, Context ctx, Assembler asm)
| | public void | codeValue(Environment env, Context ctx, Assembler asm)
| | public Expression | copyInline(Context ctx)
| | public int | costInline(int thresh, Environment env, Context ctx)
The cost of inlining this expression. | | void | ensureString(Environment env, Context ctx, Assembler asm)
Convert this expression to a string. | | public boolean | equals(int i)
Check if the expression is known to be equal to a given value. | | public boolean | equals(boolean b)
| | public boolean | equals(Identifier id)
| | public boolean | equals(String s)
| | public boolean | equalsDefault()
| | Expression | eval()
Evaluate.
Attempt to compute the value of an expression node. | | public Expression | firstConstructor()
| | public boolean | fitsType(Environment env, Context ctx, Type t)
See if this expression fits in the given type.
This is useful because some larger numbers fit into
smaller types.
If it is an "int" constant expression, inline it, if necessary,
to examine its numerical value. | | public boolean | fitsType(Environment env, Type t)
| | public FieldUpdater | getAssigner(Environment env, Context ctx)
Return a FieldUpdater object to be used in updating the
value of the location denoted by this, 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. | | public Expression | getImplementation()
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.
This appears at present to be dead code, and is not called
from within javac. | | public Type | getType()
| | public FieldUpdater | getUpdater(Environment env, Context ctx)
Return a FieldUpdater object to be used in updating the value of the
location denoted by this, which must be an expression suitable for the
left-hand side of an assignment. | | public Object | getValue()
Return the constant value. | | public Expression | inline(Environment env, Context ctx)
Inline.
Recursively simplify each child of an expression node, destructively
replacing the child with the simplified result. | | public Expression | inlineLHS(Environment env, Context ctx)
| | public Expression | inlineValue(Environment env, Context ctx)
| | protected StringBuffer | inlineValueSB(Environment env, Context ctx, StringBuffer buffer)
Attempt to evaluate this expression. | | public boolean | isConstant()
Return true if constant, according to JLS 15.27. | | public boolean | isNonNull()
Check if the expression cannot be a null reference. | | public boolean | isNull()
Check if the expression must be a null reference. | | public Expression | order()
| | int | precedence()
| | public void | print(PrintStream out)
| | Expression | simplify()
Simplify.
Attempt to simplify an expression node by returning a semantically-
equivalent expression that is presumably less costly to execute. | | Type | toType(Environment env, Context ctx)
|
| Expression | | Expression(int op, long where, Type type)(Code) | | Constructor
|
| checkAmbigName | | public Vset checkAmbigName(Environment env, Context ctx, Vset vset, Hashtable exp, UnaryExpression loc)(Code) | | Check something that might be an AmbiguousName (refman 6.5.2).
A string of dot-separated identifiers might be, in order of preference:
a variable name followed by fields or types
a type name followed by fields or types
a package name followed a type and then fields or types
If a type name is found, it rewrites itself as a TypeExpression.
If a node decides it can only be a package prefix, it sets its
type to Type.tPackage. The caller must detect this
and act appropriately to verify the full package name.
|
| checkCondition | | public ConditionVars checkCondition(Environment env, Context ctx, Vset vset, Hashtable exp)(Code) | | 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.
|
| costInline | | public int costInline(int thresh, Environment env, Context ctx)(Code) | | 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.
|
| equals | | public boolean equals(int i)(Code) | | 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.
|
| equals | | public boolean equals(boolean b)(Code) | | |
| equalsDefault | | public boolean equalsDefault()(Code) | | Check if the expression is equal to its default static value
|
| eval | | Expression eval()(Code) | | 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.
|
| firstConstructor | | public Expression firstConstructor()(Code) | | Check if the first thing is a constructor invocation
|
| fitsType | | public boolean fitsType(Environment env, Context ctx, Type t)(Code) | | See if this expression fits in the given type.
This is useful because some larger numbers fit into
smaller types.
If it is an "int" constant expression, inline it, if necessary,
to examine its numerical value. See JLS 5.2 and 15.24.
|
| getAssigner | | public FieldUpdater getAssigner(Environment env, Context ctx)(Code) | | Return a FieldUpdater object to be used in updating the
value of the location denoted by this, 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.
Called during the checking phase.
|
| getImplementation | | public Expression getImplementation()(Code) | | 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.
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.
|
| getUpdater | | public FieldUpdater getUpdater(Environment env, Context ctx)(Code) | | Return a FieldUpdater object to be used in updating the value of the
location denoted by this, 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.
Called during the checking phase.
|
| getValue | | public Object getValue()(Code) | | Return the constant value.
|
| inline | | public Expression inline(Environment env, Context ctx)(Code) | | 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.
|
| inlineValueSB | | protected StringBuffer inlineValueSB(Environment env, Context ctx, StringBuffer buffer)(Code) | | 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.
|
| isConstant | | public boolean isConstant()(Code) | | Return true if constant, according to JLS 15.27.
A constant expression must inline away to a literal constant.
|
| isNonNull | | public boolean isNonNull()(Code) | | Check if the expression cannot be a null reference.
|
| isNull | | public boolean isNull()(Code) | | Check if the expression must be a null reference.
|
| precedence | | int precedence()(Code) | | Return the precedence of the operator
|
| simplify | | Expression simplify()(Code) | | 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.
|
|
|