2085 lines
80 KiB
Java
2085 lines
80 KiB
Java
/*
|
|
* 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();
|
|
}
|
|
|
|
}
|