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:147 027 * @production Binary : {@link Expr} ::= <span class="component">LeftOperand:{@link Expr}</span> <span class="component">RightOperand:{@link Expr}</span>; 028 029 */ 030 public abstract class Binary extends Expr implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:187 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print(getLeftOperand()); 037 out.print(" "); 038 out.print(printOp()); 039 out.print(" "); 040 out.print(getRightOperand()); 041 } 042 /** 043 * @aspect CreateBCode 044 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:965 045 */ 046 public void createBCode(CodeGeneration gen) { 047 getLeftOperand().createBCode(gen); 048 getLeftOperand().type().emitCastTo(gen, type()); // Binary numeric promotion 049 getRightOperand().createBCode(gen); 050 getRightOperand().type().emitCastTo(gen, type()); // Binary numeric promotion 051 emitOperation(gen); 052 } 053 /** 054 * @aspect CreateBCode 055 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:973 056 */ 057 public void emitShiftExpr(CodeGeneration gen) { 058 getLeftOperand().createBCode(gen); 059 getLeftOperand().type().emitCastTo(gen, type()); // Binary numeric promotion 060 getRightOperand().createBCode(gen); 061 getRightOperand().type().emitCastTo(gen, typeInt()); 062 emitOperation(gen); 063 } 064 /** 065 * @declaredat ASTNode:1 066 */ 067 public Binary() { 068 super(); 069 } 070 /** 071 * Initializes the child array to the correct size. 072 * Initializes List and Opt nta children. 073 * @apilevel internal 074 * @ast method 075 * @declaredat ASTNode:10 076 */ 077 public void init$Children() { 078 children = new ASTNode[2]; 079 } 080 /** 081 * @declaredat ASTNode:13 082 */ 083 public Binary(Expr p0, Expr p1) { 084 setChild(p0, 0); 085 setChild(p1, 1); 086 } 087 /** 088 * @apilevel low-level 089 * @declaredat ASTNode:20 090 */ 091 protected int numChildren() { 092 return 2; 093 } 094 /** 095 * @apilevel internal 096 * @declaredat ASTNode:26 097 */ 098 public boolean mayHaveRewrite() { 099 return false; 100 } 101 /** 102 * @apilevel internal 103 * @declaredat ASTNode:32 104 */ 105 public void flushAttrCache() { 106 super.flushAttrCache(); 107 isConstant_reset(); 108 isDAafterTrue_Variable_reset(); 109 isDAafterFalse_Variable_reset(); 110 isDAafter_Variable_reset(); 111 isDUafter_Variable_reset(); 112 isDUbefore_Variable_reset(); 113 } 114 /** 115 * @apilevel internal 116 * @declaredat ASTNode:44 117 */ 118 public void flushCollectionCache() { 119 super.flushCollectionCache(); 120 } 121 /** 122 * @apilevel internal 123 * @declaredat ASTNode:50 124 */ 125 public void flushRewriteCache() { 126 super.flushRewriteCache(); 127 } 128 /** 129 * @apilevel internal 130 * @declaredat ASTNode:56 131 */ 132 public Binary clone() throws CloneNotSupportedException { 133 Binary node = (Binary) super.clone(); 134 return node; 135 } 136 /** 137 * Create a deep copy of the AST subtree at this node. 138 * The copy is dangling, i.e. has no parent. 139 * @return dangling copy of the subtree at this node 140 * @apilevel low-level 141 * @deprecated Please use treeCopy or treeCopyNoTransform instead 142 * @declaredat ASTNode:67 143 */ 144 @Deprecated 145 public abstract Binary fullCopy(); 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:75 152 */ 153 public abstract Binary treeCopyNoTransform(); 154 /** 155 * Create a deep copy of the AST subtree at this node. 156 * The subtree of this node is traversed to trigger rewrites before copy. 157 * The copy is dangling, i.e. has no parent. 158 * @return dangling copy of the subtree at this node 159 * @apilevel low-level 160 * @declaredat ASTNode:83 161 */ 162 public abstract Binary treeCopy(); 163 /** 164 * Replaces the LeftOperand child. 165 * @param node The new node to replace the LeftOperand child. 166 * @apilevel high-level 167 */ 168 public void setLeftOperand(Expr node) { 169 setChild(node, 0); 170 } 171 /** 172 * Retrieves the LeftOperand child. 173 * @return The current node used as the LeftOperand child. 174 * @apilevel high-level 175 */ 176 @ASTNodeAnnotation.Child(name="LeftOperand") 177 public Expr getLeftOperand() { 178 return (Expr) getChild(0); 179 } 180 /** 181 * Retrieves the LeftOperand child. 182 * <p><em>This method does not invoke AST transformations.</em></p> 183 * @return The current node used as the LeftOperand child. 184 * @apilevel low-level 185 */ 186 public Expr getLeftOperandNoTransform() { 187 return (Expr) getChildNoTransform(0); 188 } 189 /** 190 * Replaces the RightOperand child. 191 * @param node The new node to replace the RightOperand child. 192 * @apilevel high-level 193 */ 194 public void setRightOperand(Expr node) { 195 setChild(node, 1); 196 } 197 /** 198 * Retrieves the RightOperand child. 199 * @return The current node used as the RightOperand child. 200 * @apilevel high-level 201 */ 202 @ASTNodeAnnotation.Child(name="RightOperand") 203 public Expr getRightOperand() { 204 return (Expr) getChild(1); 205 } 206 /** 207 * Retrieves the RightOperand child. 208 * <p><em>This method does not invoke AST transformations.</em></p> 209 * @return The current node used as the RightOperand child. 210 * @apilevel low-level 211 */ 212 public Expr getRightOperandNoTransform() { 213 return (Expr) getChildNoTransform(1); 214 } 215 /** 216 * @aspect ConstantExpression 217 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:298 218 */ 219 private TypeDecl refined_ConstantExpression_Binary_binaryNumericPromotedType() 220 { 221 TypeDecl leftType = left().type(); 222 TypeDecl rightType = right().type(); 223 if (leftType.isString()) { 224 return leftType; 225 } 226 if (rightType.isString()) { 227 return rightType; 228 } 229 if (leftType.isNumericType() && rightType.isNumericType()) { 230 return leftType.binaryNumericPromotion(rightType); 231 } 232 if (leftType.isBoolean() && rightType.isBoolean()) { 233 return leftType; 234 } 235 return unknownType(); 236 } 237 /** The operator string used for pretty printing this expression. 238 * @attribute syn 239 * @aspect PrettyPrintUtil 240 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:270 241 */ 242 @ASTNodeAnnotation.Attribute 243 public abstract String printOp(); 244 /** 245 * @apilevel internal 246 */ 247 protected int isConstant_visited = -1; 248 /** 249 * @apilevel internal 250 */ 251 private void isConstant_reset() { 252 isConstant_computed = false; 253 isConstant_initialized = false; 254 isConstant_visited = -1; 255 } 256 /** 257 * @apilevel internal 258 */ 259 protected boolean isConstant_computed = false; 260 /** 261 * @apilevel internal 262 */ 263 protected boolean isConstant_initialized = false; 264 /** 265 * @apilevel internal 266 */ 267 protected boolean isConstant_value; 268 @ASTNodeAnnotation.Attribute 269 public boolean isConstant() { 270 if (isConstant_computed) { 271 return isConstant_value; 272 } 273 ASTNode$State state = state(); 274 boolean new_isConstant_value; 275 if (!isConstant_initialized) { 276 isConstant_initialized = true; 277 isConstant_value = false; 278 } 279 if (!state.IN_CIRCLE) { 280 state.IN_CIRCLE = true; 281 int num = state.boundariesCrossed; 282 boolean isFinal = this.is$Final(); 283 do { 284 isConstant_visited = state.CIRCLE_INDEX; 285 state.CHANGE = false; 286 new_isConstant_value = getLeftOperand().isConstant() && getRightOperand().isConstant(); 287 if (new_isConstant_value != isConstant_value) { 288 state.CHANGE = true; 289 } 290 isConstant_value = new_isConstant_value; 291 state.CIRCLE_INDEX++; 292 } while (state.CHANGE); 293 if (isFinal && num == state().boundariesCrossed) { 294 isConstant_computed = true; 295 } else { 296 state.RESET_CYCLE = true; 297 boolean $tmp = getLeftOperand().isConstant() && getRightOperand().isConstant(); 298 state.RESET_CYCLE = false; 299 isConstant_computed = false; 300 isConstant_initialized = false; 301 } 302 state.IN_CIRCLE = false; 303 state.INTERMEDIATE_VALUE = false; 304 return isConstant_value; 305 } 306 if (isConstant_visited != state.CIRCLE_INDEX) { 307 isConstant_visited = state.CIRCLE_INDEX; 308 if (state.RESET_CYCLE) { 309 isConstant_computed = false; 310 isConstant_initialized = false; 311 isConstant_visited = -1; 312 return isConstant_value; 313 } 314 new_isConstant_value = getLeftOperand().isConstant() && getRightOperand().isConstant(); 315 if (new_isConstant_value != isConstant_value) { 316 state.CHANGE = true; 317 } 318 isConstant_value = new_isConstant_value; 319 state.INTERMEDIATE_VALUE = true; 320 return isConstant_value; 321 } 322 state.INTERMEDIATE_VALUE = true; 323 return isConstant_value; 324 } 325 /** 326 * @attribute syn 327 * @aspect ConstantExpression 328 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:296 329 */ 330 @ASTNodeAnnotation.Attribute 331 public Expr left() { 332 Expr left_value = getLeftOperand(); 333 334 return left_value; 335 } 336 /** 337 * @attribute syn 338 * @aspect ConstantExpression 339 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:297 340 */ 341 @ASTNodeAnnotation.Attribute 342 public Expr right() { 343 Expr right_value = getRightOperand(); 344 345 return right_value; 346 } 347 /** 348 * @attribute syn 349 * @aspect ConstantExpression 350 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:298 351 */ 352 @ASTNodeAnnotation.Attribute 353 public TypeDecl binaryNumericPromotedType() { 354 { 355 TypeDecl leftType = left().type(); 356 TypeDecl rightType = right().type(); 357 if (leftType.isBoolean() && rightType.isBoolean()) { 358 return leftType.isReferenceType() ? leftType.unboxed() : leftType; 359 } 360 return refined_ConstantExpression_Binary_binaryNumericPromotedType(); 361 } 362 } 363 /** 364 * @apilevel internal 365 */ 366 protected java.util.Map isDAafterTrue_Variable_values; 367 /** 368 * @apilevel internal 369 */ 370 private void isDAafterTrue_Variable_reset() { 371 isDAafterTrue_Variable_values = null; 372 } 373 /** 374 * @attribute syn 375 * @aspect DA 376 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:442 377 */ 378 @ASTNodeAnnotation.Attribute 379 public boolean isDAafterTrue(Variable v) { 380 Object _parameters = v; 381 if (isDAafterTrue_Variable_values == null) isDAafterTrue_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 382 ASTNode$State state = state(); 383 if (isDAafterTrue_Variable_values.containsKey(_parameters)) { 384 return (Boolean) isDAafterTrue_Variable_values.get(_parameters); 385 } 386 boolean intermediate = state.INTERMEDIATE_VALUE; 387 state.INTERMEDIATE_VALUE = false; 388 int num = state.boundariesCrossed; 389 boolean isFinal = this.is$Final(); 390 boolean isDAafterTrue_Variable_value = isFalse() || getRightOperand().isDAafter(v); 391 if (isFinal && num == state().boundariesCrossed) { 392 isDAafterTrue_Variable_values.put(_parameters, isDAafterTrue_Variable_value); 393 } else { 394 } 395 state.INTERMEDIATE_VALUE |= intermediate; 396 397 return isDAafterTrue_Variable_value; 398 } 399 /** 400 * @apilevel internal 401 */ 402 protected java.util.Map isDAafterFalse_Variable_values; 403 /** 404 * @apilevel internal 405 */ 406 private void isDAafterFalse_Variable_reset() { 407 isDAafterFalse_Variable_values = null; 408 } 409 /** 410 * @attribute syn 411 * @aspect DA 412 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:443 413 */ 414 @ASTNodeAnnotation.Attribute 415 public boolean isDAafterFalse(Variable v) { 416 Object _parameters = v; 417 if (isDAafterFalse_Variable_values == null) isDAafterFalse_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 418 ASTNode$State state = state(); 419 if (isDAafterFalse_Variable_values.containsKey(_parameters)) { 420 return (Boolean) isDAafterFalse_Variable_values.get(_parameters); 421 } 422 boolean intermediate = state.INTERMEDIATE_VALUE; 423 state.INTERMEDIATE_VALUE = false; 424 int num = state.boundariesCrossed; 425 boolean isFinal = this.is$Final(); 426 boolean isDAafterFalse_Variable_value = isTrue() || getRightOperand().isDAafter(v); 427 if (isFinal && num == state().boundariesCrossed) { 428 isDAafterFalse_Variable_values.put(_parameters, isDAafterFalse_Variable_value); 429 } else { 430 } 431 state.INTERMEDIATE_VALUE |= intermediate; 432 433 return isDAafterFalse_Variable_value; 434 } 435 /** 436 * @apilevel internal 437 */ 438 protected java.util.Map isDAafter_Variable_values; 439 /** 440 * @apilevel internal 441 */ 442 private void isDAafter_Variable_reset() { 443 isDAafter_Variable_values = null; 444 } 445 /** 446 * @attribute syn 447 * @aspect DA 448 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:261 449 */ 450 @ASTNodeAnnotation.Attribute 451 public boolean isDAafter(Variable v) { 452 Object _parameters = v; 453 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 454 ASTNode$State state = state(); 455 if (isDAafter_Variable_values.containsKey(_parameters)) { 456 return (Boolean) isDAafter_Variable_values.get(_parameters); 457 } 458 boolean intermediate = state.INTERMEDIATE_VALUE; 459 state.INTERMEDIATE_VALUE = false; 460 int num = state.boundariesCrossed; 461 boolean isFinal = this.is$Final(); 462 boolean isDAafter_Variable_value = getRightOperand().isDAafter(v); 463 if (isFinal && num == state().boundariesCrossed) { 464 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 465 } else { 466 } 467 state.INTERMEDIATE_VALUE |= intermediate; 468 469 return isDAafter_Variable_value; 470 } 471 /** 472 * @apilevel internal 473 */ 474 protected java.util.Map isDUafter_Variable_values; 475 /** 476 * @apilevel internal 477 */ 478 private void isDUafter_Variable_reset() { 479 isDUafter_Variable_values = null; 480 } 481 /** 482 * @attribute syn 483 * @aspect DU 484 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:788 485 */ 486 @ASTNodeAnnotation.Attribute 487 public boolean isDUafter(Variable v) { 488 Object _parameters = v; 489 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 490 ASTNode$State state = state(); 491 if (isDUafter_Variable_values.containsKey(_parameters)) { 492 return (Boolean) isDUafter_Variable_values.get(_parameters); 493 } 494 boolean intermediate = state.INTERMEDIATE_VALUE; 495 state.INTERMEDIATE_VALUE = false; 496 int num = state.boundariesCrossed; 497 boolean isFinal = this.is$Final(); 498 boolean isDUafter_Variable_value = getRightOperand().isDUafter(v); 499 if (isFinal && num == state().boundariesCrossed) { 500 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 501 } else { 502 } 503 state.INTERMEDIATE_VALUE |= intermediate; 504 505 return isDUafter_Variable_value; 506 } 507 /** 508 * @attribute syn 509 * @aspect PreciseRethrow 510 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 511 */ 512 @ASTNodeAnnotation.Attribute 513 public boolean modifiedInScope(Variable var) { 514 boolean modifiedInScope_Variable_value = getLeftOperand().modifiedInScope(var) || getRightOperand().modifiedInScope(var); 515 516 return modifiedInScope_Variable_value; 517 } 518 /** 519 * @attribute inh 520 * @aspect DU 521 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:785 522 */ 523 /** 524 * @attribute inh 525 * @aspect DU 526 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:785 527 */ 528 @ASTNodeAnnotation.Attribute 529 public boolean isDUbefore(Variable v) { 530 Object _parameters = v; 531 if (isDUbefore_Variable_values == null) isDUbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 532 ASTNode$State state = state(); 533 if (isDUbefore_Variable_values.containsKey(_parameters)) { 534 return (Boolean) isDUbefore_Variable_values.get(_parameters); 535 } 536 boolean intermediate = state.INTERMEDIATE_VALUE; 537 state.INTERMEDIATE_VALUE = false; 538 int num = state.boundariesCrossed; 539 boolean isFinal = this.is$Final(); 540 boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v); 541 if (isFinal && num == state().boundariesCrossed) { 542 isDUbefore_Variable_values.put(_parameters, isDUbefore_Variable_value); 543 } else { 544 } 545 state.INTERMEDIATE_VALUE |= intermediate; 546 547 return isDUbefore_Variable_value; 548 } 549 /** 550 * @apilevel internal 551 */ 552 protected java.util.Map isDUbefore_Variable_values; 553 /** 554 * @apilevel internal 555 */ 556 private void isDUbefore_Variable_reset() { 557 isDUbefore_Variable_values = null; 558 } 559 /** 560 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 561 * @apilevel internal 562 */ 563 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 564 if (caller == getRightOperandNoTransform()) { 565 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:446 566 return getLeftOperand().isDAafter(v); 567 } 568 else { 569 return getParent().Define_isDAbefore(this, caller, v); 570 } 571 } 572 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 573 return true; 574 } 575 /** 576 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 577 * @apilevel internal 578 */ 579 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 580 if (caller == getRightOperandNoTransform()) { 581 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:951 582 return getLeftOperand().isDUafter(v); 583 } 584 else { 585 return getParent().Define_isDUbefore(this, caller, v); 586 } 587 } 588 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 589 return true; 590 } 591 /** 592 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 593 * @apilevel internal 594 */ 595 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 596 int childIndex = this.getIndexOfChild(caller); 597 return false; 598 } 599 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 600 return true; 601 } 602 /** 603 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 604 * @apilevel internal 605 */ 606 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 607 int childIndex = this.getIndexOfChild(caller); 608 return false; 609 } 610 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 611 return true; 612 } 613 /** 614 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 615 * @apilevel internal 616 */ 617 public boolean Define_castContext(ASTNode caller, ASTNode child) { 618 int childIndex = this.getIndexOfChild(caller); 619 return false; 620 } 621 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 622 return true; 623 } 624 /** 625 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 626 * @apilevel internal 627 */ 628 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 629 int childIndex = this.getIndexOfChild(caller); 630 return false; 631 } 632 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 633 return true; 634 } 635 /** 636 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 637 * @apilevel internal 638 */ 639 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 640 int childIndex = this.getIndexOfChild(caller); 641 return false; 642 } 643 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 644 return true; 645 } 646 /** 647 * @apilevel internal 648 */ 649 public ASTNode rewriteTo() { 650 return super.rewriteTo(); 651 } 652 }