001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2017 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 */ 034public final class TokenTypes { 035 // The following three types are never part of an AST, 036 // left here as a reminder so nobody will read them accidentally 037 038 // These are the types that can actually occur in an AST 039 // it makes sense to register Checks for these types 040 041 /** 042 * The end of file token. This is the root node for the source 043 * file. It's children are an optional package definition, zero 044 * or more import statements, and one or more class or interface 045 * definitions. 046 * 047 * @see #PACKAGE_DEF 048 * @see #IMPORT 049 * @see #CLASS_DEF 050 * @see #INTERFACE_DEF 051 **/ 052 public static final int EOF = GeneratedJavaTokenTypes.EOF; 053 /** 054 * Modifiers for type, method, and field declarations. The 055 * modifiers element is always present even though it may have no 056 * children. 057 * 058 * @see <a 059 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 060 * Language Specification, §8</a> 061 * @see #LITERAL_PUBLIC 062 * @see #LITERAL_PROTECTED 063 * @see #LITERAL_PRIVATE 064 * @see #ABSTRACT 065 * @see #LITERAL_STATIC 066 * @see #FINAL 067 * @see #LITERAL_TRANSIENT 068 * @see #LITERAL_VOLATILE 069 * @see #LITERAL_SYNCHRONIZED 070 * @see #LITERAL_NATIVE 071 * @see #STRICTFP 072 * @see #ANNOTATION 073 * @see #LITERAL_DEFAULT 074 **/ 075 public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS; 076 077 /** 078 * An object block. These are children of class, interface, enum, 079 * annotation and enum constant declarations. 080 * Also, object blocks are children of the new keyword when defining 081 * anonymous inner types. 082 * 083 * @see #LCURLY 084 * @see #INSTANCE_INIT 085 * @see #STATIC_INIT 086 * @see #CLASS_DEF 087 * @see #CTOR_DEF 088 * @see #METHOD_DEF 089 * @see #VARIABLE_DEF 090 * @see #RCURLY 091 * @see #INTERFACE_DEF 092 * @see #LITERAL_NEW 093 * @see #ENUM_DEF 094 * @see #ENUM_CONSTANT_DEF 095 * @see #ANNOTATION_DEF 096 **/ 097 public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK; 098 /** 099 * A list of statements. 100 * 101 * @see #RCURLY 102 * @see #EXPR 103 * @see #LABELED_STAT 104 * @see #LITERAL_THROWS 105 * @see #LITERAL_RETURN 106 * @see #SEMI 107 * @see #METHOD_DEF 108 * @see #CTOR_DEF 109 * @see #LITERAL_FOR 110 * @see #LITERAL_WHILE 111 * @see #LITERAL_IF 112 * @see #LITERAL_ELSE 113 * @see #CASE_GROUP 114 **/ 115 public static final int SLIST = GeneratedJavaTokenTypes.SLIST; 116 /** 117 * A constructor declaration. 118 * 119 * <p>For example:</p> 120 * <pre> 121 * public SpecialEntry(int value, String text) 122 * { 123 * this.value = value; 124 * this.text = text; 125 * } 126 * </pre> 127 * <p>parses as:</p> 128 * <pre> 129 * +--CTOR_DEF 130 * | 131 * +--MODIFIERS 132 * | 133 * +--LITERAL_PUBLIC (public) 134 * +--IDENT (SpecialEntry) 135 * +--LPAREN (() 136 * +--PARAMETERS 137 * | 138 * +--PARAMETER_DEF 139 * | 140 * +--MODIFIERS 141 * +--TYPE 142 * | 143 * +--LITERAL_INT (int) 144 * +--IDENT (value) 145 * +--COMMA (,) 146 * +--PARAMETER_DEF 147 * | 148 * +--MODIFIERS 149 * +--TYPE 150 * | 151 * +--IDENT (String) 152 * +--IDENT (text) 153 * +--RPAREN ()) 154 * +--SLIST ({) 155 * | 156 * +--EXPR 157 * | 158 * +--ASSIGN (=) 159 * | 160 * +--DOT (.) 161 * | 162 * +--LITERAL_THIS (this) 163 * +--IDENT (value) 164 * +--IDENT (value) 165 * +--SEMI (;) 166 * +--EXPR 167 * | 168 * +--ASSIGN (=) 169 * | 170 * +--DOT (.) 171 * | 172 * +--LITERAL_THIS (this) 173 * +--IDENT (text) 174 * +--IDENT (text) 175 * +--SEMI (;) 176 * +--RCURLY (}) 177 * </pre> 178 * 179 * @see #OBJBLOCK 180 * @see #CLASS_DEF 181 **/ 182 public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF; 183 /** 184 * A method declaration. The children are modifiers, type parameters, 185 * return type, method name, parameter list, an optional throws list, and 186 * statement list. The statement list is omitted if the method 187 * declaration appears in an interface declaration. Method 188 * declarations may appear inside object blocks of class 189 * declarations, interface declarations, enum declarations, 190 * enum constant declarations or anonymous inner-class declarations. 191 * 192 * <p>For example:</p> 193 * 194 * <pre> 195 * public static int square(int x) 196 * { 197 * return x*x; 198 * } 199 * </pre> 200 * 201 * <p>parses as:</p> 202 * 203 * <pre> 204 * +--METHOD_DEF 205 * | 206 * +--MODIFIERS 207 * | 208 * +--LITERAL_PUBLIC (public) 209 * +--LITERAL_STATIC (static) 210 * +--TYPE 211 * | 212 * +--LITERAL_INT (int) 213 * +--IDENT (square) 214 * +--PARAMETERS 215 * | 216 * +--PARAMETER_DEF 217 * | 218 * +--MODIFIERS 219 * +--TYPE 220 * | 221 * +--LITERAL_INT (int) 222 * +--IDENT (x) 223 * +--SLIST ({) 224 * | 225 * +--LITERAL_RETURN (return) 226 * | 227 * +--EXPR 228 * | 229 * +--STAR (*) 230 * | 231 * +--IDENT (x) 232 * +--IDENT (x) 233 * +--SEMI (;) 234 * +--RCURLY (}) 235 * </pre> 236 * 237 * @see #MODIFIERS 238 * @see #TYPE_PARAMETERS 239 * @see #TYPE 240 * @see #IDENT 241 * @see #PARAMETERS 242 * @see #LITERAL_THROWS 243 * @see #SLIST 244 * @see #OBJBLOCK 245 **/ 246 public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF; 247 /** 248 * A field or local variable declaration. The children are 249 * modifiers, type, the identifier name, and an optional 250 * assignment statement. 251 * 252 * @see #MODIFIERS 253 * @see #TYPE 254 * @see #IDENT 255 * @see #ASSIGN 256 **/ 257 public static final int VARIABLE_DEF = 258 GeneratedJavaTokenTypes.VARIABLE_DEF; 259 260 /** 261 * An instance initializer. Zero or more instance initializers 262 * may appear in class and enum definitions. This token will be a child 263 * of the object block of the declaring type. 264 * 265 * @see <a 266 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java 267 * Language Specification§8.6</a> 268 * @see #SLIST 269 * @see #OBJBLOCK 270 **/ 271 public static final int INSTANCE_INIT = 272 GeneratedJavaTokenTypes.INSTANCE_INIT; 273 274 /** 275 * A static initialization block. Zero or more static 276 * initializers may be children of the object block of a class 277 * or enum declaration (interfaces cannot have static initializers). The 278 * first and only child is a statement list. 279 * 280 * @see <a 281 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java 282 * Language Specification, §8.7</a> 283 * @see #SLIST 284 * @see #OBJBLOCK 285 **/ 286 public static final int STATIC_INIT = 287 GeneratedJavaTokenTypes.STATIC_INIT; 288 289 /** 290 * A type. This is either a return type of a method or a type of 291 * a variable or field. The first child of this element is the 292 * actual type. This may be a primitive type, an identifier, a 293 * dot which is the root of a fully qualified type, or an array of 294 * any of these. The second child may be type arguments to the type. 295 * 296 * @see #VARIABLE_DEF 297 * @see #METHOD_DEF 298 * @see #PARAMETER_DEF 299 * @see #IDENT 300 * @see #DOT 301 * @see #LITERAL_VOID 302 * @see #LITERAL_BOOLEAN 303 * @see #LITERAL_BYTE 304 * @see #LITERAL_CHAR 305 * @see #LITERAL_SHORT 306 * @see #LITERAL_INT 307 * @see #LITERAL_FLOAT 308 * @see #LITERAL_LONG 309 * @see #LITERAL_DOUBLE 310 * @see #ARRAY_DECLARATOR 311 * @see #TYPE_ARGUMENTS 312 **/ 313 public static final int TYPE = GeneratedJavaTokenTypes.TYPE; 314 /** 315 * A class declaration. 316 * 317 * <p>For example:</p> 318 * <pre> 319 * public class MyClass 320 * implements Serializable 321 * { 322 * } 323 * </pre> 324 * <p>parses as:</p> 325 * <pre> 326 * +--CLASS_DEF 327 * | 328 * +--MODIFIERS 329 * | 330 * +--LITERAL_PUBLIC (public) 331 * +--LITERAL_CLASS (class) 332 * +--IDENT (MyClass) 333 * +--EXTENDS_CLAUSE 334 * +--IMPLEMENTS_CLAUSE 335 * | 336 * +--IDENT (Serializable) 337 * +--OBJBLOCK 338 * | 339 * +--LCURLY ({) 340 * +--RCURLY (}) 341 * </pre> 342 * 343 * @see <a 344 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java 345 * Language Specification, §8</a> 346 * @see #MODIFIERS 347 * @see #IDENT 348 * @see #EXTENDS_CLAUSE 349 * @see #IMPLEMENTS_CLAUSE 350 * @see #OBJBLOCK 351 * @see #LITERAL_NEW 352 **/ 353 public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF; 354 /** 355 * An interface declaration. 356 * 357 * <p>For example:</p> 358 * 359 * <pre> 360 * public interface MyInterface 361 * { 362 * } 363 * 364 * </pre> 365 * 366 * <p>parses as:</p> 367 * 368 * <pre> 369 * +--INTERFACE_DEF 370 * | 371 * +--MODIFIERS 372 * | 373 * +--LITERAL_PUBLIC (public) 374 * +--LITERAL_INTERFACE (interface) 375 * +--IDENT (MyInterface) 376 * +--EXTENDS_CLAUSE 377 * +--OBJBLOCK 378 * | 379 * +--LCURLY ({) 380 * +--RCURLY (}) 381 * </pre> 382 * 383 * @see <a 384 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java 385 * Language Specification, §9</a> 386 * @see #MODIFIERS 387 * @see #IDENT 388 * @see #EXTENDS_CLAUSE 389 * @see #OBJBLOCK 390 **/ 391 public static final int INTERFACE_DEF = 392 GeneratedJavaTokenTypes.INTERFACE_DEF; 393 394 /** 395 * The package declaration. This is optional, but if it is 396 * included, then there is only one package declaration per source 397 * file and it must be the first non-comment in the file. A package 398 * declaration may be annotated in which case the annotations comes 399 * before the rest of the declaration (and are the first children). 400 * 401 * <p>For example:</p> 402 * 403 * <pre> 404 * package com.puppycrawl.tools.checkstyle.api; 405 * </pre> 406 * 407 * <p>parses as:</p> 408 * 409 * <pre> 410 * +--PACKAGE_DEF (package) 411 * | 412 * +--ANNOTATIONS 413 * +--DOT (.) 414 * | 415 * +--DOT (.) 416 * | 417 * +--DOT (.) 418 * | 419 * +--DOT (.) 420 * | 421 * +--IDENT (com) 422 * +--IDENT (puppycrawl) 423 * +--IDENT (tools) 424 * +--IDENT (checkstyle) 425 * +--IDENT (api) 426 * +--SEMI (;) 427 * </pre> 428 * 429 * @see <a 430 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java 431 * Language Specification §7.4</a> 432 * @see #DOT 433 * @see #IDENT 434 * @see #SEMI 435 * @see #ANNOTATIONS 436 * @see FullIdent 437 **/ 438 public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF; 439 /** 440 * An array declaration. 441 * 442 * <p>If the array declaration represents a type, then the type of 443 * the array elements is the first child. Multidimensional arrays 444 * may be regarded as arrays of arrays. In other words, the first 445 * child of the array declaration is another array 446 * declaration.</p> 447 * 448 * <p>For example:</p> 449 * <pre> 450 * int[] x; 451 * </pre> 452 * <p>parses as:</p> 453 * <pre> 454 * +--VARIABLE_DEF 455 * | 456 * +--MODIFIERS 457 * +--TYPE 458 * | 459 * +--ARRAY_DECLARATOR ([) 460 * | 461 * +--LITERAL_INT (int) 462 * +--IDENT (x) 463 * +--SEMI (;) 464 * </pre> 465 * 466 * <p>The array declaration may also represent an inline array 467 * definition. In this case, the first child will be either an 468 * expression specifying the length of the array or an array 469 * initialization block.</p> 470 * 471 * @see <a 472 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java 473 * Language Specification §10</a> 474 * @see #TYPE 475 * @see #ARRAY_INIT 476 **/ 477 public static final int ARRAY_DECLARATOR = 478 GeneratedJavaTokenTypes.ARRAY_DECLARATOR; 479 480 /** 481 * An extends clause. This appear as part of class and interface 482 * definitions. This element appears even if the 483 * <code>extends</code> keyword is not explicitly used. The child 484 * is an optional identifier. 485 * 486 * <p>For example:</p> 487 * 488 * <pre> 489 * extends java.util.LinkedList 490 * </pre> 491 * 492 * <p>parses as:</p> 493 * <pre> 494 * +--EXTENDS_CLAUSE 495 * | 496 * +--DOT (.) 497 * | 498 * +--DOT (.) 499 * | 500 * +--IDENT (java) 501 * +--IDENT (util) 502 * +--IDENT (LinkedList) 503 * </pre> 504 * 505 * @see #IDENT 506 * @see #DOT 507 * @see #CLASS_DEF 508 * @see #INTERFACE_DEF 509 * @see FullIdent 510 **/ 511 public static final int EXTENDS_CLAUSE = 512 GeneratedJavaTokenTypes.EXTENDS_CLAUSE; 513 514 /** 515 * An implements clause. This always appears in a class or enum 516 * declaration, even if there are no implemented interfaces. The 517 * children are a comma separated list of zero or more 518 * identifiers. 519 * 520 * <p>For example:</p> 521 * <pre> 522 * implements Serializable, Comparable 523 * </pre> 524 * <p>parses as:</p> 525 * <pre> 526 * +--IMPLEMENTS_CLAUSE 527 * | 528 * +--IDENT (Serializable) 529 * +--COMMA (,) 530 * +--IDENT (Comparable) 531 * </pre> 532 * 533 * @see #IDENT 534 * @see #DOT 535 * @see #COMMA 536 * @see #CLASS_DEF 537 * @see #ENUM_DEF 538 **/ 539 public static final int IMPLEMENTS_CLAUSE = 540 GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE; 541 542 /** 543 * A list of parameters to a method or constructor. The children 544 * are zero or more parameter declarations separated by commas. 545 * 546 * <p>For example</p> 547 * <pre> 548 * int start, int end 549 * </pre> 550 * <p>parses as:</p> 551 * <pre> 552 * +--PARAMETERS 553 * | 554 * +--PARAMETER_DEF 555 * | 556 * +--MODIFIERS 557 * +--TYPE 558 * | 559 * +--LITERAL_INT (int) 560 * +--IDENT (start) 561 * +--COMMA (,) 562 * +--PARAMETER_DEF 563 * | 564 * +--MODIFIERS 565 * +--TYPE 566 * | 567 * +--LITERAL_INT (int) 568 * +--IDENT (end) 569 * </pre> 570 * 571 * @see #PARAMETER_DEF 572 * @see #COMMA 573 * @see #METHOD_DEF 574 * @see #CTOR_DEF 575 **/ 576 public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS; 577 /** 578 * A parameter declaration. The last parameter in a list of parameters may 579 * be variable length (indicated by the ELLIPSIS child node immediately 580 * after the TYPE child). 581 * 582 * @see #MODIFIERS 583 * @see #TYPE 584 * @see #IDENT 585 * @see #PARAMETERS 586 * @see #ELLIPSIS 587 **/ 588 public static final int PARAMETER_DEF = 589 GeneratedJavaTokenTypes.PARAMETER_DEF; 590 591 /** 592 * A labeled statement. 593 * 594 * <p>For example:</p> 595 * <pre> 596 * outside: ; 597 * </pre> 598 * <p>parses as:</p> 599 * <pre> 600 * +--LABELED_STAT (:) 601 * | 602 * +--IDENT (outside) 603 * +--EMPTY_STAT (;) 604 * </pre> 605 * 606 * @see <a 607 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java 608 * Language Specification, §14.7</a> 609 * @see #SLIST 610 **/ 611 public static final int LABELED_STAT = 612 GeneratedJavaTokenTypes.LABELED_STAT; 613 614 /** 615 * A type-cast. 616 * 617 * <p>For example:</p> 618 * <pre> 619 * (String)it.next() 620 * </pre> 621 * <p>parses as:</p> 622 * <pre> 623 * +--TYPECAST (() 624 * | 625 * +--TYPE 626 * | 627 * +--IDENT (String) 628 * +--RPAREN ()) 629 * +--METHOD_CALL (() 630 * | 631 * +--DOT (.) 632 * | 633 * +--IDENT (it) 634 * +--IDENT (next) 635 * +--ELIST 636 * +--RPAREN ()) 637 * </pre> 638 * @see <a 639 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java 640 * Language Specification, §15.16</a> 641 * @see #EXPR 642 * @see #TYPE 643 * @see #TYPE_ARGUMENTS 644 * @see #RPAREN 645 **/ 646 public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST; 647 /** 648 * The array index operator. 649 * 650 * <p>For example:</p> 651 * <pre> 652 * ar[2] = 5; 653 * </pre> 654 * <p>parses as:</p> 655 * <pre> 656 * +--EXPR 657 * | 658 * +--ASSIGN (=) 659 * | 660 * +--INDEX_OP ([) 661 * | 662 * +--IDENT (ar) 663 * +--EXPR 664 * | 665 * +--NUM_INT (2) 666 * +--NUM_INT (5) 667 * +--SEMI (;) 668 * </pre> 669 * 670 * @see #EXPR 671 **/ 672 public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP; 673 /** 674 * The <code>++</code> (postfix increment) operator. 675 * 676 * @see <a 677 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java 678 * Language Specification, §15.14.1</a> 679 * @see #EXPR 680 * @see #INC 681 **/ 682 public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC; 683 /** 684 * The <code>--</code> (postfix decrement) operator. 685 * 686 * @see <a 687 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java 688 * Language Specification, §15.14.2</a> 689 * @see #EXPR 690 * @see #DEC 691 **/ 692 public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC; 693 /** 694 * A method call. A method call may have type arguments however these 695 * are attached to the appropriate node in the qualified method name. 696 * 697 * <p>For example:</p> 698 * <pre> 699 * Math.random() 700 * </pre> 701 * 702 * <p>parses as: 703 * <pre> 704 * +--METHOD_CALL (() 705 * | 706 * +--DOT (.) 707 * | 708 * +--IDENT (Math) 709 * +--IDENT (random) 710 * +--ELIST 711 * +--RPAREN ()) 712 * </pre> 713 * 714 * 715 * @see #IDENT 716 * @see #TYPE_ARGUMENTS 717 * @see #DOT 718 * @see #ELIST 719 * @see #RPAREN 720 * @see FullIdent 721 **/ 722 public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL; 723 724 /** 725 * A reference to a method or constructor without arguments. Part of Java 8 syntax. 726 * The token should be used for subscribing for double colon literal. 727 * {@link #DOUBLE_COLON} token does not appear in the tree. 728 * 729 * <p>For example:</p> 730 * <pre> 731 * String::compareToIgnoreCase 732 * </pre> 733 * 734 * <p>parses as: 735 * <pre> 736 * +--METHOD_REF (::) 737 * | 738 * +--IDENT (String) 739 * +--IDENT (compareToIgnoreCase) 740 * </pre> 741 * 742 * @see #IDENT 743 * @see #DOUBLE_COLON 744 */ 745 public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF; 746 /** 747 * An expression. Operators with lower precedence appear at a 748 * higher level in the tree than operators with higher precedence. 749 * Parentheses are siblings to the operator they enclose. 750 * 751 * <p>For example:</p> 752 * <pre> 753 * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3); 754 * </pre> 755 * <p>parses as:</p> 756 * <pre> 757 * +--EXPR 758 * | 759 * +--ASSIGN (=) 760 * | 761 * +--IDENT (x) 762 * +--PLUS (+) 763 * | 764 * +--PLUS (+) 765 * | 766 * +--PLUS (+) 767 * | 768 * +--PLUS (+) 769 * | 770 * +--NUM_INT (4) 771 * +--STAR (*) 772 * | 773 * +--NUM_INT (3) 774 * +--NUM_INT (5) 775 * +--DIV (/) 776 * | 777 * +--LPAREN (() 778 * +--PLUS (+) 779 * | 780 * +--NUM_INT (30) 781 * +--NUM_INT (26) 782 * +--RPAREN ()) 783 * +--NUM_INT (4) 784 * +--MOD (%) 785 * | 786 * +--NUM_INT (5) 787 * +--NUM_INT (4) 788 * +--LPAREN (() 789 * +--SL (<<) 790 * | 791 * +--NUM_INT (1) 792 * +--NUM_INT (3) 793 * +--RPAREN ()) 794 * +--SEMI (;) 795 * </pre> 796 * 797 * @see #ELIST 798 * @see #ASSIGN 799 * @see #LPAREN 800 * @see #RPAREN 801 **/ 802 public static final int EXPR = GeneratedJavaTokenTypes.EXPR; 803 /** 804 * An array initialization. This may occur as part of an array 805 * declaration or inline with <code>new</code>. 806 * 807 * <p>For example:</p> 808 * <pre> 809 * int[] y = 810 * { 811 * 1, 812 * 2, 813 * }; 814 * </pre> 815 * <p>parses as:</p> 816 * <pre> 817 * +--VARIABLE_DEF 818 * | 819 * +--MODIFIERS 820 * +--TYPE 821 * | 822 * +--ARRAY_DECLARATOR ([) 823 * | 824 * +--LITERAL_INT (int) 825 * +--IDENT (y) 826 * +--ASSIGN (=) 827 * | 828 * +--ARRAY_INIT ({) 829 * | 830 * +--EXPR 831 * | 832 * +--NUM_INT (1) 833 * +--COMMA (,) 834 * +--EXPR 835 * | 836 * +--NUM_INT (2) 837 * +--COMMA (,) 838 * +--RCURLY (}) 839 * +--SEMI (;) 840 * </pre> 841 * 842 * <p>Also consider:</p> 843 * <pre> 844 * int[] z = new int[] 845 * { 846 * 1, 847 * 2, 848 * }; 849 * </pre> 850 * <p>which parses as:</p> 851 * <pre> 852 * +--VARIABLE_DEF 853 * | 854 * +--MODIFIERS 855 * +--TYPE 856 * | 857 * +--ARRAY_DECLARATOR ([) 858 * | 859 * +--LITERAL_INT (int) 860 * +--IDENT (z) 861 * +--ASSIGN (=) 862 * | 863 * +--EXPR 864 * | 865 * +--LITERAL_NEW (new) 866 * | 867 * +--LITERAL_INT (int) 868 * +--ARRAY_DECLARATOR ([) 869 * +--ARRAY_INIT ({) 870 * | 871 * +--EXPR 872 * | 873 * +--NUM_INT (1) 874 * +--COMMA (,) 875 * +--EXPR 876 * | 877 * +--NUM_INT (2) 878 * +--COMMA (,) 879 * +--RCURLY (}) 880 * </pre> 881 * 882 * @see #ARRAY_DECLARATOR 883 * @see #TYPE 884 * @see #LITERAL_NEW 885 * @see #COMMA 886 **/ 887 public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT; 888 /** 889 * An import declaration. Import declarations are option, but 890 * must appear after the package declaration and before the first type 891 * declaration. 892 * 893 * <p>For example:</p> 894 * 895 * <pre> 896 * import java.io.IOException; 897 * </pre> 898 * 899 * <p>parses as:</p> 900 * 901 * <pre> 902 * +--IMPORT (import) 903 * | 904 * +--DOT (.) 905 * | 906 * +--DOT (.) 907 * | 908 * +--IDENT (java) 909 * +--IDENT (io) 910 * +--IDENT (IOException) 911 * +--SEMI (;) 912 * </pre> 913 * 914 * @see <a 915 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java 916 * Language Specification §7.5</a> 917 * @see #DOT 918 * @see #IDENT 919 * @see #STAR 920 * @see #SEMI 921 * @see FullIdent 922 **/ 923 public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT; 924 /** 925 * The <code>-</code> (unary minus) operator. 926 * 927 * @see <a 928 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java 929 * Language Specification, §15.15.4</a> 930 * @see #EXPR 931 **/ 932 public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS; 933 /** 934 * The <code>+</code> (unary plus) operator. 935 * 936 * @see <a 937 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java 938 * Language Specification, §15.15.3</a> 939 * @see #EXPR 940 **/ 941 public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS; 942 /** 943 * A group of case clauses. Case clauses with no associated 944 * statements are grouped together into a case group. The last 945 * child is a statement list containing the statements to execute 946 * upon a match. 947 * 948 * <p>For example:</p> 949 * <pre> 950 * case 0: 951 * case 1: 952 * case 2: 953 * x = 3; 954 * break; 955 * </pre> 956 * <p>parses as:</p> 957 * <pre> 958 * +--CASE_GROUP 959 * | 960 * +--LITERAL_CASE (case) 961 * | 962 * +--EXPR 963 * | 964 * +--NUM_INT (0) 965 * +--LITERAL_CASE (case) 966 * | 967 * +--EXPR 968 * | 969 * +--NUM_INT (1) 970 * +--LITERAL_CASE (case) 971 * | 972 * +--EXPR 973 * | 974 * +--NUM_INT (2) 975 * +--SLIST 976 * | 977 * +--EXPR 978 * | 979 * +--ASSIGN (=) 980 * | 981 * +--IDENT (x) 982 * +--NUM_INT (3) 983 * +--SEMI (;) 984 * +--LITERAL_BREAK (break) 985 * | 986 * +--SEMI (;) 987 * </pre> 988 * 989 * @see #LITERAL_CASE 990 * @see #LITERAL_DEFAULT 991 * @see #LITERAL_SWITCH 992 **/ 993 public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP; 994 /** 995 * An expression list. The children are a comma separated list of 996 * expressions. 997 * 998 * @see #LITERAL_NEW 999 * @see #FOR_INIT 1000 * @see #FOR_ITERATOR 1001 * @see #EXPR 1002 * @see #METHOD_CALL 1003 * @see #CTOR_CALL 1004 * @see #SUPER_CTOR_CALL 1005 **/ 1006 public static final int ELIST = GeneratedJavaTokenTypes.ELIST; 1007 /** 1008 * A for loop initializer. This is a child of 1009 * <code>LITERAL_FOR</code>. The children of this element may be 1010 * a comma separated list of variable declarations, an expression 1011 * list, or empty. 1012 * 1013 * @see #VARIABLE_DEF 1014 * @see #ELIST 1015 * @see #LITERAL_FOR 1016 **/ 1017 public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT; 1018 /** 1019 * A for loop condition. This is a child of 1020 * <code>LITERAL_FOR</code>. The child of this element is an 1021 * optional expression. 1022 * 1023 * @see #EXPR 1024 * @see #LITERAL_FOR 1025 **/ 1026 public static final int FOR_CONDITION = 1027 GeneratedJavaTokenTypes.FOR_CONDITION; 1028 1029 /** 1030 * A for loop iterator. This is a child of 1031 * <code>LITERAL_FOR</code>. The child of this element is an 1032 * optional expression list. 1033 * 1034 * @see #ELIST 1035 * @see #LITERAL_FOR 1036 **/ 1037 public static final int FOR_ITERATOR = 1038 GeneratedJavaTokenTypes.FOR_ITERATOR; 1039 1040 /** 1041 * The empty statement. This goes in place of an 1042 * <code>SLIST</code> for a <code>for</code> or <code>while</code> 1043 * loop body. 1044 * 1045 * @see <a 1046 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java 1047 * Language Specification, §14.6</a> 1048 * @see #LITERAL_FOR 1049 * @see #LITERAL_WHILE 1050 **/ 1051 public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT; 1052 /** 1053 * The <code>final</code> keyword. 1054 * 1055 * @see #MODIFIERS 1056 **/ 1057 public static final int FINAL = GeneratedJavaTokenTypes.FINAL; 1058 /** 1059 * The <code>abstract</code> keyword. 1060 * 1061 * @see #MODIFIERS 1062 **/ 1063 public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT; 1064 /** 1065 * The <code>strictfp</code> keyword. 1066 * 1067 * @see #MODIFIERS 1068 **/ 1069 public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP; 1070 /** 1071 * A super constructor call. 1072 * 1073 * @see #ELIST 1074 * @see #RPAREN 1075 * @see #SEMI 1076 * @see #CTOR_CALL 1077 **/ 1078 public static final int SUPER_CTOR_CALL = 1079 GeneratedJavaTokenTypes.SUPER_CTOR_CALL; 1080 1081 /** 1082 * A constructor call. 1083 * 1084 * <p>For example:</p> 1085 * <pre> 1086 * this(1); 1087 * </pre> 1088 * <p>parses as:</p> 1089 * <pre> 1090 * +--CTOR_CALL (this) 1091 * | 1092 * +--LPAREN (() 1093 * +--ELIST 1094 * | 1095 * +--EXPR 1096 * | 1097 * +--NUM_INT (1) 1098 * +--RPAREN ()) 1099 * +--SEMI (;) 1100 * </pre> 1101 * 1102 * @see #ELIST 1103 * @see #RPAREN 1104 * @see #SEMI 1105 * @see #SUPER_CTOR_CALL 1106 **/ 1107 public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL; 1108 1109 /** 1110 * The statement terminator (<code>;</code>). Depending on the 1111 * context, this make occur as a sibling, a child, or not at all. 1112 * 1113 * @see #PACKAGE_DEF 1114 * @see #IMPORT 1115 * @see #SLIST 1116 * @see #ARRAY_INIT 1117 * @see #LITERAL_FOR 1118 **/ 1119 public static final int SEMI = GeneratedJavaTokenTypes.SEMI; 1120 1121 /** 1122 * The <code>]</code> symbol. 1123 * 1124 * @see #INDEX_OP 1125 * @see #ARRAY_DECLARATOR 1126 **/ 1127 public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK; 1128 /** 1129 * The <code>void</code> keyword. 1130 * 1131 * @see #TYPE 1132 **/ 1133 public static final int LITERAL_VOID = 1134 GeneratedJavaTokenTypes.LITERAL_void; 1135 1136 /** 1137 * The <code>boolean</code> keyword. 1138 * 1139 * @see #TYPE 1140 **/ 1141 public static final int LITERAL_BOOLEAN = 1142 GeneratedJavaTokenTypes.LITERAL_boolean; 1143 1144 /** 1145 * The <code>byte</code> keyword. 1146 * 1147 * @see #TYPE 1148 **/ 1149 public static final int LITERAL_BYTE = 1150 GeneratedJavaTokenTypes.LITERAL_byte; 1151 1152 /** 1153 * The <code>char</code> keyword. 1154 * 1155 * @see #TYPE 1156 **/ 1157 public static final int LITERAL_CHAR = 1158 GeneratedJavaTokenTypes.LITERAL_char; 1159 1160 /** 1161 * The <code>short</code> keyword. 1162 * 1163 * @see #TYPE 1164 **/ 1165 public static final int LITERAL_SHORT = 1166 GeneratedJavaTokenTypes.LITERAL_short; 1167 1168 /** 1169 * The <code>int</code> keyword. 1170 * 1171 * @see #TYPE 1172 **/ 1173 public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int; 1174 /** 1175 * The <code>float</code> keyword. 1176 * 1177 * @see #TYPE 1178 **/ 1179 public static final int LITERAL_FLOAT = 1180 GeneratedJavaTokenTypes.LITERAL_float; 1181 1182 /** 1183 * The <code>long</code> keyword. 1184 * 1185 * @see #TYPE 1186 **/ 1187 public static final int LITERAL_LONG = 1188 GeneratedJavaTokenTypes.LITERAL_long; 1189 1190 /** 1191 * The <code>double</code> keyword. 1192 * 1193 * @see #TYPE 1194 **/ 1195 public static final int LITERAL_DOUBLE = 1196 GeneratedJavaTokenTypes.LITERAL_double; 1197 1198 /** 1199 * An identifier. These can be names of types, subpackages, 1200 * fields, methods, parameters, and local variables. 1201 **/ 1202 public static final int IDENT = GeneratedJavaTokenTypes.IDENT; 1203 /** 1204 * The <code>.</code> (dot) operator. 1205 * 1206 * @see FullIdent 1207 **/ 1208 public static final int DOT = GeneratedJavaTokenTypes.DOT; 1209 /** 1210 * The <code>*</code> (multiplication or wildcard) operator. 1211 * 1212 * @see <a 1213 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java 1214 * Language Specification, §7.5.2</a> 1215 * @see <a 1216 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java 1217 * Language Specification, §15.17.1</a> 1218 * @see #EXPR 1219 * @see #IMPORT 1220 **/ 1221 public static final int STAR = GeneratedJavaTokenTypes.STAR; 1222 /** 1223 * The <code>private</code> keyword. 1224 * 1225 * @see #MODIFIERS 1226 **/ 1227 public static final int LITERAL_PRIVATE = 1228 GeneratedJavaTokenTypes.LITERAL_private; 1229 1230 /** 1231 * The <code>public</code> keyword. 1232 * 1233 * @see #MODIFIERS 1234 **/ 1235 public static final int LITERAL_PUBLIC = 1236 GeneratedJavaTokenTypes.LITERAL_public; 1237 1238 /** 1239 * The <code>protected</code> keyword. 1240 * 1241 * @see #MODIFIERS 1242 **/ 1243 public static final int LITERAL_PROTECTED = 1244 GeneratedJavaTokenTypes.LITERAL_protected; 1245 1246 /** 1247 * The <code>static</code> keyword. 1248 * 1249 * @see #MODIFIERS 1250 **/ 1251 public static final int LITERAL_STATIC = 1252 GeneratedJavaTokenTypes.LITERAL_static; 1253 1254 /** 1255 * The <code>transient</code> keyword. 1256 * 1257 * @see #MODIFIERS 1258 **/ 1259 public static final int LITERAL_TRANSIENT = 1260 GeneratedJavaTokenTypes.LITERAL_transient; 1261 1262 /** 1263 * The <code>native</code> keyword. 1264 * 1265 * @see #MODIFIERS 1266 **/ 1267 public static final int LITERAL_NATIVE = 1268 GeneratedJavaTokenTypes.LITERAL_native; 1269 1270 /** 1271 * The <code>synchronized</code> keyword. This may be used as a 1272 * modifier of a method or in the definition of a synchronized 1273 * block. 1274 * 1275 * <p>For example:</p> 1276 * 1277 * <pre> 1278 * synchronized(this) 1279 * { 1280 * x++; 1281 * } 1282 * </pre> 1283 * 1284 * <p>parses as:</p> 1285 * 1286 * <pre> 1287 * +--LITERAL_SYNCHRONIZED (synchronized) 1288 * | 1289 * +--LPAREN (() 1290 * +--EXPR 1291 * | 1292 * +--LITERAL_THIS (this) 1293 * +--RPAREN ()) 1294 * +--SLIST ({) 1295 * | 1296 * +--EXPR 1297 * | 1298 * +--POST_INC (++) 1299 * | 1300 * +--IDENT (x) 1301 * +--SEMI (;) 1302 * +--RCURLY (}) 1303 * +--RCURLY (}) 1304 * </pre> 1305 * 1306 * @see #MODIFIERS 1307 * @see #LPAREN 1308 * @see #EXPR 1309 * @see #RPAREN 1310 * @see #SLIST 1311 * @see #RCURLY 1312 **/ 1313 public static final int LITERAL_SYNCHRONIZED = 1314 GeneratedJavaTokenTypes.LITERAL_synchronized; 1315 1316 /** 1317 * The <code>volatile</code> keyword. 1318 * 1319 * @see #MODIFIERS 1320 **/ 1321 public static final int LITERAL_VOLATILE = 1322 GeneratedJavaTokenTypes.LITERAL_volatile; 1323 1324 /** 1325 * The <code>class</code> keyword. This element appears both 1326 * as part of a class declaration, and inline to reference a 1327 * class object. 1328 * 1329 * <p>For example:</p> 1330 * 1331 * <pre> 1332 * int.class 1333 * </pre> 1334 * <p>parses as:</p> 1335 * <pre> 1336 * +--EXPR 1337 * | 1338 * +--DOT (.) 1339 * | 1340 * +--LITERAL_INT (int) 1341 * +--LITERAL_CLASS (class) 1342 * </pre> 1343 * 1344 * @see #DOT 1345 * @see #IDENT 1346 * @see #CLASS_DEF 1347 * @see FullIdent 1348 **/ 1349 public static final int LITERAL_CLASS = 1350 GeneratedJavaTokenTypes.LITERAL_class; 1351 1352 /** 1353 * The <code>interface</code> keyword. This token appears in 1354 * interface definition. 1355 * 1356 * @see #INTERFACE_DEF 1357 **/ 1358 public static final int LITERAL_INTERFACE = 1359 GeneratedJavaTokenTypes.LITERAL_interface; 1360 1361 /** 1362 * A left (curly) brace (<code>{</code>). 1363 * 1364 * @see #OBJBLOCK 1365 * @see #ARRAY_INIT 1366 * @see #SLIST 1367 **/ 1368 public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY; 1369 /** 1370 * A right (curly) brace (<code>}</code>). 1371 * 1372 * @see #OBJBLOCK 1373 * @see #ARRAY_INIT 1374 * @see #SLIST 1375 **/ 1376 public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY; 1377 /** 1378 * The <code>,</code> (comma) operator. 1379 * 1380 * @see #ARRAY_INIT 1381 * @see #FOR_INIT 1382 * @see #FOR_ITERATOR 1383 * @see #LITERAL_THROWS 1384 * @see #IMPLEMENTS_CLAUSE 1385 **/ 1386 public static final int COMMA = GeneratedJavaTokenTypes.COMMA; 1387 1388 /** 1389 * A left parenthesis (<code>(</code>). 1390 * 1391 * @see #LITERAL_FOR 1392 * @see #LITERAL_NEW 1393 * @see #EXPR 1394 * @see #LITERAL_SWITCH 1395 * @see #LITERAL_CATCH 1396 **/ 1397 public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN; 1398 /** 1399 * A right parenthesis (<code>)</code>). 1400 * 1401 * @see #LITERAL_FOR 1402 * @see #LITERAL_NEW 1403 * @see #METHOD_CALL 1404 * @see #TYPECAST 1405 * @see #EXPR 1406 * @see #LITERAL_SWITCH 1407 * @see #LITERAL_CATCH 1408 **/ 1409 public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN; 1410 /** 1411 * The <code>this</code> keyword. 1412 * 1413 * @see #EXPR 1414 * @see #CTOR_CALL 1415 **/ 1416 public static final int LITERAL_THIS = 1417 GeneratedJavaTokenTypes.LITERAL_this; 1418 1419 /** 1420 * The <code>super</code> keyword. 1421 * 1422 * @see #EXPR 1423 * @see #SUPER_CTOR_CALL 1424 **/ 1425 public static final int LITERAL_SUPER = 1426 GeneratedJavaTokenTypes.LITERAL_super; 1427 1428 /** 1429 * The <code>=</code> (assignment) operator. 1430 * 1431 * @see <a 1432 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java 1433 * Language Specification, §15.26.1</a> 1434 * @see #EXPR 1435 **/ 1436 public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN; 1437 /** 1438 * The <code>throws</code> keyword. The children are a number of 1439 * one or more identifiers separated by commas. 1440 * 1441 * @see <a 1442 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java 1443 * Language Specification, §8.4.4</a> 1444 * @see #IDENT 1445 * @see #DOT 1446 * @see #COMMA 1447 * @see #METHOD_DEF 1448 * @see #CTOR_DEF 1449 * @see FullIdent 1450 **/ 1451 public static final int LITERAL_THROWS = 1452 GeneratedJavaTokenTypes.LITERAL_throws; 1453 1454 /** 1455 * The <code>:</code> (colon) operator. This will appear as part 1456 * of the conditional operator (<code>? :</code>). 1457 * 1458 * @see #QUESTION 1459 * @see #LABELED_STAT 1460 * @see #CASE_GROUP 1461 **/ 1462 public static final int COLON = GeneratedJavaTokenTypes.COLON; 1463 1464 /** 1465 * The <code>::</code> (double colon) separator. 1466 * It is part of Java 8 syntax that is used for method reference. 1467 * The token does not appear in tree, {@link #METHOD_REF} should be used instead. 1468 * 1469 * @see #METHOD_REF 1470 */ 1471 public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON; 1472 /** 1473 * The <code>if</code> keyword. 1474 * 1475 * <p>For example:</p> 1476 * <pre> 1477 * if(optimistic) 1478 * { 1479 * message = "half full"; 1480 * } 1481 * else 1482 * { 1483 * message = "half empty"; 1484 * } 1485 * </pre> 1486 * <p>parses as:</p> 1487 * <pre> 1488 * +--LITERAL_IF (if) 1489 * | 1490 * +--LPAREN (() 1491 * +--EXPR 1492 * | 1493 * +--IDENT (optimistic) 1494 * +--RPAREN ()) 1495 * +--SLIST ({) 1496 * | 1497 * +--EXPR 1498 * | 1499 * +--ASSIGN (=) 1500 * | 1501 * +--IDENT (message) 1502 * +--STRING_LITERAL ("half full") 1503 * +--SEMI (;) 1504 * +--RCURLY (}) 1505 * +--LITERAL_ELSE (else) 1506 * | 1507 * +--SLIST ({) 1508 * | 1509 * +--EXPR 1510 * | 1511 * +--ASSIGN (=) 1512 * | 1513 * +--IDENT (message) 1514 * +--STRING_LITERAL ("half empty") 1515 * +--SEMI (;) 1516 * +--RCURLY (}) 1517 * </pre> 1518 * 1519 * @see #LPAREN 1520 * @see #EXPR 1521 * @see #RPAREN 1522 * @see #SLIST 1523 * @see #EMPTY_STAT 1524 * @see #LITERAL_ELSE 1525 **/ 1526 public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if; 1527 /** 1528 * The <code>for</code> keyword. The children are <code>(</code>, 1529 * an initializer, a condition, an iterator, a <code>)</code> and 1530 * either a statement list, a single expression, or an empty 1531 * statement. 1532 * 1533 * <p>For example:</p> 1534 * <pre> 1535 * for(int i = 0, n = myArray.length; i < n; i++) 1536 * { 1537 * } 1538 * </pre> 1539 * 1540 * <p>parses as:</p> 1541 * <pre> 1542 * +--LITERAL_FOR (for) 1543 * | 1544 * +--LPAREN (() 1545 * +--FOR_INIT 1546 * | 1547 * +--VARIABLE_DEF 1548 * | 1549 * +--MODIFIERS 1550 * +--TYPE 1551 * | 1552 * +--LITERAL_INT (int) 1553 * +--IDENT (i) 1554 * +--ASSIGN (=) 1555 * | 1556 * +--EXPR 1557 * | 1558 * +--NUM_INT (0) 1559 * +--COMMA (,) 1560 * +--VARIABLE_DEF 1561 * | 1562 * +--MODIFIERS 1563 * +--TYPE 1564 * | 1565 * +--LITERAL_INT (int) 1566 * +--IDENT (n) 1567 * +--ASSIGN (=) 1568 * | 1569 * +--EXPR 1570 * | 1571 * +--DOT (.) 1572 * | 1573 * +--IDENT (myArray) 1574 * +--IDENT (length) 1575 * +--SEMI (;) 1576 * +--FOR_CONDITION 1577 * | 1578 * +--EXPR 1579 * | 1580 * +--LT (<) 1581 * | 1582 * +--IDENT (i) 1583 * +--IDENT (n) 1584 * +--SEMI (;) 1585 * +--FOR_ITERATOR 1586 * | 1587 * +--ELIST 1588 * | 1589 * +--EXPR 1590 * | 1591 * +--POST_INC (++) 1592 * | 1593 * +--IDENT (i) 1594 * +--RPAREN ()) 1595 * +--SLIST ({) 1596 * | 1597 * +--RCURLY (}) 1598 * </pre> 1599 * 1600 * @see #LPAREN 1601 * @see #FOR_INIT 1602 * @see #SEMI 1603 * @see #FOR_CONDITION 1604 * @see #FOR_ITERATOR 1605 * @see #RPAREN 1606 * @see #SLIST 1607 * @see #EMPTY_STAT 1608 * @see #EXPR 1609 **/ 1610 public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for; 1611 /** 1612 * The <code>while</code> keyword. 1613 * 1614 * <p>For example:</p> 1615 * <pre> 1616 * while(line != null) 1617 * { 1618 * process(line); 1619 * line = in.readLine(); 1620 * } 1621 * </pre> 1622 * <p>parses as:</p> 1623 * <pre> 1624 * +--LITERAL_WHILE (while) 1625 * | 1626 * +--LPAREN (() 1627 * +--EXPR 1628 * | 1629 * +--NOT_EQUAL (!=) 1630 * | 1631 * +--IDENT (line) 1632 * +--LITERAL_NULL (null) 1633 * +--RPAREN ()) 1634 * +--SLIST ({) 1635 * | 1636 * +--EXPR 1637 * | 1638 * +--METHOD_CALL (() 1639 * | 1640 * +--IDENT (process) 1641 * +--ELIST 1642 * | 1643 * +--EXPR 1644 * | 1645 * +--IDENT (line) 1646 * +--RPAREN ()) 1647 * +--SEMI (;) 1648 * +--EXPR 1649 * | 1650 * +--ASSIGN (=) 1651 * | 1652 * +--IDENT (line) 1653 * +--METHOD_CALL (() 1654 * | 1655 * +--DOT (.) 1656 * | 1657 * +--IDENT (in) 1658 * +--IDENT (readLine) 1659 * +--ELIST 1660 * +--RPAREN ()) 1661 * +--SEMI (;) 1662 * +--RCURLY (}) 1663 * </pre> 1664 **/ 1665 public static final int LITERAL_WHILE = 1666 GeneratedJavaTokenTypes.LITERAL_while; 1667 1668 /** 1669 * The <code>do</code> keyword. Note the the while token does not 1670 * appear as part of the do-while construct. 1671 * 1672 * <p>For example:</p> 1673 * <pre> 1674 * do 1675 * { 1676 * x = rand.nextInt(10); 1677 * } 1678 * while(x < 5); 1679 * </pre> 1680 * <p>parses as:</p> 1681 * <pre> 1682 * +--LITERAL_DO (do) 1683 * | 1684 * +--SLIST ({) 1685 * | 1686 * +--EXPR 1687 * | 1688 * +--ASSIGN (=) 1689 * | 1690 * +--IDENT (x) 1691 * +--METHOD_CALL (() 1692 * | 1693 * +--DOT (.) 1694 * | 1695 * +--IDENT (rand) 1696 * +--IDENT (nextInt) 1697 * +--ELIST 1698 * | 1699 * +--EXPR 1700 * | 1701 * +--NUM_INT (10) 1702 * +--RPAREN ()) 1703 * +--SEMI (;) 1704 * +--RCURLY (}) 1705 * +--DO_WHILE (while) 1706 * +--LPAREN (() 1707 * +--EXPR 1708 * | 1709 * +--LT (<) 1710 * | 1711 * +--IDENT (x) 1712 * +--NUM_INT (5) 1713 * +--RPAREN ()) 1714 * +--SEMI (;) 1715 * </pre> 1716 * 1717 * @see #SLIST 1718 * @see #EXPR 1719 * @see #EMPTY_STAT 1720 * @see #LPAREN 1721 * @see #RPAREN 1722 * @see #SEMI 1723 **/ 1724 public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do; 1725 /** 1726 * Literal <code>while</code> in do-while loop. 1727 * @see #LITERAL_DO 1728 */ 1729 public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE; 1730 /** 1731 * The <code>break</code> keyword. The first child is an optional 1732 * identifier and the last child is a semicolon. 1733 * 1734 * @see #IDENT 1735 * @see #SEMI 1736 * @see #SLIST 1737 **/ 1738 public static final int LITERAL_BREAK = 1739 GeneratedJavaTokenTypes.LITERAL_break; 1740 1741 /** 1742 * The <code>continue</code> keyword. The first child is an 1743 * optional identifier and the last child is a semicolon. 1744 * 1745 * @see #IDENT 1746 * @see #SEMI 1747 * @see #SLIST 1748 **/ 1749 public static final int LITERAL_CONTINUE = 1750 GeneratedJavaTokenTypes.LITERAL_continue; 1751 1752 /** 1753 * The <code>return</code> keyword. The first child is an 1754 * optional expression for the return value. The last child is a 1755 * semi colon. 1756 * 1757 * @see #EXPR 1758 * @see #SEMI 1759 * @see #SLIST 1760 **/ 1761 public static final int LITERAL_RETURN = 1762 GeneratedJavaTokenTypes.LITERAL_return; 1763 1764 /** 1765 * The <code>switch</code> keyword. 1766 * 1767 * <p>For example:</p> 1768 * <pre> 1769 * switch(type) 1770 * { 1771 * case 0: 1772 * background = Color.blue; 1773 * break; 1774 * case 1: 1775 * background = Color.red; 1776 * break; 1777 * default: 1778 * background = Color.green; 1779 * break; 1780 * } 1781 * </pre> 1782 * <p>parses as:</p> 1783 * <pre> 1784 * +--LITERAL_SWITCH (switch) 1785 * | 1786 * +--LPAREN (() 1787 * +--EXPR 1788 * | 1789 * +--IDENT (type) 1790 * +--RPAREN ()) 1791 * +--LCURLY ({) 1792 * +--CASE_GROUP 1793 * | 1794 * +--LITERAL_CASE (case) 1795 * | 1796 * +--EXPR 1797 * | 1798 * +--NUM_INT (0) 1799 * +--SLIST 1800 * | 1801 * +--EXPR 1802 * | 1803 * +--ASSIGN (=) 1804 * | 1805 * +--IDENT (background) 1806 * +--DOT (.) 1807 * | 1808 * +--IDENT (Color) 1809 * +--IDENT (blue) 1810 * +--SEMI (;) 1811 * +--LITERAL_BREAK (break) 1812 * | 1813 * +--SEMI (;) 1814 * +--CASE_GROUP 1815 * | 1816 * +--LITERAL_CASE (case) 1817 * | 1818 * +--EXPR 1819 * | 1820 * +--NUM_INT (1) 1821 * +--SLIST 1822 * | 1823 * +--EXPR 1824 * | 1825 * +--ASSIGN (=) 1826 * | 1827 * +--IDENT (background) 1828 * +--DOT (.) 1829 * | 1830 * +--IDENT (Color) 1831 * +--IDENT (red) 1832 * +--SEMI (;) 1833 * +--LITERAL_BREAK (break) 1834 * | 1835 * +--SEMI (;) 1836 * +--CASE_GROUP 1837 * | 1838 * +--LITERAL_DEFAULT (default) 1839 * +--SLIST 1840 * | 1841 * +--EXPR 1842 * | 1843 * +--ASSIGN (=) 1844 * | 1845 * +--IDENT (background) 1846 * +--DOT (.) 1847 * | 1848 * +--IDENT (Color) 1849 * +--IDENT (green) 1850 * +--SEMI (;) 1851 * +--LITERAL_BREAK (break) 1852 * | 1853 * +--SEMI (;) 1854 * +--RCURLY (}) 1855 * </pre> 1856 * 1857 * @see <a 1858 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java 1859 * Language Specification, §14.10</a> 1860 * @see #LPAREN 1861 * @see #EXPR 1862 * @see #RPAREN 1863 * @see #LCURLY 1864 * @see #CASE_GROUP 1865 * @see #RCURLY 1866 * @see #SLIST 1867 **/ 1868 public static final int LITERAL_SWITCH = 1869 GeneratedJavaTokenTypes.LITERAL_switch; 1870 1871 /** 1872 * The <code>throw</code> keyword. The first child is an 1873 * expression that evaluates to a <code>Throwable</code> instance. 1874 * 1875 * @see <a 1876 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java 1877 * Language Specification, §14.17</a> 1878 * @see #SLIST 1879 * @see #EXPR 1880 **/ 1881 public static final int LITERAL_THROW = 1882 GeneratedJavaTokenTypes.LITERAL_throw; 1883 1884 /** 1885 * The <code>else</code> keyword. This appears as a child of an 1886 * <code>if</code> statement. 1887 * 1888 * @see #SLIST 1889 * @see #EXPR 1890 * @see #EMPTY_STAT 1891 * @see #LITERAL_IF 1892 **/ 1893 public static final int LITERAL_ELSE = 1894 GeneratedJavaTokenTypes.LITERAL_else; 1895 1896 /** 1897 * The <code>case</code> keyword. The first child is a constant 1898 * expression that evaluates to a integer. 1899 * 1900 * @see #CASE_GROUP 1901 * @see #EXPR 1902 **/ 1903 public static final int LITERAL_CASE = 1904 GeneratedJavaTokenTypes.LITERAL_case; 1905 1906 /** 1907 * The <code>default</code> keyword. This element has no 1908 * children. 1909 * 1910 * @see #CASE_GROUP 1911 * @see #MODIFIERS 1912 **/ 1913 public static final int LITERAL_DEFAULT = 1914 GeneratedJavaTokenTypes.LITERAL_default; 1915 1916 /** 1917 * The <code>try</code> keyword. The children are a statement 1918 * list, zero or more catch blocks and then an optional finally 1919 * block. 1920 * 1921 * <p>For example:</p> 1922 * <pre> 1923 * try 1924 * { 1925 * FileReader in = new FileReader("abc.txt"); 1926 * } 1927 * catch(IOException ioe) 1928 * { 1929 * } 1930 * finally 1931 * { 1932 * } 1933 * </pre> 1934 * <p>parses as:</p> 1935 * <pre> 1936 * +--LITERAL_TRY (try) 1937 * | 1938 * +--SLIST ({) 1939 * | 1940 * +--VARIABLE_DEF 1941 * | 1942 * +--MODIFIERS 1943 * +--TYPE 1944 * | 1945 * +--IDENT (FileReader) 1946 * +--IDENT (in) 1947 * +--ASSIGN (=) 1948 * | 1949 * +--EXPR 1950 * | 1951 * +--LITERAL_NEW (new) 1952 * | 1953 * +--IDENT (FileReader) 1954 * +--LPAREN (() 1955 * +--ELIST 1956 * | 1957 * +--EXPR 1958 * | 1959 * +--STRING_LITERAL ("abc.txt") 1960 * +--RPAREN ()) 1961 * +--SEMI (;) 1962 * +--RCURLY (}) 1963 * +--LITERAL_CATCH (catch) 1964 * | 1965 * +--LPAREN (() 1966 * +--PARAMETER_DEF 1967 * | 1968 * +--MODIFIERS 1969 * +--TYPE 1970 * | 1971 * +--IDENT (IOException) 1972 * +--IDENT (ioe) 1973 * +--RPAREN ()) 1974 * +--SLIST ({) 1975 * | 1976 * +--RCURLY (}) 1977 * +--LITERAL_FINALLY (finally) 1978 * | 1979 * +--SLIST ({) 1980 * | 1981 * +--RCURLY (}) 1982 * +--RCURLY (}) 1983 * </pre> 1984 * 1985 * @see <a 1986 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java 1987 * Language Specification, §14.19</a> 1988 * @see #SLIST 1989 * @see #LITERAL_CATCH 1990 * @see #LITERAL_FINALLY 1991 **/ 1992 public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try; 1993 1994 /** 1995 * The Java 7 try-with-resources construct. 1996 * 1997 * <p>For example:</p> 1998 * <pre> 1999 * try (Foo foo = new Foo(); Bar bar = new Bar()) { } 2000 * </pre> 2001 * <p>parses as:</p> 2002 * <pre> 2003 * +--LITERAL_TRY (try) 2004 * | 2005 * +--RESOURCE_SPECIFICATION 2006 * | 2007 * +--LPAREN (() 2008 * +--RESOURCES 2009 * | 2010 * +--RESOURCE 2011 * | 2012 * +--MODIFIERS 2013 * +--TYPE 2014 * | 2015 * +--IDENT (Foo) 2016 * +--IDENT (foo) 2017 * +--ASSIGN (=) 2018 * +--EXPR 2019 * | 2020 * +--LITERAL_NEW (new) 2021 * | 2022 * +--IDENT (Foo) 2023 * +--LPAREN (() 2024 * +--ELIST 2025 * +--RPAREN ()) 2026 * +--SEMI (;) 2027 * +--RESOURCE 2028 * | 2029 * +--MODIFIERS 2030 * +--TYPE 2031 * | 2032 * +--IDENT (Bar) 2033 * +--IDENT (bar) 2034 * +--ASSIGN (=) 2035 * +--EXPR 2036 * | 2037 * +--LITERAL_NEW (new) 2038 * | 2039 * +--IDENT (Bar) 2040 * +--LPAREN (() 2041 * +--ELIST 2042 * +--RPAREN ()) 2043 * +--RPAREN ()) 2044 * +--SLIST ({) 2045 * +--RCURLY (}) 2046 * </pre> 2047 * 2048 * <p>Also consider:</p> 2049 * <pre> 2050 * try (BufferedReader br = new BufferedReader(new FileReader(path))) 2051 * { 2052 * return br.readLine(); 2053 * } 2054 * </pre> 2055 * <p>which parses as:</p> 2056 * <pre> 2057 * +--LITERAL_TRY (try) 2058 * | 2059 * +--RESOURCE_SPECIFICATION 2060 * | 2061 * +--LPAREN (() 2062 * +--RESOURCES 2063 * | 2064 * +--RESOURCE 2065 * | 2066 * +--MODIFIERS 2067 * +--TYPE 2068 * | 2069 * +--IDENT (BufferedReader) 2070 * +--IDENT (br) 2071 * +--ASSIGN (=) 2072 * +--EXPR 2073 * | 2074 * +--LITERAL_NEW (new) 2075 * | 2076 * +--IDENT (FileReader) 2077 * +--LPAREN (() 2078 * +--ELIST 2079 * | 2080 * +--EXPR 2081 * | 2082 * +--LITERAL_NEW (new) 2083 * | 2084 * +--IDENT (BufferedReader) 2085 * +--LPAREN (() 2086 * +--ELIST 2087 * | 2088 * +--EXPR 2089 * | 2090 * +--IDENT (path) 2091 * +--RPAREN ()) 2092 * +--RPAREN ()) 2093 * +--RPAREN ()) 2094 * +--SLIST ({) 2095 * | 2096 * +--LITERAL_RETURN (return) 2097 * | 2098 * +--EXPR 2099 * | 2100 * +--METHOD_CALL (() 2101 * | 2102 * +--DOT (.) 2103 * | 2104 * +--IDENT (br) 2105 * +--IDENT (readLine) 2106 * +--ELIST 2107 * +--RPAREN ()) 2108 * +--SEMI (;) 2109 * +--RCURLY (}) 2110 * </pre> 2111 * 2112 * @see #LPAREN 2113 * @see #RESOURCES 2114 * @see #RESOURCE 2115 * @see #SEMI 2116 * @see #RPAREN 2117 * @see #LITERAL_TRY 2118 **/ 2119 public static final int RESOURCE_SPECIFICATION = 2120 GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION; 2121 2122 /** 2123 * A list of resources in the Java 7 try-with-resources construct. 2124 * This is a child of RESOURCE_SPECIFICATION. 2125 * 2126 * @see #RESOURCE_SPECIFICATION 2127 **/ 2128 public static final int RESOURCES = 2129 GeneratedJavaTokenTypes.RESOURCES; 2130 2131 /** 2132 * A resource in the Java 7 try-with-resources construct. 2133 * This is a child of RESOURCES. 2134 * 2135 * @see #RESOURCES 2136 * @see #RESOURCE_SPECIFICATION 2137 **/ 2138 public static final int RESOURCE = 2139 GeneratedJavaTokenTypes.RESOURCE; 2140 2141 /** 2142 * The <code>catch</code> keyword. 2143 * 2144 * @see #LPAREN 2145 * @see #PARAMETER_DEF 2146 * @see #RPAREN 2147 * @see #SLIST 2148 * @see #LITERAL_TRY 2149 **/ 2150 public static final int LITERAL_CATCH = 2151 GeneratedJavaTokenTypes.LITERAL_catch; 2152 2153 /** 2154 * The <code>finally</code> keyword. 2155 * 2156 * @see #SLIST 2157 * @see #LITERAL_TRY 2158 **/ 2159 public static final int LITERAL_FINALLY = 2160 GeneratedJavaTokenTypes.LITERAL_finally; 2161 2162 /** 2163 * The <code>+=</code> (addition assignment) operator. 2164 * 2165 * @see <a 2166 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2167 * Language Specification, §15.26.2</a> 2168 * @see #EXPR 2169 **/ 2170 public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN; 2171 /** 2172 * The <code>-=</code> (subtraction assignment) operator. 2173 * 2174 * @see <a 2175 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2176 * Language Specification, §15.26.2</a> 2177 * @see #EXPR 2178 **/ 2179 public static final int MINUS_ASSIGN = 2180 GeneratedJavaTokenTypes.MINUS_ASSIGN; 2181 2182 /** 2183 * The <code>*=</code> (multiplication assignment) operator. 2184 * 2185 * @see <a 2186 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2187 * Language Specification, §15.26.2</a> 2188 * @see #EXPR 2189 **/ 2190 public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN; 2191 /** 2192 * The <code>/=</code> (division assignment) operator. 2193 * 2194 * @see <a 2195 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2196 * Language Specification, §15.26.2</a> 2197 * @see #EXPR 2198 **/ 2199 public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN; 2200 /** 2201 * The <code>%=</code> (remainder assignment) operator. 2202 * 2203 * @see <a 2204 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2205 * Language Specification, §15.26.2</a> 2206 * @see #EXPR 2207 **/ 2208 public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN; 2209 /** 2210 * The <code>>>=</code> (signed right shift assignment) 2211 * operator. 2212 * 2213 * @see <a 2214 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2215 * Language Specification, §15.26.2</a> 2216 * @see #EXPR 2217 **/ 2218 public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN; 2219 /** 2220 * The <code>>>>=</code> (unsigned right shift assignment) 2221 * operator. 2222 * 2223 * @see <a 2224 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2225 * Language Specification, §15.26.2</a> 2226 * @see #EXPR 2227 **/ 2228 public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN; 2229 /** 2230 * The <code><<=</code> (left shift assignment) operator. 2231 * 2232 * @see <a 2233 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2234 * Language Specification, §15.26.2</a> 2235 * @see #EXPR 2236 **/ 2237 public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN; 2238 /** 2239 * The <code>&=</code> (bitwise AND assignment) operator. 2240 * 2241 * @see <a 2242 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2243 * Language Specification, §15.26.2</a> 2244 * @see #EXPR 2245 **/ 2246 public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN; 2247 /** 2248 * The <code>^=</code> (bitwise exclusive OR assignment) operator. 2249 * 2250 * @see <a 2251 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2252 * Language Specification, §15.26.2</a> 2253 * @see #EXPR 2254 **/ 2255 public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN; 2256 /** 2257 * The <code>|=</code> (bitwise OR assignment) operator. 2258 * 2259 * @see <a 2260 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java 2261 * Language Specification, §15.26.2</a> 2262 * @see #EXPR 2263 **/ 2264 public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN; 2265 /** 2266 * The <code>?</code> (conditional) operator. Technically, 2267 * the colon is also part of this operator, but it appears as a 2268 * separate token. 2269 * 2270 * <p>For example:</p> 2271 * <pre> 2272 * (quantity == 1) ? "": "s" 2273 * </pre> 2274 * <p> 2275 * parses as: 2276 * </p> 2277 * <pre> 2278 * +--QUESTION (?) 2279 * | 2280 * +--LPAREN (() 2281 * +--EQUAL (==) 2282 * | 2283 * +--IDENT (quantity) 2284 * +--NUM_INT (1) 2285 * +--RPAREN ()) 2286 * +--STRING_LITERAL ("") 2287 * +--COLON (:) 2288 * +--STRING_LITERAL ("s") 2289 * </pre> 2290 * 2291 * @see <a 2292 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java 2293 * Language Specification, §15.25</a> 2294 * @see #EXPR 2295 * @see #COLON 2296 **/ 2297 public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION; 2298 /** 2299 * The <code>||</code> (conditional OR) operator. 2300 * 2301 * @see <a 2302 * href="http://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>&&</code> (conditional AND) operator. 2309 * 2310 * @see <a 2311 * href="http://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>|</code> (bitwise OR) operator. 2318 * 2319 * @see <a 2320 * href="http://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>^</code> (bitwise exclusive OR) operator. 2327 * 2328 * @see <a 2329 * href="http://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>&</code> (bitwise AND) operator. 2336 * 2337 * @see <a 2338 * href="http://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 **/ 2348 public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL; 2349 /** 2350 * The <code>==</code> (equal) operator. 2351 * 2352 * @see #EXPR 2353 **/ 2354 public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL; 2355 /** 2356 * The <code><</code> (less than) operator. 2357 * 2358 * @see #EXPR 2359 **/ 2360 public static final int LT = GeneratedJavaTokenTypes.LT; 2361 /** 2362 * The <code>></code> (greater than) operator. 2363 * 2364 * @see #EXPR 2365 **/ 2366 public static final int GT = GeneratedJavaTokenTypes.GT; 2367 /** 2368 * The <code><=</code> (less than or equal) operator. 2369 * 2370 * @see #EXPR 2371 **/ 2372 public static final int LE = GeneratedJavaTokenTypes.LE; 2373 /** 2374 * The <code>>=</code> (greater than or equal) operator. 2375 * 2376 * @see #EXPR 2377 **/ 2378 public static final int GE = GeneratedJavaTokenTypes.GE; 2379 /** 2380 * The <code>instanceof</code> operator. The first child is an 2381 * object reference or something that evaluates to an object 2382 * reference. The second child is a reference type. 2383 * 2384 * @see <a 2385 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java 2386 * Language Specification, §15.20.2</a> 2387 * @see #EXPR 2388 * @see #METHOD_CALL 2389 * @see #IDENT 2390 * @see #DOT 2391 * @see #TYPE 2392 * @see FullIdent 2393 **/ 2394 public static final int LITERAL_INSTANCEOF = 2395 GeneratedJavaTokenTypes.LITERAL_instanceof; 2396 2397 /** 2398 * The <code><<</code> (shift left) operator. 2399 * 2400 * @see <a 2401 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2402 * Language Specification, §15.19</a> 2403 * @see #EXPR 2404 **/ 2405 public static final int SL = GeneratedJavaTokenTypes.SL; 2406 /** 2407 * The <code>>></code> (signed shift right) operator. 2408 * 2409 * @see <a 2410 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2411 * Language Specification, §15.19</a> 2412 * @see #EXPR 2413 **/ 2414 public static final int SR = GeneratedJavaTokenTypes.SR; 2415 /** 2416 * The <code>>>></code> (unsigned shift right) operator. 2417 * 2418 * @see <a 2419 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java 2420 * Language Specification, §15.19</a> 2421 * @see #EXPR 2422 **/ 2423 public static final int BSR = GeneratedJavaTokenTypes.BSR; 2424 /** 2425 * The <code>+</code> (addition) operator. 2426 * 2427 * @see <a 2428 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2429 * Language Specification, §15.18</a> 2430 * @see #EXPR 2431 **/ 2432 public static final int PLUS = GeneratedJavaTokenTypes.PLUS; 2433 /** 2434 * The <code>-</code> (subtraction) operator. 2435 * 2436 * @see <a 2437 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java 2438 * Language Specification, §15.18</a> 2439 * @see #EXPR 2440 **/ 2441 public static final int MINUS = GeneratedJavaTokenTypes.MINUS; 2442 /** 2443 * The <code>/</code> (division) operator. 2444 * 2445 * @see <a 2446 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java 2447 * Language Specification, §15.17.2</a> 2448 * @see #EXPR 2449 **/ 2450 public static final int DIV = GeneratedJavaTokenTypes.DIV; 2451 /** 2452 * The <code>%</code> (remainder) operator. 2453 * 2454 * @see <a 2455 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java 2456 * Language Specification, §15.17.3</a> 2457 * @see #EXPR 2458 **/ 2459 public static final int MOD = GeneratedJavaTokenTypes.MOD; 2460 /** 2461 * The <code>++</code> (prefix increment) operator. 2462 * 2463 * @see <a 2464 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java 2465 * Language Specification, §15.15.1</a> 2466 * @see #EXPR 2467 * @see #POST_INC 2468 **/ 2469 public static final int INC = GeneratedJavaTokenTypes.INC; 2470 /** 2471 * The <code>--</code> (prefix decrement) operator. 2472 * 2473 * @see <a 2474 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java 2475 * Language Specification, §15.15.2</a> 2476 * @see #EXPR 2477 * @see #POST_DEC 2478 **/ 2479 public static final int DEC = GeneratedJavaTokenTypes.DEC; 2480 /** 2481 * The <code>~</code> (bitwise complement) operator. 2482 * 2483 * @see <a 2484 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java 2485 * Language Specification, §15.15.5</a> 2486 * @see #EXPR 2487 **/ 2488 public static final int BNOT = GeneratedJavaTokenTypes.BNOT; 2489 /** 2490 * The <code>!</code> (logical complement) operator. 2491 * 2492 * @see <a 2493 * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java 2494 * Language Specification, §15.15.6</a> 2495 * @see #EXPR 2496 **/ 2497 public static final int LNOT = GeneratedJavaTokenTypes.LNOT; 2498 /** 2499 * The <code>true</code> keyword. 2500 * 2501 * @see <a 2502 * href="http://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</code> keyword. 2512 * 2513 * @see <a 2514 * href="http://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</code> keyword. 2524 * 2525 * @see <a 2526 * href="http://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</code> 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="http://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="http://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="http://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</code> or <code>f</code> suffix. 2704 * 2705 * @see <a 2706 * href="http://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</code> or <code>l</code> 2715 * (ell) suffix. 2716 * 2717 * @see <a 2718 * href="http://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</code> or <code>d</code> 2727 * suffix. 2728 * 2729 * @see <a 2730 * href="http://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</code> 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</code> 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</code>. 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 initialisation 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 initialisation. 3175 * Initializers can not be nested. 3176 * Am initializer may be present as a default to a 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 'at' 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 * '&' symbol when used in a generic upper or lower bounds constrain 3424 * e.g. {@code Comparable<<? extends Serializable, CharSequence>}. 3425 */ 3426 public static final int TYPE_EXTENSION_AND = 3427 GeneratedJavaTokenTypes.TYPE_EXTENSION_AND; 3428 3429 /** 3430 * '<' symbol signifying the start of type arguments or type 3431 * parameters. 3432 */ 3433 public static final int GENERIC_START = 3434 GeneratedJavaTokenTypes.GENERIC_START; 3435 3436 /** 3437 * '>' symbol signifying the end of type arguments or type parameters. 3438 */ 3439 public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END; 3440 3441 /** 3442 * Special lambda symbol '->'. 3443 */ 3444 public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA; 3445 3446 /** 3447 * Beginning of single line comment: '//'. 3448 * 3449 * <pre> 3450 * +--SINGLE_LINE_COMMENT 3451 * | 3452 * +--COMMENT_CONTENT 3453 * </pre> 3454 */ 3455 public static final int SINGLE_LINE_COMMENT = 3456 GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT; 3457 3458 /** 3459 * Beginning of block comment: '/*'. 3460 * 3461 * <pre> 3462 * +--BLOCK_COMMENT_BEGIN 3463 * | 3464 * +--COMMENT_CONTENT 3465 * +--BLOCK_COMMENT_END 3466 * </pre> 3467 */ 3468 public static final int BLOCK_COMMENT_BEGIN = 3469 GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN; 3470 3471 /** 3472 * End of block comment: '* /'. 3473 * 3474 * <pre> 3475 * +--BLOCK_COMMENT_BEGIN 3476 * | 3477 * +--COMMENT_CONTENT 3478 * +--BLOCK_COMMENT_END 3479 * </pre> 3480 */ 3481 public static final int BLOCK_COMMENT_END = 3482 GeneratedJavaTokenTypes.BLOCK_COMMENT_END; 3483 3484 /** 3485 * Text of single-line or block comment. 3486 * 3487 * <pre> 3488 * +--SINGLE_LINE_COMMENT 3489 * | 3490 * +--COMMENT_CONTENT 3491 * </pre> 3492 * 3493 * <pre> 3494 * +--BLOCK_COMMENT_BEGIN 3495 * | 3496 * +--COMMENT_CONTENT 3497 * +--BLOCK_COMMENT_END 3498 * </pre> 3499 */ 3500 public static final int COMMENT_CONTENT = 3501 GeneratedJavaTokenTypes.COMMENT_CONTENT; 3502 3503 /** Prevent instantiation. */ 3504 private TokenTypes() { 3505 } 3506 3507}