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:186 027 * @production Modifiers : {@link ASTNode} ::= <span class="component">{@link Modifier}*</span>; 028 029 */ 030 public class Modifiers extends ASTNode<ASTNode> implements Cloneable { 031 /** 032 * @aspect Modifiers 033 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:355 034 */ 035 public void refined_Modifiers_Modifiers_checkModifiers() { 036 super.checkModifiers(); 037 if (numProtectionModifiers() > 1) { 038 error("only one public, protected, private allowed"); 039 } 040 if (numModifier("static") > 1) { 041 error("only one static allowed"); 042 } 043 // 8.4.3.1 044 // 8.4.3.2 045 // 8.1.1.2 046 if (numCompletenessModifiers() > 1) { 047 error("only one of final, abstract, volatile allowed"); 048 } 049 if (numModifier("synchronized") > 1) { 050 error("only one synchronized allowed"); 051 } 052 if (numModifier("transient") > 1) { 053 error("only one transient allowed"); 054 } 055 if (numModifier("native") > 1) { 056 error("only one native allowed"); 057 } 058 if (numModifier("strictfp") > 1) { 059 error("only one strictfp allowed"); 060 } 061 062 if (isPublic() && !mayBePublic()) { 063 error("modifier public not allowed in this context"); 064 } 065 if (isPrivate() && !mayBePrivate()) { 066 error("modifier private not allowed in this context"); 067 } 068 if (isProtected() && !mayBeProtected()) { 069 error("modifier protected not allowed in this context"); 070 } 071 if (isStatic() && !mayBeStatic()) { 072 error("modifier static not allowed in this context"); 073 } 074 if (isFinal() && !mayBeFinal()) { 075 error("modifier final not allowed in this context"); 076 } 077 if (isAbstract() && !mayBeAbstract()) { 078 error("modifier abstract not allowed in this context"); 079 } 080 if (isVolatile() && !mayBeVolatile()) { 081 error("modifier volatile not allowed in this context"); 082 } 083 if (isTransient() && !mayBeTransient()) { 084 error("modifier transient not allowed in this context"); 085 } 086 if (isStrictfp() && !mayBeStrictfp()) { 087 error("modifier strictfp not allowed in this context"); 088 } 089 if (isSynchronized() && !mayBeSynchronized()) { 090 error("modifier synchronized not allowed in this context"); 091 } 092 if (isNative() && !mayBeNative()) { 093 error("modifier native not allowed in this context"); 094 } 095 } 096 /** 097 * @aspect Java4PrettyPrint 098 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:122 099 */ 100 public void prettyPrint(PrettyPrinter out) { 101 if (hasModifier()) { 102 out.join(getModifierList(), new PrettyPrinter.Joiner() { 103 @Override 104 public void printSeparator(PrettyPrinter out) { 105 out.print(" "); 106 } 107 }); 108 out.print(" "); 109 } 110 } 111 /** 112 * @aspect Flags 113 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:32 114 */ 115 public static final int ACC_PUBLIC = 0x0001; 116 /** 117 * @aspect Flags 118 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:33 119 */ 120 public static final int ACC_PRIVATE = 0x0002; 121 /** 122 * @aspect Flags 123 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:34 124 */ 125 public static final int ACC_PROTECTED = 0x0004; 126 /** 127 * @aspect Flags 128 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:35 129 */ 130 public static final int ACC_STATIC = 0x0008; 131 /** 132 * @aspect Flags 133 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:36 134 */ 135 public static final int ACC_FINAL = 0x0010; 136 /** 137 * @aspect Flags 138 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:37 139 */ 140 public static final int ACC_SYNCHRONIZED = 0x0020; 141 /** 142 * @aspect Flags 143 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:38 144 */ 145 public static final int ACC_SUPER = 0x0020; 146 /** 147 * @aspect Flags 148 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:39 149 */ 150 public static final int ACC_VOLATILE = 0x0040; 151 /** 152 * @aspect Flags 153 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:40 154 */ 155 public static final int ACC_TRANSIENT = 0x0080; 156 /** 157 * @aspect Flags 158 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:41 159 */ 160 public static final int ACC_NATIVE = 0x0100; 161 /** 162 * @aspect Flags 163 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:42 164 */ 165 public static final int ACC_INTERFACE = 0x0200; 166 /** 167 * @aspect Flags 168 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:43 169 */ 170 public static final int ACC_ABSTRACT = 0x0400; 171 /** 172 * @aspect Flags 173 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:44 174 */ 175 public static final int ACC_SYNTHETIC = 0x1000; 176 /** 177 * @aspect Flags 178 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:45 179 */ 180 public static final int ACC_STRICT = 0x0800; 181 /** 182 * @aspect AnnotationsCodegen 183 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:60 184 */ 185 public void addRuntimeVisibleAnnotationsAttribute(Collection c) { 186 ConstantPool cp = hostType().constantPool(); 187 Collection annotations = runtimeVisibleAnnotations(); 188 if (!annotations.isEmpty()) { 189 c.add(new AnnotationsAttribute(cp, annotations, "RuntimeVisibleAnnotations")); 190 } 191 } 192 /** 193 * @aspect AnnotationsCodegen 194 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:69 195 */ 196 public void addRuntimeInvisibleAnnotationsAttribute(Collection c) { 197 ConstantPool cp = hostType().constantPool(); 198 Collection annotations = runtimeInvisibleAnnotations(); 199 if (!annotations.isEmpty()) { 200 c.add(new AnnotationsAttribute(cp, annotations, "RuntimeInvisibleAnnotations")); 201 } 202 } 203 /** 204 * @aspect AnnotationsCodegen 205 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:125 206 */ 207 public Collection runtimeVisibleAnnotations() { 208 Collection annotations = new ArrayList(); 209 for (int i = 0; i < getNumModifier(); i++) { 210 if (getModifier(i).isRuntimeVisible()) { 211 annotations.add(getModifier(i)); 212 } 213 } 214 return annotations; 215 } 216 /** 217 * @aspect AnnotationsCodegen 218 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:151 219 */ 220 public Collection runtimeInvisibleAnnotations() { 221 Collection annotations = new ArrayList(); 222 for (int i = 0; i < getNumModifier(); i++) { 223 if (getModifier(i).isRuntimeInvisible()) { 224 annotations.add(getModifier(i)); 225 } 226 } 227 return annotations; 228 } 229 /** 230 * @aspect AnnotationsCodegen 231 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:176 232 */ 233 public static final int ACC_ANNOTATION = 0x2000; 234 /** 235 * @aspect EnumsCodegen 236 * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:33 237 */ 238 public static final int ACC_ENUM = 0x4000; 239 /** 240 * @aspect GenericsCodegen 241 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:219 242 */ 243 public static final int ACC_BRIDGE = 0x0040; 244 /** 245 * @aspect VariableArityParametersCodegen 246 * @declaredat /home/jesper/git/extendj/java5/backend/VariableArityParametersCodegen.jrag:109 247 */ 248 public static final int ACC_VARARGS = 0x0080; 249 /** 250 * @declaredat ASTNode:1 251 */ 252 public Modifiers() { 253 super(); 254 } 255 /** 256 * Initializes the child array to the correct size. 257 * Initializes List and Opt nta children. 258 * @apilevel internal 259 * @ast method 260 * @declaredat ASTNode:10 261 */ 262 public void init$Children() { 263 children = new ASTNode[1]; 264 setChild(new List(), 0); 265 } 266 /** 267 * @declaredat ASTNode:14 268 */ 269 public Modifiers(List<Modifier> p0) { 270 setChild(p0, 0); 271 } 272 /** 273 * @apilevel low-level 274 * @declaredat ASTNode:20 275 */ 276 protected int numChildren() { 277 return 1; 278 } 279 /** 280 * @apilevel internal 281 * @declaredat ASTNode:26 282 */ 283 public boolean mayHaveRewrite() { 284 return false; 285 } 286 /** 287 * @apilevel internal 288 * @declaredat ASTNode:32 289 */ 290 public void flushAttrCache() { 291 super.flushAttrCache(); 292 isPublic_reset(); 293 isPrivate_reset(); 294 isProtected_reset(); 295 isStatic_reset(); 296 isFinal_reset(); 297 isAbstract_reset(); 298 isVolatile_reset(); 299 isTransient_reset(); 300 isStrictfp_reset(); 301 isSynchronized_reset(); 302 isNative_reset(); 303 isSynthetic_reset(); 304 numModifier_String_reset(); 305 isDefault_reset(); 306 } 307 /** 308 * @apilevel internal 309 * @declaredat ASTNode:52 310 */ 311 public void flushCollectionCache() { 312 super.flushCollectionCache(); 313 } 314 /** 315 * @apilevel internal 316 * @declaredat ASTNode:58 317 */ 318 public void flushRewriteCache() { 319 super.flushRewriteCache(); 320 } 321 /** 322 * @apilevel internal 323 * @declaredat ASTNode:64 324 */ 325 public Modifiers clone() throws CloneNotSupportedException { 326 Modifiers node = (Modifiers) super.clone(); 327 return node; 328 } 329 /** 330 * @apilevel internal 331 * @declaredat ASTNode:71 332 */ 333 public Modifiers copy() { 334 try { 335 Modifiers node = (Modifiers) clone(); 336 node.parent = null; 337 if (children != null) { 338 node.children = (ASTNode[]) children.clone(); 339 } 340 return node; 341 } catch (CloneNotSupportedException e) { 342 throw new Error("Error: clone not supported for " + getClass().getName()); 343 } 344 } 345 /** 346 * Create a deep copy of the AST subtree at this node. 347 * The copy is dangling, i.e. has no parent. 348 * @return dangling copy of the subtree at this node 349 * @apilevel low-level 350 * @deprecated Please use treeCopy or treeCopyNoTransform instead 351 * @declaredat ASTNode:90 352 */ 353 @Deprecated 354 public Modifiers fullCopy() { 355 return treeCopyNoTransform(); 356 } 357 /** 358 * Create a deep copy of the AST subtree at this node. 359 * The copy is dangling, i.e. has no parent. 360 * @return dangling copy of the subtree at this node 361 * @apilevel low-level 362 * @declaredat ASTNode:100 363 */ 364 public Modifiers treeCopyNoTransform() { 365 Modifiers tree = (Modifiers) copy(); 366 if (children != null) { 367 for (int i = 0; i < children.length; ++i) { 368 ASTNode child = (ASTNode) children[i]; 369 if (child != null) { 370 child = child.treeCopyNoTransform(); 371 tree.setChild(child, i); 372 } 373 } 374 } 375 return tree; 376 } 377 /** 378 * Create a deep copy of the AST subtree at this node. 379 * The subtree of this node is traversed to trigger rewrites before copy. 380 * The copy is dangling, i.e. has no parent. 381 * @return dangling copy of the subtree at this node 382 * @apilevel low-level 383 * @declaredat ASTNode:120 384 */ 385 public Modifiers treeCopy() { 386 doFullTraversal(); 387 return treeCopyNoTransform(); 388 } 389 /** 390 * @apilevel internal 391 * @declaredat ASTNode:127 392 */ 393 protected boolean is$Equal(ASTNode node) { 394 return super.is$Equal(node); 395 } 396 /** 397 * Replaces the Modifier list. 398 * @param list The new list node to be used as the Modifier list. 399 * @apilevel high-level 400 */ 401 public void setModifierList(List<Modifier> list) { 402 setChild(list, 0); 403 } 404 /** 405 * Retrieves the number of children in the Modifier list. 406 * @return Number of children in the Modifier list. 407 * @apilevel high-level 408 */ 409 public int getNumModifier() { 410 return getModifierList().getNumChild(); 411 } 412 /** 413 * Retrieves the number of children in the Modifier list. 414 * Calling this method will not trigger rewrites. 415 * @return Number of children in the Modifier list. 416 * @apilevel low-level 417 */ 418 public int getNumModifierNoTransform() { 419 return getModifierListNoTransform().getNumChildNoTransform(); 420 } 421 /** 422 * Retrieves the element at index {@code i} in the Modifier list. 423 * @param i Index of the element to return. 424 * @return The element at position {@code i} in the Modifier list. 425 * @apilevel high-level 426 */ 427 public Modifier getModifier(int i) { 428 return (Modifier) getModifierList().getChild(i); 429 } 430 /** 431 * Check whether the Modifier list has any children. 432 * @return {@code true} if it has at least one child, {@code false} otherwise. 433 * @apilevel high-level 434 */ 435 public boolean hasModifier() { 436 return getModifierList().getNumChild() != 0; 437 } 438 /** 439 * Append an element to the Modifier list. 440 * @param node The element to append to the Modifier list. 441 * @apilevel high-level 442 */ 443 public void addModifier(Modifier node) { 444 List<Modifier> list = (parent == null) ? getModifierListNoTransform() : getModifierList(); 445 list.addChild(node); 446 } 447 /** 448 * @apilevel low-level 449 */ 450 public void addModifierNoTransform(Modifier node) { 451 List<Modifier> list = getModifierListNoTransform(); 452 list.addChild(node); 453 } 454 /** 455 * Replaces the Modifier list element at index {@code i} with the new node {@code node}. 456 * @param node The new node to replace the old list element. 457 * @param i The list index of the node to be replaced. 458 * @apilevel high-level 459 */ 460 public void setModifier(Modifier node, int i) { 461 List<Modifier> list = getModifierList(); 462 list.setChild(node, i); 463 } 464 /** 465 * Retrieves the Modifier list. 466 * @return The node representing the Modifier list. 467 * @apilevel high-level 468 */ 469 @ASTNodeAnnotation.ListChild(name="Modifier") 470 public List<Modifier> getModifierList() { 471 List<Modifier> list = (List<Modifier>) getChild(0); 472 return list; 473 } 474 /** 475 * Retrieves the Modifier list. 476 * <p><em>This method does not invoke AST transformations.</em></p> 477 * @return The node representing the Modifier list. 478 * @apilevel low-level 479 */ 480 public List<Modifier> getModifierListNoTransform() { 481 return (List<Modifier>) getChildNoTransform(0); 482 } 483 /** 484 * Retrieves the Modifier list. 485 * @return The node representing the Modifier list. 486 * @apilevel high-level 487 */ 488 public List<Modifier> getModifiers() { 489 return getModifierList(); 490 } 491 /** 492 * Retrieves the Modifier list. 493 * <p><em>This method does not invoke AST transformations.</em></p> 494 * @return The node representing the Modifier list. 495 * @apilevel low-level 496 */ 497 public List<Modifier> getModifiersNoTransform() { 498 return getModifierListNoTransform(); 499 } 500 /** 501 * @aspect Modifiers 502 * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:122 503 */ 504 505 public void checkModifiers() { 506 refined_Modifiers_Modifiers_checkModifiers(); 507 if (numModifier("default") > 1) { 508 error("only one default allowed"); 509 } 510 } 511 /** 512 * @apilevel internal 513 */ 514 protected boolean isPublic_computed = false; 515 /** 516 * @apilevel internal 517 */ 518 protected boolean isPublic_value; 519 /** 520 * @apilevel internal 521 */ 522 private void isPublic_reset() { 523 isPublic_computed = false; 524 } 525 /** 526 * @attribute syn 527 * @aspect Modifiers 528 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:431 529 */ 530 @ASTNodeAnnotation.Attribute 531 public boolean isPublic() { 532 ASTNode$State state = state(); 533 if (isPublic_computed) { 534 return isPublic_value; 535 } 536 boolean intermediate = state.INTERMEDIATE_VALUE; 537 state.INTERMEDIATE_VALUE = false; 538 int num = state.boundariesCrossed; 539 boolean isFinal = this.is$Final(); 540 isPublic_value = numModifier("public") != 0; 541 if (isFinal && num == state().boundariesCrossed) { 542 isPublic_computed = true; 543 } else { 544 } 545 state.INTERMEDIATE_VALUE |= intermediate; 546 547 return isPublic_value; 548 } 549 /** 550 * @apilevel internal 551 */ 552 protected boolean isPrivate_computed = false; 553 /** 554 * @apilevel internal 555 */ 556 protected boolean isPrivate_value; 557 /** 558 * @apilevel internal 559 */ 560 private void isPrivate_reset() { 561 isPrivate_computed = false; 562 } 563 /** 564 * @attribute syn 565 * @aspect Modifiers 566 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:432 567 */ 568 @ASTNodeAnnotation.Attribute 569 public boolean isPrivate() { 570 ASTNode$State state = state(); 571 if (isPrivate_computed) { 572 return isPrivate_value; 573 } 574 boolean intermediate = state.INTERMEDIATE_VALUE; 575 state.INTERMEDIATE_VALUE = false; 576 int num = state.boundariesCrossed; 577 boolean isFinal = this.is$Final(); 578 isPrivate_value = numModifier("private") != 0; 579 if (isFinal && num == state().boundariesCrossed) { 580 isPrivate_computed = true; 581 } else { 582 } 583 state.INTERMEDIATE_VALUE |= intermediate; 584 585 return isPrivate_value; 586 } 587 /** 588 * @apilevel internal 589 */ 590 protected boolean isProtected_computed = false; 591 /** 592 * @apilevel internal 593 */ 594 protected boolean isProtected_value; 595 /** 596 * @apilevel internal 597 */ 598 private void isProtected_reset() { 599 isProtected_computed = false; 600 } 601 /** 602 * @attribute syn 603 * @aspect Modifiers 604 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:433 605 */ 606 @ASTNodeAnnotation.Attribute 607 public boolean isProtected() { 608 ASTNode$State state = state(); 609 if (isProtected_computed) { 610 return isProtected_value; 611 } 612 boolean intermediate = state.INTERMEDIATE_VALUE; 613 state.INTERMEDIATE_VALUE = false; 614 int num = state.boundariesCrossed; 615 boolean isFinal = this.is$Final(); 616 isProtected_value = numModifier("protected") != 0; 617 if (isFinal && num == state().boundariesCrossed) { 618 isProtected_computed = true; 619 } else { 620 } 621 state.INTERMEDIATE_VALUE |= intermediate; 622 623 return isProtected_value; 624 } 625 /** 626 * @apilevel internal 627 */ 628 protected boolean isStatic_computed = false; 629 /** 630 * @apilevel internal 631 */ 632 protected boolean isStatic_value; 633 /** 634 * @apilevel internal 635 */ 636 private void isStatic_reset() { 637 isStatic_computed = false; 638 } 639 /** 640 * @attribute syn 641 * @aspect Modifiers 642 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:434 643 */ 644 @ASTNodeAnnotation.Attribute 645 public boolean isStatic() { 646 ASTNode$State state = state(); 647 if (isStatic_computed) { 648 return isStatic_value; 649 } 650 boolean intermediate = state.INTERMEDIATE_VALUE; 651 state.INTERMEDIATE_VALUE = false; 652 int num = state.boundariesCrossed; 653 boolean isFinal = this.is$Final(); 654 isStatic_value = numModifier("static") != 0; 655 if (isFinal && num == state().boundariesCrossed) { 656 isStatic_computed = true; 657 } else { 658 } 659 state.INTERMEDIATE_VALUE |= intermediate; 660 661 return isStatic_value; 662 } 663 /** 664 * @apilevel internal 665 */ 666 protected boolean isFinal_computed = false; 667 /** 668 * @apilevel internal 669 */ 670 protected boolean isFinal_value; 671 /** 672 * @apilevel internal 673 */ 674 private void isFinal_reset() { 675 isFinal_computed = false; 676 } 677 /** 678 * @attribute syn 679 * @aspect Modifiers 680 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:435 681 */ 682 @ASTNodeAnnotation.Attribute 683 public boolean isFinal() { 684 ASTNode$State state = state(); 685 if (isFinal_computed) { 686 return isFinal_value; 687 } 688 boolean intermediate = state.INTERMEDIATE_VALUE; 689 state.INTERMEDIATE_VALUE = false; 690 int num = state.boundariesCrossed; 691 boolean isFinal = this.is$Final(); 692 isFinal_value = numModifier("final") != 0; 693 if (isFinal && num == state().boundariesCrossed) { 694 isFinal_computed = true; 695 } else { 696 } 697 state.INTERMEDIATE_VALUE |= intermediate; 698 699 return isFinal_value; 700 } 701 /** 702 * @apilevel internal 703 */ 704 protected boolean isAbstract_computed = false; 705 /** 706 * @apilevel internal 707 */ 708 protected boolean isAbstract_value; 709 /** 710 * @apilevel internal 711 */ 712 private void isAbstract_reset() { 713 isAbstract_computed = false; 714 } 715 /** 716 * @attribute syn 717 * @aspect Modifiers 718 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:436 719 */ 720 @ASTNodeAnnotation.Attribute 721 public boolean isAbstract() { 722 ASTNode$State state = state(); 723 if (isAbstract_computed) { 724 return isAbstract_value; 725 } 726 boolean intermediate = state.INTERMEDIATE_VALUE; 727 state.INTERMEDIATE_VALUE = false; 728 int num = state.boundariesCrossed; 729 boolean isFinal = this.is$Final(); 730 isAbstract_value = numModifier("abstract") != 0; 731 if (isFinal && num == state().boundariesCrossed) { 732 isAbstract_computed = true; 733 } else { 734 } 735 state.INTERMEDIATE_VALUE |= intermediate; 736 737 return isAbstract_value; 738 } 739 /** 740 * @apilevel internal 741 */ 742 protected boolean isVolatile_computed = false; 743 /** 744 * @apilevel internal 745 */ 746 protected boolean isVolatile_value; 747 /** 748 * @apilevel internal 749 */ 750 private void isVolatile_reset() { 751 isVolatile_computed = false; 752 } 753 /** 754 * @attribute syn 755 * @aspect Modifiers 756 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:437 757 */ 758 @ASTNodeAnnotation.Attribute 759 public boolean isVolatile() { 760 ASTNode$State state = state(); 761 if (isVolatile_computed) { 762 return isVolatile_value; 763 } 764 boolean intermediate = state.INTERMEDIATE_VALUE; 765 state.INTERMEDIATE_VALUE = false; 766 int num = state.boundariesCrossed; 767 boolean isFinal = this.is$Final(); 768 isVolatile_value = numModifier("volatile") != 0; 769 if (isFinal && num == state().boundariesCrossed) { 770 isVolatile_computed = true; 771 } else { 772 } 773 state.INTERMEDIATE_VALUE |= intermediate; 774 775 return isVolatile_value; 776 } 777 /** 778 * @apilevel internal 779 */ 780 protected boolean isTransient_computed = false; 781 /** 782 * @apilevel internal 783 */ 784 protected boolean isTransient_value; 785 /** 786 * @apilevel internal 787 */ 788 private void isTransient_reset() { 789 isTransient_computed = false; 790 } 791 /** 792 * @attribute syn 793 * @aspect Modifiers 794 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:438 795 */ 796 @ASTNodeAnnotation.Attribute 797 public boolean isTransient() { 798 ASTNode$State state = state(); 799 if (isTransient_computed) { 800 return isTransient_value; 801 } 802 boolean intermediate = state.INTERMEDIATE_VALUE; 803 state.INTERMEDIATE_VALUE = false; 804 int num = state.boundariesCrossed; 805 boolean isFinal = this.is$Final(); 806 isTransient_value = numModifier("transient") != 0; 807 if (isFinal && num == state().boundariesCrossed) { 808 isTransient_computed = true; 809 } else { 810 } 811 state.INTERMEDIATE_VALUE |= intermediate; 812 813 return isTransient_value; 814 } 815 /** 816 * @apilevel internal 817 */ 818 protected boolean isStrictfp_computed = false; 819 /** 820 * @apilevel internal 821 */ 822 protected boolean isStrictfp_value; 823 /** 824 * @apilevel internal 825 */ 826 private void isStrictfp_reset() { 827 isStrictfp_computed = false; 828 } 829 /** 830 * @attribute syn 831 * @aspect Modifiers 832 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:439 833 */ 834 @ASTNodeAnnotation.Attribute 835 public boolean isStrictfp() { 836 ASTNode$State state = state(); 837 if (isStrictfp_computed) { 838 return isStrictfp_value; 839 } 840 boolean intermediate = state.INTERMEDIATE_VALUE; 841 state.INTERMEDIATE_VALUE = false; 842 int num = state.boundariesCrossed; 843 boolean isFinal = this.is$Final(); 844 isStrictfp_value = numModifier("strictfp") != 0; 845 if (isFinal && num == state().boundariesCrossed) { 846 isStrictfp_computed = true; 847 } else { 848 } 849 state.INTERMEDIATE_VALUE |= intermediate; 850 851 return isStrictfp_value; 852 } 853 /** 854 * @apilevel internal 855 */ 856 protected boolean isSynchronized_computed = false; 857 /** 858 * @apilevel internal 859 */ 860 protected boolean isSynchronized_value; 861 /** 862 * @apilevel internal 863 */ 864 private void isSynchronized_reset() { 865 isSynchronized_computed = false; 866 } 867 /** 868 * @attribute syn 869 * @aspect Modifiers 870 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:440 871 */ 872 @ASTNodeAnnotation.Attribute 873 public boolean isSynchronized() { 874 ASTNode$State state = state(); 875 if (isSynchronized_computed) { 876 return isSynchronized_value; 877 } 878 boolean intermediate = state.INTERMEDIATE_VALUE; 879 state.INTERMEDIATE_VALUE = false; 880 int num = state.boundariesCrossed; 881 boolean isFinal = this.is$Final(); 882 isSynchronized_value = numModifier("synchronized") != 0; 883 if (isFinal && num == state().boundariesCrossed) { 884 isSynchronized_computed = true; 885 } else { 886 } 887 state.INTERMEDIATE_VALUE |= intermediate; 888 889 return isSynchronized_value; 890 } 891 /** 892 * @apilevel internal 893 */ 894 protected boolean isNative_computed = false; 895 /** 896 * @apilevel internal 897 */ 898 protected boolean isNative_value; 899 /** 900 * @apilevel internal 901 */ 902 private void isNative_reset() { 903 isNative_computed = false; 904 } 905 /** 906 * @attribute syn 907 * @aspect Modifiers 908 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:441 909 */ 910 @ASTNodeAnnotation.Attribute 911 public boolean isNative() { 912 ASTNode$State state = state(); 913 if (isNative_computed) { 914 return isNative_value; 915 } 916 boolean intermediate = state.INTERMEDIATE_VALUE; 917 state.INTERMEDIATE_VALUE = false; 918 int num = state.boundariesCrossed; 919 boolean isFinal = this.is$Final(); 920 isNative_value = numModifier("native") != 0; 921 if (isFinal && num == state().boundariesCrossed) { 922 isNative_computed = true; 923 } else { 924 } 925 state.INTERMEDIATE_VALUE |= intermediate; 926 927 return isNative_value; 928 } 929 /** 930 * @apilevel internal 931 */ 932 protected boolean isSynthetic_computed = false; 933 /** 934 * @apilevel internal 935 */ 936 protected boolean isSynthetic_value; 937 /** 938 * @apilevel internal 939 */ 940 private void isSynthetic_reset() { 941 isSynthetic_computed = false; 942 } 943 /** 944 * @attribute syn 945 * @aspect Modifiers 946 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:443 947 */ 948 @ASTNodeAnnotation.Attribute 949 public boolean isSynthetic() { 950 ASTNode$State state = state(); 951 if (isSynthetic_computed) { 952 return isSynthetic_value; 953 } 954 boolean intermediate = state.INTERMEDIATE_VALUE; 955 state.INTERMEDIATE_VALUE = false; 956 int num = state.boundariesCrossed; 957 boolean isFinal = this.is$Final(); 958 isSynthetic_value = numModifier("synthetic") != 0; 959 if (isFinal && num == state().boundariesCrossed) { 960 isSynthetic_computed = true; 961 } else { 962 } 963 state.INTERMEDIATE_VALUE |= intermediate; 964 965 return isSynthetic_value; 966 } 967 /** 968 * @attribute syn 969 * @aspect Modifiers 970 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:445 971 */ 972 @ASTNodeAnnotation.Attribute 973 public int numProtectionModifiers() { 974 int numProtectionModifiers_value = numModifier("public") + numModifier("protected") + numModifier("private"); 975 976 return numProtectionModifiers_value; 977 } 978 /** 979 * @attribute syn 980 * @aspect Modifiers 981 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:448 982 */ 983 @ASTNodeAnnotation.Attribute 984 public int numCompletenessModifiers() { 985 int numCompletenessModifiers_value = numModifier("abstract") + numModifier("final") + numModifier("volatile"); 986 987 return numCompletenessModifiers_value; 988 } 989 /** 990 * @apilevel internal 991 */ 992 protected java.util.Map numModifier_String_values; 993 /** 994 * @apilevel internal 995 */ 996 private void numModifier_String_reset() { 997 numModifier_String_values = null; 998 } 999 /** 1000 * @attribute syn 1001 * @aspect Modifiers 1002 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:451 1003 */ 1004 @ASTNodeAnnotation.Attribute 1005 public int numModifier(String name) { 1006 Object _parameters = name; 1007 if (numModifier_String_values == null) numModifier_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1008 ASTNode$State state = state(); 1009 if (numModifier_String_values.containsKey(_parameters)) { 1010 return (Integer) numModifier_String_values.get(_parameters); 1011 } 1012 boolean intermediate = state.INTERMEDIATE_VALUE; 1013 state.INTERMEDIATE_VALUE = false; 1014 int num = state.boundariesCrossed; 1015 boolean isFinal = this.is$Final(); 1016 int numModifier_String_value = numModifier_compute(name); 1017 if (isFinal && num == state().boundariesCrossed) { 1018 numModifier_String_values.put(_parameters, numModifier_String_value); 1019 } else { 1020 } 1021 state.INTERMEDIATE_VALUE |= intermediate; 1022 1023 return numModifier_String_value; 1024 } 1025 /** 1026 * @apilevel internal 1027 */ 1028 private int numModifier_compute(String name) { 1029 int n = 0; 1030 for (int i = 0; i < getNumModifier(); i++) { 1031 String s = getModifier(i).getID(); 1032 if (s.equals(name)) { 1033 n++; 1034 } 1035 } 1036 return n; 1037 } 1038 /** 1039 * @attribute syn 1040 * @aspect Annotations 1041 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:264 1042 */ 1043 @ASTNodeAnnotation.Attribute 1044 public Annotation annotation(TypeDecl typeDecl) { 1045 { 1046 for (int i = 0; i < getNumModifier(); i++) { 1047 if (getModifier(i) instanceof Annotation) { 1048 Annotation a = (Annotation) getModifier(i); 1049 if (a.type() == typeDecl) { 1050 return a; 1051 } 1052 } 1053 } 1054 return null; 1055 } 1056 } 1057 /** 1058 * @attribute syn 1059 * @aspect Annotations 1060 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:276 1061 */ 1062 @ASTNodeAnnotation.Attribute 1063 public boolean hasAnnotation(String packageName, String name) { 1064 { 1065 for (int i = 0; i < getNumModifier(); i++) { 1066 if (getModifier(i).isAnnotation(packageName, name)) { 1067 return true; 1068 } 1069 } 1070 return false; 1071 } 1072 } 1073 /** 1074 * @attribute syn 1075 * @aspect Annotations 1076 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:362 1077 */ 1078 @ASTNodeAnnotation.Attribute 1079 public boolean hasAnnotationSuppressWarnings(String annot) { 1080 { 1081 Annotation a = annotation(lookupType("java.lang", "SuppressWarnings")); 1082 if (a != null && a.getNumElementValuePair() == 1 1083 && a.getElementValuePair(0).getName().equals("value")) { 1084 return a.getElementValuePair(0).getElementValue().hasValue(annot); 1085 } 1086 return false; 1087 } 1088 } 1089 /** 1090 * @attribute syn 1091 * @aspect Annotations 1092 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:395 1093 */ 1094 @ASTNodeAnnotation.Attribute 1095 public boolean hasDeprecatedAnnotation() { 1096 boolean hasDeprecatedAnnotation_value = hasAnnotation("java.lang", "Deprecated"); 1097 1098 return hasDeprecatedAnnotation_value; 1099 } 1100 /** 1101 * @return true if the modifier list includes the SafeVarargs annotation 1102 * @attribute syn 1103 * @aspect SafeVarargs 1104 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:67 1105 */ 1106 @ASTNodeAnnotation.Attribute 1107 public boolean hasAnnotationSafeVarargs() { 1108 boolean hasAnnotationSafeVarargs_value = hasAnnotation("java.lang", "SafeVarargs"); 1109 1110 return hasAnnotationSafeVarargs_value; 1111 } 1112 /** 1113 * @attribute syn 1114 * @aspect Annotations 1115 * @declaredat /home/jesper/git/extendj/java8/frontend/Annotations.jrag:46 1116 */ 1117 @ASTNodeAnnotation.Attribute 1118 public boolean hasAnnotationFunctionalInterface() { 1119 boolean hasAnnotationFunctionalInterface_value = hasAnnotation("java.lang", "FunctionalInterface"); 1120 1121 return hasAnnotationFunctionalInterface_value; 1122 } 1123 /** 1124 * @apilevel internal 1125 */ 1126 protected boolean isDefault_computed = false; 1127 /** 1128 * @apilevel internal 1129 */ 1130 protected boolean isDefault_value; 1131 /** 1132 * @apilevel internal 1133 */ 1134 private void isDefault_reset() { 1135 isDefault_computed = false; 1136 } 1137 /** 1138 * @attribute syn 1139 * @aspect Modifiers 1140 * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:29 1141 */ 1142 @ASTNodeAnnotation.Attribute 1143 public boolean isDefault() { 1144 ASTNode$State state = state(); 1145 if (isDefault_computed) { 1146 return isDefault_value; 1147 } 1148 boolean intermediate = state.INTERMEDIATE_VALUE; 1149 state.INTERMEDIATE_VALUE = false; 1150 int num = state.boundariesCrossed; 1151 boolean isFinal = this.is$Final(); 1152 isDefault_value = numModifier("default") != 0; 1153 if (isFinal && num == state().boundariesCrossed) { 1154 isDefault_computed = true; 1155 } else { 1156 } 1157 state.INTERMEDIATE_VALUE |= intermediate; 1158 1159 return isDefault_value; 1160 } 1161 /** 1162 * @attribute inh 1163 * @aspect Modifiers 1164 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:417 1165 */ 1166 /** 1167 * @attribute inh 1168 * @aspect Modifiers 1169 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:417 1170 */ 1171 @ASTNodeAnnotation.Attribute 1172 public TypeDecl hostType() { 1173 TypeDecl hostType_value = getParent().Define_hostType(this, null); 1174 1175 return hostType_value; 1176 } 1177 /** 1178 * @attribute inh 1179 * @aspect Modifiers 1180 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419 1181 */ 1182 /** 1183 * @attribute inh 1184 * @aspect Modifiers 1185 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419 1186 */ 1187 @ASTNodeAnnotation.Attribute 1188 public boolean mayBePublic() { 1189 boolean mayBePublic_value = getParent().Define_mayBePublic(this, null); 1190 1191 return mayBePublic_value; 1192 } 1193 /** 1194 * @attribute inh 1195 * @aspect Modifiers 1196 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420 1197 */ 1198 /** 1199 * @attribute inh 1200 * @aspect Modifiers 1201 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420 1202 */ 1203 @ASTNodeAnnotation.Attribute 1204 public boolean mayBePrivate() { 1205 boolean mayBePrivate_value = getParent().Define_mayBePrivate(this, null); 1206 1207 return mayBePrivate_value; 1208 } 1209 /** 1210 * @attribute inh 1211 * @aspect Modifiers 1212 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421 1213 */ 1214 /** 1215 * @attribute inh 1216 * @aspect Modifiers 1217 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421 1218 */ 1219 @ASTNodeAnnotation.Attribute 1220 public boolean mayBeProtected() { 1221 boolean mayBeProtected_value = getParent().Define_mayBeProtected(this, null); 1222 1223 return mayBeProtected_value; 1224 } 1225 /** 1226 * @attribute inh 1227 * @aspect Modifiers 1228 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422 1229 */ 1230 /** 1231 * @attribute inh 1232 * @aspect Modifiers 1233 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422 1234 */ 1235 @ASTNodeAnnotation.Attribute 1236 public boolean mayBeStatic() { 1237 boolean mayBeStatic_value = getParent().Define_mayBeStatic(this, null); 1238 1239 return mayBeStatic_value; 1240 } 1241 /** 1242 * @attribute inh 1243 * @aspect Modifiers 1244 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 1245 */ 1246 /** 1247 * @attribute inh 1248 * @aspect Modifiers 1249 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 1250 */ 1251 @ASTNodeAnnotation.Attribute 1252 public boolean mayBeFinal() { 1253 boolean mayBeFinal_value = getParent().Define_mayBeFinal(this, null); 1254 1255 return mayBeFinal_value; 1256 } 1257 /** 1258 * @attribute inh 1259 * @aspect Modifiers 1260 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:424 1261 */ 1262 /** 1263 * @attribute inh 1264 * @aspect Modifiers 1265 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:424 1266 */ 1267 @ASTNodeAnnotation.Attribute 1268 public boolean mayBeAbstract() { 1269 boolean mayBeAbstract_value = getParent().Define_mayBeAbstract(this, null); 1270 1271 return mayBeAbstract_value; 1272 } 1273 /** 1274 * @attribute inh 1275 * @aspect Modifiers 1276 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:425 1277 */ 1278 /** 1279 * @attribute inh 1280 * @aspect Modifiers 1281 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:425 1282 */ 1283 @ASTNodeAnnotation.Attribute 1284 public boolean mayBeVolatile() { 1285 boolean mayBeVolatile_value = getParent().Define_mayBeVolatile(this, null); 1286 1287 return mayBeVolatile_value; 1288 } 1289 /** 1290 * @attribute inh 1291 * @aspect Modifiers 1292 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:426 1293 */ 1294 /** 1295 * @attribute inh 1296 * @aspect Modifiers 1297 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:426 1298 */ 1299 @ASTNodeAnnotation.Attribute 1300 public boolean mayBeTransient() { 1301 boolean mayBeTransient_value = getParent().Define_mayBeTransient(this, null); 1302 1303 return mayBeTransient_value; 1304 } 1305 /** 1306 * @attribute inh 1307 * @aspect Modifiers 1308 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:427 1309 */ 1310 /** 1311 * @attribute inh 1312 * @aspect Modifiers 1313 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:427 1314 */ 1315 @ASTNodeAnnotation.Attribute 1316 public boolean mayBeStrictfp() { 1317 boolean mayBeStrictfp_value = getParent().Define_mayBeStrictfp(this, null); 1318 1319 return mayBeStrictfp_value; 1320 } 1321 /** 1322 * @attribute inh 1323 * @aspect Modifiers 1324 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:428 1325 */ 1326 /** 1327 * @attribute inh 1328 * @aspect Modifiers 1329 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:428 1330 */ 1331 @ASTNodeAnnotation.Attribute 1332 public boolean mayBeSynchronized() { 1333 boolean mayBeSynchronized_value = getParent().Define_mayBeSynchronized(this, null); 1334 1335 return mayBeSynchronized_value; 1336 } 1337 /** 1338 * @attribute inh 1339 * @aspect Modifiers 1340 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:429 1341 */ 1342 /** 1343 * @attribute inh 1344 * @aspect Modifiers 1345 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:429 1346 */ 1347 @ASTNodeAnnotation.Attribute 1348 public boolean mayBeNative() { 1349 boolean mayBeNative_value = getParent().Define_mayBeNative(this, null); 1350 1351 return mayBeNative_value; 1352 } 1353 /** 1354 * @attribute inh 1355 * @aspect Annotations 1356 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:79 1357 */ 1358 /** 1359 * @attribute inh 1360 * @aspect Annotations 1361 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:79 1362 */ 1363 @ASTNodeAnnotation.Attribute 1364 public TypeDecl lookupType(String packageName, String typeName) { 1365 TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName); 1366 1367 return lookupType_String_String_value; 1368 } 1369 /** 1370 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:504 1371 * @apilevel internal 1372 */ 1373 public Annotation Define_lookupAnnotation(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 1374 if (caller == getModifierListNoTransform()) { 1375 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:505 1376 int index = caller.getIndexOfChild(child); 1377 { 1378 return annotation(typeDecl); 1379 } 1380 } 1381 else { 1382 return getParent().Define_lookupAnnotation(this, caller, typeDecl); 1383 } 1384 } 1385 protected boolean canDefine_lookupAnnotation(ASTNode caller, ASTNode child, TypeDecl typeDecl) { 1386 return true; 1387 } 1388 /** 1389 * @apilevel internal 1390 */ 1391 public ASTNode rewriteTo() { 1392 return super.rewriteTo(); 1393 } 1394 }