View Javadoc
1   /*
2    * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  /*
26   * COMPONENT_NAME: idl.toJava
27   *
28   * ORIGINS: 27
29   *
30   * Licensed Materials - Property of IBM
31   * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
32   * RMI-IIOP v1.0
33   *
34   */
35  
36  package com.sun.tools.corba.se.idl.toJavaPortable;
37  
38  // NOTES:
39  // -D62023 <klr> Update for Java 2.4 RTF
40  // -D62794.1 <klr> Don't include operations inherited from abstract valuetypes
41  // -D62794.1 <scn> Don't include operations inherited from supported interfaces
42  
43  import java.io.File;
44  import java.io.PrintWriter;
45  import java.util.Hashtable;
46  import java.util.Enumeration;
47  import java.util.Vector;
48  
49  import com.sun.tools.corba.se.idl.GenFileStream;
50  import com.sun.tools.corba.se.idl.InterfaceEntry;
51  import com.sun.tools.corba.se.idl.SymtabEntry;
52  import com.sun.tools.corba.se.idl.TypedefEntry;
53  import com.sun.tools.corba.se.idl.ValueEntry;
54  import com.sun.tools.corba.se.idl.ValueBoxEntry;
55  import com.sun.tools.corba.se.idl.InterfaceState;
56  import com.sun.tools.corba.se.idl.MethodEntry;
57  import com.sun.tools.corba.se.idl.AttributeEntry;
58  import com.sun.tools.corba.se.idl.PrimitiveEntry;
59  import com.sun.tools.corba.se.idl.SequenceEntry;
60  import com.sun.tools.corba.se.idl.StringEntry;
61  import com.sun.tools.corba.se.idl.StructEntry;
62  
63  /**
64   *
65   **/
66  public class ValueGen24 extends ValueGen
67  {
68    /**
69     * Public zero-argument constructor.
70     **/
71    public ValueGen24 ()
72    {
73    } // ctor
74  
75    /**
76     * <d62023> - delete constructor; helper is abstract
77     **/
78    protected void writeConstructor ()
79    {
80    } // writeConstructor
81  
82    /**
83     * <d62023> - delete write_value from non-boxed helpers
84     *          - delete _write from non-boxed helpers
85     **/
86    public void helperWrite (SymtabEntry entry, PrintWriter stream)
87    {
88      // REVISIT: Abstract/Custom??
89      // per Simon mail 5/17/99
90      stream.println ("    ((org.omg.CORBA_2_3.portable.OutputStream) ostream).write_value (value, id ());");
91    } // helperWrite
92  
93    /**
94     * <d62023>
95     **/
96    public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream)
97    {
98      // REVISIT: Abstract/Custom??
99      // per Simon mail 5/17/99
100     stream.println ("    return (" + entryName + ")((org.omg.CORBA_2_3.portable.InputStream) istream).read_value (id ());");
101   } // helperRead
102 
103   /**
104    * <d62023> - suppress initializers from mapped value; now generated in
105    *    the Helper class and Factory class
106    **/
107   protected void writeInitializers ()
108   {
109         // override to do nothing
110   } // writeInitializers
111 
112   /**
113    * <d62023> - Goes in mapped class, not Helper
114    **/
115   protected void writeTruncatable () // <d60929>
116   {
117     if (!v.isAbstract ()) {
118        stream.println ("  private static String[] _truncatable_ids = {");
119        stream.print   ("    " + Util.helperName(v, true) + ".id ()");
120 
121        // Any safe ValueEntry must have a concete value parent.
122        // The topmost parent cannot be safe since it doesn't have
123        // a concrete parent.
124        ValueEntry child = v;
125        while (child.isSafe ())
126        {
127         stream.println(",");
128         ValueEntry parent = (ValueEntry)child.derivedFrom ().elementAt (0);
129         stream.print("    \"" + Util.stripLeadingUnderscoresFromID (parent.repositoryID ().ID ()) + "\"");
130         child = parent;
131       }
132       stream.println();
133       stream.println("  };");
134       stream.println();
135       stream.println ("  public String[] _truncatable_ids() {");
136       stream.println ("    return _truncatable_ids;");
137       stream.println ("  }");
138       stream.println ();
139     }
140   } // writeTruncatable
141 
142   class ImplStreamWriter {
143     private boolean isImplementsWritten = false ;
144 
145     public void writeClassName( String name )
146     {
147         if (!isImplementsWritten) {
148             stream.print( " implements " ) ;
149             isImplementsWritten = true ;
150         } else
151             stream.print( ", " ) ;
152 
153         stream.print( name ) ;
154     }
155   }
156 
157   /**
158    * <d62023> CustomMarshal -> CustomValue for custom valuetypes
159    *          mapped class is abstract
160    **/
161   protected void writeHeading ()
162   {
163     ImplStreamWriter isw = new ImplStreamWriter() ;
164 
165     Util.writePackage (stream, v);
166     Util.writeProlog (stream, ((GenFileStream)stream).name ());
167 
168     if (v.comment () != null)
169         v.comment ().generate ("", stream);
170 
171     if (v.isAbstract ()) {
172         writeAbstract ();
173         return;
174     } else
175         stream.print ("public abstract class " + v.name ());
176 
177     // There should always be at least one parent: ValueBase
178     SymtabEntry parent = (SymtabEntry) v.derivedFrom ().elementAt (0);
179 
180     // If parent is ValueBase, it's mapped to java.io.Serializable
181     String parentName = Util.javaName (parent);
182     boolean cv = false; // true if we've already implemented CustomValue
183 
184     if (parentName.equals ("java.io.Serializable")) {
185         if (((ValueEntry)v).isCustom ()) {
186               isw.writeClassName( "org.omg.CORBA.portable.CustomValue" ) ;
187               cv = true;
188         } else
189               isw.writeClassName( "org.omg.CORBA.portable.StreamableValue" ) ;
190     } else if ( !((ValueEntry)parent).isAbstract ())
191         stream.print (" extends " + parentName);
192 
193     // if inheriting from abstract values
194     for (int i = 0; i < v.derivedFrom ().size (); i++) {
195         parent = (SymtabEntry) v.derivedFrom ().elementAt (i);
196         if ( ((ValueEntry)parent).isAbstract ()) {
197             isw.writeClassName( Util.javaName(parent) ) ;
198         }
199     }
200 
201     // Write out the supported interfaces
202     Enumeration enumeration = v.supports().elements();
203     while (enumeration.hasMoreElements())  {
204         InterfaceEntry ie = (InterfaceEntry)(enumeration.nextElement()) ;
205         String cname = Util.javaName(ie) ;
206         if (!ie.isAbstract())
207             cname += "Operations" ;
208         isw.writeClassName( cname ) ;
209     }
210 
211     // for when a custom valuetype inherits from a non-custom valuetype
212     if ( v.isCustom () && !cv)
213         isw.writeClassName( "org.omg.CORBA.portable.CustomValue" ) ;
214 
215     stream.println ();
216     stream.println ("{");
217   } // writeHeading
218 
219   /**
220    * <d62023> - private state maps to protected, not default
221    **/
222   protected void writeMembers ()
223   {
224     // if the value type contains no data members, a null return is expected
225     if (v.state () == null)
226       return;
227 
228     for (int i = 0; i < v.state ().size (); i ++)
229     {
230       InterfaceState member = (InterfaceState) v.state ().elementAt (i);
231       SymtabEntry entry = (SymtabEntry) member.entry;
232       Util.fillInfo (entry);
233 
234       if (entry.comment () != null)
235         entry.comment ().generate (" ", stream);
236 
237       String modifier = "  ";
238       if (member.modifier == InterfaceState.Public)
239         modifier = "  public ";
240       else
241         modifier = "  protected ";
242       Util.writeInitializer (modifier, entry.name (), "", entry, stream);
243     }
244     stream.println();
245   } // writeMembers
246 
247   /**
248    * <d62023> Methods need to be abstract
249    *          writeStreamable
250    **/
251   protected void writeMethods ()
252   {
253     // contained vector contains methods, attributes, const, enums, exceptions,
254     // structs, unions, or typedefs that are declared inside the value object.
255     // State members of the nested types are also included in this vector.
256     // Thus, if the declaration of a constructed type is nested in the decl.
257     // of a state member, e.g   struct x {boolean b;}  memberx;
258     // the generation of the nested type must be handled here.
259     Enumeration e = v.contained ().elements ();
260     while (e.hasMoreElements ())
261     {
262       SymtabEntry contained = (SymtabEntry)e.nextElement ();
263       if (contained instanceof AttributeEntry)
264       {
265         AttributeEntry element = (AttributeEntry)contained;
266         ((AttributeGen24)element.generator ()).abstractMethod (symbolTable, element, stream);
267       }
268       else if (contained instanceof MethodEntry)
269       {
270         MethodEntry element = (MethodEntry)contained;
271         ((MethodGen24)element.generator ()).abstractMethod (symbolTable, element, stream);
272       }
273       else
274       {
275         // Generate the type referenced by the typedef.
276         if (contained instanceof TypedefEntry)
277           contained.type ().generate (symbolTable, stream);
278 
279         // Note that we also need to generate the typedef itself if
280         // contained is a typedef.
281         contained.generate (symbolTable, stream);
282       }
283     }
284 
285     // Abstract values are mapped to interfaces. There is no need to generate
286     // the bindings for inheriting methods in case of inheritance from other
287     // abstract values or supporting interface
288     if (v.isAbstract ())
289         return;
290 
291   // Non-abstract, Non-Custom valuetypes support the Streamable interface
292   if (!(v.isCustom () || v.isAbstract ()))
293       writeStreamableMethods ();
294   } // writeMethods
295 
296   /**
297    * <d62023> Call super._read()
298    **/
299   public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
300   {
301     // First do the state members from concrete parent hierarchy
302     Vector vParents = ((ValueEntry) entry).derivedFrom ();
303     if (vParents != null && vParents.size() != 0)
304     {
305       ValueEntry parent = (ValueEntry) vParents.elementAt (0);
306       if (parent == null)
307         return index;
308 
309       // call super._read if non-abstract value parent
310       if ((!parent.isAbstract ()) && (! Util.javaQualifiedName(parent).equals ("java.io.Serializable"))) // <d60929>
311           stream.println(indent + "super._read (istream);");
312     }
313 
314     Vector vMembers = ((ValueEntry) entry).state ();
315     int noOfMembers = vMembers == null ? 0 : vMembers.size ();
316 
317     for (int k = 0; k < noOfMembers; k++)
318     {
319       TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry;
320       String memberName = member.name ();
321       SymtabEntry mType = member.type ();
322 
323       if (mType instanceof PrimitiveEntry ||
324           mType instanceof TypedefEntry   ||
325           mType instanceof SequenceEntry  ||
326           mType instanceof StringEntry    ||
327           !member.arrayInfo ().isEmpty ())
328         index = ((JavaGenerator)member.generator ()).read (index, indent, name + '.' + memberName, member, stream);
329       else
330         stream.println (indent + name + '.' + memberName + " = " +
331                         Util.helperName (mType, true) + ".read (istream);"); // <d61056>
332     }
333 
334     return index;
335   } // read
336 
337   /**
338    * <d62023> Call super._write()
339    **/
340   public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
341   {
342     // First do the state members from concrete parent hierarchy
343     Vector vParents = ((ValueEntry)entry).derivedFrom ();
344     if (vParents != null && vParents.size () != 0)
345     {
346       ValueEntry parent = (ValueEntry)vParents.elementAt (0);
347       if (parent == null)
348         return index;
349       // call super._read if non-abstract value parent
350       if ((!parent.isAbstract ()) && (! Util.javaQualifiedName(parent).equals ("java.io.Serializable"))) // <d60929>
351           stream.println(indent + "super._write (ostream);");
352     }
353 
354     Vector vMembers = ((ValueEntry) entry ).state ();
355     int noOfMembers = vMembers == null ? 0 : vMembers.size ();
356     for (int k = 0; k < noOfMembers; k++)
357     {
358       TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry;
359       String memberName = member.name ();
360       SymtabEntry mType = member.type ();
361 
362       if (mType instanceof PrimitiveEntry ||
363           mType instanceof TypedefEntry   ||
364           mType instanceof SequenceEntry  ||
365           mType instanceof StringEntry    ||
366           !member.arrayInfo ().isEmpty ())
367         index = ((JavaGenerator)member.generator ()).write (index, indent, name + '.' + memberName, member, stream);
368       else
369         stream.println (indent + Util.helperName (mType, true) + // <d61056>
370                               ".write (ostream, " + name + '.' + memberName + ");");
371     }
372 
373     return index;
374   } // write
375 
376   /**
377    * <62023> - generate factory interface and default factory
378    **/
379   public void generate (Hashtable symbolTable, ValueEntry v, PrintWriter str)
380   {
381     this.symbolTable = symbolTable;
382     this.v = v;
383     init ();
384 
385     openStream ();
386     if (stream == null)
387       return;
388     generateTie ();
389     generateHelper ();
390     generateHolder ();
391     if (!v.isAbstract ()) {
392       generateValueFactory ();
393       generateDefaultFactory ();
394     }
395     writeHeading ();
396     writeBody ();
397     writeClosing ();
398     closeStream ();
399   } // generate
400 
401   /**
402    *
403    **/
404   protected void generateValueFactory ()
405   {
406     ((Factories)Compile.compiler.factories ()).valueFactory ().generate (symbolTable, v);
407   } // generateValueFactory
408 
409   /**
410    *
411    **/
412   protected void generateDefaultFactory ()
413   {
414     ((Factories)Compile.compiler.factories ()).defaultFactory ().generate (symbolTable, v);
415   } // generateDefaultFactory
416 }