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:204 027 * @production WhileStmt : {@link BranchTargetStmt} ::= <span class="component">Condition:{@link Expr}</span> <span class="component">{@link Stmt}</span>; 028 029 */ 030 public class WhileStmt extends BranchTargetStmt implements Cloneable { 031 /** 032 * @aspect PrettyPrintUtil 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:194 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print("while ("); 037 out.print(getCondition()); 038 out.print(") "); 039 if (getStmt() instanceof Block) { 040 out.print(getStmt()); 041 } else { 042 out.print("{"); 043 out.println(); 044 out.indent(1); 045 out.print(getStmt()); 046 out.println(); 047 out.print("}"); 048 } 049 } 050 /** 051 * @aspect TypeCheck 052 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:378 053 */ 054 public void typeCheck() { 055 TypeDecl cond = getCondition().type(); 056 if (!cond.isBoolean()) { 057 errorf("the type of \"%s\" is %s which is not boolean", 058 getCondition().prettyPrint(), cond.name()); 059 } 060 } 061 /** 062 * @aspect CreateBCode 063 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1565 064 */ 065 public void createBCode(CodeGeneration gen) { 066 super.createBCode(gen); 067 gen.addLabel(cond_label()); 068 if (!getCondition().isConstant()) { 069 getCondition().branchFalse(gen, end_label()); 070 } 071 gen.addLabel(stmt_label()); 072 if (getCondition().canBeTrue()) { 073 getStmt().createBCode(gen); 074 if (getStmt().canCompleteNormally()) { 075 gen.emitGoto(cond_label()); 076 } 077 } 078 gen.addLabel(end_label()); 079 } 080 /** 081 * @declaredat ASTNode:1 082 */ 083 public WhileStmt() { 084 super(); 085 } 086 /** 087 * Initializes the child array to the correct size. 088 * Initializes List and Opt nta children. 089 * @apilevel internal 090 * @ast method 091 * @declaredat ASTNode:10 092 */ 093 public void init$Children() { 094 children = new ASTNode[2]; 095 } 096 /** 097 * @declaredat ASTNode:13 098 */ 099 public WhileStmt(Expr p0, Stmt p1) { 100 setChild(p0, 0); 101 setChild(p1, 1); 102 } 103 /** 104 * @apilevel low-level 105 * @declaredat ASTNode:20 106 */ 107 protected int numChildren() { 108 return 2; 109 } 110 /** 111 * @apilevel internal 112 * @declaredat ASTNode:26 113 */ 114 public boolean mayHaveRewrite() { 115 return false; 116 } 117 /** 118 * @apilevel internal 119 * @declaredat ASTNode:32 120 */ 121 public void flushAttrCache() { 122 super.flushAttrCache(); 123 isDAafter_Variable_reset(); 124 isDUafter_Variable_reset(); 125 isDUbeforeCondition_Variable_reset(); 126 canCompleteNormally_reset(); 127 cond_label_reset(); 128 end_label_reset(); 129 stmt_label_reset(); 130 } 131 /** 132 * @apilevel internal 133 * @declaredat ASTNode:45 134 */ 135 public void flushCollectionCache() { 136 super.flushCollectionCache(); 137 } 138 /** 139 * @apilevel internal 140 * @declaredat ASTNode:51 141 */ 142 public void flushRewriteCache() { 143 super.flushRewriteCache(); 144 } 145 /** 146 * @apilevel internal 147 * @declaredat ASTNode:57 148 */ 149 public WhileStmt clone() throws CloneNotSupportedException { 150 WhileStmt node = (WhileStmt) super.clone(); 151 return node; 152 } 153 /** 154 * @apilevel internal 155 * @declaredat ASTNode:64 156 */ 157 public WhileStmt copy() { 158 try { 159 WhileStmt node = (WhileStmt) clone(); 160 node.parent = null; 161 if (children != null) { 162 node.children = (ASTNode[]) children.clone(); 163 } 164 return node; 165 } catch (CloneNotSupportedException e) { 166 throw new Error("Error: clone not supported for " + getClass().getName()); 167 } 168 } 169 /** 170 * Create a deep copy of the AST subtree at this node. 171 * The copy is dangling, i.e. has no parent. 172 * @return dangling copy of the subtree at this node 173 * @apilevel low-level 174 * @deprecated Please use treeCopy or treeCopyNoTransform instead 175 * @declaredat ASTNode:83 176 */ 177 @Deprecated 178 public WhileStmt fullCopy() { 179 return treeCopyNoTransform(); 180 } 181 /** 182 * Create a deep copy of the AST subtree at this node. 183 * The copy is dangling, i.e. has no parent. 184 * @return dangling copy of the subtree at this node 185 * @apilevel low-level 186 * @declaredat ASTNode:93 187 */ 188 public WhileStmt treeCopyNoTransform() { 189 WhileStmt tree = (WhileStmt) copy(); 190 if (children != null) { 191 for (int i = 0; i < children.length; ++i) { 192 ASTNode child = (ASTNode) children[i]; 193 if (child != null) { 194 child = child.treeCopyNoTransform(); 195 tree.setChild(child, i); 196 } 197 } 198 } 199 return tree; 200 } 201 /** 202 * Create a deep copy of the AST subtree at this node. 203 * The subtree of this node is traversed to trigger rewrites before copy. 204 * The copy is dangling, i.e. has no parent. 205 * @return dangling copy of the subtree at this node 206 * @apilevel low-level 207 * @declaredat ASTNode:113 208 */ 209 public WhileStmt treeCopy() { 210 doFullTraversal(); 211 return treeCopyNoTransform(); 212 } 213 /** 214 * @apilevel internal 215 * @declaredat ASTNode:120 216 */ 217 protected boolean is$Equal(ASTNode node) { 218 return super.is$Equal(node); 219 } 220 /** 221 * Replaces the Condition child. 222 * @param node The new node to replace the Condition child. 223 * @apilevel high-level 224 */ 225 public void setCondition(Expr node) { 226 setChild(node, 0); 227 } 228 /** 229 * Retrieves the Condition child. 230 * @return The current node used as the Condition child. 231 * @apilevel high-level 232 */ 233 @ASTNodeAnnotation.Child(name="Condition") 234 public Expr getCondition() { 235 return (Expr) getChild(0); 236 } 237 /** 238 * Retrieves the Condition child. 239 * <p><em>This method does not invoke AST transformations.</em></p> 240 * @return The current node used as the Condition child. 241 * @apilevel low-level 242 */ 243 public Expr getConditionNoTransform() { 244 return (Expr) getChildNoTransform(0); 245 } 246 /** 247 * Replaces the Stmt child. 248 * @param node The new node to replace the Stmt child. 249 * @apilevel high-level 250 */ 251 public void setStmt(Stmt node) { 252 setChild(node, 1); 253 } 254 /** 255 * Retrieves the Stmt child. 256 * @return The current node used as the Stmt child. 257 * @apilevel high-level 258 */ 259 @ASTNodeAnnotation.Child(name="Stmt") 260 public Stmt getStmt() { 261 return (Stmt) getChild(1); 262 } 263 /** 264 * Retrieves the Stmt child. 265 * <p><em>This method does not invoke AST transformations.</em></p> 266 * @return The current node used as the Stmt child. 267 * @apilevel low-level 268 */ 269 public Stmt getStmtNoTransform() { 270 return (Stmt) getChildNoTransform(1); 271 } 272 /** 273 * @return <code>true</code> if this statement is a potential 274 * branch target of the given branch statement. 275 * @attribute syn 276 * @aspect BranchTarget 277 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:217 278 */ 279 @ASTNodeAnnotation.Attribute 280 public boolean potentialTargetOf(Stmt branch) { 281 boolean potentialTargetOf_Stmt_value = branch.canBranchTo(this); 282 283 return potentialTargetOf_Stmt_value; 284 } 285 /** 286 * @apilevel internal 287 */ 288 protected java.util.Map isDAafter_Variable_values; 289 /** 290 * @apilevel internal 291 */ 292 private void isDAafter_Variable_reset() { 293 isDAafter_Variable_values = null; 294 } 295 /** 296 * @attribute syn 297 * @aspect DA 298 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 299 */ 300 @ASTNodeAnnotation.Attribute 301 public boolean isDAafter(Variable v) { 302 Object _parameters = v; 303 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 304 ASTNode$State state = state(); 305 if (isDAafter_Variable_values.containsKey(_parameters)) { 306 return (Boolean) isDAafter_Variable_values.get(_parameters); 307 } 308 boolean intermediate = state.INTERMEDIATE_VALUE; 309 state.INTERMEDIATE_VALUE = false; 310 int num = state.boundariesCrossed; 311 boolean isFinal = this.is$Final(); 312 boolean isDAafter_Variable_value = isDAafter_compute(v); 313 if (isFinal && num == state().boundariesCrossed) { 314 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 315 } else { 316 } 317 state.INTERMEDIATE_VALUE |= intermediate; 318 319 return isDAafter_Variable_value; 320 } 321 /** 322 * @apilevel internal 323 */ 324 private boolean isDAafter_compute(Variable v) { 325 if (!getCondition().isDAafterFalse(v)) { 326 return false; 327 } 328 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 329 BreakStmt stmt = (BreakStmt) iter.next(); 330 if (!stmt.isDAafterReachedFinallyBlocks(v)) { 331 return false; 332 } 333 } 334 return true; 335 } 336 /** 337 * @apilevel internal 338 */ 339 protected java.util.Map isDUafter_Variable_values; 340 /** 341 * @apilevel internal 342 */ 343 private void isDUafter_Variable_reset() { 344 isDUafter_Variable_values = null; 345 } 346 /** 347 * @attribute syn 348 * @aspect DU 349 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 350 */ 351 @ASTNodeAnnotation.Attribute 352 public boolean isDUafter(Variable v) { 353 Object _parameters = v; 354 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 355 ASTNode$State state = state(); 356 if (isDUafter_Variable_values.containsKey(_parameters)) { 357 return (Boolean) isDUafter_Variable_values.get(_parameters); 358 } 359 boolean intermediate = state.INTERMEDIATE_VALUE; 360 state.INTERMEDIATE_VALUE = false; 361 int num = state.boundariesCrossed; 362 boolean isFinal = this.is$Final(); 363 boolean isDUafter_Variable_value = isDUafter_compute(v); 364 if (isFinal && num == state().boundariesCrossed) { 365 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 366 } else { 367 } 368 state.INTERMEDIATE_VALUE |= intermediate; 369 370 return isDUafter_Variable_value; 371 } 372 /** 373 * @apilevel internal 374 */ 375 private boolean isDUafter_compute(Variable v) { 376 if (!isDUbeforeCondition(v)) { 377 // start a circular evaluation here 378 return false; 379 } 380 if (!getCondition().isDUafterFalse(v)) { 381 return false; 382 } 383 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 384 BreakStmt stmt = (BreakStmt) iter.next(); 385 if (!stmt.isDUafterReachedFinallyBlocks(v)) { 386 return false; 387 } 388 } 389 return true; 390 } 391 /** 392 * @apilevel internal 393 */ 394 private void isDUbeforeCondition_Variable_reset() { 395 isDUbeforeCondition_Variable_values = null; 396 } 397 protected java.util.Map isDUbeforeCondition_Variable_values; 398 @ASTNodeAnnotation.Attribute 399 public boolean isDUbeforeCondition(Variable v) { 400 Object _parameters = v; 401 if (isDUbeforeCondition_Variable_values == null) isDUbeforeCondition_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 402 ASTNode$State.CircularValue _value; 403 if (isDUbeforeCondition_Variable_values.containsKey(_parameters)) { 404 Object _o = isDUbeforeCondition_Variable_values.get(_parameters); 405 if (!(_o instanceof ASTNode$State.CircularValue)) { 406 return (Boolean) _o; 407 } else { 408 _value = (ASTNode$State.CircularValue) _o; 409 } 410 } else { 411 _value = new ASTNode$State.CircularValue(); 412 isDUbeforeCondition_Variable_values.put(_parameters, _value); 413 _value.value = true; 414 } 415 ASTNode$State state = state(); 416 boolean new_isDUbeforeCondition_Variable_value; 417 if (!state.IN_CIRCLE) { 418 state.IN_CIRCLE = true; 419 int num = state.boundariesCrossed; 420 boolean isFinal = this.is$Final(); 421 // TODO: fixme 422 // state().CIRCLE_INDEX = 1; 423 do { 424 _value.visited = state.CIRCLE_INDEX; 425 state.CHANGE = false; 426 new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v); 427 if (new_isDUbeforeCondition_Variable_value != ((Boolean)_value.value)) { 428 state.CHANGE = true; 429 _value.value = new_isDUbeforeCondition_Variable_value; 430 } 431 state.CIRCLE_INDEX++; 432 } while (state.CHANGE); 433 if (isFinal && num == state().boundariesCrossed) { 434 isDUbeforeCondition_Variable_values.put(_parameters, new_isDUbeforeCondition_Variable_value); 435 } else { 436 isDUbeforeCondition_Variable_values.remove(_parameters); 437 state.RESET_CYCLE = true; 438 boolean $tmp = isDUbeforeCondition_compute(v); 439 state.RESET_CYCLE = false; 440 } 441 state.IN_CIRCLE = false; 442 state.INTERMEDIATE_VALUE = false; 443 return new_isDUbeforeCondition_Variable_value; 444 } 445 if (state.CIRCLE_INDEX != _value.visited) { 446 _value.visited = state.CIRCLE_INDEX; 447 new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v); 448 if (state.RESET_CYCLE) { 449 isDUbeforeCondition_Variable_values.remove(_parameters); 450 } 451 else if (new_isDUbeforeCondition_Variable_value != ((Boolean)_value.value)) { 452 state.CHANGE = true; 453 _value.value = new_isDUbeforeCondition_Variable_value; 454 } 455 state.INTERMEDIATE_VALUE = true; 456 return new_isDUbeforeCondition_Variable_value; 457 } 458 state.INTERMEDIATE_VALUE = true; 459 return (Boolean) _value.value; 460 } 461 /** 462 * @apilevel internal 463 */ 464 private boolean isDUbeforeCondition_compute(Variable v) { 465 // 1st 466 if (!isDUbefore(v)) { 467 return false; 468 } else if (!getStmt().isDUafter(v)) { 469 return false; 470 } else { 471 for (Iterator iter = targetContinues().iterator(); iter.hasNext(); ) { 472 ContinueStmt stmt = (ContinueStmt) iter.next(); 473 if (!stmt.isDUafterReachedFinallyBlocks(v)) { 474 return false; 475 } 476 } 477 } 478 return true; 479 } 480 /** 481 * @attribute syn 482 * @aspect NameCheck 483 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:478 484 */ 485 @ASTNodeAnnotation.Attribute 486 public boolean continueLabel() { 487 boolean continueLabel_value = true; 488 489 return continueLabel_value; 490 } 491 /** 492 * @apilevel internal 493 */ 494 protected boolean canCompleteNormally_computed = false; 495 /** 496 * @apilevel internal 497 */ 498 protected boolean canCompleteNormally_value; 499 /** 500 * @apilevel internal 501 */ 502 private void canCompleteNormally_reset() { 503 canCompleteNormally_computed = false; 504 } 505 /** 506 * @attribute syn 507 * @aspect UnreachableStatements 508 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 509 */ 510 @ASTNodeAnnotation.Attribute 511 public boolean canCompleteNormally() { 512 ASTNode$State state = state(); 513 if (canCompleteNormally_computed) { 514 return canCompleteNormally_value; 515 } 516 boolean intermediate = state.INTERMEDIATE_VALUE; 517 state.INTERMEDIATE_VALUE = false; 518 int num = state.boundariesCrossed; 519 boolean isFinal = this.is$Final(); 520 canCompleteNormally_value = reachable() && (!getCondition().isConstant() || !getCondition().isTrue()) || reachableBreak(); 521 if (isFinal && num == state().boundariesCrossed) { 522 canCompleteNormally_computed = true; 523 } else { 524 } 525 state.INTERMEDIATE_VALUE |= intermediate; 526 527 return canCompleteNormally_value; 528 } 529 /** 530 * @apilevel internal 531 */ 532 protected boolean cond_label_computed = false; 533 /** 534 * @apilevel internal 535 */ 536 protected int cond_label_value; 537 /** 538 * @apilevel internal 539 */ 540 private void cond_label_reset() { 541 cond_label_computed = false; 542 } 543 /** 544 * @attribute syn 545 * @aspect CreateBCode 546 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1561 547 */ 548 @ASTNodeAnnotation.Attribute 549 public int cond_label() { 550 ASTNode$State state = state(); 551 if (cond_label_computed) { 552 return cond_label_value; 553 } 554 boolean intermediate = state.INTERMEDIATE_VALUE; 555 state.INTERMEDIATE_VALUE = false; 556 int num = state.boundariesCrossed; 557 boolean isFinal = this.is$Final(); 558 cond_label_value = hostType().constantPool().newLabel(); 559 if (isFinal && num == state().boundariesCrossed) { 560 cond_label_computed = true; 561 } else { 562 } 563 state.INTERMEDIATE_VALUE |= intermediate; 564 565 return cond_label_value; 566 } 567 /** 568 * @apilevel internal 569 */ 570 protected boolean end_label_computed = false; 571 /** 572 * @apilevel internal 573 */ 574 protected int end_label_value; 575 /** 576 * @apilevel internal 577 */ 578 private void end_label_reset() { 579 end_label_computed = false; 580 } 581 /** 582 * @attribute syn 583 * @aspect CreateBCode 584 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1562 585 */ 586 @ASTNodeAnnotation.Attribute 587 public int end_label() { 588 ASTNode$State state = state(); 589 if (end_label_computed) { 590 return end_label_value; 591 } 592 boolean intermediate = state.INTERMEDIATE_VALUE; 593 state.INTERMEDIATE_VALUE = false; 594 int num = state.boundariesCrossed; 595 boolean isFinal = this.is$Final(); 596 end_label_value = hostType().constantPool().newLabel(); 597 if (isFinal && num == state().boundariesCrossed) { 598 end_label_computed = true; 599 } else { 600 } 601 state.INTERMEDIATE_VALUE |= intermediate; 602 603 return end_label_value; 604 } 605 /** 606 * @apilevel internal 607 */ 608 protected boolean stmt_label_computed = false; 609 /** 610 * @apilevel internal 611 */ 612 protected int stmt_label_value; 613 /** 614 * @apilevel internal 615 */ 616 private void stmt_label_reset() { 617 stmt_label_computed = false; 618 } 619 /** 620 * @attribute syn 621 * @aspect CreateBCode 622 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1563 623 */ 624 @ASTNodeAnnotation.Attribute 625 public int stmt_label() { 626 ASTNode$State state = state(); 627 if (stmt_label_computed) { 628 return stmt_label_value; 629 } 630 boolean intermediate = state.INTERMEDIATE_VALUE; 631 state.INTERMEDIATE_VALUE = false; 632 int num = state.boundariesCrossed; 633 boolean isFinal = this.is$Final(); 634 stmt_label_value = hostType().constantPool().newLabel(); 635 if (isFinal && num == state().boundariesCrossed) { 636 stmt_label_computed = true; 637 } else { 638 } 639 state.INTERMEDIATE_VALUE |= intermediate; 640 641 return stmt_label_value; 642 } 643 /** 644 * @attribute syn 645 * @aspect CreateBCode 646 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621 647 */ 648 @ASTNodeAnnotation.Attribute 649 public int break_label() { 650 int break_label_value = end_label(); 651 652 return break_label_value; 653 } 654 /** 655 * @attribute syn 656 * @aspect CreateBCode 657 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645 658 */ 659 @ASTNodeAnnotation.Attribute 660 public int continue_label() { 661 int continue_label_value = cond_label(); 662 663 return continue_label_value; 664 } 665 /** 666 * @attribute syn 667 * @aspect PreciseRethrow 668 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 669 */ 670 @ASTNodeAnnotation.Attribute 671 public boolean modifiedInScope(Variable var) { 672 boolean modifiedInScope_Variable_value = getStmt().modifiedInScope(var); 673 674 return modifiedInScope_Variable_value; 675 } 676 /** 677 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 678 * @apilevel internal 679 */ 680 public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 681 int childIndex = this.getIndexOfChild(caller); 682 return branch.canBranchTo(this) ? this : branchTarget(branch); 683 } 684 protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 685 return true; 686 } 687 /** 688 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 689 * @apilevel internal 690 */ 691 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 692 if (caller == getStmtNoTransform()) { 693 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:659 694 return getCondition().isDAafterTrue(v); 695 } 696 else if (caller == getConditionNoTransform()) { 697 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:658 698 return isDAbefore(v); 699 } 700 else { 701 return getParent().Define_isDAbefore(this, caller, v); 702 } 703 } 704 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 705 return true; 706 } 707 /** 708 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 709 * @apilevel internal 710 */ 711 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 712 if (caller == getStmtNoTransform()) { 713 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1234 714 return getCondition().isDUafterTrue(v); 715 } 716 else if (caller == getConditionNoTransform()) { 717 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1213 718 return isDUbeforeCondition(v); 719 } 720 else { 721 return getParent().Define_isDUbefore(this, caller, v); 722 } 723 } 724 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 725 return true; 726 } 727 /** 728 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441 729 * @apilevel internal 730 */ 731 public boolean Define_insideLoop(ASTNode caller, ASTNode child) { 732 if (caller == getStmtNoTransform()) { 733 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:446 734 return true; 735 } 736 else { 737 return getParent().Define_insideLoop(this, caller); 738 } 739 } 740 protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) { 741 return true; 742 } 743 /** 744 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 745 * @apilevel internal 746 */ 747 public boolean Define_reachable(ASTNode caller, ASTNode child) { 748 if (caller == getStmtNoTransform()) { 749 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:135 750 return reachable() && !getCondition().isFalse(); 751 } 752 else { 753 return getParent().Define_reachable(this, caller); 754 } 755 } 756 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 757 return true; 758 } 759 /** 760 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:283 761 * @apilevel internal 762 */ 763 public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) { 764 if (caller == getStmtNoTransform()) { 765 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:215 766 return reachable(); 767 } 768 else { 769 return getParent().Define_reportUnreachable(this, caller); 770 } 771 } 772 protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) { 773 return true; 774 } 775 /** 776 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 777 * @apilevel internal 778 */ 779 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 780 if (caller == getStmtNoTransform()) { 781 // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:54 782 return false; 783 } 784 else { 785 return getParent().Define_inhModifiedInScope(this, caller, var); 786 } 787 } 788 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 789 return true; 790 } 791 /** 792 * @apilevel internal 793 */ 794 public ASTNode rewriteTo() { 795 return super.rewriteTo(); 796 } 797 }