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:199 027 * @production Case : {@link Stmt}; 028 029 */ 030 public abstract class Case extends Stmt implements Cloneable { 031 /** 032 * @aspect CreateBCode 033 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1532 034 */ 035 public void createBCode(CodeGeneration gen) { 036 gen.addLabel(label()); 037 } 038 /** 039 * @declaredat ASTNode:1 040 */ 041 public Case() { 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 isDAbefore_Variable_reset(); 074 isDAafter_Variable_reset(); 075 isDUafter_Variable_reset(); 076 label_reset(); 077 bind_Case_reset(); 078 } 079 /** 080 * @apilevel internal 081 * @declaredat ASTNode:38 082 */ 083 public void flushCollectionCache() { 084 super.flushCollectionCache(); 085 } 086 /** 087 * @apilevel internal 088 * @declaredat ASTNode:44 089 */ 090 public void flushRewriteCache() { 091 super.flushRewriteCache(); 092 } 093 /** 094 * @apilevel internal 095 * @declaredat ASTNode:50 096 */ 097 public Case clone() throws CloneNotSupportedException { 098 Case node = (Case) super.clone(); 099 return node; 100 } 101 /** 102 * Create a deep copy of the AST subtree at this node. 103 * The copy is dangling, i.e. has no parent. 104 * @return dangling copy of the subtree at this node 105 * @apilevel low-level 106 * @deprecated Please use treeCopy or treeCopyNoTransform instead 107 * @declaredat ASTNode:61 108 */ 109 @Deprecated 110 public abstract Case fullCopy(); 111 /** 112 * Create a deep copy of the AST subtree at this node. 113 * The copy is dangling, i.e. has no parent. 114 * @return dangling copy of the subtree at this node 115 * @apilevel low-level 116 * @declaredat ASTNode:69 117 */ 118 public abstract Case treeCopyNoTransform(); 119 /** 120 * Create a deep copy of the AST subtree at this node. 121 * The subtree of this node is traversed to trigger rewrites before copy. 122 * The copy is dangling, i.e. has no parent. 123 * @return dangling copy of the subtree at this node 124 * @apilevel low-level 125 * @declaredat ASTNode:77 126 */ 127 public abstract Case treeCopy(); 128 /** 129 * @attribute syn 130 * @aspect NameCheck 131 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:512 132 */ 133 @ASTNodeAnnotation.Attribute 134 public abstract boolean constValue(Case c); 135 /** 136 * @apilevel internal 137 */ 138 protected java.util.Map isDAbefore_Variable_values; 139 /** 140 * @apilevel internal 141 */ 142 private void isDAbefore_Variable_reset() { 143 isDAbefore_Variable_values = null; 144 } 145 /** 146 * @attribute syn 147 * @aspect DA 148 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:639 149 */ 150 @ASTNodeAnnotation.Attribute 151 public boolean isDAbefore(Variable v) { 152 Object _parameters = v; 153 if (isDAbefore_Variable_values == null) isDAbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 154 ASTNode$State state = state(); 155 if (isDAbefore_Variable_values.containsKey(_parameters)) { 156 return (Boolean) isDAbefore_Variable_values.get(_parameters); 157 } 158 boolean intermediate = state.INTERMEDIATE_VALUE; 159 state.INTERMEDIATE_VALUE = false; 160 int num = state.boundariesCrossed; 161 boolean isFinal = this.is$Final(); 162 boolean isDAbefore_Variable_value = getParent().getParent() instanceof Block 163 && ((Block) getParent().getParent()).isDAbefore(v) 164 && super.isDAbefore(v); 165 if (isFinal && num == state().boundariesCrossed) { 166 isDAbefore_Variable_values.put(_parameters, isDAbefore_Variable_value); 167 } else { 168 } 169 state.INTERMEDIATE_VALUE |= intermediate; 170 171 return isDAbefore_Variable_value; 172 } 173 /** 174 * @apilevel internal 175 */ 176 protected java.util.Map isDAafter_Variable_values; 177 /** 178 * @apilevel internal 179 */ 180 private void isDAafter_Variable_reset() { 181 isDAafter_Variable_values = null; 182 } 183 /** 184 * @attribute syn 185 * @aspect DA 186 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257 187 */ 188 @ASTNodeAnnotation.Attribute 189 public boolean isDAafter(Variable v) { 190 Object _parameters = v; 191 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 192 ASTNode$State state = state(); 193 if (isDAafter_Variable_values.containsKey(_parameters)) { 194 return (Boolean) isDAafter_Variable_values.get(_parameters); 195 } 196 boolean intermediate = state.INTERMEDIATE_VALUE; 197 state.INTERMEDIATE_VALUE = false; 198 int num = state.boundariesCrossed; 199 boolean isFinal = this.is$Final(); 200 boolean isDAafter_Variable_value = isDAbefore(v); 201 if (isFinal && num == state().boundariesCrossed) { 202 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 203 } else { 204 } 205 state.INTERMEDIATE_VALUE |= intermediate; 206 207 return isDAafter_Variable_value; 208 } 209 /** 210 * @attribute syn 211 * @aspect DU 212 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1187 213 */ 214 @ASTNodeAnnotation.Attribute 215 public boolean isDUbefore(Variable v) { 216 boolean isDUbefore_Variable_value = getParent().getParent() instanceof Block 217 && ((Block) getParent().getParent()).isDUbefore(v) 218 && super.isDUbefore(v); 219 220 return isDUbefore_Variable_value; 221 } 222 /** 223 * @apilevel internal 224 */ 225 protected java.util.Map isDUafter_Variable_values; 226 /** 227 * @apilevel internal 228 */ 229 private void isDUafter_Variable_reset() { 230 isDUafter_Variable_values = null; 231 } 232 /** 233 * @attribute syn 234 * @aspect DU 235 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781 236 */ 237 @ASTNodeAnnotation.Attribute 238 public boolean isDUafter(Variable v) { 239 Object _parameters = v; 240 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 241 ASTNode$State state = state(); 242 if (isDUafter_Variable_values.containsKey(_parameters)) { 243 return (Boolean) isDUafter_Variable_values.get(_parameters); 244 } 245 boolean intermediate = state.INTERMEDIATE_VALUE; 246 state.INTERMEDIATE_VALUE = false; 247 int num = state.boundariesCrossed; 248 boolean isFinal = this.is$Final(); 249 boolean isDUafter_Variable_value = isDUbefore(v); 250 if (isFinal && num == state().boundariesCrossed) { 251 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 252 } else { 253 } 254 state.INTERMEDIATE_VALUE |= intermediate; 255 256 return isDUafter_Variable_value; 257 } 258 /** 259 * @attribute syn 260 * @aspect UnreachableStatements 261 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:129 262 */ 263 @ASTNodeAnnotation.Attribute 264 public boolean reachable() { 265 boolean reachable_value = getParent().getParent() instanceof Block && ((Block) getParent().getParent()).reachable(); 266 267 return reachable_value; 268 } 269 /** 270 * @apilevel internal 271 */ 272 protected boolean label_computed = false; 273 /** 274 * @apilevel internal 275 */ 276 protected int label_value; 277 /** 278 * @apilevel internal 279 */ 280 private void label_reset() { 281 label_computed = false; 282 } 283 /** 284 * @attribute syn 285 * @aspect CreateBCode 286 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1530 287 */ 288 @ASTNodeAnnotation.Attribute 289 public int label() { 290 ASTNode$State state = state(); 291 if (label_computed) { 292 return label_value; 293 } 294 boolean intermediate = state.INTERMEDIATE_VALUE; 295 state.INTERMEDIATE_VALUE = false; 296 int num = state.boundariesCrossed; 297 boolean isFinal = this.is$Final(); 298 label_value = hostType().constantPool().newLabel(); 299 if (isFinal && num == state().boundariesCrossed) { 300 label_computed = true; 301 } else { 302 } 303 state.INTERMEDIATE_VALUE |= intermediate; 304 305 return label_value; 306 } 307 /** 308 * @attribute syn 309 * @aspect PreciseRethrow 310 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84 311 */ 312 @ASTNodeAnnotation.Attribute 313 public boolean modifiedInScope(Variable var) { 314 boolean modifiedInScope_Variable_value = false; 315 316 return modifiedInScope_Variable_value; 317 } 318 /** 319 * @attribute syn 320 * @aspect StringsInSwitch 321 * @declaredat /home/jesper/git/extendj/java7/frontend/StringsInSwitch.jrag:59 322 */ 323 @ASTNodeAnnotation.Attribute 324 public boolean isDefaultCase() { 325 boolean isDefaultCase_value = false; 326 327 return isDefaultCase_value; 328 } 329 /** 330 * @attribute inh 331 * @aspect NameCheck 332 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:496 333 */ 334 /** 335 * @attribute inh 336 * @aspect NameCheck 337 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:496 338 */ 339 @ASTNodeAnnotation.Attribute 340 public Case bind(Case c) { 341 Object _parameters = c; 342 if (bind_Case_values == null) bind_Case_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 343 ASTNode$State state = state(); 344 if (bind_Case_values.containsKey(_parameters)) { 345 return (Case) bind_Case_values.get(_parameters); 346 } 347 boolean intermediate = state.INTERMEDIATE_VALUE; 348 state.INTERMEDIATE_VALUE = false; 349 int num = state.boundariesCrossed; 350 boolean isFinal = this.is$Final(); 351 Case bind_Case_value = getParent().Define_bind(this, null, c); 352 if (isFinal && num == state().boundariesCrossed) { 353 bind_Case_values.put(_parameters, bind_Case_value); 354 } else { 355 } 356 state.INTERMEDIATE_VALUE |= intermediate; 357 358 return bind_Case_value; 359 } 360 /** 361 * @apilevel internal 362 */ 363 protected java.util.Map bind_Case_values; 364 /** 365 * @apilevel internal 366 */ 367 private void bind_Case_reset() { 368 bind_Case_values = null; 369 } 370 /** 371 * @attribute inh 372 * @aspect TypeCheck 373 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:420 374 */ 375 /** 376 * @attribute inh 377 * @aspect TypeCheck 378 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:420 379 */ 380 @ASTNodeAnnotation.Attribute 381 public TypeDecl switchType() { 382 TypeDecl switchType_value = getParent().Define_switchType(this, null); 383 384 return switchType_value; 385 } 386 /** 387 * @apilevel internal 388 */ 389 public ASTNode rewriteTo() { 390 return super.rewriteTo(); 391 } 392 }