001 /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */ 002 package org.extendj.ast; 003 004 import java.util.HashSet; 005 import java.io.File; 006 import java.util.Set; 007 import java.util.Collections; 008 import java.util.Collection; 009 import java.util.ArrayList; 010 import beaver.*; 011 import java.util.*; 012 import java.io.ByteArrayOutputStream; 013 import java.io.PrintStream; 014 import java.lang.reflect.InvocationTargetException; 015 import java.lang.reflect.Method; 016 import org.jastadd.util.*; 017 import java.util.zip.*; 018 import java.io.*; 019 import org.jastadd.util.PrettyPrintable; 020 import org.jastadd.util.PrettyPrinter; 021 import java.io.FileNotFoundException; 022 import java.io.BufferedInputStream; 023 import java.io.DataInputStream; 024 /** 025 * @ast node 026 * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:211 027 * @production ThrowStmt : {@link Stmt} ::= <span class="component">{@link Expr}</span>; 028 029 */ 030 public class ThrowStmt extends Stmt implements Cloneable { 031 /** 032 * @aspect AnonymousClasses 033 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:129 034 */ 035 protected void collectExceptions(Collection c, ASTNode target) { 036 super.collectExceptions(c, target); 037 TypeDecl exceptionType = getExpr().type(); 038 if (exceptionType == typeNull()) { 039 exceptionType = typeNullPointerException(); 040 } 041 c.add(exceptionType); 042 } 043 /** 044 * @aspect Java4PrettyPrint 045 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:283 046 */ 047 public void prettyPrint(PrettyPrinter out) { 048 out.print("throw "); 049 out.print(getExpr()); 050 out.print(";"); 051 } 052 /** 053 * @aspect TypeCheck 054 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:437 055 */ 056 public void typeCheck() { 057 if (!getExpr().type().instanceOf(typeThrowable())) { 058 error("*** The thrown expression must extend Throwable"); 059 } 060 } 061 /** 062 * @aspect CreateBCode 063 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1705 064 */ 065 public void createBCode(CodeGeneration gen) { 066 super.createBCode(gen); 067 getExpr().createBCode(gen); 068 gen.emitThrow(); 069 } 070 /** 071 * @declaredat ASTNode:1 072 */ 073 public ThrowStmt() { 074 super(); 075 } 076 /** 077 * Initializes the child array to the correct size. 078 * Initializes List and Opt nta children. 079 * @apilevel internal 080 * @ast method 081 * @declaredat ASTNode:10 082 */ 083 public void init$Children() { 084 children = new ASTNode[1]; 085 } 086 /** 087 * @declaredat ASTNode:13 088 */ 089 public ThrowStmt(Expr p0) { 090 setChild(p0, 0); 091 } 092 /** 093 * @apilevel low-level 094 * @declaredat ASTNode:19 095 */ 096 protected int numChildren() { 097 return 1; 098 } 099 /** 100 * @apilevel internal 101 * @declaredat ASTNode:25 102 */ 103 public boolean mayHaveRewrite() { 104 return false; 105 } 106 /** 107 * @apilevel internal 108 * @declaredat ASTNode:31 109 */ 110 public void flushAttrCache() { 111 super.flushAttrCache(); 112 isDAafter_Variable_reset(); 113 isDUafter_Variable_reset(); 114 canCompleteNormally_reset(); 115 typeNullPointerException_reset(); 116 handlesException_TypeDecl_reset(); 117 typeThrowable_reset(); 118 typeNull_reset(); 119 } 120 /** 121 * @apilevel internal 122 * @declaredat ASTNode:44 123 */ 124 public void flushCollectionCache() { 125 super.flushCollectionCache(); 126 } 127 /** 128 * @apilevel internal 129 * @declaredat ASTNode:50 130 */ 131 public void flushRewriteCache() { 132 super.flushRewriteCache(); 133 } 134 /** 135 * @apilevel internal 136 * @declaredat ASTNode:56 137 */ 138 public ThrowStmt clone() throws CloneNotSupportedException { 139 ThrowStmt node = (ThrowStmt) super.clone(); 140 return node; 141 } 142 /** 143 * @apilevel internal 144 * @declaredat ASTNode:63 145 */ 146 public ThrowStmt copy() { 147 try { 148 ThrowStmt node = (ThrowStmt) clone(); 149 node.parent = null; 150 if (children != null) { 151 node.children = (ASTNode[]) children.clone(); 152 } 153 return node; 154 } catch (CloneNotSupportedException e) { 155 throw new Error("Error: clone not supported for " + getClass().getName()); 156 } 157 } 158 /** 159 * Create a deep copy of the AST subtree at this node. 160 * The copy is dangling, i.e. has no parent. 161 * @return dangling copy of the subtree at this node 162 * @apilevel low-level 163 * @deprecated Please use treeCopy or treeCopyNoTransform instead 164 * @declaredat ASTNode:82 165 */ 166 @Deprecated 167 public ThrowStmt fullCopy() { 168 return treeCopyNoTransform(); 169 } 170 /** 171 * Create a deep copy of the AST subtree at this node. 172 * The copy is dangling, i.e. has no parent. 173 * @return dangling copy of the subtree at this node 174 * @apilevel low-level 175 * @declaredat ASTNode:92 176 */ 177 public ThrowStmt treeCopyNoTransform() { 178 ThrowStmt tree = (ThrowStmt) copy(); 179 if (children != null) { 180 for (int i = 0; i < children.length; ++i) { 181 ASTNode child = (ASTNode) children[i]; 182 if (child != null) { 183 child = child.treeCopyNoTransform(); 184 tree.setChild(child, i); 185 } 186 } 187 } 188 return tree; 189 } 190 /** 191 * Create a deep copy of the AST subtree at this node. 192 * The subtree of this node is traversed to trigger rewrites before copy. 193 * The copy is dangling, i.e. has no parent. 194 * @return dangling copy of the subtree at this node 195 * @apilevel low-level 196 * @declaredat ASTNode:112 197 */ 198 public ThrowStmt treeCopy() { 199 doFullTraversal(); 200 return treeCopyNoTransform(); 201 } 202 /** 203 * @apilevel internal 204 * @declaredat ASTNode:119 205 */ 206 protected boolean is$Equal(ASTNode node) { 207 return super.is$Equal(node); 208 } 209 /** 210 * Replaces the Expr child. 211 * @param node The new node to replace the Expr child. 212 * @apilevel high-level 213 */ 214 public void setExpr(Expr node) { 215 setChild(node, 0); 216 } 217 /** 218 * Retrieves the Expr child. 219 * @return The current node used as the Expr child. 220 * @apilevel high-level 221 */ 222 @ASTNodeAnnotation.Child(name="Expr") 223 public Expr getExpr() { 224 return (Expr) getChild(0); 225 } 226 /** 227 * Retrieves the Expr child. 228 * <p><em>This method does not invoke AST transformations.</em></p> 229 * @return The current node used as the Expr child. 230 * @apilevel low-level 231 */ 232 public Expr getExprNoTransform() { 233 return (Expr) getChildNoTransform(0); 234 } 235 /** 236 * @aspect PreciseRethrow 237 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:249 238 */ 239 240 public void exceptionHandling() { 241 Collection<TypeDecl> exceptionTypes = getExpr().throwTypes(); 242 for (TypeDecl exceptionType : exceptionTypes) { 243 if (exceptionType == typeNull()) { 244 exceptionType = typeNullPointerException(); 245 } 246 // 8.4.4 247 if (exceptionType.isCheckedException() && !handlesException(exceptionType)) { 248 errorf("%s throws uncaught exception %s", this.prettyPrint(), exceptionType.fullName()); 249 } 250 } 251 } 252 /** 253 * @aspect PreciseRethrow 254 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:263 255 */ 256 257 protected boolean reachedException(TypeDecl catchType) { 258 Collection<TypeDecl> exceptionTypes = getExpr().throwTypes(); 259 boolean reached = false; 260 for (TypeDecl exceptionType : exceptionTypes) { 261 if (exceptionType == typeNull()) { 262 exceptionType = typeNullPointerException(); 263 } 264 if (catchType.mayCatch(exceptionType)) { 265 reached = true; 266 break; 267 } 268 if (super.reachedException(catchType)) { 269 reached = true; 270 break; 271 } 272 } 273 return reached; 274 } 275 /** 276 * @apilevel internal 277 */ 278 protected java.util.Map isDAafter_Variable_values; 279 /** 280 * @apilevel internal 281 */ 282 private void isDAafter_Variable_reset() { 283 isDAafter_Variable_values = null; 284 } 285 /** 286 * @attribute syn 287 * @aspect DA 288 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 289 */ 290 @ASTNodeAnnotation.Attribute 291 public boolean isDAafter(Variable v) { 292 Object _parameters = v; 293 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 294 ASTNode$State state = state(); 295 if (isDAafter_Variable_values.containsKey(_parameters)) { 296 return (Boolean) isDAafter_Variable_values.get(_parameters); 297 } 298 boolean intermediate = state.INTERMEDIATE_VALUE; 299 state.INTERMEDIATE_VALUE = false; 300 int num = state.boundariesCrossed; 301 boolean isFinal = this.is$Final(); 302 boolean isDAafter_Variable_value = true; 303 if (isFinal && num == state().boundariesCrossed) { 304 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 305 } else { 306 } 307 state.INTERMEDIATE_VALUE |= intermediate; 308 309 return isDAafter_Variable_value; 310 } 311 /** 312 * @apilevel internal 313 */ 314 protected java.util.Map isDUafter_Variable_values; 315 /** 316 * @apilevel internal 317 */ 318 private void isDUafter_Variable_reset() { 319 isDUafter_Variable_values = null; 320 } 321 /** 322 * @attribute syn 323 * @aspect DU 324 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 325 */ 326 @ASTNodeAnnotation.Attribute 327 public boolean isDUafter(Variable v) { 328 Object _parameters = v; 329 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 330 ASTNode$State state = state(); 331 if (isDUafter_Variable_values.containsKey(_parameters)) { 332 return (Boolean) isDUafter_Variable_values.get(_parameters); 333 } 334 boolean intermediate = state.INTERMEDIATE_VALUE; 335 state.INTERMEDIATE_VALUE = false; 336 int num = state.boundariesCrossed; 337 boolean isFinal = this.is$Final(); 338 boolean isDUafter_Variable_value = true; 339 if (isFinal && num == state().boundariesCrossed) { 340 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 341 } else { 342 } 343 state.INTERMEDIATE_VALUE |= intermediate; 344 345 return isDUafter_Variable_value; 346 } 347 /** 348 * @apilevel internal 349 */ 350 protected boolean canCompleteNormally_computed = false; 351 /** 352 * @apilevel internal 353 */ 354 protected boolean canCompleteNormally_value; 355 /** 356 * @apilevel internal 357 */ 358 private void canCompleteNormally_reset() { 359 canCompleteNormally_computed = false; 360 } 361 /** 362 * @attribute syn 363 * @aspect UnreachableStatements 364 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 365 */ 366 @ASTNodeAnnotation.Attribute 367 public boolean canCompleteNormally() { 368 ASTNode$State state = state(); 369 if (canCompleteNormally_computed) { 370 return canCompleteNormally_value; 371 } 372 boolean intermediate = state.INTERMEDIATE_VALUE; 373 state.INTERMEDIATE_VALUE = false; 374 int num = state.boundariesCrossed; 375 boolean isFinal = this.is$Final(); 376 canCompleteNormally_value = false; 377 if (isFinal && num == state().boundariesCrossed) { 378 canCompleteNormally_computed = true; 379 } else { 380 } 381 state.INTERMEDIATE_VALUE |= intermediate; 382 383 return canCompleteNormally_value; 384 } 385 /** 386 * @attribute syn 387 * @aspect PreciseRethrow 388 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 389 */ 390 @ASTNodeAnnotation.Attribute 391 public boolean modifiedInScope(Variable var) { 392 boolean modifiedInScope_Variable_value = false; 393 394 return modifiedInScope_Variable_value; 395 } 396 /** 397 * @attribute inh 398 * @aspect ExceptionHandling 399 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:47 400 */ 401 /** 402 * @attribute inh 403 * @aspect ExceptionHandling 404 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:47 405 */ 406 @ASTNodeAnnotation.Attribute 407 public TypeDecl typeNullPointerException() { 408 ASTNode$State state = state(); 409 if (typeNullPointerException_computed) { 410 return typeNullPointerException_value; 411 } 412 boolean intermediate = state.INTERMEDIATE_VALUE; 413 state.INTERMEDIATE_VALUE = false; 414 int num = state.boundariesCrossed; 415 boolean isFinal = this.is$Final(); 416 typeNullPointerException_value = getParent().Define_typeNullPointerException(this, null); 417 if (isFinal && num == state().boundariesCrossed) { 418 typeNullPointerException_computed = true; 419 } else { 420 } 421 state.INTERMEDIATE_VALUE |= intermediate; 422 423 return typeNullPointerException_value; 424 } 425 /** 426 * @apilevel internal 427 */ 428 protected boolean typeNullPointerException_computed = false; 429 /** 430 * @apilevel internal 431 */ 432 protected TypeDecl typeNullPointerException_value; 433 /** 434 * @apilevel internal 435 */ 436 private void typeNullPointerException_reset() { 437 typeNullPointerException_computed = false; 438 typeNullPointerException_value = null; 439 } 440 /** 441 * @attribute inh 442 * @aspect ExceptionHandling 443 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:78 444 */ 445 /** 446 * @attribute inh 447 * @aspect ExceptionHandling 448 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:78 449 */ 450 @ASTNodeAnnotation.Attribute 451 public boolean handlesException(TypeDecl exceptionType) { 452 Object _parameters = exceptionType; 453 if (handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 454 ASTNode$State state = state(); 455 if (handlesException_TypeDecl_values.containsKey(_parameters)) { 456 return (Boolean) handlesException_TypeDecl_values.get(_parameters); 457 } 458 boolean intermediate = state.INTERMEDIATE_VALUE; 459 state.INTERMEDIATE_VALUE = false; 460 int num = state.boundariesCrossed; 461 boolean isFinal = this.is$Final(); 462 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 463 if (isFinal && num == state().boundariesCrossed) { 464 handlesException_TypeDecl_values.put(_parameters, handlesException_TypeDecl_value); 465 } else { 466 } 467 state.INTERMEDIATE_VALUE |= intermediate; 468 469 return handlesException_TypeDecl_value; 470 } 471 /** 472 * @apilevel internal 473 */ 474 protected java.util.Map handlesException_TypeDecl_values; 475 /** 476 * @apilevel internal 477 */ 478 private void handlesException_TypeDecl_reset() { 479 handlesException_TypeDecl_values = null; 480 } 481 /** 482 * @attribute inh 483 * @aspect SpecialClasses 484 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:92 485 */ 486 /** 487 * @attribute inh 488 * @aspect SpecialClasses 489 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:92 490 */ 491 @ASTNodeAnnotation.Attribute 492 public TypeDecl typeThrowable() { 493 ASTNode$State state = state(); 494 if (typeThrowable_computed) { 495 return typeThrowable_value; 496 } 497 boolean intermediate = state.INTERMEDIATE_VALUE; 498 state.INTERMEDIATE_VALUE = false; 499 int num = state.boundariesCrossed; 500 boolean isFinal = this.is$Final(); 501 typeThrowable_value = getParent().Define_typeThrowable(this, null); 502 if (isFinal && num == state().boundariesCrossed) { 503 typeThrowable_computed = true; 504 } else { 505 } 506 state.INTERMEDIATE_VALUE |= intermediate; 507 508 return typeThrowable_value; 509 } 510 /** 511 * @apilevel internal 512 */ 513 protected boolean typeThrowable_computed = false; 514 /** 515 * @apilevel internal 516 */ 517 protected TypeDecl typeThrowable_value; 518 /** 519 * @apilevel internal 520 */ 521 private void typeThrowable_reset() { 522 typeThrowable_computed = false; 523 typeThrowable_value = null; 524 } 525 /** 526 * @attribute inh 527 * @aspect SpecialClasses 528 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:95 529 */ 530 /** 531 * @attribute inh 532 * @aspect SpecialClasses 533 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:95 534 */ 535 @ASTNodeAnnotation.Attribute 536 public TypeDecl typeNull() { 537 ASTNode$State state = state(); 538 if (typeNull_computed) { 539 return typeNull_value; 540 } 541 boolean intermediate = state.INTERMEDIATE_VALUE; 542 state.INTERMEDIATE_VALUE = false; 543 int num = state.boundariesCrossed; 544 boolean isFinal = this.is$Final(); 545 typeNull_value = getParent().Define_typeNull(this, null); 546 if (isFinal && num == state().boundariesCrossed) { 547 typeNull_computed = true; 548 } else { 549 } 550 state.INTERMEDIATE_VALUE |= intermediate; 551 552 return typeNull_value; 553 } 554 /** 555 * @apilevel internal 556 */ 557 protected boolean typeNull_computed = false; 558 /** 559 * @apilevel internal 560 */ 561 protected TypeDecl typeNull_value; 562 /** 563 * @apilevel internal 564 */ 565 private void typeNull_reset() { 566 typeNull_computed = false; 567 typeNull_value = null; 568 } 569 /** 570 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 571 * @apilevel internal 572 */ 573 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 574 if (caller == getExprNoTransform()) { 575 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:735 576 return isDAbefore(v); 577 } 578 else { 579 return getParent().Define_isDAbefore(this, caller, v); 580 } 581 } 582 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 583 return true; 584 } 585 /** 586 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 587 * @apilevel internal 588 */ 589 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 590 if (caller == getExprNoTransform()) { 591 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1354 592 return isDUbefore(v); 593 } 594 else { 595 return getParent().Define_isDUbefore(this, caller, v); 596 } 597 } 598 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 599 return true; 600 } 601 /** 602 * @apilevel internal 603 */ 604 public ASTNode rewriteTo() { 605 return super.rewriteTo(); 606 } 607 }