Back to index...

	/*
	* 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 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 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 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 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) {
	if (implementation != null)
	return implementation.inlineLHS(env, ctx);
	return this;
	}

	public Expression copyInline(Context ctx) {
	if (implementation != null)
	return implementation.copyInline(ctx);
	IdentifierExpression e =
	(IdentifierExpression)super.copyInline(ctx);
	if (field != null && field.isLocal()) {
	e.field = ((LocalMember)field).getCurrentInlineCopy(ctx);
	}
	return e;
	}

	public int costInline(int thresh, Environment env, Context ctx) {
	if (implementation != null)
	return implementation.costInline(thresh, env, ctx);
	return super.costInline(thresh, env, ctx);
	}

	/**
	* Code local vars (object fields have been inlined away)
	*/
	int codeLValue(Environment env, Context ctx, Assembler asm) {
	return 0;
	}
	void codeLoad(Environment env, Context ctx, Assembler asm) {
	asm.add(where, opc_iload + type.getTypeCodeOffset(),
	new Integer(((LocalMember)field).number));
	}
	void codeStore(Environment env, Context ctx, Assembler asm) {
	LocalMember local = (LocalMember)field;
	asm.add(where, opc_istore + type.getTypeCodeOffset(),
	new LocalVariable(local, local.number));
	}
	public void codeValue(Environment env, Context ctx, Assembler asm) {
	codeLValue(env, ctx, asm);
	codeLoad(env, ctx, asm);
	}

	/**
	* Print
	*/
	public void print(PrintStream out) {
	out.print(id + "#" + ((field != null) ? field.hashCode() : 0));
	if (implementation != null) {
	out.print("/IMPL=");
	implementation.print(out);
	}
	}
	}

Back to index...