1 /*

     2  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

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

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.rmi.rmic.newrmic.jrmp;

    27 

    28 import com.sun.javadoc.ClassDoc;

    29 import com.sun.javadoc.MethodDoc;

    30 import com.sun.javadoc.Type;

    31 import java.io.IOException;

    32 import java.util.ArrayList;

    33 import java.util.Iterator;

    34 import java.util.List;

    35 import sun.rmi.rmic.newrmic.BatchEnvironment;

    36 import sun.rmi.rmic.newrmic.IndentingWriter;

    37 

    38 import static sun.rmi.rmic.newrmic.Constants.*;

    39 import static sun.rmi.rmic.newrmic.jrmp.Constants.*;

    40 

    41 /**

    42  * Writes the source code for the stub class and (optionally) skeleton

    43  * class for a particular remote implementation class.

    44  *

    45  * WARNING: The contents of this source file are not part of any

    46  * supported API.  Code that depends on them does so at its own risk:

    47  * they are subject to change or removal without notice.

    48  *

    49  * @author Peter Jones

    50  **/

    51 class StubSkeletonWriter {

    52 

    53     /** rmic environment for this object */

    54     private final BatchEnvironment env;

    55 

    56     /** the remote implementation class to generate code for */

    57     private final RemoteClass remoteClass;

    58 

    59     /** version of the JRMP stub protocol to generate code for */

    60     private final StubVersion version;

    61 

    62     /*

    63      * binary names of the stub and skeleton classes to generate for

    64      * the remote class

    65      */

    66     private final String stubClassName;

    67     private final String skeletonClassName;

    68 

    69     /* package name and simple names of the stub and skeleton classes */

    70     private final String packageName;

    71     private final String stubClassSimpleName;

    72     private final String skeletonClassSimpleName;

    73 

    74     /** remote methods of class, indexed by operation number */

    75     private final RemoteClass.Method[] remoteMethods;

    76 

    77     /**

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

    79      * the generated stub class corresponding to each remote method.

    80      **/

    81     private final String[] methodFieldNames;

    82 

    83     /**

    84      * Creates a StubSkeletonWriter instance for the specified remote

    85      * implementation class.  The generated code will implement the

    86      * specified JRMP stub protocol version.

    87      **/

    88     StubSkeletonWriter(BatchEnvironment env,

    89                        RemoteClass remoteClass,

    90                        StubVersion version)

    91     {

    92         this.env = env;

    93         this.remoteClass = remoteClass;

    94         this.version = version;

    95 

    96         stubClassName = Util.binaryNameOf(remoteClass.classDoc()) + "_Stub";

    97         skeletonClassName =

    98             Util.binaryNameOf(remoteClass.classDoc()) + "_Skel";

    99 

   100         int i = stubClassName.lastIndexOf('.');

   101         packageName = (i != -1 ? stubClassName.substring(0, i) : "");

   102         stubClassSimpleName = stubClassName.substring(i + 1);

   103         skeletonClassSimpleName = skeletonClassName.substring(i + 1);

   104 

   105         remoteMethods = remoteClass.remoteMethods();

   106         methodFieldNames = nameMethodFields(remoteMethods);

   107     }

   108 

   109     /**

   110      * Returns the binary name of the stub class to generate for the

   111      * remote implementation class.

   112      **/

   113     String stubClassName() {

   114         return stubClassName;

   115     }

   116 

   117     /**

   118      * Returns the binary name of the skeleton class to generate for

   119      * the remote implementation class.

   120      **/

   121     String skeletonClassName() {

   122         return skeletonClassName;

   123     }

   124 

   125     /**

   126      * Writes the stub class for the remote class to a stream.

   127      **/

   128     void writeStub(IndentingWriter p) throws IOException {

   129 

   130         /*

   131          * Write boiler plate comment.

   132          */

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

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

   135         p.pln();

   136 

   137         /*

   138          * If remote implementation class was in a particular package,

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

   140          */

   141         if (!packageName.equals("")) {

   142             p.pln("package " + packageName + ";");

   143             p.pln();

   144         }

   145 

   146         /*

   147          * Declare the stub class; implement all remote interfaces.

   148          */

   149         p.plnI("public final class " + stubClassSimpleName);

   150         p.pln("extends " + REMOTE_STUB);

   151         ClassDoc[] remoteInterfaces = remoteClass.remoteInterfaces();

   152         if (remoteInterfaces.length > 0) {

   153             p.p("implements ");

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

   155                 if (i > 0) {

   156                     p.p(", ");

   157                 }

   158                 p.p(remoteInterfaces[i].qualifiedName());

   159             }

   160             p.pln();

   161         }

   162         p.pOlnI("{");

   163 

   164         if (version == StubVersion.V1_1 ||

   165             version == StubVersion.VCOMPAT)

   166         {

   167             writeOperationsArray(p);

   168             p.pln();

   169             writeInterfaceHash(p);

   170             p.pln();

   171         }

   172 

   173         if (version == StubVersion.VCOMPAT ||

   174             version == StubVersion.V1_2)

   175         {

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

   177                 STUB_SERIAL_VERSION_UID + ";");

   178             p.pln();

   179 

   180             /*

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

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

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

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

   185              * (see bugid 4125181).

   186              */

   187             if (methodFieldNames.length > 0) {

   188                 if (version == StubVersion.VCOMPAT) {

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

   190                 }

   191                 writeMethodFieldDeclarations(p);

   192                 p.pln();

   193 

   194                 /*

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

   196                  * method in a static initializer.

   197                  */

   198                 p.plnI("static {");

   199                 p.plnI("try {");

   200                 if (version == StubVersion.VCOMPAT) {

   201                     /*

   202                      * Fat stubs must determine whether the API required for

   203                      * the JDK 1.2 stub protocol is supported in the current

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

   205                      * determined by using the Reflection API to test if the

   206                      * new invoke method on RemoteRef exists, and setting the

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

   208                      * to false if a NoSuchMethodException is thrown.

   209                      */

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

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

   212                     p.pln(REMOTE + ".class,");

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

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

   215                     p.pln("long.class");

   216                     p.pOln("});");

   217                     p.pO();

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

   219                 }

   220                 writeMethodFieldInitializers(p);

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

   222                 if (version == StubVersion.VCOMPAT) {

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

   224                 } else {

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

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

   227                     p.pO();

   228                 }

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

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

   231                 p.pln();

   232             }

   233         }

   234 

   235         writeStubConstructors(p);

   236         p.pln();

   237 

   238         /*

   239          * Write each stub method.

   240          */

   241         if (remoteMethods.length > 0) {

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

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

   244                 p.pln();

   245                 writeStubMethod(p, i);

   246             }

   247         }

   248 

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

   250     }

   251 

   252     /**

   253      * Writes the constructors for the stub class.

   254      **/

   255     private void writeStubConstructors(IndentingWriter p)

   256         throws IOException

   257     {

   258         p.pln("// constructors");

   259 

   260         /*

   261          * Only stubs compatible with the JDK 1.1 stub protocol need

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

   263          * the constructor that directly takes a RemoteRef argument.

   264          */

   265         if (version == StubVersion.V1_1 ||

   266             version == StubVersion.VCOMPAT)

   267         {

   268             p.plnI("public " + stubClassSimpleName + "() {");

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

   270             p.pOln("}");

   271         }

   272 

   273         p.plnI("public " + stubClassSimpleName + "(" + REMOTE_REF + " ref) {");

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

   275         p.pOln("}");

   276     }

   277 

   278     /**

   279      * Writes the stub method for the remote method with the given

   280      * operation number.

   281      **/

   282     private void writeStubMethod(IndentingWriter p, int opnum)

   283         throws IOException

   284     {

   285         RemoteClass.Method method = remoteMethods[opnum];

   286         MethodDoc methodDoc = method.methodDoc();

   287         String methodName = methodDoc.name();

   288         Type[] paramTypes = method.parameterTypes();

   289         String paramNames[] = nameParameters(paramTypes);

   290         Type returnType = methodDoc.returnType();

   291         ClassDoc[] exceptions = method.exceptionTypes();

   292 

   293         /*

   294          * Declare stub method; throw exceptions declared in remote

   295          * interface(s).

   296          */

   297         p.pln("// implementation of " +

   298               Util.getFriendlyUnqualifiedSignature(methodDoc));

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

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

   301             if (i > 0) {

   302                 p.p(", ");

   303             }

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

   305         }

   306         p.plnI(")");

   307         if (exceptions.length > 0) {

   308             p.p("throws ");

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

   310                 if (i > 0) {

   311                     p.p(", ");

   312                 }

   313                 p.p(exceptions[i].qualifiedName());

   314             }

   315             p.pln();

   316         }

   317         p.pOlnI("{");

   318 

   319         /*

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

   321          * this stub method throws Exception as well, we must catch

   322          * Exceptions thrown from the invocation.  So we must catch

   323          * Exception and rethrow something we can throw:

   324          * UnexpectedException, which is a subclass of

   325          * RemoteException.  But for any subclasses of Exception that

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

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

   328          * them to pass through unmodified, so first we must catch any

   329          * such exceptions and rethrow them directly.

   330          *

   331          * We have to be careful generating the rethrowing catch

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

   333          * any unreachable catch blocks, i.e. if the catch of an

   334          * exception class follows a previous catch of it or of one of

   335          * its superclasses.  The following method invocation takes

   336          * care of these details.

   337          */

   338         List<ClassDoc> catchList = computeUniqueCatchList(exceptions);

   339 

   340         /*

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

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

   343          * method in a try block.

   344          */

   345         if (catchList.size() > 0) {

   346             p.plnI("try {");

   347         }

   348 

   349         if (version == StubVersion.VCOMPAT) {

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

   351         }

   352         if (version == StubVersion.VCOMPAT ||

   353             version == StubVersion.V1_2)

   354         {

   355             if (!Util.isVoid(returnType)) {

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

   357             }

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

   359             if (paramTypes.length > 0) {

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

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

   362                     if (i > 0)

   363                         p.p(", ");

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

   365                 }

   366                 p.p("}");

   367             } else {

   368                 p.p("null");

   369             }

   370             p.pln(", " + method.methodHash() + "L);");

   371             if (!Util.isVoid(returnType)) {

   372                 p.pln("return " +

   373                     unwrapArgumentCode(returnType, "$result") + ";");

   374             }

   375         }

   376         if (version == StubVersion.VCOMPAT) {

   377             p.pOlnI("} else {");

   378         }

   379         if (version == StubVersion.V1_1 ||

   380             version == StubVersion.VCOMPAT)

   381         {

   382             p.pln(REMOTE_CALL + " call = ref.newCall((" + REMOTE_OBJECT +

   383                 ") this, operations, " + opnum + ", interfaceHash);");

   384 

   385             if (paramTypes.length > 0) {

   386                 p.plnI("try {");

   387                 p.pln("java.io.ObjectOutput out = call.getOutputStream();");

   388                 writeMarshalArguments(p, "out", paramTypes, paramNames);

   389                 p.pOlnI("} catch (java.io.IOException e) {");

   390                 p.pln("throw new " + MARSHAL_EXCEPTION +

   391                     "(\"error marshalling arguments\", e);");

   392                 p.pOln("}");

   393             }

   394 

   395             p.pln("ref.invoke(call);");

   396 

   397             if (Util.isVoid(returnType)) {

   398                 p.pln("ref.done(call);");

   399             } else {

   400                 p.pln(returnType.toString() + " $result;");

   401                                                         // REMIND: why $?

   402                 p.plnI("try {");

   403                 p.pln("java.io.ObjectInput in = call.getInputStream();");

   404                 boolean objectRead =

   405                     writeUnmarshalArgument(p, "in", returnType, "$result");

   406                 p.pln(";");

   407                 p.pOlnI("} catch (java.io.IOException e) {");

   408                 p.pln("throw new " + UNMARSHAL_EXCEPTION +

   409                     "(\"error unmarshalling return\", e);");

   410                 /*

   411                  * If any only if readObject has been invoked, we must catch

   412                  * ClassNotFoundException as well as IOException.

   413                  */

   414                 if (objectRead) {

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

   416                     p.pln("throw new " + UNMARSHAL_EXCEPTION +

   417                         "(\"error unmarshalling return\", e);");

   418                 }

   419                 p.pOlnI("} finally {");

   420                 p.pln("ref.done(call);");

   421                 p.pOln("}");

   422                 p.pln("return $result;");

   423             }

   424         }

   425         if (version == StubVersion.VCOMPAT) {

   426             p.pOln("}");                // end if/else (useNewInvoke) block

   427         }

   428 

   429         /*

   430          * If we need to catch any particular exceptions, finally write

   431          * the catch blocks for them, rethrow any other Exceptions with an

   432          * UnexpectedException, and end the try block.

   433          */

   434         if (catchList.size() > 0) {

   435             for (ClassDoc catchClass : catchList) {

   436                 p.pOlnI("} catch (" + catchClass.qualifiedName() + " e) {");

   437                 p.pln("throw e;");

   438             }

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

   440             p.pln("throw new " + UNEXPECTED_EXCEPTION +

   441                 "(\"undeclared checked exception\", e);");

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

   443         }

   444 

   445         p.pOln("}");                    // end stub method

   446     }

   447 

   448     /**

   449      * Computes the exceptions that need to be caught and rethrown in

   450      * a stub method before wrapping Exceptions in

   451      * UnexpectedExceptions, given the exceptions declared in the

   452      * throws clause of the method.  Returns a list containing the

   453      * exception to catch.  Each exception is guaranteed to be unique,

   454      * i.e. not a subclass of any of the other exceptions in the list,

   455      * so the catch blocks for these exceptions may be generated in

   456      * any order relative to each other.

   457      *

   458      * RemoteException and RuntimeException are each automatically

   459      * placed in the returned list (unless any of their superclasses

   460      * are already present), since those exceptions should always be

   461      * directly rethrown by a stub method.

   462      *

   463      * The returned list will be empty if java.lang.Exception or one

   464      * of its superclasses is in the throws clause of the method,

   465      * indicating that no exceptions need to be caught.

   466      **/

   467     private List<ClassDoc> computeUniqueCatchList(ClassDoc[] exceptions) {

   468         List<ClassDoc> uniqueList = new ArrayList<ClassDoc>();

   469 

   470         uniqueList.add(env.docRuntimeException());

   471         uniqueList.add(env.docRemoteException()); // always catch/rethrow these

   472 

   473         /* For each exception declared by the stub method's throws clause: */

   474     nextException:

   475         for (ClassDoc ex : exceptions) {

   476             if (env.docException().subclassOf(ex)) {

   477                 /*

   478                  * If java.lang.Exception (or a superclass) was declared

   479                  * in the throws clause of this stub method, then we don't

   480                  * have to bother catching anything; clear the list and

   481                  * return.

   482                  */

   483                 uniqueList.clear();

   484                 break;

   485             } else if (!ex.subclassOf(env.docException())) {

   486                 /*

   487                  * Ignore other Throwables that do not extend Exception,

   488                  * because they cannot be thrown by the invoke methods.

   489                  */

   490                 continue;

   491             }

   492             /*

   493              * Compare this exception against the current list of

   494              * exceptions that need to be caught:

   495              */

   496             for (Iterator<ClassDoc> i = uniqueList.iterator(); i.hasNext();) {

   497                 ClassDoc ex2 = i.next();

   498                 if (ex.subclassOf(ex2)) {

   499                     /*

   500                      * If a superclass of this exception is already on

   501                      * the list to catch, then ignore this one and continue;

   502                      */

   503                     continue nextException;

   504                 } else if (ex2.subclassOf(ex)) {

   505                     /*

   506                      * If a subclass of this exception is on the list

   507                      * to catch, then remove it;

   508                      */

   509                     i.remove();

   510                 }

   511             }

   512             /* This exception is unique: add it to the list to catch. */

   513             uniqueList.add(ex);

   514         }

   515         return uniqueList;

   516     }

   517 

   518     /**

   519      * Writes the skeleton for the remote class to a stream.

   520      **/

   521     void writeSkeleton(IndentingWriter p) throws IOException {

   522         if (version == StubVersion.V1_2) {

   523             throw new AssertionError(

   524                 "should not generate skeleton for version " + version);

   525         }

   526 

   527         /*

   528          * Write boiler plate comment.

   529          */

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

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

   532         p.pln();

   533 

   534         /*

   535          * If remote implementation class was in a particular package,

   536          * declare the skeleton class to be in the same package.

   537          */

   538         if (!packageName.equals("")) {

   539             p.pln("package " + packageName + ";");

   540             p.pln();

   541         }

   542 

   543         /*

   544          * Declare the skeleton class.

   545          */

   546         p.plnI("public final class " + skeletonClassSimpleName);

   547         p.pln("implements " + SKELETON);

   548         p.pOlnI("{");

   549 

   550         writeOperationsArray(p);

   551         p.pln();

   552 

   553         writeInterfaceHash(p);

   554         p.pln();

   555 

   556         /*

   557          * Define the getOperations() method.

   558          */

   559         p.plnI("public " + OPERATION + "[] getOperations() {");

   560         p.pln("return (" + OPERATION + "[]) operations.clone();");

   561         p.pOln("}");

   562         p.pln();

   563 

   564         /*

   565          * Define the dispatch() method.

   566          */

   567         p.plnI("public void dispatch(" + REMOTE + " obj, " +

   568             REMOTE_CALL + " call, int opnum, long hash)");

   569         p.pln("throws java.lang.Exception");

   570         p.pOlnI("{");

   571 

   572         if (version == StubVersion.VCOMPAT) {

   573             p.plnI("if (opnum < 0) {");

   574             if (remoteMethods.length > 0) {

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

   576                     if (opnum > 0)

   577                         p.pO("} else ");

   578                     p.plnI("if (hash == " +

   579                         remoteMethods[opnum].methodHash() + "L) {");

   580                     p.pln("opnum = " + opnum + ";");

   581                 }

   582                 p.pOlnI("} else {");

   583             }

   584             /*

   585              * Skeleton throws UnmarshalException if it does not recognize

   586              * the method hash; this is what UnicastServerRef.dispatch()

   587              * would do.

   588              */

   589             p.pln("throw new " +

   590                 UNMARSHAL_EXCEPTION + "(\"invalid method hash\");");

   591             if (remoteMethods.length > 0) {

   592                 p.pOln("}");

   593             }

   594             /*

   595              * Ignore the validation of the interface hash if the

   596              * operation number was negative, since it is really a

   597              * method hash instead.

   598              */

   599             p.pOlnI("} else {");

   600         }

   601 

   602         p.plnI("if (hash != interfaceHash)");

   603         p.pln("throw new " +

   604             SKELETON_MISMATCH_EXCEPTION + "(\"interface hash mismatch\");");

   605         p.pO();

   606 

   607         if (version == StubVersion.VCOMPAT) {

   608             p.pOln("}");                // end if/else (opnum < 0) block

   609         }

   610         p.pln();

   611 

   612         /*

   613          * Cast remote object reference to the remote implementation

   614          * class, if it's not private.  We don't use the binary name

   615          * of the class like previous implementations did because that

   616          * would not compile with javac (since 1.4.1).  If the remote

   617          * implementation class is private, then we can't cast to it

   618          * like previous implementations did because that also would

   619          * not compile with javac-- so instead, we'll have to try to

   620          * cast to the remote interface for each remote method.

   621          */

   622         if (!remoteClass.classDoc().isPrivate()) {

   623             p.pln(remoteClass.classDoc().qualifiedName() + " server = (" +

   624                   remoteClass.classDoc().qualifiedName() + ") obj;");

   625         }

   626 

   627         /*

   628          * Process call according to the operation number.

   629          */

   630         p.plnI("switch (opnum) {");

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

   632             writeSkeletonDispatchCase(p, opnum);

   633         }

   634         p.pOlnI("default:");

   635         /*

   636          * Skeleton throws UnmarshalException if it does not recognize

   637          * the operation number; this is consistent with the case of an

   638          * unrecognized method hash.

   639          */

   640         p.pln("throw new " + UNMARSHAL_EXCEPTION +

   641             "(\"invalid method number\");");

   642         p.pOln("}");                    // end switch statement

   643 

   644         p.pOln("}");                    // end dispatch() method

   645 

   646         p.pOln("}");                    // end skeleton class

   647     }

   648 

   649     /**

   650      * Writes the case block for the skeleton's dispatch method for

   651      * the remote method with the given "opnum".

   652      **/

   653     private void writeSkeletonDispatchCase(IndentingWriter p, int opnum)

   654         throws IOException

   655     {

   656         RemoteClass.Method method = remoteMethods[opnum];

   657         MethodDoc methodDoc = method.methodDoc();

   658         String methodName = methodDoc.name();

   659         Type paramTypes[] = method.parameterTypes();

   660         String paramNames[] = nameParameters(paramTypes);

   661         Type returnType = methodDoc.returnType();

   662 

   663         p.pOlnI("case " + opnum + ": // " +

   664             Util.getFriendlyUnqualifiedSignature(methodDoc));

   665         /*

   666          * Use nested block statement inside case to provide an independent

   667          * namespace for local variables used to unmarshal parameters for

   668          * this remote method.

   669          */

   670         p.pOlnI("{");

   671 

   672         if (paramTypes.length > 0) {

   673             /*

   674              * Declare local variables to hold arguments.

   675              */

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

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

   678             }

   679 

   680             /*

   681              * Unmarshal arguments from call stream.

   682              */

   683             p.plnI("try {");

   684             p.pln("java.io.ObjectInput in = call.getInputStream();");

   685             boolean objectsRead = writeUnmarshalArguments(p, "in",

   686                 paramTypes, paramNames);

   687             p.pOlnI("} catch (java.io.IOException e) {");

   688             p.pln("throw new " + UNMARSHAL_EXCEPTION +

   689                 "(\"error unmarshalling arguments\", e);");

   690             /*

   691              * If any only if readObject has been invoked, we must catch

   692              * ClassNotFoundException as well as IOException.

   693              */

   694             if (objectsRead) {

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

   696                 p.pln("throw new " + UNMARSHAL_EXCEPTION +

   697                     "(\"error unmarshalling arguments\", e);");

   698             }

   699             p.pOlnI("} finally {");

   700             p.pln("call.releaseInputStream();");

   701             p.pOln("}");

   702         } else {

   703             p.pln("call.releaseInputStream();");

   704         }

   705 

   706         if (!Util.isVoid(returnType)) {

   707             /*

   708              * Declare variable to hold return type, if not void.

   709              */

   710             p.p(returnType.toString() + " $result = ");

   711                                                         // REMIND: why $?

   712         }

   713 

   714         /*

   715          * Invoke the method on the server object.  If the remote

   716          * implementation class is private, then we don't have a

   717          * reference cast to it, and so we try to cast to the remote

   718          * object reference to the method's declaring interface here.

   719          */

   720         String target = remoteClass.classDoc().isPrivate() ?

   721             "((" + methodDoc.containingClass().qualifiedName() + ") obj)" :

   722             "server";

   723         p.p(target + "." + methodName + "(");

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

   725             if (i > 0)

   726                 p.p(", ");

   727             p.p(paramNames[i]);

   728         }

   729         p.pln(");");

   730 

   731         /*

   732          * Always invoke getResultStream(true) on the call object to send

   733          * the indication of a successful invocation to the caller.  If

   734          * the return type is not void, keep the result stream and marshal

   735          * the return value.

   736          */

   737         p.plnI("try {");

   738         if (!Util.isVoid(returnType)) {

   739             p.p("java.io.ObjectOutput out = ");

   740         }

   741         p.pln("call.getResultStream(true);");

   742         if (!Util.isVoid(returnType)) {

   743             writeMarshalArgument(p, "out", returnType, "$result");

   744             p.pln(";");

   745         }

   746         p.pOlnI("} catch (java.io.IOException e) {");

   747         p.pln("throw new " +

   748             MARSHAL_EXCEPTION + "(\"error marshalling return\", e);");

   749         p.pOln("}");

   750 

   751         p.pln("break;");                // break from switch statement

   752 

   753         p.pOlnI("}");                   // end nested block statement

   754         p.pln();

   755     }

   756 

   757     /**

   758      * Writes declaration and initializer for "operations" static array.

   759      **/

   760     private void writeOperationsArray(IndentingWriter p)

   761         throws IOException

   762     {

   763         p.plnI("private static final " + OPERATION + "[] operations = {");

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

   765             if (i > 0)

   766                 p.pln(",");

   767             p.p("new " + OPERATION + "(\"" +

   768                 remoteMethods[i].operationString() + "\")");

   769         }

   770         p.pln();

   771         p.pOln("};");

   772     }

   773 

   774     /**

   775      * Writes declaration and initializer for "interfaceHash" static field.

   776      **/

   777     private void writeInterfaceHash(IndentingWriter p)

   778         throws IOException

   779     {

   780         p.pln("private static final long interfaceHash = " +

   781             remoteClass.interfaceHash() + "L;");

   782     }

   783 

   784     /**

   785      * Writes declaration for java.lang.reflect.Method static fields

   786      * corresponding to each remote method in a stub.

   787      **/

   788     private void writeMethodFieldDeclarations(IndentingWriter p)

   789         throws IOException

   790     {

   791         for (String name : methodFieldNames) {

   792             p.pln("private static java.lang.reflect.Method " + name + ";");

   793         }

   794     }

   795 

   796     /**

   797      * Writes code to initialize the static fields for each method

   798      * using the Java Reflection API.

   799      **/

   800     private void writeMethodFieldInitializers(IndentingWriter p)

   801         throws IOException

   802     {

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

   804             p.p(methodFieldNames[i] + " = ");

   805             /*

   806              * Look up the Method object in the somewhat arbitrary

   807              * interface that we find in the Method object.

   808              */

   809             RemoteClass.Method method = remoteMethods[i];

   810             MethodDoc methodDoc = method.methodDoc();

   811             String methodName = methodDoc.name();

   812             Type paramTypes[] = method.parameterTypes();

   813 

   814             p.p(methodDoc.containingClass().qualifiedName() + ".class.getMethod(\"" +

   815                 methodName + "\", new java.lang.Class[] {");

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

   817                 if (j > 0)

   818                     p.p(", ");

   819                 p.p(paramTypes[j].toString() + ".class");

   820             }

   821             p.pln("});");

   822         }

   823     }

   824 

   825 

   826     /*

   827      * Following are a series of static utility methods useful during

   828      * the code generation process:

   829      */

   830 

   831     /**

   832      * Generates an array of names for fields correspondins to the

   833      * given array of remote methods.  Each name in the returned array

   834      * is guaranteed to be unique.

   835      *

   836      * The name of a method is included in its corresponding field

   837      * name to enhance readability of the generated code.

   838      **/

   839     private static String[] nameMethodFields(RemoteClass.Method[] methods) {

   840         String[] names = new String[methods.length];

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

   842             names[i] = "$method_" + methods[i].methodDoc().name() + "_" + i;

   843         }

   844         return names;

   845     }

   846 

   847     /**

   848      * Generates an array of names for parameters corresponding to the

   849      * given array of types for the parameters.  Each name in the

   850      * returned array is guaranteed to be unique.

   851      *

   852      * A representation of the type of a parameter is included in its

   853      * corresponding parameter name to enhance the readability of the

   854      * generated code.

   855      **/

   856     private static String[] nameParameters(Type[] types) {

   857         String[] names = new String[types.length];

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

   859             names[i] = "$param_" +

   860                 generateNameFromType(types[i]) + "_" + (i + 1);

   861         }

   862         return names;

   863     }

   864 

   865     /**

   866      * Generates a readable string representing the given type

   867      * suitable for embedding within a Java identifier.

   868      **/

   869     private static String generateNameFromType(Type type) {

   870         String name = type.typeName().replace('.', '$');

   871         int dimensions = type.dimension().length() / 2;

   872         for (int i = 0; i < dimensions; i++) {

   873             name = "arrayOf_" + name;

   874         }

   875         return name;

   876     }

   877 

   878     /**

   879      * Writes a snippet of Java code to marshal a value named "name"

   880      * of type "type" to the java.io.ObjectOutput stream named

   881      * "stream".

   882      *

   883      * Primitive types are marshalled with their corresponding methods

   884      * in the java.io.DataOutput interface, and objects (including

   885      * arrays) are marshalled using the writeObject method.

   886      **/

   887     private static void writeMarshalArgument(IndentingWriter p,

   888                                              String streamName,

   889                                              Type type, String name)

   890         throws IOException

   891     {

   892         if (type.dimension().length() > 0 || type.asClassDoc() != null) {

   893             p.p(streamName + ".writeObject(" + name + ")");

   894         } else if (type.typeName().equals("boolean")) {

   895             p.p(streamName + ".writeBoolean(" + name + ")");

   896         } else if (type.typeName().equals("byte")) {

   897             p.p(streamName + ".writeByte(" + name + ")");

   898         } else if (type.typeName().equals("char")) {

   899             p.p(streamName + ".writeChar(" + name + ")");

   900         } else if (type.typeName().equals("short")) {

   901             p.p(streamName + ".writeShort(" + name + ")");

   902         } else if (type.typeName().equals("int")) {

   903             p.p(streamName + ".writeInt(" + name + ")");

   904         } else if (type.typeName().equals("long")) {

   905             p.p(streamName + ".writeLong(" + name + ")");

   906         } else if (type.typeName().equals("float")) {

   907             p.p(streamName + ".writeFloat(" + name + ")");

   908         } else if (type.typeName().equals("double")) {

   909             p.p(streamName + ".writeDouble(" + name + ")");

   910         } else {

   911             throw new AssertionError(type);

   912         }

   913     }

   914 

   915     /**

   916      * Writes Java statements to marshal a series of values in order

   917      * as named in the "names" array, with types as specified in the

   918      * "types" array, to the java.io.ObjectOutput stream named

   919      * "stream".

   920      **/

   921     private static void writeMarshalArguments(IndentingWriter p,

   922                                               String streamName,

   923                                               Type[] types, String[] names)

   924         throws IOException

   925     {

   926         assert types.length == names.length;

   927 

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

   929             writeMarshalArgument(p, streamName, types[i], names[i]);

   930             p.pln(";");

   931         }

   932     }

   933 

   934     /**

   935      * Writes a snippet of Java code to unmarshal a value of type

   936      * "type" from the java.io.ObjectInput stream named "stream" into

   937      * a variable named "name" (if "name" is null, the value is

   938      * unmarshalled and discarded).

   939      *

   940      * Primitive types are unmarshalled with their corresponding

   941      * methods in the java.io.DataInput interface, and objects

   942      * (including arrays) are unmarshalled using the readObject

   943      * method.

   944      *

   945      * Returns true if code to invoke readObject was written, and

   946      * false otherwise.

   947      **/

   948     private static boolean writeUnmarshalArgument(IndentingWriter p,

   949                                                   String streamName,

   950                                                   Type type, String name)

   951         throws IOException

   952     {

   953         boolean readObject = false;

   954 

   955         if (name != null) {

   956             p.p(name + " = ");

   957         }

   958 

   959         if (type.dimension().length() > 0 || type.asClassDoc() != null) {

   960             p.p("(" + type.toString() + ") " + streamName + ".readObject()");

   961             readObject = true;

   962         } else if (type.typeName().equals("boolean")) {

   963             p.p(streamName + ".readBoolean()");

   964         } else if (type.typeName().equals("byte")) {

   965             p.p(streamName + ".readByte()");

   966         } else if (type.typeName().equals("char")) {

   967             p.p(streamName + ".readChar()");

   968         } else if (type.typeName().equals("short")) {

   969             p.p(streamName + ".readShort()");

   970         } else if (type.typeName().equals("int")) {

   971             p.p(streamName + ".readInt()");

   972         } else if (type.typeName().equals("long")) {

   973             p.p(streamName + ".readLong()");

   974         } else if (type.typeName().equals("float")) {

   975             p.p(streamName + ".readFloat()");

   976         } else if (type.typeName().equals("double")) {

   977             p.p(streamName + ".readDouble()");

   978         } else {

   979             throw new AssertionError(type);

   980         }

   981 

   982         return readObject;

   983     }

   984 

   985     /**

   986      * Writes Java statements to unmarshal a series of values in order

   987      * of types as in the "types" array from the java.io.ObjectInput

   988      * stream named "stream" into variables as named in "names" (for

   989      * any element of "names" that is null, the corresponding value is

   990      * unmarshalled and discarded).

   991      **/

   992     private static boolean writeUnmarshalArguments(IndentingWriter p,

   993                                                    String streamName,

   994                                                    Type[] types,

   995                                                    String[] names)

   996         throws IOException

   997     {

   998         assert types.length == names.length;

   999 

  1000         boolean readObject = false;

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

  1002             if (writeUnmarshalArgument(p, streamName, types[i], names[i])) {

  1003                 readObject = true;

  1004             }

  1005             p.pln(";");

  1006         }

  1007         return readObject;

  1008     }

  1009 

  1010     /**

  1011      * Returns a snippet of Java code to wrap a value named "name" of

  1012      * type "type" into an object as appropriate for use by the Java

  1013      * Reflection API.

  1014      *

  1015      * For primitive types, an appropriate wrapper class is

  1016      * instantiated with the primitive value.  For object types

  1017      * (including arrays), no wrapping is necessary, so the value is

  1018      * named directly.

  1019      **/

  1020     private static String wrapArgumentCode(Type type, String name) {

  1021         if (type.dimension().length() > 0 || type.asClassDoc() != null) {

  1022             return name;

  1023         } else if (type.typeName().equals("boolean")) {

  1024             return ("(" + name +

  1025                     " ? java.lang.Boolean.TRUE : java.lang.Boolean.FALSE)");

  1026         } else if (type.typeName().equals("byte")) {

  1027             return "new java.lang.Byte(" + name + ")";

  1028         } else if (type.typeName().equals("char")) {

  1029             return "new java.lang.Character(" + name + ")";

  1030         } else if (type.typeName().equals("short")) {

  1031             return "new java.lang.Short(" + name + ")";

  1032         } else if (type.typeName().equals("int")) {

  1033             return "new java.lang.Integer(" + name + ")";

  1034         } else if (type.typeName().equals("long")) {

  1035             return "new java.lang.Long(" + name + ")";

  1036         } else if (type.typeName().equals("float")) {

  1037             return "new java.lang.Float(" + name + ")";

  1038         } else if (type.typeName().equals("double")) {

  1039             return "new java.lang.Double(" + name + ")";

  1040         } else {

  1041             throw new AssertionError(type);

  1042         }

  1043     }

  1044 

  1045     /**

  1046      * Returns a snippet of Java code to unwrap a value named "name"

  1047      * into a value of type "type", as appropriate for the Java

  1048      * Reflection API.

  1049      *

  1050      * For primitive types, the value is assumed to be of the

  1051      * corresponding wrapper class, and a method is called on the

  1052      * wrapper to retrieve the primitive value.  For object types

  1053      * (include arrays), no unwrapping is necessary; the value is

  1054      * simply cast to the expected real object type.

  1055      **/

  1056     private static String unwrapArgumentCode(Type type, String name) {

  1057         if (type.dimension().length() > 0 || type.asClassDoc() != null) {

  1058             return "((" + type.toString() + ") " + name + ")";

  1059         } else if (type.typeName().equals("boolean")) {

  1060             return "((java.lang.Boolean) " + name + ").booleanValue()";

  1061         } else if (type.typeName().equals("byte")) {

  1062             return "((java.lang.Byte) " + name + ").byteValue()";

  1063         } else if (type.typeName().equals("char")) {

  1064             return "((java.lang.Character) " + name + ").charValue()";

  1065         } else if (type.typeName().equals("short")) {

  1066             return "((java.lang.Short) " + name + ").shortValue()";

  1067         } else if (type.typeName().equals("int")) {

  1068             return "((java.lang.Integer) " + name + ").intValue()";

  1069         } else if (type.typeName().equals("long")) {

  1070             return "((java.lang.Long) " + name + ").longValue()";

  1071         } else if (type.typeName().equals("float")) {

  1072             return "((java.lang.Float) " + name + ").floatValue()";

  1073         } else if (type.typeName().equals("double")) {

  1074             return "((java.lang.Double) " + name + ").doubleValue()";

  1075         } else {

  1076             throw new AssertionError(type);

  1077         }

  1078     }

  1079 }