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