001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2019 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 * @see <a 633 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java 634 * Language Specification, §15.16</a> 635 * @see #EXPR 636 * @see #TYPE 637 * @see #TYPE_ARGUMENTS 638 * @see #RPAREN 639 **/ 640 public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST; 641 /** 642 * The array index operator. 643 * 644 * <p>For example:</p> 645 * <pre> 646 * ar[2] = 5; 647 * </pre> 648 * <p>parses as:</p> 649 * <pre> 650 * +--EXPR 651 * | 652 * +--ASSIGN (=) 653 * | 654 * +--INDEX_OP ([) 655 * | 656 * +--IDENT (ar) 657 * +--EXPR 658 * | 659 * +--NUM_INT (2) 660 * +--NUM_INT (5) 661 * +--SEMI (;) 662 * </pre> 663 * 664 * @see #EXPR 665 **/ 666 public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP; 667 /** 668 * The {@code ++} (postfix increment) operator. 669 * 670 * @see <a 671 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java 672 * Language Specification, §15.14.1</a> 673 * @see #EXPR 674 * @see #INC 675 **/ 676 public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC; 677 /** 678 * The {@code --} (postfix decrement) operator. 679 * 680 * @see <a 681 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java 682 * Language Specification, §15.14.2</a> 683 * @see #EXPR 684 * @see #DEC 685 **/ 686 public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC; 687 /** 688 * A method call. A method call may have type arguments however these 689 * are attached to the appropriate node in the qualified method name. 690 * 691 * <p>For example:</p> 692 * <pre> 693 * Math.random() 694 * </pre> 695 * 696 * <p>parses as: 697 * <pre> 698 * +--METHOD_CALL (() 699 * | 700 * +--DOT (.) 701 * | 702 * +--IDENT (Math) 703 * +--IDENT (random) 704 * +--ELIST 705 * +--RPAREN ()) 706 * </pre> 707 * 708 * 709 * @see #IDENT 710 * @see #TYPE_ARGUMENTS 711 * @see #DOT 712 * @see #ELIST 713 * @see #RPAREN 714 * @see FullIdent 715 **/ 716 public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL; 717 718 /** 719 * A reference to a method or constructor without arguments. Part of Java 8 syntax. 720 * The token should be used for subscribing for double colon literal. 721 * {@link #DOUBLE_COLON} token does not appear in the tree. 722 * 723 * <p>For example:</p> 724 * <pre> 725 * String::compareToIgnoreCase 726 * </pre> 727 * 728 * <p>parses as: 729 * <pre> 730 * +--METHOD_REF (::) 731 * | 732 * +--IDENT (String) 733 * +--IDENT (compareToIgnoreCase) 734 * </pre> 735 * 736 * @see #IDENT 737 * @see #DOUBLE_COLON 738 */ 739 public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF; 740 /** 741 * An expression. Operators with lower precedence appear at a 742 * higher level in the tree than operators with higher precedence. 743 * Parentheses are siblings to the operator they enclose. 744 * 745 * <p>For example:</p> 746 * <pre> 747 * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3); 748 * </pre> 749 * <p>parses as:</p> 750 * <pre> 751 * +--EXPR 752 * | 753 * +--ASSIGN (=) 754 * | 755 * +--IDENT (x) 756 * +--PLUS (+) 757 * | 758 * +--PLUS (+) 759 * | 760 * +--PLUS (+) 761 * | 762 * +--PLUS (+) 763 * | 764 * +--NUM_INT (4) 765 * +--STAR (*) 766 * | 767 * +--NUM_INT (3) 768 * +--NUM_INT (5) 769 * +--DIV (/) 770 * | 771 * +--LPAREN (() 772 * +--PLUS (+) 773 * | 774 * +--NUM_INT (30) 775 * +--NUM_INT (26) 776 * +--RPAREN ()) 777 * +--NUM_INT (4) 778 * +--MOD (%) 779 * | 780 * +--NUM_INT (5) 781 * +--NUM_INT (4) 782 * +--LPAREN (() 783 * +--SL (<<) 784 * | 785 * +--NUM_INT (1) 786 * +--NUM_INT (3) 787 * +--RPAREN ()) 788 * +--SEMI (;) 789 * </pre> 790 * 791 * @see #ELIST 792 * @see #ASSIGN 793 * @see #LPAREN 794 * @see #RPAREN 795 **/ 796 public static final int EXPR = GeneratedJavaTokenTypes.EXPR; 797 /** 798 * An array initialization. This may occur as part of an array 799 * declaration or inline with {@code new}. 800 * 801 * <p>For example:</p> 802 * <pre> 803 * int[] y = 804 * { 805 * 1, 806 * 2, 807 * }; 808 * </pre> 809 * <p>parses as:</p> 810 * <pre> 811 * +--VARIABLE_DEF 812 * | 813 * +--MODIFIERS 814 * +--TYPE 815 * | 816 * +--ARRAY_DECLARATOR ([) 817 * | 818 * +--LITERAL_INT (int) 819 * +--IDENT (y) 820 * +--ASSIGN (=) 821 * | 822 * +--ARRAY_INIT ({) 823 * | 824 * +--EXPR 825 * | 826 * +--NUM_INT (1) 827 * +--COMMA (,) 828 * +--EXPR 829 * | 830 * +--NUM_INT (2) 831 * +--COMMA (,) 832 * +--RCURLY (}) 833 * +--SEMI (;) 834 * </pre> 835 * 836 * <p>Also consider:</p> 837 * <pre> 838 * int[] z = new int[] 839 * { 840 * 1, 841 * 2, 842 * }; 843 * </pre> 844 * <p>which parses as:</p> 845 * <pre> 846 * +--VARIABLE_DEF 847 * | 848 * +--MODIFIERS 849 * +--TYPE 850 * | 851 * +--ARRAY_DECLARATOR ([) 852 * | 853 * +--LITERAL_INT (int) 854 * +--IDENT (z) 855 * +--ASSIGN (=) 856 * | 857 * +--EXPR 858 * | 859 * +--LITERAL_NEW (new) 860 * | 861 * +--LITERAL_INT (int) 862 * +--ARRAY_DECLARATOR ([) 863 * +--ARRAY_INIT ({) 864 * | 865 * +--EXPR 866 * | 867 * +--NUM_INT (1) 868 * +--COMMA (,) 869 * +--EXPR 870 * | 871 * +--NUM_INT (2) 872 * +--COMMA (,) 873 * +--RCURLY (}) 874 * </pre> 875 * 876 * @see #ARRAY_DECLARATOR 877 * @see #TYPE 878 * @see #LITERAL_NEW 879 * @see #COMMA 880 **/ 881 public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT; 882 /** 883 * An import declaration. Import declarations are option, but 884 * must appear after the package declaration and before the first type 885 * declaration. 886 * 887 * <p>For example:</p> 888 * 889 * <pre> 890 * import java.io.IOException; 891 * </pre> 892 * 893 * <p>parses as:</p> 894 * 895 * <pre> 896 * +--IMPORT (import) 897 * | 898 * +--DOT (.) 899 * | 900 * +--DOT (.) 901 * | 902 * +--IDENT (java) 903 * +--IDENT (io) 904 * +--IDENT (IOException) 905 * +--SEMI (;) 906 * </pre> 907 * 908 * @see <a 909 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java 910 * Language Specification §7.5</a> 911 * @see #DOT 912 * @see #IDENT 913 * @see #STAR 914 * @see #SEMI 915 * @see FullIdent 916 **/ 917 public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT; 918 /** 919 * The {@code -} (unary minus) operator. 920 * 921 * @see <a 922 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java 923 * Language Specification, §15.15.4</a> 924 * @see #EXPR 925 **/ 926 public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS; 927 /** 928 * The {@code +} (unary plus) operator. 929 * 930 * @see <a 931 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java 932 * Language Specification, §15.15.3</a> 933 * @see #EXPR 934 **/ 935 public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS; 936 /** 937 * A group of case clauses. Case clauses with no associated 938 * statements are grouped together into a case group. The last 939 * child is a statement list containing the statements to execute 940 * upon a match. 941 * 942 * <p>For example:</p> 943 * <pre> 944 * case 0: 945 * case 1: 946 * case 2: 947 * x = 3; 948 * break; 949 * </pre> 950 * <p>parses as:</p> 951 * <pre> 952 * +--CASE_GROUP 953 * | 954 * +--LITERAL_CASE (case) 955 * | 956 * +--EXPR 957 * | 958 * +--NUM_INT (0) 959 * +--LITERAL_CASE (case) 960 * | 961 * +--EXPR 962 * | 963 * +--NUM_INT (1) 964 * +--LITERAL_CASE (case) 965 * | 966 * +--EXPR 967 * | 968 * +--NUM_INT (2) 969 * +--SLIST 970 * | 971 * +--EXPR 972 * | 973 * +--ASSIGN (=) 974 * | 975 * +--IDENT (x) 976 * +--NUM_INT (3) 977 * +--SEMI (;) 978 * +--LITERAL_BREAK (break) 979 * | 980 * +--SEMI (;) 981 * </pre> 982 * 983 * @see #LITERAL_CASE 984 * @see #LITERAL_DEFAULT 985 * @see #LITERAL_SWITCH 986 **/ 987 public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP; 988 /** 989 * An expression list. The children are a comma separated list of 990 * expressions. 991 * 992 * @see #LITERAL_NEW 993 * @see #FOR_INIT 994 * @see #FOR_ITERATOR 995 * @see #EXPR 996 * @see #METHOD_CALL 997 * @see #CTOR_CALL 998 * @see #SUPER_CTOR_CALL 999 **/ 1000 public static final int ELIST = GeneratedJavaTokenTypes.ELIST; 1001 /** 1002 * A for loop initializer. This is a child of 1003 * {@code LITERAL_FOR}. The children of this element may be 1004 * a comma separated list of variable declarations, an expression 1005 * list, or empty. 1006 * 1007 * @see #VARIABLE_DEF 1008 * @see #ELIST 1009 * @see #LITERAL_FOR 1010 **/ 1011 public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT; 1012 /** 1013 * A for loop condition. This is a child of 1014 * {@code LITERAL_FOR}. The child of this element is an 1015 * optional expression. 1016 * 1017 * @see #EXPR 1018 * @see #LITERAL_FOR 1019 **/ 1020 public static final int FOR_CONDITION = 1021 GeneratedJavaTokenTypes.FOR_CONDITION; 1022 1023 /** 1024 * A for loop iterator. This is a child of 1025 * {@code LITERAL_FOR}. The child of this element is an 1026 * optional expression list. 1027 * 1028 * @see #ELIST 1029 * @see #LITERAL_FOR 1030 **/ 1031 public static final int FOR_ITERATOR = 1032 GeneratedJavaTokenTypes.FOR_ITERATOR; 1033 1034 /** 1035 * The empty statement. This goes in place of an 1036 * {@code SLIST} for a {@code for} or {@code while} 1037 * loop body. 1038 * 1039 * @see <a 1040 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java 1041 * Language Specification, §14.6</a> 1042 * @see #LITERAL_FOR 1043 * @see #LITERAL_WHILE 1044 **/ 1045 public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT; 1046 /** 1047 * The {@code final} keyword. 1048 * 1049 * @see #MODIFIERS 1050 **/ 1051 public static final int FINAL = GeneratedJavaTokenTypes.FINAL; 1052 /** 1053 * The {@code abstract} keyword. 1054 * 1055 * @see #MODIFIERS 1056 **/ 1057 public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT; 1058 /** 1059 * The {@code strictfp} keyword. 1060 * 1061 * @see #MODIFIERS 1062 **/ 1063 public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP; 1064 /** 1065 * A super constructor call. 1066 * 1067 * @see #ELIST 1068 * @see #RPAREN 1069 * @see #SEMI 1070 * @see #CTOR_CALL 1071 **/ 1072 public static final int SUPER_CTOR_CALL = 1073 GeneratedJavaTokenTypes.SUPER_CTOR_CALL; 1074 1075 /** 1076 * A constructor call. 1077 * 1078 * <p>For example:</p> 1079 * <pre> 1080 * this(1); 1081 * </pre> 1082 * <p>parses as:</p> 1083 * <pre> 1084 * +--CTOR_CALL (this) 1085 * | 1086 * +--LPAREN (() 1087 * +--ELIST 1088 * | 1089 * +--EXPR 1090 * | 1091 * +--NUM_INT (1) 1092 * +--RPAREN ()) 1093 * +--SEMI (;) 1094 * </pre> 1095 * 1096 * @see #ELIST 1097 * @see #RPAREN 1098 * @see #SEMI 1099 * @see #SUPER_CTOR_CALL 1100 **/ 1101 public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL; 1102 1103 /** 1104 * The statement terminator ({@code ;}). Depending on the 1105 * context, this make occur as a sibling, a child, or not at all. 1106 * 1107 * @see #PACKAGE_DEF 1108 * @see #IMPORT 1109 * @see #SLIST 1110 * @see #ARRAY_INIT 1111 * @see #LITERAL_FOR 1112 **/ 1113 public static final int SEMI = GeneratedJavaTokenTypes.SEMI; 1114 1115 /** 1116 * The {@code ]} symbol. 1117 * 1118 * @see #INDEX_OP 1119 * @see #ARRAY_DECLARATOR 1120 **/ 1121 public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK; 1122 /** 1123 * The {@code void} keyword. 1124 * 1125 * @see #TYPE 1126 **/ 1127 public static final int LITERAL_VOID = 1128 GeneratedJavaTokenTypes.LITERAL_void; 1129 1130 /** 1131 * The {@code boolean} keyword. 1132 * 1133 * @see #TYPE 1134 **/ 1135 public static final int LITERAL_BOOLEAN = 1136 GeneratedJavaTokenTypes.LITERAL_boolean; 1137 1138 /** 1139 * The {@code byte} keyword. 1140 * 1141 * @see #TYPE 1142 **/ 1143 public static final int LITERAL_BYTE = 1144 GeneratedJavaTokenTypes.LITERAL_byte; 1145 1146 /** 1147 * The {@code char} keyword. 1148 * 1149 * @see #TYPE 1150 **/ 1151 public static final int LITERAL_CHAR = 1152 GeneratedJavaTokenTypes.LITERAL_char; 1153 1154 /** 1155 * The {@code short} keyword. 1156 * 1157 * @see #TYPE 1158 **/ 1159 public static final int LITERAL_SHORT = 1160 GeneratedJavaTokenTypes.LITERAL_short; 1161 1162 /** 1163 * The {@code int} keyword. 1164 * 1165 * @see #TYPE 1166 **/ 1167 public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int; 1168 /** 1169 * The {@code float} keyword. 1170 * 1171 * @see #TYPE 1172 **/ 1173 public static final int LITERAL_FLOAT = 1174 GeneratedJavaTokenTypes.LITERAL_float; 1175 1176 /** 1177 * The {@code long} keyword. 1178 * 1179 * @see #TYPE 1180 **/ 1181 public static final int LITERAL_LONG = 1182 GeneratedJavaTokenTypes.LITERAL_long; 1183 1184 /** 1185 * The {@code double} keyword. 1186 * 1187 * @see #TYPE 1188 **/ 1189 public static final int LITERAL_DOUBLE = 1190 GeneratedJavaTokenTypes.LITERAL_double; 1191 1192 /** 1193 * An identifier. These can be names of types, subpackages, 1194 * fields, methods, parameters, and local variables. 1195 **/ 1196 public static final int IDENT = GeneratedJavaTokenTypes.IDENT; 1197 /** 1198 * The <code>.</code> (dot) operator. 1199 * 1200 * @see FullIdent 1201 * @noinspection HtmlTagCanBeJavadocTag 1202 **/ 1203 public static final int DOT = GeneratedJavaTokenTypes.DOT; 1204 /** 1205 * The {@code *} (multiplication or wildcard) operator. 1206 * 1207 * @see <a 1208 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java 1209 * Language Specification, §7.5.2</a> 1210 * @see <a 1211 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java 1212 * Language Specification, §15.17.1</a> 1213 * @see #EXPR 1214 * @see #IMPORT 1215 **/ 1216 public static final int STAR = GeneratedJavaTokenTypes.STAR; 1217 /** 1218 * The {@code private} keyword. 1219 * 1220 * @see #MODIFIERS 1221 **/ 1222 public static final int LITERAL_PRIVATE = 1223 GeneratedJavaTokenTypes.LITERAL_private; 1224 1225 /** 1226 * The {@code public} keyword. 1227 * 1228 * @see #MODIFIERS 1229 **/ 1230 public static final int LITERAL_PUBLIC = 1231 GeneratedJavaTokenTypes.LITERAL_public; 1232 1233 /** 1234 * The {@code protected} keyword. 1235 * 1236 * @see #MODIFIERS 1237 **/ 1238 public static final int LITERAL_PROTECTED = 1239 GeneratedJavaTokenTypes.LITERAL_protected; 1240 1241 /** 1242 * The {@code static} keyword. 1243 * 1244 * @see #MODIFIERS 1245 **/ 1246 public static final int LITERAL_STATIC = 1247 GeneratedJavaTokenTypes.LITERAL_static; 1248 1249 /** 1250 * The {@code transient} keyword. 1251 * 1252 * @see #MODIFIERS 1253 **/ 1254 public static final int LITERAL_TRANSIENT = 1255 GeneratedJavaTokenTypes.LITERAL_transient; 1256 1257 /** 1258 * The {@code native} keyword. 1259 * 1260 * @see #MODIFIERS 1261 **/ 1262 public static final int LITERAL_NATIVE = 1263 GeneratedJavaTokenTypes.LITERAL_native; 1264 1265 /** 1266 * The {@code synchronized} keyword. This may be used as a 1267 * modifier of a method or in the definition of a synchronized 1268 * block. 1269 * 1270 * <p>For example:</p> 1271 * 1272 * <pre> 1273 * synchronized(this) 1274 * { 1275 * x++; 1276 * } 1277 * </pre> 1278 * 1279 * <p>parses as:</p> 1280 * 1281 * <pre> 1282 * +--LITERAL_SYNCHRONIZED (synchronized) 1283 * | 1284 * +--LPAREN (() 1285 * +--EXPR 1286 * | 1287 * +--LITERAL_THIS (this) 1288 * +--RPAREN ()) 1289 * +--SLIST ({) 1290 * | 1291 * +--EXPR 1292 * | 1293 * +--POST_INC (++) 1294 * | 1295 * +--IDENT (x) 1296 * +--SEMI (;) 1297 * +--RCURLY (}) 1298 * +--RCURLY (}) 1299 * </pre> 1300 * 1301 * @see #MODIFIERS 1302 * @see #LPAREN 1303 * @see #EXPR 1304 * @see #RPAREN 1305 * @see #SLIST 1306 * @see #RCURLY 1307 **/ 1308 public static final int LITERAL_SYNCHRONIZED = 1309 GeneratedJavaTokenTypes.LITERAL_synchronized; 1310 1311 /** 1312 * The {@code volatile} keyword. 1313 * 1314 * @see #MODIFIERS 1315 **/ 1316 public static final int LITERAL_VOLATILE = 1317 GeneratedJavaTokenTypes.LITERAL_volatile; 1318 1319 /** 1320 * The {@code class} keyword. This element appears both 1321 * as part of a class declaration, and inline to reference a 1322 * class object. 1323 * 1324 * <p>For example:</p> 1325 * 1326 * <pre> 1327 * int.class 1328 * </pre> 1329 * <p>parses as:</p> 1330 * <pre> 1331 * +--EXPR 1332 * | 1333 * +--DOT (.) 1334 * | 1335 * +--LITERAL_INT (int) 1336 * +--LITERAL_CLASS (class) 1337 * </pre> 1338 * 1339 * @see #DOT 1340 * @see #IDENT 1341 * @see #CLASS_DEF 1342 * @see FullIdent 1343 **/ 1344 public static final int LITERAL_CLASS = 1345 GeneratedJavaTokenTypes.LITERAL_class; 1346 1347 /** 1348 * The {@code interface} keyword. This token appears in 1349 * interface definition. 1350 * 1351 * @see #INTERFACE_DEF 1352 **/ 1353 public static final int LITERAL_INTERFACE = 1354 GeneratedJavaTokenTypes.LITERAL_interface; 1355 1356 /** 1357 * A left curly brace (<code>{</code>). 1358 * 1359 * @see #OBJBLOCK 1360 * @see #ARRAY_INIT 1361 * @see #SLIST 1362 * @noinspection HtmlTagCanBeJavadocTag 1363 **/ 1364 public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY; 1365 /** 1366 * A right curly brace (<code>}</code>). 1367 * 1368 * @see #OBJBLOCK 1369 * @see #ARRAY_INIT 1370 * @see #SLIST 1371 * @noinspection HtmlTagCanBeJavadocTag 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 * @see #LITERAL_DO 1725 */ 1726 public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE; 1727 /** 1728 * The {@code break} keyword. The first child is an optional 1729 * identifier and the last child is a semicolon. 1730 * 1731 * @see #IDENT 1732 * @see #SEMI 1733 * @see #SLIST 1734 **/ 1735 public static final int LITERAL_BREAK = 1736 GeneratedJavaTokenTypes.LITERAL_break; 1737 1738 /** 1739 * The {@code continue} keyword. The first child is an 1740 * optional identifier and the last child is a semicolon. 1741 * 1742 * @see #IDENT 1743 * @see #SEMI 1744 * @see #SLIST 1745 **/ 1746 public static final int LITERAL_CONTINUE = 1747 GeneratedJavaTokenTypes.LITERAL_continue; 1748 1749 /** 1750 * The {@code return} keyword. The first child is an 1751 * optional expression for the return value. The last child is a 1752 * semi colon. 1753 * 1754 * @see #EXPR 1755 * @see #SEMI 1756 * @see #SLIST 1757 **/ 1758 public static final int LITERAL_RETURN = 1759 GeneratedJavaTokenTypes.LITERAL_return; 1760 1761 /** 1762 * The {@code switch} keyword. 1763 * 1764 * <p>For example:</p> 1765 * <pre> 1766 * switch(type) 1767 * { 1768 * case 0: 1769 * background = Color.blue; 1770 * break; 1771 * case 1: 1772 * background = Color.red; 1773 * break; 1774 * default: 1775 * background = Color.green; 1776 * break; 1777 * } 1778 * </pre> 1779 * <p>parses as:</p> 1780 * <pre> 1781 * +--LITERAL_SWITCH (switch) 1782 * | 1783 * +--LPAREN (() 1784 * +--EXPR 1785 * | 1786 * +--IDENT (type) 1787 * +--RPAREN ()) 1788 * +--LCURLY ({) 1789 * +--CASE_GROUP 1790 * | 1791 * +--LITERAL_CASE (case) 1792 * | 1793 * +--EXPR 1794 * | 1795 * +--NUM_INT (0) 1796 * +--SLIST 1797 * | 1798 * +--EXPR 1799 * | 1800 * +--ASSIGN (=) 1801 * | 1802 * +--IDENT (background) 1803 * +--DOT (.) 1804 * | 1805 * +--IDENT (Color) 1806 * +--IDENT (blue) 1807 * +--SEMI (;) 1808 * +--LITERAL_BREAK (break) 1809 * | 1810 * +--SEMI (;) 1811 * +--CASE_GROUP 1812 * | 1813 * +--LITERAL_CASE (case) 1814 * | 1815 * +--EXPR 1816 * | 1817 * +--NUM_INT (1) 1818 * +--SLIST 1819 * | 1820 * +--EXPR 1821 * | 1822 * +--ASSIGN (=) 1823 * | 1824 * +--IDENT (background) 1825 * +--DOT (.) 1826 * | 1827 * +--IDENT (Color) 1828 * +--IDENT (red) 1829 * +--SEMI (;) 1830 * +--LITERAL_BREAK (break) 1831 * | 1832 * +--SEMI (;) 1833 * +--CASE_GROUP 1834 * | 1835 * +--LITERAL_DEFAULT (default) 1836 * +--SLIST 1837 * | 1838 * +--EXPR 1839 * | 1840 * +--ASSIGN (=) 1841 * | 1842 * +--IDENT (background) 1843 * +--DOT (.) 1844 * | 1845 * +--IDENT (Color) 1846 * +--IDENT (green) 1847 * +--SEMI (;) 1848 * +--LITERAL_BREAK (break) 1849 * | 1850 * +--SEMI (;) 1851 * +--RCURLY (}) 1852 * </pre> 1853 * 1854 * @see <a 1855 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 1856 * Language Specification, §14.10</a> 1857 * @see #LPAREN 1858 * @see #EXPR 1859 * @see #RPAREN 1860 * @see #LCURLY 1861 * @see #CASE_GROUP 1862 * @see #RCURLY 1863 * @see #SLIST 1864 **/ 1865 public static final int LITERAL_SWITCH = 1866 GeneratedJavaTokenTypes.LITERAL_switch; 1867 1868 /** 1869 * The {@code throw} keyword. The first child is an 1870 * expression that evaluates to a {@code Throwable} instance. 1871 * 1872 * @see <a 1873 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java 1874 * Language Specification, §14.17</a> 1875 * @see #SLIST 1876 * @see #EXPR 1877 **/ 1878 public static final int LITERAL_THROW = 1879 GeneratedJavaTokenTypes.LITERAL_throw; 1880 1881 /** 1882 * The {@code else} keyword. This appears as a child of an 1883 * {@code if} statement. 1884 * 1885 * @see #SLIST 1886 * @see #EXPR 1887 * @see #EMPTY_STAT 1888 * @see #LITERAL_IF 1889 **/ 1890 public static final int LITERAL_ELSE = 1891 GeneratedJavaTokenTypes.LITERAL_else; 1892 1893 /** 1894 * The {@code case} keyword. The first child is a constant 1895 * expression that evaluates to an integer. 1896 * 1897 * @see #CASE_GROUP 1898 * @see #EXPR 1899 **/ 1900 public static final int LITERAL_CASE = 1901 GeneratedJavaTokenTypes.LITERAL_case; 1902 1903 /** 1904 * The {@code default} keyword. This element has no 1905 * children. 1906 * 1907 * @see #CASE_GROUP 1908 * @see #MODIFIERS 1909 **/ 1910 public static final int LITERAL_DEFAULT = 1911 GeneratedJavaTokenTypes.LITERAL_default; 1912 1913 /** 1914 * The {@code try} keyword. The children are a statement 1915 * list, zero or more catch blocks and then an optional finally 1916 * block. 1917 * 1918 * <p>For example:</p> 1919 * <pre> 1920 * try 1921 * { 1922 * FileReader in = new FileReader("abc.txt"); 1923 * } 1924 * catch(IOException ioe) 1925 * { 1926 * } 1927 * finally 1928 * { 1929 * } 1930 * </pre> 1931 * <p>parses as:</p> 1932 * <pre> 1933 * +--LITERAL_TRY (try) 1934 * | 1935 * +--SLIST ({) 1936 * | 1937 * +--VARIABLE_DEF 1938 * | 1939 * +--MODIFIERS 1940 * +--TYPE 1941 * | 1942 * +--IDENT (FileReader) 1943 * +--IDENT (in) 1944 * +--ASSIGN (=) 1945 * | 1946 * +--EXPR 1947 * | 1948 * +--LITERAL_NEW (new) 1949 * | 1950 * +--IDENT (FileReader) 1951 * +--LPAREN (() 1952 * +--ELIST 1953 * | 1954 * +--EXPR 1955 * | 1956 * +--STRING_LITERAL ("abc.txt") 1957 * +--RPAREN ()) 1958 * +--SEMI (;) 1959 * +--RCURLY (}) 1960 * +--LITERAL_CATCH (catch) 1961 * | 1962 * +--LPAREN (() 1963 * +--PARAMETER_DEF 1964 * | 1965 * +--MODIFIERS 1966 * +--TYPE 1967 * | 1968 * +--IDENT (IOException) 1969 * +--IDENT (ioe) 1970 * +--RPAREN ()) 1971 * +--SLIST ({) 1972 * | 1973 * +--RCURLY (}) 1974 * +--LITERAL_FINALLY (finally) 1975 * | 1976 * +--SLIST ({) 1977 * | 1978 * +--RCURLY (}) 1979 * +--RCURLY (}) 1980 * </pre> 1981 * 1982 * @see <a 1983 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 1984 * Language Specification, §14.19</a> 1985 * @see #SLIST 1986 * @see #LITERAL_CATCH 1987 * @see #LITERAL_FINALLY 1988 **/ 1989 public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try; 1990 1991 /** 1992 * The Java 7 try-with-resources construct. 1993 * 1994 * <p>For example:</p> 1995 * <pre> 1996 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 1997 * </pre> 1998 * <p>parses as:</p> 1999 * <pre> 2000 * +--LITERAL_TRY (try) 2001 * | 2002 * +--RESOURCE_SPECIFICATION 2003 * | 2004 * +--LPAREN (() 2005 * +--RESOURCES 2006 * | 2007 * +--RESOURCE 2008 * | 2009 * +--MODIFIERS 2010 * +--TYPE 2011 * | 2012 * +--IDENT (Foo) 2013 * +--IDENT (foo) 2014 * +--ASSIGN (=) 2015 * +--EXPR 2016 * | 2017 * +--LITERAL_NEW (new) 2018 * | 2019 * +--IDENT (Foo) 2020 * +--LPAREN (() 2021 * +--ELIST 2022 * +--RPAREN ()) 2023 * +--SEMI (;) 2024 * +--RESOURCE 2025 * | 2026 * +--MODIFIERS 2027 * +--TYPE 2028 * | 2029 * +--IDENT (Bar) 2030 * +--IDENT (bar) 2031 * +--ASSIGN (=) 2032 * +--EXPR 2033 * | 2034 * +--LITERAL_NEW (new) 2035 * | 2036 * +--IDENT (Bar) 2037 * +--LPAREN (() 2038 * +--ELIST 2039 * +--RPAREN ()) 2040 * +--RPAREN ()) 2041 * +--SLIST ({) 2042 * +--RCURLY (}) 2043 * </pre> 2044 * 2045 * <p>Also consider:</p> 2046 * <pre> 2047 * try (BufferedReader br = new BufferedReader(new FileReader(path))) 2048 * { 2049 * return br.readLine(); 2050 * } 2051 * </pre> 2052 * <p>which parses as:</p> 2053 * <pre> 2054 * +--LITERAL_TRY (try) 2055 * | 2056 * +--RESOURCE_SPECIFICATION 2057 * | 2058 * +--LPAREN (() 2059 * +--RESOURCES 2060 * | 2061 * +--RESOURCE 2062 * | 2063 * +--MODIFIERS 2064 * +--TYPE 2065 * | 2066 * +--IDENT (BufferedReader) 2067 * +--IDENT (br) 2068 * +--ASSIGN (=) 2069 * +--EXPR 2070 * | 2071 * +--LITERAL_NEW (new) 2072 * | 2073 * +--IDENT (FileReader) 2074 * +--LPAREN (() 2075 * +--ELIST 2076 * | 2077 * +--EXPR 2078 * | 2079 * +--LITERAL_NEW (new) 2080 * | 2081 * +--IDENT (BufferedReader) 2082 * +--LPAREN (() 2083 * +--ELIST 2084 * | 2085 * +--EXPR 2086 * | 2087 * +--IDENT (path) 2088 * +--RPAREN ()) 2089 * +--RPAREN ()) 2090 * +--RPAREN ()) 2091 * +--SLIST ({) 2092 * | 2093 * +--LITERAL_RETURN (return) 2094 * | 2095 * +--EXPR 2096 * | 2097 * +--METHOD_CALL (() 2098 * | 2099 * +--DOT (.) 2100 * | 2101 * +--IDENT (br) 2102 * +--IDENT (readLine) 2103 * +--ELIST 2104 * +--RPAREN ()) 2105 * +--SEMI (;) 2106 * +--RCURLY (}) 2107 * </pre> 2108 * 2109 * @see #LPAREN 2110 * @see #RESOURCES 2111 * @see #RESOURCE 2112 * @see #SEMI 2113 * @see #RPAREN 2114 * @see #LITERAL_TRY 2115 **/ 2116 public static final int RESOURCE_SPECIFICATION = 2117 GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION; 2118 2119 /** 2120 * A list of resources in the Java 7 try-with-resources construct. 2121 * This is a child of RESOURCE_SPECIFICATION. 2122 * 2123 * @see #RESOURCE_SPECIFICATION 2124 **/ 2125 public static final int RESOURCES = 2126 GeneratedJavaTokenTypes.RESOURCES; 2127 2128 /** 2129 * A resource in the Java 7 try-with-resources construct. 2130 * This is a child of RESOURCES. 2131 * 2132 * @see #RESOURCES 2133 * @see #RESOURCE_SPECIFICATION 2134 **/ 2135 public static final int RESOURCE = 2136 GeneratedJavaTokenTypes.RESOURCE; 2137 2138 /** 2139 * The {@code catch} keyword. 2140 * 2141 * @see #LPAREN 2142 * @see #PARAMETER_DEF 2143 * @see #RPAREN 2144 * @see #SLIST 2145 * @see #LITERAL_TRY 2146 **/ 2147 public static final int LITERAL_CATCH = 2148 GeneratedJavaTokenTypes.LITERAL_catch; 2149 2150 /** 2151 * The {@code finally} keyword. 2152 * 2153 * @see #SLIST 2154 * @see #LITERAL_TRY 2155 **/ 2156 public static final int LITERAL_FINALLY = 2157 GeneratedJavaTokenTypes.LITERAL_finally; 2158 2159 /** 2160 * The {@code +=} (addition assignment) operator. 2161 * 2162 * @see <a 2163 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2164 * Language Specification, §15.26.2</a> 2165 * @see #EXPR 2166 **/ 2167 public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN; 2168 /** 2169 * The {@code -=} (subtraction assignment) operator. 2170 * 2171 * @see <a 2172 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2173 * Language Specification, §15.26.2</a> 2174 * @see #EXPR 2175 **/ 2176 public static final int MINUS_ASSIGN = 2177 GeneratedJavaTokenTypes.MINUS_ASSIGN; 2178 2179 /** 2180 * The {@code *=} (multiplication assignment) operator. 2181 * 2182 * @see <a 2183 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2184 * Language Specification, §15.26.2</a> 2185 * @see #EXPR 2186 **/ 2187 public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN; 2188 /** 2189 * The {@code /=} (division assignment) operator. 2190 * 2191 * @see <a 2192 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2193 * Language Specification, §15.26.2</a> 2194 * @see #EXPR 2195 **/ 2196 public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN; 2197 /** 2198 * The {@code %=} (remainder assignment) operator. 2199 * 2200 * @see <a 2201 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2202 * Language Specification, §15.26.2</a> 2203 * @see #EXPR 2204 **/ 2205 public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN; 2206 /** 2207 * The {@code >>=} (signed right shift assignment) 2208 * operator. 2209 * 2210 * @see <a 2211 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2212 * Language Specification, §15.26.2</a> 2213 * @see #EXPR 2214 **/ 2215 public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN; 2216 /** 2217 * The {@code >>>=} (unsigned right shift assignment) 2218 * operator. 2219 * 2220 * @see <a 2221 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2222 * Language Specification, §15.26.2</a> 2223 * @see #EXPR 2224 **/ 2225 public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN; 2226 /** 2227 * The {@code <<=} (left shift assignment) operator. 2228 * 2229 * @see <a 2230 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2231 * Language Specification, §15.26.2</a> 2232 * @see #EXPR 2233 **/ 2234 public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN; 2235 /** 2236 * The {@code &=} (bitwise AND assignment) operator. 2237 * 2238 * @see <a 2239 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2240 * Language Specification, §15.26.2</a> 2241 * @see #EXPR 2242 **/ 2243 public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN; 2244 /** 2245 * The {@code ^=} (bitwise exclusive OR assignment) operator. 2246 * 2247 * @see <a 2248 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2249 * Language Specification, §15.26.2</a> 2250 * @see #EXPR 2251 **/ 2252 public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN; 2253 /** 2254 * The {@code |=} (bitwise OR assignment) operator. 2255 * 2256 * @see <a 2257 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2258 * Language Specification, §15.26.2</a> 2259 * @see #EXPR 2260 **/ 2261 public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN; 2262 /** 2263 * The <code>?</code> (conditional) operator. Technically, 2264 * the colon is also part of this operator, but it appears as a 2265 * separate token. 2266 * 2267 * <p>For example:</p> 2268 * <pre> 2269 * (quantity == 1) ? "": "s" 2270 * </pre> 2271 * <p> 2272 * parses as: 2273 * </p> 2274 * <pre> 2275 * +--QUESTION (?) 2276 * | 2277 * +--LPAREN (() 2278 * +--EQUAL (==) 2279 * | 2280 * +--IDENT (quantity) 2281 * +--NUM_INT (1) 2282 * +--RPAREN ()) 2283 * +--STRING_LITERAL ("") 2284 * +--COLON (:) 2285 * +--STRING_LITERAL ("s") 2286 * </pre> 2287 * 2288 * @see <a 2289 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 2290 * Language Specification, §15.25</a> 2291 * @see #EXPR 2292 * @see #COLON 2293 * @noinspection HtmlTagCanBeJavadocTag 2294 **/ 2295 public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION; 2296 /** 2297 * The {@code ||} (conditional OR) operator. 2298 * 2299 * @see <a 2300 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java 2301 * Language Specification, §15.24</a> 2302 * @see #EXPR 2303 **/ 2304 public static final int LOR = GeneratedJavaTokenTypes.LOR; 2305 /** 2306 * The {@code &&} (conditional AND) operator. 2307 * 2308 * @see <a 2309 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 2310 * Language Specification, §15.23</a> 2311 * @see #EXPR 2312 **/ 2313 public static final int LAND = GeneratedJavaTokenTypes.LAND; 2314 /** 2315 * The {@code |} (bitwise OR) operator. 2316 * 2317 * @see <a 2318 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2319 * Language Specification, §15.22.1</a> 2320 * @see #EXPR 2321 **/ 2322 public static final int BOR = GeneratedJavaTokenTypes.BOR; 2323 /** 2324 * The {@code ^} (bitwise exclusive OR) operator. 2325 * 2326 * @see <a 2327 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2328 * Language Specification, §15.22.1</a> 2329 * @see #EXPR 2330 **/ 2331 public static final int BXOR = GeneratedJavaTokenTypes.BXOR; 2332 /** 2333 * The {@code &} (bitwise AND) operator. 2334 * 2335 * @see <a 2336 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2337 * Language Specification, §15.22.1</a> 2338 * @see #EXPR 2339 **/ 2340 public static final int BAND = GeneratedJavaTokenTypes.BAND; 2341 /** 2342 * The <code>!=</code> (not equal) operator. 2343 * 2344 * @see #EXPR 2345 * @noinspection HtmlTagCanBeJavadocTag 2346 **/ 2347 public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL; 2348 /** 2349 * The {@code ==} (equal) operator. 2350 * 2351 * @see #EXPR 2352 **/ 2353 public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL; 2354 /** 2355 * The {@code <} (less than) operator. 2356 * 2357 * @see #EXPR 2358 **/ 2359 public static final int LT = GeneratedJavaTokenTypes.LT; 2360 /** 2361 * The {@code >} (greater than) operator. 2362 * 2363 * @see #EXPR 2364 **/ 2365 public static final int GT = GeneratedJavaTokenTypes.GT; 2366 /** 2367 * The {@code <=} (less than or equal) operator. 2368 * 2369 * @see #EXPR 2370 **/ 2371 public static final int LE = GeneratedJavaTokenTypes.LE; 2372 /** 2373 * The {@code >=} (greater than or equal) operator. 2374 * 2375 * @see #EXPR 2376 **/ 2377 public static final int GE = GeneratedJavaTokenTypes.GE; 2378 /** 2379 * The {@code instanceof} operator. The first child is an 2380 * object reference or something that evaluates to an object 2381 * reference. The second child is a reference type. 2382 * 2383 * @see <a 2384 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 2385 * Language Specification, §15.20.2</a> 2386 * @see #EXPR 2387 * @see #METHOD_CALL 2388 * @see #IDENT 2389 * @see #DOT 2390 * @see #TYPE 2391 * @see FullIdent 2392 **/ 2393 public static final int LITERAL_INSTANCEOF = 2394 GeneratedJavaTokenTypes.LITERAL_instanceof; 2395 2396 /** 2397 * The {@code <<} (shift left) operator. 2398 * 2399 * @see <a 2400 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2401 * Language Specification, §15.19</a> 2402 * @see #EXPR 2403 **/ 2404 public static final int SL = GeneratedJavaTokenTypes.SL; 2405 /** 2406 * The {@code >>} (signed shift right) operator. 2407 * 2408 * @see <a 2409 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2410 * Language Specification, §15.19</a> 2411 * @see #EXPR 2412 **/ 2413 public static final int SR = GeneratedJavaTokenTypes.SR; 2414 /** 2415 * The {@code >>>} (unsigned shift right) operator. 2416 * 2417 * @see <a 2418 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2419 * Language Specification, §15.19</a> 2420 * @see #EXPR 2421 **/ 2422 public static final int BSR = GeneratedJavaTokenTypes.BSR; 2423 /** 2424 * The {@code +} (addition) operator. 2425 * 2426 * @see <a 2427 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2428 * Language Specification, §15.18</a> 2429 * @see #EXPR 2430 **/ 2431 public static final int PLUS = GeneratedJavaTokenTypes.PLUS; 2432 /** 2433 * The {@code -} (subtraction) operator. 2434 * 2435 * @see <a 2436 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2437 * Language Specification, §15.18</a> 2438 * @see #EXPR 2439 **/ 2440 public static final int MINUS = GeneratedJavaTokenTypes.MINUS; 2441 /** 2442 * The {@code /} (division) operator. 2443 * 2444 * @see <a 2445 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 2446 * Language Specification, §15.17.2</a> 2447 * @see #EXPR 2448 **/ 2449 public static final int DIV = GeneratedJavaTokenTypes.DIV; 2450 /** 2451 * The {@code %} (remainder) operator. 2452 * 2453 * @see <a 2454 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 2455 * Language Specification, §15.17.3</a> 2456 * @see #EXPR 2457 **/ 2458 public static final int MOD = GeneratedJavaTokenTypes.MOD; 2459 /** 2460 * The {@code ++} (prefix increment) operator. 2461 * 2462 * @see <a 2463 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 2464 * Language Specification, §15.15.1</a> 2465 * @see #EXPR 2466 * @see #POST_INC 2467 **/ 2468 public static final int INC = GeneratedJavaTokenTypes.INC; 2469 /** 2470 * The {@code --} (prefix decrement) operator. 2471 * 2472 * @see <a 2473 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 2474 * Language Specification, §15.15.2</a> 2475 * @see #EXPR 2476 * @see #POST_DEC 2477 **/ 2478 public static final int DEC = GeneratedJavaTokenTypes.DEC; 2479 /** 2480 * The {@code ~} (bitwise complement) operator. 2481 * 2482 * @see <a 2483 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 2484 * Language Specification, §15.15.5</a> 2485 * @see #EXPR 2486 **/ 2487 public static final int BNOT = GeneratedJavaTokenTypes.BNOT; 2488 /** 2489 * The <code>!</code> (logical complement) operator. 2490 * 2491 * @see <a 2492 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 2493 * Language Specification, §15.15.6</a> 2494 * @see #EXPR 2495 * @noinspection HtmlTagCanBeJavadocTag 2496 **/ 2497 public static final int LNOT = GeneratedJavaTokenTypes.LNOT; 2498 /** 2499 * The {@code true} keyword. 2500 * 2501 * @see <a 2502 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2503 * Language Specification, §3.10.3</a> 2504 * @see #EXPR 2505 * @see #LITERAL_FALSE 2506 **/ 2507 public static final int LITERAL_TRUE = 2508 GeneratedJavaTokenTypes.LITERAL_true; 2509 2510 /** 2511 * The {@code false} keyword. 2512 * 2513 * @see <a 2514 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2515 * Language Specification, §3.10.3</a> 2516 * @see #EXPR 2517 * @see #LITERAL_TRUE 2518 **/ 2519 public static final int LITERAL_FALSE = 2520 GeneratedJavaTokenTypes.LITERAL_false; 2521 2522 /** 2523 * The {@code null} keyword. 2524 * 2525 * @see <a 2526 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 2527 * Language Specification, §3.10.7</a> 2528 * @see #EXPR 2529 **/ 2530 public static final int LITERAL_NULL = 2531 GeneratedJavaTokenTypes.LITERAL_null; 2532 2533 /** 2534 * The {@code new} keyword. This element is used to define 2535 * new instances of objects, new arrays, and new anonymous inner 2536 * classes. 2537 * 2538 * <p>For example:</p> 2539 * 2540 * <pre> 2541 * new ArrayList(50) 2542 * </pre> 2543 * 2544 * <p>parses as:</p> 2545 * <pre> 2546 * +--LITERAL_NEW (new) 2547 * | 2548 * +--IDENT (ArrayList) 2549 * +--LPAREN (() 2550 * +--ELIST 2551 * | 2552 * +--EXPR 2553 * | 2554 * +--NUM_INT (50) 2555 * +--RPAREN ()) 2556 * </pre> 2557 * 2558 * <p>For example:</p> 2559 * <pre> 2560 * new float[] 2561 * { 2562 * 3.0f, 2563 * 4.0f 2564 * }; 2565 * </pre> 2566 * 2567 * <p>parses as:</p> 2568 * <pre> 2569 * +--LITERAL_NEW (new) 2570 * | 2571 * +--LITERAL_FLOAT (float) 2572 * +--ARRAY_DECLARATOR ([) 2573 * +--ARRAY_INIT ({) 2574 * | 2575 * +--EXPR 2576 * | 2577 * +--NUM_FLOAT (3.0f) 2578 * +--COMMA (,) 2579 * +--EXPR 2580 * | 2581 * +--NUM_FLOAT (4.0f) 2582 * +--RCURLY (}) 2583 * </pre> 2584 * 2585 * <p>For example:</p> 2586 * <pre> 2587 * new FilenameFilter() 2588 * { 2589 * public boolean accept(File dir, String name) 2590 * { 2591 * return name.endsWith(".java"); 2592 * } 2593 * } 2594 * </pre> 2595 * 2596 * <p>parses as:</p> 2597 * <pre> 2598 * +--LITERAL_NEW (new) 2599 * | 2600 * +--IDENT (FilenameFilter) 2601 * +--LPAREN (() 2602 * +--ELIST 2603 * +--RPAREN ()) 2604 * +--OBJBLOCK 2605 * | 2606 * +--LCURLY ({) 2607 * +--METHOD_DEF 2608 * | 2609 * +--MODIFIERS 2610 * | 2611 * +--LITERAL_PUBLIC (public) 2612 * +--TYPE 2613 * | 2614 * +--LITERAL_BOOLEAN (boolean) 2615 * +--IDENT (accept) 2616 * +--PARAMETERS 2617 * | 2618 * +--PARAMETER_DEF 2619 * | 2620 * +--MODIFIERS 2621 * +--TYPE 2622 * | 2623 * +--IDENT (File) 2624 * +--IDENT (dir) 2625 * +--COMMA (,) 2626 * +--PARAMETER_DEF 2627 * | 2628 * +--MODIFIERS 2629 * +--TYPE 2630 * | 2631 * +--IDENT (String) 2632 * +--IDENT (name) 2633 * +--SLIST ({) 2634 * | 2635 * +--LITERAL_RETURN (return) 2636 * | 2637 * +--EXPR 2638 * | 2639 * +--METHOD_CALL (() 2640 * | 2641 * +--DOT (.) 2642 * | 2643 * +--IDENT (name) 2644 * +--IDENT (endsWith) 2645 * +--ELIST 2646 * | 2647 * +--EXPR 2648 * | 2649 * +--STRING_LITERAL (".java") 2650 * +--RPAREN ()) 2651 * +--SEMI (;) 2652 * +--RCURLY (}) 2653 * +--RCURLY (}) 2654 * </pre> 2655 * 2656 * @see #IDENT 2657 * @see #DOT 2658 * @see #LPAREN 2659 * @see #ELIST 2660 * @see #RPAREN 2661 * @see #OBJBLOCK 2662 * @see #ARRAY_INIT 2663 * @see FullIdent 2664 **/ 2665 public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new; 2666 /** 2667 * An integer literal. These may be specified in decimal, 2668 * hexadecimal, or octal form. 2669 * 2670 * @see <a 2671 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2672 * Language Specification, §3.10.1</a> 2673 * @see #EXPR 2674 * @see #NUM_LONG 2675 **/ 2676 public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT; 2677 /** 2678 * A character literal. This is a (possibly escaped) character 2679 * enclosed in single quotes. 2680 * 2681 * @see <a 2682 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 2683 * Language Specification, §3.10.4</a> 2684 * @see #EXPR 2685 **/ 2686 public static final int CHAR_LITERAL = 2687 GeneratedJavaTokenTypes.CHAR_LITERAL; 2688 2689 /** 2690 * A string literal. This is a sequence of (possibly escaped) 2691 * characters enclosed in double quotes. 2692 * 2693 * @see <a 2694 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 2695 * Language Specification, §3.10.5</a> 2696 * @see #EXPR 2697 **/ 2698 public static final int STRING_LITERAL = 2699 GeneratedJavaTokenTypes.STRING_LITERAL; 2700 2701 /** 2702 * A single precision floating point literal. This is a floating 2703 * point number with an {@code F} or {@code f} suffix. 2704 * 2705 * @see <a 2706 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2707 * Language Specification, §3.10.2</a> 2708 * @see #EXPR 2709 * @see #NUM_DOUBLE 2710 **/ 2711 public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT; 2712 /** 2713 * A long integer literal. These are almost the same as integer 2714 * literals, but they have an {@code L} or {@code l} 2715 * (ell) suffix. 2716 * 2717 * @see <a 2718 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2719 * Language Specification, §3.10.1</a> 2720 * @see #EXPR 2721 * @see #NUM_INT 2722 **/ 2723 public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG; 2724 /** 2725 * A double precision floating point literal. This is a floating 2726 * point number with an optional {@code D} or {@code d} 2727 * suffix. 2728 * 2729 * @see <a 2730 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2731 * Language Specification, §3.10.2</a> 2732 * @see #EXPR 2733 * @see #NUM_FLOAT 2734 **/ 2735 public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE; 2736 2737 /** 2738 * The {@code assert} keyword. This is only for Java 1.4 and 2739 * later. 2740 * 2741 * <p>For example:</p> 2742 * <pre> 2743 * assert(x==4); 2744 * </pre> 2745 * <p>parses as:</p> 2746 * <pre> 2747 * +--LITERAL_ASSERT (assert) 2748 * | 2749 * +--EXPR 2750 * | 2751 * +--LPAREN (() 2752 * +--EQUAL (==) 2753 * | 2754 * +--IDENT (x) 2755 * +--NUM_INT (4) 2756 * +--RPAREN ()) 2757 * +--SEMI (;) 2758 * </pre> 2759 **/ 2760 public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT; 2761 2762 /** 2763 * A static import declaration. Static import declarations are optional, 2764 * but must appear after the package declaration and before the type 2765 * declaration. 2766 * 2767 * <p>For example:</p> 2768 * 2769 * <pre> 2770 * import static java.io.IOException; 2771 * </pre> 2772 * 2773 * <p>parses as:</p> 2774 * 2775 * <pre> 2776 * +--STATIC_IMPORT (import) 2777 * | 2778 * +--LITERAL_STATIC 2779 * +--DOT (.) 2780 * | 2781 * +--DOT (.) 2782 * | 2783 * +--IDENT (java) 2784 * +--IDENT (io) 2785 * +--IDENT (IOException) 2786 * +--SEMI (;) 2787 * </pre> 2788 * 2789 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2790 * JSR201</a> 2791 * @see #LITERAL_STATIC 2792 * @see #DOT 2793 * @see #IDENT 2794 * @see #STAR 2795 * @see #SEMI 2796 * @see FullIdent 2797 **/ 2798 public static final int STATIC_IMPORT = 2799 GeneratedJavaTokenTypes.STATIC_IMPORT; 2800 2801 /** 2802 * An enum declaration. Its notable children are 2803 * enum constant declarations followed by 2804 * any construct that may be expected in a class body. 2805 * 2806 * <p>For example:</p> 2807 * <pre> 2808 * public enum MyEnum 2809 * implements Serializable 2810 * { 2811 * FIRST_CONSTANT, 2812 * SECOND_CONSTANT; 2813 * 2814 * public void someMethod() 2815 * { 2816 * } 2817 * } 2818 * </pre> 2819 * <p>parses as:</p> 2820 * <pre> 2821 * +--ENUM_DEF 2822 * | 2823 * +--MODIFIERS 2824 * | 2825 * +--LITERAL_PUBLIC (public) 2826 * +--ENUM (enum) 2827 * +--IDENT (MyEnum) 2828 * +--EXTENDS_CLAUSE 2829 * +--IMPLEMENTS_CLAUSE 2830 * | 2831 * +--IDENT (Serializable) 2832 * +--OBJBLOCK 2833 * | 2834 * +--LCURLY ({) 2835 * +--ENUM_CONSTANT_DEF 2836 * | 2837 * +--IDENT (FIRST_CONSTANT) 2838 * +--COMMA (,) 2839 * +--ENUM_CONSTANT_DEF 2840 * | 2841 * +--IDENT (SECOND_CONSTANT) 2842 * +--SEMI (;) 2843 * +--METHOD_DEF 2844 * | 2845 * +--MODIFIERS 2846 * | 2847 * +--LITERAL_PUBLIC (public) 2848 * +--TYPE 2849 * | 2850 * +--LITERAL_void (void) 2851 * +--IDENT (someMethod) 2852 * +--LPAREN (() 2853 * +--PARAMETERS 2854 * +--RPAREN ()) 2855 * +--SLIST ({) 2856 * | 2857 * +--RCURLY (}) 2858 * +--RCURLY (}) 2859 * </pre> 2860 * 2861 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2862 * JSR201</a> 2863 * @see #MODIFIERS 2864 * @see #ENUM 2865 * @see #IDENT 2866 * @see #EXTENDS_CLAUSE 2867 * @see #IMPLEMENTS_CLAUSE 2868 * @see #OBJBLOCK 2869 * @see #LITERAL_NEW 2870 * @see #ENUM_CONSTANT_DEF 2871 **/ 2872 public static final int ENUM_DEF = 2873 GeneratedJavaTokenTypes.ENUM_DEF; 2874 2875 /** 2876 * The {@code enum} keyword. This element appears 2877 * as part of an enum declaration. 2878 **/ 2879 public static final int ENUM = 2880 GeneratedJavaTokenTypes.ENUM; 2881 2882 /** 2883 * An enum constant declaration. Its notable children are annotations, 2884 * arguments and object block akin to an anonymous 2885 * inner class' body. 2886 * 2887 * <p>For example:</p> 2888 * <pre> 2889 * SOME_CONSTANT(1) 2890 * { 2891 * public void someMethodOverriddenFromMainBody() 2892 * { 2893 * } 2894 * } 2895 * </pre> 2896 * <p>parses as:</p> 2897 * <pre> 2898 * +--ENUM_CONSTANT_DEF 2899 * | 2900 * +--ANNOTATIONS 2901 * +--IDENT (SOME_CONSTANT) 2902 * +--LPAREN (() 2903 * +--ELIST 2904 * | 2905 * +--EXPR 2906 * | 2907 * +--NUM_INT (1) 2908 * +--RPAREN ()) 2909 * +--OBJBLOCK 2910 * | 2911 * +--LCURLY ({) 2912 * | 2913 * +--METHOD_DEF 2914 * | 2915 * +--MODIFIERS 2916 * | 2917 * +--LITERAL_PUBLIC (public) 2918 * +--TYPE 2919 * | 2920 * +--LITERAL_void (void) 2921 * +--IDENT (someMethodOverriddenFromMainBody) 2922 * +--LPAREN (() 2923 * +--PARAMETERS 2924 * +--RPAREN ()) 2925 * +--SLIST ({) 2926 * | 2927 * +--RCURLY (}) 2928 * +--RCURLY (}) 2929 * </pre> 2930 * 2931 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2932 * JSR201</a> 2933 * @see #ANNOTATIONS 2934 * @see #MODIFIERS 2935 * @see #IDENT 2936 * @see #ELIST 2937 * @see #OBJBLOCK 2938 **/ 2939 public static final int ENUM_CONSTANT_DEF = 2940 GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF; 2941 2942 /** 2943 * A for-each clause. This is a child of 2944 * {@code LITERAL_FOR}. The children of this element may be 2945 * a parameter definition, the colon literal and an expression. 2946 * 2947 * <p>For example:</p> 2948 * <pre> 2949 * for (int value : values) { 2950 * doSmth(); 2951 * } 2952 * </pre> 2953 * <p>parses as:</p> 2954 * <pre> 2955 * --LITERAL_FOR (for) 2956 * |--LPAREN (() 2957 * |--FOR_EACH_CLAUSE 2958 * | |--VARIABLE_DEF 2959 * | | |--MODIFIERS 2960 * | | |--TYPE 2961 * | | | `--LITERAL_INT (int) 2962 * | | `--IDENT (value) 2963 * | |--COLON (:) 2964 * | `--EXPR 2965 * | `--IDENT (values 2966 * |--RPAREN ()) 2967 * `--SLIST ({) 2968 * |--EXPR 2969 * | `--METHOD_CALL (() 2970 * | |--IDENT (doSmth) 2971 * | |--ELIST 2972 * | `--RPAREN ()) 2973 * |--SEMI (;) 2974 * `--RCURLY (}) 2975 * 2976 * </pre> 2977 * 2978 * @see #VARIABLE_DEF 2979 * @see #ELIST 2980 * @see #LITERAL_FOR 2981 **/ 2982 public static final int FOR_EACH_CLAUSE = 2983 GeneratedJavaTokenTypes.FOR_EACH_CLAUSE; 2984 2985 /** 2986 * An annotation declaration. The notable children are the name of the 2987 * annotation type, annotation field declarations and (constant) fields. 2988 * 2989 * <p>For example:</p> 2990 * <pre> 2991 * public @interface MyAnnotation 2992 * { 2993 * int someValue(); 2994 * } 2995 * </pre> 2996 * <p>parses as:</p> 2997 * <pre> 2998 * +--ANNOTATION_DEF 2999 * | 3000 * +--MODIFIERS 3001 * | 3002 * +--LITERAL_PUBLIC (public) 3003 * +--AT (@) 3004 * +--LITERAL_INTERFACE (interface) 3005 * +--IDENT (MyAnnotation) 3006 * +--OBJBLOCK 3007 * | 3008 * +--LCURLY ({) 3009 * +--ANNOTATION_FIELD_DEF 3010 * | 3011 * +--MODIFIERS 3012 * +--TYPE 3013 * | 3014 * +--LITERAL_INT (int) 3015 * +--IDENT (someValue) 3016 * +--LPAREN (() 3017 * +--RPAREN ()) 3018 * +--SEMI (;) 3019 * +--RCURLY (}) 3020 * </pre> 3021 * 3022 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3023 * JSR201</a> 3024 * @see #MODIFIERS 3025 * @see #LITERAL_INTERFACE 3026 * @see #IDENT 3027 * @see #OBJBLOCK 3028 * @see #ANNOTATION_FIELD_DEF 3029 **/ 3030 public static final int ANNOTATION_DEF = 3031 GeneratedJavaTokenTypes.ANNOTATION_DEF; 3032 3033 /** 3034 * An annotation field declaration. The notable children are modifiers, 3035 * field type, field name and an optional default value (a conditional 3036 * compile-time constant expression). Default values may also by 3037 * annotations. 3038 * 3039 * <p>For example:</p> 3040 * 3041 * <pre> 3042 * String someField() default "Hello world"; 3043 * </pre> 3044 * 3045 * <p>parses as:</p> 3046 * 3047 * <pre> 3048 * +--ANNOTATION_FIELD_DEF 3049 * | 3050 * +--MODIFIERS 3051 * +--TYPE 3052 * | 3053 * +--IDENT (String) 3054 * +--IDENT (someField) 3055 * +--LPAREN (() 3056 * +--RPAREN ()) 3057 * +--LITERAL_DEFAULT (default) 3058 * +--STRING_LITERAL ("Hello world") 3059 * +--SEMI (;) 3060 * </pre> 3061 * 3062 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3063 * JSR201</a> 3064 * @see #MODIFIERS 3065 * @see #TYPE 3066 * @see #LITERAL_DEFAULT 3067 */ 3068 public static final int ANNOTATION_FIELD_DEF = 3069 GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF; 3070 3071 // note: @ is the html escape for '@', 3072 // used here to avoid confusing the javadoc tool 3073 /** 3074 * A collection of annotations on a package or enum constant. 3075 * A collections of annotations will only occur on these nodes 3076 * as all other nodes that may be qualified with an annotation can 3077 * be qualified with any other modifier and hence these annotations 3078 * would be contained in a {@link #MODIFIERS} node. 3079 * 3080 * <p>For example:</p> 3081 * 3082 * <pre> 3083 * @MyAnnotation package blah; 3084 * </pre> 3085 * 3086 * <p>parses as:</p> 3087 * 3088 * <pre> 3089 * +--PACKAGE_DEF (package) 3090 * | 3091 * +--ANNOTATIONS 3092 * | 3093 * +--ANNOTATION 3094 * | 3095 * +--AT (@) 3096 * +--IDENT (MyAnnotation) 3097 * +--IDENT (blah) 3098 * +--SEMI (;) 3099 * </pre> 3100 * 3101 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3102 * JSR201</a> 3103 * @see #ANNOTATION 3104 * @see #AT 3105 * @see #IDENT 3106 */ 3107 public static final int ANNOTATIONS = 3108 GeneratedJavaTokenTypes.ANNOTATIONS; 3109 3110 // note: @ is the html escape for '@', 3111 // used here to avoid confusing the javadoc tool 3112 /** 3113 * An annotation of a package, type, field, parameter or variable. 3114 * An annotation may occur anywhere modifiers occur (it is a 3115 * type of modifier) and may also occur prior to a package definition. 3116 * The notable children are: The annotation name and either a single 3117 * default annotation value or a sequence of name value pairs. 3118 * Annotation values may also be annotations themselves. 3119 * 3120 * <p>For example:</p> 3121 * 3122 * <pre> 3123 * @MyAnnotation(someField1 = "Hello", 3124 * someField2 = @SomeOtherAnnotation) 3125 * </pre> 3126 * 3127 * <p>parses as:</p> 3128 * 3129 * <pre> 3130 * +--ANNOTATION 3131 * | 3132 * +--AT (@) 3133 * +--IDENT (MyAnnotation) 3134 * +--LPAREN (() 3135 * +--ANNOTATION_MEMBER_VALUE_PAIR 3136 * | 3137 * +--IDENT (someField1) 3138 * +--ASSIGN (=) 3139 * +--ANNOTATION 3140 * | 3141 * +--AT (@) 3142 * +--IDENT (SomeOtherAnnotation) 3143 * +--ANNOTATION_MEMBER_VALUE_PAIR 3144 * | 3145 * +--IDENT (someField2) 3146 * +--ASSIGN (=) 3147 * +--STRING_LITERAL ("Hello") 3148 * +--RPAREN ()) 3149 * </pre> 3150 * 3151 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3152 * JSR201</a> 3153 * @see #MODIFIERS 3154 * @see #IDENT 3155 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3156 */ 3157 public static final int ANNOTATION = 3158 GeneratedJavaTokenTypes.ANNOTATION; 3159 3160 /** 3161 * An initialization of an annotation member with a value. 3162 * Its children are the name of the member, the assignment literal 3163 * and the (compile-time constant conditional expression) value. 3164 * 3165 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3166 * JSR201</a> 3167 * @see #ANNOTATION 3168 * @see #IDENT 3169 */ 3170 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 3171 GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR; 3172 3173 /** 3174 * An annotation array member initialization. 3175 * Initializers can not be nested. 3176 * An initializer may be present as a default to an annotation 3177 * member, as the single default value to an annotation 3178 * (e.g. @Annotation({1,2})) or as the value of an annotation 3179 * member value pair. 3180 * 3181 * <p>For example:</p> 3182 * 3183 * <pre> 3184 * { 1, 2 } 3185 * </pre> 3186 * 3187 * <p>parses as:</p> 3188 * 3189 * <pre> 3190 * +--ANNOTATION_ARRAY_INIT ({) 3191 * | 3192 * +--NUM_INT (1) 3193 * +--COMMA (,) 3194 * +--NUM_INT (2) 3195 * +--RCURLY (}) 3196 * </pre> 3197 * 3198 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3199 * JSR201</a> 3200 * @see #ANNOTATION 3201 * @see #IDENT 3202 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3203 */ 3204 public static final int ANNOTATION_ARRAY_INIT = 3205 GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT; 3206 3207 /** 3208 * A list of type parameters to a class, interface or 3209 * method definition. Children are LT, at least one 3210 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 3211 * TYPE_PARAMETER and a final GT. 3212 * 3213 * <p>For example:</p> 3214 * 3215 * <pre> 3216 * public class Blah<A, B> 3217 * { 3218 * } 3219 * </pre> 3220 * 3221 * <p>parses as:</p> 3222 * 3223 * <pre> 3224 * +--CLASS_DEF ({) 3225 * | 3226 * +--MODIFIERS 3227 * | 3228 * +--LITERAL_PUBLIC (public) 3229 * +--LITERAL_CLASS (class) 3230 * +--IDENT (Blah) 3231 * +--TYPE_PARAMETERS 3232 * | 3233 * +--GENERIC_START (<) 3234 * +--TYPE_PARAMETER 3235 * | 3236 * +--IDENT (A) 3237 * +--COMMA (,) 3238 * +--TYPE_PARAMETER 3239 * | 3240 * +--IDENT (B) 3241 * +--GENERIC_END (>) 3242 * +--OBJBLOCK 3243 * | 3244 * +--LCURLY ({) 3245 * +--NUM_INT (1) 3246 * +--COMMA (,) 3247 * +--NUM_INT (2) 3248 * +--RCURLY (}) 3249 * </pre> 3250 * 3251 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3252 * JSR14</a> 3253 * @see #GENERIC_START 3254 * @see #GENERIC_END 3255 * @see #TYPE_PARAMETER 3256 * @see #COMMA 3257 */ 3258 public static final int TYPE_PARAMETERS = 3259 GeneratedJavaTokenTypes.TYPE_PARAMETERS; 3260 3261 /** 3262 * A type parameter to a class, interface or method definition. 3263 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 3264 * 3265 * <p>For example:</p> 3266 * 3267 * <pre> 3268 * A extends Collection 3269 * </pre> 3270 * 3271 * <p>parses as:</p> 3272 * 3273 * <pre> 3274 * +--TYPE_PARAMETER 3275 * | 3276 * +--IDENT (A) 3277 * +--TYPE_UPPER_BOUNDS 3278 * | 3279 * +--IDENT (Collection) 3280 * </pre> 3281 * 3282 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3283 * JSR14</a> 3284 * @see #IDENT 3285 * @see #WILDCARD_TYPE 3286 * @see #TYPE_UPPER_BOUNDS 3287 */ 3288 public static final int TYPE_PARAMETER = 3289 GeneratedJavaTokenTypes.TYPE_PARAMETER; 3290 3291 /** 3292 * A list of type arguments to a type reference or 3293 * a method/ctor invocation. Children are GENERIC_START, at least one 3294 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 3295 * TYPE_ARGUMENT, and a final GENERIC_END. 3296 * 3297 * <p>For example:</p> 3298 * 3299 * <pre> 3300 * public Collection<?> a; 3301 * </pre> 3302 * 3303 * <p>parses as:</p> 3304 * 3305 * <pre> 3306 * +--VARIABLE_DEF 3307 * | 3308 * +--MODIFIERS 3309 * | 3310 * +--LITERAL_PUBLIC (public) 3311 * +--TYPE 3312 * | 3313 * +--IDENT (Collection) 3314 * | 3315 * +--TYPE_ARGUMENTS 3316 * | 3317 * +--GENERIC_START (<) 3318 * +--TYPE_ARGUMENT 3319 * | 3320 * +--WILDCARD_TYPE (?) 3321 * +--GENERIC_END (>) 3322 * +--IDENT (a) 3323 * +--SEMI (;) 3324 * </pre> 3325 * 3326 * @see #GENERIC_START 3327 * @see #GENERIC_END 3328 * @see #TYPE_ARGUMENT 3329 * @see #COMMA 3330 */ 3331 public static final int TYPE_ARGUMENTS = 3332 GeneratedJavaTokenTypes.TYPE_ARGUMENTS; 3333 3334 /** 3335 * A type arguments to a type reference or a method/ctor invocation. 3336 * Children are either: type name or wildcard type with possible type 3337 * upper or lower bounds. 3338 * 3339 * <p>For example:</p> 3340 * 3341 * <pre> 3342 * ? super List 3343 * </pre> 3344 * 3345 * <p>parses as:</p> 3346 * 3347 * <pre> 3348 * +--TYPE_ARGUMENT 3349 * | 3350 * +--WILDCARD_TYPE (?) 3351 * +--TYPE_LOWER_BOUNDS 3352 * | 3353 * +--IDENT (List) 3354 * </pre> 3355 * 3356 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3357 * JSR14</a> 3358 * @see #WILDCARD_TYPE 3359 * @see #TYPE_UPPER_BOUNDS 3360 * @see #TYPE_LOWER_BOUNDS 3361 */ 3362 public static final int TYPE_ARGUMENT = 3363 GeneratedJavaTokenTypes.TYPE_ARGUMENT; 3364 3365 /** 3366 * The type that refers to all types. This node has no children. 3367 * 3368 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3369 * JSR14</a> 3370 * @see #TYPE_ARGUMENT 3371 * @see #TYPE_UPPER_BOUNDS 3372 * @see #TYPE_LOWER_BOUNDS 3373 */ 3374 public static final int WILDCARD_TYPE = 3375 GeneratedJavaTokenTypes.WILDCARD_TYPE; 3376 3377 /** 3378 * An upper bounds on a wildcard type argument or type parameter. 3379 * This node has one child - the type that is being used for 3380 * the bounding. 3381 * 3382 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3383 * JSR14</a> 3384 * @see #TYPE_PARAMETER 3385 * @see #TYPE_ARGUMENT 3386 * @see #WILDCARD_TYPE 3387 */ 3388 public static final int TYPE_UPPER_BOUNDS = 3389 GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS; 3390 3391 /** 3392 * A lower bounds on a wildcard type argument. This node has one child 3393 * - the type that is being used for the bounding. 3394 * 3395 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3396 * JSR14</a> 3397 * @see #TYPE_ARGUMENT 3398 * @see #WILDCARD_TYPE 3399 */ 3400 public static final int TYPE_LOWER_BOUNDS = 3401 GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS; 3402 3403 /** 3404 * An {@code @} symbol - signifying an annotation instance or the prefix 3405 * to the interface literal signifying the definition of an annotation 3406 * declaration. 3407 * 3408 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3409 * JSR201</a> 3410 */ 3411 public static final int AT = GeneratedJavaTokenTypes.AT; 3412 3413 /** 3414 * A triple dot for variable-length parameters. This token only ever occurs 3415 * in a parameter declaration immediately after the type of the parameter. 3416 * 3417 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3418 * JSR201</a> 3419 */ 3420 public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS; 3421 3422 /** 3423 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain 3424 * or a type cast expression with an additional interface. 3425 * 3426 * <p>Generic type bounds extension: 3427 * {@code class Comparable<T extends Serializable & CharSequence>}</p> 3428 * <pre> 3429 * CLASS_DEF 3430 * |--MODIFIERS 3431 * |--LITERAL_CLASS (class) 3432 * |--IDENT (Comparable) 3433 * +--TYPE_PARAMETERS 3434 * |--GENERIC_START (<) 3435 * |--TYPE_PARAMETER 3436 * | |--IDENT (T) 3437 * | +--TYPE_UPPER_BOUNDS (extends) 3438 * | |--IDENT (Serializable) 3439 * | |--TYPE_EXTENSION_AND (&) 3440 * | +--IDENT (CharSequence) 3441 * +--GENERIC_END (>) 3442 * </pre> 3443 * 3444 * <p>Type cast extension: 3445 * {@code return (CheckedFunction & Serializable) null;}</p> 3446 * <pre> 3447 * LITERAL_RETURN (return) 3448 * |--EXPR 3449 * | +--TYPECAST (() 3450 * | |--TYPE 3451 * | | +--IDENT (CheckedFunction) 3452 * | |--TYPE_EXTENSION_AND (&) 3453 * | |--TYPE 3454 * | | +--IDENT (Serializable) 3455 * | |--RPAREN ()) 3456 * | +--LITERAL_NULL (null) 3457 * +--SEMI (;) 3458 * </pre> 3459 * 3460 * @see #EXTENDS_CLAUSE 3461 * @see #TYPECAST 3462 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4"> 3463 * Java Language Specification, §4.4</a> 3464 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16"> 3465 * Java Language Specification, §15.16</a> 3466 */ 3467 public static final int TYPE_EXTENSION_AND = 3468 GeneratedJavaTokenTypes.TYPE_EXTENSION_AND; 3469 3470 /** 3471 * A {@code <} symbol signifying the start of type arguments or type parameters. 3472 */ 3473 public static final int GENERIC_START = 3474 GeneratedJavaTokenTypes.GENERIC_START; 3475 3476 /** 3477 * A {@code >} symbol signifying the end of type arguments or type parameters. 3478 */ 3479 public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END; 3480 3481 /** 3482 * Special lambda symbol {@code ->}. 3483 */ 3484 public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA; 3485 3486 /** 3487 * Beginning of single line comment: '//'. 3488 * 3489 * <pre> 3490 * +--SINGLE_LINE_COMMENT 3491 * | 3492 * +--COMMENT_CONTENT 3493 * </pre> 3494 */ 3495 public static final int SINGLE_LINE_COMMENT = 3496 GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT; 3497 3498 /** 3499 * Beginning of block comment: '/*'. 3500 * 3501 * <pre> 3502 * +--BLOCK_COMMENT_BEGIN 3503 * | 3504 * +--COMMENT_CONTENT 3505 * +--BLOCK_COMMENT_END 3506 * </pre> 3507 */ 3508 public static final int BLOCK_COMMENT_BEGIN = 3509 GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN; 3510 3511 /** 3512 * End of block comment: '*/'. 3513 * 3514 * <pre> 3515 * +--BLOCK_COMMENT_BEGIN 3516 * | 3517 * +--COMMENT_CONTENT 3518 * +--BLOCK_COMMENT_END 3519 * </pre> 3520 */ 3521 public static final int BLOCK_COMMENT_END = 3522 GeneratedJavaTokenTypes.BLOCK_COMMENT_END; 3523 3524 /** 3525 * Text of single-line or block comment. 3526 * 3527 * <pre> 3528 * +--SINGLE_LINE_COMMENT 3529 * | 3530 * +--COMMENT_CONTENT 3531 * </pre> 3532 * 3533 * <pre> 3534 * +--BLOCK_COMMENT_BEGIN 3535 * | 3536 * +--COMMENT_CONTENT 3537 * +--BLOCK_COMMENT_END 3538 * </pre> 3539 */ 3540 public static final int COMMENT_CONTENT = 3541 GeneratedJavaTokenTypes.COMMENT_CONTENT; 3542 3543 /** Prevent instantiation. */ 3544 private TokenTypes() { 3545 } 3546 3547}