001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2021 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.grammar.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 * @noinspection ClassWithTooManyDependents 032 */ 033public final class TokenTypes { 034 035 /** 036 * The end of file token. This is the root node for the source 037 * file. It's children are an optional package definition, zero 038 * or more import statements, and one or more class or interface 039 * definitions. 040 * 041 * @see #PACKAGE_DEF 042 * @see #IMPORT 043 * @see #CLASS_DEF 044 * @see #INTERFACE_DEF 045 **/ 046 public static final int EOF = GeneratedJavaTokenTypes.EOF; 047 /** 048 * Modifiers for type, method, and field declarations. The 049 * modifiers element is always present even though it may have no 050 * children. 051 * <p>For example:</p> 052 * <pre> 053 * public int x; 054 * </pre> 055 * <p>parses as:</p> 056 * <pre> 057 * VARIABLE_DEF -> VARIABLE_DEF 058 * |--MODIFIERS -> MODIFIERS 059 * | `--LITERAL_PUBLIC -> public 060 * |--TYPE -> TYPE 061 * | `--LITERAL_INT -> int 062 * |--IDENT -> x 063 * `--SEMI -> ; 064 * </pre> 065 * 066 * @see <a 067 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 068 * Language Specification, §8</a> 069 * @see #LITERAL_PUBLIC 070 * @see #LITERAL_PROTECTED 071 * @see #LITERAL_PRIVATE 072 * @see #ABSTRACT 073 * @see #LITERAL_STATIC 074 * @see #FINAL 075 * @see #LITERAL_TRANSIENT 076 * @see #LITERAL_VOLATILE 077 * @see #LITERAL_SYNCHRONIZED 078 * @see #LITERAL_NATIVE 079 * @see #STRICTFP 080 * @see #ANNOTATION 081 * @see #LITERAL_DEFAULT 082 **/ 083 public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS; 084 085 /** 086 * An object block. These are children of class, interface, enum, 087 * annotation and enum constant declarations. 088 * Also, object blocks are children of the new keyword when defining 089 * anonymous inner types. 090 * <p>For example:</p> 091 * <pre> 092 * class Test {} 093 * </pre> 094 * <p>parses as:</p> 095 * <pre> 096 * CLASS_DEF -> CLASS_DEF 097 * |--MODIFIERS -> MODIFIERS 098 * |--LITERAL_CLASS -> class 099 * |--IDENT -> Test 100 * `--OBJBLOCK -> OBJBLOCK 101 * |--LCURLY -> { 102 * `--RCURLY -> } 103 * </pre> 104 * 105 * @see #LCURLY 106 * @see #INSTANCE_INIT 107 * @see #STATIC_INIT 108 * @see #CLASS_DEF 109 * @see #CTOR_DEF 110 * @see #METHOD_DEF 111 * @see #VARIABLE_DEF 112 * @see #RCURLY 113 * @see #INTERFACE_DEF 114 * @see #LITERAL_NEW 115 * @see #ENUM_DEF 116 * @see #ENUM_CONSTANT_DEF 117 * @see #ANNOTATION_DEF 118 **/ 119 public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK; 120 /** 121 * A list of statements. 122 * 123 * <p>For example:</p> 124 * <pre> 125 * if (c == 1) { 126 * c = 0; 127 * } 128 * </pre> 129 * <p>parses as:</p> 130 * <pre> 131 * LITERAL_IF -> if 132 * |--LPAREN -> ( 133 * |--EXPR -> EXPR 134 * | `--EQUAL -> == 135 * | |--IDENT -> c 136 * | `--NUM_INT -> 1 137 * |--RPAREN -> ) 138 * `--SLIST -> { 139 * |--EXPR -> EXPR 140 * | `--ASSIGN -> = 141 * | |--IDENT -> c 142 * | `--NUM_INT -> 0 143 * |--SEMI -> ; 144 * `--RCURLY -> } 145 * </pre> 146 * 147 * @see #RCURLY 148 * @see #EXPR 149 * @see #LABELED_STAT 150 * @see #LITERAL_THROWS 151 * @see #LITERAL_RETURN 152 * @see #SEMI 153 * @see #METHOD_DEF 154 * @see #CTOR_DEF 155 * @see #LITERAL_FOR 156 * @see #LITERAL_WHILE 157 * @see #LITERAL_IF 158 * @see #LITERAL_ELSE 159 * @see #CASE_GROUP 160 **/ 161 public static final int SLIST = GeneratedJavaTokenTypes.SLIST; 162 /** 163 * A constructor declaration. 164 * 165 * <p>For example:</p> 166 * <pre> 167 * public SpecialEntry(int value, String text) 168 * { 169 * this.value = value; 170 * this.text = text; 171 * } 172 * </pre> 173 * <p>parses as:</p> 174 * <pre> 175 * CTOR_DEF -> CTOR_DEF 176 * |--MODIFIERS -> MODIFIERS 177 * | `--LITERAL_PUBLIC -> public 178 * |--IDENT -> SpecialEntry 179 * |--LPAREN -> ( 180 * |--PARAMETERS -> PARAMETERS 181 * | |--PARAMETER_DEF -> PARAMETER_DEF 182 * | | |--MODIFIERS -> MODIFIERS 183 * | | |--TYPE -> TYPE 184 * | | | `--LITERAL_INT -> int 185 * | | `--IDENT -> value 186 * | |--COMMA -> , 187 * | `--PARAMETER_DEF -> PARAMETER_DEF 188 * | |--MODIFIERS -> MODIFIERS 189 * | |--TYPE -> TYPE 190 * | | `--IDENT -> String 191 * | `--IDENT -> text 192 * |--RPAREN -> ) 193 * `--SLIST -> { 194 * |--EXPR -> EXPR 195 * | `--ASSIGN -> = 196 * | |--DOT -> . 197 * | |--LITERAL_THIS -> this 198 * | | `--IDENT -> value 199 * | `--IDENT -> value 200 * |--SEMI -> ; 201 * |--EXPR -> EXPR 202 * | `--ASSIGN -> = 203 * | |--DOT -> . 204 * | | |--LITERAL_THIS -> this 205 * | | `--IDENT -> text 206 * | `--IDENT -> text 207 * |--SEMI -> ; 208 * `--RCURLY -> } 209 * </pre> 210 * 211 * @see #OBJBLOCK 212 * @see #CLASS_DEF 213 **/ 214 public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF; 215 /** 216 * A method declaration. The children are modifiers, type parameters, 217 * return type, method name, parameter list, an optional throws list, and 218 * statement list. The statement list is omitted if the method 219 * declaration appears in an interface declaration. Method 220 * declarations may appear inside object blocks of class 221 * declarations, interface declarations, enum declarations, 222 * enum constant declarations or anonymous inner-class declarations. 223 * 224 * <p>For example:</p> 225 * 226 * <pre> 227 * public static int square(int x) 228 * { 229 * return x*x; 230 * } 231 * </pre> 232 * 233 * <p>parses as:</p> 234 * 235 * <pre> 236 * --METHOD_DEF -> METHOD_DEF 237 * |--MODIFIERS -> MODIFIERS 238 * | |--LITERAL_PUBLIC -> public 239 * | `--LITERAL_STATIC -> static 240 * |--TYPE -> TYPE 241 * | `--LITERAL_INT -> int 242 * |--IDENT -> square 243 * |--LPAREN -> ( 244 * |--PARAMETERS -> PARAMETERS 245 * | `--PARAMETER_DEF -> PARAMETER_DEF 246 * | |--MODIFIERS -> MODIFIERS 247 * | |--TYPE -> TYPE 248 * | | `--LITERAL_INT -> int 249 * | `--IDENT -> x 250 * |--RPAREN -> ) 251 * `--SLIST -> { 252 * |--LITERAL_RETURN -> return 253 * | |--EXPR -> EXPR 254 * | | `--STAR -> * 255 * | | |--IDENT -> x 256 * | | `--IDENT -> x 257 * | `--SEMI -> ; 258 * `--RCURLY -> } 259 * </pre> 260 * 261 * @see #MODIFIERS 262 * @see #TYPE_PARAMETERS 263 * @see #TYPE 264 * @see #IDENT 265 * @see #PARAMETERS 266 * @see #LITERAL_THROWS 267 * @see #SLIST 268 * @see #OBJBLOCK 269 **/ 270 public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF; 271 /** 272 * A field or local variable declaration. The children are 273 * modifiers, type, the identifier name, and an optional 274 * assignment statement. 275 * 276 * <p>For example:</p> 277 * <pre> 278 * final int PI = 3.14; 279 * </pre> 280 * <p>parses as:</p> 281 * <pre> 282 * VARIABLE_DEF -> VARIABLE_DEF 283 * |--MODIFIERS -> MODIFIERS 284 * | `--FINAL -> final 285 * |--TYPE -> TYPE 286 * | `--LITERAL_INT -> int 287 * |--IDENT -> PI 288 * |--ASSIGN -> = 289 * | `--EXPR -> EXPR 290 * | `--NUM_FLOAT -> 3.14 291 * `--SEMI -> ; 292 * </pre> 293 * 294 * @see #MODIFIERS 295 * @see #TYPE 296 * @see #IDENT 297 * @see #ASSIGN 298 **/ 299 public static final int VARIABLE_DEF = 300 GeneratedJavaTokenTypes.VARIABLE_DEF; 301 302 /** 303 * An instance initializer. Zero or more instance initializers 304 * may appear in class and enum definitions. This token will be a child 305 * of the object block of the declaring type. 306 * 307 * @see <a 308 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java 309 * Language Specification§8.6</a> 310 * @see #SLIST 311 * @see #OBJBLOCK 312 **/ 313 public static final int INSTANCE_INIT = 314 GeneratedJavaTokenTypes.INSTANCE_INIT; 315 316 /** 317 * A static initialization block. Zero or more static 318 * initializers may be children of the object block of a class 319 * or enum declaration (interfaces cannot have static initializers). The 320 * first and only child is a statement list. 321 * 322 * <p>For Example:</p> 323 * <pre> 324 * static { 325 * num = 10; 326 * } 327 * </pre> 328 * <p>parses as:</p> 329 * <pre> 330 * STATIC_INIT -> STATIC_INIT 331 * `--SLIST -> { 332 * |--EXPR -> EXPR 333 * | `--ASSIGN -> = 334 * | |--IDENT -> num 335 * | `--NUM_INT -> 10 336 * |--SEMI -> ; 337 * `--RCURLY -> } 338 * </pre> 339 * 340 * @see <a 341 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java 342 * Language Specification, §8.7</a> 343 * @see #SLIST 344 * @see #OBJBLOCK 345 **/ 346 public static final int STATIC_INIT = 347 GeneratedJavaTokenTypes.STATIC_INIT; 348 349 /** 350 * A type. This is either a return type of a method or a type of 351 * a variable or field. The first child of this element is the 352 * actual type. This may be a primitive type, an identifier, a 353 * dot which is the root of a fully qualified type, or an array of 354 * any of these. The second child may be type arguments to the type. 355 * 356 * <p>For example:</p> 357 * <pre>boolean var = true;</pre> 358 * <p>parses as:</p> 359 * <pre> 360 * |--VARIABLE_DEF -> VARIABLE_DEF 361 * | |--MODIFIERS -> MODIFIERS 362 * | |--TYPE -> TYPE 363 * | | `--LITERAL_BOOLEAN -> boolean 364 * | |--IDENT -> var 365 * | `--ASSIGN -> = 366 * | `--EXPR -> EXPR 367 * | `--LITERAL_TRUE -> true 368 * |--SEMI -> ; 369 * </pre> 370 * 371 * @see #VARIABLE_DEF 372 * @see #METHOD_DEF 373 * @see #PARAMETER_DEF 374 * @see #IDENT 375 * @see #DOT 376 * @see #LITERAL_VOID 377 * @see #LITERAL_BOOLEAN 378 * @see #LITERAL_BYTE 379 * @see #LITERAL_CHAR 380 * @see #LITERAL_SHORT 381 * @see #LITERAL_INT 382 * @see #LITERAL_FLOAT 383 * @see #LITERAL_LONG 384 * @see #LITERAL_DOUBLE 385 * @see #ARRAY_DECLARATOR 386 * @see #TYPE_ARGUMENTS 387 **/ 388 public static final int TYPE = GeneratedJavaTokenTypes.TYPE; 389 /** 390 * A class declaration. 391 * 392 * <p>For example:</p> 393 * <pre> 394 * public class Test { 395 * } 396 * </pre> 397 * <p>parses as:</p> 398 * <pre> 399 * CLASS_DEF -> CLASS_DEF 400 * |--MODIFIERS -> MODIFIERS 401 * | `--LITERAL_PUBLIC -> public 402 * |--LITERAL_CLASS -> class 403 * |--IDENT -> Test 404 * `--OBJBLOCK -> OBJBLOCK 405 * |--LCURLY -> { 406 * `--RCURLY -> } 407 * </pre> 408 * 409 * @see <a 410 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 411 * Language Specification, §8</a> 412 * @see #MODIFIERS 413 * @see #IDENT 414 * @see #EXTENDS_CLAUSE 415 * @see #IMPLEMENTS_CLAUSE 416 * @see #OBJBLOCK 417 * @see #LITERAL_NEW 418 **/ 419 public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF; 420 /** 421 * An interface declaration. 422 * 423 * <p>For example:</p> 424 * 425 * <pre> 426 * public interface MyInterface { 427 * 428 * } 429 * </pre> 430 * 431 * <p>parses as:</p> 432 * 433 * <pre> 434 * INTERFACE_DEF -> INTERFACE_DEF 435 * |--MODIFIERS -> MODIFIERS 436 * | `--LITERAL_PUBLIC -> public 437 * |--LITERAL_INTERFACE -> interface 438 * |--IDENT -> MyInterface 439 * `--OBJBLOCK -> OBJBLOCK 440 * |--LCURLY -> { 441 * `--RCURLY -> } 442 * </pre> 443 * 444 * @see <a 445 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java 446 * Language Specification, §9</a> 447 * @see #MODIFIERS 448 * @see #IDENT 449 * @see #EXTENDS_CLAUSE 450 * @see #OBJBLOCK 451 **/ 452 public static final int INTERFACE_DEF = 453 GeneratedJavaTokenTypes.INTERFACE_DEF; 454 455 /** 456 * The package declaration. This is optional, but if it is 457 * included, then there is only one package declaration per source 458 * file and it must be the first non-comment in the file. A package 459 * declaration may be annotated in which case the annotations comes 460 * before the rest of the declaration (and are the first children). 461 * 462 * <p>For example:</p> 463 * 464 * <pre> 465 * package com.puppycrawl.tools.checkstyle.api; 466 * </pre> 467 * 468 * <p>parses as:</p> 469 * 470 * <pre> 471 * PACKAGE_DEF -> package 472 * |--ANNOTATIONS -> ANNOTATIONS 473 * |--DOT -> . 474 * | |--DOT -> . 475 * | | |--DOT -> . 476 * | | | |--DOT -> . 477 * | | | | |--IDENT -> com 478 * | | | | `--IDENT -> puppycrawl 479 * | | | `--IDENT -> tools 480 * | | `--IDENT -> checkstyle 481 * | `--IDENT -> api 482 * `--SEMI -> ; 483 * </pre> 484 * 485 * @see <a 486 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java 487 * Language Specification §7.4</a> 488 * @see #DOT 489 * @see #IDENT 490 * @see #SEMI 491 * @see #ANNOTATIONS 492 * @see FullIdent 493 **/ 494 public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF; 495 /** 496 * An array declaration. 497 * 498 * <p>If the array declaration represents a type, then the type of 499 * the array elements is the first child. Multidimensional arrays 500 * may be regarded as arrays of arrays. In other words, the first 501 * child of the array declaration is another array 502 * declaration.</p> 503 * 504 * <p>For example:</p> 505 * <pre> 506 * int[] x; 507 * </pre> 508 * <p>parses as:</p> 509 * <pre> 510 * VARIABLE_DEF -> VARIABLE_DEF 511 * |--MODIFIERS -> MODIFIERS 512 * |--TYPE -> TYPE 513 * | |--LITERAL_INT -> int 514 * | `--ARRAY_DECLARATOR -> [ 515 * | `--RBRACK -> ] 516 * |--IDENT -> x 517 * `--SEMI -> ; 518 * </pre> 519 * 520 * <p>The array declaration may also represent an inline array 521 * definition. In this case, the first child will be either an 522 * expression specifying the length of the array or an array 523 * initialization block.</p> 524 * 525 * @see <a 526 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java 527 * Language Specification §10</a> 528 * @see #TYPE 529 * @see #ARRAY_INIT 530 **/ 531 public static final int ARRAY_DECLARATOR = 532 GeneratedJavaTokenTypes.ARRAY_DECLARATOR; 533 534 /** 535 * An extends clause. This appear as part of class and interface 536 * definitions. This element appears even if the 537 * {@code extends} keyword is not explicitly used. The child 538 * is an optional identifier. 539 * 540 * <p>For example:</p> 541 * <pre> 542 * public class Test extends ArrayList { 543 * } 544 * </pre> 545 * <p>parses as:</p> 546 * <pre> 547 * CLASS_DEF -> CLASS_DEF 548 * |--MODIFIERS -> MODIFIERS 549 * | `--LITERAL_PUBLIC -> public 550 * |--LITERAL_CLASS -> class 551 * |--IDENT -> Test 552 * |--EXTENDS_CLAUSE -> extends 553 * | `--IDENT -> ArrayList 554 * `--OBJBLOCK -> OBJBLOCK 555 * |--LCURLY -> { 556 * `--RCURLY -> } 557 * </pre> 558 * 559 * @see #IDENT 560 * @see #DOT 561 * @see #CLASS_DEF 562 * @see #INTERFACE_DEF 563 * @see FullIdent 564 **/ 565 public static final int EXTENDS_CLAUSE = 566 GeneratedJavaTokenTypes.EXTENDS_CLAUSE; 567 568 /** 569 * An implements clause. This always appears in a class or enum 570 * declaration, even if there are no implemented interfaces. The 571 * children are a comma separated list of zero or more 572 * identifiers. 573 * 574 * <p>For example:</p> 575 * <pre> 576 * public class MyClass implements Collection { 577 * 578 * } 579 * </pre> 580 * <p>parses as:</p> 581 * <pre> 582 * CLASS_DEF -> CLASS_DEF 583 * |--MODIFIERS -> MODIFIERS 584 * | `--LITERAL_PUBLIC -> public 585 * |--LITERAL_CLASS -> class 586 * |--IDENT -> MyClass 587 * |--IMPLEMENTS_CLAUSE -> implements 588 * | `--IDENT -> Collection 589 * `--OBJBLOCK -> OBJBLOCK 590 * |--LCURLY -> { 591 * `--RCURLY -> } 592 * </pre> 593 * 594 * @see #IDENT 595 * @see #DOT 596 * @see #COMMA 597 * @see #CLASS_DEF 598 * @see #ENUM_DEF 599 **/ 600 public static final int IMPLEMENTS_CLAUSE = 601 GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE; 602 603 /** 604 * A list of parameters to a method or constructor. The children 605 * are zero or more parameter declarations separated by commas. 606 * 607 * <p>For example</p> 608 * <pre> 609 * int start, int end 610 * </pre> 611 * <p>parses as:</p> 612 * <pre> 613 * +--PARAMETERS 614 * | 615 * +--PARAMETER_DEF 616 * | 617 * +--MODIFIERS 618 * +--TYPE 619 * | 620 * +--LITERAL_INT (int) 621 * +--IDENT (start) 622 * +--COMMA (,) 623 * +--PARAMETER_DEF 624 * | 625 * +--MODIFIERS 626 * +--TYPE 627 * | 628 * +--LITERAL_INT (int) 629 * +--IDENT (end) 630 * </pre> 631 * 632 * @see #PARAMETER_DEF 633 * @see #COMMA 634 * @see #METHOD_DEF 635 * @see #CTOR_DEF 636 **/ 637 public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS; 638 /** 639 * A parameter declaration. The last parameter in a list of parameters may 640 * be variable length (indicated by the ELLIPSIS child node immediately 641 * after the TYPE child). 642 * <p>For example</p> 643 * <pre> 644 * void foo(int firstParameter, int... secondParameter) {} 645 * </pre> 646 * <p>parses as:</p> 647 * <pre> 648 * METHOD_DEF -> METHOD_DEF 649 * |--MODIFIERS -> MODIFIERS 650 * |--TYPE -> TYPE 651 * | `--LITERAL_VOID -> void 652 * |--IDENT -> foo 653 * |--LPAREN -> ( 654 * |--PARAMETERS -> PARAMETERS 655 * | |--PARAMETER_DEF -> PARAMETER_DEF 656 * | | |--MODIFIERS -> MODIFIERS 657 * | | |--TYPE -> TYPE 658 * | | | `--LITERAL_INT -> int 659 * | | `--IDENT -> firstParameter 660 * | |--COMMA -> , 661 * | `--PARAMETER_DEF -> PARAMETER_DEF 662 * | |--MODIFIERS -> MODIFIERS 663 * | |--TYPE -> TYPE 664 * | | `--LITERAL_INT -> int 665 * | |--ELLIPSIS -> ... 666 * | `--IDENT -> secondParameter 667 * |--RPAREN -> ) 668 * `--SLIST -> { 669 * `--RCURLY -> } 670 * </pre> 671 * 672 * @see #MODIFIERS 673 * @see #TYPE 674 * @see #IDENT 675 * @see #PARAMETERS 676 * @see #ELLIPSIS 677 **/ 678 public static final int PARAMETER_DEF = 679 GeneratedJavaTokenTypes.PARAMETER_DEF; 680 681 /** 682 * A labeled statement. 683 * 684 * <p>For example:</p> 685 * <pre> 686 * outer: 687 * while (i < 10) { 688 * if (i == 5) 689 * continue outer; 690 * i++; 691 * } 692 * </pre> 693 * <p>parses as:</p> 694 * <pre> 695 * LABELED_STAT -> : 696 * |--IDENT -> outer 697 * `--LITERAL_WHILE -> while 698 * |--LPAREN -> ( 699 * |--EXPR -> EXPR 700 * | `--LT -> < 701 * | |--IDENT -> i 702 * | `--NUM_INT -> 10 703 * |--RPAREN -> ) 704 * `--SLIST -> { 705 * |--LITERAL_IF -> if 706 * | |--LPAREN -> ( 707 * | |--EXPR -> EXPR 708 * | | `--EQUAL -> == 709 * | | |--IDENT -> i 710 * | | `--NUM_INT -> 5 711 * | |--RPAREN -> ) 712 * | `--LITERAL_CONTINUE -> continue 713 * | |--IDENT -> outer 714 * | `--SEMI -> ; 715 * |--EXPR -> EXPR 716 * | `--POST_INC -> ++ 717 * | `--IDENT -> i 718 * |--SEMI -> ; 719 * `--RCURLY -> } 720 * </pre> 721 * 722 * @see <a 723 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java 724 * Language Specification, §14.7</a> 725 * @see #SLIST 726 **/ 727 public static final int LABELED_STAT = 728 GeneratedJavaTokenTypes.LABELED_STAT; 729 730 /** 731 * A type-cast. 732 * 733 * <p>For example:</p> 734 * <pre> 735 * (String)it.next() 736 * </pre> 737 * <p>parses as:</p> 738 * <pre> 739 * `--TYPECAST -> ( 740 * |--TYPE -> TYPE 741 * | `--IDENT -> String 742 * |--RPAREN -> ) 743 * `--METHOD_CALL -> ( 744 * |--DOT -> . 745 * | |--IDENT -> it 746 * | `--IDENT -> next 747 * |--ELIST -> ELIST 748 * `--RPAREN -> ) 749 * </pre> 750 * 751 * @see <a 752 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java 753 * Language Specification, §15.16</a> 754 * @see #EXPR 755 * @see #TYPE 756 * @see #TYPE_ARGUMENTS 757 * @see #RPAREN 758 **/ 759 public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST; 760 /** 761 * The array index operator. 762 * 763 * <p>For example:</p> 764 * <pre> 765 * arr[0] = 10; 766 * </pre> 767 * <p>parses as:</p> 768 * <pre> 769 * |--EXPR -> EXPR 770 * | `--ASSIGN -> = 771 * | |--INDEX_OP -> [ 772 * | | |--IDENT -> arr 773 * | | |--EXPR -> EXPR 774 * | | | `--NUM_INT -> 0 775 * | | `--RBRACK -> ] 776 * | `--NUM_INT -> 10 777 * |--SEMI -> ; 778 * </pre> 779 * 780 * @see #EXPR 781 **/ 782 public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP; 783 /** 784 * The {@code ++} (postfix increment) operator. 785 * 786 * <p>For example:</p> 787 * <pre> 788 * a++; 789 * </pre> 790 * <p>parses as:</p> 791 * <pre> 792 * |--EXPR -> EXPR 793 * | `--POST_INC -> ++ 794 * | `--IDENT -> a 795 * |--SEMI -> ; 796 * </pre> 797 * 798 * @see <a 799 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java 800 * Language Specification, §15.14.1</a> 801 * @see #EXPR 802 * @see #INC 803 **/ 804 public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC; 805 /** 806 * The {@code --} (postfix decrement) operator. 807 * 808 * <p>For example:</p> 809 * <pre> 810 * a--; 811 * </pre> 812 * <p>parses as:</p> 813 * <pre> 814 * |--EXPR -> EXPR 815 * | `--POST_DEC -> -- 816 * | `--IDENT -> a 817 * |--SEMI -> ; 818 * </pre> 819 * 820 * @see <a 821 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java 822 * Language Specification, §15.14.2</a> 823 * @see #EXPR 824 * @see #DEC 825 **/ 826 public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC; 827 /** 828 * A method call. A method call may have type arguments however these 829 * are attached to the appropriate node in the qualified method name. 830 * 831 * <p>For example:</p> 832 * <pre> 833 * Integer.parseInt("123"); 834 * </pre> 835 * 836 * <p>parses as:</p> 837 * <pre> 838 * |--EXPR -> EXPR 839 * | `--METHOD_CALL -> ( 840 * | |--DOT -> . 841 * | | |--IDENT -> Integer 842 * | | `--IDENT -> parseInt 843 * | |--ELIST -> ELIST 844 * | | `--EXPR -> EXPR 845 * | | `--STRING_LITERAL -> "123" 846 * | `--RPAREN -> ) 847 * |--SEMI -> ; 848 * </pre> 849 * 850 * 851 * @see #IDENT 852 * @see #TYPE_ARGUMENTS 853 * @see #DOT 854 * @see #ELIST 855 * @see #RPAREN 856 * @see FullIdent 857 **/ 858 public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL; 859 860 /** 861 * A reference to a method or constructor without arguments. Part of Java 8 syntax. 862 * The token should be used for subscribing for double colon literal. 863 * {@link #DOUBLE_COLON} token does not appear in the tree. 864 * 865 * <p>For example:</p> 866 * <pre> 867 * Comparator<String> compare = String::compareToIgnoreCase; 868 * </pre> 869 * 870 * <p>parses as: 871 * <pre> 872 * |--VARIABLE_DEF -> VARIABLE_DEF 873 * | |--MODIFIERS -> MODIFIERS 874 * | |--TYPE -> TYPE 875 * | | |--IDENT -> Comparator 876 * | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 877 * | | |--GENERIC_START -> < 878 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 879 * | | | `--IDENT -> String 880 * | | `--GENERIC_END -> > 881 * | |--IDENT -> compare 882 * | `--ASSIGN -> = 883 * | `--EXPR -> EXPR 884 * | `--METHOD_REF -> :: 885 * | |--IDENT -> String 886 * | `--IDENT -> compareToIgnoreCase 887 * |--SEMI -> ; 888 * </pre> 889 * 890 * @see #IDENT 891 * @see #DOUBLE_COLON 892 */ 893 public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF; 894 /** 895 * An expression. Operators with lower precedence appear at a 896 * higher level in the tree than operators with higher precedence. 897 * Parentheses are siblings to the operator they enclose. 898 * 899 * <p>For example:</p> 900 * <pre> 901 * int x = 4 + 2 * (5 % 3) + (1 << 3) - 4 * 5; 902 * </pre> 903 * <p>parses as:</p> 904 * <pre> 905 * |--VARIABLE_DEF -> VARIABLE_DEF 906 * | |--MODIFIERS -> MODIFIERS 907 * | |--TYPE -> TYPE 908 * | | `--LITERAL_INT -> int 909 * | |--IDENT -> x 910 * | `--ASSIGN -> = 911 * | `--EXPR -> EXPR 912 * | `--MINUS -> - 913 * | |--PLUS -> + 914 * | | |--PLUS -> + 915 * | | | |--NUM_INT -> 4 916 * | | | `--STAR -> * 917 * | | | |--NUM_INT -> 2 918 * | | | |--LPAREN -> ( 919 * | | | |--MOD -> % 920 * | | | | |--NUM_INT -> 5 921 * | | | | `--NUM_INT -> 3 922 * | | | `--RPAREN -> ) 923 * | | |--LPAREN -> ( 924 * | | |--SL -> << 925 * | | | |--NUM_INT -> 1 926 * | | | `--NUM_INT -> 3 927 * | | `--RPAREN -> ) 928 * | `--STAR -> * 929 * | |--NUM_INT -> 4 930 * | `--NUM_INT -> 5 931 * |--SEMI -> ; 932 * </pre> 933 * 934 * @see #ELIST 935 * @see #ASSIGN 936 * @see #LPAREN 937 * @see #RPAREN 938 **/ 939 public static final int EXPR = GeneratedJavaTokenTypes.EXPR; 940 /** 941 * An array initialization. This may occur as part of an array 942 * declaration or inline with {@code new}. 943 * 944 * <p>For example:</p> 945 * <pre> 946 * int[] y = 947 * { 948 * 1, 949 * 2, 950 * }; 951 * </pre> 952 * <p>parses as:</p> 953 * <pre> 954 * VARIABLE_DEF -> VARIABLE_DEF 955 * |--MODIFIERS -> MODIFIERS 956 * |--TYPE -> TYPE 957 * | |--LITERAL_INT -> int 958 * | `--ARRAY_DECLARATOR -> [ 959 * | `--RBRACK -> ] 960 * |--IDENT -> y 961 * |--ASSIGN -> = 962 * | `--ARRAY_INIT -> { 963 * | |--EXPR -> EXPR 964 * | | `--NUM_INT -> 1 965 * | |--COMMA -> , 966 * | |--EXPR -> EXPR 967 * | | `--NUM_INT -> 2 968 * | |--COMMA -> , 969 * | `--RCURLY -> } 970 * `--SEMI -> ; 971 * </pre> 972 * 973 * <p>Also consider:</p> 974 * <pre> 975 * int[] z = new int[] 976 * { 977 * 1, 978 * 2, 979 * }; 980 * </pre> 981 * <p>which parses as:</p> 982 * <pre> 983 * VARIABLE_DEF -> VARIABLE_DEF 984 * |--MODIFIERS -> MODIFIERS 985 * |--TYPE -> TYPE [2:4] 986 * | |--LITERAL_INT -> int 987 * | `--ARRAY_DECLARATOR -> [ 988 * | `--RBRACK -> ] 989 * |--IDENT -> z 990 * |--ASSIGN -> = 991 * | `--EXPR -> EXPR 992 * | `--LITERAL_NEW -> new 993 * | |--LITERAL_INT -> int 994 * | |--ARRAY_DECLARATOR -> [ 995 * | | `--RBRACK -> ] 996 * | `--ARRAY_INIT -> { 997 * | |--EXPR -> EXPR 998 * | | `--NUM_INT -> 1 999 * | |--COMMA -> , 1000 * | |--EXPR -> EXPR 1001 * | | `--NUM_INT -> 2 1002 * | |--COMMA -> , 1003 * | `--RCURLY -> } 1004 * `--SEMI -> ; 1005 * </pre> 1006 * 1007 * @see #ARRAY_DECLARATOR 1008 * @see #TYPE 1009 * @see #LITERAL_NEW 1010 * @see #COMMA 1011 **/ 1012 public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT; 1013 /** 1014 * An import declaration. Import declarations are option, but 1015 * must appear after the package declaration and before the first type 1016 * declaration. 1017 * 1018 * <p>For example:</p> 1019 * 1020 * <pre> 1021 * import java.io.IOException; 1022 * </pre> 1023 * 1024 * <p>parses as:</p> 1025 * 1026 * <pre> 1027 * IMPORT -> import 1028 * |--DOT -> . 1029 * | |--DOT -> . 1030 * | | |--IDENT -> java 1031 * | | `--IDENT -> io 1032 * | `--IDENT -> IOException 1033 * `--SEMI -> ; 1034 * </pre> 1035 * 1036 * @see <a 1037 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java 1038 * Language Specification §7.5</a> 1039 * @see #DOT 1040 * @see #IDENT 1041 * @see #STAR 1042 * @see #SEMI 1043 * @see FullIdent 1044 **/ 1045 public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT; 1046 /** 1047 * The {@code -} (unary minus) operator. 1048 * <p>For example:</p> 1049 * <pre> 1050 * a = -b; 1051 * </pre> 1052 * <p>parses as:</p> 1053 * <pre> 1054 * |--EXPR -> EXPR 1055 * | `--ASSIGN -> = 1056 * | |--IDENT -> a 1057 * | `--UNARY_MINUS -> - 1058 * | `--IDENT -> b 1059 * |--SEMI -> ; 1060 * </pre> 1061 * 1062 * @see <a 1063 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java 1064 * Language Specification, §15.15.4</a> 1065 * @see #EXPR 1066 **/ 1067 public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS; 1068 /** 1069 * The {@code +} (unary plus) operator. 1070 * <p>For example:</p> 1071 * <pre> 1072 * a = + b; 1073 * </pre> 1074 * <p>parses as:</p> 1075 * <pre> 1076 * |--EXPR -> EXPR 1077 * | `--ASSIGN -> = 1078 * | |--IDENT -> a 1079 * | `--UNARY_PLUS -> + 1080 * | `--IDENT -> b 1081 * |--SEMI -> ; 1082 * </pre> 1083 * 1084 * @see <a 1085 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java 1086 * Language Specification, §15.15.3</a> 1087 * @see #EXPR 1088 **/ 1089 public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS; 1090 /** 1091 * A group of case clauses. Case clauses with no associated 1092 * statements are grouped together into a case group. The last 1093 * child is a statement list containing the statements to execute 1094 * upon a match. 1095 * 1096 * <p>For example:</p> 1097 * <pre> 1098 * case 0: 1099 * case 1: 1100 * case 2: 1101 * x = 3; 1102 * break; 1103 * </pre> 1104 * <p>parses as:</p> 1105 * <pre> 1106 * CASE_GROUP -> CASE_GROUP 1107 * |--LITERAL_CASE -> case 1108 * | |--EXPR -> EXPR 1109 * | | `--NUM_INT -> 0 1110 * | `--COLON -> : 1111 * |--LITERAL_CASE -> case 1112 * | |--EXPR -> EXPR 1113 * | | `--NUM_INT -> 1 1114 * | `--COLON -> : 1115 * |--LITERAL_CASE -> case 1116 * | |--EXPR -> EXPR 1117 * | | `--NUM_INT -> 2 1118 * | `--COLON -> : 1119 * `--SLIST -> SLIST 1120 * |--EXPR -> EXPR 1121 * | `--ASSIGN -> = 1122 * | |--IDENT -> x 1123 * | `--NUM_INT -> 3 1124 * |--SEMI -> ; 1125 * `--LITERAL_BREAK -> break 1126 * `--SEMI -> ; 1127 * </pre> 1128 * 1129 * @see #LITERAL_CASE 1130 * @see #LITERAL_DEFAULT 1131 * @see #LITERAL_SWITCH 1132 * @see #LITERAL_YIELD 1133 **/ 1134 public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP; 1135 /** 1136 * An expression list. The children are a comma separated list of 1137 * expressions. 1138 * 1139 * @see #LITERAL_NEW 1140 * @see #FOR_INIT 1141 * @see #FOR_ITERATOR 1142 * @see #EXPR 1143 * @see #METHOD_CALL 1144 * @see #CTOR_CALL 1145 * @see #SUPER_CTOR_CALL 1146 **/ 1147 public static final int ELIST = GeneratedJavaTokenTypes.ELIST; 1148 /** 1149 * A for loop initializer. This is a child of 1150 * {@code LITERAL_FOR}. The children of this element may be 1151 * a comma separated list of variable declarations, an expression 1152 * list, or empty. 1153 * 1154 * <p>For example:</p> 1155 * <pre> 1156 * for (int i = 0; i < arr.length; i++) {} 1157 * </pre> 1158 * <p>parses as:</p> 1159 * <pre> 1160 * LITERAL_FOR -> for 1161 * |--LPAREN -> ( 1162 * |--FOR_INIT -> FOR_INIT 1163 * | `--VARIABLE_DEF -> VARIABLE_DEF 1164 * | |--MODIFIERS -> MODIFIERS 1165 * | |--TYPE -> TYPE 1166 * | | `--LITERAL_INT -> int 1167 * | |--IDENT -> i 1168 * | `--ASSIGN -> = 1169 * | `--EXPR -> EXPR 1170 * | `--NUM_INT -> 0 1171 * |--SEMI -> ; 1172 * |--FOR_CONDITION -> FOR_CONDITION 1173 * | `--EXPR -> EXPR 1174 * | `--LT -> < 1175 * | |--IDENT -> i 1176 * | `--DOT -> . 1177 * | |--IDENT -> arr 1178 * | `--IDENT -> length 1179 * |--SEMI -> ; 1180 * |--FOR_ITERATOR -> FOR_ITERATOR 1181 * | `--ELIST -> ELIST 1182 * | `--EXPR -> EXPR 1183 * | `--POST_INC -> ++ 1184 * | `--IDENT -> i 1185 * |--RPAREN -> ) 1186 * `--SLIST -> { 1187 * `--RCURLY -> } 1188 * </pre> 1189 * 1190 * @see #VARIABLE_DEF 1191 * @see #ELIST 1192 * @see #LITERAL_FOR 1193 **/ 1194 public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT; 1195 /** 1196 * A for loop condition. This is a child of 1197 * {@code LITERAL_FOR}. The child of this element is an 1198 * optional expression. 1199 * 1200 * <p>For example:</p> 1201 * <pre> 1202 * for (int i = 0; i < arr.length; i++) {} 1203 * </pre> 1204 * <p>parses as:</p> 1205 * <pre> 1206 * LITERAL_FOR -> for 1207 * |--LPAREN -> ( 1208 * |--FOR_INIT -> FOR_INIT 1209 * | `--VARIABLE_DEF -> VARIABLE_DEF 1210 * | |--MODIFIERS -> MODIFIERS 1211 * | |--TYPE -> TYPE 1212 * | | `--LITERAL_INT -> int 1213 * | |--IDENT -> i 1214 * | `--ASSIGN -> = 1215 * | `--EXPR -> EXPR 1216 * | `--NUM_INT -> 0 1217 * |--SEMI -> ; 1218 * |--FOR_CONDITION -> FOR_CONDITION 1219 * | `--EXPR -> EXPR 1220 * | `--LT -> < 1221 * | |--IDENT -> i 1222 * | `--DOT -> . 1223 * | |--IDENT -> arr 1224 * | `--IDENT -> length 1225 * |--SEMI -> ; 1226 * |--FOR_ITERATOR -> FOR_ITERATOR 1227 * | `--ELIST -> ELIST 1228 * | `--EXPR -> EXPR 1229 * | `--POST_INC -> ++ 1230 * | `--IDENT -> i 1231 * |--RPAREN -> ) 1232 * `--SLIST -> { 1233 * `--RCURLY -> } 1234 * </pre> 1235 * 1236 * @see #EXPR 1237 * @see #LITERAL_FOR 1238 **/ 1239 public static final int FOR_CONDITION = 1240 GeneratedJavaTokenTypes.FOR_CONDITION; 1241 1242 /** 1243 * A for loop iterator. This is a child of 1244 * {@code LITERAL_FOR}. The child of this element is an 1245 * optional expression list. 1246 * 1247 * <p>For example:</p> 1248 * <pre> 1249 * for (int i = 0; i < arr.length; i++) {} 1250 * </pre> 1251 * <p>parses as:</p> 1252 * <pre> 1253 * LITERAL_FOR -> for 1254 * |--LPAREN -> ( 1255 * |--FOR_INIT -> FOR_INIT 1256 * | `--VARIABLE_DEF -> VARIABLE_DEF 1257 * | |--MODIFIERS -> MODIFIERS 1258 * | |--TYPE -> TYPE 1259 * | | `--LITERAL_INT -> int 1260 * | |--IDENT -> i 1261 * | `--ASSIGN -> = 1262 * | `--EXPR -> EXPR 1263 * | `--NUM_INT -> 0 1264 * |--SEMI -> ; 1265 * |--FOR_CONDITION -> FOR_CONDITION 1266 * | `--EXPR -> EXPR 1267 * | `--LT -> < 1268 * | |--IDENT -> i 1269 * | `--DOT -> . 1270 * | |--IDENT -> arr 1271 * | `--IDENT -> length 1272 * |--SEMI -> ; 1273 * |--FOR_ITERATOR -> FOR_ITERATOR 1274 * | `--ELIST -> ELIST 1275 * | `--EXPR -> EXPR 1276 * | `--POST_INC -> ++ 1277 * | `--IDENT -> i 1278 * |--RPAREN -> ) 1279 * `--SLIST -> { 1280 * `--RCURLY -> } 1281 * </pre> 1282 * 1283 * @see #ELIST 1284 * @see #LITERAL_FOR 1285 **/ 1286 public static final int FOR_ITERATOR = 1287 GeneratedJavaTokenTypes.FOR_ITERATOR; 1288 1289 /** 1290 * The empty statement. This goes in place of an 1291 * {@code SLIST} for a {@code for} or {@code while} 1292 * loop body. 1293 * 1294 * @see <a 1295 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java 1296 * Language Specification, §14.6</a> 1297 * @see #LITERAL_FOR 1298 * @see #LITERAL_WHILE 1299 **/ 1300 public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT; 1301 /** 1302 * The {@code final} keyword. 1303 * 1304 * <p>For example:</p> 1305 * <pre> 1306 * public final int x = 0; 1307 * </pre> 1308 * <p>parses as:</p> 1309 * <pre> 1310 * VARIABLE_DEF -> VARIABLE_DEF 1311 * |--MODIFIERS -> MODIFIERS 1312 * | |--LITERAL_PUBLIC -> public 1313 * | `--FINAL -> final 1314 * |--TYPE -> TYPE 1315 * | `--LITERAL_INT -> int 1316 * |--IDENT -> x 1317 * |--ASSIGN -> = 1318 * | `--EXPR -> EXPR 1319 * | `--NUM_INT -> 0 1320 * `--SEMI -> ; 1321 * </pre> 1322 * 1323 * @see #MODIFIERS 1324 **/ 1325 public static final int FINAL = GeneratedJavaTokenTypes.FINAL; 1326 /** 1327 * The {@code abstract} keyword. 1328 * 1329 * <p>For example:</p> 1330 * <pre> 1331 * public abstract class MyClass 1332 * { 1333 * } 1334 * </pre> 1335 * <p>parses as:</p> 1336 * <pre> 1337 * --CLASS_DEF 1338 * |--MODIFIERS 1339 * | |--LITERAL_PUBLIC (public) 1340 * | `--ABSTRACT (abstract) 1341 * |--LITERAL_CLASS (class) 1342 * |--IDENT (MyClass) 1343 * `--OBJBLOCK 1344 * |--LCURLY ({) 1345 * `--RCURLY (}) 1346 * </pre> 1347 * 1348 * @see #MODIFIERS 1349 **/ 1350 public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT; 1351 /** 1352 * The {@code strictfp} keyword. 1353 * 1354 * <p>For example:</p> 1355 * <pre>public strictfp class Test {}</pre> 1356 * 1357 * <p>parses as:</p> 1358 * <pre> 1359 * CLASS_DEF -> CLASS_DEF 1360 * |--MODIFIERS -> MODIFIERS 1361 * | |--LITERAL_PUBLIC -> public 1362 * | `--STRICTFP -> strictfp 1363 * |--LITERAL_CLASS -> class 1364 * |--IDENT -> Test 1365 * `--OBJBLOCK -> OBJBLOCK 1366 * |--LCURLY -> { 1367 * `--RCURLY -> } 1368 * </pre> 1369 * 1370 * @see #MODIFIERS 1371 **/ 1372 public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP; 1373 /** 1374 * A super constructor call. 1375 * 1376 * @see #ELIST 1377 * @see #RPAREN 1378 * @see #SEMI 1379 * @see #CTOR_CALL 1380 **/ 1381 public static final int SUPER_CTOR_CALL = 1382 GeneratedJavaTokenTypes.SUPER_CTOR_CALL; 1383 1384 /** 1385 * A constructor call. 1386 * 1387 * <p>For example:</p> 1388 * <pre> 1389 * this(1); 1390 * </pre> 1391 * <p>parses as:</p> 1392 * <pre> 1393 * +--CTOR_CALL (this) 1394 * | 1395 * +--LPAREN (() 1396 * +--ELIST 1397 * | 1398 * +--EXPR 1399 * | 1400 * +--NUM_INT (1) 1401 * +--RPAREN ()) 1402 * +--SEMI (;) 1403 * </pre> 1404 * 1405 * @see #ELIST 1406 * @see #RPAREN 1407 * @see #SEMI 1408 * @see #SUPER_CTOR_CALL 1409 **/ 1410 public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL; 1411 1412 /** 1413 * The statement terminator ({@code ;}). Depending on the 1414 * context, this make occur as a sibling, a child, or not at all. 1415 * 1416 * <p>For example:</p> 1417 * <pre> 1418 * for(;;); 1419 * </pre> 1420 * <p>parses as:</p> 1421 * <pre> 1422 * LITERAL_FOR -> for 1423 * |--LPAREN -> ( 1424 * |--FOR_INIT -> FOR_INIT 1425 * |--SEMI -> ; 1426 * |--FOR_CONDITION -> FOR_CONDITION 1427 * |--SEMI -> ; 1428 * |--FOR_ITERATOR -> FOR_ITERATOR 1429 * |--RPAREN -> ) 1430 * `--EMPTY_STAT -> ; 1431 * </pre> 1432 * 1433 * @see #PACKAGE_DEF 1434 * @see #IMPORT 1435 * @see #SLIST 1436 * @see #ARRAY_INIT 1437 * @see #LITERAL_FOR 1438 **/ 1439 public static final int SEMI = GeneratedJavaTokenTypes.SEMI; 1440 1441 /** 1442 * The {@code ]} symbol. 1443 * 1444 * <p>For example:</p> 1445 * <pre> 1446 * int a[]; 1447 * </pre> 1448 * <p>parses as:</p> 1449 * <pre> 1450 * VARIABLE_DEF -> VARIABLE_DEF 1451 * |--MODIFIERS -> MODIFIERS 1452 * |--TYPE -> TYPE 1453 * | |--LITERAL_INT -> int 1454 * | `--ARRAY_DECLARATOR -> [ 1455 * | `--RBRACK -> ] 1456 * |--IDENT -> a 1457 * `--SEMI -> ; 1458 * </pre> 1459 * 1460 * @see #INDEX_OP 1461 * @see #ARRAY_DECLARATOR 1462 **/ 1463 public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK; 1464 /** 1465 * The {@code void} keyword. 1466 * 1467 * <p>For example:</p> 1468 * <pre> 1469 * {@code void literal_void(){}} 1470 * </pre> 1471 * <p>'void' parses as:</p> 1472 * <pre> 1473 * METHOD_DEF -> METHOD_DEF 1474 * |--MODIFIERS -> MODIFIERS 1475 * |--TYPE -> TYPE 1476 * | `--LITERAL_VOID -> void 1477 * |--IDENT -> literal_void 1478 * </pre> 1479 * 1480 * @see #TYPE 1481 **/ 1482 public static final int LITERAL_VOID = 1483 GeneratedJavaTokenTypes.LITERAL_void; 1484 1485 /** 1486 * The {@code boolean} keyword. 1487 * 1488 * @see #TYPE 1489 **/ 1490 public static final int LITERAL_BOOLEAN = 1491 GeneratedJavaTokenTypes.LITERAL_boolean; 1492 1493 /** 1494 * The {@code byte} keyword. 1495 * 1496 * <p>For example:</p> 1497 * <pre> 1498 * public byte x; 1499 * </pre> 1500 * <p>parses as:</p> 1501 * <pre> 1502 * VARIABLE_DEF -> VARIABLE_DEF 1503 * |--MODIFIERS -> MODIFIERS 1504 * | `--LITERAL_PUBLIC -> public 1505 * |--TYPE -> TYPE 1506 * | `--LITERAL_BYTE -> byte 1507 * |--IDENT -> x 1508 * `--SEMI -> ; 1509 * </pre> 1510 * 1511 * @see #TYPE 1512 **/ 1513 public static final int LITERAL_BYTE = 1514 GeneratedJavaTokenTypes.LITERAL_byte; 1515 1516 /** 1517 * The {@code char} keyword. 1518 * 1519 * <p>For example:</p> 1520 * <pre> 1521 * char a = 'A'; 1522 * </pre> 1523 * <p>parses as:</p> 1524 * <pre> 1525 * VARIABLE_DEF -> VARIABLE_DEF 1526 * |--MODIFIERS -> MODIFIERS 1527 * |--TYPE -> TYPE 1528 * | `--LITERAL_CHAR -> char 1529 * |--IDENT -> a 1530 * |--ASSIGN -> = 1531 * | `--EXPR -> EXPR 1532 * | `--CHAR_LITERAL -> 'A' 1533 * `--SEMI -> ; 1534 * </pre> 1535 * 1536 * @see #TYPE 1537 **/ 1538 public static final int LITERAL_CHAR = 1539 GeneratedJavaTokenTypes.LITERAL_char; 1540 1541 /** 1542 * The {@code short} keyword. 1543 * 1544 * <p>For example:</p> 1545 * <pre> 1546 * public short x; 1547 * </pre> 1548 * <p>parses as:</p> 1549 * <pre> 1550 * VARIABLE_DEF -> VARIABLE_DEF 1551 * |--MODIFIERS -> MODIFIERS 1552 * | `--LITERAL_PUBLIC -> public 1553 * |--TYPE -> TYPE 1554 * | `--LITERAL_SHORT -> short 1555 * |--IDENT -> x 1556 * `--SEMI -> ; 1557 * </pre> 1558 * 1559 * @see #TYPE 1560 **/ 1561 public static final int LITERAL_SHORT = 1562 GeneratedJavaTokenTypes.LITERAL_short; 1563 1564 /** 1565 * The {@code int} keyword. 1566 * 1567 * <p>For example:</p> 1568 * <pre> 1569 * public int x; 1570 * </pre> 1571 * <p>parses as:</p> 1572 * <pre> 1573 * VARIABLE_DEF -> VARIABLE_DEF 1574 * |--MODIFIERS -> MODIFIERS 1575 * | `--LITERAL_PUBLIC -> public 1576 * |--TYPE -> TYPE 1577 * | `--LITERAL_INT -> int 1578 * |--IDENT -> x 1579 * `--SEMI -> ; 1580 * </pre> 1581 * 1582 * @see #TYPE 1583 **/ 1584 public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int; 1585 /** 1586 * The {@code float} keyword. 1587 * 1588 * <p>For example:</p> 1589 * <pre> 1590 * public float x; 1591 * </pre> 1592 * <p>parses as:</p> 1593 * <pre> 1594 * VARIABLE_DEF -> VARIABLE_DEF 1595 * |--MODIFIERS -> MODIFIERS 1596 * | `--LITERAL_PUBLIC -> public 1597 * |--TYPE -> TYPE 1598 * | `--LITERAL_FLOAT -> float 1599 * |--IDENT -> x 1600 * `--SEMI -> ; 1601 * </pre> 1602 * 1603 * @see #TYPE 1604 **/ 1605 public static final int LITERAL_FLOAT = 1606 GeneratedJavaTokenTypes.LITERAL_float; 1607 1608 /** 1609 * The {@code long} keyword. 1610 * 1611 * <p>For example:</p> 1612 * <pre> 1613 * public long x; 1614 * </pre> 1615 * <p>parses as:</p> 1616 * <pre> 1617 * VARIABLE_DEF -> VARIABLE_DEF 1618 * |--MODIFIERS -> MODIFIERS 1619 * | `--LITERAL_PUBLIC -> public 1620 * |--TYPE -> TYPE 1621 * | `--LITERAL_LONG -> long 1622 * |--IDENT -> x 1623 * `--SEMI -> ; 1624 * </pre> 1625 * 1626 * @see #TYPE 1627 **/ 1628 public static final int LITERAL_LONG = 1629 GeneratedJavaTokenTypes.LITERAL_long; 1630 1631 /** 1632 * The {@code double} keyword. 1633 * 1634 * <p>For example:</p> 1635 * <pre> 1636 * public double x; 1637 * </pre> 1638 * <p>parses as:</p> 1639 * <pre> 1640 * VARIABLE_DEF -> VARIABLE_DEF 1641 * |--MODIFIERS -> MODIFIERS 1642 * | `--LITERAL_PUBLIC -> public 1643 * |--TYPE -> TYPE 1644 * | `--LITERAL_DOUBLE -> double 1645 * |--IDENT -> x 1646 * `--SEMI -> ; 1647 * </pre> 1648 * 1649 * @see #TYPE 1650 **/ 1651 public static final int LITERAL_DOUBLE = 1652 GeneratedJavaTokenTypes.LITERAL_double; 1653 1654 /** 1655 * An identifier. These can be names of types, subpackages, 1656 * fields, methods, parameters, and local variables. 1657 **/ 1658 public static final int IDENT = GeneratedJavaTokenTypes.IDENT; 1659 /** 1660 * The <code>.</code> (dot) operator. 1661 * 1662 * <p>For example:</p> 1663 * <pre> 1664 * return person.name; 1665 * </pre> 1666 * <p>parses as:</p> 1667 * <pre> 1668 * --LITERAL_RETURN -> return 1669 * |--EXPR -> EXPR 1670 * | `--DOT -> . 1671 * | |--IDENT -> person 1672 * | `--IDENT -> name 1673 * `--SEMI -> ; 1674 * </pre> 1675 * 1676 * @see FullIdent 1677 * @noinspection HtmlTagCanBeJavadocTag 1678 **/ 1679 public static final int DOT = GeneratedJavaTokenTypes.DOT; 1680 /** 1681 * The {@code *} (multiplication or wildcard) operator. 1682 * 1683 * <p>For example:</p> 1684 * <pre> 1685 * f = m * a; 1686 * </pre> 1687 * <p>parses as:</p> 1688 * <pre> 1689 * |--EXPR -> EXPR 1690 * | `--ASSIGN -> = 1691 * | |--IDENT -> f 1692 * | `--STAR -> * 1693 * | |--IDENT -> m 1694 * | `--IDENT -> a 1695 * |--SEMI -> ; 1696 * </pre> 1697 * 1698 * @see <a 1699 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java 1700 * Language Specification, §7.5.2</a> 1701 * @see <a 1702 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java 1703 * Language Specification, §15.17.1</a> 1704 * @see #EXPR 1705 * @see #IMPORT 1706 **/ 1707 public static final int STAR = GeneratedJavaTokenTypes.STAR; 1708 /** 1709 * The {@code private} keyword. 1710 * 1711 * <p>For example:</p> 1712 * <pre> 1713 * private int x; 1714 * </pre> 1715 * <p>parses as:</p> 1716 * <pre> 1717 * VARIABLE_DEF -> VARIABLE_DEF 1718 * |--MODIFIERS -> MODIFIERS 1719 * | `--LITERAL_PRIVATE -> private 1720 * |--TYPE -> TYPE 1721 * | `--LITERAL_INT -> int 1722 * |--IDENT -> x 1723 * `--SEMI -> ; 1724 * </pre> 1725 * 1726 * @see #MODIFIERS 1727 **/ 1728 public static final int LITERAL_PRIVATE = 1729 GeneratedJavaTokenTypes.LITERAL_private; 1730 1731 /** 1732 * The {@code public} keyword. 1733 * 1734 * <p>For example:</p> 1735 * <pre> 1736 * public int x; 1737 * </pre> 1738 * <p>parses as:</p> 1739 * <pre> 1740 * VARIABLE_DEF -> VARIABLE_DEF 1741 * |--MODIFIERS -> MODIFIERS 1742 * | `--LITERAL_PUBLIC -> public 1743 * |--TYPE -> TYPE 1744 * | `--LITERAL_INT -> int 1745 * |--IDENT -> x 1746 * `--SEMI -> ; 1747 * </pre> 1748 * 1749 * @see #MODIFIERS 1750 **/ 1751 public static final int LITERAL_PUBLIC = 1752 GeneratedJavaTokenTypes.LITERAL_public; 1753 1754 /** 1755 * The {@code protected} keyword. 1756 * 1757 * <p>For example:</p> 1758 * <pre> 1759 * protected int x; 1760 * </pre> 1761 * <p>parses as:</p> 1762 * <pre> 1763 * VARIABLE_DEF -> VARIABLE_DEF 1764 * |--MODIFIERS -> MODIFIERS 1765 * | `--LITERAL_PROTECTED -> protected 1766 * |--TYPE -> TYPE 1767 * | `--LITERAL_INT -> int 1768 * |--IDENT -> x 1769 * `--SEMI -> ; 1770 * </pre> 1771 * 1772 * @see #MODIFIERS 1773 **/ 1774 public static final int LITERAL_PROTECTED = 1775 GeneratedJavaTokenTypes.LITERAL_protected; 1776 1777 /** 1778 * The {@code static} keyword. 1779 * 1780 * <p>For example:</p> 1781 * <pre> 1782 * public static int x; 1783 * </pre> 1784 * <p>parses as:</p> 1785 * <pre> 1786 * VARIABLE_DEF -> VARIABLE_DEF 1787 * |--MODIFIERS -> MODIFIERS 1788 * | |--LITERAL_PUBLIC -> public 1789 * | `--LITERAL_STATIC -> static 1790 * |--TYPE -> TYPE 1791 * | `--LITERAL_INT -> int 1792 * |--IDENT -> x 1793 * `--SEMI -> ; 1794 * </pre> 1795 * 1796 * @see #MODIFIERS 1797 **/ 1798 public static final int LITERAL_STATIC = 1799 GeneratedJavaTokenTypes.LITERAL_static; 1800 1801 /** 1802 * The {@code transient} keyword. 1803 * 1804 * <p>For example:</p> 1805 * <pre> 1806 * transient int a; 1807 * </pre> 1808 * <p>parses as:</p> 1809 * <pre> 1810 * VARIABLE_DEF -> VARIABLE_DEF 1811 * |--MODIFIERS -> MODIFIERS 1812 * | `--LITERAL_TRANSIENT -> transient 1813 * |--TYPE -> TYPE 1814 * | `--LITERAL_INT -> int 1815 * |--IDENT -> a 1816 * `--SEMI -> ; 1817 * </pre> 1818 * 1819 * @see #MODIFIERS 1820 **/ 1821 public static final int LITERAL_TRANSIENT = 1822 GeneratedJavaTokenTypes.LITERAL_transient; 1823 1824 /** 1825 * The {@code native} keyword. 1826 * 1827 * @see #MODIFIERS 1828 **/ 1829 public static final int LITERAL_NATIVE = 1830 GeneratedJavaTokenTypes.LITERAL_native; 1831 1832 /** 1833 * The {@code synchronized} keyword. This may be used as a 1834 * modifier of a method or in the definition of a synchronized 1835 * block. 1836 * 1837 * <p>For example:</p> 1838 * 1839 * <pre> 1840 * synchronized(this) 1841 * { 1842 * x++; 1843 * } 1844 * </pre> 1845 * 1846 * <p>parses as:</p> 1847 * 1848 * <pre> 1849 * |--LITERAL_SYNCHRONIZED -> synchronized 1850 * | |--LPAREN -> ( 1851 * | |--EXPR -> EXPR 1852 * | | `--LITERAL_THIS -> this 1853 * | |--RPAREN -> ) 1854 * | `--SLIST -> { 1855 * | |--EXPR -> EXPR 1856 * | | `--POST_INC -> ++ 1857 * | | `--IDENT -> x 1858 * | |--SEMI -> ; 1859 * | `--RCURLY -> } 1860 * `--RCURLY -> } 1861 * </pre> 1862 * 1863 * @see #MODIFIERS 1864 * @see #LPAREN 1865 * @see #EXPR 1866 * @see #RPAREN 1867 * @see #SLIST 1868 * @see #RCURLY 1869 **/ 1870 public static final int LITERAL_SYNCHRONIZED = 1871 GeneratedJavaTokenTypes.LITERAL_synchronized; 1872 1873 /** 1874 * The {@code volatile} keyword. This may be used as a 1875 * modifier of a field. 1876 * <p>For example:</p> 1877 * <pre> 1878 * private volatile int x; 1879 * </pre> 1880 * <p>parses as:</p> 1881 * <pre> 1882 * VARIABLE_DEF -> VARIABLE_DEF 1883 * |--MODIFIERS -> MODIFIERS 1884 * | |--LITERAL_PRIVATE -> private 1885 * | `--LITERAL_VOLATILE -> volatile 1886 * |--TYPE -> TYPE 1887 * | `--LITERAL_INT -> int 1888 * |--IDENT -> x 1889 * `--SEMI -> ; 1890 * </pre> 1891 * 1892 * @see #MODIFIERS 1893 **/ 1894 public static final int LITERAL_VOLATILE = 1895 GeneratedJavaTokenTypes.LITERAL_volatile; 1896 1897 /** 1898 * The {@code class} keyword. This element appears both 1899 * as part of a class declaration, and inline to reference a 1900 * class object. 1901 * 1902 * <p>For example:</p> 1903 * <pre> 1904 * class Test { 1905 * } 1906 * </pre> 1907 * <p>parses as:</p> 1908 * <pre> 1909 * CLASS_DEF -> CLASS_DEF 1910 * |--MODIFIERS -> MODIFIERS 1911 * |--LITERAL_CLASS -> class 1912 * |--IDENT -> Test 1913 * `--OBJBLOCK -> OBJBLOCK 1914 * |--LCURLY -> { 1915 * `--RCURLY -> } 1916 * </pre> 1917 * 1918 * <p>For example:</p> 1919 * <pre> int.class 1920 * </pre> 1921 * <p>parses as:</p> 1922 * <pre> 1923 * EXPR -> EXPR 1924 * `--DOT -> . 1925 * |--LITERAL_INT -> int 1926 * `--LITERAL_CLASS -> class 1927 * </pre> 1928 * 1929 * @see #DOT 1930 * @see #IDENT 1931 * @see #CLASS_DEF 1932 * @see FullIdent 1933 **/ 1934 public static final int LITERAL_CLASS = 1935 GeneratedJavaTokenTypes.LITERAL_class; 1936 1937 /** 1938 * The {@code interface} keyword. This token appears in 1939 * interface definition. 1940 * 1941 * <p>For example:</p> 1942 * 1943 * <pre> 1944 * public interface MyInterface { 1945 * 1946 * } 1947 * </pre> 1948 * 1949 * <p>parses as:</p> 1950 * 1951 * <pre> 1952 * INTERFACE_DEF -> INTERFACE_DEF 1953 * |--MODIFIERS -> MODIFIERS 1954 * | `--LITERAL_PUBLIC -> public 1955 * |--LITERAL_INTERFACE -> interface 1956 * |--IDENT -> MyInterface 1957 * `--OBJBLOCK -> OBJBLOCK 1958 * |--LCURLY -> { 1959 * `--RCURLY -> } 1960 * </pre> 1961 * 1962 * @see #INTERFACE_DEF 1963 **/ 1964 public static final int LITERAL_INTERFACE = 1965 GeneratedJavaTokenTypes.LITERAL_interface; 1966 1967 /** 1968 * A left curly brace (<code>{</code>). 1969 * 1970 * @see #OBJBLOCK 1971 * @see #ARRAY_INIT 1972 * @see #SLIST 1973 **/ 1974 public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY; 1975 /** 1976 * A right curly brace (<code>}</code>). 1977 * 1978 * <p>For example:</p> 1979 * <pre> 1980 * {@code 1981 * void foo(){} 1982 * } 1983 * </pre> 1984 * <p>parses as:</p> 1985 * <pre> 1986 * METHOD_DEF -> METHOD_DEF 1987 * |--MODIFIERS -> MODIFIERS 1988 * |--TYPE -> TYPE 1989 * | `--LITERAL_VOID -> void 1990 * |--IDENT -> foo 1991 * |--LPAREN -> ( 1992 * |--PARAMETERS -> PARAMETERS 1993 * |--RPAREN -> ) 1994 * `--SLIST -> { 1995 * `--RCURLY -> } 1996 * </pre> 1997 * 1998 * @see #OBJBLOCK 1999 * @see #ARRAY_INIT 2000 * @see #SLIST 2001 **/ 2002 public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY; 2003 2004 /** 2005 * The {@code ,} (comma) operator. 2006 * 2007 * <p>For example:</p> 2008 * <pre> 2009 * int a, b; 2010 * </pre> 2011 * <p>parses as:</p> 2012 * <pre> 2013 * |--VARIABLE_DEF -> VARIABLE_DEF 2014 * | |--MODIFIERS -> MODIFIERS 2015 * | |--TYPE -> TYPE 2016 * | | `--LITERAL_INT -> int 2017 * | `--IDENT -> a 2018 * |--COMMA -> , 2019 * |--VARIABLE_DEF -> VARIABLE_DEF 2020 * | |--MODIFIERS -> MODIFIERS 2021 * | |--TYPE -> TYPE 2022 * | | `--LITERAL_INT -> int 2023 * | `--IDENT -> b 2024 * |--SEMI -> ; 2025 * </pre> 2026 * 2027 * @see #ARRAY_INIT 2028 * @see #FOR_INIT 2029 * @see #FOR_ITERATOR 2030 * @see #LITERAL_THROWS 2031 * @see #IMPLEMENTS_CLAUSE 2032 **/ 2033 public static final int COMMA = GeneratedJavaTokenTypes.COMMA; 2034 2035 /** 2036 * A left parenthesis ({@code (}). 2037 * 2038 * <p>For example:</p> 2039 * <pre> 2040 * Integer val = new Integer(); 2041 * while (false) { 2042 * val += (-3); 2043 * } 2044 * </pre> 2045 * <p>parses as:</p> 2046 * <pre> 2047 * |--VARIABLE_DEF -> VARIABLE_DEF 2048 * | |--MODIFIERS -> MODIFIERS 2049 * | |--TYPE -> TYPE 2050 * | | `--IDENT -> Integer 2051 * | |--IDENT -> val 2052 * | `--ASSIGN -> = 2053 * | `--EXPR -> EXPR 2054 * | `--LITERAL_NEW -> new 2055 * | |--IDENT -> Integer 2056 * | |--LPAREN -> ( 2057 * | |--ELIST -> ELIST 2058 * | `--RPAREN -> ) 2059 * |--SEMI -> ; 2060 * |--LITERAL_WHILE -> while 2061 * | |--LPAREN -> ( 2062 * | |--EXPR -> EXPR 2063 * | | `--LITERAL_FALSE -> false 2064 * | |--RPAREN -> ) 2065 * | `--SLIST -> { 2066 * | |--EXPR -> EXPR 2067 * | | `--PLUS_ASSIGN -> += 2068 * | | |--IDENT -> val 2069 * | | |--LPAREN -> ( 2070 * | | |--UNARY_MINUS -> - 2071 * | | | `--NUM_INT -> 3 2072 * | | `--RPAREN -> ) 2073 * | |--SEMI -> ; 2074 * | `--RCURLY -> } 2075 * </pre> 2076 * 2077 * @see #LITERAL_FOR 2078 * @see #LITERAL_NEW 2079 * @see #EXPR 2080 * @see #LITERAL_SWITCH 2081 * @see #LITERAL_CATCH 2082 **/ 2083 public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN; 2084 /** 2085 * A right parenthesis ({@code )}). 2086 * 2087 * <p>For example:</p> 2088 * <pre> 2089 * void check() { 2090 * } 2091 * </pre> 2092 * <p>parses as:</p> 2093 * <pre> 2094 * METHOD_DEF -> METHOD_DEF 2095 * |--MODIFIERS -> MODIFIERS 2096 * |--TYPE -> TYPE 2097 * | `--LITERAL_VOID -> void 2098 * |--IDENT -> check 2099 * |--LPAREN -> ( 2100 * |--PARAMETERS -> PARAMETERS 2101 * |--RPAREN -> ) 2102 * `--SLIST -> { 2103 * `--RCURLY -> } 2104 * </pre> 2105 * 2106 * @see #LITERAL_FOR 2107 * @see #LITERAL_NEW 2108 * @see #METHOD_CALL 2109 * @see #TYPECAST 2110 * @see #EXPR 2111 * @see #LITERAL_SWITCH 2112 * @see #LITERAL_CATCH 2113 **/ 2114 public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN; 2115 /** 2116 * The {@code this} keyword use to refer the current object. 2117 * This can also be used to call the constructor. 2118 * 2119 * <p>For example:</p> 2120 * <pre> 2121 * this.name = name; 2122 * </pre> 2123 * <p>parses as:</p> 2124 * <pre> 2125 * EXPR -> EXPR 2126 * `--ASSIGN -> = 2127 * |--DOT -> . 2128 * | |--LITERAL_THIS -> this 2129 * | `--IDENT -> name 2130 * `--IDENT -> name 2131 * SEMI -> ; 2132 * </pre> 2133 * <p>Also consider:</p> 2134 * <pre> 2135 * this(1, "NULL"); 2136 * </pre> 2137 * <p>parses as:</p> 2138 * <pre> 2139 * CTOR_CALL -> this 2140 * |--LPAREN -> ( 2141 * |--ELIST -> ELIST 2142 * | |--EXPR -> EXPR 2143 * | | `--NUM_INT -> 1 2144 * | |--COMMA -> , 2145 * | `--EXPR -> EXPR 2146 * | `--STRING_LITERAL -> "NULL" 2147 * |--RPAREN -> ) 2148 * `--SEMI -> ; 2149 * </pre> 2150 * 2151 * @see #EXPR 2152 * @see #CTOR_CALL 2153 **/ 2154 public static final int LITERAL_THIS = 2155 GeneratedJavaTokenTypes.LITERAL_this; 2156 2157 /** 2158 * The {@code super} keyword. 2159 * 2160 * <p>For example:</p> 2161 * <pre> 2162 * super.toString()ï¼› 2163 * </pre> 2164 * <p>parses as:</p> 2165 * <pre> 2166 * |--EXPR -> EXPR 2167 * | `--METHOD_CALL -> ( 2168 * | |--DOT -> . 2169 * | | |--LITERAL_SUPER -> super 2170 * | | `--IDENT -> toString 2171 * | |--ELIST -> ELIST 2172 * | `--RPAREN -> ) 2173 * |--SEMI -> ; 2174 * </pre> 2175 * 2176 * @see #EXPR 2177 * @see #SUPER_CTOR_CALL 2178 **/ 2179 public static final int LITERAL_SUPER = 2180 GeneratedJavaTokenTypes.LITERAL_super; 2181 2182 /** 2183 * The {@code =} (assignment) operator. 2184 * 2185 * <p>For example:</p> 2186 * <pre> 2187 * a = b; 2188 * </pre> 2189 * <p>parses as:</p> 2190 * <pre> 2191 * |--EXPR -> EXPR 2192 * | `--ASSIGN -> = 2193 * | |--IDENT -> a 2194 * | `--IDENT -> b 2195 * |--SEMI -> ; 2196 * </pre> 2197 * 2198 * @see <a 2199 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java 2200 * Language Specification, §15.26.1</a> 2201 * @see #EXPR 2202 **/ 2203 public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN; 2204 /** 2205 * The {@code throws} keyword. The children are a number of 2206 * one or more identifiers separated by commas. 2207 * 2208 * <p>For example:</p> 2209 * <pre> 2210 * void test() throws FileNotFoundException, EOFException { 2211 * } 2212 * </pre> 2213 * <p>parses as:</p> 2214 * <pre> 2215 * METHOD_DEF -> METHOD_DEF 2216 * |--MODIFIERS -> MODIFIERS 2217 * |--TYPE -> TYPE 2218 * | `--LITERAL_VOID -> void 2219 * |--IDENT -> test 2220 * |--LPAREN -> ( 2221 * |--PARAMETERS -> PARAMETERS 2222 * |--RPAREN -> ) 2223 * |--LITERAL_THROWS -> throws 2224 * | |--IDENT -> FileNotFoundException 2225 * | |--COMMA -> , 2226 * | `--IDENT -> EOFException 2227 * `--SLIST -> { 2228 * `--RCURLY -> } 2229 * </pre> 2230 * 2231 * @see <a 2232 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java 2233 * Language Specification, §8.4.4</a> 2234 * @see #IDENT 2235 * @see #DOT 2236 * @see #COMMA 2237 * @see #METHOD_DEF 2238 * @see #CTOR_DEF 2239 * @see FullIdent 2240 **/ 2241 public static final int LITERAL_THROWS = 2242 GeneratedJavaTokenTypes.LITERAL_throws; 2243 2244 /** 2245 * The {@code :} (colon) operator. This will appear as part 2246 * of the conditional operator ({@code ? :}). 2247 * 2248 * @see #QUESTION 2249 * @see #LABELED_STAT 2250 * @see #CASE_GROUP 2251 **/ 2252 public static final int COLON = GeneratedJavaTokenTypes.COLON; 2253 2254 /** 2255 * The {@code ::} (double colon) separator. 2256 * It is part of Java 8 syntax that is used for method reference. 2257 * The token does not appear in tree, {@link #METHOD_REF} should be used instead. 2258 * 2259 * @see #METHOD_REF 2260 */ 2261 public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON; 2262 /** 2263 * The {@code if} keyword. 2264 * 2265 * <p>For example:</p> 2266 * <pre> 2267 * if (optimistic) 2268 * { 2269 * message = "half full"; 2270 * } 2271 * else 2272 * { 2273 * message = "half empty"; 2274 * } 2275 * </pre> 2276 * <p>parses as:</p> 2277 * <pre> 2278 * LITERAL_IF -> if 2279 * |--LPAREN -> ( 2280 * |--EXPR -> EXPR 2281 * | `--IDENT -> optimistic 2282 * |--RPAREN -> ) 2283 * |--SLIST -> { 2284 * | |--EXPR -> EXPR 2285 * | | `--ASSIGN -> = 2286 * | | |--IDENT -> message 2287 * | | `--STRING_LITERAL -> "half full" 2288 * | |--SEMI -> ; 2289 * | `--RCURLY -> } 2290 * `--LITERAL_ELSE -> else 2291 * `--SLIST -> { 2292 * |--EXPR -> EXPR 2293 * | `--ASSIGN -> = 2294 * | |--IDENT -> message 2295 * | `--STRING_LITERAL -> "half empty" 2296 * |--SEMI -> ; 2297 * `--RCURLY -> } 2298 * </pre> 2299 * 2300 * @see #LPAREN 2301 * @see #EXPR 2302 * @see #RPAREN 2303 * @see #SLIST 2304 * @see #EMPTY_STAT 2305 * @see #LITERAL_ELSE 2306 **/ 2307 public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if; 2308 /** 2309 * The {@code for} keyword. The children are {@code (}, 2310 * an initializer, a condition, an iterator, a {@code )} and 2311 * either a statement list, a single expression, or an empty 2312 * statement. 2313 * 2314 * <p>For example:</p> 2315 * <pre> 2316 * for (int i = 0; i < arr.length; i++) {} 2317 * </pre> 2318 * <p>parses as:</p> 2319 * <pre> 2320 * LITERAL_FOR -> for 2321 * |--LPAREN -> ( 2322 * |--FOR_INIT -> FOR_INIT 2323 * | `--VARIABLE_DEF -> VARIABLE_DEF 2324 * | |--MODIFIERS -> MODIFIERS 2325 * | |--TYPE -> TYPE 2326 * | | `--LITERAL_INT -> int 2327 * | |--IDENT -> i 2328 * | `--ASSIGN -> = 2329 * | `--EXPR -> EXPR 2330 * | `--NUM_INT -> 0 2331 * |--SEMI -> ; 2332 * |--FOR_CONDITION -> FOR_CONDITION 2333 * | `--EXPR -> EXPR 2334 * | `--LT -> < 2335 * | |--IDENT -> i 2336 * | `--DOT -> . 2337 * | |--IDENT -> arr 2338 * | `--IDENT -> length 2339 * |--SEMI -> ; 2340 * |--FOR_ITERATOR -> FOR_ITERATOR 2341 * | `--ELIST -> ELIST 2342 * | `--EXPR -> EXPR 2343 * | `--POST_INC -> ++ 2344 * | `--IDENT -> i 2345 * |--RPAREN -> ) 2346 * `--SLIST -> { 2347 * `--RCURLY -> } 2348 * </pre> 2349 * 2350 * @see #LPAREN 2351 * @see #FOR_INIT 2352 * @see #SEMI 2353 * @see #FOR_CONDITION 2354 * @see #FOR_ITERATOR 2355 * @see #RPAREN 2356 * @see #SLIST 2357 * @see #EMPTY_STAT 2358 * @see #EXPR 2359 **/ 2360 public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for; 2361 /** 2362 * The {@code while} keyword. 2363 * 2364 * <p>For example:</p> 2365 * <pre> 2366 * while (i < 5) { 2367 * i++; 2368 * } 2369 * </pre> 2370 * <p>parses as:</p> 2371 * <pre> 2372 * LITERAL_WHILE -> while 2373 * |--LPAREN -> ( 2374 * |--EXPR -> EXPR 2375 * | `--LT -> < 2376 * | |--IDENT -> i 2377 * | `--NUM_INT -> 5 2378 * |--RPAREN -> ) 2379 * `--SLIST -> { 2380 * |--EXPR -> EXPR 2381 * | `--POST_INC -> ++ 2382 * | `--IDENT -> i 2383 * |--SEMI -> ; 2384 * `--RCURLY -> } 2385 * </pre> 2386 **/ 2387 public static final int LITERAL_WHILE = 2388 GeneratedJavaTokenTypes.LITERAL_while; 2389 2390 /** 2391 * The {@code do} keyword. Note the the while token does not 2392 * appear as part of the do-while construct. 2393 * 2394 * <p>For example:</p> 2395 * <pre> 2396 * do { 2397 * x = rand.nextInt(); 2398 * } while (x < 5); 2399 * </pre> 2400 * <p>parses as:</p> 2401 * <pre> 2402 * LITERAL_DO -> do 2403 * |--SLIST -> { 2404 * | |--EXPR -> EXPR 2405 * | | `--ASSIGN -> = 2406 * | | |--IDENT -> x 2407 * | | `--METHOD_CALL -> ( 2408 * | | |--DOT -> . 2409 * | | | |--IDENT -> rand 2410 * | | | `--IDENT -> nextInt 2411 * | | |--ELIST -> ELIST 2412 * | | `--RPAREN -> ) 2413 * | |--SEMI -> ; 2414 * | `--RCURLY -> } 2415 * |--DO_WHILE -> while 2416 * |--LPAREN -> ( 2417 * |--EXPR -> EXPR 2418 * | `--LT -> < 2419 * | |--IDENT -> x 2420 * | `--NUM_INT -> 5 2421 * |--RPAREN -> ) 2422 * `--SEMI -> ; 2423 * </pre> 2424 * 2425 * @see #SLIST 2426 * @see #EXPR 2427 * @see #EMPTY_STAT 2428 * @see #LPAREN 2429 * @see #RPAREN 2430 * @see #SEMI 2431 **/ 2432 public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do; 2433 /** 2434 * Literal {@code while} in do-while loop. 2435 * 2436 * <p>For example:</p> 2437 * <pre> 2438 * do { 2439 * 2440 * } while (a > 0); 2441 * </pre> 2442 * <p>parses as:</p> 2443 * <pre> 2444 * --LITERAL_DO -> do 2445 * |--SLIST -> { 2446 * | `--RCURLY -> } 2447 * |--DO_WHILE -> while 2448 * |--LPAREN -> ( 2449 * |--EXPR -> EXPR 2450 * | `--GT -> > 2451 * | |--IDENT -> a 2452 * | `--NUM_INT -> 0 2453 * |--RPAREN -> ) 2454 * `--SEMI -> ; 2455 * </pre> 2456 * 2457 * @see #LITERAL_DO 2458 */ 2459 public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE; 2460 /** 2461 * The {@code break} keyword. The first child is an optional 2462 * identifier and the last child is a semicolon. 2463 * 2464 * @see #IDENT 2465 * @see #SEMI 2466 * @see #SLIST 2467 **/ 2468 public static final int LITERAL_BREAK = 2469 GeneratedJavaTokenTypes.LITERAL_break; 2470 2471 /** 2472 * The {@code continue} keyword. The first child is an 2473 * optional identifier and the last child is a semicolon. 2474 * 2475 * <p>For example:</p> 2476 * <pre> 2477 * for (;;) { 2478 * continue; 2479 * } 2480 * </pre> 2481 * <p>parses as:</p> 2482 * <pre> 2483 * LITERAL_FOR -> for 2484 * |--LPAREN -> ( 2485 * |--FOR_INIT -> FOR_INIT 2486 * |--SEMI -> ; 2487 * |--FOR_CONDITION -> FOR_CONDITION 2488 * |--SEMI -> ; 2489 * |--FOR_ITERATOR -> FOR_ITERATOR 2490 * |--RPAREN -> ) 2491 * `--SLIST -> { 2492 * |--LITERAL_CONTINUE -> continue 2493 * | `--SEMI -> ; 2494 * `--RCURLY -> } 2495 * </pre> 2496 * 2497 * @see #IDENT 2498 * @see #SEMI 2499 * @see #SLIST 2500 **/ 2501 public static final int LITERAL_CONTINUE = 2502 GeneratedJavaTokenTypes.LITERAL_continue; 2503 2504 /** 2505 * The {@code return} keyword. The first child is an 2506 * optional expression for the return value. The last child is a 2507 * semi colon. 2508 * 2509 * <p>For example:</p> 2510 * <pre> 2511 * public int foo(int i) { 2512 * return i+1; 2513 * } 2514 * </pre> 2515 * <p>parses as:</p> 2516 * <pre> 2517 * METHOD_DEF -> METHOD_DEF 2518 * |--MODIFIERS -> MODIFIERS 2519 * | `--LITERAL_PUBLIC -> public 2520 * |--TYPE -> TYPE 2521 * | `--LITERAL_INT -> int 2522 * |--IDENT -> foo 2523 * |--LPAREN -> ( 2524 * |--PARAMETERS -> PARAMETERS 2525 * | `--PARAMETER_DEF -> PARAMETER_DEF 2526 * | |--MODIFIERS -> MODIFIERS 2527 * | |--TYPE -> TYPE 2528 * | | `--LITERAL_INT -> int 2529 * | `--IDENT -> i 2530 * |--RPAREN -> ) 2531 * `--SLIST -> { 2532 * |--LITERAL_RETURN -> return 2533 * | |--EXPR -> EXPR 2534 * | | `--PLUS -> + 2535 * | | |--IDENT -> i 2536 * | | `--NUM_INT -> 1 2537 * | `--SEMI -> ; 2538 * `--RCURLY -> } 2539 * </pre> 2540 * 2541 * @see #EXPR 2542 * @see #SEMI 2543 * @see #SLIST 2544 **/ 2545 public static final int LITERAL_RETURN = 2546 GeneratedJavaTokenTypes.LITERAL_return; 2547 2548 /** 2549 * The {@code switch} keyword. 2550 * 2551 * <p>For example:</p> 2552 * <pre> 2553 * switch (type) { 2554 * case 0: 2555 * background = Color.red; 2556 * break; 2557 * case 1: 2558 * background = Color.blue; 2559 * break; 2560 * default: 2561 * background = Color.green; 2562 * } 2563 * </pre> 2564 * <p>parses as:</p> 2565 * <pre> 2566 * LITERAL_SWITCH -> switch 2567 * |--LPAREN -> ( 2568 * |--EXPR -> EXPR 2569 * | `--IDENT -> type 2570 * |--RPAREN -> ) 2571 * |--LCURLY -> { 2572 * |--CASE_GROUP -> CASE_GROUP 2573 * | |--LITERAL_CASE -> case 2574 * | | |--EXPR -> EXPR 2575 * | | | `--NUM_INT -> 0 2576 * | | `--COLON -> : 2577 * | `--SLIST -> SLIST 2578 * | |--EXPR -> EXPR 2579 * | | `--ASSIGN -> = 2580 * | | |--IDENT -> background 2581 * | | `--DOT -> . 2582 * | | |--IDENT -> Color 2583 * | | `--IDENT -> red 2584 * | |--SEMI -> ; 2585 * | `--LITERAL_BREAK -> break 2586 * | `--SEMI -> ; 2587 * |--CASE_GROUP -> CASE_GROUP 2588 * | |--LITERAL_CASE -> case 2589 * | | |--EXPR -> EXPR 2590 * | | | `--NUM_INT -> 1 2591 * | | `--COLON -> : 2592 * | `--SLIST -> SLIST 2593 * | |--EXPR -> EXPR 2594 * | | `--ASSIGN -> = 2595 * | | |--IDENT -> background 2596 * | | `--DOT -> . 2597 * | | |--IDENT -> Color 2598 * | | `--IDENT -> blue 2599 * | |--SEMI -> ; 2600 * | `--LITERAL_BREAK -> break 2601 * | `--SEMI -> ; 2602 * |--CASE_GROUP -> CASE_GROUP 2603 * | |--LITERAL_DEFAULT -> default 2604 * | | `--COLON -> : 2605 * | `--SLIST -> SLIST 2606 * | |--EXPR -> EXPR 2607 * | | `--ASSIGN -> = 2608 * | | |--IDENT -> background 2609 * | | `--DOT -> . 2610 * | | |--IDENT -> Color 2611 * | | `--IDENT -> green 2612 * | `--SEMI -> ; 2613 * `--RCURLY -> } 2614 * </pre> 2615 * 2616 * @see <a 2617 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 2618 * Language Specification, §14.10</a> 2619 * @see #LPAREN 2620 * @see #EXPR 2621 * @see #RPAREN 2622 * @see #LCURLY 2623 * @see #CASE_GROUP 2624 * @see #RCURLY 2625 * @see #SLIST 2626 * @see #SWITCH_RULE 2627 **/ 2628 public static final int LITERAL_SWITCH = 2629 GeneratedJavaTokenTypes.LITERAL_switch; 2630 2631 /** 2632 * The {@code throw} keyword. The first child is an 2633 * expression that evaluates to a {@code Throwable} instance. 2634 * 2635 * @see <a 2636 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java 2637 * Language Specification, §14.17</a> 2638 * @see #SLIST 2639 * @see #EXPR 2640 **/ 2641 public static final int LITERAL_THROW = 2642 GeneratedJavaTokenTypes.LITERAL_throw; 2643 2644 /** 2645 * The {@code else} keyword. This appears as a child of an 2646 * {@code if} statement. 2647 * 2648 * <p>For example:</p> 2649 * <pre> 2650 * if (flag) { 2651 * 2652 * } else { 2653 * 2654 * } 2655 * </pre> 2656 * <p>parses as:</p> 2657 * <pre> 2658 * LITERAL_IF -> if 2659 * |--LPAREN -> ( 2660 * |--EXPR -> EXPR 2661 * | `--IDENT -> flag 2662 * |--RPAREN -> ) 2663 * |--SLIST -> { 2664 * | `--RCURLY -> } 2665 * `--LITERAL_ELSE -> else 2666 * `--SLIST -> { 2667 * `--RCURLY -> } 2668 * </pre> 2669 * 2670 * @see #SLIST 2671 * @see #EXPR 2672 * @see #EMPTY_STAT 2673 * @see #LITERAL_IF 2674 **/ 2675 public static final int LITERAL_ELSE = 2676 GeneratedJavaTokenTypes.LITERAL_else; 2677 2678 /** 2679 * The {@code case} keyword. The first child is a constant 2680 * expression that evaluates to an integer. 2681 * 2682 * @see #CASE_GROUP 2683 * @see #EXPR 2684 **/ 2685 public static final int LITERAL_CASE = 2686 GeneratedJavaTokenTypes.LITERAL_case; 2687 2688 /** 2689 * The {@code default} keyword. This element has no 2690 * children. 2691 * 2692 * <p>For example:</p> 2693 * <pre> 2694 * switch (type) { 2695 * case 1: 2696 * x = 1; 2697 * break; 2698 * default: 2699 * x = 3; 2700 * } 2701 * </pre> 2702 * <p>parses as:</p> 2703 * <pre> 2704 * LITERAL_SWITCH -> switch 2705 * |--LPAREN -> ( 2706 * |--EXPR -> EXPR 2707 * | `--IDENT -> type 2708 * |--RPAREN -> ) 2709 * |--LCURLY -> { 2710 * |--CASE_GROUP -> CASE_GROUP 2711 * | |--LITERAL_CASE -> case 2712 * | | |--EXPR -> EXPR 2713 * | | | `--NUM_INT -> 1 2714 * | | `--COLON -> : 2715 * | `--SLIST -> SLIST 2716 * | |--EXPR -> EXPR 2717 * | | `--ASSIGN -> = 2718 * | | |--IDENT -> x 2719 * | | `--NUM_INT -> 1 2720 * | | | |--SEMI -> ; 2721 * | `--LITERAL_BREAK -> break 2722 * | `--SEMI -> ; 2723 * |--CASE_GROUP -> CASE_GROUP 2724 * | |--LITERAL_DEFAULT -> default 2725 * | | `--COLON -> : 2726 * | `--SLIST -> SLIST 2727 * | |--EXPR -> EXPR 2728 * | | `--ASSIGN -> = 2729 * | | |--IDENT -> x 2730 * | | `--NUM_INT -> 3 2731 * | `--SEMI -> ; 2732 * `--RCURLY -> } 2733 * </pre> 2734 * 2735 * @see #CASE_GROUP 2736 * @see #MODIFIERS 2737 * @see #SWITCH_RULE 2738 **/ 2739 public static final int LITERAL_DEFAULT = 2740 GeneratedJavaTokenTypes.LITERAL_default; 2741 2742 /** 2743 * The {@code try} keyword. The children are a statement 2744 * list, zero or more catch blocks and then an optional finally 2745 * block. 2746 * 2747 * <p>For example:</p> 2748 * <pre> 2749 * try { } finally {} 2750 * </pre> 2751 * <p>parses as:</p> 2752 * <pre> 2753 * LITERAL_TRY -> try 2754 * |--SLIST -> { 2755 * | `--RCURLY -> } 2756 * `--LITERAL_FINALLY -> finally 2757 * `--SLIST -> { 2758 * `--RCURLY -> } 2759 * </pre> 2760 * 2761 * @see <a 2762 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 2763 * Language Specification, §14.19</a> 2764 * @see #SLIST 2765 * @see #LITERAL_CATCH 2766 * @see #LITERAL_FINALLY 2767 **/ 2768 public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try; 2769 2770 /** 2771 * The Java 7 try-with-resources construct. 2772 * 2773 * <p>For example:</p> 2774 * <pre> 2775 * try (Foo foo = new Foo(); Bar bar = new Bar()) { 2776 * } 2777 * </pre> 2778 * <p>parses as:</p> 2779 * <pre> 2780 * LITERAL_TRY -> try 2781 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 2782 * | |--LPAREN -> ( 2783 * | |--RESOURCES -> RESOURCES 2784 * | | |--RESOURCE -> RESOURCE 2785 * | | | |--MODIFIERS -> MODIFIERS 2786 * | | | |--TYPE -> TYPE 2787 * | | | | `--IDENT -> Foo 2788 * | | | |--IDENT -> foo 2789 * | | | `--ASSIGN -> = 2790 * | | | `--EXPR -> EXPR 2791 * | | | `--LITERAL_NEW -> new 2792 * | | | |--IDENT -> Foo 2793 * | | | |--LPAREN -> ( 2794 * | | | |--ELIST -> ELIST 2795 * | | | `--RPAREN -> ) 2796 * | | |--SEMI -> ; 2797 * | | `--RESOURCE -> RESOURCE 2798 * | | |--MODIFIERS -> MODIFIERS 2799 * | | |--TYPE -> TYPE 2800 * | | | `--IDENT -> Bar 2801 * | | |--IDENT -> bar 2802 * | | `--ASSIGN -> = 2803 * | | `--EXPR -> EXPR 2804 * | | `--LITERAL_NEW -> new 2805 * | | |--IDENT -> Bar 2806 * | | |--LPAREN -> ( 2807 * | | |--ELIST -> ELIST 2808 * | | `--RPAREN -> ) 2809 * | `--RPAREN -> ) 2810 * `--SLIST -> { 2811 * `--RCURLY -> } 2812 * </pre> 2813 * 2814 * <p>Also consider:</p> 2815 * <pre> 2816 * try (BufferedReader br = new BufferedReader(new FileReader(path))) { 2817 * } 2818 * </pre> 2819 * <p>which parses as:</p> 2820 * <pre> 2821 * LITERAL_TRY -> try 2822 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 2823 * | |--LPAREN -> ( 2824 * | |--RESOURCES -> RESOURCES 2825 * | | `--RESOURCE -> RESOURCE 2826 * | | |--MODIFIERS -> MODIFIERS 2827 * | | |--TYPE -> TYPE 2828 * | | | `--IDENT -> BufferedReader 2829 * | | |--IDENT -> br 2830 * | | `--ASSIGN -> = 2831 * | | `--EXPR -> EXPR 2832 * | | `--LITERAL_NEW -> new 2833 * | | |--IDENT -> BufferedReader 2834 * | | |--LPAREN -> ( 2835 * | | |--ELIST -> ELIST 2836 * | | | `--EXPR -> EXPR 2837 * | | | `--LITERAL_NEW -> new 2838 * | | | |--IDENT -> FileReader 2839 * | | | |--LPAREN -> ( 2840 * | | | |--ELIST -> ELIST 2841 * | | | | `--EXPR -> EXPR 2842 * | | | | `--IDENT -> path 2843 * | | | `--RPAREN -> ) 2844 * | | `--RPAREN -> ) 2845 * | `--RPAREN -> ) 2846 * `--SLIST -> { 2847 * `--RCURLY -> } 2848 * </pre> 2849 * 2850 * @see #LPAREN 2851 * @see #RESOURCES 2852 * @see #RESOURCE 2853 * @see #SEMI 2854 * @see #RPAREN 2855 * @see #LITERAL_TRY 2856 **/ 2857 public static final int RESOURCE_SPECIFICATION = 2858 GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION; 2859 2860 /** 2861 * A list of resources in the Java 7 try-with-resources construct. 2862 * This is a child of RESOURCE_SPECIFICATION. 2863 * 2864 * <p>For example:</p> 2865 * <pre> 2866 * try (FileReader fr = new FileReader("config.xml")) { 2867 * } finally {} 2868 * </pre> 2869 * <p>parses as:</p> 2870 * <pre> 2871 * LITERAL_TRY -> try 2872 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 2873 * | |--LPAREN -> ( 2874 * | |--RESOURCES -> RESOURCES 2875 * | | `--RESOURCE -> RESOURCE 2876 * | | |--MODIFIERS -> MODIFIERS 2877 * | | |--TYPE -> TYPE 2878 * | | | `--IDENT -> FileReader 2879 * | | |--IDENT -> fr 2880 * | | `--ASSIGN -> = 2881 * | | `--EXPR -> EXPR 2882 * | | `--LITERAL_NEW -> new 2883 * | | |--IDENT -> FileReader 2884 * | | |--LPAREN -> ( 2885 * | | |--ELIST -> ELIST 2886 * | | | `--EXPR -> EXPR 2887 * | | | `--STRING_LITERAL -> "config.xml" 2888 * | | `--RPAREN -> ) 2889 * | `--RPAREN -> ) 2890 * |--SLIST -> { 2891 * | `--RCURLY -> } 2892 * `--LITERAL_FINALLY -> finally 2893 * `--SLIST -> { 2894 * `--RCURLY -> } 2895 * </pre> 2896 * 2897 * @see #RESOURCE_SPECIFICATION 2898 **/ 2899 public static final int RESOURCES = 2900 GeneratedJavaTokenTypes.RESOURCES; 2901 2902 /** 2903 * A resource in the Java 7 try-with-resources construct. 2904 * This is a child of RESOURCES. 2905 * 2906 * <p>For example:</p> 2907 * <pre> 2908 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 2909 * </pre> 2910 * <p>parses as:</p> 2911 * <pre> 2912 * LITERAL_TRY -> try 2913 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 2914 * | |--LPAREN -> ( 2915 * | |--RESOURCES -> RESOURCES 2916 * | | |--RESOURCE -> RESOURCE 2917 * | | | |--MODIFIERS -> MODIFIERS 2918 * | | | |--TYPE -> TYPE 2919 * | | | | `--IDENT -> Foo 2920 * | | | |--IDENT -> foo 2921 * | | | `--ASSIGN -> = 2922 * | | | `--EXPR -> EXPR 2923 * | | | `--LITERAL_NEW -> new 2924 * | | | |--IDENT -> Foo 2925 * | | | |--LPAREN -> ( 2926 * | | | |--ELIST -> ELIST 2927 * | | | `--RPAREN -> ) 2928 * | | |--SEMI -> ; 2929 * | | `--RESOURCE -> RESOURCE 2930 * | | |--MODIFIERS -> MODIFIERS 2931 * | | |--TYPE -> TYPE 2932 * | | | `--IDENT -> Bar 2933 * | | |--IDENT -> bar 2934 * | | `--ASSIGN -> = 2935 * | | `--EXPR -> EXPR 2936 * | | `--LITERAL_NEW -> new 2937 * | | |--IDENT -> Bar 2938 * | | |--LPAREN -> ( 2939 * | | |--ELIST -> ELIST 2940 * | | `--RPAREN -> ) 2941 * | `--RPAREN -> ) 2942 * `--SLIST -> { 2943 * `--RCURLY -> } 2944 * </pre> 2945 * 2946 * @see #RESOURCES 2947 * @see #RESOURCE_SPECIFICATION 2948 **/ 2949 public static final int RESOURCE = 2950 GeneratedJavaTokenTypes.RESOURCE; 2951 2952 /** 2953 * The {@code catch} keyword. 2954 * 2955 * <p>For example:</p> 2956 * <pre> 2957 * try { 2958 * FileReader fr = new FileReader("Test.txt"); 2959 * } catch (FileNotFoundException e) { 2960 * 2961 * } 2962 * </pre> 2963 * <p>parses as:</p> 2964 * <pre> 2965 * LITERAL_TRY -> try 2966 * |--SLIST -> { 2967 * | |--VARIABLE_DEF -> VARIABLE_DEF 2968 * | | |--MODIFIERS -> MODIFIERS 2969 * | | |--TYPE -> TYPE 2970 * | | | `--IDENT -> FileReader 2971 * | | |--IDENT -> fr 2972 * | | `--ASSIGN -> = 2973 * | | `--EXPR -> EXPR 2974 * | | `--LITERAL_NEW -> new 2975 * | | |--IDENT -> FileReader 2976 * | | |--LPAREN -> ( 2977 * | | |--ELIST -> ELIST 2978 * | | | `--EXPR -> EXPR 2979 * | | | `--STRING_LITERAL -> "Test.txt" 2980 * | | `--RPAREN -> ) 2981 * | |--SEMI -> ; 2982 * | `--RCURLY -> } 2983 * `--LITERAL_CATCH -> catch 2984 * |--LPAREN -> ( 2985 * |--PARAMETER_DEF -> PARAMETER_DEF 2986 * | |--MODIFIERS -> MODIFIERS 2987 * | |--TYPE -> TYPE 2988 * | | `--IDENT -> FileNotFoundException 2989 * | `--IDENT -> e 2990 * |--RPAREN -> ) 2991 * `--SLIST -> { 2992 * `--RCURLY -> } 2993 * </pre> 2994 * 2995 * @see #LPAREN 2996 * @see #PARAMETER_DEF 2997 * @see #RPAREN 2998 * @see #SLIST 2999 * @see #LITERAL_TRY 3000 **/ 3001 public static final int LITERAL_CATCH = 3002 GeneratedJavaTokenTypes.LITERAL_catch; 3003 3004 /** 3005 * The {@code finally} keyword. 3006 * 3007 * <p>For example:</p> 3008 * <pre> 3009 * try {} finally {} 3010 * </pre> 3011 * <p>parses as:</p> 3012 * <pre> 3013 * LITERAL_TRY -> try 3014 * |--SLIST -> { 3015 * | `--RCURLY -> } 3016 * `--LITERAL_FINALLY -> finally 3017 * `--SLIST -> { 3018 * `--RCURLY -> } 3019 * </pre> 3020 * 3021 * @see #SLIST 3022 * @see #LITERAL_TRY 3023 **/ 3024 public static final int LITERAL_FINALLY = 3025 GeneratedJavaTokenTypes.LITERAL_finally; 3026 3027 /** 3028 * The {@code +=} (addition assignment) operator. 3029 * 3030 * <p>For example:</p> 3031 * <pre> 3032 * a += b; 3033 * </pre> 3034 * <p>parses as:</p> 3035 * <pre> 3036 * |--EXPR -> EXPR 3037 * | `--PLUS_ASSIGN -> += 3038 * | |--IDENT -> a 3039 * | `--IDENT -> b 3040 * |--SEMI -> ; 3041 * </pre> 3042 * 3043 * @see <a 3044 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3045 * Language Specification, §15.26.2</a> 3046 * @see #EXPR 3047 **/ 3048 public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN; 3049 /** 3050 * The {@code -=} (subtraction assignment) operator. 3051 * 3052 * <p>For example:</p> 3053 * <pre> 3054 * a -= b; 3055 * </pre> 3056 * <p>parses as:</p> 3057 * <pre> 3058 * |--EXPR -> EXPR 3059 * | `--MINUS_ASSIGN -> -= 3060 * | |--IDENT -> a 3061 * | `--IDENT -> b 3062 * |--SEMI -> ; 3063 * </pre> 3064 * 3065 * @see <a 3066 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3067 * Language Specification, §15.26.2</a> 3068 * @see #EXPR 3069 **/ 3070 public static final int MINUS_ASSIGN = 3071 GeneratedJavaTokenTypes.MINUS_ASSIGN; 3072 3073 /** 3074 * The {@code *=} (multiplication assignment) operator. 3075 * 3076 * <p>For example:</p> 3077 * <pre> 3078 * a *= b; 3079 * </pre> 3080 * <p>parses as:</p> 3081 * <pre> 3082 * |--EXPR -> EXPR 3083 * | `--STAR_ASSIGN -> *= 3084 * | |--IDENT -> a 3085 * | `--IDENT -> b 3086 * |--SEMI -> ; 3087 * </pre> 3088 * 3089 * @see <a 3090 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3091 * Language Specification, §15.26.2</a> 3092 * @see #EXPR 3093 **/ 3094 public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN; 3095 /** 3096 * The {@code /=} (division assignment) operator. 3097 * 3098 * <p>For example:</p> 3099 * <pre> 3100 * a /= b; 3101 * </pre> 3102 * <p>parses as:</p> 3103 * <pre> 3104 * |--EXPR -> EXPR 3105 * | `--DIV_ASSIGN -> /= 3106 * | |--IDENT -> a 3107 * | `--IDENT -> b 3108 * |--SEMI -> ; 3109 * </pre> 3110 * 3111 * @see <a 3112 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3113 * Language Specification, §15.26.2</a> 3114 * @see #EXPR 3115 **/ 3116 public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN; 3117 /** 3118 * The {@code %=} (remainder assignment) operator. 3119 * <p>For example:</p> 3120 * <pre>a %= 2;</pre> 3121 * <p>parses as:</p> 3122 * <pre> 3123 * |--EXPR -> EXPR 3124 * | `--MOD_ASSIGN -> %= 3125 * | |--IDENT -> a 3126 * | `--NUM_INT -> 2 3127 * |--SEMI -> ; 3128 * </pre> 3129 * 3130 * @see <a 3131 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3132 * Language Specification, §15.26.2</a> 3133 * @see #EXPR 3134 **/ 3135 public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN; 3136 /** 3137 * The {@code >>=} (signed right shift assignment) 3138 * operator. 3139 * 3140 * <p>For example:</p> 3141 * <pre> 3142 * a >>= b; 3143 * </pre> 3144 * <p>parses as:</p> 3145 * <pre> 3146 * |--EXPR -> EXPR 3147 * | `--SR_ASSIGN -> >>= 3148 * | |--IDENT -> a 3149 * | `--IDENT -> b 3150 * |--SEMI -> ; 3151 * </pre> 3152 * 3153 * @see <a 3154 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3155 * Language Specification, §15.26.2</a> 3156 * @see #EXPR 3157 **/ 3158 public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN; 3159 /** 3160 * The {@code >>>=} (unsigned right shift assignment) 3161 * operator. 3162 * 3163 * <p>For example:</p> 3164 * <pre> 3165 * a >>>= b; 3166 * </pre> 3167 * <p>parses as:</p> 3168 * <pre> 3169 * |--EXPR -> EXPR 3170 * | `--BSR_ASSIGN -> >>>= 3171 * | |--IDENT -> a 3172 * | `--IDENT -> b 3173 * |--SEMI -> ; 3174 * </pre> 3175 * 3176 * @see <a 3177 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3178 * Language Specification, §15.26.2</a> 3179 * @see #EXPR 3180 **/ 3181 public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN; 3182 /** 3183 * The {@code <<=} (left shift assignment) operator. 3184 * 3185 * @see <a 3186 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3187 * Language Specification, §15.26.2</a> 3188 * @see #EXPR 3189 **/ 3190 public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN; 3191 /** 3192 * The {@code &=} (bitwise AND assignment) operator. 3193 * 3194 * <p>For example:</p> 3195 * <pre> 3196 * a &= b; 3197 * </pre> 3198 * <p>parses as:</p> 3199 * <pre> 3200 * |--EXPR -> EXPR 3201 * | `--BAND_ASSIGN -> &= 3202 * | |--IDENT -> a 3203 * | `--IDENT -> b 3204 * |--SEMI -> ; 3205 * </pre> 3206 * 3207 * @see <a 3208 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3209 * Language Specification, §15.26.2</a> 3210 * @see #EXPR 3211 **/ 3212 public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN; 3213 /** 3214 * The {@code ^=} (bitwise exclusive OR assignment) operator. 3215 * 3216 * @see <a 3217 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3218 * Language Specification, §15.26.2</a> 3219 * @see #EXPR 3220 **/ 3221 public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN; 3222 /** 3223 * The {@code |=} (bitwise OR assignment) operator. 3224 * 3225 * <p>For example:</p> 3226 * <pre> 3227 * a |= b; 3228 * </pre> 3229 * <p>parses as:</p> 3230 * <pre> 3231 * |--EXPR -> EXPR 3232 * | `--BOR_ASSIGN -> |= 3233 * | |--IDENT -> a 3234 * | `--IDENT -> b 3235 * |--SEMI -> ; 3236 * </pre> 3237 * 3238 * @see <a 3239 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3240 * Language Specification, §15.26.2</a> 3241 * @see #EXPR 3242 **/ 3243 public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN; 3244 /** 3245 * The <code>?</code> (conditional) operator. Technically, 3246 * the colon is also part of this operator, but it appears as a 3247 * separate token. 3248 * 3249 * <p>For example:</p> 3250 * <pre> 3251 * String variable=(quantity==1)?"true":"false"; 3252 * </pre> 3253 * <p>parses as:</p> 3254 * <pre> 3255 * |--VARIABLE_DEF -> VARIABLE_DEF 3256 * | |--MODIFIERS -> MODIFIERS 3257 * | |--TYPE -> TYPE 3258 * | | `--IDENT -> String 3259 * | |--IDENT -> variable 3260 * | `--ASSIGN -> = 3261 * | `--EXPR -> EXPR 3262 * | `--QUESTION -> ? 3263 * | |--LPAREN -> ( 3264 * | |--EQUAL -> == 3265 * | | |--IDENT -> quantity 3266 * | | `--NUM_INT -> 1 3267 * | |--RPAREN -> ) 3268 * | |--STRING_LITERAL -> "true" 3269 * | |--COLON -> : 3270 * | `--STRING_LITERAL -> "false" 3271 * |--SEMI -> ; 3272 * </pre> 3273 * 3274 * @see <a 3275 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 3276 * Language Specification, §15.25</a> 3277 * @see #EXPR 3278 * @see #COLON 3279 * @noinspection HtmlTagCanBeJavadocTag 3280 **/ 3281 public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION; 3282 /** 3283 * The {@code ||} (conditional OR) operator. 3284 * 3285 * <p>For example:</p> 3286 * <pre> 3287 * if (a || b) { 3288 * } 3289 * </pre> 3290 * <p> 3291 * parses as: 3292 * </p> 3293 * <pre> 3294 * LITERAL_IF -> if 3295 * |--LPAREN -> ( 3296 * |--EXPR -> EXPR 3297 * | `--LOR -> || 3298 * | |--IDENT -> a 3299 * | `--IDENT -> b 3300 * |--RPAREN -> ) 3301 * |--SLIST -> { 3302 * | |--RCURLY -> } 3303 * </pre> 3304 * 3305 * @see <a 3306 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java 3307 * Language Specification, §15.24</a> 3308 * @see #EXPR 3309 **/ 3310 public static final int LOR = GeneratedJavaTokenTypes.LOR; 3311 /** 3312 * The {@code &&} (conditional AND) operator. 3313 * 3314 * 3315 * <p>For example:</p> 3316 * <pre> 3317 * if (a && b) { 3318 * } 3319 * </pre> 3320 * <p>parses as:</p> 3321 * <pre> 3322 * LITERAL_IF -> if 3323 * |--LPAREN -> ( 3324 * |--EXPR -> EXPR 3325 * | `--LAND -> && 3326 * | |--IDENT -> a 3327 * | `--IDENT -> b 3328 * |--RPAREN -> ) 3329 * |--SLIST -> { 3330 * | |--RCURLY -> } 3331 * </pre> 3332 * 3333 * @see <a 3334 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 3335 * Language Specification, §15.23</a> 3336 * @see #EXPR 3337 **/ 3338 public static final int LAND = GeneratedJavaTokenTypes.LAND; 3339 /** 3340 * The {@code |} (bitwise OR) operator. 3341 * 3342 * <p>For example:</p> 3343 * <pre> 3344 * a = a | b; 3345 * </pre> 3346 * <p>parses as:</p> 3347 * <pre> 3348 * |--EXPR -> EXPR 3349 * | `--ASSIGN -> = 3350 * | |--IDENT -> a 3351 * | `--BOR -> | 3352 * | |--IDENT -> a 3353 * | `--IDENT -> b 3354 * |--SEMI -> ; 3355 * </pre> 3356 * 3357 * @see <a 3358 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3359 * Language Specification, §15.22.1</a> 3360 * @see #EXPR 3361 **/ 3362 public static final int BOR = GeneratedJavaTokenTypes.BOR; 3363 /** 3364 * The {@code ^} (bitwise exclusive OR) operator. 3365 * 3366 * @see <a 3367 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3368 * Language Specification, §15.22.1</a> 3369 * @see #EXPR 3370 **/ 3371 public static final int BXOR = GeneratedJavaTokenTypes.BXOR; 3372 /** 3373 * The {@code &} (bitwise AND) operator. 3374 * 3375 * <p>For example:</p> 3376 * <pre> 3377 * c = a & b; 3378 * </pre> 3379 * <p>parses as:</p> 3380 * <pre> 3381 * |--EXPR -> EXPR 3382 * | `--ASSIGN -> = 3383 * | |--IDENT -> c 3384 * | `--BAND -> & 3385 * | |--IDENT -> a 3386 * | `--IDENT -> b 3387 * |--SEMI -> ; 3388 * </pre> 3389 * 3390 * @see <a 3391 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3392 * Language Specification, §15.22.1</a> 3393 * @see #EXPR 3394 **/ 3395 public static final int BAND = GeneratedJavaTokenTypes.BAND; 3396 /** 3397 * The <code>!=</code> (not equal) operator. 3398 * 3399 * <p>For example:</p> 3400 * <pre> 3401 * a != b; 3402 * </pre> 3403 * <p>parses as:</p> 3404 * <pre> 3405 * |--EXPR -> EXPR 3406 * | `--NOT_EQUAL -> != 3407 * | |--IDENT -> a 3408 * | `--IDENT -> b 3409 * `--SEMI -> ; 3410 * </pre> 3411 * 3412 * @see #EXPR 3413 * @noinspection HtmlTagCanBeJavadocTag 3414 **/ 3415 public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL; 3416 /** 3417 * The {@code ==} (equal) operator. 3418 * 3419 * <p>For example:</p> 3420 * <pre> 3421 * return a == b; 3422 * </pre> 3423 * <p>parses as:</p> 3424 * <pre> 3425 * |--EXPR -> EXPR 3426 * | `--EQUAL -> == 3427 * | |--IDENT -> a 3428 * | `--IDENT -> b 3429 * `--SEMI -> ; 3430 * </pre> 3431 * 3432 * @see #EXPR 3433 **/ 3434 public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL; 3435 /** 3436 * The {@code <} (less than) operator. 3437 * 3438 * <p>For example:</p> 3439 * <pre> 3440 * c = a < b; 3441 * </pre> 3442 * <p>parses as:</p> 3443 * <pre> 3444 * |--EXPR -> EXPR 3445 * | `--ASSIGN -> = 3446 * | |--IDENT -> c 3447 * | `--LT -> < 3448 * | |--IDENT -> a 3449 * | `--IDENT -> b 3450 * |--SEMI -> ; 3451 * </pre> 3452 * 3453 * @see #EXPR 3454 **/ 3455 public static final int LT = GeneratedJavaTokenTypes.LT; 3456 /** 3457 * The {@code >} (greater than) operator. 3458 * 3459 * <p>For example:</p> 3460 * <pre> 3461 * c = a > b; 3462 * </pre> 3463 * <p>parses as:</p> 3464 * <pre> 3465 * |--EXPR -> EXPR 3466 * | `--ASSIGN -> = 3467 * | |--IDENT -> c 3468 * | `--BAND -> > 3469 * | |--IDENT -> a 3470 * | `--IDENT -> b 3471 * |--SEMI -> ; 3472 * </pre> 3473 * 3474 * @see #EXPR 3475 **/ 3476 public static final int GT = GeneratedJavaTokenTypes.GT; 3477 /** 3478 * The {@code <=} (less than or equal) operator. 3479 * 3480 * <p>For example:</p> 3481 * <pre> 3482 * c = a <= b; 3483 * </pre> 3484 * <p>parses as:</p> 3485 * <pre> 3486 * |--EXPR -> EXPR 3487 * | `--ASSIGN -> = 3488 * | |--IDENT -> c 3489 * | `--LE -> <= 3490 * | |--IDENT -> a 3491 * | `--IDENT -> b 3492 * |--SEMI -> ; 3493 * </pre> 3494 * 3495 * @see #EXPR 3496 **/ 3497 public static final int LE = GeneratedJavaTokenTypes.LE; 3498 /** 3499 * The {@code >=} (greater than or equal) operator. 3500 * 3501 * @see #EXPR 3502 **/ 3503 public static final int GE = GeneratedJavaTokenTypes.GE; 3504 /** 3505 * The {@code instanceof} operator. The first child is an 3506 * object reference or something that evaluates to an object 3507 * reference. The second child is a reference type. 3508 * <p>For example:</p> 3509 * <pre> 3510 * boolean isBuilder = text instanceof StringBuilder; 3511 * </pre> 3512 * <p>parses as:</p> 3513 * <pre> 3514 * |--VARIABLE_DEF -> VARIABLE_DEF 3515 * | |--MODIFIERS -> MODIFIERS 3516 * | |--TYPE -> TYPE 3517 * | | `--LITERAL_BOOLEAN -> boolean 3518 * | |--IDENT -> isBuilder 3519 * | `--ASSIGN -> = 3520 * | `--EXPR -> EXPR 3521 * | `--LITERAL_INSTANCEOF -> instanceof 3522 * | |--IDENT -> text 3523 * | `--TYPE -> TYPE 3524 * | `--IDENT -> StringBuilder 3525 * |--SEMI -> ; 3526 * </pre> 3527 * 3528 * @see <a 3529 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 3530 * Language Specification, §15.20.2</a> 3531 * @see #EXPR 3532 * @see #METHOD_CALL 3533 * @see #IDENT 3534 * @see #DOT 3535 * @see #TYPE 3536 * @see FullIdent 3537 **/ 3538 public static final int LITERAL_INSTANCEOF = 3539 GeneratedJavaTokenTypes.LITERAL_instanceof; 3540 3541 /** 3542 * The {@code <<} (shift left) operator. 3543 * 3544 * <p>For example:</p> 3545 * <pre> 3546 * a = a << b; 3547 * </pre> 3548 * <p>parses as:</p> 3549 * <pre> 3550 * |--EXPR -> EXPR 3551 * | `--ASSIGN -> = 3552 * | |--IDENT -> a 3553 * | `--SR -> << 3554 * | |--IDENT -> a 3555 * | `--IDENT -> b 3556 * |--SEMI -> ; 3557 * </pre> 3558 * 3559 * @see <a 3560 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 3561 * Language Specification, §15.19</a> 3562 * @see #EXPR 3563 **/ 3564 public static final int SL = GeneratedJavaTokenTypes.SL; 3565 /** 3566 * The {@code >>} (signed shift right) operator. 3567 * 3568 * <p>For example:</p> 3569 * <pre> 3570 * a = a >> b; 3571 * </pre> 3572 * <p>parses as:</p> 3573 * <pre> 3574 * |--EXPR -> EXPR 3575 * | `--ASSIGN -> = 3576 * | |--IDENT -> a 3577 * | `--SR -> >> 3578 * | |--IDENT -> a 3579 * | `--IDENT -> b 3580 * |--SEMI -> ; 3581 * </pre> 3582 * 3583 * @see <a 3584 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 3585 * Language Specification, §15.19</a> 3586 * @see #EXPR 3587 **/ 3588 public static final int SR = GeneratedJavaTokenTypes.SR; 3589 /** 3590 * The {@code >>>} (unsigned shift right) operator. 3591 * 3592 * <p>For example:</p> 3593 * <pre> 3594 * a >>> b; 3595 * </pre> 3596 * <p>parses as:</p> 3597 * <pre> 3598 * |--EXPR -> EXPR 3599 * | `--BSR -> >>> 3600 * | |--IDENT -> a 3601 * | `--IDENT -> b 3602 * |--SEMI -> ; 3603 * </pre> 3604 * 3605 * @see <a 3606 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 3607 * Language Specification, §15.19</a> 3608 * @see #EXPR 3609 **/ 3610 public static final int BSR = GeneratedJavaTokenTypes.BSR; 3611 /** 3612 * The {@code +} (addition) operator. 3613 * 3614 * <p>For example:</p> 3615 * <pre> 3616 * c = a + b; 3617 * </pre> 3618 * <p>parses as:</p> 3619 * <pre> 3620 * |--EXPR -> EXPR 3621 * | `--ASSIGN -> = 3622 * | |--IDENT -> c 3623 * | `--PLUS -> + 3624 * | |--IDENT -> a 3625 * | `--IDENT -> b 3626 * |--SEMI -> ; 3627 * </pre> 3628 * 3629 * @see <a 3630 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 3631 * Language Specification, §15.18</a> 3632 * @see #EXPR 3633 **/ 3634 public static final int PLUS = GeneratedJavaTokenTypes.PLUS; 3635 /** 3636 * The {@code -} (subtraction) operator. 3637 * 3638 * <p>For example:</p> 3639 * <pre> 3640 * c = a - b; 3641 * </pre> 3642 * <p>parses as:</p> 3643 * <pre> 3644 * |--EXPR -> EXPR 3645 * | `--ASSIGN -> = 3646 * | |--IDENT -> c 3647 * | `--MINUS -> - 3648 * | |--IDENT -> a 3649 * | `--IDENT -> b 3650 * |--SEMI -> ; 3651 * </pre> 3652 * 3653 * @see <a 3654 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 3655 * Language Specification, §15.18</a> 3656 * @see #EXPR 3657 **/ 3658 public static final int MINUS = GeneratedJavaTokenTypes.MINUS; 3659 /** 3660 * The {@code /} (division) operator. 3661 * 3662 * <p>For example:</p> 3663 * <pre> 3664 * a = 4 / 2; 3665 * </pre> 3666 * <p>parses as:</p> 3667 * <pre> 3668 * |--EXPR -> EXPR 3669 * | `--ASSIGN -> = 3670 * | |--IDENT -> a 3671 * | `--DIV -> / 3672 * | |--NUM_INT -> 4 3673 * | `--NUM_INT -> 2 3674 * |--SEMI -> ; 3675 * </pre> 3676 * 3677 * @see <a 3678 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 3679 * Language Specification, §15.17.2</a> 3680 * @see #EXPR 3681 **/ 3682 public static final int DIV = GeneratedJavaTokenTypes.DIV; 3683 /** 3684 * The {@code %} (remainder) operator. 3685 * 3686 * <p>For example:</p> 3687 * <pre> 3688 * c = a % b; 3689 * </pre> 3690 * <p>parses as:</p> 3691 * <pre> 3692 * EXPR -> EXPR 3693 * `--ASSIGN -> = 3694 * |--IDENT -> c 3695 * `--MOD -> % 3696 * |--IDENT -> a 3697 * `--IDENT -> b 3698 * SEMI -> ; 3699 * </pre> 3700 * 3701 * @see <a 3702 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 3703 * Language Specification, §15.17.3</a> 3704 * @see #EXPR 3705 **/ 3706 public static final int MOD = GeneratedJavaTokenTypes.MOD; 3707 /** 3708 * The {@code ++} (prefix increment) operator. 3709 * 3710 * <p>For example:</p> 3711 * <pre> 3712 * ++a; 3713 * </pre> 3714 * <p>parses as:</p> 3715 * <pre> 3716 * |--EXPR -> EXPR 3717 * | `--INC -> ++ 3718 * | `--IDENT -> a 3719 * |--SEMI -> ; 3720 * </pre> 3721 * 3722 * @see <a 3723 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 3724 * Language Specification, §15.15.1</a> 3725 * @see #EXPR 3726 * @see #POST_INC 3727 **/ 3728 public static final int INC = GeneratedJavaTokenTypes.INC; 3729 /** 3730 * The {@code --} (prefix decrement) operator. 3731 * 3732 * <p>For example:</p> 3733 * <pre> 3734 * --a; 3735 * </pre> 3736 * <p>parses as:</p> 3737 * <pre> 3738 * |--EXPR -> EXPR 3739 * | `--DEC -> -- 3740 * | `--IDENT -> a 3741 * |--SEMI -> ; 3742 * </pre> 3743 * 3744 * @see <a 3745 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 3746 * Language Specification, §15.15.2</a> 3747 * @see #EXPR 3748 * @see #POST_DEC 3749 **/ 3750 public static final int DEC = GeneratedJavaTokenTypes.DEC; 3751 /** 3752 * The {@code ~} (bitwise complement) operator. 3753 * 3754 * <p>For example:</p> 3755 * <pre> 3756 * a = ~ a; 3757 * </pre> 3758 * <p>parses as:</p> 3759 * <pre> 3760 * |--EXPR -> EXPR 3761 * | `--ASSIGN -> = 3762 * | |--IDENT -> a 3763 * | `--BNOT -> ~ 3764 * | `--IDENT -> a 3765 * |--SEMI -> ; 3766 * </pre> 3767 * 3768 * @see <a 3769 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 3770 * Language Specification, §15.15.5</a> 3771 * @see #EXPR 3772 **/ 3773 public static final int BNOT = GeneratedJavaTokenTypes.BNOT; 3774 /** 3775 * The <code>!</code> (logical complement) operator. 3776 * 3777 * <p>For example:</p> 3778 * <pre> 3779 * c = ! a; 3780 * </pre> 3781 * <p>parses as:</p> 3782 * <pre> 3783 * |--EXPR -> EXPR 3784 * | `--ASSIGN -> = 3785 * | |--IDENT -> c 3786 * | `--LNOT -> ! 3787 * | `--IDENT -> a 3788 * |--SEMI -> ; 3789 * </pre> 3790 * 3791 * @see <a 3792 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 3793 * Language Specification, §15.15.6</a> 3794 * @see #EXPR 3795 * @noinspection HtmlTagCanBeJavadocTag 3796 **/ 3797 public static final int LNOT = GeneratedJavaTokenTypes.LNOT; 3798 /** 3799 * The {@code true} keyword. 3800 * 3801 * <p>For example:</p> 3802 * <pre> 3803 * boolean a = true; 3804 * </pre> 3805 * <p>parses as:</p> 3806 * <pre> 3807 * |--VARIABLE_DEF -> VARIABLE_DEF 3808 * | |--MODIFIERS -> MODIFIERS 3809 * | |--TYPE -> TYPE 3810 * | | `--LITERAL_BOOLEAN -> boolean 3811 * | |--IDENT -> a 3812 * | `--ASSIGN -> = 3813 * | `--EXPR -> EXPR 3814 * | `--LITERAL_TRUE -> true 3815 * |--SEMI -> ; 3816 * </pre> 3817 * 3818 * @see <a 3819 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 3820 * Language Specification, §3.10.3</a> 3821 * @see #EXPR 3822 * @see #LITERAL_FALSE 3823 **/ 3824 public static final int LITERAL_TRUE = 3825 GeneratedJavaTokenTypes.LITERAL_true; 3826 3827 /** 3828 * The {@code false} keyword. 3829 * 3830 * <p>For example:</p> 3831 * <pre> 3832 * boolean a = false; 3833 * </pre> 3834 * <p>parses as:</p> 3835 * <pre> 3836 * VARIABLE_DEF -> VARIABLE_DEF 3837 * |--MODIFIERS -> MODIFIERS 3838 * |--TYPE -> TYPE 3839 * | `--LITERAL_BOOLEAN -> boolean 3840 * |--IDENT -> a 3841 * |--ASSIGN -> = 3842 * | `--EXPR -> EXPR 3843 * | `--LITERAL_FALSE -> false 3844 * `--SEMI -> ; 3845 * </pre> 3846 * 3847 * @see <a 3848 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 3849 * Language Specification, §3.10.3</a> 3850 * @see #EXPR 3851 * @see #LITERAL_TRUE 3852 **/ 3853 public static final int LITERAL_FALSE = 3854 GeneratedJavaTokenTypes.LITERAL_false; 3855 3856 /** 3857 * The {@code null} keyword. 3858 * 3859 * <p>For example:</p> 3860 * <pre> 3861 * String s = null; 3862 * </pre> 3863 * <p>parses as:</p> 3864 * <pre> 3865 * VARIABLE_DEF -> VARIABLE_DEF 3866 * |--MODIFIERS -> MODIFIERS 3867 * |--TYPE -> TYPE 3868 * | `--IDENT -> String 3869 * |--IDENT -> s 3870 * |--ASSIGN -> = 3871 * | `--EXPR -> EXPR 3872 * | `--LITERAL_NULL -> null 3873 * `--SEMI -> ; 3874 * </pre> 3875 * 3876 * @see <a 3877 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 3878 * Language Specification, §3.10.7</a> 3879 * @see #EXPR 3880 **/ 3881 public static final int LITERAL_NULL = 3882 GeneratedJavaTokenTypes.LITERAL_null; 3883 3884 /** 3885 * The {@code new} keyword. This element is used to define 3886 * new instances of objects, new arrays, and new anonymous inner 3887 * classes. 3888 * 3889 * <p>For example:</p> 3890 * 3891 * <pre> 3892 * new ArrayList(50) 3893 * </pre> 3894 * 3895 * <p>parses as:</p> 3896 * <pre> 3897 * LITERAL_NEW -> new 3898 * |--IDENT -> ArrayList 3899 * |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 3900 * | |--GENERIC_START -> < 3901 * | `--GENERIC_END -> > 3902 * |--LPAREN -> ( 3903 * |--ELIST -> ELIST 3904 * | `--EXPR -> EXPR 3905 * | `--NUM_INT -> 50 3906 * `--RPAREN -> ) 3907 * </pre> 3908 * 3909 * <p>For example:</p> 3910 * <pre> 3911 * new float[] 3912 * { 3913 * 3.0f, 3914 * 4.0f 3915 * }; 3916 * </pre> 3917 * 3918 * <p>parses as:</p> 3919 * <pre> 3920 * +--LITERAL_NEW (new) 3921 * | 3922 * +--LITERAL_FLOAT (float) 3923 * +--ARRAY_DECLARATOR ([) 3924 * +--ARRAY_INIT ({) 3925 * | 3926 * +--EXPR 3927 * | 3928 * +--NUM_FLOAT (3.0f) 3929 * +--COMMA (,) 3930 * +--EXPR 3931 * | 3932 * +--NUM_FLOAT (4.0f) 3933 * +--RCURLY (}) 3934 * </pre> 3935 * 3936 * <p>For example:</p> 3937 * <pre> 3938 * new FilenameFilter() 3939 * { 3940 * public boolean accept(File dir, String name) 3941 * { 3942 * return name.endsWith(".java"); 3943 * } 3944 * } 3945 * </pre> 3946 * 3947 * <p>parses as:</p> 3948 * <pre> 3949 * +--LITERAL_NEW (new) 3950 * | 3951 * +--IDENT (FilenameFilter) 3952 * +--LPAREN (() 3953 * +--ELIST 3954 * +--RPAREN ()) 3955 * +--OBJBLOCK 3956 * | 3957 * +--LCURLY ({) 3958 * +--METHOD_DEF 3959 * | 3960 * +--MODIFIERS 3961 * | 3962 * +--LITERAL_PUBLIC (public) 3963 * +--TYPE 3964 * | 3965 * +--LITERAL_BOOLEAN (boolean) 3966 * +--IDENT (accept) 3967 * +--PARAMETERS 3968 * | 3969 * +--PARAMETER_DEF 3970 * | 3971 * +--MODIFIERS 3972 * +--TYPE 3973 * | 3974 * +--IDENT (File) 3975 * +--IDENT (dir) 3976 * +--COMMA (,) 3977 * +--PARAMETER_DEF 3978 * | 3979 * +--MODIFIERS 3980 * +--TYPE 3981 * | 3982 * +--IDENT (String) 3983 * +--IDENT (name) 3984 * +--SLIST ({) 3985 * | 3986 * +--LITERAL_RETURN (return) 3987 * | 3988 * +--EXPR 3989 * | 3990 * +--METHOD_CALL (() 3991 * | 3992 * +--DOT (.) 3993 * | 3994 * +--IDENT (name) 3995 * +--IDENT (endsWith) 3996 * +--ELIST 3997 * | 3998 * +--EXPR 3999 * | 4000 * +--STRING_LITERAL (".java") 4001 * +--RPAREN ()) 4002 * +--SEMI (;) 4003 * +--RCURLY (}) 4004 * +--RCURLY (}) 4005 * </pre> 4006 * 4007 * @see #IDENT 4008 * @see #DOT 4009 * @see #LPAREN 4010 * @see #ELIST 4011 * @see #RPAREN 4012 * @see #OBJBLOCK 4013 * @see #ARRAY_INIT 4014 * @see FullIdent 4015 **/ 4016 public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new; 4017 /** 4018 * An integer literal. These may be specified in decimal, 4019 * hexadecimal, or octal form. 4020 * 4021 * <p>For example:</p> 4022 * <pre> 4023 * a = 3; 4024 * </pre> 4025 * <p>parses as:</p> 4026 * <pre> 4027 * |--EXPR -> EXPR 4028 * | `--ASSIGN -> = 4029 * | |--IDENT -> a 4030 * | `--NUM_INT -> 3 4031 * |--SEMI -> ; 4032 * </pre> 4033 * 4034 * @see <a 4035 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 4036 * Language Specification, §3.10.1</a> 4037 * @see #EXPR 4038 * @see #NUM_LONG 4039 **/ 4040 public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT; 4041 /** 4042 * A character literal. This is a (possibly escaped) character 4043 * enclosed in single quotes. 4044 * 4045 * <p>For example:</p> 4046 * <pre> 4047 * return 'a'; 4048 * </pre> 4049 * <p>parses as:</p> 4050 * <pre> 4051 * --LITERAL_RETURN -> return 4052 * |--EXPR -> EXPR 4053 * | `--CHAR_LITERAL -> 'a' 4054 * `--SEMI -> ; 4055 * </pre> 4056 * 4057 * @see <a 4058 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 4059 * Language Specification, §3.10.4</a> 4060 * @see #EXPR 4061 **/ 4062 public static final int CHAR_LITERAL = 4063 GeneratedJavaTokenTypes.CHAR_LITERAL; 4064 4065 /** 4066 * A string literal. This is a sequence of (possibly escaped) 4067 * characters enclosed in double quotes. 4068 * <p>For example:</p> 4069 * <pre>String str = "StringLiteral";</pre> 4070 * 4071 * <p>parses as:</p> 4072 * <pre> 4073 * |--VARIABLE_DEF -> VARIABLE_DEF 4074 * | |--MODIFIERS -> MODIFIERS 4075 * | |--TYPE -> TYPE 4076 * | | `--IDENT -> String 4077 * | |--IDENT -> str 4078 * | `--ASSIGN -> = 4079 * | `--EXPR -> EXPR 4080 * | `--STRING_LITERAL -> "StringLiteral" 4081 * |--SEMI -> ; 4082 * </pre> 4083 * 4084 * @see <a 4085 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 4086 * Language Specification, §3.10.5</a> 4087 * @see #EXPR 4088 **/ 4089 public static final int STRING_LITERAL = 4090 GeneratedJavaTokenTypes.STRING_LITERAL; 4091 4092 /** 4093 * A single precision floating point literal. This is a floating 4094 * point number with an {@code F} or {@code f} suffix. 4095 * 4096 * <p>For example:</p> 4097 * <pre> 4098 * a = 3.14f; 4099 * </pre> 4100 * <p>parses as:</p> 4101 * <pre> 4102 * |--EXPR -> EXPR 4103 * | `--ASSIGN -> = 4104 * | |--IDENT -> a 4105 * | `--NUM_FLOAT -> 3.14f 4106 * |--SEMI -> ; 4107 * </pre> 4108 * 4109 * @see <a 4110 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 4111 * Language Specification, §3.10.2</a> 4112 * @see #EXPR 4113 * @see #NUM_DOUBLE 4114 **/ 4115 public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT; 4116 /** 4117 * A long integer literal. These are almost the same as integer 4118 * literals, but they have an {@code L} or {@code l} 4119 * (ell) suffix. 4120 * 4121 * <p>For example:</p> 4122 * <pre> 4123 * a = 3l; 4124 * </pre> 4125 * <p>parses as:</p> 4126 * <pre> 4127 * |--EXPR -> EXPR 4128 * | `--ASSIGN -> = 4129 * | |--IDENT -> a 4130 * | `--NUM_LONG -> 3l 4131 * |--SEMI -> ; 4132 * </pre> 4133 * 4134 * @see <a 4135 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 4136 * Language Specification, §3.10.1</a> 4137 * @see #EXPR 4138 * @see #NUM_INT 4139 **/ 4140 public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG; 4141 /** 4142 * A double precision floating point literal. This is a floating 4143 * point number with an optional {@code D} or {@code d} 4144 * suffix. 4145 * 4146 * <p>For example:</p> 4147 * <pre> 4148 * a = 3.14d; 4149 * </pre> 4150 * <p>parses as:</p> 4151 * <pre> 4152 * |--EXPR -> EXPR 4153 * | `--ASSIGN -> = 4154 * | |--IDENT -> a 4155 * | `--NUM_DOUBLE -> 3.14d 4156 * |--SEMI -> ; 4157 * </pre> 4158 * 4159 * @see <a 4160 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 4161 * Language Specification, §3.10.2</a> 4162 * @see #EXPR 4163 * @see #NUM_FLOAT 4164 **/ 4165 public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE; 4166 4167 /** 4168 * The {@code assert} keyword. This is only for Java 1.4 and 4169 * later. 4170 * 4171 * <p>For example:</p> 4172 * <pre> 4173 * assert(x==4); 4174 * </pre> 4175 * <p>parses as:</p> 4176 * <pre> 4177 * +--LITERAL_ASSERT (assert) 4178 * | 4179 * +--EXPR 4180 * | 4181 * +--LPAREN (() 4182 * +--EQUAL (==) 4183 * | 4184 * +--IDENT (x) 4185 * +--NUM_INT (4) 4186 * +--RPAREN ()) 4187 * +--SEMI (;) 4188 * </pre> 4189 **/ 4190 public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT; 4191 4192 /** 4193 * A static import declaration. Static import declarations are optional, 4194 * but must appear after the package declaration and before the type 4195 * declaration. 4196 * 4197 * <p>For example:</p> 4198 * <pre> 4199 * import static java.io.IOException; 4200 * </pre> 4201 * <p>parses as:</p> 4202 * <pre> 4203 * STATIC_IMPORT -> import 4204 * |--LITERAL_STATIC -> static 4205 * |--DOT -> . 4206 * | |--DOT -> . 4207 * | | |--IDENT -> java 4208 * | | `--IDENT -> io 4209 * | `--IDENT -> IOException 4210 * `--SEMI -> ; 4211 * </pre> 4212 * 4213 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4214 * JSR201</a> 4215 * @see #LITERAL_STATIC 4216 * @see #DOT 4217 * @see #IDENT 4218 * @see #STAR 4219 * @see #SEMI 4220 * @see FullIdent 4221 **/ 4222 public static final int STATIC_IMPORT = 4223 GeneratedJavaTokenTypes.STATIC_IMPORT; 4224 4225 /** 4226 * An enum declaration. Its notable children are 4227 * enum constant declarations followed by 4228 * any construct that may be expected in a class body. 4229 * 4230 * <p>For example:</p> 4231 * <pre> 4232 * public enum MyEnum 4233 * implements Serializable 4234 * { 4235 * FIRST_CONSTANT, 4236 * SECOND_CONSTANT; 4237 * 4238 * public void someMethod() 4239 * { 4240 * } 4241 * } 4242 * </pre> 4243 * <p>parses as:</p> 4244 * <pre> 4245 * +--ENUM_DEF 4246 * | 4247 * +--MODIFIERS 4248 * | 4249 * +--LITERAL_PUBLIC (public) 4250 * +--ENUM (enum) 4251 * +--IDENT (MyEnum) 4252 * +--EXTENDS_CLAUSE 4253 * +--IMPLEMENTS_CLAUSE 4254 * | 4255 * +--IDENT (Serializable) 4256 * +--OBJBLOCK 4257 * | 4258 * +--LCURLY ({) 4259 * +--ENUM_CONSTANT_DEF 4260 * | 4261 * +--IDENT (FIRST_CONSTANT) 4262 * +--COMMA (,) 4263 * +--ENUM_CONSTANT_DEF 4264 * | 4265 * +--IDENT (SECOND_CONSTANT) 4266 * +--SEMI (;) 4267 * +--METHOD_DEF 4268 * | 4269 * +--MODIFIERS 4270 * | 4271 * +--LITERAL_PUBLIC (public) 4272 * +--TYPE 4273 * | 4274 * +--LITERAL_void (void) 4275 * +--IDENT (someMethod) 4276 * +--LPAREN (() 4277 * +--PARAMETERS 4278 * +--RPAREN ()) 4279 * +--SLIST ({) 4280 * | 4281 * +--RCURLY (}) 4282 * +--RCURLY (}) 4283 * </pre> 4284 * 4285 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4286 * JSR201</a> 4287 * @see #MODIFIERS 4288 * @see #ENUM 4289 * @see #IDENT 4290 * @see #EXTENDS_CLAUSE 4291 * @see #IMPLEMENTS_CLAUSE 4292 * @see #OBJBLOCK 4293 * @see #LITERAL_NEW 4294 * @see #ENUM_CONSTANT_DEF 4295 **/ 4296 public static final int ENUM_DEF = 4297 GeneratedJavaTokenTypes.ENUM_DEF; 4298 4299 /** 4300 * The {@code enum} keyword. This element appears 4301 * as part of an enum declaration. 4302 **/ 4303 public static final int ENUM = 4304 GeneratedJavaTokenTypes.ENUM; 4305 4306 /** 4307 * An enum constant declaration. Its notable children are annotations, 4308 * arguments and object block akin to an anonymous 4309 * inner class' body. 4310 * 4311 * <p>For example:</p> 4312 * <pre> 4313 * SOME_CONSTANT(1) 4314 * { 4315 * public void someMethodOverriddenFromMainBody() 4316 * { 4317 * } 4318 * } 4319 * </pre> 4320 * <p>parses as:</p> 4321 * <pre> 4322 * +--ENUM_CONSTANT_DEF 4323 * | 4324 * +--ANNOTATIONS 4325 * +--IDENT (SOME_CONSTANT) 4326 * +--LPAREN (() 4327 * +--ELIST 4328 * | 4329 * +--EXPR 4330 * | 4331 * +--NUM_INT (1) 4332 * +--RPAREN ()) 4333 * +--OBJBLOCK 4334 * | 4335 * +--LCURLY ({) 4336 * | 4337 * +--METHOD_DEF 4338 * | 4339 * +--MODIFIERS 4340 * | 4341 * +--LITERAL_PUBLIC (public) 4342 * +--TYPE 4343 * | 4344 * +--LITERAL_void (void) 4345 * +--IDENT (someMethodOverriddenFromMainBody) 4346 * +--LPAREN (() 4347 * +--PARAMETERS 4348 * +--RPAREN ()) 4349 * +--SLIST ({) 4350 * | 4351 * +--RCURLY (}) 4352 * +--RCURLY (}) 4353 * </pre> 4354 * 4355 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4356 * JSR201</a> 4357 * @see #ANNOTATIONS 4358 * @see #MODIFIERS 4359 * @see #IDENT 4360 * @see #ELIST 4361 * @see #OBJBLOCK 4362 **/ 4363 public static final int ENUM_CONSTANT_DEF = 4364 GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF; 4365 4366 /** 4367 * A for-each clause. This is a child of 4368 * {@code LITERAL_FOR}. The children of this element may be 4369 * a parameter definition, the colon literal and an expression. 4370 * 4371 * <p>For example:</p> 4372 * <pre> 4373 * for (int value : values) { 4374 * doSmth(); 4375 * } 4376 * </pre> 4377 * <p>parses as:</p> 4378 * <pre> 4379 * LITERAL_FOR -> for 4380 * |--LPAREN -> ( 4381 * |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE 4382 * | |--VARIABLE_DEF -> VARIABLE_DEF 4383 * | | |--MODIFIERS -> MODIFIERS 4384 * | | |--TYPE -> TYPE 4385 * | | | `--LITERAL_INT -> int 4386 * | | `--IDENT -> value 4387 * | |--COLON -> : 4388 * | `--EXPR -> EXPR 4389 * | `--IDENT -> values 4390 * |--RPAREN -> ) 4391 * `--SLIST -> { 4392 * |--EXPR -> EXPR 4393 * | `--METHOD_CALL -> ( 4394 * | |--IDENT -> doSmth 4395 * | |--ELIST -> ELIST 4396 * | `--RPAREN -> ) 4397 * |--SEMI -> ; 4398 * `--RCURLY -> } 4399 * </pre> 4400 * 4401 * @see #VARIABLE_DEF 4402 * @see #ELIST 4403 * @see #LITERAL_FOR 4404 **/ 4405 public static final int FOR_EACH_CLAUSE = 4406 GeneratedJavaTokenTypes.FOR_EACH_CLAUSE; 4407 4408 /** 4409 * An annotation declaration. The notable children are the name of the 4410 * annotation type, annotation field declarations and (constant) fields. 4411 * 4412 * <p>For example:</p> 4413 * <pre> 4414 * public @interface MyAnnotation 4415 * { 4416 * int someValue(); 4417 * } 4418 * </pre> 4419 * <p>parses as:</p> 4420 * <pre> 4421 * ANNOTATION_DEF -> ANNOTATION_DEF 4422 * |--MODIFIERS -> MODIFIERS 4423 * | `--LITERAL_PUBLIC -> public 4424 * |--AT -> @ 4425 * |--LITERAL_INTERFACE -> interface 4426 * |--IDENT -> MyAnnotation 4427 * `--OBJBLOCK -> OBJBLOCK 4428 * |--LCURLY -> { 4429 * |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF 4430 * | |--MODIFIERS -> MODIFIERS 4431 * | |--TYPE -> TYPE 4432 * | | `--LITERAL_INT -> int 4433 * | |--IDENT -> someValue 4434 * | |--LPAREN -> ( 4435 * | |--RPAREN -> ) 4436 * | `--SEMI -> ; 4437 * `--RCURLY -> } 4438 * </pre> 4439 * 4440 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4441 * JSR201</a> 4442 * @see #MODIFIERS 4443 * @see #LITERAL_INTERFACE 4444 * @see #IDENT 4445 * @see #OBJBLOCK 4446 * @see #ANNOTATION_FIELD_DEF 4447 **/ 4448 public static final int ANNOTATION_DEF = 4449 GeneratedJavaTokenTypes.ANNOTATION_DEF; 4450 4451 /** 4452 * An annotation field declaration. The notable children are modifiers, 4453 * field type, field name and an optional default value (a conditional 4454 * compile-time constant expression). Default values may also by 4455 * annotations. 4456 * 4457 * <p>For example:</p> 4458 * 4459 * <pre> 4460 * String someField() default "Hello world"; 4461 * </pre> 4462 * 4463 * <p>parses as:</p> 4464 * 4465 * <pre> 4466 * ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF 4467 * |--MODIFIERS -> MODIFIERS 4468 * |--TYPE -> TYPE 4469 * | `--IDENT -> String 4470 * |--IDENT -> someField 4471 * |--LPAREN -> ( 4472 * |--RPAREN -> ) 4473 * |--LITERAL_DEFAULT -> default 4474 * | `--EXPR -> EXPR 4475 * | `--STRING_LITERAL -> "Hello world" 4476 * `--SEMI -> ; 4477 * </pre> 4478 * 4479 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4480 * JSR201</a> 4481 * @see #MODIFIERS 4482 * @see #TYPE 4483 * @see #LITERAL_DEFAULT 4484 */ 4485 public static final int ANNOTATION_FIELD_DEF = 4486 GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF; 4487 4488 // note: @ is the html escape for '@', 4489 // used here to avoid confusing the javadoc tool 4490 /** 4491 * A collection of annotations on a package or enum constant. 4492 * A collections of annotations will only occur on these nodes 4493 * as all other nodes that may be qualified with an annotation can 4494 * be qualified with any other modifier and hence these annotations 4495 * would be contained in a {@link #MODIFIERS} node. 4496 * 4497 * <p>For example:</p> 4498 * 4499 * <pre> 4500 * @MyAnnotation package blah; 4501 * </pre> 4502 * 4503 * <p>parses as:</p> 4504 * 4505 * <pre> 4506 * +--PACKAGE_DEF (package) 4507 * | 4508 * +--ANNOTATIONS 4509 * | 4510 * +--ANNOTATION 4511 * | 4512 * +--AT (@) 4513 * +--IDENT (MyAnnotation) 4514 * +--IDENT (blah) 4515 * +--SEMI (;) 4516 * </pre> 4517 * 4518 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4519 * JSR201</a> 4520 * @see #ANNOTATION 4521 * @see #AT 4522 * @see #IDENT 4523 */ 4524 public static final int ANNOTATIONS = 4525 GeneratedJavaTokenTypes.ANNOTATIONS; 4526 4527 // note: @ is the html escape for '@', 4528 // used here to avoid confusing the javadoc tool 4529 /** 4530 * An annotation of a package, type, field, parameter or variable. 4531 * An annotation may occur anywhere modifiers occur (it is a 4532 * type of modifier) and may also occur prior to a package definition. 4533 * The notable children are: The annotation name and either a single 4534 * default annotation value or a sequence of name value pairs. 4535 * Annotation values may also be annotations themselves. 4536 * 4537 * <p>For example:</p> 4538 * 4539 * <pre> 4540 * @MyAnnotation(someField1 = "Hello", 4541 * someField2 = @SomeOtherAnnotation) 4542 * </pre> 4543 * 4544 * <p>parses as:</p> 4545 * 4546 * <pre> 4547 * +--ANNOTATION 4548 * | 4549 * +--AT (@) 4550 * +--IDENT (MyAnnotation) 4551 * +--LPAREN (() 4552 * +--ANNOTATION_MEMBER_VALUE_PAIR 4553 * | 4554 * +--IDENT (someField1) 4555 * +--ASSIGN (=) 4556 * +--ANNOTATION 4557 * | 4558 * +--AT (@) 4559 * +--IDENT (SomeOtherAnnotation) 4560 * +--ANNOTATION_MEMBER_VALUE_PAIR 4561 * | 4562 * +--IDENT (someField2) 4563 * +--ASSIGN (=) 4564 * +--STRING_LITERAL ("Hello") 4565 * +--RPAREN ()) 4566 * </pre> 4567 * 4568 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4569 * JSR201</a> 4570 * @see #MODIFIERS 4571 * @see #IDENT 4572 * @see #ANNOTATION_MEMBER_VALUE_PAIR 4573 */ 4574 public static final int ANNOTATION = 4575 GeneratedJavaTokenTypes.ANNOTATION; 4576 4577 /** 4578 * An initialization of an annotation member with a value. 4579 * Its children are the name of the member, the assignment literal 4580 * and the (compile-time constant conditional expression) value. 4581 * 4582 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4583 * JSR201</a> 4584 * @see #ANNOTATION 4585 * @see #IDENT 4586 */ 4587 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 4588 GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR; 4589 4590 /** 4591 * An annotation array member initialization. 4592 * Initializers can not be nested. 4593 * An initializer may be present as a default to an annotation 4594 * member, as the single default value to an annotation 4595 * (e.g. @Annotation({1,2})) or as the value of an annotation 4596 * member value pair. 4597 * 4598 * <p>For example:</p> 4599 * <pre> 4600 * @Annotation({1, 2}) 4601 * </pre> 4602 * <p>parses as:</p> 4603 * <pre> 4604 * ANNOTATION -> ANNOTATION 4605 * |--AT -> @ 4606 * |--IDENT -> Annotation 4607 * |--LPAREN -> ( 4608 * |--ANNOTATION_ARRAY_INIT -> { 4609 * | |--EXPR -> EXPR 4610 * | | `--NUM_INT -> 1 4611 * | |--COMMA -> , 4612 * | |--EXPR -> EXPR 4613 * | | `--NUM_INT -> 2 4614 * | `--RCURLY -> } 4615 * `--RPAREN -> ) 4616 * </pre> 4617 * 4618 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4619 * JSR201</a> 4620 * @see #ANNOTATION 4621 * @see #IDENT 4622 * @see #ANNOTATION_MEMBER_VALUE_PAIR 4623 */ 4624 public static final int ANNOTATION_ARRAY_INIT = 4625 GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT; 4626 4627 /** 4628 * A list of type parameters to a class, interface or 4629 * method definition. Children are LT, at least one 4630 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 4631 * TYPE_PARAMETER and a final GT. 4632 * 4633 * <p>For example:</p> 4634 * 4635 * <pre> 4636 * public class MyClass<A, B> { 4637 * 4638 * } 4639 * </pre> 4640 * 4641 * <p>parses as:</p> 4642 * 4643 * <pre> 4644 * CLASS_DEF -> CLASS_DEF 4645 * |--MODIFIERS -> MODIFIERS 4646 * | `--LITERAL_PUBLIC -> public 4647 * |--LITERAL_CLASS -> class 4648 * |--IDENT -> MyClass 4649 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 4650 * | |--GENERIC_START -> < 4651 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 4652 * | | `--IDENT -> A 4653 * | |--COMMA -> , 4654 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 4655 * | | `--IDENT -> B 4656 * | `--GENERIC_END -> > 4657 * `--OBJBLOCK -> OBJBLOCK 4658 * |--LCURLY -> { 4659 * `--RCURLY -> } 4660 * </pre> 4661 * 4662 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 4663 * JSR14</a> 4664 * @see #GENERIC_START 4665 * @see #GENERIC_END 4666 * @see #TYPE_PARAMETER 4667 * @see #COMMA 4668 */ 4669 public static final int TYPE_PARAMETERS = 4670 GeneratedJavaTokenTypes.TYPE_PARAMETERS; 4671 4672 /** 4673 * A type parameter to a class, interface or method definition. 4674 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 4675 * 4676 * <p>For example:</p> 4677 * 4678 * <pre> 4679 * public class MyClass <A extends Collection> { 4680 * 4681 * } 4682 * </pre> 4683 * 4684 * <p>parses as:</p> 4685 * 4686 * <pre> 4687 * CLASS_DEF -> CLASS_DEF 4688 * |--MODIFIERS -> MODIFIERS 4689 * | `--LITERAL_PUBLIC -> public 4690 * |--LITERAL_CLASS -> class 4691 * |--IDENT -> MyClass 4692 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 4693 * | |--GENERIC_START -> < 4694 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 4695 * | | |--IDENT -> A 4696 * | | `--TYPE_UPPER_BOUNDS -> extends 4697 * | | `--IDENT -> Collection 4698 * | `--GENERIC_END -> > 4699 * `--OBJBLOCK -> OBJBLOCK 4700 * |--LCURLY -> { 4701 * `--RCURLY -> } 4702 * </pre> 4703 * 4704 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 4705 * JSR14</a> 4706 * @see #IDENT 4707 * @see #WILDCARD_TYPE 4708 * @see #TYPE_UPPER_BOUNDS 4709 */ 4710 public static final int TYPE_PARAMETER = 4711 GeneratedJavaTokenTypes.TYPE_PARAMETER; 4712 4713 /** 4714 * A list of type arguments to a type reference or 4715 * a method/ctor invocation. Children are GENERIC_START, at least one 4716 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 4717 * TYPE_ARGUMENT, and a final GENERIC_END. 4718 * 4719 * <p>For example:</p> 4720 * 4721 * <pre> 4722 * public Collection<?> a; 4723 * </pre> 4724 * 4725 * <p>parses as:</p> 4726 * 4727 * <pre> 4728 * VARIABLE_DEF -> VARIABLE_DEF 4729 * |--MODIFIERS -> MODIFIERS 4730 * | `--LITERAL_PUBLIC -> public 4731 * |--TYPE -> TYPE 4732 * | |--IDENT -> Collection 4733 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4734 * | |--GENERIC_START -> < 4735 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4736 * | | `--WILDCARD_TYPE -> ? 4737 * | `--GENERIC_END -> > 4738 * |--IDENT -> a 4739 * `--SEMI -> ; 4740 * </pre> 4741 * 4742 * @see #GENERIC_START 4743 * @see #GENERIC_END 4744 * @see #TYPE_ARGUMENT 4745 * @see #COMMA 4746 */ 4747 public static final int TYPE_ARGUMENTS = 4748 GeneratedJavaTokenTypes.TYPE_ARGUMENTS; 4749 4750 /** 4751 * A type arguments to a type reference or a method/ctor invocation. 4752 * Children are either: type name or wildcard type with possible type 4753 * upper or lower bounds. 4754 * <p>For example:</p> 4755 * <pre>List<? super List> list;</pre> 4756 * <p>parses as:</p> 4757 * <pre> 4758 * VARIABLE_DEF -> VARIABLE_DEF 4759 * |--MODIFIERS -> MODIFIERS 4760 * |--TYPE -> TYPE 4761 * | |--IDENT -> List 4762 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4763 * | |--GENERIC_START -> < 4764 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4765 * | | |--WILDCARD_TYPE -> ? 4766 * | | `--TYPE_LOWER_BOUNDS -> super 4767 * | | `--IDENT -> List 4768 * | `--GENERIC_END -> > 4769 * |--IDENT -> list 4770 * `--SEMI -> ; 4771 * </pre> 4772 * 4773 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 4774 * JSR14</a> 4775 * @see #WILDCARD_TYPE 4776 * @see #TYPE_UPPER_BOUNDS 4777 * @see #TYPE_LOWER_BOUNDS 4778 */ 4779 public static final int TYPE_ARGUMENT = 4780 GeneratedJavaTokenTypes.TYPE_ARGUMENT; 4781 4782 /** 4783 * The type that refers to all types. This node has no children. 4784 * <p> For example: </p> 4785 * <pre> 4786 * 4787 * List<?> list; 4788 * </pre> 4789 * <p>parses as:</p> 4790 * <pre> 4791 * |--VARIABLE_DEF -> VARIABLE_DEF 4792 * | |--MODIFIERS -> MODIFIERS 4793 * | |--TYPE -> TYPE 4794 * | | |--IDENT -> List 4795 * | | |`--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4796 * | | |--GENERIC_START -> < 4797 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4798 * | | | `--WILDCARD_TYPE -> ? 4799 * | | `--GENERIC_END -> > 4800 * | `--IDENT -> list 4801 * |--SEMI -> ; 4802 * </pre> 4803 * 4804 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 4805 * JSR14</a> 4806 * @see #TYPE_ARGUMENT 4807 * @see #TYPE_UPPER_BOUNDS 4808 * @see #TYPE_LOWER_BOUNDS 4809 */ 4810 public static final int WILDCARD_TYPE = 4811 GeneratedJavaTokenTypes.WILDCARD_TYPE; 4812 4813 /** 4814 * An upper bounds on a wildcard type argument or type parameter. 4815 * This node has one child - the type that is being used for 4816 * the bounding. 4817 * <p>For example:</p> 4818 * <pre>List<? extends Number> list;</pre> 4819 * 4820 * <p>parses as:</p> 4821 * <pre> 4822 * --VARIABLE_DEF -> VARIABLE_DEF 4823 * |--MODIFIERS -> MODIFIERS 4824 * |--TYPE -> TYPE 4825 * | |--IDENT -> List 4826 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4827 * | |--GENERIC_START -> < 4828 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4829 * | | |--WILDCARD_TYPE -> ? 4830 * | | `--TYPE_UPPER_BOUNDS -> extends 4831 * | | `--IDENT -> Number 4832 * | `--GENERIC_END -> > 4833 * |--IDENT -> list 4834 * `--SEMI -> ; 4835 * </pre> 4836 * 4837 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 4838 * JSR14</a> 4839 * @see #TYPE_PARAMETER 4840 * @see #TYPE_ARGUMENT 4841 * @see #WILDCARD_TYPE 4842 */ 4843 public static final int TYPE_UPPER_BOUNDS = 4844 GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS; 4845 4846 /** 4847 * A lower bounds on a wildcard type argument. This node has one child 4848 * - the type that is being used for the bounding. 4849 * 4850 * <p>For example:</p> 4851 * <pre>List<? super Integer> list;</pre> 4852 * 4853 * <p>parses as:</p> 4854 * <pre> 4855 * --VARIABLE_DEF -> VARIABLE_DEF 4856 * |--MODIFIERS -> MODIFIERS 4857 * |--TYPE -> TYPE 4858 * | |--IDENT -> List 4859 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4860 * | |--GENERIC_START -> < 4861 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4862 * | | |--WILDCARD_TYPE -> ? 4863 * | | `--TYPE_LOWER_BOUNDS -> super 4864 * | | `--IDENT -> Integer 4865 * | `--GENERIC_END -> > 4866 * |--IDENT -> list 4867 * `--SEMI -> ; 4868 * </pre> 4869 * 4870 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 4871 * JSR14</a> 4872 * @see #TYPE_ARGUMENT 4873 * @see #WILDCARD_TYPE 4874 */ 4875 public static final int TYPE_LOWER_BOUNDS = 4876 GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS; 4877 4878 /** 4879 * An {@code @} symbol - signifying an annotation instance or the prefix 4880 * to the interface literal signifying the definition of an annotation 4881 * declaration. 4882 * 4883 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4884 * JSR201</a> 4885 */ 4886 public static final int AT = GeneratedJavaTokenTypes.AT; 4887 4888 /** 4889 * A triple dot for variable-length parameters. This token only ever occurs 4890 * in a parameter declaration immediately after the type of the parameter. 4891 * 4892 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4893 * JSR201</a> 4894 */ 4895 public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS; 4896 4897 /** 4898 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain 4899 * or a type cast expression with an additional interface. 4900 * 4901 * <p>Generic type bounds extension: 4902 * {@code class Comparable<T extends Serializable & CharSequence>}</p> 4903 * <pre> 4904 * CLASS_DEF -> CLASS_DEF 4905 * |--MODIFIERS -> MODIFIERS 4906 * |--LITERAL_CLASS -> class 4907 * |--IDENT -> Comparable 4908 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 4909 * |--GENERIC_START -> < 4910 * |--TYPE_PARAMETER -> TYPE_PARAMETER 4911 * | |--IDENT -> T 4912 * | `--TYPE_UPPER_BOUNDS -> extends 4913 * | |--IDENT -> Serializable 4914 * | |--TYPE_EXTENSION_AND -> & 4915 * | `--IDENT -> CharSequence 4916 * `--GENERIC_END -> > 4917 * </pre> 4918 * 4919 * <p>Type cast extension: 4920 * {@code return (Serializable & CharSequence) null;}</p> 4921 * <pre> 4922 * --LITERAL_RETURN -> return 4923 * |--EXPR -> EXPR 4924 * | `--TYPECAST -> ( 4925 * | |--TYPE -> TYPE 4926 * | | `--IDENT -> Serializable 4927 * | |--TYPE_EXTENSION_AND -> & 4928 * | |--TYPE -> TYPE 4929 * | | `--IDENT -> CharSequence 4930 * | |--RPAREN -> ) 4931 * | `--LITERAL_NULL -> null 4932 * `--SEMI -> ; 4933 * </pre> 4934 * 4935 * @see #EXTENDS_CLAUSE 4936 * @see #TYPECAST 4937 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4"> 4938 * Java Language Specification, §4.4</a> 4939 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16"> 4940 * Java Language Specification, §15.16</a> 4941 */ 4942 public static final int TYPE_EXTENSION_AND = 4943 GeneratedJavaTokenTypes.TYPE_EXTENSION_AND; 4944 4945 /** 4946 * A {@code <} symbol signifying the start of type arguments or type parameters. 4947 */ 4948 public static final int GENERIC_START = 4949 GeneratedJavaTokenTypes.GENERIC_START; 4950 4951 /** 4952 * A {@code >} symbol signifying the end of type arguments or type parameters. 4953 */ 4954 public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END; 4955 4956 /** 4957 * Special lambda symbol {@code ->}. 4958 */ 4959 public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA; 4960 4961 /** 4962 * Beginning of single line comment: '//'. 4963 * 4964 * <pre> 4965 * +--SINGLE_LINE_COMMENT 4966 * | 4967 * +--COMMENT_CONTENT 4968 * </pre> 4969 * 4970 * <p>For example:</p> 4971 * <pre> 4972 * // Comment content 4973 * </pre> 4974 * <p>parses as:</p> 4975 * <pre> 4976 * SINGLE_LINE_COMMENT -> // 4977 * `--COMMENT_CONTENT -> Comment Content\n 4978 * </pre> 4979 */ 4980 public static final int SINGLE_LINE_COMMENT = 4981 GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT; 4982 4983 /** 4984 * Beginning of block comment: '/*'. 4985 * <p>For example:</p> 4986 * <pre> 4987 * /* Comment content 4988 * */ 4989 * </pre> 4990 * <p>parses as:</p> 4991 * <pre> 4992 * --BLOCK_COMMENT_BEGIN -> /* 4993 * |--COMMENT_CONTENT -> Comment content\r\n 4994 * `--BLOCK_COMMENT_END -> */ 4995 * </pre> 4996 */ 4997 public static final int BLOCK_COMMENT_BEGIN = 4998 GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN; 4999 5000 /** 5001 * End of block comment: '*/'. 5002 * 5003 * <pre> 5004 * +--BLOCK_COMMENT_BEGIN 5005 * | 5006 * +--COMMENT_CONTENT 5007 * +--BLOCK_COMMENT_END 5008 * </pre> 5009 */ 5010 public static final int BLOCK_COMMENT_END = 5011 GeneratedJavaTokenTypes.BLOCK_COMMENT_END; 5012 5013 /** 5014 * Text of single-line or block comment. 5015 * 5016 * <pre> 5017 * +--SINGLE_LINE_COMMENT 5018 * | 5019 * +--COMMENT_CONTENT 5020 * </pre> 5021 * 5022 * <pre> 5023 * +--BLOCK_COMMENT_BEGIN 5024 * | 5025 * +--COMMENT_CONTENT 5026 * +--BLOCK_COMMENT_END 5027 * </pre> 5028 */ 5029 public static final int COMMENT_CONTENT = 5030 GeneratedJavaTokenTypes.COMMENT_CONTENT; 5031 5032 /** 5033 * A pattern variable definition; when conditionally matched, 5034 * this variable is assigned with the defined type. 5035 * 5036 * <p>For example:</p> 5037 * <pre> 5038 * if (obj instanceof String str) { } 5039 * </pre> 5040 * <p>parses as:</p> 5041 * <pre> 5042 * LITERAL_IF -> if 5043 * |--LPAREN -> ( 5044 * |--EXPR -> EXPR 5045 * | `--LITERAL_INSTANCEOF -> instanceof 5046 * | |--IDENT -> obj 5047 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 5048 * | |--TYPE -> TYPE 5049 * | | `--IDENT -> String 5050 * | `--IDENT -> str 5051 * |--RPAREN -> ) 5052 * `--SLIST -> { 5053 * `--RCURLY -> } 5054 * </pre> 5055 * 5056 * @see #LITERAL_INSTANCEOF 5057 * @since 8.35 5058 */ 5059 public static final int PATTERN_VARIABLE_DEF = 5060 GeneratedJavaTokenTypes.PATTERN_VARIABLE_DEF; 5061 5062 /** 5063 * The {@code record} keyword. This element appears 5064 * as part of a record declaration. 5065 * 5066 * <p>For example:</p> 5067 * <pre> 5068 * public record MyRecord () { 5069 * 5070 * } 5071 * </pre> 5072 * <p>parses as:</p> 5073 * <pre> 5074 * RECORD_DEF -> RECORD_DEF 5075 * |--MODIFIERS -> MODIFIERS 5076 * | `--LITERAL_PUBLIC -> public 5077 * |--LITERAL_RECORD -> record 5078 * |--IDENT -> MyRecord 5079 * |--LPAREN -> ( 5080 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5081 * |--RPAREN -> ) 5082 * `--OBJBLOCK -> OBJBLOCK 5083 * |--LCURLY -> { 5084 * `--RCURLY -> } 5085 * </pre> 5086 * 5087 * @since 8.35 5088 **/ 5089 public static final int LITERAL_RECORD = 5090 GeneratedJavaTokenTypes.LITERAL_record; 5091 5092 /** 5093 * A declaration of a record specifies a name, a header, and a body. 5094 * The header lists the components of the record, which are the variables 5095 * that make up its state. 5096 * 5097 * <p>For example:</p> 5098 * <pre> 5099 * public record MyRecord () { 5100 * 5101 * } 5102 * </pre> 5103 * <p>parses as:</p> 5104 * <pre> 5105 * RECORD_DEF -> RECORD_DEF 5106 * |--MODIFIERS -> MODIFIERS 5107 * | `--LITERAL_PUBLIC -> public 5108 * |--LITERAL_RECORD -> record 5109 * |--IDENT -> MyRecord 5110 * |--LPAREN -> ( 5111 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5112 * |--RPAREN -> ) 5113 * `--OBJBLOCK -> OBJBLOCK 5114 * |--LCURLY -> { 5115 * `--RCURLY -> } 5116 * </pre> 5117 * 5118 * @since 8.35 5119 */ 5120 public static final int RECORD_DEF = 5121 GeneratedJavaTokenTypes.RECORD_DEF; 5122 5123 /** 5124 * Record components are a (possibly empty) list containing the components of a record, which 5125 * are the variables that make up its state. 5126 * 5127 * <p>For example:</p> 5128 * <pre> 5129 * public record myRecord (Comp x, Comp y) { } 5130 * </pre> 5131 * <p>parses as:</p> 5132 * <pre> 5133 * RECORD_DEF -> RECORD_DEF 5134 * |--MODIFIERS -> MODIFIERS 5135 * | `--LITERAL_PUBLIC -> public 5136 * |--LITERAL_RECORD -> record 5137 * |--IDENT -> myRecord 5138 * |--LPAREN -> ( 5139 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5140 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5141 * | | |--ANNOTATIONS -> ANNOTATIONS 5142 * | | |--TYPE -> TYPE 5143 * | | | `--IDENT -> Comp 5144 * | | `--IDENT -> x 5145 * | |--COMMA -> , 5146 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5147 * | |--ANNOTATIONS -> ANNOTATIONS 5148 * | |--TYPE -> TYPE 5149 * | | `--IDENT -> Comp 5150 * | `--IDENT -> y 5151 * |--RPAREN -> ) 5152 * `--OBJBLOCK -> OBJBLOCK 5153 * |--LCURLY -> { 5154 * `--RCURLY -> } 5155 * </pre> 5156 * 5157 * @since 8.36 5158 */ 5159 public static final int RECORD_COMPONENTS = 5160 GeneratedJavaTokenTypes.RECORD_COMPONENTS; 5161 5162 /** 5163 * A record component is a variable that comprises the state of a record. Record components 5164 * have annotations (possibly), a type definition, and an identifier. They can also be of 5165 * variable arity ('...'). 5166 * 5167 * <p>For example:</p> 5168 * <pre> 5169 * public record MyRecord(Comp x, Comp... comps) { 5170 * 5171 * } 5172 * </pre> 5173 * <p>parses as:</p> 5174 * <pre> 5175 * RECORD_DEF -> RECORD_DEF 5176 * |--MODIFIERS -> MODIFIERS 5177 * | `--LITERAL_PUBLIC -> public 5178 * |--LITERAL_RECORD -> record 5179 * |--IDENT -> MyRecord 5180 * |--LPAREN -> ( 5181 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5182 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5183 * | | |--ANNOTATIONS -> ANNOTATIONS 5184 * | | |--TYPE -> TYPE 5185 * | | | `--IDENT -> Comp 5186 * | | `--IDENT -> x 5187 * | |--COMMA -> , 5188 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5189 * | |--ANNOTATIONS -> ANNOTATIONS 5190 * | |--TYPE -> TYPE 5191 * | | `--IDENT -> Comp 5192 * | |--ELLIPSIS -> ... 5193 * | `--IDENT -> comps 5194 * |--RPAREN -> ) 5195 * `--OBJBLOCK -> OBJBLOCK 5196 * |--LCURLY -> { 5197 * `--RCURLY -> } 5198 * </pre> 5199 * 5200 * @since 8.36 5201 */ 5202 public static final int RECORD_COMPONENT_DEF = 5203 GeneratedJavaTokenTypes.RECORD_COMPONENT_DEF; 5204 5205 /** 5206 * A compact canonical constructor eliminates the list of formal parameters; they are 5207 * declared implicitly. 5208 * 5209 * <p>For example:</p> 5210 * <pre> 5211 * public record myRecord () { 5212 * public myRecord{} 5213 * } 5214 * </pre> 5215 * <p>parses as:</p> 5216 * <pre> 5217 * RECORD_DEF 5218 * |--MODIFIERS 5219 * | `--LITERAL_PUBLIC (public) 5220 * |--LITERAL_RECORD (record) 5221 * |--IDENT (myRecord) 5222 * |--LPAREN (() 5223 * |--RECORD_COMPONENTS 5224 * |--RPAREN ()) 5225 * `--OBJBLOCK 5226 * |--LCURLY ({) 5227 * |--COMPACT_CTOR_DEF 5228 * | |--MODIFIERS 5229 * | | `--LITERAL_PUBLIC (public) 5230 * | |--IDENT (myRecord) 5231 * | `--SLIST ({) 5232 * | `--RCURLY (}) 5233 * `--RCURLY (}) 5234 * </pre> 5235 * 5236 * @since 8.36 5237 */ 5238 public static final int COMPACT_CTOR_DEF = 5239 GeneratedJavaTokenTypes.COMPACT_CTOR_DEF; 5240 5241 /** 5242 * Beginning of a Java 14 Text Block literal, 5243 * delimited by three double quotes. 5244 * 5245 * <p>For example:</p> 5246 * <pre> 5247 * String hello = """ 5248 * Hello, world! 5249 * """; 5250 * </pre> 5251 * <p>parses as:</p> 5252 * <pre> 5253 * |--VARIABLE_DEF -> VARIABLE_DEF 5254 * | |--MODIFIERS -> MODIFIERS 5255 * | |--TYPE -> TYPE 5256 * | | `--IDENT -> String 5257 * | |--IDENT -> hello 5258 * | `--ASSIGN -> = 5259 * | `--EXPR -> EXPR 5260 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 5261 * | |--TEXT_BLOCK_CONTENT -> \r\n Hello, world!\r\n 5262 * | `--TEXT_BLOCK_LITERAL_END -> """ 5263 * |--SEMI -> ; 5264 * </pre> 5265 * 5266 * @since 8.36 5267 */ 5268 public static final int TEXT_BLOCK_LITERAL_BEGIN = 5269 GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_BEGIN; 5270 5271 /** 5272 * Content of a Java 14 text block. This is a 5273 * sequence of characters, possibly escaped with '\'. Actual line terminators 5274 * are represented by '\n'. 5275 * 5276 * <p>For example:</p> 5277 * <pre> 5278 * String hello = """ 5279 * Hello, world! 5280 * """; 5281 * </pre> 5282 * <p>parses as:</p> 5283 * <pre> 5284 * |--VARIABLE_DEF -> VARIABLE_DEF 5285 * | |--MODIFIERS -> MODIFIERS 5286 * | |--TYPE -> TYPE 5287 * | | `--IDENT -> String 5288 * | |--IDENT -> hello 5289 * | `--ASSIGN -> = 5290 * | `--EXPR -> EXPR 5291 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 5292 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n 5293 * | `--TEXT_BLOCK_LITERAL_END -> """ 5294 * |--SEMI -> ; 5295 * </pre> 5296 * 5297 * @since 8.36 5298 */ 5299 public static final int TEXT_BLOCK_CONTENT = 5300 GeneratedJavaTokenTypes.TEXT_BLOCK_CONTENT; 5301 5302 /** 5303 * End of a Java 14 text block literal, delimited by three 5304 * double quotes. 5305 * 5306 * <p>For example:</p> 5307 * <pre> 5308 * String hello = """ 5309 * Hello, world! 5310 * """; 5311 * </pre> 5312 * <p>parses as:</p> 5313 * <pre> 5314 * |--VARIABLE_DEF 5315 * | |--MODIFIERS 5316 * | |--TYPE 5317 * | | `--IDENT (String) 5318 * | |--IDENT (hello) 5319 * | |--ASSIGN (=) 5320 * | | `--EXPR 5321 * | | `--TEXT_BLOCK_LITERAL_BEGIN (""") 5322 * | | |--TEXT_BLOCK_CONTENT (\n Hello, world!\n ) 5323 * | | `--TEXT_BLOCK_LITERAL_END (""") 5324 * | `--SEMI (;) 5325 * </pre> 5326 * 5327 * @since 8.36 5328 */ 5329 public static final int TEXT_BLOCK_LITERAL_END = 5330 GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_END; 5331 5332 /** 5333 * The {@code yield} keyword. This element appears 5334 * as part of a yield statement. 5335 * 5336 * <p>For example:</p> 5337 * <pre> 5338 * int yield = 0; // not a keyword here 5339 * return switch (mode) { 5340 * case "a", "b": 5341 * yield 1; 5342 * default: 5343 * yield - 1; 5344 * }; 5345 * </pre> 5346 * <p>parses as:</p> 5347 * <pre> 5348 * |--VARIABLE_DEF 5349 * | |--MODIFIERS 5350 * | |--TYPE 5351 * | | `--LITERAL_INT (int) 5352 * | |--IDENT (yield) 5353 * | `--ASSIGN (=) 5354 * | `--EXPR 5355 * | `--NUM_INT (0) 5356 * |--SEMI (;) 5357 * |--LITERAL_RETURN (return) 5358 * | |--EXPR 5359 * | | `--LITERAL_SWITCH (switch) 5360 * | | |--LPAREN (() 5361 * | | |--EXPR 5362 * | | | `--IDENT (mode) 5363 * | | |--RPAREN ()) 5364 * | | |--LCURLY ({) 5365 * | | |--CASE_GROUP 5366 * | | | |--LITERAL_CASE (case) 5367 * | | | | |--EXPR 5368 * | | | | | `--STRING_LITERAL ("a") 5369 * | | | | |--COMMA (,) 5370 * | | | | |--EXPR 5371 * | | | | | `--STRING_LITERAL ("b") 5372 * | | | | `--COLON (:) 5373 * | | | `--SLIST 5374 * | | | `--LITERAL_YIELD (yield) 5375 * | | | |--EXPR 5376 * | | | | `--NUM_INT (1) 5377 * | | | `--SEMI (;) 5378 * | | |--CASE_GROUP 5379 * | | | |--LITERAL_DEFAULT (default) 5380 * | | | | `--COLON (:) 5381 * | | | `--SLIST 5382 * | | | `--LITERAL_YIELD (yield) 5383 * | | | |--EXPR 5384 * | | | | `--UNARY_MINUS (-) 5385 * | | | | `--NUM_INT (1) 5386 * | | | `--SEMI (;) 5387 * | | `--RCURLY (}) 5388 * | `--SEMI (;) 5389 * </pre> 5390 * 5391 * 5392 * @see #LITERAL_SWITCH 5393 * @see #CASE_GROUP 5394 * @see #SLIST 5395 * @see #SWITCH_RULE 5396 * 5397 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 5398 * Java Language Specification, §14.21</a> 5399 * 5400 * @since 8.36 5401 */ 5402 public static final int LITERAL_YIELD = 5403 GeneratedJavaTokenTypes.LITERAL_yield; 5404 5405 /** 5406 * Switch Expressions. 5407 * 5408 * <p>For example:</p> 5409 * <pre> 5410 * return switch (day) { 5411 * case SAT, SUN -> "Weekend"; 5412 * default -> "Working day"; 5413 * }; 5414 * </pre> 5415 * <p>parses as:</p> 5416 * <pre> 5417 * LITERAL_RETURN -> return 5418 * |--EXPR -> EXPR 5419 * | `--LITERAL_SWITCH -> switch 5420 * | |--LPAREN -> ( 5421 * | |--EXPR -> EXPR 5422 * | | `--IDENT -> day 5423 * | |--RPAREN -> ) 5424 * | |--LCURLY -> { 5425 * | |--SWITCH_RULE -> SWITCH_RULE 5426 * | | |--LITERAL_CASE -> case 5427 * | | | |--EXPR -> EXPR 5428 * | | | | `--IDENT -> SAT 5429 * | | | |--COMMA -> , 5430 * | | | `--EXPR -> EXPR 5431 * | | | `--IDENT -> SUN 5432 * | | |--LAMBDA -> -> 5433 * | | |--EXPR -> EXPR 5434 * | | | `--STRING_LITERAL -> "Weekend" 5435 * | | `--SEMI -> ; 5436 * | |--SWITCH_RULE -> SWITCH_RULE 5437 * | | |--LITERAL_DEFAULT -> default 5438 * | | |--LAMBDA -> -> 5439 * | | |--EXPR -> EXPR 5440 * | | | `--STRING_LITERAL -> "Working day" 5441 * | | `--SEMI -> ; 5442 * | `--RCURLY -> } 5443 * `--SEMI -> ; 5444 * </pre> 5445 * 5446 * @see #LITERAL_CASE 5447 * @see #LITERAL_DEFAULT 5448 * @see #LITERAL_SWITCH 5449 * @see #LITERAL_YIELD 5450 * 5451 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 5452 * Java Language Specification, §14.21</a> 5453 * 5454 * @since 8.36 5455 */ 5456 public static final int SWITCH_RULE = 5457 GeneratedJavaTokenTypes.SWITCH_RULE; 5458 5459 /** 5460 * The {@code non-sealed} keyword. This element appears 5461 * as part of a class or interface declaration. 5462 * 5463 * <p>For example:</p> 5464 * <pre> 5465 * non-sealed class Square extends Rectangle { } 5466 * </pre> 5467 * <p>parses as:</p> 5468 * <pre> 5469 * CLASS_DEF -> CLASS_DEF 5470 * |--MODIFIERS -> MODIFIERS 5471 * | `--LITERAL_NON_SEALED -> non-sealed 5472 * |--LITERAL_CLASS -> class 5473 * |--IDENT -> Square 5474 * |--EXTENDS_CLAUSE -> extends 5475 * | `--IDENT -> Rectangle 5476 * `--OBJBLOCK -> OBJBLOCK 5477 * |--LCURLY -> { 5478 * `--RCURLY -> } 5479 * </pre> 5480 * 5481 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 5482 * Java Language Specification, §8.1.1.2</a> 5483 * @see #MODIFIERS 5484 * 5485 * @since 8.42 5486 */ 5487 public static final int LITERAL_NON_SEALED = 5488 GeneratedJavaTokenTypes.LITERAL_non_sealed; 5489 5490 /** 5491 * The {@code sealed} restricted identifier. This element appears 5492 * as part of a class or interface declaration. 5493 * 5494 * <p>For example:</p> 5495 * <pre> 5496 * public sealed class Shape permits Circle, Square, Rectangle { } 5497 * </pre> 5498 * <p>parses as:</p> 5499 * <pre> 5500 * CLASS_DEF -> CLASS_DEF 5501 * |--MODIFIERS -> MODIFIERS 5502 * | |--LITERAL_PUBLIC -> public 5503 * | `--LITERAL_SEALED -> sealed 5504 * |--LITERAL_CLASS -> class 5505 * |--IDENT -> Shape 5506 * |--PERMITS_CLAUSE -> permits 5507 * | |--IDENT -> Circle 5508 * | |--COMMA -> , 5509 * | |--IDENT -> Square 5510 * | |--COMMA -> , 5511 * | `--IDENT -> Rectangle 5512 * `--OBJBLOCK -> OBJBLOCK 5513 * |--LCURLY -> { 5514 * `--RCURLY -> } 5515 * </pre> 5516 * 5517 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 5518 * Java Language Specification, §8.1.1.2</a> 5519 * @see #MODIFIERS 5520 * 5521 * @since 8.42 5522 */ 5523 public static final int LITERAL_SEALED = 5524 GeneratedJavaTokenTypes.LITERAL_sealed; 5525 5526 /** 5527 * The {@code permits} restricted identifier. This element appears 5528 * as part of a class or interface declaration. 5529 * 5530 * <p>For example:</p> 5531 * <pre> 5532 * public sealed class Shape permits Circle, Square, Rectangle { } 5533 * </pre> 5534 * <p>parses as:</p> 5535 * <pre> 5536 * CLASS_DEF -> CLASS_DEF 5537 * |--MODIFIERS -> MODIFIERS 5538 * | |--LITERAL_PUBLIC -> public 5539 * | `--LITERAL_SEALED -> sealed 5540 * |--LITERAL_CLASS -> class 5541 * |--IDENT -> Shape 5542 * |--PERMITS_CLAUSE -> permits 5543 * | |--IDENT -> Circle 5544 * | |--COMMA -> , 5545 * | |--IDENT -> Square 5546 * | |--COMMA -> , 5547 * | `--IDENT -> Rectangle 5548 * `--OBJBLOCK -> OBJBLOCK 5549 * |--LCURLY -> { 5550 * `--RCURLY -> } 5551 * </pre> 5552 * 5553 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 5554 * Java Language Specification, §9.1.4</a> 5555 * @see #MODIFIERS 5556 * 5557 * @since 8.42 5558 */ 5559 public static final int LITERAL_PERMITS = 5560 GeneratedJavaTokenTypes.LITERAL_permits; 5561 5562 /** 5563 * A permits clause. A permits clause's children are a comma separated list of one or 5564 * more identifiers. 5565 * 5566 * <p>For example:</p> 5567 * <pre> 5568 * public sealed class Shape permits Circle, Square, Rectangle { } 5569 * </pre> 5570 * <p>parses as:</p> 5571 * <pre> 5572 * CLASS_DEF -> CLASS_DEF 5573 * |--MODIFIERS -> MODIFIERS 5574 * | |--LITERAL_PUBLIC -> public 5575 * | `--LITERAL_SEALED -> sealed 5576 * |--LITERAL_CLASS -> class 5577 * |--IDENT -> Shape 5578 * |--PERMITS_CLAUSE -> permits 5579 * | |--IDENT -> Circle 5580 * | |--COMMA -> , 5581 * | |--IDENT -> Square 5582 * | |--COMMA -> , 5583 * | `--IDENT -> Rectangle 5584 * `--OBJBLOCK -> OBJBLOCK 5585 * |--LCURLY -> { 5586 * `--RCURLY -> } 5587 * </pre> 5588 * 5589 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 5590 * Java Language Specification, §9.1.4</a> 5591 * @see #MODIFIERS 5592 * @see #CLASS_DEF 5593 * @see #INTERFACE_DEF 5594 * @see #COMMA 5595 * @see #IDENT 5596 * 5597 * @since 8.42 5598 */ 5599 public static final int PERMITS_CLAUSE = 5600 GeneratedJavaTokenTypes.PERMITS_CLAUSE; 5601 5602 /** Prevent instantiation. */ 5603 private TokenTypes() { 5604 } 5605 5606}