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:193 027 * @production Block : {@link Stmt} ::= <span class="component">{@link Stmt}*</span>; 028 029 */ 030 public class Block extends Stmt implements Cloneable, VariableScope { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:455 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print("{"); 037 out.println(); 038 out.indent(1); 039 out.join(getStmtList(), new PrettyPrinter.Joiner() { 040 @Override 041 public void printSeparator(PrettyPrinter out) { 042 out.println(); 043 } 044 }); 045 if (!out.isNewLine()) { 046 out.println(); 047 } 048 out.print("}"); 049 } 050 /** 051 * @aspect CreateBCode 052 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1363 053 */ 054 public void createBCode(CodeGeneration gen) { 055 //super.createBCode(gen); 056 for (int i = 0; i < getNumStmt(); i++) { 057 try { 058 getStmt(i).createBCode(gen); 059 } catch (Exception e) { 060 e.printStackTrace(); 061 throw new Error("Error generating code for " + errorPrefix() + " " + getStmt(i)); 062 } 063 } 064 gen.addVariableScopeLabel(variableScopeEndLabel(gen)); 065 } 066 /** 067 * @declaredat ASTNode:1 068 */ 069 public Block() { 070 super(); 071 } 072 /** 073 * Initializes the child array to the correct size. 074 * Initializes List and Opt nta children. 075 * @apilevel internal 076 * @ast method 077 * @declaredat ASTNode:10 078 */ 079 public void init$Children() { 080 children = new ASTNode[1]; 081 setChild(new List(), 0); 082 } 083 /** 084 * @declaredat ASTNode:14 085 */ 086 public Block(List<Stmt> p0) { 087 setChild(p0, 0); 088 } 089 /** 090 * @apilevel low-level 091 * @declaredat ASTNode:20 092 */ 093 protected int numChildren() { 094 return 1; 095 } 096 /** 097 * @apilevel internal 098 * @declaredat ASTNode:26 099 */ 100 public boolean mayHaveRewrite() { 101 return false; 102 } 103 /** 104 * @apilevel internal 105 * @declaredat ASTNode:32 106 */ 107 public void flushAttrCache() { 108 super.flushAttrCache(); 109 checkReturnDA_Variable_reset(); 110 isDAafter_Variable_reset(); 111 checkReturnDU_Variable_reset(); 112 isDUafter_Variable_reset(); 113 localVariableDeclaration_String_reset(); 114 canCompleteNormally_reset(); 115 variableScopeEndLabel_CodeGeneration_reset(); 116 lookupType_String_reset(); 117 lookupVariable_String_reset(); 118 } 119 /** 120 * @apilevel internal 121 * @declaredat ASTNode:47 122 */ 123 public void flushCollectionCache() { 124 super.flushCollectionCache(); 125 } 126 /** 127 * @apilevel internal 128 * @declaredat ASTNode:53 129 */ 130 public void flushRewriteCache() { 131 super.flushRewriteCache(); 132 } 133 /** 134 * @apilevel internal 135 * @declaredat ASTNode:59 136 */ 137 public Block clone() throws CloneNotSupportedException { 138 Block node = (Block) super.clone(); 139 return node; 140 } 141 /** 142 * @apilevel internal 143 * @declaredat ASTNode:66 144 */ 145 public Block copy() { 146 try { 147 Block node = (Block) clone(); 148 node.parent = null; 149 if (children != null) { 150 node.children = (ASTNode[]) children.clone(); 151 } 152 return node; 153 } catch (CloneNotSupportedException e) { 154 throw new Error("Error: clone not supported for " + getClass().getName()); 155 } 156 } 157 /** 158 * Create a deep copy of the AST subtree at this node. 159 * The copy is dangling, i.e. has no parent. 160 * @return dangling copy of the subtree at this node 161 * @apilevel low-level 162 * @deprecated Please use treeCopy or treeCopyNoTransform instead 163 * @declaredat ASTNode:85 164 */ 165 @Deprecated 166 public Block fullCopy() { 167 return treeCopyNoTransform(); 168 } 169 /** 170 * Create a deep copy of the AST subtree at this node. 171 * The copy is dangling, i.e. has no parent. 172 * @return dangling copy of the subtree at this node 173 * @apilevel low-level 174 * @declaredat ASTNode:95 175 */ 176 public Block treeCopyNoTransform() { 177 Block tree = (Block) copy(); 178 if (children != null) { 179 for (int i = 0; i < children.length; ++i) { 180 ASTNode child = (ASTNode) children[i]; 181 if (child != null) { 182 child = child.treeCopyNoTransform(); 183 tree.setChild(child, i); 184 } 185 } 186 } 187 return tree; 188 } 189 /** 190 * Create a deep copy of the AST subtree at this node. 191 * The subtree of this node is traversed to trigger rewrites before copy. 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:115 196 */ 197 public Block treeCopy() { 198 doFullTraversal(); 199 return treeCopyNoTransform(); 200 } 201 /** 202 * @apilevel internal 203 * @declaredat ASTNode:122 204 */ 205 protected boolean is$Equal(ASTNode node) { 206 return super.is$Equal(node); 207 } 208 /** 209 * Replaces the Stmt list. 210 * @param list The new list node to be used as the Stmt list. 211 * @apilevel high-level 212 */ 213 public void setStmtList(List<Stmt> list) { 214 setChild(list, 0); 215 } 216 /** 217 * Retrieves the number of children in the Stmt list. 218 * @return Number of children in the Stmt list. 219 * @apilevel high-level 220 */ 221 public int getNumStmt() { 222 return getStmtList().getNumChild(); 223 } 224 /** 225 * Retrieves the number of children in the Stmt list. 226 * Calling this method will not trigger rewrites. 227 * @return Number of children in the Stmt list. 228 * @apilevel low-level 229 */ 230 public int getNumStmtNoTransform() { 231 return getStmtListNoTransform().getNumChildNoTransform(); 232 } 233 /** 234 * Retrieves the element at index {@code i} in the Stmt list. 235 * @param i Index of the element to return. 236 * @return The element at position {@code i} in the Stmt list. 237 * @apilevel high-level 238 */ 239 public Stmt getStmt(int i) { 240 return (Stmt) getStmtList().getChild(i); 241 } 242 /** 243 * Check whether the Stmt list has any children. 244 * @return {@code true} if it has at least one child, {@code false} otherwise. 245 * @apilevel high-level 246 */ 247 public boolean hasStmt() { 248 return getStmtList().getNumChild() != 0; 249 } 250 /** 251 * Append an element to the Stmt list. 252 * @param node The element to append to the Stmt list. 253 * @apilevel high-level 254 */ 255 public void addStmt(Stmt node) { 256 List<Stmt> list = (parent == null) ? getStmtListNoTransform() : getStmtList(); 257 list.addChild(node); 258 } 259 /** 260 * @apilevel low-level 261 */ 262 public void addStmtNoTransform(Stmt node) { 263 List<Stmt> list = getStmtListNoTransform(); 264 list.addChild(node); 265 } 266 /** 267 * Replaces the Stmt list element at index {@code i} with the new node {@code node}. 268 * @param node The new node to replace the old list element. 269 * @param i The list index of the node to be replaced. 270 * @apilevel high-level 271 */ 272 public void setStmt(Stmt node, int i) { 273 List<Stmt> list = getStmtList(); 274 list.setChild(node, i); 275 } 276 /** 277 * Retrieves the Stmt list. 278 * @return The node representing the Stmt list. 279 * @apilevel high-level 280 */ 281 @ASTNodeAnnotation.ListChild(name="Stmt") 282 public List<Stmt> getStmtList() { 283 List<Stmt> list = (List<Stmt>) getChild(0); 284 return list; 285 } 286 /** 287 * Retrieves the Stmt list. 288 * <p><em>This method does not invoke AST transformations.</em></p> 289 * @return The node representing the Stmt list. 290 * @apilevel low-level 291 */ 292 public List<Stmt> getStmtListNoTransform() { 293 return (List<Stmt>) getChildNoTransform(0); 294 } 295 /** 296 * Retrieves the Stmt list. 297 * @return The node representing the Stmt list. 298 * @apilevel high-level 299 */ 300 public List<Stmt> getStmts() { 301 return getStmtList(); 302 } 303 /** 304 * Retrieves the Stmt list. 305 * <p><em>This method does not invoke AST transformations.</em></p> 306 * @return The node representing the Stmt list. 307 * @apilevel low-level 308 */ 309 public List<Stmt> getStmtsNoTransform() { 310 return getStmtListNoTransform(); 311 } 312 /** 313 * @attribute syn 314 * @aspect DeclareBeforeUse 315 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:38 316 */ 317 @ASTNodeAnnotation.Attribute 318 public boolean declaredBeforeUse(VariableDeclaration decl, int indexUse) { 319 boolean declaredBeforeUse_VariableDeclaration_int_value = decl.blockIndex() < indexUse; 320 321 return declaredBeforeUse_VariableDeclaration_int_value; 322 } 323 /** 324 * @apilevel internal 325 */ 326 protected java.util.Map checkReturnDA_Variable_values; 327 /** 328 * @apilevel internal 329 */ 330 private void checkReturnDA_Variable_reset() { 331 checkReturnDA_Variable_values = null; 332 } 333 /** 334 * @attribute syn 335 * @aspect DA 336 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:339 337 */ 338 @ASTNodeAnnotation.Attribute 339 public boolean checkReturnDA(Variable v) { 340 Object _parameters = v; 341 if (checkReturnDA_Variable_values == null) checkReturnDA_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 342 ASTNode$State state = state(); 343 if (checkReturnDA_Variable_values.containsKey(_parameters)) { 344 return (Boolean) checkReturnDA_Variable_values.get(_parameters); 345 } 346 boolean intermediate = state.INTERMEDIATE_VALUE; 347 state.INTERMEDIATE_VALUE = false; 348 int num = state.boundariesCrossed; 349 boolean isFinal = this.is$Final(); 350 boolean checkReturnDA_Variable_value = checkReturnDA_compute(v); 351 if (isFinal && num == state().boundariesCrossed) { 352 checkReturnDA_Variable_values.put(_parameters, checkReturnDA_Variable_value); 353 } else { 354 } 355 state.INTERMEDIATE_VALUE |= intermediate; 356 357 return checkReturnDA_Variable_value; 358 } 359 /** 360 * @apilevel internal 361 */ 362 private boolean checkReturnDA_compute(Variable v) { 363 HashSet set = new HashSet(); 364 collectBranches(set); 365 for (Iterator iter = set.iterator(); iter.hasNext(); ) { 366 Object o = iter.next(); 367 if (o instanceof ReturnStmt) { 368 ReturnStmt stmt = (ReturnStmt) o; 369 if (!stmt.isDAafterReachedFinallyBlocks(v)) { 370 return false; 371 } 372 } 373 } 374 return true; 375 } 376 /** 377 * @apilevel internal 378 */ 379 protected java.util.Map isDAafter_Variable_values; 380 /** 381 * @apilevel internal 382 */ 383 private void isDAafter_Variable_reset() { 384 isDAafter_Variable_values = null; 385 } 386 /** 387 * @attribute syn 388 * @aspect DA 389 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 390 */ 391 @ASTNodeAnnotation.Attribute 392 public boolean isDAafter(Variable v) { 393 Object _parameters = v; 394 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 395 ASTNode$State state = state(); 396 if (isDAafter_Variable_values.containsKey(_parameters)) { 397 return (Boolean) isDAafter_Variable_values.get(_parameters); 398 } 399 boolean intermediate = state.INTERMEDIATE_VALUE; 400 state.INTERMEDIATE_VALUE = false; 401 int num = state.boundariesCrossed; 402 boolean isFinal = this.is$Final(); 403 boolean isDAafter_Variable_value = getNumStmt() == 0 ? isDAbefore(v) : getStmt(getNumStmt()-1).isDAafter(v); 404 if (isFinal && num == state().boundariesCrossed) { 405 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 406 } else { 407 } 408 state.INTERMEDIATE_VALUE |= intermediate; 409 410 return isDAafter_Variable_value; 411 } 412 /** 413 * @attribute syn 414 * @aspect DA 415 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:492 416 */ 417 @ASTNodeAnnotation.Attribute 418 public boolean isDUeverywhere(Variable v) { 419 boolean isDUeverywhere_Variable_value = isDUbefore(v) && checkDUeverywhere(v); 420 421 return isDUeverywhere_Variable_value; 422 } 423 /** 424 * @apilevel internal 425 */ 426 protected java.util.Map checkReturnDU_Variable_values; 427 /** 428 * @apilevel internal 429 */ 430 private void checkReturnDU_Variable_reset() { 431 checkReturnDU_Variable_values = null; 432 } 433 /** 434 * @attribute syn 435 * @aspect DU 436 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:858 437 */ 438 @ASTNodeAnnotation.Attribute 439 public boolean checkReturnDU(Variable v) { 440 Object _parameters = v; 441 if (checkReturnDU_Variable_values == null) checkReturnDU_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 442 ASTNode$State state = state(); 443 if (checkReturnDU_Variable_values.containsKey(_parameters)) { 444 return (Boolean) checkReturnDU_Variable_values.get(_parameters); 445 } 446 boolean intermediate = state.INTERMEDIATE_VALUE; 447 state.INTERMEDIATE_VALUE = false; 448 int num = state.boundariesCrossed; 449 boolean isFinal = this.is$Final(); 450 boolean checkReturnDU_Variable_value = checkReturnDU_compute(v); 451 if (isFinal && num == state().boundariesCrossed) { 452 checkReturnDU_Variable_values.put(_parameters, checkReturnDU_Variable_value); 453 } else { 454 } 455 state.INTERMEDIATE_VALUE |= intermediate; 456 457 return checkReturnDU_Variable_value; 458 } 459 /** 460 * @apilevel internal 461 */ 462 private boolean checkReturnDU_compute(Variable v) { 463 HashSet set = new HashSet(); 464 collectBranches(set); 465 for (Iterator iter = set.iterator(); iter.hasNext(); ) { 466 Object o = iter.next(); 467 if (o instanceof ReturnStmt) { 468 ReturnStmt stmt = (ReturnStmt) o; 469 if (!stmt.isDUafterReachedFinallyBlocks(v)) { 470 return false; 471 } 472 } 473 } 474 return true; 475 } 476 /** 477 * @apilevel internal 478 */ 479 protected java.util.Map isDUafter_Variable_values; 480 /** 481 * @apilevel internal 482 */ 483 private void isDUafter_Variable_reset() { 484 isDUafter_Variable_values = null; 485 } 486 /** 487 * @attribute syn 488 * @aspect DU 489 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 490 */ 491 @ASTNodeAnnotation.Attribute 492 public boolean isDUafter(Variable v) { 493 Object _parameters = v; 494 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 495 ASTNode$State state = state(); 496 if (isDUafter_Variable_values.containsKey(_parameters)) { 497 return (Boolean) isDUafter_Variable_values.get(_parameters); 498 } 499 boolean intermediate = state.INTERMEDIATE_VALUE; 500 state.INTERMEDIATE_VALUE = false; 501 int num = state.boundariesCrossed; 502 boolean isFinal = this.is$Final(); 503 boolean isDUafter_Variable_value = getNumStmt() == 0 ? isDUbefore(v) : getStmt(getNumStmt()-1).isDUafter(v); 504 if (isFinal && num == state().boundariesCrossed) { 505 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 506 } else { 507 } 508 state.INTERMEDIATE_VALUE |= intermediate; 509 510 return isDUafter_Variable_value; 511 } 512 /** 513 * @apilevel internal 514 */ 515 protected java.util.Map localVariableDeclaration_String_values; 516 /** 517 * @apilevel internal 518 */ 519 private void localVariableDeclaration_String_reset() { 520 localVariableDeclaration_String_values = null; 521 } 522 /** 523 * @attribute syn 524 * @aspect VariableScope 525 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:185 526 */ 527 @ASTNodeAnnotation.Attribute 528 public VariableDeclaration localVariableDeclaration(String name) { 529 Object _parameters = name; 530 if (localVariableDeclaration_String_values == null) localVariableDeclaration_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 531 ASTNode$State state = state(); 532 if (localVariableDeclaration_String_values.containsKey(_parameters)) { 533 return (VariableDeclaration) localVariableDeclaration_String_values.get(_parameters); 534 } 535 boolean intermediate = state.INTERMEDIATE_VALUE; 536 state.INTERMEDIATE_VALUE = false; 537 int num = state.boundariesCrossed; 538 boolean isFinal = this.is$Final(); 539 VariableDeclaration localVariableDeclaration_String_value = localVariableDeclaration_compute(name); 540 if (isFinal && num == state().boundariesCrossed) { 541 localVariableDeclaration_String_values.put(_parameters, localVariableDeclaration_String_value); 542 } else { 543 } 544 state.INTERMEDIATE_VALUE |= intermediate; 545 546 return localVariableDeclaration_String_value; 547 } 548 /** 549 * @apilevel internal 550 */ 551 private VariableDeclaration localVariableDeclaration_compute(String name) { 552 for (Stmt stmt: getStmtList()) { 553 VariableDeclaration decl = stmt.variableDeclaration(name); 554 if (decl != null) { 555 return decl; 556 } 557 } 558 return null; 559 } 560 /** 561 * @attribute syn 562 * @aspect PrettyPrintUtil 563 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:219 564 */ 565 @ASTNodeAnnotation.Attribute 566 public boolean hasStmts() { 567 boolean hasStmts_value = getNumStmt() > 0; 568 569 return hasStmts_value; 570 } 571 /** 572 * @apilevel internal 573 */ 574 protected boolean canCompleteNormally_computed = false; 575 /** 576 * @apilevel internal 577 */ 578 protected boolean canCompleteNormally_value; 579 /** 580 * @apilevel internal 581 */ 582 private void canCompleteNormally_reset() { 583 canCompleteNormally_computed = false; 584 } 585 /** 586 * @attribute syn 587 * @aspect UnreachableStatements 588 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 589 */ 590 @ASTNodeAnnotation.Attribute 591 public boolean canCompleteNormally() { 592 ASTNode$State state = state(); 593 if (canCompleteNormally_computed) { 594 return canCompleteNormally_value; 595 } 596 boolean intermediate = state.INTERMEDIATE_VALUE; 597 state.INTERMEDIATE_VALUE = false; 598 int num = state.boundariesCrossed; 599 boolean isFinal = this.is$Final(); 600 canCompleteNormally_value = getNumStmt() == 0 601 ? reachable() 602 : getStmt(getNumStmt() - 1).canCompleteNormally(); 603 if (isFinal && num == state().boundariesCrossed) { 604 canCompleteNormally_computed = true; 605 } else { 606 } 607 state.INTERMEDIATE_VALUE |= intermediate; 608 609 return canCompleteNormally_value; 610 } 611 /** 612 * @apilevel internal 613 */ 614 protected java.util.Map variableScopeEndLabel_CodeGeneration_values; 615 /** 616 * @apilevel internal 617 */ 618 private void variableScopeEndLabel_CodeGeneration_reset() { 619 variableScopeEndLabel_CodeGeneration_values = null; 620 } 621 /** 622 * @attribute syn 623 * @aspect CodeGeneration 624 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:68 625 */ 626 @ASTNodeAnnotation.Attribute 627 public int variableScopeEndLabel(CodeGeneration gen) { 628 Object _parameters = gen; 629 if (variableScopeEndLabel_CodeGeneration_values == null) variableScopeEndLabel_CodeGeneration_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 630 ASTNode$State state = state(); 631 if (variableScopeEndLabel_CodeGeneration_values.containsKey(_parameters)) { 632 return (Integer) variableScopeEndLabel_CodeGeneration_values.get(_parameters); 633 } 634 boolean intermediate = state.INTERMEDIATE_VALUE; 635 state.INTERMEDIATE_VALUE = false; 636 int num = state.boundariesCrossed; 637 boolean isFinal = this.is$Final(); 638 int variableScopeEndLabel_CodeGeneration_value = gen.variableScopeLabel(); 639 if (isFinal && num == state().boundariesCrossed) { 640 variableScopeEndLabel_CodeGeneration_values.put(_parameters, variableScopeEndLabel_CodeGeneration_value); 641 } else { 642 } 643 state.INTERMEDIATE_VALUE |= intermediate; 644 645 return variableScopeEndLabel_CodeGeneration_value; 646 } 647 /** 648 * @attribute syn 649 * @aspect PreciseRethrow 650 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 651 */ 652 @ASTNodeAnnotation.Attribute 653 public boolean modifiedInScope(Variable var) { 654 { 655 for (Stmt stmt : getStmtList()) { 656 if (stmt.modifiedInScope(var)) { 657 return true; 658 } 659 } 660 return false; 661 } 662 } 663 /** 664 * @attribute inh 665 * @aspect TypeScopePropagation 666 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:340 667 */ 668 /** 669 * @attribute inh 670 * @aspect TypeScopePropagation 671 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:340 672 */ 673 @ASTNodeAnnotation.Attribute 674 public SimpleSet lookupType(String name) { 675 Object _parameters = name; 676 if (lookupType_String_values == null) lookupType_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 677 ASTNode$State state = state(); 678 if (lookupType_String_values.containsKey(_parameters)) { 679 return (SimpleSet) lookupType_String_values.get(_parameters); 680 } 681 boolean intermediate = state.INTERMEDIATE_VALUE; 682 state.INTERMEDIATE_VALUE = false; 683 int num = state.boundariesCrossed; 684 boolean isFinal = this.is$Final(); 685 SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name); 686 if (isFinal && num == state().boundariesCrossed) { 687 lookupType_String_values.put(_parameters, lookupType_String_value); 688 } else { 689 } 690 state.INTERMEDIATE_VALUE |= intermediate; 691 692 return lookupType_String_value; 693 } 694 /** 695 * @apilevel internal 696 */ 697 protected java.util.Map lookupType_String_values; 698 /** 699 * @apilevel internal 700 */ 701 private void lookupType_String_reset() { 702 lookupType_String_values = null; 703 } 704 /** 705 * @attribute inh 706 * @aspect VariableScope 707 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:38 708 */ 709 /** 710 * @attribute inh 711 * @aspect VariableScope 712 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:38 713 */ 714 @ASTNodeAnnotation.Attribute 715 public SimpleSet lookupVariable(String name) { 716 Object _parameters = name; 717 if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 718 ASTNode$State state = state(); 719 if (lookupVariable_String_values.containsKey(_parameters)) { 720 return (SimpleSet) lookupVariable_String_values.get(_parameters); 721 } 722 boolean intermediate = state.INTERMEDIATE_VALUE; 723 state.INTERMEDIATE_VALUE = false; 724 int num = state.boundariesCrossed; 725 boolean isFinal = this.is$Final(); 726 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 727 if (isFinal && num == state().boundariesCrossed) { 728 lookupVariable_String_values.put(_parameters, lookupVariable_String_value); 729 } else { 730 } 731 state.INTERMEDIATE_VALUE |= intermediate; 732 733 return lookupVariable_String_value; 734 } 735 /** 736 * @apilevel internal 737 */ 738 protected java.util.Map lookupVariable_String_values; 739 /** 740 * @apilevel internal 741 */ 742 private void lookupVariable_String_reset() { 743 lookupVariable_String_values = null; 744 } 745 /** 746 * @attribute inh 747 * @aspect NameCheck 748 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:525 749 */ 750 /** 751 * @attribute inh 752 * @aspect NameCheck 753 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:525 754 */ 755 @ASTNodeAnnotation.Attribute 756 public SimpleSet otherLocalClassDecls(String name) { 757 SimpleSet otherLocalClassDecls_String_value = getParent().Define_otherLocalClassDecls(this, null, name); 758 759 return otherLocalClassDecls_String_value; 760 } 761 /** 762 * @attribute inh 763 * @aspect UnreachableStatements 764 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 765 */ 766 /** 767 * @attribute inh 768 * @aspect UnreachableStatements 769 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 770 */ 771 @ASTNodeAnnotation.Attribute 772 public boolean reachable() { 773 boolean reachable_value = getParent().Define_reachable(this, null); 774 775 return reachable_value; 776 } 777 /** 778 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:34 779 * @apilevel internal 780 */ 781 public int Define_blockIndex(ASTNode caller, ASTNode child) { 782 if (caller == getStmtListNoTransform()) { 783 // @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:36 784 int index = caller.getIndexOfChild(child); 785 return index; 786 } 787 else { 788 return getParent().Define_blockIndex(this, caller); 789 } 790 } 791 protected boolean canDefine_blockIndex(ASTNode caller, ASTNode child) { 792 return true; 793 } 794 /** 795 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:71 796 * @apilevel internal 797 */ 798 public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) { 799 if (caller == getStmtListNoTransform()) { 800 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:74 801 int childIndex = caller.getIndexOfChild(child); 802 return false; 803 } 804 else { 805 return getParent().Define_isIncOrDec(this, caller); 806 } 807 } 808 protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) { 809 return true; 810 } 811 /** 812 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 813 * @apilevel internal 814 */ 815 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 816 if (caller == getStmtListNoTransform()) { 817 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:486 818 int index = caller.getIndexOfChild(child); 819 return index == 0 ? isDAbefore(v) : getStmt(index - 1).isDAafter(v); 820 } 821 else { 822 return getParent().Define_isDAbefore(this, caller, v); 823 } 824 } 825 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 826 return true; 827 } 828 /** 829 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 830 * @apilevel internal 831 */ 832 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 833 if (caller == getStmtListNoTransform()) { 834 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:986 835 int index = caller.getIndexOfChild(child); 836 return index == 0 ? isDUbefore(v) : getStmt(index - 1).isDUafter(v); 837 } 838 else { 839 return getParent().Define_isDUbefore(this, caller, v); 840 } 841 } 842 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 843 return true; 844 } 845 /** 846 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 847 * @apilevel internal 848 */ 849 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 850 if (caller == getStmtListNoTransform()) { 851 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:500 852 int index = caller.getIndexOfChild(child); 853 { 854 SimpleSet c = SimpleSet.emptySet; 855 for (int i = index; i >= 0 && !(getStmt(i) instanceof Case); i--) { 856 if (getStmt(i) instanceof LocalClassDeclStmt) { 857 TypeDecl t = ((LocalClassDeclStmt) getStmt(i)).getClassDecl(); 858 if (t.name().equals(name)) { 859 c = c.add(t); 860 } 861 } 862 } 863 if (!c.isEmpty()) { 864 return c; 865 } 866 return lookupType(name); 867 } 868 } 869 else { 870 return getParent().Define_lookupType(this, caller, name); 871 } 872 } 873 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 874 return true; 875 } 876 /** 877 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 878 * @apilevel internal 879 */ 880 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 881 if (caller == getStmtListNoTransform()) { 882 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:125 883 int index = caller.getIndexOfChild(child); 884 { 885 VariableDeclaration v = localVariableDeclaration(name); 886 // declare before use and shadowing 887 if (v != null && declaredBeforeUse(v, index)) { 888 return v; 889 } 890 return lookupVariable(name); 891 } 892 } 893 else { 894 return getParent().Define_lookupVariable(this, caller, name); 895 } 896 } 897 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 898 return true; 899 } 900 /** 901 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30 902 * @apilevel internal 903 */ 904 public VariableScope Define_outerScope(ASTNode caller, ASTNode child) { 905 if (caller == getStmtListNoTransform()) { 906 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:367 907 int childIndex = caller.getIndexOfChild(child); 908 return this; 909 } 910 else { 911 return getParent().Define_outerScope(this, caller); 912 } 913 } 914 protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) { 915 return true; 916 } 917 /** 918 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:524 919 * @apilevel internal 920 */ 921 public SimpleSet Define_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 922 if (caller == getStmtListNoTransform()) { 923 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:529 924 int index = caller.getIndexOfChild(child); 925 { 926 SimpleSet local = SimpleSet.emptySet; 927 for (int i = index-1; i >= 0 && !(getStmt(i) instanceof Case); --i) { 928 if (getStmt(i) instanceof LocalClassDeclStmt) { 929 TypeDecl t = ((LocalClassDeclStmt) getStmt(i)).getClassDecl(); 930 if (t.name().equals(name)) { 931 local = local.add(t); 932 } 933 } 934 } 935 if (!local.isEmpty()) { 936 return local; 937 } else { 938 return otherLocalClassDecls(name); 939 } 940 } 941 } 942 else { 943 return getParent().Define_otherLocalClassDecls(this, caller, name); 944 } 945 } 946 protected boolean canDefine_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 947 return true; 948 } 949 /** 950 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 951 * @apilevel internal 952 */ 953 public NameType Define_nameType(ASTNode caller, ASTNode child) { 954 if (caller == getStmtListNoTransform()) { 955 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:138 956 int childIndex = caller.getIndexOfChild(child); 957 return NameType.EXPRESSION_NAME; 958 } 959 else { 960 return getParent().Define_nameType(this, caller); 961 } 962 } 963 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 964 return true; 965 } 966 /** 967 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 968 * @apilevel internal 969 */ 970 public boolean Define_reachable(ASTNode caller, ASTNode child) { 971 if (caller == getStmtListNoTransform()) { 972 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:72 973 int index = caller.getIndexOfChild(child); 974 return index == 0 975 ? reachable() 976 : getStmt(index-1).canCompleteNormally(); 977 } 978 else { 979 return getParent().Define_reachable(this, caller); 980 } 981 } 982 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 983 return true; 984 } 985 /** 986 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:283 987 * @apilevel internal 988 */ 989 public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) { 990 if (caller == getStmtListNoTransform()) { 991 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:210 992 int i = caller.getIndexOfChild(child); 993 return i == 0 ? reachable() : getStmt(i-1).reachable(); 994 } 995 else { 996 return getParent().Define_reportUnreachable(this, caller); 997 } 998 } 999 protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) { 1000 return true; 1001 } 1002 /** 1003 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:67 1004 * @apilevel internal 1005 */ 1006 public int Define_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) { 1007 if (caller == getStmtListNoTransform()) { 1008 // @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:69 1009 int i = caller.getIndexOfChild(child); 1010 return variableScopeEndLabel(gen); 1011 } 1012 else { 1013 return getParent().Define_variableScopeEndLabel(this, caller, gen); 1014 } 1015 } 1016 protected boolean canDefine_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) { 1017 return true; 1018 } 1019 /** 1020 * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64 1021 * @apilevel internal 1022 */ 1023 public int Define_localNum(ASTNode caller, ASTNode child) { 1024 if (caller == getStmtListNoTransform()) { 1025 // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:183 1026 int index = caller.getIndexOfChild(child); 1027 { 1028 if (index == 0) { 1029 return localNum(); 1030 } else { 1031 return getStmt(index-1).localNum() + getStmt(index-1).localSize(); 1032 } 1033 } 1034 } 1035 else { 1036 return getParent().Define_localNum(this, caller); 1037 } 1038 } 1039 protected boolean canDefine_localNum(ASTNode caller, ASTNode child) { 1040 return true; 1041 } 1042 /** 1043 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 1044 * @apilevel internal 1045 */ 1046 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 1047 if (caller == getStmtListNoTransform()) { 1048 // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:51 1049 int childIndex = caller.getIndexOfChild(child); 1050 return modifiedInScope(var); 1051 } 1052 else { 1053 return getParent().Define_inhModifiedInScope(this, caller, var); 1054 } 1055 } 1056 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 1057 return true; 1058 } 1059 /** 1060 * @apilevel internal 1061 */ 1062 public ASTNode rewriteTo() { 1063 return super.rewriteTo(); 1064 } 1065 }