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