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