| /* |
| * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * Licensed Materials - Property of IBM |
| * RMI-IIOP v1.0 |
| * Copyright IBM Corp. 1998 1999 All Rights Reserved |
| * |
| */ |
| |
| package sun.rmi.rmic.iiop; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.SerializablePermission; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.Vector; |
| import java.util.Hashtable; |
| import java.util.Enumeration; |
| import sun.tools.java.Identifier; |
| import sun.tools.java.ClassNotFound; |
| import sun.tools.java.ClassDefinition; |
| import sun.tools.java.ClassDeclaration; |
| import sun.tools.java.CompilerError; |
| import sun.rmi.rmic.IndentingWriter; |
| import java.util.HashSet; |
| import java.util.Arrays; |
| import com.sun.corba.se.impl.util.Utility; |
| import com.sun.corba.se.impl.util.PackagePrefixChecker; |
| import sun.rmi.rmic.Main; |
| |
| |
| /** |
| * An IIOP stub/tie generator for rmic. |
| * |
| * @author Bryan Atsatt |
| * @author Anil Vijendran |
| * @author M. Mortazavi |
| */ |
| |
| public class StubGenerator extends sun.rmi.rmic.iiop.Generator { |
| |
| private static final String DEFAULT_STUB_CLASS = "javax.rmi.CORBA.Stub"; |
| private static final String DEFAULT_TIE_CLASS = "org.omg.CORBA_2_3.portable.ObjectImpl"; |
| private static final String DEFAULT_POA_TIE_CLASS = "org.omg.PortableServer.Servant"; |
| |
| protected boolean reverseIDs = false; |
| protected boolean localStubs = true; |
| protected boolean standardPackage = false; |
| protected boolean useHash = true; |
| protected String stubBaseClass = DEFAULT_STUB_CLASS; |
| protected String tieBaseClass = DEFAULT_TIE_CLASS; |
| protected HashSet namesInUse = new HashSet(); |
| protected Hashtable classesInUse = new Hashtable(); |
| protected Hashtable imports = new Hashtable(); |
| protected int importCount = 0; |
| protected String currentPackage = null; |
| protected String currentClass = null; |
| protected boolean castArray = false; |
| protected Hashtable transactionalObjects = new Hashtable() ; |
| protected boolean POATie = false ; |
| protected boolean emitPermissionCheck = false; |
| |
| /** |
| * Default constructor for Main to use. |
| */ |
| public StubGenerator() { |
| } |
| |
| /** |
| * Overridden in order to set the standardPackage flag. |
| */ |
| public void generate( |
| sun.rmi.rmic.BatchEnvironment env, |
| ClassDefinition cdef, File destDir) { |
| ((sun.rmi.rmic.iiop.BatchEnvironment)env). |
| setStandardPackage(standardPackage); |
| super.generate(env, cdef, destDir); |
| } |
| |
| /** |
| * Return true if a new instance should be created for each |
| * class on the command line. Subclasses which return true |
| * should override newInstance() to return an appropriately |
| * constructed instance. |
| */ |
| protected boolean requireNewInstance() { |
| return false; |
| } |
| |
| /** |
| * Return true if non-conforming types should be parsed. |
| * @param stack The context stack. |
| */ |
| protected boolean parseNonConforming(ContextStack stack) { |
| |
| // We let the environment setting decide so that |
| // another generator (e.g. IDLGenerator) can change |
| // it and we will just go with the flow... |
| |
| return stack.getEnv().getParseNonConforming(); |
| } |
| |
| /** |
| * Create and return a top-level type. |
| * @param cdef The top-level class definition. |
| * @param stack The context stack. |
| * @return The compound type or null if is non-conforming. |
| */ |
| protected CompoundType getTopType(ClassDefinition cdef, ContextStack stack) { |
| |
| CompoundType result = null; |
| |
| // Do we have an interface? |
| |
| if (cdef.isInterface()) { |
| |
| // Yes, so first try Abstract... |
| |
| result = AbstractType.forAbstract(cdef,stack,true); |
| |
| if (result == null) { |
| |
| // Then try Remote... |
| |
| result = RemoteType.forRemote(cdef,stack,false); |
| } |
| } else { |
| |
| // Not an interface, so try Implementation... |
| |
| result = ImplementationType.forImplementation(cdef,stack,false); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Examine and consume command line arguments. |
| * @param argv The command line arguments. Ignore null |
| * and unknown arguments. Set each consumed argument to null. |
| * @param error Report any errors using the main.error() methods. |
| * @return true if no errors, false otherwise. |
| */ |
| public boolean parseArgs(String argv[], Main main) { |
| Object marker = new Object() ; |
| |
| // Reset any cached options... |
| |
| reverseIDs = false; |
| localStubs = true; |
| useHash = true; |
| stubBaseClass = DEFAULT_STUB_CLASS; |
| // tieBaseClass = DEFAULT_TIE_CLASS; |
| transactionalObjects = new Hashtable() ; |
| |
| // Parse options... |
| |
| boolean result = super.parseArgs(argv,main); |
| if (result) { |
| for (int i = 0; i < argv.length; i++) { |
| if (argv[i] != null) { |
| String arg = argv[i].toLowerCase(); |
| if (arg.equals("-iiop")) { |
| argv[i] = null; |
| } else if (arg.equals("-xreverseids")) { |
| reverseIDs = true; |
| argv[i] = null; |
| } else if (arg.equals("-nolocalstubs")) { |
| localStubs = false; |
| argv[i] = null; |
| } else if (arg.equals("-xnohash")) { |
| useHash = false; |
| argv[i] = null; |
| } else if (argv[i].equals("-standardPackage")) { |
| standardPackage = true; |
| argv[i] = null; |
| } else if (argv[i].equals("-emitPermissionCheck")) { |
| emitPermissionCheck = true; |
| argv[i] = null; |
| } else if (arg.equals("-xstubbase")) { |
| argv[i] = null; |
| if (++i < argv.length && argv[i] != null && !argv[i].startsWith("-")) { |
| stubBaseClass = argv[i]; |
| argv[i] = null; |
| } else { |
| main.error("rmic.option.requires.argument", "-Xstubbase"); |
| result = false; |
| } |
| } else if (arg.equals("-xtiebase")) { |
| argv[i] = null; |
| if (++i < argv.length && argv[i] != null && !argv[i].startsWith("-")) { |
| tieBaseClass = argv[i]; |
| argv[i] = null; |
| } else { |
| main.error("rmic.option.requires.argument", "-Xtiebase"); |
| result = false; |
| } |
| } else if (arg.equals("-transactional" )) { |
| // Scan for the next non-flag argument. |
| // Assume that it is a class name and add it |
| // to the list of transactional classes. |
| for ( int ctr=i+1; ctr<argv.length; ctr++ ) { |
| if (argv[ctr].charAt(1) != '-') { |
| transactionalObjects.put( argv[ctr], marker ) ; |
| break ; |
| } |
| } |
| argv[i] = null; |
| } else if (arg.equals( "-poa" )) { |
| POATie = true ; |
| argv[i] = null; |
| } |
| } |
| } |
| } |
| if(POATie){ |
| tieBaseClass = DEFAULT_POA_TIE_CLASS; |
| } else { |
| tieBaseClass = DEFAULT_TIE_CLASS; |
| } |
| return result; |
| } |
| |
| /** |
| * Return an array containing all the file names and types that need to be |
| * generated for the given top-level type. The file names must NOT have an |
| * extension (e.g. ".java"). |
| * @param topType The type returned by getTopType(). |
| * @param alreadyChecked A set of Types which have already been checked. |
| * Intended to be passed to topType.collectMatching(filter,alreadyChecked). |
| */ |
| protected OutputType[] getOutputTypesFor(CompoundType topType, |
| HashSet alreadyChecked) { |
| |
| // We want to generate stubs for all remote and implementation types, |
| // so collect them up. |
| // |
| // We use the form of collectMatching which allows us to pass in a set of |
| // types which have previously been checked. By doing so, we ensure that if |
| // the command line contains Hello and HelloImpl, we will only generate |
| // output for Hello once... |
| |
| int filter = TYPE_REMOTE | TYPE_IMPLEMENTATION; |
| Type[] genTypes = topType.collectMatching(filter,alreadyChecked); |
| int count = genTypes.length; |
| Vector list = new Vector(count+5); |
| BatchEnvironment theEnv = topType.getEnv(); |
| |
| // Now walk all types... |
| |
| for (int i = 0; i < genTypes.length; i++) { |
| |
| Type type = genTypes[i]; |
| String typeName = type.getName(); |
| boolean createStub = true; |
| |
| // Is it an implementation type? |
| |
| if (type instanceof ImplementationType) { |
| |
| // Yes, so add a tie for it... |
| |
| list.addElement(new OutputType(Utility.tieNameForCompiler(typeName), type)); |
| |
| // Does it have more than 1 remote interface? If so, we |
| // want to create a stub for it... |
| |
| int remoteInterfaceCount = 0; |
| InterfaceType[] interfaces = ((CompoundType)type).getInterfaces(); |
| for (int j = 0; j < interfaces.length; j++) { |
| if (interfaces[j].isType(TYPE_REMOTE) && |
| !interfaces[j].isType(TYPE_ABSTRACT)) { |
| remoteInterfaceCount++; |
| } |
| } |
| |
| if (remoteInterfaceCount <= 1) { |
| |
| // No, so do not create a stub for this type... |
| |
| createStub = false; |
| } |
| } |
| |
| // Is it an abstract interface type? |
| |
| if (type instanceof AbstractType) { |
| |
| // Do not create a stub for this type... |
| |
| createStub = false; // d11141 |
| } |
| |
| if (createStub) { |
| |
| // Add a stub for the type... |
| |
| list.addElement(new OutputType(Utility.stubNameForCompiler(typeName), type)); |
| } |
| } |
| |
| // Copy list into array.. |
| |
| OutputType[] outputTypes = new OutputType[list.size()]; |
| list.copyInto(outputTypes); |
| return outputTypes; |
| } |
| |
| /** |
| * Return the file name extension for the given file name (e.g. ".java"). |
| * All files generated with the ".java" extension will be compiled. To |
| * change this behavior for ".java" files, override the compileJavaSourceFile |
| * method to return false. |
| * @param outputType One of the items returned by getOutputTypesFor(...) |
| */ |
| protected String getFileNameExtensionFor(OutputType outputType) { |
| return SOURCE_FILE_EXTENSION; |
| } |
| |
| /** |
| * Write the output for the given OutputFileName into the output stream. |
| * @param name One of the items returned by getOutputTypesFor(...) |
| * @param alreadyChecked A set of Types which have already been checked. |
| * Intended to be passed to Type.collectMatching(filter,alreadyChecked). |
| * @param writer The output stream. |
| */ |
| protected void writeOutputFor( OutputType outputType, |
| HashSet alreadyChecked, |
| IndentingWriter writer) throws IOException { |
| |
| String fileName = outputType.getName(); |
| CompoundType theType = (CompoundType) outputType.getType(); |
| |
| // Are we doing a Stub or Tie? |
| |
| if (fileName.endsWith(Utility.RMI_STUB_SUFFIX)) { |
| |
| // Stub. |
| |
| writeStub(outputType,writer); |
| |
| } else { |
| |
| // Tie |
| |
| writeTie(outputType,writer); |
| } |
| } |
| |
| /** |
| * Write a stub for the specified type. |
| */ |
| protected void writeStub(OutputType outputType, |
| IndentingWriter p) throws IOException { |
| |
| CompoundType theType = (CompoundType) outputType.getType(); |
| RemoteType[] remoteInterfaces = getDirectRemoteInterfaces(theType); |
| |
| // Write comment. |
| |
| p.pln("// Stub class generated by rmic, do not edit."); |
| p.pln("// Contents subject to change without notice."); |
| p.pln(); |
| |
| // Set our standard classes... |
| |
| setStandardClassesInUse(theType,true); |
| |
| // Add classes for this type... |
| |
| addClassesInUse(theType,remoteInterfaces); |
| |
| // Write package and import statements... |
| |
| writePackageAndImports(p); |
| |
| // generate |
| // import java.security.AccessController; |
| // import java.security.PrivilegedAction; |
| // import java.io.SerializablePermission; |
| if (emitPermissionCheck) { |
| p.pln("import java.security.AccessController;"); |
| p.pln("import java.security.PrivilegedAction;"); |
| p.pln("import java.io.SerializablePermission;"); |
| p.pln(); |
| p.pln(); |
| } |
| |
| // Declare the stub class; implement all remote interfaces. |
| |
| p.p("public class " + currentClass); |
| |
| p.p(" extends " + getName(stubBaseClass)); |
| p.p(" implements "); |
| if (remoteInterfaces.length > 0) { |
| for(int i = 0; i < remoteInterfaces.length; i++) { |
| if (i > 0) { |
| p.pln(","); |
| } |
| String objName = testUtil(getName(remoteInterfaces[i]), theType); |
| p.p(objName); |
| } |
| } |
| |
| // Add java.rmi.Remote if this type does not implement it. |
| // This allows stubs for Abstract interfaces to be treated |
| // uniformly... |
| |
| if (!implementsRemote(theType)) { |
| p.pln(","); |
| p.p(getName("java.rmi.Remote")); |
| } |
| |
| p.plnI(" {"); |
| p.pln(); |
| |
| // Write the ids... |
| |
| writeIds( p, theType, false ); |
| p.pln(); |
| |
| if (emitPermissionCheck) { |
| |
| // produce the following generated code for example |
| // |
| // private transient boolean _instantiated = false; |
| // |
| // private static Void checkPermission() { |
| // SecurityManager sm = System.getSecurityManager(); |
| // if (sm != null) { |
| // sm.checkPermission(new SerializablePermission( |
| // "enableSubclassImplementation")); // testing |
| // } |
| // return null; |
| // } |
| // |
| // private _XXXXX_Stub(Void ignore) { |
| // } |
| // |
| // public _XXXXX_Stub() { |
| // this(checkPermission()); |
| // _instantiated = true; |
| // } |
| // |
| // private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { |
| // checkPermission(); |
| // s.defaultReadObject(); |
| // _instantiated = true; |
| // } |
| // |
| // where XXXXX is the name of the remote interface |
| |
| p.pln(); |
| p.plnI("private transient boolean _instantiated = false;"); |
| p.pln(); |
| p.pO(); |
| p.plnI("private static Void checkPermission() {"); |
| p.plnI("SecurityManager sm = System.getSecurityManager();"); |
| p.pln("if (sm != null) {"); |
| p.pI(); |
| p.plnI("sm.checkPermission(new SerializablePermission("); |
| p.plnI("\"enableSubclassImplementation\"));"); |
| p.pO(); |
| p.pO(); |
| p.pOln("}"); |
| p.pln("return null;"); |
| p.pO(); |
| p.pOln("}"); |
| p.pln(); |
| p.pO(); |
| |
| p.pI(); |
| p.plnI("private " + currentClass + "(Void ignore) { }"); |
| p.pln(); |
| p.pO(); |
| |
| p.plnI("public " + currentClass + "() {"); |
| p.pln("this(checkPermission());"); |
| p.pln("_instantiated = true;"); |
| p.pOln("}"); |
| p.pln(); |
| p.plnI("private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {"); |
| p.plnI("checkPermission();"); |
| p.pO(); |
| p.pln("s.defaultReadObject();"); |
| p.pln("_instantiated = true;"); |
| p.pOln("}"); |
| p.pln(); |
| //p.pO(); |
| } |
| |
| if (!emitPermissionCheck) { |
| p.pI(); |
| } |
| |
| // Write the _ids() method... |
| |
| p.plnI("public String[] _ids() { "); |
| p.pln("return (String[]) _type_ids.clone();"); |
| p.pOln("}"); |
| |
| // Get all the methods and write each stub method... |
| |
| CompoundType.Method[] remoteMethods = theType.getMethods(); |
| int methodCount = remoteMethods.length; |
| if (methodCount > 0) { |
| boolean writeHeader = true; |
| for(int i = 0; i < methodCount; i++) { |
| if (!remoteMethods[i].isConstructor()) { |
| if (writeHeader) { |
| writeHeader = false; |
| } |
| p.pln(); |
| writeStubMethod(p, remoteMethods[i], theType); |
| } |
| } |
| } |
| |
| // Write the cast array hack... |
| |
| writeCastArray(p); |
| |
| p.pOln("}"); // end stub class |
| } |
| |
| void addClassInUse(String qualifiedName) { |
| String unqualifiedName = qualifiedName; |
| String packageName = null; |
| int index = qualifiedName.lastIndexOf('.'); |
| if (index > 0) { |
| unqualifiedName = qualifiedName.substring(index+1); |
| packageName = qualifiedName.substring(0,index); |
| } |
| addClassInUse(unqualifiedName,qualifiedName,packageName); |
| } |
| |
| void addClassInUse(Type type) { |
| if (!type.isPrimitive()) { |
| Identifier id = type.getIdentifier(); |
| String name = IDLNames.replace(id.getName().toString(),". ","."); |
| String packageName = type.getPackageName(); |
| String qualifiedName; |
| if (packageName != null) { |
| qualifiedName = packageName+"."+name; |
| } else { |
| qualifiedName = name; |
| } |
| addClassInUse(name,qualifiedName,packageName); |
| } |
| } |
| |
| void addClassInUse(Type[] types) { |
| for (int i = 0; i < types.length; i++) { |
| addClassInUse(types[i]); |
| } |
| } |
| |
| void addStubInUse(Type type) { |
| if (type.getIdentifier() != idCorbaObject && |
| type.isType(TYPE_CORBA_OBJECT)) { |
| String stubName = getStubNameFor(type,false); |
| String packageName = type.getPackageName(); |
| String fullName; |
| if (packageName == null) { |
| fullName = stubName; |
| } else { |
| fullName = packageName + "." + stubName; |
| } |
| addClassInUse(stubName,fullName,packageName); |
| } |
| if (type.isType(TYPE_REMOTE) || |
| type.isType(TYPE_JAVA_RMI_REMOTE)) { |
| addClassInUse("javax.rmi.PortableRemoteObject"); |
| } |
| } |
| |
| String getStubNameFor(Type type, boolean qualified) { |
| String stubName; |
| String className; |
| if (qualified) { |
| className = type.getQualifiedName(); |
| } else { |
| className = type.getName(); |
| } |
| if (((CompoundType)type).isCORBAObject()) { |
| stubName = Utility.idlStubName(className); |
| } else { |
| stubName = Utility.stubNameForCompiler(className); |
| } |
| return stubName; |
| } |
| |
| void addStubInUse(Type[] types) { |
| for (int i = 0; i < types.length; i++) { |
| addStubInUse(types[i]); |
| } |
| } |
| |
| private static final String NO_IMPORT = new String(); |
| |
| void addClassInUse(String unqualifiedName, String qualifiedName, String packageName) { |
| |
| // Have we already got an entry for this qualifiedName? |
| |
| String currentName = (String)classesInUse.get(qualifiedName); |
| |
| if (currentName == null) { |
| |
| // No, never seen it before. Grab any existing import |
| // name and then decide what to do... |
| |
| String importName = (String) imports.get(unqualifiedName); |
| String nameToUse = null; |
| |
| if (packageName == null) { |
| |
| // Default package, so doesn't matter which name to use... |
| |
| nameToUse = unqualifiedName; |
| |
| } else if (packageName.equals("java.lang")) { |
| |
| // java.lang.*, so use unqualified name... |
| |
| nameToUse = unqualifiedName; |
| |
| // unless you want to be able to import things from the right place :--) |
| |
| if(nameToUse.endsWith("_Stub")) nameToUse = Util.packagePrefix()+qualifiedName; |
| |
| } else if (currentPackage != null && packageName.equals(currentPackage)) { |
| |
| // Class in currentPackage, so use unqualified name... |
| |
| nameToUse = unqualifiedName; |
| |
| // Do we already have a previous import under this |
| // unqualified name? |
| |
| if (importName != null) { |
| |
| // Yes, so we use qualifiedName... |
| |
| nameToUse = qualifiedName; |
| |
| } |
| |
| } else if (importName != null) { |
| |
| // It is in some package for which we normally |
| // would import, but we have a previous import |
| // under this unqualified name. We must use |
| // the qualified name... |
| |
| nameToUse = qualifiedName; |
| |
| /* |
| // Is the currentPackage the default package? |
| |
| if (currentPackage == null) { |
| |
| // Yes, so undo the import so that all |
| // uses for this name will be qualified... |
| |
| String old = (String)imports.remove(unqualifiedName); |
| classesInUse.put(old,old); |
| importCount--; |
| |
| // Note that this name is in use but should |
| // not be imported... |
| |
| imports.put(nameToUse,NO_IMPORT); |
| } |
| */ |
| } else if (qualifiedName.equals("org.omg.CORBA.Object")) { |
| |
| // Always qualify this quy to avoid confusion... |
| |
| nameToUse = qualifiedName; |
| |
| } else { |
| |
| // Default to using unqualified name, and add |
| // this guy to the imports... |
| |
| // Check for nested class in which case we use |
| // the fully qualified name instead of imports |
| if (unqualifiedName.indexOf('.') != -1) { |
| nameToUse = qualifiedName; |
| } else { |
| nameToUse = unqualifiedName; |
| imports.put(unqualifiedName,qualifiedName); |
| importCount++; |
| } |
| } |
| |
| // Now add the name... |
| |
| classesInUse.put(qualifiedName,nameToUse); |
| } |
| } |
| |
| String getName(Type type) { |
| if (type.isPrimitive()) { |
| return type.getName() + type.getArrayBrackets(); |
| } |
| Identifier id = type.getIdentifier(); |
| String name = IDLNames.replace(id.toString(),". ","."); |
| return getName(name) + type.getArrayBrackets(); |
| } |
| |
| // Added for Bug 4818753 |
| String getExceptionName(Type type) { |
| Identifier id = type.getIdentifier(); |
| return IDLNames.replace(id.toString(),". ","."); |
| } |
| |
| String getName(String qualifiedName) { |
| return (String)classesInUse.get(qualifiedName); |
| } |
| |
| String getName(Identifier id) { |
| return getName(id.toString()); |
| } |
| |
| String getStubName(Type type) { |
| String stubName = getStubNameFor(type,true); |
| return getName(stubName); |
| } |
| |
| void setStandardClassesInUse(CompoundType type, |
| boolean stub) throws IOException { |
| |
| // Reset our state... |
| |
| currentPackage = type.getPackageName(); |
| imports.clear(); |
| classesInUse.clear(); |
| namesInUse.clear(); |
| importCount = 0; |
| castArray = false; |
| |
| // Add the top-level type... |
| |
| addClassInUse(type); |
| |
| // Set current class name... |
| |
| if (stub) { |
| currentClass = Utility.stubNameForCompiler(type.getName()); |
| } else { |
| currentClass = Utility.tieNameForCompiler(type.getName()); |
| } |
| |
| // Add current class... |
| |
| if (currentPackage == null) { |
| addClassInUse(currentClass,currentClass,currentPackage); |
| } else { |
| addClassInUse(currentClass,(currentPackage+"."+currentClass),currentPackage); |
| } |
| |
| // Add standard classes... |
| |
| addClassInUse("javax.rmi.CORBA.Util"); |
| addClassInUse(idRemote.toString()); |
| addClassInUse(idRemoteException.toString()); |
| addClassInUse(idOutputStream.toString()); |
| addClassInUse(idInputStream.toString()); |
| addClassInUse(idSystemException.toString()); |
| addClassInUse(idJavaIoSerializable.toString()); |
| addClassInUse(idCorbaORB.toString()); |
| addClassInUse(idReplyHandler.toString()); |
| |
| // Add stub/tie specific imports... |
| |
| if (stub) { |
| addClassInUse(stubBaseClass); |
| addClassInUse("java.rmi.UnexpectedException"); |
| addClassInUse(idRemarshalException.toString()); |
| addClassInUse(idApplicationException.toString()); |
| if (localStubs) { |
| addClassInUse("org.omg.CORBA.portable.ServantObject"); |
| } |
| } else { |
| addClassInUse(type); |
| addClassInUse(tieBaseClass); |
| addClassInUse(idTieInterface.toString()); |
| addClassInUse(idBadMethodException.toString()); |
| addClassInUse(idPortableUnknownException.toString()); |
| addClassInUse(idJavaLangThrowable.toString()); |
| } |
| } |
| |
| void addClassesInUse(CompoundType type, RemoteType[] interfaces) { |
| |
| // Walk all methods and add types in use... |
| |
| CompoundType.Method[] methods = type.getMethods(); |
| for (int i = 0; i < methods.length; i++) { |
| addClassInUse(methods[i].getReturnType()); |
| addStubInUse(methods[i].getReturnType()); |
| addClassInUse(methods[i].getArguments()); |
| addStubInUse(methods[i].getArguments()); |
| addClassInUse(methods[i].getExceptions()); |
| // bug 4473859: Also include narrower subtypes for use |
| addClassInUse(methods[i].getImplExceptions()); |
| } |
| |
| // If this is a stub, add all interfaces... |
| |
| if (interfaces != null) { |
| addClassInUse(interfaces); |
| } |
| } |
| |
| void writePackageAndImports(IndentingWriter p) throws IOException { |
| |
| // Write package declaration... |
| |
| if (currentPackage != null) { |
| p.pln("package " + |
| Util.correctPackageName( |
| currentPackage, false, standardPackage) |
| + ";"); |
| p.pln(); |
| } |
| |
| // Get imports into an array and sort them... |
| |
| String[] names = new String[importCount]; |
| int index = 0; |
| for (Enumeration e = imports.elements() ; e.hasMoreElements() ;) { |
| String it = (String) e.nextElement(); |
| if (it != NO_IMPORT) { |
| names[index++] = it; |
| } |
| } |
| |
| Arrays.sort(names,new StringComparator()); |
| |
| // Now dump them out... |
| |
| for (int i = 0; i < importCount; i++) { |
| if( |
| Util.isOffendingPackage(names[i]) |
| && names[i].endsWith("_Stub") |
| && String.valueOf(names[i].charAt(names[i].lastIndexOf(".")+1)).equals("_") |
| ){ |
| p.pln("import " + PackagePrefixChecker.packagePrefix()+names[i]+";"); |
| } else{ |
| p.pln("import " + names[i] + ";"); |
| } |
| } |
| p.pln(); |
| |
| // Include offending packages . . . |
| if ( currentPackage!=null && Util.isOffendingPackage(currentPackage) ){ |
| p.pln("import " + currentPackage +".* ;"); |
| } |
| p.pln(); |
| |
| } |
| |
| boolean implementsRemote(CompoundType theType) { |
| boolean result = theType.isType(TYPE_REMOTE) && !theType.isType(TYPE_ABSTRACT); |
| |
| // If theType is not remote, look at all the interfaces |
| // until we find one that is... |
| |
| if (!result) { |
| InterfaceType[] interfaces = theType.getInterfaces(); |
| for (int i = 0; i < interfaces.length; i++) { |
| result = implementsRemote(interfaces[i]); |
| if (result) { |
| break; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| void writeStubMethod ( IndentingWriter p, |
| CompoundType.Method method, |
| CompoundType theType) throws IOException { |
| |
| // Wtite the method declaration and opening brace... |
| String methodName = method.getName(); |
| String methodIDLName = method.getIDLName(); |
| |
| Type paramTypes[] = method.getArguments(); |
| String paramNames[] = method.getArgumentNames(); |
| Type returnType = method.getReturnType(); |
| ValueType[] exceptions = getStubExceptions(method,false); |
| boolean hasIOException = false; |
| |
| addNamesInUse(method); |
| addNameInUse("_type_ids"); |
| |
| String objName = testUtil(getName(returnType), returnType); |
| p.p("public " + objName + " " + methodName + "("); |
| for(int i = 0; i < paramTypes.length; i++) { |
| if (i > 0) |
| p.p(", "); |
| p.p(getName(paramTypes[i]) + " " + paramNames[i]); |
| } |
| |
| p.p(")"); |
| if (exceptions.length > 0) { |
| p.p(" throws "); |
| for(int i = 0; i < exceptions.length; i++) { |
| if (i > 0) { |
| p.p(", "); |
| } |
| // Added for Bug 4818753 |
| p.p(getExceptionName(exceptions[i])); |
| } |
| } |
| |
| p.plnI(" {"); |
| |
| // Now create the method body... |
| if (emitPermissionCheck) { |
| p.pln("if ((System.getSecurityManager() != null) && (!_instantiated)) {"); |
| p.plnI(" throw new java.io.IOError(new java.io.IOException(\"InvalidObject \"));"); |
| p.pOln("}"); |
| p.pln(); |
| } |
| |
| |
| if (localStubs) { |
| writeLocalStubMethodBody(p,method,theType); |
| } else { |
| writeNonLocalStubMethodBody(p,method,theType); |
| } |
| |
| // Close out the method... |
| |
| p.pOln("}"); |
| } |
| |
| |
| void writeLocalStubMethodBody (IndentingWriter p, |
| CompoundType.Method method, |
| CompoundType theType) throws IOException { |
| |
| String objName; |
| String paramNames[] = method.getArgumentNames(); |
| Type returnType = method.getReturnType(); |
| ValueType[] exceptions = getStubExceptions(method,false); |
| String methodName = method.getName(); |
| String methodIDLName = method.getIDLName(); |
| |
| p.plnI("if (!Util.isLocal(this)) {"); |
| writeNonLocalStubMethodBody(p,method,theType); |
| p.pOlnI("} else {"); |
| String so = getVariableName("so"); |
| |
| p.pln("ServantObject "+so+" = _servant_preinvoke(\""+methodIDLName+"\","+getName(theType)+".class);"); |
| p.plnI("if ("+so+" == null) {"); |
| if (!returnType.isType(TYPE_VOID)) { |
| p.p("return "); |
| } |
| p.p(methodName+"("); |
| for (int i = 0; i < paramNames.length; i++) { |
| if (i > 0) |
| p.p(", "); |
| p.p(paramNames[i]); |
| } |
| p.pln(");"); |
| if (returnType.isType(TYPE_VOID)) { |
| p.pln( "return ;" ) ; |
| } |
| |
| p.pOln("}"); |
| p.plnI("try {"); |
| |
| // Generate code to copy required arguments, and |
| // get back the names by which all arguments are known... |
| |
| String[] argNames = writeCopyArguments(method,p); |
| |
| // Now write the method... |
| |
| boolean copyReturn = mustCopy(returnType); |
| String resultName = null; |
| if (!returnType.isType(TYPE_VOID)) { |
| if (copyReturn) { |
| resultName = getVariableName("result"); |
| objName = testUtil(getName(returnType), returnType); |
| p.p(objName+" "+resultName + " = "); |
| } else { |
| p.p("return "); |
| } |
| } |
| objName = testUtil(getName(theType), theType); |
| p.p("(("+objName+")"+so+".servant)."+methodName+"("); |
| |
| for (int i = 0; i < argNames.length; i++) { |
| if (i > 0) |
| p.p(", "); |
| p.p(argNames[i]); |
| } |
| |
| if (copyReturn) { |
| p.pln(");"); |
| objName = testUtil(getName(returnType), returnType); |
| p.pln("return ("+objName+")Util.copyObject("+resultName+",_orb());"); |
| } else { |
| p.pln(");"); |
| } |
| |
| String e1 = getVariableName("ex"); |
| String e2 = getVariableName("exCopy"); |
| p.pOlnI("} catch (Throwable "+e1+") {"); |
| |
| p.pln("Throwable "+e2+" = (Throwable)Util.copyObject("+e1+",_orb());"); |
| for(int i = 0; i < exceptions.length; i++) { |
| if (exceptions[i].getIdentifier() != idRemoteException && |
| exceptions[i].isType(TYPE_VALUE)) { |
| // Added for Bug 4818753 |
| p.plnI("if ("+e2+" instanceof "+getExceptionName(exceptions[i])+") {"); |
| p.pln("throw ("+getExceptionName(exceptions[i])+")"+e2+";"); |
| p.pOln("}"); |
| } |
| } |
| |
| p.pln("throw Util.wrapException("+e2+");"); |
| p.pOlnI("} finally {"); |
| p.pln("_servant_postinvoke("+so+");"); |
| p.pOln("}"); |
| p.pOln("}"); |
| } |
| |
| |
| void writeNonLocalStubMethodBody ( IndentingWriter p, |
| CompoundType.Method method, |
| CompoundType theType) throws IOException { |
| |
| String methodName = method.getName(); |
| String methodIDLName = method.getIDLName(); |
| |
| Type paramTypes[] = method.getArguments(); |
| String paramNames[] = method.getArgumentNames(); |
| Type returnType = method.getReturnType(); |
| ValueType[] exceptions = getStubExceptions(method,true); |
| |
| String in = getVariableName("in"); |
| String out = getVariableName("out"); |
| String ex = getVariableName("ex"); |
| |
| // Decide if we need to use the new streams for |
| // any of the read calls... |
| |
| boolean needNewReadStreamClass = false; |
| for (int i = 0; i < exceptions.length; i++) { |
| if (exceptions[i].getIdentifier() != idRemoteException && |
| exceptions[i].isType(TYPE_VALUE) && |
| needNewReadStreamClass(exceptions[i])) { |
| needNewReadStreamClass = true; |
| break; |
| } |
| } |
| if (!needNewReadStreamClass) { |
| for (int i = 0; i < paramTypes.length; i++) { |
| if (needNewReadStreamClass(paramTypes[i])) { |
| needNewReadStreamClass = true; |
| break; |
| } |
| } |
| } |
| if (!needNewReadStreamClass) { |
| needNewReadStreamClass = needNewReadStreamClass(returnType); |
| } |
| |
| // Decide if we need to use the new streams for |
| // any of the write calls... |
| |
| boolean needNewWriteStreamClass = false; |
| for (int i = 0; i < paramTypes.length; i++) { |
| if (needNewWriteStreamClass(paramTypes[i])) { |
| needNewWriteStreamClass = true; |
| break; |
| } |
| } |
| |
| // Now write the method, inserting casts where needed... |
| |
| p.plnI("try {"); |
| if (needNewReadStreamClass) { |
| p.pln(idExtInputStream + " "+in+" = null;"); |
| } else { |
| p.pln(idInputStream + " "+in+" = null;"); |
| } |
| p.plnI("try {"); |
| |
| String argStream = "null"; |
| |
| if (needNewWriteStreamClass) { |
| p.plnI(idExtOutputStream + " "+out+" = "); |
| p.pln("(" + idExtOutputStream + ")"); |
| p.pln("_request(\"" + methodIDLName + "\", true);"); |
| p.pO(); |
| } else { |
| p.pln("OutputStream "+out+" = _request(\"" + methodIDLName + "\", true);"); |
| } |
| |
| if (paramTypes.length > 0) { |
| writeMarshalArguments(p, out, paramTypes, paramNames); |
| p.pln(); |
| } |
| argStream = out; |
| |
| if (returnType.isType(TYPE_VOID)) { |
| p.pln("_invoke(" + argStream + ");" ); |
| } else { |
| if (needNewReadStreamClass) { |
| p.plnI(in+" = (" + idExtInputStream + ")_invoke(" + argStream + ");"); |
| p.pO(); |
| } else { |
| p.pln(in+" = _invoke(" + argStream + ");"); |
| } |
| p.p("return "); |
| writeUnmarshalArgument(p, in, returnType, null); |
| p.pln(); |
| } |
| |
| // Handle ApplicationException... |
| |
| p.pOlnI("} catch ("+getName(idApplicationException)+" "+ex+") {"); |
| if (needNewReadStreamClass) { |
| p.pln(in + " = (" + idExtInputStream + ") "+ex+".getInputStream();"); |
| } else { |
| p.pln(in + " = "+ex+".getInputStream();"); |
| } |
| |
| boolean idRead = false; |
| boolean idAllocated = false; |
| for(int i = 0; i < exceptions.length; i++) { |
| if (exceptions[i].getIdentifier() != idRemoteException) { |
| |
| // Is this our special-case IDLEntity exception? |
| |
| if (exceptions[i].isIDLEntityException() && !exceptions[i].isCORBAUserException()) { |
| |
| // Yes. |
| |
| if (!idAllocated && !idRead) { |
| p.pln("String $_id = "+ex+".getId();"); |
| idAllocated = true; |
| } |
| |
| String helperName = IDLNames.replace(exceptions[i].getQualifiedIDLName(false),"::","."); |
| helperName += "Helper"; |
| p.plnI("if ($_id.equals("+helperName+".id())) {"); |
| p.pln("throw "+helperName+".read("+in+");"); |
| |
| } else { |
| |
| // No. |
| |
| if (!idAllocated && !idRead) { |
| p.pln("String $_id = "+in+".read_string();"); |
| idAllocated = true; |
| idRead = true; |
| } else if (idAllocated && !idRead) { |
| p.pln("$_id = "+in+".read_string();"); |
| idRead = true; |
| } |
| p.plnI("if ($_id.equals(\""+getExceptionRepositoryID(exceptions[i])+"\")) {"); |
| // Added for Bug 4818753 |
| p.pln("throw ("+getExceptionName(exceptions[i])+") "+in+".read_value(" + getExceptionName(exceptions[i]) + ".class);"); |
| } |
| p.pOln("}"); |
| } |
| } |
| if (!idAllocated && !idRead) { |
| p.pln("String $_id = "+in+".read_string();"); |
| idAllocated = true; |
| idRead = true; |
| } else if (idAllocated && !idRead) { |
| p.pln("$_id = "+in+".read_string();"); |
| idRead = true; |
| } |
| p.pln("throw new UnexpectedException($_id);"); |
| |
| // Handle RemarshalException... |
| |
| p.pOlnI("} catch ("+getName(idRemarshalException)+" "+ex+") {"); |
| if (!returnType.isType(TYPE_VOID)) { |
| p.p("return "); |
| } |
| p.p(methodName + "("); |
| for(int i = 0; i < paramTypes.length; i++) { |
| if (i > 0) { |
| p.p(","); |
| } |
| p.p(paramNames[i]); |
| } |
| p.pln(");"); |
| |
| // Ensure that we release the reply... |
| |
| p.pOlnI("} finally {"); |
| p.pln("_releaseReply("+in+");"); |
| |
| p.pOln("}"); |
| |
| // Handle SystemException... |
| |
| p.pOlnI("} catch (SystemException "+ex+") {"); |
| p.pln("throw Util.mapSystemException("+ex+");"); |
| p.pOln("}"); |
| |
| // returnResult(p,returnType); |
| } |
| |
| void allocateResult (IndentingWriter p, |
| Type returnType) throws IOException { |
| if (!returnType.isType(TYPE_VOID)) { |
| String objName = testUtil(getName(returnType), returnType); |
| p.p(objName + " result = "); |
| } |
| } |
| |
| int getTypeCode(Type type) { |
| |
| int typeCode = type.getTypeCode(); |
| |
| // Handle late-breaking special case for |
| // abstract IDL entities... |
| |
| if ((type instanceof CompoundType) && |
| ((CompoundType)type).isAbstractBase()) { |
| typeCode = TYPE_ABSTRACT; |
| } |
| |
| return typeCode; |
| } |
| |
| |
| /** |
| * Write a snippet of Java code to marshal a value named "name" of |
| * type "type" to the java.io.ObjectOutput stream named "stream". |
| */ |
| void writeMarshalArgument(IndentingWriter p, |
| String streamName, |
| Type type, String name) throws IOException { |
| |
| int typeCode = getTypeCode(type); |
| |
| switch (typeCode) { |
| case TYPE_BOOLEAN: |
| p.p(streamName + ".write_boolean(" + name + ");"); |
| break; |
| case TYPE_BYTE: |
| p.p(streamName + ".write_octet(" + name + ");"); |
| break; |
| case TYPE_CHAR: |
| p.p(streamName + ".write_wchar(" + name + ");"); |
| break; |
| case TYPE_SHORT: |
| p.p(streamName + ".write_short(" + name + ");"); |
| break; |
| case TYPE_INT: |
| p.p(streamName + ".write_long(" + name + ");"); |
| break; |
| case TYPE_LONG: |
| p.p(streamName + ".write_longlong(" + name + ");"); |
| break; |
| case TYPE_FLOAT: |
| p.p(streamName + ".write_float(" + name + ");"); |
| break; |
| case TYPE_DOUBLE: |
| p.p(streamName + ".write_double(" + name + ");"); |
| break; |
| case TYPE_STRING: |
| p.p(streamName + ".write_value(" + name + "," + getName(type) + ".class);"); |
| break; |
| case TYPE_ANY: |
| p.p("Util.writeAny("+ streamName + "," + name + ");"); |
| break; |
| case TYPE_CORBA_OBJECT: |
| p.p(streamName + ".write_Object(" + name + ");"); |
| break; |
| case TYPE_REMOTE: |
| p.p("Util.writeRemoteObject("+ streamName + "," + name + ");"); |
| break; |
| case TYPE_ABSTRACT: |
| p.p("Util.writeAbstractObject("+ streamName + "," + name + ");"); |
| break; |
| case TYPE_NC_INTERFACE: |
| p.p(streamName + ".write_value((Serializable)" + name + "," + getName(type) + ".class);"); |
| break; |
| case TYPE_VALUE: |
| p.p(streamName + ".write_value(" + name + "," + getName(type) + ".class);"); |
| break; |
| case TYPE_IMPLEMENTATION: |
| p.p(streamName + ".write_value((Serializable)" + name + "," + getName(type) + ".class);"); |
| break; |
| case TYPE_NC_CLASS: |
| p.p(streamName + ".write_value((Serializable)" + name + "," + getName(type) + ".class);"); |
| break; |
| case TYPE_ARRAY: |
| castArray = true; |
| p.p(streamName + ".write_value(cast_array(" + name + ")," + getName(type) + ".class);"); |
| break; |
| case TYPE_JAVA_RMI_REMOTE: |
| p.p("Util.writeRemoteObject("+ streamName + "," + name + ");"); |
| break; |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| } |
| |
| /** |
| * 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). |
| */ |
| void writeUnmarshalArgument(IndentingWriter p, |
| String streamName, |
| Type type, |
| String name) throws IOException { |
| |
| int typeCode = getTypeCode(type); |
| |
| if (name != null) { |
| p.p(name + " = "); |
| } |
| |
| switch (typeCode) { |
| case TYPE_BOOLEAN: |
| p.p(streamName + ".read_boolean();"); |
| break; |
| case TYPE_BYTE: |
| p.p(streamName + ".read_octet();"); |
| break; |
| case TYPE_CHAR: |
| p.p(streamName + ".read_wchar();"); |
| break; |
| case TYPE_SHORT: |
| p.p(streamName + ".read_short();"); |
| break; |
| case TYPE_INT: |
| p.p(streamName + ".read_long();"); |
| break; |
| case TYPE_LONG: |
| p.p(streamName + ".read_longlong();"); |
| break; |
| case TYPE_FLOAT: |
| p.p(streamName + ".read_float();"); |
| break; |
| case TYPE_DOUBLE: |
| p.p(streamName + ".read_double();"); |
| break; |
| case TYPE_STRING: |
| p.p("(String) " + streamName + ".read_value(" + getName(type) + ".class);"); |
| break; |
| case TYPE_ANY: |
| if (type.getIdentifier() != idJavaLangObject) { |
| p.p("(" + getName(type) + ") "); |
| } |
| p.p("Util.readAny(" + streamName + ");"); |
| break; |
| case TYPE_CORBA_OBJECT: |
| if (type.getIdentifier() == idCorbaObject) { |
| p.p("(" + getName(type) + ") " + streamName + ".read_Object();"); |
| } else { |
| p.p("(" + getName(type) + ") " + streamName + ".read_Object(" + getStubName(type) + ".class);"); |
| } |
| break; |
| case TYPE_REMOTE: |
| String objName = testUtil(getName(type), type); |
| p.p("(" + objName + ") " + |
| "PortableRemoteObject.narrow(" + streamName + ".read_Object(), " + objName + ".class);"); |
| break; |
| case TYPE_ABSTRACT: |
| p.p("(" + getName(type) + ") " + streamName + ".read_abstract_interface();"); |
| break; |
| case TYPE_NC_INTERFACE: |
| p.p("(" + getName(type) + ") " + streamName + ".read_value(" + getName(type) + ".class);"); |
| break; |
| case TYPE_VALUE: |
| p.p("(" + getName(type) + ") " + streamName + ".read_value(" + getName(type) + ".class);"); |
| break; |
| case TYPE_IMPLEMENTATION: |
| p.p("(" + getName(type) + ") " + streamName + ".read_value(" + getName(type) + ".class);"); |
| break; |
| case TYPE_NC_CLASS: |
| p.p("(" + getName(type) + ") " + streamName + ".read_value(" + getName(type) + ".class);"); |
| break; |
| case TYPE_ARRAY: |
| p.p("(" + getName(type) + ") " + streamName + ".read_value(" + getName(type) + ".class);"); |
| break; |
| case TYPE_JAVA_RMI_REMOTE: |
| p.p("(" + getName(type) + ") " + |
| "PortableRemoteObject.narrow(" + streamName + ".read_Object(), " + getName(type) + ".class);"); |
| // p.p("(" + getName(type) + ") " + streamName + ".read_Object(" + getStubName(type) + ".class);"); |
| break; |
| default: |
| throw new Error("unexpected type code: " + typeCode); |
| } |
| } |
| |
| /** |
| * Get a list of all the RepositoryIDs for interfaces |
| * implemented directly or indirectly by theType. In the |
| * case of an ImplementationType which implements 2 or |
| * more remote interfaces, this list will begin with the |
| * Identifier for the implementation (see section 5.9 in |
| * the Java -> IDL mapping). Ensures that the most derived |
| * type is first in the list because the IOR is generated |
| * using that entry in the _ids array. |
| */ |
| String[] getAllRemoteRepIDs (CompoundType theType) { |
| |
| String[] result; |
| |
| // Collect up all the (inherited) remote interfaces |
| // (ignores all the 'special' interfaces: Remote, |
| // Serializable, Externalizable)... |
| |
| Type[] types = collectAllRemoteInterfaces(theType); |
| |
| int length = types.length; |
| boolean haveImpl = theType instanceof ImplementationType; |
| InterfaceType[] interfaces = theType.getInterfaces(); |
| int remoteCount = countRemote(interfaces,false); |
| int offset = 0; |
| |
| // Do we have an implementation type that implements |
| // more than one remote interface? |
| |
| if (haveImpl && remoteCount > 1) { |
| |
| // Yes, so we need to insert it at the beginning... |
| |
| result = new String[length + 1]; |
| result[0] = getRepositoryID(theType); |
| offset = 1; |
| |
| } else { |
| |
| // No. |
| |
| result = new String[length]; |
| |
| // Here we need to ensure that the most derived |
| // interface ends up being first in the list. If |
| // there is only one, we're done. |
| |
| if (length > 1) { |
| |
| // First, decide what the most derived type is... |
| |
| String mostDerived = null; |
| |
| if (haveImpl) { |
| |
| // If we get here, we know that there is only one |
| // direct remote interface, so just find it... |
| |
| for (int i = 0; i < interfaces.length; i++) { |
| if (interfaces[i].isType(TYPE_REMOTE)) { |
| mostDerived = interfaces[i].getRepositoryID(); |
| break; |
| } |
| } |
| } else { |
| |
| // If we get here we know that theType is a RemoteType |
| // so just use its id... |
| |
| mostDerived = theType.getRepositoryID(); |
| } |
| |
| // Now search types list and make sure mostDerived is |
| // at index zero... |
| |
| for (int i = 0; i < length; i++) { |
| if (types[i].getRepositoryID() == mostDerived) { |
| |
| // Found it. Swap it if we need to... |
| |
| if (i > 0) { |
| Type temp = types[0]; |
| types[0] = types[i]; |
| types[i] = temp; |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| |
| // Now copy contents of the types array... |
| |
| for (int i = 0; i < types.length; i++) { |
| result[offset++] = getRepositoryID(types[i]); |
| } |
| |
| // If we're supposed to, reverse the array. This |
| // is only done when the -testReverseIDs flag is |
| // passed, and that should ONLY be done for test |
| // cases. This is an undocumented feature. |
| |
| if (reverseIDs) { |
| int start = 0; |
| int end = result.length -1; |
| while (start < end) { |
| String temp = result[start]; |
| result[start++] = result[end]; |
| result[end--] = temp; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Collect all the inherited remote interfaces. |
| */ |
| Type[] collectAllRemoteInterfaces (CompoundType theType) { |
| Vector list = new Vector(); |
| |
| // Collect up all the Remote interfaces, and get an instance |
| // for java.rmi.Remote... |
| |
| addRemoteInterfaces(list,theType); |
| |
| // Create and return our results... |
| |
| Type[] result = new Type[list.size()]; |
| list.copyInto(result); |
| |
| return result; |
| } |
| |
| /** |
| * Add all the inherited remote interfaces to list. |
| */ |
| void addRemoteInterfaces(Vector list, CompoundType theType) { |
| |
| if (theType != null) { |
| if (theType.isInterface() && !list.contains(theType)) { |
| list.addElement(theType); |
| } |
| |
| InterfaceType[] interfaces = theType.getInterfaces(); |
| for (int i = 0; i < interfaces.length; i++) { |
| |
| if (interfaces[i].isType(TYPE_REMOTE)) { |
| addRemoteInterfaces(list,interfaces[i]); |
| } |
| } |
| |
| addRemoteInterfaces(list,theType.getSuperclass()); |
| } |
| } |
| |
| /** |
| * Get a list of all the remote interfaces which this stub |
| * should declare. |
| */ |
| RemoteType[] getDirectRemoteInterfaces (CompoundType theType) { |
| |
| RemoteType[] result; |
| InterfaceType[] interfaces = theType.getInterfaces(); |
| |
| // First, get a list of all the interfaces... |
| |
| InterfaceType[] list; |
| |
| // Because we can be passed either an ImplementationType |
| // (which has interfaces) or a RemoteType (which is an |
| // interface and may have interfaces) we must handle each |
| // separately... |
| |
| // Do we have an implementation type? |
| |
| if (theType instanceof ImplementationType) { |
| |
| // Yes, so list is exactly what this type |
| // implements and is correct already. |
| |
| list = interfaces; |
| |
| } else { |
| |
| // No, so list is just theType... |
| |
| list = new InterfaceType[1]; |
| list[0] = (InterfaceType) theType; |
| } |
| |
| // Ok, now count up the remote interfaces, allocate |
| // our result and fill it in... |
| |
| int remoteCount = countRemote(list,false); |
| |
| if (remoteCount == 0) { |
| throw new CompilerError("iiop.StubGenerator: No remote interfaces!"); |
| } |
| |
| result = new RemoteType[remoteCount]; |
| int offset = 0; |
| for (int i = 0; i < list.length; i++) { |
| if (list[i].isType(TYPE_REMOTE)) { |
| result[offset++] = (RemoteType)list[i]; |
| } |
| } |
| |
| return result; |
| } |
| |
| int countRemote (Type[] list, boolean includeAbstract) { |
| int remoteCount = 0; |
| for (int i = 0; i < list.length; i++) { |
| if (list[i].isType(TYPE_REMOTE) && |
| (includeAbstract || !list[i].isType(TYPE_ABSTRACT))) { |
| remoteCount++; |
| } |
| } |
| |
| return remoteCount; |
| } |
| |
| void writeCastArray(IndentingWriter p) throws IOException { |
| if (castArray) { |
| p.pln(); |
| p.pln("// This method is required as a work-around for"); |
| p.pln("// a bug in the JDK 1.1.6 verifier."); |
| p.pln(); |
| p.plnI("private "+getName(idJavaIoSerializable)+" cast_array(Object obj) {"); |
| p.pln("return ("+getName(idJavaIoSerializable)+")obj;"); |
| p.pOln("}"); |
| } |
| } |
| void writeIds(IndentingWriter p, CompoundType theType, boolean isTie |
| ) throws IOException { |
| p.plnI("private static final String[] _type_ids = {"); |
| |
| String[] ids = getAllRemoteRepIDs(theType); |
| |
| if (ids.length >0 ) { |
| for(int i = 0; i < ids.length; i++) { |
| if (i > 0) |
| p.pln(", "); |
| p.p("\"" + ids[i] + "\""); |
| } |
| } else { |
| // Must be an implementation which only implements Remote... |
| p.pln("\"\""); |
| } |
| String qname = theType.getQualifiedName() ; |
| boolean isTransactional = isTie && transactionalObjects.containsKey( qname ) ; |
| // Add TransactionalObject if needed. |
| if (isTransactional) { |
| // Have already written an id. |
| p.pln( ", " ) ; |
| p.pln( "\"IDL:omg.org/CosTransactions/TransactionalObject:1.0\"" ) ; |
| } else if (ids.length > 0) { |
| p.pln(); |
| } |
| p.pOln("};"); |
| } |
| |
| |
| /** |
| * Write the Tie for the remote class to a stream. |
| */ |
| protected void writeTie(OutputType outputType, |
| IndentingWriter p) throws IOException |
| { |
| CompoundType theType = (CompoundType) outputType.getType(); |
| RemoteType[] remoteInterfaces = null; |
| |
| // Write comment... |
| p.pln("// Tie class generated by rmic, do not edit."); |
| p.pln("// Contents subject to change without notice."); |
| p.pln(); |
| |
| // Set our standard classes... |
| setStandardClassesInUse(theType,false); |
| |
| // Add classes for this type... |
| addClassesInUse(theType,remoteInterfaces); |
| |
| // Write package and import statements... |
| writePackageAndImports(p); |
| |
| // Declare the tie class. |
| p.p("public class " + currentClass + " extends " + |
| getName(tieBaseClass) + " implements Tie"); |
| |
| // Add java.rmi.Remote if this type does not implement it. |
| // This allows stubs for Abstract interfaces to be treated |
| // uniformly... |
| if (!implementsRemote(theType)) { |
| p.pln(","); |
| p.p(getName("java.rmi.Remote")); |
| } |
| |
| p.plnI(" {"); |
| |
| // Write data members... |
| p.pln(); |
| p.pln("volatile private " + getName(theType) + " target = null;"); |
| p.pln(); |
| |
| // Write the ids... |
| writeIds( p, theType, true ) ; |
| |
| // Write setTarget method... |
| p.pln(); |
| p.plnI("public void setTarget(Remote target) {"); |
| p.pln("this.target = (" + getName(theType) + ") target;"); |
| p.pOln("}"); |
| |
| // Write getTarget method... |
| p.pln(); |
| p.plnI("public Remote getTarget() {"); |
| p.pln("return target;"); |
| p.pOln("}"); |
| |
| // Write thisObject method... |
| p.pln(); |
| write_tie_thisObject_method(p,idCorbaObject); |
| |
| // Write deactivate method... |
| p.pln(); |
| write_tie_deactivate_method(p); |
| |
| // Write get orb method... |
| p.pln(); |
| p.plnI("public ORB orb() {"); |
| p.pln("return _orb();"); |
| p.pOln("}"); |
| |
| // Write set orb method... |
| p.pln(); |
| write_tie_orb_method(p); |
| |
| // Write the _ids() method... |
| p.pln(); |
| write_tie__ids_method(p); |
| |
| // Get all the methods... |
| CompoundType.Method[] remoteMethods = theType.getMethods(); |
| |
| // Register all the argument names used, plus our |
| // data member names... |
| |
| addNamesInUse(remoteMethods); |
| addNameInUse("target"); |
| addNameInUse("_type_ids"); |
| |
| // Write the _invoke method... |
| p.pln(); |
| |
| String in = getVariableName("in"); |
| String _in = getVariableName("_in"); |
| String ex = getVariableName("ex"); |
| String method = getVariableName("method"); |
| String reply = getVariableName("reply"); |
| |
| p.plnI("public OutputStream _invoke(String "+method+", InputStream "+_in+", " + |
| "ResponseHandler "+reply+") throws SystemException {"); |
| |
| if (remoteMethods.length > 0) { |
| p.plnI("try {"); |
| p.pln(getName(theType) + " target = this.target;"); |
| p.plnI("if (target == null) {"); |
| p.pln("throw new java.io.IOException();"); |
| p.pOln("}"); |
| p.plnI(idExtInputStream + " "+in+" = "); |
| p.pln("(" + idExtInputStream + ") "+_in+";"); |
| p.pO(); |
| |
| // See if we should use a hash table style |
| // comparison... |
| |
| StaticStringsHash hash = getStringsHash(remoteMethods); |
| |
| if (hash != null) { |
| p.plnI("switch ("+method+"."+hash.method+") {"); |
| for (int i = 0; i < hash.buckets.length; i++) { |
| p.plnI("case "+hash.keys[i]+": "); |
| for (int j = 0; j < hash.buckets[i].length; j++) { |
| CompoundType.Method current = remoteMethods[hash.buckets[i][j]]; |
| if (j > 0) { |
| p.pO("} else "); |
| } |
| p.plnI("if ("+method+".equals(\""+ current.getIDLName() +"\")) {"); |
| writeTieMethod(p, theType,current); |
| } |
| p.pOln("}"); |
| p.pO(); |
| } |
| } else { |
| for(int i = 0; i < remoteMethods.length; i++) { |
| CompoundType.Method current = remoteMethods[i]; |
| if (i > 0) { |
| p.pO("} else "); |
| } |
| |
| p.plnI("if ("+method+".equals(\""+ current.getIDLName() +"\")) {"); |
| writeTieMethod(p, theType, current); |
| } |
| } |
| |
| if (hash != null) { |
| p.pI(); |
| // p.plnI("default:"); |
| } else { |
| // p.pOlnI("} else {"); |
| } |
| // p.pln("throw new "+getName(idBadMethodException)+"();"); |
| |
| if (hash != null) { |
| p.pO(); |
| } |
| p.pOln("}"); |
| p.pln("throw new "+getName(idBadMethodException)+"();"); |
| |
| p.pOlnI("} catch ("+getName(idSystemException)+" "+ex+") {"); |
| p.pln("throw "+ex+";"); |
| |
| p.pOlnI("} catch ("+getName(idJavaLangThrowable)+" "+ex+") {"); |
| p.pln("throw new " + getName(idPortableUnknownException) + "("+ex+");"); |
| p.pOln("}"); |
| } else { |
| // No methods... |
| |
| p.pln("throw new " + getName(idBadMethodException) + "();"); |
| } |
| |
| p.pOln("}"); // end invoke |
| |
| // Write the cast array hack... |
| |
| writeCastArray(p); |
| |
| // End tie class... |
| p.pOln("}"); |
| } |
| public void catchWrongPolicy(IndentingWriter p) throws IOException { |
| p.pln(""); |
| } |
| public void catchServantNotActive(IndentingWriter p) throws IOException { |
| p.pln(""); |
| } |
| public void catchObjectNotActive(IndentingWriter p) throws IOException { |
| p.pln(""); |
| } |
| |
| public void write_tie_thisObject_method(IndentingWriter p, |
| Identifier idCorbaObject) |
| throws IOException |
| { |
| if(POATie){ |
| p.plnI("public " + idCorbaObject + " thisObject() {"); |
| /* |
| p.pln("org.omg.CORBA.Object objref = null;"); |
| p.pln("try{"); |
| p.pln("objref = _poa().servant_to_reference(this);"); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.WrongPolicy exception){"); |
| catchWrongPolicy(p); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.ServantNotActive exception){"); |
| catchServantNotActive(p); |
| p.pln("}"); |
| p.pln("return objref;"); |
| */ |
| p.pln("return _this_object();"); |
| p.pOln("}"); |
| } else { |
| p.plnI("public " + idCorbaObject + " thisObject() {"); |
| p.pln("return this;"); |
| p.pOln("}"); |
| } |
| } |
| |
| public void write_tie_deactivate_method(IndentingWriter p) |
| throws IOException |
| { |
| if(POATie){ |
| p.plnI("public void deactivate() {"); |
| p.pln("try{"); |
| p.pln("_poa().deactivate_object(_poa().servant_to_id(this));"); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.WrongPolicy exception){"); |
| catchWrongPolicy(p); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.ObjectNotActive exception){"); |
| catchObjectNotActive(p); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.ServantNotActive exception){"); |
| catchServantNotActive(p); |
| p.pln("}"); |
| p.pOln("}"); |
| } else { |
| p.plnI("public void deactivate() {"); |
| p.pln("_orb().disconnect(this);"); |
| p.pln("_set_delegate(null);"); |
| p.pln("target = null;"); |
| p.pOln("}"); |
| } |
| } |
| |
| public void write_tie_orb_method(IndentingWriter p) |
| throws IOException |
| { |
| if(POATie){ |
| p.plnI("public void orb(ORB orb) {"); |
| /* |
| p.pln("try{"); |
| p.pln("orb.connect(_poa().servant_to_reference(this));"); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.WrongPolicy exception){"); |
| catchWrongPolicy(p); |
| p.pln("}catch (org.omg.PortableServer.POAPackage.ServantNotActive exception){"); |
| catchServantNotActive(p); |
| p.pln("}"); |
| */ |
| p.pln("try {"); |
| p.pln(" ((org.omg.CORBA_2_3.ORB)orb).set_delegate(this);"); |
| p.pln("}"); |
| p.pln("catch(ClassCastException e) {"); |
| p.pln(" throw new org.omg.CORBA.BAD_PARAM"); |
| p.pln(" (\"POA Servant requires an instance of org.omg.CORBA_2_3.ORB\");"); |
| p.pln("}"); |
| p.pOln("}"); |
| } else { |
| p.plnI("public void orb(ORB orb) {"); |
| p.pln("orb.connect(this);"); |
| p.pOln("}"); |
| } |
| } |
| |
| public void write_tie__ids_method(IndentingWriter p) |
| throws IOException |
| { |
| if(POATie){ |
| p.plnI("public String[] _all_interfaces(org.omg.PortableServer.POA poa, byte[] objectId){"); |
| p.pln("return (String[]) _type_ids.clone();"); |
| p.pOln("}"); |
| } else { |
| p.plnI("public String[] _ids() { "); |
| p.pln("return (String[]) _type_ids.clone();"); |
| p.pOln("}"); |
| } |
| } |
| |
| |
| StaticStringsHash getStringsHash (CompoundType.Method[] methods) { |
| if (useHash && methods.length > 1) { |
| String[] methodNames = new String[methods.length]; |
| for (int i = 0; i < methodNames.length; i++) { |
| methodNames[i] = methods[i].getIDLName(); |
| } |
| return new StaticStringsHash(methodNames); |
| } |
| return null; |
| } |
| |
| static boolean needNewReadStreamClass(Type type) { |
| if (type.isType(TYPE_ABSTRACT)) { |
| return true; |
| } |
| // Handle late-breaking special case for |
| // abstract IDL entities... |
| if ((type instanceof CompoundType) && |
| ((CompoundType)type).isAbstractBase()) { |
| return true; |
| } |
| return needNewWriteStreamClass(type); |
| } |
| |
| static boolean needNewWriteStreamClass(Type type) { |
| switch (type.getTypeCode()) { |
| case TYPE_VOID: |
| case TYPE_BOOLEAN: |
| case TYPE_BYTE: |
| case TYPE_CHAR: |
| case TYPE_SHORT: |
| case TYPE_INT: |
| case TYPE_LONG: |
| case TYPE_FLOAT: |
| case TYPE_DOUBLE: return false; |
| |
| case TYPE_STRING: return true; |
| case TYPE_ANY: return false; |
| case TYPE_CORBA_OBJECT: return false; |
| case TYPE_REMOTE: return false; |
| case TYPE_ABSTRACT: return false; |
| case TYPE_NC_INTERFACE: return true; |
| case TYPE_VALUE: return true; |
| case TYPE_IMPLEMENTATION: return true; |
| case TYPE_NC_CLASS: return true; |
| case TYPE_ARRAY: return true; |
| case TYPE_JAVA_RMI_REMOTE: return false; |
| |
| default: throw new Error("unexpected type code: " + type.getTypeCode()); |
| } |
| } |
| |
| /* |
| * Decide which arguments need to be copied and write |
| * the copy code. Returns an array of argument names to |
| * use to refer to either the copy or the original. |
| */ |
| String[] writeCopyArguments(CompoundType.Method method, |
| IndentingWriter p) throws IOException { |
| |
| Type[] args = method.getArguments(); |
| String[] origNames = method.getArgumentNames(); |
| |
| // Copy the current parameter names to a result array... |
| |
| String[] result = new String[origNames.length]; |
| for (int i = 0; i < result.length; i++) { |
| result[i] = origNames[i]; |
| } |
| |
| // Decide which arguments must be copied, if any. If |
| // any of the arguments are types for which a 'real' copy |
| // will be done, rather than just an autoConnect, set |
| // realCopy = true. Note that abstract types may only |
| // need autoConnect, but we cannot know that at compile |
| // time... |
| |
| boolean realCopy = false; |
| boolean[] copyArg = new boolean[args.length]; |
| int copyCount = 0; |
| int firstCopiedArg = 0; // Only used in single copy case. It is only the first arg that |
| // needs copying IF copyCount == 1. |
| |
| for (int i = 0; i < args.length; i++) { |
| if (mustCopy(args[i])) { |
| copyArg[i] = true; |
| copyCount++; |
| firstCopiedArg = i; |
| if (args[i].getTypeCode() != TYPE_REMOTE && |
| args[i].getTypeCode() != TYPE_IMPLEMENTATION) { |
| realCopy = true; |
| } |
| } else { |
| copyArg[i] = false; |
| } |
| } |
| |
| // Do we have any types which must be copied? |
| if (copyCount > 0) { |
| // Yes. Are we only doing the copy to ensure |
| // that autoConnect occurs? |
| if (realCopy) { |
| // Nope. We need to go back thru the list and |
| // mark any strings so that they will be copied |
| // to preserve any shared references... |
| for (int i = 0; i < args.length; i++) { |
| if (args[i].getTypeCode() == TYPE_STRING) { |
| copyArg[i] = true; |
| copyCount++; |
| } |
| } |
| } |
| |
| // We're ready to generate code. Do we have more than |
| // one to copy? |
| if (copyCount > 1) { |
| // Generate a call to copyObjects... |
| String arrayName = getVariableName("copies"); |
| p.p("Object[] " + arrayName + " = Util.copyObjects(new Object[]{"); |
| boolean first = true; |
| for (int i = 0; i < args.length; i++) { |
| if (copyArg[i]) { |
| if (!first) { |
| p.p(","); |
| } |
| first = false; |
| p.p(origNames[i]); |
| } |
| } |
| p.pln("},_orb());"); |
| |
| // For each of the types which was copied, create |
| // a local temporary for it, updating the result |
| // array with the new local parameter name... |
| int copyIndex = 0 ; |
| for (int i = 0; i < args.length; i++) { |
| if (copyArg[i]) { |
| result[i] = getVariableName(result[i]+"Copy"); |
| p.pln( getName(args[i]) + " " + result[i] + " = (" + getName(args[i]) + ") " + |
| arrayName + "[" + copyIndex++ +"];"); |
| } |
| } |
| } else { |
| // Generate a call to copyObject, updating the result |
| // with the new local parameter name... |
| result[firstCopiedArg] = getVariableName(result[firstCopiedArg]+"Copy"); |
| p.pln( getName(args[firstCopiedArg]) + " " + result[firstCopiedArg] + " = (" + |
| getName(args[firstCopiedArg]) + ") Util.copyObject(" + |
| origNames[firstCopiedArg] + ",_orb());"); |
| } |
| } |
| |
| return result; |
| } |
| |
| static final String SINGLE_SLASH = "\\"; |
| static final String DOUBLE_SLASH = SINGLE_SLASH + SINGLE_SLASH; |
| |
| String getRepositoryID(Type type) { |
| return IDLNames.replace(type.getRepositoryID(), SINGLE_SLASH, DOUBLE_SLASH); |
| } |
| |
| String getExceptionRepositoryID(Type type) { |
| ClassType theType = (ClassType) type; |
| return IDLNames.getIDLRepositoryID(theType.getQualifiedIDLExceptionName(false)); |
| } |
| |
| String getVariableName(String proposed) { |
| while (namesInUse.contains(proposed)) { |
| proposed = "$" + proposed; |
| } |
| |
| return proposed; |
| } |
| |
| void addNamesInUse(CompoundType.Method[] methods) { |
| for (int i = 0; i < methods.length; i++) { |
| addNamesInUse(methods[i]); |
| } |
| } |
| |
| void addNamesInUse(CompoundType.Method method) { |
| String paramNames[] = method.getArgumentNames(); |
| for (int i = 0; i < paramNames.length; i++) { |
| addNameInUse(paramNames[i]); |
| } |
| } |
| |
| void addNameInUse(String name) { |
| namesInUse.add(name); |
| } |
| |
| static boolean mustCopy(Type type) { |
| switch (type.getTypeCode()) { |
| case TYPE_VOID: |
| case TYPE_BOOLEAN: |
| case TYPE_BYTE: |
| case TYPE_CHAR: |
| case TYPE_SHORT: |
| case TYPE_INT: |
| case TYPE_LONG: |
| case TYPE_FLOAT: |
| case TYPE_DOUBLE: |
| case TYPE_STRING: return false; |
| |
| case TYPE_ANY: return true; |
| |
| case TYPE_CORBA_OBJECT: return false; |
| |
| case TYPE_REMOTE: |
| case TYPE_ABSTRACT: |
| case TYPE_NC_INTERFACE: |
| case TYPE_VALUE: |
| case TYPE_IMPLEMENTATION: |
| case TYPE_NC_CLASS: |
| case TYPE_ARRAY: |
| case TYPE_JAVA_RMI_REMOTE: return true; |
| |
| default: throw new Error("unexpected type code: " + type.getTypeCode()); |
| } |
| } |
| |
| ValueType[] getStubExceptions (CompoundType.Method method, boolean sort) { |
| |
| ValueType[] list = method.getFilteredStubExceptions(method.getExceptions()); |
| |
| // Sort the list so that all org.omg.CORBA.UserException |
| // subtypes are at the beginning of the list. This ensures |
| // that the stub will not call read_string() before calling |
| // XXHelper.read(). |
| |
| if (sort) { |
| Arrays.sort(list,new UserExceptionComparator()); |
| } |
| |
| return list; |
| } |
| |
| ValueType[] getTieExceptions (CompoundType.Method method) { |
| return method.getUniqueCatchList(method.getImplExceptions()); |
| } |
| |
| void writeTieMethod(IndentingWriter p, CompoundType type, |
| CompoundType.Method method) throws IOException { |
| String methodName = method.getName(); |
| Type paramTypes[] = method.getArguments(); |
| String paramNames[] = method.getArgumentNames(); |
| Type returnType = method.getReturnType(); |
| ValueType[] exceptions = getTieExceptions(method); |
| String in = getVariableName("in"); |
| String ex = getVariableName("ex"); |
| String out = getVariableName("out"); |
| String reply = getVariableName("reply"); |
| |
| for (int i = 0; i < paramTypes.length; i++) { |
| p.p(getName(paramTypes[i])+" "+paramNames[i]+" = "); |
| writeUnmarshalArgument(p, in, paramTypes[i], null); |
| p.pln(); |
| } |
| |
| boolean handleExceptions = exceptions != null; |
| boolean doReturn = !returnType.isType(TYPE_VOID); |
| |
| if (handleExceptions && doReturn) { |
| String objName = testUtil(getName(returnType), returnType); |
| p.pln(objName+" result;"); |
| } |
| |
| if (handleExceptions) |
| p.plnI("try {"); |
| |
| if (doReturn) { |
| if (handleExceptions) { |
| p.p("result = "); |
| } else { |
| p.p(getName(returnType)+" result = "); |
| } |
| } |
| |
| p.p("target."+methodName+"("); |
| for(int i = 0; i < paramNames.length; i++) { |
| if (i > 0) |
| p.p(", "); |
| p.p(paramNames[i]); |
| } |
| p.pln(");"); |
| |
| if (handleExceptions) { |
| for(int i = 0; i < exceptions.length; i++) { |
| p.pOlnI("} catch ("+getName(exceptions[i])+" "+ex+") {"); |
| |
| // Is this our IDLEntity Exception special case? |
| |
| if (exceptions[i].isIDLEntityException() && !exceptions[i].isCORBAUserException()) { |
| |
| // Yes... |
| |
| String helperName = IDLNames.replace(exceptions[i].getQualifiedIDLName(false),"::","."); |
| helperName += "Helper"; |
| p.pln(idOutputStream+" "+out +" = "+reply+".createExceptionReply();"); |
| p.pln(helperName+".write("+out+","+ex+");"); |
| |
| } else { |
| |
| // No... |
| |
| p.pln("String id = \"" + getExceptionRepositoryID(exceptions[i]) + "\";"); |
| p.plnI(idExtOutputStream + " "+out+" = "); |
| p.pln("(" + idExtOutputStream + ") "+reply+".createExceptionReply();"); |
| p.pOln(out+".write_string(id);"); |
| p.pln(out+".write_value("+ex+"," + getName(exceptions[i]) + ".class);"); |
| } |
| |
| p.pln("return "+out+";"); |
| } |
| p.pOln("}"); |
| } |
| |
| if (needNewWriteStreamClass(returnType)) { |
| p.plnI(idExtOutputStream + " "+out+" = "); |
| p.pln("(" + idExtOutputStream + ") "+reply+".createReply();"); |
| p.pO(); |
| } else { |
| p.pln("OutputStream "+out+" = "+reply+".createReply();"); |
| } |
| |
| if (doReturn) { |
| writeMarshalArgument(p, out, returnType, "result"); |
| p.pln(); |
| } |
| |
| p.pln("return "+out+";"); |
| } |
| |
| |
| /** |
| * 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". |
| */ |
| 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]); |
| if (i != types.length -1) { |
| p.pln(); |
| } |
| } |
| } |
| |
| /** |
| * Added for IASRI 4987274. Remote classes named "Util" were |
| * getting confused with javax.rmi.CORBA.Util and the |
| * unqualifiedName "Util". |
| */ |
| String testUtil(String objectName, Type ttype) { |
| if (objectName.equals("Util")) { |
| String correctedName = (String)ttype.getPackageName() + "." + objectName; |
| return correctedName; |
| } else { |
| return objectName; |
| } |
| } |
| } |
| |
| class StringComparator implements java.util.Comparator { |
| public int compare(Object o1, Object o2) { |
| String s1 = (String)o1; |
| String s2 = (String)o2; |
| return s1.compareTo(s2); |
| } |
| } |
| |
| |
| class UserExceptionComparator implements java.util.Comparator { |
| public int compare(Object o1, Object o2) { |
| ValueType v1 = (ValueType)o1; |
| ValueType v2 = (ValueType)o2; |
| int result = 0; |
| if (isUserException(v1)) { |
| if (!isUserException(v2)) { |
| result = -1; |
| } |
| } else if (isUserException(v2)) { |
| if (!isUserException(v1)) { |
| result = 1; |
| } |
| } |
| return result; |
| } |
| |
| final boolean isUserException(ValueType it) { |
| return it.isIDLEntityException() && !it.isCORBAUserException(); |
| } |
| } |
