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:70 027 * @production InstanceInitializer : {@link BodyDecl} ::= <span class="component">{@link Block}</span>; 028 029 */ 030 public class InstanceInitializer extends BodyDecl implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:264 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 if (!blockIsEmpty()) { 037 out.print(getBlock()); 038 } 039 } 040 /** 041 * @aspect UnreachableStatements 042 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:45 043 */ 044 void checkUnreachableStmt() { 045 if (!getBlock().canCompleteNormally()) { 046 errorf("instance initializer in %s can not complete normally", hostType().fullName()); 047 } 048 } 049 /** 050 * @declaredat ASTNode:1 051 */ 052 public InstanceInitializer() { 053 super(); 054 } 055 /** 056 * Initializes the child array to the correct size. 057 * Initializes List and Opt nta children. 058 * @apilevel internal 059 * @ast method 060 * @declaredat ASTNode:10 061 */ 062 public void init$Children() { 063 children = new ASTNode[1]; 064 } 065 /** 066 * @declaredat ASTNode:13 067 */ 068 public InstanceInitializer(Block p0) { 069 setChild(p0, 0); 070 } 071 /** 072 * @apilevel low-level 073 * @declaredat ASTNode:19 074 */ 075 protected int numChildren() { 076 return 1; 077 } 078 /** 079 * @apilevel internal 080 * @declaredat ASTNode:25 081 */ 082 public boolean mayHaveRewrite() { 083 return false; 084 } 085 /** 086 * @apilevel internal 087 * @declaredat ASTNode:31 088 */ 089 public void flushAttrCache() { 090 super.flushAttrCache(); 091 exceptions_reset(); 092 isDAafter_Variable_reset(); 093 isDUafter_Variable_reset(); 094 handlesException_TypeDecl_reset(); 095 } 096 /** 097 * @apilevel internal 098 * @declaredat ASTNode:41 099 */ 100 public void flushCollectionCache() { 101 super.flushCollectionCache(); 102 } 103 /** 104 * @apilevel internal 105 * @declaredat ASTNode:47 106 */ 107 public void flushRewriteCache() { 108 super.flushRewriteCache(); 109 } 110 /** 111 * @apilevel internal 112 * @declaredat ASTNode:53 113 */ 114 public InstanceInitializer clone() throws CloneNotSupportedException { 115 InstanceInitializer node = (InstanceInitializer) super.clone(); 116 return node; 117 } 118 /** 119 * @apilevel internal 120 * @declaredat ASTNode:60 121 */ 122 public InstanceInitializer copy() { 123 try { 124 InstanceInitializer node = (InstanceInitializer) 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:79 141 */ 142 @Deprecated 143 public InstanceInitializer 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:89 152 */ 153 public InstanceInitializer treeCopyNoTransform() { 154 InstanceInitializer tree = (InstanceInitializer) 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:109 173 */ 174 public InstanceInitializer treeCopy() { 175 doFullTraversal(); 176 return treeCopyNoTransform(); 177 } 178 /** 179 * @apilevel internal 180 * @declaredat ASTNode:116 181 */ 182 protected boolean is$Equal(ASTNode node) { 183 return super.is$Equal(node); 184 } 185 /** 186 * Replaces the Block child. 187 * @param node The new node to replace the Block child. 188 * @apilevel high-level 189 */ 190 public void setBlock(Block node) { 191 setChild(node, 0); 192 } 193 /** 194 * Retrieves the Block child. 195 * @return The current node used as the Block child. 196 * @apilevel high-level 197 */ 198 @ASTNodeAnnotation.Child(name="Block") 199 public Block getBlock() { 200 return (Block) getChild(0); 201 } 202 /** 203 * Retrieves the Block child. 204 * <p><em>This method does not invoke AST transformations.</em></p> 205 * @return The current node used as the Block child. 206 * @apilevel low-level 207 */ 208 public Block getBlockNoTransform() { 209 return (Block) getChildNoTransform(0); 210 } 211 /** 212 * @apilevel internal 213 */ 214 protected boolean exceptions_computed = false; 215 /** 216 * @apilevel internal 217 */ 218 protected Collection exceptions_value; 219 /** 220 * @apilevel internal 221 */ 222 private void exceptions_reset() { 223 exceptions_computed = false; 224 exceptions_value = null; 225 } 226 /** 227 * @attribute syn 228 * @aspect AnonymousClasses 229 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:111 230 */ 231 @ASTNodeAnnotation.Attribute 232 public Collection exceptions() { 233 ASTNode$State state = state(); 234 if (exceptions_computed) { 235 return exceptions_value; 236 } 237 boolean intermediate = state.INTERMEDIATE_VALUE; 238 state.INTERMEDIATE_VALUE = false; 239 int num = state.boundariesCrossed; 240 boolean isFinal = this.is$Final(); 241 exceptions_value = exceptions_compute(); 242 if (isFinal && num == state().boundariesCrossed) { 243 exceptions_computed = true; 244 } else { 245 } 246 state.INTERMEDIATE_VALUE |= intermediate; 247 248 return exceptions_value; 249 } 250 /** 251 * @apilevel internal 252 */ 253 private Collection exceptions_compute() { 254 HashSet set = new HashSet(); 255 collectExceptions(set, this); 256 for (Iterator iter = set.iterator(); iter.hasNext(); ) { 257 TypeDecl typeDecl = (TypeDecl) iter.next(); 258 if (!getBlock().reachedException(typeDecl)) { 259 iter.remove(); 260 } 261 } 262 return set; 263 } 264 /** 265 * @apilevel internal 266 */ 267 protected java.util.Map isDAafter_Variable_values; 268 /** 269 * @apilevel internal 270 */ 271 private void isDAafter_Variable_reset() { 272 isDAafter_Variable_values = null; 273 } 274 /** 275 * @attribute syn 276 * @aspect DA 277 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:266 278 */ 279 @ASTNodeAnnotation.Attribute 280 public boolean isDAafter(Variable v) { 281 Object _parameters = v; 282 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 283 ASTNode$State state = state(); 284 if (isDAafter_Variable_values.containsKey(_parameters)) { 285 return (Boolean) isDAafter_Variable_values.get(_parameters); 286 } 287 boolean intermediate = state.INTERMEDIATE_VALUE; 288 state.INTERMEDIATE_VALUE = false; 289 int num = state.boundariesCrossed; 290 boolean isFinal = this.is$Final(); 291 boolean isDAafter_Variable_value = getBlock().isDAafter(v); 292 if (isFinal && num == state().boundariesCrossed) { 293 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 294 } else { 295 } 296 state.INTERMEDIATE_VALUE |= intermediate; 297 298 return isDAafter_Variable_value; 299 } 300 /** 301 * @apilevel internal 302 */ 303 protected java.util.Map isDUafter_Variable_values; 304 /** 305 * @apilevel internal 306 */ 307 private void isDUafter_Variable_reset() { 308 isDUafter_Variable_values = null; 309 } 310 /** 311 * @attribute syn 312 * @aspect DU 313 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:796 314 */ 315 @ASTNodeAnnotation.Attribute 316 public boolean isDUafter(Variable v) { 317 Object _parameters = v; 318 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 319 ASTNode$State state = state(); 320 if (isDUafter_Variable_values.containsKey(_parameters)) { 321 return (Boolean) isDUafter_Variable_values.get(_parameters); 322 } 323 boolean intermediate = state.INTERMEDIATE_VALUE; 324 state.INTERMEDIATE_VALUE = false; 325 int num = state.boundariesCrossed; 326 boolean isFinal = this.is$Final(); 327 boolean isDUafter_Variable_value = getBlock().isDUafter(v); 328 if (isFinal && num == state().boundariesCrossed) { 329 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 330 } else { 331 } 332 state.INTERMEDIATE_VALUE |= intermediate; 333 334 return isDUafter_Variable_value; 335 } 336 /** 337 * @attribute syn 338 * @aspect PrettyPrintUtil 339 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:215 340 */ 341 @ASTNodeAnnotation.Attribute 342 public boolean blockIsEmpty() { 343 boolean blockIsEmpty_value = getBlock().getNumStmt() == 0; 344 345 return blockIsEmpty_value; 346 } 347 /** 348 * @attribute syn 349 * @aspect PreciseRethrow 350 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:40 351 */ 352 @ASTNodeAnnotation.Attribute 353 public boolean modifiedInScope(Variable var) { 354 boolean modifiedInScope_Variable_value = getBlock().modifiedInScope(var); 355 356 return modifiedInScope_Variable_value; 357 } 358 /** 359 * @attribute inh 360 * @aspect ExceptionHandling 361 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:79 362 */ 363 /** 364 * @attribute inh 365 * @aspect ExceptionHandling 366 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:79 367 */ 368 @ASTNodeAnnotation.Attribute 369 public boolean handlesException(TypeDecl exceptionType) { 370 Object _parameters = exceptionType; 371 if (handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 372 ASTNode$State state = state(); 373 if (handlesException_TypeDecl_values.containsKey(_parameters)) { 374 return (Boolean) handlesException_TypeDecl_values.get(_parameters); 375 } 376 boolean intermediate = state.INTERMEDIATE_VALUE; 377 state.INTERMEDIATE_VALUE = false; 378 int num = state.boundariesCrossed; 379 boolean isFinal = this.is$Final(); 380 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 381 if (isFinal && num == state().boundariesCrossed) { 382 handlesException_TypeDecl_values.put(_parameters, handlesException_TypeDecl_value); 383 } else { 384 } 385 state.INTERMEDIATE_VALUE |= intermediate; 386 387 return handlesException_TypeDecl_value; 388 } 389 /** 390 * @apilevel internal 391 */ 392 protected java.util.Map handlesException_TypeDecl_values; 393 /** 394 * @apilevel internal 395 */ 396 private void handlesException_TypeDecl_reset() { 397 handlesException_TypeDecl_values = null; 398 } 399 /** 400 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 401 * @apilevel internal 402 */ 403 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 404 if (caller == getBlockNoTransform()) { 405 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:480 406 return isDAbefore(v); 407 } 408 else { 409 return super.Define_isDAbefore(caller, child, v); 410 } 411 } 412 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 413 return true; 414 } 415 /** 416 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113 417 * @apilevel internal 418 */ 419 public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 420 if (caller == getBlockNoTransform()) { 421 // @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:223 422 { 423 if (hostType().isAnonymous()) { 424 return true; 425 } 426 for (Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) { 427 ConstructorDecl decl = (ConstructorDecl) iter.next(); 428 if (!decl.throwsException(exceptionType)) { 429 return false; 430 } 431 } 432 return true; 433 } 434 } 435 else { 436 return getParent().Define_handlesException(this, caller, exceptionType); 437 } 438 } 439 protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 440 return true; 441 } 442 /** 443 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310 444 * @apilevel internal 445 */ 446 public ASTNode Define_enclosingBlock(ASTNode caller, ASTNode child) { 447 if (caller == getBlockNoTransform()) { 448 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:313 449 return this; 450 } 451 else { 452 return getParent().Define_enclosingBlock(this, caller); 453 } 454 } 455 protected boolean canDefine_enclosingBlock(ASTNode caller, ASTNode child) { 456 return true; 457 } 458 /** 459 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182 460 * @apilevel internal 461 */ 462 public boolean Define_inStaticContext(ASTNode caller, ASTNode child) { 463 if (caller == getBlockNoTransform()) { 464 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:188 465 return false; 466 } 467 else { 468 return getParent().Define_inStaticContext(this, caller); 469 } 470 } 471 protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) { 472 return true; 473 } 474 /** 475 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 476 * @apilevel internal 477 */ 478 public boolean Define_reachable(ASTNode caller, ASTNode child) { 479 if (caller == getBlockNoTransform()) { 480 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:66 481 return true; 482 } 483 else { 484 return getParent().Define_reachable(this, caller); 485 } 486 } 487 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 488 return true; 489 } 490 /** 491 * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64 492 * @apilevel internal 493 */ 494 public int Define_localNum(ASTNode caller, ASTNode child) { 495 if (caller == getBlockNoTransform()) { 496 // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:89 497 { 498 int localNum = 1; 499 for (Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) { 500 ConstructorDecl c = (ConstructorDecl)iter.next(); 501 int num = c.offsetAfterParameters(); 502 if (num > localNum) { 503 localNum = num; 504 } 505 } 506 return localNum; 507 } 508 } 509 else { 510 return getParent().Define_localNum(this, caller); 511 } 512 } 513 protected boolean canDefine_localNum(ASTNode caller, ASTNode child) { 514 return true; 515 } 516 /** 517 * @apilevel internal 518 */ 519 public ASTNode rewriteTo() { 520 return super.rewriteTo(); 521 } 522 }