|
1 /* |
|
2 * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. Oracle designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Oracle in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 * or visit www.oracle.com if you need additional information or have any |
|
23 * questions. |
|
24 */ |
|
25 /* |
|
26 * Licensed Materials - Property of IBM |
|
27 * RMI-IIOP v1.0 |
|
28 * Copyright IBM Corp. 1998 1999 All Rights Reserved |
|
29 * |
|
30 */ |
|
31 |
|
32 package sun.rmi.rmic.iiop; |
|
33 |
|
34 import java.io.File; |
|
35 import java.io.IOException; |
|
36 import java.text.DateFormat; |
|
37 import java.util.Date; |
|
38 import java.util.Enumeration; |
|
39 import java.util.Hashtable; |
|
40 import java.util.Locale; |
|
41 import java.util.StringTokenizer; |
|
42 import java.util.Vector; |
|
43 import sun.tools.java.Identifier; |
|
44 import sun.tools.java.ClassDefinition; |
|
45 import sun.tools.java.CompilerError; |
|
46 import sun.rmi.rmic.IndentingWriter; |
|
47 import java.util.HashSet; |
|
48 import sun.rmi.rmic.Main; |
|
49 |
|
50 /** |
|
51 * An IDL generator for rmic. |
|
52 * |
|
53 * @author Steve Newberry, Bryan Atsatt |
|
54 */ |
|
55 public class IDLGenerator extends sun.rmi.rmic.iiop.Generator { |
|
56 |
|
57 private boolean valueMethods = true; |
|
58 private boolean factory = true; //init==!factory |
|
59 private Hashtable ifHash = new Hashtable(); //IDL file Hashtable |
|
60 private Hashtable imHash = new Hashtable(); //IDL module Hashtable |
|
61 |
|
62 private boolean isThrown = true; //flag for writeInclude |
|
63 private boolean isException = true; //flag for writeBanner, writeIfndef |
|
64 private boolean isForward = true; //flag for writeIfndef |
|
65 private boolean forValuetype = true; //flag for writeInherits |
|
66 |
|
67 /** |
|
68 * Default constructor for Main to use. |
|
69 */ |
|
70 public IDLGenerator() { |
|
71 } |
|
72 |
|
73 |
|
74 /** |
|
75 * Return true if a new instance should be created for each |
|
76 * class on the command line. Subclasses which return true |
|
77 * should override newInstance() to return an appropriately |
|
78 * constructed instance. |
|
79 */ |
|
80 protected boolean requireNewInstance() { |
|
81 return false; |
|
82 } |
|
83 |
|
84 /** |
|
85 * Return true if non-conforming types should be parsed. |
|
86 * @param stack The context stack. |
|
87 */ |
|
88 protected boolean parseNonConforming(ContextStack stack) { |
|
89 return valueMethods; |
|
90 } |
|
91 |
|
92 /** |
|
93 * Create and return a top-level type. |
|
94 * @param env The compiler environment. |
|
95 * @param cdef The top-level class definition. |
|
96 * @return An RemoteType or null if is non-conforming. |
|
97 */ |
|
98 protected sun.rmi.rmic.iiop.CompoundType getTopType(ClassDefinition cdef, |
|
99 ContextStack stack) { |
|
100 return CompoundType.forCompound(cdef,stack); |
|
101 } |
|
102 |
|
103 |
|
104 /** |
|
105 * Return an Identifier which contains the fully-qualified IDL filename |
|
106 * for the given OutputType. |
|
107 * The OutputType contains a filename string (not directory) and Type. |
|
108 * @param ot the OutputType for which directory nesting is to be defined. |
|
109 * @return the new identifier. |
|
110 */ |
|
111 protected Identifier getOutputId ( |
|
112 OutputType ot ) { |
|
113 Identifier id = super.getOutputId( ot ); |
|
114 |
|
115 Type t = ot.getType(); |
|
116 String fName = ot.getName(); |
|
117 |
|
118 if ( id == idJavaLangClass ) //java.lang.Class and array of |
|
119 if ( t.isArray() ) |
|
120 return Identifier.lookup( |
|
121 "org.omg.boxedRMI.javax.rmi.CORBA." + fName ); |
|
122 else return idClassDesc; |
|
123 |
|
124 if ( id == idJavaLangString && //array of java.lang.String |
|
125 t.isArray() ) |
|
126 return Identifier.lookup( "org.omg.boxedRMI.CORBA." + fName ); |
|
127 |
|
128 if ( "org.omg.CORBA.Object".equals( t.getQualifiedName() ) && |
|
129 t.isArray() ) //array of org.omg.CORBA.Object |
|
130 return Identifier.lookup( "org.omg.boxedRMI." + fName ); |
|
131 |
|
132 if ( t.isArray()) { //array |
|
133 ArrayType at = (ArrayType)t; |
|
134 Type et = at.getElementType(); |
|
135 if ( et.isCompound() ) { |
|
136 CompoundType ct = (CompoundType)et; |
|
137 String qName = ct.getQualifiedName(); |
|
138 if ( ct.isIDLEntity() ) |
|
139 return Identifier.lookup( getQualifiedName( at ) ); |
|
140 } |
|
141 return Identifier.lookup( idBoxedRMI,id ); |
|
142 } |
|
143 |
|
144 if ( t.isCompound() ) { //boxed IDLEntity |
|
145 CompoundType ct = (CompoundType)t; |
|
146 String qName = ct.getQualifiedName(); |
|
147 if ( ct.isBoxed() ) |
|
148 return Identifier.lookup( getQualifiedName( ct ) ); |
|
149 } |
|
150 |
|
151 return id; |
|
152 } |
|
153 |
|
154 |
|
155 |
|
156 /** |
|
157 * Return the file name extension for the given file name (e.g. ".java"). |
|
158 * All files generated with the ".java" extension will be compiled. To |
|
159 * change this behavior for ".java" files, override the compileJavaSourceFile |
|
160 * method to return false. |
|
161 * @param outputType One of the items returned by getOutputTypesFor(...) |
|
162 */ |
|
163 protected String getFileNameExtensionFor(OutputType outputType) { |
|
164 return IDL_FILE_EXTENSION; |
|
165 } |
|
166 |
|
167 |
|
168 /** |
|
169 * Examine and consume command line arguments. |
|
170 * @param argv The command line arguments. Ignore null |
|
171 * and unknown arguments. Set each consumed argument to null. |
|
172 * @param error Report any errors using the main.error() methods. |
|
173 * @return true if no errors, false otherwise. |
|
174 */ |
|
175 public boolean parseArgs(String argv[], Main main) { |
|
176 boolean result = super.parseArgs(argv,main); |
|
177 String idlFrom; |
|
178 String idlTo; |
|
179 if (result) { |
|
180 nextArg: |
|
181 for (int i = 0; i < argv.length; i++) { |
|
182 if (argv[i] != null) { |
|
183 if (argv[i].equalsIgnoreCase("-idl")) { |
|
184 idl = true; |
|
185 argv[i] = null; |
|
186 } |
|
187 else if ( argv[i].equalsIgnoreCase( "-valueMethods" ) ) { |
|
188 valueMethods = true; |
|
189 argv[i] = null; |
|
190 } |
|
191 else if ( argv[i].equalsIgnoreCase( "-noValueMethods" ) ) { |
|
192 valueMethods = false; |
|
193 argv[i] = null; |
|
194 } |
|
195 else if ( argv[i].equalsIgnoreCase( "-init" ) ) { |
|
196 factory = false; |
|
197 argv[i] = null; |
|
198 } |
|
199 else if ( argv[i].equalsIgnoreCase( "-factory" ) ) { |
|
200 factory = true; |
|
201 argv[i] = null; |
|
202 } |
|
203 else if ( argv[i].equalsIgnoreCase( "-idlfile" ) ) { |
|
204 argv[i] = null; |
|
205 if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { |
|
206 idlFrom = argv[i]; |
|
207 argv[i] = null; |
|
208 if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { |
|
209 idlTo = argv[i]; |
|
210 argv[i] = null; |
|
211 ifHash.put( idlFrom,idlTo ); |
|
212 continue nextArg; |
|
213 } |
|
214 } |
|
215 main.error("rmic.option.requires.argument", "-idlfile"); |
|
216 result = false; |
|
217 } |
|
218 else if ( argv[i].equalsIgnoreCase( "-idlmodule" ) ) { |
|
219 argv[i] = null; |
|
220 if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { |
|
221 idlFrom = argv[i]; |
|
222 argv[i] = null; |
|
223 if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) { |
|
224 idlTo = argv[i]; |
|
225 argv[i] = null; |
|
226 imHash.put( idlFrom,idlTo ); |
|
227 continue nextArg; |
|
228 } |
|
229 } |
|
230 main.error("rmic.option.requires.argument", "-idlmodule"); |
|
231 result = false; |
|
232 } |
|
233 |
|
234 |
|
235 } |
|
236 } |
|
237 } |
|
238 return result; |
|
239 } |
|
240 |
|
241 |
|
242 |
|
243 /** |
|
244 * Return an array of OutputTypes for the IDL files that need to be |
|
245 * generated for the given top-level type. |
|
246 * OutputTypes contain filename string (not directory) and Type. |
|
247 * @param topType The type returned by getTopType(). |
|
248 * @param alreadyChecked A set of Types which have already been checked. |
|
249 * @return Array of OutputTypes to generate |
|
250 */ |
|
251 protected OutputType[] getOutputTypesFor( |
|
252 CompoundType topType, |
|
253 HashSet alreadyChecked ) { |
|
254 Vector refVec = getAllReferencesFor( topType ); |
|
255 Vector outVec = new Vector(); |
|
256 for ( int i1 = 0; i1 < refVec.size(); i1++ ) { //forall references |
|
257 Type t = (Type)refVec.elementAt( i1 ); |
|
258 if ( t.isArray() ) { |
|
259 ArrayType at = (ArrayType)t; |
|
260 int dim = at.getArrayDimension(); |
|
261 Type et = at.getElementType(); |
|
262 String fName = unEsc( et.getIDLName() ).replace( ' ','_' ); |
|
263 for ( int i2 = 0; i2 < dim; i2++ ) { //foreach dimension |
|
264 String fileName = "seq" + ( i2 + 1 ) + "_" + fName; |
|
265 outVec.addElement( new OutputType( fileName,at ) ); |
|
266 } |
|
267 } |
|
268 else if ( t.isCompound() ) { |
|
269 String fName = unEsc( t.getIDLName() ); |
|
270 outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) ); |
|
271 if ( t.isClass() ) { |
|
272 ClassType ct = (ClassType)t; |
|
273 if ( ct.isException() ) { //exception file |
|
274 fName = unEsc( ct.getIDLExceptionName() ); |
|
275 outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) ); |
|
276 } |
|
277 } |
|
278 } |
|
279 } |
|
280 OutputType[] outArr = new OutputType[outVec.size()]; |
|
281 outVec.copyInto( outArr ); |
|
282 return outArr; |
|
283 } |
|
284 |
|
285 /** |
|
286 * Get all referenced types of a given tyoe for which an IDL file needs |
|
287 * to be generated. |
|
288 * @param ct The given type. |
|
289 * @return Vector of Types for which IDL must be generated. |
|
290 */ |
|
291 protected Vector getAllReferencesFor( |
|
292 CompoundType ct ) { |
|
293 Hashtable refHash = new Hashtable(); |
|
294 Hashtable spcHash = new Hashtable(); |
|
295 Hashtable arrHash = new Hashtable(); |
|
296 int refSize; |
|
297 refHash.put( ct.getQualifiedName(),ct ); //put the given type |
|
298 accumulateReferences( refHash,spcHash,arrHash ); |
|
299 do { |
|
300 refSize = refHash.size(); |
|
301 accumulateReferences( refHash,spcHash,arrHash ); |
|
302 } |
|
303 while ( refSize < refHash.size() ); //till hashtable stays same size |
|
304 |
|
305 Vector outVec = new Vector(); |
|
306 Enumeration e = refHash.elements(); //ordinary references |
|
307 while ( e.hasMoreElements() ) { |
|
308 CompoundType t = (CompoundType)e.nextElement(); |
|
309 outVec.addElement( t ); |
|
310 } |
|
311 e = spcHash.elements(); //special references |
|
312 while ( e.hasMoreElements() ) { |
|
313 CompoundType t = (CompoundType)e.nextElement(); |
|
314 outVec.addElement( t ); |
|
315 } |
|
316 e = arrHash.elements(); //array references |
|
317 nextSequence: |
|
318 while ( e.hasMoreElements() ) { |
|
319 ArrayType at = (ArrayType)e.nextElement(); |
|
320 int dim = at.getArrayDimension(); |
|
321 Type et = at.getElementType(); |
|
322 Enumeration e2 = arrHash.elements(); |
|
323 while ( e2.hasMoreElements() ) { //eliminate duplicates |
|
324 ArrayType at2 = (ArrayType)e2.nextElement(); |
|
325 if ( et == at2.getElementType() && //same element type & |
|
326 dim < at2.getArrayDimension() ) //smaller dimension? |
|
327 continue nextSequence; //ignore this one |
|
328 } |
|
329 outVec.addElement( at ); |
|
330 } |
|
331 return outVec; |
|
332 } |
|
333 |
|
334 |
|
335 /** |
|
336 * Accumulate and filter all those types that are referenced by the given |
|
337 * referenced types. |
|
338 * Keep only those for which IDL is to be generated. |
|
339 * @param refHash Hashtable containing the given types |
|
340 * @param spcHash Hashtable containing referenced specials (IDL typedefs) |
|
341 * @param arrHash Hashtable containing referenced arrays (dimensioned) |
|
342 */ |
|
343 protected void accumulateReferences( |
|
344 Hashtable refHash, |
|
345 Hashtable spcHash, |
|
346 Hashtable arrHash ) { |
|
347 Enumeration e = refHash.elements(); |
|
348 while ( e.hasMoreElements() ) { |
|
349 CompoundType t = (CompoundType)e.nextElement(); |
|
350 Vector datVec = getData( t ); //collect and sort data |
|
351 Vector mthVec = getMethods( t ); //collect and filter methods |
|
352 getInterfaces( t,refHash ); //collect interfaces |
|
353 getInheritance( t,refHash ); //add inheritance |
|
354 getMethodReferences( mthVec,refHash,spcHash,arrHash,refHash ); |
|
355 getMemberReferences( datVec,refHash,spcHash,arrHash ); |
|
356 } |
|
357 e = arrHash.elements(); //add array element references |
|
358 while ( e.hasMoreElements() ) { |
|
359 ArrayType at = (ArrayType)e.nextElement(); |
|
360 Type et = at.getElementType(); |
|
361 addReference( et,refHash,spcHash,arrHash ); |
|
362 } |
|
363 e = refHash.elements(); |
|
364 while ( e.hasMoreElements() ) { |
|
365 CompoundType t = (CompoundType)e.nextElement(); |
|
366 if ( !isIDLGeneratedFor( t ) ) //remove if no IDL generation |
|
367 refHash.remove( t.getQualifiedName() ); |
|
368 } |
|
369 } |
|
370 |
|
371 |
|
372 |
|
373 /** |
|
374 * Determine if IDL should be generated for a referenced type. |
|
375 * Do not generate IDL for a CORBA Object reference. It gets mapped |
|
376 * to the original IDL or to Object (if exactly org.omg.CORBA.Object) |
|
377 * Generate (boxed) IDL for an IDL Entity unless it is an IDL user |
|
378 * exception, a ValueBase, an AbstractBase (or a CORBA Object). |
|
379 * Do not generate IDL for Implementation classes..unless they inherit |
|
380 * from multiple distinct remote interfaces |
|
381 * @param t The type to check. |
|
382 * @return true or false |
|
383 */ |
|
384 protected boolean isIDLGeneratedFor( |
|
385 CompoundType t ) { |
|
386 if ( t.isCORBAObject() ) return false; |
|
387 if ( t.isIDLEntity() ) |
|
388 if ( t.isBoxed() ) return true; |
|
389 else if ( "org.omg.CORBA.portable.IDLEntity" |
|
390 .equals( t.getQualifiedName() ) ) return true; |
|
391 else if ( t.isCORBAUserException() ) return true; |
|
392 else return false; |
|
393 Hashtable inhHash = new Hashtable(); |
|
394 getInterfaces( t,inhHash ); |
|
395 if ( t.getTypeCode() == TYPE_IMPLEMENTATION ) |
|
396 if ( inhHash.size() < 2 ) return false; //no multiple inheritance |
|
397 else return true; |
|
398 return true; //generate IDL for this type |
|
399 } |
|
400 |
|
401 |
|
402 /** |
|
403 * Write the output for the given OutputFileName into the output stream. |
|
404 * (The IDL mapping for java.lang.Class is generated from |
|
405 * javax.rmi.CORBA.ClassDesc in the tools workspace) |
|
406 * @param OutputType ot One of the items returned by getOutputTypesFor(...) |
|
407 * @param alreadyChecked A set of Types which have already been checked. |
|
408 * Intended to be passed to Type.collectMatching(filter,alreadyChecked). |
|
409 * @param p The output stream. |
|
410 */ |
|
411 protected void writeOutputFor( |
|
412 OutputType ot, |
|
413 HashSet alreadyChecked, |
|
414 IndentingWriter p ) |
|
415 throws IOException { |
|
416 Type t = ot.getType(); |
|
417 if ( t.isArray() ) { //specialcase: sequence |
|
418 writeSequence( ot,p ); |
|
419 return; |
|
420 } |
|
421 if ( isSpecialReference( t ) ) { //specialcase: IDL typecode |
|
422 writeSpecial( t,p ); |
|
423 return; |
|
424 } |
|
425 if ( t.isCompound() ) { //specialcase: boxed IDL |
|
426 CompoundType ct = (CompoundType)t; |
|
427 if ( ct.isIDLEntity() && ct.isBoxed() ) { |
|
428 writeBoxedIDL( ct,p ); |
|
429 return; |
|
430 } |
|
431 } |
|
432 if ( t.isClass() ) { //specialcase: exception |
|
433 ClassType ct = (ClassType)t; |
|
434 if ( ct.isException() ) { |
|
435 String eName = unEsc( ct.getIDLExceptionName() ); |
|
436 String fName = ot.getName(); |
|
437 if ( fName.equals( eName.replace( ' ','_' ) ) ) { |
|
438 writeException( ct,p ); |
|
439 return; |
|
440 } |
|
441 } |
|
442 } |
|
443 switch ( t.getTypeCode() ) { //general case |
|
444 case TYPE_IMPLEMENTATION: |
|
445 writeImplementation( (ImplementationType)t,p ); |
|
446 break; |
|
447 case TYPE_NC_CLASS: |
|
448 case TYPE_NC_INTERFACE: |
|
449 writeNCType( (CompoundType)t,p ); |
|
450 break; |
|
451 case TYPE_ABSTRACT: //AbstractType is a RemoteType |
|
452 case TYPE_REMOTE: |
|
453 writeRemote( (RemoteType)t,p ); |
|
454 break; |
|
455 case TYPE_VALUE: |
|
456 writeValue( (ValueType)t,p ); |
|
457 break; |
|
458 default: |
|
459 throw new CompilerError( |
|
460 "IDLGenerator got unexpected type code: " |
|
461 + t.getTypeCode()); |
|
462 } |
|
463 } |
|
464 |
|
465 |
|
466 /** |
|
467 * Write an IDL interface definition for a Java implementation class |
|
468 * @param t The current ImplementationType |
|
469 * @param p The output stream. |
|
470 */ |
|
471 protected void writeImplementation( |
|
472 ImplementationType t, |
|
473 IndentingWriter p ) |
|
474 throws IOException { |
|
475 Hashtable inhHash = new Hashtable(); |
|
476 Hashtable refHash = new Hashtable(); |
|
477 getInterfaces( t,inhHash ); //collect interfaces |
|
478 |
|
479 writeBanner( t,0,!isException,p ); |
|
480 writeInheritedIncludes( inhHash,p ); |
|
481 writeIfndef( t,0,!isException,!isForward,p ); |
|
482 writeIncOrb( p ); |
|
483 writeModule1( t,p ); |
|
484 p.pln();p.pI(); |
|
485 p.p( "interface " + t.getIDLName() ); |
|
486 writeInherits( inhHash,!forValuetype,p ); |
|
487 |
|
488 p.pln( " {" ); |
|
489 p.pln( "};" ); |
|
490 |
|
491 p.pO();p.pln(); |
|
492 writeModule2( t,p ); |
|
493 writeEpilog( t,refHash,p ); |
|
494 } |
|
495 |
|
496 |
|
497 /** |
|
498 * Write an IDL valuetype definition for |
|
499 * 1) a nonconforming Java class |
|
500 * 2) a nonconforming Java interface (that is not an AbstractType) |
|
501 * @param t The current NC Type (NCClassType or NCInterfaceType) |
|
502 * @param p The output stream. |
|
503 */ |
|
504 protected void writeNCType( |
|
505 CompoundType t, |
|
506 IndentingWriter p ) |
|
507 throws IOException { |
|
508 Vector conVec = getConstants( t ); //collect constants |
|
509 Vector mthVec = getMethods( t ); //collect methods |
|
510 Hashtable inhHash = new Hashtable(); |
|
511 Hashtable refHash = new Hashtable(); |
|
512 Hashtable spcHash = new Hashtable(); |
|
513 Hashtable arrHash = new Hashtable(); |
|
514 Hashtable excHash = new Hashtable(); |
|
515 getInterfaces( t,inhHash ); //collect interfaces |
|
516 getInheritance( t,inhHash ); //add inheritance |
|
517 getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash ); |
|
518 |
|
519 writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p ); |
|
520 writeModule1( t,p ); |
|
521 p.pln();p.pI(); |
|
522 p.p( "abstract valuetype " + t.getIDLName() ); |
|
523 writeInherits( inhHash,!forValuetype,p ); |
|
524 |
|
525 p.pln( " {" ); |
|
526 if ( conVec.size() + mthVec.size() > 0 ) { //any content? |
|
527 p.pln();p.pI(); |
|
528 for ( int i1 = 0; i1 < conVec.size(); i1++ ) //write constants |
|
529 writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p ); |
|
530 for ( int i1 = 0; i1 < mthVec.size(); i1++ ) //write methods |
|
531 writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p ); |
|
532 p.pO();p.pln(); |
|
533 } |
|
534 p.pln( "};" ); |
|
535 |
|
536 p.pO();p.pln(); |
|
537 writeModule2( t,p ); |
|
538 writeEpilog( t,refHash,p ); |
|
539 } |
|
540 |
|
541 |
|
542 /** |
|
543 * Write an IDL interface definition for either: |
|
544 * 1) a conforming Java remote interface (RemoteType)..or |
|
545 * 2) a non-conforming Java interface whose methods all throw |
|
546 * java.rmi.RemoteException (AbstractType) |
|
547 * @param t The current RemoteType |
|
548 * @param p The output stream. |
|
549 */ |
|
550 protected void writeRemote( |
|
551 RemoteType t, |
|
552 IndentingWriter p ) |
|
553 throws IOException { |
|
554 Vector conVec = getConstants( t ); //collect constants |
|
555 Vector mthVec = getMethods( t ); //collect methods |
|
556 Hashtable inhHash = new Hashtable(); |
|
557 Hashtable refHash = new Hashtable(); |
|
558 Hashtable spcHash = new Hashtable(); |
|
559 Hashtable arrHash = new Hashtable(); |
|
560 Hashtable excHash = new Hashtable(); |
|
561 getInterfaces( t,inhHash ); //collect interfaces |
|
562 getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash ); |
|
563 |
|
564 writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p ); |
|
565 writeModule1( t,p ); |
|
566 p.pln();p.pI(); |
|
567 if ( t.getTypeCode() == TYPE_ABSTRACT ) p.p( "abstract " ); |
|
568 p.p( "interface " + t.getIDLName() ); |
|
569 writeInherits( inhHash,!forValuetype,p ); |
|
570 |
|
571 p.pln( " {" ); |
|
572 if ( conVec.size() + mthVec.size() > 0 ) { //any constants or methods? |
|
573 p.pln();p.pI(); |
|
574 for ( int i1 = 0; i1 < conVec.size(); i1++ ) //constants |
|
575 writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p ); |
|
576 for ( int i1 = 0; i1 < mthVec.size(); i1++ ) //methods, attributes |
|
577 writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p ); |
|
578 p.pO();p.pln(); |
|
579 } |
|
580 p.pln( "};" ); |
|
581 |
|
582 p.pO();p.pln(); |
|
583 writeRepositoryID ( t,p ); |
|
584 p.pln(); |
|
585 writeModule2( t,p ); |
|
586 writeEpilog( t,refHash,p ); |
|
587 } |
|
588 |
|
589 |
|
590 /** |
|
591 * Write an IDL valuetype definition for a conforming Java class. |
|
592 * Methods and constructors are optional..controlled by -valueMethods flag |
|
593 * @param t The current ValueType |
|
594 * @param p The output stream. |
|
595 */ |
|
596 protected void writeValue( |
|
597 ValueType t, |
|
598 IndentingWriter p ) |
|
599 throws IOException { |
|
600 Vector datVec = getData( t ); //collect and sort data |
|
601 Vector conVec = getConstants( t ); //collect constants |
|
602 Vector mthVec = getMethods( t ); //collect and filter methods |
|
603 Hashtable inhHash = new Hashtable(); |
|
604 Hashtable refHash = new Hashtable(); |
|
605 Hashtable spcHash = new Hashtable(); |
|
606 Hashtable arrHash = new Hashtable(); |
|
607 Hashtable excHash = new Hashtable(); |
|
608 getInterfaces( t,inhHash ); //collect interfaces |
|
609 getInheritance( t,inhHash ); //add inheritance |
|
610 getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash ); |
|
611 getMemberReferences( datVec,refHash,spcHash,arrHash ); |
|
612 |
|
613 writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p ); |
|
614 writeModule1( t,p ); |
|
615 p.pln();p.pI(); |
|
616 if ( t.isCustom() ) p.p( "custom " ); |
|
617 p.p( "valuetype " + t.getIDLName() ); |
|
618 writeInherits( inhHash,forValuetype,p ); |
|
619 |
|
620 p.pln( " {" ); |
|
621 if ( conVec.size() + datVec.size() + mthVec.size() > 0 ) { //any content? |
|
622 p.pln();p.pI(); |
|
623 for ( int i1 = 0; i1 < conVec.size(); i1++ ) //write constants |
|
624 writeConstant( (CompoundType.Member)conVec.elementAt( i1 ),p ); |
|
625 for ( int i1 = 0; i1 < datVec.size(); i1++ ) { |
|
626 CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 ); |
|
627 if ( mem.getType().isPrimitive() ) |
|
628 writeData( mem,p ); //write primitive data |
|
629 } |
|
630 for ( int i1 = 0; i1 < datVec.size(); i1++ ) { |
|
631 CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 ); |
|
632 if ( !mem.getType().isPrimitive() ) |
|
633 writeData( mem,p ); //write non-primitive data |
|
634 } |
|
635 for ( int i1 = 0; i1 < mthVec.size(); i1++ ) //write methods |
|
636 writeMethod( (CompoundType.Method)mthVec.elementAt( i1 ),p ); |
|
637 p.pO();p.pln(); |
|
638 } |
|
639 p.pln( "};" ); |
|
640 |
|
641 p.pO();p.pln(); |
|
642 writeRepositoryID ( t,p ); |
|
643 p.pln(); |
|
644 writeModule2( t,p ); |
|
645 writeEpilog( t,refHash,p ); |
|
646 } |
|
647 |
|
648 |
|
649 /** |
|
650 * Write IDL prolog for a CompoundType. |
|
651 * @param t The CompoundType. |
|
652 * @param refHash Hashtable loaded with type references. |
|
653 * @param spcHash Hashtable loaded with special type references. |
|
654 * @param arrHash Hashtable loaded with array references. |
|
655 * @param excHash Hashtable loaded with exceptions thrown. |
|
656 * @param inhHash Hashtable loaded with inherited types. |
|
657 * @param p The output stream. |
|
658 */ |
|
659 protected void writeProlog( |
|
660 CompoundType t, |
|
661 Hashtable refHash, |
|
662 Hashtable spcHash, |
|
663 Hashtable arrHash, |
|
664 Hashtable excHash, |
|
665 Hashtable inhHash, |
|
666 IndentingWriter p ) |
|
667 throws IOException { |
|
668 writeBanner( t,0,!isException,p ); |
|
669 writeForwardReferences( refHash,p ); |
|
670 writeIncludes( excHash,isThrown,p ); //#includes for exceptions thrown |
|
671 writeInheritedIncludes( inhHash,p ); |
|
672 writeIncludes( spcHash,!isThrown,p ); //#includes for special types |
|
673 writeBoxedRMIIncludes( arrHash,p ); |
|
674 writeIDLEntityIncludes( refHash,p ); |
|
675 writeIncOrb( p ); |
|
676 writeIfndef( t,0,!isException,!isForward,p ); |
|
677 } |
|
678 |
|
679 |
|
680 /** |
|
681 * Write IDL epilog for a CompoundType. |
|
682 * @param t The CompoundType. |
|
683 * @param refHash Hashtable loaded with type references. |
|
684 * @param p The output stream. |
|
685 */ |
|
686 protected void writeEpilog( |
|
687 CompoundType t, |
|
688 Hashtable refHash, |
|
689 IndentingWriter p ) |
|
690 throws IOException { |
|
691 writeIncludes( refHash,!isThrown,p ); //#includes for forward dcl types |
|
692 writeEndif( p ); |
|
693 } |
|
694 |
|
695 |
|
696 |
|
697 /** |
|
698 * Write special typedef |
|
699 * @param t A special Type. |
|
700 * @param p The output stream. |
|
701 */ |
|
702 protected void writeSpecial( |
|
703 Type t, |
|
704 IndentingWriter p ) |
|
705 throws IOException { |
|
706 String spcName = t.getQualifiedName(); |
|
707 if ( "java.io.Serializable".equals( spcName ) ) |
|
708 writeJavaIoSerializable( t,p ); |
|
709 else if ( "java.io.Externalizable".equals( spcName ) ) |
|
710 writeJavaIoExternalizable( t,p ); |
|
711 else if ( "java.lang.Object".equals( spcName) ) |
|
712 writeJavaLangObject( t,p ); |
|
713 else if ( "java.rmi.Remote".equals( spcName) ) |
|
714 writeJavaRmiRemote( t,p ); |
|
715 else if ( "org.omg.CORBA.portable.IDLEntity".equals( spcName) ) |
|
716 writeIDLEntity( t,p ); |
|
717 } |
|
718 |
|
719 |
|
720 |
|
721 /** |
|
722 * Write a hard-coded IDL typedef definition for the special case |
|
723 * java.io.Serializable. |
|
724 * @param t The current Type |
|
725 * @param p The output stream. |
|
726 */ |
|
727 protected void writeJavaIoSerializable( |
|
728 Type t, |
|
729 IndentingWriter p ) |
|
730 throws IOException { |
|
731 writeBanner( t,0,!isException,p ); |
|
732 writeIfndef( t,0,!isException,!isForward,p ); |
|
733 writeModule1( t,p ); |
|
734 p.pln();p.pI(); |
|
735 p.pln( "typedef any Serializable;" ); |
|
736 p.pO();p.pln(); |
|
737 writeModule2( t,p ); |
|
738 writeEndif( p ); |
|
739 } |
|
740 |
|
741 |
|
742 /** |
|
743 * Write a hard-coded IDL typedef definition for the special case |
|
744 * java.io.Externalizable. |
|
745 * @param t The current Type |
|
746 * @param p The output stream. |
|
747 */ |
|
748 protected void writeJavaIoExternalizable( |
|
749 Type t, |
|
750 IndentingWriter p ) |
|
751 throws IOException { |
|
752 writeBanner( t,0,!isException,p ); |
|
753 writeIfndef( t,0,!isException,!isForward,p ); |
|
754 writeModule1( t,p ); |
|
755 p.pln();p.pI(); |
|
756 p.pln( "typedef any Externalizable;" ); |
|
757 p.pO();p.pln(); |
|
758 writeModule2( t,p ); |
|
759 writeEndif( p ); |
|
760 } |
|
761 |
|
762 |
|
763 /** |
|
764 * Write a hard-coded IDL typedef definition for the special case |
|
765 * java.lang.Object. |
|
766 * @param t The current Type |
|
767 * @param p The output stream. |
|
768 */ |
|
769 protected void writeJavaLangObject( |
|
770 Type t, |
|
771 IndentingWriter p ) |
|
772 throws IOException { |
|
773 writeBanner( t,0,!isException,p ); |
|
774 writeIfndef( t,0,!isException,!isForward,p ); |
|
775 writeModule1( t,p ); |
|
776 p.pln();p.pI(); |
|
777 p.pln( "typedef any _Object;" ); |
|
778 p.pO();p.pln(); |
|
779 writeModule2( t,p ); |
|
780 writeEndif( p ); |
|
781 } |
|
782 |
|
783 |
|
784 /** |
|
785 * Write a hard-coded IDL typedef definition for the special case |
|
786 * java.rmi.Remote. |
|
787 * @param t The current Type |
|
788 * @param p The output stream. |
|
789 */ |
|
790 protected void writeJavaRmiRemote( |
|
791 Type t, |
|
792 IndentingWriter p ) |
|
793 throws IOException { |
|
794 writeBanner( t,0,!isException,p ); |
|
795 writeIfndef( t,0,!isException,!isForward,p ); |
|
796 writeModule1( t,p ); |
|
797 p.pln();p.pI(); |
|
798 p.pln( "typedef Object Remote;" ); |
|
799 p.pO();p.pln(); |
|
800 writeModule2( t,p ); |
|
801 writeEndif( p ); |
|
802 } |
|
803 |
|
804 |
|
805 |
|
806 /** |
|
807 * Write a hard-coded IDL typedef definition for the special case |
|
808 * org.omg.CORBA.portable.IDLEntity |
|
809 * @param t The current Type |
|
810 * @param p The output stream. |
|
811 */ |
|
812 protected void writeIDLEntity( |
|
813 Type t, |
|
814 IndentingWriter p ) |
|
815 throws IOException { |
|
816 writeBanner( t,0,!isException,p ); |
|
817 writeIfndef( t,0,!isException,!isForward,p ); |
|
818 writeModule1( t,p ); |
|
819 p.pln();p.pI(); |
|
820 p.pln( "typedef any IDLEntity;" ); |
|
821 p.pO();p.pln(); |
|
822 writeModule2( t,p ); |
|
823 writeEndif( p ); |
|
824 } |
|
825 |
|
826 |
|
827 /** |
|
828 * Filter and collect non-duplicate inherited interfaces for a type |
|
829 * @param ct The current CompoundType |
|
830 * @param inhHash Hashtable containing the inherited interfaces |
|
831 */ |
|
832 protected void getInterfaces( |
|
833 CompoundType ct, |
|
834 Hashtable inhHash ) { |
|
835 InterfaceType[] infs = ct.getInterfaces(); |
|
836 nextInterface: |
|
837 for ( int i1 = 0; i1 < infs.length; i1++ ) { //forall inherited interfaces |
|
838 String inhName = infs[i1].getQualifiedName(); |
|
839 switch ( ct.getTypeCode() ) { |
|
840 case TYPE_NC_CLASS: |
|
841 case TYPE_VALUE: //filter for classes |
|
842 if ( "java.io.Externalizable".equals( inhName ) || |
|
843 "java.io.Serializable".equals( inhName ) || |
|
844 "org.omg.CORBA.portable.IDLEntity".equals( inhName ) ) |
|
845 continue nextInterface; |
|
846 break; |
|
847 default: //filter for all others |
|
848 if ( "java.rmi.Remote".equals( inhName ) ) |
|
849 continue nextInterface; |
|
850 break; |
|
851 } |
|
852 inhHash.put( inhName,infs[i1] ); //add this one |
|
853 } |
|
854 } |
|
855 |
|
856 |
|
857 /** |
|
858 * Filter and add base class inheritance for a class type |
|
859 * @param ct The current CompoundType |
|
860 * @param inhHash Hashtable containing inherited types |
|
861 */ |
|
862 protected void getInheritance( |
|
863 CompoundType ct, |
|
864 Hashtable inhHash ) { |
|
865 ClassType par = ct.getSuperclass(); //get parent |
|
866 if ( par == null ) return; |
|
867 String parName = par.getQualifiedName(); |
|
868 switch ( ct.getTypeCode() ) { |
|
869 case TYPE_NC_CLASS: |
|
870 case TYPE_VALUE: |
|
871 if ( "java.lang.Object".equals( parName ) ) //this is implicit |
|
872 return; |
|
873 break; |
|
874 default: return; //ignore other types |
|
875 } |
|
876 inhHash.put( parName,par ); //add valid base class |
|
877 } |
|
878 |
|
879 |
|
880 /** |
|
881 * Collect and filter type and array references from methods |
|
882 * @param mthVec Given Vector of methods |
|
883 * @param refHash Hashtable for type references |
|
884 * @param spcHash Hashtable for special type references |
|
885 * @param arrHash Hashtable for array references |
|
886 * @param excHash Hashtable for exceptions thrown |
|
887 */ |
|
888 protected void getMethodReferences( |
|
889 Vector mthVec, |
|
890 Hashtable refHash, |
|
891 Hashtable spcHash, |
|
892 Hashtable arrHash, |
|
893 Hashtable excHash ) { |
|
894 for ( int i1 = 0; i1 < mthVec.size(); i1++ ) { //forall methods |
|
895 CompoundType.Method mth = (CompoundType.Method)mthVec.elementAt( i1 ); |
|
896 Type[] args = mth.getArguments(); |
|
897 Type ret = mth.getReturnType(); |
|
898 getExceptions( mth,excHash ); //collect exceptions thrown |
|
899 for ( int i2 = 0; i2 < args.length; i2++ ) //forall arguments |
|
900 addReference( args[i2],refHash,spcHash,arrHash ); |
|
901 addReference( ret,refHash,spcHash,arrHash ); |
|
902 } |
|
903 } |
|
904 |
|
905 |
|
906 /** |
|
907 * Collect and filter type and array references from data members |
|
908 * @param datVec Given Vector of data members |
|
909 * @param refHash Hashtable for type references |
|
910 * @param spcHash Hashtable for special type references |
|
911 * @param arrHash Hashtable for array references |
|
912 */ |
|
913 protected void getMemberReferences( |
|
914 Vector datVec, |
|
915 Hashtable refHash, |
|
916 Hashtable spcHash, |
|
917 Hashtable arrHash ) { |
|
918 for ( int i1 = 0; i1 < datVec.size(); i1++ ) { //forall datamembers |
|
919 CompoundType.Member mem = (CompoundType.Member)datVec.elementAt( i1 ); |
|
920 Type dat = mem.getType(); |
|
921 addReference( dat,refHash,spcHash,arrHash ); |
|
922 } |
|
923 } |
|
924 |
|
925 |
|
926 /** |
|
927 * Add reference for given type avoiding duplication. |
|
928 * Sort into specials, arrays and regular references. |
|
929 * Filter out types which are not required. |
|
930 * @param t Given Type |
|
931 * @param refHash Hashtable for type references |
|
932 * @param spcHash Hashtable for special type references |
|
933 * @param arrHash Hashtable for array references |
|
934 */ |
|
935 protected void addReference( |
|
936 Type ref, |
|
937 Hashtable refHash, |
|
938 Hashtable spcHash, |
|
939 Hashtable arrHash ) { |
|
940 String rName = ref.getQualifiedName(); |
|
941 switch ( ref.getTypeCode() ) { |
|
942 case TYPE_ABSTRACT: |
|
943 case TYPE_REMOTE: |
|
944 case TYPE_NC_CLASS: |
|
945 case TYPE_NC_INTERFACE: |
|
946 case TYPE_VALUE: |
|
947 refHash.put( rName,ref ); |
|
948 return; |
|
949 case TYPE_CORBA_OBJECT: |
|
950 if ( "org.omg.CORBA.Object".equals( rName ) ) return; //don't want |
|
951 refHash.put( rName,ref ); |
|
952 return; |
|
953 case TYPE_ARRAY: //array? |
|
954 arrHash.put( rName + ref.getArrayDimension(),ref ); |
|
955 return; |
|
956 default: |
|
957 if ( isSpecialReference( ref ) ) //special IDL typedef? |
|
958 spcHash.put( rName,ref ); |
|
959 } |
|
960 } |
|
961 |
|
962 |
|
963 |
|
964 /** |
|
965 * Determine whether given Type is a special reference. |
|
966 * Special cases are: java.io.Serializable, java.io.Externalizable, |
|
967 * java.lang.Object, java.rmi.Remote and org.omg.CORBA.portable.IDLEntity |
|
968 * They are special because they have a hard-coded typedef defined in the |
|
969 * spec. |
|
970 * @param ref A referenced Type |
|
971 * @return boolean indicating whether it's a special reference |
|
972 */ |
|
973 protected boolean isSpecialReference( |
|
974 Type ref ) { |
|
975 String rName = ref.getQualifiedName(); |
|
976 if ( "java.io.Serializable".equals( rName ) ) return true; |
|
977 if ( "java.io.Externalizable".equals( rName ) ) return true; |
|
978 if ( "java.lang.Object".equals( rName) ) return true; |
|
979 if ( "java.rmi.Remote".equals( rName) ) return true; |
|
980 if ( "org.omg.CORBA.portable.IDLEntity".equals( rName) ) return true; |
|
981 return false; |
|
982 } |
|
983 |
|
984 |
|
985 /** |
|
986 * Collect and filter thrown exceptions for a given pre-filtered method. |
|
987 * Keep only 'checked' exception classes minus java.rmi.RemoteException |
|
988 * and its subclasses |
|
989 * @param method The current method |
|
990 * @param excHash Hashtable containing non-duplicate thrown exceptions |
|
991 */ |
|
992 protected void getExceptions( |
|
993 CompoundType.Method mth, |
|
994 Hashtable excHash ) { |
|
995 ClassType[] excs = mth.getExceptions(); |
|
996 for ( int i1 = 0; i1 < excs.length; i1++ ) { //forall exceptions |
|
997 ClassType exc = excs[i1]; |
|
998 if ( exc.isCheckedException() && |
|
999 !exc.isRemoteExceptionOrSubclass() ) { |
|
1000 excHash.put( exc.getQualifiedName(),exc ); |
|
1001 } |
|
1002 } |
|
1003 } |
|
1004 |
|
1005 |
|
1006 /** |
|
1007 * Collect and filter methods for a type. |
|
1008 * Remove any private or inherited methods. |
|
1009 * @param ct The current CompoundType |
|
1010 * @return Vector containing the methods |
|
1011 */ |
|
1012 protected Vector getMethods( |
|
1013 CompoundType ct ) { |
|
1014 Vector vec = new Vector(); |
|
1015 int ctType = ct.getTypeCode(); |
|
1016 switch ( ctType ) { |
|
1017 case TYPE_ABSTRACT: |
|
1018 case TYPE_REMOTE: break; |
|
1019 case TYPE_NC_CLASS: |
|
1020 case TYPE_NC_INTERFACE: |
|
1021 case TYPE_VALUE: if ( valueMethods ) break; |
|
1022 default: return vec; |
|
1023 } |
|
1024 Identifier ctId = ct.getIdentifier(); |
|
1025 CompoundType.Method[] mths = ct.getMethods(); |
|
1026 nextMethod: |
|
1027 for ( int i1 = 0; i1 < mths.length; i1++ ) { //forall methods |
|
1028 if ( mths[i1].isPrivate() || //private method? |
|
1029 mths[i1].isInherited() ) //inherited method? |
|
1030 continue nextMethod; //yes..ignore it |
|
1031 if ( ctType == TYPE_VALUE ) { |
|
1032 String mthName = mths[i1].getName(); |
|
1033 if ( "readObject" .equals( mthName ) || |
|
1034 "writeObject" .equals( mthName ) || |
|
1035 "readExternal".equals( mthName ) || |
|
1036 "writeExternal".equals( mthName ) ) |
|
1037 continue nextMethod; //ignore this one |
|
1038 } |
|
1039 if ( ( ctType == TYPE_NC_CLASS || |
|
1040 ctType == TYPE_NC_INTERFACE ) && |
|
1041 mths[i1].isConstructor() ) //init not valid for abstract valuetype |
|
1042 continue nextMethod; //ignore this one |
|
1043 vec.addElement( mths[i1] ); //add this one |
|
1044 } |
|
1045 return vec; |
|
1046 } |
|
1047 |
|
1048 |
|
1049 /** |
|
1050 * Collect constants for a type. |
|
1051 * A valid constant is a "public final static" field with a compile-time |
|
1052 * constant value for a primitive type or String |
|
1053 * @param ct The current CompoundType |
|
1054 * @return Vector containing the constants |
|
1055 */ |
|
1056 protected Vector getConstants( |
|
1057 CompoundType ct ) { |
|
1058 Vector vec = new Vector(); |
|
1059 CompoundType.Member[] mems = ct.getMembers(); |
|
1060 for ( int i1 = 0; i1 < mems.length; i1++ ) { //forall members |
|
1061 Type memType = mems[i1].getType(); |
|
1062 String memValue = mems[i1].getValue(); |
|
1063 if ( mems[i1].isPublic() && |
|
1064 mems[i1].isFinal() && |
|
1065 mems[i1].isStatic() && |
|
1066 ( memType.isPrimitive() || "String".equals( memType.getName() ) ) && |
|
1067 memValue != null ) |
|
1068 vec.addElement( mems[i1] ); //add this one |
|
1069 } |
|
1070 return vec; |
|
1071 } |
|
1072 |
|
1073 |
|
1074 /** |
|
1075 * Collect and sort data fields for a ValueType. |
|
1076 * Sort in Java (not IDL) Unicode name string lexicographic increasing |
|
1077 * order. |
|
1078 * Non-static, non-transient fields are mapped. |
|
1079 * If the type is a custom valuetype, only public fields are mapped. |
|
1080 * @param ct The current CompoundType |
|
1081 * @return Vector containing the data fields |
|
1082 */ |
|
1083 protected Vector getData( |
|
1084 CompoundType t ) { |
|
1085 Vector vec = new Vector(); |
|
1086 if ( t.getTypeCode() != TYPE_VALUE ) return vec; |
|
1087 ValueType vt = (ValueType)t; |
|
1088 CompoundType.Member[] mems = vt.getMembers(); |
|
1089 boolean notCust = !vt.isCustom(); |
|
1090 for ( int i1 = 0; i1 < mems.length; i1++ ) { //forall members |
|
1091 if ( !mems[i1].isStatic() && |
|
1092 !mems[i1].isTransient() && |
|
1093 ( mems[i1].isPublic() || notCust ) ) { |
|
1094 int i2; |
|
1095 String memName = mems[i1].getName(); |
|
1096 for ( i2 = 0; i2 < vec.size(); i2++ ) { //insert in java lex order |
|
1097 CompoundType.Member aMem = (CompoundType.Member)vec.elementAt( i2 ); |
|
1098 if ( memName.compareTo( aMem.getName() ) < 0 ) break; |
|
1099 } |
|
1100 vec.insertElementAt( mems[i1],i2 ); //insert this one |
|
1101 } |
|
1102 } |
|
1103 return vec; |
|
1104 } |
|
1105 |
|
1106 |
|
1107 /** |
|
1108 * Write forward references for referenced interfaces and valuetypes |
|
1109 * ...but not if the reference is to a boxed IDLEntity, |
|
1110 * @param refHash Hashtable loaded with referenced types |
|
1111 * @param p The output stream. |
|
1112 */ |
|
1113 protected void writeForwardReferences( |
|
1114 Hashtable refHash, |
|
1115 IndentingWriter p ) |
|
1116 throws IOException { |
|
1117 Enumeration refEnum = refHash.elements(); |
|
1118 nextReference: |
|
1119 while ( refEnum.hasMoreElements() ) { |
|
1120 Type t = (Type)refEnum.nextElement(); |
|
1121 if ( t.isCompound() ) { |
|
1122 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 } |