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:169 027 * @production AndLogicalExpr : {@link LogicalExpr}; 028 029 */ 030 public class AndLogicalExpr extends LogicalExpr implements Cloneable { 031 /** 032 * @aspect CreateBCode 033 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1140 034 */ 035 public void branchTrue(CodeGeneration gen, int target) { 036 // branch when true 037 Expr left = getLeftOperand(); 038 Expr right = getRightOperand(); 039 int skip_lbl = -1; 040 if (!left.isConstant()) { 041 skip_lbl = gen.constantPool().newLabel(); 042 left.branchFalse(gen, skip_lbl); 043 } 044 if (left.canBeTrue()) { 045 right.branchTrue(gen, target); 046 } 047 if (skip_lbl != -1) { 048 gen.addLabel(skip_lbl); 049 } 050 } 051 /** 052 * @aspect CreateBCode 053 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1255 054 */ 055 public void branchFalse(CodeGeneration gen, int target) { 056 // branch when false 057 Expr left = getLeftOperand(); 058 Expr right = getRightOperand(); 059 if (!left.isTrue()) { 060 left.branchFalse(gen, target); 061 } 062 if (left.canBeTrue()) { 063 right.branchFalse(gen, target); 064 } 065 } 066 /** 067 * @declaredat ASTNode:1 068 */ 069 public AndLogicalExpr() { 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[2]; 081 } 082 /** 083 * @declaredat ASTNode:13 084 */ 085 public AndLogicalExpr(Expr p0, Expr p1) { 086 setChild(p0, 0); 087 setChild(p1, 1); 088 } 089 /** 090 * @apilevel low-level 091 * @declaredat ASTNode:20 092 */ 093 protected int numChildren() { 094 return 2; 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 isDAafterTrue_Variable_reset(); 110 isDAafterFalse_Variable_reset(); 111 isDAafter_Variable_reset(); 112 isDUafter_Variable_reset(); 113 } 114 /** 115 * @apilevel internal 116 * @declaredat ASTNode:42 117 */ 118 public void flushCollectionCache() { 119 super.flushCollectionCache(); 120 } 121 /** 122 * @apilevel internal 123 * @declaredat ASTNode:48 124 */ 125 public void flushRewriteCache() { 126 super.flushRewriteCache(); 127 } 128 /** 129 * @apilevel internal 130 * @declaredat ASTNode:54 131 */ 132 public AndLogicalExpr clone() throws CloneNotSupportedException { 133 AndLogicalExpr node = (AndLogicalExpr) super.clone(); 134 return node; 135 } 136 /** 137 * @apilevel internal 138 * @declaredat ASTNode:61 139 */ 140 public AndLogicalExpr copy() { 141 try { 142 AndLogicalExpr node = (AndLogicalExpr) clone(); 143 node.parent = null; 144 if (children != null) { 145 node.children = (ASTNode[]) children.clone(); 146 } 147 return node; 148 } catch (CloneNotSupportedException e) { 149 throw new Error("Error: clone not supported for " + getClass().getName()); 150 } 151 } 152 /** 153 * Create a deep copy of the AST subtree at this node. 154 * The copy is dangling, i.e. has no parent. 155 * @return dangling copy of the subtree at this node 156 * @apilevel low-level 157 * @deprecated Please use treeCopy or treeCopyNoTransform instead 158 * @declaredat ASTNode:80 159 */ 160 @Deprecated 161 public AndLogicalExpr fullCopy() { 162 return treeCopyNoTransform(); 163 } 164 /** 165 * Create a deep copy of the AST subtree at this node. 166 * The copy is dangling, i.e. has no parent. 167 * @return dangling copy of the subtree at this node 168 * @apilevel low-level 169 * @declaredat ASTNode:90 170 */ 171 public AndLogicalExpr treeCopyNoTransform() { 172 AndLogicalExpr tree = (AndLogicalExpr) copy(); 173 if (children != null) { 174 for (int i = 0; i < children.length; ++i) { 175 ASTNode child = (ASTNode) children[i]; 176 if (child != null) { 177 child = child.treeCopyNoTransform(); 178 tree.setChild(child, i); 179 } 180 } 181 } 182 return tree; 183 } 184 /** 185 * Create a deep copy of the AST subtree at this node. 186 * The subtree of this node is traversed to trigger rewrites before copy. 187 * The copy is dangling, i.e. has no parent. 188 * @return dangling copy of the subtree at this node 189 * @apilevel low-level 190 * @declaredat ASTNode:110 191 */ 192 public AndLogicalExpr treeCopy() { 193 doFullTraversal(); 194 return treeCopyNoTransform(); 195 } 196 /** 197 * @apilevel internal 198 * @declaredat ASTNode:117 199 */ 200 protected boolean is$Equal(ASTNode node) { 201 return super.is$Equal(node); 202 } 203 /** 204 * Replaces the LeftOperand child. 205 * @param node The new node to replace the LeftOperand child. 206 * @apilevel high-level 207 */ 208 public void setLeftOperand(Expr node) { 209 setChild(node, 0); 210 } 211 /** 212 * Retrieves the LeftOperand child. 213 * @return The current node used as the LeftOperand child. 214 * @apilevel high-level 215 */ 216 @ASTNodeAnnotation.Child(name="LeftOperand") 217 public Expr getLeftOperand() { 218 return (Expr) getChild(0); 219 } 220 /** 221 * Retrieves the LeftOperand child. 222 * <p><em>This method does not invoke AST transformations.</em></p> 223 * @return The current node used as the LeftOperand child. 224 * @apilevel low-level 225 */ 226 public Expr getLeftOperandNoTransform() { 227 return (Expr) getChildNoTransform(0); 228 } 229 /** 230 * Replaces the RightOperand child. 231 * @param node The new node to replace the RightOperand child. 232 * @apilevel high-level 233 */ 234 public void setRightOperand(Expr node) { 235 setChild(node, 1); 236 } 237 /** 238 * Retrieves the RightOperand child. 239 * @return The current node used as the RightOperand child. 240 * @apilevel high-level 241 */ 242 @ASTNodeAnnotation.Child(name="RightOperand") 243 public Expr getRightOperand() { 244 return (Expr) getChild(1); 245 } 246 /** 247 * Retrieves the RightOperand child. 248 * <p><em>This method does not invoke AST transformations.</em></p> 249 * @return The current node used as the RightOperand child. 250 * @apilevel low-level 251 */ 252 public Expr getRightOperandNoTransform() { 253 return (Expr) getChildNoTransform(1); 254 } 255 /** 256 * @attribute syn 257 * @aspect ConstantExpression 258 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:32 259 */ 260 @ASTNodeAnnotation.Attribute 261 public Constant constant() { 262 Constant constant_value = Constant.create(left().constant().booleanValue() && right().constant().booleanValue()); 263 264 return constant_value; 265 } 266 /** 267 * @apilevel internal 268 */ 269 protected java.util.Map isDAafterTrue_Variable_values; 270 /** 271 * @apilevel internal 272 */ 273 private void isDAafterTrue_Variable_reset() { 274 isDAafterTrue_Variable_values = null; 275 } 276 /** 277 * @attribute syn 278 * @aspect DA 279 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:442 280 */ 281 @ASTNodeAnnotation.Attribute 282 public boolean isDAafterTrue(Variable v) { 283 Object _parameters = v; 284 if (isDAafterTrue_Variable_values == null) isDAafterTrue_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 285 ASTNode$State state = state(); 286 if (isDAafterTrue_Variable_values.containsKey(_parameters)) { 287 return (Boolean) isDAafterTrue_Variable_values.get(_parameters); 288 } 289 boolean intermediate = state.INTERMEDIATE_VALUE; 290 state.INTERMEDIATE_VALUE = false; 291 int num = state.boundariesCrossed; 292 boolean isFinal = this.is$Final(); 293 boolean isDAafterTrue_Variable_value = isFalse() || getRightOperand().isDAafterTrue(v); 294 if (isFinal && num == state().boundariesCrossed) { 295 isDAafterTrue_Variable_values.put(_parameters, isDAafterTrue_Variable_value); 296 } else { 297 } 298 state.INTERMEDIATE_VALUE |= intermediate; 299 300 return isDAafterTrue_Variable_value; 301 } 302 /** 303 * @apilevel internal 304 */ 305 protected java.util.Map isDAafterFalse_Variable_values; 306 /** 307 * @apilevel internal 308 */ 309 private void isDAafterFalse_Variable_reset() { 310 isDAafterFalse_Variable_values = null; 311 } 312 /** 313 * @attribute syn 314 * @aspect DA 315 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:443 316 */ 317 @ASTNodeAnnotation.Attribute 318 public boolean isDAafterFalse(Variable v) { 319 Object _parameters = v; 320 if (isDAafterFalse_Variable_values == null) isDAafterFalse_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 321 ASTNode$State state = state(); 322 if (isDAafterFalse_Variable_values.containsKey(_parameters)) { 323 return (Boolean) isDAafterFalse_Variable_values.get(_parameters); 324 } 325 boolean intermediate = state.INTERMEDIATE_VALUE; 326 state.INTERMEDIATE_VALUE = false; 327 int num = state.boundariesCrossed; 328 boolean isFinal = this.is$Final(); 329 boolean isDAafterFalse_Variable_value = isTrue() || (getLeftOperand().isDAafterFalse(v) && getRightOperand().isDAafterFalse(v)); 330 if (isFinal && num == state().boundariesCrossed) { 331 isDAafterFalse_Variable_values.put(_parameters, isDAafterFalse_Variable_value); 332 } else { 333 } 334 state.INTERMEDIATE_VALUE |= intermediate; 335 336 return isDAafterFalse_Variable_value; 337 } 338 /** 339 * @apilevel internal 340 */ 341 protected java.util.Map isDAafter_Variable_values; 342 /** 343 * @apilevel internal 344 */ 345 private void isDAafter_Variable_reset() { 346 isDAafter_Variable_values = null; 347 } 348 /** 349 * @attribute syn 350 * @aspect DA 351 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:261 352 */ 353 @ASTNodeAnnotation.Attribute 354 public boolean isDAafter(Variable v) { 355 Object _parameters = v; 356 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 357 ASTNode$State state = state(); 358 if (isDAafter_Variable_values.containsKey(_parameters)) { 359 return (Boolean) isDAafter_Variable_values.get(_parameters); 360 } 361 boolean intermediate = state.INTERMEDIATE_VALUE; 362 state.INTERMEDIATE_VALUE = false; 363 int num = state.boundariesCrossed; 364 boolean isFinal = this.is$Final(); 365 boolean isDAafter_Variable_value = isDAafterTrue(v) && isDAafterFalse(v); 366 if (isFinal && num == state().boundariesCrossed) { 367 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 368 } else { 369 } 370 state.INTERMEDIATE_VALUE |= intermediate; 371 372 return isDAafter_Variable_value; 373 } 374 /** 375 * @attribute syn 376 * @aspect DU 377 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791 378 */ 379 @ASTNodeAnnotation.Attribute 380 public boolean isDUafterTrue(Variable v) { 381 boolean isDUafterTrue_Variable_value = getRightOperand().isDUafterTrue(v); 382 383 return isDUafterTrue_Variable_value; 384 } 385 /** 386 * @attribute syn 387 * @aspect DU 388 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792 389 */ 390 @ASTNodeAnnotation.Attribute 391 public boolean isDUafterFalse(Variable v) { 392 boolean isDUafterFalse_Variable_value = getLeftOperand().isDUafterFalse(v) && getRightOperand().isDUafterFalse(v); 393 394 return isDUafterFalse_Variable_value; 395 } 396 /** 397 * @apilevel internal 398 */ 399 protected java.util.Map isDUafter_Variable_values; 400 /** 401 * @apilevel internal 402 */ 403 private void isDUafter_Variable_reset() { 404 isDUafter_Variable_values = null; 405 } 406 /** 407 * @attribute syn 408 * @aspect DU 409 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:788 410 */ 411 @ASTNodeAnnotation.Attribute 412 public boolean isDUafter(Variable v) { 413 Object _parameters = v; 414 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 415 ASTNode$State state = state(); 416 if (isDUafter_Variable_values.containsKey(_parameters)) { 417 return (Boolean) isDUafter_Variable_values.get(_parameters); 418 } 419 boolean intermediate = state.INTERMEDIATE_VALUE; 420 state.INTERMEDIATE_VALUE = false; 421 int num = state.boundariesCrossed; 422 boolean isFinal = this.is$Final(); 423 boolean isDUafter_Variable_value = isDUafterTrue(v) && isDUafterFalse(v); 424 if (isFinal && num == state().boundariesCrossed) { 425 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 426 } else { 427 } 428 state.INTERMEDIATE_VALUE |= intermediate; 429 430 return isDUafter_Variable_value; 431 } 432 /** The operator string used for pretty printing this expression. 433 * @attribute syn 434 * @aspect PrettyPrintUtil 435 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:270 436 */ 437 @ASTNodeAnnotation.Attribute 438 public String printOp() { 439 String printOp_value = "&&"; 440 441 return printOp_value; 442 } 443 /** 444 * @attribute syn 445 * @aspect CreateBCode 446 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1022 447 */ 448 @ASTNodeAnnotation.Attribute 449 public boolean canBeTrue() { 450 boolean canBeTrue_value = getLeftOperand().canBeTrue() && getRightOperand().canBeTrue(); 451 452 return canBeTrue_value; 453 } 454 /** 455 * @attribute syn 456 * @aspect CreateBCode 457 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1034 458 */ 459 @ASTNodeAnnotation.Attribute 460 public boolean canBeFalse() { 461 boolean canBeFalse_value = getLeftOperand().canBeFalse() || getRightOperand().canBeFalse(); 462 463 return canBeFalse_value; 464 } 465 /** 466 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 467 * @apilevel internal 468 */ 469 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 470 if (caller == getRightOperandNoTransform()) { 471 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:409 472 return getLeftOperand().isDAafterTrue(v); 473 } 474 else if (caller == getLeftOperandNoTransform()) { 475 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:407 476 return isDAbefore(v); 477 } 478 else { 479 return super.Define_isDAbefore(caller, child, v); 480 } 481 } 482 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 483 return true; 484 } 485 /** 486 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 487 * @apilevel internal 488 */ 489 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 490 if (caller == getRightOperandNoTransform()) { 491 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:901 492 return getLeftOperand().isDUafterTrue(v); 493 } 494 else if (caller == getLeftOperandNoTransform()) { 495 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:900 496 return isDUbefore(v); 497 } 498 else { 499 return super.Define_isDUbefore(caller, child, v); 500 } 501 } 502 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 503 return true; 504 } 505 /** 506 * @apilevel internal 507 */ 508 public ASTNode rewriteTo() { 509 return super.rewriteTo(); 510 } 511 }