001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2017 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018//////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle.api; 021 022import com.puppycrawl.tools.checkstyle.grammars.GeneratedJavaTokenTypes; 023 024/** 025 * Contains the constants for all the tokens contained in the Abstract 026 * Syntax Tree. 027 * 028 * <p>Implementation detail: This class has been introduced to break 029 * the circular dependency between packages.</p> 030 * 031 * @author Oliver Burn 032 * @author <a href="mailto:dobratzp@ele.uri.edu">Peter Dobratz</a> 033 * @noinspection JavaDoc 034 */ 035public final class TokenTypes { 036 // The following three types are never part of an AST, 037 // left here as a reminder so nobody will read them accidentally 038 039 // These are the types that can actually occur in an AST 040 // it makes sense to register Checks for these types 041 042 /** 043 * The end of file token. This is the root node for the source 044 * file. It's children are an optional package definition, zero 045 * or more import statements, and one or more class or interface 046 * definitions. 047 * 048 * @see #PACKAGE_DEF 049 * @see #IMPORT 050 * @see #CLASS_DEF 051 * @see #INTERFACE_DEF 052 **/ 053 public static final int EOF = GeneratedJavaTokenTypes.EOF; 054 /** 055 * Modifiers for type, method, and field declarations. The 056 * modifiers element is always present even though it may have no 057 * children. 058 * 059 * @see <a 060 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 061 * Language Specification, §8</a> 062 * @see #LITERAL_PUBLIC 063 * @see #LITERAL_PROTECTED 064 * @see #LITERAL_PRIVATE 065 * @see #ABSTRACT 066 * @see #LITERAL_STATIC 067 * @see #FINAL 068 * @see #LITERAL_TRANSIENT 069 * @see #LITERAL_VOLATILE 070 * @see #LITERAL_SYNCHRONIZED 071 * @see #LITERAL_NATIVE 072 * @see #STRICTFP 073 * @see #ANNOTATION 074 * @see #LITERAL_DEFAULT 075 **/ 076 public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS; 077 078 /** 079 * An object block. These are children of class, interface, enum, 080 * annotation and enum constant declarations. 081 * Also, object blocks are children of the new keyword when defining 082 * anonymous inner types. 083 * 084 * @see #LCURLY 085 * @see #INSTANCE_INIT 086 * @see #STATIC_INIT 087 * @see #CLASS_DEF 088 * @see #CTOR_DEF 089 * @see #METHOD_DEF 090 * @see #VARIABLE_DEF 091 * @see #RCURLY 092 * @see #INTERFACE_DEF 093 * @see #LITERAL_NEW 094 * @see #ENUM_DEF 095 * @see #ENUM_CONSTANT_DEF 096 * @see #ANNOTATION_DEF 097 **/ 098 public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK; 099 /** 100 * A list of statements. 101 * 102 * @see #RCURLY 103 * @see #EXPR 104 * @see #LABELED_STAT 105 * @see #LITERAL_THROWS 106 * @see #LITERAL_RETURN 107 * @see #SEMI 108 * @see #METHOD_DEF 109 * @see #CTOR_DEF 110 * @see #LITERAL_FOR 111 * @see #LITERAL_WHILE 112 * @see #LITERAL_IF 113 * @see #LITERAL_ELSE 114 * @see #CASE_GROUP 115 **/ 116 public static final int SLIST = GeneratedJavaTokenTypes.SLIST; 117 /** 118 * A constructor declaration. 119 * 120 * <p>For example:</p> 121 * <pre> 122 * public SpecialEntry(int value, String text) 123 * { 124 * this.value = value; 125 * this.text = text; 126 * } 127 * </pre> 128 * <p>parses as:</p> 129 * <pre> 130 * +--CTOR_DEF 131 * | 132 * +--MODIFIERS 133 * | 134 * +--LITERAL_PUBLIC (public) 135 * +--IDENT (SpecialEntry) 136 * +--LPAREN (() 137 * +--PARAMETERS 138 * | 139 * +--PARAMETER_DEF 140 * | 141 * +--MODIFIERS 142 * +--TYPE 143 * | 144 * +--LITERAL_INT (int) 145 * +--IDENT (value) 146 * +--COMMA (,) 147 * +--PARAMETER_DEF 148 * | 149 * +--MODIFIERS 150 * +--TYPE 151 * | 152 * +--IDENT (String) 153 * +--IDENT (text) 154 * +--RPAREN ()) 155 * +--SLIST ({) 156 * | 157 * +--EXPR 158 * | 159 * +--ASSIGN (=) 160 * | 161 * +--DOT (.) 162 * | 163 * +--LITERAL_THIS (this) 164 * +--IDENT (value) 165 * +--IDENT (value) 166 * +--SEMI (;) 167 * +--EXPR 168 * | 169 * +--ASSIGN (=) 170 * | 171 * +--DOT (.) 172 * | 173 * +--LITERAL_THIS (this) 174 * +--IDENT (text) 175 * +--IDENT (text) 176 * +--SEMI (;) 177 * +--RCURLY (}) 178 * </pre> 179 * 180 * @see #OBJBLOCK 181 * @see #CLASS_DEF 182 **/ 183 public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF; 184 /** 185 * A method declaration. The children are modifiers, type parameters, 186 * return type, method name, parameter list, an optional throws list, and 187 * statement list. The statement list is omitted if the method 188 * declaration appears in an interface declaration. Method 189 * declarations may appear inside object blocks of class 190 * declarations, interface declarations, enum declarations, 191 * enum constant declarations or anonymous inner-class declarations. 192 * 193 * <p>For example:</p> 194 * 195 * <pre> 196 * public static int square(int x) 197 * { 198 * return x*x; 199 * } 200 * </pre> 201 * 202 * <p>parses as:</p> 203 * 204 * <pre> 205 * +--METHOD_DEF 206 * | 207 * +--MODIFIERS 208 * | 209 * +--LITERAL_PUBLIC (public) 210 * +--LITERAL_STATIC (static) 211 * +--TYPE 212 * | 213 * +--LITERAL_INT (int) 214 * +--IDENT (square) 215 * +--PARAMETERS 216 * | 217 * +--PARAMETER_DEF 218 * | 219 * +--MODIFIERS 220 * +--TYPE 221 * | 222 * +--LITERAL_INT (int) 223 * +--IDENT (x) 224 * +--SLIST ({) 225 * | 226 * +--LITERAL_RETURN (return) 227 * | 228 * +--EXPR 229 * | 230 * +--STAR (*) 231 * | 232 * +--IDENT (x) 233 * +--IDENT (x) 234 * +--SEMI (;) 235 * +--RCURLY (}) 236 * </pre> 237 * 238 * @see #MODIFIERS 239 * @see #TYPE_PARAMETERS 240 * @see #TYPE 241 * @see #IDENT 242 * @see #PARAMETERS 243 * @see #LITERAL_THROWS 244 * @see #SLIST 245 * @see #OBJBLOCK 246 **/ 247 public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF; 248 /** 249 * A field or local variable declaration. The children are 250 * modifiers, type, the identifier name, and an optional 251 * assignment statement. 252 * 253 * @see #MODIFIERS 254 * @see #TYPE 255 * @see #IDENT 256 * @see #ASSIGN 257 **/ 258 public static final int VARIABLE_DEF = 259 GeneratedJavaTokenTypes.VARIABLE_DEF; 260 261 /** 262 * An instance initializer. Zero or more instance initializers 263 * may appear in class and enum definitions. This token will be a child 264 * of the object block of the declaring type. 265 * 266 * @see <a 267 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java 268 * Language Specification§8.6</a> 269 * @see #SLIST 270 * @see #OBJBLOCK 271 **/ 272 public static final int INSTANCE_INIT = 273 GeneratedJavaTokenTypes.INSTANCE_INIT; 274 275 /** 276 * A static initialization block. Zero or more static 277 * initializers may be children of the object block of a class 278 * or enum declaration (interfaces cannot have static initializers). The 279 * first and only child is a statement list. 280 * 281 * @see <a 282 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java 283 * Language Specification, §8.7</a> 284 * @see #SLIST 285 * @see #OBJBLOCK 286 **/ 287 public static final int STATIC_INIT = 288 GeneratedJavaTokenTypes.STATIC_INIT; 289 290 /** 291 * A type. This is either a return type of a method or a type of 292 * a variable or field. The first child of this element is the 293 * actual type. This may be a primitive type, an identifier, a 294 * dot which is the root of a fully qualified type, or an array of 295 * any of these. The second child may be type arguments to the type. 296 * 297 * @see #VARIABLE_DEF 298 * @see #METHOD_DEF 299 * @see #PARAMETER_DEF 300 * @see #IDENT 301 * @see #DOT 302 * @see #LITERAL_VOID 303 * @see #LITERAL_BOOLEAN 304 * @see #LITERAL_BYTE 305 * @see #LITERAL_CHAR 306 * @see #LITERAL_SHORT 307 * @see #LITERAL_INT 308 * @see #LITERAL_FLOAT 309 * @see #LITERAL_LONG 310 * @see #LITERAL_DOUBLE 311 * @see #ARRAY_DECLARATOR 312 * @see #TYPE_ARGUMENTS 313 **/ 314 public static final int TYPE = GeneratedJavaTokenTypes.TYPE; 315 /** 316 * A class declaration. 317 * 318 * <p>For example:</p> 319 * <pre> 320 * public class MyClass 321 * implements Serializable 322 * { 323 * } 324 * </pre> 325 * <p>parses as:</p> 326 * <pre> 327 * +--CLASS_DEF 328 * | 329 * +--MODIFIERS 330 * | 331 * +--LITERAL_PUBLIC (public) 332 * +--LITERAL_CLASS (class) 333 * +--IDENT (MyClass) 334 * +--EXTENDS_CLAUSE 335 * +--IMPLEMENTS_CLAUSE 336 * | 337 * +--IDENT (Serializable) 338 * +--OBJBLOCK 339 * | 340 * +--LCURLY ({) 341 * +--RCURLY (}) 342 * </pre> 343 * 344 * @see <a 345 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 346 * Language Specification, §8</a> 347 * @see #MODIFIERS 348 * @see #IDENT 349 * @see #EXTENDS_CLAUSE 350 * @see #IMPLEMENTS_CLAUSE 351 * @see #OBJBLOCK 352 * @see #LITERAL_NEW 353 **/ 354 public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF; 355 /** 356 * An interface declaration. 357 * 358 * <p>For example:</p> 359 * 360 * <pre> 361 * public interface MyInterface 362 * { 363 * } 364 * 365 * </pre> 366 * 367 * <p>parses as:</p> 368 * 369 * <pre> 370 * +--INTERFACE_DEF 371 * | 372 * +--MODIFIERS 373 * | 374 * +--LITERAL_PUBLIC (public) 375 * +--LITERAL_INTERFACE (interface) 376 * +--IDENT (MyInterface) 377 * +--EXTENDS_CLAUSE 378 * +--OBJBLOCK 379 * | 380 * +--LCURLY ({) 381 * +--RCURLY (}) 382 * </pre> 383 * 384 * @see <a 385 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java 386 * Language Specification, §9</a> 387 * @see #MODIFIERS 388 * @see #IDENT 389 * @see #EXTENDS_CLAUSE 390 * @see #OBJBLOCK 391 **/ 392 public static final int INTERFACE_DEF = 393 GeneratedJavaTokenTypes.INTERFACE_DEF; 394 395 /** 396 * The package declaration. This is optional, but if it is 397 * included, then there is only one package declaration per source 398 * file and it must be the first non-comment in the file. A package 399 * declaration may be annotated in which case the annotations comes 400 * before the rest of the declaration (and are the first children). 401 * 402 * <p>For example:</p> 403 * 404 * <pre> 405 * package com.puppycrawl.tools.checkstyle.api; 406 * </pre> 407 * 408 * <p>parses as:</p> 409 * 410 * <pre> 411 * +--PACKAGE_DEF (package) 412 * | 413 * +--ANNOTATIONS 414 * +--DOT (.) 415 * | 416 * +--DOT (.) 417 * | 418 * +--DOT (.) 419 * | 420 * +--DOT (.) 421 * | 422 * +--IDENT (com) 423 * +--IDENT (puppycrawl) 424 * +--IDENT (tools) 425 * +--IDENT (checkstyle) 426 * +--IDENT (api) 427 * +--SEMI (;) 428 * </pre> 429 * 430 * @see <a 431 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java 432 * Language Specification §7.4</a> 433 * @see #DOT 434 * @see #IDENT 435 * @see #SEMI 436 * @see #ANNOTATIONS 437 * @see FullIdent 438 **/ 439 public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF; 440 /** 441 * An array declaration. 442 * 443 * <p>If the array declaration represents a type, then the type of 444 * the array elements is the first child. Multidimensional arrays 445 * may be regarded as arrays of arrays. In other words, the first 446 * child of the array declaration is another array 447 * declaration.</p> 448 * 449 * <p>For example:</p> 450 * <pre> 451 * int[] x; 452 * </pre> 453 * <p>parses as:</p> 454 * <pre> 455 * +--VARIABLE_DEF 456 * | 457 * +--MODIFIERS 458 * +--TYPE 459 * | 460 * +--ARRAY_DECLARATOR ([) 461 * | 462 * +--LITERAL_INT (int) 463 * +--IDENT (x) 464 * +--SEMI (;) 465 * </pre> 466 * 467 * <p>The array declaration may also represent an inline array 468 * definition. In this case, the first child will be either an 469 * expression specifying the length of the array or an array 470 * initialization block.</p> 471 * 472 * @see <a 473 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java 474 * Language Specification §10</a> 475 * @see #TYPE 476 * @see #ARRAY_INIT 477 **/ 478 public static final int ARRAY_DECLARATOR = 479 GeneratedJavaTokenTypes.ARRAY_DECLARATOR; 480 481 /** 482 * An extends clause. This appear as part of class and interface 483 * definitions. This element appears even if the 484 * <code>extends</code> keyword is not explicitly used. The child 485 * is an optional identifier. 486 * 487 * <p>For example:</p> 488 * 489 * <pre> 490 * extends java.util.LinkedList 491 * </pre> 492 * 493 * <p>parses as:</p> 494 * <pre> 495 * +--EXTENDS_CLAUSE 496 * | 497 * +--DOT (.) 498 * | 499 * +--DOT (.) 500 * | 501 * +--IDENT (java) 502 * +--IDENT (util) 503 * +--IDENT (LinkedList) 504 * </pre> 505 * 506 * @see #IDENT 507 * @see #DOT 508 * @see #CLASS_DEF 509 * @see #INTERFACE_DEF 510 * @see FullIdent 511 **/ 512 public static final int EXTENDS_CLAUSE = 513 GeneratedJavaTokenTypes.EXTENDS_CLAUSE; 514 515 /** 516 * An implements clause. This always appears in a class or enum 517 * declaration, even if there are no implemented interfaces. The 518 * children are a comma separated list of zero or more 519 * identifiers. 520 * 521 * <p>For example:</p> 522 * <pre> 523 * implements Serializable, Comparable 524 * </pre> 525 * <p>parses as:</p> 526 * <pre> 527 * +--IMPLEMENTS_CLAUSE 528 * | 529 * +--IDENT (Serializable) 530 * +--COMMA (,) 531 * +--IDENT (Comparable) 532 * </pre> 533 * 534 * @see #IDENT 535 * @see #DOT 536 * @see #COMMA 537 * @see #CLASS_DEF 538 * @see #ENUM_DEF 539 **/ 540 public static final int IMPLEMENTS_CLAUSE = 541 GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE; 542 543 /** 544 * A list of parameters to a method or constructor. The children 545 * are zero or more parameter declarations separated by commas. 546 * 547 * <p>For example</p> 548 * <pre> 549 * int start, int end 550 * </pre> 551 * <p>parses as:</p> 552 * <pre> 553 * +--PARAMETERS 554 * | 555 * +--PARAMETER_DEF 556 * | 557 * +--MODIFIERS 558 * +--TYPE 559 * | 560 * +--LITERAL_INT (int) 561 * +--IDENT (start) 562 * +--COMMA (,) 563 * +--PARAMETER_DEF 564 * | 565 * +--MODIFIERS 566 * +--TYPE 567 * | 568 * +--LITERAL_INT (int) 569 * +--IDENT (end) 570 * </pre> 571 * 572 * @see #PARAMETER_DEF 573 * @see #COMMA 574 * @see #METHOD_DEF 575 * @see #CTOR_DEF 576 **/ 577 public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS; 578 /** 579 * A parameter declaration. The last parameter in a list of parameters may 580 * be variable length (indicated by the ELLIPSIS child node immediately 581 * after the TYPE child). 582 * 583 * @see #MODIFIERS 584 * @see #TYPE 585 * @see #IDENT 586 * @see #PARAMETERS 587 * @see #ELLIPSIS 588 **/ 589 public static final int PARAMETER_DEF = 590 GeneratedJavaTokenTypes.PARAMETER_DEF; 591 592 /** 593 * A labeled statement. 594 * 595 * <p>For example:</p> 596 * <pre> 597 * outside: ; 598 * </pre> 599 * <p>parses as:</p> 600 * <pre> 601 * +--LABELED_STAT (:) 602 * | 603 * +--IDENT (outside) 604 * +--EMPTY_STAT (;) 605 * </pre> 606 * 607 * @see <a 608 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java 609 * Language Specification, §14.7</a> 610 * @see #SLIST 611 **/ 612 public static final int LABELED_STAT = 613 GeneratedJavaTokenTypes.LABELED_STAT; 614 615 /** 616 * A type-cast. 617 * 618 * <p>For example:</p> 619 * <pre> 620 * (String)it.next() 621 * </pre> 622 * <p>parses as:</p> 623 * <pre> 624 * +--TYPECAST (() 625 * | 626 * +--TYPE 627 * | 628 * +--IDENT (String) 629 * +--RPAREN ()) 630 * +--METHOD_CALL (() 631 * | 632 * +--DOT (.) 633 * | 634 * +--IDENT (it) 635 * +--IDENT (next) 636 * +--ELIST 637 * +--RPAREN ()) 638 * </pre> 639 * @see <a 640 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java 641 * Language Specification, §15.16</a> 642 * @see #EXPR 643 * @see #TYPE 644 * @see #TYPE_ARGUMENTS 645 * @see #RPAREN 646 **/ 647 public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST; 648 /** 649 * The array index operator. 650 * 651 * <p>For example:</p> 652 * <pre> 653 * ar[2] = 5; 654 * </pre> 655 * <p>parses as:</p> 656 * <pre> 657 * +--EXPR 658 * | 659 * +--ASSIGN (=) 660 * | 661 * +--INDEX_OP ([) 662 * | 663 * +--IDENT (ar) 664 * +--EXPR 665 * | 666 * +--NUM_INT (2) 667 * +--NUM_INT (5) 668 * +--SEMI (;) 669 * </pre> 670 * 671 * @see #EXPR 672 **/ 673 public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP; 674 /** 675 * The <code>++</code> (postfix increment) operator. 676 * 677 * @see <a 678 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java 679 * Language Specification, §15.14.1</a> 680 * @see #EXPR 681 * @see #INC 682 **/ 683 public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC; 684 /** 685 * The <code>--</code> (postfix decrement) operator. 686 * 687 * @see <a 688 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java 689 * Language Specification, §15.14.2</a> 690 * @see #EXPR 691 * @see #DEC 692 **/ 693 public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC; 694 /** 695 * A method call. A method call may have type arguments however these 696 * are attached to the appropriate node in the qualified method name. 697 * 698 * <p>For example:</p> 699 * <pre> 700 * Math.random() 701 * </pre> 702 * 703 * <p>parses as: 704 * <pre> 705 * +--METHOD_CALL (() 706 * | 707 * +--DOT (.) 708 * | 709 * +--IDENT (Math) 710 * +--IDENT (random) 711 * +--ELIST 712 * +--RPAREN ()) 713 * </pre> 714 * 715 * 716 * @see #IDENT 717 * @see #TYPE_ARGUMENTS 718 * @see #DOT 719 * @see #ELIST 720 * @see #RPAREN 721 * @see FullIdent 722 **/ 723 public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL; 724 725 /** 726 * Part of Java 8 syntax. Method or constructor call without arguments. 727 * @see #DOUBLE_COLON 728 */ 729 public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF; 730 /** 731 * An expression. Operators with lower precedence appear at a 732 * higher level in the tree than operators with higher precedence. 733 * Parentheses are siblings to the operator they enclose. 734 * 735 * <p>For example:</p> 736 * <pre> 737 * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3); 738 * </pre> 739 * <p>parses as:</p> 740 * <pre> 741 * +--EXPR 742 * | 743 * +--ASSIGN (=) 744 * | 745 * +--IDENT (x) 746 * +--PLUS (+) 747 * | 748 * +--PLUS (+) 749 * | 750 * +--PLUS (+) 751 * | 752 * +--PLUS (+) 753 * | 754 * +--NUM_INT (4) 755 * +--STAR (*) 756 * | 757 * +--NUM_INT (3) 758 * +--NUM_INT (5) 759 * +--DIV (/) 760 * | 761 * +--LPAREN (() 762 * +--PLUS (+) 763 * | 764 * +--NUM_INT (30) 765 * +--NUM_INT (26) 766 * +--RPAREN ()) 767 * +--NUM_INT (4) 768 * +--MOD (%) 769 * | 770 * +--NUM_INT (5) 771 * +--NUM_INT (4) 772 * +--LPAREN (() 773 * +--SL (<<) 774 * | 775 * +--NUM_INT (1) 776 * +--NUM_INT (3) 777 * +--RPAREN ()) 778 * +--SEMI (;) 779 * </pre> 780 * 781 * @see #ELIST 782 * @see #ASSIGN 783 * @see #LPAREN 784 * @see #RPAREN 785 **/ 786 public static final int EXPR = GeneratedJavaTokenTypes.EXPR; 787 /** 788 * An array initialization. This may occur as part of an array 789 * declaration or inline with <code>new</code>. 790 * 791 * <p>For example:</p> 792 * <pre> 793 * int[] y = 794 * { 795 * 1, 796 * 2, 797 * }; 798 * </pre> 799 * <p>parses as:</p> 800 * <pre> 801 * +--VARIABLE_DEF 802 * | 803 * +--MODIFIERS 804 * +--TYPE 805 * | 806 * +--ARRAY_DECLARATOR ([) 807 * | 808 * +--LITERAL_INT (int) 809 * +--IDENT (y) 810 * +--ASSIGN (=) 811 * | 812 * +--ARRAY_INIT ({) 813 * | 814 * +--EXPR 815 * | 816 * +--NUM_INT (1) 817 * +--COMMA (,) 818 * +--EXPR 819 * | 820 * +--NUM_INT (2) 821 * +--COMMA (,) 822 * +--RCURLY (}) 823 * +--SEMI (;) 824 * </pre> 825 * 826 * <p>Also consider:</p> 827 * <pre> 828 * int[] z = new int[] 829 * { 830 * 1, 831 * 2, 832 * }; 833 * </pre> 834 * <p>which parses as:</p> 835 * <pre> 836 * +--VARIABLE_DEF 837 * | 838 * +--MODIFIERS 839 * +--TYPE 840 * | 841 * +--ARRAY_DECLARATOR ([) 842 * | 843 * +--LITERAL_INT (int) 844 * +--IDENT (z) 845 * +--ASSIGN (=) 846 * | 847 * +--EXPR 848 * | 849 * +--LITERAL_NEW (new) 850 * | 851 * +--LITERAL_INT (int) 852 * +--ARRAY_DECLARATOR ([) 853 * +--ARRAY_INIT ({) 854 * | 855 * +--EXPR 856 * | 857 * +--NUM_INT (1) 858 * +--COMMA (,) 859 * +--EXPR 860 * | 861 * +--NUM_INT (2) 862 * +--COMMA (,) 863 * +--RCURLY (}) 864 * </pre> 865 * 866 * @see #ARRAY_DECLARATOR 867 * @see #TYPE 868 * @see #LITERAL_NEW 869 * @see #COMMA 870 **/ 871 public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT; 872 /** 873 * An import declaration. Import declarations are option, but 874 * must appear after the package declaration and before the first type 875 * declaration. 876 * 877 * <p>For example:</p> 878 * 879 * <pre> 880 * import java.io.IOException; 881 * </pre> 882 * 883 * <p>parses as:</p> 884 * 885 * <pre> 886 * +--IMPORT (import) 887 * | 888 * +--DOT (.) 889 * | 890 * +--DOT (.) 891 * | 892 * +--IDENT (java) 893 * +--IDENT (io) 894 * +--IDENT (IOException) 895 * +--SEMI (;) 896 * </pre> 897 * 898 * @see <a 899 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java 900 * Language Specification §7.5</a> 901 * @see #DOT 902 * @see #IDENT 903 * @see #STAR 904 * @see #SEMI 905 * @see FullIdent 906 **/ 907 public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT; 908 /** 909 * The <code>-</code> (unary minus) operator. 910 * 911 * @see <a 912 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java 913 * Language Specification, §15.15.4</a> 914 * @see #EXPR 915 **/ 916 public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS; 917 /** 918 * The <code>+</code> (unary plus) operator. 919 * 920 * @see <a 921 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java 922 * Language Specification, §15.15.3</a> 923 * @see #EXPR 924 **/ 925 public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS; 926 /** 927 * A group of case clauses. Case clauses with no associated 928 * statements are grouped together into a case group. The last 929 * child is a statement list containing the statements to execute 930 * upon a match. 931 * 932 * <p>For example:</p> 933 * <pre> 934 * case 0: 935 * case 1: 936 * case 2: 937 * x = 3; 938 * break; 939 * </pre> 940 * <p>parses as:</p> 941 * <pre> 942 * +--CASE_GROUP 943 * | 944 * +--LITERAL_CASE (case) 945 * | 946 * +--EXPR 947 * | 948 * +--NUM_INT (0) 949 * +--LITERAL_CASE (case) 950 * | 951 * +--EXPR 952 * | 953 * +--NUM_INT (1) 954 * +--LITERAL_CASE (case) 955 * | 956 * +--EXPR 957 * | 958 * +--NUM_INT (2) 959 * +--SLIST 960 * | 961 * +--EXPR 962 * | 963 * +--ASSIGN (=) 964 * | 965 * +--IDENT (x) 966 * +--NUM_INT (3) 967 * +--SEMI (;) 968 * +--LITERAL_BREAK (break) 969 * | 970 * +--SEMI (;) 971 * </pre> 972 * 973 * @see #LITERAL_CASE 974 * @see #LITERAL_DEFAULT 975 * @see #LITERAL_SWITCH 976 **/ 977 public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP; 978 /** 979 * An expression list. The children are a comma separated list of 980 * expressions. 981 * 982 * @see #LITERAL_NEW 983 * @see #FOR_INIT 984 * @see #FOR_ITERATOR 985 * @see #EXPR 986 * @see #METHOD_CALL 987 * @see #CTOR_CALL 988 * @see #SUPER_CTOR_CALL 989 **/ 990 public static final int ELIST = GeneratedJavaTokenTypes.ELIST; 991 /** 992 * A for loop initializer. This is a child of 993 * <code>LITERAL_FOR</code>. The children of this element may be 994 * a comma separated list of variable declarations, an expression 995 * list, or empty. 996 * 997 * @see #VARIABLE_DEF 998 * @see #ELIST 999 * @see #LITERAL_FOR 1000 **/ 1001 public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT; 1002 /** 1003 * A for loop condition. This is a child of 1004 * <code>LITERAL_FOR</code>. The child of this element is an 1005 * optional expression. 1006 * 1007 * @see #EXPR 1008 * @see #LITERAL_FOR 1009 **/ 1010 public static final int FOR_CONDITION = 1011 GeneratedJavaTokenTypes.FOR_CONDITION; 1012 1013 /** 1014 * A for loop iterator. This is a child of 1015 * <code>LITERAL_FOR</code>. The child of this element is an 1016 * optional expression list. 1017 * 1018 * @see #ELIST 1019 * @see #LITERAL_FOR 1020 **/ 1021 public static final int FOR_ITERATOR = 1022 GeneratedJavaTokenTypes.FOR_ITERATOR; 1023 1024 /** 1025 * The empty statement. This goes in place of an 1026 * <code>SLIST</code> for a <code>for</code> or <code>while</code> 1027 * loop body. 1028 * 1029 * @see <a 1030 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java 1031 * Language Specification, §14.6</a> 1032 * @see #LITERAL_FOR 1033 * @see #LITERAL_WHILE 1034 **/ 1035 public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT; 1036 /** 1037 * The <code>final</code> keyword. 1038 * 1039 * @see #MODIFIERS 1040 **/ 1041 public static final int FINAL = GeneratedJavaTokenTypes.FINAL; 1042 /** 1043 * The <code>abstract</code> keyword. 1044 * 1045 * @see #MODIFIERS 1046 **/ 1047 public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT; 1048 /** 1049 * The <code>strictfp</code> keyword. 1050 * 1051 * @see #MODIFIERS 1052 **/ 1053 public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP; 1054 /** 1055 * A super constructor call. 1056 * 1057 * @see #ELIST 1058 * @see #RPAREN 1059 * @see #SEMI 1060 * @see #CTOR_CALL 1061 **/ 1062 public static final int SUPER_CTOR_CALL = 1063 GeneratedJavaTokenTypes.SUPER_CTOR_CALL; 1064 1065 /** 1066 * A constructor call. 1067 * 1068 * <p>For example:</p> 1069 * <pre> 1070 * this(1); 1071 * </pre> 1072 * <p>parses as:</p> 1073 * <pre> 1074 * +--CTOR_CALL (this) 1075 * | 1076 * +--LPAREN (() 1077 * +--ELIST 1078 * | 1079 * +--EXPR 1080 * | 1081 * +--NUM_INT (1) 1082 * +--RPAREN ()) 1083 * +--SEMI (;) 1084 * </pre> 1085 * 1086 * @see #ELIST 1087 * @see #RPAREN 1088 * @see #SEMI 1089 * @see #SUPER_CTOR_CALL 1090 **/ 1091 public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL; 1092 1093 /** 1094 * The statement terminator (<code>;</code>). Depending on the 1095 * context, this make occur as a sibling, a child, or not at all. 1096 * 1097 * @see #PACKAGE_DEF 1098 * @see #IMPORT 1099 * @see #SLIST 1100 * @see #ARRAY_INIT 1101 * @see #LITERAL_FOR 1102 **/ 1103 public static final int SEMI = GeneratedJavaTokenTypes.SEMI; 1104 1105 /** 1106 * The <code>]</code> symbol. 1107 * 1108 * @see #INDEX_OP 1109 * @see #ARRAY_DECLARATOR 1110 **/ 1111 public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK; 1112 /** 1113 * The <code>void</code> keyword. 1114 * 1115 * @see #TYPE 1116 **/ 1117 public static final int LITERAL_VOID = 1118 GeneratedJavaTokenTypes.LITERAL_void; 1119 1120 /** 1121 * The <code>boolean</code> keyword. 1122 * 1123 * @see #TYPE 1124 **/ 1125 public static final int LITERAL_BOOLEAN = 1126 GeneratedJavaTokenTypes.LITERAL_boolean; 1127 1128 /** 1129 * The <code>byte</code> keyword. 1130 * 1131 * @see #TYPE 1132 **/ 1133 public static final int LITERAL_BYTE = 1134 GeneratedJavaTokenTypes.LITERAL_byte; 1135 1136 /** 1137 * The <code>char</code> keyword. 1138 * 1139 * @see #TYPE 1140 **/ 1141 public static final int LITERAL_CHAR = 1142 GeneratedJavaTokenTypes.LITERAL_char; 1143 1144 /** 1145 * The <code>short</code> keyword. 1146 * 1147 * @see #TYPE 1148 **/ 1149 public static final int LITERAL_SHORT = 1150 GeneratedJavaTokenTypes.LITERAL_short; 1151 1152 /** 1153 * The <code>int</code> keyword. 1154 * 1155 * @see #TYPE 1156 **/ 1157 public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int; 1158 /** 1159 * The <code>float</code> keyword. 1160 * 1161 * @see #TYPE 1162 **/ 1163 public static final int LITERAL_FLOAT = 1164 GeneratedJavaTokenTypes.LITERAL_float; 1165 1166 /** 1167 * The <code>long</code> keyword. 1168 * 1169 * @see #TYPE 1170 **/ 1171 public static final int LITERAL_LONG = 1172 GeneratedJavaTokenTypes.LITERAL_long; 1173 1174 /** 1175 * The <code>double</code> keyword. 1176 * 1177 * @see #TYPE 1178 **/ 1179 public static final int LITERAL_DOUBLE = 1180 GeneratedJavaTokenTypes.LITERAL_double; 1181 1182 /** 1183 * An identifier. These can be names of types, subpackages, 1184 * fields, methods, parameters, and local variables. 1185 **/ 1186 public static final int IDENT = GeneratedJavaTokenTypes.IDENT; 1187 /** 1188 * The <code>.</code> (dot) operator. 1189 * 1190 * @see FullIdent 1191 **/ 1192 public static final int DOT = GeneratedJavaTokenTypes.DOT; 1193 /** 1194 * The <code>*</code> (multiplication or wildcard) operator. 1195 * 1196 * @see <a 1197 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java 1198 * Language Specification, §7.5.2</a> 1199 * @see <a 1200 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java 1201 * Language Specification, §15.17.1</a> 1202 * @see #EXPR 1203 * @see #IMPORT 1204 **/ 1205 public static final int STAR = GeneratedJavaTokenTypes.STAR; 1206 /** 1207 * The <code>private</code> keyword. 1208 * 1209 * @see #MODIFIERS 1210 **/ 1211 public static final int LITERAL_PRIVATE = 1212 GeneratedJavaTokenTypes.LITERAL_private; 1213 1214 /** 1215 * The <code>public</code> keyword. 1216 * 1217 * @see #MODIFIERS 1218 **/ 1219 public static final int LITERAL_PUBLIC = 1220 GeneratedJavaTokenTypes.LITERAL_public; 1221 1222 /** 1223 * The <code>protected</code> keyword. 1224 * 1225 * @see #MODIFIERS 1226 **/ 1227 public static final int LITERAL_PROTECTED = 1228 GeneratedJavaTokenTypes.LITERAL_protected; 1229 1230 /** 1231 * The <code>static</code> keyword. 1232 * 1233 * @see #MODIFIERS 1234 **/ 1235 public static final int LITERAL_STATIC = 1236 GeneratedJavaTokenTypes.LITERAL_static; 1237 1238 /** 1239 * The <code>transient</code> keyword. 1240 * 1241 * @see #MODIFIERS 1242 **/ 1243 public static final int LITERAL_TRANSIENT = 1244 GeneratedJavaTokenTypes.LITERAL_transient; 1245 1246 /** 1247 * The <code>native</code> keyword. 1248 * 1249 * @see #MODIFIERS 1250 **/ 1251 public static final int LITERAL_NATIVE = 1252 GeneratedJavaTokenTypes.LITERAL_native; 1253 1254 /** 1255 * The <code>synchronized</code> keyword. This may be used as a 1256 * modifier of a method or in the definition of a synchronized 1257 * block. 1258 * 1259 * <p>For example:</p> 1260 * 1261 * <pre> 1262 * synchronized(this) 1263 * { 1264 * x++; 1265 * } 1266 * </pre> 1267 * 1268 * <p>parses as:</p> 1269 * 1270 * <pre> 1271 * +--LITERAL_SYNCHRONIZED (synchronized) 1272 * | 1273 * +--LPAREN (() 1274 * +--EXPR 1275 * | 1276 * +--LITERAL_THIS (this) 1277 * +--RPAREN ()) 1278 * +--SLIST ({) 1279 * | 1280 * +--EXPR 1281 * | 1282 * +--POST_INC (++) 1283 * | 1284 * +--IDENT (x) 1285 * +--SEMI (;) 1286 * +--RCURLY (}) 1287 * +--RCURLY (}) 1288 * </pre> 1289 * 1290 * @see #MODIFIERS 1291 * @see #LPAREN 1292 * @see #EXPR 1293 * @see #RPAREN 1294 * @see #SLIST 1295 * @see #RCURLY 1296 **/ 1297 public static final int LITERAL_SYNCHRONIZED = 1298 GeneratedJavaTokenTypes.LITERAL_synchronized; 1299 1300 /** 1301 * The <code>volatile</code> keyword. 1302 * 1303 * @see #MODIFIERS 1304 **/ 1305 public static final int LITERAL_VOLATILE = 1306 GeneratedJavaTokenTypes.LITERAL_volatile; 1307 1308 /** 1309 * The <code>class</code> keyword. This element appears both 1310 * as part of a class declaration, and inline to reference a 1311 * class object. 1312 * 1313 * <p>For example:</p> 1314 * 1315 * <pre> 1316 * int.class 1317 * </pre> 1318 * <p>parses as:</p> 1319 * <pre> 1320 * +--EXPR 1321 * | 1322 * +--DOT (.) 1323 * | 1324 * +--LITERAL_INT (int) 1325 * +--LITERAL_CLASS (class) 1326 * </pre> 1327 * 1328 * @see #DOT 1329 * @see #IDENT 1330 * @see #CLASS_DEF 1331 * @see FullIdent 1332 **/ 1333 public static final int LITERAL_CLASS = 1334 GeneratedJavaTokenTypes.LITERAL_class; 1335 1336 /** 1337 * The <code>interface</code> keyword. This token appears in 1338 * interface definition. 1339 * 1340 * @see #INTERFACE_DEF 1341 **/ 1342 public static final int LITERAL_INTERFACE = 1343 GeneratedJavaTokenTypes.LITERAL_interface; 1344 1345 /** 1346 * A left (curly) brace (<code>{</code>). 1347 * 1348 * @see #OBJBLOCK 1349 * @see #ARRAY_INIT 1350 * @see #SLIST 1351 **/ 1352 public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY; 1353 /** 1354 * A right (curly) brace (<code>}</code>). 1355 * 1356 * @see #OBJBLOCK 1357 * @see #ARRAY_INIT 1358 * @see #SLIST 1359 **/ 1360 public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY; 1361 /** 1362 * The <code>,</code> (comma) operator. 1363 * 1364 * @see #ARRAY_INIT 1365 * @see #FOR_INIT 1366 * @see #FOR_ITERATOR 1367 * @see #LITERAL_THROWS 1368 * @see #IMPLEMENTS_CLAUSE 1369 **/ 1370 public static final int COMMA = GeneratedJavaTokenTypes.COMMA; 1371 1372 /** 1373 * A left parenthesis (<code>(</code>). 1374 * 1375 * @see #LITERAL_FOR 1376 * @see #LITERAL_NEW 1377 * @see #EXPR 1378 * @see #LITERAL_SWITCH 1379 * @see #LITERAL_CATCH 1380 **/ 1381 public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN; 1382 /** 1383 * A right parenthesis (<code>)</code>). 1384 * 1385 * @see #LITERAL_FOR 1386 * @see #LITERAL_NEW 1387 * @see #METHOD_CALL 1388 * @see #TYPECAST 1389 * @see #EXPR 1390 * @see #LITERAL_SWITCH 1391 * @see #LITERAL_CATCH 1392 **/ 1393 public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN; 1394 /** 1395 * The <code>this</code> keyword. 1396 * 1397 * @see #EXPR 1398 * @see #CTOR_CALL 1399 **/ 1400 public static final int LITERAL_THIS = 1401 GeneratedJavaTokenTypes.LITERAL_this; 1402 1403 /** 1404 * The <code>super</code> keyword. 1405 * 1406 * @see #EXPR 1407 * @see #SUPER_CTOR_CALL 1408 **/ 1409 public static final int LITERAL_SUPER = 1410 GeneratedJavaTokenTypes.LITERAL_super; 1411 1412 /** 1413 * The <code>=</code> (assignment) operator. 1414 * 1415 * @see <a 1416 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java 1417 * Language Specification, §15.26.1</a> 1418 * @see #EXPR 1419 **/ 1420 public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN; 1421 /** 1422 * The <code>throws</code> keyword. The children are a number of 1423 * one or more identifiers separated by commas. 1424 * 1425 * @see <a 1426 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java 1427 * Language Specification, §8.4.4</a> 1428 * @see #IDENT 1429 * @see #DOT 1430 * @see #COMMA 1431 * @see #METHOD_DEF 1432 * @see #CTOR_DEF 1433 * @see FullIdent 1434 **/ 1435 public static final int LITERAL_THROWS = 1436 GeneratedJavaTokenTypes.LITERAL_throws; 1437 1438 /** 1439 * The <code>:</code> (colon) operator. This will appear as part 1440 * of the conditional operator (<code>? :</code>). 1441 * 1442 * @see #QUESTION 1443 * @see #LABELED_STAT 1444 * @see #CASE_GROUP 1445 **/ 1446 public static final int COLON = GeneratedJavaTokenTypes.COLON; 1447 1448 /** 1449 * The <code>::</code> (double colon) operator. 1450 * It is part of Java 8 syntax that is used for method reference. 1451 * @see #METHOD_REF 1452 */ 1453 public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON; 1454 /** 1455 * The <code>if</code> keyword. 1456 * 1457 * <p>For example:</p> 1458 * <pre> 1459 * if(optimistic) 1460 * { 1461 * message = "half full"; 1462 * } 1463 * else 1464 * { 1465 * message = "half empty"; 1466 * } 1467 * </pre> 1468 * <p>parses as:</p> 1469 * <pre> 1470 * +--LITERAL_IF (if) 1471 * | 1472 * +--LPAREN (() 1473 * +--EXPR 1474 * | 1475 * +--IDENT (optimistic) 1476 * +--RPAREN ()) 1477 * +--SLIST ({) 1478 * | 1479 * +--EXPR 1480 * | 1481 * +--ASSIGN (=) 1482 * | 1483 * +--IDENT (message) 1484 * +--STRING_LITERAL ("half full") 1485 * +--SEMI (;) 1486 * +--RCURLY (}) 1487 * +--LITERAL_ELSE (else) 1488 * | 1489 * +--SLIST ({) 1490 * | 1491 * +--EXPR 1492 * | 1493 * +--ASSIGN (=) 1494 * | 1495 * +--IDENT (message) 1496 * +--STRING_LITERAL ("half empty") 1497 * +--SEMI (;) 1498 * +--RCURLY (}) 1499 * </pre> 1500 * 1501 * @see #LPAREN 1502 * @see #EXPR 1503 * @see #RPAREN 1504 * @see #SLIST 1505 * @see #EMPTY_STAT 1506 * @see #LITERAL_ELSE 1507 **/ 1508 public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if; 1509 /** 1510 * The <code>for</code> keyword. The children are <code>(</code>, 1511 * an initializer, a condition, an iterator, a <code>)</code> and 1512 * either a statement list, a single expression, or an empty 1513 * statement. 1514 * 1515 * <p>For example:</p> 1516 * <pre> 1517 * for(int i = 0, n = myArray.length; i < n; i++) 1518 * { 1519 * } 1520 * </pre> 1521 * 1522 * <p>parses as:</p> 1523 * <pre> 1524 * +--LITERAL_FOR (for) 1525 * | 1526 * +--LPAREN (() 1527 * +--FOR_INIT 1528 * | 1529 * +--VARIABLE_DEF 1530 * | 1531 * +--MODIFIERS 1532 * +--TYPE 1533 * | 1534 * +--LITERAL_INT (int) 1535 * +--IDENT (i) 1536 * +--ASSIGN (=) 1537 * | 1538 * +--EXPR 1539 * | 1540 * +--NUM_INT (0) 1541 * +--COMMA (,) 1542 * +--VARIABLE_DEF 1543 * | 1544 * +--MODIFIERS 1545 * +--TYPE 1546 * | 1547 * +--LITERAL_INT (int) 1548 * +--IDENT (n) 1549 * +--ASSIGN (=) 1550 * | 1551 * +--EXPR 1552 * | 1553 * +--DOT (.) 1554 * | 1555 * +--IDENT (myArray) 1556 * +--IDENT (length) 1557 * +--SEMI (;) 1558 * +--FOR_CONDITION 1559 * | 1560 * +--EXPR 1561 * | 1562 * +--LT (<) 1563 * | 1564 * +--IDENT (i) 1565 * +--IDENT (n) 1566 * +--SEMI (;) 1567 * +--FOR_ITERATOR 1568 * | 1569 * +--ELIST 1570 * | 1571 * +--EXPR 1572 * | 1573 * +--POST_INC (++) 1574 * | 1575 * +--IDENT (i) 1576 * +--RPAREN ()) 1577 * +--SLIST ({) 1578 * | 1579 * +--RCURLY (}) 1580 * </pre> 1581 * 1582 * @see #LPAREN 1583 * @see #FOR_INIT 1584 * @see #SEMI 1585 * @see #FOR_CONDITION 1586 * @see #FOR_ITERATOR 1587 * @see #RPAREN 1588 * @see #SLIST 1589 * @see #EMPTY_STAT 1590 * @see #EXPR 1591 **/ 1592 public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for; 1593 /** 1594 * The <code>while</code> keyword. 1595 * 1596 * <p>For example:</p> 1597 * <pre> 1598 * while(line != null) 1599 * { 1600 * process(line); 1601 * line = in.readLine(); 1602 * } 1603 * </pre> 1604 * <p>parses as:</p> 1605 * <pre> 1606 * +--LITERAL_WHILE (while) 1607 * | 1608 * +--LPAREN (() 1609 * +--EXPR 1610 * | 1611 * +--NOT_EQUAL (!=) 1612 * | 1613 * +--IDENT (line) 1614 * +--LITERAL_NULL (null) 1615 * +--RPAREN ()) 1616 * +--SLIST ({) 1617 * | 1618 * +--EXPR 1619 * | 1620 * +--METHOD_CALL (() 1621 * | 1622 * +--IDENT (process) 1623 * +--ELIST 1624 * | 1625 * +--EXPR 1626 * | 1627 * +--IDENT (line) 1628 * +--RPAREN ()) 1629 * +--SEMI (;) 1630 * +--EXPR 1631 * | 1632 * +--ASSIGN (=) 1633 * | 1634 * +--IDENT (line) 1635 * +--METHOD_CALL (() 1636 * | 1637 * +--DOT (.) 1638 * | 1639 * +--IDENT (in) 1640 * +--IDENT (readLine) 1641 * +--ELIST 1642 * +--RPAREN ()) 1643 * +--SEMI (;) 1644 * +--RCURLY (}) 1645 * </pre> 1646 **/ 1647 public static final int LITERAL_WHILE = 1648 GeneratedJavaTokenTypes.LITERAL_while; 1649 1650 /** 1651 * The <code>do</code> keyword. Note the the while token does not 1652 * appear as part of the do-while construct. 1653 * 1654 * <p>For example:</p> 1655 * <pre> 1656 * do 1657 * { 1658 * x = rand.nextInt(10); 1659 * } 1660 * while(x < 5); 1661 * </pre> 1662 * <p>parses as:</p> 1663 * <pre> 1664 * +--LITERAL_DO (do) 1665 * | 1666 * +--SLIST ({) 1667 * | 1668 * +--EXPR 1669 * | 1670 * +--ASSIGN (=) 1671 * | 1672 * +--IDENT (x) 1673 * +--METHOD_CALL (() 1674 * | 1675 * +--DOT (.) 1676 * | 1677 * +--IDENT (rand) 1678 * +--IDENT (nextInt) 1679 * +--ELIST 1680 * | 1681 * +--EXPR 1682 * | 1683 * +--NUM_INT (10) 1684 * +--RPAREN ()) 1685 * +--SEMI (;) 1686 * +--RCURLY (}) 1687 * +--DO_WHILE (while) 1688 * +--LPAREN (() 1689 * +--EXPR 1690 * | 1691 * +--LT (<) 1692 * | 1693 * +--IDENT (x) 1694 * +--NUM_INT (5) 1695 * +--RPAREN ()) 1696 * +--SEMI (;) 1697 * </pre> 1698 * 1699 * @see #SLIST 1700 * @see #EXPR 1701 * @see #EMPTY_STAT 1702 * @see #LPAREN 1703 * @see #RPAREN 1704 * @see #SEMI 1705 **/ 1706 public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do; 1707 /** 1708 * Literal <code>while</code> in do-while loop. 1709 * @see #LITERAL_DO 1710 */ 1711 public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE; 1712 /** 1713 * The <code>break</code> keyword. The first child is an optional 1714 * identifier and the last child is a semicolon. 1715 * 1716 * @see #IDENT 1717 * @see #SEMI 1718 * @see #SLIST 1719 **/ 1720 public static final int LITERAL_BREAK = 1721 GeneratedJavaTokenTypes.LITERAL_break; 1722 1723 /** 1724 * The <code>continue</code> keyword. The first child is an 1725 * optional identifier and the last child is a semicolon. 1726 * 1727 * @see #IDENT 1728 * @see #SEMI 1729 * @see #SLIST 1730 **/ 1731 public static final int LITERAL_CONTINUE = 1732 GeneratedJavaTokenTypes.LITERAL_continue; 1733 1734 /** 1735 * The <code>return</code> keyword. The first child is an 1736 * optional expression for the return value. The last child is a 1737 * semi colon. 1738 * 1739 * @see #EXPR 1740 * @see #SEMI 1741 * @see #SLIST 1742 **/ 1743 public static final int LITERAL_RETURN = 1744 GeneratedJavaTokenTypes.LITERAL_return; 1745 1746 /** 1747 * The <code>switch</code> keyword. 1748 * 1749 * <p>For example:</p> 1750 * <pre> 1751 * switch(type) 1752 * { 1753 * case 0: 1754 * background = Color.blue; 1755 * break; 1756 * case 1: 1757 * background = Color.red; 1758 * break; 1759 * default: 1760 * background = Color.green; 1761 * break; 1762 * } 1763 * </pre> 1764 * <p>parses as:</p> 1765 * <pre> 1766 * +--LITERAL_SWITCH (switch) 1767 * | 1768 * +--LPAREN (() 1769 * +--EXPR 1770 * | 1771 * +--IDENT (type) 1772 * +--RPAREN ()) 1773 * +--LCURLY ({) 1774 * +--CASE_GROUP 1775 * | 1776 * +--LITERAL_CASE (case) 1777 * | 1778 * +--EXPR 1779 * | 1780 * +--NUM_INT (0) 1781 * +--SLIST 1782 * | 1783 * +--EXPR 1784 * | 1785 * +--ASSIGN (=) 1786 * | 1787 * +--IDENT (background) 1788 * +--DOT (.) 1789 * | 1790 * +--IDENT (Color) 1791 * +--IDENT (blue) 1792 * +--SEMI (;) 1793 * +--LITERAL_BREAK (break) 1794 * | 1795 * +--SEMI (;) 1796 * +--CASE_GROUP 1797 * | 1798 * +--LITERAL_CASE (case) 1799 * | 1800 * +--EXPR 1801 * | 1802 * +--NUM_INT (1) 1803 * +--SLIST 1804 * | 1805 * +--EXPR 1806 * | 1807 * +--ASSIGN (=) 1808 * | 1809 * +--IDENT (background) 1810 * +--DOT (.) 1811 * | 1812 * +--IDENT (Color) 1813 * +--IDENT (red) 1814 * +--SEMI (;) 1815 * +--LITERAL_BREAK (break) 1816 * | 1817 * +--SEMI (;) 1818 * +--CASE_GROUP 1819 * | 1820 * +--LITERAL_DEFAULT (default) 1821 * +--SLIST 1822 * | 1823 * +--EXPR 1824 * | 1825 * +--ASSIGN (=) 1826 * | 1827 * +--IDENT (background) 1828 * +--DOT (.) 1829 * | 1830 * +--IDENT (Color) 1831 * +--IDENT (green) 1832 * +--SEMI (;) 1833 * +--LITERAL_BREAK (break) 1834 * | 1835 * +--SEMI (;) 1836 * +--RCURLY (}) 1837 * </pre> 1838 * 1839 * @see <a 1840 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 1841 * Language Specification, §14.10</a> 1842 * @see #LPAREN 1843 * @see #EXPR 1844 * @see #RPAREN 1845 * @see #LCURLY 1846 * @see #CASE_GROUP 1847 * @see #RCURLY 1848 * @see #SLIST 1849 **/ 1850 public static final int LITERAL_SWITCH = 1851 GeneratedJavaTokenTypes.LITERAL_switch; 1852 1853 /** 1854 * The <code>throw</code> keyword. The first child is an 1855 * expression that evaluates to a <code>Throwable</code> instance. 1856 * 1857 * @see <a 1858 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java 1859 * Language Specification, §14.17</a> 1860 * @see #SLIST 1861 * @see #EXPR 1862 **/ 1863 public static final int LITERAL_THROW = 1864 GeneratedJavaTokenTypes.LITERAL_throw; 1865 1866 /** 1867 * The <code>else</code> keyword. This appears as a child of an 1868 * <code>if</code> statement. 1869 * 1870 * @see #SLIST 1871 * @see #EXPR 1872 * @see #EMPTY_STAT 1873 * @see #LITERAL_IF 1874 **/ 1875 public static final int LITERAL_ELSE = 1876 GeneratedJavaTokenTypes.LITERAL_else; 1877 1878 /** 1879 * The <code>case</code> keyword. The first child is a constant 1880 * expression that evaluates to a integer. 1881 * 1882 * @see #CASE_GROUP 1883 * @see #EXPR 1884 **/ 1885 public static final int LITERAL_CASE = 1886 GeneratedJavaTokenTypes.LITERAL_case; 1887 1888 /** 1889 * The <code>default</code> keyword. This element has no 1890 * children. 1891 * 1892 * @see #CASE_GROUP 1893 * @see #MODIFIERS 1894 **/ 1895 public static final int LITERAL_DEFAULT = 1896 GeneratedJavaTokenTypes.LITERAL_default; 1897 1898 /** 1899 * The <code>try</code> keyword. The children are a statement 1900 * list, zero or more catch blocks and then an optional finally 1901 * block. 1902 * 1903 * <p>For example:</p> 1904 * <pre> 1905 * try 1906 * { 1907 * FileReader in = new FileReader("abc.txt"); 1908 * } 1909 * catch(IOException ioe) 1910 * { 1911 * } 1912 * finally 1913 * { 1914 * } 1915 * </pre> 1916 * <p>parses as:</p> 1917 * <pre> 1918 * +--LITERAL_TRY (try) 1919 * | 1920 * +--SLIST ({) 1921 * | 1922 * +--VARIABLE_DEF 1923 * | 1924 * +--MODIFIERS 1925 * +--TYPE 1926 * | 1927 * +--IDENT (FileReader) 1928 * +--IDENT (in) 1929 * +--ASSIGN (=) 1930 * | 1931 * +--EXPR 1932 * | 1933 * +--LITERAL_NEW (new) 1934 * | 1935 * +--IDENT (FileReader) 1936 * +--LPAREN (() 1937 * +--ELIST 1938 * | 1939 * +--EXPR 1940 * | 1941 * +--STRING_LITERAL ("abc.txt") 1942 * +--RPAREN ()) 1943 * +--SEMI (;) 1944 * +--RCURLY (}) 1945 * +--LITERAL_CATCH (catch) 1946 * | 1947 * +--LPAREN (() 1948 * +--PARAMETER_DEF 1949 * | 1950 * +--MODIFIERS 1951 * +--TYPE 1952 * | 1953 * +--IDENT (IOException) 1954 * +--IDENT (ioe) 1955 * +--RPAREN ()) 1956 * +--SLIST ({) 1957 * | 1958 * +--RCURLY (}) 1959 * +--LITERAL_FINALLY (finally) 1960 * | 1961 * +--SLIST ({) 1962 * | 1963 * +--RCURLY (}) 1964 * +--RCURLY (}) 1965 * </pre> 1966 * 1967 * @see <a 1968 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 1969 * Language Specification, §14.19</a> 1970 * @see #SLIST 1971 * @see #LITERAL_CATCH 1972 * @see #LITERAL_FINALLY 1973 **/ 1974 public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try; 1975 1976 /** 1977 * Java 7 try-with-resources construct. 1978 * 1979 * <p>For example:</p> 1980 * <pre> 1981 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 1982 * </pre> 1983 * <p>parses as:</p> 1984 * <pre> 1985 * +--LITERAL_TRY (try) 1986 * | 1987 * +--RESOURCE_SPECIFICATION 1988 * | 1989 * +--LPAREN (() 1990 * +--RESOURCES 1991 * | 1992 * +--RESOURCE 1993 * | 1994 * +--MODIFIERS 1995 * +--TYPE 1996 * | 1997 * +--IDENT (Foo) 1998 * +--IDENT (foo) 1999 * +--ASSIGN (=) 2000 * +--EXPR 2001 * | 2002 * +--LITERAL_NEW (new) 2003 * | 2004 * +--IDENT (Foo) 2005 * +--LPAREN (() 2006 * +--ELIST 2007 * +--RPAREN ()) 2008 * +--SEMI (;) 2009 * +--RESOURCE 2010 * | 2011 * +--MODIFIERS 2012 * +--TYPE 2013 * | 2014 * +--IDENT (Bar) 2015 * +--IDENT (bar) 2016 * +--ASSIGN (=) 2017 * +--EXPR 2018 * | 2019 * +--LITERAL_NEW (new) 2020 * | 2021 * +--IDENT (Bar) 2022 * +--LPAREN (() 2023 * +--ELIST 2024 * +--RPAREN ()) 2025 * +--RPAREN ()) 2026 * +--SLIST ({) 2027 * +--RCURLY (}) 2028 * </pre> 2029 * 2030 * @see #LPAREN 2031 * @see #RESOURCES 2032 * @see #RESOURCE 2033 * @see #SEMI 2034 * @see #RPAREN 2035 * @see #LITERAL_TRY 2036 **/ 2037 public static final int RESOURCE_SPECIFICATION = 2038 GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION; 2039 2040 /** 2041 * Java 7 try-with-resources construct. 2042 * 2043 * @see #RESOURCE_SPECIFICATION 2044 **/ 2045 public static final int RESOURCES = 2046 GeneratedJavaTokenTypes.RESOURCES; 2047 2048 /** 2049 * Java 7 try-with-resources construct. 2050 * 2051 * @see #RESOURCE_SPECIFICATION 2052 **/ 2053 public static final int RESOURCE = 2054 GeneratedJavaTokenTypes.RESOURCE; 2055 2056 /** 2057 * The <code>catch</code> keyword. 2058 * 2059 * @see #LPAREN 2060 * @see #PARAMETER_DEF 2061 * @see #RPAREN 2062 * @see #SLIST 2063 * @see #LITERAL_TRY 2064 **/ 2065 public static final int LITERAL_CATCH = 2066 GeneratedJavaTokenTypes.LITERAL_catch; 2067 2068 /** 2069 * The <code>finally</code> keyword. 2070 * 2071 * @see #SLIST 2072 * @see #LITERAL_TRY 2073 **/ 2074 public static final int LITERAL_FINALLY = 2075 GeneratedJavaTokenTypes.LITERAL_finally; 2076 2077 /** 2078 * The <code>+=</code> (addition assignment) operator. 2079 * 2080 * @see <a 2081 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2082 * Language Specification, §15.26.2</a> 2083 * @see #EXPR 2084 **/ 2085 public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN; 2086 /** 2087 * The <code>-=</code> (subtraction assignment) operator. 2088 * 2089 * @see <a 2090 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2091 * Language Specification, §15.26.2</a> 2092 * @see #EXPR 2093 **/ 2094 public static final int MINUS_ASSIGN = 2095 GeneratedJavaTokenTypes.MINUS_ASSIGN; 2096 2097 /** 2098 * The <code>*=</code> (multiplication assignment) operator. 2099 * 2100 * @see <a 2101 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2102 * Language Specification, §15.26.2</a> 2103 * @see #EXPR 2104 **/ 2105 public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN; 2106 /** 2107 * The <code>/=</code> (division assignment) operator. 2108 * 2109 * @see <a 2110 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2111 * Language Specification, §15.26.2</a> 2112 * @see #EXPR 2113 **/ 2114 public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN; 2115 /** 2116 * The <code>%=</code> (remainder assignment) operator. 2117 * 2118 * @see <a 2119 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2120 * Language Specification, §15.26.2</a> 2121 * @see #EXPR 2122 **/ 2123 public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN; 2124 /** 2125 * The <code>>>=</code> (signed right shift assignment) 2126 * operator. 2127 * 2128 * @see <a 2129 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2130 * Language Specification, §15.26.2</a> 2131 * @see #EXPR 2132 **/ 2133 public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN; 2134 /** 2135 * The <code>>>>=</code> (unsigned right shift assignment) 2136 * operator. 2137 * 2138 * @see <a 2139 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2140 * Language Specification, §15.26.2</a> 2141 * @see #EXPR 2142 **/ 2143 public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN; 2144 /** 2145 * The <code><<=</code> (left shift assignment) operator. 2146 * 2147 * @see <a 2148 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2149 * Language Specification, §15.26.2</a> 2150 * @see #EXPR 2151 **/ 2152 public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN; 2153 /** 2154 * The <code>&=</code> (bitwise AND assignment) operator. 2155 * 2156 * @see <a 2157 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2158 * Language Specification, §15.26.2</a> 2159 * @see #EXPR 2160 **/ 2161 public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN; 2162 /** 2163 * The <code>^=</code> (bitwise exclusive OR assignment) operator. 2164 * 2165 * @see <a 2166 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2167 * Language Specification, §15.26.2</a> 2168 * @see #EXPR 2169 **/ 2170 public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN; 2171 /** 2172 * The <code>|=</code> (bitwise OR assignment) operator. 2173 * 2174 * @see <a 2175 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2176 * Language Specification, §15.26.2</a> 2177 * @see #EXPR 2178 **/ 2179 public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN; 2180 /** 2181 * The <code>?</code> (conditional) operator. Technically, 2182 * the colon is also part of this operator, but it appears as a 2183 * separate token. 2184 * 2185 * <p>For example:</p> 2186 * <pre> 2187 * (quantity == 1) ? "": "s" 2188 * </pre> 2189 * <p> 2190 * parses as: 2191 * </p> 2192 * <pre> 2193 * +--QUESTION (?) 2194 * | 2195 * +--LPAREN (() 2196 * +--EQUAL (==) 2197 * | 2198 * +--IDENT (quantity) 2199 * +--NUM_INT (1) 2200 * +--RPAREN ()) 2201 * +--STRING_LITERAL ("") 2202 * +--COLON (:) 2203 * +--STRING_LITERAL ("s") 2204 * </pre> 2205 * 2206 * @see <a 2207 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 2208 * Language Specification, §15.25</a> 2209 * @see #EXPR 2210 * @see #COLON 2211 **/ 2212 public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION; 2213 /** 2214 * The <code>||</code> (conditional OR) operator. 2215 * 2216 * @see <a 2217 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java 2218 * Language Specification, §15.24</a> 2219 * @see #EXPR 2220 **/ 2221 public static final int LOR = GeneratedJavaTokenTypes.LOR; 2222 /** 2223 * The <code>&&</code> (conditional AND) operator. 2224 * 2225 * @see <a 2226 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 2227 * Language Specification, §15.23</a> 2228 * @see #EXPR 2229 **/ 2230 public static final int LAND = GeneratedJavaTokenTypes.LAND; 2231 /** 2232 * The <code>|</code> (bitwise OR) operator. 2233 * 2234 * @see <a 2235 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2236 * Language Specification, §15.22.1</a> 2237 * @see #EXPR 2238 **/ 2239 public static final int BOR = GeneratedJavaTokenTypes.BOR; 2240 /** 2241 * The <code>^</code> (bitwise exclusive OR) operator. 2242 * 2243 * @see <a 2244 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2245 * Language Specification, §15.22.1</a> 2246 * @see #EXPR 2247 **/ 2248 public static final int BXOR = GeneratedJavaTokenTypes.BXOR; 2249 /** 2250 * The <code>&</code> (bitwise AND) operator. 2251 * 2252 * @see <a 2253 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2254 * Language Specification, §15.22.1</a> 2255 * @see #EXPR 2256 **/ 2257 public static final int BAND = GeneratedJavaTokenTypes.BAND; 2258 /** 2259 * The <code>!=</code> (not equal) operator. 2260 * 2261 * @see #EXPR 2262 **/ 2263 public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL; 2264 /** 2265 * The <code>==</code> (equal) operator. 2266 * 2267 * @see #EXPR 2268 **/ 2269 public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL; 2270 /** 2271 * The <code><</code> (less than) operator. 2272 * 2273 * @see #EXPR 2274 **/ 2275 public static final int LT = GeneratedJavaTokenTypes.LT; 2276 /** 2277 * The <code>></code> (greater than) operator. 2278 * 2279 * @see #EXPR 2280 **/ 2281 public static final int GT = GeneratedJavaTokenTypes.GT; 2282 /** 2283 * The <code><=</code> (less than or equal) operator. 2284 * 2285 * @see #EXPR 2286 **/ 2287 public static final int LE = GeneratedJavaTokenTypes.LE; 2288 /** 2289 * The <code>>=</code> (greater than or equal) operator. 2290 * 2291 * @see #EXPR 2292 **/ 2293 public static final int GE = GeneratedJavaTokenTypes.GE; 2294 /** 2295 * The <code>instanceof</code> operator. The first child is an 2296 * object reference or something that evaluates to an object 2297 * reference. The second child is a reference type. 2298 * 2299 * @see <a 2300 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 2301 * Language Specification, §15.20.2</a> 2302 * @see #EXPR 2303 * @see #METHOD_CALL 2304 * @see #IDENT 2305 * @see #DOT 2306 * @see #TYPE 2307 * @see FullIdent 2308 **/ 2309 public static final int LITERAL_INSTANCEOF = 2310 GeneratedJavaTokenTypes.LITERAL_instanceof; 2311 2312 /** 2313 * The <code><<</code> (shift left) operator. 2314 * 2315 * @see <a 2316 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2317 * Language Specification, §15.19</a> 2318 * @see #EXPR 2319 **/ 2320 public static final int SL = GeneratedJavaTokenTypes.SL; 2321 /** 2322 * The <code>>></code> (signed shift right) operator. 2323 * 2324 * @see <a 2325 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2326 * Language Specification, §15.19</a> 2327 * @see #EXPR 2328 **/ 2329 public static final int SR = GeneratedJavaTokenTypes.SR; 2330 /** 2331 * The <code>>>></code> (unsigned shift right) operator. 2332 * 2333 * @see <a 2334 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2335 * Language Specification, §15.19</a> 2336 * @see #EXPR 2337 **/ 2338 public static final int BSR = GeneratedJavaTokenTypes.BSR; 2339 /** 2340 * The <code>+</code> (addition) operator. 2341 * 2342 * @see <a 2343 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2344 * Language Specification, §15.18</a> 2345 * @see #EXPR 2346 **/ 2347 public static final int PLUS = GeneratedJavaTokenTypes.PLUS; 2348 /** 2349 * The <code>-</code> (subtraction) operator. 2350 * 2351 * @see <a 2352 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2353 * Language Specification, §15.18</a> 2354 * @see #EXPR 2355 **/ 2356 public static final int MINUS = GeneratedJavaTokenTypes.MINUS; 2357 /** 2358 * The <code>/</code> (division) operator. 2359 * 2360 * @see <a 2361 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 2362 * Language Specification, §15.17.2</a> 2363 * @see #EXPR 2364 **/ 2365 public static final int DIV = GeneratedJavaTokenTypes.DIV; 2366 /** 2367 * The <code>%</code> (remainder) operator. 2368 * 2369 * @see <a 2370 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 2371 * Language Specification, §15.17.3</a> 2372 * @see #EXPR 2373 **/ 2374 public static final int MOD = GeneratedJavaTokenTypes.MOD; 2375 /** 2376 * The <code>++</code> (prefix increment) operator. 2377 * 2378 * @see <a 2379 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 2380 * Language Specification, §15.15.1</a> 2381 * @see #EXPR 2382 * @see #POST_INC 2383 **/ 2384 public static final int INC = GeneratedJavaTokenTypes.INC; 2385 /** 2386 * The <code>--</code> (prefix decrement) operator. 2387 * 2388 * @see <a 2389 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 2390 * Language Specification, §15.15.2</a> 2391 * @see #EXPR 2392 * @see #POST_DEC 2393 **/ 2394 public static final int DEC = GeneratedJavaTokenTypes.DEC; 2395 /** 2396 * The <code>~</code> (bitwise complement) operator. 2397 * 2398 * @see <a 2399 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 2400 * Language Specification, §15.15.5</a> 2401 * @see #EXPR 2402 **/ 2403 public static final int BNOT = GeneratedJavaTokenTypes.BNOT; 2404 /** 2405 * The <code>!</code> (logical complement) operator. 2406 * 2407 * @see <a 2408 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 2409 * Language Specification, §15.15.6</a> 2410 * @see #EXPR 2411 **/ 2412 public static final int LNOT = GeneratedJavaTokenTypes.LNOT; 2413 /** 2414 * The <code>true</code> keyword. 2415 * 2416 * @see <a 2417 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2418 * Language Specification, §3.10.3</a> 2419 * @see #EXPR 2420 * @see #LITERAL_FALSE 2421 **/ 2422 public static final int LITERAL_TRUE = 2423 GeneratedJavaTokenTypes.LITERAL_true; 2424 2425 /** 2426 * The <code>false</code> keyword. 2427 * 2428 * @see <a 2429 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2430 * Language Specification, §3.10.3</a> 2431 * @see #EXPR 2432 * @see #LITERAL_TRUE 2433 **/ 2434 public static final int LITERAL_FALSE = 2435 GeneratedJavaTokenTypes.LITERAL_false; 2436 2437 /** 2438 * The <code>null</code> keyword. 2439 * 2440 * @see <a 2441 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 2442 * Language Specification, §3.10.7</a> 2443 * @see #EXPR 2444 **/ 2445 public static final int LITERAL_NULL = 2446 GeneratedJavaTokenTypes.LITERAL_null; 2447 2448 /** 2449 * The <code>new</code> keyword. This element is used to define 2450 * new instances of objects, new arrays, and new anonymous inner 2451 * classes. 2452 * 2453 * <p>For example:</p> 2454 * 2455 * <pre> 2456 * new ArrayList(50) 2457 * </pre> 2458 * 2459 * <p>parses as:</p> 2460 * <pre> 2461 * +--LITERAL_NEW (new) 2462 * | 2463 * +--IDENT (ArrayList) 2464 * +--LPAREN (() 2465 * +--ELIST 2466 * | 2467 * +--EXPR 2468 * | 2469 * +--NUM_INT (50) 2470 * +--RPAREN ()) 2471 * </pre> 2472 * 2473 * <p>For example:</p> 2474 * <pre> 2475 * new float[] 2476 * { 2477 * 3.0f, 2478 * 4.0f 2479 * }; 2480 * </pre> 2481 * 2482 * <p>parses as:</p> 2483 * <pre> 2484 * +--LITERAL_NEW (new) 2485 * | 2486 * +--LITERAL_FLOAT (float) 2487 * +--ARRAY_DECLARATOR ([) 2488 * +--ARRAY_INIT ({) 2489 * | 2490 * +--EXPR 2491 * | 2492 * +--NUM_FLOAT (3.0f) 2493 * +--COMMA (,) 2494 * +--EXPR 2495 * | 2496 * +--NUM_FLOAT (4.0f) 2497 * +--RCURLY (}) 2498 * </pre> 2499 * 2500 * <p>For example:</p> 2501 * <pre> 2502 * new FilenameFilter() 2503 * { 2504 * public boolean accept(File dir, String name) 2505 * { 2506 * return name.endsWith(".java"); 2507 * } 2508 * } 2509 * </pre> 2510 * 2511 * <p>parses as:</p> 2512 * <pre> 2513 * +--LITERAL_NEW (new) 2514 * | 2515 * +--IDENT (FilenameFilter) 2516 * +--LPAREN (() 2517 * +--ELIST 2518 * +--RPAREN ()) 2519 * +--OBJBLOCK 2520 * | 2521 * +--LCURLY ({) 2522 * +--METHOD_DEF 2523 * | 2524 * +--MODIFIERS 2525 * | 2526 * +--LITERAL_PUBLIC (public) 2527 * +--TYPE 2528 * | 2529 * +--LITERAL_BOOLEAN (boolean) 2530 * +--IDENT (accept) 2531 * +--PARAMETERS 2532 * | 2533 * +--PARAMETER_DEF 2534 * | 2535 * +--MODIFIERS 2536 * +--TYPE 2537 * | 2538 * +--IDENT (File) 2539 * +--IDENT (dir) 2540 * +--COMMA (,) 2541 * +--PARAMETER_DEF 2542 * | 2543 * +--MODIFIERS 2544 * +--TYPE 2545 * | 2546 * +--IDENT (String) 2547 * +--IDENT (name) 2548 * +--SLIST ({) 2549 * | 2550 * +--LITERAL_RETURN (return) 2551 * | 2552 * +--EXPR 2553 * | 2554 * +--METHOD_CALL (() 2555 * | 2556 * +--DOT (.) 2557 * | 2558 * +--IDENT (name) 2559 * +--IDENT (endsWith) 2560 * +--ELIST 2561 * | 2562 * +--EXPR 2563 * | 2564 * +--STRING_LITERAL (".java") 2565 * +--RPAREN ()) 2566 * +--SEMI (;) 2567 * +--RCURLY (}) 2568 * +--RCURLY (}) 2569 * </pre> 2570 * 2571 * @see #IDENT 2572 * @see #DOT 2573 * @see #LPAREN 2574 * @see #ELIST 2575 * @see #RPAREN 2576 * @see #OBJBLOCK 2577 * @see #ARRAY_INIT 2578 * @see FullIdent 2579 **/ 2580 public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new; 2581 /** 2582 * An integer literal. These may be specified in decimal, 2583 * hexadecimal, or octal form. 2584 * 2585 * @see <a 2586 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2587 * Language Specification, §3.10.1</a> 2588 * @see #EXPR 2589 * @see #NUM_LONG 2590 **/ 2591 public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT; 2592 /** 2593 * A character literal. This is a (possibly escaped) character 2594 * enclosed in single quotes. 2595 * 2596 * @see <a 2597 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 2598 * Language Specification, §3.10.4</a> 2599 * @see #EXPR 2600 **/ 2601 public static final int CHAR_LITERAL = 2602 GeneratedJavaTokenTypes.CHAR_LITERAL; 2603 2604 /** 2605 * A string literal. This is a sequence of (possibly escaped) 2606 * characters enclosed in double quotes. 2607 * 2608 * @see <a 2609 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 2610 * Language Specification, §3.10.5</a> 2611 * @see #EXPR 2612 **/ 2613 public static final int STRING_LITERAL = 2614 GeneratedJavaTokenTypes.STRING_LITERAL; 2615 2616 /** 2617 * A single precision floating point literal. This is a floating 2618 * point number with an <code>F</code> or <code>f</code> suffix. 2619 * 2620 * @see <a 2621 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2622 * Language Specification, §3.10.2</a> 2623 * @see #EXPR 2624 * @see #NUM_DOUBLE 2625 **/ 2626 public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT; 2627 /** 2628 * A long integer literal. These are almost the same as integer 2629 * literals, but they have an <code>L</code> or <code>l</code> 2630 * (ell) suffix. 2631 * 2632 * @see <a 2633 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2634 * Language Specification, §3.10.1</a> 2635 * @see #EXPR 2636 * @see #NUM_INT 2637 **/ 2638 public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG; 2639 /** 2640 * A double precision floating point literal. This is a floating 2641 * point number with an optional <code>D</code> or <code>d</code> 2642 * suffix. 2643 * 2644 * @see <a 2645 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2646 * Language Specification, §3.10.2</a> 2647 * @see #EXPR 2648 * @see #NUM_FLOAT 2649 **/ 2650 public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE; 2651 2652 /** 2653 * The <code>assert</code> keyword. This is only for Java 1.4 and 2654 * later. 2655 * 2656 * <p>For example:</p> 2657 * <pre> 2658 * assert(x==4); 2659 * </pre> 2660 * <p>parses as:</p> 2661 * <pre> 2662 * +--LITERAL_ASSERT (assert) 2663 * | 2664 * +--EXPR 2665 * | 2666 * +--LPAREN (() 2667 * +--EQUAL (==) 2668 * | 2669 * +--IDENT (x) 2670 * +--NUM_INT (4) 2671 * +--RPAREN ()) 2672 * +--SEMI (;) 2673 * </pre> 2674 **/ 2675 public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT; 2676 2677 /** 2678 * A static import declaration. Static import declarations are optional, 2679 * but must appear after the package declaration and before the type 2680 * declaration. 2681 * 2682 * <p>For example:</p> 2683 * 2684 * <pre> 2685 * import static java.io.IOException; 2686 * </pre> 2687 * 2688 * <p>parses as:</p> 2689 * 2690 * <pre> 2691 * +--STATIC_IMPORT (import) 2692 * | 2693 * +--LITERAL_STATIC 2694 * +--DOT (.) 2695 * | 2696 * +--DOT (.) 2697 * | 2698 * +--IDENT (java) 2699 * +--IDENT (io) 2700 * +--IDENT (IOException) 2701 * +--SEMI (;) 2702 * </pre> 2703 * 2704 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2705 * JSR201</a> 2706 * @see #LITERAL_STATIC 2707 * @see #DOT 2708 * @see #IDENT 2709 * @see #STAR 2710 * @see #SEMI 2711 * @see FullIdent 2712 **/ 2713 public static final int STATIC_IMPORT = 2714 GeneratedJavaTokenTypes.STATIC_IMPORT; 2715 2716 /** 2717 * An enum declaration. Its notable children are 2718 * enum constant declarations followed by 2719 * any construct that may be expected in a class body. 2720 * 2721 * <p>For example:</p> 2722 * <pre> 2723 * public enum MyEnum 2724 * implements Serializable 2725 * { 2726 * FIRST_CONSTANT, 2727 * SECOND_CONSTANT; 2728 * 2729 * public void someMethod() 2730 * { 2731 * } 2732 * } 2733 * </pre> 2734 * <p>parses as:</p> 2735 * <pre> 2736 * +--ENUM_DEF 2737 * | 2738 * +--MODIFIERS 2739 * | 2740 * +--LITERAL_PUBLIC (public) 2741 * +--ENUM (enum) 2742 * +--IDENT (MyEnum) 2743 * +--EXTENDS_CLAUSE 2744 * +--IMPLEMENTS_CLAUSE 2745 * | 2746 * +--IDENT (Serializable) 2747 * +--OBJBLOCK 2748 * | 2749 * +--LCURLY ({) 2750 * +--ENUM_CONSTANT_DEF 2751 * | 2752 * +--IDENT (FIRST_CONSTANT) 2753 * +--COMMA (,) 2754 * +--ENUM_CONSTANT_DEF 2755 * | 2756 * +--IDENT (SECOND_CONSTANT) 2757 * +--SEMI (;) 2758 * +--METHOD_DEF 2759 * | 2760 * +--MODIFIERS 2761 * | 2762 * +--LITERAL_PUBLIC (public) 2763 * +--TYPE 2764 * | 2765 * +--LITERAL_void (void) 2766 * +--IDENT (someMethod) 2767 * +--LPAREN (() 2768 * +--PARAMETERS 2769 * +--RPAREN ()) 2770 * +--SLIST ({) 2771 * | 2772 * +--RCURLY (}) 2773 * +--RCURLY (}) 2774 * </pre> 2775 * 2776 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2777 * JSR201</a> 2778 * @see #MODIFIERS 2779 * @see #ENUM 2780 * @see #IDENT 2781 * @see #EXTENDS_CLAUSE 2782 * @see #IMPLEMENTS_CLAUSE 2783 * @see #OBJBLOCK 2784 * @see #LITERAL_NEW 2785 * @see #ENUM_CONSTANT_DEF 2786 **/ 2787 public static final int ENUM_DEF = 2788 GeneratedJavaTokenTypes.ENUM_DEF; 2789 2790 /** 2791 * The <code>enum</code> keyword. This element appears 2792 * as part of an enum declaration. 2793 **/ 2794 public static final int ENUM = 2795 GeneratedJavaTokenTypes.ENUM; 2796 2797 /** 2798 * An enum constant declaration. Its notable children are annotations, 2799 * arguments and object block akin to an anonymous 2800 * inner class' body. 2801 * 2802 * <p>For example:</p> 2803 * <pre> 2804 * SOME_CONSTANT(1) 2805 * { 2806 * public void someMethodOverriddenFromMainBody() 2807 * { 2808 * } 2809 * } 2810 * </pre> 2811 * <p>parses as:</p> 2812 * <pre> 2813 * +--ENUM_CONSTANT_DEF 2814 * | 2815 * +--ANNOTATIONS 2816 * +--IDENT (SOME_CONSTANT) 2817 * +--LPAREN (() 2818 * +--ELIST 2819 * | 2820 * +--EXPR 2821 * | 2822 * +--NUM_INT (1) 2823 * +--RPAREN ()) 2824 * +--OBJBLOCK 2825 * | 2826 * +--LCURLY ({) 2827 * | 2828 * +--METHOD_DEF 2829 * | 2830 * +--MODIFIERS 2831 * | 2832 * +--LITERAL_PUBLIC (public) 2833 * +--TYPE 2834 * | 2835 * +--LITERAL_void (void) 2836 * +--IDENT (someMethodOverriddenFromMainBody) 2837 * +--LPAREN (() 2838 * +--PARAMETERS 2839 * +--RPAREN ()) 2840 * +--SLIST ({) 2841 * | 2842 * +--RCURLY (}) 2843 * +--RCURLY (}) 2844 * </pre> 2845 * 2846 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2847 * JSR201</a> 2848 * @see #ANNOTATIONS 2849 * @see #MODIFIERS 2850 * @see #IDENT 2851 * @see #ELIST 2852 * @see #OBJBLOCK 2853 **/ 2854 public static final int ENUM_CONSTANT_DEF = 2855 GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF; 2856 2857 /** 2858 * A for-each clause. This is a child of 2859 * <code>LITERAL_FOR</code>. The children of this element may be 2860 * a parameter definition, the colon literal and an expression. 2861 * 2862 * <p>For example:</p> 2863 * <pre> 2864 * for (int value : values) { 2865 * doSmth(); 2866 * } 2867 * </pre> 2868 * <p>parses as:</p> 2869 * <pre> 2870 * --LITERAL_FOR (for) 2871 * |--LPAREN (() 2872 * |--FOR_EACH_CLAUSE 2873 * | |--VARIABLE_DEF 2874 * | | |--MODIFIERS 2875 * | | |--TYPE 2876 * | | | `--LITERAL_INT (int) 2877 * | | `--IDENT (value) 2878 * | |--COLON (:) 2879 * | `--EXPR 2880 * | `--IDENT (values 2881 * |--RPAREN ()) 2882 * `--SLIST ({) 2883 * |--EXPR 2884 * | `--METHOD_CALL (() 2885 * | |--IDENT (doSmth) 2886 * | |--ELIST 2887 * | `--RPAREN ()) 2888 * |--SEMI (;) 2889 * `--RCURLY (}) 2890 * 2891 * </pre> 2892 * 2893 * @see #VARIABLE_DEF 2894 * @see #ELIST 2895 * @see #LITERAL_FOR 2896 **/ 2897 public static final int FOR_EACH_CLAUSE = 2898 GeneratedJavaTokenTypes.FOR_EACH_CLAUSE; 2899 2900 /** 2901 * An annotation declaration. The notable children are the name of the 2902 * annotation type, annotation field declarations and (constant) fields. 2903 * 2904 * <p>For example:</p> 2905 * <pre> 2906 * public @interface MyAnnotation 2907 * { 2908 * int someValue(); 2909 * } 2910 * </pre> 2911 * <p>parses as:</p> 2912 * <pre> 2913 * +--ANNOTATION_DEF 2914 * | 2915 * +--MODIFIERS 2916 * | 2917 * +--LITERAL_PUBLIC (public) 2918 * +--AT (@) 2919 * +--LITERAL_INTERFACE (interface) 2920 * +--IDENT (MyAnnotation) 2921 * +--OBJBLOCK 2922 * | 2923 * +--LCURLY ({) 2924 * +--ANNOTATION_FIELD_DEF 2925 * | 2926 * +--MODIFIERS 2927 * +--TYPE 2928 * | 2929 * +--LITERAL_INT (int) 2930 * +--IDENT (someValue) 2931 * +--LPAREN (() 2932 * +--RPAREN ()) 2933 * +--SEMI (;) 2934 * +--RCURLY (}) 2935 * </pre> 2936 * 2937 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2938 * JSR201</a> 2939 * @see #MODIFIERS 2940 * @see #LITERAL_INTERFACE 2941 * @see #IDENT 2942 * @see #OBJBLOCK 2943 * @see #ANNOTATION_FIELD_DEF 2944 **/ 2945 public static final int ANNOTATION_DEF = 2946 GeneratedJavaTokenTypes.ANNOTATION_DEF; 2947 2948 /** 2949 * An annotation field declaration. The notable children are modifiers, 2950 * field type, field name and an optional default value (a conditional 2951 * compile-time constant expression). Default values may also by 2952 * annotations. 2953 * 2954 * <p>For example:</p> 2955 * 2956 * <pre> 2957 * String someField() default "Hello world"; 2958 * </pre> 2959 * 2960 * <p>parses as:</p> 2961 * 2962 * <pre> 2963 * +--ANNOTATION_FIELD_DEF 2964 * | 2965 * +--MODIFIERS 2966 * +--TYPE 2967 * | 2968 * +--IDENT (String) 2969 * +--IDENT (someField) 2970 * +--LPAREN (() 2971 * +--RPAREN ()) 2972 * +--LITERAL_DEFAULT (default) 2973 * +--STRING_LITERAL ("Hello world") 2974 * +--SEMI (;) 2975 * </pre> 2976 * 2977 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2978 * JSR201</a> 2979 * @see #MODIFIERS 2980 * @see #TYPE 2981 * @see #LITERAL_DEFAULT 2982 */ 2983 public static final int ANNOTATION_FIELD_DEF = 2984 GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF; 2985 2986 // note: @ is the html escape for '@', 2987 // used here to avoid confusing the javadoc tool 2988 /** 2989 * A collection of annotations on a package or enum constant. 2990 * A collections of annotations will only occur on these nodes 2991 * as all other nodes that may be qualified with an annotation can 2992 * be qualified with any other modifier and hence these annotations 2993 * would be contained in a {@link #MODIFIERS} node. 2994 * 2995 * <p>For example:</p> 2996 * 2997 * <pre> 2998 * @MyAnnotation package blah; 2999 * </pre> 3000 * 3001 * <p>parses as:</p> 3002 * 3003 * <pre> 3004 * +--PACKAGE_DEF (package) 3005 * | 3006 * +--ANNOTATIONS 3007 * | 3008 * +--ANNOTATION 3009 * | 3010 * +--AT (@) 3011 * +--IDENT (MyAnnotation) 3012 * +--IDENT (blah) 3013 * +--SEMI (;) 3014 * </pre> 3015 * 3016 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3017 * JSR201</a> 3018 * @see #ANNOTATION 3019 * @see #AT 3020 * @see #IDENT 3021 */ 3022 public static final int ANNOTATIONS = 3023 GeneratedJavaTokenTypes.ANNOTATIONS; 3024 3025 // note: @ is the html escape for '@', 3026 // used here to avoid confusing the javadoc tool 3027 /** 3028 * An annotation of a package, type, field, parameter or variable. 3029 * An annotation may occur anywhere modifiers occur (it is a 3030 * type of modifier) and may also occur prior to a package definition. 3031 * The notable children are: The annotation name and either a single 3032 * default annotation value or a sequence of name value pairs. 3033 * Annotation values may also be annotations themselves. 3034 * 3035 * <p>For example:</p> 3036 * 3037 * <pre> 3038 * @MyAnnotation(someField1 = "Hello", 3039 * someField2 = @SomeOtherAnnotation) 3040 * </pre> 3041 * 3042 * <p>parses as:</p> 3043 * 3044 * <pre> 3045 * +--ANNOTATION 3046 * | 3047 * +--AT (@) 3048 * +--IDENT (MyAnnotation) 3049 * +--LPAREN (() 3050 * +--ANNOTATION_MEMBER_VALUE_PAIR 3051 * | 3052 * +--IDENT (someField1) 3053 * +--ASSIGN (=) 3054 * +--ANNOTATION 3055 * | 3056 * +--AT (@) 3057 * +--IDENT (SomeOtherAnnotation) 3058 * +--ANNOTATION_MEMBER_VALUE_PAIR 3059 * | 3060 * +--IDENT (someField2) 3061 * +--ASSIGN (=) 3062 * +--STRING_LITERAL ("Hello") 3063 * +--RPAREN ()) 3064 * </pre> 3065 * 3066 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3067 * JSR201</a> 3068 * @see #MODIFIERS 3069 * @see #IDENT 3070 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3071 */ 3072 public static final int ANNOTATION = 3073 GeneratedJavaTokenTypes.ANNOTATION; 3074 3075 /** 3076 * An initialisation of an annotation member with a value. 3077 * Its children are the name of the member, the assignment literal 3078 * and the (compile-time constant conditional expression) value. 3079 * 3080 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3081 * JSR201</a> 3082 * @see #ANNOTATION 3083 * @see #IDENT 3084 */ 3085 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 3086 GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR; 3087 3088 /** 3089 * An annotation array member initialisation. 3090 * Initializers can not be nested. 3091 * Am initializer may be present as a default to a annotation 3092 * member, as the single default value to an annotation 3093 * (e.g. @Annotation({1,2})) or as the value of an annotation 3094 * member value pair. 3095 * 3096 * <p>For example:</p> 3097 * 3098 * <pre> 3099 * { 1, 2 } 3100 * </pre> 3101 * 3102 * <p>parses as:</p> 3103 * 3104 * <pre> 3105 * +--ANNOTATION_ARRAY_INIT ({) 3106 * | 3107 * +--NUM_INT (1) 3108 * +--COMMA (,) 3109 * +--NUM_INT (2) 3110 * +--RCURLY (}) 3111 * </pre> 3112 * 3113 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3114 * JSR201</a> 3115 * @see #ANNOTATION 3116 * @see #IDENT 3117 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3118 */ 3119 public static final int ANNOTATION_ARRAY_INIT = 3120 GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT; 3121 3122 /** 3123 * A list of type parameters to a class, interface or 3124 * method definition. Children are LT, at least one 3125 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 3126 * TYPE_PARAMETER and a final GT. 3127 * 3128 * <p>For example:</p> 3129 * 3130 * <pre> 3131 * public class Blah<A, B> 3132 * { 3133 * } 3134 * </pre> 3135 * 3136 * <p>parses as:</p> 3137 * 3138 * <pre> 3139 * +--CLASS_DEF ({) 3140 * | 3141 * +--MODIFIERS 3142 * | 3143 * +--LITERAL_PUBLIC (public) 3144 * +--LITERAL_CLASS (class) 3145 * +--IDENT (Blah) 3146 * +--TYPE_PARAMETERS 3147 * | 3148 * +--GENERIC_START (<) 3149 * +--TYPE_PARAMETER 3150 * | 3151 * +--IDENT (A) 3152 * +--COMMA (,) 3153 * +--TYPE_PARAMETER 3154 * | 3155 * +--IDENT (B) 3156 * +--GENERIC_END (>) 3157 * +--OBJBLOCK 3158 * | 3159 * +--LCURLY ({) 3160 * +--NUM_INT (1) 3161 * +--COMMA (,) 3162 * +--NUM_INT (2) 3163 * +--RCURLY (}) 3164 * </pre> 3165 * 3166 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3167 * JSR14</a> 3168 * @see #GENERIC_START 3169 * @see #GENERIC_END 3170 * @see #TYPE_PARAMETER 3171 * @see #COMMA 3172 */ 3173 public static final int TYPE_PARAMETERS = 3174 GeneratedJavaTokenTypes.TYPE_PARAMETERS; 3175 3176 /** 3177 * A type parameter to a class, interface or method definition. 3178 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 3179 * 3180 * <p>For example:</p> 3181 * 3182 * <pre> 3183 * A extends Collection 3184 * </pre> 3185 * 3186 * <p>parses as:</p> 3187 * 3188 * <pre> 3189 * +--TYPE_PARAMETER 3190 * | 3191 * +--IDENT (A) 3192 * +--TYPE_UPPER_BOUNDS 3193 * | 3194 * +--IDENT (Collection) 3195 * </pre> 3196 * 3197 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3198 * JSR14</a> 3199 * @see #IDENT 3200 * @see #WILDCARD_TYPE 3201 * @see #TYPE_UPPER_BOUNDS 3202 */ 3203 public static final int TYPE_PARAMETER = 3204 GeneratedJavaTokenTypes.TYPE_PARAMETER; 3205 3206 /** 3207 * A list of type arguments to a type reference or 3208 * a method/ctor invocation. Children are GENERIC_START, at least one 3209 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 3210 * TYPE_ARGUMENT, and a final GENERIC_END. 3211 * 3212 * <p>For example:</p> 3213 * 3214 * <pre> 3215 * public Collection<?> a; 3216 * </pre> 3217 * 3218 * <p>parses as:</p> 3219 * 3220 * <pre> 3221 * +--VARIABLE_DEF 3222 * | 3223 * +--MODIFIERS 3224 * | 3225 * +--LITERAL_PUBLIC (public) 3226 * +--TYPE 3227 * | 3228 * +--IDENT (Collection) 3229 * | 3230 * +--TYPE_ARGUMENTS 3231 * | 3232 * +--GENERIC_START (<) 3233 * +--TYPE_ARGUMENT 3234 * | 3235 * +--WILDCARD_TYPE (?) 3236 * +--GENERIC_END (>) 3237 * +--IDENT (a) 3238 * +--SEMI (;) 3239 * </pre> 3240 * 3241 * @see #GENERIC_START 3242 * @see #GENERIC_END 3243 * @see #TYPE_ARGUMENT 3244 * @see #COMMA 3245 */ 3246 public static final int TYPE_ARGUMENTS = 3247 GeneratedJavaTokenTypes.TYPE_ARGUMENTS; 3248 3249 /** 3250 * A type arguments to a type reference or a method/ctor invocation. 3251 * Children are either: type name or wildcard type with possible type 3252 * upper or lower bounds. 3253 * 3254 * <p>For example:</p> 3255 * 3256 * <pre> 3257 * ? super List 3258 * </pre> 3259 * 3260 * <p>parses as:</p> 3261 * 3262 * <pre> 3263 * +--TYPE_ARGUMENT 3264 * | 3265 * +--WILDCARD_TYPE (?) 3266 * +--TYPE_LOWER_BOUNDS 3267 * | 3268 * +--IDENT (List) 3269 * </pre> 3270 * 3271 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3272 * JSR14</a> 3273 * @see #WILDCARD_TYPE 3274 * @see #TYPE_UPPER_BOUNDS 3275 * @see #TYPE_LOWER_BOUNDS 3276 */ 3277 public static final int TYPE_ARGUMENT = 3278 GeneratedJavaTokenTypes.TYPE_ARGUMENT; 3279 3280 /** 3281 * The type that refers to all types. This node has no children. 3282 * 3283 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3284 * JSR14</a> 3285 * @see #TYPE_ARGUMENT 3286 * @see #TYPE_UPPER_BOUNDS 3287 * @see #TYPE_LOWER_BOUNDS 3288 */ 3289 public static final int WILDCARD_TYPE = 3290 GeneratedJavaTokenTypes.WILDCARD_TYPE; 3291 3292 /** 3293 * An upper bounds on a wildcard type argument or type parameter. 3294 * This node has one child - the type that is being used for 3295 * the bounding. 3296 * 3297 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3298 * JSR14</a> 3299 * @see #TYPE_PARAMETER 3300 * @see #TYPE_ARGUMENT 3301 * @see #WILDCARD_TYPE 3302 */ 3303 public static final int TYPE_UPPER_BOUNDS = 3304 GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS; 3305 3306 /** 3307 * A lower bounds on a wildcard type argument. This node has one child 3308 * - the type that is being used for the bounding. 3309 * 3310 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3311 * JSR14</a> 3312 * @see #TYPE_ARGUMENT 3313 * @see #WILDCARD_TYPE 3314 */ 3315 public static final int TYPE_LOWER_BOUNDS = 3316 GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS; 3317 3318 /** 3319 * An 'at' symbol - signifying an annotation instance or the prefix 3320 * to the interface literal signifying the definition of an annotation 3321 * declaration. 3322 * 3323 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3324 * JSR201</a> 3325 */ 3326 public static final int AT = GeneratedJavaTokenTypes.AT; 3327 3328 /** 3329 * A triple dot for variable-length parameters. This token only ever occurs 3330 * in a parameter declaration immediately after the type of the parameter. 3331 * 3332 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3333 * JSR201</a> 3334 */ 3335 public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS; 3336 3337 /** 3338 * '&' symbol when used in a generic upper or lower bounds constrain 3339 * e.g. {@code Comparable<<? extends Serializable, CharSequence>}. 3340 */ 3341 public static final int TYPE_EXTENSION_AND = 3342 GeneratedJavaTokenTypes.TYPE_EXTENSION_AND; 3343 3344 /** 3345 * '<' symbol signifying the start of type arguments or type 3346 * parameters. 3347 */ 3348 public static final int GENERIC_START = 3349 GeneratedJavaTokenTypes.GENERIC_START; 3350 3351 /** 3352 * '>' symbol signifying the end of type arguments or type parameters. 3353 */ 3354 public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END; 3355 3356 /** 3357 * Special lambda symbol '->'. 3358 */ 3359 public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA; 3360 3361 /** 3362 * Beginning of single line comment: '//'. 3363 * 3364 * <pre> 3365 * +--SINGLE_LINE_COMMENT 3366 * | 3367 * +--COMMENT_CONTENT 3368 * </pre> 3369 */ 3370 public static final int SINGLE_LINE_COMMENT = 3371 GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT; 3372 3373 /** 3374 * Beginning of block comment: '/*'. 3375 * 3376 * <pre> 3377 * +--BLOCK_COMMENT_BEGIN 3378 * | 3379 * +--COMMENT_CONTENT 3380 * +--BLOCK_COMMENT_END 3381 * </pre> 3382 */ 3383 public static final int BLOCK_COMMENT_BEGIN = 3384 GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN; 3385 3386 /** 3387 * End of block comment: '* /'. 3388 * 3389 * <pre> 3390 * +--BLOCK_COMMENT_BEGIN 3391 * | 3392 * +--COMMENT_CONTENT 3393 * +--BLOCK_COMMENT_END 3394 * </pre> 3395 */ 3396 public static final int BLOCK_COMMENT_END = 3397 GeneratedJavaTokenTypes.BLOCK_COMMENT_END; 3398 3399 /** 3400 * Text of single-line or block comment. 3401 * 3402 * <pre> 3403 * +--SINGLE_LINE_COMMENT 3404 * | 3405 * +--COMMENT_CONTENT 3406 * </pre> 3407 * 3408 * <pre> 3409 * +--BLOCK_COMMENT_BEGIN 3410 * | 3411 * +--COMMENT_CONTENT 3412 * +--BLOCK_COMMENT_END 3413 * </pre> 3414 */ 3415 public static final int COMMENT_CONTENT = 3416 GeneratedJavaTokenTypes.COMMENT_CONTENT; 3417 3418 /** Prevent instantiation. */ 3419 private TokenTypes() { 3420 } 3421 3422}