Mercurial > jdk8-mips64-public > corba / file comparison
comparison: src/share/classes/sun/rmi/rmic/iiop/CompoundType.java
src/share/classes/sun/rmi/rmic/iiop/CompoundType.java
- changeset 0
- 7ef37b2cdcad
- child 748
- 6845b95cba6b
equal
deleted
inserted
replaced
| -1:000000000000 | 0:7ef37b2cdcad |
|---|---|
| 1 /* | |
| 2 * Copyright (c) 1998, 2013, 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 /* | |
| 27 * Licensed Materials - Property of IBM | |
| 28 * RMI-IIOP v1.0 | |
| 29 * Copyright IBM Corp. 1998 1999 All Rights Reserved | |
| 30 * | |
| 31 */ | |
| 32 | |
| 33 package sun.rmi.rmic.iiop; | |
| 34 | |
| 35 import java.util.Arrays; | |
| 36 import java.util.Vector; | |
| 37 import sun.tools.java.Identifier; | |
| 38 import sun.tools.java.ClassNotFound; | |
| 39 import sun.tools.java.ClassDefinition; | |
| 40 import sun.tools.java.ClassDeclaration; | |
| 41 import sun.tools.java.MemberDefinition; | |
| 42 import sun.tools.java.CompilerError; | |
| 43 import sun.tools.tree.Node; | |
| 44 import sun.tools.tree.LocalMember; | |
| 45 import sun.tools.tree.CharExpression; | |
| 46 import sun.tools.tree.IntegerExpression; | |
| 47 import sun.rmi.rmic.IndentingWriter; | |
| 48 import java.io.IOException; | |
| 49 import java.util.HashSet; | |
| 50 import java.util.Enumeration; | |
| 51 import java.io.File; | |
| 52 | |
| 53 /** | |
| 54 * A CompoundType is an abstract base class for all IIOP class and | |
| 55 * interface types. | |
| 56 * | |
| 57 * @author Bryan Atsatt | |
| 58 */ | |
| 59 public abstract class CompoundType extends Type { | |
| 60 | |
| 61 protected Method[] methods; | |
| 62 protected InterfaceType[] interfaces; | |
| 63 protected Member[] members; | |
| 64 protected ClassDefinition classDef; | |
| 65 protected ClassDeclaration classDecl; | |
| 66 | |
| 67 protected boolean isCORBAObject = false; | |
| 68 protected boolean isIDLEntity = false; | |
| 69 protected boolean isAbstractBase = false; | |
| 70 protected boolean isValueBase = false; | |
| 71 protected boolean isCORBAUserException = false; | |
| 72 protected boolean isException = false; | |
| 73 protected boolean isCheckedException = false; | |
| 74 protected boolean isRemoteExceptionOrSubclass = false; | |
| 75 protected String idlExceptionName; | |
| 76 protected String qualifiedIDLExceptionName; | |
| 77 | |
| 78 //_____________________________________________________________________ | |
| 79 // Public Interfaces | |
| 80 //_____________________________________________________________________ | |
| 81 | |
| 82 /** | |
| 83 * Return true if this type implements | |
| 84 * org.omg.CORBA.Object. | |
| 85 */ | |
| 86 public boolean isCORBAObject () { | |
| 87 return isCORBAObject; | |
| 88 } | |
| 89 | |
| 90 /** | |
| 91 * Return true if this type implements | |
| 92 * org.omg.CORBA.portable.IDLEntity. | |
| 93 */ | |
| 94 public boolean isIDLEntity () { | |
| 95 return isIDLEntity; | |
| 96 } | |
| 97 | |
| 98 /** | |
| 99 * Return true if this type implements | |
| 100 * org.omg.CORBA.portable.ValueBase. | |
| 101 */ | |
| 102 public boolean isValueBase () { | |
| 103 return isValueBase; | |
| 104 } | |
| 105 | |
| 106 /** | |
| 107 * Return true if this type is a CORBA | |
| 108 * abstract interface. | |
| 109 */ | |
| 110 public boolean isAbstractBase () { | |
| 111 return isAbstractBase; | |
| 112 } | |
| 113 | |
| 114 /** | |
| 115 * Return true if this type is an exception. | |
| 116 */ | |
| 117 public boolean isException () { | |
| 118 return isException; | |
| 119 } | |
| 120 | |
| 121 /** | |
| 122 * Return true if this type is a "checked" exception. | |
| 123 * Result if valid iff isException() returns true. | |
| 124 */ | |
| 125 public boolean isCheckedException () { | |
| 126 return isCheckedException; | |
| 127 } | |
| 128 | |
| 129 /** | |
| 130 * Return true if this type is a java.rmi.RemoteException | |
| 131 * or one of its subclasses. Result if valid iff isException() | |
| 132 * returns true. | |
| 133 */ | |
| 134 public boolean isRemoteExceptionOrSubclass () { | |
| 135 return isRemoteExceptionOrSubclass; | |
| 136 } | |
| 137 | |
| 138 /** | |
| 139 * Return true if this type is exactly | |
| 140 * org.omg.CORBA.UserException. | |
| 141 */ | |
| 142 public boolean isCORBAUserException () { | |
| 143 return isCORBAUserException; | |
| 144 } | |
| 145 | |
| 146 /** | |
| 147 * Return true if this type implements | |
| 148 * isIDLEntity() && isException(). | |
| 149 */ | |
| 150 public boolean isIDLEntityException () { | |
| 151 return isIDLEntity() && isException(); | |
| 152 } | |
| 153 /** | |
| 154 * Return true if isIDLEntity() && !isValueBase() | |
| 155 * && !isAbstractBase() && !isCORBAObject() | |
| 156 * && !isIDLEntityException(). | |
| 157 */ | |
| 158 public boolean isBoxed () { | |
| 159 return (isIDLEntity() && !isValueBase() && | |
| 160 !isAbstractBase() && !isCORBAObject() && | |
| 161 !isIDLEntityException()); | |
| 162 } | |
| 163 | |
| 164 /** | |
| 165 * If this type represents an exception, return the | |
| 166 * IDL name including the "Ex" mangling, otherwise | |
| 167 * return null. | |
| 168 */ | |
| 169 public String getIDLExceptionName () { | |
| 170 return idlExceptionName; | |
| 171 } | |
| 172 | |
| 173 /** | |
| 174 * If this type represents an exception, return the | |
| 175 * qualified IDL name including the "Ex" mangling, | |
| 176 * otherwise return null. | |
| 177 * @param global If true, prepends "::". | |
| 178 */ | |
| 179 public String getQualifiedIDLExceptionName (boolean global) { | |
| 180 if (qualifiedIDLExceptionName != null && | |
| 181 global && | |
| 182 getIDLModuleNames().length > 0) { | |
| 183 return IDL_NAME_SEPARATOR + qualifiedIDLExceptionName; | |
| 184 } else { | |
| 185 return qualifiedIDLExceptionName; | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 /** | |
| 190 * Return signature for this type (e.g. com.acme.Dynamite | |
| 191 * would return "com.acme.Dynamite", byte = "B") | |
| 192 */ | |
| 193 public String getSignature() { | |
| 194 String sig = classDecl.getType().getTypeSignature(); | |
| 195 if (sig.endsWith(";")) { | |
| 196 sig = sig.substring(0,sig.length()-1); | |
| 197 } | |
| 198 return sig; | |
| 199 } | |
| 200 | |
| 201 /** | |
| 202 * Return the ClassDeclaration for this type. | |
| 203 */ | |
| 204 public ClassDeclaration getClassDeclaration() { | |
| 205 return classDecl; | |
| 206 } | |
| 207 | |
| 208 /** | |
| 209 * Return the ClassDefinition for this type. | |
| 210 */ | |
| 211 public ClassDefinition getClassDefinition() { | |
| 212 return classDef; | |
| 213 } | |
| 214 | |
| 215 /** | |
| 216 * Return the parent class of this type. Returns null if this | |
| 217 * type is an interface or if there is no parent. | |
| 218 */ | |
| 219 public ClassType getSuperclass() { | |
| 220 return null; | |
| 221 } | |
| 222 | |
| 223 /** | |
| 224 * Return an array of interfaces directly implemented by this type. | |
| 225 * <p> | |
| 226 * The order of the array returned is arbitrary. | |
| 227 */ | |
| 228 public InterfaceType[] getInterfaces() { | |
| 229 if( interfaces != null ) { | |
| 230 return (InterfaceType[]) interfaces.clone(); | |
| 231 } | |
| 232 return null; | |
| 233 } | |
| 234 | |
| 235 /** | |
| 236 * Return an array of Type.Method objects representing all | |
| 237 * of the methods implemented directly by this type. | |
| 238 */ | |
| 239 public Method[] getMethods() { | |
| 240 if( methods != null ) { | |
| 241 return (Method[]) methods.clone(); | |
| 242 } | |
| 243 return null; | |
| 244 } | |
| 245 | |
| 246 /** | |
| 247 * Return an array of Type.Member objects representing all of | |
| 248 * the data members directly implemented by this interface. | |
| 249 */ | |
| 250 public Member[] getMembers() { | |
| 251 if( members != null ) { | |
| 252 return (Member[]) members.clone(); | |
| 253 } | |
| 254 return null; | |
| 255 } | |
| 256 | |
| 257 /** | |
| 258 * Create a CompoundType object for the given class. | |
| 259 * | |
| 260 * If the class is not a properly formed or if some other error occurs, the | |
| 261 * return value will be null, and errors will have been reported to the | |
| 262 * supplied BatchEnvironment. | |
| 263 */ | |
| 264 public static CompoundType forCompound (ClassDefinition classDef, | |
| 265 ContextStack stack) { | |
| 266 CompoundType result = null; | |
| 267 | |
| 268 try { | |
| 269 result = (CompoundType) makeType(classDef.getType(),classDef,stack); | |
| 270 } catch (ClassCastException e) {} | |
| 271 | |
| 272 return result; | |
| 273 } | |
| 274 | |
| 275 | |
| 276 //_____________________________________________________________________ | |
| 277 // Subclass/Internal Interfaces | |
| 278 //_____________________________________________________________________ | |
| 279 | |
| 280 /** | |
| 281 * Release all resources. | |
| 282 */ | |
| 283 protected void destroy () { | |
| 284 if (!destroyed) { | |
| 285 super.destroy(); | |
| 286 | |
| 287 if (methods != null) { | |
| 288 for (int i = 0; i < methods.length; i++) { | |
| 289 if (methods[i] != null) methods[i].destroy(); | |
| 290 } | |
| 291 methods = null; | |
| 292 } | |
| 293 | |
| 294 if (interfaces != null) { | |
| 295 for (int i = 0; i < interfaces.length; i++) { | |
| 296 if (interfaces[i] != null) interfaces[i].destroy(); | |
| 297 } | |
| 298 interfaces = null; | |
| 299 } | |
| 300 | |
| 301 if (members != null) { | |
| 302 for (int i = 0; i < members.length; i++) { | |
| 303 if (members[i] != null) members[i].destroy(); | |
| 304 } | |
| 305 members = null; | |
| 306 } | |
| 307 | |
| 308 classDef = null; | |
| 309 classDecl = null; | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 /* | |
| 314 * Load a Class instance. Return null if fail. | |
| 315 */ | |
| 316 protected Class loadClass() { | |
| 317 | |
| 318 Class ourClass = null; | |
| 319 | |
| 320 // To avoid getting out-of-date Class instances, and | |
| 321 // to ensure that there is an instance, we must compile | |
| 322 // any classes that we've seen and which are not yet | |
| 323 // compiled. We can't just compile this class, 'cuz it | |
| 324 // may have dependencies on classes which have not been | |
| 325 // compiled... | |
| 326 | |
| 327 try { | |
| 328 env.getMain().compileAllClasses(env); | |
| 329 } catch (Exception e1) { | |
| 330 for (Enumeration e = env.getClasses() ; e.hasMoreElements() ; ) { | |
| 331 ClassDeclaration c = (ClassDeclaration)e.nextElement(); | |
| 332 } | |
| 333 failedConstraint(26,false,stack,"required classes"); | |
| 334 env.flushErrors(); | |
| 335 } | |
| 336 | |
| 337 // Now try to get the Class... | |
| 338 // The outer try block is there for people who might want to use | |
| 339 // the compiler at run-time of their AS. | |
| 340 // They could set and use their own context class loader for loading | |
| 341 // classes directly. | |
| 342 try { | |
| 343 ClassLoader cl = Thread.currentThread().getContextClassLoader(); | |
| 344 ourClass = cl.loadClass(getQualifiedName()); | |
| 345 } catch(ClassNotFoundException cfe) { | |
| 346 | |
| 347 try { | |
| 348 ourClass = env.classPathLoader.loadClass(getQualifiedName()); | |
| 349 } catch (NullPointerException e) { | |
| 350 // This should never happen | |
| 351 } catch (ClassNotFoundException e) { | |
| 352 // Fall through to the next case (which is to look in the | |
| 353 // output directory for generated files) | |
| 354 } | |
| 355 } | |
| 356 | |
| 357 /* This piece of code used to cause the compiler to ignore jar files | |
| 358 on its classpath | |
| 359 try { | |
| 360 ourClass = Util.loadClass(getQualifiedName(),null,null); | |
| 361 } catch (ClassNotFoundException e) { | |
| 362 } catch (LinkageError e) { | |
| 363 } | |
| 364 */ | |
| 365 | |
| 366 if (ourClass == null) { | |
| 367 | |
| 368 // Try one last thing. If the class was compiled into | |
| 369 // a directory that's not in the classpath, the load | |
| 370 // will fail. Let's get the bits off the disk and load | |
| 371 // it directly... | |
| 372 | |
| 373 if (env.loader == null) { | |
| 374 File destDir = env.getMain().getDestinationDir(); | |
| 375 if (destDir == null) { | |
| 376 destDir = new File("."); | |
| 377 } | |
| 378 env.loader = new DirectoryLoader(destDir); | |
| 379 } | |
| 380 | |
| 381 try { | |
| 382 ourClass = env.loader.loadClass(getQualifiedName()); | |
| 383 } catch (Exception e) {} | |
| 384 } | |
| 385 | |
| 386 return ourClass; | |
| 387 } | |
| 388 | |
| 389 // Print "extends XX" | |
| 390 | |
| 391 protected boolean printExtends (IndentingWriter writer, | |
| 392 boolean useQualifiedNames, | |
| 393 boolean useIDLNames, | |
| 394 boolean globalIDLNames) throws IOException { | |
| 395 | |
| 396 ClassType parent = getSuperclass(); | |
| 397 | |
| 398 if (parent != null && (!useIDLNames || | |
| 399 (!parent.isType(TYPE_ANY) && !parent.isType(TYPE_CORBA_OBJECT)))) { | |
| 400 writer.p(" extends "); | |
| 401 parent.printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 402 return true; | |
| 403 } | |
| 404 return false; | |
| 405 } | |
| 406 | |
| 407 // Print "implements XX, YY" | |
| 408 | |
| 409 protected void printImplements (IndentingWriter writer, | |
| 410 String prefix, | |
| 411 boolean useQualifiedNames, | |
| 412 boolean useIDLNames, | |
| 413 boolean globalIDLNames) throws IOException { | |
| 414 | |
| 415 InterfaceType[] interfaces = getInterfaces(); | |
| 416 | |
| 417 String adjective = " implements"; | |
| 418 | |
| 419 if (isInterface()) { | |
| 420 adjective = " extends"; | |
| 421 } | |
| 422 | |
| 423 if (useIDLNames) { | |
| 424 adjective = ":"; | |
| 425 } | |
| 426 | |
| 427 for (int i = 0; i < interfaces.length; i++) { | |
| 428 if (!useIDLNames || (!interfaces[i].isType(TYPE_ANY) && !interfaces[i].isType(TYPE_CORBA_OBJECT))) { | |
| 429 if (i == 0) { | |
| 430 writer.p(prefix + adjective + " "); | |
| 431 } else { | |
| 432 writer.p(", "); | |
| 433 } | |
| 434 interfaces[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 435 } | |
| 436 } | |
| 437 } | |
| 438 | |
| 439 // Print members | |
| 440 | |
| 441 protected void printMembers ( IndentingWriter writer, | |
| 442 boolean useQualifiedNames, | |
| 443 boolean useIDLNames, | |
| 444 boolean globalIDLNames) throws IOException { | |
| 445 | |
| 446 CompoundType.Member[] members = getMembers(); | |
| 447 | |
| 448 for (int i = 0; i < members.length; i++) { | |
| 449 if (!members[i].isInnerClassDeclaration()) { | |
| 450 Type it = members[i].getType(); | |
| 451 String visibility = members[i].getVisibility(); | |
| 452 String name; | |
| 453 | |
| 454 if (useIDLNames) { | |
| 455 name = members[i].getIDLName(); | |
| 456 } else { | |
| 457 name = members[i].getName(); | |
| 458 } | |
| 459 | |
| 460 String value = members[i].getValue(); | |
| 461 | |
| 462 writer.p(visibility); | |
| 463 if (visibility.length() > 0) { | |
| 464 writer.p(" "); | |
| 465 } | |
| 466 it.printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 467 writer.p(" " + name); | |
| 468 | |
| 469 if (value != null) { | |
| 470 writer.pln(" = " + value + ";"); | |
| 471 } else { | |
| 472 writer.pln(";"); | |
| 473 } | |
| 474 } | |
| 475 } | |
| 476 } | |
| 477 | |
| 478 // Print methods | |
| 479 | |
| 480 protected void printMethods ( IndentingWriter writer, | |
| 481 boolean useQualifiedNames, | |
| 482 boolean useIDLNames, | |
| 483 boolean globalIDLNames) throws IOException { | |
| 484 | |
| 485 CompoundType.Method[] methods = getMethods(); | |
| 486 | |
| 487 for (int m = 0; m < methods.length; m++) { | |
| 488 CompoundType.Method theMethod = methods[m]; | |
| 489 printMethod(theMethod,writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 490 } | |
| 491 } | |
| 492 | |
| 493 // Print a method... | |
| 494 | |
| 495 protected void printMethod (CompoundType.Method it, | |
| 496 IndentingWriter writer, | |
| 497 boolean useQualifiedNames, | |
| 498 boolean useIDLNames, | |
| 499 boolean globalIDLNames) throws IOException { | |
| 500 | |
| 501 | |
| 502 // Write visibility... | |
| 503 | |
| 504 String visibility = it.getVisibility(); | |
| 505 | |
| 506 writer.p(visibility); | |
| 507 if (visibility.length() > 0) { | |
| 508 writer.p(" "); | |
| 509 } | |
| 510 | |
| 511 // Write return type... | |
| 512 | |
| 513 it.getReturnType().printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 514 | |
| 515 // Write method name... | |
| 516 | |
| 517 if (useIDLNames) { | |
| 518 writer.p(" " + it.getIDLName()); | |
| 519 } else { | |
| 520 writer.p(" " + it.getName()); | |
| 521 } | |
| 522 | |
| 523 // Write arguments... | |
| 524 | |
| 525 writer.p(" ("); | |
| 526 Type[] args = it.getArguments(); | |
| 527 String[] argNames = it.getArgumentNames(); | |
| 528 | |
| 529 for (int i = 0; i < args.length; i++) { | |
| 530 if (i > 0) { | |
| 531 writer.p(", "); | |
| 532 } | |
| 533 | |
| 534 if (useIDLNames) { | |
| 535 writer.p("in "); | |
| 536 } | |
| 537 | |
| 538 args[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 539 writer.p(" " + argNames[i]); | |
| 540 } | |
| 541 writer.p(")"); | |
| 542 | |
| 543 // Write exceptions... | |
| 544 | |
| 545 ClassType[] exceptions; | |
| 546 | |
| 547 if (isType(TYPE_IMPLEMENTATION)) { | |
| 548 exceptions = it.getImplExceptions(); | |
| 549 } else { | |
| 550 exceptions = it.getExceptions(); | |
| 551 } | |
| 552 | |
| 553 for (int i = 0; i < exceptions.length; i++) { | |
| 554 if (i == 0) { | |
| 555 if (useIDLNames) { | |
| 556 writer.p(" raises ("); | |
| 557 } else { | |
| 558 writer.p(" throws "); | |
| 559 } | |
| 560 } else { | |
| 561 writer.p(", "); | |
| 562 } | |
| 563 | |
| 564 if (useIDLNames) { | |
| 565 if (useQualifiedNames) { | |
| 566 writer.p(exceptions[i].getQualifiedIDLExceptionName(globalIDLNames)); | |
| 567 } else { | |
| 568 writer.p(exceptions[i].getIDLExceptionName()); | |
| 569 } | |
| 570 writer.p(" [a.k.a. "); | |
| 571 exceptions[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 572 writer.p("]"); | |
| 573 } else { | |
| 574 exceptions[i].printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames); | |
| 575 } | |
| 576 } | |
| 577 | |
| 578 if (useIDLNames && exceptions.length > 0) { | |
| 579 writer.p(")"); | |
| 580 } | |
| 581 | |
| 582 if (it.isInherited()) { | |
| 583 writer.p(" // Inherited from "); | |
| 584 writer.p(it.getDeclaredBy()); | |
| 585 } | |
| 586 | |
| 587 writer.pln(";"); | |
| 588 } | |
| 589 | |
| 590 /** | |
| 591 * Create a CompoundType instance for the given class. NOTE: This constructor | |
| 592 * is ONLY for SpecialClassType and SpecialInterfaceType. | |
| 593 */ | |
| 594 protected CompoundType(ContextStack stack, int typeCode, ClassDefinition classDef) { | |
| 595 super(stack,typeCode); | |
| 596 this.classDef = classDef; | |
| 597 classDecl = classDef.getClassDeclaration(); | |
| 598 interfaces = new InterfaceType[0]; | |
| 599 methods = new Method[0]; | |
| 600 members = new Member[0]; | |
| 601 | |
| 602 // If we are an inner class/interface, reset the type codes... | |
| 603 | |
| 604 if (classDef.isInnerClass()) { | |
| 605 setTypeCode(typeCode | TM_INNER); | |
| 606 } | |
| 607 | |
| 608 // Set special flags... | |
| 609 | |
| 610 setFlags(); | |
| 611 } | |
| 612 | |
| 613 private void setFlags() { | |
| 614 | |
| 615 try { | |
| 616 | |
| 617 // Set our special interface flags... | |
| 618 | |
| 619 isCORBAObject = env.defCorbaObject.implementedBy(env,classDecl); | |
| 620 isIDLEntity = env.defIDLEntity.implementedBy(env,classDecl); | |
| 621 isValueBase = env.defValueBase.implementedBy(env,classDecl); | |
| 622 isAbstractBase = isInterface() && // Interface, not a class. | |
| 623 isIDLEntity && // Implements IDLEntity. | |
| 624 !isValueBase && // Does not implement ValueBase. | |
| 625 !isCORBAObject; // Does not implement org.omg.CORBA.Object; | |
| 626 isCORBAUserException = (classDecl.getName() == idCorbaUserException); | |
| 627 | |
| 628 // Is this an exception? | |
| 629 | |
| 630 if (env.defThrowable.implementedBy(env, classDecl)) { | |
| 631 | |
| 632 // Yes... | |
| 633 | |
| 634 isException = true; | |
| 635 | |
| 636 // Is it a checked exception? | |
| 637 | |
| 638 if (env.defRuntimeException.implementedBy(env,classDecl) || | |
| 639 env.defError.implementedBy(env,classDecl)) { | |
| 640 isCheckedException = false; | |
| 641 } else { | |
| 642 isCheckedException = true; | |
| 643 } | |
| 644 | |
| 645 // Is it java.rmi.RemoteException or a subclass? | |
| 646 | |
| 647 if (env.defRemoteException.implementedBy(env,classDecl)) { | |
| 648 isRemoteExceptionOrSubclass = true; | |
| 649 } else { | |
| 650 isRemoteExceptionOrSubclass = false; | |
| 651 } | |
| 652 } else { | |
| 653 isException = false; | |
| 654 } | |
| 655 } catch (ClassNotFound e) { | |
| 656 classNotFound(stack,e); | |
| 657 } | |
| 658 } | |
| 659 | |
| 660 /** | |
| 661 * Create a CompoundType instance for the given class. The resulting | |
| 662 * object is not yet completely initialized. | |
| 663 */ | |
| 664 protected CompoundType(ContextStack stack, ClassDefinition classDef, | |
| 665 int typeCode) { | |
| 666 super(stack,typeCode); | |
| 667 this.classDef = classDef; | |
| 668 classDecl = classDef.getClassDeclaration(); | |
| 669 | |
| 670 // If we are an inner class/interface, reset the type codes... | |
| 671 | |
| 672 if (classDef.isInnerClass()) { | |
| 673 setTypeCode(typeCode | TM_INNER); | |
| 674 } | |
| 675 | |
| 676 // Set special flags... | |
| 677 | |
| 678 setFlags(); | |
| 679 | |
| 680 // Set names... | |
| 681 | |
| 682 Identifier id = classDef.getName(); | |
| 683 String idlName; | |
| 684 String[] idlModuleNames; | |
| 685 | |
| 686 try { | |
| 687 | |
| 688 // These can fail if we get case-sensitive name matches... | |
| 689 | |
| 690 idlName = IDLNames.getClassOrInterfaceName(id,env); | |
| 691 idlModuleNames = IDLNames.getModuleNames(id,isBoxed(),env); | |
| 692 | |
| 693 setNames(id,idlModuleNames,idlName); | |
| 694 | |
| 695 // Is this an exception? | |
| 696 | |
| 697 if (isException()) { | |
| 698 | |
| 699 // Yes, so set our mangled exception names... | |
| 700 | |
| 701 isException = true; | |
| 702 idlExceptionName = IDLNames.getExceptionName(getIDLName()); | |
| 703 qualifiedIDLExceptionName = | |
| 704 IDLNames.getQualifiedName(getIDLModuleNames(),idlExceptionName); | |
| 705 } | |
| 706 | |
| 707 // Set interfaces, methods and members... | |
| 708 | |
| 709 interfaces = null; // set in initialize() | |
| 710 methods = null; // set in initialize() | |
| 711 members = null; // set in initialize() | |
| 712 | |
| 713 } catch (Exception e) { | |
| 714 failedConstraint(7,false,stack,id.toString(),e.getMessage()); | |
| 715 throw new CompilerError(""); | |
| 716 } | |
| 717 } | |
| 718 | |
| 719 /** | |
| 720 * Initialize this instance. | |
| 721 */ | |
| 722 protected boolean initialize ( Vector directInterfaces, | |
| 723 Vector directMethods, | |
| 724 Vector directMembers, | |
| 725 ContextStack stack, | |
| 726 boolean quiet) { | |
| 727 | |
| 728 boolean result = true; | |
| 729 | |
| 730 // Initialize our arrays... | |
| 731 | |
| 732 if (directInterfaces != null && directInterfaces.size() > 0) { | |
| 733 interfaces = new InterfaceType[directInterfaces.size()]; | |
| 734 directInterfaces.copyInto(interfaces); | |
| 735 } else { | |
| 736 interfaces = new InterfaceType[0]; | |
| 737 } | |
| 738 | |
| 739 if (directMethods != null && directMethods.size() > 0) { | |
| 740 methods = new Method[directMethods.size()]; | |
| 741 directMethods.copyInto(methods); | |
| 742 | |
| 743 // Now set the idl names for each... | |
| 744 | |
| 745 try { | |
| 746 IDLNames.setMethodNames(this, methods,env); | |
| 747 } catch (Exception e) { | |
| 748 failedConstraint(13,quiet,stack,getQualifiedName(),e.getMessage()); | |
| 749 result = false; | |
| 750 } | |
| 751 | |
| 752 } else { | |
| 753 methods = new Method[0]; | |
| 754 } | |
| 755 | |
| 756 if (directMembers != null && directMembers.size() > 0) { | |
| 757 members = new Member[directMembers.size()]; | |
| 758 directMembers.copyInto(members); | |
| 759 | |
| 760 // If we have any un-initialized inner classes, now is the time | |
| 761 // to init them... | |
| 762 | |
| 763 for (int i = 0; i < members.length; i++) { | |
| 764 if (members[i].isInnerClassDeclaration()) { | |
| 765 try { | |
| 766 members[i].init(stack,this); | |
| 767 } catch (CompilerError e) { | |
| 768 return false; | |
| 769 } | |
| 770 } | |
| 771 } | |
| 772 | |
| 773 // Now set the idl names for each... | |
| 774 | |
| 775 try { | |
| 776 IDLNames.setMemberNames(this, members,methods,env); | |
| 777 } catch (Exception e) { | |
| 778 int constraint = classDef.isInterface() ? 19 : 20; | |
| 779 failedConstraint(constraint,quiet,stack,getQualifiedName(),e.getMessage()); | |
| 780 result = false; | |
| 781 } | |
| 782 | |
| 783 } else { | |
| 784 members = new Member[0]; | |
| 785 } | |
| 786 | |
| 787 // Set our repositoryID... | |
| 788 | |
| 789 if (result) { | |
| 790 result = setRepositoryID(); | |
| 791 } | |
| 792 | |
| 793 return result; | |
| 794 } | |
| 795 | |
| 796 /* | |
| 797 * Return Type or null if error. classDef may be null. | |
| 798 */ | |
| 799 protected static Type makeType (sun.tools.java.Type theType, | |
| 800 ClassDefinition classDef, | |
| 801 ContextStack stack) { | |
| 802 | |
| 803 if (stack.anyErrors()) return null; | |
| 804 | |
| 805 // See if we can find this type in the cache. If so, return it... | |
| 806 | |
| 807 String key = theType.toString(); | |
| 808 | |
| 809 Type result = getType(key,stack); | |
| 810 | |
| 811 if (result != null) { | |
| 812 return result; | |
| 813 } | |
| 814 | |
| 815 // Gotta try with context... | |
| 816 | |
| 817 result = getType(key + stack.getContextCodeString(),stack); | |
| 818 | |
| 819 if (result != null) { | |
| 820 return result; | |
| 821 } | |
| 822 | |
| 823 // Gotta map it... | |
| 824 | |
| 825 BatchEnvironment env = stack.getEnv(); | |
| 826 int typeCode = theType.getTypeCode(); | |
| 827 switch (typeCode) { | |
| 828 case TC_BOOLEAN: | |
| 829 case TC_BYTE: | |
| 830 case TC_CHAR: | |
| 831 case TC_SHORT: | |
| 832 case TC_INT: | |
| 833 case TC_LONG: | |
| 834 case TC_FLOAT: | |
| 835 case TC_DOUBLE: | |
| 836 { | |
| 837 // Primitive... | |
| 838 | |
| 839 result = PrimitiveType.forPrimitive(theType,stack); | |
| 840 break; | |
| 841 } | |
| 842 | |
| 843 case TC_ARRAY: | |
| 844 { | |
| 845 // Array. | |
| 846 | |
| 847 result = ArrayType.forArray(theType,stack); | |
| 848 break; | |
| 849 } | |
| 850 | |
| 851 case TC_CLASS: | |
| 852 { | |
| 853 try { | |
| 854 // First, make sure we have the class definition... | |
| 855 | |
| 856 ClassDefinition theClass = classDef; | |
| 857 | |
| 858 if (theClass == null) { | |
| 859 theClass = env.getClassDeclaration(theType).getClassDefinition(env); | |
| 860 } | |
| 861 | |
| 862 // Is it an interface or a class? | |
| 863 | |
| 864 if (theClass.isInterface()) { | |
| 865 | |
| 866 // An interface. Is it a special case? | |
| 867 | |
| 868 result = SpecialInterfaceType.forSpecial(theClass,stack); | |
| 869 | |
| 870 if (result == null) { | |
| 871 | |
| 872 // No, does it implement java.rmi.Remote? | |
| 873 | |
| 874 if (env.defRemote.implementedBy(env,theClass.getClassDeclaration())) { | |
| 875 | |
| 876 // Yep, so just see if we can create an instance of RemoteType | |
| 877 // from it... | |
| 878 | |
| 879 boolean parentIsValue = stack.isParentAValue(); | |
| 880 result = RemoteType.forRemote(theClass,stack,parentIsValue); | |
| 881 | |
| 882 // If we did not succeed AND we are in a value context, then | |
| 883 // go ahead and make an NC type out of it... | |
| 884 | |
| 885 if (result == null && parentIsValue) { | |
| 886 result = NCInterfaceType.forNCInterface(theClass,stack); | |
| 887 } | |
| 888 } else { | |
| 889 | |
| 890 // Nope, is it an AbstractType? | |
| 891 | |
| 892 result = AbstractType.forAbstract(theClass,stack,true); | |
| 893 | |
| 894 if (result == null) { | |
| 895 | |
| 896 // No, so treat it as a non-conforming interface type... | |
| 897 | |
| 898 result = NCInterfaceType.forNCInterface(theClass,stack); | |
| 899 } | |
| 900 } | |
| 901 } | |
| 902 } else { | |
| 903 | |
| 904 // A class. Is it a special case? | |
| 905 | |
| 906 result = SpecialClassType.forSpecial(theClass,stack); | |
| 907 | |
| 908 if (result == null) { | |
| 909 | |
| 910 ClassDeclaration classDecl = theClass.getClassDeclaration(); | |
| 911 | |
| 912 // Nope, does it implement java.rmi.Remote? | |
| 913 | |
| 914 if (env.defRemote.implementedBy(env,classDecl)) { | |
| 915 | |
| 916 // Yep, so just see if we can create an instance of | |
| 917 // ImplementationType from it... | |
| 918 | |
| 919 boolean parentIsValue = stack.isParentAValue(); | |
| 920 result = ImplementationType.forImplementation(theClass,stack,parentIsValue); | |
| 921 | |
| 922 // If we did not succeed AND inValue is true, then | |
| 923 // go ahead and make an NC type out of it... | |
| 924 | |
| 925 if (result == null && parentIsValue) { | |
| 926 result = NCClassType.forNCClass(theClass,stack); | |
| 927 } | |
| 928 } else { | |
| 929 | |
| 930 // No, does it implement Serializable? | |
| 931 | |
| 932 if (env.defSerializable.implementedBy(env,classDecl)) { | |
| 933 | |
| 934 // Yep, so just see if we can create an instance of ValueType | |
| 935 // from it... | |
| 936 | |
| 937 result = ValueType.forValue(theClass,stack,true); | |
| 938 } | |
| 939 | |
| 940 if (result == null) { | |
| 941 | |
| 942 // Treat it as a non-conforming class type... | |
| 943 | |
| 944 result = NCClassType.forNCClass(theClass,stack); | |
| 945 } | |
| 946 } | |
| 947 } | |
| 948 } | |
| 949 } catch (ClassNotFound e) { | |
| 950 classNotFound(stack,e); | |
| 951 } | |
| 952 break; | |
| 953 } | |
| 954 | |
| 955 default: throw new CompilerError("Unknown typecode (" + typeCode + ") for " + theType.getTypeSignature()); | |
| 956 } | |
| 957 | |
| 958 return result; | |
| 959 } | |
| 960 | |
| 961 /* | |
| 962 * Check if exception is RemoteException or one of its parents. | |
| 963 */ | |
| 964 public static boolean isRemoteException (ClassType ex, | |
| 965 BatchEnvironment env) { | |
| 966 sun.tools.java.Type exceptionType = ex.getClassDeclaration().getType(); | |
| 967 | |
| 968 if (exceptionType.equals(env.typeRemoteException) || | |
| 969 exceptionType.equals(env.typeIOException) || | |
| 970 exceptionType.equals(env.typeException) || | |
| 971 exceptionType.equals(env.typeThrowable)) { | |
| 972 | |
| 973 return true; | |
| 974 } | |
| 975 return false; | |
| 976 } | |
| 977 | |
| 978 /* | |
| 979 * Check if method is conforming. | |
| 980 */ | |
| 981 protected boolean isConformingRemoteMethod (Method method, boolean quiet) | |
| 982 throws ClassNotFound { | |
| 983 | |
| 984 // Do we have one exception that is RemoteException or | |
| 985 // a superclass of RemoteException? | |
| 986 | |
| 987 boolean haveRemote = false; | |
| 988 ClassType[] exceptions = method.getExceptions(); | |
| 989 | |
| 990 for (int i = 0; i < exceptions.length; i++) { | |
| 991 | |
| 992 // Is it a conforming exception? | |
| 993 | |
| 994 if (isRemoteException(exceptions[i],env)) { | |
| 995 | |
| 996 // Got it. | |
| 997 | |
| 998 haveRemote = true; | |
| 999 break; | |
| 1000 } | |
| 1001 } | |
| 1002 | |
| 1003 // Do we have our exception? | |
| 1004 | |
| 1005 if (!haveRemote) { | |
| 1006 | |
| 1007 // No, so report failure... | |
| 1008 | |
| 1009 failedConstraint(5,quiet,stack,method.getEnclosing(), method.toString()); | |
| 1010 } | |
| 1011 | |
| 1012 // Are any of the arguments exceptions which implement IDLEntity? | |
| 1013 // If so, report failure... | |
| 1014 | |
| 1015 boolean noIDLEntity = !isIDLEntityException(method.getReturnType(),method,quiet); | |
| 1016 if (noIDLEntity) { | |
| 1017 Type[] args = method.getArguments(); | |
| 1018 for (int i = 0; i < args.length; i++) { | |
| 1019 if (isIDLEntityException(args[i],method,quiet)) { | |
| 1020 noIDLEntity = false; | |
| 1021 break; | |
| 1022 } | |
| 1023 } | |
| 1024 } | |
| 1025 | |
| 1026 return (haveRemote && noIDLEntity); | |
| 1027 } | |
| 1028 | |
| 1029 protected boolean isIDLEntityException(Type type, CompoundType.Method method,boolean quiet) | |
| 1030 throws ClassNotFound { | |
| 1031 if (type.isArray()) { | |
| 1032 type = type.getElementType(); | |
| 1033 } | |
| 1034 if (type.isCompound()){ | |
| 1035 if (((CompoundType)type).isIDLEntityException()) { | |
| 1036 failedConstraint(18,quiet,stack,method.getEnclosing(), method.toString()); | |
| 1037 return true; | |
| 1038 } | |
| 1039 } | |
| 1040 return false; | |
| 1041 } | |
| 1042 | |
| 1043 /** | |
| 1044 * Convert all invalid types to valid ones. | |
| 1045 */ | |
| 1046 protected void swapInvalidTypes () { | |
| 1047 | |
| 1048 // Walk all interfaces and check them... | |
| 1049 | |
| 1050 for (int i = 0; i < interfaces.length; i++) { | |
| 1051 if (interfaces[i].getStatus() != STATUS_VALID) { | |
| 1052 interfaces[i] = (InterfaceType)getValidType(interfaces[i]); | |
| 1053 } | |
| 1054 } | |
| 1055 | |
| 1056 // Update methods... | |
| 1057 | |
| 1058 for (int i = 0; i < methods.length; i++) { | |
| 1059 methods[i].swapInvalidTypes(); | |
| 1060 } | |
| 1061 | |
| 1062 // Update members... | |
| 1063 | |
| 1064 for (int i = 0; i < members.length; i++) { | |
| 1065 members[i].swapInvalidTypes(); | |
| 1066 } | |
| 1067 } | |
| 1068 | |
| 1069 /* | |
| 1070 * Add matching types to list. Return true if this type has not | |
| 1071 * been previously checked, false otherwise. | |
| 1072 */ | |
| 1073 protected boolean addTypes (int typeCodeFilter, | |
| 1074 HashSet checked, | |
| 1075 Vector matching) { | |
| 1076 | |
| 1077 // Check self. | |
| 1078 | |
| 1079 boolean result = super.addTypes(typeCodeFilter,checked,matching); | |
| 1080 | |
| 1081 // Have we been checked before? | |
| 1082 | |
| 1083 if (result) { | |
| 1084 | |
| 1085 // Nope, so walk parent(s) and check them... | |
| 1086 | |
| 1087 ClassType parent = getSuperclass(); | |
| 1088 | |
| 1089 if (parent != null) { | |
| 1090 parent.addTypes(typeCodeFilter,checked,matching); | |
| 1091 } | |
| 1092 | |
| 1093 // Walk all interfaces and check them... | |
| 1094 | |
| 1095 //if (interfaces == null) System.out.println("NULL for " +getQualifiedName() + " interfaces"); | |
| 1096 for (int i = 0; i < interfaces.length; i++) { | |
| 1097 | |
| 1098 // Now recurse and add it and any referenced types... | |
| 1099 | |
| 1100 //if (interfaces[i] == null) System.out.println("NULL for " +getQualifiedName() + " interfaces[" + i + "]"); | |
| 1101 interfaces[i].addTypes(typeCodeFilter,checked,matching); | |
| 1102 } | |
| 1103 | |
| 1104 // Walk all methods and check arguments... | |
| 1105 | |
| 1106 //if (methods == null) System.out.println("NULL for " +getQualifiedName() + " methods"); | |
| 1107 for (int i = 0; i < methods.length; i++) { | |
| 1108 | |
| 1109 // Add return type... | |
| 1110 //if (methods[i] == null) System.out.println("NULL for " +getQualifiedName() + " methods[" + i + "]"); | |
| 1111 //if (methods[i].getReturnType() == null) System.out.println("NULL for " +getQualifiedName() + methods[i]); | |
| 1112 methods[i].getReturnType().addTypes(typeCodeFilter,checked,matching); | |
| 1113 | |
| 1114 // Add args... | |
| 1115 | |
| 1116 Type[] args = methods[i].getArguments(); | |
| 1117 //if (args == null) System.out.println("NULL for " + getQualifiedName() + " args"); | |
| 1118 | |
| 1119 for (int j = 0; j < args.length; j++) { | |
| 1120 | |
| 1121 Type arg = args[j]; | |
| 1122 //if (arg == null) System.out.println("NULL for " + getQualifiedName() + " arg[" +j+"]"); | |
| 1123 | |
| 1124 // Add argument... | |
| 1125 | |
| 1126 arg.addTypes(typeCodeFilter,checked,matching); | |
| 1127 } | |
| 1128 | |
| 1129 // Add exceptions... | |
| 1130 | |
| 1131 ClassType[] exceptions = methods[i].getExceptions(); | |
| 1132 //if (exceptions == null) System.out.println("NULL for " + getQualifiedName() + " exceptions"); | |
| 1133 | |
| 1134 for (int j = 0; j < exceptions.length; j++) { | |
| 1135 | |
| 1136 ClassType ex = exceptions[j]; | |
| 1137 | |
| 1138 // Add argument... | |
| 1139 | |
| 1140 ex.addTypes(typeCodeFilter,checked,matching); | |
| 1141 } | |
| 1142 } | |
| 1143 | |
| 1144 // Walk all members and add em... | |
| 1145 | |
| 1146 //if (members == null) System.out.println("NULL for " +getQualifiedName() + " members"); | |
| 1147 for (int i = 0; i < members.length; i++) { | |
| 1148 //if (members[i] == null) System.out.println("NULL for " +getQualifiedName() + " members[" + i + "]"); | |
| 1149 Type cType = members[i].getType(); | |
| 1150 //if (cType == null) System.out.println("NULL for " + getQualifiedName() + " cType"); | |
| 1151 | |
| 1152 // Add it... | |
| 1153 | |
| 1154 cType.addTypes(typeCodeFilter,checked,matching); | |
| 1155 } | |
| 1156 } | |
| 1157 | |
| 1158 return result; | |
| 1159 } | |
| 1160 | |
| 1161 /* | |
| 1162 * Return true if theType is a conforming constant type. | |
| 1163 */ | |
| 1164 private boolean isConformingConstantType (MemberDefinition member) { | |
| 1165 return isConformingConstantType(member.getType(),member); | |
| 1166 } | |
| 1167 | |
| 1168 /* | |
| 1169 * Return true if theType is a conforming constant type. | |
| 1170 */ | |
| 1171 private boolean isConformingConstantType (sun.tools.java.Type theType,MemberDefinition member) { | |
| 1172 | |
| 1173 // Constraint 3: Constants must be either primitives or String. | |
| 1174 | |
| 1175 boolean result = true; | |
| 1176 int typeCode = theType.getTypeCode(); | |
| 1177 switch (typeCode) { | |
| 1178 case TC_BOOLEAN: | |
| 1179 case TC_BYTE: | |
| 1180 case TC_CHAR: | |
| 1181 case TC_SHORT: | |
| 1182 case TC_INT: | |
| 1183 case TC_LONG: | |
| 1184 case TC_FLOAT: | |
| 1185 case TC_DOUBLE: // Primitive, so OK... | |
| 1186 { | |
| 1187 break; | |
| 1188 } | |
| 1189 | |
| 1190 case TC_CLASS: // Must be java.lang.String | |
| 1191 { | |
| 1192 if (theType.getClassName() != idJavaLangString) { | |
| 1193 failedConstraint(3,false,stack,member.getClassDefinition(),member.getName()); | |
| 1194 result = false; | |
| 1195 } | |
| 1196 break; | |
| 1197 } | |
| 1198 | |
| 1199 case TC_ARRAY: // Array constants are not allowed. | |
| 1200 { | |
| 1201 failedConstraint(3,false,stack,member.getClassDefinition(),member.getName()); | |
| 1202 result = false; | |
| 1203 break; | |
| 1204 } | |
| 1205 | |
| 1206 default: | |
| 1207 throw new Error("unexpected type code: " + typeCode); | |
| 1208 } | |
| 1209 | |
| 1210 return result; | |
| 1211 } | |
| 1212 | |
| 1213 | |
| 1214 /* | |
| 1215 * Update any method from 'currentMethods' which is defined in a | |
| 1216 * parent class so that it's 'declaredBy' field specifies the | |
| 1217 * parent. | |
| 1218 * @param current The class or interface to gather methods from. | |
| 1219 * @param currentMethods The list into which to put the methods. | |
| 1220 * for contraint 6. | |
| 1221 * @param quiet true if silent errors. | |
| 1222 * @param stack the context stack. | |
| 1223 * @return currentMethods or null if failed a constraint check. | |
| 1224 */ | |
| 1225 protected Vector updateParentClassMethods(ClassDefinition current, | |
| 1226 Vector currentMethods, | |
| 1227 boolean quiet, | |
| 1228 ContextStack stack) | |
| 1229 throws ClassNotFound { | |
| 1230 | |
| 1231 ClassDeclaration parentDecl = current.getSuperClass(env); | |
| 1232 | |
| 1233 while (parentDecl != null) { | |
| 1234 | |
| 1235 ClassDefinition parentDef = parentDecl.getClassDefinition(env); | |
| 1236 Identifier currentID = parentDecl.getName(); | |
| 1237 | |
| 1238 if ( currentID == idJavaLangObject ) break; | |
| 1239 | |
| 1240 // Walk all members of this class and update any that | |
| 1241 // already exist in currentMethods... | |
| 1242 | |
| 1243 for (MemberDefinition member = parentDef.getFirstMember(); | |
| 1244 member != null; | |
| 1245 member = member.getNextMember()) { | |
| 1246 | |
| 1247 if (member.isMethod() && | |
| 1248 !member.isInitializer() && | |
| 1249 !member.isConstructor() && | |
| 1250 !member.isPrivate()) { | |
| 1251 | |
| 1252 // It's a method. Is it valid? | |
| 1253 | |
| 1254 Method method; | |
| 1255 try { | |
| 1256 method = new Method((CompoundType)this,member,quiet,stack); | |
| 1257 } catch (Exception e) { | |
| 1258 // Don't report anything here, it's already been reported... | |
| 1259 return null; | |
| 1260 } | |
| 1261 | |
| 1262 // Have we already seen it? | |
| 1263 | |
| 1264 int index = currentMethods.indexOf(method); | |
| 1265 if (index >= 0) { | |
| 1266 | |
| 1267 // Yes, so update it... | |
| 1268 | |
| 1269 Method currentMethod = (Method)currentMethods.elementAt(index); | |
| 1270 currentMethod.setDeclaredBy(currentID); | |
| 1271 } | |
| 1272 else currentMethods.addElement(method); | |
| 1273 } | |
| 1274 } | |
| 1275 | |
| 1276 // Update parent and keep walking up the chain... | |
| 1277 | |
| 1278 parentDecl = parentDef.getSuperClass(env); | |
| 1279 } | |
| 1280 | |
| 1281 return currentMethods; | |
| 1282 } | |
| 1283 | |
| 1284 /* | |
| 1285 * Add all of the public and protected methods defined in | |
| 1286 * current (other than initializers) to allMethods. If a sub-interface | |
| 1287 * re-declares an inherited method, it will not be added. | |
| 1288 * @param current The class or interface to gather methods from. | |
| 1289 * @param directMethods The list into which to put the methods. | |
| 1290 * @param noMultiInheritedMethods A flag to enable/disable checking | |
| 1291 * for contraint 6. | |
| 1292 * @param quiet true if silent errors. | |
| 1293 * @param stack the context stack. | |
| 1294 * @return directMethods or null if failed a constraint check. | |
| 1295 */ | |
| 1296 protected Vector addAllMethods (ClassDefinition current, Vector directMethods, | |
| 1297 boolean noMultiInheritedMethods, | |
| 1298 boolean quiet, | |
| 1299 ContextStack stack) | |
| 1300 throws ClassNotFound { | |
| 1301 | |
| 1302 // Constraint 6: Multiple inherited interfaces may not | |
| 1303 // declare the same method. | |
| 1304 | |
| 1305 ClassDeclaration[] interfaces = current.getInterfaces(); | |
| 1306 | |
| 1307 // We want to add members starting at the _least_ derived | |
| 1308 // interfaces. To do so, recurse until we have no more | |
| 1309 // interfaces... | |
| 1310 | |
| 1311 for (int i = 0; i < interfaces.length; i++) { | |
| 1312 | |
| 1313 Vector result = addAllMethods(interfaces[i].getClassDefinition(env), | |
| 1314 directMethods, | |
| 1315 noMultiInheritedMethods,quiet,stack); | |
| 1316 if (result == null) { | |
| 1317 return null; | |
| 1318 } | |
| 1319 } | |
| 1320 | |
| 1321 // Walk all members of this interface, adding any unique methods | |
| 1322 // other than initializers and private methods... | |
| 1323 | |
| 1324 for (MemberDefinition member = current.getFirstMember(); | |
| 1325 member != null; | |
| 1326 member = member.getNextMember()) | |
| 1327 { | |
| 1328 if (member.isMethod() && | |
| 1329 !member.isInitializer() && | |
| 1330 !member.isPrivate()) { | |
| 1331 | |
| 1332 // It's a method. Is it valid? | |
| 1333 | |
| 1334 Method method; | |
| 1335 try { | |
| 1336 method = new Method((CompoundType)this,member,quiet,stack); | |
| 1337 } catch (Exception e) { | |
| 1338 // Don't report anything here, it's already been reported... | |
| 1339 return null; | |
| 1340 } | |
| 1341 | |
| 1342 // Have we already seen it? | |
| 1343 | |
| 1344 if (!directMethods.contains(method)) { | |
| 1345 | |
| 1346 // Nope, so add it... | |
| 1347 | |
| 1348 directMethods.addElement(method); | |
| 1349 | |
| 1350 } else { | |
| 1351 | |
| 1352 // Yes. This is an error unless we are looking at the | |
| 1353 // target interface (or this is a ValueType). Are we? | |
| 1354 | |
| 1355 if (noMultiInheritedMethods && current != classDef && | |
| 1356 !stack.isParentAValue() && !stack.getContext().isValue()) { | |
| 1357 | |
| 1358 // Nope. Say so and signal error by returning null.. | |
| 1359 | |
| 1360 Method existingMethod = (Method) directMethods.elementAt(directMethods.indexOf(method)); | |
| 1361 ClassDefinition existingMemberClassDef = existingMethod.getMemberDefinition().getClassDefinition(); | |
| 1362 | |
| 1363 // There are more legal cases to consider here. | |
| 1364 // If the two methods belong to interfaces that inherit from each other | |
| 1365 // then it is just a redefinition which is legal. | |
| 1366 if ( current != existingMemberClassDef && | |
| 1367 ! inheritsFrom(current, existingMemberClassDef) && | |
| 1368 ! inheritsFrom(existingMemberClassDef, current)) | |
| 1369 { | |
| 1370 //Identifier int1 = existingMethod.getEnclosing().getIdentifier(); | |
| 1371 //Identifier int2 = current.getName(); | |
| 1372 //String message = int1.toString() + " and " + int2.toString(); | |
| 1373 String message = existingMemberClassDef.getName() + " and " + current.getName(); | |
| 1374 failedConstraint(6,quiet,stack,classDef,message,method); | |
| 1375 return null; | |
| 1376 } | |
| 1377 } | |
| 1378 | |
| 1379 // Bug fix 5014329 | |
| 1380 | |
| 1381 // find a matching method. | |
| 1382 int index = directMethods.indexOf(method); | |
| 1383 Method other = (Method) directMethods.get(index); | |
| 1384 | |
| 1385 // merge the two methods, such that the new method | |
| 1386 // will contain only those exception that can be thrown | |
| 1387 // by both these methods, not just one of them. | |
| 1388 Method newMethod = method.mergeWith(other); | |
| 1389 | |
| 1390 // replace the old method with the new. | |
| 1391 directMethods.set(index, newMethod); | |
| 1392 } | |
| 1393 } | |
| 1394 } | |
| 1395 | |
| 1396 return directMethods; | |
| 1397 } | |
| 1398 | |
| 1399 // This should really be a method on ClassDefinition, but it takes too long to change the shared source. | |
| 1400 // Works for both, classes and interfaces. | |
| 1401 protected boolean inheritsFrom(ClassDefinition def, ClassDefinition otherDef) { | |
| 1402 if (def == otherDef) | |
| 1403 return true; | |
| 1404 | |
| 1405 ClassDefinition superDef; | |
| 1406 if (def.getSuperClass() != null) { | |
| 1407 superDef = def.getSuperClass().getClassDefinition(); | |
| 1408 if (inheritsFrom(superDef, otherDef)) | |
| 1409 return true; | |
| 1410 } | |
| 1411 | |
| 1412 ClassDeclaration[] interfaces = def.getInterfaces(); | |
| 1413 for (int i=0; i<interfaces.length; i++) { | |
| 1414 superDef = interfaces[i].getClassDefinition(); | |
| 1415 if (inheritsFrom(superDef, otherDef)) | |
| 1416 return true; | |
| 1417 } | |
| 1418 return false; | |
| 1419 } | |
| 1420 | |
| 1421 /* | |
| 1422 * Add all of the interfaces implemented directly by current | |
| 1423 * to the list. Returns null if any are non-conforming. | |
| 1424 */ | |
| 1425 protected Vector addRemoteInterfaces (Vector list, | |
| 1426 boolean allowNonConforming, | |
| 1427 ContextStack stack) throws ClassNotFound { | |
| 1428 | |
| 1429 // Add all the interfaces of current... | |
| 1430 | |
| 1431 ClassDefinition theInterface = getClassDefinition(); | |
| 1432 ClassDeclaration[] interfaces = theInterface.getInterfaces(); | |
| 1433 | |
| 1434 stack.setNewContextCode(ContextStack.IMPLEMENTS); | |
| 1435 | |
| 1436 for (int i = 0; i < interfaces.length; i++) { | |
| 1437 | |
| 1438 ClassDefinition def = interfaces[i].getClassDefinition(env); | |
| 1439 | |
| 1440 // Is it a SpecialInterfaceType... | |
| 1441 | |
| 1442 InterfaceType it = SpecialInterfaceType.forSpecial(def,stack);; | |
| 1443 | |
| 1444 if (it == null) { | |
| 1445 | |
| 1446 // No, is it Remote? | |
| 1447 | |
| 1448 if (env.defRemote.implementedBy(env, interfaces[i])) { | |
| 1449 | |
| 1450 // Yes, so it must be a RemoteType. | |
| 1451 | |
| 1452 it = RemoteType.forRemote(def,stack,false); | |
| 1453 | |
| 1454 } else { | |
| 1455 | |
| 1456 // Then try Abstract... | |
| 1457 | |
| 1458 it = AbstractType.forAbstract(def,stack,true); | |
| 1459 | |
| 1460 if (it == null && allowNonConforming) { | |
| 1461 | |
| 1462 // Must be non-conforming... | |
| 1463 | |
| 1464 it = NCInterfaceType.forNCInterface(def,stack); | |
| 1465 } | |
| 1466 } | |
| 1467 } | |
| 1468 | |
| 1469 if (it != null) { | |
| 1470 list.addElement(it); | |
| 1471 } else { | |
| 1472 return null; | |
| 1473 } | |
| 1474 } | |
| 1475 | |
| 1476 return list; | |
| 1477 } | |
| 1478 | |
| 1479 /* | |
| 1480 * Add all of the interfaces implemented directly by current | |
| 1481 * to the list. | |
| 1482 */ | |
| 1483 protected Vector addNonRemoteInterfaces (Vector list, | |
| 1484 ContextStack stack) throws ClassNotFound { | |
| 1485 | |
| 1486 // Add all the interfaces of current... | |
| 1487 | |
| 1488 ClassDefinition theInterface = getClassDefinition(); | |
| 1489 ClassDeclaration[] interfaces = theInterface.getInterfaces(); | |
| 1490 | |
| 1491 stack.setNewContextCode(ContextStack.IMPLEMENTS); | |
| 1492 | |
| 1493 for (int i = 0; i < interfaces.length; i++) { | |
| 1494 | |
| 1495 ClassDefinition def = interfaces[i].getClassDefinition(env); | |
| 1496 | |
| 1497 // First try SpecialInterfaceType... | |
| 1498 | |
| 1499 InterfaceType it = SpecialInterfaceType.forSpecial(def,stack); | |
| 1500 | |
| 1501 if (it == null) { | |
| 1502 | |
| 1503 // Then try AbstractType... | |
| 1504 | |
| 1505 it = AbstractType.forAbstract(def,stack,true); | |
| 1506 | |
| 1507 if (it == null) { | |
| 1508 | |
| 1509 // Then try NCInterfaceType... | |
| 1510 | |
| 1511 it = NCInterfaceType.forNCInterface(def,stack); | |
| 1512 } | |
| 1513 } | |
| 1514 | |
| 1515 if (it != null) { | |
| 1516 list.addElement(it); | |
| 1517 } else { | |
| 1518 return null; | |
| 1519 } | |
| 1520 } | |
| 1521 | |
| 1522 return list; | |
| 1523 } | |
| 1524 | |
| 1525 | |
| 1526 /* | |
| 1527 * Walk self, adding constants and data members. | |
| 1528 * @return true if all conform, false otherwise. | |
| 1529 */ | |
| 1530 protected boolean addAllMembers (Vector allMembers, | |
| 1531 boolean onlyConformingConstants, // AND inner classes. | |
| 1532 boolean quiet, | |
| 1533 ContextStack stack) { | |
| 1534 | |
| 1535 boolean result = true; | |
| 1536 | |
| 1537 // Walk all members of this interface... | |
| 1538 | |
| 1539 for (MemberDefinition member = getClassDefinition().getFirstMember(); | |
| 1540 member != null && result; | |
| 1541 member = member.getNextMember()) | |
| 1542 { | |
| 1543 if (!member.isMethod()) { | |
| 1544 | |
| 1545 try { | |
| 1546 String value = null; | |
| 1547 | |
| 1548 // Prod it to setValue if it is a constant... | |
| 1549 | |
| 1550 member.getValue(env); | |
| 1551 | |
| 1552 // Get the value, if any... | |
| 1553 | |
| 1554 Node node = member.getValue(); | |
| 1555 | |
| 1556 if (node != null) { | |
| 1557 // We don't want to change the code in CharExpression, | |
| 1558 // which is shared among tools, to return the right string | |
| 1559 // in case the type is char, so we treat it special here. | |
| 1560 if (member.getType().getTypeCode() == TC_CHAR) { | |
| 1561 Integer intValue = (Integer)((IntegerExpression)node).getValue(); | |
| 1562 value = "L'" + String.valueOf((char)intValue.intValue()) + "'"; | |
| 1563 } else { | |
| 1564 value = node.toString(); | |
| 1565 } | |
| 1566 } | |
| 1567 | |
| 1568 // Are we supposed to allow only conforming constants? | |
| 1569 | |
| 1570 if (onlyConformingConstants && member.getInnerClass() == null) { | |
| 1571 | |
| 1572 // Yep, so check it... | |
| 1573 | |
| 1574 if (value == null || !isConformingConstantType(member)) { | |
| 1575 failedConstraint(3,quiet,stack,member.getClassDefinition(),member.getName()); | |
| 1576 result = false; | |
| 1577 break; | |
| 1578 } | |
| 1579 } | |
| 1580 | |
| 1581 // Make member and add to list... | |
| 1582 | |
| 1583 try { | |
| 1584 Member newMember = new Member(member,value,stack,this); | |
| 1585 allMembers.addElement(newMember); | |
| 1586 } catch (CompilerError e) { | |
| 1587 result = false; | |
| 1588 } | |
| 1589 | |
| 1590 } catch (ClassNotFound e) { | |
| 1591 classNotFound(stack,e); | |
| 1592 result = false; | |
| 1593 } | |
| 1594 } | |
| 1595 } | |
| 1596 | |
| 1597 return result; | |
| 1598 } | |
| 1599 /* | |
| 1600 * Walk self, adding constants. | |
| 1601 * @return true if all conform, false otherwise. | |
| 1602 */ | |
| 1603 protected boolean addConformingConstants (Vector allMembers, | |
| 1604 boolean quiet, | |
| 1605 ContextStack stack) { | |
| 1606 | |
| 1607 boolean result = true; | |
| 1608 | |
| 1609 // Walk all members of this interface... | |
| 1610 | |
| 1611 for (MemberDefinition member = getClassDefinition().getFirstMember(); | |
| 1612 member != null && result; | |
| 1613 member = member.getNextMember()) | |
| 1614 { | |
| 1615 if (!member.isMethod()) { | |
| 1616 | |
| 1617 try { | |
| 1618 String value = null; | |
| 1619 | |
| 1620 // Prod it to setValue if it is a constant... | |
| 1621 | |
| 1622 member.getValue(env); | |
| 1623 | |
| 1624 // Get the value, if any... | |
| 1625 | |
| 1626 Node node = member.getValue(); | |
| 1627 | |
| 1628 if (node != null) { | |
| 1629 value = node.toString(); | |
| 1630 } | |
| 1631 | |
| 1632 | |
| 1633 // Is it a constant? | |
| 1634 | |
| 1635 if (value != null) { | |
| 1636 | |
| 1637 // Yes, is it conforming? | |
| 1638 | |
| 1639 if (!isConformingConstantType(member)) { | |
| 1640 failedConstraint(3,quiet,stack,member.getClassDefinition(),member.getName()); | |
| 1641 result = false; | |
| 1642 break; | |
| 1643 } | |
| 1644 | |
| 1645 // Yes, so make a member and add to list... | |
| 1646 | |
| 1647 try { | |
| 1648 Member newMember = new Member(member,value,stack,this); | |
| 1649 allMembers.addElement(newMember); | |
| 1650 } catch (CompilerError e) { | |
| 1651 result = false; | |
| 1652 } | |
| 1653 } | |
| 1654 } catch (ClassNotFound e) { | |
| 1655 classNotFound(stack,e); | |
| 1656 result = false; | |
| 1657 } | |
| 1658 } | |
| 1659 } | |
| 1660 | |
| 1661 return result; | |
| 1662 } | |
| 1663 | |
| 1664 protected ValueType[] getMethodExceptions (MemberDefinition member, | |
| 1665 boolean quiet, | |
| 1666 ContextStack stack) throws Exception { | |
| 1667 | |
| 1668 boolean result = true; | |
| 1669 stack.setNewContextCode(ContextStack.METHOD_EXCEPTION); | |
| 1670 ClassDeclaration[] except = member.getExceptions(env); | |
| 1671 ValueType[] exceptions = new ValueType[except.length]; | |
| 1672 | |
| 1673 try { | |
| 1674 for (int i = 0; i < except.length; i++) { | |
| 1675 ClassDefinition theClass = except[i].getClassDefinition(env); | |
| 1676 try { | |
| 1677 ValueType type = ValueType.forValue(theClass,stack,false); | |
| 1678 if (type != null) { | |
| 1679 exceptions[i] = type; | |
| 1680 } else { | |
| 1681 result = false; | |
| 1682 } | |
| 1683 } catch (ClassCastException e1) { | |
| 1684 failedConstraint(22,quiet,stack,getQualifiedName()); | |
| 1685 throw new CompilerError("Method: exception " + theClass.getName() + " not a class type!"); | |
| 1686 } catch (NullPointerException e2) { | |
| 1687 failedConstraint(23,quiet,stack,getQualifiedName()); | |
| 1688 throw new CompilerError("Method: caught null pointer exception"); | |
| 1689 } | |
| 1690 } | |
| 1691 } catch (ClassNotFound e) { | |
| 1692 classNotFound(quiet,stack,e); | |
| 1693 result = false; | |
| 1694 } | |
| 1695 | |
| 1696 if (!result) { | |
| 1697 throw new Exception(); | |
| 1698 } | |
| 1699 | |
| 1700 // Remove any duplicates (javac seems to allow them, but rmic will | |
| 1701 // generate bad ties)... | |
| 1702 | |
| 1703 int dupCount = 0; | |
| 1704 for (int i = 0; i < exceptions.length; i++) { | |
| 1705 for (int j = 0; j < exceptions.length; j++) { | |
| 1706 if (i != j && exceptions[i] != null && exceptions[i] == exceptions[j]) { | |
| 1707 exceptions[j] = null; | |
| 1708 dupCount++; | |
| 1709 } | |
| 1710 } | |
| 1711 } | |
| 1712 if (dupCount > 0) { | |
| 1713 int offset = 0; | |
| 1714 ValueType[] temp = new ValueType[exceptions.length - dupCount]; | |
| 1715 for (int i = 0; i < exceptions.length; i++) { | |
| 1716 if (exceptions[i] != null) { | |
| 1717 temp[offset++] = exceptions[i]; | |
| 1718 } | |
| 1719 } | |
| 1720 exceptions = temp; | |
| 1721 } | |
| 1722 | |
| 1723 return exceptions; | |
| 1724 } | |
| 1725 | |
| 1726 | |
| 1727 protected static String getVisibilityString (MemberDefinition member) { | |
| 1728 String vis = ""; | |
| 1729 String prefix = ""; | |
| 1730 | |
| 1731 if (member.isPublic()) { | |
| 1732 vis += "public"; | |
| 1733 prefix = " "; | |
| 1734 } else if (member.isProtected()) { | |
| 1735 vis += "protected"; | |
| 1736 prefix = " "; | |
| 1737 } else if (member.isPrivate()) { | |
| 1738 vis += "private"; | |
| 1739 prefix = " "; | |
| 1740 } | |
| 1741 | |
| 1742 if (member.isStatic()) { | |
| 1743 vis += prefix; | |
| 1744 vis += "static"; | |
| 1745 prefix = " "; | |
| 1746 } | |
| 1747 | |
| 1748 if (member.isFinal()) { | |
| 1749 vis += prefix; | |
| 1750 vis += "final"; | |
| 1751 prefix = " "; | |
| 1752 } | |
| 1753 | |
| 1754 return vis; | |
| 1755 } | |
| 1756 | |
| 1757 protected boolean assertNotImpl(Type type, | |
| 1758 boolean quiet, | |
| 1759 ContextStack stack, | |
| 1760 CompoundType enclosing, | |
| 1761 boolean dataMember) { | |
| 1762 | |
| 1763 if (type.isType(TYPE_IMPLEMENTATION)) { | |
| 1764 int constraint = dataMember ? 28 : 21; | |
| 1765 failedConstraint(constraint,quiet,stack,type,enclosing.getName()); | |
| 1766 return false; | |
| 1767 } | |
| 1768 return true; | |
| 1769 } | |
| 1770 | |
| 1771 //_____________________________________________________________________ | |
| 1772 // Inner Class "Method" | |
| 1773 //_____________________________________________________________________ | |
| 1774 | |
| 1775 /** | |
| 1776 * A CompoundType.Method object encapsulates IIOP-specific information | |
| 1777 * about a particular method in the interface represented by the outer | |
| 1778 * instance. | |
| 1779 */ | |
| 1780 public class Method implements ContextElement, Cloneable { | |
| 1781 | |
| 1782 /** | |
| 1783 * Is this method inherited? | |
| 1784 */ | |
| 1785 public boolean isInherited () { | |
| 1786 return declaredBy != enclosing.getIdentifier(); | |
| 1787 } | |
| 1788 | |
| 1789 /** | |
| 1790 * Is this method an attribute? | |
| 1791 * Return true if getAttributeKind != ATTRIBUTE_NONE. | |
| 1792 */ | |
| 1793 public boolean isAttribute () { | |
| 1794 return attributeKind != ATTRIBUTE_NONE; | |
| 1795 } | |
| 1796 | |
| 1797 /** | |
| 1798 * Is this method a read-write attribute? | |
| 1799 */ | |
| 1800 public boolean isReadWriteAttribute () { | |
| 1801 return attributeKind == ATTRIBUTE_IS_RW || | |
| 1802 attributeKind == ATTRIBUTE_GET_RW; | |
| 1803 } | |
| 1804 | |
| 1805 /** | |
| 1806 * Return the attribute kind. | |
| 1807 */ | |
| 1808 public int getAttributeKind() { | |
| 1809 return attributeKind; | |
| 1810 } | |
| 1811 | |
| 1812 /** | |
| 1813 * Return the attribute name. Will be null if | |
| 1814 * attribute kind == ATTRIBUTE_NONE. | |
| 1815 */ | |
| 1816 public String getAttributeName() { | |
| 1817 return attributeName; | |
| 1818 } | |
| 1819 | |
| 1820 /** | |
| 1821 * For kinds ATTRIBUTE_GET_RW or ATTRIBUTE_IS_RW, return | |
| 1822 * the index of the matching ATTRIBUTE_SET method, and | |
| 1823 * vice-versa. For all other cases, return -1. | |
| 1824 */ | |
| 1825 public int getAttributePairIndex() { | |
| 1826 return attributePairIndex; | |
| 1827 } | |
| 1828 | |
| 1829 /** | |
| 1830 * Return context element name. | |
| 1831 */ | |
| 1832 public String getElementName() { | |
| 1833 return memberDef.toString(); | |
| 1834 } | |
| 1835 | |
| 1836 /** | |
| 1837 * Equality check based on method signature. | |
| 1838 */ | |
| 1839 public boolean equals(Object obj) { | |
| 1840 Method other = (Method) obj; | |
| 1841 | |
| 1842 if (getName().equals(other.getName()) && | |
| 1843 arguments.length == other.arguments.length) { | |
| 1844 | |
| 1845 for (int i = 0; i < arguments.length; i++) { | |
| 1846 if (! arguments[i].equals(other.arguments[i])) { | |
| 1847 return false; | |
| 1848 } | |
| 1849 } | |
| 1850 return true; | |
| 1851 } | |
| 1852 return false; | |
| 1853 } | |
| 1854 | |
| 1855 public int hashCode() { | |
| 1856 return getName().hashCode() ^ Arrays.hashCode(arguments); | |
| 1857 } | |
| 1858 | |
| 1859 /** | |
| 1860 * Return a new Method object that is a legal combination of | |
| 1861 * this method object and another one. | |
| 1862 * | |
| 1863 * This requires determining the exceptions declared by the | |
| 1864 * combined method, which must be only those exceptions | |
| 1865 * that may thrown by both of the old methods. | |
| 1866 */ | |
| 1867 public Method mergeWith(Method other) { | |
| 1868 if (!equals(other)) { | |
| 1869 env.error(0, "attempt to merge method failed:", getName(), | |
| 1870 enclosing.getClassDefinition().getName()); | |
| 1871 } | |
| 1872 | |
| 1873 Vector legalExceptions = new Vector(); | |
| 1874 try { | |
| 1875 collectCompatibleExceptions( | |
| 1876 other.exceptions, exceptions, legalExceptions); | |
| 1877 collectCompatibleExceptions( | |
| 1878 exceptions, other.exceptions, legalExceptions); | |
| 1879 } catch (ClassNotFound e) { | |
| 1880 env.error(0, "class.not.found", e.name, | |
| 1881 enclosing.getClassDefinition().getName()); | |
| 1882 return null; | |
| 1883 } | |
| 1884 | |
| 1885 Method merged = (Method) clone(); | |
| 1886 merged.exceptions = new ValueType[legalExceptions.size()]; | |
| 1887 legalExceptions.copyInto(merged.exceptions); | |
| 1888 merged.implExceptions = merged.exceptions; | |
| 1889 | |
| 1890 return merged; | |
| 1891 } | |
| 1892 | |
| 1893 /** | |
| 1894 * Add to the supplied list all exceptions in the "from" array | |
| 1895 * that are subclasses of an exception in the "with" array. | |
| 1896 */ | |
| 1897 private void collectCompatibleExceptions( | |
| 1898 ValueType[] from, ValueType[] with, Vector list) | |
| 1899 throws ClassNotFound { | |
| 1900 | |
| 1901 for (int i = 0; i < from.length; i++) { | |
| 1902 ClassDefinition exceptionDef = from[i].getClassDefinition(); | |
| 1903 if (!list.contains(from[i])) { | |
| 1904 for (int j = 0; j < with.length; j++) { | |
| 1905 if (exceptionDef.subClassOf( | |
| 1906 enclosing.getEnv(), | |
| 1907 with[j].getClassDeclaration())) { | |
| 1908 list.addElement(from[i]); | |
| 1909 break; | |
| 1910 } | |
| 1911 } | |
| 1912 } | |
| 1913 } | |
| 1914 } | |
| 1915 | |
| 1916 /** | |
| 1917 * Return the compound type which contains this method. | |
| 1918 */ | |
| 1919 public CompoundType getEnclosing() { | |
| 1920 return enclosing; | |
| 1921 } | |
| 1922 | |
| 1923 /** | |
| 1924 * Return the identifier for the class or interface which | |
| 1925 * declares this method. | |
| 1926 */ | |
| 1927 public Identifier getDeclaredBy() { | |
| 1928 return declaredBy; | |
| 1929 } | |
| 1930 | |
| 1931 /** | |
| 1932 * Return the visibility (e.g. "public final") of this member. | |
| 1933 */ | |
| 1934 public String getVisibility() { | |
| 1935 return vis; | |
| 1936 } | |
| 1937 | |
| 1938 /** | |
| 1939 * Methods to check various attributes. | |
| 1940 */ | |
| 1941 public boolean isPublic() { | |
| 1942 return memberDef.isPublic(); | |
| 1943 } | |
| 1944 | |
| 1945 public boolean isProtected() { | |
| 1946 return memberDef.isPrivate(); | |
| 1947 } | |
| 1948 | |
| 1949 public boolean isPrivate() { | |
| 1950 return memberDef.isPrivate(); | |
| 1951 } | |
| 1952 | |
| 1953 public boolean isStatic() { | |
| 1954 return memberDef.isStatic(); | |
| 1955 } | |
| 1956 | |
| 1957 /** | |
| 1958 * Return the name of this method. | |
| 1959 */ | |
| 1960 public String getName() { | |
| 1961 return name; | |
| 1962 } | |
| 1963 | |
| 1964 /** | |
| 1965 * IDL_Naming | |
| 1966 * Return the IDL name of this method. | |
| 1967 */ | |
| 1968 public String getIDLName() { | |
| 1969 return idlName; | |
| 1970 } | |
| 1971 | |
| 1972 /** | |
| 1973 * Return the type of this method. | |
| 1974 */ | |
| 1975 public sun.tools.java.Type getType() { | |
| 1976 return memberDef.getType(); | |
| 1977 } | |
| 1978 | |
| 1979 /** | |
| 1980 * Return true if this is a constructor. | |
| 1981 */ | |
| 1982 public boolean isConstructor () { | |
| 1983 return memberDef.isConstructor(); | |
| 1984 } | |
| 1985 | |
| 1986 /** | |
| 1987 * Return true if this is NOT a constructor && is not | |
| 1988 * an attribute. | |
| 1989 */ | |
| 1990 public boolean isNormalMethod () { | |
| 1991 return (!memberDef.isConstructor()) && attributeKind == ATTRIBUTE_NONE; | |
| 1992 } | |
| 1993 | |
| 1994 /** | |
| 1995 * Get the return type of this method. May be null. | |
| 1996 */ | |
| 1997 public Type getReturnType() { | |
| 1998 return returnType; | |
| 1999 } | |
| 2000 | |
| 2001 /** | |
| 2002 * Return the argument types of this method. | |
| 2003 */ | |
| 2004 public Type[] getArguments() { | |
| 2005 return (Type[]) arguments.clone(); | |
| 2006 } | |
| 2007 | |
| 2008 /** | |
| 2009 * Return the names of the argument types of this method. | |
| 2010 */ | |
| 2011 public String[] getArgumentNames() { | |
| 2012 return argumentNames; | |
| 2013 } | |
| 2014 | |
| 2015 /** | |
| 2016 * Return the MemberDefinition from which this method was created. | |
| 2017 */ | |
| 2018 public MemberDefinition getMemberDefinition() { | |
| 2019 return memberDef; | |
| 2020 } | |
| 2021 | |
| 2022 /** | |
| 2023 * Return an array of the exception classes declared to be | |
| 2024 * thrown by this remote method. | |
| 2025 * | |
| 2026 * For methods with the same name and type signature inherited | |
| 2027 * from multiple remote interfaces, the array will contain | |
| 2028 * the set of exceptions declared in all of the interfaces' | |
| 2029 * methods that can be legally thrown in each of them. | |
| 2030 */ | |
| 2031 public ValueType[] getExceptions() { | |
| 2032 return (ValueType[]) exceptions.clone(); | |
| 2033 } | |
| 2034 | |
| 2035 /** | |
| 2036 * Same as getExceptions(), except when method is in an | |
| 2037 * ImplementationType and the exceptions list is narrower. | |
| 2038 */ | |
| 2039 public ValueType[] getImplExceptions() { | |
| 2040 return (ValueType[]) implExceptions.clone(); | |
| 2041 } | |
| 2042 | |
| 2043 /** | |
| 2044 * Return an array containing only those exceptions which | |
| 2045 * need to be caught. Removes java.rmi.RemoteException, | |
| 2046 * java.lang.RuntimeException, java.lang.Error, and their | |
| 2047 * subclasses, then removes any exceptions which are more | |
| 2048 * derived than another in the list. Returns null if no | |
| 2049 * exceptions need to be caught. | |
| 2050 */ | |
| 2051 public ValueType[] getUniqueCatchList(ValueType[] list) { | |
| 2052 ValueType[] result = list; | |
| 2053 int newSize = list.length; | |
| 2054 | |
| 2055 try { | |
| 2056 | |
| 2057 // First, remove RemoteException, RuntimeException, Error, and their subclasses... | |
| 2058 for (int i = 0; i < list.length; i++) { | |
| 2059 ClassDeclaration decl = list[i].getClassDeclaration(); | |
| 2060 if (env.defRemoteException.superClassOf(env, decl) || | |
| 2061 env.defRuntimeException.superClassOf(env, decl) || | |
| 2062 env.defError.superClassOf(env, decl)) { | |
| 2063 list[i] = null; | |
| 2064 newSize--; | |
| 2065 } | |
| 2066 } | |
| 2067 | |
| 2068 // Now remove derived types... | |
| 2069 for (int i = 0; i < list.length; i++) { | |
| 2070 if (list[i] != null) { | |
| 2071 ClassDefinition current = list[i].getClassDefinition(); | |
| 2072 for (int j = 0; j < list.length; j++) { | |
| 2073 if (j != i && list[i] != null && list[j] != null && | |
| 2074 current.superClassOf(env, list[j].getClassDeclaration())) { | |
| 2075 list[j] = null; | |
| 2076 newSize--; | |
| 2077 } | |
| 2078 } | |
| 2079 } | |
| 2080 } | |
| 2081 | |
| 2082 } catch (ClassNotFound e) { | |
| 2083 classNotFound(stack,e); // Report error but do not stop. | |
| 2084 } | |
| 2085 | |
| 2086 // Create new list if we removed anything... | |
| 2087 | |
| 2088 if (newSize < list.length) { | |
| 2089 ValueType[] temp = new ValueType[newSize]; | |
| 2090 int offset = 0; | |
| 2091 for (int i = 0; i < list.length; i++) { | |
| 2092 if (list[i] != null) { | |
| 2093 temp[offset++] = list[i]; | |
| 2094 } | |
| 2095 } | |
| 2096 list = temp; | |
| 2097 } | |
| 2098 | |
| 2099 if (list.length == 0) { | |
| 2100 return null; | |
| 2101 } else { | |
| 2102 return list; | |
| 2103 } | |
| 2104 } | |
| 2105 | |
| 2106 /** | |
| 2107 * Return an array containing only those exceptions which need to be | |
| 2108 * handled explicitly by the stub. Removes java.lang.RuntimeException, | |
| 2109 * java.lang.Error, and their subclasses, since these are all passed | |
| 2110 * back as CORBA system exceptions. Also removes subclasses of | |
| 2111 * java.rmi.RemoteException but not java.rmi.RemoteException itself, | |
| 2112 * since this may need to be thrown by the stub. | |
| 2113 */ | |
| 2114 public ValueType[] getFilteredStubExceptions(ValueType[] list) { | |
| 2115 ValueType[] result = list; | |
| 2116 int newSize = list.length; | |
| 2117 | |
| 2118 try { | |
| 2119 | |
| 2120 for (int i = 0; i < list.length; i++) { | |
| 2121 ClassDeclaration decl = list[i].getClassDeclaration(); | |
| 2122 if ((env.defRemoteException.superClassOf(env, decl) && | |
| 2123 !env.defRemoteException.getClassDeclaration().equals(decl)) || | |
| 2124 env.defRuntimeException.superClassOf(env, decl) || | |
| 2125 env.defError.superClassOf(env, decl)) { | |
| 2126 list[i] = null; | |
| 2127 newSize--; | |
| 2128 } | |
| 2129 } | |
| 2130 | |
| 2131 } catch (ClassNotFound e) { | |
| 2132 classNotFound(stack,e); // Report error but do not stop. | |
| 2133 } | |
| 2134 | |
| 2135 // Create new list if we removed anything... | |
| 2136 | |
| 2137 if (newSize < list.length) { | |
| 2138 ValueType[] temp = new ValueType[newSize]; | |
| 2139 int offset = 0; | |
| 2140 for (int i = 0; i < list.length; i++) { | |
| 2141 if (list[i] != null) { | |
| 2142 temp[offset++] = list[i]; | |
| 2143 } | |
| 2144 } | |
| 2145 list = temp; | |
| 2146 } | |
| 2147 | |
| 2148 return list; | |
| 2149 } | |
| 2150 | |
| 2151 /** | |
| 2152 * Return the string representation of this method. | |
| 2153 */ | |
| 2154 public String toString() { | |
| 2155 | |
| 2156 if (stringRep == null) { | |
| 2157 | |
| 2158 StringBuffer result = new StringBuffer(returnType.toString()); | |
| 2159 | |
| 2160 // Add name... | |
| 2161 | |
| 2162 result.append(" "); | |
| 2163 result.append(getName()); | |
| 2164 result.append(" ("); | |
| 2165 | |
| 2166 // Add arguments... | |
| 2167 | |
| 2168 for (int i = 0; i < arguments.length; i++) { | |
| 2169 if (i > 0) { | |
| 2170 result.append(", "); | |
| 2171 } | |
| 2172 result.append(arguments[i]); | |
| 2173 result.append(" "); | |
| 2174 result.append(argumentNames[i]); | |
| 2175 } | |
| 2176 | |
| 2177 result.append(")"); | |
| 2178 | |
| 2179 // Add exceptions... | |
| 2180 | |
| 2181 for (int i = 0; i < exceptions.length; i++) { | |
| 2182 if (i == 0) { | |
| 2183 result.append(" throws "); | |
| 2184 } else { | |
| 2185 result.append(", "); | |
| 2186 } | |
| 2187 result.append(exceptions[i]); | |
| 2188 } | |
| 2189 | |
| 2190 result.append(";"); | |
| 2191 | |
| 2192 stringRep = result.toString(); | |
| 2193 } | |
| 2194 | |
| 2195 return stringRep; | |
| 2196 } | |
| 2197 | |
| 2198 | |
| 2199 /** | |
| 2200 * Set attribute kind. May only be called during initialization. | |
| 2201 */ | |
| 2202 public void setAttributeKind(int kind) { | |
| 2203 attributeKind = kind; | |
| 2204 } | |
| 2205 | |
| 2206 /** | |
| 2207 * Set pair index. May only be called during initialization. | |
| 2208 */ | |
| 2209 public void setAttributePairIndex(int index) { | |
| 2210 attributePairIndex = index; | |
| 2211 } | |
| 2212 | |
| 2213 /** | |
| 2214 * Set attribute name. May only be called during initialization. | |
| 2215 */ | |
| 2216 public void setAttributeName(String name) { | |
| 2217 attributeName = name; | |
| 2218 } | |
| 2219 | |
| 2220 /** | |
| 2221 * Set the idl name. May only be called during initialization. | |
| 2222 */ | |
| 2223 public void setIDLName (String idlName) { | |
| 2224 this.idlName=idlName; | |
| 2225 } | |
| 2226 | |
| 2227 /** | |
| 2228 * Set the implExceptions array. May only be called during initialization. | |
| 2229 */ | |
| 2230 public void setImplExceptions (ValueType[] exceptions) { | |
| 2231 implExceptions = exceptions; | |
| 2232 } | |
| 2233 | |
| 2234 /** | |
| 2235 * Set the declaredBy Identifier. May only be called during initialization. | |
| 2236 */ | |
| 2237 public void setDeclaredBy (Identifier by) { | |
| 2238 declaredBy = by; | |
| 2239 } | |
| 2240 | |
| 2241 /** | |
| 2242 * Convert all invalid types to valid ones. | |
| 2243 */ | |
| 2244 protected void swapInvalidTypes () { | |
| 2245 | |
| 2246 // Check return type... | |
| 2247 | |
| 2248 if (returnType.getStatus() != STATUS_VALID) { | |
| 2249 returnType = getValidType(returnType); | |
| 2250 } | |
| 2251 | |
| 2252 // Check args... | |
| 2253 | |
| 2254 for (int i = 0; i < arguments.length; i++) { | |
| 2255 if (arguments[i].getStatus() != STATUS_VALID) { | |
| 2256 arguments[i] = getValidType(arguments[i]); | |
| 2257 } | |
| 2258 } | |
| 2259 | |
| 2260 // Check exceptions... | |
| 2261 | |
| 2262 for (int i = 0; i < exceptions.length; i++) { | |
| 2263 if (exceptions[i].getStatus() != STATUS_VALID) { | |
| 2264 exceptions[i] = (ValueType)getValidType(exceptions[i]); | |
| 2265 } | |
| 2266 } | |
| 2267 | |
| 2268 // Check implExceptions... | |
| 2269 | |
| 2270 for (int i = 0; i < implExceptions.length; i++) { | |
| 2271 if (implExceptions[i].getStatus() != STATUS_VALID) { | |
| 2272 implExceptions[i] = (ValueType)getValidType(implExceptions[i]); | |
| 2273 } | |
| 2274 } | |
| 2275 } | |
| 2276 | |
| 2277 /** | |
| 2278 * Release all resources. | |
| 2279 */ | |
| 2280 public void destroy () { | |
| 2281 if (memberDef != null) { | |
| 2282 memberDef = null; | |
| 2283 enclosing = null; | |
| 2284 if (exceptions != null) { | |
| 2285 for (int i = 0; i < exceptions.length; i++) { | |
| 2286 if (exceptions[i] != null) exceptions[i].destroy(); | |
| 2287 exceptions[i] = null; | |
| 2288 } | |
| 2289 exceptions = null; | |
| 2290 } | |
| 2291 | |
| 2292 if (implExceptions != null) { | |
| 2293 for (int i = 0; i < implExceptions.length; i++) { | |
| 2294 if (implExceptions[i] != null) implExceptions[i].destroy(); | |
| 2295 implExceptions[i] = null; | |
| 2296 } | |
| 2297 implExceptions = null; | |
| 2298 } | |
| 2299 | |
| 2300 if (returnType != null) returnType.destroy(); | |
| 2301 returnType = null; | |
| 2302 | |
| 2303 if (arguments != null) { | |
| 2304 for (int i = 0; i < arguments.length; i++) { | |
| 2305 if (arguments[i] != null) arguments[i].destroy(); | |
| 2306 arguments[i] = null; | |
| 2307 } | |
| 2308 arguments = null; | |
| 2309 } | |
| 2310 | |
| 2311 if (argumentNames != null) { | |
| 2312 for (int i = 0; i < argumentNames.length; i++) { | |
| 2313 argumentNames[i] = null; | |
| 2314 } | |
| 2315 argumentNames = null; | |
| 2316 } | |
| 2317 | |
| 2318 vis = null; | |
| 2319 name = null; | |
| 2320 idlName = null; | |
| 2321 stringRep = null; | |
| 2322 attributeName = null; | |
| 2323 declaredBy = null; | |
| 2324 } | |
| 2325 } | |
| 2326 | |
| 2327 private MemberDefinition memberDef; | |
| 2328 private CompoundType enclosing; | |
| 2329 private ValueType[] exceptions; | |
| 2330 private ValueType[] implExceptions; | |
| 2331 private Type returnType; | |
| 2332 private Type[] arguments; | |
| 2333 private String[] argumentNames; | |
| 2334 private String vis; | |
| 2335 private String name; | |
| 2336 private String idlName; | |
| 2337 private String stringRep = null; | |
| 2338 private int attributeKind = ATTRIBUTE_NONE; | |
| 2339 private String attributeName = null; | |
| 2340 private int attributePairIndex = -1; | |
| 2341 private Identifier declaredBy = null; | |
| 2342 | |
| 2343 /** | |
| 2344 * Make up an argument name for the given type. | |
| 2345 */ | |
| 2346 private String makeArgName (int argNum, Type type) { | |
| 2347 return "arg" + argNum; | |
| 2348 } | |
| 2349 | |
| 2350 /** | |
| 2351 * Create a new Method object corresponding to the given | |
| 2352 * method definition. | |
| 2353 */ | |
| 2354 public Method (CompoundType enclosing, | |
| 2355 MemberDefinition memberDef, | |
| 2356 boolean quiet, | |
| 2357 ContextStack stack) throws Exception { | |
| 2358 | |
| 2359 this.enclosing = enclosing; | |
| 2360 this.memberDef = memberDef; | |
| 2361 vis = getVisibilityString(memberDef); | |
| 2362 idlName = null; // See setIDLName() | |
| 2363 boolean valid = true; | |
| 2364 declaredBy = memberDef.getClassDeclaration().getName(); | |
| 2365 | |
| 2366 // Set name... | |
| 2367 | |
| 2368 name = memberDef.getName().toString(); | |
| 2369 | |
| 2370 // Update the context... | |
| 2371 | |
| 2372 stack.setNewContextCode(ContextStack.METHOD); | |
| 2373 stack.push(this); | |
| 2374 | |
| 2375 // Set return type... | |
| 2376 | |
| 2377 stack.setNewContextCode(ContextStack.METHOD_RETURN); | |
| 2378 sun.tools.java.Type methodType = memberDef.getType(); | |
| 2379 sun.tools.java.Type rtnType = methodType.getReturnType(); | |
| 2380 | |
| 2381 if (rtnType == sun.tools.java.Type.tVoid) { | |
| 2382 returnType = PrimitiveType.forPrimitive(rtnType,stack); | |
| 2383 } else { | |
| 2384 returnType = makeType(rtnType,null,stack); | |
| 2385 if (returnType == null || | |
| 2386 !assertNotImpl(returnType,quiet,stack,enclosing,false)) { | |
| 2387 valid = false; | |
| 2388 failedConstraint(24,quiet,stack,enclosing.getName()); | |
| 2389 } | |
| 2390 } | |
| 2391 | |
| 2392 // Set arguments and argument names... | |
| 2393 | |
| 2394 stack.setNewContextCode(ContextStack.METHOD_ARGUMENT); | |
| 2395 sun.tools.java.Type[] args = memberDef.getType().getArgumentTypes(); | |
| 2396 arguments = new Type[args.length]; | |
| 2397 argumentNames = new String[args.length]; | |
| 2398 Vector origArgNames = memberDef.getArguments(); | |
| 2399 | |
| 2400 for (int i = 0; i < args.length; i++) { | |
| 2401 Type type = null; | |
| 2402 try { | |
| 2403 type = makeType(args[i],null,stack); | |
| 2404 } catch (Exception e) { | |
| 2405 } | |
| 2406 | |
| 2407 if (type != null) { | |
| 2408 if (!assertNotImpl(type,quiet,stack,enclosing,false)) { | |
| 2409 valid = false; | |
| 2410 } else { | |
| 2411 arguments[i] = type; | |
| 2412 if (origArgNames != null) { | |
| 2413 LocalMember local = (LocalMember)origArgNames.elementAt(i+1); | |
| 2414 argumentNames[i] = local.getName().toString(); | |
| 2415 } else { | |
| 2416 argumentNames[i] = makeArgName(i,type); | |
| 2417 } | |
| 2418 } | |
| 2419 } else { | |
| 2420 valid = false; | |
| 2421 failedConstraint(25,false,stack,enclosing.getQualifiedName(),name); | |
| 2422 } | |
| 2423 } | |
| 2424 | |
| 2425 if (!valid) { | |
| 2426 stack.pop(false); | |
| 2427 throw new Exception(); | |
| 2428 } | |
| 2429 | |
| 2430 // Set exceptions... | |
| 2431 | |
| 2432 try { | |
| 2433 exceptions = enclosing.getMethodExceptions(memberDef,quiet,stack); | |
| 2434 implExceptions = exceptions; | |
| 2435 stack.pop(true); | |
| 2436 } catch (Exception e) { | |
| 2437 stack.pop(false); | |
| 2438 throw new Exception(); | |
| 2439 } | |
| 2440 } | |
| 2441 | |
| 2442 /** | |
| 2443 * Cloning is supported by returning a shallow copy of this object. | |
| 2444 */ | |
| 2445 protected Object clone() { | |
| 2446 try { | |
| 2447 return super.clone(); | |
| 2448 } catch (CloneNotSupportedException e) { | |
| 2449 throw new Error("clone failed"); | |
| 2450 } | |
| 2451 } | |
| 2452 } | |
| 2453 | |
| 2454 //_____________________________________________________________________ | |
| 2455 // Inner Class "Member" | |
| 2456 //_____________________________________________________________________ | |
| 2457 | |
| 2458 /** | |
| 2459 * An CompoundType.Member object wraps a Type and a value representing | |
| 2460 * a data member, including constants. | |
| 2461 */ | |
| 2462 public class Member implements ContextElement, Cloneable { | |
| 2463 | |
| 2464 /** | |
| 2465 * Return context element name. | |
| 2466 */ | |
| 2467 public String getElementName() { | |
| 2468 return "\"" + getName() + "\""; | |
| 2469 } | |
| 2470 | |
| 2471 /** | |
| 2472 * Return the type of this member. | |
| 2473 */ | |
| 2474 public Type getType() { | |
| 2475 return type; | |
| 2476 } | |
| 2477 | |
| 2478 /** | |
| 2479 * Return the name of this member. | |
| 2480 */ | |
| 2481 public String getName() { | |
| 2482 return name; | |
| 2483 } | |
| 2484 | |
| 2485 /** | |
| 2486 * IDL_Naming | |
| 2487 * Return the IDL name of this member. | |
| 2488 */ | |
| 2489 public String getIDLName() { | |
| 2490 return idlName; | |
| 2491 } | |
| 2492 | |
| 2493 /** | |
| 2494 * Return the visibility (e.g. "public final") of this member. | |
| 2495 */ | |
| 2496 public String getVisibility() { | |
| 2497 return vis; | |
| 2498 } | |
| 2499 | |
| 2500 /** | |
| 2501 * Methods to check various attributes. | |
| 2502 */ | |
| 2503 public boolean isPublic() { | |
| 2504 return member.isPublic(); | |
| 2505 } | |
| 2506 | |
| 2507 public boolean isPrivate() { | |
| 2508 return member.isPrivate(); | |
| 2509 } | |
| 2510 | |
| 2511 public boolean isStatic() { | |
| 2512 return member.isStatic(); | |
| 2513 } | |
| 2514 | |
| 2515 public boolean isFinal() { | |
| 2516 return member.isFinal(); | |
| 2517 } | |
| 2518 | |
| 2519 public boolean isTransient() { | |
| 2520 if (forceTransient) return true; | |
| 2521 return member.isTransient(); | |
| 2522 } | |
| 2523 | |
| 2524 /** | |
| 2525 * Return the value of this member. May be null. | |
| 2526 */ | |
| 2527 public String getValue() { | |
| 2528 return value; | |
| 2529 } | |
| 2530 | |
| 2531 /** | |
| 2532 * Return true if this member represents an inner class declaration, | |
| 2533 * false otherwise. | |
| 2534 */ | |
| 2535 public boolean isInnerClassDeclaration() { | |
| 2536 return innerClassDecl; | |
| 2537 } | |
| 2538 | |
| 2539 /** | |
| 2540 * Return true if this member represents a constant. | |
| 2541 */ | |
| 2542 public boolean isConstant () { | |
| 2543 return constant; | |
| 2544 } | |
| 2545 | |
| 2546 /** | |
| 2547 * Return the string representation of this constant. | |
| 2548 */ | |
| 2549 public String toString() { | |
| 2550 | |
| 2551 String result = type.toString(); | |
| 2552 | |
| 2553 if (value != null) { | |
| 2554 result += (" = " + value); | |
| 2555 } | |
| 2556 | |
| 2557 return result; | |
| 2558 } | |
| 2559 | |
| 2560 /** | |
| 2561 * Convert all invalid types to valid ones. | |
| 2562 */ | |
| 2563 protected void swapInvalidTypes () { | |
| 2564 if (type.getStatus() != STATUS_VALID) { | |
| 2565 type = getValidType(type); | |
| 2566 } | |
| 2567 } | |
| 2568 | |
| 2569 protected void setTransient() { | |
| 2570 if (! isTransient()) { | |
| 2571 forceTransient = true; | |
| 2572 if (vis.length() > 0) { | |
| 2573 vis = vis + " transient"; | |
| 2574 } else { | |
| 2575 vis = "transient"; | |
| 2576 } | |
| 2577 } | |
| 2578 } | |
| 2579 | |
| 2580 protected MemberDefinition getMemberDefinition() { | |
| 2581 return member; | |
| 2582 } | |
| 2583 | |
| 2584 /** | |
| 2585 * Release all resources. | |
| 2586 */ | |
| 2587 public void destroy () { | |
| 2588 if (type != null) { | |
| 2589 type.destroy(); | |
| 2590 type = null; | |
| 2591 vis = null; | |
| 2592 value = null; | |
| 2593 name = null; | |
| 2594 idlName = null; | |
| 2595 member = null; | |
| 2596 } | |
| 2597 } | |
| 2598 | |
| 2599 private Type type; | |
| 2600 private String vis; | |
| 2601 private String value; | |
| 2602 private String name; | |
| 2603 private String idlName; | |
| 2604 private boolean innerClassDecl; | |
| 2605 private boolean constant; | |
| 2606 private MemberDefinition member; | |
| 2607 private boolean forceTransient; | |
| 2608 | |
| 2609 /** | |
| 2610 * Create a new Member object. | |
| 2611 */ | |
| 2612 public Member(MemberDefinition member, | |
| 2613 String value, | |
| 2614 ContextStack stack, | |
| 2615 CompoundType enclosing) { | |
| 2616 this.member = member; | |
| 2617 this.value = value; | |
| 2618 forceTransient = false; | |
| 2619 innerClassDecl = member.getInnerClass() != null; | |
| 2620 | |
| 2621 // If we are not an inner class, finish initializing now. | |
| 2622 // Otherwise, wait until outer class is finished, then | |
| 2623 // call init to avoid potential recursion problems... | |
| 2624 | |
| 2625 if (!innerClassDecl) { | |
| 2626 init (stack,enclosing); | |
| 2627 } | |
| 2628 } | |
| 2629 | |
| 2630 public void init (ContextStack stack, CompoundType enclosing) { | |
| 2631 | |
| 2632 constant = false; | |
| 2633 name = member.getName().toString(); | |
| 2634 vis = getVisibilityString(member); | |
| 2635 idlName = null; | |
| 2636 | |
| 2637 // Add self to stack... | |
| 2638 | |
| 2639 int contextCode = ContextStack.MEMBER; | |
| 2640 stack.setNewContextCode(contextCode); | |
| 2641 | |
| 2642 // Check for special contextCodes... | |
| 2643 | |
| 2644 if (member.isVariable()) { | |
| 2645 if (value != null && member.isConstant()) { | |
| 2646 contextCode = ContextStack.MEMBER_CONSTANT; | |
| 2647 this.constant = true; | |
| 2648 } else if (member.isStatic()) { | |
| 2649 contextCode = ContextStack.MEMBER_STATIC; | |
| 2650 } else if (member.isTransient()) { | |
| 2651 contextCode = ContextStack.MEMBER_TRANSIENT; | |
| 2652 } | |
| 2653 } | |
| 2654 | |
| 2655 stack.setNewContextCode(contextCode); | |
| 2656 stack.push(this); | |
| 2657 | |
| 2658 type = makeType(member.getType(),null,stack); | |
| 2659 | |
| 2660 if (type == null || | |
| 2661 (!innerClassDecl && | |
| 2662 !member.isStatic() && | |
| 2663 !member.isTransient() && | |
| 2664 !assertNotImpl(type,false,stack,enclosing,true))) { | |
| 2665 stack.pop(false); | |
| 2666 throw new CompilerError(""); | |
| 2667 } | |
| 2668 | |
| 2669 // Clean up primitive constant values... | |
| 2670 | |
| 2671 if (constant && type.isPrimitive()) { | |
| 2672 if (type.isType(TYPE_LONG) || type.isType(TYPE_FLOAT) || type.isType(TYPE_DOUBLE)) { | |
| 2673 int length = value.length(); | |
| 2674 char lastChar = value.charAt(length-1); | |
| 2675 if (!Character.isDigit(lastChar)) { | |
| 2676 this.value = value.substring(0,length-1); | |
| 2677 } | |
| 2678 } else if (type.isType(TYPE_BOOLEAN)) { | |
| 2679 value = value.toUpperCase(); | |
| 2680 } | |
| 2681 } | |
| 2682 if (constant && type.isType(TYPE_STRING)) { | |
| 2683 value = "L" + value; | |
| 2684 } | |
| 2685 stack.pop(true); | |
| 2686 } | |
| 2687 | |
| 2688 public void setIDLName (String name) { | |
| 2689 this.idlName = name; | |
| 2690 } | |
| 2691 | |
| 2692 /** | |
| 2693 * Cloning is supported by returning a shallow copy of this object. | |
| 2694 */ | |
| 2695 protected Object clone() { | |
| 2696 try { | |
| 2697 return super.clone(); | |
| 2698 } catch (CloneNotSupportedException e) { | |
| 2699 throw new Error("clone failed"); | |
| 2700 } | |
| 2701 } | |
| 2702 } | |
| 2703 } |
