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:139 027 * @production LogNotExpr : {@link Unary}; 028 029 */ 030 public class LogNotExpr extends Unary implements Cloneable { 031 /** 032 * @aspect TypeCheck 033 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:338 034 */ 035 public void typeCheck() { 036 if (!getOperand().type().isBoolean()) { 037 error("unary ! only operates on boolean types"); 038 } 039 } 040 /** 041 * @aspect CodeGenerationBinaryOperations 042 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:659 043 */ 044 void emitOperation(CodeGeneration gen) { type().logNot(gen); } 045 /** 046 * @aspect CreateBCode 047 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1047 048 */ 049 public void createBCode(CodeGeneration gen) { emitBooleanCondition(gen); } 050 /** 051 * @aspect CreateBCode 052 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1135 053 */ 054 public void branchTrue(CodeGeneration gen, int target) { 055 // branch when true 056 getOperand().branchFalse(gen, target); 057 } 058 /** 059 * @aspect CreateBCode 060 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1250 061 */ 062 public void branchFalse(CodeGeneration gen, int target) { 063 // branch when false 064 getOperand().branchTrue(gen, target); 065 } 066 /** 067 * @declaredat ASTNode:1 068 */ 069 public LogNotExpr() { 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 } 082 /** 083 * @declaredat ASTNode:13 084 */ 085 public LogNotExpr(Expr p0) { 086 setChild(p0, 0); 087 } 088 /** 089 * @apilevel low-level 090 * @declaredat ASTNode:19 091 */ 092 protected int numChildren() { 093 return 1; 094 } 095 /** 096 * @apilevel internal 097 * @declaredat ASTNode:25 098 */ 099 public boolean mayHaveRewrite() { 100 return false; 101 } 102 /** 103 * @apilevel internal 104 * @declaredat ASTNode:31 105 */ 106 public void flushAttrCache() { 107 super.flushAttrCache(); 108 type_reset(); 109 } 110 /** 111 * @apilevel internal 112 * @declaredat ASTNode:38 113 */ 114 public void flushCollectionCache() { 115 super.flushCollectionCache(); 116 } 117 /** 118 * @apilevel internal 119 * @declaredat ASTNode:44 120 */ 121 public void flushRewriteCache() { 122 super.flushRewriteCache(); 123 } 124 /** 125 * @apilevel internal 126 * @declaredat ASTNode:50 127 */ 128 public LogNotExpr clone() throws CloneNotSupportedException { 129 LogNotExpr node = (LogNotExpr) super.clone(); 130 return node; 131 } 132 /** 133 * @apilevel internal 134 * @declaredat ASTNode:57 135 */ 136 public LogNotExpr copy() { 137 try { 138 LogNotExpr node = (LogNotExpr) clone(); 139 node.parent = null; 140 if (children != null) { 141 node.children = (ASTNode[]) children.clone(); 142 } 143 return node; 144 } catch (CloneNotSupportedException e) { 145 throw new Error("Error: clone not supported for " + getClass().getName()); 146 } 147 } 148 /** 149 * Create a deep copy of the AST subtree at this node. 150 * The copy is dangling, i.e. has no parent. 151 * @return dangling copy of the subtree at this node 152 * @apilevel low-level 153 * @deprecated Please use treeCopy or treeCopyNoTransform instead 154 * @declaredat ASTNode:76 155 */ 156 @Deprecated 157 public LogNotExpr fullCopy() { 158 return treeCopyNoTransform(); 159 } 160 /** 161 * Create a deep copy of the AST subtree at this node. 162 * The copy is dangling, i.e. has no parent. 163 * @return dangling copy of the subtree at this node 164 * @apilevel low-level 165 * @declaredat ASTNode:86 166 */ 167 public LogNotExpr treeCopyNoTransform() { 168 LogNotExpr tree = (LogNotExpr) copy(); 169 if (children != null) { 170 for (int i = 0; i < children.length; ++i) { 171 ASTNode child = (ASTNode) children[i]; 172 if (child != null) { 173 child = child.treeCopyNoTransform(); 174 tree.setChild(child, i); 175 } 176 } 177 } 178 return tree; 179 } 180 /** 181 * Create a deep copy of the AST subtree at this node. 182 * The subtree of this node is traversed to trigger rewrites before copy. 183 * The copy is dangling, i.e. has no parent. 184 * @return dangling copy of the subtree at this node 185 * @apilevel low-level 186 * @declaredat ASTNode:106 187 */ 188 public LogNotExpr treeCopy() { 189 doFullTraversal(); 190 return treeCopyNoTransform(); 191 } 192 /** 193 * @apilevel internal 194 * @declaredat ASTNode:113 195 */ 196 protected boolean is$Equal(ASTNode node) { 197 return super.is$Equal(node); 198 } 199 /** 200 * Replaces the Operand child. 201 * @param node The new node to replace the Operand child. 202 * @apilevel high-level 203 */ 204 public void setOperand(Expr node) { 205 setChild(node, 0); 206 } 207 /** 208 * Retrieves the Operand child. 209 * @return The current node used as the Operand child. 210 * @apilevel high-level 211 */ 212 @ASTNodeAnnotation.Child(name="Operand") 213 public Expr getOperand() { 214 return (Expr) getChild(0); 215 } 216 /** 217 * Retrieves the Operand child. 218 * <p><em>This method does not invoke AST transformations.</em></p> 219 * @return The current node used as the Operand child. 220 * @apilevel low-level 221 */ 222 public Expr getOperandNoTransform() { 223 return (Expr) getChildNoTransform(0); 224 } 225 /** 226 * @attribute syn 227 * @aspect ConstantExpression 228 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:254 229 */ 230 @ASTNodeAnnotation.Attribute 231 public boolean isConstant() { 232 boolean isConstant_value = getOperand().isConstant(); 233 234 return isConstant_value; 235 } 236 /** 237 * @attribute syn 238 * @aspect ConstantExpression 239 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:283 240 */ 241 @ASTNodeAnnotation.Attribute 242 public boolean isTrue() { 243 boolean isTrue_value = getOperand().isFalse(); 244 245 return isTrue_value; 246 } 247 /** 248 * @attribute syn 249 * @aspect ConstantExpression 250 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:284 251 */ 252 @ASTNodeAnnotation.Attribute 253 public boolean isFalse() { 254 boolean isFalse_value = getOperand().isTrue(); 255 256 return isFalse_value; 257 } 258 /** 259 * @attribute syn 260 * @aspect ConstantExpression 261 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:32 262 */ 263 @ASTNodeAnnotation.Attribute 264 public Constant constant() { 265 Constant constant_value = Constant.create(!getOperand().constant().booleanValue()); 266 267 return constant_value; 268 } 269 /** 270 * @attribute syn 271 * @aspect DA 272 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:374 273 */ 274 @ASTNodeAnnotation.Attribute 275 public boolean isDAafterTrue(Variable v) { 276 boolean isDAafterTrue_Variable_value = isFalse() || getOperand().isDAafterFalse(v); 277 278 return isDAafterTrue_Variable_value; 279 } 280 /** 281 * @attribute syn 282 * @aspect DA 283 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:375 284 */ 285 @ASTNodeAnnotation.Attribute 286 public boolean isDAafterFalse(Variable v) { 287 boolean isDAafterFalse_Variable_value = isTrue() || getOperand().isDAafterTrue(v); 288 289 return isDAafterFalse_Variable_value; 290 } 291 /** 292 * @attribute syn 293 * @aspect DA 294 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 295 */ 296 @ASTNodeAnnotation.Attribute 297 public boolean isDAafter(Variable v) { 298 boolean isDAafter_Variable_value = isDAafterTrue(v) && isDAafterFalse(v); 299 300 return isDAafter_Variable_value; 301 } 302 /** 303 * @attribute syn 304 * @aspect DU 305 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791 306 */ 307 @ASTNodeAnnotation.Attribute 308 public boolean isDUafterTrue(Variable v) { 309 boolean isDUafterTrue_Variable_value = getOperand().isDUafterFalse(v); 310 311 return isDUafterTrue_Variable_value; 312 } 313 /** 314 * @attribute syn 315 * @aspect DU 316 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792 317 */ 318 @ASTNodeAnnotation.Attribute 319 public boolean isDUafterFalse(Variable v) { 320 boolean isDUafterFalse_Variable_value = getOperand().isDUafterTrue(v); 321 322 return isDUafterFalse_Variable_value; 323 } 324 /** 325 * @attribute syn 326 * @aspect DU 327 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 328 */ 329 @ASTNodeAnnotation.Attribute 330 public boolean isDUafter(Variable v) { 331 boolean isDUafter_Variable_value = isDUafterTrue(v) && isDUafterFalse(v); 332 333 return isDUafter_Variable_value; 334 } 335 /** 336 * @attribute syn 337 * @aspect PrettyPrintUtil 338 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:310 339 */ 340 @ASTNodeAnnotation.Attribute 341 public String printPreOp() { 342 String printPreOp_value = "!"; 343 344 return printPreOp_value; 345 } 346 /** 347 * @apilevel internal 348 */ 349 protected boolean type_computed = false; 350 /** 351 * @apilevel internal 352 */ 353 protected TypeDecl type_value; 354 /** 355 * @apilevel internal 356 */ 357 private void type_reset() { 358 type_computed = false; 359 type_value = null; 360 } 361 /** 362 * @attribute syn 363 * @aspect TypeAnalysis 364 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302 365 */ 366 @ASTNodeAnnotation.Attribute 367 public TypeDecl type() { 368 ASTNode$State state = state(); 369 if (type_computed) { 370 return type_value; 371 } 372 boolean intermediate = state.INTERMEDIATE_VALUE; 373 state.INTERMEDIATE_VALUE = false; 374 int num = state.boundariesCrossed; 375 boolean isFinal = this.is$Final(); 376 type_value = typeBoolean(); 377 if (isFinal && num == state().boundariesCrossed) { 378 type_computed = true; 379 } else { 380 } 381 state.INTERMEDIATE_VALUE |= intermediate; 382 383 return type_value; 384 } 385 /** 386 * @attribute syn 387 * @aspect CreateBCode 388 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1022 389 */ 390 @ASTNodeAnnotation.Attribute 391 public boolean canBeTrue() { 392 boolean canBeTrue_value = getOperand().canBeFalse(); 393 394 return canBeTrue_value; 395 } 396 /** 397 * @attribute syn 398 * @aspect CreateBCode 399 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1034 400 */ 401 @ASTNodeAnnotation.Attribute 402 public boolean canBeFalse() { 403 boolean canBeFalse_value = getOperand().canBeTrue(); 404 405 return canBeFalse_value; 406 } 407 /** 408 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 409 * @apilevel internal 410 */ 411 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 412 if (caller == getOperandNoTransform()) { 413 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:421 414 return isDAbefore(v); 415 } 416 else { 417 return getParent().Define_isDAbefore(this, caller, v); 418 } 419 } 420 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 421 return true; 422 } 423 /** 424 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 425 * @apilevel internal 426 */ 427 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 428 if (caller == getOperandNoTransform()) { 429 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:912 430 return isDUbefore(v); 431 } 432 else { 433 return getParent().Define_isDUbefore(this, caller, v); 434 } 435 } 436 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 437 return true; 438 } 439 /** 440 * @apilevel internal 441 */ 442 public ASTNode rewriteTo() { 443 return super.rewriteTo(); 444 } 445 }