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