001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2025 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>.</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 * @noinspection HtmlTagCanBeJavadocTag 1888 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded 1889 * when replaced with Javadoc tag 1890 **/ 1891 public static final int DOT = JavaLanguageLexer.DOT; 1892 /** 1893 * The {@code *} (multiplication or wildcard) operator. 1894 * 1895 * <p>For example:</p> 1896 * <pre> 1897 * f = m * a; 1898 * </pre> 1899 * 1900 * <p>parses as:</p> 1901 * <pre> 1902 * |--EXPR -> EXPR 1903 * | `--ASSIGN -> = 1904 * | |--IDENT -> f 1905 * | `--STAR -> * 1906 * | |--IDENT -> m 1907 * | `--IDENT -> a 1908 * |--SEMI -> ; 1909 * </pre> 1910 * 1911 * @see <a 1912 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java 1913 * Language Specification, §7.5.2</a> 1914 * @see <a 1915 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java 1916 * Language Specification, §15.17.1</a> 1917 * @see #EXPR 1918 * @see #IMPORT 1919 **/ 1920 public static final int STAR = JavaLanguageLexer.STAR; 1921 /** 1922 * The {@code private} keyword. 1923 * 1924 * <p>For example:</p> 1925 * <pre> 1926 * private int x; 1927 * </pre> 1928 * 1929 * <p>parses as:</p> 1930 * <pre> 1931 * VARIABLE_DEF -> VARIABLE_DEF 1932 * |--MODIFIERS -> MODIFIERS 1933 * | `--LITERAL_PRIVATE -> private 1934 * |--TYPE -> TYPE 1935 * | `--LITERAL_INT -> int 1936 * |--IDENT -> x 1937 * `--SEMI -> ; 1938 * </pre> 1939 * 1940 * @see #MODIFIERS 1941 **/ 1942 public static final int LITERAL_PRIVATE = 1943 JavaLanguageLexer.LITERAL_PRIVATE; 1944 1945 /** 1946 * The {@code public} keyword. 1947 * 1948 * <p>For example:</p> 1949 * <pre> 1950 * public int x; 1951 * </pre> 1952 * 1953 * <p>parses as:</p> 1954 * <pre> 1955 * VARIABLE_DEF -> VARIABLE_DEF 1956 * |--MODIFIERS -> MODIFIERS 1957 * | `--LITERAL_PUBLIC -> public 1958 * |--TYPE -> TYPE 1959 * | `--LITERAL_INT -> int 1960 * |--IDENT -> x 1961 * `--SEMI -> ; 1962 * </pre> 1963 * 1964 * @see #MODIFIERS 1965 **/ 1966 public static final int LITERAL_PUBLIC = 1967 JavaLanguageLexer.LITERAL_PUBLIC; 1968 1969 /** 1970 * The {@code protected} keyword. 1971 * 1972 * <p>For example:</p> 1973 * <pre> 1974 * protected int x; 1975 * </pre> 1976 * 1977 * <p>parses as:</p> 1978 * <pre> 1979 * VARIABLE_DEF -> VARIABLE_DEF 1980 * |--MODIFIERS -> MODIFIERS 1981 * | `--LITERAL_PROTECTED -> protected 1982 * |--TYPE -> TYPE 1983 * | `--LITERAL_INT -> int 1984 * |--IDENT -> x 1985 * `--SEMI -> ; 1986 * </pre> 1987 * 1988 * @see #MODIFIERS 1989 **/ 1990 public static final int LITERAL_PROTECTED = 1991 JavaLanguageLexer.LITERAL_PROTECTED; 1992 1993 /** 1994 * The {@code static} keyword. 1995 * 1996 * <p>For example:</p> 1997 * <pre> 1998 * public static int x; 1999 * </pre> 2000 * 2001 * <p>parses as:</p> 2002 * <pre> 2003 * VARIABLE_DEF -> VARIABLE_DEF 2004 * |--MODIFIERS -> MODIFIERS 2005 * | |--LITERAL_PUBLIC -> public 2006 * | `--LITERAL_STATIC -> static 2007 * |--TYPE -> TYPE 2008 * | `--LITERAL_INT -> int 2009 * |--IDENT -> x 2010 * `--SEMI -> ; 2011 * </pre> 2012 * 2013 * @see #MODIFIERS 2014 **/ 2015 public static final int LITERAL_STATIC = 2016 JavaLanguageLexer.LITERAL_STATIC; 2017 2018 /** 2019 * The {@code transient} keyword. 2020 * 2021 * <p>For example:</p> 2022 * <pre> 2023 * transient int a; 2024 * </pre> 2025 * 2026 * <p>parses as:</p> 2027 * <pre> 2028 * VARIABLE_DEF -> VARIABLE_DEF 2029 * |--MODIFIERS -> MODIFIERS 2030 * | `--LITERAL_TRANSIENT -> transient 2031 * |--TYPE -> TYPE 2032 * | `--LITERAL_INT -> int 2033 * |--IDENT -> a 2034 * `--SEMI -> ; 2035 * </pre> 2036 * 2037 * @see #MODIFIERS 2038 **/ 2039 public static final int LITERAL_TRANSIENT = 2040 JavaLanguageLexer.LITERAL_TRANSIENT; 2041 2042 /** 2043 * The {@code native} keyword. 2044 * 2045 * <p>For example:</p> 2046 * <pre> 2047 * native void foo(){} 2048 * </pre> 2049 * 2050 * <p>parses as:</p> 2051 * <pre> 2052 * METHOD_DEF -> METHOD_DEF 2053 * |--MODIFIERS -> MODIFIERS 2054 * | `--LITERAL_NATIVE -> native 2055 * |--TYPE -> TYPE 2056 * | `--LITERAL_VOID -> void 2057 * |--IDENT -> foo 2058 * |--LPAREN -> ( 2059 * |--PARAMETERS -> PARAMETERS 2060 * |--RPAREN -> ) 2061 * `--SLIST -> { 2062 * `--RCURLY -> } 2063 * </pre> 2064 * 2065 * @see #MODIFIERS 2066 **/ 2067 public static final int LITERAL_NATIVE = 2068 JavaLanguageLexer.LITERAL_NATIVE; 2069 2070 /** 2071 * The {@code synchronized} keyword. This may be used as a 2072 * modifier of a method or in the definition of a synchronized 2073 * block. 2074 * 2075 * <p>For example:</p> 2076 * 2077 * <pre> 2078 * synchronized(this) 2079 * { 2080 * x++; 2081 * } 2082 * </pre> 2083 * 2084 * <p>parses as:</p> 2085 * 2086 * <pre> 2087 * |--LITERAL_SYNCHRONIZED -> synchronized 2088 * | |--LPAREN -> ( 2089 * | |--EXPR -> EXPR 2090 * | | `--LITERAL_THIS -> this 2091 * | |--RPAREN -> ) 2092 * | `--SLIST -> { 2093 * | |--EXPR -> EXPR 2094 * | | `--POST_INC -> ++ 2095 * | | `--IDENT -> x 2096 * | |--SEMI -> ; 2097 * | `--RCURLY -> } 2098 * `--RCURLY -> } 2099 * </pre> 2100 * 2101 * @see #MODIFIERS 2102 * @see #LPAREN 2103 * @see #EXPR 2104 * @see #RPAREN 2105 * @see #SLIST 2106 * @see #RCURLY 2107 **/ 2108 public static final int LITERAL_SYNCHRONIZED = 2109 JavaLanguageLexer.LITERAL_SYNCHRONIZED; 2110 2111 /** 2112 * The {@code volatile} keyword. This may be used as a 2113 * modifier of a field. 2114 * 2115 * <p>For example:</p> 2116 * <pre> 2117 * private volatile int x; 2118 * </pre> 2119 * 2120 * <p>parses as:</p> 2121 * <pre> 2122 * VARIABLE_DEF -> VARIABLE_DEF 2123 * |--MODIFIERS -> MODIFIERS 2124 * | |--LITERAL_PRIVATE -> private 2125 * | `--LITERAL_VOLATILE -> volatile 2126 * |--TYPE -> TYPE 2127 * | `--LITERAL_INT -> int 2128 * |--IDENT -> x 2129 * `--SEMI -> ; 2130 * </pre> 2131 * 2132 * @see #MODIFIERS 2133 **/ 2134 public static final int LITERAL_VOLATILE = 2135 JavaLanguageLexer.LITERAL_VOLATILE; 2136 2137 /** 2138 * The {@code class} keyword. This element appears both 2139 * as part of a class declaration, and inline to reference a 2140 * class object. 2141 * 2142 * <p>For example:</p> 2143 * <pre> 2144 * class Test { 2145 * } 2146 * </pre> 2147 * 2148 * <p>parses as:</p> 2149 * <pre> 2150 * CLASS_DEF -> CLASS_DEF 2151 * |--MODIFIERS -> MODIFIERS 2152 * |--LITERAL_CLASS -> class 2153 * |--IDENT -> Test 2154 * `--OBJBLOCK -> OBJBLOCK 2155 * |--LCURLY -> { 2156 * `--RCURLY -> } 2157 * </pre> 2158 * 2159 * <p>For example:</p> 2160 * <pre> int.class 2161 * </pre> 2162 * 2163 * <p>parses as:</p> 2164 * <pre> 2165 * EXPR -> EXPR 2166 * `--DOT -> . 2167 * |--LITERAL_INT -> int 2168 * `--LITERAL_CLASS -> class 2169 * </pre> 2170 * 2171 * @see #DOT 2172 * @see #IDENT 2173 * @see #CLASS_DEF 2174 * @see FullIdent 2175 **/ 2176 public static final int LITERAL_CLASS = 2177 JavaLanguageLexer.LITERAL_CLASS; 2178 2179 /** 2180 * The {@code interface} keyword. This token appears in 2181 * interface definition. 2182 * 2183 * <p>For example:</p> 2184 * 2185 * <pre> 2186 * public interface MyInterface { 2187 * 2188 * } 2189 * </pre> 2190 * 2191 * <p>parses as:</p> 2192 * 2193 * <pre> 2194 * INTERFACE_DEF -> INTERFACE_DEF 2195 * |--MODIFIERS -> MODIFIERS 2196 * | `--LITERAL_PUBLIC -> public 2197 * |--LITERAL_INTERFACE -> interface 2198 * |--IDENT -> MyInterface 2199 * `--OBJBLOCK -> OBJBLOCK 2200 * |--LCURLY -> { 2201 * `--RCURLY -> } 2202 * </pre> 2203 * 2204 * @see #INTERFACE_DEF 2205 **/ 2206 public static final int LITERAL_INTERFACE = 2207 JavaLanguageLexer.LITERAL_INTERFACE; 2208 2209 /** 2210 * A left curly brace (<code>{</code>). 2211 * 2212 * <p>For example:</p> 2213 * 2214 * <pre> 2215 * class App { 2216 * int num; 2217 * } 2218 * </pre> 2219 * 2220 * <p>parses as:</p> 2221 * <pre> 2222 * CLASS_DEF -> CLASS_DEF 2223 * |--MODIFIERS -> MODIFIERS 2224 * |--LITERAL_CLASS -> class 2225 * |--IDENT -> App 2226 * `--OBJBLOCK -> OBJBLOCK 2227 * |--LCURLY -> { 2228 * |--VARIABLE_DEF -> VARIABLE_DEF 2229 * | |--MODIFIERS -> MODIFIERS 2230 * | |--TYPE -> TYPE 2231 * | | `--LITERAL_INT -> int 2232 * | |--IDENT -> num 2233 * | `--SEMI -> ; 2234 * `--RCURLY -> } 2235 * </pre> 2236 * 2237 * @see #OBJBLOCK 2238 * @see #ARRAY_INIT 2239 * @see #SLIST 2240 **/ 2241 public static final int LCURLY = JavaLanguageLexer.LCURLY; 2242 /** 2243 * A right curly brace (<code>}</code>). 2244 * 2245 * <p>For example:</p> 2246 * <pre> 2247 * {@code 2248 * void foo(){} 2249 * } 2250 * </pre> 2251 * 2252 * <p>parses as:</p> 2253 * <pre> 2254 * METHOD_DEF -> METHOD_DEF 2255 * |--MODIFIERS -> MODIFIERS 2256 * |--TYPE -> TYPE 2257 * | `--LITERAL_VOID -> void 2258 * |--IDENT -> foo 2259 * |--LPAREN -> ( 2260 * |--PARAMETERS -> PARAMETERS 2261 * |--RPAREN -> ) 2262 * `--SLIST -> { 2263 * `--RCURLY -> } 2264 * </pre> 2265 * 2266 * @see #OBJBLOCK 2267 * @see #ARRAY_INIT 2268 * @see #SLIST 2269 **/ 2270 public static final int RCURLY = JavaLanguageLexer.RCURLY; 2271 2272 /** 2273 * The {@code ,} (comma) operator. 2274 * 2275 * <p>For example:</p> 2276 * <pre> 2277 * int a, b; 2278 * </pre> 2279 * 2280 * <p>parses as:</p> 2281 * <pre> 2282 * |--VARIABLE_DEF -> VARIABLE_DEF 2283 * | |--MODIFIERS -> MODIFIERS 2284 * | |--TYPE -> TYPE 2285 * | | `--LITERAL_INT -> int 2286 * | `--IDENT -> a 2287 * |--COMMA -> , 2288 * |--VARIABLE_DEF -> VARIABLE_DEF 2289 * | |--MODIFIERS -> MODIFIERS 2290 * | |--TYPE -> TYPE 2291 * | | `--LITERAL_INT -> int 2292 * | `--IDENT -> b 2293 * |--SEMI -> ; 2294 * </pre> 2295 * 2296 * @see #ARRAY_INIT 2297 * @see #FOR_INIT 2298 * @see #FOR_ITERATOR 2299 * @see #LITERAL_THROWS 2300 * @see #IMPLEMENTS_CLAUSE 2301 **/ 2302 public static final int COMMA = JavaLanguageLexer.COMMA; 2303 2304 /** 2305 * A left parenthesis ({@code (}). 2306 * 2307 * <p>For example:</p> 2308 * <pre> 2309 * Integer val = new Integer(); 2310 * while (false) { 2311 * val += (-3); 2312 * } 2313 * </pre> 2314 * 2315 * <p>parses as:</p> 2316 * <pre> 2317 * |--VARIABLE_DEF -> VARIABLE_DEF 2318 * | |--MODIFIERS -> MODIFIERS 2319 * | |--TYPE -> TYPE 2320 * | | `--IDENT -> Integer 2321 * | |--IDENT -> val 2322 * | `--ASSIGN -> = 2323 * | `--EXPR -> EXPR 2324 * | `--LITERAL_NEW -> new 2325 * | |--IDENT -> Integer 2326 * | |--LPAREN -> ( 2327 * | |--ELIST -> ELIST 2328 * | `--RPAREN -> ) 2329 * |--SEMI -> ; 2330 * |--LITERAL_WHILE -> while 2331 * | |--LPAREN -> ( 2332 * | |--EXPR -> EXPR 2333 * | | `--LITERAL_FALSE -> false 2334 * | |--RPAREN -> ) 2335 * | `--SLIST -> { 2336 * | |--EXPR -> EXPR 2337 * | | `--PLUS_ASSIGN -> += 2338 * | | |--IDENT -> val 2339 * | | |--LPAREN -> ( 2340 * | | |--UNARY_MINUS -> - 2341 * | | | `--NUM_INT -> 3 2342 * | | `--RPAREN -> ) 2343 * | |--SEMI -> ; 2344 * | `--RCURLY -> } 2345 * </pre> 2346 * 2347 * @see #LITERAL_FOR 2348 * @see #LITERAL_NEW 2349 * @see #EXPR 2350 * @see #LITERAL_SWITCH 2351 * @see #LITERAL_CATCH 2352 **/ 2353 public static final int LPAREN = JavaLanguageLexer.LPAREN; 2354 /** 2355 * A right parenthesis ({@code )}). 2356 * 2357 * <p>For example:</p> 2358 * <pre> 2359 * void check() { 2360 * } 2361 * </pre> 2362 * 2363 * <p>parses as:</p> 2364 * <pre> 2365 * METHOD_DEF -> METHOD_DEF 2366 * |--MODIFIERS -> MODIFIERS 2367 * |--TYPE -> TYPE 2368 * | `--LITERAL_VOID -> void 2369 * |--IDENT -> check 2370 * |--LPAREN -> ( 2371 * |--PARAMETERS -> PARAMETERS 2372 * |--RPAREN -> ) 2373 * `--SLIST -> { 2374 * `--RCURLY -> } 2375 * </pre> 2376 * 2377 * @see #LITERAL_FOR 2378 * @see #LITERAL_NEW 2379 * @see #METHOD_CALL 2380 * @see #TYPECAST 2381 * @see #EXPR 2382 * @see #LITERAL_SWITCH 2383 * @see #LITERAL_CATCH 2384 **/ 2385 public static final int RPAREN = JavaLanguageLexer.RPAREN; 2386 /** 2387 * The {@code this} keyword use to refer the current object. 2388 * This can also be used to call the constructor. 2389 * 2390 * <p>For example:</p> 2391 * <pre> 2392 * this.name = name; 2393 * </pre> 2394 * 2395 * <p>parses as:</p> 2396 * <pre> 2397 * EXPR -> EXPR 2398 * `--ASSIGN -> = 2399 * |--DOT -> . 2400 * | |--LITERAL_THIS -> this 2401 * | `--IDENT -> name 2402 * `--IDENT -> name 2403 * SEMI -> ; 2404 * </pre> 2405 * 2406 * <p>Also consider:</p> 2407 * <pre> 2408 * this(1, "NULL"); 2409 * </pre> 2410 * 2411 * <p>parses as:</p> 2412 * <pre> 2413 * CTOR_CALL -> this 2414 * |--LPAREN -> ( 2415 * |--ELIST -> ELIST 2416 * | |--EXPR -> EXPR 2417 * | | `--NUM_INT -> 1 2418 * | |--COMMA -> , 2419 * | `--EXPR -> EXPR 2420 * | `--STRING_LITERAL -> "NULL" 2421 * |--RPAREN -> ) 2422 * `--SEMI -> ; 2423 * </pre> 2424 * 2425 * @see #EXPR 2426 * @see #CTOR_CALL 2427 **/ 2428 public static final int LITERAL_THIS = 2429 JavaLanguageLexer.LITERAL_THIS; 2430 2431 /** 2432 * The {@code super} keyword. 2433 * 2434 * <p>For example:</p> 2435 * <pre> 2436 * super.toString()ï¼› 2437 * </pre> 2438 * 2439 * <p>parses as:</p> 2440 * <pre> 2441 * |--EXPR -> EXPR 2442 * | `--METHOD_CALL -> ( 2443 * | |--DOT -> . 2444 * | | |--LITERAL_SUPER -> super 2445 * | | `--IDENT -> toString 2446 * | |--ELIST -> ELIST 2447 * | `--RPAREN -> ) 2448 * |--SEMI -> ; 2449 * </pre> 2450 * 2451 * @see #EXPR 2452 * @see #SUPER_CTOR_CALL 2453 **/ 2454 public static final int LITERAL_SUPER = 2455 JavaLanguageLexer.LITERAL_SUPER; 2456 2457 /** 2458 * The {@code =} (assignment) operator. 2459 * 2460 * <p>For example:</p> 2461 * <pre> 2462 * a = b; 2463 * </pre> 2464 * 2465 * <p>parses as:</p> 2466 * <pre> 2467 * |--EXPR -> EXPR 2468 * | `--ASSIGN -> = 2469 * | |--IDENT -> a 2470 * | `--IDENT -> b 2471 * |--SEMI -> ; 2472 * </pre> 2473 * 2474 * @see <a 2475 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java 2476 * Language Specification, §15.26.1</a> 2477 * @see #EXPR 2478 **/ 2479 public static final int ASSIGN = JavaLanguageLexer.ASSIGN; 2480 /** 2481 * The {@code throws} keyword. The children are a number of 2482 * one or more identifiers separated by commas. 2483 * 2484 * <p>For example:</p> 2485 * <pre> 2486 * void test() throws FileNotFoundException, EOFException { 2487 * } 2488 * </pre> 2489 * 2490 * <p>parses as:</p> 2491 * <pre> 2492 * METHOD_DEF -> METHOD_DEF 2493 * |--MODIFIERS -> MODIFIERS 2494 * |--TYPE -> TYPE 2495 * | `--LITERAL_VOID -> void 2496 * |--IDENT -> test 2497 * |--LPAREN -> ( 2498 * |--PARAMETERS -> PARAMETERS 2499 * |--RPAREN -> ) 2500 * |--LITERAL_THROWS -> throws 2501 * | |--IDENT -> FileNotFoundException 2502 * | |--COMMA -> , 2503 * | `--IDENT -> EOFException 2504 * `--SLIST -> { 2505 * `--RCURLY -> } 2506 * </pre> 2507 * 2508 * @see <a 2509 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java 2510 * Language Specification, §8.4.4</a> 2511 * @see #IDENT 2512 * @see #DOT 2513 * @see #COMMA 2514 * @see #METHOD_DEF 2515 * @see #CTOR_DEF 2516 * @see FullIdent 2517 **/ 2518 public static final int LITERAL_THROWS = 2519 JavaLanguageLexer.LITERAL_THROWS; 2520 2521 /** 2522 * The {@code :} (colon) operator. This will appear as part 2523 * of the conditional operator ({@code ? :}). 2524 * 2525 * <p>For example:</p> 2526 * <pre> 2527 * num = isValid ? 1 : 0; 2528 * </pre> 2529 * 2530 * <p>parses as:</p> 2531 * <pre> 2532 * |--EXPR -> EXPR 2533 * | `--ASSIGN -> = 2534 * | |--IDENT -> num 2535 * | `--QUESTION -> ? 2536 * | |--IDENT -> isValid 2537 * | |--NUM_INT -> 1 2538 * | |--COLON -> : 2539 * | `--NUM_INT -> 0 2540 * |--SEMI -> ; 2541 * </pre> 2542 * 2543 * @see #QUESTION 2544 * @see #LABELED_STAT 2545 * @see #CASE_GROUP 2546 **/ 2547 public static final int COLON = JavaLanguageLexer.COLON; 2548 2549 /** 2550 * The {@code ::} (double colon) separator. 2551 * It is part of Java 8 syntax that is used for method reference. 2552 * The token does not appear in tree, {@link #METHOD_REF} should be used instead. 2553 * 2554 * <p>For example:</p> 2555 * <pre> 2556 * Function<Double, Double> square = MyClass::square; 2557 * </pre> 2558 * 2559 * <p>parses as:</p> 2560 * <pre> 2561 * VARIABLE_DEF -> VARIABLE_DEF 2562 * |--MODIFIERS -> MODIFIERS 2563 * |--TYPE -> TYPE 2564 * | |--IDENT -> Function 2565 * | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 2566 * | | |--GENERIC_START -> < 2567 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 2568 * | | | `--IDENT -> Double 2569 * | | |--COMMA -> , 2570 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 2571 * | | | `--IDENT -> Double 2572 * | | `--GENERIC_END -> > 2573 * | |--IDENT -> square 2574 * | |--ASSIGN -> = 2575 * | | `--EXPR -> EXPR 2576 * | | `--METHOD_REF -> :: 2577 * | | |--IDENT -> MyClass 2578 * | | `--IDENT -> square 2579 * | `--SEMI -> ; 2580 * </pre> 2581 * 2582 * @see #METHOD_REF 2583 */ 2584 public static final int DOUBLE_COLON = JavaLanguageLexer.DOUBLE_COLON; 2585 /** 2586 * The {@code if} keyword. 2587 * 2588 * <p>For example:</p> 2589 * <pre> 2590 * if (optimistic) 2591 * { 2592 * message = "half full"; 2593 * } 2594 * else 2595 * { 2596 * message = "half empty"; 2597 * } 2598 * </pre> 2599 * 2600 * <p>parses as:</p> 2601 * <pre> 2602 * LITERAL_IF -> if 2603 * |--LPAREN -> ( 2604 * |--EXPR -> EXPR 2605 * | `--IDENT -> optimistic 2606 * |--RPAREN -> ) 2607 * |--SLIST -> { 2608 * | |--EXPR -> EXPR 2609 * | | `--ASSIGN -> = 2610 * | | |--IDENT -> message 2611 * | | `--STRING_LITERAL -> "half full" 2612 * | |--SEMI -> ; 2613 * | `--RCURLY -> } 2614 * `--LITERAL_ELSE -> else 2615 * `--SLIST -> { 2616 * |--EXPR -> EXPR 2617 * | `--ASSIGN -> = 2618 * | |--IDENT -> message 2619 * | `--STRING_LITERAL -> "half empty" 2620 * |--SEMI -> ; 2621 * `--RCURLY -> } 2622 * </pre> 2623 * 2624 * @see #LPAREN 2625 * @see #EXPR 2626 * @see #RPAREN 2627 * @see #SLIST 2628 * @see #EMPTY_STAT 2629 * @see #LITERAL_ELSE 2630 **/ 2631 public static final int LITERAL_IF = JavaLanguageLexer.LITERAL_IF; 2632 /** 2633 * The {@code for} keyword. The children are {@code (}, 2634 * an initializer, a condition, an iterator, a {@code )} and 2635 * either a statement list, a single expression, or an empty 2636 * statement. 2637 * 2638 * <p>For example:</p> 2639 * <pre> 2640 * for (int i = 0; i < arr.length; i++) {} 2641 * </pre> 2642 * 2643 * <p>parses as:</p> 2644 * <pre> 2645 * LITERAL_FOR -> for 2646 * |--LPAREN -> ( 2647 * |--FOR_INIT -> FOR_INIT 2648 * | `--VARIABLE_DEF -> VARIABLE_DEF 2649 * | |--MODIFIERS -> MODIFIERS 2650 * | |--TYPE -> TYPE 2651 * | | `--LITERAL_INT -> int 2652 * | |--IDENT -> i 2653 * | `--ASSIGN -> = 2654 * | `--EXPR -> EXPR 2655 * | `--NUM_INT -> 0 2656 * |--SEMI -> ; 2657 * |--FOR_CONDITION -> FOR_CONDITION 2658 * | `--EXPR -> EXPR 2659 * | `--LT -> < 2660 * | |--IDENT -> i 2661 * | `--DOT -> . 2662 * | |--IDENT -> arr 2663 * | `--IDENT -> length 2664 * |--SEMI -> ; 2665 * |--FOR_ITERATOR -> FOR_ITERATOR 2666 * | `--ELIST -> ELIST 2667 * | `--EXPR -> EXPR 2668 * | `--POST_INC -> ++ 2669 * | `--IDENT -> i 2670 * |--RPAREN -> ) 2671 * `--SLIST -> { 2672 * `--RCURLY -> } 2673 * </pre> 2674 * 2675 * @see #LPAREN 2676 * @see #FOR_INIT 2677 * @see #SEMI 2678 * @see #FOR_CONDITION 2679 * @see #FOR_ITERATOR 2680 * @see #RPAREN 2681 * @see #SLIST 2682 * @see #EMPTY_STAT 2683 * @see #EXPR 2684 **/ 2685 public static final int LITERAL_FOR = JavaLanguageLexer.LITERAL_FOR; 2686 /** 2687 * The {@code while} keyword. 2688 * 2689 * <p>For example:</p> 2690 * <pre> 2691 * while (i < 5) { 2692 * i++; 2693 * } 2694 * </pre> 2695 * 2696 * <p>parses as:</p> 2697 * <pre> 2698 * LITERAL_WHILE -> while 2699 * |--LPAREN -> ( 2700 * |--EXPR -> EXPR 2701 * | `--LT -> < 2702 * | |--IDENT -> i 2703 * | `--NUM_INT -> 5 2704 * |--RPAREN -> ) 2705 * `--SLIST -> { 2706 * |--EXPR -> EXPR 2707 * | `--POST_INC -> ++ 2708 * | `--IDENT -> i 2709 * |--SEMI -> ; 2710 * `--RCURLY -> } 2711 * </pre> 2712 **/ 2713 public static final int LITERAL_WHILE = 2714 JavaLanguageLexer.LITERAL_WHILE; 2715 2716 /** 2717 * The {@code do} keyword. Note that the while token does not 2718 * appear as part of the do-while construct. 2719 * 2720 * <p>For example:</p> 2721 * <pre> 2722 * do { 2723 * x = rand.nextInt(); 2724 * } while (x < 5); 2725 * </pre> 2726 * 2727 * <p>parses as:</p> 2728 * <pre> 2729 * LITERAL_DO -> do 2730 * |--SLIST -> { 2731 * | |--EXPR -> EXPR 2732 * | | `--ASSIGN -> = 2733 * | | |--IDENT -> x 2734 * | | `--METHOD_CALL -> ( 2735 * | | |--DOT -> . 2736 * | | | |--IDENT -> rand 2737 * | | | `--IDENT -> nextInt 2738 * | | |--ELIST -> ELIST 2739 * | | `--RPAREN -> ) 2740 * | |--SEMI -> ; 2741 * | `--RCURLY -> } 2742 * |--DO_WHILE -> while 2743 * |--LPAREN -> ( 2744 * |--EXPR -> EXPR 2745 * | `--LT -> < 2746 * | |--IDENT -> x 2747 * | `--NUM_INT -> 5 2748 * |--RPAREN -> ) 2749 * `--SEMI -> ; 2750 * </pre> 2751 * 2752 * @see #SLIST 2753 * @see #EXPR 2754 * @see #EMPTY_STAT 2755 * @see #LPAREN 2756 * @see #RPAREN 2757 * @see #SEMI 2758 **/ 2759 public static final int LITERAL_DO = JavaLanguageLexer.LITERAL_DO; 2760 /** 2761 * Literal {@code while} in do-while loop. 2762 * 2763 * <p>For example:</p> 2764 * <pre> 2765 * do { 2766 * 2767 * } while (a > 0); 2768 * </pre> 2769 * 2770 * <p>parses as:</p> 2771 * <pre> 2772 * --LITERAL_DO -> do 2773 * |--SLIST -> { 2774 * | `--RCURLY -> } 2775 * |--DO_WHILE -> while 2776 * |--LPAREN -> ( 2777 * |--EXPR -> EXPR 2778 * | `--GT -> > 2779 * | |--IDENT -> a 2780 * | `--NUM_INT -> 0 2781 * |--RPAREN -> ) 2782 * `--SEMI -> ; 2783 * </pre> 2784 * 2785 * @see #LITERAL_DO 2786 */ 2787 public static final int DO_WHILE = JavaLanguageLexer.DO_WHILE; 2788 /** 2789 * The {@code break} keyword. The first child is an optional 2790 * identifier and the last child is a semicolon. 2791 * 2792 * <p>For example:</p> 2793 * <pre> 2794 * for (;;) { 2795 * break; 2796 * } 2797 * </pre> 2798 * 2799 * <p>parses as:</p> 2800 * <pre> 2801 * LITERAL_FOR -> for 2802 * |--LPAREN -> ( 2803 * |--FOR_INIT -> FOR_INIT 2804 * |--SEMI -> ; 2805 * |--FOR_CONDITION -> FOR_CONDITION 2806 * |--SEMI -> ; 2807 * |--FOR_ITERATOR -> FOR_ITERATOR 2808 * |--RPAREN -> ) 2809 * `--SLIST -> { 2810 * |--LITERAL_BREAK -> break 2811 * | `--SEMI -> ; 2812 * `--RCURLY -> } 2813 * </pre> 2814 * 2815 * @see #IDENT 2816 * @see #SEMI 2817 * @see #SLIST 2818 **/ 2819 public static final int LITERAL_BREAK = 2820 JavaLanguageLexer.LITERAL_BREAK; 2821 2822 /** 2823 * The {@code continue} keyword. The first child is an 2824 * optional identifier and the last child is a semicolon. 2825 * 2826 * <p>For example:</p> 2827 * <pre> 2828 * for (;;) { 2829 * continue; 2830 * } 2831 * </pre> 2832 * 2833 * <p>parses as:</p> 2834 * <pre> 2835 * LITERAL_FOR -> for 2836 * |--LPAREN -> ( 2837 * |--FOR_INIT -> FOR_INIT 2838 * |--SEMI -> ; 2839 * |--FOR_CONDITION -> FOR_CONDITION 2840 * |--SEMI -> ; 2841 * |--FOR_ITERATOR -> FOR_ITERATOR 2842 * |--RPAREN -> ) 2843 * `--SLIST -> { 2844 * |--LITERAL_CONTINUE -> continue 2845 * | `--SEMI -> ; 2846 * `--RCURLY -> } 2847 * </pre> 2848 * 2849 * @see #IDENT 2850 * @see #SEMI 2851 * @see #SLIST 2852 **/ 2853 public static final int LITERAL_CONTINUE = 2854 JavaLanguageLexer.LITERAL_CONTINUE; 2855 2856 /** 2857 * The {@code return} keyword. The first child is an 2858 * optional expression for the return value. The last child is a 2859 * semicolon. 2860 * 2861 * <p>For example:</p> 2862 * <pre> 2863 * public int foo(int i) { 2864 * return i+1; 2865 * } 2866 * </pre> 2867 * 2868 * <p>parses as:</p> 2869 * <pre> 2870 * METHOD_DEF -> METHOD_DEF 2871 * |--MODIFIERS -> MODIFIERS 2872 * | `--LITERAL_PUBLIC -> public 2873 * |--TYPE -> TYPE 2874 * | `--LITERAL_INT -> int 2875 * |--IDENT -> foo 2876 * |--LPAREN -> ( 2877 * |--PARAMETERS -> PARAMETERS 2878 * | `--PARAMETER_DEF -> PARAMETER_DEF 2879 * | |--MODIFIERS -> MODIFIERS 2880 * | |--TYPE -> TYPE 2881 * | | `--LITERAL_INT -> int 2882 * | `--IDENT -> i 2883 * |--RPAREN -> ) 2884 * `--SLIST -> { 2885 * |--LITERAL_RETURN -> return 2886 * | |--EXPR -> EXPR 2887 * | | `--PLUS -> + 2888 * | | |--IDENT -> i 2889 * | | `--NUM_INT -> 1 2890 * | `--SEMI -> ; 2891 * `--RCURLY -> } 2892 * </pre> 2893 * 2894 * @see #EXPR 2895 * @see #SEMI 2896 * @see #SLIST 2897 **/ 2898 public static final int LITERAL_RETURN = 2899 JavaLanguageLexer.LITERAL_RETURN; 2900 2901 /** 2902 * The {@code switch} keyword. 2903 * 2904 * <p>For example:</p> 2905 * <pre> 2906 * switch (type) { 2907 * case 0: 2908 * background = Color.red; 2909 * break; 2910 * case 1: 2911 * background = Color.blue; 2912 * break; 2913 * default: 2914 * background = Color.green; 2915 * } 2916 * </pre> 2917 * 2918 * <p>parses as:</p> 2919 * <pre> 2920 * LITERAL_SWITCH -> switch 2921 * |--LPAREN -> ( 2922 * |--EXPR -> EXPR 2923 * | `--IDENT -> type 2924 * |--RPAREN -> ) 2925 * |--LCURLY -> { 2926 * |--CASE_GROUP -> CASE_GROUP 2927 * | |--LITERAL_CASE -> case 2928 * | | |--EXPR -> EXPR 2929 * | | | `--NUM_INT -> 0 2930 * | | `--COLON -> : 2931 * | `--SLIST -> SLIST 2932 * | |--EXPR -> EXPR 2933 * | | `--ASSIGN -> = 2934 * | | |--IDENT -> background 2935 * | | `--DOT -> . 2936 * | | |--IDENT -> Color 2937 * | | `--IDENT -> red 2938 * | |--SEMI -> ; 2939 * | `--LITERAL_BREAK -> break 2940 * | `--SEMI -> ; 2941 * |--CASE_GROUP -> CASE_GROUP 2942 * | |--LITERAL_CASE -> case 2943 * | | |--EXPR -> EXPR 2944 * | | | `--NUM_INT -> 1 2945 * | | `--COLON -> : 2946 * | `--SLIST -> SLIST 2947 * | |--EXPR -> EXPR 2948 * | | `--ASSIGN -> = 2949 * | | |--IDENT -> background 2950 * | | `--DOT -> . 2951 * | | |--IDENT -> Color 2952 * | | `--IDENT -> blue 2953 * | |--SEMI -> ; 2954 * | `--LITERAL_BREAK -> break 2955 * | `--SEMI -> ; 2956 * |--CASE_GROUP -> CASE_GROUP 2957 * | |--LITERAL_DEFAULT -> default 2958 * | | `--COLON -> : 2959 * | `--SLIST -> SLIST 2960 * | |--EXPR -> EXPR 2961 * | | `--ASSIGN -> = 2962 * | | |--IDENT -> background 2963 * | | `--DOT -> . 2964 * | | |--IDENT -> Color 2965 * | | `--IDENT -> green 2966 * | `--SEMI -> ; 2967 * `--RCURLY -> } 2968 * </pre> 2969 * 2970 * @see <a 2971 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 2972 * Language Specification, §14.10</a> 2973 * @see #LPAREN 2974 * @see #EXPR 2975 * @see #RPAREN 2976 * @see #LCURLY 2977 * @see #CASE_GROUP 2978 * @see #RCURLY 2979 * @see #SLIST 2980 * @see #SWITCH_RULE 2981 **/ 2982 public static final int LITERAL_SWITCH = 2983 JavaLanguageLexer.LITERAL_SWITCH; 2984 2985 /** 2986 * The {@code throw} keyword. The first child is an 2987 * expression that evaluates to a {@code Throwable} instance. 2988 * 2989 * <p>For example:</p> 2990 * <pre> 2991 * throw new ArithmeticException("An exception occurred."); 2992 * </pre> 2993 * 2994 * <p>parses as:</p> 2995 * <pre> 2996 * LITERAL_THROW -> throw 2997 * |--EXPR -> EXPR 2998 * | `--LITERAL_NEW -> new 2999 * | |--IDENT -> ArithmeticException 3000 * | |--LPAREN -> ( 3001 * | |--ELIST -> ELIST 3002 * | | `--EXPR -> EXPR 3003 * | | `--STRING_LITERAL -> "An exception occurred." 3004 * | `--RPAREN -> ) 3005 * `--SEMI -> ; 3006 * </pre> 3007 * 3008 * @see <a 3009 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java 3010 * Language Specification, §14.17</a> 3011 * @see #SLIST 3012 * @see #EXPR 3013 **/ 3014 public static final int LITERAL_THROW = 3015 JavaLanguageLexer.LITERAL_THROW; 3016 3017 /** 3018 * The {@code else} keyword. This appears as a child of an 3019 * {@code if} statement. 3020 * 3021 * <p>For example:</p> 3022 * <pre> 3023 * if (flag) { 3024 * 3025 * } else { 3026 * 3027 * } 3028 * </pre> 3029 * 3030 * <p>parses as:</p> 3031 * <pre> 3032 * LITERAL_IF -> if 3033 * |--LPAREN -> ( 3034 * |--EXPR -> EXPR 3035 * | `--IDENT -> flag 3036 * |--RPAREN -> ) 3037 * |--SLIST -> { 3038 * | `--RCURLY -> } 3039 * `--LITERAL_ELSE -> else 3040 * `--SLIST -> { 3041 * `--RCURLY -> } 3042 * </pre> 3043 * 3044 * @see #SLIST 3045 * @see #EXPR 3046 * @see #EMPTY_STAT 3047 * @see #LITERAL_IF 3048 **/ 3049 public static final int LITERAL_ELSE = 3050 JavaLanguageLexer.LITERAL_ELSE; 3051 3052 /** 3053 * The {@code case} keyword. The first child is a constant 3054 * expression that evaluates to an integer. 3055 * 3056 * <p>For example:</p> 3057 * <pre> 3058 * switch(num){ 3059 * case 0: 3060 * num = 1; 3061 * } 3062 * </pre> 3063 * 3064 * <p>parses as:</p> 3065 * <pre> 3066 * 3067 * CASE_GROUP -> CASE_GROUP 3068 * |--LITERAL_CASE -> cas 3069 * | |--EXPR -> EXPR 3070 * | | `--NUM_INT -> 0 3071 * | `--COLON -> : 3072 * `--SLIST -> SLIST 3073 * |--EXPR -> EXPR 3074 * | `--ASSIGN -> = 3075 * | |--IDENT -> num 3076 * | `--NUM_INT -> 1 3077 * `--SEMI -> ; 3078 * </pre> 3079 * 3080 * <p>For example:</p> 3081 * <pre> 3082 * switch(num){ 3083 * case 1 -> num = -1 3084 * } 3085 * </pre> 3086 * 3087 * <p>parses as:</p> 3088 * <pre> 3089 * SWITCH_RULE -> SWITCH_RULE 3090 * |--LITERAL_CASE -> case 3091 * | `--EXPR -> EXPR 3092 * | `--NUM_INT -> 1 3093 * |--LAMBDA -> -> 3094 * |--EXPR -> EXPR 3095 * | `--ASSIGN -> = 3096 * | |--IDENT -> num 3097 * | `--UNARY_MINUS -> - 3098 * | `--NUM_INT -> 1 3099 * `--SEMI -> ; 3100 * </pre> 3101 * 3102 * @see #CASE_GROUP 3103 * @see #EXPR 3104 **/ 3105 public static final int LITERAL_CASE = 3106 JavaLanguageLexer.LITERAL_CASE; 3107 3108 /** 3109 * The {@code default} keyword. This element has no 3110 * children. 3111 * 3112 * <p>For example:</p> 3113 * <pre> 3114 * switch (type) { 3115 * case 1: 3116 * x = 1; 3117 * break; 3118 * default: 3119 * x = 3; 3120 * } 3121 * </pre> 3122 * 3123 * <p>parses as:</p> 3124 * <pre> 3125 * LITERAL_SWITCH -> switch 3126 * |--LPAREN -> ( 3127 * |--EXPR -> EXPR 3128 * | `--IDENT -> type 3129 * |--RPAREN -> ) 3130 * |--LCURLY -> { 3131 * |--CASE_GROUP -> CASE_GROUP 3132 * | |--LITERAL_CASE -> case 3133 * | | |--EXPR -> EXPR 3134 * | | | `--NUM_INT -> 1 3135 * | | `--COLON -> : 3136 * | `--SLIST -> SLIST 3137 * | |--EXPR -> EXPR 3138 * | | `--ASSIGN -> = 3139 * | | |--IDENT -> x 3140 * | | `--NUM_INT -> 1 3141 * | | | |--SEMI -> ; 3142 * | `--LITERAL_BREAK -> break 3143 * | `--SEMI -> ; 3144 * |--CASE_GROUP -> CASE_GROUP 3145 * | |--LITERAL_DEFAULT -> default 3146 * | | `--COLON -> : 3147 * | `--SLIST -> SLIST 3148 * | |--EXPR -> EXPR 3149 * | | `--ASSIGN -> = 3150 * | | |--IDENT -> x 3151 * | | `--NUM_INT -> 3 3152 * | `--SEMI -> ; 3153 * `--RCURLY -> } 3154 * </pre> 3155 * 3156 * @see #CASE_GROUP 3157 * @see #MODIFIERS 3158 * @see #SWITCH_RULE 3159 **/ 3160 public static final int LITERAL_DEFAULT = 3161 JavaLanguageLexer.LITERAL_DEFAULT; 3162 3163 /** 3164 * The {@code try} keyword. The children are a statement 3165 * list, zero or more catch blocks and then an optional finally 3166 * block. 3167 * 3168 * <p>For example:</p> 3169 * <pre> 3170 * try { } finally {} 3171 * </pre> 3172 * 3173 * <p>parses as:</p> 3174 * <pre> 3175 * LITERAL_TRY -> try 3176 * |--SLIST -> { 3177 * | `--RCURLY -> } 3178 * `--LITERAL_FINALLY -> finally 3179 * `--SLIST -> { 3180 * `--RCURLY -> } 3181 * </pre> 3182 * 3183 * @see <a 3184 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 3185 * Language Specification, §14.19</a> 3186 * @see #SLIST 3187 * @see #LITERAL_CATCH 3188 * @see #LITERAL_FINALLY 3189 **/ 3190 public static final int LITERAL_TRY = JavaLanguageLexer.LITERAL_TRY; 3191 3192 /** 3193 * The Java 7 try-with-resources construct. 3194 * 3195 * <p>For example:</p> 3196 * <pre> 3197 * try (Foo foo = new Foo(); Bar bar = new Bar()) { 3198 * } 3199 * </pre> 3200 * 3201 * <p>parses as:</p> 3202 * <pre> 3203 * LITERAL_TRY -> try 3204 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 3205 * | |--LPAREN -> ( 3206 * | |--RESOURCES -> RESOURCES 3207 * | | |--RESOURCE -> RESOURCE 3208 * | | | |--MODIFIERS -> MODIFIERS 3209 * | | | |--TYPE -> TYPE 3210 * | | | | `--IDENT -> Foo 3211 * | | | |--IDENT -> foo 3212 * | | | `--ASSIGN -> = 3213 * | | | `--EXPR -> EXPR 3214 * | | | `--LITERAL_NEW -> new 3215 * | | | |--IDENT -> Foo 3216 * | | | |--LPAREN -> ( 3217 * | | | |--ELIST -> ELIST 3218 * | | | `--RPAREN -> ) 3219 * | | |--SEMI -> ; 3220 * | | `--RESOURCE -> RESOURCE 3221 * | | |--MODIFIERS -> MODIFIERS 3222 * | | |--TYPE -> TYPE 3223 * | | | `--IDENT -> Bar 3224 * | | |--IDENT -> bar 3225 * | | `--ASSIGN -> = 3226 * | | `--EXPR -> EXPR 3227 * | | `--LITERAL_NEW -> new 3228 * | | |--IDENT -> Bar 3229 * | | |--LPAREN -> ( 3230 * | | |--ELIST -> ELIST 3231 * | | `--RPAREN -> ) 3232 * | `--RPAREN -> ) 3233 * `--SLIST -> { 3234 * `--RCURLY -> } 3235 * </pre> 3236 * 3237 * <p>Also consider:</p> 3238 * <pre> 3239 * try (BufferedReader br = new BufferedReader(new FileReader(path))) { 3240 * } 3241 * </pre> 3242 * 3243 * <p>which parses as:</p> 3244 * <pre> 3245 * LITERAL_TRY -> try 3246 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 3247 * | |--LPAREN -> ( 3248 * | |--RESOURCES -> RESOURCES 3249 * | | `--RESOURCE -> RESOURCE 3250 * | | |--MODIFIERS -> MODIFIERS 3251 * | | |--TYPE -> TYPE 3252 * | | | `--IDENT -> BufferedReader 3253 * | | |--IDENT -> br 3254 * | | `--ASSIGN -> = 3255 * | | `--EXPR -> EXPR 3256 * | | `--LITERAL_NEW -> new 3257 * | | |--IDENT -> BufferedReader 3258 * | | |--LPAREN -> ( 3259 * | | |--ELIST -> ELIST 3260 * | | | `--EXPR -> EXPR 3261 * | | | `--LITERAL_NEW -> new 3262 * | | | |--IDENT -> FileReader 3263 * | | | |--LPAREN -> ( 3264 * | | | |--ELIST -> ELIST 3265 * | | | | `--EXPR -> EXPR 3266 * | | | | `--IDENT -> path 3267 * | | | `--RPAREN -> ) 3268 * | | `--RPAREN -> ) 3269 * | `--RPAREN -> ) 3270 * `--SLIST -> { 3271 * `--RCURLY -> } 3272 * </pre> 3273 * 3274 * @see #LPAREN 3275 * @see #RESOURCES 3276 * @see #RESOURCE 3277 * @see #SEMI 3278 * @see #RPAREN 3279 * @see #LITERAL_TRY 3280 **/ 3281 public static final int RESOURCE_SPECIFICATION = 3282 JavaLanguageLexer.RESOURCE_SPECIFICATION; 3283 3284 /** 3285 * A list of resources in the Java 7 try-with-resources construct. 3286 * This is a child of RESOURCE_SPECIFICATION. 3287 * 3288 * <p>For example:</p> 3289 * <pre> 3290 * try (FileReader fr = new FileReader("config.xml")) { 3291 * } finally {} 3292 * </pre> 3293 * 3294 * <p>parses as:</p> 3295 * <pre> 3296 * LITERAL_TRY -> try 3297 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 3298 * | |--LPAREN -> ( 3299 * | |--RESOURCES -> RESOURCES 3300 * | | `--RESOURCE -> RESOURCE 3301 * | | |--MODIFIERS -> MODIFIERS 3302 * | | |--TYPE -> TYPE 3303 * | | | `--IDENT -> FileReader 3304 * | | |--IDENT -> fr 3305 * | | `--ASSIGN -> = 3306 * | | `--EXPR -> EXPR 3307 * | | `--LITERAL_NEW -> new 3308 * | | |--IDENT -> FileReader 3309 * | | |--LPAREN -> ( 3310 * | | |--ELIST -> ELIST 3311 * | | | `--EXPR -> EXPR 3312 * | | | `--STRING_LITERAL -> "config.xml" 3313 * | | `--RPAREN -> ) 3314 * | `--RPAREN -> ) 3315 * |--SLIST -> { 3316 * | `--RCURLY -> } 3317 * `--LITERAL_FINALLY -> finally 3318 * `--SLIST -> { 3319 * `--RCURLY -> } 3320 * </pre> 3321 * 3322 * @see #RESOURCE_SPECIFICATION 3323 **/ 3324 public static final int RESOURCES = 3325 JavaLanguageLexer.RESOURCES; 3326 3327 /** 3328 * A resource in the Java 7 try-with-resources construct. 3329 * This is a child of RESOURCES. 3330 * 3331 * <p>For example:</p> 3332 * <pre> 3333 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 3334 * </pre> 3335 * 3336 * <p>parses as:</p> 3337 * <pre> 3338 * LITERAL_TRY -> try 3339 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION 3340 * | |--LPAREN -> ( 3341 * | |--RESOURCES -> RESOURCES 3342 * | | |--RESOURCE -> RESOURCE 3343 * | | | |--MODIFIERS -> MODIFIERS 3344 * | | | |--TYPE -> TYPE 3345 * | | | | `--IDENT -> Foo 3346 * | | | |--IDENT -> foo 3347 * | | | `--ASSIGN -> = 3348 * | | | `--EXPR -> EXPR 3349 * | | | `--LITERAL_NEW -> new 3350 * | | | |--IDENT -> Foo 3351 * | | | |--LPAREN -> ( 3352 * | | | |--ELIST -> ELIST 3353 * | | | `--RPAREN -> ) 3354 * | | |--SEMI -> ; 3355 * | | `--RESOURCE -> RESOURCE 3356 * | | |--MODIFIERS -> MODIFIERS 3357 * | | |--TYPE -> TYPE 3358 * | | | `--IDENT -> Bar 3359 * | | |--IDENT -> bar 3360 * | | `--ASSIGN -> = 3361 * | | `--EXPR -> EXPR 3362 * | | `--LITERAL_NEW -> new 3363 * | | |--IDENT -> Bar 3364 * | | |--LPAREN -> ( 3365 * | | |--ELIST -> ELIST 3366 * | | `--RPAREN -> ) 3367 * | `--RPAREN -> ) 3368 * `--SLIST -> { 3369 * `--RCURLY -> } 3370 * </pre> 3371 * 3372 * @see #RESOURCES 3373 * @see #RESOURCE_SPECIFICATION 3374 **/ 3375 public static final int RESOURCE = 3376 JavaLanguageLexer.RESOURCE; 3377 3378 /** 3379 * The {@code catch} keyword. 3380 * 3381 * <p>For example:</p> 3382 * <pre> 3383 * try { 3384 * FileReader fr = new FileReader("Test.txt"); 3385 * } catch (FileNotFoundException e) { 3386 * 3387 * } 3388 * </pre> 3389 * 3390 * <p>parses as:</p> 3391 * <pre> 3392 * LITERAL_TRY -> try 3393 * |--SLIST -> { 3394 * | |--VARIABLE_DEF -> VARIABLE_DEF 3395 * | | |--MODIFIERS -> MODIFIERS 3396 * | | |--TYPE -> TYPE 3397 * | | | `--IDENT -> FileReader 3398 * | | |--IDENT -> fr 3399 * | | `--ASSIGN -> = 3400 * | | `--EXPR -> EXPR 3401 * | | `--LITERAL_NEW -> new 3402 * | | |--IDENT -> FileReader 3403 * | | |--LPAREN -> ( 3404 * | | |--ELIST -> ELIST 3405 * | | | `--EXPR -> EXPR 3406 * | | | `--STRING_LITERAL -> "Test.txt" 3407 * | | `--RPAREN -> ) 3408 * | |--SEMI -> ; 3409 * | `--RCURLY -> } 3410 * `--LITERAL_CATCH -> catch 3411 * |--LPAREN -> ( 3412 * |--PARAMETER_DEF -> PARAMETER_DEF 3413 * | |--MODIFIERS -> MODIFIERS 3414 * | |--TYPE -> TYPE 3415 * | | `--IDENT -> FileNotFoundException 3416 * | `--IDENT -> e 3417 * |--RPAREN -> ) 3418 * `--SLIST -> { 3419 * `--RCURLY -> } 3420 * </pre> 3421 * 3422 * @see #LPAREN 3423 * @see #PARAMETER_DEF 3424 * @see #RPAREN 3425 * @see #SLIST 3426 * @see #LITERAL_TRY 3427 **/ 3428 public static final int LITERAL_CATCH = 3429 JavaLanguageLexer.LITERAL_CATCH; 3430 3431 /** 3432 * The {@code finally} keyword. 3433 * 3434 * <p>For example:</p> 3435 * <pre> 3436 * try {} finally {} 3437 * </pre> 3438 * 3439 * <p>parses as:</p> 3440 * <pre> 3441 * LITERAL_TRY -> try 3442 * |--SLIST -> { 3443 * | `--RCURLY -> } 3444 * `--LITERAL_FINALLY -> finally 3445 * `--SLIST -> { 3446 * `--RCURLY -> } 3447 * </pre> 3448 * 3449 * @see #SLIST 3450 * @see #LITERAL_TRY 3451 **/ 3452 public static final int LITERAL_FINALLY = 3453 JavaLanguageLexer.LITERAL_FINALLY; 3454 3455 /** 3456 * The {@code +=} (addition assignment) operator. 3457 * 3458 * <p>For example:</p> 3459 * <pre> 3460 * a += b; 3461 * </pre> 3462 * 3463 * <p>parses as:</p> 3464 * <pre> 3465 * |--EXPR -> EXPR 3466 * | `--PLUS_ASSIGN -> += 3467 * | |--IDENT -> a 3468 * | `--IDENT -> b 3469 * |--SEMI -> ; 3470 * </pre> 3471 * 3472 * @see <a 3473 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3474 * Language Specification, §15.26.2</a> 3475 * @see #EXPR 3476 **/ 3477 public static final int PLUS_ASSIGN = JavaLanguageLexer.PLUS_ASSIGN; 3478 /** 3479 * The {@code -=} (subtraction assignment) operator. 3480 * 3481 * <p>For example:</p> 3482 * <pre> 3483 * a -= b; 3484 * </pre> 3485 * 3486 * <p>parses as:</p> 3487 * <pre> 3488 * |--EXPR -> EXPR 3489 * | `--MINUS_ASSIGN -> -= 3490 * | |--IDENT -> a 3491 * | `--IDENT -> b 3492 * |--SEMI -> ; 3493 * </pre> 3494 * 3495 * @see <a 3496 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3497 * Language Specification, §15.26.2</a> 3498 * @see #EXPR 3499 **/ 3500 public static final int MINUS_ASSIGN = 3501 JavaLanguageLexer.MINUS_ASSIGN; 3502 3503 /** 3504 * The {@code *=} (multiplication assignment) operator. 3505 * 3506 * <p>For example:</p> 3507 * <pre> 3508 * a *= b; 3509 * </pre> 3510 * 3511 * <p>parses as:</p> 3512 * <pre> 3513 * |--EXPR -> EXPR 3514 * | `--STAR_ASSIGN -> *= 3515 * | |--IDENT -> a 3516 * | `--IDENT -> b 3517 * |--SEMI -> ; 3518 * </pre> 3519 * 3520 * @see <a 3521 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3522 * Language Specification, §15.26.2</a> 3523 * @see #EXPR 3524 **/ 3525 public static final int STAR_ASSIGN = JavaLanguageLexer.STAR_ASSIGN; 3526 /** 3527 * The {@code /=} (division assignment) operator. 3528 * 3529 * <p>For example:</p> 3530 * <pre> 3531 * a /= b; 3532 * </pre> 3533 * 3534 * <p>parses as:</p> 3535 * <pre> 3536 * |--EXPR -> EXPR 3537 * | `--DIV_ASSIGN -> /= 3538 * | |--IDENT -> a 3539 * | `--IDENT -> b 3540 * |--SEMI -> ; 3541 * </pre> 3542 * 3543 * @see <a 3544 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3545 * Language Specification, §15.26.2</a> 3546 * @see #EXPR 3547 **/ 3548 public static final int DIV_ASSIGN = JavaLanguageLexer.DIV_ASSIGN; 3549 /** 3550 * The {@code %=} (remainder assignment) operator. 3551 * 3552 * <p>For example:</p> 3553 * <pre>a %= 2;</pre> 3554 * 3555 * <p>parses as:</p> 3556 * <pre> 3557 * |--EXPR -> EXPR 3558 * | `--MOD_ASSIGN -> %= 3559 * | |--IDENT -> a 3560 * | `--NUM_INT -> 2 3561 * |--SEMI -> ; 3562 * </pre> 3563 * 3564 * @see <a 3565 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3566 * Language Specification, §15.26.2</a> 3567 * @see #EXPR 3568 **/ 3569 public static final int MOD_ASSIGN = JavaLanguageLexer.MOD_ASSIGN; 3570 /** 3571 * The {@code >>=} (signed right shift assignment) 3572 * operator. 3573 * 3574 * <p>For example:</p> 3575 * <pre> 3576 * a >>= b; 3577 * </pre> 3578 * 3579 * <p>parses as:</p> 3580 * <pre> 3581 * |--EXPR -> EXPR 3582 * | `--SR_ASSIGN -> >>= 3583 * | |--IDENT -> a 3584 * | `--IDENT -> b 3585 * |--SEMI -> ; 3586 * </pre> 3587 * 3588 * @see <a 3589 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3590 * Language Specification, §15.26.2</a> 3591 * @see #EXPR 3592 **/ 3593 public static final int SR_ASSIGN = JavaLanguageLexer.SR_ASSIGN; 3594 /** 3595 * The {@code >>>=} (unsigned right shift assignment) 3596 * operator. 3597 * 3598 * <p>For example:</p> 3599 * <pre> 3600 * a >>>= b; 3601 * </pre> 3602 * 3603 * <p>parses as:</p> 3604 * <pre> 3605 * |--EXPR -> EXPR 3606 * | `--BSR_ASSIGN -> >>>= 3607 * | |--IDENT -> a 3608 * | `--IDENT -> b 3609 * |--SEMI -> ; 3610 * </pre> 3611 * 3612 * @see <a 3613 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3614 * Language Specification, §15.26.2</a> 3615 * @see #EXPR 3616 **/ 3617 public static final int BSR_ASSIGN = JavaLanguageLexer.BSR_ASSIGN; 3618 /** 3619 * The {@code <<=} (left shift assignment) operator. 3620 * 3621 * @see <a 3622 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3623 * Language Specification, §15.26.2</a> 3624 * @see #EXPR 3625 **/ 3626 public static final int SL_ASSIGN = JavaLanguageLexer.SL_ASSIGN; 3627 /** 3628 * The {@code &=} (bitwise AND assignment) operator. 3629 * 3630 * <p>For example:</p> 3631 * <pre> 3632 * a &= b; 3633 * </pre> 3634 * 3635 * <p>parses as:</p> 3636 * <pre> 3637 * |--EXPR -> EXPR 3638 * | `--BAND_ASSIGN -> &= 3639 * | |--IDENT -> a 3640 * | `--IDENT -> b 3641 * |--SEMI -> ; 3642 * </pre> 3643 * 3644 * @see <a 3645 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3646 * Language Specification, §15.26.2</a> 3647 * @see #EXPR 3648 **/ 3649 public static final int BAND_ASSIGN = JavaLanguageLexer.BAND_ASSIGN; 3650 /** 3651 * The {@code ^=} (bitwise exclusive OR assignment) operator. 3652 * 3653 * @see <a 3654 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3655 * Language Specification, §15.26.2</a> 3656 * @see #EXPR 3657 **/ 3658 public static final int BXOR_ASSIGN = JavaLanguageLexer.BXOR_ASSIGN; 3659 /** 3660 * The {@code |=} (bitwise OR assignment) operator. 3661 * 3662 * <p>For example:</p> 3663 * <pre> 3664 * a |= b; 3665 * </pre> 3666 * 3667 * <p>parses as:</p> 3668 * <pre> 3669 * |--EXPR -> EXPR 3670 * | `--BOR_ASSIGN -> |= 3671 * | |--IDENT -> a 3672 * | `--IDENT -> b 3673 * |--SEMI -> ; 3674 * </pre> 3675 * 3676 * @see <a 3677 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 3678 * Language Specification, §15.26.2</a> 3679 * @see #EXPR 3680 **/ 3681 public static final int BOR_ASSIGN = JavaLanguageLexer.BOR_ASSIGN; 3682 /** 3683 * The <code>?</code> (conditional) operator. Technically, 3684 * the colon is also part of this operator, but it appears as a 3685 * separate token. 3686 * 3687 * <p>For example:</p> 3688 * <pre> 3689 * String variable=(quantity==1)?"true":"false"; 3690 * </pre> 3691 * 3692 * <p>parses as:</p> 3693 * <pre> 3694 * |--VARIABLE_DEF -> VARIABLE_DEF 3695 * | |--MODIFIERS -> MODIFIERS 3696 * | |--TYPE -> TYPE 3697 * | | `--IDENT -> String 3698 * | |--IDENT -> variable 3699 * | `--ASSIGN -> = 3700 * | `--EXPR -> EXPR 3701 * | `--QUESTION -> ? 3702 * | |--LPAREN -> ( 3703 * | |--EQUAL -> == 3704 * | | |--IDENT -> quantity 3705 * | | `--NUM_INT -> 1 3706 * | |--RPAREN -> ) 3707 * | |--STRING_LITERAL -> "true" 3708 * | |--COLON -> : 3709 * | `--STRING_LITERAL -> "false" 3710 * |--SEMI -> ; 3711 * </pre> 3712 * 3713 * @see <a 3714 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 3715 * Language Specification, §15.25</a> 3716 * @see #EXPR 3717 * @see #COLON 3718 * @noinspection HtmlTagCanBeJavadocTag 3719 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded 3720 * when replaced with Javadoc tag 3721 **/ 3722 public static final int QUESTION = JavaLanguageLexer.QUESTION; 3723 /** 3724 * The {@code ||} (conditional OR) operator. 3725 * 3726 * <p>For example:</p> 3727 * <pre> 3728 * if (a || b) { 3729 * } 3730 * </pre> 3731 * 3732 * <p> 3733 * parses as: 3734 * </p> 3735 * <pre> 3736 * LITERAL_IF -> if 3737 * |--LPAREN -> ( 3738 * |--EXPR -> EXPR 3739 * | `--LOR -> || 3740 * | |--IDENT -> a 3741 * | `--IDENT -> b 3742 * |--RPAREN -> ) 3743 * |--SLIST -> { 3744 * | |--RCURLY -> } 3745 * </pre> 3746 * 3747 * @see <a 3748 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java 3749 * Language Specification, §15.24</a> 3750 * @see #EXPR 3751 **/ 3752 public static final int LOR = JavaLanguageLexer.LOR; 3753 /** 3754 * The {@code &&} (conditional AND) operator. 3755 * 3756 * <p>For example:</p> 3757 * <pre> 3758 * if (a && b) { 3759 * } 3760 * </pre> 3761 * 3762 * <p>parses as:</p> 3763 * <pre> 3764 * LITERAL_IF -> if 3765 * |--LPAREN -> ( 3766 * |--EXPR -> EXPR 3767 * | `--LAND -> && 3768 * | |--IDENT -> a 3769 * | `--IDENT -> b 3770 * |--RPAREN -> ) 3771 * |--SLIST -> { 3772 * | |--RCURLY -> } 3773 * </pre> 3774 * 3775 * @see <a 3776 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 3777 * Language Specification, §15.23</a> 3778 * @see #EXPR 3779 **/ 3780 public static final int LAND = JavaLanguageLexer.LAND; 3781 /** 3782 * The {@code |} (bitwise OR) operator. 3783 * 3784 * <p>For example:</p> 3785 * <pre> 3786 * a = a | b; 3787 * </pre> 3788 * 3789 * <p>parses as:</p> 3790 * <pre> 3791 * |--EXPR -> EXPR 3792 * | `--ASSIGN -> = 3793 * | |--IDENT -> a 3794 * | `--BOR -> | 3795 * | |--IDENT -> a 3796 * | `--IDENT -> b 3797 * |--SEMI -> ; 3798 * </pre> 3799 * 3800 * @see <a 3801 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3802 * Language Specification, §15.22.1</a> 3803 * @see #EXPR 3804 **/ 3805 public static final int BOR = JavaLanguageLexer.BOR; 3806 /** 3807 * The {@code ^} (bitwise exclusive OR) operator. 3808 * 3809 * @see <a 3810 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3811 * Language Specification, §15.22.1</a> 3812 * @see #EXPR 3813 **/ 3814 public static final int BXOR = JavaLanguageLexer.BXOR; 3815 /** 3816 * The {@code &} (bitwise AND) operator. 3817 * 3818 * <p>For example:</p> 3819 * <pre> 3820 * c = a & b; 3821 * </pre> 3822 * 3823 * <p>parses as:</p> 3824 * <pre> 3825 * |--EXPR -> EXPR 3826 * | `--ASSIGN -> = 3827 * | |--IDENT -> c 3828 * | `--BAND -> & 3829 * | |--IDENT -> a 3830 * | `--IDENT -> b 3831 * |--SEMI -> ; 3832 * </pre> 3833 * 3834 * @see <a 3835 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3836 * Language Specification, §15.22.1</a> 3837 * @see #EXPR 3838 **/ 3839 public static final int BAND = JavaLanguageLexer.BAND; 3840 /** 3841 * The <code>!=</code> (not equal) operator. 3842 * 3843 * <p>For example:</p> 3844 * <pre> 3845 * a != b; 3846 * </pre> 3847 * 3848 * <p>parses as:</p> 3849 * <pre> 3850 * |--EXPR -> EXPR 3851 * | `--NOT_EQUAL -> != 3852 * | |--IDENT -> a 3853 * | `--IDENT -> b 3854 * `--SEMI -> ; 3855 * </pre> 3856 * 3857 * @see #EXPR 3858 * @noinspection HtmlTagCanBeJavadocTag 3859 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded 3860 * when replaced with Javadoc tag 3861 **/ 3862 public static final int NOT_EQUAL = JavaLanguageLexer.NOT_EQUAL; 3863 /** 3864 * The {@code ==} (equal) operator. 3865 * 3866 * <p>For example:</p> 3867 * <pre> 3868 * return a == b; 3869 * </pre> 3870 * 3871 * <p>parses as:</p> 3872 * <pre> 3873 * |--EXPR -> EXPR 3874 * | `--EQUAL -> == 3875 * | |--IDENT -> a 3876 * | `--IDENT -> b 3877 * `--SEMI -> ; 3878 * </pre> 3879 * 3880 * @see #EXPR 3881 **/ 3882 public static final int EQUAL = JavaLanguageLexer.EQUAL; 3883 /** 3884 * The {@code <} (less than) operator. 3885 * 3886 * <p>For example:</p> 3887 * <pre> 3888 * c = a < b; 3889 * </pre> 3890 * 3891 * <p>parses as:</p> 3892 * <pre> 3893 * |--EXPR -> EXPR 3894 * | `--ASSIGN -> = 3895 * | |--IDENT -> c 3896 * | `--LT -> < 3897 * | |--IDENT -> a 3898 * | `--IDENT -> b 3899 * |--SEMI -> ; 3900 * </pre> 3901 * 3902 * @see #EXPR 3903 **/ 3904 public static final int LT = JavaLanguageLexer.LT; 3905 /** 3906 * The {@code >} (greater than) operator. 3907 * 3908 * <p>For example:</p> 3909 * <pre> 3910 * c = a > b; 3911 * </pre> 3912 * 3913 * <p>parses as:</p> 3914 * <pre> 3915 * |--EXPR -> EXPR 3916 * | `--ASSIGN -> = 3917 * | |--IDENT -> c 3918 * | `--BAND -> > 3919 * | |--IDENT -> a 3920 * | `--IDENT -> b 3921 * |--SEMI -> ; 3922 * </pre> 3923 * 3924 * @see #EXPR 3925 **/ 3926 public static final int GT = JavaLanguageLexer.GT; 3927 /** 3928 * The {@code <=} (less than or equal) operator. 3929 * 3930 * <p>For example:</p> 3931 * <pre> 3932 * c = a <= b; 3933 * </pre> 3934 * 3935 * <p>parses as:</p> 3936 * <pre> 3937 * |--EXPR -> EXPR 3938 * | `--ASSIGN -> = 3939 * | |--IDENT -> c 3940 * | `--LE -> <= 3941 * | |--IDENT -> a 3942 * | `--IDENT -> b 3943 * |--SEMI -> ; 3944 * </pre> 3945 * 3946 * @see #EXPR 3947 **/ 3948 public static final int LE = JavaLanguageLexer.LE; 3949 /** 3950 * The {@code >=} (greater than or equal) operator. 3951 * 3952 * <p>For example:</p> 3953 * <pre> 3954 * boolean b = a >= 3; 3955 * </pre> 3956 * 3957 * <p>parses as:</p> 3958 * <pre> 3959 * VARIABLE_DEF -> VARIABLE_DEF 3960 * |--MODIFIERS -> MODIFIERS 3961 * |--TYPE -> TYPE 3962 * | `--LITERAL_BOOLEAN -> boolean 3963 * |--IDENT -> b 3964 * `--ASSIGN -> = 3965 * `--EXPR -> EXPR 3966 * `--GE -> >= 3967 * |--IDENT -> a 3968 * `--NUM_INT -> 3 3969 * </pre> 3970 * 3971 * @see #EXPR 3972 **/ 3973 public static final int GE = JavaLanguageLexer.GE; 3974 /** 3975 * The {@code instanceof} operator. The first child is an 3976 * object reference or something that evaluates to an object 3977 * reference. The second child is a reference type or pattern. 3978 * 3979 * <p>For example:</p> 3980 * <pre> 3981 * boolean isBuilderReferenceType = text instanceof StringBuilder; // reference type 3982 * boolean isBuilderPatternWithPattern = 3983 * text instanceof StringBuilder s; // type pattern, no `PATTERN_DEF` 3984 * boolean isBuilderEmpty = text instanceof 3985 * (StringBuilder sb && sb.isEmpty()); // guarded pattern, `PATTERN_DEF` 3986 * </pre> 3987 * 3988 * <p>parses as:</p> 3989 * <pre> 3990 * |--VARIABLE_DEF -> VARIABLE_DEF 3991 * | |--MODIFIERS -> MODIFIERS 3992 * | |--TYPE -> TYPE 3993 * | | `--LITERAL_BOOLEAN -> boolean 3994 * | |--IDENT -> isBuilderReferenceType 3995 * | `--ASSIGN -> = 3996 * | `--EXPR -> EXPR 3997 * | `--LITERAL_INSTANCEOF -> instanceof 3998 * | |--IDENT -> text 3999 * | `--TYPE -> TYPE 4000 * | `--IDENT -> StringBuilder 4001 * |--SEMI -> ; 4002 * |--VARIABLE_DEF -> VARIABLE_DEF 4003 * | |--MODIFIERS -> MODIFIERS 4004 * | |--TYPE -> TYPE 4005 * | | `--LITERAL_BOOLEAN -> boolean 4006 * | |--IDENT -> isBuilderPatternWithPattern 4007 * | `--ASSIGN -> = 4008 * | `--EXPR -> EXPR 4009 * | `--LITERAL_INSTANCEOF -> instanceof 4010 * | |--IDENT -> text 4011 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 4012 * | |--MODIFIERS -> MODIFIERS 4013 * | |--TYPE -> TYPE 4014 * | | `--IDENT -> StringBuilder 4015 * | `--IDENT -> s 4016 * |--SEMI -> ; 4017 * |--VARIABLE_DEF -> VARIABLE_DEF 4018 * | |--MODIFIERS -> MODIFIERS 4019 * | |--TYPE -> TYPE 4020 * | | `--LITERAL_BOOLEAN -> boolean 4021 * | |--IDENT -> isBuilderEmpty 4022 * | `--ASSIGN -> = 4023 * | `--EXPR -> EXPR 4024 * | `--LITERAL_INSTANCEOF -> instanceof 4025 * | |--IDENT -> text 4026 * | `--PATTERN_DEF -> PATTERN_DEF 4027 * | `--LPAREN -> ( 4028 * | |--LAND -> && 4029 * | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 4030 * | | | |--MODIFIERS -> MODIFIERS 4031 * | | | |--TYPE -> TYPE 4032 * | | | | `--IDENT -> StringBuilder 4033 * | | | `--IDENT -> sb 4034 * | | `--METHOD_CALL -> ( 4035 * | | |--DOT -> . 4036 * | | | |--IDENT -> sb 4037 * | | | `--IDENT -> isEmpty 4038 * | | |--ELIST -> ELIST 4039 * | | `--RPAREN -> ) 4040 * | `--RPAREN -> ) 4041 * `--SEMI -> ; 4042 * </pre> 4043 * 4044 * @see <a 4045 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 4046 * Language Specification, §15.20.2</a> 4047 * @see #EXPR 4048 * @see #METHOD_CALL 4049 * @see #IDENT 4050 * @see #DOT 4051 * @see #TYPE 4052 * @see #PATTERN_VARIABLE_DEF 4053 * @see #PATTERN_DEF 4054 * @see FullIdent 4055 **/ 4056 public static final int LITERAL_INSTANCEOF = 4057 JavaLanguageLexer.LITERAL_INSTANCEOF; 4058 4059 /** 4060 * The {@code <<} (shift left) operator. 4061 * 4062 * <p>For example:</p> 4063 * <pre> 4064 * a = a << b; 4065 * </pre> 4066 * 4067 * <p>parses as:</p> 4068 * <pre> 4069 * |--EXPR -> EXPR 4070 * | `--ASSIGN -> = 4071 * | |--IDENT -> a 4072 * | `--SR -> << 4073 * | |--IDENT -> a 4074 * | `--IDENT -> b 4075 * |--SEMI -> ; 4076 * </pre> 4077 * 4078 * @see <a 4079 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 4080 * Language Specification, §15.19</a> 4081 * @see #EXPR 4082 **/ 4083 public static final int SL = JavaLanguageLexer.SL; 4084 /** 4085 * The {@code >>} (signed shift right) operator. 4086 * 4087 * <p>For example:</p> 4088 * <pre> 4089 * a = a >> b; 4090 * </pre> 4091 * 4092 * <p>parses as:</p> 4093 * <pre> 4094 * |--EXPR -> EXPR 4095 * | `--ASSIGN -> = 4096 * | |--IDENT -> a 4097 * | `--SR -> >> 4098 * | |--IDENT -> a 4099 * | `--IDENT -> b 4100 * |--SEMI -> ; 4101 * </pre> 4102 * 4103 * @see <a 4104 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 4105 * Language Specification, §15.19</a> 4106 * @see #EXPR 4107 **/ 4108 public static final int SR = JavaLanguageLexer.SR; 4109 /** 4110 * The {@code >>>} (unsigned shift right) operator. 4111 * 4112 * <p>For example:</p> 4113 * <pre> 4114 * a >>> b; 4115 * </pre> 4116 * 4117 * <p>parses as:</p> 4118 * <pre> 4119 * |--EXPR -> EXPR 4120 * | `--BSR -> >>> 4121 * | |--IDENT -> a 4122 * | `--IDENT -> b 4123 * |--SEMI -> ; 4124 * </pre> 4125 * 4126 * @see <a 4127 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 4128 * Language Specification, §15.19</a> 4129 * @see #EXPR 4130 **/ 4131 public static final int BSR = JavaLanguageLexer.BSR; 4132 /** 4133 * The {@code +} (addition) operator. 4134 * 4135 * <p>For example:</p> 4136 * <pre> 4137 * c = a + b; 4138 * </pre> 4139 * 4140 * <p>parses as:</p> 4141 * <pre> 4142 * |--EXPR -> EXPR 4143 * | `--ASSIGN -> = 4144 * | |--IDENT -> c 4145 * | `--PLUS -> + 4146 * | |--IDENT -> a 4147 * | `--IDENT -> b 4148 * |--SEMI -> ; 4149 * </pre> 4150 * 4151 * @see <a 4152 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 4153 * Language Specification, §15.18</a> 4154 * @see #EXPR 4155 **/ 4156 public static final int PLUS = JavaLanguageLexer.PLUS; 4157 /** 4158 * The {@code -} (subtraction) operator. 4159 * 4160 * <p>For example:</p> 4161 * <pre> 4162 * c = a - b; 4163 * </pre> 4164 * 4165 * <p>parses as:</p> 4166 * <pre> 4167 * |--EXPR -> EXPR 4168 * | `--ASSIGN -> = 4169 * | |--IDENT -> c 4170 * | `--MINUS -> - 4171 * | |--IDENT -> a 4172 * | `--IDENT -> b 4173 * |--SEMI -> ; 4174 * </pre> 4175 * 4176 * @see <a 4177 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 4178 * Language Specification, §15.18</a> 4179 * @see #EXPR 4180 **/ 4181 public static final int MINUS = JavaLanguageLexer.MINUS; 4182 /** 4183 * The {@code /} (division) operator. 4184 * 4185 * <p>For example:</p> 4186 * <pre> 4187 * a = 4 / 2; 4188 * </pre> 4189 * 4190 * <p>parses as:</p> 4191 * <pre> 4192 * |--EXPR -> EXPR 4193 * | `--ASSIGN -> = 4194 * | |--IDENT -> a 4195 * | `--DIV -> / 4196 * | |--NUM_INT -> 4 4197 * | `--NUM_INT -> 2 4198 * |--SEMI -> ; 4199 * </pre> 4200 * 4201 * @see <a 4202 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 4203 * Language Specification, §15.17.2</a> 4204 * @see #EXPR 4205 **/ 4206 public static final int DIV = JavaLanguageLexer.DIV; 4207 /** 4208 * The {@code %} (remainder) operator. 4209 * 4210 * <p>For example:</p> 4211 * <pre> 4212 * c = a % b; 4213 * </pre> 4214 * 4215 * <p>parses as:</p> 4216 * <pre> 4217 * EXPR -> EXPR 4218 * `--ASSIGN -> = 4219 * |--IDENT -> c 4220 * `--MOD -> % 4221 * |--IDENT -> a 4222 * `--IDENT -> b 4223 * SEMI -> ; 4224 * </pre> 4225 * 4226 * @see <a 4227 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 4228 * Language Specification, §15.17.3</a> 4229 * @see #EXPR 4230 **/ 4231 public static final int MOD = JavaLanguageLexer.MOD; 4232 /** 4233 * The {@code ++} (prefix increment) operator. 4234 * 4235 * <p>For example:</p> 4236 * <pre> 4237 * ++a; 4238 * </pre> 4239 * 4240 * <p>parses as:</p> 4241 * <pre> 4242 * |--EXPR -> EXPR 4243 * | `--INC -> ++ 4244 * | `--IDENT -> a 4245 * |--SEMI -> ; 4246 * </pre> 4247 * 4248 * @see <a 4249 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 4250 * Language Specification, §15.15.1</a> 4251 * @see #EXPR 4252 * @see #POST_INC 4253 **/ 4254 public static final int INC = JavaLanguageLexer.INC; 4255 /** 4256 * The {@code --} (prefix decrement) operator. 4257 * 4258 * <p>For example:</p> 4259 * <pre> 4260 * --a; 4261 * </pre> 4262 * 4263 * <p>parses as:</p> 4264 * <pre> 4265 * |--EXPR -> EXPR 4266 * | `--DEC -> -- 4267 * | `--IDENT -> a 4268 * |--SEMI -> ; 4269 * </pre> 4270 * 4271 * @see <a 4272 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 4273 * Language Specification, §15.15.2</a> 4274 * @see #EXPR 4275 * @see #POST_DEC 4276 **/ 4277 public static final int DEC = JavaLanguageLexer.DEC; 4278 /** 4279 * The {@code ~} (bitwise complement) operator. 4280 * 4281 * <p>For example:</p> 4282 * <pre> 4283 * a = ~ a; 4284 * </pre> 4285 * 4286 * <p>parses as:</p> 4287 * <pre> 4288 * |--EXPR -> EXPR 4289 * | `--ASSIGN -> = 4290 * | |--IDENT -> a 4291 * | `--BNOT -> ~ 4292 * | `--IDENT -> a 4293 * |--SEMI -> ; 4294 * </pre> 4295 * 4296 * @see <a 4297 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 4298 * Language Specification, §15.15.5</a> 4299 * @see #EXPR 4300 **/ 4301 public static final int BNOT = JavaLanguageLexer.BNOT; 4302 /** 4303 * The <code>!</code> (logical complement) operator. 4304 * 4305 * <p>For example:</p> 4306 * <pre> 4307 * c = ! a; 4308 * </pre> 4309 * 4310 * <p>parses as:</p> 4311 * <pre> 4312 * |--EXPR -> EXPR 4313 * | `--ASSIGN -> = 4314 * | |--IDENT -> c 4315 * | `--LNOT -> ! 4316 * | `--IDENT -> a 4317 * |--SEMI -> ; 4318 * </pre> 4319 * 4320 * @see <a 4321 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 4322 * Language Specification, §15.15.6</a> 4323 * @see #EXPR 4324 * @noinspection HtmlTagCanBeJavadocTag 4325 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded 4326 * when replaced with Javadoc tag 4327 **/ 4328 public static final int LNOT = JavaLanguageLexer.LNOT; 4329 /** 4330 * The {@code true} keyword. 4331 * 4332 * <p>For example:</p> 4333 * <pre> 4334 * boolean a = true; 4335 * </pre> 4336 * 4337 * <p>parses as:</p> 4338 * <pre> 4339 * |--VARIABLE_DEF -> VARIABLE_DEF 4340 * | |--MODIFIERS -> MODIFIERS 4341 * | |--TYPE -> TYPE 4342 * | | `--LITERAL_BOOLEAN -> boolean 4343 * | |--IDENT -> a 4344 * | `--ASSIGN -> = 4345 * | `--EXPR -> EXPR 4346 * | `--LITERAL_TRUE -> true 4347 * |--SEMI -> ; 4348 * </pre> 4349 * 4350 * @see <a 4351 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 4352 * Language Specification, §3.10.3</a> 4353 * @see #EXPR 4354 * @see #LITERAL_FALSE 4355 **/ 4356 public static final int LITERAL_TRUE = 4357 JavaLanguageLexer.LITERAL_TRUE; 4358 4359 /** 4360 * The {@code false} keyword. 4361 * 4362 * <p>For example:</p> 4363 * <pre> 4364 * boolean a = false; 4365 * </pre> 4366 * 4367 * <p>parses as:</p> 4368 * <pre> 4369 * VARIABLE_DEF -> VARIABLE_DEF 4370 * |--MODIFIERS -> MODIFIERS 4371 * |--TYPE -> TYPE 4372 * | `--LITERAL_BOOLEAN -> boolean 4373 * |--IDENT -> a 4374 * |--ASSIGN -> = 4375 * | `--EXPR -> EXPR 4376 * | `--LITERAL_FALSE -> false 4377 * `--SEMI -> ; 4378 * </pre> 4379 * 4380 * @see <a 4381 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 4382 * Language Specification, §3.10.3</a> 4383 * @see #EXPR 4384 * @see #LITERAL_TRUE 4385 **/ 4386 public static final int LITERAL_FALSE = 4387 JavaLanguageLexer.LITERAL_FALSE; 4388 4389 /** 4390 * The {@code null} keyword. 4391 * 4392 * <p>For example:</p> 4393 * <pre> 4394 * String s = null; 4395 * </pre> 4396 * 4397 * <p>parses as:</p> 4398 * <pre> 4399 * VARIABLE_DEF -> VARIABLE_DEF 4400 * |--MODIFIERS -> MODIFIERS 4401 * |--TYPE -> TYPE 4402 * | `--IDENT -> String 4403 * |--IDENT -> s 4404 * |--ASSIGN -> = 4405 * | `--EXPR -> EXPR 4406 * | `--LITERAL_NULL -> null 4407 * `--SEMI -> ; 4408 * </pre> 4409 * 4410 * @see <a 4411 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 4412 * Language Specification, §3.10.7</a> 4413 * @see #EXPR 4414 **/ 4415 public static final int LITERAL_NULL = 4416 JavaLanguageLexer.LITERAL_NULL; 4417 4418 /** 4419 * The {@code new} keyword. This element is used to define 4420 * new instances of objects, new arrays, and new anonymous inner 4421 * classes. 4422 * 4423 * <p>For example:</p> 4424 * 4425 * <pre> 4426 * List<String> l = new ArrayList<String>(); 4427 * </pre> 4428 * 4429 * <p>parses as:</p> 4430 * <pre> 4431 * VARIABLE_DEF -> VARIABLE_DEF 4432 * |--MODIFIERS -> MODIFIERS 4433 * |--TYPE -> TYPE 4434 * | |--IDENT -> List 4435 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4436 * | |--GENERIC_START -> < 4437 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4438 * | | `--IDENT -> String 4439 * | `--GENERIC_END -> > 4440 * |--IDENT -> l 4441 * |--ASSIGN -> = 4442 * | `--EXPR -> EXPR 4443 * | `--LITERAL_NEW -> new 4444 * | |--IDENT -> ArrayList 4445 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4446 * | | |--GENERIC_START -> < 4447 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4448 * | | | `--IDENT -> String 4449 * | | `--GENERIC_END -> > 4450 * | |--LPAREN -> ( 4451 * | |--ELIST -> ELIST 4452 * | `--RPAREN -> ) 4453 * `--SEMI -> ; 4454 * </pre> 4455 * 4456 * <p>For example:</p> 4457 * <pre> 4458 * String[] strings = new String[3]; 4459 * </pre> 4460 * 4461 * <p>parses as:</p> 4462 * <pre> 4463 * VARIABLE_DEF -> VARIABLE_DEF 4464 * |--MODIFIERS -> MODIFIERS 4465 * |--TYPE -> TYPE 4466 * | |--IDENT -> String 4467 * | `--ARRAY_DECLARATOR -> [ 4468 * | `--RBRACK -> ] 4469 * |--IDENT -> strings 4470 * |--ASSIGN -> = 4471 * | `--EXPR -> EXPR 4472 * | `--LITERAL_NEW -> new 4473 * | |--IDENT -> String 4474 * | `--ARRAY_DECLARATOR -> [ 4475 * | |--EXPR -> EXPR 4476 * | | `--NUM_INT -> 3 4477 * | `--RBRACK -> ] 4478 * `--SEMI -> ; 4479 * </pre> 4480 * 4481 * <p>For example:</p> 4482 * <pre> 4483 * Supplier<Integer> s = new Supplier<>() { 4484 * @Override 4485 * public Integer get() { 4486 * return 42; 4487 * } 4488 * }; 4489 * </pre> 4490 * 4491 * <p>parses as:</p> 4492 * <pre> 4493 * VARIABLE_DEF -> VARIABLE_DEF 4494 * |--MODIFIERS -> MODIFIERS 4495 * |--TYPE -> TYPE 4496 * | |--IDENT -> Supplier 4497 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4498 * | |--GENERIC_START -> < 4499 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 4500 * | | `--IDENT -> Integer 4501 * | `--GENERIC_END -> > 4502 * |--IDENT -> s 4503 * |--ASSIGN -> = 4504 * | `--EXPR -> EXPR 4505 * | `--LITERAL_NEW -> new 4506 * | |--IDENT -> Supplier 4507 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4508 * | | |--GENERIC_START -> < 4509 * | | `--GENERIC_END -> > 4510 * | |--LPAREN -> ( 4511 * | |--ELIST -> ELIST 4512 * | |--RPAREN -> ) 4513 * | `--OBJBLOCK -> OBJBLOCK 4514 * | |--LCURLY -> { 4515 * | |--METHOD_DEF -> METHOD_DEF 4516 * | | |--MODIFIERS -> MODIFIERS 4517 * | | | |--ANNOTATION -> ANNOTATION 4518 * | | | | |--AT -> @ 4519 * | | | | `--IDENT -> Override 4520 * | | | `--LITERAL_PUBLIC -> public 4521 * | | |--TYPE -> TYPE 4522 * | | | `--IDENT -> Integer 4523 * | | |--IDENT -> get 4524 * | | |--LPAREN -> ( 4525 * | | |--PARAMETERS -> PARAMETERS 4526 * | | |--RPAREN -> ) 4527 * | | `--SLIST -> { 4528 * | | |--LITERAL_RETURN -> return 4529 * | | | |--EXPR -> EXPR 4530 * | | | | `--NUM_INT -> 42 4531 * | | | `--SEMI -> ; 4532 * | | `--RCURLY -> } 4533 * | `--RCURLY -> } 4534 * `--SEMI -> ; 4535 * </pre> 4536 * 4537 * @see #IDENT 4538 * @see #DOT 4539 * @see #LPAREN 4540 * @see #ELIST 4541 * @see #RPAREN 4542 * @see #OBJBLOCK 4543 * @see #ARRAY_INIT 4544 * @see FullIdent 4545 **/ 4546 public static final int LITERAL_NEW = JavaLanguageLexer.LITERAL_NEW; 4547 /** 4548 * An integer literal. These may be specified in decimal, 4549 * hexadecimal, or octal form. 4550 * 4551 * <p>For example:</p> 4552 * <pre> 4553 * a = 3; 4554 * </pre> 4555 * 4556 * <p>parses as:</p> 4557 * <pre> 4558 * |--EXPR -> EXPR 4559 * | `--ASSIGN -> = 4560 * | |--IDENT -> a 4561 * | `--NUM_INT -> 3 4562 * |--SEMI -> ; 4563 * </pre> 4564 * 4565 * @see <a 4566 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 4567 * Language Specification, §3.10.1</a> 4568 * @see #EXPR 4569 * @see #NUM_LONG 4570 **/ 4571 public static final int NUM_INT = JavaLanguageLexer.NUM_INT; 4572 /** 4573 * A character literal. This is a (possibly escaped) character 4574 * enclosed in single quotes. 4575 * 4576 * <p>For example:</p> 4577 * <pre> 4578 * return 'a'; 4579 * </pre> 4580 * 4581 * <p>parses as:</p> 4582 * <pre> 4583 * --LITERAL_RETURN -> return 4584 * |--EXPR -> EXPR 4585 * | `--CHAR_LITERAL -> 'a' 4586 * `--SEMI -> ; 4587 * </pre> 4588 * 4589 * @see <a 4590 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 4591 * Language Specification, §3.10.4</a> 4592 * @see #EXPR 4593 **/ 4594 public static final int CHAR_LITERAL = 4595 JavaLanguageLexer.CHAR_LITERAL; 4596 4597 /** 4598 * A string literal. This is a sequence of (possibly escaped) 4599 * characters enclosed in double quotes. 4600 * 4601 * <p>For example:</p> 4602 * <pre>String str = "StringLiteral";</pre> 4603 * 4604 * <p>parses as:</p> 4605 * <pre> 4606 * |--VARIABLE_DEF -> VARIABLE_DEF 4607 * | |--MODIFIERS -> MODIFIERS 4608 * | |--TYPE -> TYPE 4609 * | | `--IDENT -> String 4610 * | |--IDENT -> str 4611 * | `--ASSIGN -> = 4612 * | `--EXPR -> EXPR 4613 * | `--STRING_LITERAL -> "StringLiteral" 4614 * |--SEMI -> ; 4615 * </pre> 4616 * 4617 * @see <a 4618 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 4619 * Language Specification, §3.10.5</a> 4620 * @see #EXPR 4621 **/ 4622 public static final int STRING_LITERAL = 4623 JavaLanguageLexer.STRING_LITERAL; 4624 4625 /** 4626 * A single precision floating point literal. This is a floating 4627 * point number with an {@code F} or {@code f} suffix. 4628 * 4629 * <p>For example:</p> 4630 * <pre> 4631 * a = 3.14f; 4632 * </pre> 4633 * 4634 * <p>parses as:</p> 4635 * <pre> 4636 * |--EXPR -> EXPR 4637 * | `--ASSIGN -> = 4638 * | |--IDENT -> a 4639 * | `--NUM_FLOAT -> 3.14f 4640 * |--SEMI -> ; 4641 * </pre> 4642 * 4643 * @see <a 4644 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 4645 * Language Specification, §3.10.2</a> 4646 * @see #EXPR 4647 * @see #NUM_DOUBLE 4648 **/ 4649 public static final int NUM_FLOAT = JavaLanguageLexer.NUM_FLOAT; 4650 /** 4651 * A long integer literal. These are almost the same as integer 4652 * literals, but they have an {@code L} or {@code l} 4653 * (ell) suffix. 4654 * 4655 * <p>For example:</p> 4656 * <pre> 4657 * a = 3l; 4658 * </pre> 4659 * 4660 * <p>parses as:</p> 4661 * <pre> 4662 * |--EXPR -> EXPR 4663 * | `--ASSIGN -> = 4664 * | |--IDENT -> a 4665 * | `--NUM_LONG -> 3l 4666 * |--SEMI -> ; 4667 * </pre> 4668 * 4669 * @see <a 4670 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 4671 * Language Specification, §3.10.1</a> 4672 * @see #EXPR 4673 * @see #NUM_INT 4674 **/ 4675 public static final int NUM_LONG = JavaLanguageLexer.NUM_LONG; 4676 /** 4677 * A double precision floating point literal. This is a floating 4678 * point number with an optional {@code D} or {@code d} 4679 * suffix. 4680 * 4681 * <p>For example:</p> 4682 * <pre> 4683 * a = 3.14d; 4684 * </pre> 4685 * 4686 * <p>parses as:</p> 4687 * <pre> 4688 * |--EXPR -> EXPR 4689 * | `--ASSIGN -> = 4690 * | |--IDENT -> a 4691 * | `--NUM_DOUBLE -> 3.14d 4692 * |--SEMI -> ; 4693 * </pre> 4694 * 4695 * @see <a 4696 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 4697 * Language Specification, §3.10.2</a> 4698 * @see #EXPR 4699 * @see #NUM_FLOAT 4700 **/ 4701 public static final int NUM_DOUBLE = JavaLanguageLexer.NUM_DOUBLE; 4702 4703 /** 4704 * The {@code assert} keyword. This is only for Java 1.4 and 4705 * later. 4706 * 4707 * <p>For example:</p> 4708 * <pre> 4709 * assert(x==4); 4710 * </pre> 4711 * 4712 * <p>parses as:</p> 4713 * <pre> 4714 * LITERAL_ASSERT -> assert 4715 * |--EXPR -> EXPR 4716 * | |--LPAREN -> ( 4717 * | |--EQUAL -> == 4718 * | | |--IDENT -> x 4719 * | | `--NUM_INT -> 4 4720 * | `--RPAREN -> ) 4721 * `--SEMI -> ; 4722 * </pre> 4723 **/ 4724 public static final int LITERAL_ASSERT = JavaLanguageLexer.ASSERT; 4725 4726 /** 4727 * A static import declaration. Static import declarations are optional, 4728 * but must appear after the package declaration and before the type 4729 * declaration. 4730 * 4731 * <p>For example:</p> 4732 * <pre> 4733 * import static java.io.IOException; 4734 * </pre> 4735 * 4736 * <p>parses as:</p> 4737 * <pre> 4738 * STATIC_IMPORT -> import 4739 * |--LITERAL_STATIC -> static 4740 * |--DOT -> . 4741 * | |--DOT -> . 4742 * | | |--IDENT -> java 4743 * | | `--IDENT -> io 4744 * | `--IDENT -> IOException 4745 * `--SEMI -> ; 4746 * </pre> 4747 * 4748 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4749 * JSR201</a> 4750 * @see #LITERAL_STATIC 4751 * @see #DOT 4752 * @see #IDENT 4753 * @see #STAR 4754 * @see #SEMI 4755 * @see FullIdent 4756 **/ 4757 public static final int STATIC_IMPORT = 4758 JavaLanguageLexer.STATIC_IMPORT; 4759 4760 /** 4761 * An enum declaration. Its notable children are 4762 * enum constant declarations followed by 4763 * any construct that may be expected in a class body. 4764 * 4765 * <p>For example:</p> 4766 * <pre> 4767 * public enum MyEnum 4768 * implements Serializable 4769 * { 4770 * FIRST_CONSTANT, 4771 * SECOND_CONSTANT; 4772 * 4773 * public void someMethod() 4774 * { 4775 * } 4776 * } 4777 * </pre> 4778 * 4779 * <p>parses as:</p> 4780 * <pre> 4781 * ENUM_DEF -> ENUM_DEF 4782 * |--MODIFIERS -> MODIFIERS 4783 * | `--LITERAL_PUBLIC -> public 4784 * |--ENUM -> enum 4785 * |--IDENT -> MyEnum 4786 * |--IMPLEMENTS_CLAUSE -> implements 4787 * | `--IDENT -> Serializable 4788 * `--OBJBLOCK -> OBJBLOCK 4789 * |--LCURLY -> { 4790 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF 4791 * | |--ANNOTATIONS -> ANNOTATIONS 4792 * | `--IDENT -> FIRST_CONSTANT 4793 * |--COMMA -> , 4794 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF 4795 * | |--ANNOTATIONS -> ANNOTATIONS 4796 * | `--IDENT -> SECOND_CONSTANT 4797 * |--SEMI -> ; 4798 * |--METHOD_DEF -> METHOD_DEF 4799 * | |--MODIFIERS -> MODIFIERS 4800 * | | `--LITERAL_PUBLIC -> public 4801 * | |--TYPE -> TYPE 4802 * | | `--LITERAL_VOID -> void 4803 * | |--IDENT -> someMethod 4804 * | |--LPAREN -> ( 4805 * | |--PARAMETERS -> PARAMETERS 4806 * | |--RPAREN -> ) 4807 * | `--SLIST -> { 4808 * | `--RCURLY -> } 4809 * `--RCURLY -> } 4810 * </pre> 4811 * 4812 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4813 * JSR201</a> 4814 * @see #MODIFIERS 4815 * @see #ENUM 4816 * @see #IDENT 4817 * @see #EXTENDS_CLAUSE 4818 * @see #IMPLEMENTS_CLAUSE 4819 * @see #OBJBLOCK 4820 * @see #LITERAL_NEW 4821 * @see #ENUM_CONSTANT_DEF 4822 **/ 4823 public static final int ENUM_DEF = 4824 JavaLanguageLexer.ENUM_DEF; 4825 4826 /** 4827 * The {@code enum} keyword. This element appears 4828 * as part of an enum declaration. 4829 * 4830 * <p>For example:</p> 4831 * <pre> 4832 * public enum Count {} 4833 * </pre> 4834 * 4835 * <p>parses as:</p> 4836 * <pre> 4837 * ENUM_DEF -> ENUM_DEF 4838 * |--MODIFIERS -> MODIFIERS 4839 * | `--LITERAL_PUBLIC -> public 4840 * |--ENUM -> enum 4841 * |--IDENT -> Count 4842 * `--OBJBLOCK -> OBJBLOCK 4843 * |--LCURLY -> { 4844 * `--RCURLY -> } 4845 * </pre> 4846 * 4847 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">JSR201</a> 4848 * @see #MODIFIERS 4849 * @see #ENUM_DEF 4850 * @see #IDENT 4851 * @see #OBJBLOCK 4852 **/ 4853 public static final int ENUM = 4854 JavaLanguageLexer.ENUM; 4855 4856 /** 4857 * An enum constant declaration. Its notable children are annotations, 4858 * arguments and object block akin to an anonymous 4859 * inner class' body. 4860 * 4861 * <p>For example:</p> 4862 * <pre> 4863 * SOME_CONSTANT(1) 4864 * { 4865 * public void someMethodOverriddenFromMainBody() 4866 * { 4867 * } 4868 * } 4869 * </pre> 4870 * 4871 * <p>parses as:</p> 4872 * <pre> 4873 * ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF 4874 * | |--ANNOTATIONS -> ANNOTATIONS 4875 * | |--IDENT -> SOME_CONSTANT 4876 * | |--LPAREN -> ( 4877 * | |--ELIST -> ELIST 4878 * | | `--EXPR -> EXPR 4879 * | | `--NUM_INT -> 1 4880 * | |--RPAREN -> ) 4881 * | `--OBJBLOCK -> OBJBLOCK 4882 * | |--LCURLY -> { 4883 * | |--METHOD_DEF -> METHOD_DEF 4884 * | | |--MODIFIERS -> MODIFIERS 4885 * | | | `--LITERAL_PUBLIC -> public 4886 * | | |--TYPE -> TYPE 4887 * | | | `--LITERAL_VOID -> void 4888 * | | |--IDENT -> someMethodOverriddenFromMainBody 4889 * | | |--LPAREN -> ( 4890 * | | |--PARAMETERS -> PARAMETERS 4891 * | | |--RPAREN -> ) 4892 * | | `--SLIST -> { 4893 * | | `--RCURLY -> } 4894 * | `--RCURLY -> } 4895 * </pre> 4896 * 4897 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4898 * JSR201</a> 4899 * @see #ANNOTATIONS 4900 * @see #MODIFIERS 4901 * @see #IDENT 4902 * @see #ELIST 4903 * @see #OBJBLOCK 4904 **/ 4905 public static final int ENUM_CONSTANT_DEF = 4906 JavaLanguageLexer.ENUM_CONSTANT_DEF; 4907 4908 /** 4909 * A for-each clause. This is a child of 4910 * {@code LITERAL_FOR}. The children of this element may be 4911 * a parameter definition, the colon literal and an expression. 4912 * 4913 * <p>For example:</p> 4914 * <pre> 4915 * for (int value : values) { 4916 * doSmth(); 4917 * } 4918 * </pre> 4919 * 4920 * <p>parses as:</p> 4921 * <pre> 4922 * LITERAL_FOR -> for 4923 * |--LPAREN -> ( 4924 * |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE 4925 * | |--VARIABLE_DEF -> VARIABLE_DEF 4926 * | | |--MODIFIERS -> MODIFIERS 4927 * | | |--TYPE -> TYPE 4928 * | | | `--LITERAL_INT -> int 4929 * | | `--IDENT -> value 4930 * | |--COLON -> : 4931 * | `--EXPR -> EXPR 4932 * | `--IDENT -> values 4933 * |--RPAREN -> ) 4934 * `--SLIST -> { 4935 * |--EXPR -> EXPR 4936 * | `--METHOD_CALL -> ( 4937 * | |--IDENT -> doSmth 4938 * | |--ELIST -> ELIST 4939 * | `--RPAREN -> ) 4940 * |--SEMI -> ; 4941 * `--RCURLY -> } 4942 * </pre> 4943 * 4944 * @see #VARIABLE_DEF 4945 * @see #ELIST 4946 * @see #LITERAL_FOR 4947 **/ 4948 public static final int FOR_EACH_CLAUSE = 4949 JavaLanguageLexer.FOR_EACH_CLAUSE; 4950 4951 /** 4952 * An annotation declaration. The notable children are the name of the 4953 * annotation type, annotation field declarations and (constant) fields. 4954 * 4955 * <p>For example:</p> 4956 * <pre> 4957 * public @interface MyAnnotation 4958 * { 4959 * int someValue(); 4960 * } 4961 * </pre> 4962 * 4963 * <p>parses as:</p> 4964 * <pre> 4965 * ANNOTATION_DEF -> ANNOTATION_DEF 4966 * |--MODIFIERS -> MODIFIERS 4967 * | `--LITERAL_PUBLIC -> public 4968 * |--AT -> @ 4969 * |--LITERAL_INTERFACE -> interface 4970 * |--IDENT -> MyAnnotation 4971 * `--OBJBLOCK -> OBJBLOCK 4972 * |--LCURLY -> { 4973 * |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF 4974 * | |--MODIFIERS -> MODIFIERS 4975 * | |--TYPE -> TYPE 4976 * | | `--LITERAL_INT -> int 4977 * | |--IDENT -> someValue 4978 * | |--LPAREN -> ( 4979 * | |--RPAREN -> ) 4980 * | `--SEMI -> ; 4981 * `--RCURLY -> } 4982 * </pre> 4983 * 4984 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4985 * JSR201</a> 4986 * @see #MODIFIERS 4987 * @see #LITERAL_INTERFACE 4988 * @see #IDENT 4989 * @see #OBJBLOCK 4990 * @see #ANNOTATION_FIELD_DEF 4991 **/ 4992 public static final int ANNOTATION_DEF = 4993 JavaLanguageLexer.ANNOTATION_DEF; 4994 4995 /** 4996 * An annotation field declaration. The notable children are modifiers, 4997 * field type, field name and an optional default value (a conditional 4998 * compile-time constant expression). Default values may also be 4999 * annotations. 5000 * 5001 * <p>For example:</p> 5002 * 5003 * <pre> 5004 * String someField() default "Hello world"; 5005 * </pre> 5006 * 5007 * <p>parses as:</p> 5008 * 5009 * <pre> 5010 * ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF 5011 * |--MODIFIERS -> MODIFIERS 5012 * |--TYPE -> TYPE 5013 * | `--IDENT -> String 5014 * |--IDENT -> someField 5015 * |--LPAREN -> ( 5016 * |--RPAREN -> ) 5017 * |--LITERAL_DEFAULT -> default 5018 * | `--EXPR -> EXPR 5019 * | `--STRING_LITERAL -> "Hello world" 5020 * `--SEMI -> ; 5021 * </pre> 5022 * 5023 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5024 * JSR201</a> 5025 * @see #MODIFIERS 5026 * @see #TYPE 5027 * @see #LITERAL_DEFAULT 5028 */ 5029 public static final int ANNOTATION_FIELD_DEF = 5030 JavaLanguageLexer.ANNOTATION_FIELD_DEF; 5031 5032 // note: @ is the html escape for '@', 5033 // used here to avoid confusing the javadoc tool 5034 /** 5035 * A collection of annotations on a package or enum constant. 5036 * A collections of annotations will only occur on these nodes 5037 * as all other nodes that may be qualified with an annotation can 5038 * be qualified with any other modifier and hence these annotations 5039 * would be contained in a {@link #MODIFIERS} node. 5040 * 5041 * <p>For example:</p> 5042 * 5043 * <pre> 5044 * @MyAnnotation package blah; 5045 * </pre> 5046 * 5047 * <p>parses as:</p> 5048 * 5049 * <pre> 5050 * PACKAGE_DEF -> package 5051 * |--ANNOTATIONS -> ANNOTATIONS 5052 * | `--ANNOTATION -> ANNOTATION 5053 * | |--AT -> @ 5054 * | `--IDENT -> MyAnnotation 5055 * |--IDENT -> blah 5056 * `--SEMI -> ; 5057 * </pre> 5058 * 5059 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5060 * JSR201</a> 5061 * @see #ANNOTATION 5062 * @see #AT 5063 * @see #IDENT 5064 */ 5065 public static final int ANNOTATIONS = 5066 JavaLanguageLexer.ANNOTATIONS; 5067 5068 // note: @ is the html escape for '@', 5069 // used here to avoid confusing the javadoc tool 5070 /** 5071 * An annotation of a package, type, field, parameter or variable. 5072 * An annotation may occur anywhere modifiers occur (it is a 5073 * type of modifier) and may also occur prior to a package definition. 5074 * The notable children are: The annotation name and either a single 5075 * default annotation value or a sequence of name value pairs. 5076 * Annotation values may also be annotations themselves. 5077 * 5078 * <p>For example:</p> 5079 * <pre> 5080 * @MyAnnotation(someField1 = "Hello", 5081 * someField2 = @SomeOtherAnnotation) 5082 * </pre> 5083 * 5084 * <p>parses as:</p> 5085 * <pre> 5086 * ANNOTATION -> ANNOTATION 5087 * |--AT -> @ 5088 * |--IDENT -> MyAnnotation 5089 * |--LPAREN -> ( 5090 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR 5091 * | |--IDENT -> someField1 5092 * | |--ASSIGN -> = 5093 * | `--EXPR -> EXPR 5094 * | `--STRING_LITERAL -> "Hello" 5095 * |--COMMA -> , 5096 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR 5097 * | |--IDENT -> someField2 5098 * | |--ASSIGN -> = 5099 * | `--ANNOTATION -> ANNOTATION 5100 * | |--AT -> @ 5101 * | `--IDENT -> SomeOtherAnnotation 5102 * `--RPAREN -> ) 5103 * </pre> 5104 * 5105 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5106 * JSR201</a> 5107 * @see #MODIFIERS 5108 * @see #IDENT 5109 * @see #ANNOTATION_MEMBER_VALUE_PAIR 5110 */ 5111 public static final int ANNOTATION = 5112 JavaLanguageLexer.ANNOTATION; 5113 5114 /** 5115 * An initialization of an annotation member with a value. 5116 * Its children are the name of the member, the assignment literal 5117 * and the (compile-time constant conditional expression) value. 5118 * 5119 * <p>For example:</p> 5120 * <pre> 5121 * @Annotation( 5122 * value="123" 5123 * ) 5124 * </pre> 5125 * 5126 * <p>parses as:</p> 5127 * <pre> 5128 * ANNOTATION -> ANNOTATION 5129 * |--AT -> @ 5130 * |--IDENT -> Annotation 5131 * |--LPAREN -> ( 5132 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR 5133 * | |--IDENT -> value 5134 * | |--ASSIGN -> = 5135 * | `--EXPR -> EXPR 5136 * | `--STRING_LITERAL -> "123" 5137 * `--RPAREN -> ) 5138 * </pre> 5139 * 5140 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5141 * JSR201</a> 5142 * @see #ANNOTATION 5143 * @see #IDENT 5144 */ 5145 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 5146 JavaLanguageLexer.ANNOTATION_MEMBER_VALUE_PAIR; 5147 5148 /** 5149 * An annotation array member initialization. 5150 * Initializers can not be nested. 5151 * An initializer may be present as a default to an annotation 5152 * member, as the single default value to an annotation 5153 * (e.g. @Annotation({1,2})) or as the value of an annotation 5154 * member value pair. 5155 * 5156 * <p>For example:</p> 5157 * <pre> 5158 * @Annotation({1, 2}) 5159 * </pre> 5160 * 5161 * <p>parses as:</p> 5162 * <pre> 5163 * ANNOTATION -> ANNOTATION 5164 * |--AT -> @ 5165 * |--IDENT -> Annotation 5166 * |--LPAREN -> ( 5167 * |--ANNOTATION_ARRAY_INIT -> { 5168 * | |--EXPR -> EXPR 5169 * | | `--NUM_INT -> 1 5170 * | |--COMMA -> , 5171 * | |--EXPR -> EXPR 5172 * | | `--NUM_INT -> 2 5173 * | `--RCURLY -> } 5174 * `--RPAREN -> ) 5175 * </pre> 5176 * 5177 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5178 * JSR201</a> 5179 * @see #ANNOTATION 5180 * @see #IDENT 5181 * @see #ANNOTATION_MEMBER_VALUE_PAIR 5182 */ 5183 public static final int ANNOTATION_ARRAY_INIT = 5184 JavaLanguageLexer.ANNOTATION_ARRAY_INIT; 5185 5186 /** 5187 * A list of type parameters to a class, interface or 5188 * method definition. Children are LT, at least one 5189 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 5190 * TYPE_PARAMETER and a final GT. 5191 * 5192 * <p>For example:</p> 5193 * 5194 * <pre> 5195 * public class MyClass<A, B> { 5196 * 5197 * } 5198 * </pre> 5199 * 5200 * <p>parses as:</p> 5201 * 5202 * <pre> 5203 * CLASS_DEF -> CLASS_DEF 5204 * |--MODIFIERS -> MODIFIERS 5205 * | `--LITERAL_PUBLIC -> public 5206 * |--LITERAL_CLASS -> class 5207 * |--IDENT -> MyClass 5208 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5209 * | |--GENERIC_START -> < 5210 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5211 * | | `--IDENT -> A 5212 * | |--COMMA -> , 5213 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5214 * | | `--IDENT -> B 5215 * | `--GENERIC_END -> > 5216 * `--OBJBLOCK -> OBJBLOCK 5217 * |--LCURLY -> { 5218 * `--RCURLY -> } 5219 * </pre> 5220 * 5221 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5222 * Generic Classes and Type Parameters</a> 5223 * @see #GENERIC_START 5224 * @see #GENERIC_END 5225 * @see #TYPE_PARAMETER 5226 * @see #COMMA 5227 */ 5228 public static final int TYPE_PARAMETERS = 5229 JavaLanguageLexer.TYPE_PARAMETERS; 5230 5231 /** 5232 * A type parameter to a class, interface or method definition. 5233 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 5234 * 5235 * <p>For example:</p> 5236 * 5237 * <pre> 5238 * public class MyClass <A extends Collection> { 5239 * 5240 * } 5241 * </pre> 5242 * 5243 * <p>parses as:</p> 5244 * 5245 * <pre> 5246 * CLASS_DEF -> CLASS_DEF 5247 * |--MODIFIERS -> MODIFIERS 5248 * | `--LITERAL_PUBLIC -> public 5249 * |--LITERAL_CLASS -> class 5250 * |--IDENT -> MyClass 5251 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5252 * | |--GENERIC_START -> < 5253 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5254 * | | |--IDENT -> A 5255 * | | `--TYPE_UPPER_BOUNDS -> extends 5256 * | | `--IDENT -> Collection 5257 * | `--GENERIC_END -> > 5258 * `--OBJBLOCK -> OBJBLOCK 5259 * |--LCURLY -> { 5260 * `--RCURLY -> } 5261 * </pre> 5262 * 5263 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5264 * Generic Classes and Type Parameters</a> 5265 * @see #IDENT 5266 * @see #WILDCARD_TYPE 5267 * @see #TYPE_UPPER_BOUNDS 5268 */ 5269 public static final int TYPE_PARAMETER = 5270 JavaLanguageLexer.TYPE_PARAMETER; 5271 5272 /** 5273 * A list of type arguments to a type reference or 5274 * a method/ctor invocation. Children are GENERIC_START, at least one 5275 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 5276 * TYPE_ARGUMENT, and a final GENERIC_END. 5277 * 5278 * <p>For example:</p> 5279 * 5280 * <pre> 5281 * public Collection<?> a; 5282 * </pre> 5283 * 5284 * <p>parses as:</p> 5285 * 5286 * <pre> 5287 * VARIABLE_DEF -> VARIABLE_DEF 5288 * |--MODIFIERS -> MODIFIERS 5289 * | `--LITERAL_PUBLIC -> public 5290 * |--TYPE -> TYPE 5291 * | |--IDENT -> Collection 5292 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5293 * | |--GENERIC_START -> < 5294 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5295 * | | `--WILDCARD_TYPE -> ? 5296 * | `--GENERIC_END -> > 5297 * |--IDENT -> a 5298 * `--SEMI -> ; 5299 * </pre> 5300 * 5301 * @see #GENERIC_START 5302 * @see #GENERIC_END 5303 * @see #TYPE_ARGUMENT 5304 * @see #COMMA 5305 */ 5306 public static final int TYPE_ARGUMENTS = 5307 JavaLanguageLexer.TYPE_ARGUMENTS; 5308 5309 /** 5310 * A type arguments to a type reference or a method/ctor invocation. 5311 * Children are either: type name or wildcard type with possible type 5312 * upper or lower bounds. 5313 * 5314 * <p>For example:</p> 5315 * <pre>List<? super List> list;</pre> 5316 * 5317 * <p>parses as:</p> 5318 * <pre> 5319 * VARIABLE_DEF -> VARIABLE_DEF 5320 * |--MODIFIERS -> MODIFIERS 5321 * |--TYPE -> TYPE 5322 * | |--IDENT -> List 5323 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5324 * | |--GENERIC_START -> < 5325 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5326 * | | |--WILDCARD_TYPE -> ? 5327 * | | `--TYPE_LOWER_BOUNDS -> super 5328 * | | `--IDENT -> List 5329 * | `--GENERIC_END -> > 5330 * |--IDENT -> list 5331 * `--SEMI -> ; 5332 * </pre> 5333 * 5334 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5335 * Generic Classes and Type Parameters</a> 5336 * @see #WILDCARD_TYPE 5337 * @see #TYPE_UPPER_BOUNDS 5338 * @see #TYPE_LOWER_BOUNDS 5339 */ 5340 public static final int TYPE_ARGUMENT = 5341 JavaLanguageLexer.TYPE_ARGUMENT; 5342 5343 /** 5344 * The type that refers to all types. This node has no children. 5345 * 5346 * <p>For example: </p> 5347 * <pre> 5348 * 5349 * List<?> list; 5350 * </pre> 5351 * 5352 * <p>parses as:</p> 5353 * <pre> 5354 * |--VARIABLE_DEF -> VARIABLE_DEF 5355 * | |--MODIFIERS -> MODIFIERS 5356 * | |--TYPE -> TYPE 5357 * | | |--IDENT -> List 5358 * | | |`--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5359 * | | |--GENERIC_START -> < 5360 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5361 * | | | `--WILDCARD_TYPE -> ? 5362 * | | `--GENERIC_END -> > 5363 * | `--IDENT -> list 5364 * |--SEMI -> ; 5365 * </pre> 5366 * 5367 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5368 * Generic Classes and Type Parameters</a> 5369 * @see #TYPE_ARGUMENT 5370 * @see #TYPE_UPPER_BOUNDS 5371 * @see #TYPE_LOWER_BOUNDS 5372 */ 5373 public static final int WILDCARD_TYPE = 5374 JavaLanguageLexer.WILDCARD_TYPE; 5375 5376 /** 5377 * An upper bounds on a wildcard type argument or type parameter. 5378 * This node has one child - the type that is being used for 5379 * the bounding. 5380 * 5381 * <p>For example:</p> 5382 * <pre>List<? extends Number> list;</pre> 5383 * 5384 * <p>parses as:</p> 5385 * <pre> 5386 * --VARIABLE_DEF -> VARIABLE_DEF 5387 * |--MODIFIERS -> MODIFIERS 5388 * |--TYPE -> TYPE 5389 * | |--IDENT -> List 5390 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5391 * | |--GENERIC_START -> < 5392 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5393 * | | |--WILDCARD_TYPE -> ? 5394 * | | `--TYPE_UPPER_BOUNDS -> extends 5395 * | | `--IDENT -> Number 5396 * | `--GENERIC_END -> > 5397 * |--IDENT -> list 5398 * `--SEMI -> ; 5399 * </pre> 5400 * 5401 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5402 * Generic Classes and Type Parameters</a> 5403 * @see #TYPE_PARAMETER 5404 * @see #TYPE_ARGUMENT 5405 * @see #WILDCARD_TYPE 5406 */ 5407 public static final int TYPE_UPPER_BOUNDS = 5408 JavaLanguageLexer.TYPE_UPPER_BOUNDS; 5409 5410 /** 5411 * A lower bounds on a wildcard type argument. This node has one child 5412 * - the type that is being used for the bounding. 5413 * 5414 * <p>For example:</p> 5415 * <pre>List<? super Integer> list;</pre> 5416 * 5417 * <p>parses as:</p> 5418 * <pre> 5419 * --VARIABLE_DEF -> VARIABLE_DEF 5420 * |--MODIFIERS -> MODIFIERS 5421 * |--TYPE -> TYPE 5422 * | |--IDENT -> List 5423 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5424 * | |--GENERIC_START -> < 5425 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5426 * | | |--WILDCARD_TYPE -> ? 5427 * | | `--TYPE_LOWER_BOUNDS -> super 5428 * | | `--IDENT -> Integer 5429 * | `--GENERIC_END -> > 5430 * |--IDENT -> list 5431 * `--SEMI -> ; 5432 * </pre> 5433 * 5434 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5435 * Generic Classes and Type Parameters</a> 5436 * @see #TYPE_ARGUMENT 5437 * @see #WILDCARD_TYPE 5438 */ 5439 public static final int TYPE_LOWER_BOUNDS = 5440 JavaLanguageLexer.TYPE_LOWER_BOUNDS; 5441 5442 /** 5443 * An {@code @} symbol - signifying an annotation instance or the prefix 5444 * to the interface literal signifying the definition of an annotation 5445 * declaration. 5446 * 5447 * <p>For example:</p> 5448 * <pre> 5449 * @Deprecated 5450 * private int value; 5451 * </pre> 5452 * 5453 * <p>parses as:</p> 5454 * <pre> 5455 * VARIABLE_DEF -> VARIABLE_DEF 5456 * |--MODIFIERS -> MODIFIERS 5457 * | |--ANNOTATION -> ANNOTATION 5458 * | | |--AT -> @ 5459 * | | `--IDENT -> Deprecated 5460 * | `--LITERAL_PRIVATE -> private 5461 * |--TYPE -> TYPE 5462 * | `--LITERAL_INT -> int 5463 * |--IDENT -> value 5464 * `--SEMI -> ; 5465 * </pre> 5466 * 5467 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5468 * JSR201</a> 5469 */ 5470 public static final int AT = JavaLanguageLexer.AT; 5471 5472 /** 5473 * A triple dot for variable-length parameters. This token only ever occurs 5474 * in a parameter declaration immediately after the type of the parameter. 5475 * 5476 * <p>For example:</p> 5477 * <pre> 5478 * public void myShape(int... dimension) { 5479 * 5480 * } 5481 * </pre> 5482 * 5483 * <p>parses as:</p> 5484 * <pre> 5485 * METHOD_DEF -> METHOD_DEF 5486 * |--MODIFIERS -> MODIFIERS 5487 * | `--LITERAL_PUBLIC -> public 5488 * |--TYPE -> TYPE 5489 * | `--LITERAL_VOID -> void 5490 * |--IDENT -> myShape 5491 * |--LPAREN -> ( 5492 * |--PARAMETERS -> PARAMETERS 5493 * | `--PARAMETER_DEF -> PARAMETER_DEF 5494 * | |--MODIFIERS -> MODIFIERS 5495 * | |--TYPE -> TYPE 5496 * | | `--LITERAL_INT -> int 5497 * | |--ELLIPSIS -> ... 5498 * | `--IDENT -> dimension 5499 * |--RPAREN -> ) 5500 * `--SLIST -> { 5501 * `--RCURLY -> } 5502 * </pre> 5503 * 5504 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5505 * JSR201</a> 5506 */ 5507 public static final int ELLIPSIS = JavaLanguageLexer.ELLIPSIS; 5508 5509 /** 5510 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain 5511 * or a type cast expression with an additional interface. 5512 * 5513 * <p>Generic type bounds extension: 5514 * {@code class Comparable<T extends Serializable & CharSequence>}</p> 5515 * <pre> 5516 * CLASS_DEF -> CLASS_DEF 5517 * |--MODIFIERS -> MODIFIERS 5518 * |--LITERAL_CLASS -> class 5519 * |--IDENT -> Comparable 5520 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5521 * |--GENERIC_START -> < 5522 * |--TYPE_PARAMETER -> TYPE_PARAMETER 5523 * | |--IDENT -> T 5524 * | `--TYPE_UPPER_BOUNDS -> extends 5525 * | |--IDENT -> Serializable 5526 * | |--TYPE_EXTENSION_AND -> & 5527 * | `--IDENT -> CharSequence 5528 * `--GENERIC_END -> > 5529 * </pre> 5530 * 5531 * <p>Type cast extension: 5532 * {@code return (Serializable & CharSequence) null;}</p> 5533 * <pre> 5534 * --LITERAL_RETURN -> return 5535 * |--EXPR -> EXPR 5536 * | `--TYPECAST -> ( 5537 * | |--TYPE -> TYPE 5538 * | | `--IDENT -> Serializable 5539 * | |--TYPE_EXTENSION_AND -> & 5540 * | |--TYPE -> TYPE 5541 * | | `--IDENT -> CharSequence 5542 * | |--RPAREN -> ) 5543 * | `--LITERAL_NULL -> null 5544 * `--SEMI -> ; 5545 * </pre> 5546 * 5547 * @see #EXTENDS_CLAUSE 5548 * @see #TYPECAST 5549 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4"> 5550 * Java Language Specification, §4.4</a> 5551 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16"> 5552 * Java Language Specification, §15.16</a> 5553 */ 5554 public static final int TYPE_EXTENSION_AND = 5555 JavaLanguageLexer.TYPE_EXTENSION_AND; 5556 5557 /** 5558 * A {@code <} symbol signifying the start of type arguments or type parameters. 5559 * 5560 * <p>For example:</p> 5561 * <pre> 5562 * class Test<T> {} 5563 * </pre> 5564 * 5565 * <p>parses as:</p> 5566 * <pre> 5567 * CLASS_DEF -> CLASS_DEF 5568 * |--MODIFIERS -> MODIFIERS 5569 * |--LITERAL_CLASS -> class 5570 * |--IDENT -> Test 5571 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5572 * | |--GENERIC_START -> < 5573 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5574 * | | `--IDENT -> T 5575 * | `--GENERIC_END -> > 5576 * `--OBJBLOCK -> OBJBLOCK 5577 * |--LCURLY -> { 5578 * `--RCURLY -> } 5579 * </pre> 5580 * 5581 * @see #MODIFIERS 5582 * @see #IDENT 5583 * @see #OBJBLOCK 5584 * @see #TYPE_PARAMETERS 5585 * @see #GENERIC_END 5586 */ 5587 public static final int GENERIC_START = 5588 JavaLanguageLexer.GENERIC_START; 5589 5590 /** 5591 * A {@code >} symbol signifying the end of type arguments or type parameters. 5592 * 5593 * <p>For example:</p> 5594 * <pre> 5595 * class Test<T> {} 5596 * </pre> 5597 * 5598 * <p>parses as:</p> 5599 * <pre> 5600 * CLASS_DEF -> CLASS_DEF 5601 * |--MODIFIERS -> MODIFIERS 5602 * |--LITERAL_CLASS -> class 5603 * |--IDENT -> Test 5604 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5605 * | |--GENERIC_START -> < 5606 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5607 * | | `--IDENT -> T 5608 * | `--GENERIC_END -> > 5609 * `--OBJBLOCK -> OBJBLOCK 5610 * |--LCURLY -> { 5611 * `--RCURLY -> } 5612 * </pre> 5613 * 5614 * @see #MODIFIERS 5615 * @see #IDENT 5616 * @see #OBJBLOCK 5617 * @see #TYPE_PARAMETERS 5618 * @see #GENERIC_START 5619 */ 5620 public static final int GENERIC_END = JavaLanguageLexer.GENERIC_END; 5621 5622 /** 5623 * Special lambda symbol {@code ->}. 5624 * 5625 * <p>For example:</p> 5626 * <pre> 5627 * numbers.forEach((n) -> System.out.println(n)); 5628 * </pre> 5629 * 5630 * <p>parses as:</p> 5631 * <pre> 5632 * METHOD_CALL -> ( 5633 * |--DOT -> . 5634 * | |--IDENT -> numbers 5635 * | `--IDENT -> forEach 5636 * |--ELIST -> ELIST 5637 * | `--LAMBDA -> -> 5638 * | |--LPAREN -> ( 5639 * | |--PARAMETERS -> PARAMETERS 5640 * | | `--PARAMETER_DEF -> PARAMETER_DEF 5641 * | | |--MODIFIERS -> MODIFIERS 5642 * | | |--TYPE -> TYPE 5643 * | | `--IDENT -> n 5644 * | |--RPAREN -> ) 5645 * | `--EXPR -> EXPR 5646 * | `--METHOD_CALL -> ( 5647 * | |--DOT -> . 5648 * | | |--DOT -> . 5649 * | | | |--IDENT -> System 5650 * | | | `--IDENT -> out 5651 * | | `--IDENT -> println 5652 * | |--ELIST -> ELIST 5653 * | | `--EXPR -> EXPR 5654 * | | `--IDENT -> n 5655 * | `--RPAREN -> ) 5656 * `--RPAREN -> ) 5657 * </pre> 5658 * 5659 */ 5660 public static final int LAMBDA = JavaLanguageLexer.LAMBDA; 5661 5662 /** 5663 * Beginning of single-line comment: '//'. 5664 * 5665 * <pre> 5666 * SINGLE_LINE_COMMENT -> // 5667 * `--COMMENT_CONTENT -> \r\n 5668 * </pre> 5669 * 5670 * <p>For example:</p> 5671 * <pre> 5672 * // Comment content 5673 * </pre> 5674 * 5675 * <p>parses as:</p> 5676 * <pre> 5677 * SINGLE_LINE_COMMENT -> // 5678 * `--COMMENT_CONTENT -> Comment Content\n 5679 * </pre> 5680 */ 5681 public static final int SINGLE_LINE_COMMENT = 5682 JavaLanguageLexer.SINGLE_LINE_COMMENT; 5683 5684 /** 5685 * Beginning of block comment: '/*'. 5686 * 5687 * <p>For example:</p> 5688 * <pre> 5689 * /* Comment content 5690 * */ 5691 * </pre> 5692 * 5693 * <p>parses as:</p> 5694 * <pre> 5695 * --BLOCK_COMMENT_BEGIN -> /* 5696 * |--COMMENT_CONTENT -> Comment content\r\n 5697 * `--BLOCK_COMMENT_END -> */ 5698 * </pre> 5699 */ 5700 public static final int BLOCK_COMMENT_BEGIN = 5701 JavaLanguageLexer.BLOCK_COMMENT_BEGIN; 5702 5703 /** 5704 * End of block comment: '*/'. 5705 * 5706 * <p>For example:</p> 5707 * <pre> 5708 * /*comment*/ 5709 * </pre> 5710 * 5711 * <p>parses as:</p> 5712 * <pre> 5713 * BLOCK_COMMENT_BEGIN -> /* 5714 * |--COMMENT_CONTENT -> comment 5715 * `--BLOCK_COMMENT_END -> */ 5716 * </pre> 5717 * 5718 */ 5719 public static final int BLOCK_COMMENT_END = 5720 JavaLanguageLexer.BLOCK_COMMENT_END; 5721 5722 /** 5723 * Text of single-line or block comment. 5724 * 5725 * <p>For example:</p> 5726 * <pre> 5727 * //this is single-line comment 5728 * 5729 * /* 5730 * this is multiline comment 5731 * */ 5732 * </pre> 5733 * 5734 * <p>parses as:</p> 5735 * <pre> 5736 * |--SINGLE_LINE_COMMENT -> // 5737 * | `--COMMENT_CONTENT -> this is single-line comment\n 5738 * |--BLOCK_COMMENT_BEGIN -> /* 5739 * | |--COMMENT_CONTENT -> \n\t\t\tthis is multiline comment\n\t\t 5740 * | `--BLOCK_COMMENT_END -> */ 5741 * </pre> 5742 * 5743 */ 5744 public static final int COMMENT_CONTENT = 5745 JavaLanguageLexer.COMMENT_CONTENT; 5746 5747 /** 5748 * A pattern variable definition; when conditionally matched, 5749 * this variable is assigned with the defined type. 5750 * 5751 * <p>For example:</p> 5752 * <pre> 5753 * if (obj instanceof String str) { } 5754 * </pre> 5755 * 5756 * <p>parses as:</p> 5757 * <pre> 5758 * LITERAL_IF -> if 5759 * |--LPAREN -> ( 5760 * |--EXPR -> EXPR 5761 * | `--LITERAL_INSTANCEOF -> instanceof 5762 * | |--IDENT -> obj 5763 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 5764 * | |--TYPE -> TYPE 5765 * | | `--IDENT -> String 5766 * | `--IDENT -> str 5767 * |--RPAREN -> ) 5768 * `--SLIST -> { 5769 * `--RCURLY -> } 5770 * </pre> 5771 * 5772 * @see #LITERAL_INSTANCEOF 5773 * @since 8.35 5774 */ 5775 public static final int PATTERN_VARIABLE_DEF = 5776 JavaLanguageLexer.PATTERN_VARIABLE_DEF; 5777 5778 /** 5779 * The {@code record} keyword. This element appears 5780 * as part of a record declaration. 5781 * 5782 * <p>For example:</p> 5783 * <pre> 5784 * public record MyRecord () { 5785 * 5786 * } 5787 * </pre> 5788 * 5789 * <p>parses as:</p> 5790 * <pre> 5791 * RECORD_DEF -> RECORD_DEF 5792 * |--MODIFIERS -> MODIFIERS 5793 * | `--LITERAL_PUBLIC -> public 5794 * |--LITERAL_RECORD -> record 5795 * |--IDENT -> MyRecord 5796 * |--LPAREN -> ( 5797 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5798 * |--RPAREN -> ) 5799 * `--OBJBLOCK -> OBJBLOCK 5800 * |--LCURLY -> { 5801 * `--RCURLY -> } 5802 * </pre> 5803 * 5804 * @since 8.35 5805 **/ 5806 public static final int LITERAL_RECORD = 5807 JavaLanguageLexer.LITERAL_RECORD; 5808 5809 /** 5810 * A declaration of a record specifies a name, a header, and a body. 5811 * The header lists the components of the record, which are the variables 5812 * that make up its state. 5813 * 5814 * <p>For example:</p> 5815 * <pre> 5816 * public record MyRecord () { 5817 * 5818 * } 5819 * </pre> 5820 * 5821 * <p>parses as:</p> 5822 * <pre> 5823 * RECORD_DEF -> RECORD_DEF 5824 * |--MODIFIERS -> MODIFIERS 5825 * | `--LITERAL_PUBLIC -> public 5826 * |--LITERAL_RECORD -> record 5827 * |--IDENT -> MyRecord 5828 * |--LPAREN -> ( 5829 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5830 * |--RPAREN -> ) 5831 * `--OBJBLOCK -> OBJBLOCK 5832 * |--LCURLY -> { 5833 * `--RCURLY -> } 5834 * </pre> 5835 * 5836 * @since 8.35 5837 */ 5838 public static final int RECORD_DEF = 5839 JavaLanguageLexer.RECORD_DEF; 5840 5841 /** 5842 * Record components are a (possibly empty) list containing the components of a record, which 5843 * are the variables that make up its state. 5844 * 5845 * <p>For example:</p> 5846 * <pre> 5847 * public record myRecord (Comp x, Comp y) { } 5848 * </pre> 5849 * 5850 * <p>parses as:</p> 5851 * <pre> 5852 * RECORD_DEF -> RECORD_DEF 5853 * |--MODIFIERS -> MODIFIERS 5854 * | `--LITERAL_PUBLIC -> public 5855 * |--LITERAL_RECORD -> record 5856 * |--IDENT -> myRecord 5857 * |--LPAREN -> ( 5858 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5859 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5860 * | | |--ANNOTATIONS -> ANNOTATIONS 5861 * | | |--TYPE -> TYPE 5862 * | | | `--IDENT -> Comp 5863 * | | `--IDENT -> x 5864 * | |--COMMA -> , 5865 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5866 * | |--ANNOTATIONS -> ANNOTATIONS 5867 * | |--TYPE -> TYPE 5868 * | | `--IDENT -> Comp 5869 * | `--IDENT -> y 5870 * |--RPAREN -> ) 5871 * `--OBJBLOCK -> OBJBLOCK 5872 * |--LCURLY -> { 5873 * `--RCURLY -> } 5874 * </pre> 5875 * 5876 * @since 8.36 5877 */ 5878 public static final int RECORD_COMPONENTS = 5879 JavaLanguageLexer.RECORD_COMPONENTS; 5880 5881 /** 5882 * A record component is a variable that comprises the state of a record. Record components 5883 * have annotations (possibly), a type definition, and an identifier. They can also be of 5884 * variable arity ('...'). 5885 * 5886 * <p>For example:</p> 5887 * <pre> 5888 * public record MyRecord(Comp x, Comp... comps) { 5889 * 5890 * } 5891 * </pre> 5892 * 5893 * <p>parses as:</p> 5894 * <pre> 5895 * RECORD_DEF -> RECORD_DEF 5896 * |--MODIFIERS -> MODIFIERS 5897 * | `--LITERAL_PUBLIC -> public 5898 * |--LITERAL_RECORD -> record 5899 * |--IDENT -> MyRecord 5900 * |--LPAREN -> ( 5901 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5902 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5903 * | | |--ANNOTATIONS -> ANNOTATIONS 5904 * | | |--TYPE -> TYPE 5905 * | | | `--IDENT -> Comp 5906 * | | `--IDENT -> x 5907 * | |--COMMA -> , 5908 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5909 * | |--ANNOTATIONS -> ANNOTATIONS 5910 * | |--TYPE -> TYPE 5911 * | | `--IDENT -> Comp 5912 * | |--ELLIPSIS -> ... 5913 * | `--IDENT -> comps 5914 * |--RPAREN -> ) 5915 * `--OBJBLOCK -> OBJBLOCK 5916 * |--LCURLY -> { 5917 * `--RCURLY -> } 5918 * </pre> 5919 * 5920 * @since 8.36 5921 */ 5922 public static final int RECORD_COMPONENT_DEF = 5923 JavaLanguageLexer.RECORD_COMPONENT_DEF; 5924 5925 /** 5926 * A compact canonical constructor eliminates the list of formal parameters; they are 5927 * declared implicitly. 5928 * 5929 * <p>For example:</p> 5930 * <pre> 5931 * public record myRecord () { 5932 * public myRecord{} 5933 * } 5934 * </pre> 5935 * 5936 * <p>parses as:</p> 5937 * <pre> 5938 * RECORD_DEF 5939 * |--MODIFIERS 5940 * | `--LITERAL_PUBLIC (public) 5941 * |--LITERAL_RECORD (record) 5942 * |--IDENT (myRecord) 5943 * |--LPAREN (() 5944 * |--RECORD_COMPONENTS 5945 * |--RPAREN ()) 5946 * `--OBJBLOCK 5947 * |--LCURLY ({) 5948 * |--COMPACT_CTOR_DEF 5949 * | |--MODIFIERS 5950 * | | `--LITERAL_PUBLIC (public) 5951 * | |--IDENT (myRecord) 5952 * | `--SLIST ({) 5953 * | `--RCURLY (}) 5954 * `--RCURLY (}) 5955 * </pre> 5956 * 5957 * @since 8.36 5958 */ 5959 public static final int COMPACT_CTOR_DEF = 5960 JavaLanguageLexer.COMPACT_CTOR_DEF; 5961 5962 /** 5963 * Text blocks are a new feature added to to Java SE 15 and later 5964 * that will make writing multi-line strings much easier and cleaner. 5965 * Beginning of a Java 15 Text Block literal, 5966 * delimited by three double quotes. 5967 * 5968 * <p>For example:</p> 5969 * <pre> 5970 * String hello = """ 5971 * Hello, world! 5972 * """; 5973 * </pre> 5974 * 5975 * <p>parses as:</p> 5976 * <pre> 5977 * |--VARIABLE_DEF -> VARIABLE_DEF 5978 * | |--MODIFIERS -> MODIFIERS 5979 * | |--TYPE -> TYPE 5980 * | | `--IDENT -> String 5981 * | |--IDENT -> hello 5982 * | `--ASSIGN -> = 5983 * | `--EXPR -> EXPR 5984 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 5985 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n 5986 * | `--TEXT_BLOCK_LITERAL_END -> """ 5987 * `--SEMI -> ; 5988 * </pre> 5989 * 5990 * @since 8.36 5991 */ 5992 public static final int TEXT_BLOCK_LITERAL_BEGIN = 5993 JavaLanguageLexer.TEXT_BLOCK_LITERAL_BEGIN; 5994 5995 /** 5996 * Content of a Java 15 text block. This is a 5997 * sequence of characters, possibly escaped with '\'. Actual line terminators 5998 * are represented by '\n'. 5999 * 6000 * <p>For example:</p> 6001 * <pre> 6002 * String hello = """ 6003 * Hello, world! 6004 * """; 6005 * </pre> 6006 * 6007 * <p>parses as:</p> 6008 * <pre> 6009 * |--VARIABLE_DEF -> VARIABLE_DEF 6010 * | |--MODIFIERS -> MODIFIERS 6011 * | |--TYPE -> TYPE 6012 * | | `--IDENT -> String 6013 * | |--IDENT -> hello 6014 * | `--ASSIGN -> = 6015 * | `--EXPR -> EXPR 6016 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 6017 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n 6018 * | `--TEXT_BLOCK_LITERAL_END -> """ 6019 * `--SEMI -> ; 6020 * </pre> 6021 * 6022 * @since 8.36 6023 */ 6024 public static final int TEXT_BLOCK_CONTENT = 6025 JavaLanguageLexer.TEXT_BLOCK_CONTENT; 6026 6027 /** 6028 * End of a Java 15 text block literal, delimited by three 6029 * double quotes. 6030 * 6031 * <p>For example:</p> 6032 * <pre> 6033 * String hello = """ 6034 * Hello, world! 6035 * """; 6036 * </pre> 6037 * 6038 * <p>parses as:</p> 6039 * <pre> 6040 * |--VARIABLE_DEF -> VARIABLE_DEF 6041 * | |--MODIFIERS -> MODIFIERS 6042 * | |--TYPE -> TYPE 6043 * | | `--IDENT -> String 6044 * | |--IDENT -> hello 6045 * | `--ASSIGN -> = 6046 * | `--EXPR -> EXPR 6047 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 6048 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n 6049 * | `--TEXT_BLOCK_LITERAL_END -> """ 6050 * `--SEMI -> ; 6051 * </pre> 6052 * 6053 * @since 8.36 6054 */ 6055 public static final int TEXT_BLOCK_LITERAL_END = 6056 JavaLanguageLexer.TEXT_BLOCK_LITERAL_END; 6057 6058 /** 6059 * The {@code yield} keyword. This element appears 6060 * as part of a yield statement. 6061 * 6062 * <p>For example:</p> 6063 * <pre> 6064 * int yield = 0; // not a keyword here 6065 * return switch (mode) { 6066 * case "a", "b": 6067 * yield 1; 6068 * default: 6069 * yield - 1; 6070 * }; 6071 * </pre> 6072 * 6073 * <p>parses as:</p> 6074 * <pre> 6075 * |--VARIABLE_DEF -> VARIABLE_DEF 6076 * | |--MODIFIERS -> MODIFIERS 6077 * | |--TYPE -> TYPE 6078 * | | `--LITERAL_INT -> int 6079 * | |--IDENT -> yield 6080 * | `--ASSIGN -> = 6081 * | `--EXPR -> EXPR 6082 * | `--NUM_INT -> 0 6083 * |--SEMI -> ; 6084 * |--LITERAL_RETURN -> return 6085 * | |--EXPR -> EXPR 6086 * | | `--LITERAL_SWITCH -> switch 6087 * | | |--LPAREN -> ( 6088 * | | |--EXPR -> EXPR 6089 * | | | `--IDENT -> mode 6090 * | | |--RPAREN -> ) 6091 * | | |--LCURLY -> { 6092 * | | |--CASE_GROUP -> CASE_GROUP 6093 * | | | |--LITERAL_CASE -> case 6094 * | | | | |--EXPR -> EXPR 6095 * | | | | | `--STRING_LITERAL -> "a" 6096 * | | | | |--COMMA -> , 6097 * | | | | |--EXPR -> EXPR 6098 * | | | | | `--STRING_LITERAL -> "b" 6099 * | | | | `--COLON -> : 6100 * | | | `--SLIST -> SLIST 6101 * | | | `--LITERAL_YIELD -> yield 6102 * | | | |--EXPR -> EXPR 6103 * | | | | `--NUM_INT -> 1 6104 * | | | `--SEMI -> ; 6105 * | | |--CASE_GROUP -> CASE_GROUP 6106 * | | | |--LITERAL_DEFAULT -> default 6107 * | | | | `--COLON -> : 6108 * | | | `--SLIST -> SLIST 6109 * | | | `--LITERAL_YIELD -> yield 6110 * | | | |--EXPR -> EXPR 6111 * | | | | `--UNARY_MINUS -> - 6112 * | | | | `--NUM_INT -> 1 6113 * | | | `--SEMI -> ; 6114 * | | `--RCURLY -> } 6115 * | `--SEMI -> ; 6116 * </pre> 6117 * 6118 * 6119 * @see #LITERAL_SWITCH 6120 * @see #CASE_GROUP 6121 * @see #SLIST 6122 * @see #SWITCH_RULE 6123 * 6124 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 6125 * Java Language Specification, §14.21</a> 6126 * 6127 * @since 8.36 6128 */ 6129 public static final int LITERAL_YIELD = 6130 JavaLanguageLexer.LITERAL_YIELD; 6131 6132 /** 6133 * Switch Expressions. 6134 * 6135 * <p>For example:</p> 6136 * <pre> 6137 * return switch (day) { 6138 * case SAT, SUN -> "Weekend"; 6139 * default -> "Working day"; 6140 * }; 6141 * </pre> 6142 * 6143 * <p>parses as:</p> 6144 * <pre> 6145 * LITERAL_RETURN -> return 6146 * |--EXPR -> EXPR 6147 * | `--LITERAL_SWITCH -> switch 6148 * | |--LPAREN -> ( 6149 * | |--EXPR -> EXPR 6150 * | | `--IDENT -> day 6151 * | |--RPAREN -> ) 6152 * | |--LCURLY -> { 6153 * | |--SWITCH_RULE -> SWITCH_RULE 6154 * | | |--LITERAL_CASE -> case 6155 * | | | |--EXPR -> EXPR 6156 * | | | | `--IDENT -> SAT 6157 * | | | |--COMMA -> , 6158 * | | | `--EXPR -> EXPR 6159 * | | | `--IDENT -> SUN 6160 * | | |--LAMBDA -> -> 6161 * | | |--EXPR -> EXPR 6162 * | | | `--STRING_LITERAL -> "Weekend" 6163 * | | `--SEMI -> ; 6164 * | |--SWITCH_RULE -> SWITCH_RULE 6165 * | | |--LITERAL_DEFAULT -> default 6166 * | | |--LAMBDA -> -> 6167 * | | |--EXPR -> EXPR 6168 * | | | `--STRING_LITERAL -> "Working day" 6169 * | | `--SEMI -> ; 6170 * | `--RCURLY -> } 6171 * `--SEMI -> ; 6172 * </pre> 6173 * 6174 * @see #LITERAL_CASE 6175 * @see #LITERAL_DEFAULT 6176 * @see #LITERAL_SWITCH 6177 * @see #LITERAL_YIELD 6178 * 6179 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 6180 * Java Language Specification, §14.21</a> 6181 * 6182 * @since 8.36 6183 */ 6184 public static final int SWITCH_RULE = 6185 JavaLanguageLexer.SWITCH_RULE; 6186 6187 /** 6188 * The {@code non-sealed} keyword. This element appears 6189 * as part of a class or interface declaration. 6190 * 6191 * <p>For example:</p> 6192 * <pre> 6193 * non-sealed class Square extends Rectangle { } 6194 * </pre> 6195 * 6196 * <p>parses as:</p> 6197 * <pre> 6198 * CLASS_DEF -> CLASS_DEF 6199 * |--MODIFIERS -> MODIFIERS 6200 * | `--LITERAL_NON_SEALED -> non-sealed 6201 * |--LITERAL_CLASS -> class 6202 * |--IDENT -> Square 6203 * |--EXTENDS_CLAUSE -> extends 6204 * | `--IDENT -> Rectangle 6205 * `--OBJBLOCK -> OBJBLOCK 6206 * |--LCURLY -> { 6207 * `--RCURLY -> } 6208 * </pre> 6209 * 6210 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6211 * Java Language Specification, §8.1.1.2</a> 6212 * @see #MODIFIERS 6213 * 6214 * @since 8.42 6215 */ 6216 public static final int LITERAL_NON_SEALED = 6217 JavaLanguageLexer.LITERAL_NON_SEALED; 6218 6219 /** 6220 * The {@code sealed} restricted identifier. This element appears 6221 * as part of a class or interface declaration. 6222 * 6223 * <p>For example:</p> 6224 * <pre> 6225 * public sealed class Shape permits Circle, Square, Rectangle { } 6226 * </pre> 6227 * 6228 * <p>parses as:</p> 6229 * <pre> 6230 * CLASS_DEF -> CLASS_DEF 6231 * |--MODIFIERS -> MODIFIERS 6232 * | |--LITERAL_PUBLIC -> public 6233 * | `--LITERAL_SEALED -> sealed 6234 * |--LITERAL_CLASS -> class 6235 * |--IDENT -> Shape 6236 * |--PERMITS_CLAUSE -> permits 6237 * | |--IDENT -> Circle 6238 * | |--COMMA -> , 6239 * | |--IDENT -> Square 6240 * | |--COMMA -> , 6241 * | `--IDENT -> Rectangle 6242 * `--OBJBLOCK -> OBJBLOCK 6243 * |--LCURLY -> { 6244 * `--RCURLY -> } 6245 * </pre> 6246 * 6247 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6248 * Java Language Specification, §8.1.1.2</a> 6249 * @see #MODIFIERS 6250 * 6251 * @since 8.42 6252 */ 6253 public static final int LITERAL_SEALED = 6254 JavaLanguageLexer.LITERAL_SEALED; 6255 6256 /** 6257 * The {@code permits} restricted identifier. This element appears 6258 * as part of a class or interface declaration. 6259 * 6260 * <p>For example:</p> 6261 * <pre> 6262 * public sealed class Shape permits Circle, Square, Rectangle { } 6263 * </pre> 6264 * 6265 * <p>parses as:</p> 6266 * <pre> 6267 * CLASS_DEF -> CLASS_DEF 6268 * |--MODIFIERS -> MODIFIERS 6269 * | |--LITERAL_PUBLIC -> public 6270 * | `--LITERAL_SEALED -> sealed 6271 * |--LITERAL_CLASS -> class 6272 * |--IDENT -> Shape 6273 * |--PERMITS_CLAUSE -> permits 6274 * | |--IDENT -> Circle 6275 * | |--COMMA -> , 6276 * | |--IDENT -> Square 6277 * | |--COMMA -> , 6278 * | `--IDENT -> Rectangle 6279 * `--OBJBLOCK -> OBJBLOCK 6280 * |--LCURLY -> { 6281 * `--RCURLY -> } 6282 * </pre> 6283 * 6284 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6285 * Java Language Specification, §9.1.4</a> 6286 * @see #MODIFIERS 6287 * 6288 * @since 8.42 6289 */ 6290 public static final int LITERAL_PERMITS = 6291 JavaLanguageLexer.LITERAL_PERMITS; 6292 6293 /** 6294 * A permits clause. A permits clause's children are a comma separated list of one or 6295 * more identifiers. 6296 * 6297 * <p>For example:</p> 6298 * <pre> 6299 * public sealed class Shape permits Circle, Square, Rectangle { } 6300 * </pre> 6301 * 6302 * <p>parses as:</p> 6303 * <pre> 6304 * CLASS_DEF -> CLASS_DEF 6305 * |--MODIFIERS -> MODIFIERS 6306 * | |--LITERAL_PUBLIC -> public 6307 * | `--LITERAL_SEALED -> sealed 6308 * |--LITERAL_CLASS -> class 6309 * |--IDENT -> Shape 6310 * |--PERMITS_CLAUSE -> permits 6311 * | |--IDENT -> Circle 6312 * | |--COMMA -> , 6313 * | |--IDENT -> Square 6314 * | |--COMMA -> , 6315 * | `--IDENT -> Rectangle 6316 * `--OBJBLOCK -> OBJBLOCK 6317 * |--LCURLY -> { 6318 * `--RCURLY -> } 6319 * </pre> 6320 * 6321 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6322 * Java Language Specification, §9.1.4</a> 6323 * @see #MODIFIERS 6324 * @see #CLASS_DEF 6325 * @see #INTERFACE_DEF 6326 * @see #COMMA 6327 * @see #IDENT 6328 * 6329 * @since 8.42 6330 */ 6331 public static final int PERMITS_CLAUSE = 6332 JavaLanguageLexer.PERMITS_CLAUSE; 6333 6334 /** 6335 * A pattern definition, excluding simple type pattern (pattern variable) 6336 * definition such as {@code if (o instanceof Integer i){}}. Pattern definitions 6337 * appear as operands of statements and expressions. 6338 * 6339 * <p>For example:</p> 6340 * <pre> 6341 * switch(o) { 6342 * case String s when s.length() > 4: // guarded pattern, `PATTERN_DEF` 6343 * break; 6344 * case String s: // type pattern, no `PATTERN_DEF` 6345 * break; 6346 * } 6347 * </pre> 6348 * 6349 * <p>parses as:</p> 6350 * <pre> 6351 * LITERAL_SWITCH -> switch 6352 * | |--LPAREN -> ( 6353 * | |--EXPR -> EXPR 6354 * | | `--IDENT -> o 6355 * | |--RPAREN -> ) 6356 * | |--LCURLY -> { 6357 * | |--CASE_GROUP -> CASE_GROUP 6358 * | | |--LITERAL_CASE -> case 6359 * | | | |--PATTERN_DEF -> PATTERN_DEF 6360 * | | | | `--LITERAL_WHEN -> when 6361 * | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6362 * | | | | | |--MODIFIERS -> MODIFIERS 6363 * | | | | | |--TYPE -> TYPE 6364 * | | | | | | `--IDENT -> String 6365 * | | | | | `--IDENT -> s 6366 * | | | | `--GT -> > 6367 * | | | | |--METHOD_CALL -> ( 6368 * | | | | | |--DOT -> . 6369 * | | | | | | |--IDENT -> s 6370 * | | | | | | `--IDENT -> length 6371 * | | | | | |--ELIST -> ELIST 6372 * | | | | | `--RPAREN -> ) 6373 * | | | | `--NUM_INT -> 4 6374 * | | | `--COLON -> : 6375 * | | `--SLIST -> SLIST 6376 * | | `--LITERAL_BREAK -> break 6377 * | | `--SEMI -> ; 6378 * | |--CASE_GROUP -> CASE_GROUP 6379 * | | |--LITERAL_CASE -> case 6380 * | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6381 * | | | | |--MODIFIERS -> MODIFIERS 6382 * | | | | |--TYPE -> TYPE 6383 * | | | | | `--IDENT -> String 6384 * | | | | `--IDENT -> s 6385 * | | | `--COLON -> : 6386 * | | `--SLIST -> SLIST 6387 * | | `--LITERAL_BREAK -> break 6388 * | | `--SEMI -> ; 6389 * | `--RCURLY -> } 6390 * `--RCURLY -> } 6391 * </pre> 6392 * 6393 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30"> 6394 * Java Language Specification, §14.30</a> 6395 * @see #LITERAL_SWITCH 6396 * @see #PATTERN_VARIABLE_DEF 6397 * @see #LITERAL_INSTANCEOF 6398 * 6399 * @since 9.3 6400 */ 6401 public static final int PATTERN_DEF = 6402 JavaLanguageLexer.PATTERN_DEF; 6403 6404 /** 6405 * A {@code when} clause. Appears as part of a switch label in a guarded pattern definition. 6406 * 6407 * <p>For example:</p> 6408 * <pre> 6409 * return switch (o) { 6410 * case Integer i when i >= 0 -> i; 6411 * default -> 2; 6412 * }; 6413 * </pre> 6414 * 6415 * <p>parses as:</p> 6416 * <pre> 6417 * LITERAL_RETURN -> return 6418 * `--EXPR -> EXPR 6419 * `--LITERAL_SWITCH -> switch 6420 * |--LPAREN -> ( 6421 * |--EXPR -> EXPR 6422 * | `--IDENT -> o 6423 * |--RPAREN -> ) 6424 * |--LCURLY -> { 6425 * |--SWITCH_RULE -> SWITCH_RULE 6426 * | |--LITERAL_CASE -> case 6427 * | | `--PATTERN_DEF -> PATTERN_DEF 6428 * | | `--LITERAL_WHEN -> when 6429 * | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6430 * | | | |--MODIFIERS -> MODIFIERS 6431 * | | | |--TYPE -> TYPE 6432 * | | | | `--IDENT -> Integer 6433 * | | | `--IDENT -> i 6434 * | | `--GE -> >= 6435 * | | |--IDENT -> i 6436 * | | `--NUM_INT -> 0 6437 * | |--LAMBDA -> -> 6438 * | |--EXPR -> EXPR 6439 * | | `--IDENT -> i 6440 * | `--SEMI -> ; 6441 * |--SWITCH_RULE -> SWITCH_RULE 6442 * | |--LITERAL_DEFAULT -> default 6443 * | |--LAMBDA -> -> 6444 * | |--EXPR -> EXPR 6445 * | | `--NUM_INT -> 2 6446 * | `--SEMI -> ; 6447 * `--RCURLY -> } 6448 * </pre> 6449 * 6450 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30"> 6451 * Java Language Specification, §14.30</a> 6452 * @see #LITERAL_SWITCH 6453 * @see #PATTERN_VARIABLE_DEF 6454 * @see #LITERAL_INSTANCEOF 6455 * @see #SWITCH_RULE 6456 * 6457 * @since 10.7.0 6458 */ 6459 public static final int LITERAL_WHEN = 6460 JavaLanguageLexer.LITERAL_WHEN; 6461 6462 /** 6463 * A {@code record} pattern definition. A record pattern consists of a type, 6464 * a (possibly empty) record component pattern list which is used to match against 6465 * the corresponding record components, and an optional identifier. Appears as part of 6466 * an {@code instanceof} expression or a {@code case} label in a switch. 6467 * 6468 * <p>For example:</p> 6469 * <pre> 6470 * record R(Object o){} 6471 * if (o instanceof R(String s) myRecord) {} 6472 * switch (o) { 6473 * case R(String s) myRecord -> {} 6474 * } 6475 * </pre> 6476 * 6477 * <p>parses as:</p> 6478 * <pre> 6479 * |--RECORD_DEF -> RECORD_DEF 6480 * | |--MODIFIERS -> MODIFIERS 6481 * | |--LITERAL_RECORD -> record 6482 * | |--IDENT -> R 6483 * | |--LPAREN -> ( 6484 * | |--RECORD_COMPONENTS -> RECORD_COMPONENTS 6485 * | | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 6486 * | | |--ANNOTATIONS -> ANNOTATIONS 6487 * | | |--TYPE -> TYPE 6488 * | | | `--IDENT -> Object 6489 * | | `--IDENT -> o 6490 * | |--RPAREN -> ) 6491 * | `--OBJBLOCK -> OBJBLOCK 6492 * | |--LCURLY -> { 6493 * | `--RCURLY -> } 6494 * |--LITERAL_IF -> if 6495 * | |--LPAREN -> ( 6496 * | |--EXPR -> EXPR 6497 * | | `--LITERAL_INSTANCEOF -> instanceof 6498 * | | |--IDENT -> o 6499 * | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF 6500 * | | |--MODIFIERS -> MODIFIERS 6501 * | | |--TYPE -> TYPE 6502 * | | | `--IDENT -> R 6503 * | | |--LPAREN -> ( 6504 * | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS 6505 * | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6506 * | | | |--MODIFIERS -> MODIFIERS 6507 * | | | |--TYPE -> TYPE 6508 * | | | | `--IDENT -> String 6509 * | | | `--IDENT -> s 6510 * | | |--RPAREN -> ) 6511 * | | `--IDENT -> myRecord 6512 * | |--RPAREN -> ) 6513 * | `--SLIST -> { 6514 * | `--RCURLY -> } 6515 * |--LITERAL_SWITCH -> switch 6516 * | |--LPAREN -> ( 6517 * | |--EXPR -> EXPR 6518 * | | `--IDENT -> o 6519 * | |--RPAREN -> ) 6520 * | |--LCURLY -> { 6521 * | |--SWITCH_RULE -> SWITCH_RULE 6522 * | | |--LITERAL_CASE -> case 6523 * | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF 6524 * | | | |--MODIFIERS -> MODIFIERS 6525 * | | | |--TYPE -> TYPE 6526 * | | | | `--IDENT -> R 6527 * | | | |--LPAREN -> ( 6528 * | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS 6529 * | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6530 * | | | | |--MODIFIERS -> MODIFIERS 6531 * | | | | |--TYPE -> TYPE 6532 * | | | | | `--IDENT -> String 6533 * | | | | `--IDENT -> s 6534 * | | | |--RPAREN -> ) 6535 * | | | `--IDENT -> myRecord 6536 * | | |--LAMBDA -> -> 6537 * | | `--SLIST -> { 6538 * | | `--RCURLY -> } 6539 * | `--RCURLY -> } 6540 * `--RCURLY -> } 6541 * </pre> 6542 * 6543 * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a> 6544 * @see #LITERAL_WHEN 6545 * @see #PATTERN_VARIABLE_DEF 6546 * @see #LITERAL_INSTANCEOF 6547 * @see #SWITCH_RULE 6548 * 6549 * @since 10.12.0 6550 */ 6551 public static final int RECORD_PATTERN_DEF = 6552 JavaLanguageLexer.RECORD_PATTERN_DEF; 6553 6554 /** 6555 * A (possibly empty) record component pattern list which is used to match against 6556 * the corresponding record components. Appears as part of a record pattern definition. 6557 * 6558 * <p>For example:</p> 6559 * <pre> 6560 * record R(Object o){} 6561 * if (o instanceof R(String myComponent)) {} 6562 * switch (o) { 6563 * case R(String myComponent) when "component".equalsIgnoreCase(myComponent) -> {} 6564 * } 6565 * </pre> 6566 * 6567 * <p>parses as:</p> 6568 * <pre> 6569 * |--RECORD_DEF -> RECORD_DEF 6570 * | |--MODIFIERS -> MODIFIERS 6571 * | |--LITERAL_RECORD -> record 6572 * | |--IDENT -> R 6573 * | |--LPAREN -> ( 6574 * | |--RECORD_COMPONENTS -> RECORD_COMPONENTS 6575 * | | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 6576 * | | |--ANNOTATIONS -> ANNOTATIONS 6577 * | | |--TYPE -> TYPE 6578 * | | | `--IDENT -> Object 6579 * | | `--IDENT -> o 6580 * | |--RPAREN -> ) 6581 * | `--OBJBLOCK -> OBJBLOCK 6582 * | |--LCURLY -> { 6583 * | `--RCURLY -> } 6584 * |--LITERAL_IF -> if 6585 * | |--LPAREN -> ( 6586 * | |--EXPR -> EXPR 6587 * | | `--LITERAL_INSTANCEOF -> instanceof 6588 * | | |--IDENT -> o 6589 * | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF 6590 * | | |--MODIFIERS -> MODIFIERS 6591 * | | |--TYPE -> TYPE 6592 * | | | `--IDENT -> R 6593 * | | |--LPAREN -> ( 6594 * | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS 6595 * | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6596 * | | | |--MODIFIERS -> MODIFIERS 6597 * | | | |--TYPE -> TYPE 6598 * | | | | `--IDENT -> String 6599 * | | | `--IDENT -> myComponent 6600 * | | `--RPAREN -> ) 6601 * | |--RPAREN -> ) 6602 * | `--SLIST -> { 6603 * | `--RCURLY -> } 6604 * |--LITERAL_SWITCH -> switch 6605 * | |--LPAREN -> ( 6606 * | |--EXPR -> EXPR 6607 * | | `--IDENT -> o 6608 * | |--RPAREN -> ) 6609 * | |--LCURLY -> { 6610 * | |--SWITCH_RULE -> SWITCH_RULE 6611 * | | |--LITERAL_CASE -> case 6612 * | | | `--PATTERN_DEF -> PATTERN_DEF 6613 * | | | `--LITERAL_WHEN -> when 6614 * | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF 6615 * | | | | |--MODIFIERS -> MODIFIERS 6616 * | | | | |--TYPE -> TYPE 6617 * | | | | | `--IDENT -> R 6618 * | | | | |--LPAREN -> ( 6619 * | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS 6620 * | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6621 * | | | | | |--MODIFIERS -> MODIFIERS 6622 * | | | | | |--TYPE -> TYPE 6623 * | | | | | | `--IDENT -> String 6624 * | | | | | `--IDENT -> myComponent 6625 * | | | | `--RPAREN -> ) 6626 * | | | `--METHOD_CALL -> ( 6627 * | | | |--DOT -> . 6628 * | | | | |--STRING_LITERAL -> "component" 6629 * | | | | `--IDENT -> equalsIgnoreCase 6630 * | | | |--ELIST -> ELIST 6631 * | | | | `--EXPR -> EXPR 6632 * | | | | `--IDENT -> myComponent 6633 * | | | `--RPAREN -> ) 6634 * | | |--LAMBDA -> -> 6635 * | | `--SLIST -> { 6636 * | | `--RCURLY -> } 6637 * | `--RCURLY -> } 6638 * `--RCURLY -> } 6639 * </pre> 6640 * 6641 * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a> 6642 * @see #LITERAL_WHEN 6643 * @see #PATTERN_VARIABLE_DEF 6644 * @see #LITERAL_INSTANCEOF 6645 * @see #SWITCH_RULE 6646 * 6647 * @since 10.12.0 6648 */ 6649 public static final int RECORD_PATTERN_COMPONENTS = 6650 JavaLanguageLexer.RECORD_PATTERN_COMPONENTS; 6651 6652 /** 6653 * An unnamed pattern variable definition. Appears as part of a pattern definition. 6654 * 6655 * <p>For example:</p> 6656 * <pre> 6657 * if (r instanceof R(_)) {} 6658 * </pre> 6659 * 6660 * <p>parses as:</p> 6661 * <pre> 6662 * LITERAL_IF -> if 6663 * |--LPAREN -> ( 6664 * |--EXPR -> EXPR 6665 * | `--LITERAL_INSTANCEOF -> instanceof 6666 * | |--IDENT -> r 6667 * | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF 6668 * | |--MODIFIERS -> MODIFIERS 6669 * | |--TYPE -> TYPE 6670 * | | `--IDENT -> R 6671 * | |--LPAREN -> ( 6672 * | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS 6673 * | | `--UNNAMED_PATTERN_DEF -> _ 6674 * | `--RPAREN -> ) 6675 * |--RPAREN -> ) 6676 * `--SLIST -> { 6677 * `--RCURLY -> } 6678 * </pre> 6679 * 6680 * @see #RECORD_PATTERN_COMPONENTS 6681 * @see #RECORD_PATTERN_DEF 6682 * @see #LITERAL_SWITCH 6683 * @see #LITERAL_INSTANCEOF 6684 * @see #SWITCH_RULE 6685 * @see #LITERAL_WHEN 6686 * @see #PATTERN_VARIABLE_DEF 6687 * @see #PATTERN_DEF 6688 * 6689 * @since 10.14.0 6690 */ 6691 public static final int UNNAMED_PATTERN_DEF = 6692 JavaLanguageLexer.UNNAMED_PATTERN_DEF; 6693 6694 /** Prevent instantiation. */ 6695 private TokenTypes() { 6696 } 6697 6698}