{
// 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);