/*

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

 */

/*****************************************************************************/

/*                    Copyright (c) IBM Corporation 1998                     */

/*                                                                           */

/* (C) Copyright IBM Corp. 1998                                              */

/*                                                                           */

/*****************************************************************************/

package sun.rmi.rmic;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStreamWriter;

import java.io.IOException;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

import sun.tools.java.Type;

import sun.tools.java.Identifier;

import sun.tools.java.ClassDefinition;

import sun.tools.java.ClassDeclaration;

import sun.tools.java.ClassNotFound;

import sun.tools.java.ClassFile;

import sun.tools.java.MemberDefinition;

/**

 * A Generator object will generate the Java source code of the stub

 * and skeleton classes for an RMI remote implementation class, using

 * a particular stub protocol version.

 *

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

 *

 * @author      Peter Jones,  Bryan Atsatt

 */

public class RMIGenerator implements RMIConstants, Generator {

    private static final Hashtable<String, Integer> versionOptions = new Hashtable<>();

    static {

        versionOptions.put("-v1.1", STUB_VERSION_1_1);

        versionOptions.put("-vcompat", STUB_VERSION_FAT);

        versionOptions.put("-v1.2", STUB_VERSION_1_2);

    }

    /**

     * Default constructor for Main to use.

     */

    public RMIGenerator() {

        version = STUB_VERSION_1_2;     // default is -v1.2 (see 4638155)

    }

    /**

     * Examine and consume command line arguments.

     * @param argv The command line arguments. Ignore null

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

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

     * @return true if no errors, false otherwise.

     */

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

        String explicitVersion = null;

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

            if (argv[i] != null) {

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

                if (versionOptions.containsKey(arg)) {

                    if (explicitVersion != null &&

                        !explicitVersion.equals(arg))

                    {

                        main.error("rmic.cannot.use.both",

                                   explicitVersion, arg);

                        return false;

                    }

                    explicitVersion = arg;

                    version = versionOptions.get(arg);

                    argv[i] = null;

                }

            }

        }

        return true;

    }

    /**

     * Generate the source files for the stub and/or skeleton classes

     * needed by RMI for the given remote implementation class.

     *

     * @param env       compiler environment

     * @param cdef      definition of remote implementation class

     *                  to generate stubs and/or skeletons for

     * @param destDir   directory for the root of the package hierarchy

     *                  for generated files

     */

    public void generate(BatchEnvironment env, ClassDefinition cdef, File destDir) {

        RemoteClass remoteClass = RemoteClass.forClass(env, cdef);

        if (remoteClass == null)        // exit if an error occurred

            return;

        RMIGenerator gen;

        try {

            gen = new RMIGenerator(env, cdef, destDir, remoteClass, version);

        } catch (ClassNotFound e) {

            env.error(0, "rmic.class.not.found", e.name);

            return;

        }

        gen.generate();

    }

    private void generate() {

        env.addGeneratedFile(stubFile);

        try {

            IndentingWriter out = new IndentingWriter(

                new OutputStreamWriter(new FileOutputStream(stubFile)));

            writeStub(out);

            out.close();

            if (env.verbose()) {

                env.output(Main.getText("rmic.wrote", stubFile.getPath()));

            }

            env.parseFile(ClassFile.newClassFile(stubFile));

        } catch (IOException e) {

            env.error(0, "cant.write", stubFile.toString());

            return;

        }

        if (version == STUB_VERSION_1_1 ||

            version == STUB_VERSION_FAT)

        {

            env.addGeneratedFile(skeletonFile);

            try {

                IndentingWriter out = new IndentingWriter(

                    new OutputStreamWriter(

                        new FileOutputStream(skeletonFile)));

                writeSkeleton(out);

                out.close();

                if (env.verbose()) {

                    env.output(Main.getText("rmic.wrote",

                        skeletonFile.getPath()));

                }

                env.parseFile(ClassFile.newClassFile(skeletonFile));

            } catch (IOException e) {

                env.error(0, "cant.write", stubFile.toString());

                return;

            }

        } else {

            /*

             * For bugid 4135136: if skeleton files are not being generated

             * for this compilation run, delete old skeleton source or class

             * files for this remote implementation class that were

             * (presumably) left over from previous runs, to avoid user

             * confusion from extraneous or inconsistent generated files.

             */

            File outputDir = Util.getOutputDirectoryFor(remoteClassName,destDir,env);

            File skeletonClassFile = new File(outputDir,skeletonClassName.getName().toString() + ".class");

            skeletonFile.delete();      // ignore failures (no big deal)

            skeletonClassFile.delete();

        }

    }

    /**

     * Return the File object that should be used as the source file

     * for the given Java class, using the supplied destination

     * directory for the top of the package hierarchy.

     */

    protected static File sourceFileForClass(Identifier className,

                                             Identifier outputClassName,

                                             File destDir,

                                             BatchEnvironment env)

    {

        File packageDir = Util.getOutputDirectoryFor(className,destDir,env);

        String outputName = Names.mangleClass(outputClassName).getName().toString();

        String outputFileName = outputName + ".java";

        return new File(packageDir, outputFileName);

    }

    /** rmic environment for this object */

    private BatchEnvironment env;

    /** the remote class that this instance is generating code for */

    private RemoteClass remoteClass;

    /** version of the stub protocol to use in code generation */

    private int version;

    /** remote methods for remote class, indexed by operation number */

    private RemoteClass.Method[] remoteMethods;

    /**

     * Names for the remote class and the stub and skeleton classes

     * to be generated for it.

     */

    private Identifier remoteClassName;

    private Identifier stubClassName;

    private Identifier skeletonClassName;

    private ClassDefinition cdef;

    private File destDir;

    private File stubFile;

    private File skeletonFile;

    /**

     * Names to use for the java.lang.reflect.Method static fields

     * corresponding to each remote method.

     */

    private String[] methodFieldNames;

    /** cached definition for certain exception classes in this environment */

    private ClassDefinition defException;

    private ClassDefinition defRemoteException;

    private ClassDefinition defRuntimeException;

    /**

     * Create a new stub/skeleton Generator object for the given

     * remote implementation class to generate code according to

     * the given stub protocol version.

     */

    private RMIGenerator(BatchEnvironment env, ClassDefinition cdef,

                           File destDir, RemoteClass remoteClass, int version)

        throws ClassNotFound

    {

        this.destDir     = destDir;

        this.cdef        = cdef;

        this.env         = env;

        this.remoteClass = remoteClass;

        this.version     = version;

        remoteMethods = remoteClass.getRemoteMethods();

        remoteClassName = remoteClass.getName();

        stubClassName = Names.stubFor(remoteClassName);

        skeletonClassName = Names.skeletonFor(remoteClassName);

        methodFieldNames = nameMethodFields(remoteMethods);

        stubFile = sourceFileForClass(remoteClassName,stubClassName, destDir , env);

        skeletonFile = sourceFileForClass(remoteClassName,skeletonClassName, destDir, env);

        /*

         * Initialize cached definitions for exception classes used

         * in the generation process.

         */

        defException =

            env.getClassDeclaration(idJavaLangException).

                getClassDefinition(env);

        defRemoteException =

            env.getClassDeclaration(idRemoteException).

                getClassDefinition(env);

        defRuntimeException =

            env.getClassDeclaration(idJavaLangRuntimeException).

                getClassDefinition(env);

    }

    /**

     * Write the stub for the remote class to a stream.

     */

    private void writeStub(IndentingWriter p) throws IOException {

        /*

         * Write boiler plate comment.

         */

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

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

        p.pln();

        /*

         * If remote implementation class was in a particular package,

         * declare the stub class to be in the same package.

         */

        if (remoteClassName.isQualified()) {

            p.pln("package " + remoteClassName.getQualifier() + ";");

            p.pln();

        }

        /*

         * Declare the stub class; implement all remote interfaces.

         */

        p.plnI("public final class " +

            Names.mangleClass(stubClassName.getName()));

        p.pln("extends " + idRemoteStub);

        ClassDefinition[] remoteInterfaces = remoteClass.getRemoteInterfaces();

        if (remoteInterfaces.length > 0) {

            p.p("implements ");

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

                if (i > 0)

                    p.p(", ");

                p.p(remoteInterfaces[i].getName().toString());

            }

            p.pln();

        }

        p.pOlnI("{");

        if (version == STUB_VERSION_1_1 ||

            version == STUB_VERSION_FAT)

        {

            writeOperationsArray(p);

            p.pln();

            writeInterfaceHash(p);

            p.pln();

        }

        if (version == STUB_VERSION_FAT ||

            version == STUB_VERSION_1_2)

        {

            p.pln("private static final long serialVersionUID = " +

                STUB_SERIAL_VERSION_UID + ";");

            p.pln();

            /*

             * We only need to declare and initialize the static fields of

             * Method objects for each remote method if there are any remote

             * methods; otherwise, skip this code entirely, to avoid generating

             * a try/catch block for a checked exception that cannot occur

             * (see bugid 4125181).

             */

            if (methodFieldNames.length > 0) {

                if (version == STUB_VERSION_FAT) {

                    p.pln("private static boolean useNewInvoke;");

                }

                writeMethodFieldDeclarations(p);

                p.pln();

                /*

                 * Initialize java.lang.reflect.Method fields for each remote

                 * method in a static initializer.

                 */

                p.plnI("static {");

                p.plnI("try {");

                if (version == STUB_VERSION_FAT) {

                    /*

                     * Fat stubs must determine whether the API required for

                     * the JDK 1.2 stub protocol is supported in the current

                     * runtime, so that it can use it if supported.  This is

                     * determined by using the Reflection API to test if the

                     * new invoke method on RemoteRef exists, and setting the

                     * static boolean "useNewInvoke" to true if it does, or

                     * to false if a NoSuchMethodException is thrown.

                     */

                    p.plnI(idRemoteRef + ".class.getMethod(\"invoke\",");

                    p.plnI("new java.lang.Class[] {");

                    p.pln(idRemote + ".class,");

                    p.pln("java.lang.reflect.Method.class,");

                    p.pln("java.lang.Object[].class,");

                    p.pln("long.class");

                    p.pOln("});");

                    p.pO();

                    p.pln("useNewInvoke = true;");

                }

                writeMethodFieldInitializers(p);

                p.pOlnI("} catch (java.lang.NoSuchMethodException e) {");

                if (version == STUB_VERSION_FAT) {

                    p.pln("useNewInvoke = false;");

                } else {

                    /*

                     * REMIND: By throwing an Error here, the application will

                     * get the NoSuchMethodError directly when the stub class

                     * is initialized.  If we throw a RuntimeException

                     * instead, the application would get an

                     * ExceptionInInitializerError.  Would that be more

                     * appropriate, and if so, which RuntimeException should

                     * be thrown?

                     */

                    p.plnI("throw new java.lang.NoSuchMethodError(");

                    p.pln("\"stub class initialization failed\");");

                    p.pO();

                }

                p.pOln("}");            // end try/catch block

                p.pOln("}");            // end static initializer

                p.pln();

            }

        }

        writeStubConstructors(p);

        p.pln();

        /*

         * Write each stub method.

         */

        if (remoteMethods.length > 0) {

            p.pln("// methods from remote interfaces");

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

                p.pln();

                writeStubMethod(p, i);

            }

        }

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

    }

    /**

     * Write the constructors for the stub class.

     */

    private void writeStubConstructors(IndentingWriter p)

        throws IOException

    {

        p.pln("// constructors");

        /*

         * Only stubs compatible with the JDK 1.1 stub protocol need

         * a no-arg constructor; later versions use reflection to find

         * the constructor that directly takes a RemoteRef argument.

         */

        if (version == STUB_VERSION_1_1 ||

            version == STUB_VERSION_FAT)

        {

            p.plnI("public " + Names.mangleClass(stubClassName.getName()) +

                "() {");

            p.pln("super();");

            p.pOln("}");

        }

        p.plnI("public " + Names.mangleClass(stubClassName.getName()) +

            "(" + idRemoteRef + " ref) {");

        p.pln("super(ref);");

        p.pOln("}");

    }

    /**

     * Write the stub method for the remote method with the given "opnum".

     */

    private void writeStubMethod(IndentingWriter p, int opnum)

        throws IOException

    {

        RemoteClass.Method method = remoteMethods[opnum];

        Identifier methodName = method.getName();

        Type methodType = method.getType();

        Type paramTypes[] = methodType.getArgumentTypes();

        String paramNames[] = nameParameters(paramTypes);

        Type returnType = methodType.getReturnType();

        ClassDeclaration[] exceptions = method.getExceptions();

        /*

         * Declare stub method; throw exceptions declared in remote

         * interface(s).

         */

        p.pln("// implementation of " +

            methodType.typeString(methodName.toString(), true, false));

        p.p("public " + returnType + " " + methodName + "(");

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

            if (i > 0)

                p.p(", ");

            p.p(paramTypes[i] + " " + paramNames[i]);

        }

        p.plnI(")");

        if (exceptions.length > 0) {

            p.p("throws ");

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

                if (i > 0)

                    p.p(", ");

                p.p(exceptions[i].getName().toString());

            }

            p.pln();

        }

        p.pOlnI("{");

        /*

         * The RemoteRef.invoke methods throw Exception, but unless this

         * stub method throws Exception as well, we must catch Exceptions

         * thrown from the invocation.  So we must catch Exception and

         * rethrow something we can throw: UnexpectedException, which is a

         * subclass of RemoteException.  But for any subclasses of Exception

         * that we can throw, like RemoteException, RuntimeException, and

         * any of the exceptions declared by this stub method, we want them

         * to pass through unharmed, so first we must catch any such

         * exceptions and rethrow it directly.

         *

         * We have to be careful generating the rethrowing catch blocks

         * here, because javac will flag an error if there are any

         * unreachable catch blocks, i.e. if the catch of an exception class

         * follows a previous catch of it or of one of its superclasses.

         * The following method invocation takes care of these details.

         */

        Vector<ClassDefinition> catchList = computeUniqueCatchList(exceptions);

        /*

         * If we need to catch any particular exceptions (i.e. this method

         * does not declare java.lang.Exception), put the entire stub

         * method in a try block.

         */

        if (catchList.size() > 0) {

            p.plnI("try {");

        }

        if (version == STUB_VERSION_FAT) {

            p.plnI("if (useNewInvoke) {");

        }

        if (version == STUB_VERSION_FAT ||

            version == STUB_VERSION_1_2)

        {

            if (!returnType.isType(TC_VOID)) {

                p.p("Object $result = ");               // REMIND: why $?

            }

            p.p("ref.invoke(this, " + methodFieldNames[opnum] + ", ");

            if (paramTypes.length > 0) {

                p.p("new java.lang.Object[] {");

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

                    if (i > 0)

                        p.p(", ");

                    p.p(wrapArgumentCode(paramTypes[i], paramNames[i]));

                }