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