IDLGenerator.java revision 608:7e06bf1dcb09
1362181Sdim/* 2362181Sdim * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved. 3362181Sdim * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4362181Sdim * 5362181Sdim * This code is free software; you can redistribute it and/or modify it 6362181Sdim * under the terms of the GNU General Public License version 2 only, as 7362181Sdim * published by the Free Software Foundation. Oracle designates this 8362181Sdim * particular file as subject to the "Classpath" exception as provided 9251877Speter * by Oracle in the LICENSE file that accompanied this code. 10362181Sdim * 11251877Speter * This code is distributed in the hope that it will be useful, but WITHOUT 12362181Sdim * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13362181Sdim * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14362181Sdim * version 2 for more details (a copy is included in the LICENSE file that 15362181Sdim * accompanied this code). 16362181Sdim * 17362181Sdim * You should have received a copy of the GNU General Public License version 18362181Sdim * 2 along with this work; if not, write to the Free Software Foundation, 19251877Speter * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20251877Speter * 21251877Speter * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22251877Speter * or visit www.oracle.com if you need additional information or have any 23251877Speter * questions. 24251877Speter */ 25251877Speter/* 26251877Speter * Licensed Materials - Property of IBM 27251877Speter * RMI-IIOP v1.0 28251877Speter * Copyright IBM Corp. 1998 1999 All Rights Reserved 29251877Speter * 30251877Speter */ 31251877Speter 32251877Speterpackage sun.rmi.rmic.iiop; 33251877Speter 34251877Speterimport java.io.File; 35251877Speterimport java.io.IOException; 36251877Speterimport java.text.DateFormat; 37251877Speterimport java.util.Date; 38251877Speterimport java.util.Enumeration; 39251877Speterimport java.util.Hashtable; 40251877Speterimport java.util.Locale; 41251877Speterimport java.util.StringTokenizer; 42251877Speterimport java.util.Vector; 43251877Speterimport sun.tools.java.Identifier; 44251877Speterimport sun.tools.java.ClassDefinition; 45251877Speterimport sun.tools.java.CompilerError; 46251877Speterimport sun.rmi.rmic.IndentingWriter; 47251877Speterimport java.util.HashSet; 48251877Speterimport sun.rmi.rmic.Main; 49251877Speter 50251877Speter/** 51251877Speter * An IDL generator for rmic. 52251877Speter * 53251877Speter * @author Steve Newberry, Bryan Atsatt 54251877Speter */ 55251877Speterpublic class IDLGenerator extends sun.rmi.rmic.iiop.Generator { 56251877Speter 57251877Speter private boolean valueMethods = true; 58251877Speter private boolean factory = true; //init==!factory 59251877Speter private Hashtable ifHash = new Hashtable(); //IDL file Hashtable 60251877Speter private Hashtable imHash = new Hashtable(); //IDL module Hashtable 61251877Speter 62251877Speter private boolean isThrown = true; //flag for writeInclude 63251877Speter private boolean isException = true; //flag for writeBanner, writeIfndef 64251877Speter private boolean isForward = true; //flag for writeIfndef 65251877Speter private boolean forValuetype = true; //flag for writeInherits 66251877Speter 67253895Speter /** 68251877Speter * Default constructor for Main to use. 69251877Speter */ 70251877Speter public IDLGenerator() { 71251877Speter } 72251877Speter 73253895Speter 74251877Speter /** 75251877Speter * Return true if a new instance should be created for each 76251877Speter * class on the command line. Subclasses which return true 77253895Speter * should override newInstance() to return an appropriately 78251877Speter * constructed instance. 79251877Speter */ 80251877Speter protected boolean requireNewInstance() { 81251877Speter return false; 82253895Speter } 83251877Speter 84251877Speter /** 85253895Speter * Return true if non-conforming types should be parsed. 86251877Speter * @param stack The context stack. 87251877Speter */ 88253895Speter protected boolean parseNonConforming(ContextStack stack) { 89251877Speter return valueMethods; 90253895Speter } 91251877Speter 92253895Speter /** 93251877Speter * Create and return a top-level type. 94253895Speter * @param env The compiler environment. 95251877Speter * @param cdef The top-level class definition. 96251877Speter * @return An RemoteType or null if is non-conforming. 97253895Speter */ 98251877Speter protected sun.rmi.rmic.iiop.CompoundType getTopType(ClassDefinition cdef, 99251877Speter ContextStack stack) { 100253895Speter return CompoundType.forCompound(cdef,stack); 101251877Speter } 102251877Speter 103253895Speter 104251877Speter /** 105251877Speter * Return an Identifier which contains the fully-qualified IDL filename 106253895Speter * for the given OutputType. 107251877Speter * The OutputType contains a filename string (not directory) and Type. 108251877Speter * @param ot the OutputType for which directory nesting is to be defined. 109253895Speter * @return the new identifier. 110251877Speter */ 111251877Speter protected Identifier getOutputId ( 112253895Speter OutputType ot ) { 113251877Speter Identifier id = super.getOutputId( ot ); 114253895Speter 115253895Speter Type t = ot.getType(); 116253895Speter String fName = ot.getName(); 117251877Speter 118251877Speter if ( id == idJavaLangClass ) //java.lang.Class and array of 119251877Speter if ( t.isArray() ) 120251877Speter return Identifier.lookup( 121251877Speter "org.omg.boxedRMI.javax.rmi.CORBA." + fName ); 122251877Speter else return idClassDesc; 123251877Speter 124251877Speter if ( id == idJavaLangString && //array of java.lang.String 125251877Speter t.isArray() ) 126251877Speter return Identifier.lookup( "org.omg.boxedRMI.CORBA." + fName ); 127251877Speter 128251877Speter if ( "org.omg.CORBA.Object".equals( t.getQualifiedName() ) && 129251877Speter t.isArray() ) //array of org.omg.CORBA.Object 130251877Speter return Identifier.lookup( "org.omg.boxedRMI." + fName ); 131251877Speter 132251877Speter if ( t.isArray()) { //array 133251877Speter ArrayType at = (ArrayType)t; 134251877Speter Type et = at.getElementType(); 135251877Speter if ( et.isCompound() ) { 136251877Speter CompoundType ct = (CompoundType)et; 137251877Speter String qName = ct.getQualifiedName(); 138251877Speter if ( ct.isIDLEntity() ) 139251877Speter return Identifier.lookup( getQualifiedName( at ) ); 140251877Speter } 141251877Speter return Identifier.lookup( idBoxedRMI,id ); 142251877Speter } 143251877Speter 144251877Speter if ( t.isCompound() ) { //boxed IDLEntity 145251877Speter CompoundType ct = (CompoundType)t; 146251877Speter String qName = ct.getQualifiedName(); 147251877Speter if ( ct.isBoxed() ) 148251877Speter return Identifier.lookup( getQualifiedName( ct ) ); 149251877Speter } 150251877Speter 151251877Speter return id; 152251877Speter } 153251877Speter 154251877Speter 155251877Speter 156251877Speter /** 157251877Speter * Return the file name extension for the given file name (e.g. ".java"). 158251877Speter * All files generated with the ".java" extension will be compiled. To 159251877Speter * change this behavior for ".java" files, override the compileJavaSourceFile 160251877Speter * method to return false. 161251877Speter * @param outputType One of the items returned by getOutputTypesFor(...) 162251877Speter */ 163251877Speter protected String getFileNameExtensionFor(OutputType outputType) { 164251877Speter return IDL_FILE_EXTENSION; 165251877Speter } 166251877Speter 167251877Speter 168251877Speter /** 169251877Speter * Examine and consume command line arguments. 170251877Speter * @param argv The command line arguments. Ignore null 171251877Speter * and unknown arguments. Set each consumed argument to null. 172251877Speter * @param error Report any errors using the main.error() methods. 173251877Speter * @return true if no errors, false otherwise. 174251877Speter */ 175251877Speter public boolean parseArgs(String argv[], Main main) { 176251877Speter boolean result = super.parseArgs(argv,main); 177251877Speter String idlFrom; 178251877Speter String idlTo; 179251877Speter if (result) { 180251877Speter nextArg: 181251877Speter for (int i = 0; i < argv.length; i++) { 182251877Speter if (argv[i] != null) { 183251877Speter if (argv[i].equalsIgnoreCase("-idl")) { 184251877Speter idl = true; 185251877Speter argv[i] = null; 186251877Speter } 187251877Speter else if ( argv[i].equalsIgnoreCase( "-valueMethods" ) ) { 188251877Speter valueMethods = true; 189251877Speter argv[i] = null; 190251877Speter } 191251877Speter else if ( argv[i].equalsIgnoreCase( "-noValueMethods" ) ) { 192251877Speter valueMethods = false; 193251877Speter argv[i] = null; 194251877Speter } 195251877Speter else if ( argv[i].equalsIgnoreCase( "-init" ) ) { 196251877Speter factory = false; 197251877Speter argv[i] = null; 198251877Speter } 199251877Speter else if ( argv[i].equalsIgnoreCase( "-factory" ) ) { 200251877Speter factory = true; 201251877Speter argv[i] = null; 202251877Speter } 203251877Speter else if ( argv[i].equalsIgnoreCase( "-idlfile" ) ) { 204251877Speter argv[i] = null; 205251877Speter if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { 206251877Speter idlFrom = argv[i]; 207251877Speter argv[i] = null; 208251877Speter if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { 209251877Speter idlTo = argv[i]; 210251877Speter argv[i] = null; 211251877Speter ifHash.put( idlFrom,idlTo ); 212251877Speter continue nextArg; 213251877Speter } 214251877Speter } 215251877Speter main.error("rmic.option.requires.argument", "-idlfile"); 216251877Speter result = false; 217251877Speter } 218251877Speter else if ( argv[i].equalsIgnoreCase( "-idlmodule" ) ) { 219251877Speter argv[i] = null; 220251877Speter if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { 221251877Speter idlFrom = argv[i]; 222251877Speter argv[i] = null; 223251877Speter if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { 224251877Speter idlTo = argv[i]; 225251877Speter argv[i] = null; 226251877Speter imHash.put( idlFrom,idlTo ); 227251877Speter continue nextArg; 228251877Speter } 229251877Speter } 230251877Speter main.error("rmic.option.requires.argument", "-idlmodule"); 231251877Speter result = false; 232251877Speter } 233251877Speter 234251877Speter 235251877Speter } 236251877Speter } 237251877Speter } 238251877Speter return result; 239251877Speter } 240251877Speter 241251877Speter 242251877Speter 243251877Speter /** 244251877Speter * Return an array of OutputTypes for the IDL files that need to be 245251877Speter * generated for the given top-level type. 246251877Speter * OutputTypes contain filename string (not directory) and Type. 247251877Speter * @param topType The type returned by getTopType(). 248251877Speter * @param alreadyChecked A set of Types which have already been checked. 249251877Speter * @return Array of OutputTypes to generate 250251877Speter */ 251251877Speter protected OutputType[] getOutputTypesFor( 252251877Speter CompoundType topType, 253251877Speter HashSet alreadyChecked ) { 254251877Speter Vector refVec = getAllReferencesFor( topType ); 255251877Speter Vector outVec = new Vector(); 256251877Speter for ( int i1 = 0; i1 < refVec.size(); i1++ ) { //forall references 257251877Speter Type t = (Type)refVec.elementAt( i1 ); 258251877Speter if ( t.isArray() ) { 259251877Speter ArrayType at = (ArrayType)t; 260251877Speter int dim = at.getArrayDimension(); 261251877Speter Type et = at.getElementType(); 262251877Speter String fName = unEsc( et.getIDLName() ).replace( ' ','_' ); 263251877Speter for ( int i2 = 0; i2 < dim; i2++ ) { //foreach dimension 264251877Speter String fileName = "seq" + ( i2 + 1 ) + "_" + fName; 265251877Speter outVec.addElement( new OutputType( fileName,at ) ); 266251877Speter } 267251877Speter } 268251877Speter else if ( t.isCompound() ) { 269251877Speter String fName = unEsc( t.getIDLName() ); 270251877Speter outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) ); 271251877Speter if ( t.isClass() ) { 272251877Speter ClassType ct = (ClassType)t; 273251877Speter if ( ct.isException() ) { //exception file 274251877Speter fName = unEsc( ct.getIDLExceptionName() ); 275251877Speter outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) ); 276251877Speter } 277251877Speter } 278251877Speter } 279251877Speter } 280251877Speter OutputType[] outArr = new OutputType[outVec.size()]; 281251877Speter outVec.copyInto( outArr ); 282251877Speter return outArr; 283251877Speter } 284251877Speter 285251877Speter /** 286251877Speter * Get all referenced types of a given tyoe for which an IDL file needs 287251877Speter * to be generated. 288251877Speter * @param ct The given type. 289251877Speter * @return Vector of Types for which IDL must be generated. 290251877Speter */ 291251877Speter protected Vector getAllReferencesFor( 292251877Speter CompoundType ct ) { 293251877Speter Hashtable refHash = new Hashtable(); 294251877Speter Hashtable spcHash = new Hashtable(); 295251877Speter Hashtable arrHash = new Hashtable(); 296251877Speter int refSize; 297251877Speter refHash.put( ct.getQualifiedName(),ct ); //put the given type 298251877Speter accumulateReferences( refHash,spcHash,arrHash ); 299251877Speter do { 300251877Speter refSize = refHash.size(); 301251877Speter accumulateReferences( refHash,spcHash,arrHash ); 302251877Speter } 303251877Speter while ( refSize < refHash.size() ); //till hashtable stays same size 304251877Speter 305251877Speter Vector outVec = new Vector(); 306251877Speter Enumeration e = refHash.elements(); //ordinary references 307251877Speter while ( e.hasMoreElements() ) { 308251877Speter CompoundType t = (CompoundType)e.nextElement(); 309251877Speter outVec.addElement( t ); 310251877Speter } 311251877Speter e = spcHash.elements(); //special references 312251877Speter while ( e.hasMoreElements() ) { 313251877Speter CompoundType t = (CompoundType)e.nextElement(); 314251877Speter outVec.addElement( t ); 315251877Speter } 316251877Speter e = arrHash.elements(); //array references 317251877Speter nextSequence: 318251877Speter while ( e.hasMoreElements() ) { 319251877Speter ArrayType at = (ArrayType)e.nextElement(); 320251877Speter int dim = at.getArrayDimension(); 321251877Speter Type et = at.getElementType(); 322251877Speter Enumeration e2 = arrHash.elements(); 323251877Speter while ( e2.hasMoreElements() ) { //eliminate duplicates 324251877Speter ArrayType at2 = (ArrayType)e2.nextElement(); 325251877Speter if ( et == at2.getElementType() && //same element type & 326251877Speter dim < at2.getArrayDimension() ) //smaller dimension? 327251877Speter continue nextSequence; //ignore this one 328251877Speter } 329251877Speter outVec.addElement( at ); 330251877Speter } 331251877Speter return outVec; 332251877Speter } 333251877Speter 334251877Speter 335251877Speter /** 336251877Speter * Accumulate and filter all those types that are referenced by the given 337251877Speter * referenced types. 338251877Speter * Keep only those for which IDL is to be generated. 339251877Speter * @param refHash Hashtable containing the given types 340251877Speter * @param spcHash Hashtable containing referenced specials (IDL typedefs) 341251877Speter * @param arrHash Hashtable containing referenced arrays (dimensioned) 342251877Speter */ 343251877Speter protected void accumulateReferences( 344251877Speter Hashtable refHash, 345251877Speter Hashtable spcHash, 346251877Speter Hashtable arrHash ) { 347251877Speter Enumeration e = refHash.elements(); 348251877Speter while ( e.hasMoreElements() ) { 349251877Speter CompoundType t = (CompoundType)e.nextElement(); 350251877Speter Vector datVec = getData( t ); //collect and sort data 351251877Speter Vector mthVec = getMethods( t ); //collect and filter methods 352251877Speter getInterfaces( t,refHash ); //collect interfaces 353251877Speter getInheritance( t,refHash ); //add inheritance 354251877Speter getMethodReferences( mthVec,refHash,spcHash,arrHash,refHash ); 355251877Speter getMemberReferences( datVec,refHash,spcHash,arrHash ); 356251877Speter } 357251877Speter e = arrHash.elements(); //add array element references 358251877Speter while ( e.hasMoreElements() ) { 359251877Speter ArrayType at = (ArrayType)e.nextElement(); 360251877Speter Type et = at.getElementType(); 361251877Speter addReference( et,refHash,spcHash,arrHash ); 362251877Speter } 363251877Speter e = refHash.elements(); 364251877Speter while ( e.hasMoreElements() ) { 365251877Speter CompoundType t = (CompoundType)e.nextElement(); 366251877Speter if ( !isIDLGeneratedFor( t ) ) //remove if no IDL generation 367251877Speter refHash.remove( t.getQualifiedName() ); 368251877Speter } 369251877Speter } 370251877Speter 371251877Speter 372251877Speter 373251877Speter /** 374251877Speter * Determine if IDL should be generated for a referenced type. 375251877Speter * Do not generate IDL for a CORBA Object reference. It gets mapped 376251877Speter * to the original IDL or to Object (if exactly org.omg.CORBA.Object) 377251877Speter * Generate (boxed) IDL for an IDL Entity unless it is an IDL user 378251877Speter * exception, a ValueBase, an AbstractBase (or a CORBA Object). 379251877Speter * Do not generate IDL for Implementation classes..unless they inherit 380251877Speter * from multiple distinct remote interfaces 381251877Speter * @param t The type to check. 382251877Speter * @return true or false 383251877Speter */ 384251877Speter protected boolean isIDLGeneratedFor( 385251877Speter CompoundType t ) { 386251877Speter if ( t.isCORBAObject() ) return false; 387251877Speter if ( t.isIDLEntity() ) 388251877Speter if ( t.isBoxed() ) return true; 389251877Speter else if ( "org.omg.CORBA.portable.IDLEntity" 390251877Speter .equals( t.getQualifiedName() ) ) return true; 391251877Speter else if ( t.isCORBAUserException() ) return true; 392251877Speter else return false; 393251877Speter Hashtable inhHash = new Hashtable(); 394251877Speter getInterfaces( t,inhHash ); 395251877Speter if ( t.getTypeCode() == TYPE_IMPLEMENTATION ) 396251877Speter if ( inhHash.size() < 2 ) return false; //no multiple inheritance 397251877Speter else return true; 398251877Speter return true; //generate IDL for this type 399251877Speter } 400251877Speter 401251877Speter 402251877Speter /** 403251877Speter * Write the output for the given OutputFileName into the output stream. 404251877Speter * (The IDL mapping for java.lang.Class is generated from 405251877Speter * javax.rmi.CORBA.ClassDesc in the tools workspace) 406251877Speter * @param OutputType ot One of the items returned by getOutputTypesFor(...) 407251877Speter * @param alreadyChecked A set of Types which have already been checked. 408251877Speter * Intended to be passed to Type.collectMatching(filter,alreadyChecked). 409251877Speter * @param p The output stream. 410251877Speter */ 411251877Speter protected void writeOutputFor( 412251877Speter OutputType ot, 413251877Speter HashSet alreadyChecked, 414251877Speter IndentingWriter p ) 415251877Speter throws IOException { 416251877Speter Type t = ot.getType(); 417251877Speter if ( t.isArray() ) { //specialcase: sequence 418251877Speter writeSequence( ot,p ); 419251877Speter return; 420251877Speter } 421251877Speter if ( isSpecialReference( t ) ) { //specialcase: IDL typecode 422251877Speter writeSpecial( t,p ); 423251877Speter return; 424251877Speter } 425251877Speter if ( t.isCompound() ) { //specialcase: boxed IDL 426251877Speter CompoundType ct = (CompoundType)t; 427251877Speter if ( ct.isIDLEntity() && ct.isBoxed() ) { 428251877Speter writeBoxedIDL( ct,p ); 429251877Speter return; 430251877Speter } 431251877Speter } 432251877Speter if ( t.isClass() ) { //specialcase: exception 433251877Speter ClassType ct = (ClassType)t; 434251877Speter if ( ct.isException() ) { 435251877Speter String eName = unEsc( ct.getIDLExceptionName() ); 436251877Speter String fName = ot.getName(); 437251877Speter if ( fName.equals( eName.replace( ' ','_' ) ) ) { 438251877Speter writeException( ct,p ); 439251877Speter return; 440251877Speter } 441251877Speter } 442251877Speter } 443251877Speter switch ( t.getTypeCode() ) { //general case 444251877Speter case TYPE_IMPLEMENTATION: 445251877Speter writeImplementation( (ImplementationType)t,p ); 446251877Speter break; 447251877Speter case TYPE_NC_CLASS: 448251877Speter case TYPE_NC_INTERFACE: 449251877Speter writeNCType( (CompoundType)t,p ); 450251877Speter break; 451251877Speter case TYPE_ABSTRACT: //AbstractType is a RemoteType 452251877Speter case TYPE_REMOTE: 453251877Speter writeRemote( (RemoteType)t,p ); 454251877Speter break; 455251877Speter case TYPE_VALUE: 456251877Speter writeValue( (ValueType)t,p ); 457251877Speter break; 458251877Speter default: 459251877Speter throw new CompilerError( 460251877Speter "IDLGenerator got unexpected type code: " 461251877Speter + t.getTypeCode()); 462251877Speter } 463251877Speter } 464251877Speter 465251877Speter 466251877Speter /** 467251877Speter * Write an IDL interface definition for a Java implementation class 468251877Speter * @param t The current ImplementationType 469251877Speter * @param p The output stream. 470251877Speter */ 471251877Speter protected void writeImplementation( 472251877Speter ImplementationType t, 473251877Speter IndentingWriter p ) 474251877Speter throws IOException { 475251877Speter Hashtable inhHash = new Hashtable(); 476251877Speter Hashtable refHash = new Hashtable(); 477251877Speter getInterfaces( t,inhHash ); //collect interfaces 478251877Speter 479251877Speter writeBanner( t,0,!isException,p ); 480251877Speter writeInheritedIncludes( inhHash,p ); 481251877Speter writeIfndef( t,0,!isException,!isForward,p ); 482251877Speter writeIncOrb( p ); 483251877Speter writeModule1( t,p ); 484251877Speter p.pln();p.pI(); 485251877Speter p.p( "interface " + t.getIDLName() ); 486251877Speter writeInherits( inhHash,!forValuetype,p ); 487251877Speter 488251877Speter p.pln( " {" ); 489251877Speter p.pln( "};" ); 490251877Speter 491251877Speter p.pO();p.pln(); 492251877Speter writeModule2( t,p ); 493251877Speter writeEpilog( t,refHash,p ); 494251877Speter } 495251877Speter 496251877Speter 497251877Speter /** 498251877Speter * Write an IDL valuetype definition for 499251877Speter * 1) a nonconforming Java class 500251877Speter * 2) a nonconforming Java interface (that is not an AbstractType) 501251877Speter * @param t The current NC Type (NCClassType or NCInterfaceType) 502251877Speter * @param p The output stream. 503253895Speter */ 504253895Speter protected void writeNCType( 505251877Speter CompoundType t, 506251877Speter IndentingWriter p ) 507251877Speter throws IOException { 508251877Speter Vector conVec = getConstants( t ); //collect constants 509251877Speter Vector mthVec = getMethods( t ); //collect methods 510251877Speter Hashtable inhHash = new Hashtable(); 511251877Speter Hashtable refHash = new Hashtable(); 512251877Speter Hashtable spcHash = new Hashtable(); 513251877Speter Hashtable arrHash = new Hashtable(); 514251877Speter Hashtable excHash = new Hashtable(); 515251877Speter getInterfaces( t,inhHash ); //collect interfaces 516251877Speter getInheritance( t,inhHash ); //add inheritance 517251877Speter getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash ); 518251877Speter 519251877Speter writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p ); 520251877Speter writeModule1( t,p ); 521251877Speter p.pln();p.pI(); 522251877Speter p.p( "abstract valuetype " + t.getIDLName() ); 523251877Speter writeInherits( inhHash,!forValuetype,p ); 524251877Speter 525251877Speter p.pln( " {" ); 526251877Speter if ( conVec.size() + mthVec.size() > 0 ) { //any content? 527251877Speter p.pln();p.pI(); 528251877Speter for ( int i1 = 0; i1 < conVec.size(); i1++ ) //write constants 529251877Speter writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p ); 530251877Speter for ( int i1 = 0; i1 < mthVec.size(); i1++ ) //write methods 531251877Speter writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p ); 532251877Speter p.pO();p.pln(); 533251877Speter } 534251877Speter p.pln( "};" ); 535251877Speter 536251877Speter p.pO();p.pln(); 537251877Speter writeModule2( t,p ); 538251877Speter writeEpilog( t,refHash,p ); 539251877Speter } 540251877Speter 541251877Speter 542251877Speter /** 543251877Speter * Write an IDL interface definition for either: 544251877Speter * 1) a conforming Java remote interface (RemoteType)..or 545251877Speter * 2) a non-conforming Java interface whose methods all throw 546251877Speter * java.rmi.RemoteException (AbstractType) 547251877Speter * @param t The current RemoteType 548251877Speter * @param p The output stream. 549251877Speter */ 550251877Speter protected void writeRemote( 551251877Speter RemoteType t, 552251877Speter IndentingWriter p ) 553251877Speter throws IOException { 554251877Speter Vector conVec = getConstants( t ); //collect constants 555251877Speter Vector mthVec = getMethods( t ); //collect methods 556251877Speter Hashtable inhHash = new Hashtable(); 557251877Speter Hashtable refHash = new Hashtable(); 558251877Speter Hashtable spcHash = new Hashtable(); 559251877Speter Hashtable arrHash = new Hashtable(); 560251877Speter Hashtable excHash = new Hashtable(); 561251877Speter getInterfaces( t,inhHash ); //collect interfaces 562251877Speter getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash ); 563251877Speter 564251877Speter writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p ); 565251877Speter writeModule1( t,p ); 566251877Speter p.pln();p.pI(); 567251877Speter if ( t.getTypeCode() == TYPE_ABSTRACT ) p.p( "abstract " ); 568251877Speter p.p( "interface " + t.getIDLName() ); 569251877Speter writeInherits( inhHash,!forValuetype,p ); 570251877Speter 571251877Speter p.pln( " {" ); 572251877Speter if ( conVec.size() + mthVec.size() > 0 ) { //any constants or methods? 573251877Speter p.pln();p.pI(); 574251877Speter for ( int i1 = 0; i1 < conVec.size(); i1++ ) //constants 575251877Speter writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p ); 576251877Speter for ( int i1 = 0; i1 < mthVec.size(); i1++ ) //methods, attributes 577251877Speter writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p ); 578251877Speter p.pO();p.pln(); 579251877Speter } 580251877Speter p.pln( "};" ); 581251877Speter 582251877Speter p.pO();p.pln(); 583251877Speter writeRepositoryID ( t,p ); 584251877Speter p.pln(); 585251877Speter writeModule2( t,p ); 586251877Speter writeEpilog( t,refHash,p ); 587251877Speter } 588251877Speter 589251877Speter 590251877Speter /** 591251877Speter * Write an IDL valuetype definition for a conforming Java class. 592251877Speter * Methods and constructors are optional..controlled by -valueMethods flag 593251877Speter * @param t The current ValueType 594251877Speter * @param p The output stream. 595251877Speter */ 596251877Speter protected void writeValue( 597251877Speter ValueType t, 598251877Speter IndentingWriter p ) 599251877Speter throws IOException { 600251877Speter Vector datVec = getData( t ); //collect and sort data 601251877Speter Vector conVec = getConstants( t ); //collect constants 602251877Speter Vector mthVec = getMethods( t ); //collect and filter methods 603251877Speter Hashtable inhHash = new Hashtable(); 604251877Speter Hashtable refHash = new Hashtable(); 605251877Speter Hashtable spcHash = new Hashtable(); 606251877Speter Hashtable arrHash = new Hashtable(); 607251877Speter Hashtable excHash = new Hashtable(); 608251877Speter getInterfaces( t,inhHash ); //collect interfaces 609251877Speter getInheritance( t,inhHash ); //add inheritance 610251877Speter getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash ); 611251877Speter getMemberReferences( datVec,refHash,spcHash,arrHash ); 612251877Speter 613251877Speter writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p ); 614251877Speter writeModule1( t,p ); 615251877Speter p.pln();p.pI(); 616251877Speter if ( t.isCustom() ) p.p( "custom " ); 617251877Speter p.p( "valuetype " + t.getIDLName() ); 618251877Speter writeInherits( inhHash,forValuetype,p ); 619251877Speter 620251877Speter p.pln( " {" ); 621251877Speter if ( conVec.size() + datVec.size() + mthVec.size() > 0 ) { //any content? 622251877Speter p.pln();p.pI(); 623251877Speter for ( int i1 = 0; i1 < conVec.size(); i1++ ) //write constants 624251877Speter writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p ); 625251877Speter for ( int i1 = 0; i1 < datVec.size(); i1++ ) { 626251877Speter CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 ); 627251877Speter if ( mem.getType().isPrimitive() ) 628251877Speter writeData( mem,p ); //write primitive data 629251877Speter } 630251877Speter for ( int i1 = 0; i1 < datVec.size(); i1++ ) { 631251877Speter CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 ); 632251877Speter if ( !mem.getType().isPrimitive() ) 633251877Speter writeData( mem,p ); //write non-primitive data 634251877Speter } 635251877Speter for ( int i1 = 0; i1 < mthVec.size(); i1++ ) //write methods 636251877Speter writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p ); 637251877Speter p.pO();p.pln(); 638251877Speter } 639251877Speter p.pln( "};" ); 640251877Speter 641251877Speter p.pO();p.pln(); 642251877Speter writeRepositoryID ( t,p ); 643251877Speter p.pln(); 644251877Speter writeModule2( t,p ); 645251877Speter writeEpilog( t,refHash,p ); 646251877Speter } 647251877Speter 648251877Speter 649251877Speter /** 650251877Speter * Write IDL prolog for a CompoundType. 651251877Speter * @param t The CompoundType. 652251877Speter * @param refHash Hashtable loaded with type references. 653251877Speter * @param spcHash Hashtable loaded with special type references. 654251877Speter * @param arrHash Hashtable loaded with array references. 655251877Speter * @param excHash Hashtable loaded with exceptions thrown. 656251877Speter * @param inhHash Hashtable loaded with inherited types. 657251877Speter * @param p The output stream. 658251877Speter */ 659251877Speter protected void writeProlog( 660251877Speter CompoundType t, 661251877Speter Hashtable refHash, 662251877Speter Hashtable spcHash, 663251877Speter Hashtable arrHash, 664251877Speter Hashtable excHash, 665251877Speter Hashtable inhHash, 666251877Speter IndentingWriter p ) 667251877Speter throws IOException { 668251877Speter writeBanner( t,0,!isException,p ); 669251877Speter writeForwardReferences( refHash,p ); 670251877Speter writeIncludes( excHash,isThrown,p ); //#includes for exceptions thrown 671251877Speter writeInheritedIncludes( inhHash,p ); 672251877Speter writeIncludes( spcHash,!isThrown,p ); //#includes for special types 673251877Speter writeBoxedRMIIncludes( arrHash,p ); 674251877Speter writeIDLEntityIncludes( refHash,p ); 675251877Speter writeIncOrb( p ); 676251877Speter writeIfndef( t,0,!isException,!isForward,p ); 677251877Speter } 678251877Speter 679251877Speter 680251877Speter /** 681251877Speter * Write IDL epilog for a CompoundType. 682251877Speter * @param t The CompoundType. 683251877Speter * @param refHash Hashtable loaded with type references. 684251877Speter * @param p The output stream. 685251877Speter */ 686251877Speter protected void writeEpilog( 687251877Speter CompoundType t, 688251877Speter Hashtable refHash, 689251877Speter IndentingWriter p ) 690251877Speter throws IOException { 691251877Speter writeIncludes( refHash,!isThrown,p ); //#includes for forward dcl types 692251877Speter writeEndif( p ); 693251877Speter } 694251877Speter 695251877Speter 696251877Speter 697251877Speter /** 698251877Speter * Write special typedef 699251877Speter * @param t A special Type. 700251877Speter * @param p The output stream. 701251877Speter */ 702251877Speter protected void writeSpecial( 703251877Speter Type t, 704251877Speter IndentingWriter p ) 705251877Speter throws IOException { 706251877Speter String spcName = t.getQualifiedName(); 707251877Speter if ( "java.io.Serializable".equals( spcName ) ) 708251877Speter writeJavaIoSerializable( t,p ); 709251877Speter else if ( "java.io.Externalizable".equals( spcName ) ) 710251877Speter writeJavaIoExternalizable( t,p ); 711251877Speter else if ( "java.lang.Object".equals( spcName) ) 712251877Speter writeJavaLangObject( t,p ); 713251877Speter else if ( "java.rmi.Remote".equals( spcName) ) 714251877Speter writeJavaRmiRemote( t,p ); 715251877Speter else if ( "org.omg.CORBA.portable.IDLEntity".equals( spcName) ) 716251877Speter writeIDLEntity( t,p ); 717251877Speter } 718251877Speter 719251877Speter 720251877Speter 721251877Speter /** 722251877Speter * Write a hard-coded IDL typedef definition for the special case 723251877Speter * java.io.Serializable. 724251877Speter * @param t The current Type 725251877Speter * @param p The output stream. 726251877Speter */ 727251877Speter protected void writeJavaIoSerializable( 728251877Speter Type t, 729251877Speter IndentingWriter p ) 730251877Speter throws IOException { 731251877Speter writeBanner( t,0,!isException,p ); 732251877Speter writeIfndef( t,0,!isException,!isForward,p ); 733251877Speter writeModule1( t,p ); 734251877Speter p.pln();p.pI(); 735251877Speter p.pln( "typedef any Serializable;" ); 736251877Speter p.pO();p.pln(); 737251877Speter writeModule2( t,p ); 738251877Speter writeEndif( p ); 739251877Speter } 740251877Speter 741251877Speter 742251877Speter /** 743251877Speter * Write a hard-coded IDL typedef definition for the special case 744251877Speter * java.io.Externalizable. 745251877Speter * @param t The current Type 746251877Speter * @param p The output stream. 747251877Speter */ 748251877Speter protected void writeJavaIoExternalizable( 749251877Speter Type t, 750251877Speter IndentingWriter p ) 751251877Speter throws IOException { 752251877Speter writeBanner( t,0,!isException,p ); 753251877Speter writeIfndef( t,0,!isException,!isForward,p ); 754251877Speter writeModule1( t,p ); 755251877Speter p.pln();p.pI(); 756251877Speter p.pln( "typedef any Externalizable;" ); 757251877Speter p.pO();p.pln(); 758251877Speter writeModule2( t,p ); 759251877Speter writeEndif( p ); 760251877Speter } 761251877Speter 762251877Speter 763251877Speter /** 764251877Speter * Write a hard-coded IDL typedef definition for the special case 765251877Speter * java.lang.Object. 766251877Speter * @param t The current Type 767251877Speter * @param p The output stream. 768251877Speter */ 769251877Speter protected void writeJavaLangObject( 770251877Speter Type t, 771251877Speter IndentingWriter p ) 772251877Speter throws IOException { 773251877Speter writeBanner( t,0,!isException,p ); 774251877Speter writeIfndef( t,0,!isException,!isForward,p ); 775251877Speter writeModule1( t,p ); 776251877Speter p.pln();p.pI(); 777251877Speter p.pln( "typedef any _Object;" ); 778251877Speter p.pO();p.pln(); 779251877Speter writeModule2( t,p ); 780251877Speter writeEndif( p ); 781251877Speter } 782251877Speter 783251877Speter 784251877Speter /** 785251877Speter * Write a hard-coded IDL typedef definition for the special case 786251877Speter * java.rmi.Remote. 787251877Speter * @param t The current Type 788251877Speter * @param p The output stream. 789251877Speter */ 790251877Speter protected void writeJavaRmiRemote( 791251877Speter Type t, 792251877Speter IndentingWriter p ) 793251877Speter throws IOException { 794251877Speter writeBanner( t,0,!isException,p ); 795251877Speter writeIfndef( t,0,!isException,!isForward,p ); 796251877Speter writeModule1( t,p ); 797251877Speter p.pln();p.pI(); 798251877Speter p.pln( "typedef Object Remote;" ); 799251877Speter p.pO();p.pln(); 800251877Speter writeModule2( t,p ); 801251877Speter writeEndif( p ); 802251877Speter } 803251877Speter 804251877Speter 805251877Speter 806251877Speter /** 807251877Speter * Write a hard-coded IDL typedef definition for the special case 808251877Speter * org.omg.CORBA.portable.IDLEntity 809251877Speter * @param t The current Type 810251877Speter * @param p The output stream. 811251877Speter */ 812251877Speter protected void writeIDLEntity( 813251877Speter Type t, 814251877Speter IndentingWriter p ) 815251877Speter throws IOException { 816251877Speter writeBanner( t,0,!isException,p ); 817251877Speter writeIfndef( t,0,!isException,!isForward,p ); 818251877Speter writeModule1( t,p ); 819251877Speter p.pln();p.pI(); 820251877Speter p.pln( "typedef any IDLEntity;" ); 821251877Speter p.pO();p.pln(); 822251877Speter writeModule2( t,p ); 823251877Speter writeEndif( p ); 824251877Speter } 825251877Speter 826251877Speter 827251877Speter /** 828251877Speter * Filter and collect non-duplicate inherited interfaces for a type 829251877Speter * @param ct The current CompoundType 830251877Speter * @param inhHash Hashtable containing the inherited interfaces 831251877Speter */ 832251877Speter protected void getInterfaces( 833251877Speter CompoundType ct, 834251877Speter Hashtable inhHash ) { 835251877Speter InterfaceType[] infs = ct.getInterfaces(); 836251877Speter nextInterface: 837251877Speter for ( int i1 = 0; i1 < infs.length; i1++ ) { //forall inherited interfaces 838251877Speter String inhName = infs[i1].getQualifiedName(); 839251877Speter switch ( ct.getTypeCode() ) { 840251877Speter case TYPE_NC_CLASS: 841251877Speter case TYPE_VALUE: //filter for classes 842251877Speter if ( "java.io.Externalizable".equals( inhName ) || 843251877Speter "java.io.Serializable".equals( inhName ) || 844251877Speter "org.omg.CORBA.portable.IDLEntity".equals( inhName ) ) 845251877Speter continue nextInterface; 846251877Speter break; 847251877Speter default: //filter for all others 848251877Speter if ( "java.rmi.Remote".equals( inhName ) ) 849251877Speter continue nextInterface; 850251877Speter break; 851251877Speter } 852251877Speter inhHash.put( inhName,infs[i1] ); //add this one 853251877Speter } 854251877Speter } 855251877Speter 856251877Speter 857251877Speter /** 858251877Speter * Filter and add base class inheritance for a class type 859251877Speter * @param ct The current CompoundType 860251877Speter * @param inhHash Hashtable containing inherited types 861251877Speter */ 862251877Speter protected void getInheritance( 863251877Speter CompoundType ct, 864251877Speter Hashtable inhHash ) { 865251877Speter ClassType par = ct.getSuperclass(); //get parent 866251877Speter if ( par == null ) return; 867251877Speter String parName = par.getQualifiedName(); 868251877Speter switch ( ct.getTypeCode() ) { 869251877Speter case TYPE_NC_CLASS: 870251877Speter case TYPE_VALUE: 871251877Speter if ( "java.lang.Object".equals( parName ) ) //this is implicit 872251877Speter return; 873251877Speter break; 874251877Speter default: return; //ignore other types 875251877Speter } 876251877Speter inhHash.put( parName,par ); //add valid base class 877251877Speter } 878251877Speter 879251877Speter 880251877Speter /** 881251877Speter * Collect and filter type and array references from methods 882251877Speter * @param mthVec Given Vector of methods 883251877Speter * @param refHash Hashtable for type references 884251877Speter * @param spcHash Hashtable for special type references 885251877Speter * @param arrHash Hashtable for array references 886251877Speter * @param excHash Hashtable for exceptions thrown 887251877Speter */ 888251877Speter protected void getMethodReferences( 889251877Speter Vector mthVec, 890251877Speter Hashtable refHash, 891251877Speter Hashtable spcHash, 892251877Speter Hashtable arrHash, 893251877Speter Hashtable excHash ) { 894251877Speter for ( int i1 = 0; i1 < mthVec.size(); i1++ ) { //forall methods 895251877Speter CompoundType.Method mth = (CompoundType.Method)mthVec.elementAt( i1 ); 896251877Speter Type[] args = mth.getArguments(); 897251877Speter Type ret = mth.getReturnType(); 898251877Speter getExceptions( mth,excHash ); //collect exceptions thrown 899251877Speter for ( int i2 = 0; i2 < args.length; i2++ ) //forall arguments 900251877Speter addReference( args[i2],refHash,spcHash,arrHash ); 901251877Speter addReference( ret,refHash,spcHash,arrHash ); 902251877Speter } 903251877Speter } 904251877Speter 905251877Speter 906251877Speter /** 907251877Speter * Collect and filter type and array references from data members 908251877Speter * @param datVec Given Vector of data members 909251877Speter * @param refHash Hashtable for type references 910251877Speter * @param spcHash Hashtable for special type references 911251877Speter * @param arrHash Hashtable for array references 912251877Speter */ 913251877Speter protected void getMemberReferences( 914251877Speter Vector datVec, 915251877Speter Hashtable refHash, 916251877Speter Hashtable spcHash, 917251877Speter Hashtable arrHash ) { 918251877Speter for ( int i1 = 0; i1 < datVec.size(); i1++ ) { //forall datamembers 919251877Speter CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 ); 920251877Speter Type dat = mem.getType(); 921251877Speter addReference( dat,refHash,spcHash,arrHash ); 922251877Speter } 923251877Speter } 924251877Speter 925251877Speter 926251877Speter /** 927251877Speter * Add reference for given type avoiding duplication. 928251877Speter * Sort into specials, arrays and regular references. 929251877Speter * Filter out types which are not required. 930251877Speter * @param t Given Type 931251877Speter * @param refHash Hashtable for type references 932251877Speter * @param spcHash Hashtable for special type references 933251877Speter * @param arrHash Hashtable for array references 934251877Speter */ 935251877Speter protected void addReference( 936251877Speter Type ref, 937251877Speter Hashtable refHash, 938251877Speter Hashtable spcHash, 939251877Speter Hashtable arrHash ) { 940251877Speter String rName = ref.getQualifiedName(); 941251877Speter switch ( ref.getTypeCode() ) { 942251877Speter case TYPE_ABSTRACT: 943251877Speter case TYPE_REMOTE: 944251877Speter case TYPE_NC_CLASS: 945251877Speter case TYPE_NC_INTERFACE: 946251877Speter case TYPE_VALUE: 947251877Speter refHash.put( rName,ref ); 948251877Speter return; 949251877Speter case TYPE_CORBA_OBJECT: 950251877Speter if ( "org.omg.CORBA.Object".equals( rName ) ) return; //don't want 951251877Speter refHash.put( rName,ref ); 952251877Speter return; 953251877Speter case TYPE_ARRAY: //array? 954251877Speter arrHash.put( rName + ref.getArrayDimension(),ref ); 955251877Speter return; 956251877Speter default: 957251877Speter if ( isSpecialReference( ref ) ) //special IDL typedef? 958251877Speter spcHash.put( rName,ref ); 959251877Speter } 960251877Speter } 961251877Speter 962251877Speter 963251877Speter 964251877Speter /** 965251877Speter * Determine whether given Type is a special reference. 966251877Speter * Special cases are: java.io.Serializable, java.io.Externalizable, 967251877Speter * java.lang.Object, java.rmi.Remote and org.omg.CORBA.portable.IDLEntity 968251877Speter * They are special because they have a hard-coded typedef defined in the 969251877Speter * spec. 970251877Speter * @param ref A referenced Type 971251877Speter * @return boolean indicating whether it's a special reference 972251877Speter */ 973251877Speter protected boolean isSpecialReference( 974251877Speter Type ref ) { 975251877Speter String rName = ref.getQualifiedName(); 976251877Speter if ( "java.io.Serializable".equals( rName ) ) return true; 977251877Speter if ( "java.io.Externalizable".equals( rName ) ) return true; 978251877Speter if ( "java.lang.Object".equals( rName) ) return true; 979251877Speter if ( "java.rmi.Remote".equals( rName) ) return true; 980251877Speter if ( "org.omg.CORBA.portable.IDLEntity".equals( rName) ) return true; 981251877Speter return false; 982251877Speter } 983251877Speter 984251877Speter 985251877Speter /** 986251877Speter * Collect and filter thrown exceptions for a given pre-filtered method. 987251877Speter * Keep only 'checked' exception classes minus java.rmi.RemoteException 988251877Speter * and its subclasses 989251877Speter * @param method The current method 990251877Speter * @param excHash Hashtable containing non-duplicate thrown exceptions 991251877Speter */ 992251877Speter protected void getExceptions( 993251877Speter CompoundType.Method mth, 994251877Speter Hashtable excHash ) { 995251877Speter ClassType[] excs = mth.getExceptions(); 996251877Speter for ( int i1 = 0; i1 < excs.length; i1++ ) { //forall exceptions 997251877Speter ClassType exc = excs[i1]; 998251877Speter if ( exc.isCheckedException() && 999251877Speter !exc.isRemoteExceptionOrSubclass() ) { 1000251877Speter excHash.put( exc.getQualifiedName(),exc ); 1001251877Speter } 1002251877Speter } 1003251877Speter } 1004251877Speter 1005251877Speter 1006251877Speter /** 1007251877Speter * Collect and filter methods for a type. 1008251877Speter * Remove any private or inherited methods. 1009251877Speter * @param ct The current CompoundType 1010251877Speter * @return Vector containing the methods 1011251877Speter */ 1012251877Speter protected Vector getMethods( 1013251877Speter CompoundType ct ) { 1014251877Speter Vector vec = new Vector(); 1015251877Speter int ctType = ct.getTypeCode(); 1016251877Speter switch ( ctType ) { 1017251877Speter case TYPE_ABSTRACT: 1018251877Speter case TYPE_REMOTE: break; 1019251877Speter case TYPE_NC_CLASS: 1020251877Speter case TYPE_NC_INTERFACE: 1021251877Speter case TYPE_VALUE: if ( valueMethods ) break; 1022251877Speter default: return vec; 1023251877Speter } 1024251877Speter Identifier ctId = ct.getIdentifier(); 1025251877Speter CompoundType.Method[] mths = ct.getMethods(); 1026251877Speter nextMethod: 1027251877Speter for ( int i1 = 0; i1 < mths.length; i1++ ) { //forall methods 1028251877Speter if ( mths[i1].isPrivate() || //private method? 1029251877Speter mths[i1].isInherited() ) //inherited method? 1030251877Speter continue nextMethod; //yes..ignore it 1031251877Speter if ( ctType == TYPE_VALUE ) { 1032251877Speter String mthName = mths[i1].getName(); 1033251877Speter if ( "readObject" .equals( mthName ) || 1034251877Speter "writeObject" .equals( mthName ) || 1035251877Speter "readExternal".equals( mthName ) || 1036251877Speter "writeExternal".equals( mthName ) ) 1037251877Speter continue nextMethod; //ignore this one 1038251877Speter } 1039251877Speter if ( ( ctType == TYPE_NC_CLASS || 1040251877Speter ctType == TYPE_NC_INTERFACE ) && 1041251877Speter mths[i1].isConstructor() ) //init not valid for abstract valuetype 1042251877Speter continue nextMethod; //ignore this one 1043251877Speter vec.addElement( mths[i1] ); //add this one 1044251877Speter } 1045251877Speter return vec; 1046251877Speter } 1047251877Speter 1048251877Speter 1049251877Speter /** 1050251877Speter * Collect constants for a type. 1051251877Speter * A valid constant is a "public final static" field with a compile-time 1052251877Speter * constant value for a primitive type or String 1053251877Speter * @param ct The current CompoundType 1054251877Speter * @return Vector containing the constants 1055251877Speter */ 1056251877Speter protected Vector getConstants( 1057251877Speter CompoundType ct ) { 1058251877Speter Vector vec = new Vector(); 1059251877Speter CompoundType.Member[] mems = ct.getMembers(); 1060251877Speter for ( int i1 = 0; i1 < mems.length; i1++ ) { //forall members 1061251877Speter Type memType = mems[i1].getType(); 1062251877Speter String memValue = mems[i1].getValue(); 1063251877Speter if ( mems[i1].isPublic() && 1064251877Speter mems[i1].isFinal() && 1065251877Speter mems[i1].isStatic() && 1066251877Speter ( memType.isPrimitive() || "String".equals( memType.getName() ) ) && 1067251877Speter memValue != null ) 1068251877Speter vec.addElement( mems[i1] ); //add this one 1069253895Speter } 1070362181Sdim return vec; 1071251877Speter } 1072251877Speter 1073251877Speter 1074251877Speter /** 1075251877Speter * Collect and sort data fields for a ValueType. 1076251877Speter * Sort in Java (not IDL) Unicode name string lexicographic increasing 1077251877Speter * order. 1078251877Speter * Non-static, non-transient fields are mapped. 1079251877Speter * If the type is a custom valuetype, only public fields are mapped. 1080251877Speter * @param ct The current CompoundType 1081251877Speter * @return Vector containing the data fields 1082251877Speter */ 1083251877Speter protected Vector getData( 1084251877Speter CompoundType t ) { 1085251877Speter Vector vec = new Vector(); 1086251877Speter if ( t.getTypeCode() != TYPE_VALUE ) return vec; 1087251877Speter ValueType vt = (ValueType)t; 1088251877Speter CompoundType.Member[] mems = vt.getMembers(); 1089251877Speter boolean notCust = !vt.isCustom(); 1090251877Speter for ( int i1 = 0; i1 < mems.length; i1++ ) { //forall members 1091251877Speter if ( !mems[i1].isStatic() && 1092251877Speter !mems[i1].isTransient() && 1093251877Speter ( mems[i1].isPublic() || notCust ) ) { 1094251877Speter int i2; 1095251877Speter String memName = mems[i1].getName(); 1096251877Speter for ( i2 = 0; i2 < vec.size(); i2++ ) { //insert in java lex order 1097251877Speter CompoundType.Member aMem = (CompoundType.Member)vec.elementAt( i2 ); 1098251877Speter if ( memName.compareTo( aMem.getName() ) < 0 ) break; 1099251877Speter } 1100251877Speter vec.insertElementAt( mems[i1],i2 ); //insert this one 1101251877Speter } 1102251877Speter } 1103251877Speter return vec; 1104251877Speter } 1105251877Speter 1106251877Speter 1107251877Speter /** 1108251877Speter * Write forward references for referenced interfaces and valuetypes 1109251877Speter * ...but not if the reference is to a boxed IDLEntity, 1110251877Speter * @param refHash Hashtable loaded with referenced types 1111251877Speter * @param p The output stream. 1112251877Speter */ 1113251877Speter protected void writeForwardReferences( 1114251877Speter Hashtable refHash, 1115251877Speter IndentingWriter p ) 1116251877Speter throws IOException { 1117251877Speter Enumeration refEnum = refHash.elements(); 1118251877Speter nextReference: 1119251877Speter while ( refEnum.hasMoreElements() ) { 1120251877Speter Type t = (Type)refEnum.nextElement(); 1121251877Speter if ( t.isCompound() ) { 1122251877Speter CompoundType ct = (CompoundType)t; 1123 if ( ct.isIDLEntity() ) 1124 continue nextReference; //ignore IDLEntity reference 1125 } 1126 writeForwardReference( t,p ); 1127 } 1128 } 1129 1130 1131 /** 1132 * Write forward reference for given type 1133 * @param t Given type 1134 * @param p The output stream. 1135 */ 1136 protected void writeForwardReference( 1137 Type t, 1138 IndentingWriter p ) 1139 throws IOException { 1140 String qName = t.getQualifiedName(); 1141 if ( "java.lang.String".equals( qName ) ) ; 1142 else if ( "org.omg.CORBA.Object".equals( qName ) ) return ; //no fwd dcl 1143 1144 writeIfndef( t,0,!isException,isForward,p ); 1145 writeModule1( t,p ); 1146 p.pln();p.pI(); 1147 switch ( t.getTypeCode() ) { 1148 case TYPE_NC_CLASS: 1149 case TYPE_NC_INTERFACE: p.p( "abstract valuetype " ); break; 1150 case TYPE_ABSTRACT: p.p( "abstract interface " ); break; 1151 case TYPE_VALUE: p.p( "valuetype " ); break; 1152 case TYPE_REMOTE: 1153 case TYPE_CORBA_OBJECT: p.p( "interface " ); break; 1154 default: ; //all other types were filtered 1155 } 1156 p.pln( t.getIDLName() + ";" ); 1157 p.pO();p.pln(); 1158 writeModule2( t,p ); 1159 writeEndif( p ); 1160 } 1161 1162 1163 /** 1164 * Write forward reference for boxed valuetype for single dimension of IDL 1165 * sequence. 1166 * If the dimension is <1 and the element is a CompoundType, write a 1167 * forward declare for the element 1168 * @param at ArrayType for forward declare 1169 * @param dim The dimension to write 1170 * @param p The output stream. 1171 */ 1172 protected void writeForwardReference( 1173 ArrayType at, 1174 int dim, 1175 IndentingWriter p) 1176 throws IOException { 1177 Type et = at.getElementType(); 1178 if ( dim < 1 ) { 1179 if ( et.isCompound() ) { 1180 CompoundType ct = (CompoundType)et; 1181 writeForwardReference( et,p); 1182 } 1183 return; 1184 } 1185 String fName = unEsc( et.getIDLName() ).replace( ' ','_' ); 1186 1187 writeIfndef( at,dim,!isException,isForward,p ); 1188 writeModule1( at,p ); 1189 p.pln();p.pI(); 1190 switch ( et.getTypeCode() ) { 1191 case TYPE_NC_CLASS: 1192 case TYPE_NC_INTERFACE: p.p( "abstract valuetype " ); break; 1193 case TYPE_ABSTRACT: p.p( "abstract interface " ); break; 1194 case TYPE_VALUE: p.p( "valuetype " ); break; 1195 case TYPE_REMOTE: 1196 case TYPE_CORBA_OBJECT: p.p( "interface " ); break; 1197 default: ; //all other types were filtered 1198 } 1199 p.pln( "seq" + dim + "_" + fName + ";" ); 1200 p.pO();p.pln(); 1201 writeModule2( at,p ); 1202 writeEndif( p ); 1203 } 1204 1205 1206 /** 1207 * Write #includes for boxed IDLEntity references. 1208 * @param refHash Hashtable loaded with referenced types 1209 * @param p The output stream. 1210 */ 1211 protected void writeIDLEntityIncludes( 1212 Hashtable refHash, 1213 IndentingWriter p ) 1214 throws IOException { 1215 Enumeration refEnum = refHash.elements(); 1216 while ( refEnum.hasMoreElements() ) { 1217 Type t = (Type)refEnum.nextElement(); 1218 if ( t.isCompound() ) { 1219 CompoundType ct = (CompoundType)t; 1220 if ( ct.isIDLEntity() ) { //select IDLEntities 1221 writeInclude( ct,0,!isThrown,p ); 1222 refHash.remove( ct.getQualifiedName() ); //avoid another #include 1223 } 1224 } 1225 } 1226 } 1227 1228 1229 /** 1230 * Write #includes 1231 * @param incHash Hashtable loaded with Types to include 1232 * @param isThrown true if Types are thrown exceptions 1233 * @param p The output stream. 1234 */ 1235 protected void writeIncludes( 1236 Hashtable incHash, 1237 boolean isThrown, 1238 IndentingWriter p ) 1239 throws IOException { 1240 Enumeration incEnum = incHash.elements(); 1241 while ( incEnum.hasMoreElements() ) { 1242 CompoundType t = (CompoundType)incEnum.nextElement(); 1243 writeInclude( t,0,isThrown,p ); 1244 } 1245 } 1246 1247 1248 /** 1249 * Write includes for boxedRMI valuetypes for IDL sequences. 1250 * Write only the maximum dimension found for an ArrayType. 1251 * @param arrHash Hashtable loaded with array types 1252 * @param p The output stream. 1253 */ 1254 protected void writeBoxedRMIIncludes( 1255 Hashtable arrHash, 1256 IndentingWriter p) 1257 throws IOException { 1258 Enumeration e1 = arrHash.elements(); 1259 nextSequence: 1260 while ( e1.hasMoreElements() ) { 1261 ArrayType at = (ArrayType)e1.nextElement(); 1262 int dim = at.getArrayDimension(); 1263 Type et = at.getElementType(); 1264 1265 Enumeration e2 = arrHash.elements(); 1266 while ( e2.hasMoreElements() ) { //eliminate duplicates 1267 ArrayType at2 = (ArrayType)e2.nextElement(); 1268 if ( et == at2.getElementType() && //same element type & 1269 dim < at2.getArrayDimension() ) //smaller dimension? 1270 continue nextSequence; //ignore this one 1271 } 1272 writeInclude( at,dim,!isThrown,p ); 1273 } 1274 } 1275 1276 1277 /** 1278 * Write #includes 1279 * @param incHash Hashtable loaded with Types to include 1280 * @param p The output stream. 1281 */ 1282 protected void writeInheritedIncludes( 1283 Hashtable inhHash, 1284 IndentingWriter p ) 1285 throws IOException { 1286 Enumeration inhEnum = inhHash.elements(); 1287 while ( inhEnum.hasMoreElements() ) { 1288 CompoundType t = (CompoundType)inhEnum.nextElement(); 1289 writeInclude( t,0,!isThrown,p ); 1290 } 1291 } 1292 1293 1294 /** 1295 * Write a #include. 1296 * @param t Type to include 1297 * @param dim The dimension to write if t is an array. 1298 * @param isThrown boolean indicating if include is for thrown exception. 1299 * @param p The output stream. 1300 */ 1301 protected void writeInclude( 1302 Type t, 1303 int dim, 1304 boolean isThrown, 1305 IndentingWriter p) 1306 throws IOException { 1307 CompoundType ct; 1308 String tName; 1309 String[] modNames; 1310 if ( t.isCompound() ) { 1311 ct = (CompoundType)t; 1312 String qName = ct.getQualifiedName(); 1313 if ( "java.lang.String".equals( qName ) ) { 1314 writeIncOrb( p ); //#include orb.idl for String 1315 return; 1316 } 1317 if ( "org.omg.CORBA.Object".equals( qName ) ) 1318 return; //Object treated like primitive 1319 modNames = getIDLModuleNames( ct ); //module name array 1320 tName = unEsc( ct.getIDLName() ); //file name default 1321 1322 if ( ct.isException() ) 1323 if ( ct.isIDLEntityException() ) 1324 if ( ct.isCORBAUserException() ) 1325 if ( isThrown ) tName = unEsc( ct.getIDLExceptionName() ); 1326 else ; 1327 else tName = ct.getName(); //use original IDL name 1328 else if ( isThrown ) 1329 tName = unEsc( ct.getIDLExceptionName() ); 1330 } 1331 else if ( t.isArray() ) { 1332 Type et = t.getElementType(); //file name for sequence 1333 if ( dim > 0 ) { 1334 modNames = getIDLModuleNames( t ); //module name array 1335 tName = "seq" + dim + "_" + unEsc( et.getIDLName().replace( ' ','_' ) ); 1336 } 1337 else{ //#include element 1338 if ( !et.isCompound() ) return; //no include needed for primitive 1339 ct = (CompoundType) et; 1340 modNames = getIDLModuleNames( ct ); //no boxedRMI for element 1341 tName = unEsc( ct.getIDLName() ); 1342 writeInclude( ct,modNames,tName,p ); 1343 return; 1344 } 1345 } 1346 else return; //no include needed for primitive 1347 writeInclude( t,modNames,tName,p ); 1348 } 1349 1350 1351 /** 1352 * Write a #include doing user specified -idlFile translation (if any) for 1353 * IDLEntities. 1354 * @param t Type to include. 1355 * @param modNames Preprocessed module names (default). 1356 * @param tName Preprocessed Type name (default). 1357 * @param p The output stream. 1358 */ 1359 protected void writeInclude( 1360 Type t, 1361 String[] modNames, 1362 String tName, 1363 IndentingWriter p) 1364 throws IOException { 1365 if ( t.isCompound() ) { 1366 CompoundType it = (CompoundType)t; 1367 1368 if ( ifHash.size() > 0 && //any -idlFile translation to apply 1369 it.isIDLEntity() ) { //..for this IDLEntity? 1370 String qName = t.getQualifiedName(); //fully qualified orig Java name 1371 1372 Enumeration k = ifHash.keys(); 1373 while ( k.hasMoreElements() ) { //loop thro user-defined -idlFiles 1374 String from = (String)k.nextElement(); 1375 if ( qName.startsWith( from ) ) { //found a match? 1376 String to = (String)ifHash.get( from ); 1377 p.pln( "#include \"" + to + "\"" ); //user-specified idl filename 1378 return; //don't look for any more 1379 } 1380 } 1381 } 1382 } 1383 else if ( t.isArray() ) ; //no -idlFile translation needed for array 1384 else return; //no #include needed for primitive 1385 1386 p.p( "#include \"" ); //no -idlFile translation required 1387 for ( int i1 = 0; i1 < modNames.length; i1++ ) p.p( modNames[i1] + "/" ); 1388 p.p( tName + ".idl\"" ); 1389 p.pln(); 1390 } 1391 1392 1393 /** 1394 * Return the fully qualified Java Name for a Type. 1395 * IDLEntity preprocessing done by getIDLModuleNames(t) 1396 * @param t Given Type 1397 * @return Array containing the original module nesting. 1398 */ 1399 protected String getQualifiedName( 1400 Type t ) { 1401 String[] modNames = getIDLModuleNames( t ); 1402 int len = modNames.length; 1403 StringBuffer buf = new StringBuffer(); 1404 for ( int i1 = 0; i1 < len; i1++ ) 1405 buf.append( modNames[i1] + "." ); 1406 buf.append( t.getIDLName() ); 1407 return buf.toString(); 1408 } 1409 1410 1411 /** 1412 * Return the global fully qualified IDL Name for a Type. 1413 * IDLEntity preprocessing done by getIDLModuleNames(t) 1414 * @param t Given Type 1415 * @return Array containing the original module nesting. 1416 */ 1417 protected String getQualifiedIDLName(Type t) { 1418 if ( t.isPrimitive() ) 1419 return t.getIDLName(); 1420 if ( !t.isArray() && 1421 "org.omg.CORBA.Object".equals( t.getQualifiedName() ) ) 1422 return t.getIDLName(); 1423 1424 String[] modNames = getIDLModuleNames( t ); 1425 int len = modNames.length; 1426 if (len > 0) { 1427 StringBuffer buf = new StringBuffer(); 1428 for ( int i1 = 0; i1 < len; i1++ ) 1429 buf.append( IDL_NAME_SEPARATOR + modNames[i1] ); 1430 buf.append( IDL_NAME_SEPARATOR + t.getIDLName() ); 1431 return buf.toString(); 1432 } else { 1433 return t.getIDLName(); 1434 } 1435 } 1436 1437 1438 /** 1439 * Return the IDL module nesting of the given Type. 1440 * For IDLEntity CompoundTypes (or their arrays) apply any user specified 1441 * -idlModule translation or, if none applicable, strip any package 1442 * prefix. 1443 * Add boxedIDL or boxedRMI modules if required. 1444 * @param t Given Type 1445 * @return Array containing the original module nesting. 1446 */ 1447 protected String[] getIDLModuleNames(Type t) { 1448 String[] modNames = t.getIDLModuleNames(); //default module name array 1449 CompoundType ct; 1450 if ( t.isCompound() ) { 1451 ct = (CompoundType)t; 1452 if ( !ct.isIDLEntity ) return modNames; //normal (non-IDLEntity) case 1453 if ( "org.omg.CORBA.portable.IDLEntity" 1454 .equals( t.getQualifiedName() ) ) 1455 return modNames; 1456 } 1457 else if ( t.isArray() ) { 1458 Type et = t.getElementType(); 1459 if ( et.isCompound() ) { 1460 ct = (CompoundType)et; 1461 if ( !ct.isIDLEntity ) return modNames; //normal (non-IDLEntity) case 1462 if ( "org.omg.CORBA.portable.IDLEntity" 1463 .equals( t.getQualifiedName() ) ) 1464 return modNames; 1465 } 1466 else return modNames; 1467 } 1468 else return modNames; //no preprocessing needed for primitives 1469 1470 //it's an IDLEntity or an array of... 1471 Vector mVec = new Vector(); 1472 if ( !translateJavaPackage( ct,mVec ) ) //apply -idlModule translation 1473 stripJavaPackage( ct,mVec ); //..or strip prefixes (not both) 1474 1475 if ( ct.isBoxed() ) { //add boxedIDL if required 1476 mVec.insertElementAt( "org",0 ); 1477 mVec.insertElementAt( "omg",1 ); 1478 mVec.insertElementAt( "boxedIDL",2 ); 1479 } 1480 if ( t.isArray() ) { //add boxedRMI if required 1481 mVec.insertElementAt( "org",0 ); 1482 mVec.insertElementAt( "omg",1 ); 1483 mVec.insertElementAt( "boxedRMI",2 ); 1484 } 1485 String[] outArr = new String[mVec.size()]; 1486 mVec.copyInto( outArr ); 1487 return outArr; 1488 } 1489 1490 1491 /** 1492 * Apply user specified -idlModule translation to package names of given 1493 * IDLEntity ct. Example: 1494 * -idlModule foo.bar real::mod::nesting 1495 * @param ct CompoundType containing given IDLEntity. 1496 * @param vec Returned Vector of translated IDL module names. 1497 * @return boolean true if any translation was done. 1498 */ 1499 protected boolean translateJavaPackage( 1500 CompoundType ct, 1501 Vector vec ) { 1502 vec.removeAllElements(); 1503 boolean ret = false; 1504 String fc = null; 1505 if ( ! ct.isIDLEntity() ) return ret; 1506 1507 String pName = ct.getPackageName(); //start from Java package names 1508 if ( pName == null ) return ret; 1509 StringTokenizer pt = new StringTokenizer( pName,"." ); 1510 while ( pt.hasMoreTokens() ) vec.addElement( pt.nextToken() ); 1511 1512 if ( imHash.size() > 0 ) { //any -idlModule translation to apply? 1513 Enumeration k = imHash.keys(); 1514 1515 nextModule: 1516 while ( k.hasMoreElements() ) { //loop thro user-defined -idlModules 1517 String from = (String)k.nextElement(); //from String.. 1518 StringTokenizer ft = new StringTokenizer( from,"." ); 1519 int vecLen = vec.size(); 1520 int ifr; 1521 for ( ifr = 0; ifr < vecLen && ft.hasMoreTokens(); ifr++ ) 1522 if ( ! vec.elementAt(ifr).equals( ft.nextToken() ) ) 1523 continue nextModule; //..no match 1524 1525 if ( ft.hasMoreTokens() ) { //matched so far.. 1526 fc = ft.nextToken(); //a 'from' token remains 1527 if ( ! ct.getName().equals( fc ) || //matches class name? 1528 ft.hasMoreTokens() ) 1529 continue nextModule; //..no match 1530 } 1531 1532 ret = true; //found a match 1533 for ( int i4 = 0; i4 < ifr; i4++ ) 1534 vec.removeElementAt( 0 ); //remove 'from' package 1535 1536 String to = (String)imHash.get( from ); //..to String 1537 StringTokenizer tt = new StringTokenizer( to,IDL_NAME_SEPARATOR ); 1538 1539 int itoco = tt.countTokens(); 1540 int ito = 0; 1541 if ( fc != null ) itoco--; //user may have given IDL type 1542 for ( ito = 0; ito < itoco; ito++ ) 1543 vec.insertElementAt( tt.nextToken(),ito ); //insert 'to' modules 1544 if ( fc != null ) { 1545 String tc = tt.nextToken(); 1546 if ( ! ct.getName().equals( tc ) ) //not the IDL type, so.. 1547 vec.insertElementAt( tc,ito ); //insert final 'to' module 1548 } 1549 } 1550 } 1551 return ret; 1552 } 1553 1554 1555 /** 1556 * Strip Java #pragma prefix and/or -pkgPrefix prefix package names from 1557 * given IDLEntity ct. 1558 * Strip any package prefix which may have been added by comparing with 1559 * repository id. For example in Java package fake.omega: 1560 * repid = IDL:phoney.pfix/omega/Juliet:1.0 gives { "omega" } 1561 * @param ct CompoundType containing given IDLEntity. 1562 * @param vec Returned Vector of stripped IDL module names. 1563 */ 1564 protected void stripJavaPackage( 1565 CompoundType ct, 1566 Vector vec ) { 1567 vec.removeAllElements(); 1568 if ( ! ct.isIDLEntity() ) return; 1569 1570 String repID = ct.getRepositoryID().substring( 4 ); 1571 StringTokenizer rept = new StringTokenizer( repID,"/" ); 1572 if ( rept.countTokens() < 2 ) return; 1573 1574 while ( rept.hasMoreTokens() ) 1575 vec.addElement( rept.nextToken() ); 1576 vec.removeElementAt( vec.size() - 1 ); 1577 1578 String pName = ct.getPackageName(); //start from Java package names 1579 if ( pName == null ) return; 1580 Vector pVec = new Vector(); 1581 StringTokenizer pt = new StringTokenizer( pName,"." ); 1582 while ( pt.hasMoreTokens() ) pVec.addElement( pt.nextToken() ); 1583 1584 int i1 = vec.size() - 1; 1585 int i2 = pVec.size() - 1; 1586 while ( i1 >= 0 && i2 >= 0 ) { //go R->L till mismatch 1587 String rep = (String)( vec.elementAt( i1 ) ); 1588 String pkg = (String)( pVec.elementAt( i2 ) ); 1589 if ( ! pkg.equals( rep ) ) break; 1590 i1--; i2--; 1591 } 1592 for ( int i3 = 0; i3 <= i1; i3++ ) 1593 vec.removeElementAt( 0 ); //strip prefix 1594 } 1595 1596 1597 1598 /** 1599 * Write boxedRMI valuetype for a single dimension of an IDL sequence 1600 * indicated by the given OutputType. 1601 * The filename for the OutputType is of the form "seqn_elemName" where n 1602 * is the dimension required. 1603 * @param ot Given OutputType. 1604 * @param p The output stream. 1605 */ 1606 protected void writeSequence( 1607 OutputType ot, 1608 IndentingWriter p) 1609 throws IOException { 1610 ArrayType at = (ArrayType)ot.getType(); 1611 Type et = at.getElementType(); 1612 String fName = ot.getName(); 1613 int dim = Integer.parseInt( fName.substring( 3,fName.indexOf( "_" ) ) ); 1614 String idlName = unEsc( et.getIDLName() ).replace( ' ','_' ); 1615 String qIdlName = getQualifiedIDLName( et ); 1616 String qName = et.getQualifiedName(); 1617 1618 String repID = at.getRepositoryID(); 1619 int rix1 = repID.indexOf( '[' ); //edit repository id 1620 int rix2 = repID.lastIndexOf( '[' ) + 1; 1621 StringBuffer rid = new StringBuffer( 1622 repID.substring( 0,rix1 ) + 1623 repID.substring( rix2 ) ); 1624 for ( int i1 = 0; i1 < dim; i1++ ) rid.insert( rix1,'[' ); 1625 1626 String vtName = "seq" + dim + "_" + idlName; 1627 boolean isFromIDL = false; 1628 if ( et.isCompound() ) { 1629 CompoundType ct = (CompoundType)et; 1630 isFromIDL = ct.isIDLEntity() || ct.isCORBAObject(); 1631 } 1632 boolean isForwardInclude = 1633 et.isCompound() && 1634 !isSpecialReference( et ) && 1635 dim == 1 && 1636 !isFromIDL && 1637 !"org.omg.CORBA.Object".equals(qName) && 1638 !"java.lang.String".equals(qName); 1639 1640 writeBanner( at,dim,!isException,p ); 1641 if ( dim == 1 && "java.lang.String".equals(qName) ) //special case 1642 writeIncOrb( p ); 1643 if ( dim == 1 && "org.omg.CORBA.Object".equals(qName) ) ; 1644 else if ( isSpecialReference( et ) || dim > 1 || isFromIDL ) 1645 writeInclude( at,dim-1,!isThrown,p ); //"trivial" include 1646 writeIfndef( at,dim,!isException,!isForward,p ); 1647 if ( isForwardInclude ) 1648 writeForwardReference( at,dim-1,p ); //forward declare 1649 writeModule1( at,p ); 1650 p.pln();p.pI(); 1651 p.p( "valuetype " + vtName ); 1652 p.p( " sequence<" ); 1653 if ( dim == 1 ) p.p( qIdlName ); 1654 else { 1655 p.p( "seq" + ( dim - 1 ) + "_" ); 1656 p.p( idlName ); 1657 } 1658 p.pln( ">;" ); 1659 p.pO();p.pln(); 1660 p.pln( "#pragma ID " + vtName + " \"" + rid + "\"" ); 1661 p.pln(); 1662 writeModule2( at,p ); 1663 if ( isForwardInclude ) 1664 writeInclude( at,dim-1,!isThrown,p ); //#include for forward declare 1665 writeEndif( p ); 1666 } 1667 1668 1669 /** 1670 * Write valuetype for a boxed IDLEntity. 1671 * @param t Given CompoundType representing the IDLEntity. 1672 * @param p The output stream. 1673 */ 1674 protected void writeBoxedIDL( 1675 CompoundType t, 1676 IndentingWriter p) 1677 throws IOException { 1678 String[] boxNames = getIDLModuleNames( t ); 1679 int len = boxNames.length; 1680 String[] modNames = new String[len - 3]; //remove box modules 1681 for ( int i1 = 0; i1 < len - 3; i1++ ) modNames[i1] = boxNames[i1 + 3]; 1682 String tName = unEsc( t.getIDLName() ); 1683 1684 writeBanner( t,0,!isException,p ); 1685 writeInclude( t,modNames,tName,p ); 1686 writeIfndef( t,0,!isException,!isForward,p ); 1687 writeModule1( t,p ); 1688 p.pln();p.pI(); 1689 1690 p.p( "valuetype " + tName + " " ); 1691 for ( int i1 = 0; i1 < modNames.length; i1++ ) 1692 p.p( IDL_NAME_SEPARATOR + modNames[i1] ); 1693 p.pln( IDL_NAME_SEPARATOR + tName + ";" ); 1694 1695 p.pO();p.pln(); 1696 writeRepositoryID( t,p ); 1697 p.pln(); 1698 writeModule2( t,p ); 1699 writeEndif( p ); 1700 } 1701 1702 1703 /** 1704 * Write an exception. 1705 * @param t Given ClassType representing the exception. 1706 * @param p The output stream. 1707 */ 1708 protected void writeException( 1709 ClassType t, 1710 IndentingWriter p) 1711 throws IOException { 1712 writeBanner( t,0,isException,p ); 1713 writeIfndef( t,0,isException,!isForward,p ); 1714 writeForwardReference( t,p ); 1715 writeModule1( t,p ); 1716 p.pln();p.pI(); 1717 1718 p.pln( "exception " + t.getIDLExceptionName() + " {" ); 1719 p.pln();p.pI(); 1720 p.pln( t.getIDLName() + " value;" ); 1721 p.pO();p.pln(); 1722 p.pln( "};" ); 1723 1724 p.pO();p.pln(); 1725 writeModule2( t,p ); 1726 writeInclude( t,0,!isThrown,p ); //include valuetype idl file 1727 writeEndif( p ); 1728 } 1729 1730 1731 /** 1732 * Write #pragma to identify the repository ID of the given type 1733 * @param t The given Type. 1734 * @param p The output stream. 1735 */ 1736 protected void writeRepositoryID( 1737 Type t, 1738 IndentingWriter p ) 1739 throws IOException { 1740 String repid = t.getRepositoryID(); 1741 if ( t.isCompound() ) { 1742 CompoundType ct = (CompoundType)t; 1743 if ( ct.isBoxed() ) 1744 repid = ct.getBoxedRepositoryID(); 1745 } 1746 1747 p.pln( "#pragma ID " + t.getIDLName() + " \"" + 1748 repid + "\"" ); 1749 } 1750 1751 /** 1752 * Write inheritance for an IDL interface or valuetype. Any class 1753 * inheritance precedes any interface inheritance. 1754 * For a valutype any inheritance from abstract interfaces then 1755 * follows the "supports" keyword. 1756 * @param inhHash Hashtable loaded with inherited Types 1757 * @param forValuetype true if writing inheritance for a valuetype 1758 * @param p The output stream. 1759 */ 1760 protected void writeInherits( 1761 Hashtable inhHash, 1762 boolean forValuetype, 1763 IndentingWriter p ) 1764 throws IOException { 1765 int itot = inhHash.size(); 1766 int iinh = 0; 1767 int isup = 0; 1768 if ( itot < 1 ) return; //any inheritance to write? 1769 Enumeration inhEnum = inhHash.elements(); 1770 CompoundType ct; 1771 if ( forValuetype ) 1772 while ( inhEnum.hasMoreElements() ) { 1773 ct = (CompoundType)inhEnum.nextElement(); 1774 if ( ct.getTypeCode() == TYPE_ABSTRACT ) isup++; 1775 } 1776 iinh = itot - isup; 1777 1778 if ( iinh > 0 ) { 1779 p.p( ": " ); 1780 inhEnum = inhHash.elements(); 1781 while ( inhEnum.hasMoreElements() ) { //write any class inheritance 1782 ct = (CompoundType)inhEnum.nextElement(); 1783 if ( ct.isClass() ) { 1784 p.p( getQualifiedIDLName( ct ) ); 1785 if ( iinh > 1 ) p.p( ", " ); //delimit them with commas 1786 else if ( itot > 1 ) p.p( " " ); 1787 break; //only one parent 1788 } 1789 } 1790 int i = 0; 1791 inhEnum = inhHash.elements(); 1792 while ( inhEnum.hasMoreElements() ) { //write any interface inheritance 1793 ct = (CompoundType)inhEnum.nextElement(); 1794 if ( !ct.isClass() && 1795 !( ct.getTypeCode() == TYPE_ABSTRACT ) ) { 1796 if ( i++ > 0 ) p.p( ", " ); //delimit with commas 1797 p.p( getQualifiedIDLName( ct ) ); 1798 } 1799 } 1800 } 1801 if ( isup > 0 ) { //write abstract interface inheritance 1802 p.p( " supports " ); 1803 int i = 0; 1804 inhEnum = inhHash.elements(); 1805 while ( inhEnum.hasMoreElements() ) { 1806 ct = (CompoundType)inhEnum.nextElement(); 1807 if ( ct.getTypeCode() == TYPE_ABSTRACT ) { 1808 if ( i++ > 0 ) p.p( ", " ); //delimit with commas 1809 p.p( getQualifiedIDLName( ct ) ); 1810 } 1811 } 1812 } 1813 } 1814 1815 1816 /** 1817 * Write an IDL constant 1818 * @param constant The current CompoundType.Member constant 1819 * @param p The output stream. 1820 */ 1821 protected void writeConstant( 1822 CompoundType.Member constant, 1823 IndentingWriter p ) 1824 throws IOException { 1825 Type t = constant.getType(); 1826 p.p( "const " ); 1827 p.p( getQualifiedIDLName( t ) ); 1828 p.p( " " + constant.getIDLName() + " = " + constant.getValue() ); 1829 p.pln( ";" ); 1830 } 1831 1832 1833 1834 /** 1835 * Write an IDL data member 1836 * @param data The current CompoundType.Member data member 1837 * @param p The output stream. 1838 */ 1839 protected void writeData( 1840 CompoundType.Member data, 1841 IndentingWriter p ) 1842 throws IOException { 1843 if ( data.isInnerClassDeclaration() ) return; //ignore 1844 Type t = data.getType(); 1845 if ( data.isPublic() ) 1846 p.p( "public " ); 1847 else p.p( "private " ); 1848 p.pln( getQualifiedIDLName( t ) + " " + 1849 data.getIDLName() + ";" ); 1850 } 1851 1852 1853 1854 /** 1855 * Write an IDL Attribute 1856 * @param attr The current CompoundType.Method attribute 1857 * @param p The output stream. 1858 */ 1859 protected void writeAttribute( 1860 CompoundType.Method attr, 1861 IndentingWriter p ) 1862 throws IOException { 1863 if ( attr.getAttributeKind() == ATTRIBUTE_SET ) return; //use getters only 1864 Type t = attr.getReturnType(); 1865 if ( !attr.isReadWriteAttribute() ) p.p( "readonly " ); 1866 p.p( "attribute " + getQualifiedIDLName( t ) + " " ); 1867 p.pln( attr.getAttributeName() + ";" ); 1868 } 1869 1870 1871 1872 /** 1873 * Write an IDL method 1874 * @param method The current CompoundType.Method 1875 * @param p The output stream. 1876 */ 1877 protected void writeMethod( 1878 CompoundType.Method method, 1879 IndentingWriter p ) 1880 throws IOException { 1881 if ( method.isAttribute() ) { 1882 writeAttribute( method,p ); 1883 return; 1884 } 1885 Type[] pts = method.getArguments(); 1886 String[] paramNames = method.getArgumentNames(); 1887 Type rt = method.getReturnType(); 1888 Hashtable excHash = new Hashtable(); 1889 getExceptions( method,excHash ); 1890 1891 if ( method.isConstructor() ) 1892 if ( factory ) p.p( "factory " + method.getIDLName() + "(" ); 1893 else p.p( "init(" ); //IDL initializer 1894 else { 1895 p.p( getQualifiedIDLName( rt ) ); 1896 p.p( " " + method.getIDLName() + "(" ); 1897 } 1898 p.pI(); 1899 1900 for ( int i=0; i < pts.length; i++ ) { 1901 if ( i > 0 ) p.pln( "," ); //delimit with comma and newline 1902 else p.pln(); 1903 p.p( "in " ); 1904 p.p( getQualifiedIDLName( pts[i] ) ); 1905 p.p( " " + paramNames[i] ); 1906 } 1907 p.pO(); 1908 p.p( " )" ); 1909 1910 if ( excHash.size() > 0 ) { //any exceptions to write? 1911 p.pln( " raises (" ); 1912 p.pI(); 1913 int i = 0; 1914 Enumeration excEnum = excHash.elements(); 1915 while ( excEnum.hasMoreElements() ) { 1916 ValueType exc = (ValueType)excEnum.nextElement(); 1917 if ( i > 0 ) p.pln( "," ); //delimit them with commas 1918 if ( exc.isIDLEntityException() ) 1919 if ( exc.isCORBAUserException() ) 1920 p.p( "::org::omg::CORBA::UserEx" ); 1921 else { 1922 String[] modNames = getIDLModuleNames( exc ); 1923 for ( int i2 = 0; i2 < modNames.length; i2++ ) 1924 p.p( IDL_NAME_SEPARATOR + modNames[i2] ); 1925 p.p( IDL_NAME_SEPARATOR + exc.getName() ); 1926 } 1927 else p.p( exc.getQualifiedIDLExceptionName( true ) ); 1928 i++; 1929 } 1930 p.pO(); 1931 p.p( " )" ); 1932 } 1933 1934 p.pln( ";" ); 1935 } 1936 1937 1938 /** 1939 * Remove escape character ("_"), if any, from given String 1940 * @param name Given String 1941 * @return String with any escape character removed 1942 */ 1943 protected String unEsc( 1944 String name ) { 1945 if ( name.startsWith( "_" ) ) return name.substring( 1 ); 1946 else return name; 1947 } 1948 1949 1950 /** 1951 * Write IDL banner into the output stream for a given Type 1952 * @param t The given Type. 1953 * @param dim The dimension required if t is an ArrayType. 1954 * @param isException true if writing an exception. 1955 * @param p The output stream. 1956 */ 1957 protected void writeBanner( 1958 Type t, 1959 int dim, 1960 boolean isException, 1961 IndentingWriter p ) 1962 throws IOException { 1963 String[] modNames = getIDLModuleNames( t ); //module name array 1964 String fName = unEsc( t.getIDLName() ); //file name default 1965 if ( isException && t.isClass() ) { 1966 ClassType ct = (ClassType)t; //file name for Exception 1967 fName = unEsc( ct.getIDLExceptionName() ); 1968 } 1969 if ( dim > 0 && t.isArray() ) { 1970 Type et = t.getElementType(); //file name for sequence 1971 fName = "seq" + dim + "_" + unEsc( et.getIDLName().replace( ' ','_' ) ); 1972 } 1973 1974 p.pln( "/**" ); 1975 p.p( " * " ); 1976 for ( int i1 = 0; i1 < modNames.length; i1++ ) 1977 p.p( modNames[i1] + "/" ); 1978 p.pln( fName + ".idl" ); 1979 p.pln( " * Generated by rmic -idl. Do not edit" ); 1980 String d = DateFormat.getDateTimeInstance( 1981 DateFormat.FULL,DateFormat.FULL,Locale.getDefault() ) 1982 .format( new Date() ); 1983 String ocStr = "o'clock"; 1984 int ocx = d.indexOf( ocStr ); //remove unwanted o'clock, if any 1985 p.p ( " * " ); 1986 if ( ocx > -1 ) 1987 p.pln( d.substring( 0,ocx ) + d.substring( ocx + ocStr.length() ) ); 1988 else p.pln( d ); 1989 p.pln( " */" ); 1990 p.pln(); 1991 } 1992 1993 1994 /** 1995 * Write #include for orb.idl 1996 * @param p The output stream. 1997 */ 1998 protected void writeIncOrb( 1999 IndentingWriter p ) 2000 throws IOException { 2001 p.pln( "#include \"orb.idl\"" ); 2002 } 2003 2004 2005 /** 2006 * Write #ifndef guard into the output stream for a given Type 2007 * @param t The given Type. 2008 * @param dim The dimension required if t is an ArrayType. 2009 * @param isException true if writing an exception. 2010 * @param isForward. No #define needed if it's a forward declare 2011 * @param p The output stream. 2012 */ 2013 protected void writeIfndef( 2014 Type t, 2015 int dim, 2016 boolean isException, 2017 boolean isForward, 2018 IndentingWriter p ) 2019 throws IOException { 2020 String[] modNames = getIDLModuleNames( t ); //module name array 2021 String fName = unEsc( t.getIDLName() ); //file name default 2022 if ( isException && t.isClass() ) { 2023 ClassType ct = (ClassType)t; //file name for Exception 2024 fName = unEsc( ct.getIDLExceptionName() ); 2025 } 2026 if ( dim > 0 && t.isArray() ) { 2027 Type et = t.getElementType(); //file name for sequence 2028 fName = "seq" + dim + "_" + unEsc( et.getIDLName().replace( ' ','_' ) ); 2029 } 2030 p.pln(); 2031 p.p( "#ifndef __" ); 2032 for ( int i = 0; i < modNames.length; i++ ) p.p( modNames[i] + "_" ); 2033 p.pln( fName + "__" ); 2034 if ( !isForward ) { 2035 p.p( "#define __" ); 2036 for ( int i = 0; i < modNames.length; i++ ) p.p( modNames[i] + "_" ); 2037 p.pln( fName + "__" ); 2038 p.pln(); 2039 } 2040 } 2041 2042 2043 /** 2044 * Write #endif bracket into the output stream 2045 * @param p The output stream. 2046 */ 2047 protected void writeEndif( 2048 IndentingWriter p ) 2049 throws IOException { 2050 p.pln("#endif"); 2051 p.pln(); 2052 } 2053 2054 /** 2055 * Write Module start bracketing for the given type into the output stream 2056 * @param t The given Type 2057 * @param p The output stream. 2058 */ 2059 protected void writeModule1( 2060 Type t, 2061 IndentingWriter p ) 2062 throws IOException { 2063 2064 String[] modNames = getIDLModuleNames( t ); 2065 p.pln(); 2066 for ( int i = 0; i < modNames.length; i++ ) 2067 p.pln( "module " + modNames[i] + " {" ); 2068 } 2069 2070 /** 2071 * Write Module end bracketing for the given type into the output stream 2072 * @param t The given Type 2073 * @param p The output stream. 2074 */ 2075 protected void writeModule2( 2076 Type t, 2077 IndentingWriter p ) 2078 throws IOException { 2079 String[] modNames = getIDLModuleNames( t ); 2080 for ( int i=0; i < modNames.length; i++ ) p.pln( "};" ); 2081 p.pln(); 2082 } 2083 2084} 2085