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