Source code: com/puppycrawl/tools/checkstyle/api/TokenTypes.java
1 ////////////////////////////////////////////////////////////////////////////////
2 // checkstyle: Checks Java source code for adherence to a set of rules.
3 // Copyright (C) 2001-2003 Oliver Burn
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 ////////////////////////////////////////////////////////////////////////////////
19 package com.puppycrawl.tools.checkstyle.api;
20
21 import java.util.Map;
22 import java.util.HashMap;
23 import java.lang.reflect.Field;
24
25 /**
26 * Contains the constants for all the tokens contained in the Abstract
27 * Syntax Tree.
28 *
29 * <p>Implementation detail: This class has been introduced to break
30 * the circular dependency between packages.<p>
31 *
32 * @author Oliver Burn
33 * @author <a href="mailto:dobratzp@ele.uri.edu">Peter Dobratz</a>
34 * @version 1.0
35 */
36 public final class TokenTypes
37 {
38 ///CLOVER:OFF
39 /** prevent instantiation */
40 private TokenTypes()
41 {
42 }
43 ///CLOVER:ON
44
45 // The following three types are never part of an AST,
46 // left here as a reminder so nobody will readd them accidentally
47
48 /* * token representing a NULL_TREE_LOOKAHEAD */
49 // public static final int NULL_TREE_LOOKAHEAD = 3;
50 /* * token representing a BLOCK */
51 // public static final int BLOCK = 4;
52 /* * token representing a VOCAB */
53 // public static final int VOCAB = 149;
54
55 // These are the types that can actually occur in an AST
56 // it makes sense to register Checks for these types
57
58 /**
59 * The end of file token. This is the root node for the source
60 * file. It's children are an optional package definition, zero
61 * or more import statements, and one or more class or interface
62 * definitions.
63 *
64 * @see #PACKAGE_DEF
65 * @see #IMPORT
66 * @see #CLASS_DEF
67 * @see #INTERFACE_DEF
68 **/
69 public static final int EOF = GeneratedJava14TokenTypes.EOF;
70 /**
71 * Modifiers for type, method, and field declarations. The
72 * modifiers element is always present even though it may have no
73 * children.
74 *
75 * @see <a target="_top"
76 * href="http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html">Java
77 * Language Specification, Chapter 8</a>
78 * @see #LITERAL_PUBLIC
79 * @see #LITERAL_PROTECTED
80 * @see #LITERAL_PRIVATE
81 * @see #ABSTRACT
82 * @see #LITERAL_STATIC
83 * @see #FINAL
84 * @see #LITERAL_TRANSIENT
85 * @see #LITERAL_VOLATILE
86 * @see #LITERAL_SYNCHRONIZED
87 * @see #LITERAL_NATIVE
88 * @see #STRICTFP
89 **/
90 public static final int MODIFIERS = GeneratedJava14TokenTypes.MODIFIERS;
91 /**
92 * An object block. These are children of class and interface
93 * declarations. Also, object blocks are children of the new
94 * keyword when defining anonymous inner classes.
95 *
96 * @see #LCURLY
97 * @see #INSTANCE_INIT
98 * @see #STATIC_INIT
99 * @see #CLASS_DEF
100 * @see #CTOR_DEF
101 * @see #METHOD_DEF
102 * @see #VARIABLE_DEF
103 * @see #RCURLY
104 * @see #INTERFACE_DEF
105 * @see #LITERAL_NEW
106 **/
107 public static final int OBJBLOCK = GeneratedJava14TokenTypes.OBJBLOCK;
108 /**
109 * A list of statements.
110 *
111 * @see #RCURLY
112 * @see #EXPR
113 * @see #LABELED_STAT
114 * @see #LITERAL_THROWS
115 * @see #LITERAL_RETURN
116 * @see #SEMI
117 * @see #METHOD_DEF
118 * @see #CTOR_DEF
119 * @see #LITERAL_FOR
120 * @see #LITERAL_WHILE
121 * @see #LITERAL_IF
122 * @see #LITERAL_ELSE
123 * @see #CASE_GROUP
124 **/
125 public static final int SLIST = GeneratedJava14TokenTypes.SLIST;
126 /**
127 * A constructor declaration.
128 *
129 * <p>For example:</p>
130 * <pre>
131 * public SpecialEntry(int value, String text)
132 * {
133 * this.value = value;
134 * this.text = text;
135 * }
136 * </pre>
137 * <p>parses as:</p>
138 * <pre>
139 * +--CTOR_DEF
140 * |
141 * +--MODIFIERS
142 * |
143 * +--LITERAL_PUBLIC (public)
144 * +--IDENT (SpecialEntry)
145 * +--LPAREN (()
146 * +--PARAMETERS
147 * |
148 * +--PARAMETER_DEF
149 * |
150 * +--MODIFIERS
151 * +--TYPE
152 * |
153 * +--LITERAL_INT (int)
154 * +--IDENT (value)
155 * +--COMMA (,)
156 * +--PARAMETER_DEF
157 * |
158 * +--MODIFIERS
159 * +--TYPE
160 * |
161 * +--IDENT (String)
162 * +--IDENT (text)
163 * +--RPAREN ())
164 * +--SLIST ({)
165 * |
166 * +--EXPR
167 * |
168 * +--ASSIGN (=)
169 * |
170 * +--DOT (.)
171 * |
172 * +--LITERAL_THIS (this)
173 * +--IDENT (value)
174 * +--IDENT (value)
175 * +--SEMI (;)
176 * +--EXPR
177 * |
178 * +--ASSIGN (=)
179 * |
180 * +--DOT (.)
181 * |
182 * +--LITERAL_THIS (this)
183 * +--IDENT (text)
184 * +--IDENT (text)
185 * +--SEMI (;)
186 * +--RCURLY (})
187 * </pre>
188 *
189 * @see #OBJBLOCK
190 * @see #CLASS_DEF
191 **/
192 public static final int CTOR_DEF = GeneratedJava14TokenTypes.CTOR_DEF;
193 /**
194 * A method declaration. The children are modifiers, return type,
195 * method name, parameter list, an optional throws list, and
196 * statement list. The statement list is omitted if the method
197 * declaration appears in an interface declaration. Method
198 * declarations may appear inside object blocks of class
199 * declarations, interface declarations, or anonymous inner-class
200 * declarations.
201 *
202 * <p>For example:</p>
203 *
204 * <pre>
205 * public static int square(int x)
206 * {
207 * return x*x;
208 * }
209 * </pre>
210 *
211 * <p>parses as:</p>
212 *
213 * <pre>
214 * +--METHOD_DEF
215 * |
216 * +--MODIFIERS
217 * |
218 * +--LITERAL_PUBLIC (public)
219 * +--LITERAL_STATIC (static)
220 * +--TYPE
221 * |
222 * +--LITERAL_INT (int)
223 * +--IDENT (square)
224 * +--PARAMETERS
225 * |
226 * +--PARAMETER_DEF
227 * |
228 * +--MODIFIERS
229 * +--TYPE
230 * |
231 * +--LITERAL_INT (int)
232 * +--IDENT (x)
233 * +--SLIST ({)
234 * |
235 * +--LITERAL_RETURN (return)
236 * |
237 * +--EXPR
238 * |
239 * +--STAR (*)
240 * |
241 * +--IDENT (x)
242 * +--IDENT (x)
243 * +--SEMI (;)
244 * +--RCURLY (})
245 * </pre>
246 *
247 * @see #MODIFIERS
248 * @see #TYPE
249 * @see #IDENT
250 * @see #PARAMETERS
251 * @see #LITERAL_THROWS
252 * @see #SLIST
253 * @see #OBJBLOCK
254 **/
255 public static final int METHOD_DEF = GeneratedJava14TokenTypes.METHOD_DEF;
256 /**
257 * A field or local variable declaration. The children are
258 * modifiers, type, the identifier name, and an optional
259 * assignment statement.
260 *
261 * @see #MODIFIERS
262 * @see #TYPE
263 * @see #IDENT
264 * @see #ASSIGN
265 **/
266 public static final int VARIABLE_DEF =
267 GeneratedJava14TokenTypes.VARIABLE_DEF;
268
269 /**
270 * An instance initializer. Zero or more instance initializers
271 * may appear in class definitions. This token will be a child of
272 * the object block in either a normal or anonymous inner class.
273 *
274 * @see <a target="_top"
275 * href="http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#246032">Java
276 * Language Specification§8.6</a>
277 * @see #SLIST
278 * @see #OBJBLOCK
279 **/
280 public static final int INSTANCE_INIT =
281 GeneratedJava14TokenTypes.INSTANCE_INIT;
282
283 /**
284 * A static initialization block. Zero or more static
285 * initializers may be children of the object block of a class
286 * declaration (interfaces cannot have static initializers). The
287 * first and only child is a statement list.
288 *
289 * @see <a target="_top"
290 * href="http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#39245">Java
291 * Language Specification, §8.7</a>
292 * @see #SLIST
293 * @see #OBJBLOCK
294 **/
295 public static final int STATIC_INIT =
296 GeneratedJava14TokenTypes.STATIC_INIT;
297
298 /**
299 * A type. This is either a return type of a method or a type of
300 * a variable or field. The first child of this element is the
301 * actual type. This may be a primitive type, an identifier, a
302 * dot which is the root of a fully qualified type, or an array of
303 * any of these.
304 *
305 * @see #VARIABLE_DEF
306 * @see #METHOD_DEF
307 * @see #PARAMETER_DEF
308 * @see #IDENT
309 * @see #DOT
310 * @see #LITERAL_VOID
311 * @see #LITERAL_BOOLEAN
312 * @see #LITERAL_BYTE
313 * @see #LITERAL_CHAR
314 * @see #LITERAL_SHORT
315 * @see #LITERAL_INT
316 * @see #LITERAL_FLOAT
317 * @see #LITERAL_LONG
318 * @see #LITERAL_DOUBLE
319 * @see #ARRAY_DECLARATOR
320 **/
321 public static final int TYPE = GeneratedJava14TokenTypes.TYPE;
322 /**
323 * A class declaration.
324 *
325 * <p>For example:</p>
326 * <pre>
327 * public class MyClass
328 * implements Serializable
329 * {
330 * }
331 * </pre>
332 * <p>parses as:</p>
333 * <pre>
334 * +--CLASS_DEF
335 * |
336 * +--MODIFIERS
337 * |
338 * +--LITERAL_PUBLIC (public)
339 * +--IDENT (MyClass)
340 * +--EXTENDS_CLAUSE
341 * +--IMPLEMENTS_CLAUSE
342 * |
343 * +--IDENT (Serializable)
344 * +--OBJBLOCK
345 * |
346 * +--LCURLY ({)
347 * +--RCURLY (})
348 * </pre>
349 *
350 * @see <a target="_top"
351 * href="http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html">Java
352 * Language Specification, Chapter 8</a>
353 * @see #MODIFIERS
354 * @see #IDENT
355 * @see #EXTENDS_CLAUSE
356 * @see #IMPLEMENTS_CLAUSE
357 * @see #OBJBLOCK
358 * @see #LITERAL_NEW
359 **/
360 public static final int CLASS_DEF = GeneratedJava14TokenTypes.CLASS_DEF;
361 /**
362 * An interface declaration.
363 *
364 * <p>For example:</p>
365 *
366 * <pre>
367 * public interface MyInterface
368 * {
369 * }
370 *
371 * </pre>
372 *
373 * <p>parses as:</p>
374 *
375 * <pre>
376 * +--INTERFACE_DEF
377 * |
378 * +--MODIFIERS
379 * |
380 * +--LITERAL_PUBLIC (public)
381 * +--IDENT (MyInterface)
382 * +--EXTENDS_CLAUSE
383 * +--OBJBLOCK
384 * |
385 * +--LCURLY ({)
386 * +--RCURLY (})
387 * </pre>
388 *
389 * @see <a target="_top"
390 * href="http://java.sun.com/docs/books/jls/second_edition/html/interfaces.doc.html">Java
391 * Language Specification, Chapter 9</a>
392 * @see #MODIFIERS
393 * @see #IDENT
394 * @see #EXTENDS_CLAUSE
395 * @see #OBJBLOCK
396 **/
397 public static final int INTERFACE_DEF =
398 GeneratedJava14TokenTypes.INTERFACE_DEF;
399
400 /**
401 * The package declaration. This is optional, but if it is
402 * included, then there is only one package declaration per source
403 * file and it must be the first non-comment in the file.
404 * <p>For example:</p>
405 *
406 * <pre>
407 * package com.puppycrawl.tools.checkstyle.api;
408 * </pre>
409 *
410 * <p>parses as:</p>
411 *
412 * <pre>
413 * +--PACKAGE_DEF (package)
414 * |
415 * +--DOT (.)
416 * |
417 * +--DOT (.)
418 * |
419 * +--DOT (.)
420 * |
421 * +--DOT (.)
422 * |
423 * +--IDENT (com)
424 * +--IDENT (puppycrawl)
425 * +--IDENT (tools)
426 * +--IDENT (checkstyle)
427 * +--IDENT (api)
428 * +--SEMI (;)
429 * </pre>
430 *
431 * @see <a target="_top"
432 * href="http://java.sun.com/docs/books/jls/second_edition/html/packages.doc.html#26619">Java
433 * Language Specification §7.4</a>
434 * @see #DOT
435 * @see #IDENT
436 * @see #SEMI
437 * @see FullIdent
438 **/
439 public static final int PACKAGE_DEF = GeneratedJava14TokenTypes.PACKAGE_DEF;
440 /**
441 * An array declaration.
442 *
443 * <p>If the array declaration represents a type, then the type of
444 * the array elements is the first child. Multidimensional arrays
445 * may be regarded as arrays of arrays. In other words, the first
446 * child of the array declaration is another array
447 * declaration.</p>
448 *
449 * <p>For example:</p>
450 * <pre>
451 * int[] x;
452 * </pre>
453 * <p>parses as:</p>
454 * <pre>
455 * +--VARIABLE_DEF
456 * |
457 * +--MODIFIERS
458 * +--TYPE
459 * |
460 * +--ARRAY_DECLARATOR ([)
461 * |
462 * +--LITERAL_INT (int)
463 * +--IDENT (x)
464 * +--SEMI (;)
465 * </pre>
466 *
467 * <p>The array declaration may also represent an inline array
468 * definition. In this case, the first child will be either an
469 * expression specifying the length of the array or an array
470 * initialization block.</p>
471 *
472 * @see <a target="_top"
473 * href="http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html">Java
474 * Language Specification Chapter 10</a>
475 * @see #TYPE
476 * @see #ARRAY_INIT
477 **/
478 public static final int ARRAY_DECLARATOR =
479 GeneratedJava14TokenTypes.ARRAY_DECLARATOR;
480
481 /**
482 * An extends clause. This appear as part of class and interface
483 * definitions. This element appears even if the
484 * <code>extends</code> keyword is not explicitly used. The child
485 * is an optional identifier.
486 *
487 * <p>For example:</p>
488 * <pre>
489 * </pre>
490 * <p>parses as:</p>
491 * <pre>
492 * +--EXTENDS_CLAUSE
493 * |
494 * +--DOT (.)
495 * |
496 * +--DOT (.)
497 * |
498 * +--IDENT (java)
499 * +--IDENT (util)
500 * +--IDENT (LinkedList)
501 * </pre>
502 *
503 * @see #IDENT
504 * @see #DOT
505 * @see #CLASS_DEF
506 * @see #INTERFACE_DEF
507 * @see FullIdent
508 **/
509 public static final int EXTENDS_CLAUSE =
510 GeneratedJava14TokenTypes.EXTENDS_CLAUSE;
511
512 /**
513 * An implements clause. This always appears in a class
514 * declaration, even if there are no implemented interfaces. The
515 * children are a comma separated list of zero or more
516 * identifiers.
517 *
518 * <p>For example:</p>
519 * <pre>
520 * implements Serializable, Comparable
521 * </pre>
522 * <p>parses as:</p>
523 * <pre>
524 * +--IMPLEMENTS_CLAUSE
525 * |
526 * +--IDENT (Serializable)
527 * +--COMMA (,)
528 * +--IDENT (Comparable)
529 * </pre>
530 *
531 * @see #IDENT
532 * @see #DOT
533 * @see #COMMA
534 * @see #CLASS_DEF
535 **/
536 public static final int IMPLEMENTS_CLAUSE =
537 GeneratedJava14TokenTypes.IMPLEMENTS_CLAUSE;
538
539 /**
540 * A list of parameters to a method or constructor. The children
541 * are zero or more parameter declarations separated by commas.
542 *
543 * <p>For example</p>
544 * <pre>
545 * int start, int end
546 * </pre>
547 * <p>parses as:</p>
548 * <pre>
549 * +--PARAMETERS
550 * |
551 * +--PARAMETER_DEF
552 * |
553 * +--MODIFIERS
554 * +--TYPE
555 * |
556 * +--LITERAL_INT (int)
557 * +--IDENT (start)
558 * +--COMMA (,)
559 * +--PARAMETER_DEF
560 * |
561 * +--MODIFIERS
562 * +--TYPE
563 * |
564 * +--LITERAL_INT (int)
565 * +--IDENT (end)
566 * </pre>
567 *
568 * @see #PARAMETER_DEF
569 * @see #COMMA
570 * @see #METHOD_DEF
571 * @see #CTOR_DEF
572 **/
573 public static final int PARAMETERS = GeneratedJava14TokenTypes.PARAMETERS;
574 /**
575 * A parameter declaration.
576 *
577 * @see #MODIFIERS
578 * @see #TYPE
579 * @see #IDENT
580 * @see #PARAMETERS
581 **/
582 public static final int PARAMETER_DEF =
583 GeneratedJava14TokenTypes.PARAMETER_DEF;
584
585 /**
586 * A labeled statement.
587 *
588 * <p>For example:</p>
589 * <pre>
590 * outside: ;
591 * </pre>
592 * <p>parses as:</p>
593 * <pre>
594 * +--LABELED_STAT (:)
595 * |
596 * +--IDENT (outside)
597 * +--EMPTY_STAT (;)
598 * </pre>
599 *
600 * @see <a target="_top"
601 * href="http://java.sun.com/docs/books/jls/second_edition/html/statements.doc.html#78993">Java
602 * Language Specification, §14.7</a>
603 * @see #SLIST
604 **/
605 public static final int LABELED_STAT =
606 GeneratedJava14TokenTypes.LABELED_STAT;
607
608 /**
609 * A type-cast.
610 *
611 * <p>For example:</p>
612 * <pre>
613 * (String)it.next()
614 * </pre>
615 * <p>parses as:</p>
616 * <pre>
617 * +--TYPECAST (()
618 * |
619 * +--TYPE
620 * |
621 * +--IDENT (String)
622 * +--RPAREN ())
623 * +--METHOD_CALL (()
624 * |
625 * +--DOT (.)
626 * |
627 * +--IDENT (it)
628 * +--IDENT (next)
629 * +--ELIST
630 * +--RPAREN ())
631 * </pre>
632 * @see <a target="_top"
633 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#238146">Java
634 * Language Specification, §15.16</a>
635 * @see #EXPR
636 * @see #TYPE
637 * @see #RPAREN
638 **/
639 public static final int TYPECAST = GeneratedJava14TokenTypes.TYPECAST;
640 /**
641 * The array index operator.
642 *
643 * <p>For example:</p>
644 * <pre>
645 * ar[2] = 5;
646 * </pre>
647 * <p>parses as:</p>
648 * <pre>
649 * +--EXPR
650 * |
651 * +--ASSIGN (=)
652 * |
653 * +--INDEX_OP ([)
654 * |
655 * +--IDENT (ar)
656 * +--EXPR
657 * |
658 * +--NUM_INT (2)
659 * +--NUM_INT (5)
660 * +--SEMI (;)
661 * </pre>
662 *
663 * @see #EXPR
664 **/
665 public static final int INDEX_OP = GeneratedJava14TokenTypes.INDEX_OP;
666 /**
667 * The <code>++</code> (postfix increment) operator.
668 *
669 * @see <a target="_top"
670 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#39438">Java
671 * Language Specification, §15.14.1</a>
672 * @see #EXPR
673 * @see #INC
674 **/
675 public static final int POST_INC = GeneratedJava14TokenTypes.POST_INC;
676 /**
677 * The <code>--</code> (postfix decrement) operator.
678 *
679 * @see <a target="_top"
680 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#4987">Java
681 * Language Specification, §15.14.2</a>
682 * @see #EXPR
683 * @see #DEC
684 **/
685 public static final int POST_DEC = GeneratedJava14TokenTypes.POST_DEC;
686 /**
687 * A method call.
688 *
689 * <p>For example:</p>
690 * <pre>
691 * Math.random()
692 * </pre>
693 * <p>parses as:
694 * <pre>
695 * +--METHOD_CALL (()
696 * |
697 * +--DOT (.)
698 * |
699 * +--IDENT (Math)
700 * +--IDENT (random)
701 * +--ELIST
702 * +--RPAREN ())
703 * </pre>
704 *
705 * @see #IDENT
706 * @see #DOT
707 * @see #ELIST
708 * @see #RPAREN
709 * @see FullIdent
710 **/
711 public static final int METHOD_CALL = GeneratedJava14TokenTypes.METHOD_CALL;
712 /**
713 * An expression. Operators with lower precedence appear at a
714 * higher level in the tree than operators with higher precedence.
715 * Parentheses are siblings to the operator they enclose.
716 *
717 * <p>For example:</p>
718 * <pre>
719 * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3);
720 * </pre>
721 * <p>parses as:</p>
722 * <pre>
723 * +--EXPR
724 * |
725 * +--ASSIGN (=)
726 * |
727 * +--IDENT (x)
728 * +--PLUS (+)
729 * |
730 * +--PLUS (+)
731 * |
732 * +--PLUS (+)
733 * |
734 * +--PLUS (+)
735 * |
736 * +--NUM_INT (4)
737 * +--STAR (*)
738 * |
739 * +--NUM_INT (3)
740 * +--NUM_INT (5)
741 * +--DIV (/)
742 * |
743 * +--LPAREN (()
744 * +--PLUS (+)
745 * |
746 * +--NUM_INT (30)
747 * +--NUM_INT (26)
748 * +--RPAREN ())
749 * +--NUM_INT (4)
750 * +--MOD (%)
751 * |
752 * +--NUM_INT (5)
753 * +--NUM_INT (4)
754 * +--LPAREN (()
755 * +--SL (<<)
756 * |
757 * +--NUM_INT (1)
758 * +--NUM_INT (3)
759 * +--RPAREN ())
760 * +--SEMI (;)
761 * </pre>
762 *
763 * @see #ELIST
764 * @see #ASSIGN
765 * @see #LPAREN
766 * @see #RPAREN
767 **/
768 public static final int EXPR = GeneratedJava14TokenTypes.EXPR;
769 /**
770 * An array initialization. This may occur as part of an array
771 * declaration or inline with <code>new</code>.
772 *
773 * <p>For example:</p>
774 * <pre>
775 * int[] y =
776 * {
777 * 1,
778 * 2,
779 * };
780 * </pre>
781 * <p>parses as:</p>
782 * <pre>
783 * +--VARIABLE_DEF
784 * |
785 * +--MODIFIERS
786 * +--TYPE
787 * |
788 * +--ARRAY_DECLARATOR ([)
789 * |
790 * +--LITERAL_INT (int)
791 * +--IDENT (y)
792 * +--ASSIGN (=)
793 * |
794 * +--ARRAY_INIT ({)
795 * |
796 * +--EXPR
797 * |
798 * +--NUM_INT (1)
799 * +--COMMA (,)
800 * +--EXPR
801 * |
802 * +--NUM_INT (2)
803 * +--COMMA (,)
804 * +--RCURLY (})
805 * +--SEMI (;)
806 * </pre>
807 *
808 * <p>Also consider:</p>
809 * <pre>
810 * int[] z = new int[]
811 * {
812 * 1,
813 * 2,
814 * };
815 * </pre>
816 * <p>which parses as:</p>
817 * <pre>
818 * +--VARIABLE_DEF
819 * |
820 * +--MODIFIERS
821 * +--TYPE
822 * |
823 * +--ARRAY_DECLARATOR ([)
824 * |
825 * +--LITERAL_INT (int)
826 * +--IDENT (z)
827 * +--ASSIGN (=)
828 * |
829 * +--EXPR
830 * |
831 * +--LITERAL_NEW (new)
832 * |
833 * +--LITERAL_INT (int)
834 * +--ARRAY_DECLARATOR ([)
835 * +--ARRAY_INIT ({)
836 * |
837 * +--EXPR
838 * |
839 * +--NUM_INT (1)
840 * +--COMMA (,)
841 * +--EXPR
842 * |
843 * +--NUM_INT (2)
844 * +--COMMA (,)
845 * +--RCURLY (})
846 * </pre>
847 *
848 * @see #ARRAY_DECLARATOR
849 * @see #TYPE
850 * @see #LITERAL_NEW
851 * @see #COMMA
852 **/
853 public static final int ARRAY_INIT = GeneratedJava14TokenTypes.ARRAY_INIT;
854 /**
855 * An import declaration. Import declarations are option, but
856 * must appear after the package declaration and before the type
857 * declaration.
858 *
859 * <p>For example:</p>
860 *
861 * <pre>
862 * import java.io.IOException;
863 * </pre>
864 *
865 * <p>parses as:</p>
866 *
867 * <pre>
868 * +--IMPORT (import)
869 * |
870 * +--DOT (.)
871 * |
872 * +--DOT (.)
873 * |
874 * +--IDENT (java)
875 * +--IDENT (io)
876 * +--IDENT (IOException)
877 * +--SEMI (;)
878 * </pre>
879 *
880 * @see <a target="_top"
881 * href="http://java.sun.com/docs/books/jls/second_edition/html/packages.doc.html#70209">Java
882 * Language Specification §7.5</a>
883 * @see #DOT
884 * @see #IDENT
885 * @see #STAR
886 * @see #SEMI
887 * @see FullIdent
888 **/
889 public static final int IMPORT = GeneratedJava14TokenTypes.IMPORT;
890 /**
891 * The <code>+</code> (unary plus) operator.
892 *
893 * @see <a target="_top"
894 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#24924">Java
895 * Language Specification, §15.15.3</a>
896 * @see #EXPR
897 **/
898 public static final int UNARY_MINUS = GeneratedJava14TokenTypes.UNARY_MINUS;
899 /**
900 * The <code>-</code> (unary minus) operator.
901 *
902 * @see <a target="_top"
903 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#236345">Java
904 * Language Specification, §15.15.4</a>
905 * @see #EXPR
906 **/
907 public static final int UNARY_PLUS = GeneratedJava14TokenTypes.UNARY_PLUS;
908 /**
909 * A group of case clauses. Case clauses with no associated
910 * statements are grouped together into a case group. The last
911 * child is a statement list containing the statements to execute
912 * upon a match.
913 *
914 * <p>For example:</p>
915 * <pre>
916 * case 0:
917 * case 1:
918 * case 2:
919 * x = 3;
920 * break;
921 * </pre>
922 * <p>parses as:</p>
923 * <pre>
924 * +--CASE_GROUP
925 * |
926 * +--LITERAL_CASE (case)
927 * |
928 * +--EXPR
929 * |
930 * +--NUM_INT (0)
931 * +--LITERAL_CASE (case)
932 * |
933 * +--EXPR
934 * |
935 * +--NUM_INT (1)
936 * +--LITERAL_CASE (case)
937 * |
938 * +--EXPR
939 * |
940 * +--NUM_INT (2)
941 * +--SLIST
942 * |
943 * +--EXPR
944 * |
945 * +--ASSIGN (=)
946 * |
947 * +--IDENT (x)
948 * +--NUM_INT (3)
949 * +--SEMI (;)
950 * +--LITERAL_BREAK (break)
951 * |
952 * +--SEMI (;)
953 * </pre>
954 *
955 * @see #LITERAL_CASE
956 * @see #LITERAL_DEFAULT
957 * @see #LITERAL_SWITCH
958 **/
959 public static final int CASE_GROUP = GeneratedJava14TokenTypes.CASE_GROUP;
960 /**
961 * An expression list. The children are a comma separated list of
962 * expressions.
963 *
964 * @see #LITERAL_NEW
965 * @see #FOR_INIT
966 * @see #FOR_ITERATOR
967 * @see #EXPR
968 * @see #METHOD_CALL
969 * @see #CTOR_CALL
970 * @see #SUPER_CTOR_CALL
971 **/
972 public static final int ELIST = GeneratedJava14TokenTypes.ELIST;
973 /**
974 * A for loop initializer. This is a child of
975 * <code>LITERAL_FOR</code>. The children of this element may be
976 * a comma separated list of variable declarations, an expression
977 * list, or empty.
978 *
979 * @see #VARIABLE_DEF
980 * @see #ELIST
981 * @see #LITERAL_FOR
982 **/
983 public static final int FOR_INIT = GeneratedJava14TokenTypes.FOR_INIT;
984 /**
985 * A for loop condition. This is a child of
986 * <code>LITERAL_FOR</code>. The child of this element is an
987 * optional expression.
988 *
989 * @see #EXPR
990 * @see #LITERAL_FOR
991 **/
992 public static final int FOR_CONDITION =
993 GeneratedJava14TokenTypes.FOR_CONDITION;
994
995 /**
996 * A for loop iterator. This is a child of
997 * <code>LITERAL_FOR</code>. The child of this element is an
998 * optional expression list.
999 *
1000 * @see #ELIST
1001 * @see #LITERAL_FOR
1002 **/
1003 public static final int FOR_ITERATOR =
1004 GeneratedJava14TokenTypes.FOR_ITERATOR;
1005
1006 /**
1007 * The empty statement. This goes in place of an
1008 * <code>SLIST</code> for a <code>for</code> or <code>while</code>
1009 * loop body.
1010 *
1011 * @see <a target="_top"
1012 * href="http://java.sun.com/docs/books/jls/second_edition/html/statements.doc.html#5970">Java
1013 * Language Specification, §14.6</a>
1014 * @see #LITERAL_FOR
1015 * @see #LITERAL_WHILE
1016 **/
1017 public static final int EMPTY_STAT = GeneratedJava14TokenTypes.EMPTY_STAT;
1018 /**
1019 * The <code>final</code> keyword.
1020 *
1021 * @see #MODIFIERS
1022 **/
1023 public static final int FINAL = GeneratedJava14TokenTypes.FINAL;
1024 /**
1025 * The <code>abstract</code> keyword.
1026 *
1027 * @see #MODIFIERS
1028 **/
1029 public static final int ABSTRACT = GeneratedJava14TokenTypes.ABSTRACT;
1030 /**
1031 * The <code>strictfp</code> keyword.
1032 *
1033 * @see #MODIFIERS
1034 **/
1035 public static final int STRICTFP = GeneratedJava14TokenTypes.STRICTFP;
1036 /**
1037 * A super constructor call.
1038 *
1039 * @see #ELIST
1040 * @see #RPAREN
1041 * @see #SEMI
1042 * @see #CTOR_CALL
1043 **/
1044 public static final int SUPER_CTOR_CALL =
1045 GeneratedJava14TokenTypes.SUPER_CTOR_CALL;
1046
1047 /**
1048 * A constructor call.
1049 *
1050 * <p>For example:</p>
1051 * <pre>
1052 * this(1);
1053 * </pre>
1054 * <p>parses as:</p>
1055 * <pre>
1056 * +--CTOR_CALL (()
1057 * |
1058 * +--ELIST
1059 * |
1060 * +--EXPR
1061 * |
1062 * +--NUM_INT (1)
1063 * +--RPAREN ())
1064 * +--SEMI (;)
1065 * </pre>
1066 *
1067 * @see #ELIST
1068 * @see #RPAREN
1069 * @see #SEMI
1070 * @see #SUPER_CTOR_CALL
1071 **/
1072 public static final int CTOR_CALL = GeneratedJava14TokenTypes.CTOR_CALL;
1073 /* *
1074 * This token does not appear in the tree.
1075 *
1076 * @see #PACKAGE_DEF
1077 **/
1078 //public static final int LITERAL_PACKAGE =
1079 // GeneratedJava14TokenTypes.LITERAL_package;
1080
1081 /**
1082 * The statement terminator (<code>;</code>). Depending on the
1083 * context, this make occur as a sibling, a child, or not at all.
1084 *
1085 * @see #PACKAGE_DEF
1086 * @see #IMPORT
1087 * @see #SLIST
1088 * @see #ARRAY_INIT
1089 * @see #LITERAL_FOR
1090 **/
1091 public static final int SEMI = GeneratedJava14TokenTypes.SEMI;
1092 /* *
1093 * This token does not appear in the tree.
1094 *
1095 * @see #IMPORT
1096 **/
1097 // public static final int LITERAL_IMPORT =
1098 // GeneratedJava14TokenTypes.LITERAL_import;
1099
1100 /* *
1101 * This token does not appear in the tree.
1102 *
1103 * @see #INDEX_OP
1104 * @see #ARRAY_DECLARATOR
1105 **/
1106 //public static final int LBRACK = GeneratedJava14TokenTypes.LBRACK;
1107 /* *
1108 * This token does not appear in the tree.
1109 *
1110 * @see #INDEX_OP
1111 * @see #ARRAY_DECLARATOR
1112 **/
1113 //public static final int RBRACK = GeneratedJava14TokenTypes.RBRACK;
1114 /**
1115 * The <code>void</code> keyword.
1116 *
1117 * @see #TYPE
1118 **/
1119 public static final int LITERAL_VOID =
1120 GeneratedJava14TokenTypes.LITERAL_void;
1121
1122 /**
1123 * The <code>boolean</code> keyword.
1124 *
1125 * @see #TYPE
1126 **/
1127 public static final int LITERAL_BOOLEAN =
1128 GeneratedJava14TokenTypes.LITERAL_boolean;
1129
1130 /**
1131 * The <code>byte</code> keyword.
1132 *
1133 * @see #TYPE
1134 **/
1135 public static final int LITERAL_BYTE =
1136 GeneratedJava14TokenTypes.LITERAL_byte;
1137
1138 /**
1139 * The <code>char</code> keyword.
1140 *
1141 * @see #TYPE
1142 **/
1143 public static final int LITERAL_CHAR =
1144 GeneratedJava14TokenTypes.LITERAL_char;
1145
1146 /**
1147 * The <code>short</code> keyword.
1148 *
1149 * @see #TYPE
1150 **/
1151 public static final int LITERAL_SHORT =
1152 GeneratedJava14TokenTypes.LITERAL_short;
1153
1154 /**
1155 * The <code>int</code> keyword.
1156 *
1157 * @see #TYPE
1158 **/
1159 public static final int LITERAL_INT = GeneratedJava14TokenTypes.LITERAL_int;
1160 /**
1161 * The <code>float</code> keyword.
1162 *
1163 * @see #TYPE
1164 **/
1165 public static final int LITERAL_FLOAT =
1166 GeneratedJava14TokenTypes.LITERAL_float;
1167
1168 /**
1169 * The <code>long</code> keyword.
1170 *
1171 * @see #TYPE
1172 **/
1173 public static final int LITERAL_LONG =
1174 GeneratedJava14TokenTypes.LITERAL_long;
1175
1176 /**
1177 * The <code>double</code> keyword.
1178 *
1179 * @see #TYPE
1180 **/
1181 public static final int LITERAL_DOUBLE =
1182 GeneratedJava14TokenTypes.LITERAL_double;
1183
1184 /**
1185 * An identifier. These can be names of types, subpackages,
1186 * fields, methods, parameters, and local variables.
1187 **/
1188 public static final int IDENT = GeneratedJava14TokenTypes.IDENT;
1189 /**
1190 * The <code>.</code> (dot) operator.
1191 *
1192 * @see FullIdent
1193 **/
1194 public static final int DOT = GeneratedJava14TokenTypes.DOT;
1195 /**
1196 * The <code>*</code> (multiplication or wildcard) operator.
1197 *
1198 * @see <a target="_top"
1199 * href="http://java.sun.com/docs/books/jls/second_edition/html/packages.doc.html#26725">Java
1200 * Language Specification, §7.5.2</a>
1201 * @see <a target="_top"
1202 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5036">Java
1203 * Language Specification, §15.17.1</a>
1204 * @see #EXPR
1205 * @see #IMPORT
1206 **/
1207 public static final int STAR = GeneratedJava14TokenTypes.STAR;
1208 /**
1209 * The <code>private</code> keyword.
1210 *
1211 * @see #MODIFIERS
1212 **/
1213 public static final int LITERAL_PRIVATE =
1214 GeneratedJava14TokenTypes.LITERAL_private;
1215
1216 /**
1217 * The <code>public</code> keyword.
1218 *
1219 * @see #MODIFIERS
1220 **/
1221 public static final int LITERAL_PUBLIC =
1222 GeneratedJava14TokenTypes.LITERAL_public;
1223
1224 /**
1225 * The <code>protected</code> keyword.
1226 *
1227 * @see #MODIFIERS
1228 **/
1229 public static final int LITERAL_PROTECTED =
1230 GeneratedJava14TokenTypes.LITERAL_protected;
1231
1232 /**
1233 * The <code>static</code> keyword.
1234 *
1235 * @see #MODIFIERS
1236 **/
1237 public static final int LITERAL_STATIC =
1238 GeneratedJava14TokenTypes.LITERAL_static;
1239
1240 /**
1241 * The <code>transient</code> keyword.
1242 *
1243 * @see #MODIFIERS
1244 **/
1245 public static final int LITERAL_TRANSIENT =
1246 GeneratedJava14TokenTypes.LITERAL_transient;
1247
1248 /**
1249 * The <code>native</code> keyword.
1250 *
1251 * @see #MODIFIERS
1252 **/
1253 public static final int LITERAL_NATIVE =
1254 GeneratedJava14TokenTypes.LITERAL_native;
1255
1256 /**
1257 * The <code>synchronized</code> keyword. This may be used as a
1258 * modifier of a method or in the definition of a synchronized
1259 * block.
1260 *
1261 * <p>For example:</p>
1262 *
1263 * <pre>
1264 * synchronized(this)
1265 * {
1266 * x++;
1267 * }
1268 * </pre>
1269 *
1270 * <p>parses as:</p>
1271 *
1272 * <pre>
1273 * +--LITERAL_SYNCHRONIZED (synchronized)
1274 * |
1275 * +--LPAREN (()
1276 * +--EXPR
1277 * |
1278 * +--LITERAL_THIS (this)
1279 * +--RPAREN ())
1280 * +--SLIST ({)
1281 * |
1282 * +--EXPR
1283 * |
1284 * +--POST_INC (++)
1285 * |
1286 * +--IDENT (x)
1287 * +--SEMI (;)
1288 * +--RCURLY (})
1289 * +--RCURLY (})
1290 * </pre>
1291 *
1292 * @see #MODIFIERS
1293 * @see #LPAREN
1294 * @see #EXPR
1295 * @see #RPAREN
1296 * @see #SLIST
1297 * @see #RCURLY
1298 **/
1299 public static final int LITERAL_SYNCHRONIZED =
1300 GeneratedJava14TokenTypes.LITERAL_synchronized;
1301
1302 /**
1303 * The <code>volatile</code> keyword.
1304 *
1305 * @see #MODIFIERS
1306 **/
1307 public static final int LITERAL_VOLATILE =
1308 GeneratedJava14TokenTypes.LITERAL_volatile;
1309
1310 /**
1311 * The <code>class</code> keyword. This element does not appear
1312 * as part of a class declaration, but only inline to reference a
1313 * class object.
1314 *
1315 * <p>For example:</p>
1316 *
1317 * <pre>
1318 * int.class
1319 * </pre>
1320 * <p>parses as:</p>
1321 * <pre>
1322 * +--EXPR
1323 * |
1324 * +--DOT (.)
1325 * |
1326 * +--LITERAL_INT (int)
1327 * +--LITERAL_CLASS (class)
1328 * </pre>
1329 *
1330 * @see #DOT
1331 * @see #IDENT
1332 * @see #CLASS_DEF
1333 * @see FullIdent
1334 **/
1335 public static final int LITERAL_CLASS =
1336 GeneratedJava14TokenTypes.LITERAL_class;
1337
1338 /* *
1339 * This token does not appear in the tree.
1340 *
1341 * @see #EXTENDS_CLAUSE
1342 **/
1343 //public static final int LITERAL_EXTENDS =
1344 // GeneratedJava14TokenTypes.LITERAL_extends;
1345
1346 /* *
1347 * This token does not appear in the tree.
1348 *
1349 * @see #INTERFACE_DEF
1350 **/
1351 //public static final int LITERAL_INTERFACE =
1352 // GeneratedJava14TokenTypes.LITERAL_interface;
1353
1354 /**
1355 * A left (curly) brace (<code>{</code>).
1356 *
1357 * @see #OBJBLOCK
1358 * @see #ARRAY_INIT
1359 * @see #SLIST
1360 **/
1361 public static final int LCURLY = GeneratedJava14TokenTypes.LCURLY;
1362 /**
1363 * A right (curly) brace (<code>}</code>).
1364 *
1365 * @see #OBJBLOCK
1366 * @see #ARRAY_INIT
1367 * @see #SLIST
1368 **/
1369 public static final int RCURLY = GeneratedJava14TokenTypes.RCURLY;
1370 /**
1371 * The <code>,</code> (comma) operator.
1372 *
1373 * @see #ARRAY_INIT
1374 * @see #FOR_INIT
1375 * @see #FOR_ITERATOR
1376 * @see #LITERAL_THROWS
1377 * @see #IMPLEMENTS_CLAUSE
1378 **/
1379 public static final int COMMA = GeneratedJava14TokenTypes.COMMA;
1380 /* *
1381 * This token does not appear in the tree.
1382 *
1383 * @see #IMPLEMENTS_CLAUSE
1384 **/
1385 // public static final int LITERAL_IMPLEMENTS =
1386 // GeneratedJava14TokenTypes.LITERAL_implements;
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 = GeneratedJava14TokenTypes.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 = GeneratedJava14TokenTypes.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 GeneratedJava14TokenTypes.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 GeneratedJava14TokenTypes.LITERAL_super;
1427
1428 /**
1429 * The <code>=</code> (assignment) operator.
1430 *
1431 * @see <a target="_top"
1432 * href="http://java.sun.com/docs/books/jls/second_edition/html/expressions.doc.html#5295">Java
1433 * Language Specification, §15.26.1</a>
1434 * @see #EXPR
1435 **/
1436 public static final int ASSIGN = GeneratedJava14TokenTypes.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 target="_top"
1442 * href="http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#78323">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 GeneratedJava14TokenTypes.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 = GeneratedJava14TokenTypes.COLON;
1463 /**
1464 * The <code>if</code> keyword.
1465 *
1466 * <p>For example:</p>
1467 * <pre>
1468 * if(optimistic)
1469 * {
1470 * message = "half full";
1471 * }
1472 * else
1473 * {
1474 * message = "half empty";
1475 * }
1476 * </pre>
1477 * <p>parses as:</p>
1478 * <pre>
1479 * +--LITERAL_IF (if)
1480 * |
1481 * +--LPAREN (()
1482 * +--EXPR
1483 * |
1484 * +--IDENT (optimistic)
1485 * +--RPAREN ())
1486 * +--SLIST ({)
1487 * |
1488 * +--EXPR
1489 * |
1490 * +--ASSIGN (=)
1491 * |
1492 * +--IDENT (message)
1493 * +--STRING_LITERAL ("half full")
1494 * +--SEMI (;)
1495 * +--RCURLY (})
1496 * +--LITERAL_ELSE (else)
1497 * |
1498 * +--SLIST ({)
1499 * |
1500 * +--EXPR
1501 * |
1502 * +--ASSIGN (=)
1503 * |
1504 * +--IDENT (message)
1505 * +--STRING_LITERAL ("half empty")
1506 * +--SEMI (;)
1507 * +--RCURLY (})
1508 * </pre>
1509 *
1510 * @see #LPAREN
1511 * @see #EXPR
1512 * @see #RPAREN
1513 * @see #SLIST
1514 * @see #EMPTY_STAT
1515 * @see #LITERAL_ELSE
1516 **/
1517 public static final int LITERAL_IF = GeneratedJava14TokenTypes.LITERAL_if;
1518 /**
1519 * The <code>for</code> keyword. The children are <code>(</code>,
1520 * an initializer, a condition, an iterator, a <code>)</code> and
1521 * either a statement list, a single expression, or an empty
1522 * statement.
1523 *
1524 * <p>For example:</p>
1525 * <pre>
1526 * for(int i = 0, n = myArray.length; i < n; i++)
1527 * {
1528 * }
1529 * </pre>
1530 *
1531 * <p>parses as:</p>
1532 * <pre>
1533 * +--LITERAL_FOR (for)
1534 * |
1535 * +--LPAREN (()
1536 * +--FOR_INIT
1537 * |
1538 * +--VARIABLE_DEF
1539 * |
1540 * +--MODIFIERS
1541 * +--TYPE
1542 * |
1543 * +--LITERAL_INT (int)
1544 * +--IDENT (i)
1545 * +--ASSIGN (=)
1546 * |
1547 * +--EXPR
1548 * |
1549 * +--NUM_INT (0)
1550 * +--COMMA (,)
1551 * +--VARIABLE_DEF
1552 * |
1553 * +--MODIFIERS
1554 * +--TYPE
1555 * |
1556 * +--LITERAL_INT (int)
1557 * +--IDENT (n)
1558 * +--ASSIGN (=)
1559 * |
1560 * +--EXPR
1561 * |
1562 * +--DOT (.)
1563 * |
1564 * +--IDENT (myArray)
1565 * +--IDENT (length)
1566 * +--SEMI (;)
1567 * +--FOR_CONDITION
1568 * |
1569 * +--EXPR
1570 * |
1571 * +--LT (<)
1572 * |
1573 * +--IDENT (i)
1574 * +--IDENT (n)
1575 * +--SEMI (;)
1576 * +--FOR_ITERATOR
1577 * |
1578 * +--ELIST
1579 * |
1580 * +--EXPR
1581 * |
1582 * +--POST_INC (++)
1583 * |
1584 * +--IDENT (i)
1585 * +--RPAREN ())
1586 * +--SLIST ({)
1587 * |
1588 * +--RCURLY (})
1589 * </pre>
1590 *
1591 * @see #LPAREN
1592 * @see #FOR_INIT
1593 * @see #SEMI
1594 * @see #FOR_CONDITION
1595 * @see #FOR_ITERATOR
1596 * @see #RPAREN
1597 * @see #SLIST
1598 * @see #EMPTY_STAT
1599 * @see #EXPR
1600 **/
1601 public static final int LITERAL_FOR = GeneratedJava14TokenTypes.LITERAL_for;
1602 /**
1603 * The <code>while</code> keyword.
1604 *
1605 * <p>For example:</p>
1606 * <pre>
1607 * while(line != null)
1608 * {
1609 * process(line);
1610 * line = in.readLine();
1611 * }
1612 * </pre>
1613 * <p>parses as:</p>
1614 * <pre>
1615 * +--LITERAL_WHILE (while)
1616 * |
1617 * +--LPAREN (()
1618 * +--EXPR
1619 * |
1620 * +--NOT_EQUAL (!=)
1621 * |
1622 * +--IDENT (line)
1623 * +--LITERAL_NULL (null)
1624 * +--RPAREN ())
1625 * +--SLIST ({)
1626 * |
1627 * +--EXPR
1628 * |
1629 * +--METHOD_CALL (()
1630 * |
1631 * +--IDENT (process)
1632 * +--ELIST
1633 * |
1634 * +--EXPR
1635 * |
1636 * +--IDENT (line)
1637 * +--RPAREN ())
1638 * +--SEMI (;)
1639 * +--EXPR
1640 * |
1641 * +--ASSIGN (=)
1642 * |
1643 * +--IDENT (line)
1644 * +--METHOD_CALL (()
1645 * |
1646 * +--DOT (.)
1647 * |
1648 * +--IDENT (in)
1649 * +--IDENT (readLine)
1650 * +--ELIST
1651 * +--RPAREN ())
1652 * +--SEMI (;)
1653 * +--RCURLY (})
1654 * </pre>
1655 **/
1656 public static final int LITERAL_WHILE =
1657 GeneratedJava14TokenTypes.LITERAL_while;
1658
1659 /**
1660 * The <code>do</code> keyword. Note the the while token does not
1661 * appear as part of the do-while construct.
1662 *
1663 * <p>For example:</p>
1664 * <pre>
1665 * do
1666 * {
1667 * x = rand.nextInt(10);
1668 * }
1669 * while(x < 5);
1670 * </pre>
1671 * <p>parses as:</p>
1672 * <pre>
1673 * +--LITERAL_DO (do)
1674 * |
1675 * +--SLIST ({)
1676 * |
1677 * +--EXPR
1678 * |
1679 * +--ASSIGN (=)
1680 * |
1681 * +--IDENT (x)
1682 * +--METHOD_CALL (()
1683 * |
1684 * +--DOT (.)
1685 * |
1686 * +--IDENT (rand)
1687 * +--IDENT (nextInt)
1688 * +--ELIST
1689 * |
1690 * +--EXPR
1691 * |
1692 * +--NUM_INT (10)
1693 * +--RPAREN ())
1694 * +--SEMI (;)
1695 * +--RCURLY (})
1696 * +--LPAREN (()
1697 * +--EXPR
1698 * |
1699 * +--LT (<)
1700 * |
1701 * +--IDENT (x)
1702 * +--NUM_INT (5)
1703 * +--RPAREN ())
1704 * +--SEMI (;)
1705 * </pre>
1706 *
1707 * @see #SLIST
1708 * @see #EXPR
1709 * @see #EMPTY_STAT
1710 * @see #LPAREN
1711 * @see #RPAREN
1712 * @see #SEMI
1713 **/
1714 public static final int LITERAL_DO = GeneratedJava14TokenTypes.LITERAL_do;
1715 /**
1716 * The <code>break</code> keyword. The first child is an optional
1717 * identifier and the last child is a semicolon.
1718 *
1719 * @see #IDENT
1720 * @see #SEMI
1721 * @see #SLIST
1722 **/
1723 public static final int LITERAL_BREAK =
1724 GeneratedJava14TokenTypes.LITERAL_break;
1725
1726 /**
1727 * The <code>continue</code> keyword. The first child is an
1728 * optional identifier and the last child is a semicolon.
1729 *
1730 * @see #IDENT
1731 * @see #SEMI
1732 * @see #SLIST
1733 **/
1734 public static final int LITERAL_CONTINUE =
1735 GeneratedJava14TokenTypes.LITERAL_continue;
1736
1737 /**
1738 * The <code>return</code> keyword. The first child is an
1739 * optional expression for the return value. The last child is a
1740 * semi colon.
1741 *
1742 * @see #EXPR
1743 * @see #SEMI
1744 * @see #SLIST
1745 **/
1746 public static final int LITERAL_RETURN =
1747 GeneratedJava14TokenTypes.LITERAL_return;
1748
1749 /**
1750 * The <code>switch</code> keyword.
1751 *
1752 * <p>For example:</p>
1753 * <pre>
1754 * switch(type)
1755 * {
1756 * case 0:
1757 * background = Color.blue;
1758 * break;
1759 * case 1:
1760 * background = Color.red;
1761 * break;
1762 * default:
1763 * background = Color.green;
1764 * break;
1765 * }
1766 * </pre>
1767 * <p>parses as:</p>
1768 * <pre>
1769 * +--LITERAL_SWITCH (switch)
1770 * |
1771 * +--LPAREN (()
1772 * +--EXPR
1773 * |
1774 * +--IDENT (type)
1775 * +--RPAREN ())
1776 * +--LCURLY ({)
1777 * +--CASE_GROUP
1778 * |
1779 * +--LITERAL_CASE (case)
1780 * |
1781 * +--EXPR
1782 * |
1783 * +--NUM_INT (0)
1784 * +--SLIST
1785 * |
1786 * +--EXPR
1787 * |
1788 * +--ASSIGN (=)
1789 * |
1790 * +--IDENT (background)
1791 * +--DOT (.)
1792 * |
1793 * +--IDENT (Color)
1794 * +--IDENT (blue)
1795 * +--SEMI (;)
1796 * +--LITERAL_BREAK (break)
1797 * |
1798 * +--SEMI (;)
1799 * +--CASE_GROUP
1800 * |
1801 * +--LITERAL_CASE (case)
1802 * |
1803 * +--EXPR
1804 * |
1805 * +--NUM_INT (1)
1806 * +--SLIST
1807 * |
1808 * +--EXPR
1809 * |
1810 * +--ASSIGN (=)
1811 * |
1812 * +--IDENT (background)
1813 * +--DOT (.)
1814 * |
1815 * +--IDENT (Color)
1816 * +--IDENT (red)
1817 * +--SEMI (;)
1818 * +--LITERAL_BREAK (break)
1819 * |
1820 * +--SEMI (;)
1821 * +--CASE_GROUP
1822 * |
1823 * +--LITERAL_DEFAULT (default)
1824 * +--SLIST
1825 * |
1826 * +--EXPR
1827 * |
1828 * +--ASSIGN (=)
1829 * |
1830 * +--IDENT (background)
1831 * +--DOT (.)
1832 * |
1833 * +--IDENT (Color)
1834 * +--IDENT (green)
1835 * +--SEMI (;)
1836 * +--LITERAL_BREAK (break)
1837 * |
1838 * +--SEMI (;)
1839 * +--RCURLY (})
1840 * </pre>
1841 *
1842 * @see <a target="_top"
1843 * href="http://java.sun.com/docs/books/jls/second_edition/html/statements.doc.html#35518">Java
1844 * Language Specification, §14.10</a>
1845 * @see #LPAREN
1846 * @see #EXPR
1847 * @see #RPAREN
1848 * @see #LCURLY
1849 * @see #CASE_GROUP
1850 * @see #RCURLY
1851 * @see #SLIST
1852 **/
1853 public static final int LITERAL_SWITCH =
1854 GeneratedJava14TokenTypes.LITERAL_switch;
1855
1856 /**
1857 * The <code>throw</code> keyword. The first child is an
1858 * expression that evaluates to a <code>Throwable</code> instance.
1859 *
1860 * @see <a target="_top"
1861 * href="http://java.sun.com/docs/books/jls/second_edition/html/statements.doc.html#237350">Java
1862 * Language Specification, §14.17</a>
1863 * @see #SLIST
1864 * @see #EXPR
1865 **/
1866 public static final int LITERAL_THROW =
1867 GeneratedJava14TokenTypes.LITERAL_throw;
1868
1869 /**
1870 * The <code>else</code> keyword. This appears as a child of an
1871 * <code>if</code> statement.
1872 *
1873 * @see #SLIST
1874 * @see #EXPR
1875 * @see #EMPTY_STAT
1876 * @see #LITERAL_IF
1877 **/
1878 public static final int LITERAL_ELSE =
1879 GeneratedJava14TokenTypes.LITERAL_else;
1880
1881 /**
1882 * The <code>case</code> keyword. The first child is a constant
1883 * expression that evaluates to a integer.
1884 *
1885 * @see #CASE_GROUP
1886 * @see #EXPR
1887 **/
1888 public static final int LITERAL_CASE =
1889 GeneratedJava14TokenTypes.LITERAL_case;
1890
1891 /**
1892 * The <code>default</code> keyword. This element has no
1893 * children.
1894 *
1895 * @see #CASE_GROUP
1896 **/
1897 public static final int LITERAL_DEFAULT =
1898 GeneratedJava14TokenTypes.LITERAL_default;
1899
1900 /**
1901 * The <code>try</code> keyword. The children are a statement
1902 * list, zero or more catch blocks and then an optional finally
1903 * block.
1904 *
1905 * <p>For example:</p>
1906 * <pre>
1907 * try
1908 * {
1909 * FileReader in = new FileReader("abc.txt");
1910 * }
1911 * catch(IOException ioe)
1912 * {
1913 * }
1914 * finally
1915 * {
1916 * }
1917 * </pre>
1918 * <p>parses as:</p>
1919 * <pre>
1920 * +--LITERAL_TRY (try)
1921 * |
1922<