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