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 * <p>For example:</p> 3638 * <pre> 3639 * if (a && b) { 3640 * } 3641 * </pre> 3642 * <p>parses as:</p> 3643 * <pre> 3644 * LITERAL_IF -> if 3645 * |--LPAREN -> ( 3646 * |--EXPR -> EXPR 3647 * | `--LAND -> && 3648 * | |--IDENT -> a 3649 * | `--IDENT -> b 3650 * |--RPAREN -> ) 3651 * |--SLIST -> { 3652 * | |--RCURLY -> } 3653 * </pre> 3654 * 3655 * @see <a 3656 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 3657 * Language Specification, §15.23</a> 3658 * @see #EXPR 3659 **/ 3660 public static final int LAND = JavaLanguageLexer.LAND; 3661 /** 3662 * The {@code |} (bitwise OR) operator. 3663 * 3664 * <p>For example:</p> 3665 * <pre> 3666 * a = a | b; 3667 * </pre> 3668 * <p>parses as:</p> 3669 * <pre> 3670 * |--EXPR -> EXPR 3671 * | `--ASSIGN -> = 3672 * | |--IDENT -> a 3673 * | `--BOR -> | 3674 * | |--IDENT -> a 3675 * | `--IDENT -> b 3676 * |--SEMI -> ; 3677 * </pre> 3678 * 3679 * @see <a 3680 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3681 * Language Specification, §15.22.1</a> 3682 * @see #EXPR 3683 **/ 3684 public static final int BOR = JavaLanguageLexer.BOR; 3685 /** 3686 * The {@code ^} (bitwise exclusive OR) operator. 3687 * 3688 * @see <a 3689 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3690 * Language Specification, §15.22.1</a> 3691 * @see #EXPR 3692 **/ 3693 public static final int BXOR = JavaLanguageLexer.BXOR; 3694 /** 3695 * The {@code &} (bitwise AND) operator. 3696 * 3697 * <p>For example:</p> 3698 * <pre> 3699 * c = a & b; 3700 * </pre> 3701 * <p>parses as:</p> 3702 * <pre> 3703 * |--EXPR -> EXPR 3704 * | `--ASSIGN -> = 3705 * | |--IDENT -> c 3706 * | `--BAND -> & 3707 * | |--IDENT -> a 3708 * | `--IDENT -> b 3709 * |--SEMI -> ; 3710 * </pre> 3711 * 3712 * @see <a 3713 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 3714 * Language Specification, §15.22.1</a> 3715 * @see #EXPR 3716 **/ 3717 public static final int BAND = JavaLanguageLexer.BAND; 3718 /** 3719 * The <code>!=</code> (not equal) operator. 3720 * 3721 * <p>For example:</p> 3722 * <pre> 3723 * a != b; 3724 * </pre> 3725 * <p>parses as:</p> 3726 * <pre> 3727 * |--EXPR -> EXPR 3728 * | `--NOT_EQUAL -> != 3729 * | |--IDENT -> a 3730 * | `--IDENT -> b 3731 * `--SEMI -> ; 3732 * </pre> 3733 * 3734 * @see #EXPR 3735 * @noinspection HtmlTagCanBeJavadocTag 3736 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded 3737 * when replaced with Javadoc tag 3738 **/ 3739 public static final int NOT_EQUAL = JavaLanguageLexer.NOT_EQUAL; 3740 /** 3741 * The {@code ==} (equal) operator. 3742 * 3743 * <p>For example:</p> 3744 * <pre> 3745 * return a == b; 3746 * </pre> 3747 * <p>parses as:</p> 3748 * <pre> 3749 * |--EXPR -> EXPR 3750 * | `--EQUAL -> == 3751 * | |--IDENT -> a 3752 * | `--IDENT -> b 3753 * `--SEMI -> ; 3754 * </pre> 3755 * 3756 * @see #EXPR 3757 **/ 3758 public static final int EQUAL = JavaLanguageLexer.EQUAL; 3759 /** 3760 * The {@code <} (less than) operator. 3761 * 3762 * <p>For example:</p> 3763 * <pre> 3764 * c = a < b; 3765 * </pre> 3766 * <p>parses as:</p> 3767 * <pre> 3768 * |--EXPR -> EXPR 3769 * | `--ASSIGN -> = 3770 * | |--IDENT -> c 3771 * | `--LT -> < 3772 * | |--IDENT -> a 3773 * | `--IDENT -> b 3774 * |--SEMI -> ; 3775 * </pre> 3776 * 3777 * @see #EXPR 3778 **/ 3779 public static final int LT = JavaLanguageLexer.LT; 3780 /** 3781 * The {@code >} (greater than) operator. 3782 * 3783 * <p>For example:</p> 3784 * <pre> 3785 * c = a > b; 3786 * </pre> 3787 * <p>parses as:</p> 3788 * <pre> 3789 * |--EXPR -> EXPR 3790 * | `--ASSIGN -> = 3791 * | |--IDENT -> c 3792 * | `--BAND -> > 3793 * | |--IDENT -> a 3794 * | `--IDENT -> b 3795 * |--SEMI -> ; 3796 * </pre> 3797 * 3798 * @see #EXPR 3799 **/ 3800 public static final int GT = JavaLanguageLexer.GT; 3801 /** 3802 * The {@code <=} (less than or equal) operator. 3803 * 3804 * <p>For example:</p> 3805 * <pre> 3806 * c = a <= b; 3807 * </pre> 3808 * <p>parses as:</p> 3809 * <pre> 3810 * |--EXPR -> EXPR 3811 * | `--ASSIGN -> = 3812 * | |--IDENT -> c 3813 * | `--LE -> <= 3814 * | |--IDENT -> a 3815 * | `--IDENT -> b 3816 * |--SEMI -> ; 3817 * </pre> 3818 * 3819 * @see #EXPR 3820 **/ 3821 public static final int LE = JavaLanguageLexer.LE; 3822 /** 3823 * The {@code >=} (greater than or equal) operator. 3824 * 3825 * <p>For example:</p> 3826 * <pre> 3827 * boolean b = a >= 3; 3828 * </pre> 3829 * <p>parses as:</p> 3830 * <pre> 3831 * VARIABLE_DEF -> VARIABLE_DEF 3832 * |--MODIFIERS -> MODIFIERS 3833 * |--TYPE -> TYPE 3834 * | `--LITERAL_BOOLEAN -> boolean 3835 * |--IDENT -> b 3836 * `--ASSIGN -> = 3837 * `--EXPR -> EXPR 3838 * `--GE -> >= 3839 * |--IDENT -> a 3840 * `--NUM_INT -> 3 3841 * </pre> 3842 * 3843 * @see #EXPR 3844 **/ 3845 public static final int GE = JavaLanguageLexer.GE; 3846 /** 3847 * The {@code instanceof} operator. The first child is an 3848 * object reference or something that evaluates to an object 3849 * reference. The second child is a reference type or pattern. 3850 * <p>For example:</p> 3851 * <pre> 3852 * boolean isBuilderReferenceType = text instanceof StringBuilder; // reference type 3853 * boolean isBuilderPatternWithPattern = 3854 * text instanceof StringBuilder s; // type pattern, no `PATTERN_DEF` 3855 * boolean isBuilderEmpty = text instanceof 3856 * (StringBuilder sb && sb.isEmpty()); // guarded pattern, `PATTERN_DEF` 3857 * </pre> 3858 * <p>parses as:</p> 3859 * <pre> 3860 * |--VARIABLE_DEF -> VARIABLE_DEF 3861 * | |--MODIFIERS -> MODIFIERS 3862 * | |--TYPE -> TYPE 3863 * | | `--LITERAL_BOOLEAN -> boolean 3864 * | |--IDENT -> isBuilderReferenceType 3865 * | `--ASSIGN -> = 3866 * | `--EXPR -> EXPR 3867 * | `--LITERAL_INSTANCEOF -> instanceof 3868 * | |--IDENT -> text 3869 * | `--TYPE -> TYPE 3870 * | `--IDENT -> StringBuilder 3871 * |--SEMI -> ; 3872 * |--VARIABLE_DEF -> VARIABLE_DEF 3873 * | |--MODIFIERS -> MODIFIERS 3874 * | |--TYPE -> TYPE 3875 * | | `--LITERAL_BOOLEAN -> boolean 3876 * | |--IDENT -> isBuilderPatternWithPattern 3877 * | `--ASSIGN -> = 3878 * | `--EXPR -> EXPR 3879 * | `--LITERAL_INSTANCEOF -> instanceof 3880 * | |--IDENT -> text 3881 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 3882 * | |--MODIFIERS -> MODIFIERS 3883 * | |--TYPE -> TYPE 3884 * | | `--IDENT -> StringBuilder 3885 * | `--IDENT -> s 3886 * |--SEMI -> ; 3887 * |--VARIABLE_DEF -> VARIABLE_DEF 3888 * | |--MODIFIERS -> MODIFIERS 3889 * | |--TYPE -> TYPE 3890 * | | `--LITERAL_BOOLEAN -> boolean 3891 * | |--IDENT -> isBuilderEmpty 3892 * | `--ASSIGN -> = 3893 * | `--EXPR -> EXPR 3894 * | `--LITERAL_INSTANCEOF -> instanceof 3895 * | |--IDENT -> text 3896 * | `--PATTERN_DEF -> PATTERN_DEF 3897 * | `--LPAREN -> ( 3898 * | |--LAND -> && 3899 * | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 3900 * | | | |--MODIFIERS -> MODIFIERS 3901 * | | | |--TYPE -> TYPE 3902 * | | | | `--IDENT -> StringBuilder 3903 * | | | `--IDENT -> sb 3904 * | | `--METHOD_CALL -> ( 3905 * | | |--DOT -> . 3906 * | | | |--IDENT -> sb 3907 * | | | `--IDENT -> isEmpty 3908 * | | |--ELIST -> ELIST 3909 * | | `--RPAREN -> ) 3910 * | `--RPAREN -> ) 3911 * `--SEMI -> ; 3912 * </pre> 3913 * 3914 * @see <a 3915 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 3916 * Language Specification, §15.20.2</a> 3917 * @see #EXPR 3918 * @see #METHOD_CALL 3919 * @see #IDENT 3920 * @see #DOT 3921 * @see #TYPE 3922 * @see #PATTERN_VARIABLE_DEF 3923 * @see #PATTERN_DEF 3924 * @see FullIdent 3925 **/ 3926 public static final int LITERAL_INSTANCEOF = 3927 JavaLanguageLexer.LITERAL_INSTANCEOF; 3928 3929 /** 3930 * The {@code <<} (shift left) operator. 3931 * 3932 * <p>For example:</p> 3933 * <pre> 3934 * a = a << b; 3935 * </pre> 3936 * <p>parses as:</p> 3937 * <pre> 3938 * |--EXPR -> EXPR 3939 * | `--ASSIGN -> = 3940 * | |--IDENT -> a 3941 * | `--SR -> << 3942 * | |--IDENT -> a 3943 * | `--IDENT -> b 3944 * |--SEMI -> ; 3945 * </pre> 3946 * 3947 * @see <a 3948 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 3949 * Language Specification, §15.19</a> 3950 * @see #EXPR 3951 **/ 3952 public static final int SL = JavaLanguageLexer.SL; 3953 /** 3954 * The {@code >>} (signed shift right) operator. 3955 * 3956 * <p>For example:</p> 3957 * <pre> 3958 * a = a >> b; 3959 * </pre> 3960 * <p>parses as:</p> 3961 * <pre> 3962 * |--EXPR -> EXPR 3963 * | `--ASSIGN -> = 3964 * | |--IDENT -> a 3965 * | `--SR -> >> 3966 * | |--IDENT -> a 3967 * | `--IDENT -> b 3968 * |--SEMI -> ; 3969 * </pre> 3970 * 3971 * @see <a 3972 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 3973 * Language Specification, §15.19</a> 3974 * @see #EXPR 3975 **/ 3976 public static final int SR = JavaLanguageLexer.SR; 3977 /** 3978 * The {@code >>>} (unsigned shift right) operator. 3979 * 3980 * <p>For example:</p> 3981 * <pre> 3982 * a >>> b; 3983 * </pre> 3984 * <p>parses as:</p> 3985 * <pre> 3986 * |--EXPR -> EXPR 3987 * | `--BSR -> >>> 3988 * | |--IDENT -> a 3989 * | `--IDENT -> b 3990 * |--SEMI -> ; 3991 * </pre> 3992 * 3993 * @see <a 3994 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 3995 * Language Specification, §15.19</a> 3996 * @see #EXPR 3997 **/ 3998 public static final int BSR = JavaLanguageLexer.BSR; 3999 /** 4000 * The {@code +} (addition) operator. 4001 * 4002 * <p>For example:</p> 4003 * <pre> 4004 * c = a + b; 4005 * </pre> 4006 * <p>parses as:</p> 4007 * <pre> 4008 * |--EXPR -> EXPR 4009 * | `--ASSIGN -> = 4010 * | |--IDENT -> c 4011 * | `--PLUS -> + 4012 * | |--IDENT -> a 4013 * | `--IDENT -> b 4014 * |--SEMI -> ; 4015 * </pre> 4016 * 4017 * @see <a 4018 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 4019 * Language Specification, §15.18</a> 4020 * @see #EXPR 4021 **/ 4022 public static final int PLUS = JavaLanguageLexer.PLUS; 4023 /** 4024 * The {@code -} (subtraction) operator. 4025 * 4026 * <p>For example:</p> 4027 * <pre> 4028 * c = a - b; 4029 * </pre> 4030 * <p>parses as:</p> 4031 * <pre> 4032 * |--EXPR -> EXPR 4033 * | `--ASSIGN -> = 4034 * | |--IDENT -> c 4035 * | `--MINUS -> - 4036 * | |--IDENT -> a 4037 * | `--IDENT -> b 4038 * |--SEMI -> ; 4039 * </pre> 4040 * 4041 * @see <a 4042 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 4043 * Language Specification, §15.18</a> 4044 * @see #EXPR 4045 **/ 4046 public static final int MINUS = JavaLanguageLexer.MINUS; 4047 /** 4048 * The {@code /} (division) operator. 4049 * 4050 * <p>For example:</p> 4051 * <pre> 4052 * a = 4 / 2; 4053 * </pre> 4054 * <p>parses as:</p> 4055 * <pre> 4056 * |--EXPR -> EXPR 4057 * | `--ASSIGN -> = 4058 * | |--IDENT -> a 4059 * | `--DIV -> / 4060 * | |--NUM_INT -> 4 4061 * | `--NUM_INT -> 2 4062 * |--SEMI -> ; 4063 * </pre> 4064 * 4065 * @see <a 4066 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 4067 * Language Specification, §15.17.2</a> 4068 * @see #EXPR 4069 **/ 4070 public static final int DIV = JavaLanguageLexer.DIV; 4071 /** 4072 * The {@code %} (remainder) operator. 4073 * 4074 * <p>For example:</p> 4075 * <pre> 4076 * c = a % b; 4077 * </pre> 4078 * <p>parses as:</p> 4079 * <pre> 4080 * EXPR -> EXPR 4081 * `--ASSIGN -> = 4082 * |--IDENT -> c 4083 * `--MOD -> % 4084 * |--IDENT -> a 4085 * `--IDENT -> b 4086 * SEMI -> ; 4087 * </pre> 4088 * 4089 * @see <a 4090 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 4091 * Language Specification, §15.17.3</a> 4092 * @see #EXPR 4093 **/ 4094 public static final int MOD = JavaLanguageLexer.MOD; 4095 /** 4096 * The {@code ++} (prefix increment) operator. 4097 * 4098 * <p>For example:</p> 4099 * <pre> 4100 * ++a; 4101 * </pre> 4102 * <p>parses as:</p> 4103 * <pre> 4104 * |--EXPR -> EXPR 4105 * | `--INC -> ++ 4106 * | `--IDENT -> a 4107 * |--SEMI -> ; 4108 * </pre> 4109 * 4110 * @see <a 4111 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 4112 * Language Specification, §15.15.1</a> 4113 * @see #EXPR 4114 * @see #POST_INC 4115 **/ 4116 public static final int INC = JavaLanguageLexer.INC; 4117 /** 4118 * The {@code --} (prefix decrement) operator. 4119 * 4120 * <p>For example:</p> 4121 * <pre> 4122 * --a; 4123 * </pre> 4124 * <p>parses as:</p> 4125 * <pre> 4126 * |--EXPR -> EXPR 4127 * | `--DEC -> -- 4128 * | `--IDENT -> a 4129 * |--SEMI -> ; 4130 * </pre> 4131 * 4132 * @see <a 4133 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 4134 * Language Specification, §15.15.2</a> 4135 * @see #EXPR 4136 * @see #POST_DEC 4137 **/ 4138 public static final int DEC = JavaLanguageLexer.DEC; 4139 /** 4140 * The {@code ~} (bitwise complement) operator. 4141 * 4142 * <p>For example:</p> 4143 * <pre> 4144 * a = ~ a; 4145 * </pre> 4146 * <p>parses as:</p> 4147 * <pre> 4148 * |--EXPR -> EXPR 4149 * | `--ASSIGN -> = 4150 * | |--IDENT -> a 4151 * | `--BNOT -> ~ 4152 * | `--IDENT -> a 4153 * |--SEMI -> ; 4154 * </pre> 4155 * 4156 * @see <a 4157 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 4158 * Language Specification, §15.15.5</a> 4159 * @see #EXPR 4160 **/ 4161 public static final int BNOT = JavaLanguageLexer.BNOT; 4162 /** 4163 * The <code>!</code> (logical complement) operator. 4164 * 4165 * <p>For example:</p> 4166 * <pre> 4167 * c = ! a; 4168 * </pre> 4169 * <p>parses as:</p> 4170 * <pre> 4171 * |--EXPR -> EXPR 4172 * | `--ASSIGN -> = 4173 * | |--IDENT -> c 4174 * | `--LNOT -> ! 4175 * | `--IDENT -> a 4176 * |--SEMI -> ; 4177 * </pre> 4178 * 4179 * @see <a 4180 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 4181 * Language Specification, §15.15.6</a> 4182 * @see #EXPR 4183 * @noinspection HtmlTagCanBeJavadocTag 4184 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded 4185 * when replaced with Javadoc tag 4186 **/ 4187 public static final int LNOT = JavaLanguageLexer.LNOT; 4188 /** 4189 * The {@code true} keyword. 4190 * 4191 * <p>For example:</p> 4192 * <pre> 4193 * boolean a = true; 4194 * </pre> 4195 * <p>parses as:</p> 4196 * <pre> 4197 * |--VARIABLE_DEF -> VARIABLE_DEF 4198 * | |--MODIFIERS -> MODIFIERS 4199 * | |--TYPE -> TYPE 4200 * | | `--LITERAL_BOOLEAN -> boolean 4201 * | |--IDENT -> a 4202 * | `--ASSIGN -> = 4203 * | `--EXPR -> EXPR 4204 * | `--LITERAL_TRUE -> true 4205 * |--SEMI -> ; 4206 * </pre> 4207 * 4208 * @see <a 4209 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 4210 * Language Specification, §3.10.3</a> 4211 * @see #EXPR 4212 * @see #LITERAL_FALSE 4213 **/ 4214 public static final int LITERAL_TRUE = 4215 JavaLanguageLexer.LITERAL_TRUE; 4216 4217 /** 4218 * The {@code false} keyword. 4219 * 4220 * <p>For example:</p> 4221 * <pre> 4222 * boolean a = false; 4223 * </pre> 4224 * <p>parses as:</p> 4225 * <pre> 4226 * VARIABLE_DEF -> VARIABLE_DEF 4227 * |--MODIFIERS -> MODIFIERS 4228 * |--TYPE -> TYPE 4229 * | `--LITERAL_BOOLEAN -> boolean 4230 * |--IDENT -> a 4231 * |--ASSIGN -> = 4232 * | `--EXPR -> EXPR 4233 * | `--LITERAL_FALSE -> false 4234 * `--SEMI -> ; 4235 * </pre> 4236 * 4237 * @see <a 4238 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 4239 * Language Specification, §3.10.3</a> 4240 * @see #EXPR 4241 * @see #LITERAL_TRUE 4242 **/ 4243 public static final int LITERAL_FALSE = 4244 JavaLanguageLexer.LITERAL_FALSE; 4245 4246 /** 4247 * The {@code null} keyword. 4248 * 4249 * <p>For example:</p> 4250 * <pre> 4251 * String s = null; 4252 * </pre> 4253 * <p>parses as:</p> 4254 * <pre> 4255 * VARIABLE_DEF -> VARIABLE_DEF 4256 * |--MODIFIERS -> MODIFIERS 4257 * |--TYPE -> TYPE 4258 * | `--IDENT -> String 4259 * |--IDENT -> s 4260 * |--ASSIGN -> = 4261 * | `--EXPR -> EXPR 4262 * | `--LITERAL_NULL -> null 4263 * `--SEMI -> ; 4264 * </pre> 4265 * 4266 * @see <a 4267 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 4268 * Language Specification, §3.10.7</a> 4269 * @see #EXPR 4270 **/ 4271 public static final int LITERAL_NULL = 4272 JavaLanguageLexer.LITERAL_NULL; 4273 4274 /** 4275 * The {@code new} keyword. This element is used to define 4276 * new instances of objects, new arrays, and new anonymous inner 4277 * classes. 4278 * 4279 * <p>For example:</p> 4280 * 4281 * <pre> 4282 * new ArrayList(50) 4283 * </pre> 4284 * 4285 * <p>parses as:</p> 4286 * <pre> 4287 * LITERAL_NEW -> new 4288 * |--IDENT -> ArrayList 4289 * |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 4290 * | |--GENERIC_START -> < 4291 * | `--GENERIC_END -> > 4292 * |--LPAREN -> ( 4293 * |--ELIST -> ELIST 4294 * | `--EXPR -> EXPR 4295 * | `--NUM_INT -> 50 4296 * `--RPAREN -> ) 4297 * </pre> 4298 * 4299 * <p>For example:</p> 4300 * <pre> 4301 * new float[] 4302 * { 4303 * 3.0f, 4304 * 4.0f 4305 * }; 4306 * </pre> 4307 * 4308 * <p>parses as:</p> 4309 * <pre> 4310 * +--LITERAL_NEW (new) 4311 * | 4312 * +--LITERAL_FLOAT (float) 4313 * +--ARRAY_DECLARATOR ([) 4314 * +--ARRAY_INIT ({) 4315 * | 4316 * +--EXPR 4317 * | 4318 * +--NUM_FLOAT (3.0f) 4319 * +--COMMA (,) 4320 * +--EXPR 4321 * | 4322 * +--NUM_FLOAT (4.0f) 4323 * +--RCURLY (}) 4324 * </pre> 4325 * 4326 * <p>For example:</p> 4327 * <pre> 4328 * new FilenameFilter() 4329 * { 4330 * public boolean accept(File dir, String name) 4331 * { 4332 * return name.endsWith(".java"); 4333 * } 4334 * } 4335 * </pre> 4336 * 4337 * <p>parses as:</p> 4338 * <pre> 4339 * +--LITERAL_NEW (new) 4340 * | 4341 * +--IDENT (FilenameFilter) 4342 * +--LPAREN (() 4343 * +--ELIST 4344 * +--RPAREN ()) 4345 * +--OBJBLOCK 4346 * | 4347 * +--LCURLY ({) 4348 * +--METHOD_DEF 4349 * | 4350 * +--MODIFIERS 4351 * | 4352 * +--LITERAL_PUBLIC (public) 4353 * +--TYPE 4354 * | 4355 * +--LITERAL_BOOLEAN (boolean) 4356 * +--IDENT (accept) 4357 * +--PARAMETERS 4358 * | 4359 * +--PARAMETER_DEF 4360 * | 4361 * +--MODIFIERS 4362 * +--TYPE 4363 * | 4364 * +--IDENT (File) 4365 * +--IDENT (dir) 4366 * +--COMMA (,) 4367 * +--PARAMETER_DEF 4368 * | 4369 * +--MODIFIERS 4370 * +--TYPE 4371 * | 4372 * +--IDENT (String) 4373 * +--IDENT (name) 4374 * +--SLIST ({) 4375 * | 4376 * +--LITERAL_RETURN (return) 4377 * | 4378 * +--EXPR 4379 * | 4380 * +--METHOD_CALL (() 4381 * | 4382 * +--DOT (.) 4383 * | 4384 * +--IDENT (name) 4385 * +--IDENT (endsWith) 4386 * +--ELIST 4387 * | 4388 * +--EXPR 4389 * | 4390 * +--STRING_LITERAL (".java") 4391 * +--RPAREN ()) 4392 * +--SEMI (;) 4393 * +--RCURLY (}) 4394 * +--RCURLY (}) 4395 * </pre> 4396 * 4397 * @see #IDENT 4398 * @see #DOT 4399 * @see #LPAREN 4400 * @see #ELIST 4401 * @see #RPAREN 4402 * @see #OBJBLOCK 4403 * @see #ARRAY_INIT 4404 * @see FullIdent 4405 **/ 4406 public static final int LITERAL_NEW = JavaLanguageLexer.LITERAL_NEW; 4407 /** 4408 * An integer literal. These may be specified in decimal, 4409 * hexadecimal, or octal form. 4410 * 4411 * <p>For example:</p> 4412 * <pre> 4413 * a = 3; 4414 * </pre> 4415 * <p>parses as:</p> 4416 * <pre> 4417 * |--EXPR -> EXPR 4418 * | `--ASSIGN -> = 4419 * | |--IDENT -> a 4420 * | `--NUM_INT -> 3 4421 * |--SEMI -> ; 4422 * </pre> 4423 * 4424 * @see <a 4425 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 4426 * Language Specification, §3.10.1</a> 4427 * @see #EXPR 4428 * @see #NUM_LONG 4429 **/ 4430 public static final int NUM_INT = JavaLanguageLexer.NUM_INT; 4431 /** 4432 * A character literal. This is a (possibly escaped) character 4433 * enclosed in single quotes. 4434 * 4435 * <p>For example:</p> 4436 * <pre> 4437 * return 'a'; 4438 * </pre> 4439 * <p>parses as:</p> 4440 * <pre> 4441 * --LITERAL_RETURN -> return 4442 * |--EXPR -> EXPR 4443 * | `--CHAR_LITERAL -> 'a' 4444 * `--SEMI -> ; 4445 * </pre> 4446 * 4447 * @see <a 4448 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 4449 * Language Specification, §3.10.4</a> 4450 * @see #EXPR 4451 **/ 4452 public static final int CHAR_LITERAL = 4453 JavaLanguageLexer.CHAR_LITERAL; 4454 4455 /** 4456 * A string literal. This is a sequence of (possibly escaped) 4457 * characters enclosed in double quotes. 4458 * <p>For example:</p> 4459 * <pre>String str = "StringLiteral";</pre> 4460 * 4461 * <p>parses as:</p> 4462 * <pre> 4463 * |--VARIABLE_DEF -> VARIABLE_DEF 4464 * | |--MODIFIERS -> MODIFIERS 4465 * | |--TYPE -> TYPE 4466 * | | `--IDENT -> String 4467 * | |--IDENT -> str 4468 * | `--ASSIGN -> = 4469 * | `--EXPR -> EXPR 4470 * | `--STRING_LITERAL -> "StringLiteral" 4471 * |--SEMI -> ; 4472 * </pre> 4473 * 4474 * @see <a 4475 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 4476 * Language Specification, §3.10.5</a> 4477 * @see #EXPR 4478 **/ 4479 public static final int STRING_LITERAL = 4480 JavaLanguageLexer.STRING_LITERAL; 4481 4482 /** 4483 * A single precision floating point literal. This is a floating 4484 * point number with an {@code F} or {@code f} suffix. 4485 * 4486 * <p>For example:</p> 4487 * <pre> 4488 * a = 3.14f; 4489 * </pre> 4490 * <p>parses as:</p> 4491 * <pre> 4492 * |--EXPR -> EXPR 4493 * | `--ASSIGN -> = 4494 * | |--IDENT -> a 4495 * | `--NUM_FLOAT -> 3.14f 4496 * |--SEMI -> ; 4497 * </pre> 4498 * 4499 * @see <a 4500 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 4501 * Language Specification, §3.10.2</a> 4502 * @see #EXPR 4503 * @see #NUM_DOUBLE 4504 **/ 4505 public static final int NUM_FLOAT = JavaLanguageLexer.NUM_FLOAT; 4506 /** 4507 * A long integer literal. These are almost the same as integer 4508 * literals, but they have an {@code L} or {@code l} 4509 * (ell) suffix. 4510 * 4511 * <p>For example:</p> 4512 * <pre> 4513 * a = 3l; 4514 * </pre> 4515 * <p>parses as:</p> 4516 * <pre> 4517 * |--EXPR -> EXPR 4518 * | `--ASSIGN -> = 4519 * | |--IDENT -> a 4520 * | `--NUM_LONG -> 3l 4521 * |--SEMI -> ; 4522 * </pre> 4523 * 4524 * @see <a 4525 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 4526 * Language Specification, §3.10.1</a> 4527 * @see #EXPR 4528 * @see #NUM_INT 4529 **/ 4530 public static final int NUM_LONG = JavaLanguageLexer.NUM_LONG; 4531 /** 4532 * A double precision floating point literal. This is a floating 4533 * point number with an optional {@code D} or {@code d} 4534 * suffix. 4535 * 4536 * <p>For example:</p> 4537 * <pre> 4538 * a = 3.14d; 4539 * </pre> 4540 * <p>parses as:</p> 4541 * <pre> 4542 * |--EXPR -> EXPR 4543 * | `--ASSIGN -> = 4544 * | |--IDENT -> a 4545 * | `--NUM_DOUBLE -> 3.14d 4546 * |--SEMI -> ; 4547 * </pre> 4548 * 4549 * @see <a 4550 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 4551 * Language Specification, §3.10.2</a> 4552 * @see #EXPR 4553 * @see #NUM_FLOAT 4554 **/ 4555 public static final int NUM_DOUBLE = JavaLanguageLexer.NUM_DOUBLE; 4556 4557 /** 4558 * The {@code assert} keyword. This is only for Java 1.4 and 4559 * later. 4560 * 4561 * <p>For example:</p> 4562 * <pre> 4563 * assert(x==4); 4564 * </pre> 4565 * <p>parses as:</p> 4566 * <pre> 4567 * LITERAL_ASSERT -> assert 4568 * |--EXPR -> EXPR 4569 * | |--LPAREN -> ( 4570 * | |--EQUAL -> == 4571 * | | |--IDENT -> x 4572 * | | `--NUM_INT -> 4 4573 * | `--RPAREN -> ) 4574 * `--SEMI -> ; 4575 * </pre> 4576 **/ 4577 public static final int LITERAL_ASSERT = JavaLanguageLexer.ASSERT; 4578 4579 /** 4580 * A static import declaration. Static import declarations are optional, 4581 * but must appear after the package declaration and before the type 4582 * declaration. 4583 * 4584 * <p>For example:</p> 4585 * <pre> 4586 * import static java.io.IOException; 4587 * </pre> 4588 * <p>parses as:</p> 4589 * <pre> 4590 * STATIC_IMPORT -> import 4591 * |--LITERAL_STATIC -> static 4592 * |--DOT -> . 4593 * | |--DOT -> . 4594 * | | |--IDENT -> java 4595 * | | `--IDENT -> io 4596 * | `--IDENT -> IOException 4597 * `--SEMI -> ; 4598 * </pre> 4599 * 4600 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4601 * JSR201</a> 4602 * @see #LITERAL_STATIC 4603 * @see #DOT 4604 * @see #IDENT 4605 * @see #STAR 4606 * @see #SEMI 4607 * @see FullIdent 4608 **/ 4609 public static final int STATIC_IMPORT = 4610 JavaLanguageLexer.STATIC_IMPORT; 4611 4612 /** 4613 * An enum declaration. Its notable children are 4614 * enum constant declarations followed by 4615 * any construct that may be expected in a class body. 4616 * 4617 * <p>For example:</p> 4618 * <pre> 4619 * public enum MyEnum 4620 * implements Serializable 4621 * { 4622 * FIRST_CONSTANT, 4623 * SECOND_CONSTANT; 4624 * 4625 * public void someMethod() 4626 * { 4627 * } 4628 * } 4629 * </pre> 4630 * <p>parses as:</p> 4631 * <pre> 4632 * ENUM_DEF -> ENUM_DEF 4633 * |--MODIFIERS -> MODIFIERS 4634 * | `--LITERAL_PUBLIC -> public 4635 * |--ENUM -> enum 4636 * |--IDENT -> MyEnum 4637 * |--IMPLEMENTS_CLAUSE -> implements 4638 * | `--IDENT -> Serializable 4639 * `--OBJBLOCK -> OBJBLOCK 4640 * |--LCURLY -> { 4641 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF 4642 * | |--ANNOTATIONS -> ANNOTATIONS 4643 * | `--IDENT -> FIRST_CONSTANT 4644 * |--COMMA -> , 4645 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF 4646 * | |--ANNOTATIONS -> ANNOTATIONS 4647 * | `--IDENT -> SECOND_CONSTANT 4648 * |--SEMI -> ; 4649 * |--METHOD_DEF -> METHOD_DEF 4650 * | |--MODIFIERS -> MODIFIERS 4651 * | | `--LITERAL_PUBLIC -> public 4652 * | |--TYPE -> TYPE 4653 * | | `--LITERAL_VOID -> void 4654 * | |--IDENT -> someMethod 4655 * | |--LPAREN -> ( 4656 * | |--PARAMETERS -> PARAMETERS 4657 * | |--RPAREN -> ) 4658 * | `--SLIST -> { 4659 * | `--RCURLY -> } 4660 * `--RCURLY -> } 4661 * </pre> 4662 * 4663 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4664 * JSR201</a> 4665 * @see #MODIFIERS 4666 * @see #ENUM 4667 * @see #IDENT 4668 * @see #EXTENDS_CLAUSE 4669 * @see #IMPLEMENTS_CLAUSE 4670 * @see #OBJBLOCK 4671 * @see #LITERAL_NEW 4672 * @see #ENUM_CONSTANT_DEF 4673 **/ 4674 public static final int ENUM_DEF = 4675 JavaLanguageLexer.ENUM_DEF; 4676 4677 /** 4678 * The {@code enum} keyword. This element appears 4679 * as part of an enum declaration. 4680 * 4681 * <p>For example:</p> 4682 * <pre> 4683 * public enum Count {} 4684 * </pre> 4685 * <p>parses as:</p> 4686 * <pre> 4687 * ENUM_DEF -> ENUM_DEF 4688 * |--MODIFIERS -> MODIFIERS 4689 * | `--LITERAL_PUBLIC -> public 4690 * |--ENUM -> enum 4691 * |--IDENT -> Count 4692 * `--OBJBLOCK -> OBJBLOCK 4693 * |--LCURLY -> { 4694 * `--RCURLY -> } 4695 * </pre> 4696 * 4697 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">JSR201</a> 4698 * @see #MODIFIERS 4699 * @see #ENUM_DEF 4700 * @see #IDENT 4701 * @see #OBJBLOCK 4702 **/ 4703 public static final int ENUM = 4704 JavaLanguageLexer.ENUM; 4705 4706 /** 4707 * An enum constant declaration. Its notable children are annotations, 4708 * arguments and object block akin to an anonymous 4709 * inner class' body. 4710 * 4711 * <p>For example:</p> 4712 * <pre> 4713 * SOME_CONSTANT(1) 4714 * { 4715 * public void someMethodOverriddenFromMainBody() 4716 * { 4717 * } 4718 * } 4719 * </pre> 4720 * <p>parses as:</p> 4721 * <pre> 4722 * ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF 4723 * | |--ANNOTATIONS -> ANNOTATIONS 4724 * | |--IDENT -> SOME_CONSTANT 4725 * | |--LPAREN -> ( 4726 * | |--ELIST -> ELIST 4727 * | | `--EXPR -> EXPR 4728 * | | `--NUM_INT -> 1 4729 * | |--RPAREN -> ) 4730 * | `--OBJBLOCK -> OBJBLOCK 4731 * | |--LCURLY -> { 4732 * | |--METHOD_DEF -> METHOD_DEF 4733 * | | |--MODIFIERS -> MODIFIERS 4734 * | | | `--LITERAL_PUBLIC -> public 4735 * | | |--TYPE -> TYPE 4736 * | | | `--LITERAL_VOID -> void 4737 * | | |--IDENT -> someMethodOverriddenFromMainBody 4738 * | | |--LPAREN -> ( 4739 * | | |--PARAMETERS -> PARAMETERS 4740 * | | |--RPAREN -> ) 4741 * | | `--SLIST -> { 4742 * | | `--RCURLY -> } 4743 * | `--RCURLY -> } 4744 * </pre> 4745 * 4746 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4747 * JSR201</a> 4748 * @see #ANNOTATIONS 4749 * @see #MODIFIERS 4750 * @see #IDENT 4751 * @see #ELIST 4752 * @see #OBJBLOCK 4753 **/ 4754 public static final int ENUM_CONSTANT_DEF = 4755 JavaLanguageLexer.ENUM_CONSTANT_DEF; 4756 4757 /** 4758 * A for-each clause. This is a child of 4759 * {@code LITERAL_FOR}. The children of this element may be 4760 * a parameter definition, the colon literal and an expression. 4761 * 4762 * <p>For example:</p> 4763 * <pre> 4764 * for (int value : values) { 4765 * doSmth(); 4766 * } 4767 * </pre> 4768 * <p>parses as:</p> 4769 * <pre> 4770 * LITERAL_FOR -> for 4771 * |--LPAREN -> ( 4772 * |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE 4773 * | |--VARIABLE_DEF -> VARIABLE_DEF 4774 * | | |--MODIFIERS -> MODIFIERS 4775 * | | |--TYPE -> TYPE 4776 * | | | `--LITERAL_INT -> int 4777 * | | `--IDENT -> value 4778 * | |--COLON -> : 4779 * | `--EXPR -> EXPR 4780 * | `--IDENT -> values 4781 * |--RPAREN -> ) 4782 * `--SLIST -> { 4783 * |--EXPR -> EXPR 4784 * | `--METHOD_CALL -> ( 4785 * | |--IDENT -> doSmth 4786 * | |--ELIST -> ELIST 4787 * | `--RPAREN -> ) 4788 * |--SEMI -> ; 4789 * `--RCURLY -> } 4790 * </pre> 4791 * 4792 * @see #VARIABLE_DEF 4793 * @see #ELIST 4794 * @see #LITERAL_FOR 4795 **/ 4796 public static final int FOR_EACH_CLAUSE = 4797 JavaLanguageLexer.FOR_EACH_CLAUSE; 4798 4799 /** 4800 * An annotation declaration. The notable children are the name of the 4801 * annotation type, annotation field declarations and (constant) fields. 4802 * 4803 * <p>For example:</p> 4804 * <pre> 4805 * public @interface MyAnnotation 4806 * { 4807 * int someValue(); 4808 * } 4809 * </pre> 4810 * <p>parses as:</p> 4811 * <pre> 4812 * ANNOTATION_DEF -> ANNOTATION_DEF 4813 * |--MODIFIERS -> MODIFIERS 4814 * | `--LITERAL_PUBLIC -> public 4815 * |--AT -> @ 4816 * |--LITERAL_INTERFACE -> interface 4817 * |--IDENT -> MyAnnotation 4818 * `--OBJBLOCK -> OBJBLOCK 4819 * |--LCURLY -> { 4820 * |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF 4821 * | |--MODIFIERS -> MODIFIERS 4822 * | |--TYPE -> TYPE 4823 * | | `--LITERAL_INT -> int 4824 * | |--IDENT -> someValue 4825 * | |--LPAREN -> ( 4826 * | |--RPAREN -> ) 4827 * | `--SEMI -> ; 4828 * `--RCURLY -> } 4829 * </pre> 4830 * 4831 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4832 * JSR201</a> 4833 * @see #MODIFIERS 4834 * @see #LITERAL_INTERFACE 4835 * @see #IDENT 4836 * @see #OBJBLOCK 4837 * @see #ANNOTATION_FIELD_DEF 4838 **/ 4839 public static final int ANNOTATION_DEF = 4840 JavaLanguageLexer.ANNOTATION_DEF; 4841 4842 /** 4843 * An annotation field declaration. The notable children are modifiers, 4844 * field type, field name and an optional default value (a conditional 4845 * compile-time constant expression). Default values may also be 4846 * annotations. 4847 * 4848 * <p>For example:</p> 4849 * 4850 * <pre> 4851 * String someField() default "Hello world"; 4852 * </pre> 4853 * 4854 * <p>parses as:</p> 4855 * 4856 * <pre> 4857 * ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF 4858 * |--MODIFIERS -> MODIFIERS 4859 * |--TYPE -> TYPE 4860 * | `--IDENT -> String 4861 * |--IDENT -> someField 4862 * |--LPAREN -> ( 4863 * |--RPAREN -> ) 4864 * |--LITERAL_DEFAULT -> default 4865 * | `--EXPR -> EXPR 4866 * | `--STRING_LITERAL -> "Hello world" 4867 * `--SEMI -> ; 4868 * </pre> 4869 * 4870 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4871 * JSR201</a> 4872 * @see #MODIFIERS 4873 * @see #TYPE 4874 * @see #LITERAL_DEFAULT 4875 */ 4876 public static final int ANNOTATION_FIELD_DEF = 4877 JavaLanguageLexer.ANNOTATION_FIELD_DEF; 4878 4879 // note: @ is the html escape for '@', 4880 // used here to avoid confusing the javadoc tool 4881 /** 4882 * A collection of annotations on a package or enum constant. 4883 * A collections of annotations will only occur on these nodes 4884 * as all other nodes that may be qualified with an annotation can 4885 * be qualified with any other modifier and hence these annotations 4886 * would be contained in a {@link #MODIFIERS} node. 4887 * 4888 * <p>For example:</p> 4889 * 4890 * <pre> 4891 * @MyAnnotation package blah; 4892 * </pre> 4893 * 4894 * <p>parses as:</p> 4895 * 4896 * <pre> 4897 * PACKAGE_DEF -> package 4898 * |--ANNOTATIONS -> ANNOTATIONS 4899 * | `--ANNOTATION -> ANNOTATION 4900 * | |--AT -> @ 4901 * | `--IDENT -> MyAnnotation 4902 * |--IDENT -> blah 4903 * `--SEMI -> ; 4904 * </pre> 4905 * 4906 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4907 * JSR201</a> 4908 * @see #ANNOTATION 4909 * @see #AT 4910 * @see #IDENT 4911 */ 4912 public static final int ANNOTATIONS = 4913 JavaLanguageLexer.ANNOTATIONS; 4914 4915 // note: @ is the html escape for '@', 4916 // used here to avoid confusing the javadoc tool 4917 /** 4918 * An annotation of a package, type, field, parameter or variable. 4919 * An annotation may occur anywhere modifiers occur (it is a 4920 * type of modifier) and may also occur prior to a package definition. 4921 * The notable children are: The annotation name and either a single 4922 * default annotation value or a sequence of name value pairs. 4923 * Annotation values may also be annotations themselves. 4924 * 4925 * <p>For example:</p> 4926 * <pre> 4927 * @MyAnnotation(someField1 = "Hello", 4928 * someField2 = @SomeOtherAnnotation) 4929 * </pre> 4930 * <p>parses as:</p> 4931 * <pre> 4932 * ANNOTATION -> ANNOTATION 4933 * |--AT -> @ 4934 * |--IDENT -> MyAnnotation 4935 * |--LPAREN -> ( 4936 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR 4937 * | |--IDENT -> someField1 4938 * | |--ASSIGN -> = 4939 * | `--EXPR -> EXPR 4940 * | `--STRING_LITERAL -> "Hello" 4941 * |--COMMA -> , 4942 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR 4943 * | |--IDENT -> someField2 4944 * | |--ASSIGN -> = 4945 * | `--ANNOTATION -> ANNOTATION 4946 * | |--AT -> @ 4947 * | `--IDENT -> SomeOtherAnnotation 4948 * `--RPAREN -> ) 4949 * </pre> 4950 * 4951 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4952 * JSR201</a> 4953 * @see #MODIFIERS 4954 * @see #IDENT 4955 * @see #ANNOTATION_MEMBER_VALUE_PAIR 4956 */ 4957 public static final int ANNOTATION = 4958 JavaLanguageLexer.ANNOTATION; 4959 4960 /** 4961 * An initialization of an annotation member with a value. 4962 * Its children are the name of the member, the assignment literal 4963 * and the (compile-time constant conditional expression) value. 4964 * 4965 * <p>For example:</p> 4966 * <pre> 4967 * @Annotation( 4968 * value="123" 4969 * ) 4970 * </pre> 4971 * <p>parses as:</p> 4972 * <pre> 4973 * ANNOTATION -> ANNOTATION 4974 * |--AT -> @ 4975 * |--IDENT -> Annotation 4976 * |--LPAREN -> ( 4977 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR 4978 * | |--IDENT -> value 4979 * | |--ASSIGN -> = 4980 * | `--EXPR -> EXPR 4981 * | `--STRING_LITERAL -> "123" 4982 * `--RPAREN -> ) 4983 * </pre> 4984 * 4985 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 4986 * JSR201</a> 4987 * @see #ANNOTATION 4988 * @see #IDENT 4989 */ 4990 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 4991 JavaLanguageLexer.ANNOTATION_MEMBER_VALUE_PAIR; 4992 4993 /** 4994 * An annotation array member initialization. 4995 * Initializers can not be nested. 4996 * An initializer may be present as a default to an annotation 4997 * member, as the single default value to an annotation 4998 * (e.g. @Annotation({1,2})) or as the value of an annotation 4999 * member value pair. 5000 * 5001 * <p>For example:</p> 5002 * <pre> 5003 * @Annotation({1, 2}) 5004 * </pre> 5005 * <p>parses as:</p> 5006 * <pre> 5007 * ANNOTATION -> ANNOTATION 5008 * |--AT -> @ 5009 * |--IDENT -> Annotation 5010 * |--LPAREN -> ( 5011 * |--ANNOTATION_ARRAY_INIT -> { 5012 * | |--EXPR -> EXPR 5013 * | | `--NUM_INT -> 1 5014 * | |--COMMA -> , 5015 * | |--EXPR -> EXPR 5016 * | | `--NUM_INT -> 2 5017 * | `--RCURLY -> } 5018 * `--RPAREN -> ) 5019 * </pre> 5020 * 5021 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5022 * JSR201</a> 5023 * @see #ANNOTATION 5024 * @see #IDENT 5025 * @see #ANNOTATION_MEMBER_VALUE_PAIR 5026 */ 5027 public static final int ANNOTATION_ARRAY_INIT = 5028 JavaLanguageLexer.ANNOTATION_ARRAY_INIT; 5029 5030 /** 5031 * A list of type parameters to a class, interface or 5032 * method definition. Children are LT, at least one 5033 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 5034 * TYPE_PARAMETER and a final GT. 5035 * 5036 * <p>For example:</p> 5037 * 5038 * <pre> 5039 * public class MyClass<A, B> { 5040 * 5041 * } 5042 * </pre> 5043 * 5044 * <p>parses as:</p> 5045 * 5046 * <pre> 5047 * CLASS_DEF -> CLASS_DEF 5048 * |--MODIFIERS -> MODIFIERS 5049 * | `--LITERAL_PUBLIC -> public 5050 * |--LITERAL_CLASS -> class 5051 * |--IDENT -> MyClass 5052 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5053 * | |--GENERIC_START -> < 5054 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5055 * | | `--IDENT -> A 5056 * | |--COMMA -> , 5057 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5058 * | | `--IDENT -> B 5059 * | `--GENERIC_END -> > 5060 * `--OBJBLOCK -> OBJBLOCK 5061 * |--LCURLY -> { 5062 * `--RCURLY -> } 5063 * </pre> 5064 * 5065 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5066 * Generic Classes and Type Parameters</a> 5067 * @see #GENERIC_START 5068 * @see #GENERIC_END 5069 * @see #TYPE_PARAMETER 5070 * @see #COMMA 5071 */ 5072 public static final int TYPE_PARAMETERS = 5073 JavaLanguageLexer.TYPE_PARAMETERS; 5074 5075 /** 5076 * A type parameter to a class, interface or method definition. 5077 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 5078 * 5079 * <p>For example:</p> 5080 * 5081 * <pre> 5082 * public class MyClass <A extends Collection> { 5083 * 5084 * } 5085 * </pre> 5086 * 5087 * <p>parses as:</p> 5088 * 5089 * <pre> 5090 * CLASS_DEF -> CLASS_DEF 5091 * |--MODIFIERS -> MODIFIERS 5092 * | `--LITERAL_PUBLIC -> public 5093 * |--LITERAL_CLASS -> class 5094 * |--IDENT -> MyClass 5095 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5096 * | |--GENERIC_START -> < 5097 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5098 * | | |--IDENT -> A 5099 * | | `--TYPE_UPPER_BOUNDS -> extends 5100 * | | `--IDENT -> Collection 5101 * | `--GENERIC_END -> > 5102 * `--OBJBLOCK -> OBJBLOCK 5103 * |--LCURLY -> { 5104 * `--RCURLY -> } 5105 * </pre> 5106 * 5107 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5108 * Generic Classes and Type Parameters</a> 5109 * @see #IDENT 5110 * @see #WILDCARD_TYPE 5111 * @see #TYPE_UPPER_BOUNDS 5112 */ 5113 public static final int TYPE_PARAMETER = 5114 JavaLanguageLexer.TYPE_PARAMETER; 5115 5116 /** 5117 * A list of type arguments to a type reference or 5118 * a method/ctor invocation. Children are GENERIC_START, at least one 5119 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 5120 * TYPE_ARGUMENT, and a final GENERIC_END. 5121 * 5122 * <p>For example:</p> 5123 * 5124 * <pre> 5125 * public Collection<?> a; 5126 * </pre> 5127 * 5128 * <p>parses as:</p> 5129 * 5130 * <pre> 5131 * VARIABLE_DEF -> VARIABLE_DEF 5132 * |--MODIFIERS -> MODIFIERS 5133 * | `--LITERAL_PUBLIC -> public 5134 * |--TYPE -> TYPE 5135 * | |--IDENT -> Collection 5136 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5137 * | |--GENERIC_START -> < 5138 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5139 * | | `--WILDCARD_TYPE -> ? 5140 * | `--GENERIC_END -> > 5141 * |--IDENT -> a 5142 * `--SEMI -> ; 5143 * </pre> 5144 * 5145 * @see #GENERIC_START 5146 * @see #GENERIC_END 5147 * @see #TYPE_ARGUMENT 5148 * @see #COMMA 5149 */ 5150 public static final int TYPE_ARGUMENTS = 5151 JavaLanguageLexer.TYPE_ARGUMENTS; 5152 5153 /** 5154 * A type arguments to a type reference or a method/ctor invocation. 5155 * Children are either: type name or wildcard type with possible type 5156 * upper or lower bounds. 5157 * <p>For example:</p> 5158 * <pre>List<? super List> list;</pre> 5159 * <p>parses as:</p> 5160 * <pre> 5161 * VARIABLE_DEF -> VARIABLE_DEF 5162 * |--MODIFIERS -> MODIFIERS 5163 * |--TYPE -> TYPE 5164 * | |--IDENT -> List 5165 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5166 * | |--GENERIC_START -> < 5167 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5168 * | | |--WILDCARD_TYPE -> ? 5169 * | | `--TYPE_LOWER_BOUNDS -> super 5170 * | | `--IDENT -> List 5171 * | `--GENERIC_END -> > 5172 * |--IDENT -> list 5173 * `--SEMI -> ; 5174 * </pre> 5175 * 5176 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5177 * Generic Classes and Type Parameters</a> 5178 * @see #WILDCARD_TYPE 5179 * @see #TYPE_UPPER_BOUNDS 5180 * @see #TYPE_LOWER_BOUNDS 5181 */ 5182 public static final int TYPE_ARGUMENT = 5183 JavaLanguageLexer.TYPE_ARGUMENT; 5184 5185 /** 5186 * The type that refers to all types. This node has no children. 5187 * <p> For example: </p> 5188 * <pre> 5189 * 5190 * List<?> list; 5191 * </pre> 5192 * <p>parses as:</p> 5193 * <pre> 5194 * |--VARIABLE_DEF -> VARIABLE_DEF 5195 * | |--MODIFIERS -> MODIFIERS 5196 * | |--TYPE -> TYPE 5197 * | | |--IDENT -> List 5198 * | | |`--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5199 * | | |--GENERIC_START -> < 5200 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5201 * | | | `--WILDCARD_TYPE -> ? 5202 * | | `--GENERIC_END -> > 5203 * | `--IDENT -> list 5204 * |--SEMI -> ; 5205 * </pre> 5206 * 5207 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5208 * Generic Classes and Type Parameters</a> 5209 * @see #TYPE_ARGUMENT 5210 * @see #TYPE_UPPER_BOUNDS 5211 * @see #TYPE_LOWER_BOUNDS 5212 */ 5213 public static final int WILDCARD_TYPE = 5214 JavaLanguageLexer.WILDCARD_TYPE; 5215 5216 /** 5217 * An upper bounds on a wildcard type argument or type parameter. 5218 * This node has one child - the type that is being used for 5219 * the bounding. 5220 * <p>For example:</p> 5221 * <pre>List<? extends Number> list;</pre> 5222 * 5223 * <p>parses as:</p> 5224 * <pre> 5225 * --VARIABLE_DEF -> VARIABLE_DEF 5226 * |--MODIFIERS -> MODIFIERS 5227 * |--TYPE -> TYPE 5228 * | |--IDENT -> List 5229 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5230 * | |--GENERIC_START -> < 5231 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5232 * | | |--WILDCARD_TYPE -> ? 5233 * | | `--TYPE_UPPER_BOUNDS -> extends 5234 * | | `--IDENT -> Number 5235 * | `--GENERIC_END -> > 5236 * |--IDENT -> list 5237 * `--SEMI -> ; 5238 * </pre> 5239 * 5240 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5241 * Generic Classes and Type Parameters</a> 5242 * @see #TYPE_PARAMETER 5243 * @see #TYPE_ARGUMENT 5244 * @see #WILDCARD_TYPE 5245 */ 5246 public static final int TYPE_UPPER_BOUNDS = 5247 JavaLanguageLexer.TYPE_UPPER_BOUNDS; 5248 5249 /** 5250 * A lower bounds on a wildcard type argument. This node has one child 5251 * - the type that is being used for the bounding. 5252 * 5253 * <p>For example:</p> 5254 * <pre>List<? super Integer> list;</pre> 5255 * 5256 * <p>parses as:</p> 5257 * <pre> 5258 * --VARIABLE_DEF -> VARIABLE_DEF 5259 * |--MODIFIERS -> MODIFIERS 5260 * |--TYPE -> TYPE 5261 * | |--IDENT -> List 5262 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 5263 * | |--GENERIC_START -> < 5264 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 5265 * | | |--WILDCARD_TYPE -> ? 5266 * | | `--TYPE_LOWER_BOUNDS -> super 5267 * | | `--IDENT -> Integer 5268 * | `--GENERIC_END -> > 5269 * |--IDENT -> list 5270 * `--SEMI -> ; 5271 * </pre> 5272 * 5273 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2"> 5274 * Generic Classes and Type Parameters</a> 5275 * @see #TYPE_ARGUMENT 5276 * @see #WILDCARD_TYPE 5277 */ 5278 public static final int TYPE_LOWER_BOUNDS = 5279 JavaLanguageLexer.TYPE_LOWER_BOUNDS; 5280 5281 /** 5282 * An {@code @} symbol - signifying an annotation instance or the prefix 5283 * to the interface literal signifying the definition of an annotation 5284 * declaration. 5285 * 5286 * <p>For example:</p> 5287 * <pre> 5288 * @Deprecated 5289 * private int value; 5290 * </pre> 5291 * 5292 * <p>parses as:</p> 5293 * <pre> 5294 * VARIABLE_DEF -> VARIABLE_DEF 5295 * |--MODIFIERS -> MODIFIERS 5296 * | |--ANNOTATION -> ANNOTATION 5297 * | | |--AT -> @ 5298 * | | `--IDENT -> Deprecated 5299 * | `--LITERAL_PRIVATE -> private 5300 * |--TYPE -> TYPE 5301 * | `--LITERAL_INT -> int 5302 * |--IDENT -> value 5303 * `--SEMI -> ; 5304 * </pre> 5305 * 5306 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5307 * JSR201</a> 5308 */ 5309 public static final int AT = JavaLanguageLexer.AT; 5310 5311 /** 5312 * A triple dot for variable-length parameters. This token only ever occurs 5313 * in a parameter declaration immediately after the type of the parameter. 5314 * 5315 * <p>For example:</p> 5316 * <pre> 5317 * public void myShape(int... dimension) { 5318 * 5319 * } 5320 * </pre> 5321 * 5322 * <p>parses as:</p> 5323 * <pre> 5324 * METHOD_DEF -> METHOD_DEF 5325 * |--MODIFIERS -> MODIFIERS 5326 * | `--LITERAL_PUBLIC -> public 5327 * |--TYPE -> TYPE 5328 * | `--LITERAL_VOID -> void 5329 * |--IDENT -> myShape 5330 * |--LPAREN -> ( 5331 * |--PARAMETERS -> PARAMETERS 5332 * | `--PARAMETER_DEF -> PARAMETER_DEF 5333 * | |--MODIFIERS -> MODIFIERS 5334 * | |--TYPE -> TYPE 5335 * | | `--LITERAL_INT -> int 5336 * | |--ELLIPSIS -> ... 5337 * | `--IDENT -> dimension 5338 * |--RPAREN -> ) 5339 * `--SLIST -> { 5340 * `--RCURLY -> } 5341 * </pre> 5342 * 5343 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 5344 * JSR201</a> 5345 */ 5346 public static final int ELLIPSIS = JavaLanguageLexer.ELLIPSIS; 5347 5348 /** 5349 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain 5350 * or a type cast expression with an additional interface. 5351 * 5352 * <p>Generic type bounds extension: 5353 * {@code class Comparable<T extends Serializable & CharSequence>}</p> 5354 * <pre> 5355 * CLASS_DEF -> CLASS_DEF 5356 * |--MODIFIERS -> MODIFIERS 5357 * |--LITERAL_CLASS -> class 5358 * |--IDENT -> Comparable 5359 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5360 * |--GENERIC_START -> < 5361 * |--TYPE_PARAMETER -> TYPE_PARAMETER 5362 * | |--IDENT -> T 5363 * | `--TYPE_UPPER_BOUNDS -> extends 5364 * | |--IDENT -> Serializable 5365 * | |--TYPE_EXTENSION_AND -> & 5366 * | `--IDENT -> CharSequence 5367 * `--GENERIC_END -> > 5368 * </pre> 5369 * 5370 * <p>Type cast extension: 5371 * {@code return (Serializable & CharSequence) null;}</p> 5372 * <pre> 5373 * --LITERAL_RETURN -> return 5374 * |--EXPR -> EXPR 5375 * | `--TYPECAST -> ( 5376 * | |--TYPE -> TYPE 5377 * | | `--IDENT -> Serializable 5378 * | |--TYPE_EXTENSION_AND -> & 5379 * | |--TYPE -> TYPE 5380 * | | `--IDENT -> CharSequence 5381 * | |--RPAREN -> ) 5382 * | `--LITERAL_NULL -> null 5383 * `--SEMI -> ; 5384 * </pre> 5385 * 5386 * @see #EXTENDS_CLAUSE 5387 * @see #TYPECAST 5388 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4"> 5389 * Java Language Specification, §4.4</a> 5390 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16"> 5391 * Java Language Specification, §15.16</a> 5392 */ 5393 public static final int TYPE_EXTENSION_AND = 5394 JavaLanguageLexer.TYPE_EXTENSION_AND; 5395 5396 /** 5397 * A {@code <} symbol signifying the start of type arguments or type parameters. 5398 * 5399 * <p>For example:</p> 5400 * <pre> 5401 * class Test<T> {} 5402 * </pre> 5403 * <p>parses as:</p> 5404 * <pre> 5405 * CLASS_DEF -> CLASS_DEF 5406 * |--MODIFIERS -> MODIFIERS 5407 * |--LITERAL_CLASS -> class 5408 * |--IDENT -> Test 5409 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5410 * | |--GENERIC_START -> < 5411 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5412 * | | `--IDENT -> T 5413 * | `--GENERIC_END -> > 5414 * `--OBJBLOCK -> OBJBLOCK 5415 * |--LCURLY -> { 5416 * `--RCURLY -> } 5417 * </pre> 5418 * 5419 * @see #MODIFIERS 5420 * @see #IDENT 5421 * @see #OBJBLOCK 5422 * @see #TYPE_PARAMETERS 5423 * @see #GENERIC_END 5424 */ 5425 public static final int GENERIC_START = 5426 JavaLanguageLexer.GENERIC_START; 5427 5428 /** 5429 * A {@code >} symbol signifying the end of type arguments or type parameters. 5430 * 5431 * <p>For example:</p> 5432 * <pre> 5433 * class Test<T> {} 5434 * </pre> 5435 * <p>parses as:</p> 5436 * <pre> 5437 * CLASS_DEF -> CLASS_DEF 5438 * |--MODIFIERS -> MODIFIERS 5439 * |--LITERAL_CLASS -> class 5440 * |--IDENT -> Test 5441 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS 5442 * | |--GENERIC_START -> < 5443 * | |--TYPE_PARAMETER -> TYPE_PARAMETER 5444 * | | `--IDENT -> T 5445 * | `--GENERIC_END -> > 5446 * `--OBJBLOCK -> OBJBLOCK 5447 * |--LCURLY -> { 5448 * `--RCURLY -> } 5449 * </pre> 5450 * 5451 * @see #MODIFIERS 5452 * @see #IDENT 5453 * @see #OBJBLOCK 5454 * @see #TYPE_PARAMETERS 5455 * @see #GENERIC_START 5456 */ 5457 public static final int GENERIC_END = JavaLanguageLexer.GENERIC_END; 5458 5459 /** 5460 * Special lambda symbol {@code ->}. 5461 * 5462 * <p>For example:</p> 5463 * <pre> 5464 * numbers.forEach((n) -> System.out.println(n)); 5465 * </pre> 5466 * <p>parses as:</p> 5467 * <pre> 5468 * METHOD_CALL -> ( 5469 * |--DOT -> . 5470 * | |--IDENT -> numbers 5471 * | `--IDENT -> forEach 5472 * |--ELIST -> ELIST 5473 * | `--LAMBDA -> -> 5474 * | |--LPAREN -> ( 5475 * | |--PARAMETERS -> PARAMETERS 5476 * | | `--PARAMETER_DEF -> PARAMETER_DEF 5477 * | | |--MODIFIERS -> MODIFIERS 5478 * | | |--TYPE -> TYPE 5479 * | | `--IDENT -> n 5480 * | |--RPAREN -> ) 5481 * | `--EXPR -> EXPR 5482 * | `--METHOD_CALL -> ( 5483 * | |--DOT -> . 5484 * | | |--DOT -> . 5485 * | | | |--IDENT -> System 5486 * | | | `--IDENT -> out 5487 * | | `--IDENT -> println 5488 * | |--ELIST -> ELIST 5489 * | | `--EXPR -> EXPR 5490 * | | `--IDENT -> n 5491 * | `--RPAREN -> ) 5492 * `--RPAREN -> ) 5493 * </pre> 5494 * 5495 */ 5496 public static final int LAMBDA = JavaLanguageLexer.LAMBDA; 5497 5498 /** 5499 * Beginning of single-line comment: '//'. 5500 * 5501 * <pre> 5502 * +--SINGLE_LINE_COMMENT 5503 * | 5504 * +--COMMENT_CONTENT 5505 * </pre> 5506 * 5507 * <p>For example:</p> 5508 * <pre> 5509 * // Comment content 5510 * </pre> 5511 * <p>parses as:</p> 5512 * <pre> 5513 * SINGLE_LINE_COMMENT -> // 5514 * `--COMMENT_CONTENT -> Comment Content\n 5515 * </pre> 5516 */ 5517 public static final int SINGLE_LINE_COMMENT = 5518 JavaLanguageLexer.SINGLE_LINE_COMMENT; 5519 5520 /** 5521 * Beginning of block comment: '/*'. 5522 * <p>For example:</p> 5523 * <pre> 5524 * /* Comment content 5525 * */ 5526 * </pre> 5527 * <p>parses as:</p> 5528 * <pre> 5529 * --BLOCK_COMMENT_BEGIN -> /* 5530 * |--COMMENT_CONTENT -> Comment content\r\n 5531 * `--BLOCK_COMMENT_END -> */ 5532 * </pre> 5533 */ 5534 public static final int BLOCK_COMMENT_BEGIN = 5535 JavaLanguageLexer.BLOCK_COMMENT_BEGIN; 5536 5537 /** 5538 * End of block comment: '*/'. 5539 * 5540 * <p>For example:</p> 5541 * <pre> 5542 * /*comment*/ 5543 * </pre> 5544 * <p>parses as:</p> 5545 * <pre> 5546 * BLOCK_COMMENT_BEGIN -> /* 5547 * |--COMMENT_CONTENT -> comment 5548 * `--BLOCK_COMMENT_END -> */ 5549 * </pre> 5550 * 5551 */ 5552 public static final int BLOCK_COMMENT_END = 5553 JavaLanguageLexer.BLOCK_COMMENT_END; 5554 5555 /** 5556 * Text of single-line or block comment. 5557 * 5558 * <p>For example:</p> 5559 * <pre> 5560 * //this is single-line comment 5561 * 5562 * /* 5563 * this is multiline comment 5564 * */ 5565 * </pre> 5566 * <p>parses as:</p> 5567 * <pre> 5568 * |--SINGLE_LINE_COMMENT -> // 5569 * | `--COMMENT_CONTENT -> this is single-line comment\n 5570 * |--BLOCK_COMMENT_BEGIN -> /* 5571 * | |--COMMENT_CONTENT -> \n\t\t\tthis is multiline comment\n\t\t 5572 * | `--BLOCK_COMMENT_END -> */ 5573 * </pre> 5574 * 5575 */ 5576 public static final int COMMENT_CONTENT = 5577 JavaLanguageLexer.COMMENT_CONTENT; 5578 5579 /** 5580 * A pattern variable definition; when conditionally matched, 5581 * this variable is assigned with the defined type. 5582 * 5583 * <p>For example:</p> 5584 * <pre> 5585 * if (obj instanceof String str) { } 5586 * </pre> 5587 * <p>parses as:</p> 5588 * <pre> 5589 * LITERAL_IF -> if 5590 * |--LPAREN -> ( 5591 * |--EXPR -> EXPR 5592 * | `--LITERAL_INSTANCEOF -> instanceof 5593 * | |--IDENT -> obj 5594 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 5595 * | |--TYPE -> TYPE 5596 * | | `--IDENT -> String 5597 * | `--IDENT -> str 5598 * |--RPAREN -> ) 5599 * `--SLIST -> { 5600 * `--RCURLY -> } 5601 * </pre> 5602 * 5603 * @see #LITERAL_INSTANCEOF 5604 * @since 8.35 5605 */ 5606 public static final int PATTERN_VARIABLE_DEF = 5607 JavaLanguageLexer.PATTERN_VARIABLE_DEF; 5608 5609 /** 5610 * The {@code record} keyword. This element appears 5611 * as part of a record declaration. 5612 * 5613 * <p>For example:</p> 5614 * <pre> 5615 * public record MyRecord () { 5616 * 5617 * } 5618 * </pre> 5619 * <p>parses as:</p> 5620 * <pre> 5621 * RECORD_DEF -> RECORD_DEF 5622 * |--MODIFIERS -> MODIFIERS 5623 * | `--LITERAL_PUBLIC -> public 5624 * |--LITERAL_RECORD -> record 5625 * |--IDENT -> MyRecord 5626 * |--LPAREN -> ( 5627 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5628 * |--RPAREN -> ) 5629 * `--OBJBLOCK -> OBJBLOCK 5630 * |--LCURLY -> { 5631 * `--RCURLY -> } 5632 * </pre> 5633 * 5634 * @since 8.35 5635 **/ 5636 public static final int LITERAL_RECORD = 5637 JavaLanguageLexer.LITERAL_RECORD; 5638 5639 /** 5640 * A declaration of a record specifies a name, a header, and a body. 5641 * The header lists the components of the record, which are the variables 5642 * that make up its state. 5643 * 5644 * <p>For example:</p> 5645 * <pre> 5646 * public record MyRecord () { 5647 * 5648 * } 5649 * </pre> 5650 * <p>parses as:</p> 5651 * <pre> 5652 * RECORD_DEF -> RECORD_DEF 5653 * |--MODIFIERS -> MODIFIERS 5654 * | `--LITERAL_PUBLIC -> public 5655 * |--LITERAL_RECORD -> record 5656 * |--IDENT -> MyRecord 5657 * |--LPAREN -> ( 5658 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5659 * |--RPAREN -> ) 5660 * `--OBJBLOCK -> OBJBLOCK 5661 * |--LCURLY -> { 5662 * `--RCURLY -> } 5663 * </pre> 5664 * 5665 * @since 8.35 5666 */ 5667 public static final int RECORD_DEF = 5668 JavaLanguageLexer.RECORD_DEF; 5669 5670 /** 5671 * Record components are a (possibly empty) list containing the components of a record, which 5672 * are the variables that make up its state. 5673 * 5674 * <p>For example:</p> 5675 * <pre> 5676 * public record myRecord (Comp x, Comp y) { } 5677 * </pre> 5678 * <p>parses as:</p> 5679 * <pre> 5680 * RECORD_DEF -> RECORD_DEF 5681 * |--MODIFIERS -> MODIFIERS 5682 * | `--LITERAL_PUBLIC -> public 5683 * |--LITERAL_RECORD -> record 5684 * |--IDENT -> myRecord 5685 * |--LPAREN -> ( 5686 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5687 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5688 * | | |--ANNOTATIONS -> ANNOTATIONS 5689 * | | |--TYPE -> TYPE 5690 * | | | `--IDENT -> Comp 5691 * | | `--IDENT -> x 5692 * | |--COMMA -> , 5693 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5694 * | |--ANNOTATIONS -> ANNOTATIONS 5695 * | |--TYPE -> TYPE 5696 * | | `--IDENT -> Comp 5697 * | `--IDENT -> y 5698 * |--RPAREN -> ) 5699 * `--OBJBLOCK -> OBJBLOCK 5700 * |--LCURLY -> { 5701 * `--RCURLY -> } 5702 * </pre> 5703 * 5704 * @since 8.36 5705 */ 5706 public static final int RECORD_COMPONENTS = 5707 JavaLanguageLexer.RECORD_COMPONENTS; 5708 5709 /** 5710 * A record component is a variable that comprises the state of a record. Record components 5711 * have annotations (possibly), a type definition, and an identifier. They can also be of 5712 * variable arity ('...'). 5713 * 5714 * <p>For example:</p> 5715 * <pre> 5716 * public record MyRecord(Comp x, Comp... comps) { 5717 * 5718 * } 5719 * </pre> 5720 * <p>parses as:</p> 5721 * <pre> 5722 * RECORD_DEF -> RECORD_DEF 5723 * |--MODIFIERS -> MODIFIERS 5724 * | `--LITERAL_PUBLIC -> public 5725 * |--LITERAL_RECORD -> record 5726 * |--IDENT -> MyRecord 5727 * |--LPAREN -> ( 5728 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS 5729 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5730 * | | |--ANNOTATIONS -> ANNOTATIONS 5731 * | | |--TYPE -> TYPE 5732 * | | | `--IDENT -> Comp 5733 * | | `--IDENT -> x 5734 * | |--COMMA -> , 5735 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF 5736 * | |--ANNOTATIONS -> ANNOTATIONS 5737 * | |--TYPE -> TYPE 5738 * | | `--IDENT -> Comp 5739 * | |--ELLIPSIS -> ... 5740 * | `--IDENT -> comps 5741 * |--RPAREN -> ) 5742 * `--OBJBLOCK -> OBJBLOCK 5743 * |--LCURLY -> { 5744 * `--RCURLY -> } 5745 * </pre> 5746 * 5747 * @since 8.36 5748 */ 5749 public static final int RECORD_COMPONENT_DEF = 5750 JavaLanguageLexer.RECORD_COMPONENT_DEF; 5751 5752 /** 5753 * A compact canonical constructor eliminates the list of formal parameters; they are 5754 * declared implicitly. 5755 * 5756 * <p>For example:</p> 5757 * <pre> 5758 * public record myRecord () { 5759 * public myRecord{} 5760 * } 5761 * </pre> 5762 * <p>parses as:</p> 5763 * <pre> 5764 * RECORD_DEF 5765 * |--MODIFIERS 5766 * | `--LITERAL_PUBLIC (public) 5767 * |--LITERAL_RECORD (record) 5768 * |--IDENT (myRecord) 5769 * |--LPAREN (() 5770 * |--RECORD_COMPONENTS 5771 * |--RPAREN ()) 5772 * `--OBJBLOCK 5773 * |--LCURLY ({) 5774 * |--COMPACT_CTOR_DEF 5775 * | |--MODIFIERS 5776 * | | `--LITERAL_PUBLIC (public) 5777 * | |--IDENT (myRecord) 5778 * | `--SLIST ({) 5779 * | `--RCURLY (}) 5780 * `--RCURLY (}) 5781 * </pre> 5782 * 5783 * @since 8.36 5784 */ 5785 public static final int COMPACT_CTOR_DEF = 5786 JavaLanguageLexer.COMPACT_CTOR_DEF; 5787 5788 /** 5789 * Beginning of a Java 14 Text Block literal, 5790 * delimited by three double quotes. 5791 * 5792 * <p>For example:</p> 5793 * <pre> 5794 * String hello = """ 5795 * Hello, world! 5796 * """; 5797 * </pre> 5798 * <p>parses as:</p> 5799 * <pre> 5800 * |--VARIABLE_DEF -> VARIABLE_DEF 5801 * | |--MODIFIERS -> MODIFIERS 5802 * | |--TYPE -> TYPE 5803 * | | `--IDENT -> String 5804 * | |--IDENT -> hello 5805 * | `--ASSIGN -> = 5806 * | `--EXPR -> EXPR 5807 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 5808 * | |--TEXT_BLOCK_CONTENT -> \r\n Hello, world!\r\n 5809 * | `--TEXT_BLOCK_LITERAL_END -> """ 5810 * |--SEMI -> ; 5811 * </pre> 5812 * 5813 * @since 8.36 5814 */ 5815 public static final int TEXT_BLOCK_LITERAL_BEGIN = 5816 JavaLanguageLexer.TEXT_BLOCK_LITERAL_BEGIN; 5817 5818 /** 5819 * Content of a Java 14 text block. This is a 5820 * sequence of characters, possibly escaped with '\'. Actual line terminators 5821 * are represented by '\n'. 5822 * 5823 * <p>For example:</p> 5824 * <pre> 5825 * String hello = """ 5826 * Hello, world! 5827 * """; 5828 * </pre> 5829 * <p>parses as:</p> 5830 * <pre> 5831 * |--VARIABLE_DEF -> VARIABLE_DEF 5832 * | |--MODIFIERS -> MODIFIERS 5833 * | |--TYPE -> TYPE 5834 * | | `--IDENT -> String 5835 * | |--IDENT -> hello 5836 * | `--ASSIGN -> = 5837 * | `--EXPR -> EXPR 5838 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """ 5839 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n 5840 * | `--TEXT_BLOCK_LITERAL_END -> """ 5841 * |--SEMI -> ; 5842 * </pre> 5843 * 5844 * @since 8.36 5845 */ 5846 public static final int TEXT_BLOCK_CONTENT = 5847 JavaLanguageLexer.TEXT_BLOCK_CONTENT; 5848 5849 /** 5850 * End of a Java 14 text block literal, delimited by three 5851 * double quotes. 5852 * 5853 * <p>For example:</p> 5854 * <pre> 5855 * String hello = """ 5856 * Hello, world! 5857 * """; 5858 * </pre> 5859 * <p>parses as:</p> 5860 * <pre> 5861 * |--VARIABLE_DEF 5862 * | |--MODIFIERS 5863 * | |--TYPE 5864 * | | `--IDENT (String) 5865 * | |--IDENT (hello) 5866 * | |--ASSIGN (=) 5867 * | | `--EXPR 5868 * | | `--TEXT_BLOCK_LITERAL_BEGIN (""") 5869 * | | |--TEXT_BLOCK_CONTENT (\n Hello, world!\n ) 5870 * | | `--TEXT_BLOCK_LITERAL_END (""") 5871 * | `--SEMI (;) 5872 * </pre> 5873 * 5874 * @since 8.36 5875 */ 5876 public static final int TEXT_BLOCK_LITERAL_END = 5877 JavaLanguageLexer.TEXT_BLOCK_LITERAL_END; 5878 5879 /** 5880 * The {@code yield} keyword. This element appears 5881 * as part of a yield statement. 5882 * 5883 * <p>For example:</p> 5884 * <pre> 5885 * int yield = 0; // not a keyword here 5886 * return switch (mode) { 5887 * case "a", "b": 5888 * yield 1; 5889 * default: 5890 * yield - 1; 5891 * }; 5892 * </pre> 5893 * <p>parses as:</p> 5894 * <pre> 5895 * |--VARIABLE_DEF -> VARIABLE_DEF 5896 * | |--MODIFIERS -> MODIFIERS 5897 * | |--TYPE -> TYPE 5898 * | | `--LITERAL_INT -> int 5899 * | |--IDENT -> yield 5900 * | `--ASSIGN -> = 5901 * | `--EXPR -> EXPR 5902 * | `--NUM_INT -> 0 5903 * |--SEMI -> ; 5904 * |--LITERAL_RETURN -> return 5905 * | |--EXPR -> EXPR 5906 * | | `--LITERAL_SWITCH -> switch 5907 * | | |--LPAREN -> ( 5908 * | | |--EXPR -> EXPR 5909 * | | | `--IDENT -> mode 5910 * | | |--RPAREN -> ) 5911 * | | |--LCURLY -> { 5912 * | | |--CASE_GROUP -> CASE_GROUP 5913 * | | | |--LITERAL_CASE -> case 5914 * | | | | |--EXPR -> EXPR 5915 * | | | | | `--STRING_LITERAL -> "a" 5916 * | | | | |--COMMA -> , 5917 * | | | | |--EXPR -> EXPR 5918 * | | | | | `--STRING_LITERAL -> "b" 5919 * | | | | `--COLON -> : 5920 * | | | `--SLIST -> SLIST 5921 * | | | `--LITERAL_YIELD -> yield 5922 * | | | |--EXPR -> EXPR 5923 * | | | | `--NUM_INT -> 1 5924 * | | | `--SEMI -> ; 5925 * | | |--CASE_GROUP -> CASE_GROUP 5926 * | | | |--LITERAL_DEFAULT -> default 5927 * | | | | `--COLON -> : 5928 * | | | `--SLIST -> SLIST 5929 * | | | `--LITERAL_YIELD -> yield 5930 * | | | |--EXPR -> EXPR 5931 * | | | | `--UNARY_MINUS -> - 5932 * | | | | `--NUM_INT -> 1 5933 * | | | `--SEMI -> ; 5934 * | | `--RCURLY -> } 5935 * | `--SEMI -> ; 5936 * </pre> 5937 * 5938 * 5939 * @see #LITERAL_SWITCH 5940 * @see #CASE_GROUP 5941 * @see #SLIST 5942 * @see #SWITCH_RULE 5943 * 5944 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 5945 * Java Language Specification, §14.21</a> 5946 * 5947 * @since 8.36 5948 */ 5949 public static final int LITERAL_YIELD = 5950 JavaLanguageLexer.LITERAL_YIELD; 5951 5952 /** 5953 * Switch Expressions. 5954 * 5955 * <p>For example:</p> 5956 * <pre> 5957 * return switch (day) { 5958 * case SAT, SUN -> "Weekend"; 5959 * default -> "Working day"; 5960 * }; 5961 * </pre> 5962 * <p>parses as:</p> 5963 * <pre> 5964 * LITERAL_RETURN -> return 5965 * |--EXPR -> EXPR 5966 * | `--LITERAL_SWITCH -> switch 5967 * | |--LPAREN -> ( 5968 * | |--EXPR -> EXPR 5969 * | | `--IDENT -> day 5970 * | |--RPAREN -> ) 5971 * | |--LCURLY -> { 5972 * | |--SWITCH_RULE -> SWITCH_RULE 5973 * | | |--LITERAL_CASE -> case 5974 * | | | |--EXPR -> EXPR 5975 * | | | | `--IDENT -> SAT 5976 * | | | |--COMMA -> , 5977 * | | | `--EXPR -> EXPR 5978 * | | | `--IDENT -> SUN 5979 * | | |--LAMBDA -> -> 5980 * | | |--EXPR -> EXPR 5981 * | | | `--STRING_LITERAL -> "Weekend" 5982 * | | `--SEMI -> ; 5983 * | |--SWITCH_RULE -> SWITCH_RULE 5984 * | | |--LITERAL_DEFAULT -> default 5985 * | | |--LAMBDA -> -> 5986 * | | |--EXPR -> EXPR 5987 * | | | `--STRING_LITERAL -> "Working day" 5988 * | | `--SEMI -> ; 5989 * | `--RCURLY -> } 5990 * `--SEMI -> ; 5991 * </pre> 5992 * 5993 * @see #LITERAL_CASE 5994 * @see #LITERAL_DEFAULT 5995 * @see #LITERAL_SWITCH 5996 * @see #LITERAL_YIELD 5997 * 5998 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 5999 * Java Language Specification, §14.21</a> 6000 * 6001 * @since 8.36 6002 */ 6003 public static final int SWITCH_RULE = 6004 JavaLanguageLexer.SWITCH_RULE; 6005 6006 /** 6007 * The {@code non-sealed} keyword. This element appears 6008 * as part of a class or interface declaration. 6009 * 6010 * <p>For example:</p> 6011 * <pre> 6012 * non-sealed class Square extends Rectangle { } 6013 * </pre> 6014 * <p>parses as:</p> 6015 * <pre> 6016 * CLASS_DEF -> CLASS_DEF 6017 * |--MODIFIERS -> MODIFIERS 6018 * | `--LITERAL_NON_SEALED -> non-sealed 6019 * |--LITERAL_CLASS -> class 6020 * |--IDENT -> Square 6021 * |--EXTENDS_CLAUSE -> extends 6022 * | `--IDENT -> Rectangle 6023 * `--OBJBLOCK -> OBJBLOCK 6024 * |--LCURLY -> { 6025 * `--RCURLY -> } 6026 * </pre> 6027 * 6028 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6029 * Java Language Specification, §8.1.1.2</a> 6030 * @see #MODIFIERS 6031 * 6032 * @since 8.42 6033 */ 6034 public static final int LITERAL_NON_SEALED = 6035 JavaLanguageLexer.LITERAL_NON_SEALED; 6036 6037 /** 6038 * The {@code sealed} restricted identifier. This element appears 6039 * as part of a class or interface declaration. 6040 * 6041 * <p>For example:</p> 6042 * <pre> 6043 * public sealed class Shape permits Circle, Square, Rectangle { } 6044 * </pre> 6045 * <p>parses as:</p> 6046 * <pre> 6047 * CLASS_DEF -> CLASS_DEF 6048 * |--MODIFIERS -> MODIFIERS 6049 * | |--LITERAL_PUBLIC -> public 6050 * | `--LITERAL_SEALED -> sealed 6051 * |--LITERAL_CLASS -> class 6052 * |--IDENT -> Shape 6053 * |--PERMITS_CLAUSE -> permits 6054 * | |--IDENT -> Circle 6055 * | |--COMMA -> , 6056 * | |--IDENT -> Square 6057 * | |--COMMA -> , 6058 * | `--IDENT -> Rectangle 6059 * `--OBJBLOCK -> OBJBLOCK 6060 * |--LCURLY -> { 6061 * `--RCURLY -> } 6062 * </pre> 6063 * 6064 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6065 * Java Language Specification, §8.1.1.2</a> 6066 * @see #MODIFIERS 6067 * 6068 * @since 8.42 6069 */ 6070 public static final int LITERAL_SEALED = 6071 JavaLanguageLexer.LITERAL_SEALED; 6072 6073 /** 6074 * The {@code permits} restricted identifier. This element appears 6075 * as part of a class or interface declaration. 6076 * 6077 * <p>For example:</p> 6078 * <pre> 6079 * public sealed class Shape permits Circle, Square, Rectangle { } 6080 * </pre> 6081 * <p>parses as:</p> 6082 * <pre> 6083 * CLASS_DEF -> CLASS_DEF 6084 * |--MODIFIERS -> MODIFIERS 6085 * | |--LITERAL_PUBLIC -> public 6086 * | `--LITERAL_SEALED -> sealed 6087 * |--LITERAL_CLASS -> class 6088 * |--IDENT -> Shape 6089 * |--PERMITS_CLAUSE -> permits 6090 * | |--IDENT -> Circle 6091 * | |--COMMA -> , 6092 * | |--IDENT -> Square 6093 * | |--COMMA -> , 6094 * | `--IDENT -> Rectangle 6095 * `--OBJBLOCK -> OBJBLOCK 6096 * |--LCURLY -> { 6097 * `--RCURLY -> } 6098 * </pre> 6099 * 6100 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6101 * Java Language Specification, §9.1.4</a> 6102 * @see #MODIFIERS 6103 * 6104 * @since 8.42 6105 */ 6106 public static final int LITERAL_PERMITS = 6107 JavaLanguageLexer.LITERAL_PERMITS; 6108 6109 /** 6110 * A permits clause. A permits clause's children are a comma separated list of one or 6111 * more identifiers. 6112 * 6113 * <p>For example:</p> 6114 * <pre> 6115 * public sealed class Shape permits Circle, Square, Rectangle { } 6116 * </pre> 6117 * <p>parses as:</p> 6118 * <pre> 6119 * CLASS_DEF -> CLASS_DEF 6120 * |--MODIFIERS -> MODIFIERS 6121 * | |--LITERAL_PUBLIC -> public 6122 * | `--LITERAL_SEALED -> sealed 6123 * |--LITERAL_CLASS -> class 6124 * |--IDENT -> Shape 6125 * |--PERMITS_CLAUSE -> permits 6126 * | |--IDENT -> Circle 6127 * | |--COMMA -> , 6128 * | |--IDENT -> Square 6129 * | |--COMMA -> , 6130 * | `--IDENT -> Rectangle 6131 * `--OBJBLOCK -> OBJBLOCK 6132 * |--LCURLY -> { 6133 * `--RCURLY -> } 6134 * </pre> 6135 * 6136 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html"> 6137 * Java Language Specification, §9.1.4</a> 6138 * @see #MODIFIERS 6139 * @see #CLASS_DEF 6140 * @see #INTERFACE_DEF 6141 * @see #COMMA 6142 * @see #IDENT 6143 * 6144 * @since 8.42 6145 */ 6146 public static final int PERMITS_CLAUSE = 6147 JavaLanguageLexer.PERMITS_CLAUSE; 6148 6149 /** 6150 * A pattern definition, excluding simple type pattern (pattern variable) 6151 * definition such as {@code if (o instanceof Integer i){}}. Pattern definitions 6152 * appear as operands of statements and expressions. 6153 * 6154 * <p>For example:</p> 6155 * <pre> 6156 * switch(o) { 6157 * case String s && s.length() > 4: // guarded pattern, `PATTERN_DEF` 6158 * break; 6159 * case String s: // type pattern, no `PATTERN_DEF` 6160 * break; 6161 * } 6162 * </pre> 6163 * <p>parses as:</p> 6164 * <pre> 6165 * LITERAL_SWITCH -> switch 6166 * | |--LPAREN -> ( 6167 * | |--EXPR -> EXPR 6168 * | | `--IDENT -> o 6169 * | |--RPAREN -> ) 6170 * | |--LCURLY -> { 6171 * | |--CASE_GROUP -> CASE_GROUP 6172 * | | |--LITERAL_CASE -> case 6173 * | | | |--PATTERN_DEF -> PATTERN_DEF 6174 * | | | | `--LAND -> && 6175 * | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6176 * | | | | | |--MODIFIERS -> MODIFIERS 6177 * | | | | | |--TYPE -> TYPE 6178 * | | | | | | `--IDENT -> String 6179 * | | | | | `--IDENT -> s 6180 * | | | | `--GT -> > 6181 * | | | | |--METHOD_CALL -> ( 6182 * | | | | | |--DOT -> . 6183 * | | | | | | |--IDENT -> s 6184 * | | | | | | `--IDENT -> length 6185 * | | | | | |--ELIST -> ELIST 6186 * | | | | | `--RPAREN -> ) 6187 * | | | | `--NUM_INT -> 4 6188 * | | | `--COLON -> : 6189 * | | `--SLIST -> SLIST 6190 * | | `--LITERAL_BREAK -> break 6191 * | | `--SEMI -> ; 6192 * | |--CASE_GROUP -> CASE_GROUP 6193 * | | |--LITERAL_CASE -> case 6194 * | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF 6195 * | | | | |--MODIFIERS -> MODIFIERS 6196 * | | | | |--TYPE -> TYPE 6197 * | | | | | `--IDENT -> String 6198 * | | | | `--IDENT -> s 6199 * | | | `--COLON -> : 6200 * | | `--SLIST -> SLIST 6201 * | | `--LITERAL_BREAK -> break 6202 * | | `--SEMI -> ; 6203 * | `--RCURLY -> } 6204 * `--RCURLY -> } 6205 * </pre> 6206 * 6207 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30"> 6208 * Java Language Specification, §14.30</a> 6209 * @see #LITERAL_SWITCH 6210 * @see #PATTERN_VARIABLE_DEF 6211 * @see #LITERAL_INSTANCEOF 6212 * 6213 * @since 9.3 6214 */ 6215 public static final int PATTERN_DEF = 6216 JavaLanguageLexer.PATTERN_DEF; 6217 6218 /** Prevent instantiation. */ 6219 private TokenTypes() { 6220 } 6221 6222}