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:69 027 * @production BodyDecl : {@link ASTNode}; 028 029 */ 030 public abstract class BodyDecl extends ASTNode<ASTNode> implements Cloneable { 031 /** 032 * @aspect DocumentationComments 033 * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:36 034 */ 035 public String docComment = ""; 036 /** 037 * @aspect GenerateClassfile 038 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:281 039 */ 040 public void generateMethod(DataOutputStream out, ConstantPool cp) throws IOException { 041 } 042 /** 043 * @aspect GenerateClassfile 044 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:302 045 */ 046 public void touchMethod(ConstantPool cp) { 047 } 048 /** 049 * @aspect LookupParTypeDecl 050 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1361 051 */ 052 public BodyDecl substitutedBodyDecl(Parameterization parTypeDecl) { 053 throw new Error("Operation substitutedBodyDecl not supported for " + getClass().getName()); 054 } 055 /** 056 * We must report illegal uses of the SafeVarargs annotation. 057 * It is only allowed on variable arity method and constructor declarations. 058 * @aspect SafeVarargs 059 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:108 060 */ 061 public void checkWarnings() { 062 if (hasIllegalAnnotationSafeVarargs()) { 063 error("@SafeVarargs is only allowed for variable arity method and constructor declarations"); 064 } 065 } 066 /** 067 * @declaredat ASTNode:1 068 */ 069 public BodyDecl() { 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 } 081 /** 082 * @apilevel low-level 083 * @declaredat ASTNode:15 084 */ 085 protected int numChildren() { 086 return 0; 087 } 088 /** 089 * @apilevel internal 090 * @declaredat ASTNode:21 091 */ 092 public boolean mayHaveRewrite() { 093 return false; 094 } 095 /** 096 * @apilevel internal 097 * @declaredat ASTNode:27 098 */ 099 public void flushAttrCache() { 100 super.flushAttrCache(); 101 isDAafter_Variable_reset(); 102 isDAbefore_Variable_reset(); 103 isDUafter_Variable_reset(); 104 isDUbefore_Variable_reset(); 105 attributes_reset(); 106 typeThrowable_reset(); 107 lookupVariable_String_reset(); 108 } 109 /** 110 * @apilevel internal 111 * @declaredat ASTNode:40 112 */ 113 public void flushCollectionCache() { 114 super.flushCollectionCache(); 115 } 116 /** 117 * @apilevel internal 118 * @declaredat ASTNode:46 119 */ 120 public void flushRewriteCache() { 121 super.flushRewriteCache(); 122 } 123 /** 124 * @apilevel internal 125 * @declaredat ASTNode:52 126 */ 127 public BodyDecl clone() throws CloneNotSupportedException { 128 BodyDecl node = (BodyDecl) super.clone(); 129 return node; 130 } 131 /** 132 * Create a deep copy of the AST subtree at this node. 133 * The copy is dangling, i.e. has no parent. 134 * @return dangling copy of the subtree at this node 135 * @apilevel low-level 136 * @deprecated Please use treeCopy or treeCopyNoTransform instead 137 * @declaredat ASTNode:63 138 */ 139 @Deprecated 140 public abstract BodyDecl fullCopy(); 141 /** 142 * Create a deep copy of the AST subtree at this node. 143 * The copy is dangling, i.e. has no parent. 144 * @return dangling copy of the subtree at this node 145 * @apilevel low-level 146 * @declaredat ASTNode:71 147 */ 148 public abstract BodyDecl treeCopyNoTransform(); 149 /** 150 * Create a deep copy of the AST subtree at this node. 151 * The subtree of this node is traversed to trigger rewrites before copy. 152 * The copy is dangling, i.e. has no parent. 153 * @return dangling copy of the subtree at this node 154 * @apilevel low-level 155 * @declaredat ASTNode:79 156 */ 157 public abstract BodyDecl treeCopy(); 158 /** 159 * @apilevel internal 160 */ 161 protected java.util.Map isDAafter_Variable_values; 162 /** 163 * @apilevel internal 164 */ 165 private void isDAafter_Variable_reset() { 166 isDAafter_Variable_values = null; 167 } 168 /** 169 * @attribute syn 170 * @aspect DA 171 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:266 172 */ 173 @ASTNodeAnnotation.Attribute 174 public boolean isDAafter(Variable v) { 175 Object _parameters = v; 176 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 177 ASTNode$State state = state(); 178 if (isDAafter_Variable_values.containsKey(_parameters)) { 179 return (Boolean) isDAafter_Variable_values.get(_parameters); 180 } 181 boolean intermediate = state.INTERMEDIATE_VALUE; 182 state.INTERMEDIATE_VALUE = false; 183 int num = state.boundariesCrossed; 184 boolean isFinal = this.is$Final(); 185 boolean isDAafter_Variable_value = true; 186 if (isFinal && num == state().boundariesCrossed) { 187 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 188 } else { 189 } 190 state.INTERMEDIATE_VALUE |= intermediate; 191 192 return isDAafter_Variable_value; 193 } 194 /** 195 * @apilevel internal 196 */ 197 protected java.util.Map isDAbefore_Variable_values; 198 /** 199 * @apilevel internal 200 */ 201 private void isDAbefore_Variable_reset() { 202 isDAbefore_Variable_values = null; 203 } 204 /** 205 * @attribute syn 206 * @aspect DA 207 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:270 208 */ 209 @ASTNodeAnnotation.Attribute 210 public boolean isDAbefore(Variable v) { 211 Object _parameters = v; 212 if (isDAbefore_Variable_values == null) isDAbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 213 ASTNode$State state = state(); 214 if (isDAbefore_Variable_values.containsKey(_parameters)) { 215 return (Boolean) isDAbefore_Variable_values.get(_parameters); 216 } 217 boolean intermediate = state.INTERMEDIATE_VALUE; 218 state.INTERMEDIATE_VALUE = false; 219 int num = state.boundariesCrossed; 220 boolean isFinal = this.is$Final(); 221 boolean isDAbefore_Variable_value = isDAbefore(v, this); 222 if (isFinal && num == state().boundariesCrossed) { 223 isDAbefore_Variable_values.put(_parameters, isDAbefore_Variable_value); 224 } else { 225 } 226 state.INTERMEDIATE_VALUE |= intermediate; 227 228 return isDAbefore_Variable_value; 229 } 230 /** 231 * @apilevel internal 232 */ 233 protected java.util.Map isDUafter_Variable_values; 234 /** 235 * @apilevel internal 236 */ 237 private void isDUafter_Variable_reset() { 238 isDUafter_Variable_values = null; 239 } 240 /** 241 * @attribute syn 242 * @aspect DU 243 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:796 244 */ 245 @ASTNodeAnnotation.Attribute 246 public boolean isDUafter(Variable v) { 247 Object _parameters = v; 248 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 249 ASTNode$State state = state(); 250 if (isDUafter_Variable_values.containsKey(_parameters)) { 251 return (Boolean) isDUafter_Variable_values.get(_parameters); 252 } 253 boolean intermediate = state.INTERMEDIATE_VALUE; 254 state.INTERMEDIATE_VALUE = false; 255 int num = state.boundariesCrossed; 256 boolean isFinal = this.is$Final(); 257 boolean isDUafter_Variable_value = true; 258 if (isFinal && num == state().boundariesCrossed) { 259 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 260 } else { 261 } 262 state.INTERMEDIATE_VALUE |= intermediate; 263 264 return isDUafter_Variable_value; 265 } 266 /** 267 * @apilevel internal 268 */ 269 protected java.util.Map isDUbefore_Variable_values; 270 /** 271 * @apilevel internal 272 */ 273 private void isDUbefore_Variable_reset() { 274 isDUbefore_Variable_values = null; 275 } 276 /** 277 * @attribute syn 278 * @aspect DU 279 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:802 280 */ 281 @ASTNodeAnnotation.Attribute 282 public boolean isDUbefore(Variable v) { 283 Object _parameters = v; 284 if (isDUbefore_Variable_values == null) isDUbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 285 ASTNode$State state = state(); 286 if (isDUbefore_Variable_values.containsKey(_parameters)) { 287 return (Boolean) isDUbefore_Variable_values.get(_parameters); 288 } 289 boolean intermediate = state.INTERMEDIATE_VALUE; 290 state.INTERMEDIATE_VALUE = false; 291 int num = state.boundariesCrossed; 292 boolean isFinal = this.is$Final(); 293 boolean isDUbefore_Variable_value = isDUbefore(v, this); 294 if (isFinal && num == state().boundariesCrossed) { 295 isDUbefore_Variable_values.put(_parameters, isDUbefore_Variable_value); 296 } else { 297 } 298 state.INTERMEDIATE_VALUE |= intermediate; 299 300 return isDUbefore_Variable_value; 301 } 302 /** 303 * @attribute syn 304 * @aspect DocumentationComments 305 * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:41 306 */ 307 @ASTNodeAnnotation.Attribute 308 public String docComment() { 309 String docComment_value = docComment; 310 311 return docComment_value; 312 } 313 /** 314 * @attribute syn 315 * @aspect DocumentationComments 316 * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:45 317 */ 318 @ASTNodeAnnotation.Attribute 319 public boolean hasDocComment() { 320 boolean hasDocComment_value = !docComment.isEmpty(); 321 322 return hasDocComment_value; 323 } 324 /** 325 * @attribute syn 326 * @aspect TypeScopePropagation 327 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:599 328 */ 329 @ASTNodeAnnotation.Attribute 330 public boolean declaresType(String name) { 331 boolean declaresType_String_value = false; 332 333 return declaresType_String_value; 334 } 335 /** 336 * @attribute syn 337 * @aspect TypeScopePropagation 338 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:601 339 */ 340 @ASTNodeAnnotation.Attribute 341 public TypeDecl type(String name) { 342 TypeDecl type_String_value = null; 343 344 return type_String_value; 345 } 346 /** 347 * @attribute syn 348 * @aspect TypeAnalysis 349 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:297 350 */ 351 @ASTNodeAnnotation.Attribute 352 public boolean isVoid() { 353 boolean isVoid_value = false; 354 355 return isVoid_value; 356 } 357 /** 358 * @apilevel internal 359 */ 360 protected boolean attributes_computed = false; 361 /** 362 * @apilevel internal 363 */ 364 protected Collection attributes_value; 365 /** 366 * @apilevel internal 367 */ 368 private void attributes_reset() { 369 attributes_computed = false; 370 attributes_value = null; 371 } 372 /** 373 * @attribute syn 374 * @aspect Attributes 375 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:212 376 */ 377 @ASTNodeAnnotation.Attribute 378 public Collection attributes() { 379 ASTNode$State state = state(); 380 if (attributes_computed) { 381 return attributes_value; 382 } 383 boolean intermediate = state.INTERMEDIATE_VALUE; 384 state.INTERMEDIATE_VALUE = false; 385 int num = state.boundariesCrossed; 386 boolean isFinal = this.is$Final(); 387 attributes_value = new ArrayList(); 388 if (isFinal && num == state().boundariesCrossed) { 389 attributes_computed = true; 390 } else { 391 } 392 state.INTERMEDIATE_VALUE |= intermediate; 393 394 return attributes_value; 395 } 396 /** 397 * @attribute syn 398 * @aspect GenerateClassfile 399 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:347 400 */ 401 @ASTNodeAnnotation.Attribute 402 public boolean isBytecodeField() { 403 boolean isBytecodeField_value = false; 404 405 return isBytecodeField_value; 406 } 407 /** 408 * @attribute syn 409 * @aspect GenerateClassfile 410 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:350 411 */ 412 @ASTNodeAnnotation.Attribute 413 public boolean isBytecodeMethod() { 414 boolean isBytecodeMethod_value = false; 415 416 return isBytecodeMethod_value; 417 } 418 /** 419 * @attribute syn 420 * @aspect Annotations 421 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:356 422 */ 423 @ASTNodeAnnotation.Attribute 424 public boolean hasAnnotationSuppressWarnings(String annot) { 425 boolean hasAnnotationSuppressWarnings_String_value = false; 426 427 return hasAnnotationSuppressWarnings_String_value; 428 } 429 /** 430 * @attribute syn 431 * @aspect Annotations 432 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:402 433 */ 434 @ASTNodeAnnotation.Attribute 435 public boolean isDeprecated() { 436 boolean isDeprecated_value = false; 437 438 return isDeprecated_value; 439 } 440 /** 441 * @attribute syn 442 * @aspect Enums 443 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:48 444 */ 445 @ASTNodeAnnotation.Attribute 446 public boolean isEnumConstant() { 447 boolean isEnumConstant_value = false; 448 449 return isEnumConstant_value; 450 } 451 /** 452 * @attribute syn 453 * @aspect GenericsParTypeDecl 454 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:90 455 */ 456 @ASTNodeAnnotation.Attribute 457 public boolean visibleTypeParameters() { 458 boolean visibleTypeParameters_value = true; 459 460 return visibleTypeParameters_value; 461 } 462 /** 463 * @return {@code true} if this is a generic method or constructor, or a 464 * substitued generic method or constructor. 465 * @attribute syn 466 * @aspect MethodSignature15 467 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:375 468 */ 469 @ASTNodeAnnotation.Attribute 470 public boolean isGeneric() { 471 boolean isGeneric_value = false; 472 473 return isGeneric_value; 474 } 475 /** 476 * Note: isGeneric must be called first to check if this declaration is generic. 477 * Otherwise this attribute will throw an error! 478 * @return type parameters for this declaration. 479 * @attribute syn 480 * @aspect MethodSignature15 481 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:408 482 */ 483 @ASTNodeAnnotation.Attribute 484 public List<TypeVariable> typeParameters() { 485 { 486 throw new Error("can not evaulate type parameters for non-generic declaration"); 487 } 488 } 489 /** 490 * @attribute syn 491 * @aspect GenericsCodegen 492 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:374 493 */ 494 @ASTNodeAnnotation.Attribute 495 public boolean needsSignatureAttribute() { 496 boolean needsSignatureAttribute_value = false; 497 498 return needsSignatureAttribute_value; 499 } 500 /** 501 * @return true if the modifier list includes the SafeVarargs annotation 502 * @attribute syn 503 * @aspect SafeVarargs 504 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:42 505 */ 506 @ASTNodeAnnotation.Attribute 507 public boolean hasAnnotationSafeVarargs() { 508 boolean hasAnnotationSafeVarargs_value = false; 509 510 return hasAnnotationSafeVarargs_value; 511 } 512 /** 513 * It is an error if the SafeVarargs annotation is used on something 514 * that is not a variable arity method or constructor. 515 * @attribute syn 516 * @aspect SafeVarargs 517 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:73 518 */ 519 @ASTNodeAnnotation.Attribute 520 public boolean hasIllegalAnnotationSafeVarargs() { 521 boolean hasIllegalAnnotationSafeVarargs_value = hasAnnotationSafeVarargs(); 522 523 return hasIllegalAnnotationSafeVarargs_value; 524 } 525 /** 526 * @attribute syn 527 * @aspect PreciseRethrow 528 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:40 529 */ 530 @ASTNodeAnnotation.Attribute 531 public boolean modifiedInScope(Variable var) { 532 boolean modifiedInScope_Variable_value = false; 533 534 return modifiedInScope_Variable_value; 535 } 536 /** 537 * @attribute inh 538 * @aspect DA 539 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:272 540 */ 541 /** 542 * @attribute inh 543 * @aspect DA 544 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:272 545 */ 546 @ASTNodeAnnotation.Attribute 547 public boolean isDAbefore(Variable v, BodyDecl b) { 548 boolean isDAbefore_Variable_BodyDecl_value = getParent().Define_isDAbefore(this, null, v, b); 549 550 return isDAbefore_Variable_BodyDecl_value; 551 } 552 /** 553 * @attribute inh 554 * @aspect DU 555 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:804 556 */ 557 /** 558 * @attribute inh 559 * @aspect DU 560 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:804 561 */ 562 @ASTNodeAnnotation.Attribute 563 public boolean isDUbefore(Variable v, BodyDecl b) { 564 boolean isDUbefore_Variable_BodyDecl_value = getParent().Define_isDUbefore(this, null, v, b); 565 566 return isDUbefore_Variable_BodyDecl_value; 567 } 568 /** 569 * @attribute inh 570 * @aspect ExceptionHandling 571 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:49 572 */ 573 /** 574 * @attribute inh 575 * @aspect ExceptionHandling 576 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:49 577 */ 578 @ASTNodeAnnotation.Attribute 579 public TypeDecl typeThrowable() { 580 ASTNode$State state = state(); 581 if (typeThrowable_computed) { 582 return typeThrowable_value; 583 } 584 boolean intermediate = state.INTERMEDIATE_VALUE; 585 state.INTERMEDIATE_VALUE = false; 586 int num = state.boundariesCrossed; 587 boolean isFinal = this.is$Final(); 588 typeThrowable_value = getParent().Define_typeThrowable(this, null); 589 if (isFinal && num == state().boundariesCrossed) { 590 typeThrowable_computed = true; 591 } else { 592 } 593 state.INTERMEDIATE_VALUE |= intermediate; 594 595 return typeThrowable_value; 596 } 597 /** 598 * @apilevel internal 599 */ 600 protected boolean typeThrowable_computed = false; 601 /** 602 * @apilevel internal 603 */ 604 protected TypeDecl typeThrowable_value; 605 /** 606 * @apilevel internal 607 */ 608 private void typeThrowable_reset() { 609 typeThrowable_computed = false; 610 typeThrowable_value = null; 611 } 612 /** 613 * @attribute inh 614 * @aspect LookupMethod 615 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:47 616 */ 617 /** 618 * @attribute inh 619 * @aspect LookupMethod 620 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:47 621 */ 622 @ASTNodeAnnotation.Attribute 623 public Collection lookupMethod(String name) { 624 Collection lookupMethod_String_value = getParent().Define_lookupMethod(this, null, name); 625 626 return lookupMethod_String_value; 627 } 628 /** 629 * @attribute inh 630 * @aspect LookupFullyQualifiedTypes 631 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:131 632 */ 633 /** 634 * @attribute inh 635 * @aspect LookupFullyQualifiedTypes 636 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:131 637 */ 638 @ASTNodeAnnotation.Attribute 639 public TypeDecl lookupType(String packageName, String typeName) { 640 TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName); 641 642 return lookupType_String_String_value; 643 } 644 /** 645 * @attribute inh 646 * @aspect TypeScopePropagation 647 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:338 648 */ 649 /** 650 * @attribute inh 651 * @aspect TypeScopePropagation 652 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:338 653 */ 654 @ASTNodeAnnotation.Attribute 655 public SimpleSet lookupType(String name) { 656 SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name); 657 658 return lookupType_String_value; 659 } 660 /** 661 * @attribute inh 662 * @aspect VariableScope 663 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:36 664 */ 665 /** 666 * @attribute inh 667 * @aspect VariableScope 668 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:36 669 */ 670 @ASTNodeAnnotation.Attribute 671 public SimpleSet lookupVariable(String name) { 672 Object _parameters = name; 673 if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 674 ASTNode$State state = state(); 675 if (lookupVariable_String_values.containsKey(_parameters)) { 676 return (SimpleSet) lookupVariable_String_values.get(_parameters); 677 } 678 boolean intermediate = state.INTERMEDIATE_VALUE; 679 state.INTERMEDIATE_VALUE = false; 680 int num = state.boundariesCrossed; 681 boolean isFinal = this.is$Final(); 682 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 683 if (isFinal && num == state().boundariesCrossed) { 684 lookupVariable_String_values.put(_parameters, lookupVariable_String_value); 685 } else { 686 } 687 state.INTERMEDIATE_VALUE |= intermediate; 688 689 return lookupVariable_String_value; 690 } 691 /** 692 * @apilevel internal 693 */ 694 protected java.util.Map lookupVariable_String_values; 695 /** 696 * @apilevel internal 697 */ 698 private void lookupVariable_String_reset() { 699 lookupVariable_String_values = null; 700 } 701 /** 702 * @attribute inh 703 * @aspect NestedTypes 704 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:621 705 */ 706 /** 707 * @attribute inh 708 * @aspect NestedTypes 709 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:621 710 */ 711 @ASTNodeAnnotation.Attribute 712 public String hostPackage() { 713 String hostPackage_value = getParent().Define_hostPackage(this, null); 714 715 return hostPackage_value; 716 } 717 /** 718 * @attribute inh 719 * @aspect NestedTypes 720 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:637 721 */ 722 /** 723 * @attribute inh 724 * @aspect NestedTypes 725 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:637 726 */ 727 @ASTNodeAnnotation.Attribute 728 public TypeDecl hostType() { 729 TypeDecl hostType_value = getParent().Define_hostType(this, null); 730 731 return hostType_value; 732 } 733 /** 734 * @attribute inh 735 * @aspect Annotations 736 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:341 737 */ 738 /** 739 * @attribute inh 740 * @aspect Annotations 741 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:341 742 */ 743 @ASTNodeAnnotation.Attribute 744 public boolean withinSuppressWarnings(String annot) { 745 boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot); 746 747 return withinSuppressWarnings_String_value; 748 } 749 /** 750 * @attribute inh 751 * @aspect Annotations 752 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:449 753 */ 754 /** 755 * @attribute inh 756 * @aspect Annotations 757 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:449 758 */ 759 @ASTNodeAnnotation.Attribute 760 public boolean withinDeprecatedAnnotation() { 761 boolean withinDeprecatedAnnotation_value = getParent().Define_withinDeprecatedAnnotation(this, null); 762 763 return withinDeprecatedAnnotation_value; 764 } 765 /** 766 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 767 * @apilevel internal 768 */ 769 public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 770 int childIndex = this.getIndexOfChild(caller); 771 { 772 throw new Error("Found no branch targets for " + branch.getClass().getName()); 773 } 774 } 775 protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 776 return true; 777 } 778 /** 779 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262 780 * @apilevel internal 781 */ 782 public FinallyHost Define_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 783 int childIndex = this.getIndexOfChild(caller); 784 return null; 785 } 786 protected boolean canDefine_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 787 return true; 788 } 789 /** 790 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 791 * @apilevel internal 792 */ 793 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 794 int childIndex = this.getIndexOfChild(caller); 795 return isDAbefore(v, this); 796 } 797 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 798 return true; 799 } 800 /** 801 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 802 * @apilevel internal 803 */ 804 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 805 int childIndex = this.getIndexOfChild(caller); 806 return isDUbefore(v, this); 807 } 808 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 809 return true; 810 } 811 /** 812 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:524 813 * @apilevel internal 814 */ 815 public SimpleSet Define_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 816 int childIndex = this.getIndexOfChild(caller); 817 return SimpleSet.emptySet; 818 } 819 protected boolean canDefine_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 820 return true; 821 } 822 /** 823 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:29 824 * @apilevel internal 825 */ 826 public BodyDecl Define_enclosingBodyDecl(ASTNode caller, ASTNode child) { 827 int childIndex = this.getIndexOfChild(caller); 828 return this; 829 } 830 protected boolean canDefine_enclosingBodyDecl(ASTNode caller, ASTNode child) { 831 return true; 832 } 833 /** 834 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836 835 * @apilevel internal 836 */ 837 public boolean Define_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 838 int childIndex = this.getIndexOfChild(caller); 839 { 840 throw new Error("Enclosing monitor not found!"); 841 } 842 } 843 protected boolean canDefine_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 844 return true; 845 } 846 /** 847 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:38 848 * @apilevel internal 849 */ 850 public boolean Define_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) { 851 int childIndex = this.getIndexOfChild(caller); 852 return hasAnnotationSuppressWarnings(annot) || hasAnnotationSuppressWarnings(annot) 853 || withinSuppressWarnings(annot); 854 } 855 protected boolean canDefine_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) { 856 return true; 857 } 858 /** 859 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:449 860 * @apilevel internal 861 */ 862 public boolean Define_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) { 863 int childIndex = this.getIndexOfChild(caller); 864 return isDeprecated() || isDeprecated() || withinDeprecatedAnnotation(); 865 } 866 protected boolean canDefine_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) { 867 return true; 868 } 869 /** 870 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:183 871 * @apilevel internal 872 */ 873 public boolean Define_resourcePreviouslyDeclared(ASTNode caller, ASTNode child, String name) { 874 int i = this.getIndexOfChild(caller); 875 return false; 876 } 877 protected boolean canDefine_resourcePreviouslyDeclared(ASTNode caller, ASTNode child, String name) { 878 return true; 879 } 880 /** 881 * @apilevel internal 882 */ 883 public ASTNode rewriteTo() { 884 return super.rewriteTo(); 885 } 886 }