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:209 027 * @production ContinueStmt : {@link Stmt} ::= <span class="component"><Label:String></span> <span class="component">[Finally:{@link Block}]</span>; 028 029 */ 030 public class ContinueStmt extends Stmt implements Cloneable { 031 /** 032 * @aspect BranchTarget 033 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:96 034 */ 035 public void collectBranches(Collection<Stmt> c) { 036 c.add(this); 037 } 038 /** 039 * @aspect NameCheck 040 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:465 041 */ 042 public void nameCheck() { 043 if (!insideLoop()) { 044 error("continue outside loop"); 045 } else if (hasLabel()) { 046 LabeledStmt label = lookupLabel(getLabel()); 047 if (label == null) { 048 error("labeled continue must have visible matching label"); 049 } else if (!label.getStmt().continueLabel()) { 050 errorf("%s is not a loop label", getLabel()); 051 } 052 } 053 } 054 /** 055 * @aspect Java4PrettyPrint 056 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:194 057 */ 058 public void prettyPrint(PrettyPrinter out) { 059 out.print("continue"); 060 if (hasLabel()) { 061 out.print(" "); 062 out.print(getLabel()); 063 } 064 out.print(";"); 065 } 066 /** 067 * @aspect CreateBCode 068 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1656 069 */ 070 public void createBCode(CodeGeneration gen) { 071 super.createBCode(gen); 072 if (hasFinally()) { 073 int nextRange = gen.constantPool().newLabel(); 074 getFinally().createBCode(gen); 075 gen.emitGoto(targetStmt().continue_label()); 076 gen.addLabel(nextRange); 077 gen.monitorRangesStart(this, nextRange); 078 } else { 079 gen.emitGoto(targetStmt().continue_label()); 080 } 081 } 082 /** 083 * @declaredat ASTNode:1 084 */ 085 public ContinueStmt() { 086 super(); 087 } 088 /** 089 * Initializes the child array to the correct size. 090 * Initializes List and Opt nta children. 091 * @apilevel internal 092 * @ast method 093 * @declaredat ASTNode:10 094 */ 095 public void init$Children() { 096 children = new ASTNode[1]; 097 setChild(new Opt(), 0); 098 } 099 /** 100 * @declaredat ASTNode:14 101 */ 102 public ContinueStmt(String p0) { 103 setLabel(p0); 104 } 105 /** 106 * @declaredat ASTNode:17 107 */ 108 public ContinueStmt(beaver.Symbol p0) { 109 setLabel(p0); 110 } 111 /** 112 * @apilevel low-level 113 * @declaredat ASTNode:23 114 */ 115 protected int numChildren() { 116 return 0; 117 } 118 /** 119 * @apilevel internal 120 * @declaredat ASTNode:29 121 */ 122 public boolean mayHaveRewrite() { 123 return false; 124 } 125 /** 126 * @apilevel internal 127 * @declaredat ASTNode:35 128 */ 129 public void flushAttrCache() { 130 super.flushAttrCache(); 131 targetStmt_reset(); 132 isDAafter_Variable_reset(); 133 isDUafterReachedFinallyBlocks_Variable_reset(); 134 isDAafterReachedFinallyBlocks_Variable_reset(); 135 isDUafter_Variable_reset(); 136 getFinallyOpt_reset(); 137 canCompleteNormally_reset(); 138 lookupLabel_String_reset(); 139 } 140 /** 141 * @apilevel internal 142 * @declaredat ASTNode:49 143 */ 144 public void flushCollectionCache() { 145 super.flushCollectionCache(); 146 } 147 /** 148 * @apilevel internal 149 * @declaredat ASTNode:55 150 */ 151 public void flushRewriteCache() { 152 super.flushRewriteCache(); 153 } 154 /** 155 * @apilevel internal 156 * @declaredat ASTNode:61 157 */ 158 public ContinueStmt clone() throws CloneNotSupportedException { 159 ContinueStmt node = (ContinueStmt) super.clone(); 160 return node; 161 } 162 /** 163 * @apilevel internal 164 * @declaredat ASTNode:68 165 */ 166 public ContinueStmt copy() { 167 try { 168 ContinueStmt node = (ContinueStmt) clone(); 169 node.parent = null; 170 if (children != null) { 171 node.children = (ASTNode[]) children.clone(); 172 } 173 return node; 174 } catch (CloneNotSupportedException e) { 175 throw new Error("Error: clone not supported for " + getClass().getName()); 176 } 177 } 178 /** 179 * Create a deep copy of the AST subtree at this node. 180 * The copy is dangling, i.e. has no parent. 181 * @return dangling copy of the subtree at this node 182 * @apilevel low-level 183 * @deprecated Please use treeCopy or treeCopyNoTransform instead 184 * @declaredat ASTNode:87 185 */ 186 @Deprecated 187 public ContinueStmt fullCopy() { 188 return treeCopyNoTransform(); 189 } 190 /** 191 * Create a deep copy of the AST subtree at this node. 192 * The copy is dangling, i.e. has no parent. 193 * @return dangling copy of the subtree at this node 194 * @apilevel low-level 195 * @declaredat ASTNode:97 196 */ 197 public ContinueStmt treeCopyNoTransform() { 198 ContinueStmt tree = (ContinueStmt) copy(); 199 if (children != null) { 200 for (int i = 0; i < children.length; ++i) { 201 switch (i) { 202 case 0: 203 tree.children[i] = new Opt(); 204 continue; 205 } 206 ASTNode child = (ASTNode) children[i]; 207 if (child != null) { 208 child = child.treeCopyNoTransform(); 209 tree.setChild(child, i); 210 } 211 } 212 } 213 return tree; 214 } 215 /** 216 * Create a deep copy of the AST subtree at this node. 217 * The subtree of this node is traversed to trigger rewrites before copy. 218 * The copy is dangling, i.e. has no parent. 219 * @return dangling copy of the subtree at this node 220 * @apilevel low-level 221 * @declaredat ASTNode:122 222 */ 223 public ContinueStmt treeCopy() { 224 doFullTraversal(); 225 return treeCopyNoTransform(); 226 } 227 /** 228 * @apilevel internal 229 * @declaredat ASTNode:129 230 */ 231 protected boolean is$Equal(ASTNode node) { 232 return super.is$Equal(node) && (tokenString_Label == ((ContinueStmt)node).tokenString_Label); 233 } 234 /** 235 * Replaces the lexeme Label. 236 * @param value The new value for the lexeme Label. 237 * @apilevel high-level 238 */ 239 public void setLabel(String value) { 240 tokenString_Label = value; 241 } 242 /** 243 * @apilevel internal 244 */ 245 protected String tokenString_Label; 246 /** 247 */ 248 public int Labelstart; 249 /** 250 */ 251 public int Labelend; 252 /** 253 * JastAdd-internal setter for lexeme Label using the Beaver parser. 254 * @param symbol Symbol containing the new value for the lexeme Label 255 * @apilevel internal 256 */ 257 public void setLabel(beaver.Symbol symbol) { 258 if (symbol.value != null && !(symbol.value instanceof String)) 259 throw new UnsupportedOperationException("setLabel is only valid for String lexemes"); 260 tokenString_Label = (String)symbol.value; 261 Labelstart = symbol.getStart(); 262 Labelend = symbol.getEnd(); 263 } 264 /** 265 * Retrieves the value for the lexeme Label. 266 * @return The value for the lexeme Label. 267 * @apilevel high-level 268 */ 269 @ASTNodeAnnotation.Token(name="Label") 270 public String getLabel() { 271 return tokenString_Label != null ? tokenString_Label : ""; 272 } 273 /** 274 * Replaces the (optional) Finally child. 275 * @param node The new node to be used as the Finally child. 276 * @apilevel high-level 277 */ 278 public void setFinally(Block node) { 279 getFinallyOpt().setChild(node, 0); 280 } 281 /** 282 * Check whether the optional Finally child exists. 283 * @return {@code true} if the optional Finally child exists, {@code false} if it does not. 284 * @apilevel high-level 285 */ 286 public boolean hasFinally() { 287 return getFinallyOpt().getNumChild() != 0; 288 } 289 /** 290 * Retrieves the (optional) Finally child. 291 * @return The Finally child, if it exists. Returns {@code null} otherwise. 292 * @apilevel low-level 293 */ 294 public Block getFinally() { 295 return (Block) getFinallyOpt().getChild(0); 296 } 297 /** 298 * Retrieves the optional node for child Finally. This is the <code>Opt</code> node containing the child Finally, not the actual child! 299 * <p><em>This method does not invoke AST transformations.</em></p> 300 * @return The optional node for child Finally. 301 * @apilevel low-level 302 */ 303 public Opt<Block> getFinallyOptNoTransform() { 304 return (Opt<Block>) getChildNoTransform(0); 305 } 306 /** 307 * Retrieves the child position of the optional child Finally. 308 * @return The the child position of the optional child Finally. 309 * @apilevel low-level 310 */ 311 protected int getFinallyOptChildPosition() { 312 return 0; 313 } 314 /** 315 * @attribute syn 316 * @aspect BranchTarget 317 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:116 318 */ 319 @ASTNodeAnnotation.Attribute 320 public boolean hasLabel() { 321 boolean hasLabel_value = !getLabel().equals(""); 322 323 return hasLabel_value; 324 } 325 /** 326 * @return <code>true</code> if this statement can branch to 327 * the target statement. 328 * @attribute syn 329 * @aspect BranchTarget 330 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:187 331 */ 332 @ASTNodeAnnotation.Attribute 333 public boolean canBranchTo(BranchTargetStmt target) { 334 boolean canBranchTo_BranchTargetStmt_value = !hasLabel(); 335 336 return canBranchTo_BranchTargetStmt_value; 337 } 338 /** 339 * @attribute syn 340 * @aspect BranchTarget 341 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:188 342 */ 343 @ASTNodeAnnotation.Attribute 344 public boolean canBranchTo(LabeledStmt target) { 345 boolean canBranchTo_LabeledStmt_value = hasLabel() && target.getLabel().equals(getLabel()); 346 347 return canBranchTo_LabeledStmt_value; 348 } 349 /** 350 * @attribute syn 351 * @aspect BranchTarget 352 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:189 353 */ 354 @ASTNodeAnnotation.Attribute 355 public boolean canBranchTo(SwitchStmt target) { 356 boolean canBranchTo_SwitchStmt_value = false; 357 358 return canBranchTo_SwitchStmt_value; 359 } 360 /** 361 * @apilevel internal 362 */ 363 protected boolean targetStmt_computed = false; 364 /** 365 * @apilevel internal 366 */ 367 protected Stmt targetStmt_value; 368 /** 369 * @apilevel internal 370 */ 371 private void targetStmt_reset() { 372 targetStmt_computed = false; 373 targetStmt_value = null; 374 } 375 /** 376 * Find the target statement for break and continue. This can be a try 377 * statement with a finally block that can not complete normally. 378 * @attribute syn 379 * @aspect BranchTarget 380 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:46 381 */ 382 @ASTNodeAnnotation.Attribute 383 public Stmt targetStmt() { 384 ASTNode$State state = state(); 385 if (targetStmt_computed) { 386 return targetStmt_value; 387 } 388 boolean intermediate = state.INTERMEDIATE_VALUE; 389 state.INTERMEDIATE_VALUE = false; 390 int num = state.boundariesCrossed; 391 boolean isFinal = this.is$Final(); 392 targetStmt_value = branchTarget(this); 393 if (isFinal && num == state().boundariesCrossed) { 394 targetStmt_computed = true; 395 } else { 396 } 397 state.INTERMEDIATE_VALUE |= intermediate; 398 399 return targetStmt_value; 400 } 401 /** 402 * @apilevel internal 403 */ 404 protected java.util.Map isDAafter_Variable_values; 405 /** 406 * @apilevel internal 407 */ 408 private void isDAafter_Variable_reset() { 409 isDAafter_Variable_values = null; 410 } 411 /** 412 * @attribute syn 413 * @aspect DA 414 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 415 */ 416 @ASTNodeAnnotation.Attribute 417 public boolean isDAafter(Variable v) { 418 Object _parameters = v; 419 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 420 ASTNode$State state = state(); 421 if (isDAafter_Variable_values.containsKey(_parameters)) { 422 return (Boolean) isDAafter_Variable_values.get(_parameters); 423 } 424 boolean intermediate = state.INTERMEDIATE_VALUE; 425 state.INTERMEDIATE_VALUE = false; 426 int num = state.boundariesCrossed; 427 boolean isFinal = this.is$Final(); 428 boolean isDAafter_Variable_value = true; 429 if (isFinal && num == state().boundariesCrossed) { 430 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 431 } else { 432 } 433 state.INTERMEDIATE_VALUE |= intermediate; 434 435 return isDAafter_Variable_value; 436 } 437 /** 438 * @apilevel internal 439 */ 440 protected java.util.Map isDUafterReachedFinallyBlocks_Variable_values; 441 /** 442 * @apilevel internal 443 */ 444 private void isDUafterReachedFinallyBlocks_Variable_reset() { 445 isDUafterReachedFinallyBlocks_Variable_values = null; 446 } 447 /** 448 * @attribute syn 449 * @aspect DU 450 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1071 451 */ 452 @ASTNodeAnnotation.Attribute 453 public boolean isDUafterReachedFinallyBlocks(Variable v) { 454 Object _parameters = v; 455 if (isDUafterReachedFinallyBlocks_Variable_values == null) isDUafterReachedFinallyBlocks_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 456 ASTNode$State state = state(); 457 if (isDUafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) { 458 return (Boolean) isDUafterReachedFinallyBlocks_Variable_values.get(_parameters); 459 } 460 boolean intermediate = state.INTERMEDIATE_VALUE; 461 state.INTERMEDIATE_VALUE = false; 462 int num = state.boundariesCrossed; 463 boolean isFinal = this.is$Final(); 464 boolean isDUafterReachedFinallyBlocks_Variable_value = isDUafterReachedFinallyBlocks_compute(v); 465 if (isFinal && num == state().boundariesCrossed) { 466 isDUafterReachedFinallyBlocks_Variable_values.put(_parameters, isDUafterReachedFinallyBlocks_Variable_value); 467 } else { 468 } 469 state.INTERMEDIATE_VALUE |= intermediate; 470 471 return isDUafterReachedFinallyBlocks_Variable_value; 472 } 473 /** 474 * @apilevel internal 475 */ 476 private boolean isDUafterReachedFinallyBlocks_compute(Variable v) { 477 Iterator<FinallyHost> iter = finallyIterator(); 478 if (!isDUbefore(v) && !iter.hasNext()) { 479 return false; 480 } 481 while (iter.hasNext()) { 482 FinallyHost f = iter.next(); 483 if (!f.isDUafterFinally(v)) { 484 return false; 485 } 486 } 487 return true; 488 } 489 /** 490 * @apilevel internal 491 */ 492 protected java.util.Map isDAafterReachedFinallyBlocks_Variable_values; 493 /** 494 * @apilevel internal 495 */ 496 private void isDAafterReachedFinallyBlocks_Variable_reset() { 497 isDAafterReachedFinallyBlocks_Variable_values = null; 498 } 499 /** 500 * @attribute syn 501 * @aspect DU 502 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1115 503 */ 504 @ASTNodeAnnotation.Attribute 505 public boolean isDAafterReachedFinallyBlocks(Variable v) { 506 Object _parameters = v; 507 if (isDAafterReachedFinallyBlocks_Variable_values == null) isDAafterReachedFinallyBlocks_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 508 ASTNode$State state = state(); 509 if (isDAafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) { 510 return (Boolean) isDAafterReachedFinallyBlocks_Variable_values.get(_parameters); 511 } 512 boolean intermediate = state.INTERMEDIATE_VALUE; 513 state.INTERMEDIATE_VALUE = false; 514 int num = state.boundariesCrossed; 515 boolean isFinal = this.is$Final(); 516 boolean isDAafterReachedFinallyBlocks_Variable_value = isDAafterReachedFinallyBlocks_compute(v); 517 if (isFinal && num == state().boundariesCrossed) { 518 isDAafterReachedFinallyBlocks_Variable_values.put(_parameters, isDAafterReachedFinallyBlocks_Variable_value); 519 } else { 520 } 521 state.INTERMEDIATE_VALUE |= intermediate; 522 523 return isDAafterReachedFinallyBlocks_Variable_value; 524 } 525 /** 526 * @apilevel internal 527 */ 528 private boolean isDAafterReachedFinallyBlocks_compute(Variable v) { 529 if (isDAbefore(v)) { 530 return true; 531 } 532 Iterator<FinallyHost> iter = finallyIterator(); 533 if (!iter.hasNext()) { 534 return false; 535 } 536 while (iter.hasNext()) { 537 FinallyHost f = iter.next(); 538 if (!f.isDAafterFinally(v)) { 539 return false; 540 } 541 } 542 return true; 543 } 544 /** 545 * @apilevel internal 546 */ 547 protected java.util.Map isDUafter_Variable_values; 548 /** 549 * @apilevel internal 550 */ 551 private void isDUafter_Variable_reset() { 552 isDUafter_Variable_values = null; 553 } 554 /** 555 * @attribute syn 556 * @aspect DU 557 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 558 */ 559 @ASTNodeAnnotation.Attribute 560 public boolean isDUafter(Variable v) { 561 Object _parameters = v; 562 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 563 ASTNode$State state = state(); 564 if (isDUafter_Variable_values.containsKey(_parameters)) { 565 return (Boolean) isDUafter_Variable_values.get(_parameters); 566 } 567 boolean intermediate = state.INTERMEDIATE_VALUE; 568 state.INTERMEDIATE_VALUE = false; 569 int num = state.boundariesCrossed; 570 boolean isFinal = this.is$Final(); 571 boolean isDUafter_Variable_value = true; 572 if (isFinal && num == state().boundariesCrossed) { 573 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 574 } else { 575 } 576 state.INTERMEDIATE_VALUE |= intermediate; 577 578 return isDUafter_Variable_value; 579 } 580 /** 581 * @apilevel internal 582 */ 583 protected boolean getFinallyOpt_computed = false; 584 /** 585 * @apilevel internal 586 */ 587 protected Opt<Block> getFinallyOpt_value; 588 /** 589 * @apilevel internal 590 */ 591 private void getFinallyOpt_reset() { 592 getFinallyOpt_computed = false; 593 getFinallyOpt_value = null; 594 } 595 /** 596 * @attribute syn nta 597 * @aspect NTAFinally 598 * @declaredat /home/jesper/git/extendj/java4/frontend/NTAFinally.jrag:57 599 */ 600 @ASTNodeAnnotation.Attribute 601 public Opt<Block> getFinallyOpt() { 602 ASTNode$State state = state(); 603 if (getFinallyOpt_computed) { 604 return (Opt<Block>) getChild(getFinallyOptChildPosition()); 605 } 606 boolean intermediate = state.INTERMEDIATE_VALUE; 607 state.INTERMEDIATE_VALUE = false; 608 int num = state.boundariesCrossed; 609 boolean isFinal = this.is$Final(); 610 getFinallyOpt_value = getFinallyOpt_compute(); 611 setChild(getFinallyOpt_value, getFinallyOptChildPosition()); 612 if (isFinal && num == state().boundariesCrossed) { 613 getFinallyOpt_computed = true; 614 } else { 615 } 616 state.INTERMEDIATE_VALUE |= intermediate; 617 618 Opt<Block> node = (Opt<Block>) this.getChild(getFinallyOptChildPosition()); 619 return node; 620 } 621 /** 622 * @apilevel internal 623 */ 624 private Opt<Block> getFinallyOpt_compute() { 625 return branchFinallyOpt(); 626 } 627 /** 628 * @apilevel internal 629 */ 630 protected boolean canCompleteNormally_computed = false; 631 /** 632 * @apilevel internal 633 */ 634 protected boolean canCompleteNormally_value; 635 /** 636 * @apilevel internal 637 */ 638 private void canCompleteNormally_reset() { 639 canCompleteNormally_computed = false; 640 } 641 /** 642 * @attribute syn 643 * @aspect UnreachableStatements 644 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 645 */ 646 @ASTNodeAnnotation.Attribute 647 public boolean canCompleteNormally() { 648 ASTNode$State state = state(); 649 if (canCompleteNormally_computed) { 650 return canCompleteNormally_value; 651 } 652 boolean intermediate = state.INTERMEDIATE_VALUE; 653 state.INTERMEDIATE_VALUE = false; 654 int num = state.boundariesCrossed; 655 boolean isFinal = this.is$Final(); 656 canCompleteNormally_value = false; 657 if (isFinal && num == state().boundariesCrossed) { 658 canCompleteNormally_computed = true; 659 } else { 660 } 661 state.INTERMEDIATE_VALUE |= intermediate; 662 663 return canCompleteNormally_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 = false; 673 674 return modifiedInScope_Variable_value; 675 } 676 /** 677 * @attribute inh 678 * @aspect BranchTarget 679 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:250 680 */ 681 /** 682 * @attribute inh 683 * @aspect BranchTarget 684 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:250 685 */ 686 @ASTNodeAnnotation.Attribute 687 public LabeledStmt lookupLabel(String name) { 688 Object _parameters = name; 689 if (lookupLabel_String_values == null) lookupLabel_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 690 ASTNode$State state = state(); 691 if (lookupLabel_String_values.containsKey(_parameters)) { 692 return (LabeledStmt) lookupLabel_String_values.get(_parameters); 693 } 694 boolean intermediate = state.INTERMEDIATE_VALUE; 695 state.INTERMEDIATE_VALUE = false; 696 int num = state.boundariesCrossed; 697 boolean isFinal = this.is$Final(); 698 LabeledStmt lookupLabel_String_value = getParent().Define_lookupLabel(this, null, name); 699 if (isFinal && num == state().boundariesCrossed) { 700 lookupLabel_String_values.put(_parameters, lookupLabel_String_value); 701 } else { 702 } 703 state.INTERMEDIATE_VALUE |= intermediate; 704 705 return lookupLabel_String_value; 706 } 707 /** 708 * @apilevel internal 709 */ 710 protected java.util.Map lookupLabel_String_values; 711 /** 712 * @apilevel internal 713 */ 714 private void lookupLabel_String_reset() { 715 lookupLabel_String_values = null; 716 } 717 /** 718 * @attribute inh 719 * @aspect NameCheck 720 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441 721 */ 722 /** 723 * @attribute inh 724 * @aspect NameCheck 725 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441 726 */ 727 @ASTNodeAnnotation.Attribute 728 public boolean insideLoop() { 729 boolean insideLoop_value = getParent().Define_insideLoop(this, null); 730 731 return insideLoop_value; 732 } 733 /** 734 * @apilevel internal 735 */ 736 public ASTNode rewriteTo() { 737 return super.rewriteTo(); 738 } 739 }