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 * <pre> 84 * d62023 - delete write_value from non-boxed helpers 85 * - delete _write from non-boxed helpers 86 * </pre> 87 **/ 88 public void helperWrite (SymtabEntry entry, PrintWriter stream) 89 { 90 // REVISIT: Abstract/Custom?? 91 // per Simon mail 5/17/99 92 stream.println (" ((org.omg.CORBA_2_3.portable.OutputStream) ostream).write_value (value, id ());"); 93 } // helperWrite 94 95 /** 96 * d62023 97 **/ 98 public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream) 99 { 100 // REVISIT: Abstract/Custom?? 101 // per Simon mail 5/17/99 102 stream.println (" return (" + entryName + ")((org.omg.CORBA_2_3.portable.InputStream) istream).read_value (id ());"); 103 } // helperRead 104 105 /** 106 * d62023 - suppress initializers from mapped value; now generated in 107 * the Helper class and Factory class 108 **/ 109 protected void writeInitializers () 110 { 111 // override to do nothing 112 } // writeInitializers 113 114 /** 115 * d62023 - goes in mapped class, not Helper 116 **/ 117 protected void writeTruncatable () // <d60929> 118 { 119 if (!v.isAbstract ()) { 120 stream.println (" private static String[] _truncatable_ids = {"); 121 stream.print (" " + Util.helperName(v, true) + ".id ()"); 122 123 // Any safe ValueEntry must have a concete value parent. 124 // The topmost parent cannot be safe since it doesn't have 125 // a concrete parent. 126 ValueEntry child = v; 127 while (child.isSafe ()) 128 { 129 stream.println(","); 130 ValueEntry parent = (ValueEntry)child.derivedFrom ().elementAt (0); 131 stream.print(" \"" + Util.stripLeadingUnderscoresFromID (parent.repositoryID ().ID ()) + "\""); 132 child = parent; 133 } 134 stream.println(); 135 stream.println(" };"); 136 stream.println(); 137 stream.println (" public String[] _truncatable_ids() {"); 138 stream.println (" return _truncatable_ids;"); 139 stream.println (" }"); 140 stream.println (); 141 } 142 } // writeTruncatable 143 144 class ImplStreamWriter { 145 private boolean isImplementsWritten = false ; 146 147 public void writeClassName( String name ) 148 { 149 if (!isImplementsWritten) { 150 stream.print( " implements " ) ; 151 isImplementsWritten = true ; 152 } else 153 stream.print( ", " ) ; 154 155 stream.print( name ) ; 156 } 157 } 158 159 /** 160 * d62023 - CustomMarshal {@literal ->} CustomValue for custom valuetypes 161 * mapped class is abstract 162 **/ 163 protected void writeHeading () 164 { 165 ImplStreamWriter isw = new ImplStreamWriter() ; 166 167 Util.writePackage (stream, v); 168 Util.writeProlog (stream, ((GenFileStream)stream).name ()); 169 170 if (v.comment () != null) 171 v.comment ().generate ("", stream); 172 173 if (v.isAbstract ()) { 174 writeAbstract (); 175 return; 176 } else 177 stream.print ("public abstract class " + v.name ()); 178 179 // There should always be at least one parent: ValueBase 180 SymtabEntry parent = (SymtabEntry) v.derivedFrom ().elementAt (0); 181 182 // If parent is ValueBase, it's mapped to java.io.Serializable 183 String parentName = Util.javaName (parent); 184 boolean cv = false; // true if we've already implemented CustomValue 185 186 if (parentName.equals ("java.io.Serializable")) { 187 if (((ValueEntry)v).isCustom ()) { 188 isw.writeClassName( "org.omg.CORBA.portable.CustomValue" ) ; 189 cv = true; 190 } else 191 isw.writeClassName( "org.omg.CORBA.portable.StreamableValue" ) ; 192 } else if ( !((ValueEntry)parent).isAbstract ()) 193 stream.print (" extends " + parentName); 194 195 // if inheriting from abstract values 196 for (int i = 0; i < v.derivedFrom ().size (); i++) { 197 parent = (SymtabEntry) v.derivedFrom ().elementAt (i); 198 if ( ((ValueEntry)parent).isAbstract ()) { 199 isw.writeClassName( Util.javaName(parent) ) ; 200 } 201 } 202 203 // Write out the supported interfaces 204 Enumeration enumeration = v.supports().elements(); 205 while (enumeration.hasMoreElements()) { 206 InterfaceEntry ie = (InterfaceEntry)(enumeration.nextElement()) ; 207 String cname = Util.javaName(ie) ; 208 if (!ie.isAbstract()) 209 cname += "Operations" ; 210 isw.writeClassName( cname ) ; 211 } 212 213 // for when a custom valuetype inherits from a non-custom valuetype 214 if ( v.isCustom () && !cv) 215 isw.writeClassName( "org.omg.CORBA.portable.CustomValue" ) ; 216 217 stream.println (); 218 stream.println ("{"); 219 } // writeHeading 220 221 /** 222 * d62023 - private state maps to protected, not default 223 **/ 224 protected void writeMembers () 225 { 226 // if the value type contains no data members, a null return is expected 227 if (v.state () == null) 228 return; 229 230 for (int i = 0; i < v.state ().size (); i ++) 231 { 232 InterfaceState member = (InterfaceState) v.state ().elementAt (i); 233 SymtabEntry entry = (SymtabEntry) member.entry; 234 Util.fillInfo (entry); 235 236 if (entry.comment () != null) 237 entry.comment ().generate (" ", stream); 238 239 String modifier = " "; 240 if (member.modifier == InterfaceState.Public) 241 modifier = " public "; 242 else 243 modifier = " protected "; 244 Util.writeInitializer (modifier, entry.name (), "", entry, stream); 245 } 246 stream.println(); 247 } // writeMembers 248 249 /** 250 * d62023 - methods need to be abstract writeStreamable 251 **/ 252 protected void writeMethods () 253 { 254 // contained vector contains methods, attributes, const, enums, exceptions, 255 // structs, unions, or typedefs that are declared inside the value object. 256 // State members of the nested types are also included in this vector. 257 // Thus, if the declaration of a constructed type is nested in the decl. 258 // of a state member, e.g struct x {boolean b;} memberx; 259 // the generation of the nested type must be handled here. 260 Enumeration e = v.contained ().elements (); 261 while (e.hasMoreElements ()) 262 { 263 SymtabEntry contained = (SymtabEntry)e.nextElement (); 264 if (contained instanceof AttributeEntry) 265 { 266 AttributeEntry element = (AttributeEntry)contained; 267 ((AttributeGen24)element.generator ()).abstractMethod (symbolTable, element, stream); 268 } 269 else if (contained instanceof MethodEntry) 270 { 271 MethodEntry element = (MethodEntry)contained; 272 ((MethodGen24)element.generator ()).abstractMethod (symbolTable, element, stream); 273 } 274 else 275 { 276 // Generate the type referenced by the typedef. 277 if (contained instanceof TypedefEntry) 278 contained.type ().generate (symbolTable, stream); 279 280 // Note that we also need to generate the typedef itself if 281 // contained is a typedef. 282 contained.generate (symbolTable, stream); 283 } 284 } 285 286 // Abstract values are mapped to interfaces. There is no need to generate 287 // the bindings for inheriting methods in case of inheritance from other 288 // abstract values or supporting interface 289 if (v.isAbstract ()) 290 return; 291 292 // Non-abstract, Non-Custom valuetypes support the Streamable interface 293 if (!(v.isCustom () || v.isAbstract ())) 294 writeStreamableMethods (); 295 } // writeMethods 296 297 /** 298 * d62023 - call super._read() 299 **/ 300 public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream) 301 { 302 // First do the state members from concrete parent hierarchy 303 Vector vParents = ((ValueEntry) entry).derivedFrom (); 304 if (vParents != null && vParents.size() != 0) 305 { 306 ValueEntry parent = (ValueEntry) vParents.elementAt (0); 307 if (parent == null) 308 return index; 309 310 // call super._read if non-abstract value parent 311 if ((!parent.isAbstract ()) && (! Util.javaQualifiedName(parent).equals ("java.io.Serializable"))) // <d60929> 312 stream.println(indent + "super._read (istream);"); 313 } 314 315 Vector vMembers = ((ValueEntry) entry).state (); 316 int noOfMembers = vMembers == null ? 0 : vMembers.size (); 317 318 for (int k = 0; k < noOfMembers; k++) 319 { 320 TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry; 321 String memberName = member.name (); 322 SymtabEntry mType = member.type (); 323 324 if (mType instanceof PrimitiveEntry || 325 mType instanceof TypedefEntry || 326 mType instanceof SequenceEntry || 327 mType instanceof StringEntry || 328 !member.arrayInfo ().isEmpty ()) 329 index = ((JavaGenerator)member.generator ()).read (index, indent, name + '.' + memberName, member, stream); 330 else 331 stream.println (indent + name + '.' + memberName + " = " + 332 Util.helperName (mType, true) + ".read (istream);"); // <d61056> 333 } 334 335 return index; 336 } // read 337 338 /** 339 * d62023 - call super._write() 340 **/ 341 public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream) 342 { 343 // First do the state members from concrete parent hierarchy 344 Vector vParents = ((ValueEntry)entry).derivedFrom (); 345 if (vParents != null && vParents.size () != 0) 346 { 347 ValueEntry parent = (ValueEntry)vParents.elementAt (0); 348 if (parent == null) 349 return index; 350 // call super._read if non-abstract value parent 351 if ((!parent.isAbstract ()) && (! Util.javaQualifiedName(parent).equals ("java.io.Serializable"))) // <d60929> 352 stream.println(indent + "super._write (ostream);"); 353 } 354 355 Vector vMembers = ((ValueEntry) entry ).state (); 356 int noOfMembers = vMembers == null ? 0 : vMembers.size (); 357 for (int k = 0; k < noOfMembers; k++) 358 { 359 TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry; 360 String memberName = member.name (); 361 SymtabEntry mType = member.type (); 362 363 if (mType instanceof PrimitiveEntry || 364 mType instanceof TypedefEntry || 365 mType instanceof SequenceEntry || 366 mType instanceof StringEntry || 367 !member.arrayInfo ().isEmpty ()) 368 index = ((JavaGenerator)member.generator ()).write (index, indent, name + '.' + memberName, member, stream); 369 else 370 stream.println (indent + Util.helperName (mType, true) + // <d61056> 371 ".write (ostream, " + name + '.' + memberName + ");"); 372 } 373 374 return index; 375 } // write 376 377 /** 378 * d62023 - generate factory interface and default factory 379 **/ 380 public void generate (Hashtable symbolTable, ValueEntry v, PrintWriter str) 381 { 382 this.symbolTable = symbolTable; 383 this.v = v; 384 init (); 385 386 openStream (); 387 if (stream == null) 388 return; 389 generateTie (); 390 generateHelper (); 391 generateHolder (); 392 if (!v.isAbstract ()) { 393 generateValueFactory (); 394 generateDefaultFactory (); 395 } 396 writeHeading (); 397 writeBody (); 398 writeClosing (); 399 closeStream (); 400 } // generate 401 402 /** 403 * 404 **/ 405 protected void generateValueFactory () 406 { 407 ((Factories)Compile.compiler.factories ()).valueFactory ().generate (symbolTable, v); 408 } // generateValueFactory 409 410 /** 411 * 412 **/ 413 protected void generateDefaultFactory () 414 { 415 ((Factories)Compile.compiler.factories ()).defaultFactory ().generate (symbolTable, v); 416 } // generateDefaultFactory 417 }