/*

 * Copyright (c) 1994, 2013, 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.java;

/**

 * This class represents an Java class declaration. It refers

 * to either a binary or source definition.

 *

 * ClassDefinitions are loaded on demand, this means that

 * class declarations are late bound. The definition of the

 * class is obtained in stages. The status field describes

 * the state of the class definition:

 *

 * CS_UNDEFINED - the definition is not yet loaded

 * CS_UNDECIDED - a binary definition is loaded, but it is

 *                still unclear if the source definition need to

 *                be loaded

 * CS_BINARY    - the binary class is loaded

 * CS_PARSED    - the class is loaded from the source file, the

 *                type information is available, but the class has

 *                not yet been compiled.

 * CS_CHECKED   - the class is loaded from the source file and has

 *                been type-checked.

 * CS_COMPILED  - the class has been type checked, compiled,

 *                and written out.

 * CS_NOTFOUND  - no class definition could be found

 *

 * 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 final

class ClassDeclaration implements Constants {

    int status;

    Type type;

    ClassDefinition definition;

    /**

     * Constructor

     */

    public ClassDeclaration(Identifier name) {

        this.type = Type.tClass(name);

    }

    /**

     * Get the status of the class

     */

    public int getStatus() {

        return status;

    }

    /**

     * Get the name of the class

     */

    public Identifier getName() {

       return type.getClassName();

    }

    /**

     * Get the type of the class

     */

    public Type getType() {

        return type;

    }

    /**

     * Check if the class is defined

     */

    public boolean isDefined() {

        switch (status) {

          case CS_BINARY:

          case CS_PARSED:

          case CS_CHECKED:

          case CS_COMPILED:

            return true;

        }

        return false;

    }

    /**

     * Get the definition of this class. Returns null if

     * the class is not yet defined.

     */

    public ClassDefinition getClassDefinition() {

        return definition;

    }

    /**

     * This is a flag for use by getClassDefinition(env).  It is

     * used to mark that a class has been successfully looked up

     * by that method before.

     */

    private boolean found = false;

    /**

     * Get the definition of this class, if the class is not

     * yet defined, load the definition. Loading a class may

     * throw various exceptions.

     */

    public ClassDefinition getClassDefinition(Environment env)

    throws ClassNotFound {

        if (tracing) env.dtEvent("getClassDefinition: " +

                                 getName() + ", status " + getStatus());

        // The majority of calls to getClassDefinition() are duplicates.

        // This check makes them fast.  It also allows us to avoid

        // duplicate, useless calls to basicCheck().  In the future it

        // would be good to add an additional status value, CS_BASICCHECKED.

        if (found) {

            return definition;

        }

        for(;;) {

            switch (status) {

                case CS_UNDEFINED:

                case CS_UNDECIDED:

                case CS_SOURCE:

                    env.loadDefinition(this);

                    break;

                case CS_BINARY:

                case CS_PARSED:

                    //+FIX FOR BUGID 4056065

                    //definition.basicCheck(env);

                    if (!definition.isInsideLocal()) {

                        // Classes inside a block, including anonymous classes,

                        // are checked when their surrounding member is checked.

                        definition.basicCheck(env);

                    }

                    //-FIX FOR BUGID 4056065

                    found = true;

                    return definition;

                case CS_CHECKED:

                case CS_COMPILED:

                    found = true;

                    return definition;

                default:

                    throw new ClassNotFound(getName());

                }

        }

    }

    /**

     * Get the definition of this class, if the class is not

     * yet defined, load the definition. Loading a class may

     * throw various exceptions.  Perform no basicCheck() on this

     * class.

     */

    public ClassDefinition getClassDefinitionNoCheck(Environment env) throws ClassNotFound {

        if (tracing) env.dtEvent("getClassDefinition: " +

                                 getName() + ", status " + getStatus());

        for(;;) {

            switch (status) {

                case CS_UNDEFINED:

                case CS_UNDECIDED:

                case CS_SOURCE:

                    env.loadDefinition(this);

                    break;

                case CS_BINARY:

                case CS_PARSED:

                case CS_CHECKED:

                case CS_COMPILED:

                    return definition;

                default:

                    throw new ClassNotFound(getName());

                }

        }

    }

   /**

     * Set the class definition

     */

    public void setDefinition(ClassDefinition definition, int status) {

        // Sanity checks.

        // The name of the definition should match that of the declaration.

        if ((definition != null) && !getName().equals(definition.getName())) {

            throw new CompilerError("setDefinition: name mismatch: " +

                                    this + ", " + definition);

        }

        // The status states can be considered ordered in the same

        // manner as their numerical values. We expect classes to

        // progress through a sequence of monotonically increasing

        // states. NOTE: There are currently exceptions to this rule

        // which are believed to be legitimate.  In particular, a

        // class may be checked more than once, though we believe that

        // this is unnecessary and may be avoided.

        /*-----------------*

        if (status <= this.status) {

            System.out.println("STATUS REGRESSION: " +

                               this + " FROM " + this.status + " TO " + status);

        }

        *------------------*/

        this.definition = definition;

        this.status = status;

    }

    /**

     * Equality

     */

    public boolean equals(Object obj) {

        if (obj instanceof ClassDeclaration) {

            return type.equals(((ClassDeclaration)obj).type);

        }

        return false;

    }

    @Override

    public int hashCode() {

        return type.hashCode();

    }

    /**

     * toString

     */

    public String toString() {

        String name = getName().toString();

        String type = "type ";

        String nested = getName().isInner() ? "nested " : "";

        if (getClassDefinition() != null) {

            if (getClassDefinition().isInterface()) {

                type = "interface ";

            } else {

                type = "class ";

            }

            if (!getClassDefinition().isTopLevel()) {

                nested = "inner ";

                if (getClassDefinition().isLocal()) {

                    nested = "local ";

                    if (!getClassDefinition().isAnonymous()) {

                        name = getClassDefinition().getLocalName() +

                            " (" + name + ")";

                    }

                }

            }

        }

        return nested + type + name;

    }

}