/*

 * 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(),

    }

    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);

        }

    }