Mercurial > jdk8-mips64-public > corba / file revision

 /*

  * 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();

     }

 }