JDK14/Java14源码在线阅读
/*
* 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.LocalVariable;
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 IdentifierExpression extends Expression {
Identifier id;
MemberDefinition field;
Expression implementation;
/**
* Constructor
*/
public IdentifierExpression(long where, Identifier id) {
super(IDENT, where, Type.tError);
this.id = id;
}
public IdentifierExpression(IdentifierToken id) {
this(id.getWhere(), id.getName());
}
public IdentifierExpression(long where, MemberDefinition field) {
super(IDENT, where, field.getType());
this.id = field.getName();
this.field = field;
}
public Expression getImplementation() {
if (implementation != null)
return implementation;
return this;
}
/**
* Check if the expression is equal to a value
*/
public boolean equals(Identifier id) {
return this.id.equals(id);
}
/**
* Assign a value to this identifier. [It must already be "bound"]
*/
private Vset assign(Environment env, Context ctx, Vset vset) {
if (field.isLocal()) {
LocalMember local = (LocalMember)field;
if (local.scopeNumber < ctx.frameNumber) {
env.error(where, "assign.to.uplevel", id);
}
if (local.isFinal()) {
// allow definite single assignment of blank finals
if (!local.isBlankFinal()) {
env.error(where, "assign.to.final", id);
} else if (!vset.testVarUnassigned(local.number)) {
env.error(where, "assign.to.blank.final", id);
}
}
vset.addVar(local.number);
local.writecount++;
} else if (field.isFinal()) {
vset = FieldExpression.checkFinalAssign(env, ctx, vset,
where, field);
}
return vset;
}
/**
* Get the value of this identifier. [ It must already be "bound"]
*/
private Vset get(Environment env, Context ctx, Vset vset) {
if (field.isLocal()) {
LocalMember local = (LocalMember)field;
if (local.scopeNumber < ctx.frameNumber && !local.isFinal()) {
env.error(where, "invalid.uplevel", id);
}
if (!vset.testVar(local.number)) {
env.error(where, "var.not.initialized", id);
vset.addVar(local.number);
}
local.readcount++;
} else {
if (!field.isStatic()) {
if (!vset.testVar(ctx.getThisNumber())) {
env.error(where, "access.inst.before.super", id);
implementation = null;
}
}
if (field.isBlankFinal()) {
int number = ctx.getFieldNumber(field);
if (number >= 0 && !vset.testVar(number)) {
env.error(where, "var.not.initialized", id);
}
}
}
return vset;
}
/**
* Bind to a field
*/
boolean bind(Environment env, Context ctx) {
try {
field = ctx.getField(env, id);
if (field == null) {
for (ClassDefinition cdef = ctx.field.getClassDefinition();
cdef != null; cdef = cdef.getOuterClass()) {
if (cdef.findAnyMethod(env, id) != null) {
env.error(where, "invalid.var", id,
ctx.field.getClassDeclaration());
return false;
}
}
env.error(where, "undef.var", id);
return false;
}
type = field.getType();
// Check access permission
if (!ctx.field.getClassDefinition().canAccess(env, field)) {
env.error(where, "no.field.access",
id, field.getClassDeclaration(),
ctx.field.getClassDeclaration());
return false;
}
// Find out how to access this variable.
if (field.isLocal()) {
LocalMember local = (LocalMember)field;
if (local.scopeNumber < ctx.frameNumber) {
// get a "val$x" copy via the current object
implementation = ctx.makeReference(env, local);
}
} else {
MemberDefinition f = field;
if (f.reportDeprecated(env)) {
env.error(where, "warn.field.is.deprecated",
id, f.getClassDefinition());
}
ClassDefinition fclass = f.getClassDefinition();
if (fclass != ctx.field.getClassDefinition()) {
// Maybe an inherited field hides an apparent variable.
MemberDefinition f2 = ctx.getApparentField(env, id);
if (f2 != null && f2 != f) {
ClassDefinition c = ctx.findScope(env, fclass);
if (c == null) c = f.getClassDefinition();
if (f2.isLocal()) {
env.error(where, "inherited.hides.local",
id, c.getClassDeclaration());
} else {
env.error(where, "inherited.hides.field",
id, c.getClassDeclaration(),
f2.getClassDeclaration());
}
}
}
// Rewrite as a FieldExpression.
// Access methods for private fields, if needed, will be added
// during subsequent processing of the FieldExpression. See
// method 'FieldExpression.checkCommon'. This division of labor
// is somewhat awkward, as most further processing of a
// FieldExpression during the checking phase is suppressed when
// the referenced field is pre-set as it is here.
if (f.isStatic()) {
Expression base = new TypeExpression(where,
f.getClassDeclaration().getType());
implementation = new FieldExpression(where, null, f);
} else {
Expression base = ctx.findOuterLink(env, where, f);
if (base != null) {
implementation = new FieldExpression(where, base, f);
}
}
}
// Check forward reference
if (!ctx.canReach(env, field)) {
env.error(where, "forward.ref",
id, field.getClassDeclaration());
return false;
}
return true;
} catch (ClassNotFound e) {
env.error(where, "class.not.found", e.name, ctx.field);
} catch (AmbiguousMember e) {
env.error(where, "ambig.field", id,
e.field1.getClassDeclaration(),
e.field2.getClassDeclaration());
}
return false;
}
/**
* Check expression
*/
public Vset checkValue(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) {
if (field != null) {
// An internally pre-set field, such as an argument copying
// an uplevel value. Do not re-check it.
return vset;
}
if (bind(env, ctx)) {
vset = get(env, ctx, vset);
ctx.field.getClassDefinition().addDependency(field.getClassDeclaration());
if (implementation != null)
vset = implementation.checkValue(env, ctx, vset, exp);
}
return vset;
}
/**
* Check the expression if it appears on the LHS of an assignment
*/
public Vset checkLHS(Environment env, Context ctx,
Vset vset, Hashtable<Object, Object> exp) {
if (!bind(env, ctx))
return vset;
vset = assign(env, ctx, vset);
if (implementation != null)
vset = implementation.checkValue(env, ctx, vset, exp);
return vset;
}
/**
* Check the expression if it appears on the LHS of an op= expression
*/
public Vset checkAssignOp(Environment env, Context ctx,
Vset vset, Hashtable<Object, Object> exp, Expression outside) {
if (!bind(env, ctx))
return vset;
vset = assign(env, ctx, get(env, ctx, vset));
if (implementation != null)
vset = implementation.checkValue(env, ctx, vset, exp);
return vset;
}
/**
* Return an accessor if one is needed for assignments to this expression.
*/
public FieldUpdater getAssigner(Environment env, Context ctx) {
if (implementation != null)
return implementation.getAssigner(env, ctx);
return null;
}
/**
* Return an updater if one is needed for assignments to this expression.
*/
public FieldUpdater getUpdater(Environment env, Context ctx) {
if (implementation != null)
return implementation.getUpdater(env, ctx);
return null;
}
/**
* Check if the present name is part of a scoping prefix.
*/
public Vset checkAmbigName(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp,
UnaryExpression loc) {
try {
if (ctx.getField(env, id) != null) {
// if this is a local field, there's nothing more to do.
return checkValue(env, ctx, vset, exp);
}
} catch (ClassNotFound ee) {
} catch (AmbiguousMember ee) {
}
// Can this be interpreted as a type?
ClassDefinition c = toResolvedType(env, ctx, true);
// Is it a real type??
if (c != null) {
loc.right = new TypeExpression(where, c.getType());
return vset;
}
// We hope it is a package prefix. Let the caller decide.
type = Type.tPackage;
return vset;
}
/**
* Convert an identifier to a known type, or null.
*/
private ClassDefinition toResolvedType(Environment env, Context ctx,
boolean pkgOK) {
Identifier rid = ctx.resolveName(env, id);
Type t = Type.tClass(rid);
if (pkgOK && !env.classExists(t)) {
return null;
}
if (env.resolve(where, ctx.field.getClassDefinition(), t)) {
try {
ClassDefinition c = env.getClassDefinition(t);
// Maybe an inherited class hides an apparent class.
if (c.isMember()) {
ClassDefinition sc = ctx.findScope(env, c.getOuterClass());
if (sc != c.getOuterClass()) {
Identifier rid2 = ctx.getApparentClassName(env, id);
if (!rid2.equals(idNull) && !rid2.equals(rid)) {
env.error(where, "inherited.hides.type",
id, sc.getClassDeclaration());
}
}
}
if (!c.getLocalName().equals(id.getFlatName().getName())) {
env.error(where, "illegal.mangled.name", id, c);
}
return c;
} catch (ClassNotFound ee) {
}
}
return null;
}
/**
* Convert an identifier to a type.
* If one is not known, use the current package as a qualifier.
*/
Type toType(Environment env, Context ctx) {
ClassDefinition c = toResolvedType(env, ctx, false);
if (c != null) {
return c.getType();
}
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. We do not necessarily know where the package prefix ends,
* so we operate similarly to 'checkAmbiguousName'. This is the
* base case -- the first component of the qualified name.
*/
/*-------------------------------------------------------*
Type toQualifiedType(Environment env, Context ctx) {
// We do not look for non-type fields. Is this correct?
ClassDefinition c = toResolvedType(env, ctx, true);
// Is it a real type?
if (c != null) {
return c.getType();
}
// We hope it is a package prefix. Let the caller decide.
return Type.tPackage;
}
*-------------------------------------------------------*/
/**
* Check if constant: Will it inline away?
*/
public boolean isConstant() {
if (implementation != null)
return implementation.isConstant();
if (field != null) {
return field.isConstant();
}
return false;
}
/**
* Inline
*/
public Expression inline(Environment env, Context ctx) {
return null;
}
public Expression inlineValue(Environment env, Context ctx) {
if (implementation != null)
return implementation.inlineValue(env, ctx);
if (field == null) {
return this;
}
try {
if (field.isLocal()) {
if (field.isInlineable(env, false)) {
Expression e = (Expression)field.getValue(env);
return (e == null) ? this : e.inlineValue(env, ctx);
}
return this;
}
return this;
} catch (ClassNotFound e) {
throw new CompilerError(e);
}
}
public Expression inlineLHS(Environment env, Context ctx) {
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java