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