View Javadoc
1   /*
2    * Copyright (c) 1999, 2004, 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   * COMPONENT_NAME: idl.toJava
27   *
28   * ORIGINS: 27
29   *
30   * Licensed Materials - Property of IBM
31   * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
32   * RMI-IIOP v1.0
33   *
34   */
35  
36  package com.sun.tools.corba.se.idl.toJavaPortable;
37  
38  // Notes:
39  // -F46838.4<klr> Ported -td option from toJava.
40  // -10/17/98  KLR Ported fix for d48911 from toJava
41  // -10/18/98  KLR Ported fix from toJava for "unsigned long" constants
42  // -F46082.51<daz> Removed code to collect makefile list generation inforamtion
43  //  from getStream(); see f46830.
44  // -F46082.51<daz> Removed -stateful feature: methods javaStatefulName(String)
45  //  and javaStatefulName(SymtabEntry) are obsolete, supplanted by javaName().
46  // -D54640<daz> Represent unsigned long long expressions with their computed
47  //  value rather than their actual representation (see notes in method
48  //  parseTerminal(), parseBinary(), and parseUnary().)
49  // -D58319<daz> Add getVersion() method.
50  // -D48034<daz> Import Helper classes for typedef struct members when generating
51  //  helper.  See method addImportLines().
52  // -D59851<daz> Modify to enable QuickTest build. (pending)
53  // -D42256<daz> Determine import lines for template types, which may specify any
54  //  positive int., constant expression for a boundary. Such expression containing
55  //  non-literal contansts previously caused problems when appearing in constructs
56  //  structs, unions, exceptions, typedefs, operation types and parameters,
57  //  attributes; and of course, sequences, strings.
58  // -D59063<daz> Add helper for global exception to stub import list.
59  // -D58951<daz> Publicise members for QuickTest.
60  // -D59421<klr> Change ValueBaseHolder to SerializableHolder
61  // -D59596<klr> Prevent accesses to elements of empty Vectors.
62  // -D59771<daz> Add import stmt for Helper of global type in stubs.
63  // -D59355<daz> Remove target dir. from filename when writing to prolog.
64  // -D59437<daz> Fill typename information for value boxes.
65  // -D62023<klr> Don't import ValueBase*
66  // -D62023<klr> Add corbaLevel
67  
68  import java.io.File;
69  import java.io.PrintWriter;
70  import java.math.BigInteger;
71  import java.text.DateFormat;
72  import java.util.Date;
73  import java.util.Enumeration;
74  import java.util.Hashtable;
75  import java.util.Locale;
76  import java.util.Vector;
77  
78  import com.sun.tools.corba.se.idl.ConstEntry;
79  import com.sun.tools.corba.se.idl.EnumEntry;
80  import com.sun.tools.corba.se.idl.ExceptionEntry;
81  import com.sun.tools.corba.se.idl.GenFileStream;
82  import com.sun.tools.corba.se.idl.InterfaceEntry;
83  import com.sun.tools.corba.se.idl.MethodEntry;
84  import com.sun.tools.corba.se.idl.NativeEntry;
85  import com.sun.tools.corba.se.idl.ParameterEntry;
86  import com.sun.tools.corba.se.idl.PrimitiveEntry;
87  import com.sun.tools.corba.se.idl.SequenceEntry;
88  import com.sun.tools.corba.se.idl.StringEntry;
89  import com.sun.tools.corba.se.idl.StructEntry;
90  import com.sun.tools.corba.se.idl.SymtabEntry;
91  import com.sun.tools.corba.se.idl.TypedefEntry;
92  import com.sun.tools.corba.se.idl.UnionBranch;
93  import com.sun.tools.corba.se.idl.UnionEntry;
94  import com.sun.tools.corba.se.idl.ValueEntry;
95  import com.sun.tools.corba.se.idl.ValueBoxEntry;
96  import com.sun.tools.corba.se.idl.InterfaceState;
97  
98  import com.sun.tools.corba.se.idl.constExpr.*;
99  
100 /**
101  * Class Util is a repository of static members available for general
102  * use by the IDL parser framework and any generator extensions.
103  **/
104 public class Util extends com.sun.tools.corba.se.idl.Util
105 {
106   // <d58319>
107   /**
108    * Fetch the version number of this build of the IDL-to-Java (portable)
109    * compiler from the appropriate properties file.
110    * @return the version number of this compiler build.
111    **/
112   public static String getVersion ()
113   {
114     return com.sun.tools.corba.se.idl.Util.getVersion ("com/sun/tools/corba/se/idl/toJavaPortable/toJavaPortable.prp");
115   } // getVersion
116 
117   /**
118    * This method is called by Setup.preEmit, so
119    * symbolTable is available for all Util methods.
120    **/
121   static void setSymbolTable (Hashtable symtab)
122   {
123     symbolTable = symtab;
124   } // setSymbolTable
125 
126   public static void setPackageTranslation( Hashtable pkgtrans )
127   {
128     packageTranslation = pkgtrans ;
129   }
130 
131   public static boolean isInterface (String name)
132   {
133     return isInterface (name, symbolTable);
134   } // isInterface
135 
136   static String arrayInfo (Vector arrayInfo)
137   {
138     int         arrays = arrayInfo.size ();
139     String      info   = "";
140     Enumeration e      = arrayInfo.elements ();
141     while (e.hasMoreElements ())
142       info = info + '[' + parseExpression ((Expression)e.nextElement ()) + ']';
143     return info;
144   } // arrayInfo
145 
146   // <d58951> static String sansArrayInfo (Vector arrayInfo)
147   public static String sansArrayInfo (Vector arrayInfo)
148   {
149     int    arrays   = arrayInfo.size ();
150     String brackets = "";
151     for (int i = 0; i < arrays; ++i)
152       brackets = brackets + "[]";
153     return brackets;
154   } // sansArrayInfo
155 
156   // <d58951> static String sansArrayInfo (String name)
157   static public String sansArrayInfo (String name)
158   {
159     int index = name.indexOf ('[');
160     if (index >= 0)
161     {
162       String array = name.substring (index);
163       name = name.substring (0, index);
164       while (!array.equals (""))
165       {
166         name = name + "[]";
167         array = array.substring (array.indexOf (']') + 1);
168       }
169     }
170     return name;
171   } // sansArrayInfo
172 
173   /**
174    * Given a symbol table entry, return the name of
175    * the file which should be created.
176    **/
177   public static String fileName (SymtabEntry entry, String extension )
178   {
179     NameModifier nm = new NameModifierImpl() ;
180     return fileName( entry, nm, extension ) ;
181   } // fileName
182 
183   public static String fileName (SymtabEntry entry, NameModifier modifier, String extension )
184   {
185     // This may not be the most appropriate place for
186     // the mkdir calls, but it's common to everything:
187     String pkg = containerFullName (entry.container ());
188     if (pkg != null && !pkg.equals (""))
189       mkdir (pkg);
190 
191     String name = entry.name ();
192     name = modifier.makeName( name ) + extension ;
193     if (pkg != null && !pkg.equals (""))
194       name = pkg + '/' + name;
195 
196     return name.replace ('/', File.separatorChar);
197   } // fileName
198 
199   public static GenFileStream stream (SymtabEntry entry, String extension)
200   {
201     NameModifier nm = new NameModifierImpl() ;
202     return stream(entry, nm, extension);
203   } // stream
204 
205   public static GenFileStream stream (SymtabEntry entry, NameModifier modifier, String extension )
206   {
207     return getStream ( fileName (entry,modifier,extension), entry ) ;
208   }
209 
210   public static GenFileStream getStream (String name, SymtabEntry entry)
211   {
212     // <f46838.4>
213     String absPathName = ((Arguments)Compile.compiler.arguments).targetDir + name;
214     if (Compile.compiler.arguments.keepOldFiles && new File (absPathName).exists ())
215       return null;
216     else
217       // Write the data to the file stream
218       return new GenFileStream (absPathName);
219   } // getStream
220 
221   public static String containerFullName( SymtabEntry container)
222   {
223       String name = doContainerFullName( container ) ;
224       if (packageTranslation.size() > 0)
225           name = translate( name ) ;
226       return name ;
227   }
228 
229   public static String translate( String name )
230   {
231       String head = name ;
232       String tail = "" ;
233       int index ;
234       String trname ;
235 
236       // Check for package name translations, starting with the
237       // most specific match.
238       do {
239           trname = (String)(packageTranslation.get( head )) ;
240           if (trname != null)
241               return trname + tail ;
242 
243           index = head.lastIndexOf( '/' ) ;
244           if (index >= 0) {
245               tail = head.substring( index ) + tail ;
246               head = head.substring( 0, index ) ;
247           }
248       } while (index >= 0) ;
249 
250       return name ;
251   }
252 
253   private static String doContainerFullName (SymtabEntry container)
254   {
255     String name = "";
256 
257     if (container == null)
258       name = "";
259     else
260     {
261       if (container instanceof InterfaceEntry ||
262           container instanceof StructEntry ||
263           container instanceof UnionEntry)
264         name = container.name () + "Package";
265       else
266         name = container.name ();
267 
268       if (container.container () != null &&
269         !container.container ().name ().equals (""))
270         name = doContainerFullName (container.container ()) + '/' + name;
271     }
272 
273     return name;
274   } // doContainerFullName
275 
276   /**
277    * Given a SymtabEntry, return the string which should be used
278    * for this entry. Enums are converted to ints, typedefs and
279    * sequences are converted to their info types. javaQualifiedName
280    * does not do any of these conversions.
281    **/
282   public static String javaName (SymtabEntry entry)
283   {
284     // First get the real name of this type
285     String name = "";
286     if (entry instanceof TypedefEntry || entry instanceof SequenceEntry)
287       try
288       {
289         name = sansArrayInfo ((String)entry.dynamicVariable (Compile.typedefInfo));
290       }
291       catch (NoSuchFieldException e)
292       {
293         name = entry.name ();
294       }
295     else if (entry instanceof PrimitiveEntry)
296       name = javaPrimName (entry.name ());
297     else if (entry instanceof StringEntry)
298       name = "String";
299     else if (entry instanceof NativeEntry)
300       name = javaNativeName (entry.name());
301     else if (entry instanceof ValueEntry && entry.name ().equals ("ValueBase"))
302         name = "java.io.Serializable";
303     else if (entry instanceof ValueBoxEntry)
304     {
305       ValueBoxEntry v = (ValueBoxEntry) entry;
306       TypedefEntry member = ((InterfaceState) v.state ().elementAt (0)).entry;
307       SymtabEntry mType = member.type ();
308       if (mType instanceof PrimitiveEntry)
309       {
310          name = containerFullName (entry.container ());
311          if (!name.equals (""))
312            name = name + '.';
313          name = name + entry.name ();
314       }
315       else
316          name = javaName (mType);
317     }
318     else
319     {
320       name = containerFullName (entry.container ());
321       if (name.equals (""))
322         name = entry.name ();
323       else
324         name = name + '.' + entry.name ();
325     }
326 
327     // Make it a fully package-qualified name
328     return name.replace ('/', '.');
329   } // javaName
330 
331   public static String javaPrimName (String name)
332   {
333     if (name.equals ("long") || name.equals ("unsigned long"))
334       name = "int";
335     else if (name.equals ("octet"))
336       name = "byte";
337     // "unisigned long long" exceeds Java long.
338     else if (name.equals ("long long") || name.equals ("unsigned long long"))
339       name = "long";
340     else if (name.equals ("wchar"))
341       name = "char";
342     else if (name.equals ("unsigned short"))
343       name = "short";
344     else if (name.equals ("any"))
345       name = "org.omg.CORBA.Any";
346     else if (name.equals ("TypeCode"))
347       name = "org.omg.CORBA.TypeCode";
348     else if (name.equals ("Principal")) // <d61961>
349       name = "org.omg.CORBA.Principal";
350     return name;
351   } // javaPrimName
352 
353   public static String javaNativeName (String name)
354   {
355 
356     // translations for Native declarations according to CORBA 2.3 spec
357 
358     if (name.equals ("AbstractBase") || name.equals ("Cookie"))
359       name = "java.lang.Object";
360     else if (name.equals ("Servant"))
361       name = "org.omg.PortableServer.Servant";
362     else if (name.equals ("ValueFactory"))
363       name = "org.omg.CORBA.portable.ValueFactory";
364     return name;
365   }
366 
367 
368   /**
369    * Given a symtabEntry, return the name of this entry. This
370    * method does not do any conversions like javaName does.
371    **/
372   public static String javaQualifiedName (SymtabEntry entry)
373   {
374     String name = "";
375     if (entry instanceof PrimitiveEntry)
376       name = javaPrimName (entry.name ());
377     else if (entry instanceof StringEntry)
378       name = "String";
379     else if (entry instanceof ValueEntry && entry.name ().equals ("ValueBase"))
380       name = "java.io.Serializable";
381     else
382     {
383       SymtabEntry container = entry.container ();
384       if (container != null)
385         name = container.name ();
386       if (name.equals (""))
387         name = entry.name ();
388       else
389         name = containerFullName (entry.container ()) + '.' + entry.name ();
390     }
391     return name.replace ('/', '.');
392   } // javaQualifiedName
393 
394   // <f46082.03> Publicize for extensions.
395   //static String collapseName (String name)
396 
397   /**
398    * Collapse primitive type names.
399    **/
400   public static String collapseName (String name)
401   {
402     if (name.equals ("unsigned short"))
403       name = "ushort";
404     else if (name.equals ("unsigned long"))
405       name = "ulong";
406     else if (name.equals ("unsigned long long"))
407       name = "ulonglong";
408     else if (name.equals ("long long"))
409       name = "longlong";
410     return name;
411   } // collapseName
412 
413   /**
414    *
415    **/
416   public static SymtabEntry typeOf (SymtabEntry entry)
417   {
418     while (entry instanceof TypedefEntry && ((TypedefEntry)entry).arrayInfo ().isEmpty () && !(entry.type () instanceof SequenceEntry))
419       entry = entry.type ();
420     return entry;
421   } // typeOf
422 
423   /**
424    * Fill the info field with the full name (with array info) of the type.
425    **/
426   static void fillInfo (SymtabEntry infoEntry)
427   {
428     String      arrayInfo   = "";
429     SymtabEntry entry       = infoEntry;
430     boolean     alreadyHave = false;
431 
432     do
433     {
434       try
435       {
436         alreadyHave = entry.dynamicVariable (Compile.typedefInfo) != null;
437       }
438       catch (NoSuchFieldException e)
439       {}
440       // If this entry's info has already been processed
441       // don't bother processing it again, just take it.
442       if (!alreadyHave)
443       {
444         if (entry instanceof TypedefEntry)
445           arrayInfo = arrayInfo + arrayInfo (((TypedefEntry)entry).arrayInfo ());
446         else if (entry instanceof SequenceEntry)
447         {
448           Expression maxSize = ((SequenceEntry)entry).maxSize ();
449           if (maxSize == null)
450             arrayInfo = arrayInfo + "[]";
451           else
452             arrayInfo = arrayInfo + '[' + parseExpression (maxSize) + ']';
453         }
454         if (entry.type () == null)
455         {
456           // <d59437> Suppress this message.  It tells the developer nothing, and
457           // this path does not cause the algorithm to fail.  Value boxes may
458           // contain anonymous types, like a struct or enum.
459           //System.err.println (getMessage ("PreEmit.indeterminateTypeInfo", entry.typeName ()));
460         }
461         else
462           entry = entry.type ();
463       }
464     } while (!alreadyHave && entry != null &&
465         (entry instanceof TypedefEntry || entry instanceof SequenceEntry));
466     // <d59437> Value boxes may contain types lacking typename info., which
467     // causes the 2nd case, below, to fail with exception when retrieving the
468     // javaName().
469     if (entry instanceof ValueBoxEntry)
470       fillValueBoxInfo ((ValueBoxEntry)entry);
471     try
472     {
473       if (alreadyHave)
474         infoEntry.dynamicVariable (Compile.typedefInfo, (String)entry.dynamicVariable (Compile.typedefInfo) + arrayInfo);
475       else
476         infoEntry.dynamicVariable (Compile.typedefInfo, javaName (entry) + arrayInfo);
477     }
478     catch (NoSuchFieldException e)
479     {}
480   } // fillInfo
481 
482   // <d59437>
483   /**
484    *
485    **/
486   static void fillValueBoxInfo (ValueBoxEntry vb)
487   {
488     SymtabEntry stateMember = (((InterfaceState) vb.state ().elementAt (0)).entry);
489     if (stateMember.type() != null)
490       Util.fillInfo (stateMember.type ());
491     Util.fillInfo (stateMember);
492   } // fillValueBoxInfo
493 
494   /**
495    *
496    **/
497   public static String holderName (SymtabEntry entry)
498   {
499     String name;
500     if (entry instanceof PrimitiveEntry)
501       if (entry.name ().equals ("any"))
502         name = "org.omg.CORBA.AnyHolder";
503       else if (entry.name ().equals ("TypeCode"))
504         name = "org.omg.CORBA.TypeCodeHolder";
505       else if (entry.name ().equals ("Principal")) // <d61961>
506         name = "org.omg.CORBA.PrincipalHolder";
507       else
508         name = "org.omg.CORBA." + capitalize (javaQualifiedName (entry)) + "Holder";
509     else if (entry instanceof TypedefEntry)
510     {
511       TypedefEntry td = (TypedefEntry)entry;
512       if (!td.arrayInfo ().isEmpty () || td.type () instanceof SequenceEntry)
513         name = javaQualifiedName (entry) + "Holder";
514       else
515         name = holderName (entry.type ());
516     }
517     else if (entry instanceof StringEntry)
518       name = "org.omg.CORBA.StringHolder";
519     else if (entry instanceof ValueEntry)
520     {
521       if (entry.name ().equals ("ValueBase"))
522           name = "org.omg.CORBA.ValueBaseHolder"; // <d59421>, <d60929>
523       else
524           name = javaName (entry) + "Holder";
525     } else if (entry instanceof NativeEntry) {
526       // do not attach holder to the translation for Native Entries, e.g.
527       // for Cookie it should be CookieHolder instead of java.lang.ObjectHolder
528       // returns the complete name for the package, etc.
529       name = javaQualifiedName(entry) + "Holder";
530     }
531     else
532       name = javaName (entry) + "Holder";
533     return name;
534   } // holderName
535 
536   /**
537    * <d61056>
538    **/
539   public static String helperName (SymtabEntry entry, boolean qualifiedName)
540   {
541     if (entry instanceof ValueEntry)
542       if (entry.name ().equals ("ValueBase"))
543           return "org.omg.CORBA.ValueBaseHelper";
544 
545     if (qualifiedName)
546       return javaQualifiedName (entry) + "Helper";
547     else
548       return javaName (entry) + "Helper";
549   } // helperName
550 
551   public static final short
552       TypeFile   = 0,
553       StubFile   = 1,
554       HelperFile = 2,
555       HolderFile = 3,
556       StateFile  = 4;
557 
558   /**
559    *
560    **/
561   public static void writePackage (PrintWriter stream, SymtabEntry entry)
562   {
563     writePackage (stream, entry, TypeFile);
564   } // writePackage
565 
566   /**
567    *
568    **/
569   public static void writePackage (PrintWriter stream, SymtabEntry entry, String name, short type)
570   {
571     if (name != null && !name.equals (""))
572     {
573       stream.println ("package " + name.replace ('/', '.') + ';');
574 
575       // This type is in a module.  Just in case it refers to types
576       // in the unnamed module, add an import statement for each of
577       // those types.
578       if (!Compile.compiler.importTypes.isEmpty ())
579       {
580         stream.println ();
581         Vector v = addImportLines (entry, Compile.compiler.importTypes, type);
582         printImports (v, stream);
583       }
584     }
585   } // writePackage
586 
587   /**
588    *
589    **/
590   public static void writePackage (PrintWriter stream, SymtabEntry entry, short type)
591   {
592     String fullName = containerFullName (entry.container ());
593     if (fullName != null && !fullName.equals (""))
594     {
595       stream.println ("package " + fullName.replace ('/', '.') + ';');
596        // This type is in a module.  Just in case it refers to types
597       // in the unnamed module, add an import statement for each of
598       // those types.
599       if ((type != HolderFile || entry instanceof TypedefEntry) && !Compile.compiler.importTypes.isEmpty ())
600       {
601         stream.println ();
602         Vector v = addImportLines (entry, Compile.compiler.importTypes, type);
603         printImports (v, stream);
604       }
605       /*
606       Enumeration e = Compile.compiler.importTypes.elements ();
607       while (e.hasMoreElements ())
608       {
609         SymtabEntry i = (SymtabEntry)e.nextElement ();
610         // Write import for type
611         if (!(i instanceof TypedefEntry))
612           stream.println ("import " + i.name () + ';');
613 
614         // Write import for Helper
615         if (!(i instanceof ConstEntry))
616           stream.println ("import " + i.name () + "Helper;");
617 
618         // Write import for Holder
619         if (!(i instanceof ConstEntry))
620           if (!(i instanceof TypedefEntry) || (i.type () instanceof SequenceEntry || !((TypedefEntry)i).arrayInfo ().isEmpty ()))
621             stream.println ("import " + i.name () + "Holder;");
622       }
623       */
624     }
625   } // writePackage
626 
627   /**
628    *
629    **/
630   static private void printImports (Vector importList, PrintWriter stream)
631   {
632     Enumeration e = importList.elements ();
633     while (e.hasMoreElements ())
634       stream.println ("import " + (String)e.nextElement () + ';');
635   } // printImport
636 
637   /**
638    *
639    **/
640   static private void addTo (Vector importList, String name)
641   {
642     // REVISIT - <d62023-klr> was also importing ValueBaseHolder and Helper
643     if (name.startsWith ("ValueBase"))  // don't import ValueBase*
644       if ((name.compareTo ("ValueBase") == 0) ||
645           (name.compareTo ("ValueBaseHolder") == 0) ||
646               (name.compareTo ("ValueBaseHelper") == 0))
647         return;
648     if (!importList.contains (name))
649       importList.addElement (name);
650   } // addTo
651 
652   /**
653    *
654    **/
655   static private Vector addImportLines (SymtabEntry entry, Vector importTypes, short type)
656   {
657     Vector importList = new Vector ();
658     if (entry instanceof ConstEntry)
659     {
660       ConstEntry c      = (ConstEntry)entry;
661       Object     cvalue = c.value ().value ();
662       if (cvalue instanceof ConstEntry && importTypes.contains (cvalue))
663         addTo (importList, ((ConstEntry)cvalue).name ());
664     }
665     else if (entry instanceof ValueEntry && type == HelperFile) // <d59512>
666     {
667       // This code inspired by ValueGen.getConcreteBaseTypeCode().  Helper method
668       // type() could be invoked against a global valuetype.
669       if (((ValueEntry)entry).derivedFrom ().size () > 0) // <59596> KLR HACK
670       {
671         ValueEntry base = (ValueEntry)((ValueEntry)entry).derivedFrom ().elementAt (0);
672         String baseName = base.name ();
673         if (!"ValueBase".equals (baseName))
674           if (importTypes.contains (base))
675             addTo (importList, baseName + "Helper");
676       }
677     }
678     else if (entry instanceof InterfaceEntry && (type == TypeFile || type == StubFile))
679     {
680       InterfaceEntry i = (InterfaceEntry)entry;
681 
682       if (i instanceof ValueEntry) // <d59512>
683       {
684         // Examine interface parents in supports vector.
685         Enumeration e = ((ValueEntry)i).supports ().elements ();
686         while (e.hasMoreElements ())
687         {
688           SymtabEntry parent = (SymtabEntry)e.nextElement ();
689           if (importTypes.contains (parent))
690           {
691             addTo (importList, parent.name () + "Operations");
692           }
693           // If this is a stub, then recurse to the parents
694           if (type == StubFile)
695           {
696             if (importTypes.contains (parent))
697               addTo (importList, parent.name ());
698             Vector subImportList = addImportLines (parent, importTypes, StubFile);
699             Enumeration en = subImportList.elements ();
700             while (en.hasMoreElements ())
701             {
702               addTo (importList, (String)en.nextElement ());
703             }
704           }
705         }
706       }
707       // Interface or valuetype -- Examine interface and valuetype parents,
708       // Look through derivedFrom vector
709       Enumeration e = i.derivedFrom ().elements ();
710       while (e.hasMoreElements ())
711       {
712         SymtabEntry parent = (SymtabEntry)e.nextElement ();
713         if (importTypes.contains (parent))
714         {
715           addTo (importList, parent.name ());
716           // <d59512> Always add both imports, even though superfluous.  Cannot
717           // tell when writing Operations or Signature interface!
718           if (!(parent instanceof ValueEntry)) // && parent.name ().equals ("ValueBase")))
719             addTo (importList, parent.name () + "Operations");
720         }
721         // If this is a stub, then recurse to the parents
722         if (type == StubFile)
723         {
724           Vector subImportList = addImportLines (parent, importTypes, StubFile);
725           Enumeration en = subImportList.elements ();
726           while (en.hasMoreElements ())
727           {
728             addTo (importList, (String)en.nextElement ());
729           }
730         }
731       }
732       // Look through methods vector
733       e = i.methods ().elements ();
734       while (e.hasMoreElements ())
735       {
736         MethodEntry m = (MethodEntry)e.nextElement ();
737 
738         // Look at method type
739         SymtabEntry mtype = typeOf (m.type ());
740         if (mtype != null && importTypes.contains (mtype))
741           if (type == TypeFile || type == StubFile)
742           {
743             addTo (importList, mtype.name ());
744             addTo (importList, mtype.name () + "Holder");
745             if (type == StubFile)
746               addTo (importList, mtype.name () + "Helper");
747           }
748         checkForArrays (mtype, importTypes, importList);
749         // <d42256> Print import lines for globals constants and constants
750         // within global interfaces.
751         if (type == StubFile)
752           checkForBounds (mtype, importTypes, importList);
753 
754         // Look through exceptions
755         Enumeration exEnum = m.exceptions ().elements ();
756         while (exEnum.hasMoreElements ())
757         {
758           ExceptionEntry ex = (ExceptionEntry)exEnum.nextElement ();
759           if (importTypes.contains (ex))
760           {
761             addTo (importList, ex.name ());
762             addTo (importList, ex.name () + "Helper"); // <d59063>
763           }
764         }
765 
766         // Look through parameters
767         Enumeration parms = m.parameters ().elements ();
768         while (parms.hasMoreElements ())
769         {
770           ParameterEntry parm = (ParameterEntry)parms.nextElement ();
771           SymtabEntry parmType = typeOf (parm.type ());
772           if (importTypes.contains (parmType))
773           {
774             // <d59771> Helper needed in stubs.
775             if (type == StubFile)
776               addTo (importList, parmType.name () + "Helper");
777             if (parm.passType () == ParameterEntry.In)
778               addTo (importList, parmType.name ());
779             else
780               addTo (importList, parmType.name () + "Holder");
781           }
782           checkForArrays (parmType, importTypes, importList);
783           // <d42256>
784           if (type == StubFile)
785             checkForBounds (parmType, importTypes, importList);
786         }
787       }
788     }
789     else if (entry instanceof StructEntry)
790     {
791       StructEntry s = (StructEntry)entry;
792 
793       // Look through the members
794       Enumeration members = s.members ().elements ();
795       while (members.hasMoreElements ())
796       {
797         SymtabEntry member = (TypedefEntry)members.nextElement ();
798         // <d48034> Need to add helper name for typedef members.  This name
799         // is referenced at typecode generation in Helper class.
800         SymtabEntry memberType = member.type ();
801         member = typeOf (member);
802         if (importTypes.contains (member))
803         {
804           // If this IS a typedef, then there are only Helper/Holder classes.
805           //if (!(member instanceof TypedefEntry))
806           // <d59437>  Valueboxes
807           if (!(member instanceof TypedefEntry) && !(member instanceof ValueBoxEntry))
808             addTo (importList, member.name ());
809           // <d48034> Add helper name of alias, too, if member is a typedef.
810           //if (type == HelperFile)
811           //  addTo (importList, member.name () + "Helper");
812           if (type == HelperFile)
813           {
814             addTo (importList, member.name () + "Helper");
815             if (memberType instanceof TypedefEntry)
816               addTo (importList, memberType.name () + "Helper");
817           }
818         }
819         checkForArrays (member, importTypes, importList);
820         checkForBounds (member, importTypes, importList);
821       }
822     }
823     else if (entry instanceof TypedefEntry)
824     {
825       TypedefEntry t = (TypedefEntry)entry;
826       String arrays = checkForArrayBase (t, importTypes, importList);
827       if (type == HelperFile)
828       {
829         checkForArrayDimensions (arrays, importTypes, importList);
830         try
831         {
832           String name = (String)t.dynamicVariable (Compile.typedefInfo);
833           int index = name.indexOf ('[');
834           if (index >= 0)
835             name = name.substring (0, index);
836           // See if the base type should be added to the list.
837           SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (name);
838           if (typeEntry != null && importTypes.contains (typeEntry))
839             addTo (importList, typeEntry.name () + "Helper");
840         }
841         catch (NoSuchFieldException e)
842         {}
843 
844         // <d42256> Typedefs for global bounded strings need import
845         // statement when bound expression contains non-literal constants.
846         checkForBounds (typeOf (t), importTypes, importList);
847       }
848       Vector subImportList = addImportLines (t.type (), importTypes, type);
849       Enumeration e = subImportList.elements ();
850       while (e.hasMoreElements ())
851         addTo (importList, (String)e.nextElement ());
852     }
853     else if (entry instanceof UnionEntry)
854     {
855       UnionEntry u = (UnionEntry)entry;
856 
857       // Look at the discriminant type
858       SymtabEntry utype = typeOf (u.type ());
859       if (utype instanceof EnumEntry && importTypes.contains (utype))
860         addTo (importList, utype.name ());
861 
862       // Look through the branches
863       Enumeration branches = u.branches ().elements ();
864       while (branches.hasMoreElements ())
865       {
866         UnionBranch branch = (UnionBranch)branches.nextElement ();
867         SymtabEntry branchEntry = typeOf (branch.typedef);
868         if (importTypes.contains (branchEntry))
869         {
870           addTo (importList, branchEntry.name ());
871           if (type == HelperFile)
872             addTo (importList, branchEntry.name () + "Helper");
873         }
874         checkForArrays (branchEntry, importTypes, importList);
875         // <d42256>
876         checkForBounds (branchEntry, importTypes, importList);
877       }
878     }
879 
880     // If a typedef is not a sequence or an array, only holders and
881     // helpers are generated for it.  Remove references to such
882     // class names.
883     Enumeration en = importList.elements ();
884     while (en.hasMoreElements ())
885     {
886       String name = (String)en.nextElement ();
887       SymtabEntry e = (SymtabEntry)symbolTable.get (name);
888       if (e != null && e instanceof TypedefEntry)
889       {
890         TypedefEntry t = (TypedefEntry)e;
891         if (t.arrayInfo ().size () == 0 || !(t.type () instanceof SequenceEntry))
892           importList.removeElement (name);
893       }
894     }
895     return importList;
896   } // addImportLines
897 
898   /**
899    *
900    **/
901   static private void checkForArrays (SymtabEntry entry, Vector importTypes, Vector importList)
902   {
903     if (entry instanceof TypedefEntry)
904     {
905       TypedefEntry t = (TypedefEntry)entry;
906       String arrays = checkForArrayBase (t, importTypes, importList);
907       checkForArrayDimensions (arrays, importTypes, importList);
908     }
909   } // checkForArrays
910 
911   /**
912    *
913    **/
914   static private String checkForArrayBase (TypedefEntry t, Vector importTypes, Vector importList)
915   {
916     String arrays = "";
917     try
918     {
919       String name = (String)t.dynamicVariable (Compile.typedefInfo);
920       int index = name.indexOf ('[');
921       if (index >= 0)
922       {
923         arrays = name.substring (index);
924         name = name.substring (0, index);
925       }
926 
927       // See if the base type should be added to the list.
928       SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (name);
929       if (typeEntry != null && importTypes.contains (typeEntry))
930         addTo (importList, typeEntry.name ());
931     }
932     catch (NoSuchFieldException e)
933     {}
934     return arrays;
935   } // checkForArrayBase
936 
937   /**
938    *
939    **/
940   static private void checkForArrayDimensions (String arrays, Vector importTypes, Vector importList)
941   {
942     // See if any of the arrays contain a constentry.
943     // If so, see if it should be added to the list.
944     while (!arrays.equals (""))
945     {
946       int index = arrays.indexOf (']');
947       String dim = arrays.substring (1, index);
948       arrays = arrays.substring (index + 1);
949       SymtabEntry constant = (SymtabEntry)symbolTable.get (dim);
950       if (constant == null)
951       {
952         // A constant expr could be of the form <const> OR
953         // <interface>.<const>.  This if branch checks for that case.
954         int i = dim.lastIndexOf ('.');
955         if (i >= 0)
956           constant = (SymtabEntry)symbolTable.get (dim.substring (0, i));
957       }
958       if (constant != null && importTypes.contains (constant))
959         addTo (importList, constant.name ());
960     }
961   } // checkForArrayDimensions
962 
963   // <d42256> Call the following method when its necessary to determine the
964   // the import types for IDL constructs containing arbitrary positive int.
965   // expressions, which may specify non-literal constants.
966 
967   /**
968    * Determine the import lines for template types.
969    **/
970   static private void checkForBounds (SymtabEntry entry, Vector importTypes, Vector importList)
971   {
972     // Obtain actual type, just to be complete.
973     SymtabEntry entryType = entry;
974     while (entryType instanceof TypedefEntry)
975       entryType = entryType.type ();
976 
977     if (entryType instanceof StringEntry && ((StringEntry)entryType).maxSize () != null)
978       checkForGlobalConstants (((StringEntry)entryType).maxSize ().rep (), importTypes, importList);
979     else
980       if (entryType instanceof SequenceEntry && ((SequenceEntry)entryType).maxSize () != null)
981         checkForGlobalConstants (((SequenceEntry)entryType).maxSize ().rep (), importTypes, importList);
982   } // checkForBounds
983 
984   /**
985    * Extract the global constants from the supplied integer expression
986    * representation (string) and add them to the supplied import list.
987    **/
988   static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
989   {
990     // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
991     // delimiter and would not be otherwise properly collected. Blanks and
992     // arithmetic symbols do not appear in tokens, except for '/'.
993     java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
994     while (st.hasMoreTokens ())
995     {
996       String token = st.nextToken ();
997       // When token contains '/', it represents the division symbol or
998       // a nested type (e.g., I/x). Ignore the division symbol, and don't
999       // forget constants declared within global interfaces!
1000       if (!token.equals ("/"))
1001       {
1002         SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
1003         if (typeEntry instanceof ConstEntry)
1004         {
1005           int slashIdx = token.indexOf ('/');
1006           if (slashIdx < 0)  // Possible global constant
1007           {
1008             if (importTypes.contains (typeEntry))
1009               addTo (importList, typeEntry.name ());
1010           }
1011           else  // Possible constant in global interface
1012           {
1013             SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
1014             if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
1015               addTo (importList, constContainer.name ());
1016           }
1017         }
1018       }
1019     }
1020   } // checkForGlobalConstants
1021 
1022   /**
1023    *
1024    **/
1025   public static void writeInitializer (String indent, String name, String arrayDcl, SymtabEntry entry, PrintWriter stream)
1026   {
1027     if (entry instanceof TypedefEntry)
1028     {
1029       TypedefEntry td = (TypedefEntry)entry;
1030       writeInitializer (indent, name, arrayDcl + sansArrayInfo (td.arrayInfo ()), td.type (), stream);
1031     }
1032     else if (entry instanceof SequenceEntry)
1033       writeInitializer (indent, name, arrayDcl + "[]", entry.type (), stream);
1034     else if (entry instanceof EnumEntry)
1035       if (arrayDcl.length () > 0)
1036         stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = null;");
1037       else
1038         stream.println (indent + javaName (entry) + ' ' + name + " = null;");
1039     else if (entry instanceof PrimitiveEntry)
1040     {
1041       boolean array = arrayDcl.length () > 0;
1042       String tname = javaPrimName (entry.name ());
1043       if (tname.equals ("boolean"))
1044         stream.println (indent + "boolean " + name + arrayDcl + " = " + (array ? "null;" : "false;"));
1045       else if (tname.equals ("org.omg.CORBA.TypeCode"))
1046         stream.println (indent + "org.omg.CORBA.TypeCode " + name + arrayDcl + " = null;");
1047       else if (tname.equals ("org.omg.CORBA.Any"))
1048         stream.println (indent + "org.omg.CORBA.Any " + name + arrayDcl + " = null;");
1049       else if (tname.equals ("org.omg.CORBA.Principal")) // <d61961>
1050         stream.println (indent + "org.omg.CORBA.Principal " + name + arrayDcl + " = null;");
1051       else
1052         stream.println (indent + tname + ' ' + name + arrayDcl + " = " + (array ? "null;" : '(' + tname + ")0;"));
1053     }
1054     // <f46082.51> Remove -stateful feature. This case is identical to next one
1055     // because javaName() supplants javaStatefulName().
1056     //else if (entry instanceof InterfaceEntry && ((InterfaceEntry)entry).state () != null)
1057     //  stream.println (indent + javaStatefulName ((InterfaceEntry)entry) + ' ' + name + arrayDcl + " = null;");
1058     else
1059       stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = null;");
1060   } // writeInitializer
1061 
1062   /**
1063    *
1064    **/
1065   public static void writeInitializer (String indent, String name, String arrayDcl, SymtabEntry entry, String initializer, PrintWriter stream)
1066   {
1067     if (entry instanceof TypedefEntry)
1068     {
1069       TypedefEntry td = (TypedefEntry)entry;
1070       writeInitializer (indent, name, arrayDcl + sansArrayInfo (td.arrayInfo ()), td.type (), initializer, stream);
1071     }
1072     else if (entry instanceof SequenceEntry)
1073       writeInitializer (indent, name, arrayDcl + "[]", entry.type (), initializer, stream);
1074     else if (entry instanceof EnumEntry)
1075       if (arrayDcl.length () > 0)
1076         stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = " + initializer + ';');
1077       else
1078         stream.println (indent + javaName (entry) + ' ' + name + " = " + initializer + ';');
1079     else if (entry instanceof PrimitiveEntry)
1080     {
1081       boolean array = arrayDcl.length () > 0;
1082       String tname = javaPrimName (entry.name ());
1083       if (tname.equals ("boolean"))
1084         stream.println (indent + "boolean " + name + arrayDcl + " = " + initializer + ';');
1085       else if (tname.equals ("org.omg.CORBA.TypeCode"))
1086         stream.println (indent + "org.omg.CORBA.TypeCode " + name + arrayDcl + " = " + initializer + ';');
1087       else if (tname.equals ("org.omg.CORBA.Any"))
1088         stream.println (indent + "org.omg.CORBA.Any " + name + arrayDcl + " = " + initializer + ';');
1089       else if (tname.equals ("org.omg.CORBA.Principal")) // <d61961>
1090         stream.println (indent + "org.omg.CORBA.Principal " + name + arrayDcl + " = " + initializer + ';');
1091       else
1092         stream.println (indent + tname + ' ' + name + arrayDcl + " = " + initializer + ';');
1093     }
1094     // <f46082.51> Remove -stateful feature. This case is identical to next one
1095     // because javaName() supplants javaStatefulName().
1096     //else if (entry instanceof InterfaceEntry && ((InterfaceEntry)entry).state () != null)
1097     //  stream.println (indent + javaStatefulName ((InterfaceEntry)entry) + ' ' + name + arrayDcl + " = " + initializer + ';');
1098     else
1099       stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = " + initializer + ';');
1100   } // writeInitializer
1101 
1102   /**
1103    *
1104    **/
1105   public static void mkdir (String name)
1106   {
1107     String targetDir = ((Arguments)Compile.compiler.arguments).targetDir; // F46838.4
1108     name = (targetDir + name).replace ('/', File.separatorChar); // F46838.4
1109     File pkg = new File (name);
1110     if (!pkg.exists ())
1111       if (!pkg.mkdirs ())
1112         System.err.println (getMessage ("Util.cantCreatePkg", name));
1113   } // mkdir
1114 
1115   /**
1116    *
1117    **/
1118   public static void writeProlog (PrintWriter stream, String filename)
1119   {
1120     // <d59355> Remove target directory
1121     String targetDir = ((Arguments)Compile.compiler.arguments).targetDir;
1122     if (targetDir != null)
1123       filename = filename.substring (targetDir.length ());
1124     stream.println ();
1125     stream.println ("/**");
1126     stream.println ("* " + filename.replace (File.separatorChar, '/') +
1127         " .");
1128     stream.println ("* " + Util.getMessage ("toJavaProlog1",
1129         Util.getMessage ("Version.product", Util.getMessage ("Version.number"))));
1130     // <d48911> Do not introduce invalid escape characters into comment! <daz>
1131     //stream.println ("* " + Util.getMessage ("toJavaProlog2", Compile.compiler.arguments.file));
1132     stream.println ("* " + Util.getMessage ("toJavaProlog2", Compile.compiler.arguments.file.replace (File.separatorChar, '/')));
1133 
1134     ///////////////
1135     // This SHOULD work, but there's a bug in the JDK.
1136     //    stream.println ("* " + DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, Locale.getDefault ()).format (new Date ()));
1137     // This gets around the bug:
1138 
1139     DateFormat formatter = DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, Locale.getDefault ());
1140 
1141     // Japanese-specific workaround.  JDK bug 4069784 being repaired by JavaSoft.
1142     // Keep this transient solution until bug fix is reported.cd .
1143 
1144     if (Locale.getDefault () == Locale.JAPAN)
1145       formatter.setTimeZone (java.util.TimeZone.getTimeZone ("JST"));
1146     else
1147       formatter.setTimeZone (java.util.TimeZone.getDefault ());
1148 
1149     stream.println ("* " + formatter.format (new Date ()));
1150 
1151     // <daz>
1152     ///////////////
1153 
1154     stream.println ("*/");
1155     stream.println ();
1156   } // writeProlog
1157 
1158   // keywords ending in Holder or Helper or Package have '_' prepended.
1159   // These prepended underscores must not be part of anything sent
1160   // across the wire, so these two methods are provided to strip them
1161   // off.
1162 
1163   /**
1164    *
1165    **/
1166   public static String stripLeadingUnderscores (String string)
1167   {
1168     while (string.startsWith ("_"))
1169       string = string.substring (1);
1170     return string;
1171   } // stripLeadingUnderscores
1172 
1173   /**
1174    *
1175    **/
1176   public static String stripLeadingUnderscoresFromID (String string)
1177   {
1178     String stringPrefix = "";
1179     int slashIndex = string.indexOf (':');
1180     if (slashIndex >= 0)
1181       do
1182       {
1183         stringPrefix = stringPrefix + string.substring (0, slashIndex + 1);
1184         string = string.substring (slashIndex + 1);
1185         while (string.startsWith ("_"))
1186           string = string.substring (1);
1187         slashIndex = string.indexOf ('/');
1188       } while (slashIndex >= 0);
1189     return stringPrefix + string;
1190   } // stripLeadingUnderscoresFromID
1191 
1192   /**
1193    *
1194    **/
1195   public static String parseExpression (Expression e)
1196   {
1197     if (e instanceof Terminal)
1198       return parseTerminal ((Terminal)e);
1199     else if (e instanceof BinaryExpr)
1200       return parseBinary ((BinaryExpr)e);
1201     else if (e instanceof UnaryExpr)
1202       return parseUnary ((UnaryExpr)e);
1203     else
1204       return "(UNKNOWN_VALUE)"; // This shouldn't happen unless someone slips
1205                                 // in another type of expression.
1206   } // parseExpression
1207 
1208   /**
1209    *
1210    **/
1211   static String parseTerminal (Terminal e)
1212   {
1213     if (e.value () instanceof ConstEntry)
1214     {
1215       ConstEntry c = (ConstEntry)e.value ();
1216       if (c.container () instanceof InterfaceEntry)
1217         return javaQualifiedName (c.container ()) + '.' + c.name ();
1218       else
1219         return javaQualifiedName (c) + ".value";
1220     }
1221     else if (e.value () instanceof Expression)
1222       return '(' + parseExpression ((Expression)e.value ()) + ')';
1223     else if (e.value () instanceof Character)
1224     {
1225       if (((Character)e.value ()).charValue () == '\013')
1226         // e.rep is \v.  \v for vertical tab is meaningless in Java.
1227         return "'\\013'";
1228       else if (((Character)e.value ()).charValue () == '\007')
1229         // e.rep is \a.  \a for alert is meaningless in Java.
1230         return "'\\007'";
1231       else if (e.rep ().startsWith ("'\\x"))
1232         return hexToOctal (e.rep ());
1233       else if (e.rep ().equals ("'\\?'"))
1234         return "'?'";
1235       else
1236         return e.rep ();
1237     }
1238     else if (e.value () instanceof Boolean)
1239       return e.value ().toString ();
1240 
1241     // <d54640> If value is type "unsigned long long" (ull) and its magnitude
1242     // is greater than the maximal Java long (i.e., IDL long long) value, then
1243     // return its signed representation rather than its actual representation.
1244     /*
1245     // Support long long
1246     //else if (e.value () instanceof Long)
1247     else if (e.value () instanceof BigInteger &&
1248              (e.type ().indexOf ("long long") >= 0 || e.type ().equals ("unsigned long"))) // <klr>
1249     {
1250       String rep   = e.rep ();
1251       int    index = rep.indexOf (')');
1252       if (index < 0)
1253         return rep + 'L';
1254       else
1255         return rep.substring (0, index) + 'L' + rep.substring (index);
1256     }
1257     */
1258     else if (e.value () instanceof BigInteger)
1259     {
1260       // Get the correct primitive type. Since integer types (octet, short,
1261       // long, long long, unsigned short, unsigned long, unsigned long long)
1262       // could be aliased (typedef'ed) to any arbitrary levels, the code
1263       // below walks up the alias chain to get to the primitive type.
1264 
1265       // Get the symbol table entry corresponding to the 'type'.
1266       SymtabEntry typeEntry = (SymtabEntry) symbolTable.get(e.type());
1267 
1268       // Get to the primitive type.
1269       while (typeEntry.type() != null) {
1270           typeEntry = typeEntry.type();
1271       }
1272       String type = typeEntry.name();
1273 
1274       if (type.equals("unsigned long long") &&
1275           ((BigInteger)e.value ()).compareTo (Expression.llMax) > 0) // value > long long Max?
1276       {
1277         // Convert to signed value, which will always be negative.
1278         BigInteger v = (BigInteger)e.value ();
1279         v = v.subtract (Expression.twoPow64);
1280         int index = e.rep ().indexOf (')');
1281         if (index < 0)
1282           return v.toString () + 'L';
1283         else
1284           return '(' + v.toString () + 'L' + ')';
1285       }
1286       else if ( type.indexOf("long long") >= 0 || type.equals("unsigned long") )
1287       {
1288         String rep   = e.rep ();
1289         int    index = rep.indexOf (')');
1290         if (index < 0)
1291           return rep + 'L';
1292         else
1293           return rep.substring (0, index) + 'L' + rep.substring (index);
1294       }
1295       else
1296         return e.rep ();
1297     } // end <d54640>
1298     else
1299       return e.rep ();
1300   } // parseTerminal
1301 
1302   /**
1303    *
1304    **/
1305   static String hexToOctal (String hex)
1306   {
1307     // The format of hex is '/xXX' where XX is one or two hex digits.
1308     // This statement pulls off XX.
1309     hex = hex.substring (3, hex.length () - 1);
1310     return "'\\" + Integer.toString (Integer.parseInt (hex, 16), 8) + "'";
1311   } // hexToOctal
1312 
1313   /**
1314    *
1315    **/
1316   static String parseBinary (BinaryExpr e)
1317   {
1318     String castString = "";
1319     if (e.value () instanceof Float || e.value () instanceof Double)
1320     {
1321       castString = "(double)";
1322       if (!(e instanceof Plus || e instanceof Minus ||
1323             e instanceof Times || e instanceof Divide))
1324         System.err.println ("Operator " + e.op () + " is invalid on floating point numbers");
1325     }
1326     else if (e.value () instanceof Number)
1327     {
1328       if (e.type (). indexOf ("long long") >= 0)
1329         castString = "(long)";
1330       else
1331         castString = "(int)";
1332     }
1333     else
1334     {
1335       castString = "";
1336       System.err.println ("Unknown type in constant expression");
1337     }
1338 
1339     // <d54640> Must emit value rather than representation when type "unsigned
1340     // long long" (ull) because emitted binary arithmetic expressions containing
1341     // ull's converted to long (i.e., IDL long long) do not always compute to
1342     // the correct result.
1343 
1344     //return castString + '(' + parseExpression (e.left ()) + ' ' + e.op () + ' ' + parseExpression (e.right ()) + ')';
1345     if (e.type ().equals ("unsigned long long"))
1346     {
1347       BigInteger value = (BigInteger)e.value ();
1348       if (value.compareTo (Expression.llMax) > 0) // value > long long max?
1349         value = value.subtract (Expression.twoPow64); // Convert to Java long (signed)
1350       return castString + '(' + value.toString () + 'L' + ')';
1351     }
1352     else
1353       return castString + '(' + parseExpression (e.left ()) + ' ' + e.op () + ' ' + parseExpression (e.right ()) + ')';
1354     // <d54640> end
1355   } // parseBinary
1356 
1357   /**
1358    *
1359    **/
1360   static String parseUnary (UnaryExpr e)
1361   {
1362     if (!(e.value () instanceof Number))
1363       return "(UNKNOWN_VALUE)"; // This shouldn't happen if the parser checked the expression types correctly.
1364     else if ((e.value () instanceof Float || e.value () instanceof Double) && e instanceof Not)
1365       return "(UNKNOWN_VALUE)"; // This shouldn't happen if the parser checked the expression types correctly.
1366     else
1367     {
1368       String castString = "";
1369       if (e.operand ().value () instanceof Float ||
1370           e.operand ().value () instanceof Double)
1371         castString = "(double)";
1372       // Support long long.
1373       //else
1374       //  castString = "(long)";
1375       else if (e.type (). indexOf ("long long") >= 0)
1376         castString = "(long)";
1377       else
1378         castString = "(int)";
1379 
1380       // <d54640> Must emit value rather than representation when type is
1381       // "unsigned long long" (ull) because emitted unary arithmetic expressions
1382       // containing a ull converted to long (i.e., IDL long long) do not always
1383       // compute to the correct result.
1384 
1385       //return castString + e.op () + parseExpression (e.operand ());
1386       if (e.type ().equals ("unsigned long long"))
1387       {
1388         BigInteger value = (BigInteger)e.value ();
1389         if (value.compareTo (Expression.llMax) > 0) // value > long long max?
1390           value = value.subtract (Expression.twoPow64); // Convert to Java long (signed)
1391         return castString + '(' + value.toString () + 'L' + ')';
1392       }
1393       else
1394         return castString + e.op () + parseExpression (e.operand ());
1395       // end <d54640>
1396     }
1397   } // parseUnary
1398 
1399   /**
1400    *
1401    **/
1402   public static boolean IDLEntity (SymtabEntry entry)
1403   {
1404     boolean rc = true;
1405     if (entry instanceof PrimitiveEntry || entry instanceof StringEntry)
1406        rc = false;
1407     else if (entry instanceof TypedefEntry)
1408        rc = IDLEntity (entry.type ());
1409     return rc;
1410   } // IDLEntity
1411 
1412   // <d62023>
1413   /**
1414    * @return true if the current setting of corbaLevel is within delta of
1415    *    the range min <= corbaLevel <= max
1416    **/
1417   public static boolean corbaLevel (float min, float max)
1418   {
1419     float level = Compile.compiler.arguments.corbaLevel;
1420     float delta = 0.001f;
1421     if ((level - min + delta >= 0.0f) && (max - level + delta >= 0.0f))
1422         return true;
1423     else
1424         return false;
1425   } // corbaLevel
1426 
1427   static Hashtable symbolTable = new Hashtable ();
1428   static Hashtable packageTranslation = new Hashtable() ;
1429 } // class Util