/*

 * Copyright (c) 1998, 2007, 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.

 */

/*

 * Licensed Materials - Property of IBM

 * RMI-IIOP v1.0

 * Copyright IBM Corp. 1998 1999  All Rights Reserved

 *

 */

package sun.rmi.rmic.iiop;

import java.util.Vector;

import sun.tools.java.Identifier;

import sun.tools.java.ClassNotFound;

import sun.tools.java.ClassDefinition;

import sun.tools.java.ClassDeclaration;

import sun.tools.java.MemberDefinition;

import sun.tools.java.CompilerError;

import sun.tools.tree.Node;

import sun.tools.tree.LocalMember;

import sun.tools.tree.CharExpression;

import sun.tools.tree.IntegerExpression;

import sun.rmi.rmic.IndentingWriter;

import java.io.IOException;

import java.util.HashSet;

import java.util.Enumeration;

import java.io.File;

/**

 * A CompoundType is an abstract base class for all IIOP class and

 * interface types.

 *

 * @author      Bryan Atsatt

 */

public abstract class CompoundType extends Type {

    protected Method[] methods;

    protected InterfaceType[] interfaces;

    protected Member[] members;

    protected ClassDefinition classDef;

    protected ClassDeclaration classDecl;

    protected boolean isCORBAObject = false;

    protected boolean isIDLEntity = false;

    protected boolean isAbstractBase = false;

    protected boolean isValueBase = false;

    protected boolean isCORBAUserException = false;

    protected boolean isException = false;

    protected boolean isCheckedException = false;

    protected boolean isRemoteExceptionOrSubclass = false;

    protected String idlExceptionName;

    protected String qualifiedIDLExceptionName;

    //_____________________________________________________________________

    // Public Interfaces

    //_____________________________________________________________________

    /**

     * Return true if this type implements

     * org.omg.CORBA.Object.

     */

    public boolean isCORBAObject () {

        return isCORBAObject;

    }

    /**

     * Return true if this type implements

     * org.omg.CORBA.portable.IDLEntity.

     */

    public boolean isIDLEntity () {

        return isIDLEntity;

    }

    /**

     * Return true if this type implements

     * org.omg.CORBA.portable.ValueBase.

     */

    public boolean isValueBase () {

        return isValueBase;

    }

    /**

     * Return true if this type is a CORBA

     * abstract interface.

     */

    public boolean isAbstractBase () {

        return isAbstractBase;

    }

    /**

     * Return true if this type is an exception.

     */

    public boolean isException () {

        return isException;

    }

    /**

     * Return true if this type is a "checked" exception.

     * Result if valid iff isException() returns true.

     */

    public boolean isCheckedException () {

        return isCheckedException;

    }

    /**

     * Return true if this type is a java.rmi.RemoteException

     * or one of its subclasses. Result if valid iff isException()

     * returns true.

     */

    public boolean isRemoteExceptionOrSubclass () {

        return isRemoteExceptionOrSubclass;

    }

    /**

     * Return true if this type is exactly

     * org.omg.CORBA.UserException.

     */

    public boolean isCORBAUserException () {

        return isCORBAUserException;

    }

    /**

     * Return true if this type implements

     * isIDLEntity() && isException().

     */

    public boolean isIDLEntityException () {

        return isIDLEntity() && isException();

    }

    /**

     * Return true if isIDLEntity() && !isValueBase()

     * && !isAbstractBase() && !isCORBAObject()

     * && !isIDLEntityException().

     */

    public boolean isBoxed () {

        return (isIDLEntity() && !isValueBase() &&

                !isAbstractBase() && !isCORBAObject() &&

                !isIDLEntityException());

    }

    /**

     * If this type represents an exception, return the

     * IDL name including the "Ex" mangling, otherwise

     * return null.

     */

    public String getIDLExceptionName () {

        return idlExceptionName;

    }

    /**

     * If this type represents an exception, return the

     * qualified IDL name including the "Ex" mangling,

     * otherwise return null.

     * @param global If true, prepends "::".

     */

    public String getQualifiedIDLExceptionName (boolean global) {

        if (qualifiedIDLExceptionName != null &&

            global &&

            getIDLModuleNames().length > 0) {

            return IDL_NAME_SEPARATOR + qualifiedIDLExceptionName;

        } else {

            return qualifiedIDLExceptionName;

        }

    }

    /**

     * Return signature for this type  (e.g. com.acme.Dynamite

     * would return "com.acme.Dynamite", byte = "B")

     */

    public String getSignature() {

        String sig = classDecl.getType().getTypeSignature();

        if (sig.endsWith(";")) {

            sig = sig.substring(0,sig.length()-1);

        }

        return sig;

    }

    /**

     * Return the ClassDeclaration for this type.

     */

    public ClassDeclaration getClassDeclaration() {

        return classDecl;

    }

    /**

     * Return the ClassDefinition for this type.

     */

    public ClassDefinition getClassDefinition() {

        return classDef;

    }

    /**

     * Return the parent class of this type. Returns null if this

     * type is an interface or if there is no parent.

     */

    public ClassType getSuperclass() {

        return null;

    }

    /**

     * Return an array of interfaces directly implemented by this type.

     * <p>

     * The order of the array returned is arbitrary.

     */

    public InterfaceType[] getInterfaces() {

        if( interfaces != null ) {

            return (InterfaceType[]) interfaces.clone();

        }

        return null;

    }

    /**

     * Return an array of Type.Method objects representing all

     * of the methods implemented directly by this type.

     */

    public Method[] getMethods() {

        if( methods != null ) {

            return (Method[]) methods.clone();

        }

        return null;

    }

    /**

     * Return an array of Type.Member objects representing all of

     * the data members directly implemented by this interface.

     */

    public Member[] getMembers() {

        if( members != null ) {

            return (Member[]) members.clone();

        }

        return null;

    }

    /**

     * Create a CompoundType object for the given class.

     *

     * If the class is not a properly formed or if some other error occurs, the

     * return value will be null, and errors will have been reported to the

     * supplied BatchEnvironment.

     */

    public static CompoundType forCompound (ClassDefinition classDef,

                                            ContextStack stack) {

        CompoundType result = null;

        try {

            result = (CompoundType) makeType(classDef.getType(),classDef,stack);

        } catch (ClassCastException e) {}

        return result;

    }

    //_____________________________________________________________________

    // Subclass/Internal Interfaces

    //_____________________________________________________________________

    /**

     * Release all resources.

     */

    protected void destroy () {

        if (!destroyed) {

            super.destroy();

            if (methods != null) {

                for (int i = 0; i < methods.length; i++) {

                    if (methods[i] != null) methods[i].destroy();

                }

                methods = null;

            }

            if (interfaces != null) {

                for (int i = 0; i < interfaces.length; i++) {

                    if (interfaces[i] != null) interfaces[i].destroy();

                }

                interfaces = null;

            }

            if (members != null) {

                for (int i = 0; i < members.length; i++) {

                    if (members[i] != null) members[i].destroy();

                }

                members = null;

            }

            classDef = null;

            classDecl = null;

        }

    }

    /*

     * Load a Class instance. Return null if fail.

     */

    protected Class loadClass() {

        Class ourClass = null;

        // To avoid getting out-of-date Class instances, and

        // to ensure that there is an instance, we must compile

        // any classes that we've seen and which are not yet

        // compiled. We can't just compile this class, 'cuz it

        // may have dependencies on classes which have not been

        // compiled...

        try {

            env.getMain().compileAllClasses(env);

        } catch (Exception e1) {

            for (Enumeration e = env.getClasses() ; e.hasMoreElements() ; ) {

                ClassDeclaration c = (ClassDeclaration)e.nextElement();

            }

            failedConstraint(26,false,stack,"required classes");

            env.flushErrors();

        }

        // Now try to get the Class...

        // The outer try block is there for people who might want to use

        // the compiler at run-time of their AS.

        // They could set and use their own context class loader for loading

        // classes directly.

        try {

            ClassLoader cl = Thread.currentThread().getContextClassLoader();

            ourClass = cl.loadClass(getQualifiedName());

        } catch(ClassNotFoundException cfe) {

            try {

                ourClass = env.classPathLoader.loadClass(getQualifiedName());

            } catch (NullPointerException e) {

                // This should never happen

            } catch (ClassNotFoundException e) {

                // Fall through to the next case (which is to look in the

                // output directory for generated files)

            }

        }

        /* This piece of code used to cause the compiler to ignore jar files

           on its classpath

        try {

            ourClass = Util.loadClass(getQualifiedName(),null,null);

        } catch (ClassNotFoundException e) {

        } catch (LinkageError e) {

        }

        */

        if (ourClass == null) {

            // Try one last thing. If the class was compiled into

            // a directory that's not in the classpath, the load

            // will fail. Let's get the bits off the disk and load

            // it directly...

            if (env.loader == null) {

                File destDir = env.getMain().getDestinationDir();

                if (destDir == null) {

                    destDir = new File(".");

                }

                env.loader = new DirectoryLoader(destDir);

            }

            try {

                ourClass = env.loader.loadClass(getQualifiedName());

            } catch (Exception e) {}

        }

        return ourClass;

    }

    // Print "extends XX"

    protected boolean printExtends (IndentingWriter writer,

                                    boolean useQualifiedNames,

                                    boolean useIDLNames,

                                    boolean globalIDLNames) throws IOException {

        ClassType parent = getSuperclass();

        if (parent != null && (!useIDLNames ||

                               (!parent.isType(TYPE_ANY) && !parent.isType(TYPE_CORBA_OBJECT)))) {

            writer.p(" extends ");

            parent.printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);

            return true;

        }

        return false;

    }

    // Print "implements XX, YY"

    protected void printImplements (IndentingWriter writer,

                                    String prefix,

                                    boolean useQualifiedNames,

                                    boolean useIDLNames,

                                    boolean globalIDLNames) throws IOException {

        InterfaceType[] interfaces = getInterfaces();

        String adjective = " implements";

        if (isInterface()) {

            adjective = " extends";

        }

        if (useIDLNames) {

            adjective = ":";

        }

        for (int i = 0; i < interfaces.length; i++) {

            if (!useIDLNames || (!interfaces[i].isType(TYPE_ANY) && !interfaces[i].isType(TYPE_CORBA_OBJECT))) {

                if (i == 0) {

                    writer.p(prefix + adjective + " ");

                } else {

                    writer.p(", ");

                }

                interfaces[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);

            }

        }

    }

    // Print members

    protected void printMembers (       IndentingWriter writer,

                                        boolean useQualifiedNames,

                                        boolean useIDLNames,

                                        boolean globalIDLNames) throws IOException {

        CompoundType.Member[] members = getMembers();

        for (int i = 0; i < members.length; i++) {

            if (!members[i].isInnerClassDeclaration()) {

                Type it = members[i].getType();

                String visibility = members[i].getVisibility();

                String name;

                if (useIDLNames) {

                    name = members[i].getIDLName();

                } else {

                    name = members[i].getName();

                }

                String value = members[i].getValue();

                writer.p(visibility);

                if (visibility.length() > 0) {

                    writer.p(" ");

                }

                it.printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);

                writer.p(" " + name);

                if (value != null) {

                    writer.pln(" = " + value + ";");

                } else {

                    writer.pln(";");

                }

            }

        }

    }

    // Print methods

    protected void printMethods (       IndentingWriter writer,

                                        boolean useQualifiedNames,

                                        boolean useIDLNames,

                                        boolean globalIDLNames) throws IOException {

        CompoundType.Method[] methods = getMethods();

        for (int m = 0; m < methods.length; m++) {

            CompoundType.Method theMethod = methods[m];

            printMethod(theMethod,writer,useQualifiedNames,useIDLNames,globalIDLNames);

        }

    }

    // Print a method...

    protected void printMethod (CompoundType.Method it,

                                IndentingWriter writer,

                                boolean useQualifiedNames,

                                boolean useIDLNames,

                                boolean globalIDLNames) throws IOException {

        // Write visibility...

        String visibility = it.getVisibility();

        writer.p(visibility);

        if (visibility.length() > 0) {

            writer.p(" ");

        }

        // Write return type...

        it.getReturnType().printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);

        // Write method name...

        if (useIDLNames) {

            writer.p(" " + it.getIDLName());

        } else {

            writer.p(" " + it.getName());

        }

        // Write arguments...

        writer.p(" (");

        Type[] args = it.getArguments();

        String[] argNames = it.getArgumentNames();