idl/toJavaPortable/Util.java

/*
 * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
/*
 * COMPONENT_NAME: idl.toJava
 *
 * ORIGINS: 27
 *
 * Licensed Materials - Property of IBM
 * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
 * RMI-IIOP v1.0
 *
 */

package com.sun.tools.corba.se.idl.toJavaPortable;

// Notes:
// -F46838.4<klr> Ported -td option from toJava.
// -10/17/98  KLR Ported fix for d48911 from toJava
// -10/18/98  KLR Ported fix from toJava for "unsigned long" constants
// -F46082.51<daz> Removed code to collect makefile list generation inforamtion
//  from getStream(); see f46830.
// -F46082.51<daz> Removed -stateful feature: methods javaStatefulName(String)
//  and javaStatefulName(SymtabEntry) are obsolete, supplanted by javaName().
// -D54640<daz> Represent unsigned long long expressions with their computed
//  value rather than their actual representation (see notes in method
//  parseTerminal(), parseBinary(), and parseUnary().)
// -D58319<daz> Add getVersion() method.
// -D48034<daz> Import Helper classes for typedef struct members when generating
//  helper.  See method addImportLines().
// -D59851<daz> Modify to enable QuickTest build. (pending)
// -D42256<daz> Determine import lines for template types, which may specify any
//  positive int., constant expression for a boundary. Such expression containing
//  non-literal contansts previously caused problems when appearing in constructs
//  structs, unions, exceptions, typedefs, operation types and parameters,
//  attributes; and of course, sequences, strings.
// -D59063<daz> Add helper for global exception to stub import list.
// -D58951<daz> Publicise members for QuickTest.
// -D59421<klr> Change ValueBaseHolder to SerializableHolder
// -D59596<klr> Prevent accesses to elements of empty Vectors.
// -D59771<daz> Add import stmt for Helper of global type in stubs.
// -D59355<daz> Remove target dir. from filename when writing to prolog.
// -D59437<daz> Fill typename information for value boxes.
// -D62023<klr> Don't import ValueBase*
// -D62023<klr> Add corbaLevel

import java.io.File;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.text.DateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Vector;

import com.sun.tools.corba.se.idl.ConstEntry;
import com.sun.tools.corba.se.idl.EnumEntry;
import com.sun.tools.corba.se.idl.ExceptionEntry;
import com.sun.tools.corba.se.idl.GenFileStream;
import com.sun.tools.corba.se.idl.InterfaceEntry;
import com.sun.tools.corba.se.idl.MethodEntry;
import com.sun.tools.corba.se.idl.NativeEntry;
import com.sun.tools.corba.se.idl.ParameterEntry;
import com.sun.tools.corba.se.idl.PrimitiveEntry;
import com.sun.tools.corba.se.idl.SequenceEntry;
import com.sun.tools.corba.se.idl.StringEntry;
import com.sun.tools.corba.se.idl.StructEntry;
import com.sun.tools.corba.se.idl.SymtabEntry;
import com.sun.tools.corba.se.idl.TypedefEntry;
import com.sun.tools.corba.se.idl.UnionBranch;
import com.sun.tools.corba.se.idl.UnionEntry;
import com.sun.tools.corba.se.idl.ValueEntry;
import com.sun.tools.corba.se.idl.ValueBoxEntry;
import com.sun.tools.corba.se.idl.InterfaceState;

import com.sun.tools.corba.se.idl.constExpr.*;

/**
 * Class Util is a repository of static members available for general
 * use by the IDL parser framework and any generator extensions.
 **/
public class Util extends com.sun.tools.corba.se.idl.Util
{
  // <d58319>
  /**
   * Fetch the version number of this build of the IDL-to-Java (portable)
   * compiler from the appropriate properties file.
   * @return the version number of this compiler build.
   **/
  public static String getVersion ()
  {
    return com.sun.tools.corba.se.idl.Util.getVersion ("com/sun/tools/corba/se/idl/toJavaPortable/toJavaPortable.prp");
  } // getVersion

  /**
   * This method is called by Setup.preEmit, so
   * symbolTable is available for all Util methods.
   **/
  static void setSymbolTable (Hashtable symtab)
  {
    symbolTable = symtab;
  } // setSymbolTable

  public static void setPackageTranslation( Hashtable pkgtrans )
  {
    packageTranslation = pkgtrans ;
  }

  public static boolean isInterface (String name)
  {
    return isInterface (name, symbolTable);
  } // isInterface

  static String arrayInfo (Vector arrayInfo)
  {
    int         arrays = arrayInfo.size ();
    String      info   = "";
    Enumeration e      = arrayInfo.elements ();
    while (e.hasMoreElements ())
      info = info + '[' + parseExpression ((Expression)e.nextElement ()) + ']';
    return info;
  } // arrayInfo

  // <d58951> static String sansArrayInfo (Vector arrayInfo)
  public static String sansArrayInfo (Vector arrayInfo)
  {
    int    arrays   = arrayInfo.size ();
    String brackets = "";
    for (int i = 0; i < arrays; ++i)
      brackets = brackets + "[]";
    return brackets;
  } // sansArrayInfo

  // <d58951> static String sansArrayInfo (String name)
  static public String sansArrayInfo (String name)
  {
    int index = name.indexOf ('[');
    if (index >= 0)
    {
      String array = name.substring (index);
      name = name.substring (0, index);
      while (!array.equals (""))
      {
        name = name + "[]";
        array = array.substring (array.indexOf (']') + 1);
      }
    }
    return name;
  } // sansArrayInfo

  /**
   * Given a symbol table entry, return the name of
   * the file which should be created.
   **/
  public static String fileName (SymtabEntry entry, String extension )
  {
    NameModifier nm = new NameModifierImpl() ;
    return fileName( entry, nm, extension ) ;
  } // fileName

  public static String fileName (SymtabEntry entry, NameModifier modifier, String extension )
  {
    // This may not be the most appropriate place for
    // the mkdir calls, but it's common to everything:
    String pkg = containerFullName (entry.container ());
    if (pkg != null && !pkg.equals (""))
      mkdir (pkg);

    String name = entry.name ();
    name = modifier.makeName( name ) + extension ;
    if (pkg != null && !pkg.equals (""))
      name = pkg + '/' + name;

    return name.replace ('/', File.separatorChar);
  } // fileName

  public static GenFileStream stream (SymtabEntry entry, String extension)
  {
    NameModifier nm = new NameModifierImpl() ;
    return stream(entry, nm, extension);
  } // stream

  public static GenFileStream stream (SymtabEntry entry, NameModifier modifier, String extension )
  {
    return getStream ( fileName (entry,modifier,extension), entry ) ;
  }

  public static GenFileStream getStream (String name, SymtabEntry entry)
  {
    // <f46838.4>
    String absPathName = ((Arguments)Compile.compiler.arguments).targetDir + name;
    if (Compile.compiler.arguments.keepOldFiles && new File (absPathName).exists ())
      return null;
    else
      // Write the data to the file stream
      return new GenFileStream (absPathName);
  } // getStream

  public static String containerFullName( SymtabEntry container)
  {
      String name = doContainerFullName( container ) ;
      if (packageTranslation.size() > 0)
          name = translate( name ) ;
      return name ;
  }

  public static String translate( String name )
  {
      String head = name ;
      String tail = "" ;
      int index ;
      String trname ;

      // Check for package name translations, starting with the
      // most specific match.
      do {
          trname = (String)(packageTranslation.get( head )) ;
          if (trname != null)
              return trname + tail ;

          index = head.lastIndexOf( '/' ) ;
          if (index >= 0) {
              tail = head.substring( index ) + tail ;
              head = head.substring( 0, index ) ;
          }
      } while (index >= 0) ;

      return name ;
  }

  private static String doContainerFullName (SymtabEntry container)
  {
    String name = "";

    if (container == null)
      name = "";
    else
    {
      if (container instanceof InterfaceEntry ||
          container instanceof StructEntry ||
          container instanceof UnionEntry)
        name = container.name () + "Package";
      else
        name = container.name ();

      if (container.container () != null &&
        !container.container ().name ().equals (""))
        name = doContainerFullName (container.container ()) + '/' + name;
    }

    return name;
  } // doContainerFullName

  /**
   * Given a SymtabEntry, return the string which should be used
   * for this entry. Enums are converted to ints, typedefs and
   * sequences are converted to their info types. javaQualifiedName
   * does not do any of these conversions.
   **/
  public static String javaName (SymtabEntry entry)
  {
    // First get the real name of this type
    String name = "";
    if (entry instanceof TypedefEntry || entry instanceof SequenceEntry)
      try
      {
        name = sansArrayInfo ((String)entry.dynamicVariable (Compile.typedefInfo));
      }
      catch (NoSuchFieldException e)
      {
        name = entry.name ();
      }
    else if (entry instanceof PrimitiveEntry)
      name = javaPrimName (entry.name ());
    else if (entry instanceof StringEntry)
      name = "String";
    else if (entry instanceof NativeEntry)
      name = javaNativeName (entry.name());
    else if (entry instanceof ValueEntry && entry.name ().equals ("ValueBase"))
        name = "java.io.Serializable";
    else if (entry instanceof ValueBoxEntry)
    {
      ValueBoxEntry v = (ValueBoxEntry) entry;
      TypedefEntry member = ((InterfaceState) v.state ().elementAt (0)).entry;
      SymtabEntry mType = member.type ();
      if (mType instanceof PrimitiveEntry)
      {
         name = containerFullName (entry.container ());
         if (!name.equals (""))
           name = name + '.';
         name = name + entry.name ();
      }
      else
         name = javaName (mType);
    }
    else
    {
      name = containerFullName (entry.container ());
      if (name.equals (""))
        name = entry.name ();
      else
        name = name + '.' + entry.name ();
    }

    // Make it a fully package-qualified name
    return name.replace ('/', '.');
  } // javaName

  public static String javaPrimName (String name)
  {
    if (name.equals ("long") || name.equals ("unsigned long"))
      name = "int";
    else if (name.equals ("octet"))
      name = "byte";
    // "unisigned long long" exceeds Java long.
    else if (name.equals ("long long") || name.equals ("unsigned long long"))
      name = "long";
    else if (name.equals ("wchar"))
      name = "char";
    else if (name.equals ("unsigned short"))
      name = "short";
    else if (name.equals ("any"))
      name = "org.omg.CORBA.Any";
    else if (name.equals ("TypeCode"))
      name = "org.omg.CORBA.TypeCode";
    else if (name.equals ("Principal")) // <d61961>
      name = "org.omg.CORBA.Principal";
    return name;
  } // javaPrimName

  public static String javaNativeName (String name)
  {

    // translations for Native declarations according to CORBA 2.3 spec

    if (name.equals ("AbstractBase") || name.equals ("Cookie"))
      name = "java.lang.Object";
    else if (name.equals ("Servant"))
      name = "org.omg.PortableServer.Servant";
    else if (name.equals ("ValueFactory"))
      name = "org.omg.CORBA.portable.ValueFactory";
    return name;
  }


  /**
   * Given a symtabEntry, return the name of this entry. This
   * method does not do any conversions like javaName does.
   **/
  public static String javaQualifiedName (SymtabEntry entry)
  {
    String name = "";
    if (entry instanceof PrimitiveEntry)
      name = javaPrimName (entry.name ());
    else if (entry instanceof StringEntry)
      name = "String";
    else if (entry instanceof ValueEntry && entry.name ().equals ("ValueBase"))
      name = "java.io.Serializable";
    else
    {
      SymtabEntry container = entry.container ();
      if (container != null)
        name = container.name ();
      if (name.equals (""))
        name = entry.name ();
      else
        name = containerFullName (entry.container ()) + '.' + entry.name ();
    }
    return name.replace ('/', '.');
  } // javaQualifiedName

  // <f46082.03> Publicize for extensions.
  //static String collapseName (String name)

  /**
   * Collapse primitive type names.
   **/
  public static String collapseName (String name)
  {
    if (name.equals ("unsigned short"))
      name = "ushort";
    else if (name.equals ("unsigned long"))
      name = "ulong";
    else if (name.equals ("unsigned long long"))
      name = "ulonglong";
    else if (name.equals ("long long"))
      name = "longlong";
    return name;
  } // collapseName

  /**
   *
   **/
  public static SymtabEntry typeOf (SymtabEntry entry)
  {
    while (entry instanceof TypedefEntry && ((TypedefEntry)entry).arrayInfo ().isEmpty () && !(entry.type () instanceof SequenceEntry))
      entry = entry.type ();
    return entry;
  } // typeOf

  /**
   * Fill the info field with the full name (with array info) of the type.
   **/
  static void fillInfo (SymtabEntry infoEntry)
  {
    String      arrayInfo   = "";
    SymtabEntry entry       = infoEntry;
    boolean     alreadyHave = false;

    do
    {
      try
      {
        alreadyHave = entry.dynamicVariable (Compile.typedefInfo) != null;
      }
      catch (NoSuchFieldException e)
      {}
      // If this entry's info has already been processed
      // don't bother processing it again, just take it.
      if (!alreadyHave)
      {
        if (entry instanceof TypedefEntry)
          arrayInfo = arrayInfo + arrayInfo (((TypedefEntry)entry).arrayInfo ());
        else if (entry instanceof SequenceEntry)
        {
          Expression maxSize = ((SequenceEntry)entry).maxSize ();
          if (maxSize == null)
            arrayInfo = arrayInfo + "[]";
          else
            arrayInfo = arrayInfo + '[' + parseExpression (maxSize) + ']';
        }
        if (entry.type () == null)
        {
          // <d59437> Suppress this message.  It tells the developer nothing, and
          // this path does not cause the algorithm to fail.  Value boxes may
          // contain anonymous types, like a struct or enum.
          //System.err.println (getMessage ("PreEmit.indeterminateTypeInfo", entry.typeName ()));
        }
        else
          entry = entry.type ();
      }
    } while (!alreadyHave && entry != null &&
        (entry instanceof TypedefEntry || entry instanceof SequenceEntry));
    // <d59437> Value boxes may contain types lacking typename info., which
    // causes the 2nd case, below, to fail with exception when retrieving the
    // javaName().
    if (entry instanceof ValueBoxEntry)
      fillValueBoxInfo ((ValueBoxEntry)entry);
    try
    {
      if (alreadyHave)
        infoEntry.dynamicVariable (Compile.typedefInfo, (String)entry.dynamicVariable (Compile.typedefInfo) + arrayInfo);
      else
        infoEntry.dynamicVariable (Compile.typedefInfo, javaName (entry) + arrayInfo);
    }
    catch (NoSuchFieldException e)
    {}
  } // fillInfo

  // <d59437>
  /**
   *
   **/
  static void fillValueBoxInfo (ValueBoxEntry vb)
  {
    SymtabEntry stateMember = (((InterfaceState) vb.state ().elementAt (0)).entry);
    if (stateMember.type() != null)
      Util.fillInfo (stateMember.type ());
    Util.fillInfo (stateMember);
  } // fillValueBoxInfo

  /**
   *
   **/
  public static String holderName (SymtabEntry entry)
  {
    String name;
    if (entry instanceof PrimitiveEntry)
      if (entry.name ().equals ("any"))
        name = "org.omg.CORBA.AnyHolder";
      else if (entry.name ().equals ("TypeCode"))
        name = "org.omg.CORBA.TypeCodeHolder";
      else if (entry.name ().equals ("Principal")) // <d61961>
        name = "org.omg.CORBA.PrincipalHolder";
      else
        name = "org.omg.CORBA." + capitalize (javaQualifiedName (entry)) + "Holder";
    else if (entry instanceof TypedefEntry)
    {
      TypedefEntry td = (TypedefEntry)entry;
      if (!td.arrayInfo ().isEmpty () || td.type () instanceof SequenceEntry)
        name = javaQualifiedName (entry) + "Holder";
      else
        name = holderName (entry.type ());
    }
    else if (entry instanceof StringEntry)
      name = "org.omg.CORBA.StringHolder";
    else if (entry instanceof ValueEntry)
    {
      if (entry.name ().equals ("ValueBase"))
          name = "org.omg.CORBA.ValueBaseHolder"; // <d59421>, <d60929>
      else
          name = javaName (entry) + "Holder";
    } else if (entry instanceof NativeEntry) {
      // do not attach holder to the translation for Native Entries, e.g.
      // for Cookie it should be CookieHolder instead of java.lang.ObjectHolder
      // returns the complete name for the package, etc.
      name = javaQualifiedName(entry) + "Holder";
    }
    else
      name = javaName (entry) + "Holder";
    return name;
  } // holderName

  /**
   * <d61056>
   **/
  public static String helperName (SymtabEntry entry, boolean qualifiedName)
  {
    if (entry instanceof ValueEntry)
      if (entry.name ().equals ("ValueBase"))
          return "org.omg.CORBA.ValueBaseHelper";

    if (qualifiedName)
      return javaQualifiedName (entry) + "Helper";
    else
      return javaName (entry) + "Helper";
  } // helperName

  public static final short
      TypeFile   = 0,
      StubFile   = 1,
      HelperFile = 2,
      HolderFile = 3,
      StateFile  = 4;

  /**
   *
   **/
  public static void writePackage (PrintWriter stream, SymtabEntry entry)
  {
    writePackage (stream, entry, TypeFile);
  } // writePackage

  /**
   *
   **/
  public static void writePackage (PrintWriter stream, SymtabEntry entry, String name, short type)
  {
    if (name != null && !name.equals (""))
    {
      stream.println ("package " + name.replace ('/', '.') + ';');

      // This type is in a module.  Just in case it refers to types
      // in the unnamed module, add an import statement for each of
      // those types.
      if (!Compile.compiler.importTypes.isEmpty ())
      {
        stream.println ();
        Vector v = addImportLines (entry, Compile.compiler.importTypes, type);
        printImports (v, stream);
      }
    }
  } // writePackage

  /**
   *
   **/
  public static void writePackage (PrintWriter stream, SymtabEntry entry, short type)
  {
    String fullName = containerFullName (entry.container ());
    if (fullName != null && !fullName.equals (""))
    {
      stream.println ("package " + fullName.replace ('/', '.') + ';');
       // This type is in a module.  Just in case it refers to types
      // in the unnamed module, add an import statement for each of
      // those types.
      if ((type != HolderFile || entry instanceof TypedefEntry) && !Compile.compiler.importTypes.isEmpty ())
      {
        stream.println ();
        Vector v = addImportLines (entry, Compile.compiler.importTypes, type);
        printImports (v, stream);
      }
      /*
      Enumeration e = Compile.compiler.importTypes.elements ();
      while (e.hasMoreElements ())
      {
        SymtabEntry i = (SymtabEntry)e.nextElement ();
        // Write import for type
        if (!(i instanceof TypedefEntry))
          stream.println ("import " + i.name () + ';');

        // Write import for Helper
        if (!(i instanceof ConstEntry))
          stream.println ("import " + i.name () + "Helper;");

        // Write import for Holder
        if (!(i instanceof ConstEntry))
          if (!(i instanceof TypedefEntry) || (i.type () instanceof SequenceEntry || !((TypedefEntry)i).arrayInfo ().isEmpty ()))
            stream.println ("import " + i.name () + "Holder;");
      }
      */
    }
  } // writePackage

  /**
   *
   **/
  static private void printImports (Vector importList, PrintWriter stream)
  {
    Enumeration e = importList.elements ();
    while (e.hasMoreElements ())
      stream.println ("import " + (String)e.nextElement () + ';');
  } // printImport

  /**
   *
   **/
  static private void addTo (Vector importList, String name)
  {
    // REVISIT - <d62023-klr> was also importing ValueBaseHolder and Helper
    if (name.startsWith ("ValueBase"))  // don't import ValueBase*
      if ((name.compareTo ("ValueBase") == 0) ||
          (name.compareTo ("ValueBaseHolder") == 0) ||
              (name.compareTo ("ValueBaseHelper") == 0))
        return;
    if (!importList.contains (name))
      importList.addElement (name);
  } // addTo

  /**
   *
   **/
  static private Vector addImportLines (SymtabEntry entry, Vector importTypes, short type)
  {
    Vector importList = new Vector ();
    if (entry instanceof ConstEntry)
    {
      ConstEntry c      = (ConstEntry)entry;
      Object     cvalue = c.value ().value ();
      if (cvalue instanceof ConstEntry && importTypes.contains (cvalue))
        addTo (importList, ((ConstEntry)cvalue).name ());
    }
    else if (entry instanceof ValueEntry && type == HelperFile) // <d59512>
    {
      // This code inspired by ValueGen.getConcreteBaseTypeCode().  Helper method
      // type() could be invoked against a global valuetype.
      if (((ValueEntry)entry).derivedFrom ().size () > 0) // <59596> KLR HACK
      {
        ValueEntry base = (ValueEntry)((ValueEntry)entry).derivedFrom ().elementAt (0);
        String baseName = base.name ();
        if (!"ValueBase".equals (baseName))
          if (importTypes.contains (base))
            addTo (importList, baseName + "Helper");
      }
    }
    else if (entry instanceof InterfaceEntry && (type == TypeFile || type == StubFile))
    {
      InterfaceEntry i = (InterfaceEntry)entry;

      if (i instanceof ValueEntry) // <d59512>
      {
        // Examine interface parents in supports vector.
        Enumeration e = ((ValueEntry)i).supports ().elements ();
        while (e.hasMoreElements ())
        {
          SymtabEntry parent = (SymtabEntry)e.nextElement ();
          if (importTypes.contains (parent))
          {
            addTo (importList, parent.name () + "Operations");
          }
          // If this is a stub, then recurse to the parents
          if (type == StubFile)
          {
            if (importTypes.contains (parent))
              addTo (importList, parent.name ());
            Vector subImportList = addImportLines (parent, importTypes, StubFile);
            Enumeration en = subImportList.elements ();
            while (en.hasMoreElements ())
            {
              addTo (importList, (String)en.nextElement ());
            }
          }
        }
      }
      // Interface or valuetype -- Examine interface and valuetype parents,
      // Look through derivedFrom vector
      Enumeration e = i.derivedFrom ().elements ();
      while (e.hasMoreElements ())
      {
        SymtabEntry parent = (SymtabEntry)e.nextElement ();
        if (importTypes.contains (parent))
        {
          addTo (importList, parent.name ());
          // <d59512> Always add both imports, even though superfluous.  Cannot
          // tell when writing Operations or Signature interface!
          if (!(parent instanceof ValueEntry)) // && parent.name ().equals ("ValueBase")))
            addTo (importList, parent.name () + "Operations");
        }
        // If this is a stub, then recurse to the parents
        if (type == StubFile)
        {
          Vector subImportList = addImportLines (parent, importTypes, StubFile);
          Enumeration en = subImportList.elements ();
          while (en.hasMoreElements ())
          {
            addTo (importList, (String)en.nextElement ());
          }
        }
      }
      // Look through methods vector
      e = i.methods ().elements ();
      while (e.hasMoreElements ())
      {
        MethodEntry m = (MethodEntry)e.nextElement ();

        // Look at method type
        SymtabEntry mtype = typeOf (m.type ());
        if (mtype != null && importTypes.contains (mtype))
          if (type == TypeFile || type == StubFile)
          {
            addTo (importList, mtype.name ());
            addTo (importList, mtype.name () + "Holder");
            if (type == StubFile)
              addTo (importList, mtype.name () + "Helper");
          }
        checkForArrays (mtype, importTypes, importList);
        // <d42256> Print import lines for globals constants and constants
        // within global interfaces.
        if (type == StubFile)
          checkForBounds (mtype, importTypes, importList);

        // Look through exceptions
        Enumeration exEnum = m.exceptions ().elements ();
        while (exEnum.hasMoreElements ())
        {
          ExceptionEntry ex = (ExceptionEntry)exEnum.nextElement ();
          if (importTypes.contains (ex))
          {
            addTo (importList, ex.name ());
            addTo (importList, ex.name () + "Helper"); // <d59063>
          }
        }

        // Look through parameters
        Enumeration parms = m.parameters ().elements ();
        while (parms.hasMoreElements ())
        {
          ParameterEntry parm = (ParameterEntry)parms.nextElement ();
          SymtabEntry parmType = typeOf (parm.type ());
          if (importTypes.contains (parmType))
          {
            // <d59771> Helper needed in stubs.
            if (type == StubFile)
              addTo (importList, parmType.name () + "Helper");
            if (parm.passType () == ParameterEntry.In)
              addTo (importList, parmType.name ());
            else
              addTo (importList, parmType.name () + "Holder");
          }
          checkForArrays (parmType, importTypes, importList);
          // <d42256>
          if (type == StubFile)
            checkForBounds (parmType, importTypes, importList);
        }
      }
    }
    else if (entry instanceof StructEntry)
    {
      StructEntry s = (StructEntry)entry;

      // Look through the members
      Enumeration members = s.members ().elements ();
      while (members.hasMoreElements ())
      {
        SymtabEntry member = (TypedefEntry)members.nextElement ();
        // <d48034> Need to add helper name for typedef members.  This name
        // is referenced at typecode generation in Helper class.
        SymtabEntry memberType = member.type ();
        member = typeOf (member);
        if (importTypes.contains (member))
        {
          // If this IS a typedef, then there are only Helper/Holder classes.
          //if (!(member instanceof TypedefEntry))
          // <d59437>  Valueboxes
          if (!(member instanceof TypedefEntry) && !(member instanceof ValueBoxEntry))
            addTo (importList, member.name ());
          // <d48034> Add helper name of alias, too, if member is a typedef.
          //if (type == HelperFile)
          //  addTo (importList, member.name () + "Helper");
          if (type == HelperFile)
          {
            addTo (importList, member.name () + "Helper");
            if (memberType instanceof TypedefEntry)
              addTo (importList, memberType.name () + "Helper");
          }
        }
        checkForArrays (member, importTypes, importList);
        checkForBounds (member, importTypes, importList);
      }
    }
    else if (entry instanceof TypedefEntry)
    {
      TypedefEntry t = (TypedefEntry)entry;
      String arrays = checkForArrayBase (t, importTypes, importList);
      if (type == HelperFile)
      {
        checkForArrayDimensions (arrays, importTypes, importList);
        try
        {
          String name = (String)t.dynamicVariable (Compile.typedefInfo);
          int index = name.indexOf ('[');
          if (index >= 0)
            name = name.substring (0, index);
          // See if the base type should be added to the list.
          SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (name);
          if (typeEntry != null && importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name () + "Helper");
        }
        catch (NoSuchFieldException e)
        {}

        // <d42256> Typedefs for global bounded strings need import
        // statement when bound expression contains non-literal constants.
        checkForBounds (typeOf (t), importTypes, importList);
      }
      Vector subImportList = addImportLines (t.type (), importTypes, type);
      Enumeration e = subImportList.elements ();
      while (e.hasMoreElements ())
        addTo (importList, (String)e.nextElement ());
    }
    else if (entry instanceof UnionEntry)
    {
      UnionEntry u = (UnionEntry)entry;

      // Look at the discriminant type
      SymtabEntry utype = typeOf (u.type ());
      if (utype instanceof EnumEntry && importTypes.contains (utype))
        addTo (importList, utype.name ());

      // Look through the branches
      Enumeration branches = u.branches ().elements ();
      while (branches.hasMoreElements ())
      {
        UnionBranch branch = (UnionBranch)branches.nextElement ();
        SymtabEntry branchEntry = typeOf (branch.typedef);
        if (importTypes.contains (branchEntry))
        {
          addTo (importList, branchEntry.name ());
          if (type == HelperFile)
            addTo (importList, branchEntry.name () + "Helper");
        }
        checkForArrays (branchEntry, importTypes, importList);
        // <d42256>
        checkForBounds (branchEntry, importTypes, importList);
      }
    }

    // If a typedef is not a sequence or an array, only holders and
    // helpers are generated for it.  Remove references to such
    // class names.
    Enumeration en = importList.elements ();
    while (en.hasMoreElements ())
    {
      String name = (String)en.nextElement ();
      SymtabEntry e = (SymtabEntry)symbolTable.get (name);
      if (e != null && e instanceof TypedefEntry)
      {
        TypedefEntry t = (TypedefEntry)e;
        if (t.arrayInfo ().size () == 0 || !(t.type () instanceof SequenceEntry))
          importList.removeElement (name);
      }
    }
    return importList;
  } // addImportLines

  /**
   *
   **/
  static private void checkForArrays (SymtabEntry entry, Vector importTypes, Vector importList)
  {
    if (entry instanceof TypedefEntry)
    {
      TypedefEntry t = (TypedefEntry)entry;
      String arrays = checkForArrayBase (t, importTypes, importList);
      checkForArrayDimensions (arrays, importTypes, importList);
    }
  } // checkForArrays

  /**
   *
   **/
  static private String checkForArrayBase (TypedefEntry t, Vector importTypes, Vector importList)
  {
    String arrays = "";
    try
    {
      String name = (String)t.dynamicVariable (Compile.typedefInfo);
      int index = name.indexOf ('[');
      if (index >= 0)
      {
        arrays = name.substring (index);
        name = name.substring (0, index);
      }

      // See if the base type should be added to the list.
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (name);
      if (typeEntry != null && importTypes.contains (typeEntry))
        addTo (importList, typeEntry.name ());
    }
    catch (NoSuchFieldException e)
    {}
    return arrays;
  } // checkForArrayBase

  /**
   *
   **/
  static private void checkForArrayDimensions (String arrays, Vector importTypes, Vector importList)
  {
    // See if any of the arrays contain a constentry.
    // If so, see if it should be added to the list.
    while (!arrays.equals (""))
    {
      int index = arrays.indexOf (']');
      String dim = arrays.substring (1, index);
      arrays = arrays.substring (index + 1);
      SymtabEntry constant = (SymtabEntry)symbolTable.get (dim);
      if (constant == null)
      {
        // A constant expr could be of the form <const> OR
        // <interface>.<const>.  This if branch checks for that case.
        int i = dim.lastIndexOf ('.');
        if (i >= 0)
          constant = (SymtabEntry)symbolTable.get (dim.substring (0, i));
      }
      if (constant != null && importTypes.contains (constant))
        addTo (importList, constant.name ());
    }
  } // checkForArrayDimensions

  // <d42256> Call the following method when its necessary to determine the
  // the import types for IDL constructs containing arbitrary positive int.
  // expressions, which may specify non-literal constants.

  /**
   * Determine the import lines for template types.
   **/
  static private void checkForBounds (SymtabEntry entry, Vector importTypes, Vector importList)
  {
    // Obtain actual type, just to be complete.
    SymtabEntry entryType = entry;
    while (entryType instanceof TypedefEntry)
      entryType = entryType.type ();

    if (entryType instanceof StringEntry && ((StringEntry)entryType).maxSize () != null)
      checkForGlobalConstants (((StringEntry)entryType).maxSize ().rep (), importTypes, importList);
    else
      if (entryType instanceof SequenceEntry && ((SequenceEntry)entryType).maxSize () != null)
        checkForGlobalConstants (((SequenceEntry)entryType).maxSize ().rep (), importTypes, importList);
  } // checkForBounds

  /**
   * Extract the global constants from the supplied integer expression
   * representation (string) and add them to the supplied import list.
   **/
  static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
  {
    // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
    // delimiter and would not be otherwise properly collected. Blanks and
    // arithmetic symbols do not appear in tokens, except for '/'.
    java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
    while (st.hasMoreTokens ())
    {
      String token = st.nextToken ();
      // When token contains '/', it represents the division symbol or
      // a nested type (e.g., I/x). Ignore the division symbol, and don't
      // forget constants declared within global interfaces!
      if (!token.equals ("/"))
      {
        SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
        if (typeEntry instanceof ConstEntry)
        {
          int slashIdx = token.indexOf ('/');
          if (slashIdx < 0)  // Possible global constant
          {
            if (importTypes.contains (typeEntry))
              addTo (importList, typeEntry.name ());
          }
          else  // Possible constant in global interface
          {
            SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
            if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
              addTo (importList, constContainer.name ());
          }
        }
      }
    }
  } // checkForGlobalConstants

  /**
   *
   **/
  public static void writeInitializer (String indent, String name, String arrayDcl, SymtabEntry entry, PrintWriter stream)
  {
    if (entry instanceof TypedefEntry)
    {
      TypedefEntry td = (TypedefEntry)entry;
      writeInitializer (indent, name, arrayDcl + sansArrayInfo (td.arrayInfo ()), td.type (), stream);
    }
    else if (entry instanceof SequenceEntry)
      writeInitializer (indent, name, arrayDcl + "[]", entry.type (), stream);
    else if (entry instanceof EnumEntry)
      if (arrayDcl.length () > 0)
        stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = null;");
      else
        stream.println (indent + javaName (entry) + ' ' + name + " = null;");
    else if (entry instanceof PrimitiveEntry)
    {
      boolean array = arrayDcl.length () > 0;
      String tname = javaPrimName (entry.name ());
      if (tname.equals ("boolean"))
        stream.println (indent + "boolean " + name + arrayDcl + " = " + (array ? "null;" : "false;"));
      else if (tname.equals ("org.omg.CORBA.TypeCode"))
        stream.println (indent + "org.omg.CORBA.TypeCode " + name + arrayDcl + " = null;");
      else if (tname.equals ("org.omg.CORBA.Any"))
        stream.println (indent + "org.omg.CORBA.Any " + name + arrayDcl + " = null;");
      else if (tname.equals ("org.omg.CORBA.Principal")) // <d61961>
        stream.println (indent + "org.omg.CORBA.Principal " + name + arrayDcl + " = null;");
      else
        stream.println (indent + tname + ' ' + name + arrayDcl + " = " + (array ? "null;" : '(' + tname + ")0;"));
    }
    // <f46082.51> Remove -stateful feature. This case is identical to next one
    // because javaName() supplants javaStatefulName().
    //else if (entry instanceof InterfaceEntry && ((InterfaceEntry)entry).state () != null)
    //  stream.println (indent + javaStatefulName ((InterfaceEntry)entry) + ' ' + name + arrayDcl + " = null;");
    else
      stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = null;");
  } // writeInitializer

  /**
   *
   **/
  public static void writeInitializer (String indent, String name, String arrayDcl, SymtabEntry entry, String initializer, PrintWriter stream)
  {
    if (entry instanceof TypedefEntry)
    {
      TypedefEntry td = (TypedefEntry)entry;
      writeInitializer (indent, name, arrayDcl + sansArrayInfo (td.arrayInfo ()), td.type (), initializer, stream);
    }
    else if (entry instanceof SequenceEntry)
      writeInitializer (indent, name, arrayDcl + "[]", entry.type (), initializer, stream);
    else if (entry instanceof EnumEntry)
      if (arrayDcl.length () > 0)
        stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = " + initializer + ';');
      else
        stream.println (indent + javaName (entry) + ' ' + name + " = " + initializer + ';');
    else if (entry instanceof PrimitiveEntry)
    {
      boolean array = arrayDcl.length () > 0;
      String tname = javaPrimName (entry.name ());
      if (tname.equals ("boolean"))
        stream.println (indent + "boolean " + name + arrayDcl + " = " + initializer + ';');
      else if (tname.equals ("org.omg.CORBA.TypeCode"))
        stream.println (indent + "org.omg.CORBA.TypeCode " + name + arrayDcl + " = " + initializer + ';');
      else if (tname.equals ("org.omg.CORBA.Any"))
        stream.println (indent + "org.omg.CORBA.Any " + name + arrayDcl + " = " + initializer + ';');
      else if (tname.equals ("org.omg.CORBA.Principal")) // <d61961>
        stream.println (indent + "org.omg.CORBA.Principal " + name + arrayDcl + " = " + initializer + ';');
      else
        stream.println (indent + tname + ' ' + name + arrayDcl + " = " + initializer + ';');
    }
    // <f46082.51> Remove -stateful feature. This case is identical to next one
    // because javaName() supplants javaStatefulName().
    //else if (entry instanceof InterfaceEntry && ((InterfaceEntry)entry).state () != null)
    //  stream.println (indent + javaStatefulName ((InterfaceEntry)entry) + ' ' + name + arrayDcl + " = " + initializer + ';');
    else
      stream.println (indent + javaName (entry) + ' ' + name + arrayDcl + " = " + initializer + ';');
  } // writeInitializer

  /**
   *
   **/
  public static void mkdir (String name)
  {
    String targetDir = ((Arguments)Compile.compiler.arguments).targetDir; // F46838.4
    name = (targetDir + name).replace ('/', File.separatorChar); // F46838.4
    File pkg = new File (name);
    if (!pkg.exists ())
      if (!pkg.mkdirs ())
        System.err.println (getMessage ("Util.cantCreatePkg", name));
  } // mkdir

  /**
   *
   **/
  public static void writeProlog (PrintWriter stream, String filename)
  {
    // <d59355> Remove target directory
    String targetDir = ((Arguments)Compile.compiler.arguments).targetDir;
    if (targetDir != null)
      filename = filename.substring (targetDir.length ());
    stream.println ();
    stream.println ("/**");
    stream.println ("* " + filename.replace (File.separatorChar, '/') +
        " .");
    stream.println ("* " + Util.getMessage ("toJavaProlog1",
        Util.getMessage ("Version.product", Util.getMessage ("Version.number"))));
    // <d48911> Do not introduce invalid escape characters into comment! <daz>
    //stream.println ("* " + Util.getMessage ("toJavaProlog2", Compile.compiler.arguments.file));
    stream.println ("* " + Util.getMessage ("toJavaProlog2", Compile.compiler.arguments.file.replace (File.separatorChar, '/')));

    ///////////////
    // This SHOULD work, but there's a bug in the JDK.
    //    stream.println ("* " + DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, Locale.getDefault ()).format (new Date ()));
    // This gets around the bug:

    DateFormat formatter = DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, Locale.getDefault ());

    // Japanese-specific workaround.  JDK bug 4069784 being repaired by JavaSoft.
    // Keep this transient solution until bug fix is reported.cd .

    if (Locale.getDefault () == Locale.JAPAN)
      formatter.setTimeZone (java.util.TimeZone.getTimeZone ("JST"));
    else
      formatter.setTimeZone (java.util.TimeZone.getDefault ());

    stream.println ("* " + formatter.format (new Date ()));

    // <daz>
    ///////////////

    stream.println ("*/");
    stream.println ();
  } // writeProlog

  // keywords ending in Holder or Helper or Package have '_' prepended.
  // These prepended underscores must not be part of anything sent
  // across the wire, so these two methods are provided to strip them
  // off.

  /**
   *
   **/
  public static String stripLeadingUnderscores (String string)
  {
    while (string.startsWith ("_"))
      string = string.substring (1);
    return string;
  } // stripLeadingUnderscores

  /**
   *
   **/
  public static String stripLeadingUnderscoresFromID (String string)
  {
    String stringPrefix = "";
    int slashIndex = string.indexOf (':');
    if (slashIndex >= 0)
      do
      {
        stringPrefix = stringPrefix + string.substring (0, slashIndex + 1);
        string = string.substring (slashIndex + 1);
        while (string.startsWith ("_"))
          string = string.substring (1);
        slashIndex = string.indexOf ('/');
      } while (slashIndex >= 0);
    return stringPrefix + string;
  } // stripLeadingUnderscoresFromID

  /**
   *
   **/
  public static String parseExpression (Expression e)
  {
    if (e instanceof Terminal)
      return parseTerminal ((Terminal)e);
    else if (e instanceof BinaryExpr)
      return parseBinary ((BinaryExpr)e);
    else if (e instanceof UnaryExpr)
      return parseUnary ((UnaryExpr)e);
    else
      return "(UNKNOWN_VALUE)"; // This shouldn't happen unless someone slips
                                // in another type of expression.
  } // parseExpression

  /**
   *
   **/
  static String parseTerminal (Terminal e)
  {
    if (e.value () instanceof ConstEntry)
    {
      ConstEntry c = (ConstEntry)e.value ();
      if (c.container () instanceof InterfaceEntry)
        return javaQualifiedName (c.container ()) + '.' + c.name ();
      else
        return javaQualifiedName (c) + ".value";
    }
    else if (e.value () instanceof Expression)
      return '(' + parseExpression ((Expression)e.value ()) + ')';
    else if (e.value () instanceof Character)
    {
      if (((Character)e.value ()).charValue () == '\013')
        // e.rep is \v.  \v for vertical tab is meaningless in Java.
        return "'\\013'";
      else if (((Character)e.value ()).charValue () == '\007')
        // e.rep is \a.  \a for alert is meaningless in Java.
        return "'\\007'";
      else if (e.rep ().startsWith ("'\\x"))
        return hexToOctal (e.rep ());
      else if (e.rep ().equals ("'\\?'"))
        return "'?'";
      else
        return e.rep ();
    }
    else if (e.value () instanceof Boolean)
      return e.value ().toString ();

    // <d54640> If value is type "unsigned long long" (ull) and its magnitude
    // is greater than the maximal Java long (i.e., IDL long long) value, then
    // return its signed representation rather than its actual representation.
    /*
    // Support long long
    //else if (e.value () instanceof Long)
    else if (e.value () instanceof BigInteger &&
             (e.type ().indexOf ("long long") >= 0 || e.type ().equals ("unsigned long"))) // <klr>
    {
      String rep   = e.rep ();
      int    index = rep.indexOf (')');
      if (index < 0)
        return rep + 'L';
      else
        return rep.substring (0, index) + 'L' + rep.substring (index);
    }
    */
    else if (e.value () instanceof BigInteger)
    {
      // Get the correct primitive type. Since integer types (octet, short,
      // long, long long, unsigned short, unsigned long, unsigned long long)
      // could be aliased (typedef'ed) to any arbitrary levels, the code
      // below walks up the alias chain to get to the primitive type.

      // Get the symbol table entry corresponding to the 'type'.
      SymtabEntry typeEntry = (SymtabEntry) symbolTable.get(e.type());

      // Get to the primitive type.
      while (typeEntry.type() != null) {
          typeEntry = typeEntry.type();
      }
      String type = typeEntry.name();

      if (type.equals("unsigned long long") &&
          ((BigInteger)e.value ()).compareTo (Expression.llMax) > 0) // value > long long Max?
      {
        // Convert to signed value, which will always be negative.
        BigInteger v = (BigInteger)e.value ();
        v = v.subtract (Expression.twoPow64);
        int index = e.rep ().indexOf (')');
        if (index < 0)
          return v.toString () + 'L';
        else
          return '(' + v.toString () + 'L' + ')';
      }
      else if ( type.indexOf("long long") >= 0 || type.equals("unsigned long") )
      {
        String rep   = e.rep ();
        int    index = rep.indexOf (')');
        if (index < 0)
          return rep + 'L';
        else
          return rep.substring (0, index) + 'L' + rep.substring (index);
      }
      else
        return e.rep ();
    } // end <d54640>
    else
      return e.rep ();
  } // parseTerminal

  /**
   *
   **/
  static String hexToOctal (String hex)
  {
    // The format of hex is '/xXX' where XX is one or two hex digits.
    // This statement pulls off XX.
    hex = hex.substring (3, hex.length () - 1);
    return "'\\" + Integer.toString (Integer.parseInt (hex, 16), 8) + "'";
  } // hexToOctal

  /**
   *
   **/
  static String parseBinary (BinaryExpr e)
  {
    String castString = "";
    if (e.value () instanceof Float || e.value () instanceof Double)
    {
      castString = "(double)";
      if (!(e instanceof Plus || e instanceof Minus ||
            e instanceof Times || e instanceof Divide))
        System.err.println ("Operator " + e.op () + " is invalid on floating point numbers");
    }
    else if (e.value () instanceof Number)
    {
      if (e.type (). indexOf ("long long") >= 0)
        castString = "(long)";
      else
        castString = "(int)";
    }
    else
    {
      castString = "";
      System.err.println ("Unknown type in constant expression");
    }

    // <d54640> Must emit value rather than representation when type "unsigned
    // long long" (ull) because emitted binary arithmetic expressions containing
    // ull's converted to long (i.e., IDL long long) do not always compute to
    // the correct result.

    //return castString + '(' + parseExpression (e.left ()) + ' ' + e.op () + ' ' + parseExpression (e.right ()) + ')';
    if (e.type ().equals ("unsigned long long"))
    {
      BigInteger value = (BigInteger)e.value ();
      if (value.compareTo (Expression.llMax) > 0) // value > long long max?
        value = value.subtract (Expression.twoPow64); // Convert to Java long (signed)
      return castString + '(' + value.toString () + 'L' + ')';
    }
    else
      return castString + '(' + parseExpression (e.left ()) + ' ' + e.op () + ' ' + parseExpression (e.right ()) + ')';
    // <d54640> end
  } // parseBinary

  /**
   *
   **/
  static String parseUnary (UnaryExpr e)
  {
    if (!(e.value () instanceof Number))
      return "(UNKNOWN_VALUE)"; // This shouldn't happen if the parser checked the expression types correctly.
    else if ((e.value () instanceof Float || e.value () instanceof Double) && e instanceof Not)
      return "(UNKNOWN_VALUE)"; // This shouldn't happen if the parser checked the expression types correctly.
    else
    {
      String castString = "";
      if (e.operand ().value () instanceof Float ||
          e.operand ().value () instanceof Double)
        castString = "(double)";
      // Support long long.
      //else
      //  castString = "(long)";
      else if (e.type (). indexOf ("long long") >= 0)
        castString = "(long)";
      else
        castString = "(int)";

      // <d54640> Must emit value rather than representation when type is
      // "unsigned long long" (ull) because emitted unary arithmetic expressions
      // containing a ull converted to long (i.e., IDL long long) do not always
      // compute to the correct result.

      //return castString + e.op () + parseExpression (e.operand ());
      if (e.type ().equals ("unsigned long long"))
      {
        BigInteger value = (BigInteger)e.value ();
        if (value.compareTo (Expression.llMax) > 0) // value > long long max?
          value = value.subtract (Expression.twoPow64); // Convert to Java long (signed)
        return castString + '(' + value.toString () + 'L' + ')';
      }
      else
        return castString + e.op () + parseExpression (e.operand ());
      // end <d54640>
    }
  } // parseUnary

  /**
   *
   **/
  public static boolean IDLEntity (SymtabEntry entry)
  {
    boolean rc = true;
    if (entry instanceof PrimitiveEntry || entry instanceof StringEntry)
       rc = false;
    else if (entry instanceof TypedefEntry)
       rc = IDLEntity (entry.type ());
    return rc;
  } // IDLEntity

  // <d62023>
  /**
   * @return true if the current setting of corbaLevel is within delta of
   *    the range min <= corbaLevel <= max
   **/
  public static boolean corbaLevel (float min, float max)
  {
    float level = Compile.compiler.arguments.corbaLevel;
    float delta = 0.001f;
    if ((level - min + delta >= 0.0f) && (max - level + delta >= 0.0f))
        return true;
    else
        return false;
  } // corbaLevel

  static Hashtable symbolTable = new Hashtable ();
  static Hashtable packageTranslation = new Hashtable() ;
} // class Util