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/java5/grammar/EnhancedFor.ast:1 027 * @production EnhancedForStmt : {@link BranchTargetStmt} ::= <span class="component">{@link VariableDeclaration}</span> <span class="component">{@link Expr}</span> <span class="component">{@link Stmt}</span>; 028 029 */ 030 public class EnhancedForStmt extends BranchTargetStmt implements Cloneable, VariableScope { 031 /** 032 * @aspect EnhancedFor 033 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:41 034 */ 035 public void typeCheck() { 036 if (!getExpr().type().isArrayDecl() && !getExpr().type().isIterable()) { 037 errorf("type %s of expression in foreach is neither array type nor java.lang.Iterable", 038 getExpr().type().name()); 039 } else if (getExpr().type().isArrayDecl() && !getExpr().type().componentType().assignConversionTo(getVariableDeclaration().type(), null)) { 040 errorf("parameter of type %s can not be assigned an element of type %s", 041 getVariableDeclaration().type().typeName(), getExpr().type().componentType().typeName()); 042 } else if (getExpr().type().isIterable() && !getExpr().type().isUnknown()) { 043 MethodDecl iterator = (MethodDecl) getExpr().type().memberMethods("iterator").iterator().next(); 044 MethodDecl next = (MethodDecl) iterator.type().memberMethods("next").iterator().next(); 045 TypeDecl componentType = next.type(); 046 if (!componentType.assignConversionTo(getVariableDeclaration().type(), null)) { 047 errorf("parameter of type %s can not be assigned an element of type %s", 048 getVariableDeclaration().type().typeName(), componentType.typeName()); 049 } 050 } 051 } 052 /** 053 * @aspect EnhancedFor 054 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:86 055 */ 056 public void prettyPrint(PrettyPrinter out) { 057 out.print("for ("); 058 out.print(getVariableDeclaration().getModifiers()); 059 out.print(getVariableDeclaration().getTypeAccess()); 060 out.print(" " + getVariableDeclaration().name()); 061 out.print(" : "); 062 out.print(getExpr()); 063 out.print(") "); 064 if (getStmt() instanceof Block) { 065 out.print(getStmt()); 066 } else { 067 out.print("{"); 068 out.println(); 069 out.indent(1); 070 out.print(getStmt()); 071 out.println(); 072 out.print("}"); 073 } 074 } 075 /** 076 * @aspect EnhancedForToBytecode 077 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:48 078 */ 079 public void createBCode(CodeGeneration gen) { 080 VariableDeclaration decl = getVariableDeclaration(); 081 gen.addLocalVariableEntryAtCurrentPC(decl.name(), decl.type().typeDescriptor(), extraLocalIndex(), variableScopeEndLabel(gen)); 082 if (getExpr().type().isArrayDecl()) { 083 getExpr().createBCode(gen); 084 gen.emitStoreReference(extraLocalIndex()); 085 IntegerLiteral.push(gen, 0); 086 gen.emit(Bytecode.ISTORE).add(extraLocalIndex()+1); 087 gen.addLabel(cond_label()); 088 gen.emit(Bytecode.ILOAD).add(extraLocalIndex()+1); 089 gen.emitLoadReference(extraLocalIndex()); 090 gen.emit(Bytecode.ARRAYLENGTH); 091 gen.emitCompare(Bytecode.IF_ICMPGE, end_label()); 092 gen.emitLoadReference(extraLocalIndex()); 093 gen.emit(Bytecode.ILOAD).add(extraLocalIndex()+1); 094 gen.emit(getExpr().type().componentType().arrayLoad()); 095 getExpr().type().componentType().emitCastTo(gen, getVariableDeclaration().type()); 096 getVariableDeclaration().type().emitStoreLocal(gen, getVariableDeclaration().localNum()); 097 getStmt().createBCode(gen); 098 gen.addLabel(update_label()); 099 gen.emit(Bytecode.IINC).add(extraLocalIndex()+1).add(1); 100 gen.emitGoto(cond_label()); 101 gen.addLabel(end_label()); 102 } else { 103 TypeDecl typeIterable = lookupType("java.lang", "Iterable"); 104 TypeDecl typeIterator = lookupType("java.util", "Iterator"); 105 MethodDecl iteratorMethod = getMethod(typeIterable, "iterator"); 106 MethodDecl hasNextMethod = getMethod(typeIterator, "hasNext"); 107 MethodDecl nextMethod = getMethod(typeIterator, "next"); 108 getExpr().createBCode(gen); 109 iteratorMethod.emitInvokeMethod(gen, typeIterable); 110 gen.emitStoreReference(extraLocalIndex()); 111 gen.addLabel(cond_label()); 112 gen.emitLoadReference(extraLocalIndex()); 113 hasNextMethod.emitInvokeMethod(gen, typeIterator); 114 gen.emitCompare(Bytecode.IFEQ, end_label()); 115 gen.emitLoadReference(extraLocalIndex()); 116 nextMethod.emitInvokeMethod(gen, typeIterator); 117 VariableDeclaration obj = getVariableDeclaration(); 118 if (!obj.type().boxed().isUnknown()) { 119 gen.emitCheckCast(obj.type().boxed()); 120 obj.type().boxed().emitCastTo(gen, obj.type()); 121 obj.type().emitStoreLocal(gen, obj.localNum()); 122 } else { 123 gen.emitCheckCast(obj.type()); 124 gen.emitStoreReference(obj.localNum()); 125 } 126 getStmt().createBCode(gen); 127 gen.addLabel(update_label()); 128 gen.emitGoto(cond_label()); 129 gen.addLabel(end_label()); 130 } 131 gen.addVariableScopeLabel(variableScopeEndLabel(gen)); 132 } 133 /** 134 * @declaredat ASTNode:1 135 */ 136 public EnhancedForStmt() { 137 super(); 138 } 139 /** 140 * Initializes the child array to the correct size. 141 * Initializes List and Opt nta children. 142 * @apilevel internal 143 * @ast method 144 * @declaredat ASTNode:10 145 */ 146 public void init$Children() { 147 children = new ASTNode[3]; 148 } 149 /** 150 * @declaredat ASTNode:13 151 */ 152 public EnhancedForStmt(VariableDeclaration p0, Expr p1, Stmt p2) { 153 setChild(p0, 0); 154 setChild(p1, 1); 155 setChild(p2, 2); 156 } 157 /** 158 * @apilevel low-level 159 * @declaredat ASTNode:21 160 */ 161 protected int numChildren() { 162 return 3; 163 } 164 /** 165 * @apilevel internal 166 * @declaredat ASTNode:27 167 */ 168 public boolean mayHaveRewrite() { 169 return false; 170 } 171 /** 172 * @apilevel internal 173 * @declaredat ASTNode:33 174 */ 175 public void flushAttrCache() { 176 super.flushAttrCache(); 177 canCompleteNormally_reset(); 178 isDAafter_Variable_reset(); 179 isDUafter_Variable_reset(); 180 cond_label_reset(); 181 update_label_reset(); 182 end_label_reset(); 183 extraLocalIndex_reset(); 184 variableScopeEndLabel_CodeGeneration_reset(); 185 } 186 /** 187 * @apilevel internal 188 * @declaredat ASTNode:47 189 */ 190 public void flushCollectionCache() { 191 super.flushCollectionCache(); 192 } 193 /** 194 * @apilevel internal 195 * @declaredat ASTNode:53 196 */ 197 public void flushRewriteCache() { 198 super.flushRewriteCache(); 199 } 200 /** 201 * @apilevel internal 202 * @declaredat ASTNode:59 203 */ 204 public EnhancedForStmt clone() throws CloneNotSupportedException { 205 EnhancedForStmt node = (EnhancedForStmt) super.clone(); 206 return node; 207 } 208 /** 209 * @apilevel internal 210 * @declaredat ASTNode:66 211 */ 212 public EnhancedForStmt copy() { 213 try { 214 EnhancedForStmt node = (EnhancedForStmt) clone(); 215 node.parent = null; 216 if (children != null) { 217 node.children = (ASTNode[]) children.clone(); 218 } 219 return node; 220 } catch (CloneNotSupportedException e) { 221 throw new Error("Error: clone not supported for " + getClass().getName()); 222 } 223 } 224 /** 225 * Create a deep copy of the AST subtree at this node. 226 * The copy is dangling, i.e. has no parent. 227 * @return dangling copy of the subtree at this node 228 * @apilevel low-level 229 * @deprecated Please use treeCopy or treeCopyNoTransform instead 230 * @declaredat ASTNode:85 231 */ 232 @Deprecated 233 public EnhancedForStmt fullCopy() { 234 return treeCopyNoTransform(); 235 } 236 /** 237 * Create a deep copy of the AST subtree at this node. 238 * The copy is dangling, i.e. has no parent. 239 * @return dangling copy of the subtree at this node 240 * @apilevel low-level 241 * @declaredat ASTNode:95 242 */ 243 public EnhancedForStmt treeCopyNoTransform() { 244 EnhancedForStmt tree = (EnhancedForStmt) copy(); 245 if (children != null) { 246 for (int i = 0; i < children.length; ++i) { 247 ASTNode child = (ASTNode) children[i]; 248 if (child != null) { 249 child = child.treeCopyNoTransform(); 250 tree.setChild(child, i); 251 } 252 } 253 } 254 return tree; 255 } 256 /** 257 * Create a deep copy of the AST subtree at this node. 258 * The subtree of this node is traversed to trigger rewrites before copy. 259 * The copy is dangling, i.e. has no parent. 260 * @return dangling copy of the subtree at this node 261 * @apilevel low-level 262 * @declaredat ASTNode:115 263 */ 264 public EnhancedForStmt treeCopy() { 265 doFullTraversal(); 266 return treeCopyNoTransform(); 267 } 268 /** 269 * @apilevel internal 270 * @declaredat ASTNode:122 271 */ 272 protected boolean is$Equal(ASTNode node) { 273 return super.is$Equal(node); 274 } 275 /** 276 * Replaces the VariableDeclaration child. 277 * @param node The new node to replace the VariableDeclaration child. 278 * @apilevel high-level 279 */ 280 public void setVariableDeclaration(VariableDeclaration node) { 281 setChild(node, 0); 282 } 283 /** 284 * Retrieves the VariableDeclaration child. 285 * @return The current node used as the VariableDeclaration child. 286 * @apilevel high-level 287 */ 288 @ASTNodeAnnotation.Child(name="VariableDeclaration") 289 public VariableDeclaration getVariableDeclaration() { 290 return (VariableDeclaration) getChild(0); 291 } 292 /** 293 * Retrieves the VariableDeclaration child. 294 * <p><em>This method does not invoke AST transformations.</em></p> 295 * @return The current node used as the VariableDeclaration child. 296 * @apilevel low-level 297 */ 298 public VariableDeclaration getVariableDeclarationNoTransform() { 299 return (VariableDeclaration) getChildNoTransform(0); 300 } 301 /** 302 * Replaces the Expr child. 303 * @param node The new node to replace the Expr child. 304 * @apilevel high-level 305 */ 306 public void setExpr(Expr node) { 307 setChild(node, 1); 308 } 309 /** 310 * Retrieves the Expr child. 311 * @return The current node used as the Expr child. 312 * @apilevel high-level 313 */ 314 @ASTNodeAnnotation.Child(name="Expr") 315 public Expr getExpr() { 316 return (Expr) getChild(1); 317 } 318 /** 319 * Retrieves the Expr child. 320 * <p><em>This method does not invoke AST transformations.</em></p> 321 * @return The current node used as the Expr child. 322 * @apilevel low-level 323 */ 324 public Expr getExprNoTransform() { 325 return (Expr) getChildNoTransform(1); 326 } 327 /** 328 * Replaces the Stmt child. 329 * @param node The new node to replace the Stmt child. 330 * @apilevel high-level 331 */ 332 public void setStmt(Stmt node) { 333 setChild(node, 2); 334 } 335 /** 336 * Retrieves the Stmt child. 337 * @return The current node used as the Stmt child. 338 * @apilevel high-level 339 */ 340 @ASTNodeAnnotation.Child(name="Stmt") 341 public Stmt getStmt() { 342 return (Stmt) getChild(2); 343 } 344 /** 345 * Retrieves the Stmt child. 346 * <p><em>This method does not invoke AST transformations.</em></p> 347 * @return The current node used as the Stmt child. 348 * @apilevel low-level 349 */ 350 public Stmt getStmtNoTransform() { 351 return (Stmt) getChildNoTransform(2); 352 } 353 /** 354 * @attribute syn 355 * @aspect EnhancedFor 356 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:78 357 */ 358 @ASTNodeAnnotation.Attribute 359 public SimpleSet localLookupVariable(String name) { 360 { 361 if (getVariableDeclaration().name().equals(name)) { 362 return SimpleSet.emptySet.add(getVariableDeclaration()); 363 } 364 return lookupVariable(name); 365 } 366 } 367 /** 368 * @apilevel internal 369 */ 370 protected boolean canCompleteNormally_computed = false; 371 /** 372 * @apilevel internal 373 */ 374 protected boolean canCompleteNormally_value; 375 /** 376 * @apilevel internal 377 */ 378 private void canCompleteNormally_reset() { 379 canCompleteNormally_computed = false; 380 } 381 /** 382 * @attribute syn 383 * @aspect UnreachableStatements 384 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 385 */ 386 @ASTNodeAnnotation.Attribute 387 public boolean canCompleteNormally() { 388 ASTNode$State state = state(); 389 if (canCompleteNormally_computed) { 390 return canCompleteNormally_value; 391 } 392 boolean intermediate = state.INTERMEDIATE_VALUE; 393 state.INTERMEDIATE_VALUE = false; 394 int num = state.boundariesCrossed; 395 boolean isFinal = this.is$Final(); 396 canCompleteNormally_value = reachable(); 397 if (isFinal && num == state().boundariesCrossed) { 398 canCompleteNormally_computed = true; 399 } else { 400 } 401 state.INTERMEDIATE_VALUE |= intermediate; 402 403 return canCompleteNormally_value; 404 } 405 /** 406 * @apilevel internal 407 */ 408 protected java.util.Map isDAafter_Variable_values; 409 /** 410 * @apilevel internal 411 */ 412 private void isDAafter_Variable_reset() { 413 isDAafter_Variable_values = null; 414 } 415 /** 416 * @attribute syn 417 * @aspect DA 418 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 419 */ 420 @ASTNodeAnnotation.Attribute 421 public boolean isDAafter(Variable v) { 422 Object _parameters = v; 423 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 424 ASTNode$State state = state(); 425 if (isDAafter_Variable_values.containsKey(_parameters)) { 426 return (Boolean) isDAafter_Variable_values.get(_parameters); 427 } 428 boolean intermediate = state.INTERMEDIATE_VALUE; 429 state.INTERMEDIATE_VALUE = false; 430 int num = state.boundariesCrossed; 431 boolean isFinal = this.is$Final(); 432 boolean isDAafter_Variable_value = isDAafter_compute(v); 433 if (isFinal && num == state().boundariesCrossed) { 434 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 435 } else { 436 } 437 state.INTERMEDIATE_VALUE |= intermediate; 438 439 return isDAafter_Variable_value; 440 } 441 /** 442 * @apilevel internal 443 */ 444 private boolean isDAafter_compute(Variable v) { 445 if (!getExpr().isDAafter(v)) { 446 return false; 447 } 448 /* 449 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 450 BreakStmt stmt = (BreakStmt) iter.next(); 451 if (!stmt.isDAafterReachedFinallyBlocks(v)) { 452 return false; 453 } 454 } 455 */ 456 return true; 457 } 458 /** 459 * @apilevel internal 460 */ 461 protected java.util.Map isDUafter_Variable_values; 462 /** 463 * @apilevel internal 464 */ 465 private void isDUafter_Variable_reset() { 466 isDUafter_Variable_values = null; 467 } 468 /** 469 * @attribute syn 470 * @aspect DU 471 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 472 */ 473 @ASTNodeAnnotation.Attribute 474 public boolean isDUafter(Variable v) { 475 Object _parameters = v; 476 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 477 ASTNode$State state = state(); 478 if (isDUafter_Variable_values.containsKey(_parameters)) { 479 return (Boolean) isDUafter_Variable_values.get(_parameters); 480 } 481 boolean intermediate = state.INTERMEDIATE_VALUE; 482 state.INTERMEDIATE_VALUE = false; 483 int num = state.boundariesCrossed; 484 boolean isFinal = this.is$Final(); 485 boolean isDUafter_Variable_value = isDUafter_compute(v); 486 if (isFinal && num == state().boundariesCrossed) { 487 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 488 } else { 489 } 490 state.INTERMEDIATE_VALUE |= intermediate; 491 492 return isDUafter_Variable_value; 493 } 494 /** 495 * @apilevel internal 496 */ 497 private boolean isDUafter_compute(Variable v) { 498 if (!getExpr().isDUafter(v)) { 499 return false; 500 } 501 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 502 BreakStmt stmt = (BreakStmt) iter.next(); 503 if (!stmt.isDUafterReachedFinallyBlocks(v)) { 504 return false; 505 } 506 } 507 return true; 508 } 509 /** 510 * @attribute syn 511 * @aspect NameCheck 512 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:478 513 */ 514 @ASTNodeAnnotation.Attribute 515 public boolean continueLabel() { 516 boolean continueLabel_value = true; 517 518 return continueLabel_value; 519 } 520 /** 521 * @apilevel internal 522 */ 523 protected boolean cond_label_computed = false; 524 /** 525 * @apilevel internal 526 */ 527 protected int cond_label_value; 528 /** 529 * @apilevel internal 530 */ 531 private void cond_label_reset() { 532 cond_label_computed = false; 533 } 534 /** 535 * @attribute syn 536 * @aspect EnhancedForToBytecode 537 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:33 538 */ 539 @ASTNodeAnnotation.Attribute 540 public int cond_label() { 541 ASTNode$State state = state(); 542 if (cond_label_computed) { 543 return cond_label_value; 544 } 545 boolean intermediate = state.INTERMEDIATE_VALUE; 546 state.INTERMEDIATE_VALUE = false; 547 int num = state.boundariesCrossed; 548 boolean isFinal = this.is$Final(); 549 cond_label_value = hostType().constantPool().newLabel(); 550 if (isFinal && num == state().boundariesCrossed) { 551 cond_label_computed = true; 552 } else { 553 } 554 state.INTERMEDIATE_VALUE |= intermediate; 555 556 return cond_label_value; 557 } 558 /** 559 * @apilevel internal 560 */ 561 protected boolean update_label_computed = false; 562 /** 563 * @apilevel internal 564 */ 565 protected int update_label_value; 566 /** 567 * @apilevel internal 568 */ 569 private void update_label_reset() { 570 update_label_computed = false; 571 } 572 /** 573 * @attribute syn 574 * @aspect EnhancedForToBytecode 575 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:34 576 */ 577 @ASTNodeAnnotation.Attribute 578 public int update_label() { 579 ASTNode$State state = state(); 580 if (update_label_computed) { 581 return update_label_value; 582 } 583 boolean intermediate = state.INTERMEDIATE_VALUE; 584 state.INTERMEDIATE_VALUE = false; 585 int num = state.boundariesCrossed; 586 boolean isFinal = this.is$Final(); 587 update_label_value = hostType().constantPool().newLabel(); 588 if (isFinal && num == state().boundariesCrossed) { 589 update_label_computed = true; 590 } else { 591 } 592 state.INTERMEDIATE_VALUE |= intermediate; 593 594 return update_label_value; 595 } 596 /** 597 * @apilevel internal 598 */ 599 protected boolean end_label_computed = false; 600 /** 601 * @apilevel internal 602 */ 603 protected int end_label_value; 604 /** 605 * @apilevel internal 606 */ 607 private void end_label_reset() { 608 end_label_computed = false; 609 } 610 /** 611 * @attribute syn 612 * @aspect EnhancedForToBytecode 613 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:35 614 */ 615 @ASTNodeAnnotation.Attribute 616 public int end_label() { 617 ASTNode$State state = state(); 618 if (end_label_computed) { 619 return end_label_value; 620 } 621 boolean intermediate = state.INTERMEDIATE_VALUE; 622 state.INTERMEDIATE_VALUE = false; 623 int num = state.boundariesCrossed; 624 boolean isFinal = this.is$Final(); 625 end_label_value = hostType().constantPool().newLabel(); 626 if (isFinal && num == state().boundariesCrossed) { 627 end_label_computed = true; 628 } else { 629 } 630 state.INTERMEDIATE_VALUE |= intermediate; 631 632 return end_label_value; 633 } 634 /** 635 * @apilevel internal 636 */ 637 protected boolean extraLocalIndex_computed = false; 638 /** 639 * @apilevel internal 640 */ 641 protected int extraLocalIndex_value; 642 /** 643 * @apilevel internal 644 */ 645 private void extraLocalIndex_reset() { 646 extraLocalIndex_computed = false; 647 } 648 /** 649 * @attribute syn 650 * @aspect EnhancedForToBytecode 651 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:37 652 */ 653 @ASTNodeAnnotation.Attribute 654 public int extraLocalIndex() { 655 ASTNode$State state = state(); 656 if (extraLocalIndex_computed) { 657 return extraLocalIndex_value; 658 } 659 boolean intermediate = state.INTERMEDIATE_VALUE; 660 state.INTERMEDIATE_VALUE = false; 661 int num = state.boundariesCrossed; 662 boolean isFinal = this.is$Final(); 663 extraLocalIndex_value = localNum(); 664 if (isFinal && num == state().boundariesCrossed) { 665 extraLocalIndex_computed = true; 666 } else { 667 } 668 state.INTERMEDIATE_VALUE |= intermediate; 669 670 return extraLocalIndex_value; 671 } 672 /** 673 * @attribute syn 674 * @aspect CreateBCode 675 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621 676 */ 677 @ASTNodeAnnotation.Attribute 678 public int break_label() { 679 int break_label_value = end_label(); 680 681 return break_label_value; 682 } 683 /** 684 * @attribute syn 685 * @aspect CreateBCode 686 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645 687 */ 688 @ASTNodeAnnotation.Attribute 689 public int continue_label() { 690 int continue_label_value = update_label(); 691 692 return continue_label_value; 693 } 694 /** 695 * @apilevel internal 696 */ 697 protected java.util.Map variableScopeEndLabel_CodeGeneration_values; 698 /** 699 * @apilevel internal 700 */ 701 private void variableScopeEndLabel_CodeGeneration_reset() { 702 variableScopeEndLabel_CodeGeneration_values = null; 703 } 704 /** 705 * @attribute syn 706 * @aspect EnhancedForToBytecode 707 * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:45 708 */ 709 @ASTNodeAnnotation.Attribute 710 public int variableScopeEndLabel(CodeGeneration gen) { 711 Object _parameters = gen; 712 if (variableScopeEndLabel_CodeGeneration_values == null) variableScopeEndLabel_CodeGeneration_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 713 ASTNode$State state = state(); 714 if (variableScopeEndLabel_CodeGeneration_values.containsKey(_parameters)) { 715 return (Integer) variableScopeEndLabel_CodeGeneration_values.get(_parameters); 716 } 717 boolean intermediate = state.INTERMEDIATE_VALUE; 718 state.INTERMEDIATE_VALUE = false; 719 int num = state.boundariesCrossed; 720 boolean isFinal = this.is$Final(); 721 int variableScopeEndLabel_CodeGeneration_value = gen.variableScopeLabel(); 722 if (isFinal && num == state().boundariesCrossed) { 723 variableScopeEndLabel_CodeGeneration_values.put(_parameters, variableScopeEndLabel_CodeGeneration_value); 724 } else { 725 } 726 state.INTERMEDIATE_VALUE |= intermediate; 727 728 return variableScopeEndLabel_CodeGeneration_value; 729 } 730 /** 731 * @attribute syn 732 * @aspect PreciseRethrow 733 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 734 */ 735 @ASTNodeAnnotation.Attribute 736 public boolean modifiedInScope(Variable var) { 737 boolean modifiedInScope_Variable_value = getStmt().modifiedInScope(var); 738 739 return modifiedInScope_Variable_value; 740 } 741 /** 742 * @attribute inh 743 * @aspect EnhancedFor 744 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:66 745 */ 746 /** 747 * @attribute inh 748 * @aspect EnhancedFor 749 * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:66 750 */ 751 @ASTNodeAnnotation.Attribute 752 public SimpleSet lookupVariable(String name) { 753 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 754 755 return lookupVariable_String_value; 756 } 757 /** 758 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 759 * @apilevel internal 760 */ 761 public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 762 int childIndex = this.getIndexOfChild(caller); 763 return branch.canBranchTo(this) ? this : branchTarget(branch); 764 } 765 protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 766 return true; 767 } 768 /** 769 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 770 * @apilevel internal 771 */ 772 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 773 if (caller == getStmtNoTransform()) { 774 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:69 775 return localLookupVariable(name); 776 } 777 else if (caller == getExprNoTransform()) { 778 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:68 779 return localLookupVariable(name); 780 } 781 else if (caller == getVariableDeclarationNoTransform()) { 782 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:67 783 return localLookupVariable(name); 784 } 785 else { 786 return getParent().Define_lookupVariable(this, caller, name); 787 } 788 } 789 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 790 return true; 791 } 792 /** 793 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 794 * @apilevel internal 795 */ 796 public NameType Define_nameType(ASTNode caller, ASTNode child) { 797 if (caller == getVariableDeclarationNoTransform()) { 798 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:71 799 return NameType.TYPE_NAME; 800 } 801 else { 802 return getParent().Define_nameType(this, caller); 803 } 804 } 805 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 806 return true; 807 } 808 /** 809 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30 810 * @apilevel internal 811 */ 812 public VariableScope Define_outerScope(ASTNode caller, ASTNode child) { 813 if (caller == getStmtNoTransform()) { 814 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:76 815 return this; 816 } 817 else if (caller == getExprNoTransform()) { 818 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:75 819 return this; 820 } 821 else if (caller == getVariableDeclarationNoTransform()) { 822 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:74 823 return this; 824 } 825 else { 826 return getParent().Define_outerScope(this, caller); 827 } 828 } 829 protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) { 830 return true; 831 } 832 /** 833 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:44 834 * @apilevel internal 835 */ 836 public boolean Define_isMethodParameter(ASTNode caller, ASTNode child) { 837 if (caller == getVariableDeclarationNoTransform()) { 838 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:107 839 return false; 840 } 841 else { 842 return getParent().Define_isMethodParameter(this, caller); 843 } 844 } 845 protected boolean canDefine_isMethodParameter(ASTNode caller, ASTNode child) { 846 return true; 847 } 848 /** 849 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:45 850 * @apilevel internal 851 */ 852 public boolean Define_isConstructorParameter(ASTNode caller, ASTNode child) { 853 if (caller == getVariableDeclarationNoTransform()) { 854 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:108 855 return false; 856 } 857 else { 858 return getParent().Define_isConstructorParameter(this, caller); 859 } 860 } 861 protected boolean canDefine_isConstructorParameter(ASTNode caller, ASTNode child) { 862 return true; 863 } 864 /** 865 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:46 866 * @apilevel internal 867 */ 868 public boolean Define_isExceptionHandlerParameter(ASTNode caller, ASTNode child) { 869 if (caller == getVariableDeclarationNoTransform()) { 870 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:109 871 return false; 872 } 873 else { 874 return getParent().Define_isExceptionHandlerParameter(this, caller); 875 } 876 } 877 protected boolean canDefine_isExceptionHandlerParameter(ASTNode caller, ASTNode child) { 878 return true; 879 } 880 /** 881 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 882 * @apilevel internal 883 */ 884 public boolean Define_reachable(ASTNode caller, ASTNode child) { 885 if (caller == getStmtNoTransform()) { 886 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:113 887 return reachable(); 888 } 889 else { 890 return getParent().Define_reachable(this, caller); 891 } 892 } 893 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 894 return true; 895 } 896 /** 897 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 898 * @apilevel internal 899 */ 900 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 901 if (caller == getStmtNoTransform()) { 902 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:132 903 return getExpr().isDAafter(v); 904 } 905 else if (caller == getExprNoTransform()) { 906 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:130 907 return v == getVariableDeclaration() || isDAbefore(v); 908 } 909 else { 910 return getParent().Define_isDAbefore(this, caller, v); 911 } 912 } 913 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 914 return true; 915 } 916 /** 917 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 918 * @apilevel internal 919 */ 920 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 921 if (caller == getStmtNoTransform()) { 922 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:148 923 return getExpr().isDUafter(v); 924 } 925 else if (caller == getExprNoTransform()) { 926 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:146 927 return v != getVariableDeclaration() && isDUbefore(v); 928 } 929 else { 930 return getParent().Define_isDUbefore(this, caller, v); 931 } 932 } 933 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 934 return true; 935 } 936 /** 937 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441 938 * @apilevel internal 939 */ 940 public boolean Define_insideLoop(ASTNode caller, ASTNode child) { 941 if (caller == getStmtNoTransform()) { 942 // @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:150 943 return true; 944 } 945 else { 946 return getParent().Define_insideLoop(this, caller); 947 } 948 } 949 protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) { 950 return true; 951 } 952 /** 953 * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64 954 * @apilevel internal 955 */ 956 public int Define_localNum(ASTNode caller, ASTNode child) { 957 if (caller == getStmtNoTransform()) { 958 // @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:39 959 return getVariableDeclaration().localNum() + getVariableDeclaration().type().size(); 960 } 961 else if (caller == getVariableDeclarationNoTransform()) { 962 // @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:38 963 return localNum() + (getExpr().type().isArrayDecl() ? 2 : 1); 964 } 965 else { 966 return getParent().Define_localNum(this, caller); 967 } 968 } 969 protected boolean canDefine_localNum(ASTNode caller, ASTNode child) { 970 return true; 971 } 972 /** 973 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 974 * @apilevel internal 975 */ 976 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 977 if (caller == getStmtNoTransform()) { 978 // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:50 979 return false; 980 } 981 else if (caller == getVariableDeclarationNoTransform()) { 982 // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:48 983 return modifiedInScope(var); 984 } 985 else { 986 return getParent().Define_inhModifiedInScope(this, caller, var); 987 } 988 } 989 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 990 return true; 991 } 992 /** 993 * @apilevel internal 994 */ 995 public ASTNode rewriteTo() { 996 return super.rewriteTo(); 997 } 998 }