| /* |
| * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /*****************************************************************************/ |
| /* 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; |
| import com.sun.corba.se.impl.util.Utility; |
| |
| /** |
| * 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", new Integer(STUB_VERSION_1_1)); |
| versionOptions.put("-vcompat", new Integer(STUB_VERSION_FAT)); |
| versionOptions.put("-v1.2", new Integer(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 error 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(new ClassFile(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(new ClassFile(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(); |
| |
| // Is there any existing _Tie equivalent leftover from a |
| // previous invocation of rmic -iiop? Only do this once per |
| // class by looking for skeleton generation... |
| |
| if (outputName.endsWith("_Skel")) { |
| String classNameStr = className.getName().toString(); |
| File temp = new File(packageDir, Utility.tieName(classNameStr) + ".class"); |
| if (temp.exists()) { |
| |
| // Found a tie. Is IIOP generation also being done? |
| |
| if (!env.getMain().iiopGeneration) { |
| |
| // No, so write a warning... |
| |
| env.error(0,"warn.rmic.tie.found", |
| classNameStr, |
| temp.getAbsolutePath()); |
| } |
| } |
| } |
| |
| 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])); |
| } |
| p.p("}"); |
| } else { |
| p.p("null"); |
| } |
| p.pln(", " + method.getMethodHash() + "L);"); |
| if (!returnType.isType(TC_VOID)) { |
| p.pln("return " + |
| unwrapArgumentCode(returnType, "$result") + ";"); |
| } |
| } |
| if (version == STUB_VERSION_FAT) { |
| p.pOlnI("} else {"); |
| } |
| if (version == STUB_VERSION_1_1 || |
| version == STUB_VERSION_FAT) |
| { |
| p.pln(idRemoteCall + " call = ref.newCall((" + idRemoteObject + |
| ") this, operations, " + opnum + ", interfaceHash);"); |
| |
| if (paramTypes.length > 0) { |
| p.plnI("try {"); |
| p.pln("java.io.ObjectOutput out = call.getOutputStream();"); |
| writeMarshalArguments(p, "out", paramTypes, paramNames); |
| p.pOlnI("} catch (java.io.IOException e) {"); |
| p.pln("throw new " + idMarshalException + |
| "(\"error marshalling arguments\", e);"); |
| p.pOln("}"); |
| } |
| |
| p.pln("ref.invoke(call);"); |
| |
| if (returnType.isType(TC_VOID)) { |
| p.pln("ref.done(call);"); |
| } else { |
| p.pln(returnType + " $result;"); // REMIND: why $? |
| p.plnI("try {"); |
| p.pln("java.io.ObjectInput in = call.getInputStream();"); |
| boolean objectRead = |
| writeUnmarshalArgument(p, "in", returnType, "$result"); |
| p.pln(";"); |
| p.pOlnI("} catch (java.io.IOException e) {"); |
| p.pln("throw new " + idUnmarshalException + |
| "(\"error unmarshalling return\", e);"); |
| /* |
| * If any only if readObject has been invoked, we must catch |
| * ClassNotFoundException as well as IOException. |
| */ |
| if (objectRead) { |
| p.pOlnI("} catch (java.lang.ClassNotFoundException e) {"); |
| p.pln("throw new " + idUnmarshalException + |
| "(\"error unmarshalling return\", e);"); |
| } |
| p.pOlnI("} finally {"); |
| p.pln("ref.done(call);"); |
| p.pOln("}"); |
| p.pln("return $result;"); |
| } |
| } |
| if (version == STUB_VERSION_FAT) { |
| p.pOln("}"); // end if/else (useNewInvoke) block |
| } |
| |
| /* |
| * If we need to catch any particular exceptions, finally write |
| * the catch blocks for them, rethrow any other Exceptions with an |
| * UnexpectedException, and end the try block. |
| */ |
| if (catchList.size() > 0) { |
| for (Enumeration<ClassDefinition> enumeration = catchList.elements(); |
| enumeration.hasMoreElements();) |
| { |
| ClassDefinition def = enumeration.nextElement(); |
| p.pOlnI("} catch (" + def.getName() + " e) {"); |
| p.pln("throw e;"); |
| } |
| p.pOlnI("} catch (java.lang.Exception e) {"); |
| p.pln("throw new " + idUnexpectedException + |
| "(\"undeclared checked exception\", e);"); |
| p.pOln("}"); // end try/catch block |
| } |
| |
| p.pOln("}"); // end stub method |
| } |
| |
| /** |
| * Compute the exceptions which need to be caught and rethrown in a |
| * stub method before wrapping Exceptions in UnexpectedExceptions, |
| * given the exceptions declared in the throws clause of the method. |
| * Returns a Vector containing ClassDefinition objects for each |
| * exception to catch. Each exception is guaranteed to be unique, |
| * i.e. not a subclass of any of the other exceptions in the Vector, |
| * so the catch blocks for these exceptions may be generated in any |
| * order relative to each other. |
| * |
| * RemoteException and RuntimeException are each automatically placed |
| * in the returned Vector (if none of their superclasses are already |
| * present), since those exceptions should always be directly rethrown |
| * by a stub method. |
| * |
| * The returned Vector will be empty if java.lang.Exception or one |
| * of its superclasses is in the throws clause of the method, indicating |
| * that no exceptions need to be caught. |
| */ |
| private Vector<ClassDefinition> computeUniqueCatchList(ClassDeclaration[] exceptions) { |
| Vector<ClassDefinition> uniqueList = new Vector<>(); // unique exceptions to catch |
| |
| uniqueList.addElement(defRuntimeException); |
| uniqueList.addElement(defRemoteException); |
| |
| /* For each exception declared by the stub method's throws clause: */ |
| nextException: |
| for (int i = 0; i < exceptions.length; i++) { |
| ClassDeclaration decl = exceptions[i]; |
| try { |
| if (defException.subClassOf(env, decl)) { |
| /* |
| * (If java.lang.Exception (or a superclass) was declared |
| * in the throws clause of this stub method, then we don't |
| * have to bother catching anything; clear the list and |
| * return.) |
| */ |
| uniqueList.clear(); |
| break; |
| } else if (!defException.superClassOf(env, decl)) { |
| /* |
| * Ignore other Throwables that do not extend Exception, |
| * since they do not need to be caught anyway. |
| */ |
| continue; |
| } |
| /* |
| * Compare this exception against the current list of |
| * exceptions that need to be caught: |
| */ |
| for (int j = 0; j < uniqueList.size();) { |
| ClassDefinition def = uniqueList.elementAt(j); |
| if (def.superClassOf(env, decl)) { |
| /* |
| * If a superclass of this exception is already on |
| * the list to catch, then ignore and continue; |
| */ |
| continue nextException; |
| } else if (def.subClassOf(env, decl)) { |
| /* |
| * If a subclass of this exception is on the list |
| * to catch, then remove it. |
| */ |
| uniqueList.removeElementAt(j); |
| } else { |
| j++; // else continue comparing |
| } |
| } |
| /* This exception is unique: add it to the list to catch. */ |
| uniqueList.addElement(decl.getClassDefinition(env)); |
| } catch (ClassNotFound e) { |
| env.error(0, "class.not.found", e.name, decl.getName()); |
| /* |
| * REMIND: We do not exit from this exceptional condition, |
| * generating questionable code and likely letting the |
| * compiler report a resulting error later. |
| */ |
| } |
| } |
| return uniqueList; |
| } |
| |
| /** |
| * Write the skeleton for the remote class to a stream. |
| */ |
| private void writeSkeleton(IndentingWriter p) throws IOException { |
| if (version == STUB_VERSION_1_2) { |
| throw new Error("should not generate skeleton for version"); |
| } |
| |
| /* |
| * Write boiler plate comment. |
| */ |
| p.pln("// Skeleton 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 skeleton class to be in the same package. |
| */ |
| if (remoteClassName.isQualified()) { |
| p.pln("package " + remoteClassName.getQualifier() + ";"); |
| p.pln(); |
| } |
| |
| /* |
| * Declare the skeleton class. |
| */ |
| p.plnI("public final class " + |
| Names.mangleClass(skeletonClassName.getName())); |
| p.pln("implements " + idSkeleton); |
| p.pOlnI("{"); |
| |
| writeOperationsArray(p); |
| p.pln(); |
| |
| writeInterfaceHash(p); |
| p.pln(); |
| |
| /* |
| * Define the getOperations() method. |
| */ |
| p.plnI("public " + idOperation + "[] getOperations() {"); |
| p.pln("return (" + idOperation + "[]) operations.clone();"); |
| p.pOln("}"); |
| p.pln(); |
| |
| /* |
| * Define the dispatch() method. |
| */ |
| p.plnI("public void dispatch(" + idRemote + " obj, " + |
| idRemoteCall + " call, int opnum, long hash)"); |
| p.pln("throws java.lang.Exception"); |
| p.pOlnI("{"); |
| |
| if (version == STUB_VERSION_FAT) { |
| p.plnI("if (opnum < 0) {"); |
| if (remoteMethods.length > 0) { |
| for (int opnum = 0; opnum < remoteMethods.length; opnum++) { |
| if (opnum > 0) |
| p.pO("} else "); |
| p.plnI("if (hash == " + |
| remoteMethods[opnum].getMethodHash() + "L) {"); |
| p.pln("opnum = " + opnum + ";"); |
| } |
| p.pOlnI("} else {"); |
| } |
| /* |
| * Skeleton throws UnmarshalException if it does not recognize |
| * the method hash; this is what UnicastServerRef.dispatch() |
| * would do. |
| */ |
| p.pln("throw new " + |
| idUnmarshalException + "(\"invalid method hash\");"); |
| if (remoteMethods.length > 0) { |
| p.pOln("}"); |
| } |
| /* |
| * Ignore the validation of the interface hash if the |
| * operation number was negative, since it is really a |
| * method hash instead. |
| */ |
| p.pOlnI("} else {"); |
| } |
| |
| p.plnI("if (hash != interfaceHash)"); |
| p.pln("throw new " + |
| idSkeletonMismatchException + "(\"interface hash mismatch\");"); |
| p.pO(); |
| |
| if (version == STUB_VERSION_FAT) { |
| p.pOln("}"); // end if/else (opnum < 0) block |
| } |
| p.pln(); |
| |
| /* |
| * Cast remote object instance to our specific implementation class. |
| */ |
| p.pln(remoteClassName + " server = (" + remoteClassName + ") obj;"); |
| |
| /* |
| * Process call according to the operation number. |
| */ |
| p.plnI("switch (opnum) {"); |
| for (int opnum = 0; opnum < remoteMethods.length; opnum++) { |
| writeSkeletonDispatchCase(p, opnum); |
| } |
| p.pOlnI("default:"); |
| /* |
| * Skeleton throws UnmarshalException if it does not recognize |
| * the operation number; this is consistent with the case of an |
| * unrecognized method hash. |
| */ |
| p.pln("throw new " + idUnmarshalException + |
| "(\"invalid method number\");"); |
| p.pOln("}"); // end switch statement |
| |
| p.pOln("}"); // end dispatch() method |
| |
| p.pOln("}"); // end skeleton class |
| } |
| |
| /** |
| * Write the case block for the skeleton's dispatch method for |
| * the remote method with the given "opnum". |
| */ |
| private void writeSkeletonDispatchCase(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(); |
| |
| p.pOlnI("case " + opnum + ": // " + |
| methodType.typeString(methodName.toString(), true, false)); |
| /* |
| * Use nested block statement inside case to provide an independent |
| * namespace for local variables used to unmarshal parameters for |
| * this remote method. |
| */ |
| p.pOlnI("{"); |
| |
| if (paramTypes.length > 0) { |
| /* |
| * Declare local variables to hold arguments. |
| */ |
| for (int i = 0; i < paramTypes.length; i++) { |
| p.pln(paramTypes[i] + " " + paramNames[i] + ";"); |
| } |
| |
| /* |
| * Unmarshal arguments from call stream. |
| */ |
| p.plnI("try {"); |
| p.pln("java.io.ObjectInput in = call.getInputStream();"); |
| boolean objectsRead = writeUnmarshalArguments(p, "in", |
| paramTypes, paramNames); |
| p.pOlnI("} catch (java.io.IOException e) {"); |
| p.pln("throw new " + idUnmarshalException + |
| "(\"error unmarshalling arguments\", e);"); |
| /* |
| * If any only if readObject has been invoked, we must catch |
| * ClassNotFoundException as well as IOException. |
| */ |
| if (objectsRead) { |
| p.pOlnI("} catch (java.lang.ClassNotFoundException e) {"); |
| p.pln("throw new " + idUnmarshalException + |
| "(\"error unmarshalling arguments\", e);"); |
| } |
| p.pOlnI("} finally {"); |
| p.pln("call.releaseInputStream();"); |
| p.pOln("}"); |
| } else { |
| p.pln("call.releaseInputStream();"); |
| } |
| |
| if (!returnType.isType(TC_VOID)) { |
| /* |
| * Declare variable to hold return type, if not void. |
| */ |
| p.p(returnType + " $result = "); // REMIND: why $? |
| } |
| |
| /* |
| * Invoke the method on the server object. |
| */ |
| p.p("server." + methodName + "("); |
| for (int i = 0; i < paramNames.length; i++) { |
| if (i > 0) |
| p.p(", "); |
| p.p(paramNames[i]); |
| } |
| p.pln(");"); |
| |
| /* |
| * Always invoke getResultStream(true) on the call object to send |
| * the indication of a successful invocation to the caller. If |
| * the return type is not void, keep the result stream and marshal |
| * the return value. |
| */ |
| p.plnI("try {"); |
| if (!returnType.isType(TC_VOID)) { |
| p.p("java.io.ObjectOutput out = "); |
| } |
| p.pln("call.getResultStream(true);"); |
| if (!returnType.isType(TC_VOID)) { |
| writeMarshalArgument(p, "out", returnType, "$result"); |
| p.pln(";"); |
| } |
| p.pOlnI("} catch (java.io.IOException e) {"); |
| p.pln("throw new " + |
| idMarshalException + "(\"error marshalling return\", e);"); |
| p.pOln("}"); |
| |
| p.pln("break;"); // break from switch statement |
| |
| p.pOlnI("}"); // end nested block statement |
| p.pln(); |
| } |
| |
| /** |
| * Write declaration and initializer for "operations" static array. |
| */ |
| private void writeOperationsArray(IndentingWriter p) |
| throws IOException |
| { |
| p.plnI("private static final " + idOperation + "[] operations = {"); |
| for (int i = 0; i < remoteMethods.length; i++) { |
| if (i > 0) |
| p.pln(","); |
| p.p("new " + idOperation + "(\"" + |
| remoteMethods[i].getOperationString() + "\")"); |
| } |
| p.pln(); |
| p.pOln("};"); |
| } |
| |
| /** |
| * Write declaration and initializer for "interfaceHash" static field. |
| */ |
| private void writeInterfaceHash(IndentingWriter p) |
| throws IOException |
| { |
| p.pln("private static final long interfaceHash = " + |
| remoteClass.getInterfaceHash() + "L;"); |
| } |
| |
| /** |
| * Write declaration for java.lang.reflect.Method static fields |
| * corresponding to each remote method in a stub. |
| */ |
| private void writeMethodFieldDeclarations(IndentingWriter p) |
| throws IOException |
| { |
| for (int i = 0; i < methodFieldNames.length; i++) { |
| p.pln("private static java.lang.reflect.Method " + |
| methodFieldNames[i] + ";"); |
| } |
| } |
| |
| /** |
| * Write code to initialize the static fields for each method |
| * using the Java Reflection API. |
| */ |
| private void writeMethodFieldInitializers(IndentingWriter p) |
| throws IOException |
| { |
| for (int i = 0; i < methodFieldNames.length; i++) { |
| p.p(methodFieldNames[i] + " = "); |
| /* |
| * Here we look up the Method object in the arbitrary interface |
| * that we find in the RemoteClass.Method object. |
| * REMIND: Is this arbitrary choice OK? |
| * REMIND: Should this access be part of RemoteClass.Method's |
| * abstraction? |
| */ |
| RemoteClass.Method method = remoteMethods[i]; |
| MemberDefinition def = method.getMemberDefinition(); |
| Identifier methodName = method.getName(); |
| Type methodType = method.getType(); |
| Type paramTypes[] = methodType.getArgumentTypes(); |
| |
| p.p(def.getClassDefinition().getName() + ".class.getMethod(\"" + |
| methodName + "\", new java.lang.Class[] {"); |
| for (int j = 0; j < paramTypes.length; j++) { |
| if (j > 0) |
| p.p(", "); |
| p.p(paramTypes[j] + ".class"); |
| } |
| p.pln("});"); |
| } |
| } |
| |
| |
| /* |
| * Following are a series of static utility methods useful during |
| * the code generation process: |
| */ |
| |
| /** |
| * Generate an array of names for fields that correspond to the given |
| * array of remote methods. Each name in the returned array is |
| * guaranteed to be unique. |
| * |
| * The name of a method is included in its corresponding field name |
| * to enhance readability of the generated code. |
| */ |
| private static String[] nameMethodFields(RemoteClass.Method[] methods) { |
| String[] names = new String[methods.length]; |
| for (int i = 0; i < names.length; i++) { |
| names[i] = "$method_" + methods[i].getName() + "_" + i; |
| } |
| return names; |
| } |
| |
| /** |
| * Generate an array of names for parameters corresponding to the |
| * given array of types for the parameters. Each name in the returned |
| * array is guaranteed to be unique. |
| * |
| * A representation of the type of a parameter is included in its |
| * corresponding field name to enhance the readability of the generated |
| * code. |
| */ |
| private static String[] nameParameters(Type[] types) { |
| String[] names = new String[types.length]; |
| for (int i = 0; i < names.length; i++) { |
| names[i] = "$param_" + |
| generateNameFromType(types[i]) + "_" + (i + 1); |
| } |
| return names; |
| } |
| |
| /** |
| * Generate a readable string representing the given type suitable |
| * for embedding within a Java identifier. |
| */ |
| private static String generateNameFromType(Type type) { |
| int typeCode = type.getTypeCode(); |
| switch (typeCode) { |
| case TC_BOOLEAN: |
| case TC_BYTE: |
| case TC_CHAR: |
| case TC_SHORT: |
| case TC_INT: |
| case TC_LONG: |
| case TC_FLOAT: |
| case TC_DOUBLE: |
| return type.toString(); |
| case TC_ARRAY: |
| return "arrayOf_" + generateNameFromType(type.getElementType()); |
| case TC_CLASS: |
| return Names.mangleClass(type.getClassName().getName()).toString(); |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| } |
| |
| /** |
| * Write a snippet of Java code to marshal a value named "name" of |
| * type "type" to the java.io.ObjectOutput stream named "stream". |
| * |
| * Primitive types are marshalled with their corresponding methods |
| * in the java.io.DataOutput interface, and objects (including arrays) |
| * are marshalled using the writeObject method. |
| */ |
| private static void writeMarshalArgument(IndentingWriter p, |
| String streamName, |
| Type type, String name) |
| throws IOException |
| { |
| int typeCode = type.getTypeCode(); |
| switch (typeCode) { |
| case TC_BOOLEAN: |
| p.p(streamName + ".writeBoolean(" + name + ")"); |
| break; |
| case TC_BYTE: |
| p.p(streamName + ".writeByte(" + name + ")"); |
| break; |
| case TC_CHAR: |
| p.p(streamName + ".writeChar(" + name + ")"); |
| break; |
| case TC_SHORT: |
| p.p(streamName + ".writeShort(" + name + ")"); |
| break; |
| case TC_INT: |
| p.p(streamName + ".writeInt(" + name + ")"); |
| break; |
| case TC_LONG: |
| p.p(streamName + ".writeLong(" + name + ")"); |
| break; |
| case TC_FLOAT: |
| p.p(streamName + ".writeFloat(" + name + ")"); |
| break; |
| case TC_DOUBLE: |
| p.p(streamName + ".writeDouble(" + name + ")"); |
| break; |
| case TC_ARRAY: |
| case TC_CLASS: |
| p.p(streamName + ".writeObject(" + name + ")"); |
| break; |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| } |
| |
| /** |
| * Write Java statements to marshal a series of values in order as |
| * named in the "names" array, with types as specified in the "types" |
| * array", to the java.io.ObjectOutput stream named "stream". |
| */ |
| private static void writeMarshalArguments(IndentingWriter p, |
| String streamName, |
| Type[] types, String[] names) |
| throws IOException |
| { |
| if (types.length != names.length) { |
| throw new Error("paramter type and name arrays different sizes"); |
| } |
| |
| for (int i = 0; i < types.length; i++) { |
| writeMarshalArgument(p, streamName, types[i], names[i]); |
| p.pln(";"); |
| } |
| } |
| |
| /** |
| * Write a snippet of Java code to unmarshal a value of type "type" |
| * from the java.io.ObjectInput stream named "stream" into a variable |
| * named "name" (if "name" is null, the value in unmarshalled and |
| * discarded). |
| * |
| * Primitive types are unmarshalled with their corresponding methods |
| * in the java.io.DataInput interface, and objects (including arrays) |
| * are unmarshalled using the readObject method. |
| */ |
| private static boolean writeUnmarshalArgument(IndentingWriter p, |
| String streamName, |
| Type type, String name) |
| throws IOException |
| { |
| boolean readObject = false; |
| |
| if (name != null) { |
| p.p(name + " = "); |
| } |
| |
| int typeCode = type.getTypeCode(); |
| switch (type.getTypeCode()) { |
| case TC_BOOLEAN: |
| p.p(streamName + ".readBoolean()"); |
| break; |
| case TC_BYTE: |
| p.p(streamName + ".readByte()"); |
| break; |
| case TC_CHAR: |
| p.p(streamName + ".readChar()"); |
| break; |
| case TC_SHORT: |
| p.p(streamName + ".readShort()"); |
| break; |
| case TC_INT: |
| p.p(streamName + ".readInt()"); |
| break; |
| case TC_LONG: |
| p.p(streamName + ".readLong()"); |
| break; |
| case TC_FLOAT: |
| p.p(streamName + ".readFloat()"); |
| break; |
| case TC_DOUBLE: |
| p.p(streamName + ".readDouble()"); |
| break; |
| case TC_ARRAY: |
| case TC_CLASS: |
| p.p("(" + type + ") " + streamName + ".readObject()"); |
| readObject = true; |
| break; |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| return readObject; |
| } |
| |
| /** |
| * Write Java statements to unmarshal a series of values in order of |
| * types as in the "types" array from the java.io.ObjectInput stream |
| * named "stream" into variables as named in "names" (for any element |
| * of "names" that is null, the corresponding value is unmarshalled |
| * and discarded). |
| */ |
| private static boolean writeUnmarshalArguments(IndentingWriter p, |
| String streamName, |
| Type[] types, |
| String[] names) |
| throws IOException |
| { |
| if (types.length != names.length) { |
| throw new Error("paramter type and name arrays different sizes"); |
| } |
| |
| boolean readObject = false; |
| for (int i = 0; i < types.length; i++) { |
| if (writeUnmarshalArgument(p, streamName, types[i], names[i])) { |
| readObject = true; |
| } |
| p.pln(";"); |
| } |
| return readObject; |
| } |
| |
| /** |
| * Return a snippet of Java code to wrap a value named "name" of |
| * type "type" into an object as appropriate for use by the |
| * Java Reflection API. |
| * |
| * For primitive types, an appropriate wrapper class instantiated |
| * with the primitive value. For object types (including arrays), |
| * no wrapping is necessary, so the value is named directly. |
| */ |
| private static String wrapArgumentCode(Type type, String name) { |
| int typeCode = type.getTypeCode(); |
| switch (typeCode) { |
| case TC_BOOLEAN: |
| return ("(" + name + |
| " ? java.lang.Boolean.TRUE : java.lang.Boolean.FALSE)"); |
| case TC_BYTE: |
| return "new java.lang.Byte(" + name + ")"; |
| case TC_CHAR: |
| return "new java.lang.Character(" + name + ")"; |
| case TC_SHORT: |
| return "new java.lang.Short(" + name + ")"; |
| case TC_INT: |
| return "new java.lang.Integer(" + name + ")"; |
| case TC_LONG: |
| return "new java.lang.Long(" + name + ")"; |
| case TC_FLOAT: |
| return "new java.lang.Float(" + name + ")"; |
| case TC_DOUBLE: |
| return "new java.lang.Double(" + name + ")"; |
| case TC_ARRAY: |
| case TC_CLASS: |
| return name; |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| } |
| |
| /** |
| * Return a snippet of Java code to unwrap a value named "name" into |
| * a value of type "type", as appropriate for the Java Reflection API. |
| * |
| * For primitive types, the value is assumed to be of the corresponding |
| * wrapper type, and a method is called on the wrapper type to retrieve |
| * the primitive value. For object types (include arrays), no |
| * unwrapping is necessary; the value is simply cast to the expected |
| * real object type. |
| */ |
| private static String unwrapArgumentCode(Type type, String name) { |
| int typeCode = type.getTypeCode(); |
| switch (typeCode) { |
| case TC_BOOLEAN: |
| return "((java.lang.Boolean) " + name + ").booleanValue()"; |
| case TC_BYTE: |
| return "((java.lang.Byte) " + name + ").byteValue()"; |
| case TC_CHAR: |
| return "((java.lang.Character) " + name + ").charValue()"; |
| case TC_SHORT: |
| return "((java.lang.Short) " + name + ").shortValue()"; |
| case TC_INT: |
| return "((java.lang.Integer) " + name + ").intValue()"; |
| case TC_LONG: |
| return "((java.lang.Long) " + name + ").longValue()"; |
| case TC_FLOAT: |
| return "((java.lang.Float) " + name + ").floatValue()"; |
| case TC_DOUBLE: |
| return "((java.lang.Double) " + name + ").doubleValue()"; |
| case TC_ARRAY: |
| case TC_CLASS: |
| return "((" + type + ") " + name + ")"; |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| } |
| } |
