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