/*

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

 */

/*

 * 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.io.SerializablePermission;

import java.security.AccessController;

import java.security.PrivilegedAction;

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 ;

    protected boolean emitPermissionCheck = 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 (argv[i].equals("-emitPermissionCheck")) {

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

//        generate

//        import java.security.AccessController;

//        import java.security.PrivilegedAction;

//        import java.io.SerializablePermission;

        if (emitPermissionCheck) {

            p.pln("import java.security.AccessController;");

            p.pln("import java.security.PrivilegedAction;");

            p.pln("import java.io.SerializablePermission;");

            p.pln();

            p.pln();

        }

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

        if (emitPermissionCheck) {

            // produce the following generated code for example

            // private static Void checkPermission() {

            // SecurityManager sm = System.getSecurityManager();

            // if (sm != null) {

            //     sm.checkPermission(new SerializablePermission(

            // "enableSubclassImplementation")); // testing

            // }

            // return null;

            // }

            //

            // private _XXXXX_Stub(Void ignore) {

            // }

            //

            // public _XXXXX_Stub() {

            // this(checkPermission());

            // }

            //

            // where XXXXX is the name of the remote interface

                p.pln();

                p.plnI("private static Void checkPermission() {");

                p.plnI("SecurityManager sm = System.getSecurityManager();");

                p.pln("if (sm != null) {");

                p.pI();

                p.plnI("sm.checkPermission(new SerializablePermission(");

                p.plnI("\"enableSubclassImplementation\"));");

                p.pO();

                p.pO();

                p.pOln("}");

                p.pln("return null;");

                p.pO();

                p.pOln("}");

                p.pln();

                p.pO();

                p.pI();

                p.pln();

                p.plnI("public " + currentClass + "() { ");

                p.pln("this(checkPermission());");

                p.pOln("}");

                p.pln();

        }

       if (!emitPermissionCheck) {

            p.pI();

       }

        // Write the _ids() method...