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