jdk8-mips64-public/corba: src/share/classes/sun/rmi/rmic/iiop/CompoundType.java@81d694b1ab2f (annotated)

src/share/classes/sun/rmi/rmic/iiop/CompoundType.java@81d694b1ab2f (annotated)

src/share/classes/sun/rmi/rmic/iiop/CompoundType.java

Fri, 14 Jun 2013 16:31:55 +0100

author: msheppar
date: Fri, 14 Jun 2013 16:31:55 +0100
changeset 512: 81d694b1ab2f
parent 473: 5845df371e25
child 553: 5ca1b4c282b8
permissions: -rw-r--r--

8011157: Improve CORBA portablility
Summary: fix also reviewed by Alexander Fomin
Reviewed-by: alanb, coffeys, skoivu

 /*
  * Copyright (c) 1998, 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.
  */
 /*
  * Licensed Materials - Property of IBM
  * RMI-IIOP v1.0
  * Copyright IBM Corp. 1998 1999  All Rights Reserved
  *
  */
 package sun.rmi.rmic.iiop;
 import java.util.Arrays;
 import java.util.Vector;
 import sun.tools.java.Identifier;
 import sun.tools.java.ClassNotFound;
 import sun.tools.java.ClassDefinition;
 import sun.tools.java.ClassDeclaration;
 import sun.tools.java.MemberDefinition;
 import sun.tools.java.CompilerError;
 import sun.tools.tree.Node;
 import sun.tools.tree.LocalMember;
 import sun.tools.tree.CharExpression;
 import sun.tools.tree.IntegerExpression;
 import sun.rmi.rmic.IndentingWriter;
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Enumeration;
 import java.io.File;
 /**
  * A CompoundType is an abstract base class for all IIOP class and
  * interface types.
  *
  * @author      Bryan Atsatt
  */
 public abstract class CompoundType extends Type {
     protected Method[] methods;
     protected InterfaceType[] interfaces;
     protected Member[] members;
     protected ClassDefinition classDef;
     protected ClassDeclaration classDecl;
     protected boolean isCORBAObject = false;
     protected boolean isIDLEntity = false;
     protected boolean isAbstractBase = false;
     protected boolean isValueBase = false;
     protected boolean isCORBAUserException = false;
     protected boolean isException = false;
     protected boolean isCheckedException = false;
     protected boolean isRemoteExceptionOrSubclass = false;
     protected String idlExceptionName;
     protected String qualifiedIDLExceptionName;
     //_____________________________________________________________________
     // Public Interfaces
     //_____________________________________________________________________
     /**
      * Return true if this type implements
      * org.omg.CORBA.Object.
      */
     public boolean isCORBAObject () {
         return isCORBAObject;
     }
     /**
      * Return true if this type implements
      * org.omg.CORBA.portable.IDLEntity.
      */
     public boolean isIDLEntity () {
         return isIDLEntity;
     }
     /**
      * Return true if this type implements
      * org.omg.CORBA.portable.ValueBase.
      */
     public boolean isValueBase () {
         return isValueBase;
     }
     /**
      * Return true if this type is a CORBA
      * abstract interface.
      */
     public boolean isAbstractBase () {
         return isAbstractBase;
     }
     /**
      * Return true if this type is an exception.
      */
     public boolean isException () {
         return isException;
     }
     /**
      * Return true if this type is a "checked" exception.
      * Result if valid iff isException() returns true.
      */
     public boolean isCheckedException () {
         return isCheckedException;
     }
     /**
      * Return true if this type is a java.rmi.RemoteException
      * or one of its subclasses. Result if valid iff isException()
      * returns true.
      */
     public boolean isRemoteExceptionOrSubclass () {
         return isRemoteExceptionOrSubclass;
     }
     /**
      * Return true if this type is exactly
      * org.omg.CORBA.UserException.
      */
     public boolean isCORBAUserException () {
         return isCORBAUserException;
     }
     /**
      * Return true if this type implements
      * isIDLEntity() && isException().
      */
     public boolean isIDLEntityException () {
         return isIDLEntity() && isException();
     }
     /**
      * Return true if isIDLEntity() && !isValueBase()
      * && !isAbstractBase() && !isCORBAObject()
      * && !isIDLEntityException().
      */
     public boolean isBoxed () {
         return (isIDLEntity() && !isValueBase() &&
                 !isAbstractBase() && !isCORBAObject() &&
                 !isIDLEntityException());
     }
     /**
      * If this type represents an exception, return the
      * IDL name including the "Ex" mangling, otherwise
      * return null.
      */
     public String getIDLExceptionName () {
         return idlExceptionName;
     }
     /**
      * If this type represents an exception, return the
      * qualified IDL name including the "Ex" mangling,
      * otherwise return null.
      * @param global If true, prepends "::".
      */
     public String getQualifiedIDLExceptionName (boolean global) {
         if (qualifiedIDLExceptionName != null &&
             global &&
             getIDLModuleNames().length > 0) {
             return IDL_NAME_SEPARATOR + qualifiedIDLExceptionName;
         } else {
             return qualifiedIDLExceptionName;
         }
     }
     /**
      * Return signature for this type  (e.g. com.acme.Dynamite
      * would return "com.acme.Dynamite", byte = "B")
      */
     public String getSignature() {
         String sig = classDecl.getType().getTypeSignature();
         if (sig.endsWith(";")) {
             sig = sig.substring(0,sig.length()-1);
         }
         return sig;
     }
     /**
      * Return the ClassDeclaration for this type.
      */
     public ClassDeclaration getClassDeclaration() {
         return classDecl;
     }
     /**
      * Return the ClassDefinition for this type.
      */
     public ClassDefinition getClassDefinition() {
         return classDef;
     }
     /**
      * Return the parent class of this type. Returns null if this
      * type is an interface or if there is no parent.
      */
     public ClassType getSuperclass() {
         return null;
     }
     /**
      * Return an array of interfaces directly implemented by this type.
      * <p>
      * The order of the array returned is arbitrary.
      */
     public InterfaceType[] getInterfaces() {
         if( interfaces != null ) {
             return (InterfaceType[]) interfaces.clone();
         }
         return null;
     }
     /**
      * Return an array of Type.Method objects representing all
      * of the methods implemented directly by this type.
      */
     public Method[] getMethods() {
         if( methods != null ) {
             return (Method[]) methods.clone();
         }
         return null;
     }
     /**
      * Return an array of Type.Member objects representing all of
      * the data members directly implemented by this interface.
      */
     public Member[] getMembers() {
         if( members != null ) {
             return (Member[]) members.clone();
         }
         return null;
     }
     /**
      * Create a CompoundType object for the given class.
      *
      * If the class is not a properly formed or if some other error occurs, the
      * return value will be null, and errors will have been reported to the
      * supplied BatchEnvironment.
      */
     public static CompoundType forCompound (ClassDefinition classDef,
                                             ContextStack stack) {
         CompoundType result = null;
         try {
             result = (CompoundType) makeType(classDef.getType(),classDef,stack);
         } catch (ClassCastException e) {}
         return result;
     }
     //_____________________________________________________________________
     // Subclass/Internal Interfaces
     //_____________________________________________________________________
     /**
      * Release all resources.
      */
     protected void destroy () {
         if (!destroyed) {
             super.destroy();
             if (methods != null) {
                 for (int i = 0; i < methods.length; i++) {
                     if (methods[i] != null) methods[i].destroy();
                 }
                 methods = null;
             }
             if (interfaces != null) {
                 for (int i = 0; i < interfaces.length; i++) {
                     if (interfaces[i] != null) interfaces[i].destroy();
                 }
                 interfaces = null;
             }
             if (members != null) {
                 for (int i = 0; i < members.length; i++) {
                     if (members[i] != null) members[i].destroy();
                 }
                 members = null;
             }
             classDef = null;
             classDecl = null;
         }
     }
     /*
      * Load a Class instance. Return null if fail.
      */
     protected Class loadClass() {
         Class ourClass = null;
         // To avoid getting out-of-date Class instances, and
         // to ensure that there is an instance, we must compile
         // any classes that we've seen and which are not yet
         // compiled. We can't just compile this class, 'cuz it
         // may have dependencies on classes which have not been
         // compiled...
         try {
             env.getMain().compileAllClasses(env);
         } catch (Exception e1) {
             for (Enumeration e = env.getClasses() ; e.hasMoreElements() ; ) {
                 ClassDeclaration c = (ClassDeclaration)e.nextElement();
             }
             failedConstraint(26,false,stack,"required classes");
             env.flushErrors();
         }
         // Now try to get the Class...
         // The outer try block is there for people who might want to use
         // the compiler at run-time of their AS.
         // They could set and use their own context class loader for loading
         // classes directly.
         try {
             ClassLoader cl = Thread.currentThread().getContextClassLoader();
             ourClass = cl.loadClass(getQualifiedName());
         } catch(ClassNotFoundException cfe) {
             try {
                 ourClass = env.classPathLoader.loadClass(getQualifiedName());
             } catch (NullPointerException e) {
                 // This should never happen
             } catch (ClassNotFoundException e) {
                 // Fall through to the next case (which is to look in the
                 // output directory for generated files)
             }
         }
         /* This piece of code used to cause the compiler to ignore jar files
            on its classpath
         try {
             ourClass = Util.loadClass(getQualifiedName(),null,null);
         } catch (ClassNotFoundException e) {
         } catch (LinkageError e) {
         }
         */
         if (ourClass == null) {
             // Try one last thing. If the class was compiled into
             // a directory that's not in the classpath, the load
             // will fail. Let's get the bits off the disk and load
             // it directly...
             if (env.loader == null) {
                 File destDir = env.getMain().getDestinationDir();
                 if (destDir == null) {
                     destDir = new File(".");
                 }
                 env.loader = new DirectoryLoader(destDir);
             }
             try {
                 ourClass = env.loader.loadClass(getQualifiedName());
             } catch (Exception e) {}
         }
         return ourClass;
     }
     // Print "extends XX"
     protected boolean printExtends (IndentingWriter writer,
                                     boolean useQualifiedNames,
                                     boolean useIDLNames,
                                     boolean globalIDLNames) throws IOException {
         ClassType parent = getSuperclass();
         if (parent != null && (!useIDLNames ||
                                (!parent.isType(TYPE_ANY) && !parent.isType(TYPE_CORBA_OBJECT)))) {
             writer.p(" extends ");
             parent.printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
             return true;
         }
         return false;
     }
     // Print "implements XX, YY"
     protected void printImplements (IndentingWriter writer,
                                     String prefix,
                                     boolean useQualifiedNames,
                                     boolean useIDLNames,
                                     boolean globalIDLNames) throws IOException {
         InterfaceType[] interfaces = getInterfaces();
         String adjective = " implements";
         if (isInterface()) {
             adjective = " extends";
         }
         if (useIDLNames) {
             adjective = ":";
         }
         for (int i = 0; i < interfaces.length; i++) {
             if (!useIDLNames || (!interfaces[i].isType(TYPE_ANY) && !interfaces[i].isType(TYPE_CORBA_OBJECT))) {
                 if (i == 0) {
                     writer.p(prefix + adjective + " ");
                 } else {
                     writer.p(", ");
                 }
                 interfaces[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
             }
         }
     }
     // Print members
     protected void printMembers (       IndentingWriter writer,
                                         boolean useQualifiedNames,
                                         boolean useIDLNames,
                                         boolean globalIDLNames) throws IOException {
         CompoundType.Member[] members = getMembers();
         for (int i = 0; i < members.length; i++) {
             if (!members[i].isInnerClassDeclaration()) {
                 Type it = members[i].getType();
                 String visibility = members[i].getVisibility();
                 String name;
                 if (useIDLNames) {
                     name = members[i].getIDLName();
                 } else {
                     name = members[i].getName();
                 }
                 String value = members[i].getValue();
                 writer.p(visibility);
                 if (visibility.length() > 0) {
                     writer.p(" ");
                 }
                 it.printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
                 writer.p(" " + name);
                 if (value != null) {
                     writer.pln(" = " + value + ";");
                 } else {
                     writer.pln(";");
                 }
             }
         }
     }
     // Print methods
     protected void printMethods (       IndentingWriter writer,
                                         boolean useQualifiedNames,
                                         boolean useIDLNames,
                                         boolean globalIDLNames) throws IOException {
         CompoundType.Method[] methods = getMethods();
         for (int m = 0; m < methods.length; m++) {
             CompoundType.Method theMethod = methods[m];
             printMethod(theMethod,writer,useQualifiedNames,useIDLNames,globalIDLNames);
         }
     }
     // Print a method...
     protected void printMethod (CompoundType.Method it,
                                 IndentingWriter writer,
                                 boolean useQualifiedNames,
                                 boolean useIDLNames,
                                 boolean globalIDLNames) throws IOException {
         // Write visibility...
         String visibility = it.getVisibility();
         writer.p(visibility);
         if (visibility.length() > 0) {
             writer.p(" ");
         }
         // Write return type...
         it.getReturnType().printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
         // Write method name...
         if (useIDLNames) {
             writer.p(" " + it.getIDLName());
         } else {
             writer.p(" " + it.getName());
         }
         // Write arguments...
         writer.p(" (");
         Type[] args = it.getArguments();
         String[] argNames = it.getArgumentNames();
         for (int i = 0; i < args.length; i++) {
             if (i > 0) {
                 writer.p(", ");
             }
             if (useIDLNames) {
                 writer.p("in ");
             }
             args[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
             writer.p(" " + argNames[i]);
         }
         writer.p(")");
         // Write exceptions...
         ClassType[] exceptions;
         if (isType(TYPE_IMPLEMENTATION)) {
             exceptions = it.getImplExceptions();
         } else {
             exceptions = it.getExceptions();
         }
         for (int i = 0; i < exceptions.length; i++) {
             if (i == 0) {
                 if (useIDLNames) {
                     writer.p(" raises (");
                 } else {
                     writer.p(" throws ");
                 }
             } else {
                 writer.p(", ");
             }
             if (useIDLNames) {
                 if (useQualifiedNames) {
                     writer.p(exceptions[i].getQualifiedIDLExceptionName(globalIDLNames));
                 } else {
                     writer.p(exceptions[i].getIDLExceptionName());
                 }
                 writer.p(" [a.k.a. ");
                 exceptions[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
                 writer.p("]");
             } else {
                 exceptions[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
             }
         }
         if (useIDLNames && exceptions.length > 0) {
             writer.p(")");
         }
         if (it.isInherited()) {
             writer.p(" // Inherited from ");
         writer.p(it.getDeclaredBy());
         }
         writer.pln(";");
     }
     /**
      * Create a CompoundType instance for the given class. NOTE: This constructor
      * is ONLY for SpecialClassType and SpecialInterfaceType.
      */
     protected CompoundType(ContextStack stack, int typeCode, ClassDefinition classDef) {
         super(stack,typeCode);
         this.classDef = classDef;
         classDecl = classDef.getClassDeclaration();
         interfaces = new InterfaceType[0];
         methods = new Method[0];
         members = new Member[0];
         // If we are an inner class/interface, reset the type codes...
         if (classDef.isInnerClass()) {
             setTypeCode(typeCode | TM_INNER);
         }
         // Set special flags...
         setFlags();
     }
     private void setFlags() {
         try {
         // Set our special interface flags...
             isCORBAObject = env.defCorbaObject.implementedBy(env,classDecl);
             isIDLEntity = env.defIDLEntity.implementedBy(env,classDecl);
             isValueBase = env.defValueBase.implementedBy(env,classDecl);
             isAbstractBase = isInterface() &&   // Interface, not a class.
                              isIDLEntity &&     // Implements IDLEntity.
                              !isValueBase &&    // Does not implement ValueBase.
                              !isCORBAObject;    // Does not implement org.omg.CORBA.Object;
             isCORBAUserException = (classDecl.getName() == idCorbaUserException);
             // Is this an exception?
             if (env.defThrowable.implementedBy(env, classDecl)) {
                 // Yes...
                 isException = true;
                 // Is it a checked exception?
                 if (env.defRuntimeException.implementedBy(env,classDecl) ||
                     env.defError.implementedBy(env,classDecl)) {
                     isCheckedException = false;
                 } else {
                     isCheckedException = true;
                 }
                 // Is it java.rmi.RemoteException or a subclass?
                 if (env.defRemoteException.implementedBy(env,classDecl)) {
                     isRemoteExceptionOrSubclass = true;
                 } else {
                     isRemoteExceptionOrSubclass = false;
                 }
             } else {
                 isException = false;
             }
         } catch (ClassNotFound e) {
             classNotFound(stack,e);
         }
     }
     /**
      * Create a CompoundType instance for the given class.  The resulting
      * object is not yet completely initialized.
      */
     protected CompoundType(ContextStack stack, ClassDefinition classDef,
                            int typeCode) {
         super(stack,typeCode);
         this.classDef = classDef;
         classDecl = classDef.getClassDeclaration();
         // If we are an inner class/interface, reset the type codes...
         if (classDef.isInnerClass()) {
             setTypeCode(typeCode | TM_INNER);
         }
         // Set special flags...
         setFlags();
         // Set names...
         Identifier id = classDef.getName();
         String idlName;
         String[] idlModuleNames;
         try {
             // These can fail if we get case-sensitive name matches...
             idlName = IDLNames.getClassOrInterfaceName(id,env);
             idlModuleNames = IDLNames.getModuleNames(id,isBoxed(),env);
             setNames(id,idlModuleNames,idlName);
             // Is this an exception?
             if (isException()) {
                 // Yes, so set our mangled exception names...
                 isException = true;
                 idlExceptionName = IDLNames.getExceptionName(getIDLName());
                 qualifiedIDLExceptionName =
                     IDLNames.getQualifiedName(getIDLModuleNames(),idlExceptionName);
             }
             // Set interfaces, methods and members...
             interfaces = null;          // set in initialize()
             methods = null;                     // set in initialize()
             members = null;                 // set in initialize()
         } catch (Exception e) {
             failedConstraint(7,false,stack,id.toString(),e.getMessage());
             throw new CompilerError("");
         }
     }
     /**
      * Initialize this instance.
      */
     protected boolean initialize (      Vector directInterfaces,
                                         Vector directMethods,
                                         Vector directMembers,
                                         ContextStack stack,
                                         boolean quiet) {
         boolean result = true;
         // Initialize our arrays...
         if (directInterfaces != null && directInterfaces.size() > 0) {
             interfaces = new InterfaceType[directInterfaces.size()];
             directInterfaces.copyInto(interfaces);
         } else {
             interfaces = new InterfaceType[0];
         }
         if (directMethods != null && directMethods.size() > 0) {
             methods = new Method[directMethods.size()];
             directMethods.copyInto(methods);
             // Now set the idl names for each...
             try {
                 IDLNames.setMethodNames(this, methods,env);
             } catch (Exception e) {
                 failedConstraint(13,quiet,stack,getQualifiedName(),e.getMessage());
                 result = false;
             }
         } else {
             methods = new Method[0];
         }
         if (directMembers != null && directMembers.size() > 0) {
             members = new Member[directMembers.size()];
             directMembers.copyInto(members);
             // If we have any un-initialized inner classes, now is the time
             // to init them...
             for (int i = 0; i < members.length; i++) {
                 if (members[i].isInnerClassDeclaration()) {
                     try {
                         members[i].init(stack,this);
                     } catch (CompilerError e) {
                         return false;
                     }
                 }
             }
             // Now set the idl names for each...
             try {
                 IDLNames.setMemberNames(this, members,methods,env);
             } catch (Exception e) {
                 int constraint = classDef.isInterface() ? 19 : 20;
                 failedConstraint(constraint,quiet,stack,getQualifiedName(),e.getMessage());
                 result = false;
             }
         } else {
             members = new Member[0];
         }
         // Set our repositoryID...
         if (result) {
             result = setRepositoryID();
         }
         return result;
     }
     /*
      * Return Type or null if error. classDef may be null.
      */
     protected static Type makeType (sun.tools.java.Type theType,
                                     ClassDefinition classDef,
                                     ContextStack stack) {
         if (stack.anyErrors()) return null;
         // See if we can find this type in the cache.  If so, return it...
         String key = theType.toString();
         Type result = getType(key,stack);
         if (result != null) {
             return result;
         }
         // Gotta try with context...
         result = getType(key + stack.getContextCodeString(),stack);
         if (result != null) {
             return result;
         }
         // Gotta map it...
         BatchEnvironment env = stack.getEnv();
         int typeCode = theType.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:
             {
                 // Primitive...
                 result = PrimitiveType.forPrimitive(theType,stack);
                 break;
             }
         case TC_ARRAY:
             {
                 // Array.
                 result = ArrayType.forArray(theType,stack);
                 break;
             }
         case TC_CLASS:
             {
                 try {
                                 // First, make sure we have the class definition...
                     ClassDefinition theClass = classDef;
                     if (theClass == null) {
                         theClass = env.getClassDeclaration(theType).getClassDefinition(env);
                     }
                                 // Is it an interface or a class?
                     if (theClass.isInterface()) {
                         // An interface. Is it a special case?
                         result = SpecialInterfaceType.forSpecial(theClass,stack);
                         if (result == null) {
                             // No, does it implement java.rmi.Remote?
                             if (env.defRemote.implementedBy(env,theClass.getClassDeclaration())) {
                                 // Yep, so just see if we can create an instance of RemoteType
                                 // from it...
                                 boolean parentIsValue = stack.isParentAValue();
                                 result = RemoteType.forRemote(theClass,stack,parentIsValue);
                                 // If we did not succeed AND we are in a value context, then
                                 // go ahead and make an NC type out of it...
                                 if (result == null && parentIsValue) {
                                     result = NCInterfaceType.forNCInterface(theClass,stack);
                                 }
                             } else {
                                 // Nope, is it an AbstractType?
                                 result = AbstractType.forAbstract(theClass,stack,true);
                                 if (result == null) {
                                     // No, so treat it as a non-conforming interface type...
                                     result = NCInterfaceType.forNCInterface(theClass,stack);
                                 }
                             }
                         }
                     } else {
                         // A class. Is it a special case?
                         result = SpecialClassType.forSpecial(theClass,stack);
                         if (result == null) {
                             ClassDeclaration classDecl = theClass.getClassDeclaration();
                             // Nope, does it implement java.rmi.Remote?
                             if (env.defRemote.implementedBy(env,classDecl)) {
                                 // Yep, so just see if we can create an instance of
                                 // ImplementationType from it...
                                 boolean parentIsValue = stack.isParentAValue();
                                 result = ImplementationType.forImplementation(theClass,stack,parentIsValue);
                                 // If we did not succeed AND inValue is true, then
                                 // go ahead and make an NC type out of it...
                                 if (result == null && parentIsValue) {
                                     result = NCClassType.forNCClass(theClass,stack);
                                 }
                             } else {
                                 // No, does it implement Serializable?
                                 if (env.defSerializable.implementedBy(env,classDecl)) {
                                     // Yep, so just see if we can create an instance of ValueType
                                     // from it...
                                     result = ValueType.forValue(theClass,stack,true);
                                 }
                                 if (result == null) {
                                     // Treat it as a non-conforming class type...
                                     result = NCClassType.forNCClass(theClass,stack);
                                 }
                             }
                         }
                     }
                 } catch (ClassNotFound e) {
                     classNotFound(stack,e);
                 }
                 break;
             }
         default: throw new CompilerError("Unknown typecode (" + typeCode + ") for " + theType.getTypeSignature());
         }
         return result;
     }
     /*
      * Check if exception is RemoteException or one of its parents.
      */
     public static boolean isRemoteException (ClassType ex,
                                              BatchEnvironment env) {
         sun.tools.java.Type exceptionType = ex.getClassDeclaration().getType();
         if (exceptionType.equals(env.typeRemoteException) ||
             exceptionType.equals(env.typeIOException) ||
             exceptionType.equals(env.typeException) ||
             exceptionType.equals(env.typeThrowable)) {
             return true;
         }
         return false;
     }
     /*
      * Check if method is conforming.
      */
     protected boolean isConformingRemoteMethod (Method method, boolean quiet)
         throws ClassNotFound {
         // Do we have one exception that is RemoteException or
         // a superclass of RemoteException?
         boolean haveRemote = false;
         ClassType[] exceptions = method.getExceptions();
         for (int i = 0; i < exceptions.length; i++) {
             // Is it a conforming exception?
             if (isRemoteException(exceptions[i],env)) {
                 // Got it.
                 haveRemote = true;
                 break;
             }
         }
         // Do we have our exception?
         if (!haveRemote) {
             // No, so report failure...
             failedConstraint(5,quiet,stack,method.getEnclosing(), method.toString());
         }
         // Are any of the arguments exceptions which implement IDLEntity?
         // If so, report failure...
         boolean noIDLEntity = !isIDLEntityException(method.getReturnType(),method,quiet);
         if (noIDLEntity) {
             Type[] args = method.getArguments();
             for (int i = 0; i < args.length; i++) {
                 if (isIDLEntityException(args[i],method,quiet)) {
                     noIDLEntity = false;
                     break;
                 }
             }
         }
         return (haveRemote && noIDLEntity);
     }
     protected boolean isIDLEntityException(Type type, CompoundType.Method method,boolean quiet)
         throws ClassNotFound {
         if (type.isArray()) {
             type = type.getElementType();
         }
         if (type.isCompound()){
             if (((CompoundType)type).isIDLEntityException()) {
                 failedConstraint(18,quiet,stack,method.getEnclosing(), method.toString());
                 return true;
             }
         }
         return false;
     }
     /**
      * Convert all invalid types to valid ones.
      */
     protected void swapInvalidTypes () {
         // Walk all interfaces and check them...
         for (int i = 0; i < interfaces.length; i++) {
             if (interfaces[i].getStatus() != STATUS_VALID) {
                 interfaces[i] = (InterfaceType)getValidType(interfaces[i]);
             }
         }
         // Update methods...
         for (int i = 0; i < methods.length; i++) {
             methods[i].swapInvalidTypes();
         }
         // Update members...
         for (int i = 0; i < members.length; i++) {
             members[i].swapInvalidTypes();
         }
     }
     /*
      * Add matching types to list. Return true if this type has not
      * been previously checked, false otherwise.
      */
     protected boolean addTypes (int typeCodeFilter,
                                 HashSet checked,
                                 Vector matching) {
         // Check self.
         boolean result = super.addTypes(typeCodeFilter,checked,matching);
         // Have we been checked before?
         if (result) {
             // Nope, so walk parent(s) and check them...
             ClassType parent = getSuperclass();
             if (parent != null) {
                 parent.addTypes(typeCodeFilter,checked,matching);
             }
             // Walk all interfaces and check them...
             //if (interfaces == null) System.out.println("NULL for " +getQualifiedName() + " interfaces");
             for (int i = 0; i < interfaces.length; i++) {
                 // Now recurse and add it and any referenced types...
                 //if (interfaces[i] == null) System.out.println("NULL for " +getQualifiedName() + " interfaces[" + i + "]");
                 interfaces[i].addTypes(typeCodeFilter,checked,matching);
             }
             // Walk all methods and check arguments...
             //if (methods == null) System.out.println("NULL for " +getQualifiedName() + " methods");
             for (int i = 0; i < methods.length; i++) {
                 // Add return type...
                 //if (methods[i] == null) System.out.println("NULL for " +getQualifiedName() + " methods[" + i + "]");
                 //if (methods[i].getReturnType() == null) System.out.println("NULL for " +getQualifiedName() + methods[i]);
                 methods[i].getReturnType().addTypes(typeCodeFilter,checked,matching);
                 // Add args...
                 Type[] args = methods[i].getArguments();
                 //if (args == null) System.out.println("NULL for " + getQualifiedName() + " args");
                 for (int j = 0; j < args.length; j++) {
                     Type arg = args[j];
                     //if (arg == null) System.out.println("NULL for " + getQualifiedName() + " arg[" +j+"]");
                                 // Add argument...
                     arg.addTypes(typeCodeFilter,checked,matching);
                 }
                 // Add exceptions...
                 ClassType[] exceptions = methods[i].getExceptions();
                 //if (exceptions == null) System.out.println("NULL for " + getQualifiedName() + " exceptions");
                 for (int j = 0; j < exceptions.length; j++) {
                     ClassType ex = exceptions[j];
                                 // Add argument...
                     ex.addTypes(typeCodeFilter,checked,matching);
                 }
             }
             // Walk all members and add em...
             //if (members == null) System.out.println("NULL for " +getQualifiedName() + " members");
             for (int i = 0; i < members.length; i++) {
                 //if (members[i] == null) System.out.println("NULL for " +getQualifiedName() + " members[" + i + "]");
                 Type cType = members[i].getType();
                 //if (cType == null) System.out.println("NULL for " + getQualifiedName() + " cType");
                 // Add it...
                 cType.addTypes(typeCodeFilter,checked,matching);
             }
         }
         return result;
     }
     /*
      * Return true if theType is a conforming constant type.
      */
     private boolean isConformingConstantType (MemberDefinition member) {
         return isConformingConstantType(member.getType(),member);
     }
     /*
      * Return true if theType is a conforming constant type.
      */
     private boolean isConformingConstantType (sun.tools.java.Type theType,MemberDefinition member) {
         // Constraint 3:    Constants must be either primitives or String.
         boolean result = true;
         int typeCode = theType.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: // Primitive, so OK...
             {
                 break;
             }
         case TC_CLASS:  // Must be java.lang.String
             {
                 if (theType.getClassName() != idJavaLangString) {
                     failedConstraint(3,false,stack,member.getClassDefinition(),member.getName());
                     result = false;
                 }
                 break;
             }
         case TC_ARRAY: // Array constants are not allowed.
             {
                 failedConstraint(3,false,stack,member.getClassDefinition(),member.getName());
                 result = false;
                 break;
             }
         default:
             throw new Error("unexpected type code: " + typeCode);
         }
         return result;
     }
     /*
      * Update any method from 'currentMethods' which is defined in a
      * parent class so that it's 'declaredBy' field specifies the
      * parent.
      * @param current The class or interface to gather methods from.
      * @param currentMethods The list into which to put the methods.
      *  for contraint 6.
      * @param quiet true if silent errors.
      * @param stack the context stack.
      * @return currentMethods or null if failed a constraint check.
      */
     protected Vector updateParentClassMethods(ClassDefinition current,
                                               Vector currentMethods,
                                               boolean quiet,
                                               ContextStack stack)
         throws ClassNotFound {
         ClassDeclaration parentDecl = current.getSuperClass(env);
         while (parentDecl != null) {
             ClassDefinition parentDef = parentDecl.getClassDefinition(env);
             Identifier currentID = parentDecl.getName();
             if ( currentID == idJavaLangObject ) break;
             // Walk all members of this class and update any that
             // already exist in currentMethods...
             for (MemberDefinition member = parentDef.getFirstMember();
                  member != null;
                  member = member.getNextMember()) {
                 if (member.isMethod() &&
                     !member.isInitializer() &&
                     !member.isConstructor() &&
                     !member.isPrivate()) {
                     // It's a method.  Is it valid?
                     Method method;
                     try {
                         method = new Method((CompoundType)this,member,quiet,stack);
                     } catch (Exception e) {
                         // Don't report anything here, it's already been reported...
                         return null;
                     }
                     // Have we already seen it?
                     int index = currentMethods.indexOf(method);
                     if (index >= 0) {
                         // Yes, so update it...
                         Method currentMethod = (Method)currentMethods.elementAt(index);
                         currentMethod.setDeclaredBy(currentID);
                     }
                     else currentMethods.addElement(method);
                 }
             }
             // Update parent and keep walking up the chain...
             parentDecl = parentDef.getSuperClass(env);
         }
         return currentMethods;
     }
     /*
      * Add all of the public and protected methods defined in
      * current (other than initializers) to allMethods. If a sub-interface
      * re-declares an inherited method, it will not be added.
      * @param current The class or interface to gather methods from.
      * @param directMethods The list into which to put the methods.
      * @param noMultiInheritedMethods A flag to enable/disable checking
      *  for contraint 6.
      * @param quiet true if silent errors.
      * @param stack the context stack.
      * @return directMethods or null if failed a constraint check.
      */
     protected Vector addAllMethods (ClassDefinition current, Vector directMethods,
                                     boolean noMultiInheritedMethods,
                                     boolean quiet,
                                     ContextStack stack)
         throws ClassNotFound {
         // Constraint 6:    Multiple inherited interfaces may not
         //                  declare the same method.
         ClassDeclaration[] interfaces = current.getInterfaces();
         // We want to add members starting at the _least_ derived
         // interfaces.  To do so, recurse until we have no more
         // interfaces...
         for (int i = 0; i < interfaces.length; i++) {
             Vector result = addAllMethods(interfaces[i].getClassDefinition(env),
                                           directMethods,
                                           noMultiInheritedMethods,quiet,stack);
             if (result == null) {
                 return null;
             }
         }
         // Walk all members of this interface, adding any unique methods
         // other than initializers and private methods...
         for (MemberDefinition member = current.getFirstMember();
              member != null;
              member = member.getNextMember())
             {
                 if (member.isMethod() &&
                     !member.isInitializer() &&
                     !member.isPrivate()) {
                     // It's a method.  Is it valid?
                     Method method;
                     try {
                         method = new Method((CompoundType)this,member,quiet,stack);
                     } catch (Exception e) {
                         // Don't report anything here, it's already been reported...
                         return null;
                     }
                                 // Have we already seen it?
                     if (!directMethods.contains(method)) {
                         // Nope, so add it...
                         directMethods.addElement(method);
                     } else {
                         // Yes. This is an error unless we are looking at the
                         // target interface (or this is a ValueType). Are we?
                         if (noMultiInheritedMethods && current != classDef  &&
                             !stack.isParentAValue() && !stack.getContext().isValue()) {
                             // Nope. Say so and signal error by returning null..
                             Method existingMethod = (Method) directMethods.elementAt(directMethods.indexOf(method));
                             ClassDefinition existingMemberClassDef = existingMethod.getMemberDefinition().getClassDefinition();
                             // There are more legal cases to consider here.
                             // If the two methods belong to interfaces that inherit from each other
                             // then it is just a redefinition which is legal.
                             if ( current != existingMemberClassDef &&
                                  ! inheritsFrom(current, existingMemberClassDef) &&
                                  ! inheritsFrom(existingMemberClassDef, current))
                             {
                                 //Identifier int1 = existingMethod.getEnclosing().getIdentifier();
                                 //Identifier int2 = current.getName();
                                 //String message = int1.toString() + " and " + int2.toString();
                                 String message = existingMemberClassDef.getName() + " and " + current.getName();
                                 failedConstraint(6,quiet,stack,classDef,message,method);
                                 return null;
                             }
                         }
                         // Bug fix 5014329
                         // find a matching method.
                         int index = directMethods.indexOf(method);
                         Method other = (Method) directMethods.get(index);
                         // merge the two methods, such that the new method
                         // will contain only those exception that can be thrown
                         // by both these methods, not just one of them.
                         Method newMethod = method.mergeWith(other);
                         // replace the old method with the new.
                         directMethods.set(index, newMethod);
                     }
                 }
             }
         return directMethods;
     }
     // This should really be a method on ClassDefinition, but it takes too long to change the shared source.
     // Works for both, classes and interfaces.
     protected boolean inheritsFrom(ClassDefinition def, ClassDefinition otherDef) {
         if (def == otherDef)
             return true;
         ClassDefinition superDef;
         if (def.getSuperClass() != null) {
             superDef = def.getSuperClass().getClassDefinition();
             if (inheritsFrom(superDef, otherDef))
                 return true;
         }
         ClassDeclaration[] interfaces = def.getInterfaces();
         for (int i=0; i<interfaces.length; i++) {
             superDef = interfaces[i].getClassDefinition();
             if (inheritsFrom(superDef, otherDef))
                 return true;
         }
         return false;
     }
     /*
      * Add all of the interfaces implemented directly by current
      * to the list. Returns null if any are non-conforming.
      */
     protected Vector addRemoteInterfaces (Vector list,
                                           boolean allowNonConforming,
                                           ContextStack stack) throws ClassNotFound {
         // Add all the interfaces of current...
         ClassDefinition theInterface = getClassDefinition();
         ClassDeclaration[] interfaces = theInterface.getInterfaces();
         stack.setNewContextCode(ContextStack.IMPLEMENTS);
         for (int i = 0; i < interfaces.length; i++) {
             ClassDefinition def = interfaces[i].getClassDefinition(env);
             // Is it a SpecialInterfaceType...
             InterfaceType it = SpecialInterfaceType.forSpecial(def,stack);;
             if (it == null) {
                 // No, is it Remote?
                 if (env.defRemote.implementedBy(env, interfaces[i])) {
                     // Yes, so it must be a RemoteType.
                     it = RemoteType.forRemote(def,stack,false);
                 } else {
                     // Then try Abstract...
                     it = AbstractType.forAbstract(def,stack,true);
                     if (it == null && allowNonConforming) {
                         // Must be non-conforming...
                         it = NCInterfaceType.forNCInterface(def,stack);
                     }
                 }
             }
             if (it != null) {
                 list.addElement(it);
             } else {
                 return null;
             }
         }
         return list;
     }
     /*
      * Add all of the interfaces implemented directly by current
      * to the list.
      */
     protected Vector addNonRemoteInterfaces (Vector list,
                                              ContextStack stack) throws ClassNotFound {
         // Add all the interfaces of current...
         ClassDefinition theInterface = getClassDefinition();
         ClassDeclaration[] interfaces = theInterface.getInterfaces();
         stack.setNewContextCode(ContextStack.IMPLEMENTS);
         for (int i = 0; i < interfaces.length; i++) {
             ClassDefinition def = interfaces[i].getClassDefinition(env);
             // First try SpecialInterfaceType...
             InterfaceType it = SpecialInterfaceType.forSpecial(def,stack);
             if (it == null) {
                 // Then try AbstractType...
                 it = AbstractType.forAbstract(def,stack,true);
                 if (it == null) {
                     // Then try NCInterfaceType...
                     it = NCInterfaceType.forNCInterface(def,stack);
                 }
             }
             if (it != null) {
                 list.addElement(it);
             } else {
                 return null;
             }
         }
         return list;
     }
     /*
      * Walk self, adding constants and data members.
      * @return true if all conform, false otherwise.
      */
     protected boolean addAllMembers (Vector allMembers,
                                      boolean onlyConformingConstants,   // AND inner classes.
                                      boolean quiet,
                                      ContextStack stack) {
         boolean result = true;
         // Walk all members of this interface...
         for (MemberDefinition member = getClassDefinition().getFirstMember();
              member != null && result;
              member = member.getNextMember())
             {
                 if (!member.isMethod()) {
                     try {
                         String value = null;
                         // Prod it to setValue if it is a constant...
                         member.getValue(env);
                                 // Get the value, if any...
                         Node node = member.getValue();
                         if (node != null) {
                             // We don't want to change the code in CharExpression,
                             // which is shared among tools, to return the right string
                             // in case the type is char, so we treat it special here.
                             if (member.getType().getTypeCode() == TC_CHAR) {
                                 Integer intValue = (Integer)((IntegerExpression)node).getValue();
                                 value = "L'" + String.valueOf((char)intValue.intValue()) + "'";
                             } else {
                                 value = node.toString();
                             }
                         }
                         // Are we supposed to allow only conforming constants?
                         if (onlyConformingConstants && member.getInnerClass() == null) {
                                 // Yep, so check it...
                             if (value == null || !isConformingConstantType(member)) {
                                 failedConstraint(3,quiet,stack,member.getClassDefinition(),member.getName());
                                 result = false;
                                 break;
                             }
                         }
                         // Make member and add to list...
                         try {
                             Member newMember = new Member(member,value,stack,this);
                             allMembers.addElement(newMember);
                         } catch (CompilerError e) {
                             result = false;
                         }
                     } catch (ClassNotFound e) {
                         classNotFound(stack,e);
                         result = false;
                     }
                 }
             }
         return result;
     }
     /*
      * Walk self, adding constants.
      * @return true if all conform, false otherwise.
      */
     protected boolean addConformingConstants (Vector allMembers,
                                               boolean quiet,
                                               ContextStack stack) {
         boolean result = true;
         // Walk all members of this interface...
         for (MemberDefinition member = getClassDefinition().getFirstMember();
              member != null && result;
              member = member.getNextMember())
             {
                 if (!member.isMethod()) {
                     try {
                         String value = null;
                         // Prod it to setValue if it is a constant...
                         member.getValue(env);
                                 // Get the value, if any...
                         Node node = member.getValue();
                         if (node != null) {
                             value = node.toString();
                         }
                         // Is it a constant?
                         if (value != null) {
                             // Yes, is it conforming?
                             if (!isConformingConstantType(member)) {
                                 failedConstraint(3,quiet,stack,member.getClassDefinition(),member.getName());
                                 result = false;
                                 break;
                             }
                             // Yes, so make a member and add to list...
                             try {
                                 Member newMember = new Member(member,value,stack,this);
                                 allMembers.addElement(newMember);
                             } catch (CompilerError e) {
                                 result = false;
                             }
                         }
                     } catch (ClassNotFound e) {
                         classNotFound(stack,e);
                         result = false;
                     }
                 }
             }
         return result;
     }
     protected ValueType[] getMethodExceptions (MemberDefinition member,
                                                boolean quiet,
                                                ContextStack stack) throws Exception {
         boolean result = true;
         stack.setNewContextCode(ContextStack.METHOD_EXCEPTION);
         ClassDeclaration[] except = member.getExceptions(env);
         ValueType[] exceptions = new ValueType[except.length];
         try {
             for (int i = 0; i < except.length; i++) {
                 ClassDefinition theClass = except[i].getClassDefinition(env);
                 try {
                     ValueType type = ValueType.forValue(theClass,stack,false);
                     if (type != null) {
                             exceptions[i] = type;
                         } else {
                             result = false;
                         }
                 } catch (ClassCastException e1) {
                     failedConstraint(22,quiet,stack,getQualifiedName());
                     throw new CompilerError("Method: exception " + theClass.getName() + " not a class type!");
                 } catch (NullPointerException e2) {
                     failedConstraint(23,quiet,stack,getQualifiedName());
                     throw new CompilerError("Method: caught null pointer exception");
                 }
             }
         } catch (ClassNotFound e) {
             classNotFound(quiet,stack,e);
             result = false;
         }
         if (!result) {
             throw new Exception();
         }
         // Remove any duplicates (javac seems to allow them, but rmic will
         // generate bad ties)...
         int dupCount = 0;
         for (int i = 0; i < exceptions.length; i++) {
             for (int j = 0; j < exceptions.length; j++) {
                 if (i != j && exceptions[i] != null && exceptions[i] == exceptions[j]) {
                     exceptions[j] = null;
                     dupCount++;
                 }
             }
         }
         if (dupCount > 0) {
             int offset = 0;
             ValueType[] temp = new ValueType[exceptions.length - dupCount];
             for (int i = 0; i < exceptions.length; i++) {
                 if (exceptions[i] != null) {
                     temp[offset++] = exceptions[i];
                 }
             }
             exceptions = temp;
         }
         return exceptions;
     }
     protected static String getVisibilityString (MemberDefinition member) {
         String vis = "";
         String prefix = "";
         if (member.isPublic()) {
             vis += "public";
             prefix = " ";
         } else if (member.isProtected()) {
             vis += "protected";
             prefix = " ";
         } else if (member.isPrivate()) {
             vis += "private";
             prefix = " ";
         }
         if (member.isStatic()) {
             vis += prefix;
             vis += "static";
             prefix = " ";
         }
         if (member.isFinal()) {
             vis += prefix;
             vis += "final";
             prefix = " ";
         }
         return vis;
     }
     protected boolean assertNotImpl(Type type,
                                     boolean quiet,
                                     ContextStack stack,
                                     CompoundType enclosing,
                                     boolean dataMember) {
         if (type.isType(TYPE_IMPLEMENTATION)) {
             int constraint = dataMember ? 28 : 21;
             failedConstraint(constraint,quiet,stack,type,enclosing.getName());
             return false;
         }
         return true;
     }
     //_____________________________________________________________________
     // Inner Class "Method"
     //_____________________________________________________________________
     /**
      * A CompoundType.Method object encapsulates IIOP-specific information
      * about a particular method in the interface represented by the outer
      * instance.
      */
     public class Method implements ContextElement, Cloneable {
         /**
          * Is this method inherited?
          */
         public boolean isInherited () {
             return declaredBy != enclosing.getIdentifier();
         }
         /**
          * Is this method an attribute?
          * Return true if getAttributeKind != ATTRIBUTE_NONE.
          */
         public boolean isAttribute () {
             return attributeKind != ATTRIBUTE_NONE;
         }
         /**
          * Is this method a read-write attribute?
          */
         public boolean isReadWriteAttribute () {
             return attributeKind == ATTRIBUTE_IS_RW ||
                 attributeKind == ATTRIBUTE_GET_RW;
         }
         /**
          * Return the attribute kind.
          */
         public int getAttributeKind() {
             return attributeKind;
         }
         /**
          * Return the attribute name. Will be null if
          * attribute kind == ATTRIBUTE_NONE.
          */
         public String getAttributeName() {
             return attributeName;
         }
         /**
          * For kinds ATTRIBUTE_GET_RW or ATTRIBUTE_IS_RW, return
          * the index of the matching ATTRIBUTE_SET method, and
          * vice-versa. For all other cases, return -1.
          */
         public int getAttributePairIndex() {
             return attributePairIndex;
         }
         /**
          * Return context element name.
          */
         public String getElementName() {
             return memberDef.toString();
         }
         /**
          * Equality check based on method signature.
          */
         public boolean equals(Object obj) {
             Method other = (Method) obj;
             if (getName().equals(other.getName()) &&
                 arguments.length == other.arguments.length) {
                 for (int i = 0; i < arguments.length; i++) {
                     if (! arguments[i].equals(other.arguments[i])) {
                         return false;
                     }
                 }
                 return true;
             }
             return false;
         }
         public int hashCode() {
             return getName().hashCode() ^ Arrays.hashCode(arguments);
         }
         /**
          * Return a new Method object that is a legal combination of
          * this method object and another one.
          *
          * This requires determining the exceptions declared by the
          * combined method, which must be only those exceptions
          * that may thrown by both of the old methods.
          */
         public Method mergeWith(Method other) {
             if (!equals(other)) {
                 env.error(0, "attempt to merge method failed:", getName(),
                           enclosing.getClassDefinition().getName());
             }
             Vector legalExceptions = new Vector();
             try {
                 collectCompatibleExceptions(
                       other.exceptions, exceptions, legalExceptions);
                 collectCompatibleExceptions(
                       exceptions, other.exceptions, legalExceptions);
             } catch (ClassNotFound e) {
                 env.error(0, "class.not.found", e.name,
                           enclosing.getClassDefinition().getName());
                 return null;
             }
             Method merged = (Method) clone();
             merged.exceptions = new ValueType[legalExceptions.size()];
             legalExceptions.copyInto(merged.exceptions);
             merged.implExceptions = merged.exceptions;
             return merged;
         }
         /**
          * Add to the supplied list all exceptions in the "from" array
          * that are subclasses of an exception in the "with" array.
          */
         private void collectCompatibleExceptions(
                 ValueType[] from, ValueType[] with, Vector list)
                 throws ClassNotFound {
             for (int i = 0; i < from.length; i++) {
                 ClassDefinition exceptionDef = from[i].getClassDefinition();
                 if (!list.contains(from[i])) {
                     for (int j = 0; j < with.length; j++) {
                         if (exceptionDef.subClassOf(
                                 enclosing.getEnv(),
                                 with[j].getClassDeclaration())) {
                             list.addElement(from[i]);
                             break;
                         }
                     }
                 }
             }
         }
         /**
          * Return the compound type which contains this method.
          */
         public CompoundType getEnclosing() {
             return enclosing;
         }
         /**
          * Return the identifier for the class or interface which
          * declares this method.
          */
         public Identifier getDeclaredBy() {
             return declaredBy;
         }
         /**
          * Return the visibility (e.g. "public final") of this member.
          */
         public String getVisibility() {
             return vis;
         }
         /**
          * Methods to check various attributes.
          */
         public boolean isPublic() {
             return memberDef.isPublic();
         }
         public boolean isProtected() {
             return memberDef.isPrivate();
         }
         public boolean isPrivate() {
             return memberDef.isPrivate();
         }
         public boolean isStatic() {
             return memberDef.isStatic();
         }
         /**
          * Return the name of this method.
          */
         public String getName() {
             return name;
         }
         /**
          * IDL_Naming
          * Return the IDL name of this method.
          */
         public String getIDLName() {
             return idlName;
         }
         /**
          * Return the type of this method.
          */
         public sun.tools.java.Type getType() {
             return memberDef.getType();
         }
         /**
          * Return true if this is a constructor.
          */
         public boolean isConstructor () {
             return memberDef.isConstructor();
         }
         /**
          * Return true if this is NOT a constructor && is not
          * an attribute.
          */
         public boolean isNormalMethod () {
             return (!memberDef.isConstructor()) && attributeKind == ATTRIBUTE_NONE;
         }
         /**
          * Get the return type of this method. May be null.
          */
         public Type getReturnType() {
             return returnType;
         }
         /**
          * Return the argument types of this method.
          */
         public Type[] getArguments() {
             return (Type[]) arguments.clone();
         }
         /**
          * Return the names of the argument types of this method.
          */
         public String[] getArgumentNames() {
             return argumentNames;
         }
         /**
          * Return the MemberDefinition from which this method was created.
          */
         public MemberDefinition getMemberDefinition() {
             return memberDef;
         }
         /**
          * Return an array of the exception classes declared to be
          * thrown by this remote method.
          *
          * For methods with the same name and type signature inherited
          * from multiple remote interfaces, the array will contain
          * the set of exceptions declared in all of the interfaces'
          * methods that can be legally thrown in each of them.
          */
         public ValueType[] getExceptions() {
             return (ValueType[]) exceptions.clone();
         }
         /**
          * Same as getExceptions(), except when method is in an
          * ImplementationType and the exceptions list is narrower.
          */
         public ValueType[] getImplExceptions() {
             return (ValueType[]) implExceptions.clone();
         }
         /**
          * Return an array containing only those exceptions which
          * need to be caught.  Removes java.rmi.RemoteException,
          * java.lang.RuntimeException, java.lang.Error, and their
          * subclasses, then removes any exceptions which are more
          * derived than another in the list. Returns null if no
          * exceptions need to be caught.
          */
         public ValueType[] getUniqueCatchList(ValueType[] list) {
             ValueType[] result = list;
             int newSize = list.length;
             try {
                 // First, remove RemoteException, RuntimeException, Error, and their subclasses...
                 for (int i = 0; i < list.length; i++) {
                     ClassDeclaration decl = list[i].getClassDeclaration();
                     if (env.defRemoteException.superClassOf(env, decl) ||
                         env.defRuntimeException.superClassOf(env, decl) ||
                         env.defError.superClassOf(env, decl)) {
                         list[i] = null;
                         newSize--;
                     }
                 }
                 // Now remove derived types...
                 for (int i = 0; i < list.length; i++) {
                     if (list[i] != null) {
                         ClassDefinition current = list[i].getClassDefinition();
                         for (int j = 0; j < list.length; j++) {
                             if (j != i && list[i] != null && list[j] != null &&
                                 current.superClassOf(env, list[j].getClassDeclaration())) {
                                 list[j] = null;
                                 newSize--;
                             }
                         }
                     }
                 }
             } catch (ClassNotFound e) {
                 classNotFound(stack,e); // Report error but do not stop.
             }
             // Create new list if we removed anything...
             if (newSize < list.length) {
                 ValueType[] temp = new ValueType[newSize];
                 int offset = 0;
                 for (int i = 0; i < list.length; i++) {
                     if (list[i] != null) {
                         temp[offset++] = list[i];
                     }
                 }
                 list = temp;
             }
             if (list.length == 0) {
                 return null;
             } else {
                 return list;
             }
         }
         /**
          * Return an array containing only those exceptions which need to be
          * handled explicitly by the stub.  Removes java.lang.RuntimeException,
          * java.lang.Error, and their subclasses, since these are all passed
          * back as CORBA system exceptions.  Also removes subclasses of
          * java.rmi.RemoteException but not java.rmi.RemoteException itself,
          * since this may need to be thrown by the stub.
          */
         public ValueType[] getFilteredStubExceptions(ValueType[] list) {
             ValueType[] result = list;
             int newSize = list.length;
             try {
                 for (int i = 0; i < list.length; i++) {
                     ClassDeclaration decl = list[i].getClassDeclaration();
                     if ((env.defRemoteException.superClassOf(env, decl) &&
                          !env.defRemoteException.getClassDeclaration().equals(decl)) ||
                         env.defRuntimeException.superClassOf(env, decl) ||
                         env.defError.superClassOf(env, decl)) {
                         list[i] = null;
                         newSize--;
                     }
                 }
             } catch (ClassNotFound e) {
                 classNotFound(stack,e); // Report error but do not stop.
             }
             // Create new list if we removed anything...
             if (newSize < list.length) {
                 ValueType[] temp = new ValueType[newSize];
                 int offset = 0;
                 for (int i = 0; i < list.length; i++) {
                     if (list[i] != null) {
                         temp[offset++] = list[i];
                     }
                 }
                 list = temp;
             }
             return list;
         }
         /**
          * Return the string representation of this method.
          */
         public String toString() {
             if (stringRep == null) {
                 StringBuffer result = new StringBuffer(returnType.toString());
                 // Add name...
                 result.append(" ");
                 result.append(getName());
                 result.append(" (");
                 // Add arguments...
                 for (int i = 0; i < arguments.length; i++) {
                     if (i > 0) {
                         result.append(", ");
                     }
                     result.append(arguments[i]);
                     result.append(" ");
                     result.append(argumentNames[i]);
                 }
                 result.append(")");
                 // Add exceptions...
                 for (int i = 0; i < exceptions.length; i++) {
                     if (i == 0) {
                         result.append(" throws ");
                     } else {
                         result.append(", ");
                     }
                     result.append(exceptions[i]);
                 }
                 result.append(";");
                 stringRep = result.toString();
             }
             return stringRep;
         }
         /**
          * Set attribute kind. May only be called during initialization.
          */
         public void setAttributeKind(int kind) {
             attributeKind = kind;
         }
         /**
          * Set pair index. May only be called during initialization.
          */
         public void setAttributePairIndex(int index) {
             attributePairIndex = index;
         }
         /**
          * Set attribute name. May only be called during initialization.
          */
         public void setAttributeName(String name) {
             attributeName = name;
         }
         /**
          * Set the idl name. May only be called during initialization.
          */
         public void setIDLName (String idlName) {
             this.idlName=idlName;
         }
         /**
          * Set the implExceptions array. May only be called during initialization.
          */
         public void setImplExceptions (ValueType[] exceptions) {
             implExceptions = exceptions;
         }
         /**
          * Set the declaredBy Identifier. May only be called during initialization.
          */
         public void setDeclaredBy (Identifier by) {
             declaredBy = by;
         }
         /**
          * Convert all invalid types to valid ones.
          */
         protected void swapInvalidTypes () {
             // Check return type...
             if (returnType.getStatus() != STATUS_VALID) {
                 returnType = getValidType(returnType);
             }
             // Check args...
             for (int i = 0; i < arguments.length; i++) {
                 if (arguments[i].getStatus() != STATUS_VALID) {
                     arguments[i] = getValidType(arguments[i]);
                 }
             }
             // Check exceptions...
             for (int i = 0; i < exceptions.length; i++) {
                 if (exceptions[i].getStatus() != STATUS_VALID) {
                     exceptions[i] = (ValueType)getValidType(exceptions[i]);
                 }
             }
             // Check implExceptions...
             for (int i = 0; i < implExceptions.length; i++) {
                 if (implExceptions[i].getStatus() != STATUS_VALID) {
                     implExceptions[i] = (ValueType)getValidType(implExceptions[i]);
                 }
             }
         }
         /**
          * Release all resources.
          */
         public void destroy () {
             if (memberDef != null) {
                 memberDef = null;
                 enclosing = null;
                 if (exceptions != null) {
                     for (int i = 0; i < exceptions.length; i++) {
                         if (exceptions[i] != null) exceptions[i].destroy();
                         exceptions[i] = null;
                     }
                     exceptions = null;
                 }
                 if (implExceptions != null) {
                     for (int i = 0; i < implExceptions.length; i++) {
                         if (implExceptions[i] != null) implExceptions[i].destroy();
                         implExceptions[i] = null;
                     }
                     implExceptions = null;
                 }
                 if (returnType != null) returnType.destroy();
                 returnType = null;
                 if (arguments != null) {
                     for (int i = 0; i < arguments.length; i++) {
                         if (arguments[i] != null) arguments[i].destroy();
                         arguments[i] = null;
                     }
                     arguments = null;
                 }
                 if (argumentNames != null) {
                     for (int i = 0; i < argumentNames.length; i++) {
                         argumentNames[i] = null;
                     }
                     argumentNames = null;
                 }
                 vis = null;
                 name = null;
                 idlName = null;
                 stringRep = null;
                 attributeName = null;
                 declaredBy = null;
             }
         }
         private MemberDefinition memberDef;
         private CompoundType enclosing;
         private ValueType[] exceptions;
         private ValueType[] implExceptions;
         private Type returnType;
         private Type[] arguments;
         private String[] argumentNames;
         private String vis;
         private String name;
         private String idlName;
         private String stringRep = null;
         private int attributeKind = ATTRIBUTE_NONE;
         private String attributeName = null;
         private int attributePairIndex = -1;
         private Identifier declaredBy = null;
         /**
          * Make up an argument name for the given type.
          */
         private String makeArgName (int argNum, Type type) {
             return "arg" + argNum;
         }
         /**
          * Create a new Method object corresponding to the given
          * method definition.
          */
         public Method (CompoundType enclosing,
                        MemberDefinition memberDef,
                        boolean quiet,
                        ContextStack stack) throws Exception {
             this.enclosing = enclosing;
             this.memberDef = memberDef;
             vis = getVisibilityString(memberDef);
             idlName = null; // See setIDLName()
             boolean valid = true;
             declaredBy = memberDef.getClassDeclaration().getName();
             // Set name...
             name = memberDef.getName().toString();
             // Update the context...
             stack.setNewContextCode(ContextStack.METHOD);
             stack.push(this);
             // Set return type...
             stack.setNewContextCode(ContextStack.METHOD_RETURN);
             sun.tools.java.Type methodType = memberDef.getType();
             sun.tools.java.Type rtnType = methodType.getReturnType();
             if (rtnType == sun.tools.java.Type.tVoid) {
                 returnType = PrimitiveType.forPrimitive(rtnType,stack);
             } else {
                 returnType = makeType(rtnType,null,stack);
                 if (returnType == null ||
                     !assertNotImpl(returnType,quiet,stack,enclosing,false)) {
                     valid = false;
                     failedConstraint(24,quiet,stack,enclosing.getName());
                 }
             }
             // Set arguments and argument names...
             stack.setNewContextCode(ContextStack.METHOD_ARGUMENT);
             sun.tools.java.Type[] args = memberDef.getType().getArgumentTypes();
             arguments = new Type[args.length];
             argumentNames = new String[args.length];
             Vector origArgNames = memberDef.getArguments();
             for (int i = 0; i < args.length; i++) {
                 Type type = null;
                 try {
                     type = makeType(args[i],null,stack);
                 } catch (Exception e) {
                 }
                 if (type != null) {
                     if (!assertNotImpl(type,quiet,stack,enclosing,false)) {
                         valid = false;
                     } else {
                     arguments[i] = type;
                     if (origArgNames != null) {
                         LocalMember local = (LocalMember)origArgNames.elementAt(i+1);
                         argumentNames[i] = local.getName().toString();
                     } else {
                         argumentNames[i] = makeArgName(i,type);
                     }
                     }
                 } else {
                     valid = false;
                     failedConstraint(25,false,stack,enclosing.getQualifiedName(),name);
                 }
             }
             if (!valid) {
                 stack.pop(false);
                 throw new Exception();
             }
             // Set exceptions...
             try {
                 exceptions = enclosing.getMethodExceptions(memberDef,quiet,stack);
                 implExceptions = exceptions;
                 stack.pop(true);
             } catch (Exception e) {
                 stack.pop(false);
                 throw new Exception();
             }
         }
         /**
          * Cloning is supported by returning a shallow copy of this object.
          */
         protected Object clone() {
             try {
                 return super.clone();
             } catch (CloneNotSupportedException e) {
                 throw new Error("clone failed");
             }
         }
     }
     //_____________________________________________________________________
     // Inner Class "Member"
     //_____________________________________________________________________
     /**
      * An CompoundType.Member object wraps a Type and a value representing
      * a data member, including constants.
      */
     public class Member implements ContextElement, Cloneable {
         /**
          * Return context element name.
          */
         public String getElementName() {
             return "\"" + getName() + "\"";
         }
         /**
          * Return the type of this member.
          */
         public Type getType() {
             return type;
         }
         /**
          * Return the name of this member.
          */
         public String getName() {
             return name;
         }
         /**
          * IDL_Naming
          * Return the IDL name of this member.
          */
         public String getIDLName() {
             return idlName;
         }
         /**
          * Return the visibility (e.g. "public final") of this member.
          */
         public String getVisibility() {
             return vis;
         }
         /**
          * Methods to check various attributes.
          */
         public boolean isPublic() {
             return member.isPublic();
         }
         public boolean isPrivate() {
             return member.isPrivate();
         }
         public boolean isStatic() {
             return member.isStatic();
         }
         public boolean isFinal() {
             return member.isFinal();
         }
         public boolean isTransient() {
             if (forceTransient) return true;
             return member.isTransient();
         }
         /**
          * Return the value of this member. May be null.
          */
         public String getValue() {
             return value;
         }
         /**
          * Return true if this member represents an inner class declaration,
          * false otherwise.
          */
         public boolean isInnerClassDeclaration() {
             return innerClassDecl;
         }
         /**
          * Return true if this member represents a constant.
          */
         public boolean isConstant () {
             return constant;
         }
         /**
          * Return the string representation of this constant.
          */
         public String toString() {
             String result = type.toString();
             if (value != null) {
                 result += (" = " + value);
             }
             return result;
         }
         /**
          * Convert all invalid types to valid ones.
          */
         protected void swapInvalidTypes () {
             if (type.getStatus() != STATUS_VALID) {
                 type = getValidType(type);
             }
         }
         protected void setTransient() {
             if (! isTransient()) {
                 forceTransient = true;
                 if (vis.length() > 0) {
                     vis = vis + " transient";
                 } else {
                     vis = "transient";
                 }
             }
         }
         protected MemberDefinition getMemberDefinition() {
             return member;
         }
         /**
          * Release all resources.
          */
         public void destroy () {
             if (type != null) {
                 type.destroy();
                 type = null;
                 vis = null;
                 value = null;
                 name = null;
                 idlName = null;
                 member = null;
             }
         }
         private Type type;
         private String vis;
         private String value;
         private String name;
         private String idlName;
         private boolean innerClassDecl;
         private boolean constant;
         private MemberDefinition member;
         private boolean forceTransient;
         /**
          * Create a new Member object.
          */
         public Member(MemberDefinition member,
                       String value,
                       ContextStack stack,
                       CompoundType enclosing) {
             this.member = member;
             this.value = value;
             forceTransient = false;
             innerClassDecl = member.getInnerClass() != null;
             // If we are not an inner class, finish initializing now.
             // Otherwise, wait until outer class is finished, then
             // call init to avoid potential recursion problems...
             if (!innerClassDecl) {
                 init (stack,enclosing);
             }
         }
         public void init (ContextStack stack, CompoundType enclosing) {
             constant = false;
             name = member.getName().toString();
             vis = getVisibilityString(member);
             idlName = null;
             // Add self to stack...
             int contextCode = ContextStack.MEMBER;
             stack.setNewContextCode(contextCode);
             // Check for special contextCodes...
             if (member.isVariable()) {
                 if (value != null && member.isConstant()) {
                     contextCode = ContextStack.MEMBER_CONSTANT;
                     this.constant = true;
                 } else if (member.isStatic()) {
                     contextCode = ContextStack.MEMBER_STATIC;
                 } else if (member.isTransient()) {
                     contextCode = ContextStack.MEMBER_TRANSIENT;
                 }
             }
             stack.setNewContextCode(contextCode);
             stack.push(this);
             type = makeType(member.getType(),null,stack);
             if (type == null ||
                 (!innerClassDecl &&
                  !member.isStatic() &&
                  !member.isTransient() &&
                  !assertNotImpl(type,false,stack,enclosing,true))) {
                 stack.pop(false);
                 throw new CompilerError("");
             }
             // Clean up primitive constant values...
             if (constant && type.isPrimitive()) {
                 if (type.isType(TYPE_LONG) || type.isType(TYPE_FLOAT) || type.isType(TYPE_DOUBLE)) {
                     int length = value.length();
                     char lastChar = value.charAt(length-1);
                     if (!Character.isDigit(lastChar)) {
                         this.value = value.substring(0,length-1);
                     }
                 } else if (type.isType(TYPE_BOOLEAN)) {
                     value = value.toUpperCase();
                 }
             }
             if (constant && type.isType(TYPE_STRING)) {
                 value = "L" + value;
             }
             stack.pop(true);
         }
         public void setIDLName (String name) {
             this.idlName = name;
         }
         /**
          * Cloning is supported by returning a shallow copy of this object.
          */
         protected Object clone() {
             try {
                 return super.clone();
             } catch (CloneNotSupportedException e) {
                 throw new Error("clone failed");
             }
         }
     }
 }

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/sun/rmi/rmic/iiop/CompoundType.java@81d694b1ab2f (annotated)

src/share/classes/sun/rmi/rmic/iiop/CompoundType.java