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:191 027 * @production Stmt : {@link ASTNode}; 028 029 */ 030 public abstract class Stmt extends ASTNode<ASTNode> implements Cloneable { 031 /** 032 * @return An Opt node containing the finally and monitor exit blocks 033 * from the list of enclosing try-statements and synchronized blocks. 034 * @aspect NTAFinally 035 * @declaredat /home/jesper/git/extendj/java4/frontend/NTAFinally.jrag:82 036 */ 037 public Opt<Block> branchFinallyOpt() { 038 FinallyHost enclosing = enclosingFinally(this); 039 if (enclosing != null) { 040 return new Opt<Block>(ntaFinallyBlock(enclosing, this, enclosing.getFinallyBlock())); 041 } else { 042 return new Opt<Block>(); 043 } 044 } 045 /** 046 * @aspect UnreachableStatements 047 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:35 048 */ 049 void checkUnreachableStmt() { 050 if (!reachable() && reportUnreachable()) { 051 error("statement is unreachable"); 052 } 053 } 054 /** 055 * @aspect CreateBCode 056 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1359 057 */ 058 public void createBCode(CodeGeneration gen) { 059 gen.addLineNumberEntryAtCurrentPC(this); 060 } 061 /** 062 * @declaredat ASTNode:1 063 */ 064 public Stmt() { 065 super(); 066 } 067 /** 068 * Initializes the child array to the correct size. 069 * Initializes List and Opt nta children. 070 * @apilevel internal 071 * @ast method 072 * @declaredat ASTNode:10 073 */ 074 public void init$Children() { 075 } 076 /** 077 * @apilevel low-level 078 * @declaredat ASTNode:15 079 */ 080 protected int numChildren() { 081 return 0; 082 } 083 /** 084 * @apilevel internal 085 * @declaredat ASTNode:21 086 */ 087 public boolean mayHaveRewrite() { 088 return false; 089 } 090 /** 091 * @apilevel internal 092 * @declaredat ASTNode:27 093 */ 094 public void flushAttrCache() { 095 super.flushAttrCache(); 096 finallyIterator_reset(); 097 isDAafter_Variable_reset(); 098 isDUafter_Variable_reset(); 099 canCompleteNormally_reset(); 100 localSize_reset(); 101 enclosingFinally_Stmt_reset(); 102 localNum_reset(); 103 } 104 /** 105 * @apilevel internal 106 * @declaredat ASTNode:40 107 */ 108 public void flushCollectionCache() { 109 super.flushCollectionCache(); 110 } 111 /** 112 * @apilevel internal 113 * @declaredat ASTNode:46 114 */ 115 public void flushRewriteCache() { 116 super.flushRewriteCache(); 117 } 118 /** 119 * @apilevel internal 120 * @declaredat ASTNode:52 121 */ 122 public Stmt clone() throws CloneNotSupportedException { 123 Stmt node = (Stmt) super.clone(); 124 return node; 125 } 126 /** 127 * Create a deep copy of the AST subtree at this node. 128 * The copy is dangling, i.e. has no parent. 129 * @return dangling copy of the subtree at this node 130 * @apilevel low-level 131 * @deprecated Please use treeCopy or treeCopyNoTransform instead 132 * @declaredat ASTNode:63 133 */ 134 @Deprecated 135 public abstract Stmt fullCopy(); 136 /** 137 * Create a deep copy of the AST subtree at this node. 138 * The copy is dangling, i.e. has no parent. 139 * @return dangling copy of the subtree at this node 140 * @apilevel low-level 141 * @declaredat ASTNode:71 142 */ 143 public abstract Stmt treeCopyNoTransform(); 144 /** 145 * Create a deep copy of the AST subtree at this node. 146 * The subtree of this node is traversed to trigger rewrites before copy. 147 * The copy is dangling, i.e. has no parent. 148 * @return dangling copy of the subtree at this node 149 * @apilevel low-level 150 * @declaredat ASTNode:79 151 */ 152 public abstract Stmt treeCopy(); 153 /** 154 * @attribute syn 155 * @aspect PreciseRethrow 156 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 157 */ 158 @ASTNodeAnnotation.Attribute 159 public abstract boolean modifiedInScope(Variable var); 160 /** 161 * @apilevel internal 162 */ 163 protected boolean finallyIterator_computed = false; 164 /** 165 * @apilevel internal 166 */ 167 protected Iterator<FinallyHost> finallyIterator_value; 168 /** 169 * @apilevel internal 170 */ 171 private void finallyIterator_reset() { 172 finallyIterator_computed = false; 173 finallyIterator_value = null; 174 } 175 /** 176 * Finds enclosing finally and monitor exit blocks. 177 * @return an iterator for finally (and monitor exit) blocks that are 178 * reached before the final target of this statement is reached 179 * @attribute syn 180 * @aspect BranchTarget 181 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:80 182 */ 183 @ASTNodeAnnotation.Attribute 184 public Iterator<FinallyHost> finallyIterator() { 185 ASTNode$State state = state(); 186 if (finallyIterator_computed) { 187 return finallyIterator_value; 188 } 189 boolean intermediate = state.INTERMEDIATE_VALUE; 190 state.INTERMEDIATE_VALUE = false; 191 int num = state.boundariesCrossed; 192 boolean isFinal = this.is$Final(); 193 finallyIterator_value = finallyIterator_compute(); 194 if (isFinal && num == state().boundariesCrossed) { 195 finallyIterator_computed = true; 196 } else { 197 } 198 state.INTERMEDIATE_VALUE |= intermediate; 199 200 return finallyIterator_value; 201 } 202 /** 203 * @apilevel internal 204 */ 205 private Iterator<FinallyHost> finallyIterator_compute() { 206 return new LazyFinallyIterator(this); 207 } 208 /** 209 * @return <code>true</code> if this statement can branch to 210 * the target statement. 211 * @attribute syn 212 * @aspect BranchTarget 213 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:187 214 */ 215 @ASTNodeAnnotation.Attribute 216 public boolean canBranchTo(BranchTargetStmt target) { 217 boolean canBranchTo_BranchTargetStmt_value = false; 218 219 return canBranchTo_BranchTargetStmt_value; 220 } 221 /** 222 * @attribute syn 223 * @aspect BranchTarget 224 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:188 225 */ 226 @ASTNodeAnnotation.Attribute 227 public boolean canBranchTo(LabeledStmt target) { 228 boolean canBranchTo_LabeledStmt_value = false; 229 230 return canBranchTo_LabeledStmt_value; 231 } 232 /** 233 * @attribute syn 234 * @aspect BranchTarget 235 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:189 236 */ 237 @ASTNodeAnnotation.Attribute 238 public boolean canBranchTo(SwitchStmt target) { 239 boolean canBranchTo_SwitchStmt_value = false; 240 241 return canBranchTo_SwitchStmt_value; 242 } 243 /** 244 * @apilevel internal 245 */ 246 protected java.util.Map isDAafter_Variable_values; 247 /** 248 * @apilevel internal 249 */ 250 private void isDAafter_Variable_reset() { 251 isDAafter_Variable_values = null; 252 } 253 /** 254 * @attribute syn 255 * @aspect DA 256 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 257 */ 258 @ASTNodeAnnotation.Attribute 259 public boolean isDAafter(Variable v) { 260 Object _parameters = v; 261 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 262 ASTNode$State state = state(); 263 if (isDAafter_Variable_values.containsKey(_parameters)) { 264 return (Boolean) isDAafter_Variable_values.get(_parameters); 265 } 266 boolean intermediate = state.INTERMEDIATE_VALUE; 267 state.INTERMEDIATE_VALUE = false; 268 int num = state.boundariesCrossed; 269 boolean isFinal = this.is$Final(); 270 boolean isDAafter_Variable_value = isDAbefore(v); 271 if (isFinal && num == state().boundariesCrossed) { 272 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 273 } else { 274 } 275 state.INTERMEDIATE_VALUE |= intermediate; 276 277 return isDAafter_Variable_value; 278 } 279 /** 280 * @apilevel internal 281 */ 282 protected java.util.Map isDUafter_Variable_values; 283 /** 284 * @apilevel internal 285 */ 286 private void isDUafter_Variable_reset() { 287 isDUafter_Variable_values = null; 288 } 289 /** 290 * @attribute syn 291 * @aspect DU 292 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 293 */ 294 @ASTNodeAnnotation.Attribute 295 public boolean isDUafter(Variable v) { 296 Object _parameters = v; 297 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 298 ASTNode$State state = state(); 299 if (isDUafter_Variable_values.containsKey(_parameters)) { 300 return (Boolean) isDUafter_Variable_values.get(_parameters); 301 } 302 boolean intermediate = state.INTERMEDIATE_VALUE; 303 state.INTERMEDIATE_VALUE = false; 304 int num = state.boundariesCrossed; 305 boolean isFinal = this.is$Final(); 306 boolean isDUafter_Variable_value = isDUafter_compute(v); 307 if (isFinal && num == state().boundariesCrossed) { 308 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 309 } else { 310 } 311 state.INTERMEDIATE_VALUE |= intermediate; 312 313 return isDUafter_Variable_value; 314 } 315 /** 316 * @apilevel internal 317 */ 318 private boolean isDUafter_compute(Variable v) { 319 throw new Error("isDUafter in " + getClass().getName()); 320 } 321 /** 322 * @attribute syn 323 * @aspect VariableScope 324 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:205 325 */ 326 @ASTNodeAnnotation.Attribute 327 public VariableDeclaration variableDeclaration(String name) { 328 VariableDeclaration variableDeclaration_String_value = null; 329 330 return variableDeclaration_String_value; 331 } 332 /** 333 * @attribute syn 334 * @aspect NameCheck 335 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:478 336 */ 337 @ASTNodeAnnotation.Attribute 338 public boolean continueLabel() { 339 boolean continueLabel_value = false; 340 341 return continueLabel_value; 342 } 343 /** 344 * @apilevel internal 345 */ 346 protected boolean canCompleteNormally_computed = false; 347 /** 348 * @apilevel internal 349 */ 350 protected boolean canCompleteNormally_value; 351 /** 352 * @apilevel internal 353 */ 354 private void canCompleteNormally_reset() { 355 canCompleteNormally_computed = false; 356 } 357 /** 358 * @attribute syn 359 * @aspect UnreachableStatements 360 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 361 */ 362 @ASTNodeAnnotation.Attribute 363 public boolean canCompleteNormally() { 364 ASTNode$State state = state(); 365 if (canCompleteNormally_computed) { 366 return canCompleteNormally_value; 367 } 368 boolean intermediate = state.INTERMEDIATE_VALUE; 369 state.INTERMEDIATE_VALUE = false; 370 int num = state.boundariesCrossed; 371 boolean isFinal = this.is$Final(); 372 canCompleteNormally_value = true; 373 if (isFinal && num == state().boundariesCrossed) { 374 canCompleteNormally_computed = true; 375 } else { 376 } 377 state.INTERMEDIATE_VALUE |= intermediate; 378 379 return canCompleteNormally_value; 380 } 381 /** 382 * @attribute syn 383 * @aspect CreateBCode 384 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621 385 */ 386 @ASTNodeAnnotation.Attribute 387 public int break_label() { 388 { 389 throw new UnsupportedOperationException("Can not break at this statement of type " + getClass().getName()); 390 } 391 } 392 /** 393 * @attribute syn 394 * @aspect CreateBCode 395 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645 396 */ 397 @ASTNodeAnnotation.Attribute 398 public int continue_label() { 399 { 400 throw new UnsupportedOperationException("Can not continue at this statement"); 401 } 402 } 403 /** 404 * @apilevel internal 405 */ 406 protected boolean localSize_computed = false; 407 /** 408 * @apilevel internal 409 */ 410 protected int localSize_value; 411 /** 412 * @apilevel internal 413 */ 414 private void localSize_reset() { 415 localSize_computed = false; 416 } 417 /** 418 * Computes size required for local variables of this statement. 419 * NB: only relevant for variable declaration statements. 420 * @return local size for declared variables 421 * @attribute syn 422 * @aspect LocalNum 423 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:38 424 */ 425 @ASTNodeAnnotation.Attribute 426 public int localSize() { 427 ASTNode$State state = state(); 428 if (localSize_computed) { 429 return localSize_value; 430 } 431 boolean intermediate = state.INTERMEDIATE_VALUE; 432 state.INTERMEDIATE_VALUE = false; 433 int num = state.boundariesCrossed; 434 boolean isFinal = this.is$Final(); 435 localSize_value = 0; 436 if (isFinal && num == state().boundariesCrossed) { 437 localSize_computed = true; 438 } else { 439 } 440 state.INTERMEDIATE_VALUE |= intermediate; 441 442 return localSize_value; 443 } 444 /** 445 * @return the target statement for a break or continue 446 * @attribute inh 447 * @aspect BranchTarget 448 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 449 */ 450 /** 451 * @return the target statement for a break or continue 452 * @attribute inh 453 * @aspect BranchTarget 454 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 455 */ 456 @ASTNodeAnnotation.Attribute 457 public Stmt branchTarget(Stmt branch) { 458 Stmt branchTarget_Stmt_value = getParent().Define_branchTarget(this, null, branch); 459 460 return branchTarget_Stmt_value; 461 } 462 /** 463 * Find finally block of enclosing try-statement, or monitor exit 464 * block of enclosing synchronized block. 465 * @param branch the source branch 466 * @return a finally block, or <code>null</code> if there is no 467 * enclosing try-statement 468 * @attribute inh 469 * @aspect BranchTarget 470 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262 471 */ 472 /** 473 * Find finally block of enclosing try-statement, or monitor exit 474 * block of enclosing synchronized block. 475 * @param branch the source branch 476 * @return a finally block, or <code>null</code> if there is no 477 * enclosing try-statement 478 * @attribute inh 479 * @aspect BranchTarget 480 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262 481 */ 482 @ASTNodeAnnotation.Attribute 483 public FinallyHost enclosingFinally(Stmt branch) { 484 Object _parameters = branch; 485 if (enclosingFinally_Stmt_values == null) enclosingFinally_Stmt_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 486 ASTNode$State state = state(); 487 if (enclosingFinally_Stmt_values.containsKey(_parameters)) { 488 return (FinallyHost) enclosingFinally_Stmt_values.get(_parameters); 489 } 490 boolean intermediate = state.INTERMEDIATE_VALUE; 491 state.INTERMEDIATE_VALUE = false; 492 int num = state.boundariesCrossed; 493 boolean isFinal = this.is$Final(); 494 FinallyHost enclosingFinally_Stmt_value = getParent().Define_enclosingFinally(this, null, branch); 495 if (isFinal && num == state().boundariesCrossed) { 496 enclosingFinally_Stmt_values.put(_parameters, enclosingFinally_Stmt_value); 497 } else { 498 } 499 state.INTERMEDIATE_VALUE |= intermediate; 500 501 return enclosingFinally_Stmt_value; 502 } 503 /** 504 * @apilevel internal 505 */ 506 protected java.util.Map enclosingFinally_Stmt_values; 507 /** 508 * @apilevel internal 509 */ 510 private void enclosingFinally_Stmt_reset() { 511 enclosingFinally_Stmt_values = null; 512 } 513 /** 514 * @attribute inh 515 * @aspect DA 516 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 517 */ 518 /** 519 * @attribute inh 520 * @aspect DA 521 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 522 */ 523 @ASTNodeAnnotation.Attribute 524 public boolean isDAbefore(Variable v) { 525 boolean isDAbefore_Variable_value = getParent().Define_isDAbefore(this, null, v); 526 527 return isDAbefore_Variable_value; 528 } 529 /** 530 * @attribute inh 531 * @aspect DU 532 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 533 */ 534 /** 535 * @attribute inh 536 * @aspect DU 537 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 538 */ 539 @ASTNodeAnnotation.Attribute 540 public boolean isDUbefore(Variable v) { 541 boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v); 542 543 return isDUbefore_Variable_value; 544 } 545 /** 546 * @attribute inh 547 * @aspect LookupMethod 548 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 549 */ 550 /** 551 * @attribute inh 552 * @aspect LookupMethod 553 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 554 */ 555 @ASTNodeAnnotation.Attribute 556 public Collection lookupMethod(String name) { 557 Collection lookupMethod_String_value = getParent().Define_lookupMethod(this, null, name); 558 559 return lookupMethod_String_value; 560 } 561 /** 562 * @attribute inh 563 * @aspect LookupFullyQualifiedTypes 564 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:130 565 */ 566 /** 567 * @attribute inh 568 * @aspect LookupFullyQualifiedTypes 569 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:130 570 */ 571 @ASTNodeAnnotation.Attribute 572 public TypeDecl lookupType(String packageName, String typeName) { 573 TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName); 574 575 return lookupType_String_String_value; 576 } 577 /** 578 * @attribute inh 579 * @aspect TypeScopePropagation 580 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:339 581 */ 582 /** 583 * @attribute inh 584 * @aspect TypeScopePropagation 585 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:339 586 */ 587 @ASTNodeAnnotation.Attribute 588 public SimpleSet lookupType(String name) { 589 SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name); 590 591 return lookupType_String_value; 592 } 593 /** 594 * @attribute inh 595 * @aspect VariableScope 596 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:37 597 */ 598 /** 599 * @attribute inh 600 * @aspect VariableScope 601 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:37 602 */ 603 @ASTNodeAnnotation.Attribute 604 public SimpleSet lookupVariable(String name) { 605 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 606 607 return lookupVariable_String_value; 608 } 609 /** 610 * @attribute inh 611 * @aspect NestedTypes 612 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:561 613 */ 614 /** 615 * @attribute inh 616 * @aspect NestedTypes 617 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:561 618 */ 619 @ASTNodeAnnotation.Attribute 620 public BodyDecl enclosingBodyDecl() { 621 BodyDecl enclosingBodyDecl_value = getParent().Define_enclosingBodyDecl(this, null); 622 623 return enclosingBodyDecl_value; 624 } 625 /** 626 * @attribute inh 627 * @aspect NestedTypes 628 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:639 629 */ 630 /** 631 * @attribute inh 632 * @aspect NestedTypes 633 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:639 634 */ 635 @ASTNodeAnnotation.Attribute 636 public TypeDecl hostType() { 637 TypeDecl hostType_value = getParent().Define_hostType(this, null); 638 639 return hostType_value; 640 } 641 /** 642 * @attribute inh 643 * @aspect UnreachableStatements 644 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:51 645 */ 646 /** 647 * @attribute inh 648 * @aspect UnreachableStatements 649 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:51 650 */ 651 @ASTNodeAnnotation.Attribute 652 public boolean reachable() { 653 boolean reachable_value = getParent().Define_reachable(this, null); 654 655 return reachable_value; 656 } 657 /** 658 * @attribute inh 659 * @aspect UnreachableStatements 660 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:209 661 */ 662 /** 663 * @attribute inh 664 * @aspect UnreachableStatements 665 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:209 666 */ 667 @ASTNodeAnnotation.Attribute 668 public boolean reportUnreachable() { 669 boolean reportUnreachable_value = getParent().Define_reportUnreachable(this, null); 670 671 return reportUnreachable_value; 672 } 673 /** 674 * Checks if the branch statement leaves the monitor. 675 * @return <code>true</code> if the branch leaves the monitor 676 * @attribute inh 677 * @aspect CreateBCode 678 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836 679 */ 680 /** 681 * Checks if the branch statement leaves the monitor. 682 * @return <code>true</code> if the branch leaves the monitor 683 * @attribute inh 684 * @aspect CreateBCode 685 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836 686 */ 687 @ASTNodeAnnotation.Attribute 688 public boolean leavesMonitor(Stmt branch, SynchronizedStmt monitor) { 689 boolean leavesMonitor_Stmt_SynchronizedStmt_value = getParent().Define_leavesMonitor(this, null, branch, monitor); 690 691 return leavesMonitor_Stmt_SynchronizedStmt_value; 692 } 693 /** 694 * @return The next available local variable index. 695 * @attribute inh 696 * @aspect LocalNum 697 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:63 698 */ 699 /** 700 * @return The next available local variable index. 701 * @attribute inh 702 * @aspect LocalNum 703 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:63 704 */ 705 @ASTNodeAnnotation.Attribute 706 public int localNum() { 707 ASTNode$State state = state(); 708 if (localNum_computed) { 709 return localNum_value; 710 } 711 boolean intermediate = state.INTERMEDIATE_VALUE; 712 state.INTERMEDIATE_VALUE = false; 713 int num = state.boundariesCrossed; 714 boolean isFinal = this.is$Final(); 715 localNum_value = getParent().Define_localNum(this, null); 716 if (isFinal && num == state().boundariesCrossed) { 717 localNum_computed = true; 718 } else { 719 } 720 state.INTERMEDIATE_VALUE |= intermediate; 721 722 return localNum_value; 723 } 724 /** 725 * @apilevel internal 726 */ 727 protected boolean localNum_computed = false; 728 /** 729 * @apilevel internal 730 */ 731 protected int localNum_value; 732 /** 733 * @apilevel internal 734 */ 735 private void localNum_reset() { 736 localNum_computed = false; 737 } 738 /** 739 * @apilevel internal 740 */ 741 public ASTNode rewriteTo() { 742 return super.rewriteTo(); 743 } 744 }