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:30 027 * @production ArrayAccess : {@link Access} ::= <span class="component">{@link Expr}</span>; 028 029 */ 030 public class ArrayAccess extends Access implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:432 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print("["); 037 out.print(getExpr()); 038 out.print("]"); 039 } 040 /** 041 * @aspect TypeCheck 042 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:159 043 */ 044 public void typeCheck() { 045 if (isQualified() && !qualifier().type().isArrayDecl() && !qualifier().type().isUnknown()) { 046 errorf("the type %s of the indexed element is not an array", qualifier().type().name()); 047 } 048 if (!getExpr().type().unaryNumericPromotion().isInt() || !getExpr().type().isIntegralType()) { 049 errorf("array index must be int after unary numeric promotion which %s is not", 050 getExpr().type().typeName()); 051 } 052 } 053 /** 054 * @aspect CodeGeneration 055 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:377 056 */ 057 public void emitStore(CodeGeneration gen) { 058 gen.emit(type().arrayStore()); 059 } 060 /** 061 * @aspect CreateBCode 062 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:459 063 */ 064 public void createPushAssignmentResult(CodeGeneration gen) { 065 type().emitDup_x2(gen); 066 } 067 /** 068 * @declaredat ASTNode:1 069 */ 070 public ArrayAccess() { 071 super(); 072 } 073 /** 074 * Initializes the child array to the correct size. 075 * Initializes List and Opt nta children. 076 * @apilevel internal 077 * @ast method 078 * @declaredat ASTNode:10 079 */ 080 public void init$Children() { 081 children = new ASTNode[1]; 082 } 083 /** 084 * @declaredat ASTNode:13 085 */ 086 public ArrayAccess(Expr p0) { 087 setChild(p0, 0); 088 } 089 /** 090 * @apilevel low-level 091 * @declaredat ASTNode:19 092 */ 093 protected int numChildren() { 094 return 1; 095 } 096 /** 097 * @apilevel internal 098 * @declaredat ASTNode:25 099 */ 100 public boolean mayHaveRewrite() { 101 return false; 102 } 103 /** 104 * @apilevel internal 105 * @declaredat ASTNode:31 106 */ 107 public void flushAttrCache() { 108 super.flushAttrCache(); 109 type_reset(); 110 } 111 /** 112 * @apilevel internal 113 * @declaredat ASTNode:38 114 */ 115 public void flushCollectionCache() { 116 super.flushCollectionCache(); 117 } 118 /** 119 * @apilevel internal 120 * @declaredat ASTNode:44 121 */ 122 public void flushRewriteCache() { 123 super.flushRewriteCache(); 124 } 125 /** 126 * @apilevel internal 127 * @declaredat ASTNode:50 128 */ 129 public ArrayAccess clone() throws CloneNotSupportedException { 130 ArrayAccess node = (ArrayAccess) super.clone(); 131 return node; 132 } 133 /** 134 * @apilevel internal 135 * @declaredat ASTNode:57 136 */ 137 public ArrayAccess copy() { 138 try { 139 ArrayAccess node = (ArrayAccess) clone(); 140 node.parent = null; 141 if (children != null) { 142 node.children = (ASTNode[]) children.clone(); 143 } 144 return node; 145 } catch (CloneNotSupportedException e) { 146 throw new Error("Error: clone not supported for " + getClass().getName()); 147 } 148 } 149 /** 150 * Create a deep copy of the AST subtree at this node. 151 * The copy is dangling, i.e. has no parent. 152 * @return dangling copy of the subtree at this node 153 * @apilevel low-level 154 * @deprecated Please use treeCopy or treeCopyNoTransform instead 155 * @declaredat ASTNode:76 156 */ 157 @Deprecated 158 public ArrayAccess fullCopy() { 159 return treeCopyNoTransform(); 160 } 161 /** 162 * Create a deep copy of the AST subtree at this node. 163 * The copy is dangling, i.e. has no parent. 164 * @return dangling copy of the subtree at this node 165 * @apilevel low-level 166 * @declaredat ASTNode:86 167 */ 168 public ArrayAccess treeCopyNoTransform() { 169 ArrayAccess tree = (ArrayAccess) copy(); 170 if (children != null) { 171 for (int i = 0; i < children.length; ++i) { 172 ASTNode child = (ASTNode) children[i]; 173 if (child != null) { 174 child = child.treeCopyNoTransform(); 175 tree.setChild(child, i); 176 } 177 } 178 } 179 return tree; 180 } 181 /** 182 * Create a deep copy of the AST subtree at this node. 183 * The subtree of this node is traversed to trigger rewrites before copy. 184 * The copy is dangling, i.e. has no parent. 185 * @return dangling copy of the subtree at this node 186 * @apilevel low-level 187 * @declaredat ASTNode:106 188 */ 189 public ArrayAccess treeCopy() { 190 doFullTraversal(); 191 return treeCopyNoTransform(); 192 } 193 /** 194 * @apilevel internal 195 * @declaredat ASTNode:113 196 */ 197 protected boolean is$Equal(ASTNode node) { 198 return super.is$Equal(node); 199 } 200 /** 201 * Replaces the Expr child. 202 * @param node The new node to replace the Expr child. 203 * @apilevel high-level 204 */ 205 public void setExpr(Expr node) { 206 setChild(node, 0); 207 } 208 /** 209 * Retrieves the Expr child. 210 * @return The current node used as the Expr child. 211 * @apilevel high-level 212 */ 213 @ASTNodeAnnotation.Child(name="Expr") 214 public Expr getExpr() { 215 return (Expr) getChild(0); 216 } 217 /** 218 * Retrieves the Expr child. 219 * <p><em>This method does not invoke AST transformations.</em></p> 220 * @return The current node used as the Expr child. 221 * @apilevel low-level 222 */ 223 public Expr getExprNoTransform() { 224 return (Expr) getChildNoTransform(0); 225 } 226 /** 227 * @aspect AutoBoxingCodegen 228 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:449 229 */ 230 public void createAssignSimpleLoadDest(CodeGeneration gen) { 231 prevExpr().createBCode(gen); 232 getExpr().createBCode(gen); 233 getExpr().type().emitCastTo(gen, typeInt()); 234 } 235 /** 236 * @aspect AutoBoxingCodegen 237 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:455 238 */ 239 public void createAssignLoadDest(CodeGeneration gen) { 240 prevExpr().createBCode(gen); 241 gen.emitDup(); 242 getExpr().createBCode(gen); 243 getExpr().type().emitCastTo(gen, typeInt()); 244 typeInt().emitDup_x1(gen); 245 gen.emit(type().arrayLoad()); 246 } 247 /** 248 * @aspect AutoBoxingCodegen 249 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:442 250 */ 251 public void createBCode(CodeGeneration gen) { 252 prevExpr().createBCode(gen); 253 getExpr().createBCode(gen); 254 getExpr().type().emitCastTo(gen, typeInt()); 255 gen.emit(type().arrayLoad()); 256 } 257 /** 258 * @attribute syn 259 * @aspect DA 260 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 261 */ 262 @ASTNodeAnnotation.Attribute 263 public boolean isDAafter(Variable v) { 264 boolean isDAafter_Variable_value = getExpr().isDAafter(v); 265 266 return isDAafter_Variable_value; 267 } 268 /** 269 * @attribute syn 270 * @aspect DU 271 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 272 */ 273 @ASTNodeAnnotation.Attribute 274 public boolean isDUafter(Variable v) { 275 boolean isDUafter_Variable_value = getExpr().isDUafter(v); 276 277 return isDUafter_Variable_value; 278 } 279 /** 280 * @attribute syn 281 * @aspect AccessTypes 282 * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:63 283 */ 284 @ASTNodeAnnotation.Attribute 285 public boolean isArrayAccess() { 286 boolean isArrayAccess_value = true; 287 288 return isArrayAccess_value; 289 } 290 /** 291 * Defines the expected kind of name for the left hand side in a qualified 292 * expression. 293 * @attribute syn 294 * @aspect SyntacticClassification 295 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58 296 */ 297 @ASTNodeAnnotation.Attribute 298 public NameType predNameType() { 299 NameType predNameType_value = NameType.EXPRESSION_NAME; 300 301 return predNameType_value; 302 } 303 /** 304 * @apilevel internal 305 */ 306 protected boolean type_computed = false; 307 /** 308 * @apilevel internal 309 */ 310 protected TypeDecl type_value; 311 /** 312 * @apilevel internal 313 */ 314 private void type_reset() { 315 type_computed = false; 316 type_value = null; 317 } 318 /** 319 * @attribute syn 320 * @aspect TypeAnalysis 321 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302 322 */ 323 @ASTNodeAnnotation.Attribute 324 public TypeDecl type() { 325 ASTNode$State state = state(); 326 if (type_computed) { 327 return type_value; 328 } 329 boolean intermediate = state.INTERMEDIATE_VALUE; 330 state.INTERMEDIATE_VALUE = false; 331 int num = state.boundariesCrossed; 332 boolean isFinal = this.is$Final(); 333 type_value = isQualified() ? qualifier().type().componentType() : unknownType(); 334 if (isFinal && num == state().boundariesCrossed) { 335 type_computed = true; 336 } else { 337 } 338 state.INTERMEDIATE_VALUE |= intermediate; 339 340 return type_value; 341 } 342 /** 343 * @attribute syn 344 * @aspect TypeCheck 345 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:36 346 */ 347 @ASTNodeAnnotation.Attribute 348 public boolean isVariable() { 349 boolean isVariable_value = true; 350 351 return isVariable_value; 352 } 353 /** 354 * @attribute syn 355 * @aspect PreciseRethrow 356 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 357 */ 358 @ASTNodeAnnotation.Attribute 359 public boolean modifiedInScope(Variable var) { 360 boolean modifiedInScope_Variable_value = getExpr().modifiedInScope(var); 361 362 return modifiedInScope_Variable_value; 363 } 364 /** 365 * @attribute inh 366 * @aspect TypeAnalysis 367 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:307 368 */ 369 /** 370 * @attribute inh 371 * @aspect TypeAnalysis 372 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:307 373 */ 374 @ASTNodeAnnotation.Attribute 375 public TypeDecl unknownType() { 376 TypeDecl unknownType_value = getParent().Define_unknownType(this, null); 377 378 return unknownType_value; 379 } 380 /** 381 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37 382 * @apilevel internal 383 */ 384 public boolean Define_isDest(ASTNode caller, ASTNode child) { 385 if (caller == getExprNoTransform()) { 386 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:56 387 return false; 388 } 389 else { 390 return getParent().Define_isDest(this, caller); 391 } 392 } 393 protected boolean canDefine_isDest(ASTNode caller, ASTNode child) { 394 return true; 395 } 396 /** 397 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47 398 * @apilevel internal 399 */ 400 public boolean Define_isSource(ASTNode caller, ASTNode child) { 401 if (caller == getExprNoTransform()) { 402 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:57 403 return true; 404 } 405 else { 406 return getParent().Define_isSource(this, caller); 407 } 408 } 409 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 410 return true; 411 } 412 /** 413 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 414 * @apilevel internal 415 */ 416 public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) { 417 if (caller == getExprNoTransform()) { 418 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:52 419 return unqualifiedScope().lookupMethod(name); 420 } 421 else { 422 return getParent().Define_lookupMethod(this, caller, name); 423 } 424 } 425 protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) { 426 return true; 427 } 428 /** 429 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115 430 * @apilevel internal 431 */ 432 public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) { 433 if (caller == getExprNoTransform()) { 434 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:122 435 return unqualifiedScope().hasPackage(packageName); 436 } 437 else { 438 return getParent().Define_hasPackage(this, caller, packageName); 439 } 440 } 441 protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) { 442 return true; 443 } 444 /** 445 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 446 * @apilevel internal 447 */ 448 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 449 if (caller == getExprNoTransform()) { 450 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:332 451 return unqualifiedScope().lookupType(name); 452 } 453 else { 454 return getParent().Define_lookupType(this, caller, name); 455 } 456 } 457 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 458 return true; 459 } 460 /** 461 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 462 * @apilevel internal 463 */ 464 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 465 if (caller == getExprNoTransform()) { 466 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:223 467 return unqualifiedScope().lookupVariable(name); 468 } 469 else { 470 return getParent().Define_lookupVariable(this, caller, name); 471 } 472 } 473 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 474 return true; 475 } 476 /** 477 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 478 * @apilevel internal 479 */ 480 public NameType Define_nameType(ASTNode caller, ASTNode child) { 481 if (caller == getExprNoTransform()) { 482 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:145 483 return NameType.EXPRESSION_NAME; 484 } 485 else { 486 return getParent().Define_nameType(this, caller); 487 } 488 } 489 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 490 return true; 491 } 492 /** 493 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 494 * @apilevel internal 495 */ 496 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 497 if (caller == getExprNoTransform()) { 498 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:282 499 return false; 500 } 501 else { 502 return getParent().Define_assignmentContext(this, caller); 503 } 504 } 505 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 506 return true; 507 } 508 /** 509 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 510 * @apilevel internal 511 */ 512 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 513 if (caller == getExprNoTransform()) { 514 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:283 515 return false; 516 } 517 else { 518 return getParent().Define_invocationContext(this, caller); 519 } 520 } 521 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 522 return true; 523 } 524 /** 525 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 526 * @apilevel internal 527 */ 528 public boolean Define_castContext(ASTNode caller, ASTNode child) { 529 if (caller == getExprNoTransform()) { 530 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:284 531 return false; 532 } 533 else { 534 return getParent().Define_castContext(this, caller); 535 } 536 } 537 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 538 return true; 539 } 540 /** 541 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 542 * @apilevel internal 543 */ 544 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 545 if (caller == getExprNoTransform()) { 546 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:285 547 return false; 548 } 549 else { 550 return getParent().Define_stringContext(this, caller); 551 } 552 } 553 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 554 return true; 555 } 556 /** 557 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 558 * @apilevel internal 559 */ 560 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 561 if (caller == getExprNoTransform()) { 562 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:286 563 return false; 564 } 565 else { 566 return getParent().Define_numericContext(this, caller); 567 } 568 } 569 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 570 return true; 571 } 572 /** 573 * @apilevel internal 574 */ 575 public ASTNode rewriteTo() { 576 return super.rewriteTo(); 577 } 578 }