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