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