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