/*
* Copyright (c) 1999, 2001, 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:
// -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete.
// -D57067 <klr> suppress default init if an emit init explicitly specified.
// -D59071 <daz> Clone method entries when their content needs modification.
// -D59092 <klr> Valuetype supporting interfaces should implement interface.
// -D59418 <klr> Custom values implement org.omg.CORBA.CustomMarshal
// -D59418 <klr> Invert read/read_Value, write/write_Value for Simon
// -D60929 <klr> Update for RTF2.4 changes
// -D62018 <klr> write_value for value with value field x calls xHelper.write.
// -D62062 <klr> Add _write to value Helper to marshal state.
// write_value for value subclass calls parent._write
// -D61650<daz> Remove '\n' from generated strings; use println()'s.
import java.io.File;
import java.io.PrintWriter;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Vector;
import com.sun.tools.corba.se.idl.GenFileStream;
import com.sun.tools.corba.se.idl.InterfaceEntry;
import com.sun.tools.corba.se.idl.SymtabEntry;
import com.sun.tools.corba.se.idl.TypedefEntry;
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.MethodEntry;
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;
/**
*
**/
public class ValueGen implements com.sun.tools.corba.se.idl.ValueGen, JavaGenerator
{
/**
* Public zero-argument constructor.
**/
public ValueGen ()
{
} // ctor
/**
*
**/
public void generate (Hashtable symbolTable, ValueEntry v, PrintWriter str)
{
this.symbolTable = symbolTable;
this.v = v;
init ();
openStream ();
if (stream == null)
return;
generateTie ();
generateHelper ();
generateHolder ();
writeHeading ();
writeBody ();
writeClosing ();
closeStream ();
} // generate
/**
* Initialize members unique to this generator.
**/
protected void init ()
{
emit = ((Arguments)Compile.compiler.arguments).emit;
factories = (Factories)Compile.compiler.factories ();
} // init
/**
*
**/
protected void openStream ()
{
stream = Util.stream (v, ".java");
} // openStream
/**
* Generate a Tie class only when the user specifies the TIE option
* and the valuetype does support an interface.
**/
protected void generateTie ()
{
boolean tie = ((Arguments)Compile.compiler.arguments).TIEServer;
if (v.supports ().size () > 0 && tie)
{
Factories factories = (Factories)Compile.compiler.factories ();
factories.skeleton ().generate (symbolTable, v);
}
} // generateTie
/**
*
**/
protected void generateHelper ()
{
((Factories)Compile.compiler.factories ()).helper ().generate (symbolTable, v);
} // generateHelper
/**
*
**/
protected void generateHolder ()
{
((Factories)Compile.compiler.factories ()).holder ().generate (symbolTable, v);
} // generateHolder
/**
*
**/
protected void writeHeading ()
{
Util.writePackage (stream, v);
Util.writeProlog (stream, ((GenFileStream)stream).name ());
if (v.comment () != null)
v.comment ().generate ("", stream);
if (v.isAbstract ())
{
writeAbstract ();
return;
}
else
stream.print ("public class " + v.name ());
// There should always be at least one parent: ValueBase
SymtabEntry parent = (SymtabEntry) v.derivedFrom ().elementAt (0);
// If parent is ValueBase, it's mapped to java.io.Serializable
String parentName = Util.javaName (parent);
boolean impl = false;
if (parentName.equals ("java.io.Serializable"))
{
// stream.print (" implements org.omg.CORBA.portable.ValueBase, org.omg.CORBA.portable.Streamable");
stream.print (" implements org.omg.CORBA.portable.ValueBase"); // <d60929>
impl = true;
}
else if ( !((ValueEntry)parent).isAbstract ())
stream.print (" extends " + parentName);
// if inheriting from abstract values
for (int i = 0; i < v.derivedFrom ().size (); i++) {
parent = (SymtabEntry) v.derivedFrom ().elementAt (i);
if ( ((ValueEntry)parent).isAbstract ())
{
if (!impl)
{
stream.print (" implements ");
impl = true;
}
else
stream.print (", ");
stream.print (Util.javaName (parent));
}
}
// <d59092-klr> Valuetype supporting interface implement Operations interface
// for supported IDL interface
if (((ValueEntry)v).supports ().size () > 0) {
if (!impl)
{
stream.print (" implements ");
impl = true;
}
else
stream.print (", ");
InterfaceEntry s =(InterfaceEntry)((ValueEntry)v).supports().elementAt(0);
// abstract supported classes don't have "Operations"
if (s.isAbstract ())
stream.print (Util.javaName (s));
else
stream.print (Util.javaName (s) + "Operations");
}
// <d59418> Custom valuetypes implement org.omg.CORBA.CustomMarshal.
if ( ((ValueEntry)v).isCustom ()) {
if (!impl)
{
stream.print (" implements ");
impl = true;
}
else
stream.print (", ");
stream.print ("org.omg.CORBA.CustomMarshal ");
}
stream.println ();
stream.println ("{");
} // writeHeading
/**
*
**/
protected void writeBody ()
{
writeMembers ();
writeInitializers ();
writeConstructor (); // <d57067>
writeTruncatable (); // <d60929>
writeMethods ();
} // writeBody
/**
*
**/
protected void writeClosing ()
{
if (v.isAbstract ())
stream.println ("} // interface " + v.name ());
else
stream.println ("} // class " + v.name ());
} // writeClosing
/**
*
**/
protected void closeStream ()
{
stream.close ();
} // closeStream
/**
*
**/
protected void writeConstructor ()
{
// Per Simon, 9/3/98, emit a protected default constructor
if (!v.isAbstract () && !explicitDefaultInit) { // <d57067 - klr>
stream.println (" protected " + v.name () + " () {}");
stream.println ();
}
} // writeConstructor
/**
*
**/
protected void writeTruncatable () // <d60929>
{
// Per Simon, 4/6/98, emit _truncatable_ids()
if (!v.isAbstract ()) {
stream.println (" public String[] _truncatable_ids() {");
stream.println (" return " + Util.helperName(v, true) + ".get_instance().get_truncatable_base_ids();"); // <d61056>
stream.println (" }");
stream.println ();
}
} // writeTruncatable
/**
*
**/
protected void writeMembers ()
{
// if the value type contains no data members, a null return is expected
if (v.state () == null)
return;
for (int i = 0; i < v.state ().size (); i ++)
{
InterfaceState member = (InterfaceState) v.state ().elementAt (i);
SymtabEntry entry = (SymtabEntry) member.entry;
Util.fillInfo (entry);
if (entry.comment () != null)
entry.comment ().generate (" ", stream);
String modifier = " ";
if (member.modifier == InterfaceState.Public)
modifier = " public ";
Util.writeInitializer (modifier, entry.name (), "", entry, stream);
}
} // writeMembers
/**
*
**/
protected void writeInitializers ()
{
Vector init = v.initializers ();
if (init != null)
{
stream.println ();
for (int i = 0; i < init.size (); i++)
{
MethodEntry element = (MethodEntry) init.elementAt (i);
element.valueMethod (true);
((MethodGen) element.generator ()). interfaceMethod (symbolTable, element, stream);
if (element.parameters ().isEmpty ()) // <d57067-klr>
explicitDefaultInit = true;
}
}
} // writeInitializers
/**
*
**/
protected void writeMethods ()
{
// contained vector contains methods, attributes, const, enums, exceptions,
// structs, unions, or typedefs that are declared inside the value object.
// State members of the nested types are also included in this vector.
// Thus, if the declaration of a constructed type is nested in the decl.
// of a state member, e.g struct x {boolean b;} memberx;
// the generation of the nested type must be handled here.
Enumeration e = v.contained ().elements ();
while (e.hasMoreElements ())
{
SymtabEntry contained = (SymtabEntry)e.nextElement ();
if (contained instanceof MethodEntry)
{
MethodEntry element = (MethodEntry)contained;
((MethodGen)element.generator ()).interfaceMethod (symbolTable, element, stream);
}
else
{
// Generate the type referenced by the typedef.
if (contained instanceof TypedefEntry)
contained.type ().generate (symbolTable, stream);
// Note that we also need to generate the typedef itself if
// contained is a typedef.
contained.generate (symbolTable, stream);
}
}
// Abstract values are mapped to interfaces. There is no need to generate
// the bindings for inheriting methods in case of inheritance from other
// abstract values or supporting interface
if (v.isAbstract ())
return;
// workaround: if the value type doesnot support any interfaces, a null
// return is expected instead of an empty vector
// if supporting an interfaces, generate bindings for inheriting methods
if (v.supports ().size () > 0)
{
InterfaceEntry intf = (InterfaceEntry) v.supports ().elementAt (0);
Enumeration el = intf.allMethods ().elements ();
while (el.hasMoreElements ())
{
MethodEntry m = (MethodEntry) el.nextElement ();
// <d59071> Don't alter the symbol table/emit list elements!
//m.container (v);
//((MethodGen)m.generator ()).interfaceMethod (symbolTable, m, stream);
MethodEntry mClone = (MethodEntry)m.clone ();
mClone.container (v);
((MethodGen)mClone.generator ()).interfaceMethod (symbolTable, mClone, stream);
}
}
// if inheriting from abstract values, generating bindings for all
// inheriting methods
for (int i = 0; i < v.derivedFrom ().size (); i++) {
ValueEntry parentValue = (ValueEntry) v.derivedFrom ().elementAt (i);
if (parentValue.isAbstract ())
{
Enumeration el = parentValue.allMethods ().elements ();
while (el.hasMoreElements ())
{
MethodEntry m = (MethodEntry) el.nextElement ();
// <d59071> Don't alter the symbol table/emit list elements!
//m.container (v);
//((MethodGen)m.generator ()).interfaceMethod (symbolTable, m, stream);
MethodEntry mClone = (MethodEntry)m.clone ();
mClone.container (v);
((MethodGen)mClone.generator ()).interfaceMethod (symbolTable, mClone, stream);
}
}
}
//writeStreamableMethods ();
} // writeMethods
/**
*
**/
protected void writeStreamableMethods ()
{
stream.println (" public void _read (org.omg.CORBA.portable.InputStream istream)");
stream.println (" {");
read (0, " ", "this", v, stream);
stream.println (" }");
stream.println ();
stream.println (" public void _write (org.omg.CORBA.portable.OutputStream ostream)");
stream.println (" {");
write (0, " ", "this", v, stream);
stream.println (" }");
stream.println ();
stream.println (" public org.omg.CORBA.TypeCode _type ()");
stream.println (" {");
stream.println (" return " + Util.helperName (v, false) + ".type ();"); // <d61056>
stream.println (" }");
} // writeStreamableMethods
///////////////
// From JavaGenerator
public int helperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream)
{
ValueEntry vt = (ValueEntry) entry;
Vector state = vt.state ();
int noOfMembers = state == null ? 0 : state.size ();
String members = "_members" + index++;
String tcOfMembers = "_tcOf" + members;
stream.println (indent + "org.omg.CORBA.ValueMember[] "
+ members + " = new org.omg.CORBA.ValueMember["
+ noOfMembers
+ "];");
stream.println (indent + "org.omg.CORBA.TypeCode " + tcOfMembers + " = null;");
//stream.println (""); // <d61650>
String definedInrepId = "_id";
String repId, version;
for (int k=0; k<noOfMembers; k++)
{
InterfaceState valueMember = (InterfaceState)state.elementAt (k);
TypedefEntry member = (TypedefEntry)valueMember.entry;
SymtabEntry mType = Util.typeOf (member);
if (hasRepId (member))
{
repId = Util.helperName (mType, true) + ".id ()"; // <d61056>
if (mType instanceof ValueEntry || mType instanceof ValueBoxEntry)
// OBV spec is silent on defining VersionSpec for valuetype RepIds
version = "\"\"";
else
{
String id = mType.repositoryID ().ID ();
version = '"' + id.substring (id.lastIndexOf (':')+1) + '"';
}
}
else
{
repId = "\"\"";
version = "\"\"";
}
// Get TypeCode for valuetype member and store it var. name given by tcOfMembers
stream.println (indent + "// ValueMember instance for " + member.name ());
index = ((JavaGenerator)member.generator ()).type (index, indent, tcoffsets, tcOfMembers, member, stream);
stream.println (indent + members + "[" + k + "] = new org.omg.CORBA.ValueMember (" // <d61650>
+ '"' + member.name () + "\", "); // name
stream.println (indent + " " + repId + ", "); // id
stream.println (indent + " " + definedInrepId + ", "); // defined_in
stream.println (indent + " " + version + ", "); // version
stream.println (indent + " " + tcOfMembers + ", "); // type
stream.println (indent + " " + "null, "); // type_def
stream.println (indent + " " + "org.omg.CORBA." +
(valueMember.modifier == InterfaceState.Public ?
"PUBLIC_MEMBER" : "PRIVATE_MEMBER") + ".value" + ");"); // access
} // end for
stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_value_tc ("
+ "_id, "
+ '"' + entry.name () + "\", "
+ getValueModifier (vt) + ", "
+ getConcreteBaseTypeCode (vt) + ", "
+ members
+ ");");
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 ();"); // <d61056>
return index;
} // type
// Check for types which don't have a Repository ID: primitive,
// string, arrays and sequences.
private static boolean hasRepId (SymtabEntry member)
{
SymtabEntry mType = Util.typeOf (member);
return !( mType instanceof PrimitiveEntry ||
mType instanceof StringEntry ||
( mType instanceof TypedefEntry &&
!(((TypedefEntry)mType).arrayInfo ().isEmpty ()) ) ||
( mType instanceof TypedefEntry && member.type () instanceof SequenceEntry) );
} // hasRepId
private static String getValueModifier (ValueEntry vt)
{
String mod = "NONE";
if (vt.isCustom ())
mod = "CUSTOM";
else if (vt.isAbstract ())
mod = "ABSTRACT";
else if (vt.isSafe ())
mod = "TRUNCATABLE";
return "org.omg.CORBA.VM_" + mod + ".value";
} // getValueModifier
private static String getConcreteBaseTypeCode (ValueEntry vt)
{
Vector v = vt.derivedFrom ();
if (!vt.isAbstract ())
{
SymtabEntry base = (SymtabEntry)vt.derivedFrom ().elementAt (0);
if (!"ValueBase".equals (base.name ()))
return Util.helperName (base, true) + ".type ()"; // <d61056>
}
return "null";
} // getConcreteBaseTypeCode
public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream)
{
// <d59418 - KLR> per Simon, make "static" read call istream.read_value.
// put real marshalling code in read_value.
if (((ValueEntry)entry).isAbstract ())
{
stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"abstract value cannot be instantiated\");");
}
else
{
stream.println (" return (" + entryName +") ((org.omg.CORBA_2_3.portable.InputStream) istream).read_value (get_instance());"); // <d60929>
}
stream.println (" }");
stream.println ();
// done with "read", now do "read_value with real marshalling code.
stream.println (" public java.io.Serializable read_value (org.omg.CORBA.portable.InputStream istream)"); // <d60929>
stream.println (" {");
// per Simon, 3/3/99, read_value for custom values throws an exception
if (((ValueEntry)entry).isAbstract ())
{
stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"abstract value cannot be instantiated\");");
}
else
if (((ValueEntry)entry).isCustom ())
{
stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"custom values should use unmarshal()\");");
}
else
{
stream.println (" " + entryName + " value = new " + entryName + " ();");
read (0, " ", "value", entry, stream);
stream.println (" return value;");
}
stream.println (" }");
stream.println ();
// End of normal read method
// Per Simon, 8/26/98 - Value helpers get an additional overloaded
// read method where the value is passed in instead of "new'd" up. This is
// used for reading parent value state.
// Per Simon, 3/3/99 - Don't change this "read" for custom marshalling
stream.println (" public static void read (org.omg.CORBA.portable.InputStream istream, " + entryName + " value)");
stream.println (" {");
read (0, " ", "value", entry, stream);
} // helperRead
public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
{
// First do the state members from concrete parent hierarchy
Vector vParents = ((ValueEntry) entry).derivedFrom ();
if (vParents != null && vParents.size() != 0)
{
ValueEntry parent = (ValueEntry) vParents.elementAt (0);
if (parent == null)
return index;
// Per Simon, 4/6/99 - call parent read. <d60929>
if (! Util.javaQualifiedName(parent).equals ("java.io.Serializable")) // <d60929>
stream.println(indent + Util.helperName (parent, true) + ".read (istream, value);"); // <d60929> // <d61056>
}
Vector vMembers = ((ValueEntry) entry).state ();
int noOfMembers = vMembers == null ? 0 : vMembers.size ();
for (int k = 0; k < noOfMembers; k++)
{
TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry;
String memberName = member.name ();
SymtabEntry mType = member.type ();
if (mType instanceof PrimitiveEntry ||
mType instanceof TypedefEntry ||
mType instanceof SequenceEntry ||
mType instanceof StringEntry ||
!member.arrayInfo ().isEmpty ())
index = ((JavaGenerator)member.generator ()).read (index, indent, name + '.' + memberName, member, stream);
else if (mType instanceof ValueEntry)
{
String returnType = Util.javaQualifiedName (mType);
if (mType instanceof ValueBoxEntry)
// <f46082.51> Remove -stateful.
//returnType = Util.javaStatefulName (mType);
returnType = Util.javaName (mType);
stream.println (" " + name + '.' + memberName + " = (" + returnType +
") ((org.omg.CORBA_2_3.portable.InputStream)istream).read_value (" + Util.helperName (mType, true) + // <d61056>
".get_instance ());"); // <d61056>
}
else
stream.println (indent + name + '.' + memberName + " = " +
Util.helperName (mType, true) + ".read (istream);"); // <d61056>
}
return index;
} // read
public void helperWrite (SymtabEntry entry, PrintWriter stream)
{
// <d59418 - KLR> per Simon, make "static" write call istream.write_value.
// put real marshalling code in write_value.
stream.println (" ((org.omg.CORBA_2_3.portable.OutputStream) ostream).write_value (value, get_instance());"); // <d60929>
stream.println (" }");
stream.println ();
// <d62062>
// per Simon, 4/27/99, add static _write that marshals the state of this
// value for non-custom valuetypes
if (!((ValueEntry)entry).isCustom ())
{
stream.println (" public static void _write (org.omg.CORBA.portable.OutputStream ostream, " + Util.javaName (entry) + " value)");
stream.println (" {");
write (0, " ", "value", entry, stream);
stream.println (" }");
stream.println ();
}
// done with "_write", now do "write_value
stream.println (" public void write_value (org.omg.CORBA.portable.OutputStream ostream, java.io.Serializable obj)"); // <d60929>
stream.println (" {");
// per Simon, 3/3/99, write_value for custom values throws an exception
if (((ValueEntry)entry).isCustom ())
{
stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"custom values should use marshal()\");");
}
else {
String entryName = Util.javaName(entry);
stream.println (" _write (ostream, (" + entryName + ") obj);"); // <d62062>
// write (0, " ", "value", entry, stream); <d62062>
}
} // helperWrite
public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
{
// First do the state members from concrete parent hierarchy
Vector vParents = ((ValueEntry)entry).derivedFrom ();
if (vParents != null && vParents.size () != 0)
{
ValueEntry parent = (ValueEntry)vParents.elementAt (0);
if (parent == null)
return index;
// Per Simon, 4/06/99 - call parent write. <d60929>
// Per Simon, 4/27/99 - call parent _write. <d62062>
if (! Util.javaQualifiedName(parent).equals ("java.io.Serializable")) // <d60929>
stream.println(indent + Util.helperName (parent, true) + "._write (ostream, value);"); // <d60929> <d61056> <d62062>
}
Vector vMembers = ((ValueEntry) entry ).state ();
int noOfMembers = vMembers == null ? 0 : vMembers.size ();
for (int k = 0; k < noOfMembers; k++)
{
TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry;
String memberName = member.name ();
SymtabEntry mType = member.type ();
if (mType instanceof PrimitiveEntry ||
mType instanceof TypedefEntry ||
mType instanceof SequenceEntry ||
mType instanceof StringEntry ||
!member.arrayInfo ().isEmpty ())
index = ((JavaGenerator)member.generator ()).write (index, indent, name + '.' + memberName, member, stream);
else
stream.println (indent + Util.helperName (mType, true) + // <d61056>
".write (ostream, " + name + '.' + memberName + ");");
}
return index;
} // write
/**
*
**/
protected void writeAbstract ()
{
stream.print ("public interface " + v.name ());
// workaround: if the abstract value type does not have any parent, a vector
// containing ValueBase should be returned instead of an empty vector
if (v.derivedFrom ().size () == 0)
stream.print (" extends org.omg.CORBA.portable.ValueBase"); // <d60929>
else
{
SymtabEntry parent;
// list the values the abstract value type inherits
for (int i = 0; i < v.derivedFrom ().size (); i++)
{
if (i == 0)
stream.print (" extends ");
else
stream.print (", ");
parent = (SymtabEntry) v.derivedFrom ().elementAt (i);
stream.print (Util.javaName (parent));
}
}
// list the interface the abstract value type supports
if (v.supports ().size () > 0)
{
stream.print (", ");
SymtabEntry intf = (SymtabEntry) v.supports ().elementAt (0);
stream.print (Util.javaName (intf));
}
stream.println ();
stream.println ("{");
}
protected int emit = 0;
protected Factories factories = null;
protected Hashtable symbolTable = null;
protected ValueEntry v = null;
protected PrintWriter stream = null;
protected boolean explicitDefaultInit = false; // <d57067 - klr>
} // class ValueGen