001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2018 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.grammars.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 * @author Oliver Burn 032 * @author <a href="mailto:dobratzp@ele.uri.edu">Peter Dobratz</a> 033 * @noinspection ClassWithTooManyDependents 034 */ 035public final class TokenTypes { 036 037 /** 038 * The end of file token. This is the root node for the source 039 * file. It's children are an optional package definition, zero 040 * or more import statements, and one or more class or interface 041 * definitions. 042 * 043 * @see #PACKAGE_DEF 044 * @see #IMPORT 045 * @see #CLASS_DEF 046 * @see #INTERFACE_DEF 047 **/ 048 public static final int EOF = GeneratedJavaTokenTypes.EOF; 049 /** 050 * Modifiers for type, method, and field declarations. The 051 * modifiers element is always present even though it may have no 052 * children. 053 * 054 * @see <a 055 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 056 * Language Specification, §8</a> 057 * @see #LITERAL_PUBLIC 058 * @see #LITERAL_PROTECTED 059 * @see #LITERAL_PRIVATE 060 * @see #ABSTRACT 061 * @see #LITERAL_STATIC 062 * @see #FINAL 063 * @see #LITERAL_TRANSIENT 064 * @see #LITERAL_VOLATILE 065 * @see #LITERAL_SYNCHRONIZED 066 * @see #LITERAL_NATIVE 067 * @see #STRICTFP 068 * @see #ANNOTATION 069 * @see #LITERAL_DEFAULT 070 **/ 071 public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS; 072 073 /** 074 * An object block. These are children of class, interface, enum, 075 * annotation and enum constant declarations. 076 * Also, object blocks are children of the new keyword when defining 077 * anonymous inner types. 078 * 079 * @see #LCURLY 080 * @see #INSTANCE_INIT 081 * @see #STATIC_INIT 082 * @see #CLASS_DEF 083 * @see #CTOR_DEF 084 * @see #METHOD_DEF 085 * @see #VARIABLE_DEF 086 * @see #RCURLY 087 * @see #INTERFACE_DEF 088 * @see #LITERAL_NEW 089 * @see #ENUM_DEF 090 * @see #ENUM_CONSTANT_DEF 091 * @see #ANNOTATION_DEF 092 **/ 093 public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK; 094 /** 095 * A list of statements. 096 * 097 * @see #RCURLY 098 * @see #EXPR 099 * @see #LABELED_STAT 100 * @see #LITERAL_THROWS 101 * @see #LITERAL_RETURN 102 * @see #SEMI 103 * @see #METHOD_DEF 104 * @see #CTOR_DEF 105 * @see #LITERAL_FOR 106 * @see #LITERAL_WHILE 107 * @see #LITERAL_IF 108 * @see #LITERAL_ELSE 109 * @see #CASE_GROUP 110 **/ 111 public static final int SLIST = GeneratedJavaTokenTypes.SLIST; 112 /** 113 * A constructor declaration. 114 * 115 * <p>For example:</p> 116 * <pre> 117 * public SpecialEntry(int value, String text) 118 * { 119 * this.value = value; 120 * this.text = text; 121 * } 122 * </pre> 123 * <p>parses as:</p> 124 * <pre> 125 * +--CTOR_DEF 126 * | 127 * +--MODIFIERS 128 * | 129 * +--LITERAL_PUBLIC (public) 130 * +--IDENT (SpecialEntry) 131 * +--LPAREN (() 132 * +--PARAMETERS 133 * | 134 * +--PARAMETER_DEF 135 * | 136 * +--MODIFIERS 137 * +--TYPE 138 * | 139 * +--LITERAL_INT (int) 140 * +--IDENT (value) 141 * +--COMMA (,) 142 * +--PARAMETER_DEF 143 * | 144 * +--MODIFIERS 145 * +--TYPE 146 * | 147 * +--IDENT (String) 148 * +--IDENT (text) 149 * +--RPAREN ()) 150 * +--SLIST ({) 151 * | 152 * +--EXPR 153 * | 154 * +--ASSIGN (=) 155 * | 156 * +--DOT (.) 157 * | 158 * +--LITERAL_THIS (this) 159 * +--IDENT (value) 160 * +--IDENT (value) 161 * +--SEMI (;) 162 * +--EXPR 163 * | 164 * +--ASSIGN (=) 165 * | 166 * +--DOT (.) 167 * | 168 * +--LITERAL_THIS (this) 169 * +--IDENT (text) 170 * +--IDENT (text) 171 * +--SEMI (;) 172 * +--RCURLY (}) 173 * </pre> 174 * 175 * @see #OBJBLOCK 176 * @see #CLASS_DEF 177 **/ 178 public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF; 179 /** 180 * A method declaration. The children are modifiers, type parameters, 181 * return type, method name, parameter list, an optional throws list, and 182 * statement list. The statement list is omitted if the method 183 * declaration appears in an interface declaration. Method 184 * declarations may appear inside object blocks of class 185 * declarations, interface declarations, enum declarations, 186 * enum constant declarations or anonymous inner-class declarations. 187 * 188 * <p>For example:</p> 189 * 190 * <pre> 191 * public static int square(int x) 192 * { 193 * return x*x; 194 * } 195 * </pre> 196 * 197 * <p>parses as:</p> 198 * 199 * <pre> 200 * +--METHOD_DEF 201 * | 202 * +--MODIFIERS 203 * | 204 * +--LITERAL_PUBLIC (public) 205 * +--LITERAL_STATIC (static) 206 * +--TYPE 207 * | 208 * +--LITERAL_INT (int) 209 * +--IDENT (square) 210 * +--PARAMETERS 211 * | 212 * +--PARAMETER_DEF 213 * | 214 * +--MODIFIERS 215 * +--TYPE 216 * | 217 * +--LITERAL_INT (int) 218 * +--IDENT (x) 219 * +--SLIST ({) 220 * | 221 * +--LITERAL_RETURN (return) 222 * | 223 * +--EXPR 224 * | 225 * +--STAR (*) 226 * | 227 * +--IDENT (x) 228 * +--IDENT (x) 229 * +--SEMI (;) 230 * +--RCURLY (}) 231 * </pre> 232 * 233 * @see #MODIFIERS 234 * @see #TYPE_PARAMETERS 235 * @see #TYPE 236 * @see #IDENT 237 * @see #PARAMETERS 238 * @see #LITERAL_THROWS 239 * @see #SLIST 240 * @see #OBJBLOCK 241 **/ 242 public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF; 243 /** 244 * A field or local variable declaration. The children are 245 * modifiers, type, the identifier name, and an optional 246 * assignment statement. 247 * 248 * @see #MODIFIERS 249 * @see #TYPE 250 * @see #IDENT 251 * @see #ASSIGN 252 **/ 253 public static final int VARIABLE_DEF = 254 GeneratedJavaTokenTypes.VARIABLE_DEF; 255 256 /** 257 * An instance initializer. Zero or more instance initializers 258 * may appear in class and enum definitions. This token will be a child 259 * of the object block of the declaring type. 260 * 261 * @see <a 262 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java 263 * Language Specification§8.6</a> 264 * @see #SLIST 265 * @see #OBJBLOCK 266 **/ 267 public static final int INSTANCE_INIT = 268 GeneratedJavaTokenTypes.INSTANCE_INIT; 269 270 /** 271 * A static initialization block. Zero or more static 272 * initializers may be children of the object block of a class 273 * or enum declaration (interfaces cannot have static initializers). The 274 * first and only child is a statement list. 275 * 276 * @see <a 277 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java 278 * Language Specification, §8.7</a> 279 * @see #SLIST 280 * @see #OBJBLOCK 281 **/ 282 public static final int STATIC_INIT = 283 GeneratedJavaTokenTypes.STATIC_INIT; 284 285 /** 286 * A type. This is either a return type of a method or a type of 287 * a variable or field. The first child of this element is the 288 * actual type. This may be a primitive type, an identifier, a 289 * dot which is the root of a fully qualified type, or an array of 290 * any of these. The second child may be type arguments to the type. 291 * 292 * @see #VARIABLE_DEF 293 * @see #METHOD_DEF 294 * @see #PARAMETER_DEF 295 * @see #IDENT 296 * @see #DOT 297 * @see #LITERAL_VOID 298 * @see #LITERAL_BOOLEAN 299 * @see #LITERAL_BYTE 300 * @see #LITERAL_CHAR 301 * @see #LITERAL_SHORT 302 * @see #LITERAL_INT 303 * @see #LITERAL_FLOAT 304 * @see #LITERAL_LONG 305 * @see #LITERAL_DOUBLE 306 * @see #ARRAY_DECLARATOR 307 * @see #TYPE_ARGUMENTS 308 **/ 309 public static final int TYPE = GeneratedJavaTokenTypes.TYPE; 310 /** 311 * A class declaration. 312 * 313 * <p>For example:</p> 314 * <pre> 315 * public class MyClass 316 * implements Serializable 317 * { 318 * } 319 * </pre> 320 * <p>parses as:</p> 321 * <pre> 322 * +--CLASS_DEF 323 * | 324 * +--MODIFIERS 325 * | 326 * +--LITERAL_PUBLIC (public) 327 * +--LITERAL_CLASS (class) 328 * +--IDENT (MyClass) 329 * +--EXTENDS_CLAUSE 330 * +--IMPLEMENTS_CLAUSE 331 * | 332 * +--IDENT (Serializable) 333 * +--OBJBLOCK 334 * | 335 * +--LCURLY ({) 336 * +--RCURLY (}) 337 * </pre> 338 * 339 * @see <a 340 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 341 * Language Specification, §8</a> 342 * @see #MODIFIERS 343 * @see #IDENT 344 * @see #EXTENDS_CLAUSE 345 * @see #IMPLEMENTS_CLAUSE 346 * @see #OBJBLOCK 347 * @see #LITERAL_NEW 348 **/ 349 public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF; 350 /** 351 * An interface declaration. 352 * 353 * <p>For example:</p> 354 * 355 * <pre> 356 * public interface MyInterface 357 * { 358 * } 359 * 360 * </pre> 361 * 362 * <p>parses as:</p> 363 * 364 * <pre> 365 * +--INTERFACE_DEF 366 * | 367 * +--MODIFIERS 368 * | 369 * +--LITERAL_PUBLIC (public) 370 * +--LITERAL_INTERFACE (interface) 371 * +--IDENT (MyInterface) 372 * +--EXTENDS_CLAUSE 373 * +--OBJBLOCK 374 * | 375 * +--LCURLY ({) 376 * +--RCURLY (}) 377 * </pre> 378 * 379 * @see <a 380 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java 381 * Language Specification, §9</a> 382 * @see #MODIFIERS 383 * @see #IDENT 384 * @see #EXTENDS_CLAUSE 385 * @see #OBJBLOCK 386 **/ 387 public static final int INTERFACE_DEF = 388 GeneratedJavaTokenTypes.INTERFACE_DEF; 389 390 /** 391 * The package declaration. This is optional, but if it is 392 * included, then there is only one package declaration per source 393 * file and it must be the first non-comment in the file. A package 394 * declaration may be annotated in which case the annotations comes 395 * before the rest of the declaration (and are the first children). 396 * 397 * <p>For example:</p> 398 * 399 * <pre> 400 * package com.puppycrawl.tools.checkstyle.api; 401 * </pre> 402 * 403 * <p>parses as:</p> 404 * 405 * <pre> 406 * +--PACKAGE_DEF (package) 407 * | 408 * +--ANNOTATIONS 409 * +--DOT (.) 410 * | 411 * +--DOT (.) 412 * | 413 * +--DOT (.) 414 * | 415 * +--DOT (.) 416 * | 417 * +--IDENT (com) 418 * +--IDENT (puppycrawl) 419 * +--IDENT (tools) 420 * +--IDENT (checkstyle) 421 * +--IDENT (api) 422 * +--SEMI (;) 423 * </pre> 424 * 425 * @see <a 426 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java 427 * Language Specification §7.4</a> 428 * @see #DOT 429 * @see #IDENT 430 * @see #SEMI 431 * @see #ANNOTATIONS 432 * @see FullIdent 433 **/ 434 public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF; 435 /** 436 * An array declaration. 437 * 438 * <p>If the array declaration represents a type, then the type of 439 * the array elements is the first child. Multidimensional arrays 440 * may be regarded as arrays of arrays. In other words, the first 441 * child of the array declaration is another array 442 * declaration.</p> 443 * 444 * <p>For example:</p> 445 * <pre> 446 * int[] x; 447 * </pre> 448 * <p>parses as:</p> 449 * <pre> 450 * +--VARIABLE_DEF 451 * | 452 * +--MODIFIERS 453 * +--TYPE 454 * | 455 * +--ARRAY_DECLARATOR ([) 456 * | 457 * +--LITERAL_INT (int) 458 * +--IDENT (x) 459 * +--SEMI (;) 460 * </pre> 461 * 462 * <p>The array declaration may also represent an inline array 463 * definition. In this case, the first child will be either an 464 * expression specifying the length of the array or an array 465 * initialization block.</p> 466 * 467 * @see <a 468 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java 469 * Language Specification §10</a> 470 * @see #TYPE 471 * @see #ARRAY_INIT 472 **/ 473 public static final int ARRAY_DECLARATOR = 474 GeneratedJavaTokenTypes.ARRAY_DECLARATOR; 475 476 /** 477 * An extends clause. This appear as part of class and interface 478 * definitions. This element appears even if the 479 * {@code extends} keyword is not explicitly used. The child 480 * is an optional identifier. 481 * 482 * <p>For example:</p> 483 * 484 * <pre> 485 * extends java.util.LinkedList 486 * </pre> 487 * 488 * <p>parses as:</p> 489 * <pre> 490 * +--EXTENDS_CLAUSE 491 * | 492 * +--DOT (.) 493 * | 494 * +--DOT (.) 495 * | 496 * +--IDENT (java) 497 * +--IDENT (util) 498 * +--IDENT (LinkedList) 499 * </pre> 500 * 501 * @see #IDENT 502 * @see #DOT 503 * @see #CLASS_DEF 504 * @see #INTERFACE_DEF 505 * @see FullIdent 506 **/ 507 public static final int EXTENDS_CLAUSE = 508 GeneratedJavaTokenTypes.EXTENDS_CLAUSE; 509 510 /** 511 * An implements clause. This always appears in a class or enum 512 * declaration, even if there are no implemented interfaces. The 513 * children are a comma separated list of zero or more 514 * identifiers. 515 * 516 * <p>For example:</p> 517 * <pre> 518 * implements Serializable, Comparable 519 * </pre> 520 * <p>parses as:</p> 521 * <pre> 522 * +--IMPLEMENTS_CLAUSE 523 * | 524 * +--IDENT (Serializable) 525 * +--COMMA (,) 526 * +--IDENT (Comparable) 527 * </pre> 528 * 529 * @see #IDENT 530 * @see #DOT 531 * @see #COMMA 532 * @see #CLASS_DEF 533 * @see #ENUM_DEF 534 **/ 535 public static final int IMPLEMENTS_CLAUSE = 536 GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE; 537 538 /** 539 * A list of parameters to a method or constructor. The children 540 * are zero or more parameter declarations separated by commas. 541 * 542 * <p>For example</p> 543 * <pre> 544 * int start, int end 545 * </pre> 546 * <p>parses as:</p> 547 * <pre> 548 * +--PARAMETERS 549 * | 550 * +--PARAMETER_DEF 551 * | 552 * +--MODIFIERS 553 * +--TYPE 554 * | 555 * +--LITERAL_INT (int) 556 * +--IDENT (start) 557 * +--COMMA (,) 558 * +--PARAMETER_DEF 559 * | 560 * +--MODIFIERS 561 * +--TYPE 562 * | 563 * +--LITERAL_INT (int) 564 * +--IDENT (end) 565 * </pre> 566 * 567 * @see #PARAMETER_DEF 568 * @see #COMMA 569 * @see #METHOD_DEF 570 * @see #CTOR_DEF 571 **/ 572 public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS; 573 /** 574 * A parameter declaration. The last parameter in a list of parameters may 575 * be variable length (indicated by the ELLIPSIS child node immediately 576 * after the TYPE child). 577 * 578 * @see #MODIFIERS 579 * @see #TYPE 580 * @see #IDENT 581 * @see #PARAMETERS 582 * @see #ELLIPSIS 583 **/ 584 public static final int PARAMETER_DEF = 585 GeneratedJavaTokenTypes.PARAMETER_DEF; 586 587 /** 588 * A labeled statement. 589 * 590 * <p>For example:</p> 591 * <pre> 592 * outside: ; 593 * </pre> 594 * <p>parses as:</p> 595 * <pre> 596 * +--LABELED_STAT (:) 597 * | 598 * +--IDENT (outside) 599 * +--EMPTY_STAT (;) 600 * </pre> 601 * 602 * @see <a 603 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java 604 * Language Specification, §14.7</a> 605 * @see #SLIST 606 **/ 607 public static final int LABELED_STAT = 608 GeneratedJavaTokenTypes.LABELED_STAT; 609 610 /** 611 * A type-cast. 612 * 613 * <p>For example:</p> 614 * <pre> 615 * (String)it.next() 616 * </pre> 617 * <p>parses as:</p> 618 * <pre> 619 * +--TYPECAST (() 620 * | 621 * +--TYPE 622 * | 623 * +--IDENT (String) 624 * +--RPAREN ()) 625 * +--METHOD_CALL (() 626 * | 627 * +--DOT (.) 628 * | 629 * +--IDENT (it) 630 * +--IDENT (next) 631 * +--ELIST 632 * +--RPAREN ()) 633 * </pre> 634 * @see <a 635 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java 636 * Language Specification, §15.16</a> 637 * @see #EXPR 638 * @see #TYPE 639 * @see #TYPE_ARGUMENTS 640 * @see #RPAREN 641 **/ 642 public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST; 643 /** 644 * The array index operator. 645 * 646 * <p>For example:</p> 647 * <pre> 648 * ar[2] = 5; 649 * </pre> 650 * <p>parses as:</p> 651 * <pre> 652 * +--EXPR 653 * | 654 * +--ASSIGN (=) 655 * | 656 * +--INDEX_OP ([) 657 * | 658 * +--IDENT (ar) 659 * +--EXPR 660 * | 661 * +--NUM_INT (2) 662 * +--NUM_INT (5) 663 * +--SEMI (;) 664 * </pre> 665 * 666 * @see #EXPR 667 **/ 668 public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP; 669 /** 670 * The {@code ++} (postfix increment) operator. 671 * 672 * @see <a 673 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java 674 * Language Specification, §15.14.1</a> 675 * @see #EXPR 676 * @see #INC 677 **/ 678 public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC; 679 /** 680 * The {@code --} (postfix decrement) operator. 681 * 682 * @see <a 683 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java 684 * Language Specification, §15.14.2</a> 685 * @see #EXPR 686 * @see #DEC 687 **/ 688 public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC; 689 /** 690 * A method call. A method call may have type arguments however these 691 * are attached to the appropriate node in the qualified method name. 692 * 693 * <p>For example:</p> 694 * <pre> 695 * Math.random() 696 * </pre> 697 * 698 * <p>parses as: 699 * <pre> 700 * +--METHOD_CALL (() 701 * | 702 * +--DOT (.) 703 * | 704 * +--IDENT (Math) 705 * +--IDENT (random) 706 * +--ELIST 707 * +--RPAREN ()) 708 * </pre> 709 * 710 * 711 * @see #IDENT 712 * @see #TYPE_ARGUMENTS 713 * @see #DOT 714 * @see #ELIST 715 * @see #RPAREN 716 * @see FullIdent 717 **/ 718 public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL; 719 720 /** 721 * A reference to a method or constructor without arguments. Part of Java 8 syntax. 722 * The token should be used for subscribing for double colon literal. 723 * {@link #DOUBLE_COLON} token does not appear in the tree. 724 * 725 * <p>For example:</p> 726 * <pre> 727 * String::compareToIgnoreCase 728 * </pre> 729 * 730 * <p>parses as: 731 * <pre> 732 * +--METHOD_REF (::) 733 * | 734 * +--IDENT (String) 735 * +--IDENT (compareToIgnoreCase) 736 * </pre> 737 * 738 * @see #IDENT 739 * @see #DOUBLE_COLON 740 */ 741 public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF; 742 /** 743 * An expression. Operators with lower precedence appear at a 744 * higher level in the tree than operators with higher precedence. 745 * Parentheses are siblings to the operator they enclose. 746 * 747 * <p>For example:</p> 748 * <pre> 749 * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3); 750 * </pre> 751 * <p>parses as:</p> 752 * <pre> 753 * +--EXPR 754 * | 755 * +--ASSIGN (=) 756 * | 757 * +--IDENT (x) 758 * +--PLUS (+) 759 * | 760 * +--PLUS (+) 761 * | 762 * +--PLUS (+) 763 * | 764 * +--PLUS (+) 765 * | 766 * +--NUM_INT (4) 767 * +--STAR (*) 768 * | 769 * +--NUM_INT (3) 770 * +--NUM_INT (5) 771 * +--DIV (/) 772 * | 773 * +--LPAREN (() 774 * +--PLUS (+) 775 * | 776 * +--NUM_INT (30) 777 * +--NUM_INT (26) 778 * +--RPAREN ()) 779 * +--NUM_INT (4) 780 * +--MOD (%) 781 * | 782 * +--NUM_INT (5) 783 * +--NUM_INT (4) 784 * +--LPAREN (() 785 * +--SL (<<) 786 * | 787 * +--NUM_INT (1) 788 * +--NUM_INT (3) 789 * +--RPAREN ()) 790 * +--SEMI (;) 791 * </pre> 792 * 793 * @see #ELIST 794 * @see #ASSIGN 795 * @see #LPAREN 796 * @see #RPAREN 797 **/ 798 public static final int EXPR = GeneratedJavaTokenTypes.EXPR; 799 /** 800 * An array initialization. This may occur as part of an array 801 * declaration or inline with {@code new}. 802 * 803 * <p>For example:</p> 804 * <pre> 805 * int[] y = 806 * { 807 * 1, 808 * 2, 809 * }; 810 * </pre> 811 * <p>parses as:</p> 812 * <pre> 813 * +--VARIABLE_DEF 814 * | 815 * +--MODIFIERS 816 * +--TYPE 817 * | 818 * +--ARRAY_DECLARATOR ([) 819 * | 820 * +--LITERAL_INT (int) 821 * +--IDENT (y) 822 * +--ASSIGN (=) 823 * | 824 * +--ARRAY_INIT ({) 825 * | 826 * +--EXPR 827 * | 828 * +--NUM_INT (1) 829 * +--COMMA (,) 830 * +--EXPR 831 * | 832 * +--NUM_INT (2) 833 * +--COMMA (,) 834 * +--RCURLY (}) 835 * +--SEMI (;) 836 * </pre> 837 * 838 * <p>Also consider:</p> 839 * <pre> 840 * int[] z = new int[] 841 * { 842 * 1, 843 * 2, 844 * }; 845 * </pre> 846 * <p>which parses as:</p> 847 * <pre> 848 * +--VARIABLE_DEF 849 * | 850 * +--MODIFIERS 851 * +--TYPE 852 * | 853 * +--ARRAY_DECLARATOR ([) 854 * | 855 * +--LITERAL_INT (int) 856 * +--IDENT (z) 857 * +--ASSIGN (=) 858 * | 859 * +--EXPR 860 * | 861 * +--LITERAL_NEW (new) 862 * | 863 * +--LITERAL_INT (int) 864 * +--ARRAY_DECLARATOR ([) 865 * +--ARRAY_INIT ({) 866 * | 867 * +--EXPR 868 * | 869 * +--NUM_INT (1) 870 * +--COMMA (,) 871 * +--EXPR 872 * | 873 * +--NUM_INT (2) 874 * +--COMMA (,) 875 * +--RCURLY (}) 876 * </pre> 877 * 878 * @see #ARRAY_DECLARATOR 879 * @see #TYPE 880 * @see #LITERAL_NEW 881 * @see #COMMA 882 **/ 883 public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT; 884 /** 885 * An import declaration. Import declarations are option, but 886 * must appear after the package declaration and before the first type 887 * declaration. 888 * 889 * <p>For example:</p> 890 * 891 * <pre> 892 * import java.io.IOException; 893 * </pre> 894 * 895 * <p>parses as:</p> 896 * 897 * <pre> 898 * +--IMPORT (import) 899 * | 900 * +--DOT (.) 901 * | 902 * +--DOT (.) 903 * | 904 * +--IDENT (java) 905 * +--IDENT (io) 906 * +--IDENT (IOException) 907 * +--SEMI (;) 908 * </pre> 909 * 910 * @see <a 911 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java 912 * Language Specification §7.5</a> 913 * @see #DOT 914 * @see #IDENT 915 * @see #STAR 916 * @see #SEMI 917 * @see FullIdent 918 **/ 919 public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT; 920 /** 921 * The {@code -} (unary minus) operator. 922 * 923 * @see <a 924 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java 925 * Language Specification, §15.15.4</a> 926 * @see #EXPR 927 **/ 928 public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS; 929 /** 930 * The {@code +} (unary plus) operator. 931 * 932 * @see <a 933 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java 934 * Language Specification, §15.15.3</a> 935 * @see #EXPR 936 **/ 937 public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS; 938 /** 939 * A group of case clauses. Case clauses with no associated 940 * statements are grouped together into a case group. The last 941 * child is a statement list containing the statements to execute 942 * upon a match. 943 * 944 * <p>For example:</p> 945 * <pre> 946 * case 0: 947 * case 1: 948 * case 2: 949 * x = 3; 950 * break; 951 * </pre> 952 * <p>parses as:</p> 953 * <pre> 954 * +--CASE_GROUP 955 * | 956 * +--LITERAL_CASE (case) 957 * | 958 * +--EXPR 959 * | 960 * +--NUM_INT (0) 961 * +--LITERAL_CASE (case) 962 * | 963 * +--EXPR 964 * | 965 * +--NUM_INT (1) 966 * +--LITERAL_CASE (case) 967 * | 968 * +--EXPR 969 * | 970 * +--NUM_INT (2) 971 * +--SLIST 972 * | 973 * +--EXPR 974 * | 975 * +--ASSIGN (=) 976 * | 977 * +--IDENT (x) 978 * +--NUM_INT (3) 979 * +--SEMI (;) 980 * +--LITERAL_BREAK (break) 981 * | 982 * +--SEMI (;) 983 * </pre> 984 * 985 * @see #LITERAL_CASE 986 * @see #LITERAL_DEFAULT 987 * @see #LITERAL_SWITCH 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 * @noinspection HtmlTagCanBeJavadocTag 1365 **/ 1366 public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY; 1367 /** 1368 * A right curly brace (<code>}</code>). 1369 * 1370 * @see #OBJBLOCK 1371 * @see #ARRAY_INIT 1372 * @see #SLIST 1373 * @noinspection HtmlTagCanBeJavadocTag 1374 **/ 1375 public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY; 1376 /** 1377 * The {@code ,} (comma) operator. 1378 * 1379 * @see #ARRAY_INIT 1380 * @see #FOR_INIT 1381 * @see #FOR_ITERATOR 1382 * @see #LITERAL_THROWS 1383 * @see #IMPLEMENTS_CLAUSE 1384 **/ 1385 public static final int COMMA = GeneratedJavaTokenTypes.COMMA; 1386 1387 /** 1388 * A left parenthesis ({@code (}). 1389 * 1390 * @see #LITERAL_FOR 1391 * @see #LITERAL_NEW 1392 * @see #EXPR 1393 * @see #LITERAL_SWITCH 1394 * @see #LITERAL_CATCH 1395 **/ 1396 public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN; 1397 /** 1398 * A right parenthesis ({@code )}). 1399 * 1400 * @see #LITERAL_FOR 1401 * @see #LITERAL_NEW 1402 * @see #METHOD_CALL 1403 * @see #TYPECAST 1404 * @see #EXPR 1405 * @see #LITERAL_SWITCH 1406 * @see #LITERAL_CATCH 1407 **/ 1408 public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN; 1409 /** 1410 * The {@code this} keyword. 1411 * 1412 * @see #EXPR 1413 * @see #CTOR_CALL 1414 **/ 1415 public static final int LITERAL_THIS = 1416 GeneratedJavaTokenTypes.LITERAL_this; 1417 1418 /** 1419 * The {@code super} keyword. 1420 * 1421 * @see #EXPR 1422 * @see #SUPER_CTOR_CALL 1423 **/ 1424 public static final int LITERAL_SUPER = 1425 GeneratedJavaTokenTypes.LITERAL_super; 1426 1427 /** 1428 * The {@code =} (assignment) operator. 1429 * 1430 * @see <a 1431 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java 1432 * Language Specification, §15.26.1</a> 1433 * @see #EXPR 1434 **/ 1435 public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN; 1436 /** 1437 * The {@code throws} keyword. The children are a number of 1438 * one or more identifiers separated by commas. 1439 * 1440 * @see <a 1441 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java 1442 * Language Specification, §8.4.4</a> 1443 * @see #IDENT 1444 * @see #DOT 1445 * @see #COMMA 1446 * @see #METHOD_DEF 1447 * @see #CTOR_DEF 1448 * @see FullIdent 1449 **/ 1450 public static final int LITERAL_THROWS = 1451 GeneratedJavaTokenTypes.LITERAL_throws; 1452 1453 /** 1454 * The {@code :} (colon) operator. This will appear as part 1455 * of the conditional operator ({@code ? :}). 1456 * 1457 * @see #QUESTION 1458 * @see #LABELED_STAT 1459 * @see #CASE_GROUP 1460 **/ 1461 public static final int COLON = GeneratedJavaTokenTypes.COLON; 1462 1463 /** 1464 * The {@code ::} (double colon) separator. 1465 * It is part of Java 8 syntax that is used for method reference. 1466 * The token does not appear in tree, {@link #METHOD_REF} should be used instead. 1467 * 1468 * @see #METHOD_REF 1469 */ 1470 public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON; 1471 /** 1472 * The {@code if} keyword. 1473 * 1474 * <p>For example:</p> 1475 * <pre> 1476 * if(optimistic) 1477 * { 1478 * message = "half full"; 1479 * } 1480 * else 1481 * { 1482 * message = "half empty"; 1483 * } 1484 * </pre> 1485 * <p>parses as:</p> 1486 * <pre> 1487 * +--LITERAL_IF (if) 1488 * | 1489 * +--LPAREN (() 1490 * +--EXPR 1491 * | 1492 * +--IDENT (optimistic) 1493 * +--RPAREN ()) 1494 * +--SLIST ({) 1495 * | 1496 * +--EXPR 1497 * | 1498 * +--ASSIGN (=) 1499 * | 1500 * +--IDENT (message) 1501 * +--STRING_LITERAL ("half full") 1502 * +--SEMI (;) 1503 * +--RCURLY (}) 1504 * +--LITERAL_ELSE (else) 1505 * | 1506 * +--SLIST ({) 1507 * | 1508 * +--EXPR 1509 * | 1510 * +--ASSIGN (=) 1511 * | 1512 * +--IDENT (message) 1513 * +--STRING_LITERAL ("half empty") 1514 * +--SEMI (;) 1515 * +--RCURLY (}) 1516 * </pre> 1517 * 1518 * @see #LPAREN 1519 * @see #EXPR 1520 * @see #RPAREN 1521 * @see #SLIST 1522 * @see #EMPTY_STAT 1523 * @see #LITERAL_ELSE 1524 **/ 1525 public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if; 1526 /** 1527 * The {@code for} keyword. The children are {@code (}, 1528 * an initializer, a condition, an iterator, a {@code )} and 1529 * either a statement list, a single expression, or an empty 1530 * statement. 1531 * 1532 * <p>For example:</p> 1533 * <pre> 1534 * for(int i = 0, n = myArray.length; i < n; i++) 1535 * { 1536 * } 1537 * </pre> 1538 * 1539 * <p>parses as:</p> 1540 * <pre> 1541 * +--LITERAL_FOR (for) 1542 * | 1543 * +--LPAREN (() 1544 * +--FOR_INIT 1545 * | 1546 * +--VARIABLE_DEF 1547 * | 1548 * +--MODIFIERS 1549 * +--TYPE 1550 * | 1551 * +--LITERAL_INT (int) 1552 * +--IDENT (i) 1553 * +--ASSIGN (=) 1554 * | 1555 * +--EXPR 1556 * | 1557 * +--NUM_INT (0) 1558 * +--COMMA (,) 1559 * +--VARIABLE_DEF 1560 * | 1561 * +--MODIFIERS 1562 * +--TYPE 1563 * | 1564 * +--LITERAL_INT (int) 1565 * +--IDENT (n) 1566 * +--ASSIGN (=) 1567 * | 1568 * +--EXPR 1569 * | 1570 * +--DOT (.) 1571 * | 1572 * +--IDENT (myArray) 1573 * +--IDENT (length) 1574 * +--SEMI (;) 1575 * +--FOR_CONDITION 1576 * | 1577 * +--EXPR 1578 * | 1579 * +--LT (<) 1580 * | 1581 * +--IDENT (i) 1582 * +--IDENT (n) 1583 * +--SEMI (;) 1584 * +--FOR_ITERATOR 1585 * | 1586 * +--ELIST 1587 * | 1588 * +--EXPR 1589 * | 1590 * +--POST_INC (++) 1591 * | 1592 * +--IDENT (i) 1593 * +--RPAREN ()) 1594 * +--SLIST ({) 1595 * | 1596 * +--RCURLY (}) 1597 * </pre> 1598 * 1599 * @see #LPAREN 1600 * @see #FOR_INIT 1601 * @see #SEMI 1602 * @see #FOR_CONDITION 1603 * @see #FOR_ITERATOR 1604 * @see #RPAREN 1605 * @see #SLIST 1606 * @see #EMPTY_STAT 1607 * @see #EXPR 1608 **/ 1609 public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for; 1610 /** 1611 * The {@code while} keyword. 1612 * 1613 * <p>For example:</p> 1614 * <pre> 1615 * while(line != null) 1616 * { 1617 * process(line); 1618 * line = in.readLine(); 1619 * } 1620 * </pre> 1621 * <p>parses as:</p> 1622 * <pre> 1623 * +--LITERAL_WHILE (while) 1624 * | 1625 * +--LPAREN (() 1626 * +--EXPR 1627 * | 1628 * +--NOT_EQUAL (!=) 1629 * | 1630 * +--IDENT (line) 1631 * +--LITERAL_NULL (null) 1632 * +--RPAREN ()) 1633 * +--SLIST ({) 1634 * | 1635 * +--EXPR 1636 * | 1637 * +--METHOD_CALL (() 1638 * | 1639 * +--IDENT (process) 1640 * +--ELIST 1641 * | 1642 * +--EXPR 1643 * | 1644 * +--IDENT (line) 1645 * +--RPAREN ()) 1646 * +--SEMI (;) 1647 * +--EXPR 1648 * | 1649 * +--ASSIGN (=) 1650 * | 1651 * +--IDENT (line) 1652 * +--METHOD_CALL (() 1653 * | 1654 * +--DOT (.) 1655 * | 1656 * +--IDENT (in) 1657 * +--IDENT (readLine) 1658 * +--ELIST 1659 * +--RPAREN ()) 1660 * +--SEMI (;) 1661 * +--RCURLY (}) 1662 * </pre> 1663 **/ 1664 public static final int LITERAL_WHILE = 1665 GeneratedJavaTokenTypes.LITERAL_while; 1666 1667 /** 1668 * The {@code do} keyword. Note the the while token does not 1669 * appear as part of the do-while construct. 1670 * 1671 * <p>For example:</p> 1672 * <pre> 1673 * do 1674 * { 1675 * x = rand.nextInt(10); 1676 * } 1677 * while(x < 5); 1678 * </pre> 1679 * <p>parses as:</p> 1680 * <pre> 1681 * +--LITERAL_DO (do) 1682 * | 1683 * +--SLIST ({) 1684 * | 1685 * +--EXPR 1686 * | 1687 * +--ASSIGN (=) 1688 * | 1689 * +--IDENT (x) 1690 * +--METHOD_CALL (() 1691 * | 1692 * +--DOT (.) 1693 * | 1694 * +--IDENT (rand) 1695 * +--IDENT (nextInt) 1696 * +--ELIST 1697 * | 1698 * +--EXPR 1699 * | 1700 * +--NUM_INT (10) 1701 * +--RPAREN ()) 1702 * +--SEMI (;) 1703 * +--RCURLY (}) 1704 * +--DO_WHILE (while) 1705 * +--LPAREN (() 1706 * +--EXPR 1707 * | 1708 * +--LT (<) 1709 * | 1710 * +--IDENT (x) 1711 * +--NUM_INT (5) 1712 * +--RPAREN ()) 1713 * +--SEMI (;) 1714 * </pre> 1715 * 1716 * @see #SLIST 1717 * @see #EXPR 1718 * @see #EMPTY_STAT 1719 * @see #LPAREN 1720 * @see #RPAREN 1721 * @see #SEMI 1722 **/ 1723 public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do; 1724 /** 1725 * Literal {@code while} in do-while loop. 1726 * @see #LITERAL_DO 1727 */ 1728 public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE; 1729 /** 1730 * The {@code break} keyword. The first child is an optional 1731 * identifier and the last child is a semicolon. 1732 * 1733 * @see #IDENT 1734 * @see #SEMI 1735 * @see #SLIST 1736 **/ 1737 public static final int LITERAL_BREAK = 1738 GeneratedJavaTokenTypes.LITERAL_break; 1739 1740 /** 1741 * The {@code continue} keyword. The first child is an 1742 * optional identifier and the last child is a semicolon. 1743 * 1744 * @see #IDENT 1745 * @see #SEMI 1746 * @see #SLIST 1747 **/ 1748 public static final int LITERAL_CONTINUE = 1749 GeneratedJavaTokenTypes.LITERAL_continue; 1750 1751 /** 1752 * The {@code return} keyword. The first child is an 1753 * optional expression for the return value. The last child is a 1754 * semi colon. 1755 * 1756 * @see #EXPR 1757 * @see #SEMI 1758 * @see #SLIST 1759 **/ 1760 public static final int LITERAL_RETURN = 1761 GeneratedJavaTokenTypes.LITERAL_return; 1762 1763 /** 1764 * The {@code switch} keyword. 1765 * 1766 * <p>For example:</p> 1767 * <pre> 1768 * switch(type) 1769 * { 1770 * case 0: 1771 * background = Color.blue; 1772 * break; 1773 * case 1: 1774 * background = Color.red; 1775 * break; 1776 * default: 1777 * background = Color.green; 1778 * break; 1779 * } 1780 * </pre> 1781 * <p>parses as:</p> 1782 * <pre> 1783 * +--LITERAL_SWITCH (switch) 1784 * | 1785 * +--LPAREN (() 1786 * +--EXPR 1787 * | 1788 * +--IDENT (type) 1789 * +--RPAREN ()) 1790 * +--LCURLY ({) 1791 * +--CASE_GROUP 1792 * | 1793 * +--LITERAL_CASE (case) 1794 * | 1795 * +--EXPR 1796 * | 1797 * +--NUM_INT (0) 1798 * +--SLIST 1799 * | 1800 * +--EXPR 1801 * | 1802 * +--ASSIGN (=) 1803 * | 1804 * +--IDENT (background) 1805 * +--DOT (.) 1806 * | 1807 * +--IDENT (Color) 1808 * +--IDENT (blue) 1809 * +--SEMI (;) 1810 * +--LITERAL_BREAK (break) 1811 * | 1812 * +--SEMI (;) 1813 * +--CASE_GROUP 1814 * | 1815 * +--LITERAL_CASE (case) 1816 * | 1817 * +--EXPR 1818 * | 1819 * +--NUM_INT (1) 1820 * +--SLIST 1821 * | 1822 * +--EXPR 1823 * | 1824 * +--ASSIGN (=) 1825 * | 1826 * +--IDENT (background) 1827 * +--DOT (.) 1828 * | 1829 * +--IDENT (Color) 1830 * +--IDENT (red) 1831 * +--SEMI (;) 1832 * +--LITERAL_BREAK (break) 1833 * | 1834 * +--SEMI (;) 1835 * +--CASE_GROUP 1836 * | 1837 * +--LITERAL_DEFAULT (default) 1838 * +--SLIST 1839 * | 1840 * +--EXPR 1841 * | 1842 * +--ASSIGN (=) 1843 * | 1844 * +--IDENT (background) 1845 * +--DOT (.) 1846 * | 1847 * +--IDENT (Color) 1848 * +--IDENT (green) 1849 * +--SEMI (;) 1850 * +--LITERAL_BREAK (break) 1851 * | 1852 * +--SEMI (;) 1853 * +--RCURLY (}) 1854 * </pre> 1855 * 1856 * @see <a 1857 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 1858 * Language Specification, §14.10</a> 1859 * @see #LPAREN 1860 * @see #EXPR 1861 * @see #RPAREN 1862 * @see #LCURLY 1863 * @see #CASE_GROUP 1864 * @see #RCURLY 1865 * @see #SLIST 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 **/ 1912 public static final int LITERAL_DEFAULT = 1913 GeneratedJavaTokenTypes.LITERAL_default; 1914 1915 /** 1916 * The {@code try} keyword. The children are a statement 1917 * list, zero or more catch blocks and then an optional finally 1918 * block. 1919 * 1920 * <p>For example:</p> 1921 * <pre> 1922 * try 1923 * { 1924 * FileReader in = new FileReader("abc.txt"); 1925 * } 1926 * catch(IOException ioe) 1927 * { 1928 * } 1929 * finally 1930 * { 1931 * } 1932 * </pre> 1933 * <p>parses as:</p> 1934 * <pre> 1935 * +--LITERAL_TRY (try) 1936 * | 1937 * +--SLIST ({) 1938 * | 1939 * +--VARIABLE_DEF 1940 * | 1941 * +--MODIFIERS 1942 * +--TYPE 1943 * | 1944 * +--IDENT (FileReader) 1945 * +--IDENT (in) 1946 * +--ASSIGN (=) 1947 * | 1948 * +--EXPR 1949 * | 1950 * +--LITERAL_NEW (new) 1951 * | 1952 * +--IDENT (FileReader) 1953 * +--LPAREN (() 1954 * +--ELIST 1955 * | 1956 * +--EXPR 1957 * | 1958 * +--STRING_LITERAL ("abc.txt") 1959 * +--RPAREN ()) 1960 * +--SEMI (;) 1961 * +--RCURLY (}) 1962 * +--LITERAL_CATCH (catch) 1963 * | 1964 * +--LPAREN (() 1965 * +--PARAMETER_DEF 1966 * | 1967 * +--MODIFIERS 1968 * +--TYPE 1969 * | 1970 * +--IDENT (IOException) 1971 * +--IDENT (ioe) 1972 * +--RPAREN ()) 1973 * +--SLIST ({) 1974 * | 1975 * +--RCURLY (}) 1976 * +--LITERAL_FINALLY (finally) 1977 * | 1978 * +--SLIST ({) 1979 * | 1980 * +--RCURLY (}) 1981 * +--RCURLY (}) 1982 * </pre> 1983 * 1984 * @see <a 1985 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 1986 * Language Specification, §14.19</a> 1987 * @see #SLIST 1988 * @see #LITERAL_CATCH 1989 * @see #LITERAL_FINALLY 1990 **/ 1991 public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try; 1992 1993 /** 1994 * The Java 7 try-with-resources construct. 1995 * 1996 * <p>For example:</p> 1997 * <pre> 1998 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 1999 * </pre> 2000 * <p>parses as:</p> 2001 * <pre> 2002 * +--LITERAL_TRY (try) 2003 * | 2004 * +--RESOURCE_SPECIFICATION 2005 * | 2006 * +--LPAREN (() 2007 * +--RESOURCES 2008 * | 2009 * +--RESOURCE 2010 * | 2011 * +--MODIFIERS 2012 * +--TYPE 2013 * | 2014 * +--IDENT (Foo) 2015 * +--IDENT (foo) 2016 * +--ASSIGN (=) 2017 * +--EXPR 2018 * | 2019 * +--LITERAL_NEW (new) 2020 * | 2021 * +--IDENT (Foo) 2022 * +--LPAREN (() 2023 * +--ELIST 2024 * +--RPAREN ()) 2025 * +--SEMI (;) 2026 * +--RESOURCE 2027 * | 2028 * +--MODIFIERS 2029 * +--TYPE 2030 * | 2031 * +--IDENT (Bar) 2032 * +--IDENT (bar) 2033 * +--ASSIGN (=) 2034 * +--EXPR 2035 * | 2036 * +--LITERAL_NEW (new) 2037 * | 2038 * +--IDENT (Bar) 2039 * +--LPAREN (() 2040 * +--ELIST 2041 * +--RPAREN ()) 2042 * +--RPAREN ()) 2043 * +--SLIST ({) 2044 * +--RCURLY (}) 2045 * </pre> 2046 * 2047 * <p>Also consider:</p> 2048 * <pre> 2049 * try (BufferedReader br = new BufferedReader(new FileReader(path))) 2050 * { 2051 * return br.readLine(); 2052 * } 2053 * </pre> 2054 * <p>which parses as:</p> 2055 * <pre> 2056 * +--LITERAL_TRY (try) 2057 * | 2058 * +--RESOURCE_SPECIFICATION 2059 * | 2060 * +--LPAREN (() 2061 * +--RESOURCES 2062 * | 2063 * +--RESOURCE 2064 * | 2065 * +--MODIFIERS 2066 * +--TYPE 2067 * | 2068 * +--IDENT (BufferedReader) 2069 * +--IDENT (br) 2070 * +--ASSIGN (=) 2071 * +--EXPR 2072 * | 2073 * +--LITERAL_NEW (new) 2074 * | 2075 * +--IDENT (FileReader) 2076 * +--LPAREN (() 2077 * +--ELIST 2078 * | 2079 * +--EXPR 2080 * | 2081 * +--LITERAL_NEW (new) 2082 * | 2083 * +--IDENT (BufferedReader) 2084 * +--LPAREN (() 2085 * +--ELIST 2086 * | 2087 * +--EXPR 2088 * | 2089 * +--IDENT (path) 2090 * +--RPAREN ()) 2091 * +--RPAREN ()) 2092 * +--RPAREN ()) 2093 * +--SLIST ({) 2094 * | 2095 * +--LITERAL_RETURN (return) 2096 * | 2097 * +--EXPR 2098 * | 2099 * +--METHOD_CALL (() 2100 * | 2101 * +--DOT (.) 2102 * | 2103 * +--IDENT (br) 2104 * +--IDENT (readLine) 2105 * +--ELIST 2106 * +--RPAREN ()) 2107 * +--SEMI (;) 2108 * +--RCURLY (}) 2109 * </pre> 2110 * 2111 * @see #LPAREN 2112 * @see #RESOURCES 2113 * @see #RESOURCE 2114 * @see #SEMI 2115 * @see #RPAREN 2116 * @see #LITERAL_TRY 2117 **/ 2118 public static final int RESOURCE_SPECIFICATION = 2119 GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION; 2120 2121 /** 2122 * A list of resources in the Java 7 try-with-resources construct. 2123 * This is a child of RESOURCE_SPECIFICATION. 2124 * 2125 * @see #RESOURCE_SPECIFICATION 2126 **/ 2127 public static final int RESOURCES = 2128 GeneratedJavaTokenTypes.RESOURCES; 2129 2130 /** 2131 * A resource in the Java 7 try-with-resources construct. 2132 * This is a child of RESOURCES. 2133 * 2134 * @see #RESOURCES 2135 * @see #RESOURCE_SPECIFICATION 2136 **/ 2137 public static final int RESOURCE = 2138 GeneratedJavaTokenTypes.RESOURCE; 2139 2140 /** 2141 * The {@code catch} keyword. 2142 * 2143 * @see #LPAREN 2144 * @see #PARAMETER_DEF 2145 * @see #RPAREN 2146 * @see #SLIST 2147 * @see #LITERAL_TRY 2148 **/ 2149 public static final int LITERAL_CATCH = 2150 GeneratedJavaTokenTypes.LITERAL_catch; 2151 2152 /** 2153 * The {@code finally} keyword. 2154 * 2155 * @see #SLIST 2156 * @see #LITERAL_TRY 2157 **/ 2158 public static final int LITERAL_FINALLY = 2159 GeneratedJavaTokenTypes.LITERAL_finally; 2160 2161 /** 2162 * The {@code +=} (addition assignment) operator. 2163 * 2164 * @see <a 2165 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2166 * Language Specification, §15.26.2</a> 2167 * @see #EXPR 2168 **/ 2169 public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN; 2170 /** 2171 * The {@code -=} (subtraction assignment) operator. 2172 * 2173 * @see <a 2174 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2175 * Language Specification, §15.26.2</a> 2176 * @see #EXPR 2177 **/ 2178 public static final int MINUS_ASSIGN = 2179 GeneratedJavaTokenTypes.MINUS_ASSIGN; 2180 2181 /** 2182 * The {@code *=} (multiplication assignment) operator. 2183 * 2184 * @see <a 2185 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2186 * Language Specification, §15.26.2</a> 2187 * @see #EXPR 2188 **/ 2189 public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN; 2190 /** 2191 * The {@code /=} (division assignment) operator. 2192 * 2193 * @see <a 2194 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2195 * Language Specification, §15.26.2</a> 2196 * @see #EXPR 2197 **/ 2198 public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN; 2199 /** 2200 * The {@code %=} (remainder assignment) operator. 2201 * 2202 * @see <a 2203 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2204 * Language Specification, §15.26.2</a> 2205 * @see #EXPR 2206 **/ 2207 public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN; 2208 /** 2209 * The {@code >>=} (signed right shift assignment) 2210 * operator. 2211 * 2212 * @see <a 2213 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2214 * Language Specification, §15.26.2</a> 2215 * @see #EXPR 2216 **/ 2217 public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN; 2218 /** 2219 * The {@code >>>=} (unsigned right shift assignment) 2220 * operator. 2221 * 2222 * @see <a 2223 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2224 * Language Specification, §15.26.2</a> 2225 * @see #EXPR 2226 **/ 2227 public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN; 2228 /** 2229 * The {@code <<=} (left shift assignment) operator. 2230 * 2231 * @see <a 2232 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2233 * Language Specification, §15.26.2</a> 2234 * @see #EXPR 2235 **/ 2236 public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN; 2237 /** 2238 * The {@code &=} (bitwise AND assignment) operator. 2239 * 2240 * @see <a 2241 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2242 * Language Specification, §15.26.2</a> 2243 * @see #EXPR 2244 **/ 2245 public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN; 2246 /** 2247 * The {@code ^=} (bitwise exclusive OR assignment) operator. 2248 * 2249 * @see <a 2250 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2251 * Language Specification, §15.26.2</a> 2252 * @see #EXPR 2253 **/ 2254 public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN; 2255 /** 2256 * The {@code |=} (bitwise OR assignment) operator. 2257 * 2258 * @see <a 2259 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2260 * Language Specification, §15.26.2</a> 2261 * @see #EXPR 2262 **/ 2263 public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN; 2264 /** 2265 * The <code>?</code> (conditional) operator. Technically, 2266 * the colon is also part of this operator, but it appears as a 2267 * separate token. 2268 * 2269 * <p>For example:</p> 2270 * <pre> 2271 * (quantity == 1) ? "": "s" 2272 * </pre> 2273 * <p> 2274 * parses as: 2275 * </p> 2276 * <pre> 2277 * +--QUESTION (?) 2278 * | 2279 * +--LPAREN (() 2280 * +--EQUAL (==) 2281 * | 2282 * +--IDENT (quantity) 2283 * +--NUM_INT (1) 2284 * +--RPAREN ()) 2285 * +--STRING_LITERAL ("") 2286 * +--COLON (:) 2287 * +--STRING_LITERAL ("s") 2288 * </pre> 2289 * 2290 * @see <a 2291 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 2292 * Language Specification, §15.25</a> 2293 * @see #EXPR 2294 * @see #COLON 2295 * @noinspection HtmlTagCanBeJavadocTag 2296 **/ 2297 public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION; 2298 /** 2299 * The {@code ||} (conditional OR) operator. 2300 * 2301 * @see <a 2302 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java 2303 * Language Specification, §15.24</a> 2304 * @see #EXPR 2305 **/ 2306 public static final int LOR = GeneratedJavaTokenTypes.LOR; 2307 /** 2308 * The {@code &&} (conditional AND) operator. 2309 * 2310 * @see <a 2311 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java 2312 * Language Specification, §15.23</a> 2313 * @see #EXPR 2314 **/ 2315 public static final int LAND = GeneratedJavaTokenTypes.LAND; 2316 /** 2317 * The {@code |} (bitwise OR) operator. 2318 * 2319 * @see <a 2320 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2321 * Language Specification, §15.22.1</a> 2322 * @see #EXPR 2323 **/ 2324 public static final int BOR = GeneratedJavaTokenTypes.BOR; 2325 /** 2326 * The {@code ^} (bitwise exclusive OR) operator. 2327 * 2328 * @see <a 2329 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2330 * Language Specification, §15.22.1</a> 2331 * @see #EXPR 2332 **/ 2333 public static final int BXOR = GeneratedJavaTokenTypes.BXOR; 2334 /** 2335 * The {@code &} (bitwise AND) operator. 2336 * 2337 * @see <a 2338 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java 2339 * Language Specification, §15.22.1</a> 2340 * @see #EXPR 2341 **/ 2342 public static final int BAND = GeneratedJavaTokenTypes.BAND; 2343 /** 2344 * The <code>!=</code> (not equal) operator. 2345 * 2346 * @see #EXPR 2347 * @noinspection HtmlTagCanBeJavadocTag 2348 **/ 2349 public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL; 2350 /** 2351 * The {@code ==} (equal) operator. 2352 * 2353 * @see #EXPR 2354 **/ 2355 public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL; 2356 /** 2357 * The {@code <} (less than) operator. 2358 * 2359 * @see #EXPR 2360 **/ 2361 public static final int LT = GeneratedJavaTokenTypes.LT; 2362 /** 2363 * The {@code >} (greater than) operator. 2364 * 2365 * @see #EXPR 2366 **/ 2367 public static final int GT = GeneratedJavaTokenTypes.GT; 2368 /** 2369 * The {@code <=} (less than or equal) operator. 2370 * 2371 * @see #EXPR 2372 **/ 2373 public static final int LE = GeneratedJavaTokenTypes.LE; 2374 /** 2375 * The {@code >=} (greater than or equal) operator. 2376 * 2377 * @see #EXPR 2378 **/ 2379 public static final int GE = GeneratedJavaTokenTypes.GE; 2380 /** 2381 * The {@code instanceof} operator. The first child is an 2382 * object reference or something that evaluates to an object 2383 * reference. The second child is a reference type. 2384 * 2385 * @see <a 2386 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 2387 * Language Specification, §15.20.2</a> 2388 * @see #EXPR 2389 * @see #METHOD_CALL 2390 * @see #IDENT 2391 * @see #DOT 2392 * @see #TYPE 2393 * @see FullIdent 2394 **/ 2395 public static final int LITERAL_INSTANCEOF = 2396 GeneratedJavaTokenTypes.LITERAL_instanceof; 2397 2398 /** 2399 * The {@code <<} (shift left) operator. 2400 * 2401 * @see <a 2402 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2403 * Language Specification, §15.19</a> 2404 * @see #EXPR 2405 **/ 2406 public static final int SL = GeneratedJavaTokenTypes.SL; 2407 /** 2408 * The {@code >>} (signed shift right) operator. 2409 * 2410 * @see <a 2411 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2412 * Language Specification, §15.19</a> 2413 * @see #EXPR 2414 **/ 2415 public static final int SR = GeneratedJavaTokenTypes.SR; 2416 /** 2417 * The {@code >>>} (unsigned shift right) operator. 2418 * 2419 * @see <a 2420 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2421 * Language Specification, §15.19</a> 2422 * @see #EXPR 2423 **/ 2424 public static final int BSR = GeneratedJavaTokenTypes.BSR; 2425 /** 2426 * The {@code +} (addition) operator. 2427 * 2428 * @see <a 2429 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2430 * Language Specification, §15.18</a> 2431 * @see #EXPR 2432 **/ 2433 public static final int PLUS = GeneratedJavaTokenTypes.PLUS; 2434 /** 2435 * The {@code -} (subtraction) operator. 2436 * 2437 * @see <a 2438 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2439 * Language Specification, §15.18</a> 2440 * @see #EXPR 2441 **/ 2442 public static final int MINUS = GeneratedJavaTokenTypes.MINUS; 2443 /** 2444 * The {@code /} (division) operator. 2445 * 2446 * @see <a 2447 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 2448 * Language Specification, §15.17.2</a> 2449 * @see #EXPR 2450 **/ 2451 public static final int DIV = GeneratedJavaTokenTypes.DIV; 2452 /** 2453 * The {@code %} (remainder) operator. 2454 * 2455 * @see <a 2456 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 2457 * Language Specification, §15.17.3</a> 2458 * @see #EXPR 2459 **/ 2460 public static final int MOD = GeneratedJavaTokenTypes.MOD; 2461 /** 2462 * The {@code ++} (prefix increment) operator. 2463 * 2464 * @see <a 2465 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 2466 * Language Specification, §15.15.1</a> 2467 * @see #EXPR 2468 * @see #POST_INC 2469 **/ 2470 public static final int INC = GeneratedJavaTokenTypes.INC; 2471 /** 2472 * The {@code --} (prefix decrement) operator. 2473 * 2474 * @see <a 2475 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 2476 * Language Specification, §15.15.2</a> 2477 * @see #EXPR 2478 * @see #POST_DEC 2479 **/ 2480 public static final int DEC = GeneratedJavaTokenTypes.DEC; 2481 /** 2482 * The {@code ~} (bitwise complement) operator. 2483 * 2484 * @see <a 2485 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 2486 * Language Specification, §15.15.5</a> 2487 * @see #EXPR 2488 **/ 2489 public static final int BNOT = GeneratedJavaTokenTypes.BNOT; 2490 /** 2491 * The <code>!</code> (logical complement) operator. 2492 * 2493 * @see <a 2494 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 2495 * Language Specification, §15.15.6</a> 2496 * @see #EXPR 2497 * @noinspection HtmlTagCanBeJavadocTag 2498 **/ 2499 public static final int LNOT = GeneratedJavaTokenTypes.LNOT; 2500 /** 2501 * The {@code true} keyword. 2502 * 2503 * @see <a 2504 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2505 * Language Specification, §3.10.3</a> 2506 * @see #EXPR 2507 * @see #LITERAL_FALSE 2508 **/ 2509 public static final int LITERAL_TRUE = 2510 GeneratedJavaTokenTypes.LITERAL_true; 2511 2512 /** 2513 * The {@code false} keyword. 2514 * 2515 * @see <a 2516 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java 2517 * Language Specification, §3.10.3</a> 2518 * @see #EXPR 2519 * @see #LITERAL_TRUE 2520 **/ 2521 public static final int LITERAL_FALSE = 2522 GeneratedJavaTokenTypes.LITERAL_false; 2523 2524 /** 2525 * The {@code null} keyword. 2526 * 2527 * @see <a 2528 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java 2529 * Language Specification, §3.10.7</a> 2530 * @see #EXPR 2531 **/ 2532 public static final int LITERAL_NULL = 2533 GeneratedJavaTokenTypes.LITERAL_null; 2534 2535 /** 2536 * The {@code new} keyword. This element is used to define 2537 * new instances of objects, new arrays, and new anonymous inner 2538 * classes. 2539 * 2540 * <p>For example:</p> 2541 * 2542 * <pre> 2543 * new ArrayList(50) 2544 * </pre> 2545 * 2546 * <p>parses as:</p> 2547 * <pre> 2548 * +--LITERAL_NEW (new) 2549 * | 2550 * +--IDENT (ArrayList) 2551 * +--LPAREN (() 2552 * +--ELIST 2553 * | 2554 * +--EXPR 2555 * | 2556 * +--NUM_INT (50) 2557 * +--RPAREN ()) 2558 * </pre> 2559 * 2560 * <p>For example:</p> 2561 * <pre> 2562 * new float[] 2563 * { 2564 * 3.0f, 2565 * 4.0f 2566 * }; 2567 * </pre> 2568 * 2569 * <p>parses as:</p> 2570 * <pre> 2571 * +--LITERAL_NEW (new) 2572 * | 2573 * +--LITERAL_FLOAT (float) 2574 * +--ARRAY_DECLARATOR ([) 2575 * +--ARRAY_INIT ({) 2576 * | 2577 * +--EXPR 2578 * | 2579 * +--NUM_FLOAT (3.0f) 2580 * +--COMMA (,) 2581 * +--EXPR 2582 * | 2583 * +--NUM_FLOAT (4.0f) 2584 * +--RCURLY (}) 2585 * </pre> 2586 * 2587 * <p>For example:</p> 2588 * <pre> 2589 * new FilenameFilter() 2590 * { 2591 * public boolean accept(File dir, String name) 2592 * { 2593 * return name.endsWith(".java"); 2594 * } 2595 * } 2596 * </pre> 2597 * 2598 * <p>parses as:</p> 2599 * <pre> 2600 * +--LITERAL_NEW (new) 2601 * | 2602 * +--IDENT (FilenameFilter) 2603 * +--LPAREN (() 2604 * +--ELIST 2605 * +--RPAREN ()) 2606 * +--OBJBLOCK 2607 * | 2608 * +--LCURLY ({) 2609 * +--METHOD_DEF 2610 * | 2611 * +--MODIFIERS 2612 * | 2613 * +--LITERAL_PUBLIC (public) 2614 * +--TYPE 2615 * | 2616 * +--LITERAL_BOOLEAN (boolean) 2617 * +--IDENT (accept) 2618 * +--PARAMETERS 2619 * | 2620 * +--PARAMETER_DEF 2621 * | 2622 * +--MODIFIERS 2623 * +--TYPE 2624 * | 2625 * +--IDENT (File) 2626 * +--IDENT (dir) 2627 * +--COMMA (,) 2628 * +--PARAMETER_DEF 2629 * | 2630 * +--MODIFIERS 2631 * +--TYPE 2632 * | 2633 * +--IDENT (String) 2634 * +--IDENT (name) 2635 * +--SLIST ({) 2636 * | 2637 * +--LITERAL_RETURN (return) 2638 * | 2639 * +--EXPR 2640 * | 2641 * +--METHOD_CALL (() 2642 * | 2643 * +--DOT (.) 2644 * | 2645 * +--IDENT (name) 2646 * +--IDENT (endsWith) 2647 * +--ELIST 2648 * | 2649 * +--EXPR 2650 * | 2651 * +--STRING_LITERAL (".java") 2652 * +--RPAREN ()) 2653 * +--SEMI (;) 2654 * +--RCURLY (}) 2655 * +--RCURLY (}) 2656 * </pre> 2657 * 2658 * @see #IDENT 2659 * @see #DOT 2660 * @see #LPAREN 2661 * @see #ELIST 2662 * @see #RPAREN 2663 * @see #OBJBLOCK 2664 * @see #ARRAY_INIT 2665 * @see FullIdent 2666 **/ 2667 public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new; 2668 /** 2669 * An integer literal. These may be specified in decimal, 2670 * hexadecimal, or octal form. 2671 * 2672 * @see <a 2673 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2674 * Language Specification, §3.10.1</a> 2675 * @see #EXPR 2676 * @see #NUM_LONG 2677 **/ 2678 public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT; 2679 /** 2680 * A character literal. This is a (possibly escaped) character 2681 * enclosed in single quotes. 2682 * 2683 * @see <a 2684 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java 2685 * Language Specification, §3.10.4</a> 2686 * @see #EXPR 2687 **/ 2688 public static final int CHAR_LITERAL = 2689 GeneratedJavaTokenTypes.CHAR_LITERAL; 2690 2691 /** 2692 * A string literal. This is a sequence of (possibly escaped) 2693 * characters enclosed in double quotes. 2694 * 2695 * @see <a 2696 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java 2697 * Language Specification, §3.10.5</a> 2698 * @see #EXPR 2699 **/ 2700 public static final int STRING_LITERAL = 2701 GeneratedJavaTokenTypes.STRING_LITERAL; 2702 2703 /** 2704 * A single precision floating point literal. This is a floating 2705 * point number with an {@code F} or {@code f} suffix. 2706 * 2707 * @see <a 2708 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2709 * Language Specification, §3.10.2</a> 2710 * @see #EXPR 2711 * @see #NUM_DOUBLE 2712 **/ 2713 public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT; 2714 /** 2715 * A long integer literal. These are almost the same as integer 2716 * literals, but they have an {@code L} or {@code l} 2717 * (ell) suffix. 2718 * 2719 * @see <a 2720 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java 2721 * Language Specification, §3.10.1</a> 2722 * @see #EXPR 2723 * @see #NUM_INT 2724 **/ 2725 public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG; 2726 /** 2727 * A double precision floating point literal. This is a floating 2728 * point number with an optional {@code D} or {@code d} 2729 * suffix. 2730 * 2731 * @see <a 2732 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java 2733 * Language Specification, §3.10.2</a> 2734 * @see #EXPR 2735 * @see #NUM_FLOAT 2736 **/ 2737 public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE; 2738 2739 /** 2740 * The {@code assert} keyword. This is only for Java 1.4 and 2741 * later. 2742 * 2743 * <p>For example:</p> 2744 * <pre> 2745 * assert(x==4); 2746 * </pre> 2747 * <p>parses as:</p> 2748 * <pre> 2749 * +--LITERAL_ASSERT (assert) 2750 * | 2751 * +--EXPR 2752 * | 2753 * +--LPAREN (() 2754 * +--EQUAL (==) 2755 * | 2756 * +--IDENT (x) 2757 * +--NUM_INT (4) 2758 * +--RPAREN ()) 2759 * +--SEMI (;) 2760 * </pre> 2761 **/ 2762 public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT; 2763 2764 /** 2765 * A static import declaration. Static import declarations are optional, 2766 * but must appear after the package declaration and before the type 2767 * declaration. 2768 * 2769 * <p>For example:</p> 2770 * 2771 * <pre> 2772 * import static java.io.IOException; 2773 * </pre> 2774 * 2775 * <p>parses as:</p> 2776 * 2777 * <pre> 2778 * +--STATIC_IMPORT (import) 2779 * | 2780 * +--LITERAL_STATIC 2781 * +--DOT (.) 2782 * | 2783 * +--DOT (.) 2784 * | 2785 * +--IDENT (java) 2786 * +--IDENT (io) 2787 * +--IDENT (IOException) 2788 * +--SEMI (;) 2789 * </pre> 2790 * 2791 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2792 * JSR201</a> 2793 * @see #LITERAL_STATIC 2794 * @see #DOT 2795 * @see #IDENT 2796 * @see #STAR 2797 * @see #SEMI 2798 * @see FullIdent 2799 **/ 2800 public static final int STATIC_IMPORT = 2801 GeneratedJavaTokenTypes.STATIC_IMPORT; 2802 2803 /** 2804 * An enum declaration. Its notable children are 2805 * enum constant declarations followed by 2806 * any construct that may be expected in a class body. 2807 * 2808 * <p>For example:</p> 2809 * <pre> 2810 * public enum MyEnum 2811 * implements Serializable 2812 * { 2813 * FIRST_CONSTANT, 2814 * SECOND_CONSTANT; 2815 * 2816 * public void someMethod() 2817 * { 2818 * } 2819 * } 2820 * </pre> 2821 * <p>parses as:</p> 2822 * <pre> 2823 * +--ENUM_DEF 2824 * | 2825 * +--MODIFIERS 2826 * | 2827 * +--LITERAL_PUBLIC (public) 2828 * +--ENUM (enum) 2829 * +--IDENT (MyEnum) 2830 * +--EXTENDS_CLAUSE 2831 * +--IMPLEMENTS_CLAUSE 2832 * | 2833 * +--IDENT (Serializable) 2834 * +--OBJBLOCK 2835 * | 2836 * +--LCURLY ({) 2837 * +--ENUM_CONSTANT_DEF 2838 * | 2839 * +--IDENT (FIRST_CONSTANT) 2840 * +--COMMA (,) 2841 * +--ENUM_CONSTANT_DEF 2842 * | 2843 * +--IDENT (SECOND_CONSTANT) 2844 * +--SEMI (;) 2845 * +--METHOD_DEF 2846 * | 2847 * +--MODIFIERS 2848 * | 2849 * +--LITERAL_PUBLIC (public) 2850 * +--TYPE 2851 * | 2852 * +--LITERAL_void (void) 2853 * +--IDENT (someMethod) 2854 * +--LPAREN (() 2855 * +--PARAMETERS 2856 * +--RPAREN ()) 2857 * +--SLIST ({) 2858 * | 2859 * +--RCURLY (}) 2860 * +--RCURLY (}) 2861 * </pre> 2862 * 2863 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2864 * JSR201</a> 2865 * @see #MODIFIERS 2866 * @see #ENUM 2867 * @see #IDENT 2868 * @see #EXTENDS_CLAUSE 2869 * @see #IMPLEMENTS_CLAUSE 2870 * @see #OBJBLOCK 2871 * @see #LITERAL_NEW 2872 * @see #ENUM_CONSTANT_DEF 2873 **/ 2874 public static final int ENUM_DEF = 2875 GeneratedJavaTokenTypes.ENUM_DEF; 2876 2877 /** 2878 * The {@code enum} keyword. This element appears 2879 * as part of an enum declaration. 2880 **/ 2881 public static final int ENUM = 2882 GeneratedJavaTokenTypes.ENUM; 2883 2884 /** 2885 * An enum constant declaration. Its notable children are annotations, 2886 * arguments and object block akin to an anonymous 2887 * inner class' body. 2888 * 2889 * <p>For example:</p> 2890 * <pre> 2891 * SOME_CONSTANT(1) 2892 * { 2893 * public void someMethodOverriddenFromMainBody() 2894 * { 2895 * } 2896 * } 2897 * </pre> 2898 * <p>parses as:</p> 2899 * <pre> 2900 * +--ENUM_CONSTANT_DEF 2901 * | 2902 * +--ANNOTATIONS 2903 * +--IDENT (SOME_CONSTANT) 2904 * +--LPAREN (() 2905 * +--ELIST 2906 * | 2907 * +--EXPR 2908 * | 2909 * +--NUM_INT (1) 2910 * +--RPAREN ()) 2911 * +--OBJBLOCK 2912 * | 2913 * +--LCURLY ({) 2914 * | 2915 * +--METHOD_DEF 2916 * | 2917 * +--MODIFIERS 2918 * | 2919 * +--LITERAL_PUBLIC (public) 2920 * +--TYPE 2921 * | 2922 * +--LITERAL_void (void) 2923 * +--IDENT (someMethodOverriddenFromMainBody) 2924 * +--LPAREN (() 2925 * +--PARAMETERS 2926 * +--RPAREN ()) 2927 * +--SLIST ({) 2928 * | 2929 * +--RCURLY (}) 2930 * +--RCURLY (}) 2931 * </pre> 2932 * 2933 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 2934 * JSR201</a> 2935 * @see #ANNOTATIONS 2936 * @see #MODIFIERS 2937 * @see #IDENT 2938 * @see #ELIST 2939 * @see #OBJBLOCK 2940 **/ 2941 public static final int ENUM_CONSTANT_DEF = 2942 GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF; 2943 2944 /** 2945 * A for-each clause. This is a child of 2946 * {@code LITERAL_FOR}. The children of this element may be 2947 * a parameter definition, the colon literal and an expression. 2948 * 2949 * <p>For example:</p> 2950 * <pre> 2951 * for (int value : values) { 2952 * doSmth(); 2953 * } 2954 * </pre> 2955 * <p>parses as:</p> 2956 * <pre> 2957 * --LITERAL_FOR (for) 2958 * |--LPAREN (() 2959 * |--FOR_EACH_CLAUSE 2960 * | |--VARIABLE_DEF 2961 * | | |--MODIFIERS 2962 * | | |--TYPE 2963 * | | | `--LITERAL_INT (int) 2964 * | | `--IDENT (value) 2965 * | |--COLON (:) 2966 * | `--EXPR 2967 * | `--IDENT (values 2968 * |--RPAREN ()) 2969 * `--SLIST ({) 2970 * |--EXPR 2971 * | `--METHOD_CALL (() 2972 * | |--IDENT (doSmth) 2973 * | |--ELIST 2974 * | `--RPAREN ()) 2975 * |--SEMI (;) 2976 * `--RCURLY (}) 2977 * 2978 * </pre> 2979 * 2980 * @see #VARIABLE_DEF 2981 * @see #ELIST 2982 * @see #LITERAL_FOR 2983 **/ 2984 public static final int FOR_EACH_CLAUSE = 2985 GeneratedJavaTokenTypes.FOR_EACH_CLAUSE; 2986 2987 /** 2988 * An annotation declaration. The notable children are the name of the 2989 * annotation type, annotation field declarations and (constant) fields. 2990 * 2991 * <p>For example:</p> 2992 * <pre> 2993 * public @interface MyAnnotation 2994 * { 2995 * int someValue(); 2996 * } 2997 * </pre> 2998 * <p>parses as:</p> 2999 * <pre> 3000 * +--ANNOTATION_DEF 3001 * | 3002 * +--MODIFIERS 3003 * | 3004 * +--LITERAL_PUBLIC (public) 3005 * +--AT (@) 3006 * +--LITERAL_INTERFACE (interface) 3007 * +--IDENT (MyAnnotation) 3008 * +--OBJBLOCK 3009 * | 3010 * +--LCURLY ({) 3011 * +--ANNOTATION_FIELD_DEF 3012 * | 3013 * +--MODIFIERS 3014 * +--TYPE 3015 * | 3016 * +--LITERAL_INT (int) 3017 * +--IDENT (someValue) 3018 * +--LPAREN (() 3019 * +--RPAREN ()) 3020 * +--SEMI (;) 3021 * +--RCURLY (}) 3022 * </pre> 3023 * 3024 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3025 * JSR201</a> 3026 * @see #MODIFIERS 3027 * @see #LITERAL_INTERFACE 3028 * @see #IDENT 3029 * @see #OBJBLOCK 3030 * @see #ANNOTATION_FIELD_DEF 3031 **/ 3032 public static final int ANNOTATION_DEF = 3033 GeneratedJavaTokenTypes.ANNOTATION_DEF; 3034 3035 /** 3036 * An annotation field declaration. The notable children are modifiers, 3037 * field type, field name and an optional default value (a conditional 3038 * compile-time constant expression). Default values may also by 3039 * annotations. 3040 * 3041 * <p>For example:</p> 3042 * 3043 * <pre> 3044 * String someField() default "Hello world"; 3045 * </pre> 3046 * 3047 * <p>parses as:</p> 3048 * 3049 * <pre> 3050 * +--ANNOTATION_FIELD_DEF 3051 * | 3052 * +--MODIFIERS 3053 * +--TYPE 3054 * | 3055 * +--IDENT (String) 3056 * +--IDENT (someField) 3057 * +--LPAREN (() 3058 * +--RPAREN ()) 3059 * +--LITERAL_DEFAULT (default) 3060 * +--STRING_LITERAL ("Hello world") 3061 * +--SEMI (;) 3062 * </pre> 3063 * 3064 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3065 * JSR201</a> 3066 * @see #MODIFIERS 3067 * @see #TYPE 3068 * @see #LITERAL_DEFAULT 3069 */ 3070 public static final int ANNOTATION_FIELD_DEF = 3071 GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF; 3072 3073 // note: @ is the html escape for '@', 3074 // used here to avoid confusing the javadoc tool 3075 /** 3076 * A collection of annotations on a package or enum constant. 3077 * A collections of annotations will only occur on these nodes 3078 * as all other nodes that may be qualified with an annotation can 3079 * be qualified with any other modifier and hence these annotations 3080 * would be contained in a {@link #MODIFIERS} node. 3081 * 3082 * <p>For example:</p> 3083 * 3084 * <pre> 3085 * @MyAnnotation package blah; 3086 * </pre> 3087 * 3088 * <p>parses as:</p> 3089 * 3090 * <pre> 3091 * +--PACKAGE_DEF (package) 3092 * | 3093 * +--ANNOTATIONS 3094 * | 3095 * +--ANNOTATION 3096 * | 3097 * +--AT (@) 3098 * +--IDENT (MyAnnotation) 3099 * +--IDENT (blah) 3100 * +--SEMI (;) 3101 * </pre> 3102 * 3103 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3104 * JSR201</a> 3105 * @see #ANNOTATION 3106 * @see #AT 3107 * @see #IDENT 3108 */ 3109 public static final int ANNOTATIONS = 3110 GeneratedJavaTokenTypes.ANNOTATIONS; 3111 3112 // note: @ is the html escape for '@', 3113 // used here to avoid confusing the javadoc tool 3114 /** 3115 * An annotation of a package, type, field, parameter or variable. 3116 * An annotation may occur anywhere modifiers occur (it is a 3117 * type of modifier) and may also occur prior to a package definition. 3118 * The notable children are: The annotation name and either a single 3119 * default annotation value or a sequence of name value pairs. 3120 * Annotation values may also be annotations themselves. 3121 * 3122 * <p>For example:</p> 3123 * 3124 * <pre> 3125 * @MyAnnotation(someField1 = "Hello", 3126 * someField2 = @SomeOtherAnnotation) 3127 * </pre> 3128 * 3129 * <p>parses as:</p> 3130 * 3131 * <pre> 3132 * +--ANNOTATION 3133 * | 3134 * +--AT (@) 3135 * +--IDENT (MyAnnotation) 3136 * +--LPAREN (() 3137 * +--ANNOTATION_MEMBER_VALUE_PAIR 3138 * | 3139 * +--IDENT (someField1) 3140 * +--ASSIGN (=) 3141 * +--ANNOTATION 3142 * | 3143 * +--AT (@) 3144 * +--IDENT (SomeOtherAnnotation) 3145 * +--ANNOTATION_MEMBER_VALUE_PAIR 3146 * | 3147 * +--IDENT (someField2) 3148 * +--ASSIGN (=) 3149 * +--STRING_LITERAL ("Hello") 3150 * +--RPAREN ()) 3151 * </pre> 3152 * 3153 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3154 * JSR201</a> 3155 * @see #MODIFIERS 3156 * @see #IDENT 3157 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3158 */ 3159 public static final int ANNOTATION = 3160 GeneratedJavaTokenTypes.ANNOTATION; 3161 3162 /** 3163 * An initialization of an annotation member with a value. 3164 * Its children are the name of the member, the assignment literal 3165 * and the (compile-time constant conditional expression) value. 3166 * 3167 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3168 * JSR201</a> 3169 * @see #ANNOTATION 3170 * @see #IDENT 3171 */ 3172 public static final int ANNOTATION_MEMBER_VALUE_PAIR = 3173 GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR; 3174 3175 /** 3176 * An annotation array member initialization. 3177 * Initializers can not be nested. 3178 * An initializer may be present as a default to an annotation 3179 * member, as the single default value to an annotation 3180 * (e.g. @Annotation({1,2})) or as the value of an annotation 3181 * member value pair. 3182 * 3183 * <p>For example:</p> 3184 * 3185 * <pre> 3186 * { 1, 2 } 3187 * </pre> 3188 * 3189 * <p>parses as:</p> 3190 * 3191 * <pre> 3192 * +--ANNOTATION_ARRAY_INIT ({) 3193 * | 3194 * +--NUM_INT (1) 3195 * +--COMMA (,) 3196 * +--NUM_INT (2) 3197 * +--RCURLY (}) 3198 * </pre> 3199 * 3200 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3201 * JSR201</a> 3202 * @see #ANNOTATION 3203 * @see #IDENT 3204 * @see #ANNOTATION_MEMBER_VALUE_PAIR 3205 */ 3206 public static final int ANNOTATION_ARRAY_INIT = 3207 GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT; 3208 3209 /** 3210 * A list of type parameters to a class, interface or 3211 * method definition. Children are LT, at least one 3212 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single 3213 * TYPE_PARAMETER and a final GT. 3214 * 3215 * <p>For example:</p> 3216 * 3217 * <pre> 3218 * public class Blah<A, B> 3219 * { 3220 * } 3221 * </pre> 3222 * 3223 * <p>parses as:</p> 3224 * 3225 * <pre> 3226 * +--CLASS_DEF ({) 3227 * | 3228 * +--MODIFIERS 3229 * | 3230 * +--LITERAL_PUBLIC (public) 3231 * +--LITERAL_CLASS (class) 3232 * +--IDENT (Blah) 3233 * +--TYPE_PARAMETERS 3234 * | 3235 * +--GENERIC_START (<) 3236 * +--TYPE_PARAMETER 3237 * | 3238 * +--IDENT (A) 3239 * +--COMMA (,) 3240 * +--TYPE_PARAMETER 3241 * | 3242 * +--IDENT (B) 3243 * +--GENERIC_END (>) 3244 * +--OBJBLOCK 3245 * | 3246 * +--LCURLY ({) 3247 * +--NUM_INT (1) 3248 * +--COMMA (,) 3249 * +--NUM_INT (2) 3250 * +--RCURLY (}) 3251 * </pre> 3252 * 3253 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3254 * JSR14</a> 3255 * @see #GENERIC_START 3256 * @see #GENERIC_END 3257 * @see #TYPE_PARAMETER 3258 * @see #COMMA 3259 */ 3260 public static final int TYPE_PARAMETERS = 3261 GeneratedJavaTokenTypes.TYPE_PARAMETERS; 3262 3263 /** 3264 * A type parameter to a class, interface or method definition. 3265 * Children are the type name and an optional TYPE_UPPER_BOUNDS. 3266 * 3267 * <p>For example:</p> 3268 * 3269 * <pre> 3270 * A extends Collection 3271 * </pre> 3272 * 3273 * <p>parses as:</p> 3274 * 3275 * <pre> 3276 * +--TYPE_PARAMETER 3277 * | 3278 * +--IDENT (A) 3279 * +--TYPE_UPPER_BOUNDS 3280 * | 3281 * +--IDENT (Collection) 3282 * </pre> 3283 * 3284 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3285 * JSR14</a> 3286 * @see #IDENT 3287 * @see #WILDCARD_TYPE 3288 * @see #TYPE_UPPER_BOUNDS 3289 */ 3290 public static final int TYPE_PARAMETER = 3291 GeneratedJavaTokenTypes.TYPE_PARAMETER; 3292 3293 /** 3294 * A list of type arguments to a type reference or 3295 * a method/ctor invocation. Children are GENERIC_START, at least one 3296 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single 3297 * TYPE_ARGUMENT, and a final GENERIC_END. 3298 * 3299 * <p>For example:</p> 3300 * 3301 * <pre> 3302 * public Collection<?> a; 3303 * </pre> 3304 * 3305 * <p>parses as:</p> 3306 * 3307 * <pre> 3308 * +--VARIABLE_DEF 3309 * | 3310 * +--MODIFIERS 3311 * | 3312 * +--LITERAL_PUBLIC (public) 3313 * +--TYPE 3314 * | 3315 * +--IDENT (Collection) 3316 * | 3317 * +--TYPE_ARGUMENTS 3318 * | 3319 * +--GENERIC_START (<) 3320 * +--TYPE_ARGUMENT 3321 * | 3322 * +--WILDCARD_TYPE (?) 3323 * +--GENERIC_END (>) 3324 * +--IDENT (a) 3325 * +--SEMI (;) 3326 * </pre> 3327 * 3328 * @see #GENERIC_START 3329 * @see #GENERIC_END 3330 * @see #TYPE_ARGUMENT 3331 * @see #COMMA 3332 */ 3333 public static final int TYPE_ARGUMENTS = 3334 GeneratedJavaTokenTypes.TYPE_ARGUMENTS; 3335 3336 /** 3337 * A type arguments to a type reference or a method/ctor invocation. 3338 * Children are either: type name or wildcard type with possible type 3339 * upper or lower bounds. 3340 * 3341 * <p>For example:</p> 3342 * 3343 * <pre> 3344 * ? super List 3345 * </pre> 3346 * 3347 * <p>parses as:</p> 3348 * 3349 * <pre> 3350 * +--TYPE_ARGUMENT 3351 * | 3352 * +--WILDCARD_TYPE (?) 3353 * +--TYPE_LOWER_BOUNDS 3354 * | 3355 * +--IDENT (List) 3356 * </pre> 3357 * 3358 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3359 * JSR14</a> 3360 * @see #WILDCARD_TYPE 3361 * @see #TYPE_UPPER_BOUNDS 3362 * @see #TYPE_LOWER_BOUNDS 3363 */ 3364 public static final int TYPE_ARGUMENT = 3365 GeneratedJavaTokenTypes.TYPE_ARGUMENT; 3366 3367 /** 3368 * The type that refers to all types. This node has no children. 3369 * 3370 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3371 * JSR14</a> 3372 * @see #TYPE_ARGUMENT 3373 * @see #TYPE_UPPER_BOUNDS 3374 * @see #TYPE_LOWER_BOUNDS 3375 */ 3376 public static final int WILDCARD_TYPE = 3377 GeneratedJavaTokenTypes.WILDCARD_TYPE; 3378 3379 /** 3380 * An upper bounds on a wildcard type argument or type parameter. 3381 * This node has one child - the type that is being used for 3382 * the bounding. 3383 * 3384 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3385 * JSR14</a> 3386 * @see #TYPE_PARAMETER 3387 * @see #TYPE_ARGUMENT 3388 * @see #WILDCARD_TYPE 3389 */ 3390 public static final int TYPE_UPPER_BOUNDS = 3391 GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS; 3392 3393 /** 3394 * A lower bounds on a wildcard type argument. This node has one child 3395 * - the type that is being used for the bounding. 3396 * 3397 * @see <a href="https://www.jcp.org/en/jsr/detail?id=14"> 3398 * JSR14</a> 3399 * @see #TYPE_ARGUMENT 3400 * @see #WILDCARD_TYPE 3401 */ 3402 public static final int TYPE_LOWER_BOUNDS = 3403 GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS; 3404 3405 /** 3406 * An {@code @} symbol - signifying an annotation instance or the prefix 3407 * to the interface literal signifying the definition of an annotation 3408 * declaration. 3409 * 3410 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3411 * JSR201</a> 3412 */ 3413 public static final int AT = GeneratedJavaTokenTypes.AT; 3414 3415 /** 3416 * A triple dot for variable-length parameters. This token only ever occurs 3417 * in a parameter declaration immediately after the type of the parameter. 3418 * 3419 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201"> 3420 * JSR201</a> 3421 */ 3422 public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS; 3423 3424 /** 3425 * The {@code &} symbol when used in a generic upper or lower bounds constrain 3426 * e.g. <code>Comparable<T extends Serializable & CharSequence></code>. 3427 * @noinspection HtmlTagCanBeJavadocTag 3428 */ 3429 public static final int TYPE_EXTENSION_AND = 3430 GeneratedJavaTokenTypes.TYPE_EXTENSION_AND; 3431 3432 /** 3433 * A {@code <} symbol signifying the start of type arguments or type parameters. 3434 */ 3435 public static final int GENERIC_START = 3436 GeneratedJavaTokenTypes.GENERIC_START; 3437 3438 /** 3439 * A {@code >} symbol signifying the end of type arguments or type parameters. 3440 */ 3441 public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END; 3442 3443 /** 3444 * Special lambda symbol {@code ->}. 3445 */ 3446 public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA; 3447 3448 /** 3449 * Beginning of single line comment: '//'. 3450 * 3451 * <pre> 3452 * +--SINGLE_LINE_COMMENT 3453 * | 3454 * +--COMMENT_CONTENT 3455 * </pre> 3456 */ 3457 public static final int SINGLE_LINE_COMMENT = 3458 GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT; 3459 3460 /** 3461 * Beginning of block comment: '/*'. 3462 * 3463 * <pre> 3464 * +--BLOCK_COMMENT_BEGIN 3465 * | 3466 * +--COMMENT_CONTENT 3467 * +--BLOCK_COMMENT_END 3468 * </pre> 3469 */ 3470 public static final int BLOCK_COMMENT_BEGIN = 3471 GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN; 3472 3473 /** 3474 * End of block comment: '*/'. 3475 * 3476 * <pre> 3477 * +--BLOCK_COMMENT_BEGIN 3478 * | 3479 * +--COMMENT_CONTENT 3480 * +--BLOCK_COMMENT_END 3481 * </pre> 3482 */ 3483 public static final int BLOCK_COMMENT_END = 3484 GeneratedJavaTokenTypes.BLOCK_COMMENT_END; 3485 3486 /** 3487 * Text of single-line or block comment. 3488 * 3489 * <pre> 3490 * +--SINGLE_LINE_COMMENT 3491 * | 3492 * +--COMMENT_CONTENT 3493 * </pre> 3494 * 3495 * <pre> 3496 * +--BLOCK_COMMENT_BEGIN 3497 * | 3498 * +--COMMENT_CONTENT 3499 * +--BLOCK_COMMENT_END 3500 * </pre> 3501 */ 3502 public static final int COMMENT_CONTENT = 3503 GeneratedJavaTokenTypes.COMMENT_CONTENT; 3504 3505 /** Prevent instantiation. */ 3506 private TokenTypes() { 3507 } 3508 3509}