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:196 027 * @production ExprStmt : {@link Stmt} ::= <span class="component">{@link Expr}</span>; 028 029 */ 030 public class ExprStmt extends Stmt implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:151 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print(getExpr()); 037 out.print(";"); 038 } 039 /** 040 * @aspect CreateBCode 041 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1389 042 */ 043 public void createBCode(CodeGeneration gen) { 044 super.createBCode(gen); 045 getExpr().createBCode(gen); 046 if (needsPop()) { 047 getExpr().type().emitPop(gen); 048 } 049 } 050 /** 051 * @declaredat ASTNode:1 052 */ 053 public ExprStmt() { 054 super(); 055 } 056 /** 057 * Initializes the child array to the correct size. 058 * Initializes List and Opt nta children. 059 * @apilevel internal 060 * @ast method 061 * @declaredat ASTNode:10 062 */ 063 public void init$Children() { 064 children = new ASTNode[1]; 065 } 066 /** 067 * @declaredat ASTNode:13 068 */ 069 public ExprStmt(Expr p0) { 070 setChild(p0, 0); 071 } 072 /** 073 * @apilevel low-level 074 * @declaredat ASTNode:19 075 */ 076 protected int numChildren() { 077 return 1; 078 } 079 /** 080 * @apilevel internal 081 * @declaredat ASTNode:25 082 */ 083 public boolean mayHaveRewrite() { 084 return false; 085 } 086 /** 087 * @apilevel internal 088 * @declaredat ASTNode:31 089 */ 090 public void flushAttrCache() { 091 super.flushAttrCache(); 092 isDAafter_Variable_reset(); 093 isDUafter_Variable_reset(); 094 canCompleteNormally_reset(); 095 } 096 /** 097 * @apilevel internal 098 * @declaredat ASTNode:40 099 */ 100 public void flushCollectionCache() { 101 super.flushCollectionCache(); 102 } 103 /** 104 * @apilevel internal 105 * @declaredat ASTNode:46 106 */ 107 public void flushRewriteCache() { 108 super.flushRewriteCache(); 109 } 110 /** 111 * @apilevel internal 112 * @declaredat ASTNode:52 113 */ 114 public ExprStmt clone() throws CloneNotSupportedException { 115 ExprStmt node = (ExprStmt) super.clone(); 116 return node; 117 } 118 /** 119 * @apilevel internal 120 * @declaredat ASTNode:59 121 */ 122 public ExprStmt copy() { 123 try { 124 ExprStmt node = (ExprStmt) clone(); 125 node.parent = null; 126 if (children != null) { 127 node.children = (ASTNode[]) children.clone(); 128 } 129 return node; 130 } catch (CloneNotSupportedException e) { 131 throw new Error("Error: clone not supported for " + getClass().getName()); 132 } 133 } 134 /** 135 * Create a deep copy of the AST subtree at this node. 136 * The copy is dangling, i.e. has no parent. 137 * @return dangling copy of the subtree at this node 138 * @apilevel low-level 139 * @deprecated Please use treeCopy or treeCopyNoTransform instead 140 * @declaredat ASTNode:78 141 */ 142 @Deprecated 143 public ExprStmt fullCopy() { 144 return treeCopyNoTransform(); 145 } 146 /** 147 * Create a deep copy of the AST subtree at this node. 148 * The copy is dangling, i.e. has no parent. 149 * @return dangling copy of the subtree at this node 150 * @apilevel low-level 151 * @declaredat ASTNode:88 152 */ 153 public ExprStmt treeCopyNoTransform() { 154 ExprStmt tree = (ExprStmt) copy(); 155 if (children != null) { 156 for (int i = 0; i < children.length; ++i) { 157 ASTNode child = (ASTNode) children[i]; 158 if (child != null) { 159 child = child.treeCopyNoTransform(); 160 tree.setChild(child, i); 161 } 162 } 163 } 164 return tree; 165 } 166 /** 167 * Create a deep copy of the AST subtree at this node. 168 * The subtree of this node is traversed to trigger rewrites before copy. 169 * The copy is dangling, i.e. has no parent. 170 * @return dangling copy of the subtree at this node 171 * @apilevel low-level 172 * @declaredat ASTNode:108 173 */ 174 public ExprStmt treeCopy() { 175 doFullTraversal(); 176 return treeCopyNoTransform(); 177 } 178 /** 179 * @apilevel internal 180 * @declaredat ASTNode:115 181 */ 182 protected boolean is$Equal(ASTNode node) { 183 return super.is$Equal(node); 184 } 185 /** 186 * Replaces the Expr child. 187 * @param node The new node to replace the Expr child. 188 * @apilevel high-level 189 */ 190 public void setExpr(Expr node) { 191 setChild(node, 0); 192 } 193 /** 194 * Retrieves the Expr child. 195 * @return The current node used as the Expr child. 196 * @apilevel high-level 197 */ 198 @ASTNodeAnnotation.Child(name="Expr") 199 public Expr getExpr() { 200 return (Expr) getChild(0); 201 } 202 /** 203 * Retrieves the Expr child. 204 * <p><em>This method does not invoke AST transformations.</em></p> 205 * @return The current node used as the Expr child. 206 * @apilevel low-level 207 */ 208 public Expr getExprNoTransform() { 209 return (Expr) getChildNoTransform(0); 210 } 211 /** 212 * @apilevel internal 213 */ 214 protected java.util.Map isDAafter_Variable_values; 215 /** 216 * @apilevel internal 217 */ 218 private void isDAafter_Variable_reset() { 219 isDAafter_Variable_values = null; 220 } 221 /** 222 * @attribute syn 223 * @aspect DA 224 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 225 */ 226 @ASTNodeAnnotation.Attribute 227 public boolean isDAafter(Variable v) { 228 Object _parameters = v; 229 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 230 ASTNode$State state = state(); 231 if (isDAafter_Variable_values.containsKey(_parameters)) { 232 return (Boolean) isDAafter_Variable_values.get(_parameters); 233 } 234 boolean intermediate = state.INTERMEDIATE_VALUE; 235 state.INTERMEDIATE_VALUE = false; 236 int num = state.boundariesCrossed; 237 boolean isFinal = this.is$Final(); 238 boolean isDAafter_Variable_value = getExpr().isDAafter(v); 239 if (isFinal && num == state().boundariesCrossed) { 240 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 241 } else { 242 } 243 state.INTERMEDIATE_VALUE |= intermediate; 244 245 return isDAafter_Variable_value; 246 } 247 /** 248 * @apilevel internal 249 */ 250 protected java.util.Map isDUafter_Variable_values; 251 /** 252 * @apilevel internal 253 */ 254 private void isDUafter_Variable_reset() { 255 isDUafter_Variable_values = null; 256 } 257 /** 258 * @attribute syn 259 * @aspect DU 260 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 261 */ 262 @ASTNodeAnnotation.Attribute 263 public boolean isDUafter(Variable v) { 264 Object _parameters = v; 265 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 266 ASTNode$State state = state(); 267 if (isDUafter_Variable_values.containsKey(_parameters)) { 268 return (Boolean) isDUafter_Variable_values.get(_parameters); 269 } 270 boolean intermediate = state.INTERMEDIATE_VALUE; 271 state.INTERMEDIATE_VALUE = false; 272 int num = state.boundariesCrossed; 273 boolean isFinal = this.is$Final(); 274 boolean isDUafter_Variable_value = getExpr().isDUafter(v); 275 if (isFinal && num == state().boundariesCrossed) { 276 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 277 } else { 278 } 279 state.INTERMEDIATE_VALUE |= intermediate; 280 281 return isDUafter_Variable_value; 282 } 283 /** 284 * @apilevel internal 285 */ 286 protected boolean canCompleteNormally_computed = false; 287 /** 288 * @apilevel internal 289 */ 290 protected boolean canCompleteNormally_value; 291 /** 292 * @apilevel internal 293 */ 294 private void canCompleteNormally_reset() { 295 canCompleteNormally_computed = false; 296 } 297 /** 298 * @attribute syn 299 * @aspect UnreachableStatements 300 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53 301 */ 302 @ASTNodeAnnotation.Attribute 303 public boolean canCompleteNormally() { 304 ASTNode$State state = state(); 305 if (canCompleteNormally_computed) { 306 return canCompleteNormally_value; 307 } 308 boolean intermediate = state.INTERMEDIATE_VALUE; 309 state.INTERMEDIATE_VALUE = false; 310 int num = state.boundariesCrossed; 311 boolean isFinal = this.is$Final(); 312 canCompleteNormally_value = reachable(); 313 if (isFinal && num == state().boundariesCrossed) { 314 canCompleteNormally_computed = true; 315 } else { 316 } 317 state.INTERMEDIATE_VALUE |= intermediate; 318 319 return canCompleteNormally_value; 320 } 321 /** 322 * @attribute syn 323 * @aspect CodeGeneration 324 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:37 325 */ 326 @ASTNodeAnnotation.Attribute 327 public int sourceLineNumber() { 328 int sourceLineNumber_value = getExpr().findFirstSourceLineNumber(); 329 330 return sourceLineNumber_value; 331 } 332 /** 333 * @attribute syn 334 * @aspect CreateBCode 335 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:250 336 */ 337 @ASTNodeAnnotation.Attribute 338 public boolean needsPop() { 339 boolean needsPop_value = getExpr().needsPop(); 340 341 return needsPop_value; 342 } 343 /** 344 * @attribute syn 345 * @aspect PreciseRethrow 346 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 347 */ 348 @ASTNodeAnnotation.Attribute 349 public boolean modifiedInScope(Variable var) { 350 boolean modifiedInScope_Variable_value = getExpr().modifiedInScope(var); 351 352 return modifiedInScope_Variable_value; 353 } 354 /** 355 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 356 * @apilevel internal 357 */ 358 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 359 if (caller == getExprNoTransform()) { 360 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:588 361 return isDAbefore(v); 362 } 363 else { 364 return getParent().Define_isDAbefore(this, caller, v); 365 } 366 } 367 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 368 return true; 369 } 370 /** 371 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 372 * @apilevel internal 373 */ 374 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 375 if (caller == getExprNoTransform()) { 376 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1149 377 return isDUbefore(v); 378 } 379 else { 380 return getParent().Define_isDUbefore(this, caller, v); 381 } 382 } 383 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 384 return true; 385 } 386 /** 387 * @apilevel internal 388 */ 389 public ASTNode rewriteTo() { 390 return super.rewriteTo(); 391 } 392 }