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:79 027 * @production VarDeclStmt : {@link Stmt} ::= <span class="component">{@link Modifiers}</span> <span class="component">TypeAccess:{@link Access}</span> <span class="component">{@link VariableDecl}*</span> <span class="component">SingleDecl:{@link VariableDeclaration}*</span>; 028 029 */ 030 public class VarDeclStmt extends Stmt implements Cloneable { 031 /** 032 * @aspect ErrorCheck 033 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:250 034 */ 035 public void collectErrors() { 036 // check reachability of the multi-declaration 037 checkUnreachableStmt(); 038 039 // delegate other error checks to NTA single variable declarations 040 getSingleDeclList().collectErrors(); 041 } 042 /** 043 * @aspect Java4PrettyPrint 044 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:165 045 */ 046 public void prettyPrint(PrettyPrinter out) { 047 out.print(getModifiers()); 048 out.print(getTypeAccess()); 049 out.print(" "); 050 out.join(getVariableDecls(), new PrettyPrinter.Joiner() { 051 @Override 052 public void printSeparator(PrettyPrinter out) { 053 out.print(", "); 054 } 055 }); 056 out.print(";"); 057 } 058 /** 059 * @aspect CreateBCode 060 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:269 061 */ 062 public void createBCode(CodeGeneration gen) { 063 gen.addLineNumberEntryAtCurrentPC(this);// generate line number entry 064 for (VariableDeclaration decl: getSingleDeclList()) { 065 decl.createBCode(gen); 066 } 067 } 068 /** 069 * @declaredat ASTNode:1 070 */ 071 public VarDeclStmt() { 072 super(); 073 } 074 /** 075 * Initializes the child array to the correct size. 076 * Initializes List and Opt nta children. 077 * @apilevel internal 078 * @ast method 079 * @declaredat ASTNode:10 080 */ 081 public void init$Children() { 082 children = new ASTNode[4]; 083 setChild(new List(), 2); 084 setChild(new List(), 3); 085 } 086 /** 087 * @declaredat ASTNode:15 088 */ 089 public VarDeclStmt(Modifiers p0, Access p1, List<VariableDecl> p2) { 090 setChild(p0, 0); 091 setChild(p1, 1); 092 setChild(p2, 2); 093 } 094 /** 095 * @apilevel low-level 096 * @declaredat ASTNode:23 097 */ 098 protected int numChildren() { 099 return 3; 100 } 101 /** 102 * @apilevel internal 103 * @declaredat ASTNode:29 104 */ 105 public boolean mayHaveRewrite() { 106 return false; 107 } 108 /** 109 * @apilevel internal 110 * @declaredat ASTNode:35 111 */ 112 public void flushAttrCache() { 113 super.flushAttrCache(); 114 isDAafter_Variable_reset(); 115 isDUafter_Variable_reset(); 116 canCompleteNormally_reset(); 117 getSingleDeclList_reset(); 118 localSize_reset(); 119 } 120 /** 121 * @apilevel internal 122 * @declaredat ASTNode:46 123 */ 124 public void flushCollectionCache() { 125 super.flushCollectionCache(); 126 } 127 /** 128 * @apilevel internal 129 * @declaredat ASTNode:52 130 */ 131 public void flushRewriteCache() { 132 super.flushRewriteCache(); 133 } 134 /** 135 * @apilevel internal 136 * @declaredat ASTNode:58 137 */ 138 public VarDeclStmt clone() throws CloneNotSupportedException { 139 VarDeclStmt node = (VarDeclStmt) super.clone(); 140 return node; 141 } 142 /** 143 * @apilevel internal 144 * @declaredat ASTNode:65 145 */ 146 public VarDeclStmt copy() { 147 try { 148 VarDeclStmt node = (VarDeclStmt) clone(); 149 node.parent = null; 150 if (children != null) { 151 node.children = (ASTNode[]) children.clone(); 152 } 153 return node; 154 } catch (CloneNotSupportedException e) { 155 throw new Error("Error: clone not supported for " + getClass().getName()); 156 } 157 } 158 /** 159 * Create a deep copy of the AST subtree at this node. 160 * The copy is dangling, i.e. has no parent. 161 * @return dangling copy of the subtree at this node 162 * @apilevel low-level 163 * @deprecated Please use treeCopy or treeCopyNoTransform instead 164 * @declaredat ASTNode:84 165 */ 166 @Deprecated 167 public VarDeclStmt fullCopy() { 168 return treeCopyNoTransform(); 169 } 170 /** 171 * Create a deep copy of the AST subtree at this node. 172 * The copy is dangling, i.e. has no parent. 173 * @return dangling copy of the subtree at this node 174 * @apilevel low-level 175 * @declaredat ASTNode:94 176 */ 177 public VarDeclStmt treeCopyNoTransform() { 178 VarDeclStmt tree = (VarDeclStmt) copy(); 179 if (children != null) { 180 for (int i = 0; i < children.length; ++i) { 181 switch (i) { 182 case 3: 183 tree.children[i] = new List(); 184 continue; 185 } 186 ASTNode child = (ASTNode) children[i]; 187 if (child != null) { 188 child = child.treeCopyNoTransform(); 189 tree.setChild(child, i); 190 } 191 } 192 } 193 return tree; 194 } 195 /** 196 * Create a deep copy of the AST subtree at this node. 197 * The subtree of this node is traversed to trigger rewrites before copy. 198 * The copy is dangling, i.e. has no parent. 199 * @return dangling copy of the subtree at this node 200 * @apilevel low-level 201 * @declaredat ASTNode:119 202 */ 203 public VarDeclStmt treeCopy() { 204 doFullTraversal(); 205 return treeCopyNoTransform(); 206 } 207 /** 208 * @apilevel internal 209 * @declaredat ASTNode:126 210 */ 211 protected boolean is$Equal(ASTNode node) { 212 return super.is$Equal(node); 213 } 214 /** 215 * Replaces the Modifiers child. 216 * @param node The new node to replace the Modifiers child. 217 * @apilevel high-level 218 */ 219 public void setModifiers(Modifiers node) { 220 setChild(node, 0); 221 } 222 /** 223 * Retrieves the Modifiers child. 224 * @return The current node used as the Modifiers child. 225 * @apilevel high-level 226 */ 227 @ASTNodeAnnotation.Child(name="Modifiers") 228 public Modifiers getModifiers() { 229 return (Modifiers) getChild(0); 230 } 231 /** 232 * Retrieves the Modifiers child. 233 * <p><em>This method does not invoke AST transformations.</em></p> 234 * @return The current node used as the Modifiers child. 235 * @apilevel low-level 236 */ 237 public Modifiers getModifiersNoTransform() { 238 return (Modifiers) getChildNoTransform(0); 239 } 240 /** 241 * Replaces the TypeAccess child. 242 * @param node The new node to replace the TypeAccess child. 243 * @apilevel high-level 244 */ 245 public void setTypeAccess(Access node) { 246 setChild(node, 1); 247 } 248 /** 249 * Retrieves the TypeAccess child. 250 * @return The current node used as the TypeAccess child. 251 * @apilevel high-level 252 */ 253 @ASTNodeAnnotation.Child(name="TypeAccess") 254 public Access getTypeAccess() { 255 return (Access) getChild(1); 256 } 257 /** 258 * Retrieves the TypeAccess child. 259 * <p><em>This method does not invoke AST transformations.</em></p> 260 * @return The current node used as the TypeAccess child. 261 * @apilevel low-level 262 */ 263 public Access getTypeAccessNoTransform() { 264 return (Access) getChildNoTransform(1); 265 } 266 /** 267 * Replaces the VariableDecl list. 268 * @param list The new list node to be used as the VariableDecl list. 269 * @apilevel high-level 270 */ 271 public void setVariableDeclList(List<VariableDecl> list) { 272 setChild(list, 2); 273 } 274 /** 275 * Retrieves the number of children in the VariableDecl list. 276 * @return Number of children in the VariableDecl list. 277 * @apilevel high-level 278 */ 279 public int getNumVariableDecl() { 280 return getVariableDeclList().getNumChild(); 281 } 282 /** 283 * Retrieves the number of children in the VariableDecl list. 284 * Calling this method will not trigger rewrites. 285 * @return Number of children in the VariableDecl list. 286 * @apilevel low-level 287 */ 288 public int getNumVariableDeclNoTransform() { 289 return getVariableDeclListNoTransform().getNumChildNoTransform(); 290 } 291 /** 292 * Retrieves the element at index {@code i} in the VariableDecl list. 293 * @param i Index of the element to return. 294 * @return The element at position {@code i} in the VariableDecl list. 295 * @apilevel high-level 296 */ 297 public VariableDecl getVariableDecl(int i) { 298 return (VariableDecl) getVariableDeclList().getChild(i); 299 } 300 /** 301 * Check whether the VariableDecl list has any children. 302 * @return {@code true} if it has at least one child, {@code false} otherwise. 303 * @apilevel high-level 304 */ 305 public boolean hasVariableDecl() { 306 return getVariableDeclList().getNumChild() != 0; 307 } 308 /** 309 * Append an element to the VariableDecl list. 310 * @param node The element to append to the VariableDecl list. 311 * @apilevel high-level 312 */ 313 public void addVariableDecl(VariableDecl node) { 314 List<VariableDecl> list = (parent == null) ? getVariableDeclListNoTransform() : getVariableDeclList(); 315 list.addChild(node); 316 } 317 /** 318 * @apilevel low-level 319 */ 320 public void addVariableDeclNoTransform(VariableDecl node) { 321 List<VariableDecl> list = getVariableDeclListNoTransform(); 322 list.addChild(node); 323 } 324 /** 325 * Replaces the VariableDecl list element at index {@code i} with the new node {@code node}. 326 * @param node The new node to replace the old list element. 327 * @param i The list index of the node to be replaced. 328 * @apilevel high-level 329 */ 330 public void setVariableDecl(VariableDecl node, int i) { 331 List<VariableDecl> list = getVariableDeclList(); 332 list.setChild(node, i); 333 } 334 /** 335 * Retrieves the VariableDecl list. 336 * @return The node representing the VariableDecl list. 337 * @apilevel high-level 338 */ 339 @ASTNodeAnnotation.ListChild(name="VariableDecl") 340 public List<VariableDecl> getVariableDeclList() { 341 List<VariableDecl> list = (List<VariableDecl>) getChild(2); 342 return list; 343 } 344 /** 345 * Retrieves the VariableDecl list. 346 * <p><em>This method does not invoke AST transformations.</em></p> 347 * @return The node representing the VariableDecl list. 348 * @apilevel low-level 349 */ 350 public List<VariableDecl> getVariableDeclListNoTransform() { 351 return (List<VariableDecl>) getChildNoTransform(2); 352 } 353 /** 354 * Retrieves the VariableDecl list. 355 * @return The node representing the VariableDecl list. 356 * @apilevel high-level 357 */ 358 public List<VariableDecl> getVariableDecls() { 359 return getVariableDeclList(); 360 } 361 /** 362 * Retrieves the VariableDecl list. 363 * <p><em>This method does not invoke AST transformations.</em></p> 364 * @return The node representing the VariableDecl list. 365 * @apilevel low-level 366 */ 367 public List<VariableDecl> getVariableDeclsNoTransform() { 368 return getVariableDeclListNoTransform(); 369 } 370 /** 371 * Retrieves the number of children in the SingleDecl list. 372 * @return Number of children in the SingleDecl list. 373 * @apilevel high-level 374 */ 375 public int getNumSingleDecl() { 376 return getSingleDeclList().getNumChild(); 377 } 378 /** 379 * Retrieves the number of children in the SingleDecl list. 380 * Calling this method will not trigger rewrites. 381 * @return Number of children in the SingleDecl list. 382 * @apilevel low-level 383 */ 384 public int getNumSingleDeclNoTransform() { 385 return getSingleDeclListNoTransform().getNumChildNoTransform(); 386 } 387 /** 388 * Retrieves the element at index {@code i} in the SingleDecl list. 389 * @param i Index of the element to return. 390 * @return The element at position {@code i} in the SingleDecl list. 391 * @apilevel high-level 392 */ 393 public VariableDeclaration getSingleDecl(int i) { 394 return (VariableDeclaration) getSingleDeclList().getChild(i); 395 } 396 /** 397 * Check whether the SingleDecl list has any children. 398 * @return {@code true} if it has at least one child, {@code false} otherwise. 399 * @apilevel high-level 400 */ 401 public boolean hasSingleDecl() { 402 return getSingleDeclList().getNumChild() != 0; 403 } 404 /** 405 * Append an element to the SingleDecl list. 406 * @param node The element to append to the SingleDecl list. 407 * @apilevel high-level 408 */ 409 public void addSingleDecl(VariableDeclaration node) { 410 List<VariableDeclaration> list = (parent == null) ? getSingleDeclListNoTransform() : getSingleDeclList(); 411 list.addChild(node); 412 } 413 /** 414 * @apilevel low-level 415 */ 416 public void addSingleDeclNoTransform(VariableDeclaration node) { 417 List<VariableDeclaration> list = getSingleDeclListNoTransform(); 418 list.addChild(node); 419 } 420 /** 421 * Replaces the SingleDecl list element at index {@code i} with the new node {@code node}. 422 * @param node The new node to replace the old list element. 423 * @param i The list index of the node to be replaced. 424 * @apilevel high-level 425 */ 426 public void setSingleDecl(VariableDeclaration node, int i) { 427 List<VariableDeclaration> list = getSingleDeclList(); 428 list.setChild(node, i); 429 } 430 /** 431 * Retrieves the child position of the SingleDecl list. 432 * @return The the child position of the SingleDecl list. 433 * @apilevel low-level 434 */ 435 protected int getSingleDeclListChildPosition() { 436 return 3; 437 } 438 /** 439 * Retrieves the SingleDecl list. 440 * <p><em>This method does not invoke AST transformations.</em></p> 441 * @return The node representing the SingleDecl list. 442 * @apilevel low-level 443 */ 444 public List<VariableDeclaration> getSingleDeclListNoTransform() { 445 return (List<VariableDeclaration>) getChildNoTransform(3); 446 } 447 /** 448 * Retrieves the SingleDecl list. 449 * @return The node representing the SingleDecl list. 450 * @apilevel high-level 451 */ 452 public List<VariableDeclaration> getSingleDecls() { 453 return getSingleDeclList(); 454 } 455 /** 456 * Retrieves the SingleDecl list. 457 * <p><em>This method does not invoke AST transformations.</em></p> 458 * @return The node representing the SingleDecl list. 459 * @apilevel low-level 460 */ 461 public List<VariableDeclaration> getSingleDeclsNoTransform() { 462 return getSingleDeclListNoTransform(); 463 } 464 /** 465 * @apilevel internal 466 */ 467 protected java.util.Map isDAafter_Variable_values; 468 /** 469 * @apilevel internal 470 */ 471 private void isDAafter_Variable_reset() { 472 isDAafter_Variable_values = null; 473 } 474 /** 475 * @attribute syn 476 * @aspect DA 477 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 478 */ 479 @ASTNodeAnnotation.Attribute 480 public boolean isDAafter(Variable v) { 481 Object _parameters = v; 482 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 483 ASTNode$State state = state(); 484 if (isDAafter_Variable_values.containsKey(_parameters)) { 485 return (Boolean) isDAafter_Variable_values.get(_parameters); 486 } 487 boolean intermediate = state.INTERMEDIATE_VALUE; 488 state.INTERMEDIATE_VALUE = false; 489 int num = state.boundariesCrossed; 490 boolean isFinal = this.is$Final(); 491 boolean isDAafter_Variable_value = getSingleDecl(getNumSingleDecl()-1).isDAafter(v); 492 if (isFinal && num == state().boundariesCrossed) { 493 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 494 } else { 495 } 496 state.INTERMEDIATE_VALUE |= intermediate; 497 498 return isDAafter_Variable_value; 499 } 500 /** 501 * @apilevel internal 502 */ 503 protected java.util.Map isDUafter_Variable_values; 504 /** 505 * @apilevel internal 506 */ 507 private void isDUafter_Variable_reset() { 508 isDUafter_Variable_values = null; 509 } 510 /** 511 * @attribute syn 512 * @aspect DU 513 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 514 */ 515 @ASTNodeAnnotation.Attribute 516 public boolean isDUafter(Variable v) { 517 Object _parameters = v; 518 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 519 ASTNode$State state = state(); 520 if (isDUafter_Variable_values.containsKey(_parameters)) { 521 return (Boolean) isDUafter_Variable_values.get(_parameters); 522 } 523 boolean intermediate = state.INTERMEDIATE_VALUE; 524 state.INTERMEDIATE_VALUE = false; 525 int num = state.boundariesCrossed; 526 boolean isFinal = this.is$Final(); 527 boolean isDUafter_Variable_value = getSingleDecl(getNumSingleDecl()-1).isDUafter(v); 528 if (isFinal && num == state().boundariesCrossed) { 529 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 530 } else { 531 } 532 state.INTERMEDIATE_VALUE |= intermediate; 533 534 return isDUafter_Variable_value; 535 } 536 /** 537 * @attribute syn 538 * @aspect VariableScope 539 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:205 540 */ 541 @ASTNodeAnnotation.Attribute 542 public VariableDeclaration variableDeclaration(String name) { 543 { 544 for (VariableDeclaration decl: getSingleDeclList()) { 545 if (decl.declaresVariable(name)) { 546 return decl; 547 } 548 } 549 return null; 550 } 551 } 552 /** 553 * @attribute syn 554 * @aspect TypeAnalysis 555 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:279 556 */ 557 @ASTNodeAnnotation.Attribute 558 public TypeDecl type() { 559 TypeDecl type_value = getTypeAccess().type(); 560 561 return type_value; 562 } 563 /** 564 * @apilevel internal 565 */ 566 protected boolean canCompleteNormally_computed = false; 567 /** 568 * @apilevel internal 569 */ 570 protected boolean canCompleteNormally_value; 571 /** 572 * @apilevel internal 573 */ 574 private void canCompleteNormally_reset() { 575 canCompleteNormally_computed = false; 576 } 577 /** 578 * @attribute syn 579 * @aspect UnreachableStatements 580 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 581 */ 582 @ASTNodeAnnotation.Attribute 583 public boolean canCompleteNormally() { 584 ASTNode$State state = state(); 585 if (canCompleteNormally_computed) { 586 return canCompleteNormally_value; 587 } 588 boolean intermediate = state.INTERMEDIATE_VALUE; 589 state.INTERMEDIATE_VALUE = false; 590 int num = state.boundariesCrossed; 591 boolean isFinal = this.is$Final(); 592 canCompleteNormally_value = reachable(); 593 if (isFinal && num == state().boundariesCrossed) { 594 canCompleteNormally_computed = true; 595 } else { 596 } 597 state.INTERMEDIATE_VALUE |= intermediate; 598 599 return canCompleteNormally_value; 600 } 601 /** 602 * @apilevel internal 603 */ 604 protected boolean getSingleDeclList_computed = false; 605 /** 606 * @apilevel internal 607 */ 608 protected List<VariableDeclaration> getSingleDeclList_value; 609 /** 610 * @apilevel internal 611 */ 612 private void getSingleDeclList_reset() { 613 getSingleDeclList_computed = false; 614 getSingleDeclList_value = null; 615 } 616 /** 617 * @attribute syn nta 618 * @aspect VariableDeclarationTransformation 619 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:163 620 */ 621 @ASTNodeAnnotation.Attribute 622 public List<VariableDeclaration> getSingleDeclList() { 623 ASTNode$State state = state(); 624 if (getSingleDeclList_computed) { 625 return (List<VariableDeclaration>) getChild(getSingleDeclListChildPosition()); 626 } 627 boolean intermediate = state.INTERMEDIATE_VALUE; 628 state.INTERMEDIATE_VALUE = false; 629 int num = state.boundariesCrossed; 630 boolean isFinal = this.is$Final(); 631 getSingleDeclList_value = getSingleDeclList_compute(); 632 setChild(getSingleDeclList_value, getSingleDeclListChildPosition()); 633 if (isFinal && num == state().boundariesCrossed) { 634 getSingleDeclList_computed = true; 635 } else { 636 } 637 state.INTERMEDIATE_VALUE |= intermediate; 638 639 List<VariableDeclaration> node = (List<VariableDeclaration>) this.getChild(getSingleDeclListChildPosition()); 640 return node; 641 } 642 /** 643 * @apilevel internal 644 */ 645 private List<VariableDeclaration> getSingleDeclList_compute() { 646 List<VariableDeclaration> decls = new List<VariableDeclaration>(); 647 for (int i = 0; i < getNumVariableDecl(); ++i) { 648 VariableDecl varDecl = getVariableDecl(i); 649 VariableDeclaration decl = varDecl.createVariableDeclarationFrom(getModifiers(), getTypeAccess()); 650 decls.add(decl); 651 } 652 return decls; 653 } 654 /** 655 * @apilevel internal 656 */ 657 protected boolean localSize_computed = false; 658 /** 659 * @apilevel internal 660 */ 661 protected int localSize_value; 662 /** 663 * @apilevel internal 664 */ 665 private void localSize_reset() { 666 localSize_computed = false; 667 } 668 /** 669 * Computes size required for local variables of this statement. 670 * NB: only relevant for variable declaration statements. 671 * @return local size for declared variables 672 * @attribute syn 673 * @aspect LocalNum 674 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:38 675 */ 676 @ASTNodeAnnotation.Attribute 677 public int localSize() { 678 ASTNode$State state = state(); 679 if (localSize_computed) { 680 return localSize_value; 681 } 682 boolean intermediate = state.INTERMEDIATE_VALUE; 683 state.INTERMEDIATE_VALUE = false; 684 int num = state.boundariesCrossed; 685 boolean isFinal = this.is$Final(); 686 localSize_value = localSize_compute(); 687 if (isFinal && num == state().boundariesCrossed) { 688 localSize_computed = true; 689 } else { 690 } 691 state.INTERMEDIATE_VALUE |= intermediate; 692 693 return localSize_value; 694 } 695 /** 696 * @apilevel internal 697 */ 698 private int localSize_compute() { 699 int size = 0; 700 for (VariableDeclaration decl: getSingleDeclList()) { 701 size += decl.localSize(); 702 } 703 return size; 704 } 705 /** 706 * @attribute syn 707 * @aspect PreciseRethrow 708 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 709 */ 710 @ASTNodeAnnotation.Attribute 711 public boolean modifiedInScope(Variable var) { 712 { 713 for (VariableDeclaration decl: getSingleDeclList()) { 714 if (decl.modifiedInScope(var)) { 715 return true; 716 } 717 } 718 return false; 719 } 720 } 721 /** 722 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:71 723 * @apilevel internal 724 */ 725 public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) { 726 if (caller == getSingleDeclListNoTransform()) { 727 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:75 728 int childIndex = caller.getIndexOfChild(child); 729 return false; 730 } 731 else { 732 return getParent().Define_isIncOrDec(this, caller); 733 } 734 } 735 protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) { 736 return true; 737 } 738 /** 739 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 740 * @apilevel internal 741 */ 742 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 743 if (caller == getSingleDeclListNoTransform()) { 744 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:488 745 int index = caller.getIndexOfChild(child); 746 return index == 0 ? isDAbefore(v) : getSingleDecl(index - 1).isDAafter(v); 747 } 748 else { 749 return getParent().Define_isDAbefore(this, caller, v); 750 } 751 } 752 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 753 return true; 754 } 755 /** 756 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 757 * @apilevel internal 758 */ 759 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 760 if (caller == getSingleDeclListNoTransform()) { 761 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:988 762 int index = caller.getIndexOfChild(child); 763 return index == 0 ? isDUbefore(v) : getSingleDecl(index - 1).isDUafter(v); 764 } 765 else { 766 return getParent().Define_isDUbefore(this, caller, v); 767 } 768 } 769 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 770 return true; 771 } 772 /** 773 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 774 * @apilevel internal 775 */ 776 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 777 if (caller == getSingleDeclListNoTransform()) { 778 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:112 779 int index = caller.getIndexOfChild(child); 780 { 781 for (int i = index; i >= 0; --i) { 782 if (getSingleDecl(i).declaresVariable(name)) { 783 return getSingleDecl(i); 784 } 785 } 786 return lookupVariable(name); 787 } 788 } 789 else { 790 return getParent().Define_lookupVariable(this, caller, name); 791 } 792 } 793 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 794 return true; 795 } 796 /** 797 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 798 * @apilevel internal 799 */ 800 public NameType Define_nameType(ASTNode caller, ASTNode child) { 801 if (caller == getTypeAccessNoTransform()) { 802 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:111 803 return NameType.TYPE_NAME; 804 } 805 else { 806 return getParent().Define_nameType(this, caller); 807 } 808 } 809 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 810 return true; 811 } 812 /** 813 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:601 814 * @apilevel internal 815 */ 816 public TypeDecl Define_declType(ASTNode caller, ASTNode child) { 817 if (caller == getVariableDeclListNoTransform()) { 818 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:284 819 int childIndex = caller.getIndexOfChild(child); 820 return null; 821 } 822 else { 823 return getParent().Define_declType(this, caller); 824 } 825 } 826 protected boolean canDefine_declType(ASTNode caller, ASTNode child) { 827 return true; 828 } 829 /** 830 * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64 831 * @apilevel internal 832 */ 833 public int Define_localNum(ASTNode caller, ASTNode child) { 834 if (caller == getSingleDeclListNoTransform()) { 835 // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:52 836 int index = caller.getIndexOfChild(child); 837 { 838 if (index == 0) { 839 return localNum(); 840 } else { 841 return getSingleDecl(index-1).localNum() + getSingleDecl(index-1).localSize(); 842 } 843 } 844 } 845 else { 846 return getParent().Define_localNum(this, caller); 847 } 848 } 849 protected boolean canDefine_localNum(ASTNode caller, ASTNode child) { 850 return true; 851 } 852 /** 853 * @apilevel internal 854 */ 855 public ASTNode rewriteTo() { 856 return super.rewriteTo(); 857 } 858 }