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