/*
* 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