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