/*
* Copyright (c) 1999, 2013, 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:
// -cast() does not support longlong types yet.
// -Deal with typedef changes.
// -Scoped names for the discriminator are ignored at the moment.
// -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete.
// -D61056 <klr> Use Util.helperName
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import com.sun.tools.corba.se.idl.GenFileStream;
import com.sun.tools.corba.se.idl.ConstEntry;
import com.sun.tools.corba.se.idl.EnumEntry;
import com.sun.tools.corba.se.idl.InterfaceEntry;
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.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.constExpr.Expression;
import com.sun.tools.corba.se.idl.constExpr.EvaluationException;
/**
*
**/
public class UnionGen implements com.sun.tools.corba.se.idl.UnionGen, JavaGenerator
{
/**
* Public zero-argument constructor.
**/
public UnionGen ()
{
} // ctor
/**
*
**/
public void generate (Hashtable symbolTable, UnionEntry u, PrintWriter s)
{
this.symbolTable = symbolTable;
this.u = u;
init ();
openStream ();
if (stream == null)
return;
generateHelper ();
generateHolder ();
writeHeading ();
writeBody ();
writeClosing ();
closeStream ();
generateContainedTypes ();
} // generate
/**
* Initialize members unique to this generator.
**/
protected void init ()
{
utype = Util.typeOf (u.type ());
unionIsEnum = utype instanceof EnumEntry;
} // init
/**
*
**/
protected void openStream ()
{
stream = Util.stream (u, ".java");
} // openStream
/**
*
**/
protected void generateHelper ()
{
((Factories)Compile.compiler.factories ()).helper ().generate (symbolTable, u);
} // generateHelper
/**
*
**/
protected void generateHolder ()
{
((Factories)Compile.compiler.factories ()).holder ().generate (symbolTable, u);
} // generateHolder
/**
*
**/
protected void writeHeading ()
{
// If the discriminator is an enum, assign the typePackage string.
if (unionIsEnum)
typePackage = Util.javaQualifiedName (utype) + '.';
else
typePackage = "";
Util.writePackage (stream, u);
Util.writeProlog (stream, ((GenFileStream)stream).name ());
String className = u.name ();
stream.println ("public final class " + u.name () + " implements org.omg.CORBA.portable.IDLEntity");
stream.println ("{");
} // writeHeading
/**
*
**/
protected void writeBody ()
{
// Write branches and populate quality arrays
int size = u.branches ().size () + 1;
Enumeration e = u.branches ().elements ();
int i = 0;
while (e.hasMoreElements ())
{
UnionBranch branch = (UnionBranch)e.nextElement ();
Util.fillInfo (branch.typedef);
// <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
//stream.println (" private " + Util.javaStatefulName (branch.typedef) + " ___" + branch.typedef.name () + ";");
stream.println (" private " + Util.javaName (branch.typedef) + " ___" + branch.typedef.name () + ";");
++i;
}
stream.println (" private " + Util.javaName (utype) + " __discriminator;");
stream.println (" private boolean __uninitialized = true;");
// Write ctor
stream.println ();
stream.println (" public " + u.name () + " ()");
stream.println (" {");
stream.println (" }");
// Write discriminator
stream.println ();
stream.println (" public " + Util.javaName (utype) + " " + safeName (u, "discriminator") + " ()");
stream.println (" {");
stream.println (" if (__uninitialized)");
stream.println (" throw new org.omg.CORBA.BAD_OPERATION ();");
stream.println (" return __discriminator;");
stream.println (" }");
// Write for each branch:
// - setter
// - getter
// - private verifyXXX
e = u.branches ().elements ();
i = 0;
while (e.hasMoreElements ())
{
UnionBranch branch = (UnionBranch)e.nextElement ();
writeBranchMethods (stream, u, branch, i++);
}
if (u.defaultBranch () == null && !coversAll (u))
{
stream.println ();
stream.println (" public void _default ()");
stream.println (" {");
stream.println (" __discriminator = " + defaultDiscriminator (u) + ';');
stream.println (" __uninitialized = false;");
stream.println (" }");
stream.println ();
stream.println (" public void _default (" + Util.javaName(utype) +
" discriminator)");
stream.println (" {");
stream.println (" verifyDefault( discriminator ) ;" );
stream.println (" __discriminator = discriminator ;");
stream.println (" __uninitialized = false;");
stream.println (" }");
writeVerifyDefault() ;
}
stream.println ();
} // writeBody
/**
*
**/
protected void writeClosing ()
{
stream.println ("} // class " + u.name ());
} // writeClosing
/**
*
**/
protected void closeStream ()
{
stream.close ();
} // closeStream
/**
*
**/
protected void generateContainedTypes ()
{
Enumeration e = u.contained ().elements ();
while (e.hasMoreElements ())
{
SymtabEntry entry = (SymtabEntry)e.nextElement ();
// Don't generate contained entries if they are sequences.
// Sequences are unnamed and since they translate to arrays,
// no classes are generated for them, not even holders in this
// case since they cannot be accessed outside of this union.
if (!(entry instanceof SequenceEntry))
entry.generate (symbolTable, stream);
}
} // generateContainedTypes
private void writeVerifyDefault()
{
Vector labels = vectorizeLabels (u.branches (), true);
if (Util.javaName(utype).equals ("boolean")) {
stream.println( "" ) ;
stream.println( " private void verifyDefault (boolean discriminator)" ) ;
stream.println( " {" ) ;
if (labels.contains ("true"))
stream.println (" if ( discriminator )");
else
stream.println (" if ( !discriminator )");
stream.println( " throw new org.omg.CORBA.BAD_OPERATION();" ) ;
stream.println( " }" ) ;
return;
}
stream.println( "" ) ;
stream.println( " private void verifyDefault( " + Util.javaName(utype) +
" value )" ) ;
stream.println( " {" ) ;
if (unionIsEnum)
stream.println( " switch (value.value()) {" ) ;
else
stream.println( " switch (value) {" ) ;
Enumeration e = labels.elements() ;
while (e.hasMoreElements()) {
String str = (String)(e.nextElement()) ;
stream.println( " case " + str + ":" ) ;
}
stream.println( " throw new org.omg.CORBA.BAD_OPERATION() ;" ) ;
stream.println( "" ) ;
stream.println( " default:" ) ;
stream.println( " return;" ) ;
stream.println( " }" ) ;
stream.println( " }" ) ;
}
private String defaultDiscriminator (UnionEntry u)
{
Vector labels = vectorizeLabels (u.branches (), false );
String ret = null;
SymtabEntry utype = Util.typeOf (u.type ());
if (utype instanceof PrimitiveEntry && utype.name ().equals ("boolean")) {
// If it got this far, then:
// - there is only one branch;
// - that branch has only one label.
if (labels.contains ("true"))
ret = "false";
else
ret = "true";
} else if (utype.name ().equals ("char")) {
// This doesn't handle '\u0030' == '0'. Unions are so
// seldom used. I don't have time to make this perfect.
int def = 0;
String string = "'\\u0000'";
while (def != 0xFFFF && labels.contains (string))
if (++def / 0x10 == 0)
string = "'\\u000" + def + "'";
else if (def / 0x100 == 0)
string = "\\u00" + def + "'";
else if (def / 0x1000 == 0)
string = "\\u0" + def + "'";
else
string = "\\u" + def + "'";
ret = string;
} else if (utype instanceof EnumEntry) {
Enumeration e = labels.elements ();
EnumEntry enumEntry = (EnumEntry)utype;
Vector enumList = (Vector)enumEntry.elements ().clone ();
// cull out those elements in the enumeration list that are
// in the cases of this union
while (e.hasMoreElements ())
enumList.removeElement (e.nextElement ());
// If all of the enum elements are covered in this union and
// there is a default statement, just pick one of the
// elements for the default. If there are enum elements
// which are NOT covered by the cases, pick one as the
// default.
if (enumList.size () == 0)
ret = typePackage + (String)enumEntry.elements ().lastElement ();
else
ret = typePackage + (String)enumList.firstElement ();
} else if (utype.name ().equals ("octet")) {
short def = Byte.MIN_VALUE;
while (def != Byte.MAX_VALUE && labels.contains (Integer.toString (def)))
++def;
ret = Integer.toString (def);
} else if (utype.name ().equals ("short")) {
short def = Short.MIN_VALUE;
while (def != Short.MAX_VALUE && labels.contains (Integer.toString (def)))
++def;
ret = Integer.toString (def);
} else if (utype.name ().equals ("long")) {
int def = Integer.MIN_VALUE;
while (def != Integer.MAX_VALUE && labels.contains (Integer.toString (def)))
++def;
ret = Integer.toString (def);
} else if (utype.name ().equals ("long long")) {
long def = Long.MIN_VALUE;
while (def != Long.MAX_VALUE && labels.contains (Long.toString (def)))
++def;
ret = Long.toString (def);
} else if (utype.name ().equals ("unsigned short")) {
short def = 0;
while (def != Short.MAX_VALUE && labels.contains (Integer.toString (def)))
++def;
ret = Integer.toString (def);
} else if (utype.name ().equals ("unsigned long")) {
int def = 0;
while (def != Integer.MAX_VALUE && labels.contains (Integer.toString (def)))
++def;
ret = Integer.toString (def);
} else if (utype.name ().equals ("unsigned long long")) {
long def = 0;
while (def != Long.MAX_VALUE && labels.contains (Long.toString (def)))
++def;
ret = Long.toString (def);
}
return ret;
} // defaultDiscriminator
/**
*
**/
private Vector vectorizeLabels (Vector branchVector, boolean useIntsForEnums )
{
Vector mergedLabels = new Vector ();
Enumeration branches = branchVector.elements ();
while (branches.hasMoreElements ())
{
UnionBranch branch = (UnionBranch)branches.nextElement ();
Enumeration labels = branch.labels.elements ();
while (labels.hasMoreElements ())
{
Expression expr = (Expression)labels.nextElement ();
String str ;
if (unionIsEnum)
if (useIntsForEnums)
str = typePackage + "_" + Util.parseExpression( expr ) ;
else
str = typePackage + Util.parseExpression( expr ) ;
else
str = Util.parseExpression( expr ) ;
mergedLabels.addElement (str);
}
}
return mergedLabels;
} // vectorizeLabels
/**
*
**/
private String safeName (UnionEntry u, String name)
{
Enumeration e = u.branches ().elements ();
while (e.hasMoreElements ())
if (((UnionBranch)e.nextElement ()).typedef.name ().equals (name))
{
name = '_' + name;
break;
}
return name;
} // safeName
/**
*
**/
private boolean coversAll (UnionEntry u)
{
// This assumes that it is not possible to cover types other than
// boolean and enums. This is not quite correct, but since octet
// is not a valid discriminator type, it's not too bad in practice.
// It may also be possible to cover a char type, but we won't worry
// about that either.
SymtabEntry utype = Util.typeOf (u.type ());
boolean coversAll = false;
if (utype.name ().equals ("boolean")) {
if (u.branches ().size () == 2)
coversAll = true;
} else if (utype instanceof EnumEntry) {
Vector labels = vectorizeLabels (u.branches (), true);
if (labels.size () == ((EnumEntry)utype).elements ().size ())
coversAll = true;
}
return coversAll;
} // coversAll
/**
*
**/
private void writeBranchMethods (PrintWriter stream, UnionEntry u, UnionBranch branch, int i)
{
// Write getter
stream.println ();
// <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
//stream.println (" public " + Util.javaStatefulName (branch.typedef) + " " + branch.typedef.name () + " ()");
stream.println (" public " + Util.javaName (branch.typedef) + " " + branch.typedef.name () + " ()");
stream.println (" {");
stream.println (" if (__uninitialized)");
stream.println (" throw new org.omg.CORBA.BAD_OPERATION ();");
stream.println (" verify" + branch.typedef.name () + " (__discriminator);");
stream.println (" return ___" + branch.typedef.name () + ";");
stream.println (" }");
// Write setter(s)
stream.println ();
// <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
//stream.println (" public void " + branch.typedef.name () + " (" + Util.javaStatefulName (branch.typedef) + " value)");
stream.println (" public void " + branch.typedef.name () + " (" + Util.javaName (branch.typedef) + " value)");
stream.println (" {");
if (branch.labels.size () == 0)
{
// This is a default branch
stream.println (" __discriminator = " + defaultDiscriminator (u) + ";");
}
else
{
// This is a non-default branch
if (unionIsEnum)
stream.println (" __discriminator = " + typePackage + Util.parseExpression ((Expression)branch.labels.firstElement ()) + ";");
else
stream.println (" __discriminator = " + cast ((Expression)branch.labels.firstElement (), u.type ()) + ";");
}
stream.println (" ___" + branch.typedef.name () + " = value;");
stream.println (" __uninitialized = false;");
stream.println (" }");
SymtabEntry utype = Util.typeOf (u.type ());
// If there are multiple labels for one branch, write the
// setter that takes a discriminator.
if (branch.labels.size () > 0 || branch.isDefault)
{
stream.println ();
// <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
//stream.println (" public void " + branch.typedef.name () + " (" + Util.javaName (utype) + " discriminator, " + Util.javaStatefulName (branch.typedef) + " value)");
stream.println (" public void " + branch.typedef.name () + " (" + Util.javaName (utype) + " discriminator, " + Util.javaName (branch.typedef) + " value)");
stream.println (" {");
stream.println (" verify" + branch.typedef.name () + " (discriminator);");
stream.println (" __discriminator = discriminator;");
stream.println (" ___" + branch.typedef.name () + " = value;");
stream.println (" __uninitialized = false;");
stream.println (" }");
}
// Write verifyXXX
stream.println ();
stream.println (" private void verify" + branch.typedef.name () + " (" + Util.javaName (utype) + " discriminator)");
stream.println (" {");
boolean onlyOne = true;
if (branch.isDefault && u.branches ().size () == 1)
;// If all that is in this union is a default branch,
// all discriminators are legal. Don't print any
// body to this method in that case.
else
{
// Otherwise this code is executed and a body is printed.
stream.print (" if (");
if (branch.isDefault)
{
Enumeration eBranches = u.branches ().elements ();
while (eBranches.hasMoreElements ())
{
UnionBranch b = (UnionBranch)eBranches.nextElement ();
if (b != branch)
{
Enumeration eLabels = b.labels.elements ();
while (eLabels.hasMoreElements ())
{
Expression label = (Expression)eLabels.nextElement ();
if (!onlyOne)
stream.print (" || ");
if (unionIsEnum)
stream.print ("discriminator == " + typePackage + Util.parseExpression (label));
else
stream.print ("discriminator == " + Util.parseExpression (label));
onlyOne = false;
}
}
}
}
else
{
Enumeration e = branch.labels.elements ();
while (e.hasMoreElements ())
{
Expression label = (Expression)e.nextElement ();
if (!onlyOne)
stream.print (" && ");
if (unionIsEnum)
stream.print ("discriminator != " + typePackage + Util.parseExpression (label));
else
stream.print ("discriminator != " + Util.parseExpression (label));
onlyOne = false;
}
}
stream.println (")");
stream.println (" throw new org.omg.CORBA.BAD_OPERATION ();");
}
stream.println (" }");
} // writeBranchMethods
///////////////
// From JavaGenerator
/**
*
**/
// Computes the total number of labels in the union, which is the sum
// of the number of labels in each branch of the union. Note that the
// label for the default branch has size 0, but still counts in the total
// size.
private int unionLabelSize( UnionEntry un )
{
int size = 0 ;
Vector branches = un.branches() ;
for (int i = 0; i < branches.size (); ++i) {
UnionBranch branch = (UnionBranch)(branches.get(i)) ;
int branchSize = branch.labels.size() ;
size += ((branchSize == 0) ? 1 : branchSize) ;
}
return size ;
}
public int helperType (int index, String indent, TCOffsets tcoffsets,
String name, SymtabEntry entry, PrintWriter stream)
{
TCOffsets innerOffsets = new TCOffsets ();
UnionEntry u = (UnionEntry)entry;
String discTypeCode = "_disTypeCode" + index;
String membersName = "_members" + index;
// Build discriminator tc
stream.println (indent + "org.omg.CORBA.TypeCode " + discTypeCode + ';');
index = ((JavaGenerator)u.type ().generator ()).type (index + 1, indent,
innerOffsets, discTypeCode, u.type (), stream);
tcoffsets.bumpCurrentOffset (innerOffsets.currentOffset ());
stream.println (indent + "org.omg.CORBA.UnionMember[] " + membersName +
" = new org.omg.CORBA.UnionMember [" + unionLabelSize(u) + "];");
String tcOfMembers = "_tcOf" + membersName;
String anyOfMembers = "_anyOf" + membersName;
stream.println (indent + "org.omg.CORBA.TypeCode " + tcOfMembers + ';');
stream.println (indent + "org.omg.CORBA.Any " + anyOfMembers + ';');
innerOffsets = new TCOffsets ();
innerOffsets.set (entry);
int offsetForUnion = innerOffsets.currentOffset ();
for (int i = 0; i < u.branches ().size (); ++i) {
UnionBranch branch = (UnionBranch)u.branches ().elementAt (i);
TypedefEntry member = branch.typedef;
Vector labels = branch.labels;
String memberName = Util.stripLeadingUnderscores (member.name ());
if (labels.size() == 0) {
stream.println ();
stream.println (indent + "// Branch for " + memberName +
" (Default case)" );
SymtabEntry utype = Util.typeOf (u.type ());
stream.println (indent + anyOfMembers + " = org.omg.CORBA.ORB.init ().create_any ();");
// For default member, label is the zero octet (per CORBA spec.)
stream.println (indent + anyOfMembers + ".insert_octet ((byte)0); // default member label");
// Build typecode
innerOffsets.bumpCurrentOffset (4); // label value
index = ((JavaGenerator)member.generator ()).type (index, indent, innerOffsets, tcOfMembers, member, stream);
int offsetSoFar = innerOffsets.currentOffset ();
innerOffsets = new TCOffsets ();
innerOffsets.set (entry);
innerOffsets.bumpCurrentOffset (offsetSoFar - offsetForUnion);
// Build union member
stream.println (indent + membersName + '[' + i + "] = new org.omg.CORBA.UnionMember (");
stream.println (indent + " \"" + memberName + "\",");
stream.println (indent + " " + anyOfMembers + ',');
stream.println (indent + " " + tcOfMembers + ',');
stream.println (indent + " null);");
} else {
Enumeration enumeration = labels.elements() ;
while (enumeration.hasMoreElements()) {
Expression expr = (Expression)(enumeration.nextElement()) ;
String elem = Util.parseExpression( expr ) ;
stream.println ();
stream.println (indent + "// Branch for " + memberName +
" (case label " + elem + ")" );
SymtabEntry utype = Util.typeOf (u.type ());
// Build any
stream.println (indent + anyOfMembers + " = org.omg.CORBA.ORB.init ().create_any ();");
if (utype instanceof PrimitiveEntry)
stream.println (indent + anyOfMembers + ".insert_" +
Util.collapseName (utype.name ()) + " ((" + Util.javaName (utype) +
')' + elem + ");");
else { // it must be enum
String enumClass = Util.javaName (utype);
stream.println (indent + Util.helperName (utype, false) + ".insert (" +
anyOfMembers + ", " + enumClass + '.' + elem + ");"); // <d61056>
}
// Build typecode
innerOffsets.bumpCurrentOffset (4); // label value
index = ((JavaGenerator)member.generator ()).type (index, indent, innerOffsets, tcOfMembers, member, stream);
int offsetSoFar = innerOffsets.currentOffset ();
innerOffsets = new TCOffsets ();
innerOffsets.set (entry);
innerOffsets.bumpCurrentOffset (offsetSoFar - offsetForUnion);
// Build union member
stream.println (indent + membersName + '[' + i + "] = new org.omg.CORBA.UnionMember (");
stream.println (indent + " \"" + memberName + "\",");
stream.println (indent + " " + anyOfMembers + ',');
stream.println (indent + " " + tcOfMembers + ',');
stream.println (indent + " null);");
}
}
}
tcoffsets.bumpCurrentOffset (innerOffsets.currentOffset ());
// Build create_union_tc
stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_union_tc (" +
Util.helperName (u, true) + ".id (), \"" + entry.name () + "\", " +
discTypeCode + ", " + membersName + ");");
return index;
} // helperType
public int type (int index, String indent, TCOffsets tcoffsets, String name,
SymtabEntry entry, PrintWriter stream)
{
stream.println (indent + name + " = " + Util.helperName (entry, true) + ".type ();");
return index;
}
public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream)
{
stream.println (" " + entryName + " value = new " + entryName + " ();");
read (0, " ", "value", entry, stream);
stream.println (" return value;");
}
public void helperWrite (SymtabEntry entry, PrintWriter stream)
{
write (0, " ", "value", entry, stream);
}
public int read (int index, String indent, String name,
SymtabEntry entry, PrintWriter stream)
{
UnionEntry u = (UnionEntry)entry;
String disName = "_dis" + index++;
SymtabEntry utype = Util.typeOf (u.type ());
Util.writeInitializer (indent, disName, "", utype, stream);
if (utype instanceof PrimitiveEntry)
index = ((JavaGenerator)utype.generator ()).read (index, indent, disName, utype, stream);
else
stream.println (indent + disName + " = " + Util.helperName (utype, true) + ".read (istream);");
if (utype.name ().equals ("boolean"))
index = readBoolean (disName, index, indent, name, u, stream);
else
index = readNonBoolean (disName, index, indent, name, u, stream);
return index;
}
private int readBoolean (String disName, int index, String indent,
String name, UnionEntry u, PrintWriter stream)
{
UnionBranch firstBranch = (UnionBranch)u.branches ().firstElement ();
UnionBranch secondBranch;
if (u.branches ().size () == 2)
secondBranch = (UnionBranch)u.branches ().lastElement ();
else
secondBranch = null;
boolean firstBranchIsTrue = false;
boolean noCases = false;
try {
if (u.branches ().size () == 1 &&
(u.defaultBranch () != null || firstBranch.labels.size () == 2)) {
noCases = true;
} else {
Expression expr = (Expression)(firstBranch.labels.firstElement()) ;
Boolean bool = (Boolean)(expr.evaluate()) ;
firstBranchIsTrue = bool.booleanValue ();
}
} catch (EvaluationException ex) {
// no action
}
if (noCases) {
// There is only a default label. Since there are no cases,
// there is no need for if...else branches.
index = readBranch (index, indent, firstBranch.typedef.name (), "", firstBranch.typedef, stream);
} else {
// If first branch is false, swap branches
if (!firstBranchIsTrue) {
UnionBranch tmp = firstBranch;
firstBranch = secondBranch;
secondBranch = tmp;
}
stream.println (indent + "if (" + disName + ')');
if (firstBranch == null)
stream.println (indent + " value._default(" + disName + ");");
else {
stream.println (indent + '{');
index = readBranch (index, indent + " ", firstBranch.typedef.name (),
disName, firstBranch.typedef, stream);
stream.println (indent + '}');
}
stream.println (indent + "else");
if (secondBranch == null)
stream.println (indent + " value._default(" + disName + ");");
else {
stream.println (indent + '{');
index = readBranch (index, indent + " ", secondBranch.typedef.name (),
disName, secondBranch.typedef, stream);
stream.println (indent + '}');
}
}
return index;
}
private int readNonBoolean (String disName, int index, String indent,
String name, UnionEntry u, PrintWriter stream)
{
SymtabEntry utype = Util.typeOf (u.type ());
if (utype instanceof EnumEntry)
stream.println (indent + "switch (" + disName + ".value ())");
else
stream.println (indent + "switch (" + disName + ')');
stream.println (indent + '{');
String typePackage = Util.javaQualifiedName (utype) + '.';
Enumeration e = u.branches ().elements ();
while (e.hasMoreElements ()) {
UnionBranch branch = (UnionBranch)e.nextElement ();
Enumeration labels = branch.labels.elements ();
while (labels.hasMoreElements ()) {
Expression label = (Expression)labels.nextElement ();
if (utype instanceof EnumEntry) {
String key = Util.parseExpression (label);
stream.println (indent + " case " + typePackage + '_' + key + ':');
} else
stream.println (indent + " case " + cast (label, utype) + ':');
}
if (!branch.typedef.equals (u.defaultBranch ())) {
index = readBranch (index, indent + " ", branch.typedef.name (),
branch.labels.size() > 1 ? disName : "" ,
branch.typedef, stream);
stream.println (indent + " break;");
}
}
// We need a default branch unless all of the case of the discriminator type
// are listed in the case branches.
if (!coversAll(u)) {
stream.println( indent + " default:") ;
if (u.defaultBranch () == null) {
// If the union does not have a default branch, we still need to initialize
// the discriminator.
stream.println( indent + " value._default( " + disName + " ) ;" ) ;
} else {
index = readBranch (index, indent + " ", u.defaultBranch ().name (), disName,
u.defaultBranch (), stream);
}
stream.println (indent + " break;");
}
stream.println (indent + '}');
return index;
}
private int readBranch (int index, String indent, String name, String disName, TypedefEntry entry, PrintWriter stream)
{
SymtabEntry type = entry.type ();
Util.writeInitializer (indent, '_' + name, "", entry, stream);
if (!entry.arrayInfo ().isEmpty () ||
type instanceof SequenceEntry ||
type instanceof PrimitiveEntry ||
type instanceof StringEntry) {
index = ((JavaGenerator)entry.generator ()).read (index, indent, '_' + name, entry, stream);
} else {
stream.println (indent + '_' + name + " = " + Util.helperName (type, true) + ".read (istream);");
}
stream.print (indent + "value." + name + " (");
if( disName == "" )
stream.println("_" + name + ");");
else
stream.println(disName + ", " + "_" + name + ");");
return index;
}
/**
*
**/
public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
{
UnionEntry u = (UnionEntry)entry;
SymtabEntry utype = Util.typeOf (u.type ());
if (utype instanceof PrimitiveEntry)
index = ((JavaGenerator)utype.generator ()).write (index, indent, name + ".discriminator ()", utype, stream);
else
stream.println (indent + Util.helperName (utype, true) + ".write (ostream, " + name + ".discriminator ());"); // <d61056>
if (utype.name ().equals ("boolean"))
index = writeBoolean (name + ".discriminator ()", index, indent, name, u, stream);
else
index = writeNonBoolean (name + ".discriminator ()", index, indent, name, u, stream);
return index;
} // write
/**
*
**/
private int writeBoolean (String disName, int index, String indent, String name, UnionEntry u, PrintWriter stream)
{
SymtabEntry utype = Util.typeOf (u.type ());
UnionBranch firstBranch = (UnionBranch)u.branches ().firstElement ();
UnionBranch secondBranch;
if (u.branches ().size () == 2)
secondBranch = (UnionBranch)u.branches ().lastElement ();
else
secondBranch = null;
boolean firstBranchIsTrue = false;
boolean noCases = false;
try
{
if (u.branches ().size () == 1 && (u.defaultBranch () != null || firstBranch.labels.size () == 2))
noCases = true;
else
firstBranchIsTrue = ((Boolean)((Expression)firstBranch.labels.firstElement ()).evaluate ()).booleanValue ();
}
catch (EvaluationException ex)
{}
if (noCases)
{
// There is only a default label. Since there are no cases,
// there is no need for if...else branches.
index = writeBranch (index, indent, name, firstBranch.typedef, stream);
}
else
{
// If first branch is false, swap branches
if (!firstBranchIsTrue)
{
UnionBranch tmp = firstBranch;
firstBranch = secondBranch;
secondBranch = tmp;
}
if (firstBranch != null && secondBranch != null) {
stream.println (indent + "if (" + disName + ')');
stream.println (indent + '{');
index = writeBranch (index, indent + " ", name, firstBranch.typedef, stream);
stream.println (indent + '}');
stream.println (indent + "else");
stream.println (indent + '{');
index = writeBranch (index, indent + " ", name, secondBranch.typedef, stream);
stream.println (indent + '}');
} else if (firstBranch != null) {
stream.println (indent + "if (" + disName + ')');
stream.println (indent + '{');
index = writeBranch (index, indent + " ", name, firstBranch.typedef, stream);
stream.println (indent + '}');
} else {
stream.println (indent + "if (!" + disName + ')');
stream.println (indent + '{');
index = writeBranch (index, indent + " ", name, secondBranch.typedef, stream);
stream.println (indent + '}');
}
}
return index;
} // writeBoolean
/**
*
**/
private int writeNonBoolean (String disName, int index, String indent, String name, UnionEntry u, PrintWriter stream)
{
SymtabEntry utype = Util.typeOf (u.type ());
if (utype instanceof EnumEntry)
stream.println (indent + "switch (" + name + ".discriminator ().value ())");
else
stream.println (indent + "switch (" + name + ".discriminator ())");
stream.println (indent + "{");
String typePackage = Util.javaQualifiedName (utype) + '.';
Enumeration e = u.branches ().elements ();
while (e.hasMoreElements ())
{
UnionBranch branch = (UnionBranch)e.nextElement ();
Enumeration labels = branch.labels.elements ();
while (labels.hasMoreElements ())
{
Expression label = (Expression)labels.nextElement ();
if (utype instanceof EnumEntry)
{
String key = Util.parseExpression (label);
stream.println (indent + " case " + typePackage + '_' + key + ":");
}
else
stream.println (indent + " case " + cast (label, utype) + ':');
}
if (!branch.typedef.equals (u.defaultBranch ()))
{
index = writeBranch (index, indent + " ", name, branch.typedef, stream);
stream.println (indent + " break;");
}
}
if (u.defaultBranch () != null) {
stream.println (indent + " default:");
index = writeBranch (index, indent + " ", name, u.defaultBranch (), stream);
stream.println (indent + " break;");
}
stream.println (indent + "}");
return index;
} // writeNonBoolean
/**
*
**/
private int writeBranch (int index, String indent, String name, TypedefEntry entry, PrintWriter stream)
{
SymtabEntry type = entry.type ();
if (!entry.arrayInfo ().isEmpty () || type instanceof SequenceEntry || type instanceof PrimitiveEntry || type instanceof StringEntry)
index = ((JavaGenerator)entry.generator ()).write (index, indent, name + '.' + entry.name () + " ()", entry, stream);
else
stream.println (indent + Util.helperName (type, true) + ".write (ostream, " + name + '.' + entry.name () + " ());"); // <d61056>
return index;
} // writeBranch
// From JavaGenerator
///////////////
/**
*
**/
private String cast (Expression expr, SymtabEntry type)
{
String ret = Util.parseExpression (expr);
if (type.name ().indexOf ("short") >= 0)
{
if (expr.value () instanceof Long)
{
long value = ((Long)expr.value ()).longValue ();
if (value > Short.MAX_VALUE)
ret = "(short)(" + ret + ')';
}
else if (expr.value () instanceof Integer)
{
int value = ((Integer)expr.value ()).intValue ();
if (value > Short.MAX_VALUE)
ret = "(short)(" + ret + ')';
}
}
else if (type.name ().indexOf ("long") >= 0)
{
if (expr.value () instanceof Long)
{
long value = ((Long)expr.value ()).longValue ();
// value == Integer.MIN_VALUE because if the number is
// Integer.MIN_VALUE, then it will have the 'L' suffix and
// the cast will be necessary.
if (value > Integer.MAX_VALUE || value == Integer.MIN_VALUE)
ret = "(int)(" + ret + ')';
}
else if (expr.value () instanceof Integer)
{
int value = ((Integer)expr.value ()).intValue ();
// value == Integer.MIN_VALUE because if the number is
// Integer.MIN_VALUE, then it will have the 'L' suffix and
// the cast will be necessary.
if (value > Integer.MAX_VALUE || value == Integer.MIN_VALUE)
ret = "(int)(" + ret + ')';
}
}
return ret;
} // cast
protected Hashtable symbolTable = null;
protected UnionEntry u = null;
protected PrintWriter stream = null;
protected SymtabEntry utype = null;
protected boolean unionIsEnum;
protected String typePackage = "";
} // class UnionGen