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