/*
* Copyright (c) 1997, 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.tree.*;
import sun.tools.asm.Assembler;
/**
* A reference from one scope to another.
*
* 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 UplevelReference implements Constants {
/**
* The class in which the reference occurs.
*/
ClassDefinition client;
/**
* The field being referenced.
* It is always a final argument or a final local variable.
* (An uplevel reference to a field of a class C is fetched
* through an implicit uplevel reference to C.this, which is
* an argument.)
*/
LocalMember target;
/**
* The local variable which bears a copy of the target's value,
* for all methods of the client class.
* Its name is "this$C" for <code>this.C</code> or
* "val$x" for other target variables <code>x</code>.
* <p>
* This local variable is always a constructor argument,
* and is therefore usable only in the constructor and in initializers.
* All other methods use the local field.
* @see #localField
*/
LocalMember localArgument;
/**
* A private synthetic field of the client class which
* bears a copy of the target's value.
* The compiler tries to avoid creating it if possible.
* The field has the same name and type as the localArgument.
* @see #localArgument
*/
MemberDefinition localField;
/**
* The next item on the references list of the client.
*/
UplevelReference next;
/**
* constructor
*/
public UplevelReference(ClassDefinition client, LocalMember target) {
this.client = client;
this.target = target;
// Choose a name and build a variable declaration node.
Identifier valName;
if (target.getName().equals(idThis)) {
ClassDefinition tc = target.getClassDefinition();
// It should always be true that tc.enclosingClassOf(client).
// If it were false, the numbering scheme would fail
// to produce unique names, since we'd be trying
// to number classes which were not in the sequence
// of enclosing scopes. The next paragraph of this
// code robustly deals with that possibility, however,
// by detecting name collisions and perturbing the names.
int depth = 0;
for (ClassDefinition pd = tc; !pd.isTopLevel(); pd = pd.getOuterClass()) {
// The inner classes specification states that the name of
// a private field containing a reference to the outermost
// enclosing instance is named "this$0". That outermost
// enclosing instance is always the innermost toplevel class.
depth += 1;
}
// In this example, T1,T2,T3 are all top-level (static),
// while I4,I5,I6,I7 are all inner. Each of the inner classes
// will have a single up-level "this$N" reference to the next
// class out. Only the outermost "this$0" will refer to a
// top-level class, T3.
//
// class T1 {
// static class T2 {
// static class T3 {
// class I4 {
// class I5 {
// class I6 {
// // at this point we have these fields in various places:
// // I4 this$0; I5 this$1; I6 this$2;
// }
// }
// class I7 {
// // I4 this$0; I7 this$1;
// }
// }
// }
// }
// }
valName = Identifier.lookup(prefixThis + depth);
} else {
valName = Identifier.lookup(prefixVal + target.getName());
}
// Make reasonably certain that valName is unique to this client.
// (This check can be fooled by malicious naming of explicit
// constructor arguments, or of inherited fields.)
Identifier base = valName;
int tick = 0;
while (true) {
boolean failed = (client.getFirstMatch(valName) != null);
for (UplevelReference r = client.getReferences();
r != null; r = r.next) {
if (r.target.getName().equals(valName)) {
failed = true;
}
}
if (!failed) {
break;
}
// try another name
valName = Identifier.lookup(base + "$" + (++tick));
}
// Build the constructor argument.
// Like "this", it wil be shared equally by all constructors of client.
localArgument = new LocalMember(target.getWhere(),
client,
M_FINAL | M_SYNTHETIC,
target.getType(),
valName);
}
/**
* Insert self into a list of references.
* Maintain "isEarlierThan" as an invariant of the list.
* This is important (a) to maximize stability of signatures,
* and (b) to allow uplevel "this" parameters to come at the
* front of every argument list they appear in.
*/
public UplevelReference insertInto(UplevelReference references) {
if (references == null || isEarlierThan(references)) {
next = references;
return this;
} else {
UplevelReference prev = references;
while (!(prev.next == null || isEarlierThan(prev.next))) {
prev = prev.next;
}
next = prev.next;
prev.next = this;
return references;
}
}
/**
* Tells if self precedes the other in the canonical ordering.
*/
public final boolean isEarlierThan(UplevelReference other) {
// Outer fields always come first.
if (isClientOuterField()) {
return true;
} else if (other.isClientOuterField()) {
return false;
}
// Now it doesn't matter what the order is; use string comparison.
LocalMember target2 = other.target;
Identifier name = target.getName();
Identifier name2 = target2.getName();
int cmp = name.toString().compareTo(name2.toString());
if (cmp != 0) {
return cmp < 0;
}
Identifier cname = target.getClassDefinition().getName();
Identifier cname2 = target2.getClassDefinition().getName();
int ccmp = cname.toString().compareTo(cname2.toString());
return ccmp < 0;
}
/**
* the target of this reference
*/
public final LocalMember getTarget() {
return target;
}
/**
* the local argument for this reference
*/
public final LocalMember getLocalArgument() {
return localArgument;
}
/**
* the field allocated in the client for this reference
*/
public final MemberDefinition getLocalField() {
return localField;
}
/**
* Get the local field, creating one if necessary.
* The client class must not be frozen.
*/
public final MemberDefinition getLocalField(Environment env) {
if (localField == null) {
makeLocalField(env);
}
return localField;
}
/**
* the client class
*/
public final ClassDefinition getClient() {
return client;
}
/**
* the next reference in the client's list
*/
public final UplevelReference getNext() {
return next;
}
/**
* Tell if this uplevel reference is the up-level "this" pointer
* of an inner class. Such references are treated differently
* than others, because they affect constructor calls across
* compilation units.
*/
public boolean isClientOuterField() {
MemberDefinition outerf = client.findOuterMember();
return (outerf != null) && (localField == outerf);
}
/**
* Tell if my local argument is directly available in this context.
* If not, the uplevel reference will have to be via a class field.
* <p>
* This must be called in a context which is local
* to the client of the uplevel reference.
*/
public boolean localArgumentAvailable(Environment env, Context ctx) {
MemberDefinition reff = ctx.field;
if (reff.getClassDefinition() != client) {
throw new CompilerError("localArgumentAvailable");
}
return ( reff.isConstructor()
|| reff.isVariable()
|| reff.isInitializer() );
}
/**
* Process an uplevel reference.
* The only decision to make at this point is whether
* to build a "localField" instance variable, which
* is done (lazily) when localArgumentAvailable() proves false.
*/
public void noteReference(Environment env, Context ctx) {
if (localField == null && !localArgumentAvailable(env, ctx)) {
// We need an instance variable unless client is a constructor.
makeLocalField(env);
}
}
private void makeLocalField(Environment env) {
// Cannot alter decisions like this one at a late date.
client.referencesMustNotBeFrozen();
int mod = M_PRIVATE | M_FINAL | M_SYNTHETIC;
localField = env.makeMemberDefinition(env,
localArgument.getWhere(),
client, null,
mod,
localArgument.getType(),
localArgument.getName(),
null, null, null);
}
/**
* Assuming noteReference() is all taken care of,
* build an uplevel reference.
* <p>
* This must be called in a context which is local
* to the client of the uplevel reference.
*/
public Expression makeLocalReference(Environment env, Context ctx) {
if (ctx.field.getClassDefinition() != client) {
throw new CompilerError("makeLocalReference");
}
if (localArgumentAvailable(env, ctx)) {
return new IdentifierExpression(0, localArgument);
} else {
return makeFieldReference(env, ctx);
}
}
/**
* As with makeLocalReference(), build a locally-usable reference.
* Ignore the availability of local arguments; always use a class field.
*/
public Expression makeFieldReference(Environment env, Context ctx) {
Expression e = ctx.findOuterLink(env, 0, localField);
return new FieldExpression(0, e, localField);
}
/**
* During the inline phase, call this on a list of references
* for which the code phase will later emit arguments.
* It will make sure that any "double-uplevel" values
* needed by the callee are also present at the call site.
* <p>
* If any reference is a "ClientOuterField", it is skipped
* by this method (and by willCodeArguments). This is because
*/
public void willCodeArguments(Environment env, Context ctx) {
if (!isClientOuterField()) {
ctx.noteReference(env, target);
}
if (next != null) {
next.willCodeArguments(env, ctx);
}
}
/**
* Code is being generated for a call to a constructor of
* the client class. Push an argument for the constructor.
*/
public void codeArguments(Environment env, Context ctx, Assembler asm,
long where, MemberDefinition conField) {
if (!isClientOuterField()) {
Expression e = ctx.makeReference(env, target);
e.codeValue(env, ctx, asm);
}
if (next != null) {
next.codeArguments(env, ctx, asm, where, conField);
}
}
/**
* Code is being generated for a constructor of the client class.
* Emit code which initializes the instance.
*/
public void codeInitialization(Environment env, Context ctx, Assembler asm,
long where, MemberDefinition conField) {
// If the reference is a clientOuterField, then the initialization
// code is generated in MethodExpression.makeVarInits().
// (Fix for bug 4075063.)
if (localField != null && !isClientOuterField()) {
Expression e = ctx.makeReference(env, target);
Expression f = makeFieldReference(env, ctx);
e = new AssignExpression(e.getWhere(), f, e);
e.type = localField.getType();
e.code(env, ctx, asm);
}
if (next != null) {
next.codeInitialization(env, ctx, asm, where, conField);
}
}
public String toString() {
return "[" + localArgument + " in " + client + "]";
}
}