| /* |
| * Copyright (c) 1999, 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: |
| // -11aug1997<daz> No modification: comments for type_defs will appear in |
| // helper, holder classes as a result of modifications to routines |
| // makeHelper(), makeHolder() in class com.sun.tools.corba.se.idl.toJava.Util. |
| // -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete. |
| // -D61056 <klr> Use Util.helperName |
| |
| import java.io.PrintWriter; |
| |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| |
| import com.sun.tools.corba.se.idl.InterfaceEntry; |
| import com.sun.tools.corba.se.idl.InterfaceState; |
| 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.UnionEntry; |
| |
| import com.sun.tools.corba.se.idl.constExpr.Expression; |
| |
| // Notes: |
| |
| /** |
| * |
| **/ |
| public class TypedefGen implements com.sun.tools.corba.se.idl.TypedefGen, JavaGenerator |
| { |
| /** |
| * Public zero-argument constructor. |
| **/ |
| public TypedefGen () |
| { |
| } // ctor |
| |
| /** |
| * |
| **/ |
| public void generate (Hashtable symbolTable, TypedefEntry t, PrintWriter stream) |
| { |
| this.symbolTable = symbolTable; |
| this.t = t; |
| |
| if (t.arrayInfo ().size () > 0 || t.type () instanceof SequenceEntry) |
| generateHolder (); |
| generateHelper (); |
| } // generator |
| |
| /** |
| * |
| **/ |
| protected void generateHolder () |
| { |
| ((Factories)Compile.compiler.factories ()).holder ().generate (symbolTable, t); |
| } |
| |
| /** |
| * |
| **/ |
| protected void generateHelper () |
| { |
| ((Factories)Compile.compiler.factories ()).helper ().generate (symbolTable, t); |
| } |
| |
| /////////////// |
| // From JavaGenerator |
| |
| private boolean inStruct (TypedefEntry entry) |
| { |
| boolean inStruct = false; |
| if (entry.container () instanceof StructEntry || entry.container () instanceof UnionEntry) |
| inStruct = true; |
| else if (entry.container () instanceof InterfaceEntry) |
| { |
| InterfaceEntry i = (InterfaceEntry)entry.container (); |
| if (i.state () != null) |
| { |
| Enumeration e = i.state ().elements (); |
| while (e.hasMoreElements ()) |
| if (((InterfaceState)e.nextElement ()).entry == entry) |
| { |
| inStruct = true; |
| break; |
| } |
| } |
| } |
| return inStruct; |
| } // inStruct |
| |
| public int helperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| TypedefEntry td = (TypedefEntry)entry; |
| boolean inStruct = inStruct (td); |
| if (inStruct) |
| tcoffsets.setMember (entry); |
| else |
| tcoffsets.set (entry); |
| |
| // Print the base types typecode |
| index = ((JavaGenerator)td.type ().generator ()).type (index, indent, tcoffsets, name, td.type (), stream); |
| |
| if (inStruct && td.arrayInfo ().size () != 0) |
| tcoffsets.bumpCurrentOffset (4); // for array length field |
| |
| // Print the array typecodes (if there are any) |
| int dimensions = td.arrayInfo ().size (); |
| for (int i = 0; i < dimensions; ++i) |
| { |
| String size = Util.parseExpression ((Expression)td.arrayInfo ().elementAt (i)); |
| stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_array_tc (" + size + ", " + name + " );"); |
| } |
| |
| // If this typedef describes a struct/union member, don't put it |
| // in an alias typedef; otherwise that's where it belongs. |
| if (!inStruct) |
| // <54697> |
| //stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_alias_tc (id (), \"" + Util.stripLeadingUnderscores (td.name ()) + "\", " + name + ");"); |
| stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_alias_tc (" + Util.helperName (td, true) + ".id (), \"" + Util.stripLeadingUnderscores (td.name ()) + "\", " + name + ");"); // <d61056> |
| |
| return index; |
| } // helperType |
| |
| public int type (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| // The type() method is invoked from other emitters instead of when an IDL |
| // typedef statement is being processed. Code generated is identical minus the |
| // generation of a create_alias_tc() which is required for IDL typedef's but not |
| // needed when typedef is being processed as a member of struct/union/valuetype. |
| |
| return helperType( index, indent, tcoffsets, name, entry, stream); |
| } // type |
| |
| public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream) |
| { |
| Util.writeInitializer (" ", "value", "", entry, stream); |
| read (0, " ", "value", entry, stream); |
| stream.println (" return value;"); |
| } // helperRead |
| |
| public void helperWrite (SymtabEntry entry, PrintWriter stream) |
| { |
| write (0, " ", "value", entry, stream); |
| } // helperWrite |
| |
| public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| TypedefEntry td = (TypedefEntry)entry; |
| String modifier = Util.arrayInfo (td.arrayInfo ()); |
| if (!modifier.equals ("")) |
| { |
| // arrayInfo is a vector of Expressions which indicate the |
| // number of array dimensions for this typedef. But what if |
| // this is a typedef of a sequence? |
| // The `new' statement being generated must know the full |
| // number of brackets. That can be found in td.info. |
| // For instance: |
| // typedef sequence<short> A[10][10]; |
| // void proc (out A a); |
| // typeModifier = "[10][10]" |
| // td.info = "short[][][]"; |
| // The first new statement generated is: |
| // a.value = new short[10][][]; |
| // Note that the 3 sets of brackets come from td.info, not |
| // arrayInfo; |
| // The second new statement generated is: |
| // a.value[_i1] = new short[10][]; |
| // ------------ ---- ------ |
| // \ \ \ |
| // name baseName arrayDcl |
| int closingBrackets = 0; |
| String loopIndex = ""; |
| String baseName; |
| try |
| { |
| baseName = (String)td.dynamicVariable (Compile.typedefInfo); |
| } |
| catch (NoSuchFieldException e) |
| { |
| baseName = td.name (); |
| } |
| int startArray = baseName.indexOf ('['); |
| String arrayDcl = Util.sansArrayInfo (baseName.substring (startArray)) + "[]"; // Add an extra set because the first gets stripped off in the loop. |
| baseName = baseName.substring (0, startArray); |
| |
| // For interfaces having state, e.g., valuetypes. |
| SymtabEntry baseEntry = (SymtabEntry)Util.symbolTable.get (baseName.replace ('.', '/')); |
| if (baseEntry instanceof InterfaceEntry && ((InterfaceEntry)baseEntry).state () != null) |
| // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete. |
| //baseName = Util.javaStatefulName ((InterfaceEntry)baseEntry); |
| baseName = Util.javaName ((InterfaceEntry)baseEntry); |
| |
| int end1stArray; |
| while (!modifier.equals ("")) |
| { |
| int rbracket = modifier.indexOf (']'); |
| String size = modifier.substring (1, rbracket); |
| end1stArray = arrayDcl.indexOf (']'); |
| arrayDcl = '[' + size + arrayDcl.substring (end1stArray + 2); |
| stream.println (indent + name + " = new " + baseName + arrayDcl + ';'); |
| loopIndex = "_o" + index++; |
| stream.println (indent + "for (int " + loopIndex + " = 0;" + loopIndex + " < (" + size + "); ++" + loopIndex + ')'); |
| stream.println (indent + '{'); |
| ++closingBrackets; |
| modifier = modifier.substring (rbracket + 1); |
| indent = indent + " "; |
| name = name + '[' + loopIndex + ']'; |
| } |
| end1stArray = arrayDcl.indexOf (']'); |
| if (td.type () instanceof SequenceEntry || td.type () instanceof PrimitiveEntry || td.type () instanceof StringEntry) |
| index = ((JavaGenerator)td.type ().generator ()).read (index, indent, name, td.type (), stream); |
| else if (td.type () instanceof InterfaceEntry && td.type ().fullName ().equals ("org/omg/CORBA/Object")) |
| stream.println (indent + name + " = istream.read_Object ();"); |
| else |
| stream.println (indent + name + " = " + Util.helperName (td.type (), true) + ".read (istream);"); // <d61056> |
| for (int i = 0; i < closingBrackets; ++i) |
| { |
| indent = indent.substring (2); |
| stream.println (indent + '}'); |
| } |
| } |
| else |
| { |
| SymtabEntry tdtype = Util.typeOf (td.type ()); |
| if (tdtype instanceof SequenceEntry || tdtype instanceof PrimitiveEntry || tdtype instanceof StringEntry) |
| index = ((JavaGenerator)tdtype.generator ()).read (index, indent, name, tdtype, stream); |
| else if (tdtype instanceof InterfaceEntry && tdtype.fullName ().equals ("org/omg/CORBA/Object")) |
| stream.println (indent + name + " = istream.read_Object ();"); |
| else |
| stream.println (indent + name + " = " + Util.helperName (tdtype, true) + ".read (istream);"); // <d61056> |
| } |
| return index; |
| } // read |
| |
| public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| TypedefEntry td = (TypedefEntry)entry; |
| String modifier = Util.arrayInfo (td.arrayInfo ()); |
| if (!modifier.equals ("")) |
| { |
| int closingBrackets = 0; |
| String loopIndex = ""; |
| while (!modifier.equals ("")) |
| { |
| int rbracket = modifier.indexOf (']'); |
| String size = modifier.substring (1, rbracket); |
| stream.println (indent + "if (" + name + ".length != (" + size + "))"); |
| stream.println (indent + " throw new org.omg.CORBA.MARSHAL (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);"); |
| loopIndex = "_i" + index++; |
| stream.println (indent + "for (int " + loopIndex + " = 0;" + loopIndex + " < (" + size + "); ++" + loopIndex + ')'); |
| stream.println (indent + '{'); |
| ++closingBrackets; |
| modifier = modifier.substring (rbracket + 1); |
| indent = indent + " "; |
| name = name + '[' + loopIndex + ']'; |
| } |
| if (td.type () instanceof SequenceEntry || td.type () instanceof PrimitiveEntry || td.type () instanceof StringEntry) |
| index = ((JavaGenerator)td.type ().generator ()).write (index, indent, name, td.type (), stream); |
| else if (td.type () instanceof InterfaceEntry && td.type ().fullName ().equals ("org/omg/CORBA/Object")) |
| stream.println (indent + "ostream.write_Object (" + name + ");"); |
| else |
| stream.println (indent + Util.helperName (td.type (), true) + ".write (ostream, " + name + ");"); // <d61056> |
| for (int i = 0; i < closingBrackets; ++i) |
| { |
| indent = indent.substring (2); |
| stream.println (indent + '}'); |
| } |
| } |
| else |
| { |
| SymtabEntry tdtype = Util.typeOf (td.type ()); |
| if (tdtype instanceof SequenceEntry || tdtype instanceof PrimitiveEntry || tdtype instanceof StringEntry) |
| index = ((JavaGenerator)tdtype.generator ()).write (index, indent, name, tdtype, stream); |
| else if (tdtype instanceof InterfaceEntry && tdtype.fullName ().equals ("org/omg/CORBA/Object")) |
| stream.println (indent + "ostream.write_Object (" + name + ");"); |
| else |
| stream.println (indent + Util.helperName (tdtype, true) + ".write (ostream, " + name + ");"); // <d61056> |
| } |
| return index; |
| } // write |
| |
| // From JavaGenerator |
| //////////////// |
| |
| protected Hashtable symbolTable = null; |
| protected TypedefEntry t = null; |
| } // class TypedefGen |