001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2020 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018//////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle.api; 021 022import com.puppycrawl.tools.checkstyle.grammar.GeneratedJavaTokenTypes; 023 024/** 025 * Contains the constants for all the tokens contained in the Abstract 026 * Syntax Tree. 027 * 028 * <p>Implementation detail: This class has been introduced to break 029 * the circular dependency between packages.</p> 030 * 031 * @noinspection ClassWithTooManyDependents 032 */ 033public final class TokenTypes { 034 035 /** 036 * The end of file token. This is the root node for the source 037 * file. It's children are an optional package definition, zero 038 * or more import statements, and one or more class or interface 039 * definitions. 040 * 041 * @see #PACKAGE_DEF 042 * @see #IMPORT 043 * @see #CLASS_DEF 044 * @see #INTERFACE_DEF 045 **/ 046 public static final int EOF = GeneratedJavaTokenTypes.EOF; 047 /** 048 * Modifiers for type, method, and field declarations. The 049 * modifiers element is always present even though it may have no 050 * children. 051 * 052 * @see <a 053 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 054 * Language Specification, §8</a> 055 * @see #LITERAL_PUBLIC 056 * @see #LITERAL_PROTECTED 057 * @see #LITERAL_PRIVATE 058 * @see #ABSTRACT 059 * @see #LITERAL_STATIC 060 * @see #FINAL 061 * @see #LITERAL_TRANSIENT 062 * @see #LITERAL_VOLATILE 063 * @see #LITERAL_SYNCHRONIZED 064 * @see #LITERAL_NATIVE 065 * @see #STRICTFP 066 * @see #ANNOTATION 067 * @see #LITERAL_DEFAULT 068 **/ 069 public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS; 070 071 /** 072 * An object block. These are children of class, interface, enum, 073 * annotation and enum constant declarations. 074 * Also, object blocks are children of the new keyword when defining 075 * anonymous inner types. 076 * 077 * @see #LCURLY 078 * @see #INSTANCE_INIT 079 * @see #STATIC_INIT 080 * @see #CLASS_DEF 081 * @see #CTOR_DEF 082 * @see #METHOD_DEF 083 * @see #VARIABLE_DEF 084 * @see #RCURLY 085 * @see #INTERFACE_DEF 086 * @see #LITERAL_NEW 087 * @see #ENUM_DEF 088 * @see #ENUM_CONSTANT_DEF 089 * @see #ANNOTATION_DEF 090 **/ 091 public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK; 092 /** 093 * A list of statements. 094 * 095 * @see #RCURLY 096 * @see #EXPR 097 * @see #LABELED_STAT 098 * @see #LITERAL_THROWS 099 * @see #LITERAL_RETURN 100 * @see #SEMI 101 * @see #METHOD_DEF 102 * @see #CTOR_DEF 103 * @see #LITERAL_FOR 104 * @see #LITERAL_WHILE 105 * @see #LITERAL_IF 106 * @see #LITERAL_ELSE 107 * @see #CASE_GROUP 108 **/ 109 public static final int SLIST = GeneratedJavaTokenTypes.SLIST; 110 /** 111 * A constructor declaration. 112 * 113 * <p>For example:</p> 114 * <pre> 115 * public SpecialEntry(int value, String text) 116 * { 117 * this.value = value; 118 * this.text = text; 119 * } 120 * </pre> 121 * <p>parses as:</p> 122 * <pre> 123 * +--CTOR_DEF 124 * | 125 * +--MODIFIERS 126 * | 127 * +--LITERAL_PUBLIC (public) 128 * +--IDENT (SpecialEntry) 129 * +--LPAREN (() 130 * +--PARAMETERS 131 * | 132 * +--PARAMETER_DEF 133 * | 134 * +--MODIFIERS 135 * +--TYPE 136 * | 137 * +--LITERAL_INT (int) 138 * +--IDENT (value) 139 * +--COMMA (,) 140 * +--PARAMETER_DEF 141 * | 142 * +--MODIFIERS 143 * +--TYPE 144 * | 145 * +--IDENT (String) 146 * +--IDENT (text) 147 * +--RPAREN ()) 148 * +--SLIST ({) 149 * | 150 * +--EXPR 151 * | 152 * +--ASSIGN (=) 153 * | 154 * +--DOT (.) 155 * | 156 * +--LITERAL_THIS (this) 157 * +--IDENT (value) 158 * +--IDENT (value) 159 * +--SEMI (;) 160 * +--EXPR 161 * | 162 * +--ASSIGN (=) 163 * | 164 * +--DOT (.) 165 * | 166 * +--LITERAL_THIS (this) 167 * +--IDENT (text) 168 * +--IDENT (text) 169 * +--SEMI (;) 170 * +--RCURLY (}) 171 * </pre> 172 * 173 * @see #OBJBLOCK 174 * @see #CLASS_DEF 175 **/ 176 public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF; 177 /** 178 * A method declaration. The children are modifiers, type parameters, 179 * return type, method name, parameter list, an optional throws list, and 180 * statement list. The statement list is omitted if the method 181 * declaration appears in an interface declaration. Method 182 * declarations may appear inside object blocks of class 183 * declarations, interface declarations, enum declarations, 184 * enum constant declarations or anonymous inner-class declarations. 185 * 186 * <p>For example:</p> 187 * 188 * <pre> 189 * public static int square(int x) 190 * { 191 * return x*x; 192 * } 193 * </pre> 194 * 195 * <p>parses as:</p> 196 * 197 * <pre> 198 * +--METHOD_DEF 199 * | 200 * +--MODIFIERS 201 * | 202 * +--LITERAL_PUBLIC (public) 203 * +--LITERAL_STATIC (static) 204 * +--TYPE 205 * | 206 * +--LITERAL_INT (int) 207 * +--IDENT (square) 208 * +--PARAMETERS 209 * | 210 * +--PARAMETER_DEF 211 * | 212 * +--MODIFIERS 213 * +--TYPE 214 * | 215 * +--LITERAL_INT (int) 216 * +--IDENT (x) 217 * +--SLIST ({) 218 * | 219 * +--LITERAL_RETURN (return) 220 * | 221 * +--EXPR 222 * | 223 * +--STAR (*) 224 * | 225 * +--IDENT (x) 226 * +--IDENT (x) 227 * +--SEMI (;) 228 * +--RCURLY (}) 229 * </pre> 230 * 231 * @see #MODIFIERS 232 * @see #TYPE_PARAMETERS 233 * @see #TYPE 234 * @see #IDENT 235 * @see #PARAMETERS 236 * @see #LITERAL_THROWS 237 * @see #SLIST 238 * @see #OBJBLOCK 239 **/ 240 public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF; 241 /** 242 * A field or local variable declaration. The children are 243 * modifiers, type, the identifier name, and an optional 244 * assignment statement. 245 * 246 * @see #MODIFIERS 247 * @see #TYPE 248 * @see #IDENT 249 * @see #ASSIGN 250 **/ 251 public static final int VARIABLE_DEF = 252 GeneratedJavaTokenTypes.VARIABLE_DEF; 253 254 /** 255 * An instance initializer. Zero or more instance initializers 256 * may appear in class and enum definitions. This token will be a child 257 * of the object block of the declaring type. 258 * 259 * @see <a 260 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java 261 * Language Specification§8.6</a> 262 * @see #SLIST 263 * @see #OBJBLOCK 264 **/ 265 public static final int INSTANCE_INIT = 266 GeneratedJavaTokenTypes.INSTANCE_INIT; 267 268 /** 269 * A static initialization block. Zero or more static 270 * initializers may be children of the object block of a class 271 * or enum declaration (interfaces cannot have static initializers). The 272 * first and only child is a statement list. 273 * 274 * @see <a 275 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java 276 * Language Specification, §8.7</a> 277 * @see #SLIST 278 * @see #OBJBLOCK 279 **/ 280 public static final int STATIC_INIT = 281 GeneratedJavaTokenTypes.STATIC_INIT; 282 283 /** 284 * A type. This is either a return type of a method or a type of 285 * a variable or field. The first child of this element is the 286 * actual type. This may be a primitive type, an identifier, a 287 * dot which is the root of a fully qualified type, or an array of 288 * any of these. The second child may be type arguments to the type. 289 * 290 * @see #VARIABLE_DEF 291 * @see #METHOD_DEF 292 * @see #PARAMETER_DEF 293 * @see #IDENT 294 * @see #DOT 295 * @see #LITERAL_VOID 296 * @see #LITERAL_BOOLEAN 297 * @see #LITERAL_BYTE 298 * @see #LITERAL_CHAR 299 * @see #LITERAL_SHORT 300 * @see #LITERAL_INT 301 * @see #LITERAL_FLOAT 302 * @see #LITERAL_LONG 303 * @see #LITERAL_DOUBLE 304 * @see #ARRAY_DECLARATOR 305 * @see #TYPE_ARGUMENTS 306 **/ 307 public static final int TYPE = GeneratedJavaTokenTypes.TYPE; 308 /** 309 * A class declaration. 310 * 311 * <p>For example:</p> 312 * <pre> 313 * public class MyClass 314 * implements Serializable 315 * { 316 * } 317 * </pre> 318 * <p>parses as:</p> 319 * <pre> 320 * +--CLASS_DEF 321 * | 322 * +--MODIFIERS 323 * | 324 * +--LITERAL_PUBLIC (public) 325 * +--LITERAL_CLASS (class) 326 * +--IDENT (MyClass) 327 * +--EXTENDS_CLAUSE 328 * +--IMPLEMENTS_CLAUSE 329 * | 330 * +--IDENT (Serializable) 331 * +--OBJBLOCK 332 * | 333 * +--LCURLY ({) 334 * +--RCURLY (}) 335 * </pre> 336 * 337 * @see <a 338 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 339 * Language Specification, §8</a> 340 * @see #MODIFIERS 341 * @see #IDENT 342 * @see #EXTENDS_CLAUSE 343 * @see #IMPLEMENTS_CLAUSE 344 * @see #OBJBLOCK 345 * @see #LITERAL_NEW 346 **/ 347 public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF; 348 /** 349 * An interface declaration. 350 * 351 * <p>For example:</p> 352 * 353 * <pre> 354 * public interface MyInterface 355 * { 356 * } 357 * 358 * </pre> 359 * 360 * <p>parses as:</p> 361 * 362 * <pre> 363 * +--INTERFACE_DEF 364 * | 365 * +--MODIFIERS 366 * | 367 * +--LITERAL_PUBLIC (public) 368 * +--LITERAL_INTERFACE (interface) 369 * +--IDENT (MyInterface) 370 * +--EXTENDS_CLAUSE 371 * +--OBJBLOCK 372 * | 373 * +--LCURLY ({) 374 * +--RCURLY (}) 375 * </pre> 376 * 377 * @see <a 378 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java 379 * Language Specification, §9</a> 380 * @see #MODIFIERS 381 * @see #IDENT 382 * @see #EXTENDS_CLAUSE 383 * @see #OBJBLOCK 384 **/ 385 public static final int INTERFACE_DEF = 386 GeneratedJavaTokenTypes.INTERFACE_DEF; 387 388 /** 389 * The package declaration. This is optional, but if it is 390 * included, then there is only one package declaration per source 391 * file and it must be the first non-comment in the file. A package 392 * declaration may be annotated in which case the annotations comes 393 * before the rest of the declaration (and are the first children). 394 * 395 * <p>For example:</p> 396 * 397 * <pre> 398 * package com.puppycrawl.tools.checkstyle.api; 399 * </pre> 400 * 401 * <p>parses as:</p> 402 * 403 * <pre> 404 * +--PACKAGE_DEF (package) 405 * | 406 * +--ANNOTATIONS 407 * +--DOT (.) 408 * | 409 * +--DOT (.) 410 * | 411 * +--DOT (.) 412 * | 413 * +--DOT (.) 414 * | 415 * +--IDENT (com) 416 * +--IDENT (puppycrawl) 417 * +--IDENT (tools) 418 * +--IDENT (checkstyle) 419 * +--IDENT (api) 420 * +--SEMI (;) 421 * </pre> 422 * 423 * @see <a 424 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java 425 * Language Specification §7.4</a> 426 * @see #DOT 427 * @see #IDENT 428 * @see #SEMI 429 * @see #ANNOTATIONS 430 * @see FullIdent 431 **/ 432 public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF; 433 /** 434 * An array declaration. 435 * 436 * <p>If the array declaration represents a type, then the type of 437 * the array elements is the first child. Multidimensional arrays 438 * may be regarded as arrays of arrays. In other words, the first 439 * child of the array declaration is another array 440 * declaration.</p> 441 * 442 * <p>For example:</p> 443 * <pre> 444 * int[] x; 445 * </pre> 446 * <p>parses as:</p> 447 * <pre> 448 * +--VARIABLE_DEF 449 * | 450 * +--MODIFIERS 451 * +--TYPE 452 * | 453 * +--ARRAY_DECLARATOR ([) 454 * | 455 * +--LITERAL_INT (int) 456 * +--IDENT (x) 457 * +--SEMI (;) 458 * </pre> 459 * 460 * <p>The array declaration may also represent an inline array 461 * definition. In this case, the first child will be either an 462 * expression specifying the length of the array or an array 463 * initialization block.</p> 464 * 465 * @see <a 466 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java 467 * Language Specification §10</a> 468 * @see #TYPE 469 * @see #ARRAY_INIT 470 **/ 471 public static final int ARRAY_DECLARATOR = 472 GeneratedJavaTokenTypes.ARRAY_DECLARATOR; 473 474 /** 475 * An extends clause. This appear as part of class and interface 476 * definitions. This element appears even if the 477 * {@code extends} keyword is not explicitly used. The child 478 * is an optional identifier. 479 * 480 * <p>For example:</p> 481 * 482 * <pre> 483 * extends java.util.LinkedList 484 * </pre> 485 * 486 * <p>parses as:</p> 487 * <pre> 488 * +--EXTENDS_CLAUSE 489 * | 490 * +--DOT (.) 491 * | 492 * +--DOT (.) 493 * | 494 * +--IDENT (java) 495 * +--IDENT (util) 496 * +--IDENT (LinkedList) 497 * </pre> 498 * 499 * @see #IDENT 500 * @see #DOT 501 * @see #CLASS_DEF 502 * @see #INTERFACE_DEF 503 * @see FullIdent 504 **/ 505 public static final int EXTENDS_CLAUSE = 506 GeneratedJavaTokenTypes.EXTENDS_CLAUSE; 507 508 /** 509 * An implements clause. This always appears in a class or enum 510 * declaration, even if there are no implemented interfaces. The 511 * children are a comma separated list of zero or more 512 * identifiers. 513 * 514 * <p>For example:</p> 515 * <pre> 516 * implements Serializable, Comparable 517 * </pre> 518 * <p>parses as:</p> 519 * <pre> 520 * +--IMPLEMENTS_CLAUSE 521 * | 522 * +--IDENT (Serializable) 523 * +--COMMA (,) 524 * +--IDENT (Comparable) 525 * </pre> 526 * 527 * @see #IDENT 528 * @see #DOT 529 * @see #COMMA 530 * @see #CLASS_DEF 531 * @see #ENUM_DEF 532 **/ 533 public static final int IMPLEMENTS_CLAUSE = 534 GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE; 535 536 /** 537 * A list of parameters to a method or constructor. The children 538 * are zero or more parameter declarations separated by commas. 539 * 540 * <p>For example</p> 541 * <pre> 542 * int start, int end 543 * </pre> 544 * <p>parses as:</p> 545 * <pre> 546 * +--PARAMETERS 547 * | 548 * +--PARAMETER_DEF 549 * | 550 * +--MODIFIERS 551 * +--TYPE 552 * | 553 * +--LITERAL_INT (int) 554 * +--IDENT (start) 555 * +--COMMA (,) 556 * +--PARAMETER_DEF 557 * | 558 * +--MODIFIERS 559 * +--TYPE 560 * | 561 * +--LITERAL_INT (int) 562 * +--IDENT (end) 563 * </pre> 564 * 565 * @see #PARAMETER_DEF 566 * @see #COMMA 567 * @see #METHOD_DEF 568 * @see #CTOR_DEF 569 **/ 570 public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS; 571 /** 572 * A parameter declaration. The last parameter in a list of parameters may 573 * be variable length (indicated by the ELLIPSIS child node immediately 574 * after the TYPE child). 575 * 576 * @see #MODIFIERS 577 * @see #TYPE 578 * @see #IDENT 579 * @see #PARAMETERS 580 * @see #ELLIPSIS 581 **/ 582 public static final int PARAMETER_DEF = 583 GeneratedJavaTokenTypes.PARAMETER_DEF; 584 585 /** 586 * A labeled statement. 587 * 588 * <p>For example:</p> 589 * <pre> 590 * outside: ; 591 * </pre> 592 * <p>parses as:</p> 593 * <pre> 594 * +--LABELED_STAT (:) 595 * | 596 * +--IDENT (outside) 597 * +--EMPTY_STAT (;) 598 * </pre> 599 * 600 * @see <a 601 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java 602 * Language Specification, §14.7</a> 603 * @see #SLIST 604 **/ 605 public static final int LABELED_STAT = 606 GeneratedJavaTokenTypes.LABELED_STAT; 607 608 /** 609 * A type-cast. 610 * 611 * <p>For example:</p> 612 * <pre> 613 * (String)it.next() 614 * </pre> 615 * <p>parses as:</p> 616 * <pre> 617 * +--TYPECAST (() 618 * | 619 * +--TYPE 620 * | 621 * +--IDENT (String) 622 * +--RPAREN ()) 623 * +--METHOD_CALL (() 624 * | 625 * +--DOT (.) 626 * | 627 * +--IDENT (it) 628 * +--IDENT (next) 629 * +--ELIST 630 * +--RPAREN ()) 631 * </pre> 632 * 633 * @see <a 634 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java 635 * Language Specification, §15.16</a> 636 * @see #EXPR 637 * @see #TYPE 638 * @see #TYPE_ARGUMENTS 639 * @see #RPAREN 640 **/ 641 public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST; 642 /** 643 * The array index operator. 644 * 645 * <p>For example:</p> 646 * <pre> 647 * ar[2] = 5; 648 * </pre> 649 * <p>parses as:</p> 650 * <pre> 651 * +--EXPR 652 * | 653 * +--ASSIGN (=) 654 * | 655 * +--INDEX_OP ([) 656 * | 657 * +--IDENT (ar) 658 * +--EXPR 659 * | 660 * +--NUM_INT (2) 661 * +--NUM_INT (5) 662 * +--SEMI (;) 663 * </pre> 664 * 665 * @see #EXPR 666 **/ 667 public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP; 668 /** 669 * The {@code ++} (postfix increment) operator. 670 * 671 * @see <a 672 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java 673 * Language Specification, §15.14.1</a> 674 * @see #EXPR 675 * @see #INC 676 **/ 677 public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC; 678 /** 679 * The {@code --} (postfix decrement) operator. 680 * 681 * @see <a 682 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java 683 * Language Specification, §15.14.2</a> 684 * @see #EXPR 685 * @see #DEC 686 **/ 687 public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC; 688 /** 689 * A method call. A method call may have type arguments however these 690 * are attached to the appropriate node in the qualified method name. 691 * 692 * <p>For example:</p> 693 * <pre> 694 * Math.random() 695 * </pre> 696 * 697 * <p>parses as: 698 * <pre> 699 * +--METHOD_CALL (() 700 * | 701 * +--DOT (.) 702 * | 703 * +--IDENT (Math) 704 * +--IDENT (random) 705 * +--ELIST 706 * +--RPAREN ()) 707 * </pre> 708 * 709 * 710 * @see #IDENT 711 * @see #TYPE_ARGUMENTS 712 * @see #DOT 713 * @see #ELIST 714 * @see #RPAREN 715 * @see FullIdent 716 **/ 717 public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL; 718 719 /** 720 * A reference to a method or constructor without arguments. Part of Java 8 syntax. 721 * The token should be used for subscribing for double colon literal. 722 * {@link #DOUBLE_COLON} token does not appear in the tree. 723 * 724 * <p>For example:</p> 725 * <pre> 726 * String::compareToIgnoreCase 727 * </pre> 728 * 729 * <p>parses as: 730 * <pre> 731 * +--METHOD_REF (::) 732 * | 733 * +--IDENT (String) 734 * +--IDENT (compareToIgnoreCase) 735 * </pre> 736 * 737 * @see #IDENT 738 * @see #DOUBLE_COLON 739 */ 740 public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF; 741 /** 742 * An expression. Operators with lower precedence appear at a 743 * higher level in the tree than operators with higher precedence. 744 * Parentheses are siblings to the operator they enclose. 745 * 746 * <p>For example:</p> 747 * <pre> 748 * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3); 749 * </pre> 750 * <p>parses as:</p> 751 * <pre> 752 * +--EXPR 753 * | 754 * +--ASSIGN (=) 755 * | 756 * +--IDENT (x) 757 * +--PLUS (+) 758 * | 759 * +--PLUS (+) 760 * | 761 * +--PLUS (+) 762 * | 763 * +--PLUS (+) 764 * | 765 * +--NUM_INT (4) 766 * +--STAR (*) 767 * | 768 * +--NUM_INT (3) 769 * +--NUM_INT (5) 770 * +--DIV (/) 771 * | 772 * +--LPAREN (() 773 * +--PLUS (+) 774 * | 775 * +--NUM_INT (30) 776 * +--NUM_INT (26) 777 * +--RPAREN ()) 778 * +--NUM_INT (4) 779 * +--MOD (%) 780 * | 781 * +--NUM_INT (5) 782 * +--NUM_INT (4) 783 * +--LPAREN (() 784 * +--SL (<<) 785 * | 786 * +--NUM_INT (1) 787 * +--NUM_INT (3) 788 * +--RPAREN ()) 789 * +--SEMI (;) 790 * </pre> 791 * 792 * @see #ELIST 793 * @see #ASSIGN 794 * @see #LPAREN 795 * @see #RPAREN 796 **/ 797 public static final int EXPR = GeneratedJavaTokenTypes.EXPR; 798 /** 799 * An array initialization. This may occur as part of an array 800 * declaration or inline with {@code new}. 801 * 802 * <p>For example:</p> 803 * <pre> 804 * int[] y = 805 * { 806 * 1, 807 * 2, 808 * }; 809 * </pre> 810 * <p>parses as:</p> 811 * <pre> 812 * +--VARIABLE_DEF 813 * | 814 * +--MODIFIERS 815 * +--TYPE 816 * | 817 * +--ARRAY_DECLARATOR ([) 818 * | 819 * +--LITERAL_INT (int) 820 * +--IDENT (y) 821 * +--ASSIGN (=) 822 * | 823 * +--ARRAY_INIT ({) 824 * | 825 * +--EXPR 826 * | 827 * +--NUM_INT (1) 828 * +--COMMA (,) 829 * +--EXPR 830 * | 831 * +--NUM_INT (2) 832 * +--COMMA (,) 833 * +--RCURLY (}) 834 * +--SEMI (;) 835 * </pre> 836 * 837 * <p>Also consider:</p> 838 * <pre> 839 * int[] z = new int[] 840 * { 841 * 1, 842 * 2, 843 * }; 844 * </pre> 845 * <p>which parses as:</p> 846 * <pre> 847 * +--VARIABLE_DEF 848 * | 849 * +--MODIFIERS 850 * +--TYPE 851 * | 852 * +--ARRAY_DECLARATOR ([) 853 * | 854 * +--LITERAL_INT (int) 855 * +--IDENT (z) 856 * +--ASSIGN (=) 857 * | 858 * +--EXPR 859 * | 860 * +--LITERAL_NEW (new) 861 * | 862 * +--LITERAL_INT (int) 863 * +--ARRAY_DECLARATOR ([) 864 * +--ARRAY_INIT ({) 865 * | 866 * +--EXPR 867 * | 868 * +--NUM_INT (1) 869 * +--COMMA (,) 870 * +--EXPR 871 * | 872 * +--NUM_INT (2) 873 * +--COMMA (,) 874 * +--RCURLY (}) 875 * </pre> 876 * 877 * @see #ARRAY_DECLARATOR 878 * @see #TYPE 879 * @see #LITERAL_NEW 880 * @see #COMMA 881 **/ 882 public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT; 883 /** 884 * An import declaration. Import declarations are option, but 885 * must appear after the package declaration and before the first type 886 * declaration. 887 * 888 * <p>For example:</p> 889 * 890 * <pre> 891 * import java.io.IOException; 892 * </pre> 893 * 894 * <p>parses as:</p> 895 * 896 * <pre> 897 * +--IMPORT (import) 898 * | 899 * +--DOT (.) 900 * | 901 * +--DOT (.) 902 * | 903 * +--IDENT (java) 904 * +--IDENT (io) 905 * +--IDENT (IOException) 906 * +--SEMI (;) 907 * </pre> 908 * 909 * @see <a 910 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java 911 * Language Specification §7.5</a> 912 * @see #DOT 913 * @see #IDENT 914 * @see #STAR 915 * @see #SEMI 916 * @see FullIdent 917 **/ 918 public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT; 919 /** 920 * The {@code -} (unary minus) operator. 921 * 922 * @see <a 923 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java 924 * Language Specification, §15.15.4</a> 925 * @see #EXPR 926 **/ 927 public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS; 928 /** 929 * The {@code +} (unary plus) operator. 930 * 931 * @see <a 932 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java 933 * Language Specification, §15.15.3</a> 934 * @see #EXPR 935 **/ 936 public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS; 937 /** 938 * A group of case clauses. Case clauses with no associated 939 * statements are grouped together into a case group. The last 940 * child is a statement list containing the statements to execute 941 * upon a match. 942 * 943 * <p>For example:</p> 944 * <pre> 945 * case 0: 946 * case 1: 947 * case 2: 948 * x = 3; 949 * break; 950 * </pre> 951 * <p>parses as:</p> 952 * <pre> 953 * +--CASE_GROUP 954 * | 955 * +--LITERAL_CASE (case) 956 * | 957 * +--EXPR 958 * | 959 * +--NUM_INT (0) 960 * +--LITERAL_CASE (case) 961 * | 962 * +--EXPR 963 * | 964 * +--NUM_INT (1) 965 * +--LITERAL_CASE (case) 966 * | 967 * +--EXPR 968 * | 969 * +--NUM_INT (2) 970 * +--SLIST 971 * | 972 * +--EXPR 973 * | 974 * +--ASSIGN (=) 975 * | 976 * +--IDENT (x) 977 * +--NUM_INT (3) 978 * +--SEMI (;) 979 * +--LITERAL_BREAK (break) 980 * | 981 * +--SEMI (;) 982 * </pre> 983 * 984 * @see #LITERAL_CASE 985 * @see #LITERAL_DEFAULT 986 * @see #LITERAL_SWITCH 987 * @see #LITERAL_YIELD 988 **/ 989 public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP; 990 /** 991 * An expression list. The children are a comma separated list of 992 * expressions. 993 * 994 * @see #LITERAL_NEW 995 * @see #FOR_INIT 996 * @see #FOR_ITERATOR 997 * @see #EXPR 998 * @see #METHOD_CALL 999 * @see #CTOR_CALL 1000 * @see #SUPER_CTOR_CALL 1001 **/ 1002 public static final int ELIST = GeneratedJavaTokenTypes.ELIST; 1003 /** 1004 * A for loop initializer. This is a child of 1005 * {@code LITERAL_FOR}. The children of this element may be 1006 * a comma separated list of variable declarations, an expression 1007 * list, or empty. 1008 * 1009 * @see #VARIABLE_DEF 1010 * @see #ELIST 1011 * @see #LITERAL_FOR 1012 **/ 1013 public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT; 1014 /** 1015 * A for loop condition. This is a child of 1016 * {@code LITERAL_FOR}. The child of this element is an 1017 * optional expression. 1018 * 1019 * @see #EXPR 1020 * @see #LITERAL_FOR 1021 **/ 1022 public static final int FOR_CONDITION = 1023 GeneratedJavaTokenTypes.FOR_CONDITION; 1024 1025 /** 1026 * A for loop iterator. This is a child of 1027 * {@code LITERAL_FOR}. The child of this element is an 1028 * optional expression list. 1029 * 1030 * @see #ELIST 1031 * @see #LITERAL_FOR 1032 **/ 1033 public static final int FOR_ITERATOR = 1034 GeneratedJavaTokenTypes.FOR_ITERATOR; 1035 1036 /** 1037 * The empty statement. This goes in place of an 1038 * {@code SLIST} for a {@code for} or {@code while} 1039 * loop body. 1040 * 1041 * @see <a 1042 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java 1043 * Language Specification, §14.6</a> 1044 * @see #LITERAL_FOR 1045 * @see #LITERAL_WHILE 1046 **/ 1047 public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT; 1048 /** 1049 * The {@code final} keyword. 1050 * 1051 * @see #MODIFIERS 1052 **/ 1053 public static final int FINAL = GeneratedJavaTokenTypes.FINAL; 1054 /** 1055 * The {@code abstract} keyword. 1056 * 1057 * @see #MODIFIERS 1058 **/ 1059 public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT; 1060 /** 1061 * The {@code strictfp} keyword. 1062 * 1063 * @see #MODIFIERS 1064 **/ 1065 public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP; 1066 /** 1067 * A super constructor call. 1068 * 1069 * @see #ELIST 1070 * @see #RPAREN 1071 * @see #SEMI 1072 * @see #CTOR_CALL 1073 **/ 1074 public static final int SUPER_CTOR_CALL = 1075 GeneratedJavaTokenTypes.SUPER_CTOR_CALL; 1076 1077 /** 1078 * A constructor call. 1079 * 1080 * <p>For example:</p> 1081 * <pre> 1082 * this(1); 1083 * </pre> 1084 * <p>parses as:</p> 1085 * <pre> 1086 * +--CTOR_CALL (this) 1087 * | 1088 * +--LPAREN (() 1089 * +--ELIST 1090 * | 1091 * +--EXPR 1092 * | 1093 * +--NUM_INT (1) 1094 * +--RPAREN ()) 1095 * +--SEMI (;) 1096 * </pre> 1097 * 1098 * @see #ELIST 1099 * @see #RPAREN 1100 * @see #SEMI 1101 * @see #SUPER_CTOR_CALL 1102 **/ 1103 public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL; 1104 1105 /** 1106 * The statement terminator ({@code ;}). Depending on the 1107 * context, this make occur as a sibling, a child, or not at all. 1108 * 1109 * @see #PACKAGE_DEF 1110 * @see #IMPORT 1111 * @see #SLIST 1112 * @see #ARRAY_INIT 1113 * @see #LITERAL_FOR 1114 **/ 1115 public static final int SEMI = GeneratedJavaTokenTypes.SEMI; 1116 1117 /** 1118 * The {@code ]} symbol. 1119 * 1120 * @see #INDEX_OP 1121 * @see #ARRAY_DECLARATOR 1122 **/ 1123 public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK; 1124 /** 1125 * The {@code void} keyword. 1126 * 1127 * @see #TYPE 1128 **/ 1129 public static final int LITERAL_VOID = 1130 GeneratedJavaTokenTypes.LITERAL_void; 1131 1132 /** 1133 * The {@code boolean} keyword. 1134 * 1135 * @see #TYPE 1136 **/ 1137 public static final int LITERAL_BOOLEAN = 1138 GeneratedJavaTokenTypes.LITERAL_boolean; 1139 1140 /** 1141 * The {@code byte} keyword. 1142 * 1143 * @see #TYPE 1144 **/ 1145 public static final int LITERAL_BYTE = 1146 GeneratedJavaTokenTypes.LITERAL_byte; 1147 1148 /** 1149 * The {@code char} keyword. 1150 * 1151 * @see #TYPE 1152 **/ 1153 public static final int LITERAL_CHAR = 1154 GeneratedJavaTokenTypes.LITERAL_char; 1155 1156 /** 1157 * The {@code short} keyword. 1158 * 1159 * @see #TYPE 1160 **/ 1161 public static final int LITERAL_SHORT = 1162 GeneratedJavaTokenTypes.LITERAL_short; 1163 1164 /** 1165 * The {@code int} keyword. 1166 * 1167 * @see #TYPE 1168 **/ 1169 public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int; 1170 /** 1171 * The {@code float} keyword. 1172 * 1173 * @see #TYPE 1174 **/ 1175 public static final int LITERAL_FLOAT = 1176 GeneratedJavaTokenTypes.LITERAL_float; 1177 1178 /** 1179 * The {@code long} keyword. 1180 * 1181 * @see #TYPE 1182 **/ 1183 public static final int LITERAL_LONG = 1184 GeneratedJavaTokenTypes.LITERAL_long; 1185 1186 /** 1187 * The {@code double} keyword. 1188 * 1189 * @see #TYPE 1190 **/ 1191 public static final int LITERAL_DOUBLE = 1192 GeneratedJavaTokenTypes.LITERAL_double; 1193 1194 /** 1195 * An identifier. These can be names of types, subpackages, 1196 * fields, methods, parameters, and local variables. 1197 **/ 1198 public static final int IDENT = GeneratedJavaTokenTypes.IDENT; 1199 /** 1200 * The <code>.</code> (dot) operator. 1201 * 1202 * @see FullIdent 1203 * @noinspection HtmlTagCanBeJavadocTag 1204 **/ 1205 public static final int DOT = GeneratedJavaTokenTypes.DOT; 1206 /** 1207 * The {@code *} (multiplication or wildcard) operator. 1208 * 1209 * @see <a 1210 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java 1211 * Language Specification, §7.5.2</a> 1212 * @see <a 1213 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java 1214 * Language Specification, §15.17.1</a> 1215 * @see #EXPR 1216 * @see #IMPORT 1217 **/ 1218 public static final int STAR = GeneratedJavaTokenTypes.STAR; 1219 /** 1220 * The {@code private} keyword. 1221 * 1222 * @see #MODIFIERS 1223 **/ 1224 public static final int LITERAL_PRIVATE = 1225 GeneratedJavaTokenTypes.LITERAL_private; 1226 1227 /** 1228 * The {@code public} keyword. 1229 * 1230 * @see #MODIFIERS 1231 **/ 1232 public static final int LITERAL_PUBLIC = 1233 GeneratedJavaTokenTypes.LITERAL_public; 1234 1235 /** 1236 * The {@code protected} keyword. 1237 * 1238 * @see #MODIFIERS 1239 **/ 1240 public static final int LITERAL_PROTECTED = 1241 GeneratedJavaTokenTypes.LITERAL_protected; 1242 1243 /** 1244 * The {@code static} keyword. 1245 * 1246 * @see #MODIFIERS 1247 **/ 1248 public static final int LITERAL_STATIC = 1249 GeneratedJavaTokenTypes.LITERAL_static; 1250 1251 /** 1252 * The {@code transient} keyword. 1253 * 1254 * @see #MODIFIERS 1255 **/ 1256 public static final int LITERAL_TRANSIENT = 1257 GeneratedJavaTokenTypes.LITERAL_transient; 1258 1259 /** 1260 * The {@code native} keyword. 1261 * 1262 * @see #MODIFIERS 1263 **/ 1264 public static final int LITERAL_NATIVE = 1265 GeneratedJavaTokenTypes.LITERAL_native; 1266 1267 /** 1268 * The {@code synchronized} keyword. This may be used as a 1269 * modifier of a method or in the definition of a synchronized 1270 * block. 1271 * 1272 * <p>For example:</p> 1273 * 1274 * <pre> 1275 * synchronized(this) 1276 * { 1277 * x++; 1278 * } 1279 * </pre> 1280 * 1281 * <p>parses as:</p> 1282 * 1283 * <pre> 1284 * +--LITERAL_SYNCHRONIZED (synchronized) 1285 * | 1286 * +--LPAREN (() 1287 * +--EXPR 1288 * | 1289 * +--LITERAL_THIS (this) 1290 * +--RPAREN ()) 1291 * +--SLIST ({) 1292 * | 1293 * +--EXPR 1294 * | 1295 * +--POST_INC (++) 1296 * | 1297 * +--IDENT (x) 1298 * +--SEMI (;) 1299 * +--RCURLY (}) 1300 * +--RCURLY (}) 1301 * </pre> 1302 * 1303 * @see #MODIFIERS 1304 * @see #LPAREN 1305 * @see #EXPR 1306 * @see #RPAREN 1307 * @see #SLIST 1308 * @see #RCURLY 1309 **/ 1310 public static final int LITERAL_SYNCHRONIZED = 1311 GeneratedJavaTokenTypes.LITERAL_synchronized; 1312 1313 /** 1314 * The {@code volatile} keyword. 1315 * 1316 * @see #MODIFIERS 1317 **/ 1318 public static final int LITERAL_VOLATILE = 1319 GeneratedJavaTokenTypes.LITERAL_volatile; 1320 1321 /** 1322 * The {@code class} keyword. This element appears both 1323 * as part of a class declaration, and inline to reference a 1324 * class object. 1325 * 1326 * <p>For example:</p> 1327 * 1328 * <pre> 1329 * int.class 1330 * </pre> 1331 * <p>parses as:</p> 1332 * <pre> 1333 * +--EXPR 1334 * | 1335 * +--DOT (.) 1336 * | 1337 * +--LITERAL_INT (int) 1338 * +--LITERAL_CLASS (class) 1339 * </pre> 1340 * 1341 * @see #DOT 1342 * @see #IDENT 1343 * @see #CLASS_DEF 1344 * @see FullIdent 1345 **/ 1346 public static final int LITERAL_CLASS = 1347 GeneratedJavaTokenTypes.LITERAL_class; 1348 1349 /** 1350 * The {@code interface} keyword. This token appears in 1351 * interface definition. 1352 * 1353 * @see #INTERFACE_DEF 1354 **/ 1355 public static final int LITERAL_INTERFACE = 1356 GeneratedJavaTokenTypes.LITERAL_interface; 1357 1358 /** 1359 * A left curly brace (<code>{</code>). 1360 * 1361 * @see #OBJBLOCK 1362 * @see #ARRAY_INIT 1363 * @see #SLIST 1364 **/ 1365 public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY; 1366 /** 1367 * A right curly brace (<code>}</code>). 1368 * 1369 * @see #OBJBLOCK 1370 * @see #ARRAY_INIT 1371 * @see #SLIST 1372 **/ 1373 public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY; 1374 /** 1375 * The {@code ,} (comma) operator. 1376 * 1377 * @see #ARRAY_INIT 1378 * @see #FOR_INIT 1379 * @see #FOR_ITERATOR 1380 * @see #LITERAL_THROWS 1381 * @see #IMPLEMENTS_CLAUSE 1382 **/ 1383 public static final int COMMA = GeneratedJavaTokenTypes.COMMA; 1384 1385 /** 1386 * A left parenthesis ({@code (}). 1387 * 1388 * @see #LITERAL_FOR 1389 * @see #LITERAL_NEW 1390 * @see #EXPR 1391 * @see #LITERAL_SWITCH 1392 * @see #LITERAL_CATCH 1393 **/ 1394 public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN; 1395 /** 1396 * A right parenthesis ({@code )}). 1397 * 1398 * @see #LITERAL_FOR 1399 * @see #LITERAL_NEW 1400 * @see #METHOD_CALL 1401 * @see #TYPECAST 1402 * @see #EXPR 1403 * @see #LITERAL_SWITCH 1404 * @see #LITERAL_CATCH 1405 **/ 1406 public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN; 1407 /** 1408 * The {@code this} keyword. 1409 * 1410 * @see #EXPR 1411 * @see #CTOR_CALL 1412 **/ 1413 public static final int LITERAL_THIS = 1414 GeneratedJavaTokenTypes.LITERAL_this; 1415 1416 /** 1417 * The {@code super} keyword. 1418 * 1419 * @see #EXPR 1420 * @see #SUPER_CTOR_CALL 1421 **/ 1422 public static final int LITERAL_SUPER = 1423 GeneratedJavaTokenTypes.LITERAL_super; 1424 1425 /** 1426 * The {@code =} (assignment) operator. 1427 * 1428 * @see <a 1429 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java 1430 * Language Specification, §15.26.1</a> 1431 * @see #EXPR 1432 **/ 1433 public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN; 1434 /** 1435 * The {@code throws} keyword. The children are a number of 1436 * one or more identifiers separated by commas. 1437 * 1438 * @see <a 1439 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java 1440 * Language Specification, §8.4.4</a> 1441 * @see #IDENT 1442 * @see #DOT 1443 * @see #COMMA 1444 * @see #METHOD_DEF 1445 * @see #CTOR_DEF 1446 * @see FullIdent 1447 **/ 1448 public static final int LITERAL_THROWS = 1449 GeneratedJavaTokenTypes.LITERAL_throws; 1450 1451 /** 1452 * The {@code :} (colon) operator. This will appear as part 1453 * of the conditional operator ({@code ? :}). 1454 * 1455 * @see #QUESTION 1456 * @see #LABELED_STAT 1457 * @see #CASE_GROUP 1458 **/ 1459 public static final int COLON = GeneratedJavaTokenTypes.COLON; 1460 1461 /** 1462 * The {@code ::} (double colon) separator. 1463 * It is part of Java 8 syntax that is used for method reference. 1464 * The token does not appear in tree, {@link #METHOD_REF} should be used instead. 1465 * 1466 * @see #METHOD_REF 1467 */ 1468 public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON; 1469 /** 1470 * The {@code if} keyword. 1471 * 1472 * <p>For example:</p> 1473 * <pre> 1474 * if(optimistic) 1475 * { 1476 * message = "half full"; 1477 * } 1478 * else 1479 * { 1480 * message = "half empty"; 1481 * } 1482 * </pre> 1483 * <p>parses as:</p> 1484 * <pre> 1485 * +--LITERAL_IF (if) 1486 * | 1487 * +--LPAREN (() 1488 * +--EXPR 1489 * | 1490 * +--IDENT (optimistic) 1491 * +--RPAREN ()) 1492 * +--SLIST ({) 1493 * | 1494 * +--EXPR 1495 * | 1496 * +--ASSIGN (=) 1497 * | 1498 * +--IDENT (message) 1499 * +--STRING_LITERAL ("half full") 1500 * +--SEMI (;) 1501 * +--RCURLY (}) 1502 * +--LITERAL_ELSE (else) 1503 * | 1504 * +--SLIST ({) 1505 * | 1506 * +--EXPR 1507 * | 1508 * +--ASSIGN (=) 1509 * | 1510 * +--IDENT (message) 1511 * +--STRING_LITERAL ("half empty") 1512 * +--SEMI (;) 1513 * +--RCURLY (}) 1514 * </pre> 1515 * 1516 * @see #LPAREN 1517 * @see #EXPR 1518 * @see #RPAREN 1519 * @see #SLIST 1520 * @see #EMPTY_STAT 1521 * @see #LITERAL_ELSE 1522 **/ 1523 public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if; 1524 /** 1525 * The {@code for} keyword. The children are {@code (}, 1526 * an initializer, a condition, an iterator, a {@code )} and 1527 * either a statement list, a single expression, or an empty 1528 * statement. 1529 * 1530 * <p>For example:</p> 1531 * <pre> 1532 * for(int i = 0, n = myArray.length; i < n; i++) 1533 * { 1534 * } 1535 * </pre> 1536 * 1537 * <p>parses as:</p> 1538 * <pre> 1539 * +--LITERAL_FOR (for) 1540 * | 1541 * +--LPAREN (() 1542 * +--FOR_INIT 1543 * | 1544 * +--VARIABLE_DEF 1545 * | 1546 * +--MODIFIERS 1547 * +--TYPE 1548 * | 1549 * +--LITERAL_INT (int) 1550 * +--IDENT (i) 1551 * +--ASSIGN (=) 1552 * | 1553 * +--EXPR 1554 * | 1555 * +--NUM_INT (0) 1556 * +--COMMA (,) 1557 * +--VARIABLE_DEF 1558 * | 1559 * +--MODIFIERS 1560 * +--TYPE 1561 * | 1562 * +--LITERAL_INT (int) 1563 * +--IDENT (n) 1564 * +--ASSIGN (=) 1565 * | 1566 * +--EXPR 1567 * | 1568 * +--DOT (.) 1569 * | 1570 * +--IDENT (myArray) 1571 * +--IDENT (length) 1572 * +--SEMI (;) 1573 * +--FOR_CONDITION 1574 * | 1575 * +--EXPR 1576 * | 1577 * +--LT (<) 1578 * | 1579 * +--IDENT (i) 1580 * +--IDENT (n) 1581 * +--SEMI (;) 1582 * +--FOR_ITERATOR 1583 * | 1584 * +--ELIST 1585 * | 1586 * +--EXPR 1587 * | 1588 * +--POST_INC (++) 1589 * | 1590 * +--IDENT (i) 1591 * +--RPAREN ()) 1592 * +--SLIST ({) 1593 * | 1594 * +--RCURLY (}) 1595 * </pre> 1596 * 1597 * @see #LPAREN 1598 * @see #FOR_INIT 1599 * @see #SEMI 1600 * @see #FOR_CONDITION 1601 * @see #FOR_ITERATOR 1602 * @see #RPAREN 1603 * @see #SLIST 1604 * @see #EMPTY_STAT 1605 * @see #EXPR 1606 **/ 1607 public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for; 1608 /** 1609 * The {@code while} keyword. 1610 * 1611 * <p>For example:</p> 1612 * <pre> 1613 * while(line != null) 1614 * { 1615 * process(line); 1616 * line = in.readLine(); 1617 * } 1618 * </pre> 1619 * <p>parses as:</p> 1620 * <pre> 1621 * +--LITERAL_WHILE (while) 1622 * | 1623 * +--LPAREN (() 1624 * +--EXPR 1625 * | 1626 * +--NOT_EQUAL (!=) 1627 * | 1628 * +--IDENT (line) 1629 * +--LITERAL_NULL (null) 1630 * +--RPAREN ()) 1631 * +--SLIST ({) 1632 * | 1633 * +--EXPR 1634 * | 1635 * +--METHOD_CALL (() 1636 * | 1637 * +--IDENT (process) 1638 * +--ELIST 1639 * | 1640 * +--EXPR 1641 * | 1642 * +--IDENT (line) 1643 * +--RPAREN ()) 1644 * +--SEMI (;) 1645 * +--EXPR 1646 * | 1647 * +--ASSIGN (=) 1648 * | 1649 * +--IDENT (line) 1650 * +--METHOD_CALL (() 1651 * | 1652 * +--DOT (.) 1653 * | 1654 * +--IDENT (in) 1655 * +--IDENT (readLine) 1656 * +--ELIST 1657 * +--RPAREN ()) 1658 * +--SEMI (;) 1659 * +--RCURLY (}) 1660 * </pre> 1661 **/ 1662 public static final int LITERAL_WHILE = 1663 GeneratedJavaTokenTypes.LITERAL_while; 1664 1665 /** 1666 * The {@code do} keyword. Note the the while token does not 1667 * appear as part of the do-while construct. 1668 * 1669 * <p>For example:</p> 1670 * <pre> 1671 * do 1672 * { 1673 * x = rand.nextInt(10); 1674 * } 1675 * while(x < 5); 1676 * </pre> 1677 * <p>parses as:</p> 1678 * <pre> 1679 * +--LITERAL_DO (do) 1680 * | 1681 * +--SLIST ({) 1682 * | 1683 * +--EXPR 1684 * | 1685 * +--ASSIGN (=) 1686 * | 1687 * +--IDENT (x) 1688 * +--METHOD_CALL (() 1689 * | 1690 * +--DOT (.) 1691 * | 1692 * +--IDENT (rand) 1693 * +--IDENT (nextInt) 1694 * +--ELIST 1695 * | 1696 * +--EXPR 1697 * | 1698 * +--NUM_INT (10) 1699 * +--RPAREN ()) 1700 * +--SEMI (;) 1701 * +--RCURLY (}) 1702 * +--DO_WHILE (while) 1703 * +--LPAREN (() 1704 * +--EXPR 1705 * | 1706 * +--LT (<) 1707 * | 1708 * +--IDENT (x) 1709 * +--NUM_INT (5) 1710 * +--RPAREN ()) 1711 * +--SEMI (;) 1712 * </pre> 1713 * 1714 * @see #SLIST 1715 * @see #EXPR 1716 * @see #EMPTY_STAT 1717 * @see #LPAREN 1718 * @see #RPAREN 1719 * @see #SEMI 1720 **/ 1721 public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do; 1722 /** 1723 * Literal {@code while} in do-while loop. 1724 * 1725 * @see #LITERAL_DO 1726 */ 1727 public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE; 1728 /** 1729 * The {@code break} keyword. The first child is an optional 1730 * identifier and the last child is a semicolon. 1731 * 1732 * @see #IDENT 1733 * @see #SEMI 1734 * @see #SLIST 1735 **/ 1736 public static final int LITERAL_BREAK = 1737 GeneratedJavaTokenTypes.LITERAL_break; 1738 1739 /** 1740 * The {@code continue} keyword. The first child is an 1741 * optional identifier and the last child is a semicolon. 1742 * 1743 * @see #IDENT 1744 * @see #SEMI 1745 * @see #SLIST 1746 **/ 1747 public static final int LITERAL_CONTINUE = 1748 GeneratedJavaTokenTypes.LITERAL_continue; 1749 1750 /** 1751 * The {@code return} keyword. The first child is an 1752 * optional expression for the return value. The last child is a 1753 * semi colon. 1754 * 1755 * @see #EXPR 1756 * @see #SEMI 1757 * @see #SLIST 1758 **/ 1759 public static final int LITERAL_RETURN = 1760 GeneratedJavaTokenTypes.LITERAL_return; 1761 1762 /** 1763 * The {@code switch} keyword. 1764 * 1765 * <p>For example:</p> 1766 * <pre> 1767 * switch(type) 1768 * { 1769 * case 0: 1770 * background = Color.blue; 1771 * break; 1772 * case 1: 1773 * background = Color.red; 1774 * break; 1775 * default: 1776 * background = Color.green; 1777 * break; 1778 * } 1779 * </pre> 1780 * <p>parses as:</p> 1781 * <pre> 1782 * +--LITERAL_SWITCH (switch) 1783 * | 1784 * +--LPAREN (() 1785 * +--EXPR 1786 * | 1787 * +--IDENT (type) 1788 * +--RPAREN ()) 1789 * +--LCURLY ({) 1790 * +--CASE_GROUP 1791 * | 1792 * +--LITERAL_CASE (case) 1793 * | 1794 * +--EXPR 1795 * | 1796 * +--NUM_INT (0) 1797 * +--SLIST 1798 * | 1799 * +--EXPR 1800 * | 1801 * +--ASSIGN (=) 1802 * | 1803 * +--IDENT (background) 1804 * +--DOT (.) 1805 * | 1806 * +--IDENT (Color) 1807 * +--IDENT (blue) 1808 * +--SEMI (;) 1809 * +--LITERAL_BREAK (break) 1810 * | 1811 * +--SEMI (;) 1812 * +--CASE_GROUP 1813 * | 1814 * +--LITERAL_CASE (case) 1815 * | 1816 * +--EXPR 1817 * | 1818 * +--NUM_INT (1) 1819 * +--SLIST 1820 * | 1821 * +--EXPR 1822 * | 1823 * +--ASSIGN (=) 1824 * | 1825 * +--IDENT (background) 1826 * +--DOT (.) 1827 * | 1828 * +--IDENT (Color) 1829 * +--IDENT (red) 1830 * +--SEMI (;) 1831 * +--LITERAL_BREAK (break) 1832 * | 1833 * +--SEMI (;) 1834 * +--CASE_GROUP 1835 * | 1836 * +--LITERAL_DEFAULT (default) 1837 * +--SLIST 1838 * | 1839 * +--EXPR 1840 * | 1841 * +--ASSIGN (=) 1842 * | 1843 * +--IDENT (background) 1844 * +--DOT (.) 1845 * | 1846 * +--IDENT (Color) 1847 * +--IDENT (green) 1848 * +--SEMI (;) 1849 * +--LITERAL_BREAK (break) 1850 * | 1851 * +--SEMI (;) 1852 * +--RCURLY (}) 1853 * </pre> 1854 * 1855 * @see <a 1856 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 1857 * Language Specification, §14.10</a> 1858 * @see #LPAREN 1859 * @see #EXPR 1860 * @see #RPAREN 1861 * @see #LCURLY 1862 * @see #CASE_GROUP 1863 * @see #RCURLY 1864 * @see #SLIST 1865 * @see #SWITCH_RULE 1866 **/ 1867 public static final int LITERAL_SWITCH = 1868 GeneratedJavaTokenTypes.LITERAL_switch; 1869 1870 /** 1871 * The {@code throw} keyword. The first child is an 1872 * expression that evaluates to a {@code Throwable} instance. 1873 * 1874 * @see <a 1875 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java 1876 * Language Specification, §14.17</a> 1877 * @see #SLIST 1878 * @see #EXPR 1879 **/ 1880 public static final int LITERAL_THROW = 1881 GeneratedJavaTokenTypes.LITERAL_throw; 1882 1883 /** 1884 * The {@code else} keyword. This appears as a child of an 1885 * {@code if} statement. 1886 * 1887 * @see #SLIST 1888 * @see #EXPR 1889 * @see #EMPTY_STAT 1890 * @see #LITERAL_IF 1891 **/ 1892 public static final int LITERAL_ELSE = 1893 GeneratedJavaTokenTypes.LITERAL_else; 1894 1895 /** 1896 * The {@code case} keyword. The first child is a constant 1897 * expression that evaluates to an integer. 1898 * 1899 * @see #CASE_GROUP 1900 * @see #EXPR 1901 **/ 1902 public static final int LITERAL_CASE = 1903 GeneratedJavaTokenTypes.LITERAL_case; 1904 1905 /** 1906 * The {@code default} keyword. This element has no 1907 * children. 1908 * 1909 * @see #CASE_GROUP 1910 * @see #MODIFIERS 1911 * @see #SWITCH_RULE 1912 **/ 1913 public static final int LITERAL_DEFAULT = 1914 GeneratedJavaTokenTypes.LITERAL_default; 1915 1916 /** 1917 * The {@code try} keyword. The children are a statement 1918 * list, zero or more catch blocks and then an optional finally 1919 * block. 1920 * 1921 * <p>For example:</p> 1922 * <pre> 1923 * try 1924 * { 1925 * FileReader in = new FileReader("abc.txt"); 1926 * } 1927 * catch(IOException ioe) 1928 * { 1929 * } 1930 * finally 1931 * { 1932 * } 1933 * </pre> 1934 * <p>parses as:</p> 1935 * <pre> 1936 * +--LITERAL_TRY (try) 1937 * | 1938 * +--SLIST ({) 1939 * | 1940 * +--VARIABLE_DEF 1941 * | 1942 * +--MODIFIERS 1943 * +--TYPE 1944 * | 1945 * +--IDENT (FileReader) 1946 * +--IDENT (in) 1947 * +--ASSIGN (=) 1948 * | 1949 * +--EXPR 1950 * | 1951 * +--LITERAL_NEW (new) 1952 * | 1953 * +--IDENT (FileReader) 1954 * +--LPAREN (() 1955 * +--ELIST 1956 * | 1957 * +--EXPR 1958 * | 1959 * +--STRING_LITERAL ("abc.txt") 1960 * +--RPAREN ()) 1961 * +--SEMI (;) 1962 * +--RCURLY (}) 1963 * +--LITERAL_CATCH (catch) 1964 * | 1965 * +--LPAREN (() 1966 * +--PARAMETER_DEF 1967 * | 1968 * +--MODIFIERS 1969 * +--TYPE 1970 * | 1971 * +--IDENT (IOException) 1972 * +--IDENT (ioe) 1973 * +--RPAREN ()) 1974 * +--SLIST ({) 1975 * | 1976 * +--RCURLY (}) 1977 * +--LITERAL_FINALLY (finally) 1978 * | 1979 * +--SLIST ({) 1980 * | 1981 * +--RCURLY (}) 1982 * +--RCURLY (}) 1983 * </pre> 1984 * 1985 * @see <a 1986 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 1987 * Language Specification, §14.19</a> 1988 * @see #SLIST 1989 * @see #LITERAL_CATCH 1990 * @see #LITERAL_FINALLY 1991 **/ 1992 public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try; 1993 1994 /** 1995 * The Java 7 try-with-resources construct. 1996 * 1997 * <p>For example:</p> 1998 * <pre> 1999 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 2000 * </pre> 2001 * <p>parses as:</p> 2002 * <pre> 2003 * +--LITERAL_TRY (try) 2004 * | 2005 * +--RESOURCE_SPECIFICATION 2006 * | 2007 * +--LPAREN (() 2008 * +--RESOURCES 2009 * | 2010 * +--RESOURCE 2011 * | 2012 * +--MODIFIERS 2013 * +--TYPE 2014 * | 2015 * +--IDENT (Foo) 2016 * +--IDENT (foo) 2017 * +--ASSIGN (=) 2018 * +--EXPR 2019 * | 2020 * +--LITERAL_NEW (new) 2021 * | 2022 * +--IDENT (Foo) 2023 * +--LPAREN (() 2024 * +--ELIST 2025 * +--RPAREN ()) 2026 * +--SEMI (;) 2027 * +--RESOURCE 2028 * | 2029 * +--MODIFIERS 2030 * +--TYPE 2031 * | 2032 * +--IDENT (Bar) 2033 * +--IDENT (bar) 2034 * +--ASSIGN (=) 2035 * +--EXPR 2036 * | 2037 * +--LITERAL_NEW (new) 2038 * | 2039 * +--IDENT (Bar) 2040 * +--LPAREN (() 2041 * +--ELIST 2042 * +--RPAREN ()) 2043 * +--RPAREN ()) 2044 * +--SLIST ({) 2045 * +--RCURLY (}) 2046 * </pre> 2047 * 2048 * <p>Also consider:</p> 2049 * <pre> 2050 * try (BufferedReader br = new BufferedReader(new FileReader(path))) 2051 * { 2052 * return br.readLine(); 2053 * } 2054 * </pre> 2055 * <p>which parses as:</p> 2056 * <pre> 2057 * +--LITERAL_TRY (try) 2058 * | 2059 * +--RESOURCE_SPECIFICATION 2060 * | 2061 * +--LPAREN (() 2062 * +--RESOURCES 2063 * | 2064 * +--RESOURCE 2065 * | 2066 * +--MODIFIERS 2067 * +--TYPE 2068 * | 2069 * +--IDENT (BufferedReader) 2070 * +--IDENT (br) 2071 * +--ASSIGN (=) 2072 * +--EXPR 2073 * | 2074 * +--LITERAL_NEW (new) 2075 * | 2076 * +--IDENT (FileReader) 2077 * +--LPAREN (() 2078 * +--ELIST 2079 * | 2080 * +--EXPR 2081 * | 2082 * +--LITERAL_NEW (new) 2083 * | 2084 * +--IDENT (BufferedReader) 2085 * +--LPAREN (() 2086 * +--ELIST 2087 * | 2088 * +--EXPR 2089 * | 2090 * +--IDENT (path) 2091 * +--RPAREN ()) 2092 * +--RPAREN ()) 2093 * +--RPAREN ()) 2094 * +--SLIST ({) 2095 * | 2096 * +--LITERAL_RETURN (return) 2097 * | 2098 * +--EXPR 2099 * | 2100 * +--METHOD_CALL (() 2101 * | 2102 * +--DOT (.) 2103 * | 2104 * +--IDENT (br) 2105 * +--IDENT (readLine) 2106 * +--ELIST 2107 * +--RPAREN ()) 2108 * +--SEMI (;) 2109 * +--RCURLY (}) 2110 * </pre> 2111 * 2112 * @see #LPAREN 2113 * @see #RESOURCES 2114 * @see #RESOURCE 2115 * @see #SEMI 2116 * @see #RPAREN 2117 * @see #LITERAL_TRY 2118 **/ 2119 public static final int RESOURCE_SPECIFICATION = 2120 GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION; 2121 2122 /** 2123 * A list of resources in the Java 7 try-with-resources construct. 2124 * This is a child of RESOURCE_SPECIFICATION. 2125 * 2126 * @see #RESOURCE_SPECIFICATION 2127 **/ 2128 public static final int RESOURCES = 2129 GeneratedJavaTokenTypes.RESOURCES; 2130 2131 /** 2132 * A resource in the Java 7 try-with-resources construct. 2133 * This is a child of RESOURCES. 2134 * 2135 * @see #RESOURCES 2136 * @see #RESOURCE_SPECIFICATION 2137 **/ 2138 public static final int RESOURCE = 2139 GeneratedJavaTokenTypes.RESOURCE; 2140 2141 /** 2142 * The {@code catch} keyword. 2143 * 2144 * @see #LPAREN 2145 * @see #PARAMETER_DEF 2146 * @see #RPAREN 2147 * @see #SLIST 2148 * @see #LITERAL_TRY 2149 **/ 2150 public static final int LITERAL_CATCH = 2151 GeneratedJavaTokenTypes.LITERAL_catch; 2152 2153 /** 2154 * The {@code finally} keyword. 2155 * 2156 * @see #SLIST 2157 * @see #LITERAL_TRY 2158 **/ 2159 public static final int LITERAL_FINALLY = 2160 GeneratedJavaTokenTypes.LITERAL_finally; 2161 2162 /** 2163 * The {@code +=} (addition assignment) operator. 2164 * 2165 * @see <a 2166 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2167 * Language Specification, §15.26.2</a> 2168 * @see #EXPR 2169 **/ 2170 public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN; 2171 /** 2172 * The {@code -=} (subtraction assignment) operator. 2173 * 2174 * @see <a 2175 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2176 * Language Specification, §15.26.2</a> 2177 * @see #EXPR 2178 **/ 2179 public static final int MINUS_ASSIGN = 2180 GeneratedJavaTokenTypes.MINUS_ASSIGN; 2181 2182 /** 2183 * The {@code *=} (multiplication assignment) operator. 2184 * 2185 * @see <a 2186 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2187 * Language Specification, §15.26.2</a> 2188 * @see #EXPR 2189 **/ 2190 public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN; 2191 /** 2192 * The {@code /=} (division assignment) operator. 2193 * 2194 * @see <a 2195 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2196 * Language Specification, §15.26.2</a> 2197 * @see #EXPR 2198 **/ 2199 public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN; 2200 /** 2201 * The {@code %=} (remainder assignment) operator. 2202 * 2203 * @see <a 2204 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2205 * Language Specification, §15.26.2</a> 2206 * @see #EXPR 2207 **/ 2208 public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN; 2209 /** 2210 * The {@code >>=} (signed right shift assignment) 2211 * operator. 2212 * 2213 * @see <a 2214 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2215 * Language Specification, §15.26.2</a> 2216 * @see #EXPR 2217 **/ 2218 public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN; 2219 /** 2220 * The {@code >>>=} (unsigned right shift assignment) 2221 * operator. 2222 * 2223 * @see <a 2224 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2225 * Language Specification, §15.26.2</a> 2226 * @see #EXPR 2227 **/ 2228 public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN; 2229 /** 2230 * The {@code <<=} (left shift assignment) operator. 2231 * 2232 * @see <a 2233 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2234 * Language Specification, §15.26.2</a> 2235 * @see #EXPR 2236 **/ 2237 public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN; 2238 /** 2239 * The {@code &=} (bitwise AND assignment) operator. 2240 * 2241 * @see <a 2242 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2243 * Language Specification, §15.26.2</a> 2244 * @see #EXPR 2245 **/ 2246 public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN; 2247 /** 2248 * The {@code ^=} (bitwise exclusive OR assignment) operator. 2249 * 2250 * @see <a 2251 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2252 * Language Specification, §15.26.2</a> 2253 * @see #EXPR 2254 **/ 2255 public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN; 2256 /** 2257 * The {@code |=} (bitwise OR assignment) operator. 2258 * 2259 * @see <a 2260 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2261 * Language Specification, §15.26.2</a> 2262 * @see #EXPR 2263 **/ 2264 public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN; 2265 /** 2266 * The <code>?</code> (conditional) operator. Technically, 2267 * the colon is also part of this operator, but it appears as a 2268 * separate token. 2269 * 2270 * <p>For example:</p> 2271 * <pre> 2272 * (quantity == 1) ? "": "s" 2273 * </pre> 2274 * <p> 2275 * parses as: 2276 * </p> 2277 * <pre> 2278 * +--QUESTION (?) 2279 * | 2280 * +--LPAREN (() 2281 * +--EQUAL (==) 2282 * | 2283 * +--IDENT (quantity) 2284 * +--NUM_INT (1) 2285 * +--RPAREN ()) 2286 * +--STRING_LITERAL ("") 2287 * +--COLON (:) 2288 * +--STRING_LITERAL ("s") 2289 * </pre> 2290 * 2291 * @see <a 2292 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 2293 * Language Specification, §15.25</a> 2294 * @see #EXPR 2295 * @see #COLON 2296 * @noinspection HtmlTagCanBeJavadocTag 2297 **/ 2298 public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION; 2299 /** 2300 * The {@code ||} (conditional OR) operator. 2301 * 2302 * @see <a 2303 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java 2304 * Language Specification, §15.24</a> 2305 * @see #EXPR 2306 **/ 2307 public static final int LOR = GeneratedJavaTokenTypes.LOR; 2308 /** 2309 * The {@code &&} (conditional AND) operator. 2310 * 2311 * @see <a 2312 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 2313 * Language Specification, §15.23</a> 2314 * @see #EXPR 2315 **/ 2316 public static final int LAND = GeneratedJavaTokenTypes.LAND; 2317 /** 2318 * The {@code |} (bitwise OR) operator. 2319 * 2320 * @see <a 2321 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2322 * Language Specification, §15.22.1</a> 2323 * @see #EXPR 2324 **/ 2325 public static final int BOR = GeneratedJavaTokenTypes.BOR; 2326 /** 2327 * The {@code ^} (bitwise exclusive OR) operator. 2328 * 2329 * @see <a 2330 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2331 * Language Specification, §15.22.1</a> 2332 * @see #EXPR 2333 **/ 2334 public static final int BXOR = GeneratedJavaTokenTypes.BXOR; 2335 /** 2336 * The {@code &} (bitwise AND) operator. 2337 * 2338 * @see <a 2339 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2340 * Language Specification, §15.22.1</a> 2341 * @see #EXPR 2342 **/ 2343 public static final int BAND = GeneratedJavaTokenTypes.BAND; 2344 /** 2345 * The <code>!=</code> (not equal) operator. 2346 * 2347 * @see #EXPR 2348 * @noinspection HtmlTagCanBeJavadocTag 2349 **/ 2350 public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL; 2351 /** 2352 * The {@code ==} (equal) operator. 2353 * 2354 * @see #EXPR 2355 **/ 2356 public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL; 2357 /** 2358 * The {@code <} (less than) operator. 2359 * 2360 * @see #EXPR 2361 **/ 2362 public static final int LT = GeneratedJavaTokenTypes.LT; 2363 /** 2364 * The {@code >} (greater than) operator. 2365 * 2366 * @see #EXPR 2367 **/ 2368 public static final int GT = GeneratedJavaTokenTypes.GT; 2369 /** 2370 * The {@code <=} (less than or equal) operator. 2371 * 2372 * @see #EXPR 2373 **/ 2374 public static final int LE = GeneratedJavaTokenTypes.LE; 2375 /** 2376 * The {@code >=} (greater than or equal) operator. 2377 * 2378 * @see #EXPR 2379 **/ 2380 public static final int GE = GeneratedJavaTokenTypes.GE; 2381 /** 2382 * The {@code instanceof} operator. The first child is an 2383 * object reference or something that evaluates to an object 2384 * reference. The second child is a reference type. 2385 * 2386 * @see <a 2387 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 2388 * Language Specification, §15.20.2</a> 2389 * @see #EXPR 2390 * @see #METHOD_CALL 2391 * @see #IDENT 2392 * @see #DOT 2393 * @see #TYPE 2394 * @see FullIdent 2395 **/ 2396 public static final int LITERAL_INSTANCEOF = 2397 GeneratedJavaTokenTypes.LITERAL_instanceof; 2398 2399 /** 2400 * The {@code <<} (shift left) operator. 2401 * 2402 * @see <a 2403 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2404 * Language Specification, §15.19</a> 2405 * @see #EXPR 2406 **/ 2407 public static final int SL = GeneratedJavaTokenTypes.SL; 2408 /** 2409 * The {@code >>} (signed shift right) operator. 2410 * 2411 * @see <a 2412 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2413 * Language Specification, §15.19</a> 2414 * @see #EXPR 2415 **/ 2416 public static final int SR = GeneratedJavaTokenTypes.SR; 2417 /** 2418 * The {@code >>>} (unsigned shift right) operator. 2419 * 2420 * @see <a 2421 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2422 * Language Specification, §15.19</a> 2423 * @see #EXPR 2424 **/ 2425 public static final int BSR = GeneratedJavaTokenTypes.BSR; 2426 /** 2427 * The {@code +} (addition) operator. 2428 * 2429 * @see <a 2430 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2431 * Language Specification, §15.18</a> 2432 * @see #EXPR 2433 **/ 2434 public static final int PLUS = GeneratedJavaTokenTypes.PLUS; 2435 /** 2436 * The {@code -} (subtraction) operator. 2437 * 2438 * @see <a 2439 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2440 * Language Specification, §15.18</a> 2441 * @see #EXPR 2442 **/ 2443 public static final int MINUS = GeneratedJavaTokenTypes.MINUS; 2444 /** 2445 * The {@code /} (division) operator. 2446 * 2447 * @see <a 2448 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 2449 * Language Specification, §15.17.2</a> 2450 * @see #EXPR 2451 **/ 2452 public static final int DIV = GeneratedJavaTokenTypes.DIV; 2453 /** 2454 * The {@code %} (remainder) operator. 2455 * 2456 * @see <a 2457 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 2458 * Language Specification, §15.17.3</a> 2459 * @see #EXPR 2460 **/ 2461 public static final int MOD = GeneratedJavaTokenTypes.MOD; 2462 /** 2463 * The {@code ++} (prefix increment) operator. 2464 * 2465 * @see <a 2466 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 2467 * Language Specification, §15.15.1</a> 2468 * @see #EXPR 2469 * @see #POST_INC 2470 **/ 2471 public static final int INC = GeneratedJavaTokenTypes.INC; 2472 /** 2473 * The {@code --} (prefix decrement) operator. 2474 * 2475 * @see <a 2476 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 2477 * Language Specification, §15.15.2</a> 2478 * @see #EXPR 2479 * @see #POST_DEC 2480 **/ 2481 public static final int DEC = GeneratedJavaTokenTypes.DEC; 2482 /** 2483 * The {@code ~} (bitwise complement) operator. 2484 * 2485 * @see <a 2486 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 2487 * Language Specification, §15.15.5</a> 2488 * @see #EXPR 2489 **/ 2490 public static final int BNOT = GeneratedJavaTokenTypes.BNOT; 2491 /** 2492 * The <code>!</code> (logical complement) operator. 2493 * 2494 * @see <a 2495 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 2496 * Language Specification, §15.15.6</a> 2497 * @see #EXPR 2498 * @noinspection HtmlTagCanBeJavadocTag 2499 **/ 2500 public static final int LNOT = GeneratedJavaTokenTypes.LNOT; 2501 /** 2502 * The {@code true} keyword. 2503 * 2504 * @see <a 2505 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2506 * Language Specification, §3.10.3</a> 2507 * @see #EXPR 2508 * @see #LITERAL_FALSE 2509 **/ 2510 public static final int LITERAL_TRUE = 2511 GeneratedJavaTokenTypes.LITERAL_true; 2512 2513 /** 2514 * The {@code false} keyword. 2515 * 2516 * @see <a 2517 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2518 * Language Specification, §3.10.3</a> 2519 * @see #EXPR 2520 * @see #LITERAL_TRUE 2521 **/ 2522 public static final int LITERAL_FALSE = 2523 GeneratedJavaTokenTypes.LITERAL_false; 2524 2525 /** 2526 * The {@code null} keyword. 2527 * 2528 * @see <a 2529 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 2530 * Language Specification, §3.10.7</a> 2531 * @see #EXPR 2532 **/ 2533 public static final int LITERAL_NULL = 2534 GeneratedJavaTokenTypes.LITERAL_null; 2535 2536 /** 2537 * The {@code new} keyword. This element is used to define 2538 * new instances of objects, new arrays, and new anonymous inner 2539 * classes. 2540 * 2541 * <p>For example:</p> 2542 * 2543 * <pre> 2544 * new ArrayList(50) 2545 * </pre> 2546 * 2547 * <p>parses as:</p> 2548 * <pre> 2549 * +--LITERAL_NEW (new) 2550 * | 2551 * +--IDENT (ArrayList) 2552 * +--LPAREN (() 2553 * +--ELIST 2554 * | 2555 * +--EXPR 2556 * | 2557 * +--NUM_INT (50) 2558 * +--RPAREN ()) 2559 * </pre> 2560 * 2561 * <p>For example:</p> 2562 * <pre> 2563 * new float[] 2564 * { 2565 * 3.0f, 2566 * 4.0f 2567 * }; 2568 * </pre> 2569 * 2570 * <p>parses as:</p> 2571 * <pre> 2572 * +--LITERAL_NEW (new) 2573 * | 2574 * +--LITERAL_FLOAT (float) 2575 * +--ARRAY_DECLARATOR ([) 2576 * +--ARRAY_INIT ({) 2577 * | 2578 * +--EXPR 2579 * | 2580 * +--NUM_FLOAT (3.0f) 2581 * +--COMMA (,) 2582 * +--EXPR 2583 * | 2584 * +--NUM_FLOAT (4.0f) 2585 * +--RCURLY (}) 2586 * </pre> 2587 * 2588 * <p>For example:</p> 2589 * <pre> 2590 * new FilenameFilter() 2591 * { 2592 * public boolean accept(File dir, String name) 2593 * { 2594 * return name.endsWith(".java"); 2595 * } 2596 * } 2597 * </pre> 2598 * 2599 * <p>parses as:</p> 2600 * <pre> 2601 * +--LITERAL_NEW (new) 2602 * | 2603 * +--IDENT (FilenameFilter) 2604 * +--LPAREN (() 2605 * +--ELIST 2606 * +--RPAREN ()) 2607 * +--OBJBLOCK 2608 * | 2609 * +--LCURLY ({) 2610 * +--METHOD_DEF 2611 * | 2612 * +--MODIFIERS 2613 * | 2614 * +--LITERAL_PUBLIC (public) 2615 * +--TYPE 2616 * | 2617 * +--LITERAL_BOOLEAN (boolean) 2618 * +--IDENT (accept) 2619 * +--PARAMETERS 2620 * | 2621 * +--PARAMETER_DEF 2622 * | 2623 * +--MODIFIERS 2624 * +--TYPE 2625 * | 2626 * +--IDENT (File) 2627 * +--IDENT (dir) 2628 * +--COMMA (,) 2629 * +--PARAMETER_DEF 2630 * | 2631 * +--MODIFIERS 2632 * +--TYPE 2633 * | 2634 * +--IDENT (String) 2635 * +--IDENT (name) 2636 * +--SLIST ({) 2637 * | 2638 * +--LITERAL_RETURN (return) 2639 * | 2640 * +--EXPR 2641 * | 2642 * +--METHOD_CALL (() 2643 * | 2644 * +--DOT (.) 2645 * | 2646 * +--IDENT (name) 2647 * +--IDENT (endsWith) 2648 * +--ELIST 2649 * | 2650 * +--EXPR 2651 * | 2652 * +--STRING_LITERAL (".java") 2653 * +--RPAREN ()) 2654 * +--SEMI (;) 2655 * +--RCURLY (}) 2656 * +--RCURLY (}) 2657 * </pre> 2658 * 2659 * @see #IDENT 2660 * @see #DOT 2661 * @see #LPAREN 2662 * @see #ELIST 2663 * @see #RPAREN 2664 * @see #OBJBLOCK 2665 * @see #ARRAY_INIT 2666 * @see FullIdent 2667 **/ 2668 public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new; 2669 /** 2670 * An integer literal. These may be specified in decimal, 2671 * hexadecimal, or octal form. 2672 * 2673 * @see <a 2674 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2675 * Language Specification, §3.10.1</a> 2676 * @see #EXPR 2677 * @see #NUM_LONG 2678 **/ 2679 public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT; 2680 /** 2681 * A character literal. This is a (possibly escaped) character 2682 * enclosed in single quotes. 2683 * 2684 * @see <a 2685 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 2686 * Language Specification, §3.10.4</a> 2687 * @see #EXPR 2688 **/ 2689 public static final int CHAR_LITERAL = 2690 GeneratedJavaTokenTypes.CHAR_LITERAL; 2691 2692 /** 2693 * A string literal. This is a sequence of (possibly escaped) 2694 * characters enclosed in double quotes. 2695 * 2696 * @see <a 2697 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 2698 * Language Specification, §3.10.5</a> 2699 * @see #EXPR 2700 **/ 2701 public static final int STRING_LITERAL = 2702 GeneratedJavaTokenTypes.STRING_LITERAL; 2703 2704 /** 2705 * A single precision floating point literal. This is a floating 2706 * point number with an {@code F} or {@code f} suffix. 2707 * 2708 * @see <a 2709 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2710 * Language Specification, §3.10.2</a> 2711 * @see #EXPR 2712 * @see #NUM_DOUBLE 2713 **/ 2714 public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT; 2715 /** 2716 * A long integer literal. These are almost the same as integer 2717 * literals, but they have an {@code L} or {@code l} 2718 * (ell) suffix. 2719 * 2720 * @see <a 2721 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2722 * Language Specification, §3.10.1</a> 2723 * @see #EXPR 2724 * @see #NUM_INT 2725 **/ 2726 public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG; 2727 /** 2728 * A double precision floating point literal. This is a floating 2729 * point number with an optional {@code D} or {@code d} 2730 * suffix. 2731 * 2732 * @see <a 2733 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2734 * Language Specification, §3.10.2</a> 2735 * @see #EXPR 2736 * @see #NUM_FLOAT 2737 **/ 2738 public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE; 2739 2740 /** 2741 * The {@code assert} keyword. This is only for Java 1.4 and 2742 * later. 2743 * 2744 * <p>For example:</p> 2745 * <pre> 2746 * assert(x==4); 2747 * </pre> 2748 * <p>parses as:</p> 2749 * <pre> 2750 * +--LITERAL_ASSERT (assert) 2751 * | 2752 * +--EXPR 2753 * | 2754 * +--LPAREN (() 2755 * +--EQUAL (==) 2756 * | 2757 * +--IDENT (x) 2758 * +--NUM_INT (4) 2759 * +--RPAREN ()) 2760 * +--SEMI (;) 2761 * </pre> 2762 **/ 2763 public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT; 2764 2765 /** 2766 * A static import declaration. Static import declarations are optional, 2767 * but must appear after the package declaration and before the type 2768 * declaration. 2769 * 2770 * <p>For example:</p> 2771 * 2772 * <pre> 2773 * import static java.io.IOException; 2774 * </pre> 2775 * 2776 * <p>parses as:</p> 2777 * 2778 * <pre> 2779 * +--STATIC_IMPORT (import) 2780 * | 2781 * +--LITERAL_STATIC 2782 * +--DOT (.) 2783 * | 2784 * +--DOT (.) 2785 * | 2786 * +--IDENT (java) 2787 * +--IDENT (io) 2788 * +--IDENT (IOException) 2789 * +--SEMI (;) 2790 * </pre> 2791 * 2792 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2793 * JSR201</a> 2794 * @see #LITERAL_STATIC 2795 * @see #DOT 2796 * @see #IDENT 2797 * @see #STAR 2798 * @see #SEMI 2799 * @see FullIdent 2800 **/ 2801 public static final int STATIC_IMPORT = 2802 GeneratedJavaTokenTypes.STATIC_IMPORT; 2803 2804 /** 2805 * An enum declaration. Its notable children are 2806 * enum constant declarations followed by 2807 * any construct that may be expected in a class body. 2808 * 2809 * <p>For example:</p> 2810 * <pre> 2811 * public enum MyEnum 2812 * implements Serializable 2813 * { 2814 * FIRST_CONSTANT, 2815 * SECOND_CONSTANT; 2816 * 2817 * public void someMethod() 2818 * { 2819 * } 2820 * } 2821 * </pre> 2822 * <p>parses as:</p> 2823 * <pre> 2824 * +--ENUM_DEF 2825 * | 2826 * +--MODIFIERS 2827 * | 2828 * +--LITERAL_PUBLIC (public) 2829 * +--ENUM (enum) 2830 * +--IDENT (MyEnum) 2831 * +--EXTENDS_CLAUSE 2832 * +--IMPLEMENTS_CLAUSE 2833 * | 2834 * +--IDENT (Serializable) 2835 * +--OBJBLOCK 2836 * | 2837 * +--LCURLY ({) 2838 * +--ENUM_CONSTANT_DEF 2839 * | 2840 * +--IDENT (FIRST_CONSTANT) 2841 * +--COMMA (,) 2842 * +--ENUM_CONSTANT_DEF 2843 * | 2844 * +--IDENT (SECOND_CONSTANT) 2845 * +--SEMI (;) 2846 * +--METHOD_DEF 2847 * | 2848 * +--MODIFIERS 2849 * | 2850 * +--LITERAL_PUBLIC (public) 2851 * +--TYPE 2852 * | 2853 * +--LITERAL_void (void) 2854 * +--IDENT (someMethod) 2855 * +--LPAREN (() 2856 * +--PARAMETERS 2857 * +--RPAREN ()) 2858 * +--SLIST ({) 2859 * | 2860 * +--RCURLY (}) 2861 * +--RCURLY (}) 2862 * </pre> 2863 * 2864 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2865 * JSR201</a> 2866 * @see #MODIFIERS 2867 * @see #ENUM 2868 * @see #IDENT 2869 * @see #EXTENDS_CLAUSE 2870 * @see #IMPLEMENTS_CLAUSE 2871 * @see #OBJBLOCK 2872 * @see #LITERAL_NEW 2873 * @see #ENUM_CONSTANT_DEF 2874 **/ 2875 public static final int ENUM_DEF = 2876 GeneratedJavaTokenTypes.ENUM_DEF; 2877 2878 /** 2879 * The {@code enum} keyword. This element appears 2880 * as part of an enum declaration. 2881 **/ 2882 public static final int ENUM = 2883 GeneratedJavaTokenTypes.ENUM; 2884 2885 /** 2886 * An enum constant declaration. Its notable children are annotations, 2887 * arguments and object block akin to an anonymous 2888 * inner class' body. 2889 * 2890 * <p>For example:</p> 2891 * <pre> 2892 * SOME_CONSTANT(1) 2893 * { 2894 * public void someMethodOverriddenFromMainBody() 2895 * { 2896 * } 2897 * } 2898 * </pre> 2899 * <p>parses as:</p> 2900 * <pre> 2901 * +--ENUM_CONSTANT_DEF 2902 * | 2903 * +--ANNOTATIONS 2904 * +--IDENT (SOME_CONSTANT) 2905 * +--LPAREN (() 2906 * +--ELIST 2907 * | 2908 * +--EXPR 2909 * | 2910 * +--NUM_INT (1) 2911 * +--RPAREN ()) 2912 * +--OBJBLOCK 2913 * | 2914 * +--LCURLY ({) 2915 * | 2916 * +--METHOD_DEF 2917 * | 2918 * +--MODIFIERS 2919 * | 2920 * +--LITERAL_PUBLIC (public) 2921 * +--TYPE 2922 * | 2923 * +--LITERAL_void (void) 2924 * +--IDENT (someMethodOverriddenFromMainBody) 2925 * +--LPAREN (() 2926 * +--PARAMETERS 2927 * +--RPAREN ()) 2928 * +--SLIST ({) 2929 * | 2930 * +--RCURLY (}) 2931 * +--RCURLY (}) 2932 * </pre> 2933 * 2934 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2935 * JSR201</a> 2936 * @see #ANNOTATIONS 2937 * @see #MODIFIERS 2938 * @see #IDENT 2939 * @see #ELIST 2940 * @see #OBJBLOCK 2941 **/ 2942 public static final int ENUM_CONSTANT_DEF = 2943 GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF; 2944 2945 /** 2946 * A for-each clause. This is a child of 2947 * {@code LITERAL_FOR}. The children of this element may be 2948 * a parameter definition, the colon literal and an expression. 2949 * 2950 * <p>For example:</p> 2951 * <pre> 2952 * for (int value : values) { 2953 * doSmth(); 2954 * } 2955 * </pre> 2956 * <p>parses as:</p> 2957 * <pre> 2958 * --LITERAL_FOR (for) 2959 * |--LPAREN (() 2960 * |--FOR_EACH_CLAUSE 2961 * | |--VARIABLE_DEF 2962 * | | |--MODIFIERS 2963 * | | |--TYPE 2964 * | | | `--LITERAL_INT (int) 2965 * | | `--IDENT (value) 2966 * | |--COLON (:) 2967 * | `--EXPR 2968 * | `--IDENT (values 2969 * |--RPAREN ()) 2970 * `--SLIST ({) 2971 * |--EXPR 2972 * | `--METHOD_CALL (() 2973 * | |--IDENT (doSmth) 2974 * | |--ELIST 2975 * | `--RPAREN ()) 2976 * |--SEMI (;) 2977 * `--RCURLY (}) 2978 * 2979 * </pre> 2980 * 2981 * @see #VARIABLE_DEF 2982 * @see #ELIST 2983 * @see #LITERAL_FOR 2984 **/ 2985 public static final int FOR_EACH_CLAUSE = 2986 GeneratedJavaTokenTypes.FOR_EACH_CLAUSE; 2987 2988 /** 2989 * An annotation declaration. The notable children are the name of the 2990 * annotation type, annotation field declarations and (constant) fields. 2991 * 2992 * <p>For example:</p> 2993 * <pre> 2994 * public @interface MyAnnotation 2995 * { 2996 * int someValue(); 2997 * } 2998 * </pre> 2999 * <p>parses as:</p> 3000 * <pre> 3001 * +--ANNOTATION_DEF 3002 * | 3003 * +--MODIFIERS 3004 * | 3005 * +--LITERAL_PUBLIC (public) 3006 * +--AT (@) 3007 * +--LITERAL_INTERFACE (interface) 3008 * +--IDENT (MyAnnotation) 3009 * +--OBJBLOCK 3010 * | 3011 * +--LCURLY ({) 3012 * +--ANNOTATION_FIELD_DEF 3013 * | 3014 * +--MODIFIERS 3015 * +--TYPE 3016 * | 3017 * +--LITERAL_INT (int) 3018 * +--IDENT (someValue) 3019 * +--LPAREN (() 3020 * +--RPAREN ()) 3021 * +--SEMI (;) 3022 * +--RCURLY (}) 3023 * </pre> 3024 * 3025 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3026 * JSR201</a> 3027 * @see #MODIFIERS 3028 * @see #LITERAL_INTERFACE 3029 * @see #IDENT 3030 * @see #OBJBLOCK 3031 * @see #ANNOTATION_FIELD_DEF 3032 **/ 3033 public static final int ANNOTATION_DEF = 3034 GeneratedJavaTokenTypes.ANNOTATION_DEF; 3035 3036 /** 3037 * An annotation field declaration. The notable children are modifiers, 3038 * field type, field name and an optional default value (a conditional 3039 * compile-time constant expression). Default values may also by 3040 * annotations. 3041 * 3042 * <p>For example:</p> 3043 * 3044 * <pre> 3045 * String someField() default "Hello world"; 3046 * </pre> 3047 * 3048 * <p>parses as:</p> 3049 * 3050 * <pre> 3051 * +--ANNOTATION_FIELD_DEF 3052 * | 3053 * +--MODIFIERS 3054 * +--TYPE 3055 * | 3056 * +--IDENT (String) 3057 * +--IDENT (someField) 3058 * +--LPAREN (() 3059 * +--RPAREN ()) 3060 * +--LITERAL_DEFAULT (default) 3061 * +--STRING_LITERAL ("Hello world") 3062 * +--SEMI (;) 3063 * </pre> 3064 * 3065 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3066 * JSR201</a> 3067 * @see #MODIFIERS 3068 * @see #TYPE 3069 * @see #LITERAL_DEFAULT 3070 */ 3071 public static final int ANNOTATION_FIELD_DEF = 3072 GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF; 3073 3074 // note: @ is the html escape for '@', 3075 // used here to avoid confusing the javadoc tool 3076 /** 3077 * A collection of annotations on a package or enum constant. 3078 * A collections of annotations will only occur on these nodes 3079 * as all other nodes that may be qualified with an annotation can 3080 * be qualified with any other modifier and hence these annotations 3081 * would be contained in a {@link #MODIFIERS} node. 3082 * 3083 * <p>For example:</p> 3084 * 3085 * <pre> 3086 * @MyAnnotation package blah; 3087 * </pre> 3088 * 3089 * <p>parses as:</p> 3090 * 3091 * <pre> 3092 * +--PACKAGE_DEF (package) 3093 * | 3094 * +--ANNOTATIONS 3095 * | 3096 * +--ANNOTATION 3097 * | 3098 * +--AT (@) 3099 * +--IDENT (MyAnnotation) 3100 * +--IDENT (blah) 3101 * +--SEMI (;) 3102 * </pre> 3103 * 3104 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3105 * JSR201</a> 3106 * @see #ANNOTATION 3107 * @see #AT 3108 * @see #IDENT 3109 */ 3110 public static final int ANNOTATIONS = 3111 GeneratedJavaTokenTypes.ANNOTATIONS; 3112 3113 // note: @ is the html escape for '@', 3114 // used here to avoid confusing the javadoc tool 3115 /** 3116 * An annotation of a package, type, field, parameter or variable. 3117 * An annotation may occur anywhere modifiers occur (it is a 3118 * type of modifier) and may also occur prior to a package definition. 3119 * The notable children are: The annotation name and either a single 3120 * default annotation value or a sequence of name value pairs. 3121 * Annotation values may also be annotations themselves. 3122 * 3123 * <p>For example:</p> 3124 * 3125 * <pre> 3126 * @MyAnnotation(someField1 = "Hello", 3127 * someField2 = @SomeOtherAnnotation) 3128 * </pre> 3129 * 3130 * <p>parses as:</p> 3131 * 3132 * <pre> 3133 * +--ANNOTATION 3134 * | 3135 * +--AT (@) 3136 * +--IDENT (MyAnnotation) 3137 * +--LPAREN (() 3138 * +--ANNOTATION_MEMBER_VALUE_PAIR 3139 * | 3140 * +--IDENT (someField1) 3141 * +--ASSIGN (=) 3142 * +--ANNOTATION 3143 * | 3144 * +--AT (@) 3145 * +--IDENT (SomeOtherAnnotation) 3146 * +--ANNOTATION_MEMBER_VALUE_PAIR 3147 * | 3148 * +--IDENT (someField2) 3149 * +--ASSIGN (=) 3150 * +--STRING_LITERAL ("Hello") 3151 * +--RPAREN ()) 3152 * </pre> 3153 * 3154 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3155 * JSR201</a> 3156 * @see #MODIFIERS 3157 * @see #IDENT 3158 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3159 */ 3160 public static final int ANNOTATION = 3161 GeneratedJavaTokenTypes.ANNOTATION; 3162 3163 /** 3164 * An initialization of an annotation member with a value. 3165 * Its children are the name of the member, the assignment literal 3166 * and the (compile-time constant conditional expression) value. 3167 * 3168 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3169 * JSR201</a> 3170 * @see #ANNOTATION 3171 * @see #IDENT 3172 */ 3173 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 3174 GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR; 3175 3176 /** 3177 * An annotation array member initialization. 3178 * Initializers can not be nested. 3179 * An initializer may be present as a default to an annotation 3180 * member, as the single default value to an annotation 3181 * (e.g. @Annotation({1,2})) or as the value of an annotation 3182 * member value pair. 3183 * 3184 * <p>For example:</p> 3185 * 3186 * <pre> 3187 * { 1, 2 } 3188 * </pre> 3189 * 3190 * <p>parses as:</p> 3191 * 3192 * <pre> 3193 * +--ANNOTATION_ARRAY_INIT ({) 3194 * | 3195 * +--NUM_INT (1) 3196 * +--COMMA (,) 3197 * +--NUM_INT (2) 3198 * +--RCURLY (}) 3199 * </pre> 3200 * 3201 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3202 * JSR201</a> 3203 * @see #ANNOTATION 3204 * @see #IDENT 3205 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3206 */ 3207 public static final int ANNOTATION_ARRAY_INIT = 3208 GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT; 3209 3210 /** 3211 * A list of type parameters to a class, interface or 3212 * method definition. Children are LT, at least one 3213 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 3214 * TYPE_PARAMETER and a final GT. 3215 * 3216 * <p>For example:</p> 3217 * 3218 * <pre> 3219 * public class Blah<A, B> 3220 * { 3221 * } 3222 * </pre> 3223 * 3224 * <p>parses as:</p> 3225 * 3226 * <pre> 3227 * +--CLASS_DEF ({) 3228 * | 3229 * +--MODIFIERS 3230 * | 3231 * +--LITERAL_PUBLIC (public) 3232 * +--LITERAL_CLASS (class) 3233 * +--IDENT (Blah) 3234 * +--TYPE_PARAMETERS 3235 * | 3236 * +--GENERIC_START (<) 3237 * +--TYPE_PARAMETER 3238 * | 3239 * +--IDENT (A) 3240 * +--COMMA (,) 3241 * +--TYPE_PARAMETER 3242 * | 3243 * +--IDENT (B) 3244 * +--GENERIC_END (>) 3245 * +--OBJBLOCK 3246 * | 3247 * +--LCURLY ({) 3248 * +--NUM_INT (1) 3249 * +--COMMA (,) 3250 * +--NUM_INT (2) 3251 * +--RCURLY (}) 3252 * </pre> 3253 * 3254 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3255 * JSR14</a> 3256 * @see #GENERIC_START 3257 * @see #GENERIC_END 3258 * @see #TYPE_PARAMETER 3259 * @see #COMMA 3260 */ 3261 public static final int TYPE_PARAMETERS = 3262 GeneratedJavaTokenTypes.TYPE_PARAMETERS; 3263 3264 /** 3265 * A type parameter to a class, interface or method definition. 3266 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 3267 * 3268 * <p>For example:</p> 3269 * 3270 * <pre> 3271 * A extends Collection 3272 * </pre> 3273 * 3274 * <p>parses as:</p> 3275 * 3276 * <pre> 3277 * +--TYPE_PARAMETER 3278 * | 3279 * +--IDENT (A) 3280 * +--TYPE_UPPER_BOUNDS 3281 * | 3282 * +--IDENT (Collection) 3283 * </pre> 3284 * 3285 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3286 * JSR14</a> 3287 * @see #IDENT 3288 * @see #WILDCARD_TYPE 3289 * @see #TYPE_UPPER_BOUNDS 3290 */ 3291 public static final int TYPE_PARAMETER = 3292 GeneratedJavaTokenTypes.TYPE_PARAMETER; 3293 3294 /** 3295 * A list of type arguments to a type reference or 3296 * a method/ctor invocation. Children are GENERIC_START, at least one 3297 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 3298 * TYPE_ARGUMENT, and a final GENERIC_END. 3299 * 3300 * <p>For example:</p> 3301 * 3302 * <pre> 3303 * public Collection<?> a; 3304 * </pre> 3305 * 3306 * <p>parses as:</p> 3307 * 3308 * <pre> 3309 * +--VARIABLE_DEF 3310 * | 3311 * +--MODIFIERS 3312 * | 3313 * +--LITERAL_PUBLIC (public) 3314 * +--TYPE 3315 * | 3316 * +--IDENT (Collection) 3317 * | 3318 * +--TYPE_ARGUMENTS 3319 * | 3320 * +--GENERIC_START (<) 3321 * +--TYPE_ARGUMENT 3322 * | 3323 * +--WILDCARD_TYPE (?) 3324 * +--GENERIC_END (>) 3325 * +--IDENT (a) 3326 * +--SEMI (;) 3327 * </pre> 3328 * 3329 * @see #GENERIC_START 3330 * @see #GENERIC_END 3331 * @see #TYPE_ARGUMENT 3332 * @see #COMMA 3333 */ 3334 public static final int TYPE_ARGUMENTS = 3335 GeneratedJavaTokenTypes.TYPE_ARGUMENTS; 3336 3337 /** 3338 * A type arguments to a type reference or a method/ctor invocation. 3339 * Children are either: type name or wildcard type with possible type 3340 * upper or lower bounds. 3341 * 3342 * <p>For example:</p> 3343 * 3344 * <pre> 3345 * ? super List 3346 * </pre> 3347 * 3348 * <p>parses as:</p> 3349 * 3350 * <pre> 3351 * +--TYPE_ARGUMENT 3352 * | 3353 * +--WILDCARD_TYPE (?) 3354 * +--TYPE_LOWER_BOUNDS 3355 * | 3356 * +--IDENT (List) 3357 * </pre> 3358 * 3359 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3360 * JSR14</a> 3361 * @see #WILDCARD_TYPE 3362 * @see #TYPE_UPPER_BOUNDS 3363 * @see #TYPE_LOWER_BOUNDS 3364 */ 3365 public static final int TYPE_ARGUMENT = 3366 GeneratedJavaTokenTypes.TYPE_ARGUMENT; 3367 3368 /** 3369 * The type that refers to all types. This node has no children. 3370 * 3371 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3372 * JSR14</a> 3373 * @see #TYPE_ARGUMENT 3374 * @see #TYPE_UPPER_BOUNDS 3375 * @see #TYPE_LOWER_BOUNDS 3376 */ 3377 public static final int WILDCARD_TYPE = 3378 GeneratedJavaTokenTypes.WILDCARD_TYPE; 3379 3380 /** 3381 * An upper bounds on a wildcard type argument or type parameter. 3382 * This node has one child - the type that is being used for 3383 * the bounding. 3384 * 3385 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3386 * JSR14</a> 3387 * @see #TYPE_PARAMETER 3388 * @see #TYPE_ARGUMENT 3389 * @see #WILDCARD_TYPE 3390 */ 3391 public static final int TYPE_UPPER_BOUNDS = 3392 GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS; 3393 3394 /** 3395 * A lower bounds on a wildcard type argument. This node has one child 3396 * - the type that is being used for the bounding. 3397 * 3398 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3399 * JSR14</a> 3400 * @see #TYPE_ARGUMENT 3401 * @see #WILDCARD_TYPE 3402 */ 3403 public static final int TYPE_LOWER_BOUNDS = 3404 GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS; 3405 3406 /** 3407 * An {@code @} symbol - signifying an annotation instance or the prefix 3408 * to the interface literal signifying the definition of an annotation 3409 * declaration. 3410 * 3411 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3412 * JSR201</a> 3413 */ 3414 public static final int AT = GeneratedJavaTokenTypes.AT; 3415 3416 /** 3417 * A triple dot for variable-length parameters. This token only ever occurs 3418 * in a parameter declaration immediately after the type of the parameter. 3419 * 3420 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3421 * JSR201</a> 3422 */ 3423 public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS; 3424 3425 /** 3426 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain 3427 * or a type cast expression with an additional interface. 3428 * 3429 * <p>Generic type bounds extension: 3430 * {@code class Comparable<T extends Serializable & CharSequence>}</p> 3431 * <pre> 3432 * CLASS_DEF 3433 * |--MODIFIERS 3434 * |--LITERAL_CLASS (class) 3435 * |--IDENT (Comparable) 3436 * +--TYPE_PARAMETERS 3437 * |--GENERIC_START (<) 3438 * |--TYPE_PARAMETER 3439 * | |--IDENT (T) 3440 * | +--TYPE_UPPER_BOUNDS (extends) 3441 * | |--IDENT (Serializable) 3442 * | |--TYPE_EXTENSION_AND (&) 3443 * | +--IDENT (CharSequence) 3444 * +--GENERIC_END (>) 3445 * </pre> 3446 * 3447 * <p>Type cast extension: 3448 * {@code return (CheckedFunction & Serializable) null;}</p> 3449 * <pre> 3450 * LITERAL_RETURN (return) 3451 * |--EXPR 3452 * | +--TYPECAST (() 3453 * | |--TYPE 3454 * | | +--IDENT (CheckedFunction) 3455 * | |--TYPE_EXTENSION_AND (&) 3456 * | |--TYPE 3457 * | | +--IDENT (Serializable) 3458 * | |--RPAREN ()) 3459 * | +--LITERAL_NULL (null) 3460 * +--SEMI (;) 3461 * </pre> 3462 * 3463 * @see #EXTENDS_CLAUSE 3464 * @see #TYPECAST 3465 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4"> 3466 * Java Language Specification, §4.4</a> 3467 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16"> 3468 * Java Language Specification, §15.16</a> 3469 */ 3470 public static final int TYPE_EXTENSION_AND = 3471 GeneratedJavaTokenTypes.TYPE_EXTENSION_AND; 3472 3473 /** 3474 * A {@code <} symbol signifying the start of type arguments or type parameters. 3475 */ 3476 public static final int GENERIC_START = 3477 GeneratedJavaTokenTypes.GENERIC_START; 3478 3479 /** 3480 * A {@code >} symbol signifying the end of type arguments or type parameters. 3481 */ 3482 public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END; 3483 3484 /** 3485 * Special lambda symbol {@code ->}. 3486 */ 3487 public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA; 3488 3489 /** 3490 * Beginning of single line comment: '//'. 3491 * 3492 * <pre> 3493 * +--SINGLE_LINE_COMMENT 3494 * | 3495 * +--COMMENT_CONTENT 3496 * </pre> 3497 */ 3498 public static final int SINGLE_LINE_COMMENT = 3499 GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT; 3500 3501 /** 3502 * Beginning of block comment: '/*'. 3503 * 3504 * <pre> 3505 * +--BLOCK_COMMENT_BEGIN 3506 * | 3507 * +--COMMENT_CONTENT 3508 * +--BLOCK_COMMENT_END 3509 * </pre> 3510 */ 3511 public static final int BLOCK_COMMENT_BEGIN = 3512 GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN; 3513 3514 /** 3515 * End of block comment: '*/'. 3516 * 3517 * <pre> 3518 * +--BLOCK_COMMENT_BEGIN 3519 * | 3520 * +--COMMENT_CONTENT 3521 * +--BLOCK_COMMENT_END 3522 * </pre> 3523 */ 3524 public static final int BLOCK_COMMENT_END = 3525 GeneratedJavaTokenTypes.BLOCK_COMMENT_END; 3526 3527 /** 3528 * Text of single-line or block comment. 3529 * 3530 * <pre> 3531 * +--SINGLE_LINE_COMMENT 3532 * | 3533 * +--COMMENT_CONTENT 3534 * </pre> 3535 * 3536 * <pre> 3537 * +--BLOCK_COMMENT_BEGIN 3538 * | 3539 * +--COMMENT_CONTENT 3540 * +--BLOCK_COMMENT_END 3541 * </pre> 3542 */ 3543 public static final int COMMENT_CONTENT = 3544 GeneratedJavaTokenTypes.COMMENT_CONTENT; 3545 3546 /** 3547 * A pattern variable definition; when conditionally matched, 3548 * this variable is assigned with the defined type. 3549 * 3550 * <p>For example:</p> 3551 * <pre> 3552 * if (obj instanceof String str) { } 3553 * </pre> 3554 * <p>parses as:</p> 3555 * <pre> 3556 * LITERAL_IF (if) 3557 * |--LPAREN (() 3558 * |--EXPR 3559 * | `--LITERAL_INSTANCEOF (instanceof) 3560 * | |--IDENT (obj) 3561 * | `--PATTERN_VARIABLE_DEF 3562 * | |--TYPE 3563 * | | `--IDENT (String) 3564 * | `--IDENT (str) 3565 * |--RPAREN ()) 3566 * `--SLIST ({) 3567 * `--RCURLY (}) 3568 * </pre> 3569 * 3570 * @see #LITERAL_INSTANCEOF 3571 * @since 8.35 3572 */ 3573 public static final int PATTERN_VARIABLE_DEF = 3574 GeneratedJavaTokenTypes.PATTERN_VARIABLE_DEF; 3575 3576 /** 3577 * The {@code record} keyword. This element appears 3578 * as part of a record declaration. 3579 * 3580 * @since 8.35 3581 **/ 3582 public static final int LITERAL_RECORD = 3583 GeneratedJavaTokenTypes.LITERAL_record; 3584 3585 /** 3586 * A declaration of a record specifies a name, a header, and a body. 3587 * The header lists the components of the record, which are the variables 3588 * that make up its state. 3589 * 3590 * <p>For example:</p> 3591 * <pre> 3592 * public record myRecord () {} 3593 * </pre> 3594 * <p>parses as:</p> 3595 * <pre> 3596 * RECORD_DEF 3597 * |--MODIFIERS 3598 * | `--LITERAL_PUBLIC (public) 3599 * |--LITERAL_RECORD (record) 3600 * |--IDENT (myRecord) 3601 * |--LPAREN (() 3602 * |--RECORD_COMPONENTS 3603 * |--RPAREN ()) 3604 * `--OBJBLOCK 3605 * |--LCURLY ({) 3606 * `--RCURLY (}) 3607 * </pre> 3608 * 3609 * @since 8.35 3610 */ 3611 public static final int RECORD_DEF = 3612 GeneratedJavaTokenTypes.RECORD_DEF; 3613 3614 /** 3615 * Record components are a (possibly empty) list containing the components of a record, which 3616 * are the variables that make up its state. 3617 * 3618 * <p>For example:</p> 3619 * <pre> 3620 * public record myRecord (Comp x, Comp y) { } 3621 * </pre> 3622 * <p>parses as:</p> 3623 * <pre> 3624 * RECORD_DEF 3625 * |--MODIFIERS 3626 * | `--LITERAL_PUBLIC (public) 3627 * |--LITERAL_RECORD (record) 3628 * |--IDENT (myRecord) 3629 * |--LPAREN (() 3630 * |--RECORD_COMPONENTS 3631 * | |--RECORD_COMPONENT_DEF 3632 * | | |--ANNOTATIONS 3633 * | | |--TYPE 3634 * | | | `--IDENT (Comp) 3635 * | | `--IDENT (x) 3636 * | |--COMMA (,) 3637 * | `--RECORD_COMPONENT_DEF 3638 * | |--ANNOTATIONS 3639 * | |--TYPE 3640 * | | `--IDENT (Comp) 3641 * | `--IDENT (y) 3642 * |--RPAREN ()) 3643 * `--OBJBLOCK 3644 * |--LCURLY ({) 3645 * `--RCURLY (}) 3646 * </pre> 3647 * 3648 * @since 8.36 3649 */ 3650 public static final int RECORD_COMPONENTS = 3651 GeneratedJavaTokenTypes.RECORD_COMPONENTS; 3652 3653 /** 3654 * A record component is a variable that comprises the state of a record. Record components 3655 * have annotations (possibly), a type definition, and an identifier. They can also be of 3656 * variable arity ('...'). 3657 * 3658 * <p>For example:</p> 3659 * <pre> 3660 * public record myRecord (Comp x, Comp... comps) { } 3661 * </pre> 3662 * <p>parses as:</p> 3663 * <pre> 3664 * RECORD_DEF 3665 * |--MODIFIERS 3666 * | `--LITERAL_PUBLIC (public) 3667 * |--LITERAL_RECORD (record) 3668 * |--IDENT (myRecord) 3669 * |--LPAREN (() 3670 * |--RECORD_COMPONENTS 3671 * | |--RECORD_COMPONENT_DEF 3672 * | | |--ANNOTATIONS 3673 * | | |--TYPE 3674 * | | | `--IDENT (Comp) 3675 * | | `--IDENT (x) 3676 * | |--COMMA (,) 3677 * | `--RECORD_COMPONENT_DEF 3678 * | |--ANNOTATIONS 3679 * | |--TYPE 3680 * | | `--IDENT (Comp) 3681 * | |--ELLIPSIS (...) 3682 * | `--IDENT (comps) 3683 * |--RPAREN ()) 3684 * `--OBJBLOCK 3685 * |--LCURLY ({) 3686 * `--RCURLY (}) 3687 * </pre> 3688 * 3689 * @since 8.36 3690 */ 3691 public static final int RECORD_COMPONENT_DEF = 3692 GeneratedJavaTokenTypes.RECORD_COMPONENT_DEF; 3693 3694 /** 3695 * A compact canonical constructor eliminates the list of formal parameters; they are 3696 * declared implicitly. 3697 * 3698 * <p>For example:</p> 3699 * <pre> 3700 * public record myRecord () { 3701 * public myRecord{} 3702 * } 3703 * </pre> 3704 * <p>parses as:</p> 3705 * <pre> 3706 * RECORD_DEF 3707 * |--MODIFIERS 3708 * | `--LITERAL_PUBLIC (public) 3709 * |--LITERAL_RECORD (record) 3710 * |--IDENT (myRecord) 3711 * |--LPAREN (() 3712 * |--RECORD_COMPONENTS 3713 * |--RPAREN ()) 3714 * `--OBJBLOCK 3715 * |--LCURLY ({) 3716 * |--COMPACT_CTOR_DEF 3717 * | |--MODIFIERS 3718 * | | `--LITERAL_PUBLIC (public) 3719 * | |--IDENT (myRecord) 3720 * | `--SLIST ({) 3721 * | `--RCURLY (}) 3722 * `--RCURLY (}) 3723 * </pre> 3724 * 3725 * @since 8.36 3726 */ 3727 public static final int COMPACT_CTOR_DEF = 3728 GeneratedJavaTokenTypes.COMPACT_CTOR_DEF; 3729 3730 /** 3731 * Beginning of a Java 14 Text Block literal, 3732 * delimited by three double quotes. 3733 * 3734 * <p>For example:</p> 3735 * <pre> 3736 * String hello = """ 3737 * Hello, world! 3738 * """; 3739 * </pre> 3740 * <p>parses as:</p> 3741 * <pre> 3742 * |--VARIABLE_DEF 3743 * | |--MODIFIERS 3744 * | |--TYPE 3745 * | | `--IDENT (String) 3746 * | |--IDENT (hello) 3747 * | |--ASSIGN (=) 3748 * | | `--EXPR 3749 * | | `--TEXT_BLOCK_LITERAL_BEGIN (""") 3750 * | | |--TEXT_BLOCK_CONTENT (\n Hello, world!\n ) 3751 * | | `--TEXT_BLOCK_LITERAL_END (""") 3752 * | `--SEMI (;) 3753 * </pre> 3754 * 3755 * @since 8.36 3756 */ 3757 public static final int TEXT_BLOCK_LITERAL_BEGIN = 3758 GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_BEGIN; 3759 3760 /** 3761 * Content of a Java 14 text block. This is a 3762 * sequence of characters, possibly escaped with '\'. Actual line terminators 3763 * are represented by '\n'. 3764 * 3765 * <p>For example:</p> 3766 * <pre> 3767 * String hello = """ 3768 * Hello, world! 3769 * """; 3770 * </pre> 3771 * <p>parses as:</p> 3772 * <pre> 3773 * |--VARIABLE_DEF 3774 * | |--MODIFIERS 3775 * | |--TYPE 3776 * | | `--IDENT (String) 3777 * | |--IDENT (hello) 3778 * | |--ASSIGN (=) 3779 * | | `--EXPR 3780 * | | `--TEXT_BLOCK_LITERAL_BEGIN (""") 3781 * | | |--TEXT_BLOCK_CONTENT (\n Hello, world!\n ) 3782 * | | `--TEXT_BLOCK_LITERAL_END (""") 3783 * | `--SEMI (;) 3784 * </pre> 3785 * 3786 * @since 8.36 3787 */ 3788 public static final int TEXT_BLOCK_CONTENT = 3789 GeneratedJavaTokenTypes.TEXT_BLOCK_CONTENT; 3790 3791 /** 3792 * End of a Java 14 text block literal, delimited by three 3793 * double quotes. 3794 * 3795 * <p>For example:</p> 3796 * <pre> 3797 * String hello = """ 3798 * Hello, world! 3799 * """; 3800 * </pre> 3801 * <p>parses as:</p> 3802 * <pre> 3803 * |--VARIABLE_DEF 3804 * | |--MODIFIERS 3805 * | |--TYPE 3806 * | | `--IDENT (String) 3807 * | |--IDENT (hello) 3808 * | |--ASSIGN (=) 3809 * | | `--EXPR 3810 * | | `--TEXT_BLOCK_LITERAL_BEGIN (""") 3811 * | | |--TEXT_BLOCK_CONTENT (\n Hello, world!\n ) 3812 * | | `--TEXT_BLOCK_LITERAL_END (""") 3813 * | `--SEMI (;) 3814 * </pre> 3815 * 3816 * @since 8.36 3817 */ 3818 public static final int TEXT_BLOCK_LITERAL_END = 3819 GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_END; 3820 3821 /** 3822 * The {@code yield} keyword. This element appears 3823 * as part of a yield statement. 3824 * 3825 * <p>For example:</p> 3826 * <pre> 3827 * int yield = 0; // not a keyword here 3828 * return switch (mode) { 3829 * case "a", "b": 3830 * yield 1; 3831 * default: 3832 * yield - 1; 3833 * }; 3834 * </pre> 3835 * <p>parses as:</p> 3836 * <pre> 3837 * |--VARIABLE_DEF 3838 * | |--MODIFIERS 3839 * | |--TYPE 3840 * | | `--LITERAL_INT (int) 3841 * | |--IDENT (yield) 3842 * | `--ASSIGN (=) 3843 * | `--EXPR 3844 * | `--NUM_INT (0) 3845 * |--SEMI (;) 3846 * |--LITERAL_RETURN (return) 3847 * | |--EXPR 3848 * | | `--LITERAL_SWITCH (switch) 3849 * | | |--LPAREN (() 3850 * | | |--EXPR 3851 * | | | `--IDENT (mode) 3852 * | | |--RPAREN ()) 3853 * | | |--LCURLY ({) 3854 * | | |--CASE_GROUP 3855 * | | | |--LITERAL_CASE (case) 3856 * | | | | |--EXPR 3857 * | | | | | `--STRING_LITERAL ("a") 3858 * | | | | |--COMMA (,) 3859 * | | | | |--EXPR 3860 * | | | | | `--STRING_LITERAL ("b") 3861 * | | | | `--COLON (:) 3862 * | | | `--SLIST 3863 * | | | `--LITERAL_YIELD (yield) 3864 * | | | |--EXPR 3865 * | | | | `--NUM_INT (1) 3866 * | | | `--SEMI (;) 3867 * | | |--CASE_GROUP 3868 * | | | |--LITERAL_DEFAULT (default) 3869 * | | | | `--COLON (:) 3870 * | | | `--SLIST 3871 * | | | `--LITERAL_YIELD (yield) 3872 * | | | |--EXPR 3873 * | | | | `--UNARY_MINUS (-) 3874 * | | | | `--NUM_INT (1) 3875 * | | | `--SEMI (;) 3876 * | | `--RCURLY (}) 3877 * | `--SEMI (;) 3878 * </pre> 3879 * 3880 * 3881 * @see #LITERAL_SWITCH 3882 * @see #CASE_GROUP 3883 * @see #SLIST 3884 * @see #SWITCH_RULE 3885 * 3886 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 3887 * Java Language Specification, §14.21</a> 3888 * 3889 * @since 8.36 3890 */ 3891 public static final int LITERAL_YIELD = 3892 GeneratedJavaTokenTypes.LITERAL_yield; 3893 3894 /** 3895 * Switch Expressions. 3896 * 3897 * <p>For example:</p> 3898 * <pre> 3899 * return switch (day) { 3900 * case SAT, SUN {@code ->} "Weekend"; 3901 * default {@code ->} "Working day"; 3902 * }; 3903 * </pre> 3904 * <p>parses as:</p> 3905 * <pre> 3906 * LITERAL_RETURN (return) 3907 * |--EXPR 3908 * | `--LITERAL_SWITCH (switch) 3909 * | |--LPAREN (() 3910 * | |--EXPR 3911 * | | `--IDENT (day) 3912 * | |--RPAREN ()) 3913 * | |--LCURLY ({) 3914 * | |--SWITCH_RULE 3915 * | | |--LITERAL_CASE (case) 3916 * | | | |--EXPR 3917 * | | | | `--IDENT (SAT) 3918 * | | | |--COMMA (,) 3919 * | | | `--EXPR 3920 * | | | `--IDENT (SUN) 3921 * | | |--LAMBDA {@code ->} 3922 * | | |--EXPR 3923 * | | | `--STRING_LITERAL ("Weekend") 3924 * | | `--SEMI (;) 3925 * | |--SWITCH_RULE 3926 * | | |--LITERAL_DEFAULT (default) 3927 * | | |--LAMBDA {@code ->} 3928 * | | |--EXPR 3929 * | | | `--STRING_LITERAL ("Working day") 3930 * | | `--SEMI (;) 3931 * | `--RCURLY (}) 3932 * `--SEMI (;) 3933 * </pre> 3934 * 3935 * @see #LITERAL_CASE 3936 * @see #LITERAL_DEFAULT 3937 * @see #LITERAL_SWITCH 3938 * @see #LITERAL_YIELD 3939 * 3940 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html"> 3941 * Java Language Specification, §14.21</a> 3942 * 3943 * @since 8.36 3944 */ 3945 public static final int SWITCH_RULE = 3946 GeneratedJavaTokenTypes.SWITCH_RULE; 3947 3948 /** Prevent instantiation. */ 3949 private TokenTypes() { 3950 } 3951 3952}