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:192 027 * @production BranchTargetStmt : {@link Stmt}; 028 029 */ 030 public abstract class BranchTargetStmt extends Stmt implements Cloneable { 031 /** 032 * @aspect BranchTarget 033 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:108 034 */ 035 public void collectBranches(Collection<Stmt> c) { 036 c.addAll(escapedBranches()); 037 } 038 /** 039 * @declaredat ASTNode:1 040 */ 041 public BranchTargetStmt() { 042 super(); 043 } 044 /** 045 * Initializes the child array to the correct size. 046 * Initializes List and Opt nta children. 047 * @apilevel internal 048 * @ast method 049 * @declaredat ASTNode:10 050 */ 051 public void init$Children() { 052 } 053 /** 054 * @apilevel low-level 055 * @declaredat ASTNode:15 056 */ 057 protected int numChildren() { 058 return 0; 059 } 060 /** 061 * @apilevel internal 062 * @declaredat ASTNode:21 063 */ 064 public boolean mayHaveRewrite() { 065 return false; 066 } 067 /** 068 * @apilevel internal 069 * @declaredat ASTNode:27 070 */ 071 public void flushAttrCache() { 072 super.flushAttrCache(); 073 targetBranches_reset(); 074 escapedBranches_reset(); 075 branches_reset(); 076 targetContinues_reset(); 077 targetBreaks_reset(); 078 reachableBreak_reset(); 079 reachableContinue_reset(); 080 } 081 /** 082 * @apilevel internal 083 * @declaredat ASTNode:40 084 */ 085 public void flushCollectionCache() { 086 super.flushCollectionCache(); 087 } 088 /** 089 * @apilevel internal 090 * @declaredat ASTNode:46 091 */ 092 public void flushRewriteCache() { 093 super.flushRewriteCache(); 094 } 095 /** 096 * @apilevel internal 097 * @declaredat ASTNode:52 098 */ 099 public BranchTargetStmt clone() throws CloneNotSupportedException { 100 BranchTargetStmt node = (BranchTargetStmt) super.clone(); 101 return node; 102 } 103 /** 104 * Create a deep copy of the AST subtree at this node. 105 * The copy is dangling, i.e. has no parent. 106 * @return dangling copy of the subtree at this node 107 * @apilevel low-level 108 * @deprecated Please use treeCopy or treeCopyNoTransform instead 109 * @declaredat ASTNode:63 110 */ 111 @Deprecated 112 public abstract BranchTargetStmt fullCopy(); 113 /** 114 * Create a deep copy of the AST subtree at this node. 115 * The copy is dangling, i.e. has no parent. 116 * @return dangling copy of the subtree at this node 117 * @apilevel low-level 118 * @declaredat ASTNode:71 119 */ 120 public abstract BranchTargetStmt treeCopyNoTransform(); 121 /** 122 * Create a deep copy of the AST subtree at this node. 123 * The subtree of this node is traversed to trigger rewrites before copy. 124 * The copy is dangling, i.e. has no parent. 125 * @return dangling copy of the subtree at this node 126 * @apilevel low-level 127 * @declaredat ASTNode:79 128 */ 129 public abstract BranchTargetStmt treeCopy(); 130 /** 131 * @apilevel internal 132 */ 133 protected boolean targetBranches_computed = false; 134 /** 135 * @apilevel internal 136 */ 137 protected Collection<Stmt> targetBranches_value; 138 /** 139 * @apilevel internal 140 */ 141 private void targetBranches_reset() { 142 targetBranches_computed = false; 143 targetBranches_value = null; 144 } 145 /** 146 * @attribute syn 147 * @aspect BranchTarget 148 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:86 149 */ 150 @ASTNodeAnnotation.Attribute 151 public Collection<Stmt> targetBranches() { 152 ASTNode$State state = state(); 153 if (targetBranches_computed) { 154 return targetBranches_value; 155 } 156 boolean intermediate = state.INTERMEDIATE_VALUE; 157 state.INTERMEDIATE_VALUE = false; 158 int num = state.boundariesCrossed; 159 boolean isFinal = this.is$Final(); 160 targetBranches_value = targetBranches_compute(); 161 if (isFinal && num == state().boundariesCrossed) { 162 targetBranches_computed = true; 163 } else { 164 } 165 state.INTERMEDIATE_VALUE |= intermediate; 166 167 return targetBranches_value; 168 } 169 /** 170 * @apilevel internal 171 */ 172 private Collection<Stmt> targetBranches_compute() { 173 Collection<Stmt> set = new HashSet<Stmt>(); 174 for (Stmt branch : branches()) { 175 if (potentialTargetOf(branch)) { 176 set.add(branch); 177 } 178 } 179 return set; 180 } 181 /** 182 * @apilevel internal 183 */ 184 protected boolean escapedBranches_computed = false; 185 /** 186 * @apilevel internal 187 */ 188 protected Collection<Stmt> escapedBranches_value; 189 /** 190 * @apilevel internal 191 */ 192 private void escapedBranches_reset() { 193 escapedBranches_computed = false; 194 escapedBranches_value = null; 195 } 196 /** 197 * @attribute syn 198 * @aspect BranchTarget 199 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:87 200 */ 201 @ASTNodeAnnotation.Attribute 202 public Collection<Stmt> escapedBranches() { 203 ASTNode$State state = state(); 204 if (escapedBranches_computed) { 205 return escapedBranches_value; 206 } 207 boolean intermediate = state.INTERMEDIATE_VALUE; 208 state.INTERMEDIATE_VALUE = false; 209 int num = state.boundariesCrossed; 210 boolean isFinal = this.is$Final(); 211 escapedBranches_value = escapedBranches_compute(); 212 if (isFinal && num == state().boundariesCrossed) { 213 escapedBranches_computed = true; 214 } else { 215 } 216 state.INTERMEDIATE_VALUE |= intermediate; 217 218 return escapedBranches_value; 219 } 220 /** 221 * @apilevel internal 222 */ 223 private Collection<Stmt> escapedBranches_compute() { 224 Collection<Stmt> set = new HashSet<Stmt>(); 225 for (Stmt branch : branches()) { 226 if (!potentialTargetOf(branch)) { 227 set.add(branch); 228 } else if (branch instanceof ReturnStmt) { 229 set.add(branch); 230 } 231 } 232 return set; 233 } 234 /** 235 * @apilevel internal 236 */ 237 protected boolean branches_computed = false; 238 /** 239 * @apilevel internal 240 */ 241 protected Collection<Stmt> branches_value; 242 /** 243 * @apilevel internal 244 */ 245 private void branches_reset() { 246 branches_computed = false; 247 branches_value = null; 248 } 249 /** 250 * @attribute syn 251 * @aspect BranchTarget 252 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:88 253 */ 254 @ASTNodeAnnotation.Attribute 255 public Collection<Stmt> branches() { 256 ASTNode$State state = state(); 257 if (branches_computed) { 258 return branches_value; 259 } 260 boolean intermediate = state.INTERMEDIATE_VALUE; 261 state.INTERMEDIATE_VALUE = false; 262 int num = state.boundariesCrossed; 263 boolean isFinal = this.is$Final(); 264 branches_value = branches_compute(); 265 if (isFinal && num == state().boundariesCrossed) { 266 branches_computed = true; 267 } else { 268 } 269 state.INTERMEDIATE_VALUE |= intermediate; 270 271 return branches_value; 272 } 273 /** 274 * @apilevel internal 275 */ 276 private Collection<Stmt> branches_compute() { 277 Collection<Stmt> set = new HashSet<Stmt>(); 278 super.collectBranches(set); 279 return set; 280 } 281 /** 282 * @return <code>true</code> if this statement is a potential 283 * branch target of the given branch statement. 284 * @attribute syn 285 * @aspect BranchTarget 286 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:217 287 */ 288 @ASTNodeAnnotation.Attribute 289 public boolean potentialTargetOf(Stmt branch) { 290 boolean potentialTargetOf_Stmt_value = false; 291 292 return potentialTargetOf_Stmt_value; 293 } 294 /** 295 * @apilevel internal 296 */ 297 protected boolean targetContinues_computed = false; 298 /** 299 * @apilevel internal 300 */ 301 protected Collection<Stmt> targetContinues_value; 302 /** 303 * @apilevel internal 304 */ 305 private void targetContinues_reset() { 306 targetContinues_computed = false; 307 targetContinues_value = null; 308 } 309 /** 310 * @attribute syn 311 * @aspect BranchTarget 312 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:84 313 */ 314 @ASTNodeAnnotation.Attribute 315 public Collection<Stmt> targetContinues() { 316 ASTNode$State state = state(); 317 if (targetContinues_computed) { 318 return targetContinues_value; 319 } 320 boolean intermediate = state.INTERMEDIATE_VALUE; 321 state.INTERMEDIATE_VALUE = false; 322 int num = state.boundariesCrossed; 323 boolean isFinal = this.is$Final(); 324 targetContinues_value = targetContinues_compute(); 325 if (isFinal && num == state().boundariesCrossed) { 326 targetContinues_computed = true; 327 } else { 328 } 329 state.INTERMEDIATE_VALUE |= intermediate; 330 331 return targetContinues_value; 332 } 333 /** 334 * @apilevel internal 335 */ 336 private Collection<Stmt> targetContinues_compute() { 337 HashSet<Stmt> set = new HashSet<Stmt>(); 338 for (Stmt branch : targetBranches()) { 339 if (branch instanceof ContinueStmt) { 340 set.add(branch); 341 } 342 } 343 if (getParent() instanceof LabeledStmt) { 344 for (Stmt branch : ((LabeledStmt) getParent()).targetBranches()) { 345 if (branch instanceof ContinueStmt) { 346 set.add(branch); 347 } 348 } 349 } 350 return set; 351 } 352 /** 353 * @apilevel internal 354 */ 355 protected boolean targetBreaks_computed = false; 356 /** 357 * @apilevel internal 358 */ 359 protected Collection<Stmt> targetBreaks_value; 360 /** 361 * @apilevel internal 362 */ 363 private void targetBreaks_reset() { 364 targetBreaks_computed = false; 365 targetBreaks_value = null; 366 } 367 /** 368 * @attribute syn 369 * @aspect BranchTarget 370 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:85 371 */ 372 @ASTNodeAnnotation.Attribute 373 public Collection<Stmt> targetBreaks() { 374 ASTNode$State state = state(); 375 if (targetBreaks_computed) { 376 return targetBreaks_value; 377 } 378 boolean intermediate = state.INTERMEDIATE_VALUE; 379 state.INTERMEDIATE_VALUE = false; 380 int num = state.boundariesCrossed; 381 boolean isFinal = this.is$Final(); 382 targetBreaks_value = targetBreaks_compute(); 383 if (isFinal && num == state().boundariesCrossed) { 384 targetBreaks_computed = true; 385 } else { 386 } 387 state.INTERMEDIATE_VALUE |= intermediate; 388 389 return targetBreaks_value; 390 } 391 /** 392 * @apilevel internal 393 */ 394 private Collection<Stmt> targetBreaks_compute() { 395 HashSet<Stmt> set = new HashSet<Stmt>(); 396 for (Stmt branch : targetBranches()) { 397 if (branch instanceof BreakStmt) { 398 set.add(branch); 399 } 400 } 401 return set; 402 } 403 /** 404 * @apilevel internal 405 */ 406 protected boolean reachableBreak_computed = false; 407 /** 408 * @apilevel internal 409 */ 410 protected boolean reachableBreak_value; 411 /** 412 * @apilevel internal 413 */ 414 private void reachableBreak_reset() { 415 reachableBreak_computed = false; 416 } 417 /** 418 * @attribute syn 419 * @aspect UnreachableStatements 420 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:86 421 */ 422 @ASTNodeAnnotation.Attribute 423 public boolean reachableBreak() { 424 ASTNode$State state = state(); 425 if (reachableBreak_computed) { 426 return reachableBreak_value; 427 } 428 boolean intermediate = state.INTERMEDIATE_VALUE; 429 state.INTERMEDIATE_VALUE = false; 430 int num = state.boundariesCrossed; 431 boolean isFinal = this.is$Final(); 432 reachableBreak_value = reachableBreak_compute(); 433 if (isFinal && num == state().boundariesCrossed) { 434 reachableBreak_computed = true; 435 } else { 436 } 437 state.INTERMEDIATE_VALUE |= intermediate; 438 439 return reachableBreak_value; 440 } 441 /** 442 * @apilevel internal 443 */ 444 private boolean reachableBreak_compute() { 445 for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) { 446 BreakStmt stmt = (BreakStmt) iter.next(); 447 if (stmt.reachable()) { 448 return true; 449 } 450 } 451 return false; 452 } 453 /** 454 * @apilevel internal 455 */ 456 protected boolean reachableContinue_computed = false; 457 /** 458 * @apilevel internal 459 */ 460 protected boolean reachableContinue_value; 461 /** 462 * @apilevel internal 463 */ 464 private void reachableContinue_reset() { 465 reachableContinue_computed = false; 466 } 467 /** 468 * @attribute syn 469 * @aspect UnreachableStatements 470 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:142 471 */ 472 @ASTNodeAnnotation.Attribute 473 public boolean reachableContinue() { 474 ASTNode$State state = state(); 475 if (reachableContinue_computed) { 476 return reachableContinue_value; 477 } 478 boolean intermediate = state.INTERMEDIATE_VALUE; 479 state.INTERMEDIATE_VALUE = false; 480 int num = state.boundariesCrossed; 481 boolean isFinal = this.is$Final(); 482 reachableContinue_value = reachableContinue_compute(); 483 if (isFinal && num == state().boundariesCrossed) { 484 reachableContinue_computed = true; 485 } else { 486 } 487 state.INTERMEDIATE_VALUE |= intermediate; 488 489 return reachableContinue_value; 490 } 491 /** 492 * @apilevel internal 493 */ 494 private boolean reachableContinue_compute() { 495 for (Iterator iter = targetContinues().iterator(); iter.hasNext(); ) { 496 Stmt stmt = (Stmt) iter.next(); 497 if (stmt.reachable()) { 498 return true; 499 } 500 } 501 return false; 502 } 503 /** 504 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262 505 * @apilevel internal 506 */ 507 public FinallyHost Define_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 508 int childIndex = this.getIndexOfChild(caller); 509 return potentialTargetOf(branch) ? null : enclosingFinally(branch); 510 } 511 protected boolean canDefine_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 512 return true; 513 } 514 /** 515 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836 516 * @apilevel internal 517 */ 518 public boolean Define_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 519 int childIndex = this.getIndexOfChild(caller); 520 { 521 if (potentialTargetOf(branch)) { 522 return false; 523 } else { 524 return leavesMonitor(branch, monitor); 525 } 526 } 527 } 528 protected boolean canDefine_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 529 return true; 530 } 531 /** 532 * @apilevel internal 533 */ 534 public ASTNode rewriteTo() { 535 return super.rewriteTo(); 536 } 537 }