jdk8-mips64-public/corba: src/share/classes/sun/rmi/rmic/iiop/IDLGenerator.java@6845b95cba6b (annotated)

src/share/classes/sun/rmi/rmic/iiop/IDLGenerator.java@6845b95cba6b (annotated)

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

Thu, 31 Aug 2017 18:10:36 +0800

author: aoqi
date: Thu, 31 Aug 2017 18:10:36 +0800
changeset 748: 6845b95cba6b
parent 158: 91006f157c46
parent 0: 7ef37b2cdcad
permissions: -rw-r--r--

merge

 /*
  * 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.io.File;
 import java.io.IOException;
 import java.text.DateFormat;
 import java.util.Date;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Locale;
 import java.util.StringTokenizer;
 import java.util.Vector;
 import sun.tools.java.Identifier;
 import sun.tools.java.ClassDefinition;
 import sun.tools.java.CompilerError;
 import sun.rmi.rmic.IndentingWriter;
 import java.util.HashSet;
 import sun.rmi.rmic.Main;
 /**
  * An IDL generator for rmic.
  *
  * @author  Steve Newberry, Bryan Atsatt
  */
 public class IDLGenerator extends sun.rmi.rmic.iiop.Generator {
     private boolean valueMethods = true;
     private boolean factory = true;                              //init==!factory
     private Hashtable ifHash = new Hashtable();              //IDL file Hashtable
     private Hashtable imHash = new Hashtable();            //IDL module Hashtable
     private boolean isThrown = true;                      //flag for writeInclude
     private boolean isException = true;       //flag for writeBanner, writeIfndef
     private boolean isForward = true;                      //flag for writeIfndef
     private boolean forValuetype = true;                 //flag for writeInherits
     /**
      * Default constructor for Main to use.
      */
     public IDLGenerator() {
     }
     /**
      * 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) {
         return valueMethods;
     }
     /**
      * Create and return a top-level type.
      * @param env The compiler environment.
      * @param cdef The top-level class definition.
      * @return An RemoteType or null if is non-conforming.
      */
     protected sun.rmi.rmic.iiop.CompoundType getTopType(ClassDefinition cdef,
                                                         ContextStack stack) {
         return CompoundType.forCompound(cdef,stack);
     }
     /**
      * Return an Identifier which contains the fully-qualified IDL filename
      * for the given OutputType.
      * The OutputType contains a filename string (not directory) and Type.
      * @param ot the OutputType for which directory nesting is to be defined.
      * @return the new identifier.
      */
     protected Identifier getOutputId (
                                       OutputType ot ) {
         Identifier id = super.getOutputId( ot );
         Type t = ot.getType();
         String fName = ot.getName();
         if ( id == idJavaLangClass )                 //java.lang.Class and array of
             if ( t.isArray() )
                 return Identifier.lookup(
                                          "org.omg.boxedRMI.javax.rmi.CORBA." + fName  );
             else return idClassDesc;
         if ( id == idJavaLangString &&                  //array of java.lang.String
              t.isArray() )
             return Identifier.lookup( "org.omg.boxedRMI.CORBA." + fName );
         if ( "org.omg.CORBA.Object".equals( t.getQualifiedName() ) &&
              t.isArray() )                          //array of org.omg.CORBA.Object
             return Identifier.lookup( "org.omg.boxedRMI." + fName );
         if ( t.isArray()) {                                                 //array
             ArrayType at = (ArrayType)t;
             Type et = at.getElementType();
             if ( et.isCompound() ) {
                 CompoundType ct = (CompoundType)et;
                 String qName = ct.getQualifiedName();
                 if ( ct.isIDLEntity() )
                     return Identifier.lookup( getQualifiedName( at ) );
             }
             return Identifier.lookup( idBoxedRMI,id );
         }
         if ( t.isCompound() ) {                                   //boxed IDLEntity
             CompoundType ct = (CompoundType)t;
             String qName = ct.getQualifiedName();
             if ( ct.isBoxed() )
                 return Identifier.lookup( getQualifiedName( ct ) );
         }
         return id;
     }
     /**
      * 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 IDL_FILE_EXTENSION;
     }
     /**
      * 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) {
         boolean result = super.parseArgs(argv,main);
         String idlFrom;
         String idlTo;
         if (result) {
         nextArg:
             for (int i = 0; i < argv.length; i++) {
                 if (argv[i] != null) {
                     if (argv[i].equalsIgnoreCase("-idl")) {
                         idl = true;
                         argv[i] = null;
                     }
                     else if ( argv[i].equalsIgnoreCase( "-valueMethods" ) ) {
                         valueMethods = true;
                         argv[i] = null;
                     }
                     else if ( argv[i].equalsIgnoreCase( "-noValueMethods" ) ) {
                         valueMethods = false;
                         argv[i] = null;
                     }
                     else if ( argv[i].equalsIgnoreCase( "-init" ) ) {
                         factory = false;
                         argv[i] = null;
                 }
                     else if ( argv[i].equalsIgnoreCase( "-factory" ) ) {
                         factory = true;
                         argv[i] = null;
             }
                     else if ( argv[i].equalsIgnoreCase( "-idlfile" ) ) {
                         argv[i] = null;
                         if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {
                             idlFrom = argv[i];
                             argv[i] = null;
                             if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {
                                 idlTo = argv[i];
                                 argv[i] = null;
                                 ifHash.put( idlFrom,idlTo );
                                 continue nextArg;
         }
                         }
                         main.error("rmic.option.requires.argument", "-idlfile");
                         result = false;
                     }
                     else if ( argv[i].equalsIgnoreCase( "-idlmodule" ) ) {
                         argv[i] = null;
                         if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {
                             idlFrom = argv[i];
                             argv[i] = null;
                             if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {
                                 idlTo = argv[i];
                                 argv[i] = null;
                                 imHash.put( idlFrom,idlTo );
                                 continue nextArg;
                             }
                         }
                         main.error("rmic.option.requires.argument", "-idlmodule");
                         result = false;
                     }
                 }
             }
         }
         return result;
     }
     /**
      * Return an array of OutputTypes for the IDL files that need to be
      * generated for the given top-level type.
      * OutputTypes contain filename string (not directory) and Type.
      * @param topType The type returned by getTopType().
      * @param alreadyChecked A set of Types which have already been checked.
      * @return Array of OutputTypes to generate
      */
     protected OutputType[] getOutputTypesFor(
                                              CompoundType topType,
                                              HashSet alreadyChecked ) {
         Vector refVec = getAllReferencesFor( topType );
         Vector outVec = new Vector();
         for ( int i1 = 0; i1 < refVec.size(); i1++ ) {          //forall references
             Type t = (Type)refVec.elementAt( i1 );
             if ( t.isArray() ) {
                 ArrayType at = (ArrayType)t;
                 int dim = at.getArrayDimension();
                 Type et = at.getElementType();
                 String fName = unEsc( et.getIDLName() ).replace( ' ','_' );
                 for ( int i2 = 0; i2 < dim; i2++ ) {                //foreach dimension
                     String fileName = "seq" + ( i2 + 1 ) + "_" + fName;
                     outVec.addElement( new OutputType( fileName,at ) );
                 }
             }
             else if ( t.isCompound() ) {
                 String fName = unEsc( t.getIDLName() );
                 outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) );
             if ( t.isClass() ) {
                 ClassType ct = (ClassType)t;
                     if ( ct.isException() ) {                            //exception file
                         fName = unEsc( ct.getIDLExceptionName() );
                         outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) );
             }
         }
     }
     }
         OutputType[] outArr = new OutputType[outVec.size()];
         outVec.copyInto( outArr );
         return outArr;
     }
     /**
      * Get all referenced types of a given tyoe for which an IDL file needs
      * to be generated.
      * @param ct The given type.
      * @return Vector of Types for which IDL must be generated.
      */
     protected Vector getAllReferencesFor(
                                          CompoundType ct ) {
         Hashtable refHash = new Hashtable();
         Hashtable spcHash = new Hashtable();
         Hashtable arrHash = new Hashtable();
         int refSize;
         refHash.put( ct.getQualifiedName(),ct );               //put the given type
         accumulateReferences( refHash,spcHash,arrHash );
         do {
             refSize = refHash.size();
             accumulateReferences( refHash,spcHash,arrHash );
         }
         while ( refSize < refHash.size() );        //till hashtable stays same size
         Vector outVec = new Vector();
         Enumeration e = refHash.elements();                   //ordinary references
         while ( e.hasMoreElements() ) {
             CompoundType t = (CompoundType)e.nextElement();
             outVec.addElement( t );
         }
         e = spcHash.elements();                                //special references
         while ( e.hasMoreElements() ) {
             CompoundType t = (CompoundType)e.nextElement();
             outVec.addElement( t );
     }
         e = arrHash.elements();                                  //array references
                                          nextSequence:
         while ( e.hasMoreElements() ) {
             ArrayType at = (ArrayType)e.nextElement();
             int dim = at.getArrayDimension();
             Type et = at.getElementType();
             Enumeration e2 = arrHash.elements();
             while ( e2.hasMoreElements() ) {                   //eliminate duplicates
                 ArrayType at2 = (ArrayType)e2.nextElement();
                 if ( et == at2.getElementType() &&                //same element type &
                      dim < at2.getArrayDimension() )               //smaller dimension?
                     continue nextSequence;                              //ignore this one
             }
             outVec.addElement( at );
         }
         return outVec;
     }
     /**
      * Accumulate and filter all those types that are referenced by the given
      * referenced types.
      * Keep only those for which IDL is to be generated.
      * @param refHash Hashtable containing the given types
      * @param spcHash Hashtable containing referenced specials (IDL typedefs)
      * @param arrHash Hashtable containing referenced arrays (dimensioned)
      */
     protected void accumulateReferences(
                                         Hashtable refHash,
                                         Hashtable spcHash,
                                         Hashtable arrHash ) {
         Enumeration e = refHash.elements();
         while ( e.hasMoreElements() ) {
             CompoundType t = (CompoundType)e.nextElement();
             Vector datVec = getData( t );                     //collect and sort data
             Vector mthVec = getMethods( t );             //collect and filter methods
             getInterfaces( t,refHash );                          //collect interfaces
             getInheritance( t,refHash );                            //add inheritance
             getMethodReferences( mthVec,refHash,spcHash,arrHash,refHash );
             getMemberReferences( datVec,refHash,spcHash,arrHash );
         }
         e = arrHash.elements();                      //add array element references
         while ( e.hasMoreElements() ) {
             ArrayType at = (ArrayType)e.nextElement();
             Type et = at.getElementType();
             addReference( et,refHash,spcHash,arrHash );
         }
         e = refHash.elements();
         while ( e.hasMoreElements() ) {
             CompoundType t = (CompoundType)e.nextElement();
             if ( !isIDLGeneratedFor( t ) )              //remove if no IDL generation
                 refHash.remove( t.getQualifiedName() );
     }
     }
     /**
      * Determine if IDL should be generated for a referenced type.
      * Do not generate IDL for a CORBA Object reference. It gets mapped
      * to the original IDL or to Object (if exactly org.omg.CORBA.Object)
      * Generate (boxed) IDL for an IDL Entity unless it is an IDL user
      * exception, a ValueBase, an AbstractBase (or a CORBA Object).
      * Do not generate IDL for Implementation classes..unless they inherit
      * from multiple distinct remote interfaces
      * @param t The type to check.
      * @return true or false
      */
     protected boolean isIDLGeneratedFor(
                                  CompoundType t ) {
         if ( t.isCORBAObject() ) return false;
         if ( t.isIDLEntity() )
             if ( t.isBoxed() ) return true;
             else if ( "org.omg.CORBA.portable.IDLEntity"
                       .equals( t.getQualifiedName() ) ) return true;
             else if ( t.isCORBAUserException() ) return true;
             else return false;
         Hashtable inhHash = new Hashtable();
         getInterfaces( t,inhHash );
         if ( t.getTypeCode() == TYPE_IMPLEMENTATION )
             if ( inhHash.size() < 2 ) return false;         //no multiple inheritance
             else return true;
         return true;                                   //generate IDL for this type
     }
     /**
      * Write the output for the given OutputFileName into the output stream.
      * (The IDL mapping for java.lang.Class is generated from
      * javax.rmi.CORBA.ClassDesc in the tools workspace)
      * @param OutputType ot 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 p The output stream.
      */
     protected void writeOutputFor(
                                   OutputType ot,
                                   HashSet alreadyChecked,
                                   IndentingWriter p )
         throws IOException {
         Type t = ot.getType();
         if ( t.isArray() ) {                                //specialcase: sequence
             writeSequence( ot,p );
             return;
         }
         if ( isSpecialReference( t ) ) {                //specialcase: IDL typecode
             writeSpecial( t,p );
             return;
         }
         if ( t.isCompound() ) {                            //specialcase: boxed IDL
             CompoundType ct = (CompoundType)t;
             if ( ct.isIDLEntity() && ct.isBoxed() ) {
                 writeBoxedIDL( ct,p );
                 return;
             }
         }
         if ( t.isClass() ) {                               //specialcase: exception
             ClassType ct = (ClassType)t;
             if ( ct.isException() ) {
                 String eName = unEsc( ct.getIDLExceptionName() );
                 String fName = ot.getName();
                 if ( fName.equals( eName.replace( ' ','_' ) ) ) {
                     writeException( ct,p );
                     return;
                 }
             }
         }
         switch ( t.getTypeCode() ) {                                 //general case
         case TYPE_IMPLEMENTATION:
             writeImplementation( (ImplementationType)t,p );
             break;
         case TYPE_NC_CLASS:
         case TYPE_NC_INTERFACE:
             writeNCType( (CompoundType)t,p );
             break;
         case TYPE_ABSTRACT:                        //AbstractType is a RemoteType
         case TYPE_REMOTE:
             writeRemote( (RemoteType)t,p );
             break;
         case TYPE_VALUE:
             writeValue( (ValueType)t,p );
             break;
         default:
             throw new CompilerError(
                                     "IDLGenerator got unexpected type code: "
                                     + t.getTypeCode());
         }
     }
     /**
      * Write an IDL interface definition for a Java implementation class
      * @param t The current ImplementationType
      * @param p The output stream.
      */
     protected void writeImplementation(
                                        ImplementationType t,
                                        IndentingWriter p )
         throws IOException {
         Hashtable inhHash = new Hashtable();
         Hashtable refHash = new Hashtable();
         getInterfaces( t,inhHash );                            //collect interfaces
         writeBanner( t,0,!isException,p );
         writeInheritedIncludes( inhHash,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeIncOrb( p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.p( "interface " + t.getIDLName() );
         writeInherits( inhHash,!forValuetype,p );
         p.pln( " {" );
         p.pln( "};" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeEpilog( t,refHash,p );
     }
     /**
      * Write an IDL valuetype definition for
      * 1) a nonconforming Java class
      * 2) a nonconforming Java interface (that is not an AbstractType)
      * @param t The current NC Type (NCClassType or NCInterfaceType)
      * @param p The output stream.
      */
     protected void writeNCType(
                                CompoundType t,
                                IndentingWriter p )
         throws IOException {
         Vector conVec = getConstants( t );                      //collect constants
         Vector mthVec = getMethods( t );                          //collect methods
         Hashtable inhHash = new Hashtable();
         Hashtable refHash = new Hashtable();
         Hashtable spcHash = new Hashtable();
         Hashtable arrHash = new Hashtable();
         Hashtable excHash = new Hashtable();
         getInterfaces( t,inhHash );                            //collect interfaces
         getInheritance( t,inhHash );                              //add inheritance
         getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash );
         writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.p( "abstract valuetype " + t.getIDLName() );
         writeInherits( inhHash,!forValuetype,p );
         p.pln( " {" );
         if ( conVec.size() + mthVec.size() > 0 ) {                   //any content?
             p.pln();p.pI();
             for ( int i1 = 0; i1 < conVec.size(); i1++ )            //write constants
                 writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p );
             for ( int i1 = 0; i1 < mthVec.size(); i1++ )              //write methods
                 writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p );
             p.pO();p.pln();
         }
         p.pln( "};" );
                 p.pO();p.pln();
         writeModule2( t,p );
         writeEpilog( t,refHash,p );
     }
     /**
      * Write an IDL interface definition for either:
      * 1) a conforming Java remote interface (RemoteType)..or
      * 2) a non-conforming Java interface whose methods all throw
      *     java.rmi.RemoteException (AbstractType)
      * @param t The current RemoteType
      * @param p The output stream.
      */
     protected void writeRemote(
                                RemoteType t,
                                IndentingWriter p )
         throws IOException {
         Vector conVec = getConstants( t );                      //collect constants
         Vector mthVec = getMethods( t );                          //collect methods
         Hashtable inhHash = new Hashtable();
         Hashtable refHash = new Hashtable();
         Hashtable spcHash = new Hashtable();
         Hashtable arrHash = new Hashtable();
         Hashtable excHash = new Hashtable();
         getInterfaces( t,inhHash );                            //collect interfaces
         getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash );
         writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p );
         writeModule1( t,p );
         p.pln();p.pI();
         if ( t.getTypeCode() == TYPE_ABSTRACT ) p.p( "abstract " );
         p.p( "interface " + t.getIDLName() );
         writeInherits( inhHash,!forValuetype,p );
         p.pln( " {" );
         if ( conVec.size() + mthVec.size() > 0 ) {      //any constants or methods?
             p.pln();p.pI();
             for ( int i1 = 0; i1 < conVec.size(); i1++ )                  //constants
                 writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p );
             for ( int i1 = 0; i1 < mthVec.size(); i1++ )        //methods, attributes
                 writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p );
             p.pO();p.pln();
         }
         p.pln( "};" );
         p.pO();p.pln();
         writeRepositoryID ( t,p );
         p.pln();
         writeModule2( t,p );
         writeEpilog( t,refHash,p );
     }
     /**
      * Write an IDL valuetype definition for a conforming Java class.
      * Methods and constructors are optional..controlled by -valueMethods flag
      * @param t The current ValueType
      * @param p The output stream.
      */
     protected void writeValue(
                               ValueType t,
                               IndentingWriter p )
         throws IOException {
         Vector datVec = getData( t );                       //collect and sort data
         Vector conVec = getConstants( t );                      //collect constants
         Vector mthVec = getMethods( t );               //collect and filter methods
         Hashtable inhHash = new Hashtable();
         Hashtable refHash = new Hashtable();
         Hashtable spcHash = new Hashtable();
         Hashtable arrHash = new Hashtable();
         Hashtable excHash = new Hashtable();
         getInterfaces( t,inhHash );                            //collect interfaces
         getInheritance( t,inhHash );                              //add inheritance
         getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash );
         getMemberReferences( datVec,refHash,spcHash,arrHash );
         writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p );
         writeModule1( t,p );
         p.pln();p.pI();
         if ( t.isCustom() ) p.p( "custom " );
         p.p( "valuetype " + t.getIDLName() );
         writeInherits( inhHash,forValuetype,p );
         p.pln( " {" );
         if ( conVec.size() + datVec.size() + mthVec.size() > 0 ) {   //any content?
             p.pln();p.pI();
             for ( int i1 = 0; i1 < conVec.size(); i1++ )            //write constants
                 writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p );
             for ( int i1 = 0; i1 < datVec.size(); i1++ ) {
                 CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 );
                 if ( mem.getType().isPrimitive() )
                     writeData( mem,p );                            //write primitive data
             }
             for ( int i1 = 0; i1 < datVec.size(); i1++ ) {
                 CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 );
                 if ( !mem.getType().isPrimitive() )
                     writeData( mem,p );                        //write non-primitive data
             }
             for ( int i1 = 0; i1 < mthVec.size(); i1++ )              //write methods
                 writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p );
             p.pO();p.pln();
         }
         p.pln( "};" );
         p.pO();p.pln();
         writeRepositoryID ( t,p );
             p.pln();
         writeModule2( t,p );
         writeEpilog( t,refHash,p );
         }
     /**
      * Write IDL prolog for a CompoundType.
      * @param t The CompoundType.
      * @param refHash Hashtable loaded with type references.
      * @param spcHash Hashtable loaded with special type references.
      * @param arrHash Hashtable loaded with array references.
      * @param excHash Hashtable loaded with exceptions thrown.
      * @param inhHash Hashtable loaded with inherited types.
      * @param p The output stream.
      */
     protected void writeProlog(
                                CompoundType t,
                                Hashtable refHash,
                                Hashtable spcHash,
                                Hashtable arrHash,
                                Hashtable excHash,
                                Hashtable inhHash,
                                IndentingWriter p )
         throws IOException {
         writeBanner( t,0,!isException,p );
         writeForwardReferences( refHash,p );
         writeIncludes( excHash,isThrown,p );      //#includes for exceptions thrown
         writeInheritedIncludes( inhHash,p );
         writeIncludes( spcHash,!isThrown,p );         //#includes for special types
         writeBoxedRMIIncludes( arrHash,p );
         writeIDLEntityIncludes( refHash,p );
         writeIncOrb( p );
         writeIfndef( t,0,!isException,!isForward,p );
     }
     /**
      * Write IDL epilog for a CompoundType.
      * @param t The CompoundType.
      * @param refHash Hashtable loaded with type references.
      * @param p The output stream.
      */
     protected void writeEpilog(
                                CompoundType t,
                                Hashtable refHash,
                                IndentingWriter p )
         throws IOException {
         writeIncludes( refHash,!isThrown,p );     //#includes for forward dcl types
         writeEndif( p );
     }
     /**
      * Write special typedef
      * @param t A special Type.
      * @param p The output stream.
      */
     protected void writeSpecial(
                                 Type t,
                                 IndentingWriter p )
         throws IOException {
         String spcName = t.getQualifiedName();
         if ( "java.io.Serializable".equals( spcName ) )
             writeJavaIoSerializable( t,p );
         else if ( "java.io.Externalizable".equals( spcName ) )
             writeJavaIoExternalizable( t,p );
         else if ( "java.lang.Object".equals( spcName) )
             writeJavaLangObject( t,p );
         else if ( "java.rmi.Remote".equals( spcName) )
             writeJavaRmiRemote( t,p );
         else if ( "org.omg.CORBA.portable.IDLEntity".equals( spcName) )
             writeIDLEntity( t,p );
     }
     /**
      * Write a hard-coded IDL typedef definition for the special case
      * java.io.Serializable.
      * @param t The current Type
      * @param p The output stream.
      */
     protected void writeJavaIoSerializable(
                                            Type t,
                                            IndentingWriter p )
         throws IOException {
         writeBanner( t,0,!isException,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.pln( "typedef any Serializable;" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeEndif( p );
     }
     /**
      * Write a hard-coded IDL typedef definition for the special case
      * java.io.Externalizable.
      * @param t The current Type
      * @param p The output stream.
      */
     protected void writeJavaIoExternalizable(
                                              Type t,
                                              IndentingWriter p )
         throws IOException {
         writeBanner( t,0,!isException,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.pln( "typedef any Externalizable;" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeEndif( p );
     }
     /**
      * Write a hard-coded IDL typedef definition for the special case
      * java.lang.Object.
      * @param t The current Type
      * @param p The output stream.
      */
     protected void writeJavaLangObject(
                                        Type t,
                                        IndentingWriter p )
         throws IOException {
         writeBanner( t,0,!isException,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.pln( "typedef any _Object;" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeEndif( p );
     }
     /**
      * Write a hard-coded IDL typedef definition for the special case
      * java.rmi.Remote.
      * @param t The current Type
      * @param p The output stream.
      */
     protected void writeJavaRmiRemote(
                                       Type t,
                                       IndentingWriter p )
         throws IOException {
         writeBanner( t,0,!isException,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.pln( "typedef Object Remote;" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeEndif( p );
     }
     /**
      * Write a hard-coded IDL typedef definition for the special case
      * org.omg.CORBA.portable.IDLEntity
      * @param t The current Type
      * @param p The output stream.
      */
     protected void writeIDLEntity(
                                   Type t,
                                   IndentingWriter p )
         throws IOException {
         writeBanner( t,0,!isException,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.pln( "typedef any IDLEntity;" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeEndif( p );
     }
     /**
      * Filter and collect non-duplicate inherited interfaces for a type
      * @param ct The current CompoundType
      * @param inhHash Hashtable containing the inherited interfaces
      */
     protected void getInterfaces(
                                  CompoundType ct,
                                  Hashtable inhHash ) {
         InterfaceType[] infs = ct.getInterfaces();
                                  nextInterface:
         for ( int i1 = 0; i1 < infs.length; i1++ ) {  //forall inherited interfaces
             String inhName = infs[i1].getQualifiedName();
             switch ( ct.getTypeCode() ) {
             case TYPE_NC_CLASS:
             case TYPE_VALUE:                                   //filter for classes
                 if ( "java.io.Externalizable".equals( inhName ) ||
                      "java.io.Serializable".equals( inhName ) ||
                      "org.omg.CORBA.portable.IDLEntity".equals( inhName ) )
                     continue nextInterface;
                 break;
             default:                                        //filter for all others
                 if ( "java.rmi.Remote".equals( inhName ) )
                     continue nextInterface;
                 break;
             }
             inhHash.put( inhName,infs[i1] );                           //add this one
         }
     }
     /**
      * Filter and add base class inheritance for a class type
      * @param ct The current CompoundType
      * @param inhHash Hashtable containing inherited types
      */
     protected void getInheritance(
                                   CompoundType ct,
                                   Hashtable inhHash ) {
         ClassType par = ct.getSuperclass();                            //get parent
         if ( par == null ) return;
         String parName = par.getQualifiedName();
         switch ( ct.getTypeCode() ) {
         case TYPE_NC_CLASS:
         case TYPE_VALUE:
             if ( "java.lang.Object".equals( parName ) )          //this is implicit
                 return;
             break;
         default: return;                                     //ignore other types
         }
         inhHash.put( parName,par );                          //add valid base class
     }
     /**
      * Collect and filter type and array references from methods
      * @param mthVec Given Vector of methods
      * @param refHash Hashtable for type references
      * @param spcHash Hashtable for special type references
      * @param arrHash Hashtable for array references
      * @param excHash Hashtable for exceptions thrown
      */
     protected void getMethodReferences(
                                        Vector mthVec,
                                        Hashtable refHash,
                                        Hashtable spcHash,
                                        Hashtable arrHash,
                                        Hashtable excHash ) {
         for ( int i1 = 0; i1 < mthVec.size(); i1++ ) {             //forall methods
             CompoundType.Method mth = (CompoundType.Method)mthVec.elementAt( i1 );
             Type[] args = mth.getArguments();
             Type ret = mth.getReturnType();
             getExceptions( mth,excHash );                 //collect exceptions thrown
             for ( int i2 = 0; i2 < args.length; i2++ )             //forall arguments
                 addReference( args[i2],refHash,spcHash,arrHash );
             addReference( ret,refHash,spcHash,arrHash );
         }
     }
     /**
      * Collect and filter type and array references from data members
      * @param datVec Given Vector of data members
      * @param refHash Hashtable for type references
      * @param spcHash Hashtable for special type references
      * @param arrHash Hashtable for array references
      */
     protected void getMemberReferences(
                                        Vector datVec,
                                        Hashtable refHash,
                                        Hashtable spcHash,
                                        Hashtable arrHash ) {
         for ( int i1 = 0; i1 < datVec.size(); i1++ ) {         //forall datamembers
             CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 );
             Type dat = mem.getType();
             addReference( dat,refHash,spcHash,arrHash );
         }
     }
     /**
      * Add reference for given type avoiding duplication.
      * Sort into specials, arrays and regular references.
      * Filter out types which are not required.
      * @param t Given Type
      * @param refHash Hashtable for type references
      * @param spcHash Hashtable for special type references
      * @param arrHash Hashtable for array references
      */
     protected void addReference(
                                 Type ref,
                                 Hashtable refHash,
                                 Hashtable spcHash,
                                 Hashtable arrHash ) {
         String rName = ref.getQualifiedName();
         switch ( ref.getTypeCode() ) {
         case TYPE_ABSTRACT:
         case TYPE_REMOTE:
         case TYPE_NC_CLASS:
         case TYPE_NC_INTERFACE:
         case TYPE_VALUE:
             refHash.put( rName,ref );
             return;
         case TYPE_CORBA_OBJECT:
             if ( "org.omg.CORBA.Object".equals( rName ) ) return;      //don't want
             refHash.put( rName,ref );
             return;
         case TYPE_ARRAY:                                                 //array?
             arrHash.put( rName + ref.getArrayDimension(),ref );
             return;
         default:
             if ( isSpecialReference( ref ) )                 //special IDL typedef?
                 spcHash.put( rName,ref );
         }
     }
     /**
      * Determine whether given Type is a special reference.
      * Special cases are: java.io.Serializable, java.io.Externalizable,
      * java.lang.Object, java.rmi.Remote and org.omg.CORBA.portable.IDLEntity
      * They are special because they have a hard-coded typedef defined in the
      * spec.
      * @param ref A referenced Type
      * @return boolean indicating whether it's a special reference
      */
     protected boolean isSpecialReference(
                                          Type ref ) {
         String rName = ref.getQualifiedName();
         if ( "java.io.Serializable".equals( rName ) ) return true;
         if ( "java.io.Externalizable".equals( rName ) ) return true;
         if ( "java.lang.Object".equals( rName) ) return true;
         if ( "java.rmi.Remote".equals( rName) ) return true;
         if ( "org.omg.CORBA.portable.IDLEntity".equals( rName) ) return true;
         return false;
     }
     /**
      * Collect and filter thrown exceptions for a given pre-filtered method.
      * Keep only 'checked' exception classes minus java.rmi.RemoteException
      * and its subclasses
      * @param method The current method
      * @param excHash Hashtable containing non-duplicate thrown exceptions
      */
     protected void getExceptions(
                                       CompoundType.Method mth,
                                       Hashtable excHash ) {
         ClassType[] excs = mth.getExceptions();
         for ( int i1 = 0; i1 < excs.length; i1++ ) {            //forall exceptions
             ClassType exc = excs[i1];
             if ( exc.isCheckedException() &&
                  !exc.isRemoteExceptionOrSubclass() ) {
                 excHash.put( exc.getQualifiedName(),exc );
         }
     }
     }
     /**
      * Collect and filter methods for a type.
      * Remove any private or inherited methods.
      * @param ct The current CompoundType
      * @return Vector containing the methods
      */
     protected Vector getMethods(
                                 CompoundType ct ) {
         Vector vec = new Vector();
         int ctType = ct.getTypeCode();
         switch ( ctType ) {
         case TYPE_ABSTRACT:
         case TYPE_REMOTE:       break;
         case TYPE_NC_CLASS:
         case TYPE_NC_INTERFACE:
         case TYPE_VALUE:        if ( valueMethods ) break;
         default: return vec;
         }
         Identifier ctId = ct.getIdentifier();
         CompoundType.Method[] mths = ct.getMethods();
                                 nextMethod:
         for ( int i1 = 0; i1 < mths.length; i1++ ) {               //forall methods
             if ( mths[i1].isPrivate() ||                            //private method?
                  mths[i1].isInherited() )                         //inherited method?
                 continue nextMethod;                                   //yes..ignore it
             if ( ctType == TYPE_VALUE ) {
                 String mthName = mths[i1].getName();
                 if ( "readObject"  .equals( mthName ) ||
                      "writeObject" .equals( mthName ) ||
                      "readExternal".equals( mthName ) ||
                      "writeExternal".equals( mthName ) )
                     continue nextMethod;                                //ignore this one
             }
             if ( ( ctType == TYPE_NC_CLASS ||
                    ctType == TYPE_NC_INTERFACE ) &&
                  mths[i1].isConstructor() )   //init not valid for abstract valuetype
                 continue nextMethod;                                  //ignore this one
             vec.addElement( mths[i1] );                                //add this one
         }
         return vec;
     }
     /**
      * Collect constants for a type.
      * A valid constant is a "public final static" field with a compile-time
      * constant value for a primitive type or String
      * @param ct The current CompoundType
      * @return Vector containing the constants
      */
     protected Vector getConstants(
                                   CompoundType ct ) {
         Vector vec = new Vector();
         CompoundType.Member[] mems = ct.getMembers();
         for ( int i1 = 0; i1 < mems.length; i1++ ) {               //forall members
             Type   memType  = mems[i1].getType();
             String memValue = mems[i1].getValue();
             if ( mems[i1].isPublic() &&
                  mems[i1].isFinal()  &&
                  mems[i1].isStatic() &&
                  ( memType.isPrimitive() || "String".equals( memType.getName() ) ) &&
                  memValue != null )
                 vec.addElement( mems[i1] );                              //add this one
         }
         return vec;
     }
     /**
      * Collect and sort data fields for a ValueType.
      * Sort in Java (not IDL) Unicode name string lexicographic increasing
      * order.
      * Non-static, non-transient fields are mapped.
      * If the type is a custom valuetype, only public fields are mapped.
      * @param ct The current CompoundType
      * @return Vector containing the data fields
      */
     protected Vector getData(
                              CompoundType t ) {
         Vector vec = new Vector();
         if ( t.getTypeCode() != TYPE_VALUE ) return vec;
         ValueType vt = (ValueType)t;
         CompoundType.Member[] mems = vt.getMembers();
         boolean notCust = !vt.isCustom();
         for ( int i1 = 0; i1 < mems.length; i1++ ) {               //forall members
             if ( !mems[i1].isStatic()    &&
                  !mems[i1].isTransient() &&
                  (  mems[i1].isPublic() || notCust ) ) {
                 int i2;
                 String memName = mems[i1].getName();
                 for ( i2 = 0; i2 < vec.size(); i2++ ) {      //insert in java lex order
                     CompoundType.Member aMem = (CompoundType.Member)vec.elementAt( i2 );
                     if ( memName.compareTo( aMem.getName() ) < 0 ) break;
                 }
                 vec.insertElementAt( mems[i1],i2 );                   //insert this one
             }
         }
         return vec;
     }
     /**
      * Write forward references for referenced interfaces and valuetypes
      * ...but not if the reference is to a boxed IDLEntity,
      * @param refHash Hashtable loaded with referenced types
      * @param p The output stream.
      */
     protected void writeForwardReferences(
                                           Hashtable refHash,
                                           IndentingWriter p )
         throws IOException {
         Enumeration refEnum = refHash.elements();
         nextReference:
         while ( refEnum.hasMoreElements() ) {
             Type t = (Type)refEnum.nextElement();
             if ( t.isCompound() ) {
                 CompoundType ct = (CompoundType)t;
                 if ( ct.isIDLEntity() )
                     continue nextReference;                  //ignore IDLEntity reference
             }
             writeForwardReference( t,p );
         }
     }
     /**
      * Write forward reference for given type
      * @param t Given type
      * @param p The output stream.
      */
     protected void writeForwardReference(
                                          Type t,
                                          IndentingWriter p )
         throws IOException {
         String qName = t.getQualifiedName();
         if ( "java.lang.String".equals( qName ) ) ;
         else if ( "org.omg.CORBA.Object".equals( qName ) ) return ;    //no fwd dcl
         writeIfndef( t,0,!isException,isForward,p );
             writeModule1( t,p );
             p.pln();p.pI();
             switch ( t.getTypeCode() ) {
         case TYPE_NC_CLASS:
             case TYPE_NC_INTERFACE: p.p( "abstract valuetype " ); break;
             case TYPE_ABSTRACT:     p.p( "abstract interface " ); break;
             case TYPE_VALUE:        p.p( "valuetype " ); break;
         case TYPE_REMOTE:
         case TYPE_CORBA_OBJECT: p.p( "interface " ); break;
             default: ;                              //all other types were filtered
             }
             p.pln( t.getIDLName() + ";" );
             p.pO();p.pln();
             writeModule2( t,p );
         writeEndif( p );
         }
     /**
      * Write forward reference for boxed valuetype for single dimension of IDL
      * sequence.
      * If the dimension is <1 and the element is a CompoundType, write a
      * forward declare for the element
      * @param at ArrayType for forward declare
      * @param dim The dimension to write
      * @param p The output stream.
      */
     protected void writeForwardReference(
                                          ArrayType at,
                                          int dim,
                                          IndentingWriter p)
         throws IOException {
         Type et = at.getElementType();
         if ( dim < 1 ) {
             if ( et.isCompound() ) {
                 CompoundType ct = (CompoundType)et;
                 writeForwardReference( et,p);
     }
             return;
         }
         String fName = unEsc( et.getIDLName() ).replace( ' ','_' );
         writeIfndef( at,dim,!isException,isForward,p );
         writeModule1( at,p );
         p.pln();p.pI();
         switch ( et.getTypeCode() ) {
         case TYPE_NC_CLASS:
         case TYPE_NC_INTERFACE: p.p( "abstract valuetype " ); break;
         case TYPE_ABSTRACT:     p.p( "abstract interface " ); break;
         case TYPE_VALUE:        p.p( "valuetype " ); break;
         case TYPE_REMOTE:
         case TYPE_CORBA_OBJECT: p.p( "interface " ); break;
         default: ;                              //all other types were filtered
         }
         p.pln( "seq" + dim + "_" + fName + ";" );
         p.pO();p.pln();
         writeModule2( at,p );
         writeEndif( p );
     }
     /**
      * Write #includes for boxed IDLEntity references.
      * @param refHash Hashtable loaded with referenced types
      * @param p The output stream.
      */
     protected void writeIDLEntityIncludes(
                                           Hashtable refHash,
                                           IndentingWriter p )
         throws IOException {
         Enumeration refEnum = refHash.elements();
         while ( refEnum.hasMoreElements() ) {
             Type t = (Type)refEnum.nextElement();
             if ( t.isCompound() ) {
                 CompoundType ct = (CompoundType)t;
                 if ( ct.isIDLEntity() ) {                          //select IDLEntities
                     writeInclude( ct,0,!isThrown,p );
                     refHash.remove( ct.getQualifiedName() );     //avoid another #include
                 }
             }
         }
     }
     /**
      * Write #includes
      * @param incHash Hashtable loaded with Types to include
      * @param isThrown true if Types are thrown exceptions
      * @param p The output stream.
      */
     protected void writeIncludes(
                                  Hashtable incHash,
                                  boolean isThrown,
                                  IndentingWriter p )
         throws IOException {
         Enumeration incEnum = incHash.elements();
         while ( incEnum.hasMoreElements() ) {
             CompoundType t = (CompoundType)incEnum.nextElement();
             writeInclude( t,0,isThrown,p );
             }
     }
     /**
      * Write includes for boxedRMI valuetypes for IDL sequences.
      * Write only the maximum dimension found for an ArrayType.
      * @param arrHash Hashtable loaded with array types
      * @param p The output stream.
      */
     protected void writeBoxedRMIIncludes(
                                          Hashtable arrHash,
                                          IndentingWriter p)
         throws IOException {
         Enumeration e1 = arrHash.elements();
         nextSequence:
         while ( e1.hasMoreElements() ) {
             ArrayType at = (ArrayType)e1.nextElement();
             int dim = at.getArrayDimension();
             Type et = at.getElementType();
             Enumeration e2 = arrHash.elements();
             while ( e2.hasMoreElements() ) {                   //eliminate duplicates
                 ArrayType at2 = (ArrayType)e2.nextElement();
                 if ( et == at2.getElementType() &&                //same element type &
                      dim < at2.getArrayDimension() )               //smaller dimension?
                     continue nextSequence;                              //ignore this one
         }
             writeInclude( at,dim,!isThrown,p );
     }
     }
     /**
      * Write #includes
      * @param incHash Hashtable loaded with Types to include
      * @param p The output stream.
      */
     protected void writeInheritedIncludes(
                                           Hashtable inhHash,
                                  IndentingWriter p )
         throws IOException {
         Enumeration inhEnum = inhHash.elements();
         while ( inhEnum.hasMoreElements() ) {
             CompoundType t = (CompoundType)inhEnum.nextElement();
             writeInclude( t,0,!isThrown,p );
         }
     }
     /**
      * Write a #include.
      * @param t Type to include
      * @param dim The dimension to write if t is an array.
      * @param isThrown boolean indicating if include is for thrown exception.
      * @param p The output stream.
      */
     protected void writeInclude(
                                 Type t,
                                 int dim,
                                 boolean isThrown,
                                   IndentingWriter p)
         throws IOException {
         CompoundType ct;
         String tName;
         String[] modNames;
         if ( t.isCompound() ) {
             ct = (CompoundType)t;
             String qName = ct.getQualifiedName();
             if ( "java.lang.String".equals( qName ) ) {
                 writeIncOrb( p );                         //#include orb.idl for String
                 return;
             }
             if ( "org.omg.CORBA.Object".equals( qName ) )
                 return;                                 //Object treated like primitive
             modNames = getIDLModuleNames( ct );                   //module name array
             tName = unEsc( ct.getIDLName() );                     //file name default
             if ( ct.isException() )
                 if ( ct.isIDLEntityException() )
                     if ( ct.isCORBAUserException() )
                         if ( isThrown ) tName = unEsc( ct.getIDLExceptionName() );
                         else ;
                     else tName = ct.getName();                    //use original IDL name
                 else if ( isThrown )
                     tName = unEsc( ct.getIDLExceptionName() );
             }
         else if ( t.isArray() ) {
             Type et = t.getElementType();                    //file name for sequence
             if ( dim > 0 ) {
                 modNames = getIDLModuleNames( t );                  //module name array
                 tName = "seq" + dim + "_" + unEsc( et.getIDLName().replace( ' ','_' ) );
             }
             else{                                                  //#include element
                 if ( !et.isCompound() ) return;       //no include needed for primitive
                 ct = (CompoundType) et;
                 modNames = getIDLModuleNames( ct );           //no boxedRMI for element
                 tName = unEsc( ct.getIDLName() );
                 writeInclude( ct,modNames,tName,p );
                 return;
             }
         }
         else return;                              //no include needed for primitive
         writeInclude( t,modNames,tName,p );
     }
     /**
      * Write a #include doing user specified -idlFile translation (if any) for
      * IDLEntities.
      * @param t Type to include.
      * @param modNames Preprocessed module names (default).
      * @param tName Preprocessed Type name (default).
      * @param p The output stream.
      */
     protected void writeInclude(
                                 Type t,
                                 String[] modNames,
                                 String tName,
                                 IndentingWriter p)
         throws IOException {
         if ( t.isCompound() ) {
             CompoundType it = (CompoundType)t;
             if ( ifHash.size() > 0 &&             //any -idlFile translation to apply
                  it.isIDLEntity() ) {                         //..for this IDLEntity?
                 String qName = t.getQualifiedName();   //fully qualified orig Java name
                 Enumeration k = ifHash.keys();
                 while ( k.hasMoreElements() ) {      //loop thro user-defined -idlFiles
                     String from = (String)k.nextElement();
                     if ( qName.startsWith( from ) ) {                    //found a match?
                         String to = (String)ifHash.get( from );
                         p.pln( "#include \"" + to + "\"" );   //user-specified idl filename
                         return;                                   //don't look for any more
                     }
                 }
             }
         }
         else if ( t.isArray() ) ;        //no -idlFile translation needed for array
         else return;                             //no #include needed for primitive
         p.p( "#include \"" );                    //no -idlFile translation required
         for ( int i1 = 0; i1 < modNames.length; i1++ ) p.p( modNames[i1] + "/" );
         p.p( tName + ".idl\"" );
         p.pln();
     }
     /**
      * Return the fully qualified Java Name for a Type.
      * IDLEntity preprocessing done by getIDLModuleNames(t)
      * @param t Given Type
      * @return Array containing the original module nesting.
      */
     protected String getQualifiedName(
                                       Type t ) {
         String[] modNames = getIDLModuleNames( t );
         int len = modNames.length;
         StringBuffer buf = new StringBuffer();
         for ( int i1 = 0; i1 < len; i1++ )
             buf.append( modNames[i1] + "." );
         buf.append( t.getIDLName() );
         return buf.toString();
     }
     /**
      * Return the global fully qualified IDL Name for a Type.
      * IDLEntity preprocessing done by getIDLModuleNames(t)
      * @param t Given Type
      * @return Array containing the original module nesting.
      */
     protected String getQualifiedIDLName(Type t) {
         if ( t.isPrimitive() )
             return t.getIDLName();
         if ( !t.isArray() &&
              "org.omg.CORBA.Object".equals( t.getQualifiedName() ) )
             return t.getIDLName();
         String[] modNames = getIDLModuleNames( t );
         int len = modNames.length;
         if (len > 0) {
             StringBuffer buf = new StringBuffer();
             for ( int i1 = 0; i1 < len; i1++ )
                 buf.append( IDL_NAME_SEPARATOR + modNames[i1] );
             buf.append( IDL_NAME_SEPARATOR + t.getIDLName() );
             return buf.toString();
         } else {
             return t.getIDLName();
         }
     }
     /**
      * Return the IDL module nesting of the given Type.
      * For IDLEntity CompoundTypes (or their arrays) apply any user specified
      * -idlModule translation or, if none applicable, strip any package
      * prefix.
      * Add boxedIDL or boxedRMI modules if required.
      * @param t Given Type
      * @return Array containing the original module nesting.
      */
     protected String[] getIDLModuleNames(Type t) {
         String[] modNames = t.getIDLModuleNames();      //default module name array
         CompoundType ct;
         if ( t.isCompound() ) {
             ct = (CompoundType)t;
             if ( !ct.isIDLEntity ) return modNames;     //normal (non-IDLEntity) case
             if ( "org.omg.CORBA.portable.IDLEntity"
                  .equals( t.getQualifiedName() ) )
                 return modNames;
         }
         else if ( t.isArray() ) {
             Type et = t.getElementType();
             if ( et.isCompound() ) {
                 ct = (CompoundType)et;
                 if ( !ct.isIDLEntity ) return modNames;   //normal (non-IDLEntity) case
                 if ( "org.omg.CORBA.portable.IDLEntity"
                      .equals( t.getQualifiedName() ) )
                     return modNames;
             }
             else return modNames;
         }
         else return modNames;              //no preprocessing needed for primitives
         //it's an IDLEntity or an array of...
         Vector mVec = new Vector();
         if ( !translateJavaPackage( ct,mVec ) )      //apply -idlModule translation
             stripJavaPackage( ct,mVec );             //..or strip prefixes (not both)
         if ( ct.isBoxed() ) {                            //add boxedIDL if required
             mVec.insertElementAt( "org",0 );
             mVec.insertElementAt( "omg",1 );
             mVec.insertElementAt( "boxedIDL",2 );
         }
         if ( t.isArray() ) {                             //add boxedRMI if required
             mVec.insertElementAt( "org",0 );
             mVec.insertElementAt( "omg",1 );
             mVec.insertElementAt( "boxedRMI",2 );
         }
         String[] outArr = new String[mVec.size()];
         mVec.copyInto( outArr );
         return outArr;
     }
     /**
      * Apply user specified -idlModule translation to package names of given
      * IDLEntity ct. Example:
      *   -idlModule foo.bar real::mod::nesting
      * @param ct CompoundType containing given IDLEntity.
      * @param vec Returned Vector of translated IDL module names.
      * @return boolean true if any translation was done.
      */
     protected boolean translateJavaPackage(
                                            CompoundType ct,
                                            Vector vec ) {
         vec.removeAllElements();
         boolean ret = false;
         String fc = null;
         if ( ! ct.isIDLEntity() ) return ret;
         String pName = ct.getPackageName();         //start from Java package names
         if ( pName == null ) return ret;
         StringTokenizer pt = new StringTokenizer( pName,"." );
         while ( pt.hasMoreTokens() ) vec.addElement( pt.nextToken() );
         if ( imHash.size() > 0 ) {           //any -idlModule translation to apply?
             Enumeration k = imHash.keys();
         nextModule:
             while ( k.hasMoreElements() ) {      //loop thro user-defined -idlModules
                 String from = (String)k.nextElement();                  //from String..
                 StringTokenizer ft = new StringTokenizer( from,"." );
                 int vecLen = vec.size();
                 int ifr;
                 for ( ifr = 0; ifr < vecLen && ft.hasMoreTokens(); ifr++ )
                     if ( ! vec.elementAt(ifr).equals( ft.nextToken() ) )
                         continue nextModule;                                  //..no match
                 if ( ft.hasMoreTokens() ) {                          //matched so far..
                     fc = ft.nextToken();                         //a 'from' token remains
                     if ( ! ct.getName().equals( fc ) ||             //matches class name?
                          ft.hasMoreTokens() )
                         continue nextModule;                                   //..no match
                 }
                 ret = true;                                             //found a match
                 for ( int i4 = 0; i4 < ifr; i4++ )
                     vec.removeElementAt( 0 );                     //remove 'from' package
                 String to = (String)imHash.get( from );                   //..to String
                 StringTokenizer tt = new StringTokenizer( to,IDL_NAME_SEPARATOR );
                 int itoco = tt.countTokens();
                 int ito = 0;
                 if ( fc != null ) itoco--;               //user may have given IDL type
                 for ( ito = 0; ito < itoco; ito++ )
                     vec.insertElementAt( tt.nextToken(),ito );      //insert 'to' modules
                 if ( fc != null ) {
                     String tc = tt.nextToken();
                     if ( ! ct.getName().equals( tc ) )           //not the IDL type, so..
                         vec.insertElementAt( tc,ito );           //insert final 'to' module
                 }
             }
         }
         return ret;
     }
     /**
      * Strip Java #pragma prefix and/or -pkgPrefix prefix package names from
      * given IDLEntity ct.
      * Strip any package prefix which may have been added by comparing with
      * repository id. For example in Java package fake.omega:
      *   repid = IDL:phoney.pfix/omega/Juliet:1.0 gives { "omega" }
      * @param ct CompoundType containing given IDLEntity.
      * @param vec Returned Vector of stripped IDL module names.
      */
     protected void stripJavaPackage(
                                     CompoundType ct,
                                     Vector vec ) {
         vec.removeAllElements();
         if ( ! ct.isIDLEntity() ) return;
         String repID = ct.getRepositoryID().substring( 4 );
         StringTokenizer rept = new StringTokenizer( repID,"/" );
         if ( rept.countTokens() < 2 ) return;
         while ( rept.hasMoreTokens() )
             vec.addElement( rept.nextToken() );
         vec.removeElementAt( vec.size() - 1 );
         String pName = ct.getPackageName();         //start from Java package names
         if ( pName == null ) return;
         Vector pVec = new Vector();
         StringTokenizer pt = new StringTokenizer( pName,"." );
         while ( pt.hasMoreTokens() ) pVec.addElement( pt.nextToken() );
         int i1 = vec.size() - 1;
         int i2 = pVec.size() - 1;
         while ( i1 >= 0 && i2 >= 0 ) {                      //go R->L till mismatch
             String rep = (String)( vec.elementAt( i1 ) );
             String pkg = (String)( pVec.elementAt( i2 ) );
             if ( ! pkg.equals( rep ) ) break;
             i1--; i2--;
         }
         for ( int i3 = 0; i3 <= i1; i3++ )
             vec.removeElementAt( 0 );                                  //strip prefix
     }
     /**
      * Write boxedRMI valuetype for a single dimension of an IDL sequence
      * indicated by the given OutputType.
      * The filename for the OutputType is of the form "seqn_elemName" where n
      * is the dimension required.
      * @param ot Given OutputType.
      * @param p The output stream.
      */
     protected void writeSequence(
                                  OutputType ot,
                                  IndentingWriter p)
         throws IOException {
         ArrayType at = (ArrayType)ot.getType();
         Type et = at.getElementType();
         String fName = ot.getName();
         int dim = Integer.parseInt( fName.substring( 3,fName.indexOf( "_" ) ) );
         String idlName = unEsc( et.getIDLName() ).replace( ' ','_' );
         String qIdlName = getQualifiedIDLName( et );
         String qName = et.getQualifiedName();
         String repID = at.getRepositoryID();
         int rix1 = repID.indexOf( '[' );                       //edit repository id
         int rix2 = repID.lastIndexOf( '[' ) + 1;
             StringBuffer rid = new StringBuffer(
                                             repID.substring( 0,rix1 ) +
                                             repID.substring( rix2 ) );
         for ( int i1 = 0; i1 < dim; i1++ ) rid.insert( rix1,'[' );
         String vtName = "seq" + dim + "_" + idlName;
         boolean isFromIDL = false;
         if ( et.isCompound() ) {
             CompoundType ct = (CompoundType)et;
             isFromIDL = ct.isIDLEntity() || ct.isCORBAObject();
         }
         boolean isForwardInclude =
             et.isCompound() &&
             !isSpecialReference( et ) &&
             dim == 1 &&
             !isFromIDL &&
             !"org.omg.CORBA.Object".equals(qName) &&
             !"java.lang.String".equals(qName);
         writeBanner( at,dim,!isException,p );
         if ( dim == 1 && "java.lang.String".equals(qName) )          //special case
             writeIncOrb( p );
         if ( dim == 1 && "org.omg.CORBA.Object".equals(qName) ) ;
         else if ( isSpecialReference( et ) || dim > 1 || isFromIDL )
             writeInclude( at,dim-1,!isThrown,p );               //"trivial" include
         writeIfndef( at,dim,!isException,!isForward,p );
         if ( isForwardInclude )
             writeForwardReference( at,dim-1,p );                    //forward declare
         writeModule1( at,p );
                 p.pln();p.pI();
                 p.p( "valuetype " + vtName );
                 p.p( " sequence<" );
         if ( dim == 1 ) p.p( qIdlName );
                 else {
             p.p( "seq" + ( dim - 1 ) + "_"  );
                     p.p( idlName );
                 }
                 p.pln( ">;" );
                 p.pO();p.pln();
                 p.pln( "#pragma ID " + vtName + " \"" + rid + "\"" );
                 p.pln();
         writeModule2( at,p );
         if ( isForwardInclude )
             writeInclude( at,dim-1,!isThrown,p );      //#include for forward declare
                 writeEndif( p );
             }
     /**
      * Write valuetype for a boxed IDLEntity.
      * @param t Given CompoundType representing the IDLEntity.
      * @param p The output stream.
      */
     protected void writeBoxedIDL(
                                  CompoundType t,
                                  IndentingWriter p)
         throws IOException {
         String[] boxNames = getIDLModuleNames( t );
         int len = boxNames.length;
         String[] modNames = new String[len - 3];               //remove box modules
         for ( int i1 = 0; i1 < len - 3; i1++ ) modNames[i1] = boxNames[i1 + 3];
         String tName = unEsc( t.getIDLName() );
         writeBanner( t,0,!isException,p );
         writeInclude( t,modNames,tName,p );
         writeIfndef( t,0,!isException,!isForward,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.p( "valuetype " + tName + " " );
         for ( int i1 = 0; i1 < modNames.length; i1++ )
             p.p( IDL_NAME_SEPARATOR + modNames[i1] );
         p.pln( IDL_NAME_SEPARATOR + tName + ";" );
         p.pO();p.pln();
         writeRepositoryID( t,p );
         p.pln();
         writeModule2( t,p );
         writeEndif( p );
         }
     /**
      * Write an exception.
      * @param t Given ClassType representing the exception.
      * @param p The output stream.
      */
     protected void writeException(
                                   ClassType t,
                                   IndentingWriter p)
         throws IOException {
         writeBanner( t,0,isException,p );
         writeIfndef( t,0,isException,!isForward,p );
         writeForwardReference( t,p );
         writeModule1( t,p );
         p.pln();p.pI();
         p.pln( "exception " + t.getIDLExceptionName() + " {" );
         p.pln();p.pI();
         p.pln( t.getIDLName() + " value;" );
         p.pO();p.pln();
         p.pln( "};" );
         p.pO();p.pln();
         writeModule2( t,p );
         writeInclude( t,0,!isThrown,p );               //include valuetype idl file
         writeEndif( p );
     }
     /**
      * Write #pragma to identify the repository ID of the given type
      * @param t The given Type.
      * @param p The output stream.
      */
     protected void writeRepositoryID(
                                      Type t,
                                      IndentingWriter p )
         throws IOException {
         String repid = t.getRepositoryID();
         if ( t.isCompound() ) {
             CompoundType ct = (CompoundType)t;
             if ( ct.isBoxed() )
                 repid = ct.getBoxedRepositoryID();
         }
         p.pln( "#pragma ID " + t.getIDLName() + " \"" +
                repid + "\"" );
     }
     /**
      * Write inheritance for an IDL interface or valuetype. Any class
      * inheritance precedes any interface inheritance.
      * For a valutype any inheritance from abstract interfaces then
      * follows the "supports" keyword.
      * @param inhHash Hashtable loaded with inherited Types
      * @param forValuetype true if writing inheritance for a valuetype
      * @param p The output stream.
      */
     protected void writeInherits(
                                  Hashtable inhHash,
                                  boolean forValuetype,
                                  IndentingWriter p )
         throws IOException {
         int itot = inhHash.size();
         int iinh = 0;
         int isup = 0;
         if ( itot < 1 ) return;                         //any inheritance to write?
         Enumeration inhEnum = inhHash.elements();
         CompoundType ct;
         if ( forValuetype )
             while ( inhEnum.hasMoreElements() ) {
                 ct = (CompoundType)inhEnum.nextElement();
                 if ( ct.getTypeCode() == TYPE_ABSTRACT ) isup++;
             }
         iinh = itot - isup;
         if ( iinh > 0 ) {
         p.p( ": " );
             inhEnum = inhHash.elements();
         while ( inhEnum.hasMoreElements() ) {         //write any class inheritance
                 ct = (CompoundType)inhEnum.nextElement();
                 if ( ct.isClass() ) {
                     p.p( getQualifiedIDLName( ct ) );
                     if ( iinh > 1 ) p.p( ", " );               //delimit them with commas
                     else if ( itot > 1 ) p.p( " " );
                 break;                                                //only one parent
             }
         }
             int i = 0;
         inhEnum = inhHash.elements();
         while ( inhEnum.hasMoreElements() ) {     //write any interface inheritance
                 ct = (CompoundType)inhEnum.nextElement();
                 if ( !ct.isClass() &&
                      !( ct.getTypeCode() == TYPE_ABSTRACT ) ) {
                     if ( i++ > 0 ) p.p( ", " );                     //delimit with commas
                     p.p( getQualifiedIDLName( ct ) );
             }
         }
     }
         if ( isup > 0 ) {                    //write abstract interface inheritance
             p.p( " supports " );
             int i = 0;
             inhEnum = inhHash.elements();
             while ( inhEnum.hasMoreElements() ) {
                 ct = (CompoundType)inhEnum.nextElement();
                 if ( ct.getTypeCode() == TYPE_ABSTRACT ) {
                     if ( i++ > 0 ) p.p( ", " );                     //delimit with commas
                     p.p( getQualifiedIDLName( ct ) );
                 }
             }
         }
     }
     /**
      * Write an IDL constant
      * @param constant The current CompoundType.Member constant
      * @param p The output stream.
      */
     protected void writeConstant(
                                  CompoundType.Member constant,
                                  IndentingWriter p )
         throws IOException {
         Type t = constant.getType();
         p.p( "const " );
         p.p( getQualifiedIDLName( t ) );
         p.p( " " + constant.getIDLName() + " = " + constant.getValue() );
         p.pln( ";" );
     }
     /**
      * Write an IDL data member
      * @param data The current CompoundType.Member data member
      * @param p The output stream.
      */
     protected void writeData(
                              CompoundType.Member data,
                              IndentingWriter p )
         throws IOException {
         if ( data.isInnerClassDeclaration() ) return;                      //ignore
         Type t = data.getType();
         if ( data.isPublic() )
             p.p( "public " );
         else p.p( "private " );
         p.pln( getQualifiedIDLName( t ) +  " " +
                data.getIDLName() + ";" );
     }
     /**
      * Write an IDL Attribute
      * @param attr The current CompoundType.Method attribute
      * @param p The output stream.
      */
     protected void writeAttribute(
                                   CompoundType.Method attr,
                                   IndentingWriter p )
         throws IOException {
         if ( attr.getAttributeKind() == ATTRIBUTE_SET ) return;  //use getters only
         Type t = attr.getReturnType();
         if ( !attr.isReadWriteAttribute() ) p.p( "readonly " );
         p.p( "attribute " + getQualifiedIDLName( t ) + " " );
         p.pln( attr.getAttributeName() + ";" );
     }
     /**
      * Write an IDL method
      * @param method The current CompoundType.Method
      * @param p The output stream.
      */
     protected void writeMethod(
                                CompoundType.Method method,
                                IndentingWriter p )
         throws IOException {
         if ( method.isAttribute() ) {
             writeAttribute( method,p );
             return;
         }
         Type[]    pts = method.getArguments();
         String[]  paramNames = method.getArgumentNames();
         Type      rt = method.getReturnType();
         Hashtable excHash = new Hashtable();
         getExceptions( method,excHash );
         if ( method.isConstructor() )
             if ( factory ) p.p( "factory " + method.getIDLName() + "(" );
             else p.p( "init(" );                                    //IDL initializer
         else {
             p.p( getQualifiedIDLName( rt ) );
             p.p( " " + method.getIDLName() + "(" );
         }
         p.pI();
         for ( int i=0; i < pts.length; i++ ) {
             if ( i > 0 ) p.pln( "," );               //delimit with comma and newline
             else p.pln();
             p.p( "in " );
             p.p( getQualifiedIDLName( pts[i] ) );
             p.p( " " + paramNames[i] );
         }
         p.pO();
         p.p( " )" );
         if ( excHash.size() > 0 ) {                      //any exceptions to write?
             p.pln( " raises (" );
             p.pI();
             int i = 0;
             Enumeration excEnum = excHash.elements();
             while ( excEnum.hasMoreElements() ) {
                 ValueType exc = (ValueType)excEnum.nextElement();
                 if ( i > 0 ) p.pln( "," );                   //delimit them with commas
                 if ( exc.isIDLEntityException() )
                     if ( exc.isCORBAUserException() )
                         p.p( "::org::omg::CORBA::UserEx" );
                     else {
                         String[] modNames = getIDLModuleNames( exc );
                         for ( int i2 = 0; i2 < modNames.length; i2++ )
                             p.p( IDL_NAME_SEPARATOR + modNames[i2] );
                         p.p( IDL_NAME_SEPARATOR + exc.getName() );
                     }
                 else p.p( exc.getQualifiedIDLExceptionName( true ) );
                 i++;
             }
             p.pO();
             p.p( " )" );
         }
         p.pln( ";" );
     }
     /**
      * Remove escape character ("_"), if any, from given String
      * @param name Given String
      * @return String with any escape character removed
      */
     protected String unEsc(
                            String name ) {
         if ( name.startsWith( "_" ) ) return name.substring( 1 );
         else return name;
     }
     /**
      * Write IDL banner into the output stream for a given Type
      * @param t The given Type.
      * @param dim The dimension required if t is an ArrayType.
      * @param isException true if writing an exception.
      * @param p The output stream.
      */
     protected void writeBanner(
                                Type t,
                                int dim,
                                boolean isException,
                                IndentingWriter p )
         throws IOException {
         String[] modNames = getIDLModuleNames( t );             //module name array
         String fName = unEsc( t.getIDLName() );                 //file name default
         if ( isException && t.isClass() ) {
             ClassType ct = (ClassType)t;                    //file name for Exception
             fName = unEsc( ct.getIDLExceptionName() );
         }
         if ( dim > 0 && t.isArray() ) {
             Type et = t.getElementType();                    //file name for sequence
             fName = "seq" + dim + "_" + unEsc( et.getIDLName().replace( ' ','_' ) );
         }
         p.pln( "/**" );
         p.p( " * " );
         for ( int i1 = 0; i1 < modNames.length; i1++ )
             p.p( modNames[i1] + "/" );
         p.pln( fName + ".idl" );
         p.pln( " * Generated by rmic -idl. Do not edit" );
         String d = DateFormat.getDateTimeInstance(
                                                   DateFormat.FULL,DateFormat.FULL,Locale.getDefault() )
             .format( new Date() );
         String ocStr = "o'clock";
         int ocx = d.indexOf( ocStr );             //remove unwanted o'clock, if any
         p.p ( " * " );
         if ( ocx > -1 )
             p.pln( d.substring( 0,ocx ) + d.substring( ocx + ocStr.length() ) );
         else p.pln( d );
         p.pln( " */" );
         p.pln();
     }
     /**
      * Write #include for orb.idl
      * @param p The output stream.
      */
     protected void writeIncOrb(
                                IndentingWriter p )
         throws IOException {
         p.pln( "#include \"orb.idl\"" );
     }
     /**
      * Write #ifndef guard into the output stream for a given Type
      * @param t The given Type.
      * @param dim The dimension required if t is an ArrayType.
      * @param isException true if writing an exception.
      * @param isForward. No #define needed if it's a forward declare
      * @param p The output stream.
      */
     protected void writeIfndef(
                                Type t,
                                int dim,
                                boolean isException,
                                boolean isForward,
                                IndentingWriter p )
         throws IOException {
         String[] modNames = getIDLModuleNames( t );             //module name array
         String fName = unEsc( t.getIDLName() );                 //file name default
         if ( isException && t.isClass() ) {
             ClassType ct = (ClassType)t;                    //file name for Exception
             fName = unEsc( ct.getIDLExceptionName() );
         }
         if ( dim > 0 && t.isArray() ) {
             Type et = t.getElementType();                    //file name for sequence
             fName = "seq" + dim + "_" + unEsc( et.getIDLName().replace( ' ','_' ) );
         }
         p.pln();
         p.p( "#ifndef __" );
         for ( int i = 0; i < modNames.length; i++ ) p.p( modNames[i] + "_" );
         p.pln( fName + "__" );
         if ( !isForward ) {
         p.p( "#define __" );
         for ( int i = 0; i < modNames.length; i++ ) p.p( modNames[i] + "_" );
             p.pln( fName + "__" );
             p.pln();
     }
     }
     /**
      * Write #endif bracket into the output stream
      * @param p The output stream.
      */
     protected void writeEndif(
                               IndentingWriter p )
         throws IOException {
         p.pln("#endif");
         p.pln();
     }
     /**
      * Write Module start bracketing for the given type into the output stream
      * @param t The given Type
      * @param p The output stream.
      */
     protected void writeModule1(
                                 Type t,
                                 IndentingWriter p )
         throws IOException {
         String[] modNames = getIDLModuleNames( t );
         p.pln();
         for ( int i = 0; i < modNames.length; i++ )
             p.pln( "module " + modNames[i] + " {" );
     }
     /**
      * Write Module end bracketing for the given type into the output stream
      * @param t The given Type
      * @param p The output stream.
      */
     protected void writeModule2(
                                 Type t,
                                 IndentingWriter p )
         throws IOException {
         String[] modNames = getIDLModuleNames( t );
         for ( int i=0; i < modNames.length; i++ ) p.pln( "};" );
         p.pln();
     }
 }

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/sun/rmi/rmic/iiop/IDLGenerator.java@6845b95cba6b (annotated)

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