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:195 027 * @production LabeledStmt : {@link BranchTargetStmt} ::= <span class="component"><Label:String></span> <span class="component">{@link Stmt}</span>; 028 029 */ 030 public class LabeledStmt extends BranchTargetStmt implements Cloneable { 031 /** 032 * @aspect NameCheck 033 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:431 034 */ 035 public void nameCheck() { 036 LabeledStmt stmt = lookupLabel(getLabel()); 037 if (stmt != null) { 038 if (stmt.enclosingBodyDecl() == enclosingBodyDecl()) { 039 error("Labels can not shadow labels in the same member"); 040 } 041 } 042 } 043 /** 044 * @aspect Java4PrettyPrint 045 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:155 046 */ 047 public void prettyPrint(PrettyPrinter out) { 048 out.print(getLabel()); 049 out.print(":"); 050 } 051 /** 052 * @aspect CreateBCode 053 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1382 054 */ 055 public void createBCode(CodeGeneration gen) { 056 super.createBCode(gen); 057 gen.addLabel(label()); 058 getStmt().createBCode(gen); 059 gen.addLabel(end_label()); 060 } 061 /** 062 * @declaredat ASTNode:1 063 */ 064 public LabeledStmt() { 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 children = new ASTNode[1]; 076 } 077 /** 078 * @declaredat ASTNode:13 079 */ 080 public LabeledStmt(String p0, Stmt p1) { 081 setLabel(p0); 082 setChild(p1, 0); 083 } 084 /** 085 * @declaredat ASTNode:17 086 */ 087 public LabeledStmt(beaver.Symbol p0, Stmt p1) { 088 setLabel(p0); 089 setChild(p1, 0); 090 } 091 /** 092 * @apilevel low-level 093 * @declaredat ASTNode:24 094 */ 095 protected int numChildren() { 096 return 1; 097 } 098 /** 099 * @apilevel internal 100 * @declaredat ASTNode:30 101 */ 102 public boolean mayHaveRewrite() { 103 return false; 104 } 105 /** 106 * @apilevel internal 107 * @declaredat ASTNode:36 108 */ 109 public void flushAttrCache() { 110 super.flushAttrCache(); 111 isDAafter_Variable_reset(); 112 isDUafter_Variable_reset(); 113 canCompleteNormally_reset(); 114 label_reset(); 115 end_label_reset(); 116 lookupLabel_String_reset(); 117 } 118 /** 119 * @apilevel internal 120 * @declaredat ASTNode:48 121 */ 122 public void flushCollectionCache() { 123 super.flushCollectionCache(); 124 } 125 /** 126 * @apilevel internal 127 * @declaredat ASTNode:54 128 */ 129 public void flushRewriteCache() { 130 super.flushRewriteCache(); 131 } 132 /** 133 * @apilevel internal 134 * @declaredat ASTNode:60 135 */ 136 public LabeledStmt clone() throws CloneNotSupportedException { 137 LabeledStmt node = (LabeledStmt) super.clone(); 138 return node; 139 } 140 /** 141 * @apilevel internal 142 * @declaredat ASTNode:67 143 */ 144 public LabeledStmt copy() { 145 try { 146 LabeledStmt node = (LabeledStmt) clone(); 147 node.parent = null; 148 if (children != null) { 149 node.children = (ASTNode[]) children.clone(); 150 } 151 return node; 152 } catch (CloneNotSupportedException e) { 153 throw new Error("Error: clone not supported for " + getClass().getName()); 154 } 155 } 156 /** 157 * Create a deep copy of the AST subtree at this node. 158 * The copy is dangling, i.e. has no parent. 159 * @return dangling copy of the subtree at this node 160 * @apilevel low-level 161 * @deprecated Please use treeCopy or treeCopyNoTransform instead 162 * @declaredat ASTNode:86 163 */ 164 @Deprecated 165 public LabeledStmt fullCopy() { 166 return treeCopyNoTransform(); 167 } 168 /** 169 * Create a deep copy of the AST subtree at this node. 170 * The copy is dangling, i.e. has no parent. 171 * @return dangling copy of the subtree at this node 172 * @apilevel low-level 173 * @declaredat ASTNode:96 174 */ 175 public LabeledStmt treeCopyNoTransform() { 176 LabeledStmt tree = (LabeledStmt) copy(); 177 if (children != null) { 178 for (int i = 0; i < children.length; ++i) { 179 ASTNode child = (ASTNode) children[i]; 180 if (child != null) { 181 child = child.treeCopyNoTransform(); 182 tree.setChild(child, i); 183 } 184 } 185 } 186 return tree; 187 } 188 /** 189 * Create a deep copy of the AST subtree at this node. 190 * The subtree of this node is traversed to trigger rewrites before copy. 191 * The copy is dangling, i.e. has no parent. 192 * @return dangling copy of the subtree at this node 193 * @apilevel low-level 194 * @declaredat ASTNode:116 195 */ 196 public LabeledStmt treeCopy() { 197 doFullTraversal(); 198 return treeCopyNoTransform(); 199 } 200 /** 201 * @apilevel internal 202 * @declaredat ASTNode:123 203 */ 204 protected boolean is$Equal(ASTNode node) { 205 return super.is$Equal(node) && (tokenString_Label == ((LabeledStmt)node).tokenString_Label); 206 } 207 /** 208 * Replaces the lexeme Label. 209 * @param value The new value for the lexeme Label. 210 * @apilevel high-level 211 */ 212 public void setLabel(String value) { 213 tokenString_Label = value; 214 } 215 /** 216 * @apilevel internal 217 */ 218 protected String tokenString_Label; 219 /** 220 */ 221 public int Labelstart; 222 /** 223 */ 224 public int Labelend; 225 /** 226 * JastAdd-internal setter for lexeme Label using the Beaver parser. 227 * @param symbol Symbol containing the new value for the lexeme Label 228 * @apilevel internal 229 */ 230 public void setLabel(beaver.Symbol symbol) { 231 if (symbol.value != null && !(symbol.value instanceof String)) 232 throw new UnsupportedOperationException("setLabel is only valid for String lexemes"); 233 tokenString_Label = (String)symbol.value; 234 Labelstart = symbol.getStart(); 235 Labelend = symbol.getEnd(); 236 } 237 /** 238 * Retrieves the value for the lexeme Label. 239 * @return The value for the lexeme Label. 240 * @apilevel high-level 241 */ 242 @ASTNodeAnnotation.Token(name="Label") 243 public String getLabel() { 244 return tokenString_Label != null ? tokenString_Label : ""; 245 } 246 /** 247 * Replaces the Stmt child. 248 * @param node The new node to replace the Stmt child. 249 * @apilevel high-level 250 */ 251 public void setStmt(Stmt node) { 252 setChild(node, 0); 253 } 254 /** 255 * Retrieves the Stmt child. 256 * @return The current node used as the Stmt child. 257 * @apilevel high-level 258 */ 259 @ASTNodeAnnotation.Child(name="Stmt") 260 public Stmt getStmt() { 261 return (Stmt) getChild(0); 262 } 263 /** 264 * Retrieves the Stmt child. 265 * <p><em>This method does not invoke AST transformations.</em></p> 266 * @return The current node used as the Stmt child. 267 * @apilevel low-level 268 */ 269 public Stmt getStmtNoTransform() { 270 return (Stmt) getChildNoTransform(0); 271 } 272 /** 273 * @return <code>true</code> if this statement is a potential 274 * branch target of the given branch statement. 275 * @attribute syn 276 * @aspect BranchTarget 277 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:217 278 */ 279 @ASTNodeAnnotation.Attribute 280 public boolean potentialTargetOf(Stmt branch) { 281 boolean potentialTargetOf_Stmt_value = branch.canBranchTo(this); 282 283 return potentialTargetOf_Stmt_value; 284 } 285 /** 286 * @apilevel internal 287 */ 288 protected java.util.Map isDAafter_Variable_values; 289 /** 290 * @apilevel internal 291 */ 292 private void isDAafter_Variable_reset() { 293 isDAafter_Variable_values = null; 294 } 295 /** 296 * @attribute syn 297 * @aspect DA 298 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 299 */ 300 @ASTNodeAnnotation.Attribute 301 public boolean isDAafter(Variable v) { 302 Object _parameters = v; 303 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 304 ASTNode$State state = state(); 305 if (isDAafter_Variable_values.containsKey(_parameters)) { 306 return (Boolean) isDAafter_Variable_values.get(_parameters); 307 } 308 boolean intermediate = state.INTERMEDIATE_VALUE; 309 state.INTERMEDIATE_VALUE = false; 310 int num = state.boundariesCrossed; 311 boolean isFinal = this.is$Final(); 312 boolean isDAafter_Variable_value = isDAafter_compute(v); 313 if (isFinal && num == state().boundariesCrossed) { 314 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 315 } else { 316 } 317 state.INTERMEDIATE_VALUE |= intermediate; 318 319 return isDAafter_Variable_value; 320 } 321 /** 322 * @apilevel internal 323 */ 324 private boolean isDAafter_compute(Variable v) { 325 if (!getStmt().isDAafter(v)) { 326 return false; 327 } 328 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 329 BreakStmt stmt = (BreakStmt) iter.next(); 330 if (!stmt.isDAafterReachedFinallyBlocks(v)) { 331 return false; 332 } 333 } 334 return true; 335 } 336 /** 337 * @apilevel internal 338 */ 339 protected java.util.Map isDUafter_Variable_values; 340 /** 341 * @apilevel internal 342 */ 343 private void isDUafter_Variable_reset() { 344 isDUafter_Variable_values = null; 345 } 346 /** 347 * @attribute syn 348 * @aspect DU 349 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 350 */ 351 @ASTNodeAnnotation.Attribute 352 public boolean isDUafter(Variable v) { 353 Object _parameters = v; 354 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 355 ASTNode$State state = state(); 356 if (isDUafter_Variable_values.containsKey(_parameters)) { 357 return (Boolean) isDUafter_Variable_values.get(_parameters); 358 } 359 boolean intermediate = state.INTERMEDIATE_VALUE; 360 state.INTERMEDIATE_VALUE = false; 361 int num = state.boundariesCrossed; 362 boolean isFinal = this.is$Final(); 363 boolean isDUafter_Variable_value = isDUafter_compute(v); 364 if (isFinal && num == state().boundariesCrossed) { 365 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 366 } else { 367 } 368 state.INTERMEDIATE_VALUE |= intermediate; 369 370 return isDUafter_Variable_value; 371 } 372 /** 373 * @apilevel internal 374 */ 375 private boolean isDUafter_compute(Variable v) { 376 if (!getStmt().isDUafter(v)) { 377 return false; 378 } 379 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 380 BreakStmt stmt = (BreakStmt) iter.next(); 381 if (!stmt.isDUafterReachedFinallyBlocks(v)) { 382 return false; 383 } 384 } 385 return true; 386 } 387 /** 388 * @apilevel internal 389 */ 390 protected boolean canCompleteNormally_computed = false; 391 /** 392 * @apilevel internal 393 */ 394 protected boolean canCompleteNormally_value; 395 /** 396 * @apilevel internal 397 */ 398 private void canCompleteNormally_reset() { 399 canCompleteNormally_computed = false; 400 } 401 /** 402 * @attribute syn 403 * @aspect UnreachableStatements 404 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 405 */ 406 @ASTNodeAnnotation.Attribute 407 public boolean canCompleteNormally() { 408 ASTNode$State state = state(); 409 if (canCompleteNormally_computed) { 410 return canCompleteNormally_value; 411 } 412 boolean intermediate = state.INTERMEDIATE_VALUE; 413 state.INTERMEDIATE_VALUE = false; 414 int num = state.boundariesCrossed; 415 boolean isFinal = this.is$Final(); 416 canCompleteNormally_value = getStmt().canCompleteNormally() || reachableBreak(); 417 if (isFinal && num == state().boundariesCrossed) { 418 canCompleteNormally_computed = true; 419 } else { 420 } 421 state.INTERMEDIATE_VALUE |= intermediate; 422 423 return canCompleteNormally_value; 424 } 425 /** 426 * @apilevel internal 427 */ 428 protected boolean label_computed = false; 429 /** 430 * @apilevel internal 431 */ 432 protected int label_value; 433 /** 434 * @apilevel internal 435 */ 436 private void label_reset() { 437 label_computed = false; 438 } 439 /** 440 * @attribute syn 441 * @aspect CreateBCode 442 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1380 443 */ 444 @ASTNodeAnnotation.Attribute 445 public int label() { 446 ASTNode$State state = state(); 447 if (label_computed) { 448 return label_value; 449 } 450 boolean intermediate = state.INTERMEDIATE_VALUE; 451 state.INTERMEDIATE_VALUE = false; 452 int num = state.boundariesCrossed; 453 boolean isFinal = this.is$Final(); 454 label_value = hostType().constantPool().newLabel(); 455 if (isFinal && num == state().boundariesCrossed) { 456 label_computed = true; 457 } else { 458 } 459 state.INTERMEDIATE_VALUE |= intermediate; 460 461 return label_value; 462 } 463 /** 464 * @apilevel internal 465 */ 466 protected boolean end_label_computed = false; 467 /** 468 * @apilevel internal 469 */ 470 protected int end_label_value; 471 /** 472 * @apilevel internal 473 */ 474 private void end_label_reset() { 475 end_label_computed = false; 476 } 477 /** 478 * @attribute syn 479 * @aspect CreateBCode 480 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1381 481 */ 482 @ASTNodeAnnotation.Attribute 483 public int end_label() { 484 ASTNode$State state = state(); 485 if (end_label_computed) { 486 return end_label_value; 487 } 488 boolean intermediate = state.INTERMEDIATE_VALUE; 489 state.INTERMEDIATE_VALUE = false; 490 int num = state.boundariesCrossed; 491 boolean isFinal = this.is$Final(); 492 end_label_value = hostType().constantPool().newLabel(); 493 if (isFinal && num == state().boundariesCrossed) { 494 end_label_computed = true; 495 } else { 496 } 497 state.INTERMEDIATE_VALUE |= intermediate; 498 499 return end_label_value; 500 } 501 /** 502 * @attribute syn 503 * @aspect CreateBCode 504 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621 505 */ 506 @ASTNodeAnnotation.Attribute 507 public int break_label() { 508 int break_label_value = end_label(); 509 510 return break_label_value; 511 } 512 /** 513 * @attribute syn 514 * @aspect CreateBCode 515 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645 516 */ 517 @ASTNodeAnnotation.Attribute 518 public int continue_label() { 519 int continue_label_value = getStmt().continue_label(); 520 521 return continue_label_value; 522 } 523 /** 524 * @attribute syn 525 * @aspect PreciseRethrow 526 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 527 */ 528 @ASTNodeAnnotation.Attribute 529 public boolean modifiedInScope(Variable var) { 530 boolean modifiedInScope_Variable_value = getStmt().modifiedInScope(var); 531 532 return modifiedInScope_Variable_value; 533 } 534 /** 535 * @attribute inh 536 * @aspect BranchTarget 537 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:251 538 */ 539 /** 540 * @attribute inh 541 * @aspect BranchTarget 542 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:251 543 */ 544 @ASTNodeAnnotation.Attribute 545 public LabeledStmt lookupLabel(String name) { 546 Object _parameters = name; 547 if (lookupLabel_String_values == null) lookupLabel_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 548 ASTNode$State state = state(); 549 if (lookupLabel_String_values.containsKey(_parameters)) { 550 return (LabeledStmt) lookupLabel_String_values.get(_parameters); 551 } 552 boolean intermediate = state.INTERMEDIATE_VALUE; 553 state.INTERMEDIATE_VALUE = false; 554 int num = state.boundariesCrossed; 555 boolean isFinal = this.is$Final(); 556 LabeledStmt lookupLabel_String_value = getParent().Define_lookupLabel(this, null, name); 557 if (isFinal && num == state().boundariesCrossed) { 558 lookupLabel_String_values.put(_parameters, lookupLabel_String_value); 559 } else { 560 } 561 state.INTERMEDIATE_VALUE |= intermediate; 562 563 return lookupLabel_String_value; 564 } 565 /** 566 * @apilevel internal 567 */ 568 protected java.util.Map lookupLabel_String_values; 569 /** 570 * @apilevel internal 571 */ 572 private void lookupLabel_String_reset() { 573 lookupLabel_String_values = null; 574 } 575 /** 576 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 577 * @apilevel internal 578 */ 579 public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 580 int childIndex = this.getIndexOfChild(caller); 581 return branch.canBranchTo(this) ? this : branchTarget(branch); 582 } 583 protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 584 return true; 585 } 586 /** 587 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:250 588 * @apilevel internal 589 */ 590 public LabeledStmt Define_lookupLabel(ASTNode caller, ASTNode child, String name) { 591 if (caller == getStmtNoTransform()) { 592 // @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:252 593 return name.equals(getLabel()) ? this : lookupLabel(name); 594 } 595 else { 596 return getParent().Define_lookupLabel(this, caller, name); 597 } 598 } 599 protected boolean canDefine_lookupLabel(ASTNode caller, ASTNode child, String name) { 600 return true; 601 } 602 /** 603 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 604 * @apilevel internal 605 */ 606 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 607 if (caller == getStmtNoTransform()) { 608 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:573 609 return isDAbefore(v); 610 } 611 else { 612 return getParent().Define_isDAbefore(this, caller, v); 613 } 614 } 615 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 616 return true; 617 } 618 /** 619 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 620 * @apilevel internal 621 */ 622 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 623 if (caller == getStmtNoTransform()) { 624 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1018 625 return isDUbefore(v); 626 } 627 else { 628 return getParent().Define_isDUbefore(this, caller, v); 629 } 630 } 631 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 632 return true; 633 } 634 /** 635 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 636 * @apilevel internal 637 */ 638 public boolean Define_reachable(ASTNode caller, ASTNode child) { 639 if (caller == getStmtNoTransform()) { 640 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:84 641 return reachable(); 642 } 643 else { 644 return getParent().Define_reachable(this, caller); 645 } 646 } 647 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 648 return true; 649 } 650 /** 651 * @apilevel internal 652 */ 653 public ASTNode rewriteTo() { 654 return super.rewriteTo(); 655 } 656 }