/*

 * Portions Copyright 1998-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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.io.File;

import java.io.IOException;

import java.util.Vector;

import java.util.Hashtable;

import java.util.Enumeration;

import sun.tools.java.Identifier;

import sun.tools.java.ClassNotFound;

import sun.tools.java.ClassDefinition;

import sun.tools.java.ClassDeclaration;

import sun.tools.java.CompilerError;

import sun.rmi.rmic.IndentingWriter;

import java.util.HashSet;

import java.util.Arrays;

import com.sun.corba.se.impl.util.Utility;

import com.sun.corba.se.impl.util.PackagePrefixChecker;

import sun.rmi.rmic.Main;

/**

 * An IIOP stub/tie generator for rmic.

 *

 * @author      Bryan Atsatt

 * @author      Anil Vijendran

 * @author      M. Mortazavi

 */

public class StubGenerator extends sun.rmi.rmic.iiop.Generator {

    private static final String DEFAULT_STUB_CLASS = "javax.rmi.CORBA.Stub";

    private static final String DEFAULT_TIE_CLASS = "org.omg.CORBA_2_3.portable.ObjectImpl";

    private static final String DEFAULT_POA_TIE_CLASS = "org.omg.PortableServer.Servant";

    protected boolean reverseIDs = false;

    protected boolean localStubs = true;

    protected boolean standardPackage = false;

    protected boolean useHash = true;

    protected String stubBaseClass = DEFAULT_STUB_CLASS;

    protected String tieBaseClass = DEFAULT_TIE_CLASS;

    protected HashSet namesInUse = new HashSet();

    protected Hashtable classesInUse = new Hashtable();

    protected Hashtable imports = new Hashtable();

    protected int importCount = 0;

    protected String currentPackage = null;

    protected String currentClass = null;

    protected boolean castArray = false;

    protected Hashtable transactionalObjects = new Hashtable() ;

    protected boolean POATie = false ;

    /**

     * Default constructor for Main to use.

     */

    public StubGenerator() {

    }

    /**

     * Overridden in order to set the standardPackage flag.

     */

    public void generate(

            sun.rmi.rmic.BatchEnvironment env,

            ClassDefinition cdef, File destDir) {

        ((sun.rmi.rmic.iiop.BatchEnvironment)env).

                setStandardPackage(standardPackage);

        super.generate(env, cdef, destDir);

    }

    /**

     * Return true if a new instance should be created for each

     * class on the command line. Subclasses which return true

     * should override newInstance() to return an appropriately

     * constructed instance.

     */

    protected boolean requireNewInstance() {

        return false;

    }

    /**

     * Return true if non-conforming types should be parsed.

     * @param stack The context stack.

     */

    protected boolean parseNonConforming(ContextStack stack) {

        // We let the environment setting decide so that

        // another generator (e.g. IDLGenerator) can change

        // it and we will just go with the flow...

        return stack.getEnv().getParseNonConforming();

    }

    /**

     * Create and return a top-level type.

     * @param cdef The top-level class definition.

     * @param stack The context stack.

     * @return The compound type or null if is non-conforming.

     */

    protected CompoundType getTopType(ClassDefinition cdef, ContextStack stack) {

        CompoundType result = null;

        // Do we have an interface?

        if (cdef.isInterface()) {

            // Yes, so first try Abstract...

            result = AbstractType.forAbstract(cdef,stack,true);

            if (result == null) {

                // Then try Remote...

                result = RemoteType.forRemote(cdef,stack,false);

            }

        } else {

            // Not an interface, so try Implementation...

            result = ImplementationType.forImplementation(cdef,stack,false);

        }

        return result;

    }

    /**

     * Examine and consume command line arguments.

     * @param argv The command line arguments. Ignore null

     * and unknown arguments. Set each consumed argument to null.

     * @param error Report any errors using the main.error() methods.

     * @return true if no errors, false otherwise.

     */

    public boolean parseArgs(String argv[], Main main) {

        Object marker = new Object() ;

        // Reset any cached options...

        reverseIDs = false;

        localStubs = true;

        useHash = true;

        stubBaseClass = DEFAULT_STUB_CLASS;

        //       tieBaseClass = DEFAULT_TIE_CLASS;

        transactionalObjects = new Hashtable() ;

        // Parse options...

        boolean result = super.parseArgs(argv,main);

        if (result) {

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

                if (argv[i] != null) {

                    String arg = argv[i].toLowerCase();

                    if (arg.equals("-iiop")) {

                        argv[i] = null;

                    } else if (arg.equals("-xreverseids")) {

                        reverseIDs = true;

                        argv[i] = null;

                    } else if (arg.equals("-nolocalstubs")) {

                        localStubs = false;

                        argv[i] = null;

                    } else if (arg.equals("-xnohash")) {

                        useHash = false;

                        argv[i] = null;

                    } else if (argv[i].equals("-standardPackage")) {

                        standardPackage = true;

                        argv[i] = null;

                    } else if (arg.equals("-xstubbase")) {

                        argv[i] = null;

                        if (++i < argv.length && argv[i] != null && !argv[i].startsWith("-")) {

                            stubBaseClass = argv[i];

                            argv[i] = null;

                        } else {

                            main.error("rmic.option.requires.argument", "-Xstubbase");

                            result = false;

                        }

                    } else if (arg.equals("-xtiebase")) {

                        argv[i] = null;

                        if (++i < argv.length && argv[i] != null && !argv[i].startsWith("-")) {

                            tieBaseClass = argv[i];

                            argv[i] = null;

                        } else {

                            main.error("rmic.option.requires.argument", "-Xtiebase");

                            result = false;

                        }

                    } else if (arg.equals("-transactional" )) {

                        // Scan for the next non-flag argument.

                        // Assume that it is a class name and add it

                        // to the list of transactional classes.

                        for ( int ctr=i+1; ctr<argv.length; ctr++ ) {

                            if (argv[ctr].charAt(1) != '-') {

                                transactionalObjects.put( argv[ctr], marker ) ;

                                break ;

                            }

                        }

                        argv[i] = null;

                    } else if (arg.equals( "-poa" )) {

                        POATie = true ;

                        argv[i] = null;

                    }

                }

            }

        }

        if(POATie){

            tieBaseClass = DEFAULT_POA_TIE_CLASS;

        } else {

            tieBaseClass = DEFAULT_TIE_CLASS;

        }

        return result;

    }

    /**

     * Return an array containing all the file names and types that need to be

     * generated for the given top-level type.  The file names must NOT have an

     * extension (e.g. ".java").

     * @param topType The type returned by getTopType().

     * @param alreadyChecked A set of Types which have already been checked.

     *  Intended to be passed to topType.collectMatching(filter,alreadyChecked).

     */

    protected OutputType[] getOutputTypesFor(CompoundType topType,

                                             HashSet alreadyChecked) {

        // We want to generate stubs for all remote and implementation types,

        // so collect them up.

        //

        // We use the form of collectMatching which allows us to pass in a set of

        // types which have previously been checked. By doing so, we ensure that if

        // the command line contains Hello and HelloImpl, we will only generate

        // output for Hello once...

        int filter = TYPE_REMOTE | TYPE_IMPLEMENTATION;

        Type[] genTypes = topType.collectMatching(filter,alreadyChecked);

        int count = genTypes.length;

        Vector list = new Vector(count+5);

        BatchEnvironment theEnv = topType.getEnv();

        // Now walk all types...

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

            Type type = genTypes[i];

            String typeName = type.getName();

            boolean createStub = true;

            // Is it an implementation type?

            if (type instanceof ImplementationType) {

                // Yes, so add a tie for it...

                list.addElement(new OutputType(Utility.tieNameForCompiler(typeName), type));

                // Does it have more than 1 remote interface?  If so, we

                // want to create a stub for it...

                int remoteInterfaceCount = 0;

                InterfaceType[] interfaces = ((CompoundType)type).getInterfaces();

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

                    if (interfaces[j].isType(TYPE_REMOTE) &&

                        !interfaces[j].isType(TYPE_ABSTRACT)) {

                        remoteInterfaceCount++;

                    }

                }

                if (remoteInterfaceCount <= 1) {

                    // No, so do not create a stub for this type...

                    createStub = false;

                }

            }

            // Is it an abstract interface type?

            if (type instanceof AbstractType) {

                // Do not create a stub for this type...

                createStub = false;  // d11141

            }

            if (createStub) {

                // Add a stub for the type...

                list.addElement(new OutputType(Utility.stubNameForCompiler(typeName), type));

            }

        }

        // Copy list into array..

        OutputType[] outputTypes = new OutputType[list.size()];

        list.copyInto(outputTypes);

        return outputTypes;

    }

    /**

     * Return the file name extension for the given file name (e.g. ".java").

     * All files generated with the ".java" extension will be compiled. To

     * change this behavior for ".java" files, override the compileJavaSourceFile

     * method to return false.

     * @param outputType One of the items returned by getOutputTypesFor(...)

     */

    protected String getFileNameExtensionFor(OutputType outputType) {

        return SOURCE_FILE_EXTENSION;

    }

    /**

     * Write the output for the given OutputFileName into the output stream.

     * @param name One of the items returned by getOutputTypesFor(...)

     * @param alreadyChecked A set of Types which have already been checked.

     *  Intended to be passed to Type.collectMatching(filter,alreadyChecked).

     * @param writer The output stream.

     */

    protected void writeOutputFor(      OutputType outputType,

                                        HashSet alreadyChecked,

                                        IndentingWriter writer) throws IOException {

        String fileName = outputType.getName();

        CompoundType theType = (CompoundType) outputType.getType();

        // Are we doing a Stub or Tie?

        if (fileName.endsWith(Utility.RMI_STUB_SUFFIX)) {

            // Stub.

            writeStub(outputType,writer);

        } else {

            // Tie

            writeTie(outputType,writer);

        }

    }

    /**

     * Write a stub for the specified type.

     */

    protected void writeStub(OutputType outputType,

                             IndentingWriter p) throws IOException {

        CompoundType theType = (CompoundType) outputType.getType();

        RemoteType[] remoteInterfaces = getDirectRemoteInterfaces(theType);

        // Write comment.

        p.pln("// Stub class generated by rmic, do not edit.");

        p.pln("// Contents subject to change without notice.");

        p.pln();

        // Set our standard classes...

        setStandardClassesInUse(theType,true);

        // Add classes for this type...

        addClassesInUse(theType,remoteInterfaces);

        // Write package and import statements...

        writePackageAndImports(p);

        // Declare the stub class; implement all remote interfaces.

        p.p("public class " + currentClass);

        p.p(" extends " + getName(stubBaseClass));

        p.p(" implements ");

        if (remoteInterfaces.length > 0) {

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

                if (i > 0) {

                    p.pln(",");

                }

                String objName = testUtil(getName(remoteInterfaces[i]), theType);

                p.p(objName);

            }

        }

        // Add java.rmi.Remote if this type does not implement it.

        // This allows stubs for Abstract interfaces to be treated

        // uniformly...

        if (!implementsRemote(theType)) {

            p.pln(",");

            p.p(getName("java.rmi.Remote"));

        }

        p.plnI(" {");

        p.pln();

        // Write the ids...

        writeIds( p, theType, false );

        p.pln();

        // Write the _ids() method...

        p.plnI("public String[] _ids() { ");

        p.pln("return _type_ids;");

        p.pOln("}");

        // Get all the methods and write each stub method...

        CompoundType.Method[] remoteMethods = theType.getMethods();

        int methodCount = remoteMethods.length;

        if (methodCount > 0) {

            boolean writeHeader = true;

            for(int i = 0; i < methodCount; i++) {

                if (!remoteMethods[i].isConstructor()) {

                    if (writeHeader) {

                        writeHeader = false;

                    }

                    p.pln();

                    writeStubMethod(p, remoteMethods[i], theType);

                }

            }

        }

        // Write the cast array hack...

        writeCastArray(p);

        p.pOln("}");            // end stub class

    }

    void addClassInUse(String qualifiedName) {

        String unqualifiedName = qualifiedName;

        String packageName = null;

        int index = qualifiedName.lastIndexOf('.');

        if (index > 0) {

            unqualifiedName = qualifiedName.substring(index+1);

            packageName = qualifiedName.substring(0,index);

        }

        addClassInUse(unqualifiedName,qualifiedName,packageName);

    }

    void addClassInUse(Type type) {

        if (!type.isPrimitive()) {

            Identifier id = type.getIdentifier();

            String name = IDLNames.replace(id.getName().toString(),". ",".");

            String packageName = type.getPackageName();

            String qualifiedName;

            if (packageName != null) {

                qualifiedName = packageName+"."+name;

            } else {

                qualifiedName = name;

            }

            addClassInUse(name,qualifiedName,packageName);

        }

    }

    void addClassInUse(Type[] types) {

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

            addClassInUse(types[i]);

        }

    }

    void addStubInUse(Type type) {

        if (type.getIdentifier() != idCorbaObject &&

            type.isType(TYPE_CORBA_OBJECT)) {

            String stubName = getStubNameFor(type,false);

            String packageName = type.getPackageName();

            String fullName;

            if (packageName == null) {

                fullName = stubName;

            } else {

                fullName = packageName + "." + stubName;

            }

            addClassInUse(stubName,fullName,packageName);

        }

        if (type.isType(TYPE_REMOTE) ||

            type.isType(TYPE_JAVA_RMI_REMOTE)) {

            addClassInUse("javax.rmi.PortableRemoteObject");

        }

    }

    String getStubNameFor(Type type, boolean qualified) {

        String stubName;

        String className;

        if (qualified) {

            className = type.getQualifiedName();

        } else {

            className = type.getName();

        }

        if (((CompoundType)type).isCORBAObject()) {

            stubName = Utility.idlStubName(className);

        } else {

            stubName = Utility.stubNameForCompiler(className);

        }

        return stubName;

    }

    void addStubInUse(Type[] types) {

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

            addStubInUse(types[i]);

        }

    }

    private static final String NO_IMPORT = new String();