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