com.puppycrawl.tools.checkstyle.api
Class TokenTypes

java.lang.Object
  com.puppycrawl.tools.checkstyle.api.TokenTypes

public final class TokenTypes
extends Object

Contains the constants for all the tokens contained in the Abstract Syntax Tree.

Implementation detail: This class has been introduced to break the circular dependency between packages.

Version:

1.0

Author:

Oliver Burn, Peter Dobratz

Field Summary

static int	ABSTRACT The abstract keyword.
static int	ANNOTATION An annotation of a package, type, field, parameter or variable.
static int	ANNOTATION_ARRAY_INIT An annotation array member initialisation.
static int	ANNOTATION_DEF An annotation declaration.
static int	ANNOTATION_FIELD_DEF An annotation field declaration.
static int	ANNOTATION_MEMBER_VALUE_PAIR An initialisation of an annotation member with a value.
static int	ANNOTATIONS A collection of annotations on a package or enum constant.
static int	ARRAY_DECLARATOR An array declaration.
static int	ARRAY_INIT An array initialization.
static int	ASSIGN The = (assignment) operator.
static int	AT An 'at' symbol - signifying an annotation instance or the prefix to the interface literal signifying the definition of an annotation declaration.
static int	BAND The & (bitwise AND) operator.
static int	BAND_ASSIGN The &= (bitwise AND assignment) operator.
static int	BNOT The ~ (bitwise complement) operator.
static int	BOR The | (bitwise OR) operator.
static int	BOR_ASSIGN The |= (bitwise OR assignment) operator.
static int	BSR The >>> (unsigned shift right) operator.
static int	BSR_ASSIGN The >>>= (unsigned right shift assignment) operator.
static int	BXOR The ^ (bitwise exclusive OR) operator.
static int	BXOR_ASSIGN The ^= (bitwise exclusive OR assignment) operator.
static int	CASE_GROUP A group of case clauses.
static int	CHAR_LITERAL A character literal.
static int	CLASS_DEF A class declaration.
static int	COLON The : (colon) operator.
static int	COMMA The , (comma) operator.
static int	CTOR_CALL A constructor call.
static int	CTOR_DEF A constructor declaration.
static int	DEC The -- (prefix decrement) operator.
static int	DIV The / (division) operator.
static int	DIV_ASSIGN The /= (division assignment) operator.
static int	DO_WHILE Literal while in do-while loop.
static int	DOT The . (dot) operator.
static int	ELIST An expression list.
static int	ELLIPSIS A triple dot for variable-length parameters.
static int	EMPTY_STAT The empty statement.
static int	ENUM The enum keyword.
static int	ENUM_CONSTANT_DEF An enum constant declaration.
static int	ENUM_DEF An enum declaration.
static int	EOF The end of file token.
static int	EQUAL The == (equal) operator.
static int	EXPR An expression.
static int	EXTENDS_CLAUSE An extends clause.
static int	FINAL The final keyword.
static int	FOR_CONDITION A for loop condition.
static int	FOR_EACH_CLAUSE A for-each clause.
static int	FOR_INIT A for loop initializer.
static int	FOR_ITERATOR A for loop iterator.
static int	GE The >= (greater than or equal) operator.
static int	GENERIC_END '>' symbol signifying the end of type arguments or type parameters.
static int	GENERIC_START '<' symbol signifying the start of type arguments or type parameters.
static int	GT The > (greater than) operator.
static int	IDENT An identifier.
static int	IMPLEMENTS_CLAUSE An implements clause.
static int	IMPORT An import declaration.
static int	INC The ++ (prefix increment) operator.
static int	INDEX_OP The array index operator.
static int	INSTANCE_INIT An instance initializer.
static int	INTERFACE_DEF An interface declaration.
static int	LABELED_STAT A labeled statement.
static int	LAND The && (conditional AND) operator.
static int	LCURLY A left (curly) brace ({).
static int	LE The <= (less than or equal) operator.
static int	LITERAL_ASSERT The assert keyword.
static int	LITERAL_BOOLEAN The boolean keyword.
static int	LITERAL_BREAK The break keyword.
static int	LITERAL_BYTE The byte keyword.
static int	LITERAL_CASE The case keyword.
static int	LITERAL_CATCH The catch keyword.
static int	LITERAL_CHAR The char keyword.
static int	LITERAL_CLASS The class keyword.
static int	LITERAL_CONTINUE The continue keyword.
static int	LITERAL_DEFAULT The default keyword.
static int	LITERAL_DO The do keyword.
static int	LITERAL_DOUBLE The double keyword.
static int	LITERAL_ELSE The else keyword.
static int	LITERAL_FALSE The false keyword.
static int	LITERAL_FINALLY The finally keyword.
static int	LITERAL_FLOAT The float keyword.
static int	LITERAL_FOR The for keyword.
static int	LITERAL_IF The if keyword.
static int	LITERAL_INSTANCEOF The instanceof operator.
static int	LITERAL_INT The int keyword.
static int	LITERAL_INTERFACE The interface keyword.
static int	LITERAL_LONG The long keyword.
static int	LITERAL_NATIVE The native keyword.
static int	LITERAL_NEW The new keyword.
static int	LITERAL_NULL The null keyword.
static int	LITERAL_PRIVATE The private keyword.
static int	LITERAL_PROTECTED The protected keyword.
static int	LITERAL_PUBLIC The public keyword.
static int	LITERAL_RETURN The return keyword.
static int	LITERAL_SHORT The short keyword.
static int	LITERAL_STATIC The static keyword.
static int	LITERAL_SUPER The super keyword.
static int	LITERAL_SWITCH The switch keyword.
static int	LITERAL_SYNCHRONIZED The synchronized keyword.
static int	LITERAL_THIS The this keyword.
static int	LITERAL_THROW The throw keyword.
static int	LITERAL_THROWS The throws keyword.
static int	LITERAL_TRANSIENT The transient keyword.
static int	LITERAL_TRUE The true keyword.
static int	LITERAL_TRY The try keyword.
static int	LITERAL_VOID The void keyword.
static int	LITERAL_VOLATILE The volatile keyword.
static int	LITERAL_WHILE The while keyword.
static int	LNOT The ! (logical complement) operator.
static int	LOR The || (conditional OR) operator.
static int	LPAREN A left parenthesis (().
static int	LT The < (less than) operator.
static int	METHOD_CALL A method call.
static int	METHOD_DEF A method declaration.
static int	MINUS The - (subtraction) operator.
static int	MINUS_ASSIGN The -= (subtraction assignment) operator.
static int	MOD The % (remainder) operator.
static int	MOD_ASSIGN The %= (remainder assignment) operator.
static int	MODIFIERS Modifiers for type, method, and field declarations.
static int	NOT_EQUAL The != (not equal) operator.
static int	NUM_DOUBLE A double precision floating point literal.
static int	NUM_FLOAT A single precision floating point literal.
static int	NUM_INT An integer literal.
static int	NUM_LONG A long integer literal.
static int	OBJBLOCK An object block.
static int	PACKAGE_DEF The package declaration.
static int	PARAMETER_DEF A parameter declaration.
static int	PARAMETERS A list of parameters to a method or constructor.
static int	PLUS The + (addition) operator.
static int	PLUS_ASSIGN The += (addition assignment) operator.
static int	POST_DEC The -- (postfix decrement) operator.
static int	POST_INC The ++ (postfix increment) operator.
static int	QUESTION The ? (conditional) operator.
static int	RBRACK The ] symbol.
static int	RCURLY A right (curly) brace (}).
static int	RPAREN A right parenthesis ()).
static int	SEMI The statement terminator (;).
static int	SL The << (shift left) operator.
static int	SL_ASSIGN The <<= (left shift assignment) operator.
static int	SLIST A list of statements.
static int	SR The >> (signed shift right) operator.
static int	SR_ASSIGN The >>= (signed right shift assignment) operator.
static int	STAR The * (multiplication or wildcard) operator.
static int	STAR_ASSIGN The *= (multiplication assignment) operator.
static int	STATIC_IMPORT A static import declaration.
static int	STATIC_INIT A static initialization block.
static int	STRICTFP The strictfp keyword.
static int	STRING_LITERAL A string literal.
static int	SUPER_CTOR_CALL A super constructor call.
static int	TYPE A type.
static int	TYPE_ARGUMENT A type arguments to a type reference or a method/ctor invocation.
static int	TYPE_ARGUMENTS A list of type arguments to a type reference or a method/ctor invocation.
static int	TYPE_EXTENSION_AND '&' symbol when used in a generic upper or lower bounds constrain e.g.
static int	TYPE_LOWER_BOUNDS A lower bounds on a wildcard type argument.
static int	TYPE_PARAMETER A type parameter to a class, interface or method definition.
static int	TYPE_PARAMETERS A list of type parameters to a class, interface or method definition.
static int	TYPE_UPPER_BOUNDS An upper bounds on a wildcard type argument or type parameter.
static int	TYPECAST A type-cast.
static int	UNARY_MINUS The + (unary plus) operator.
static int	UNARY_PLUS The - (unary minus) operator.
static int	VARIABLE_DEF A field or local variable declaration.
static int	WILDCARD_TYPE The type that refers to all types.

Method Summary

static String	getShortDescription(String aName) Returns the short description of a token for a given name.
static int	getTokenId(String aName) Returns the ID of a token for a given name.
static String	getTokenName(int aID) Returns the name of a token for a given ID.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

EOF

public static final int EOF

The end of file token. This is the root node for the source file. It's children are an optional package definition, zero or more import statements, and one or more class or interface definitions.

See Also:

PACKAGE_DEF, IMPORT, CLASS_DEF, INTERFACE_DEF, Constant Field Values

MODIFIERS

public static final int MODIFIERS

Modifiers for type, method, and field declarations. The modifiers element is always present even though it may have no children.

See Also:

Java Language Specification, Chapter 8, LITERAL_PUBLIC, LITERAL_PROTECTED, LITERAL_PRIVATE, ABSTRACT, LITERAL_STATIC, FINAL, LITERAL_TRANSIENT, LITERAL_VOLATILE, LITERAL_SYNCHRONIZED, LITERAL_NATIVE, STRICTFP, ANNOTATION, Constant Field Values

OBJBLOCK

public static final int OBJBLOCK

An object block. These are children of class, interface, enum, annotation and enum constant declarations. Also, object blocks are children of the new keyword when defining anonymous inner types.

See Also:

LCURLY, INSTANCE_INIT, STATIC_INIT, CLASS_DEF, CTOR_DEF, METHOD_DEF, VARIABLE_DEF, RCURLY, INTERFACE_DEF, LITERAL_NEW, ENUM_DEF, ENUM_CONSTANT_DEF, ANNOTATION_DEF, Constant Field Values

SLIST

public static final int SLIST

A list of statements.

See Also:

RCURLY, EXPR, LABELED_STAT, LITERAL_THROWS, LITERAL_RETURN, SEMI, METHOD_DEF, CTOR_DEF, LITERAL_FOR, LITERAL_WHILE, LITERAL_IF, LITERAL_ELSE, CASE_GROUP, Constant Field Values

CTOR_DEF

public static final int CTOR_DEF

A constructor declaration.

For example:

 public SpecialEntry(int value, String text)
 {
   this.value = value;
   this.text = text;
 }
 

parses as:

 +--CTOR_DEF
     |
     +--MODIFIERS
         |
         +--LITERAL_PUBLIC (public)
     +--IDENT (SpecialEntry)
     +--LPAREN (()
     +--PARAMETERS
         |
         +--PARAMETER_DEF
             |
             +--MODIFIERS
             +--TYPE
                 |
                 +--LITERAL_INT (int)
             +--IDENT (value)
         +--COMMA (,)
         +--PARAMETER_DEF
             |
             +--MODIFIERS
             +--TYPE
                 |
                 +--IDENT (String)
             +--IDENT (text)
     +--RPAREN ())
     +--SLIST ({)
         |
         +--EXPR
             |
             +--ASSIGN (=)
                 |
                 +--DOT (.)
                     |
                     +--LITERAL_THIS (this)
                     +--IDENT (value)
                 +--IDENT (value)
         +--SEMI (;)
         +--EXPR
             |
             +--ASSIGN (=)
                 |
                 +--DOT (.)
                     |
                     +--LITERAL_THIS (this)
                     +--IDENT (text)
                 +--IDENT (text)
         +--SEMI (;)
         +--RCURLY (})
 

See Also:

OBJBLOCK, CLASS_DEF, Constant Field Values

METHOD_DEF

public static final int METHOD_DEF

A method declaration. The children are modifiers, type parameters, return type, method name, parameter list, an optional throws list, and statement list. The statement list is omitted if the method declaration appears in an interface declaration. Method declarations may appear inside object blocks of class declarations, interface declarations, enum declarations, enum constant declarations or anonymous inner-class declarations.

For example:

  public static int square(int x)
  {
    return x*x;
  }
 

parses as:

 +--METHOD_DEF
     |
     +--MODIFIERS
         |
         +--LITERAL_PUBLIC (public)
         +--LITERAL_STATIC (static)
     +--TYPE
         |
         +--LITERAL_INT (int)
     +--IDENT (square)
     +--PARAMETERS
         |
         +--PARAMETER_DEF
             |
             +--MODIFIERS
             +--TYPE
                 |
                 +--LITERAL_INT (int)
             +--IDENT (x)
     +--SLIST ({)
         |
         +--LITERAL_RETURN (return)
             |
             +--EXPR
                 |
                 +--STAR (*)
                     |
                     +--IDENT (x)
                     +--IDENT (x)
             +--SEMI (;)
         +--RCURLY (})
 

See Also:

MODIFIERS, TYPE_PARAMETERS, TYPE, IDENT, PARAMETERS, LITERAL_THROWS, SLIST, OBJBLOCK, Constant Field Values

VARIABLE_DEF

public static final int VARIABLE_DEF

A field or local variable declaration. The children are modifiers, type, the identifier name, and an optional assignment statement.

See Also:

MODIFIERS, TYPE, IDENT, ASSIGN, Constant Field Values

INSTANCE_INIT

public static final int INSTANCE_INIT

An instance initializer. Zero or more instance initializers may appear in class and enum definitions. This token will be a child of the object block of the declaring type.

See Also:

Java Language Specification§8.6, SLIST, OBJBLOCK, Constant Field Values

STATIC_INIT

public static final int STATIC_INIT

A static initialization block. Zero or more static initializers may be children of the object block of a class or enum declaration (interfaces cannot have static initializers). The first and only child is a statement list.

See Also:

Java Language Specification, §8.7, SLIST, OBJBLOCK, Constant Field Values

TYPE

public static final int TYPE

A type. This is either a return type of a method or a type of a variable or field. The first child of this element is the actual type. This may be a primitive type, an identifier, a dot which is the root of a fully qualified type, or an array of any of these. The second child may be type arguments to the type.

See Also:

VARIABLE_DEF, METHOD_DEF, PARAMETER_DEF, IDENT, DOT, LITERAL_VOID, LITERAL_BOOLEAN, LITERAL_BYTE, LITERAL_CHAR, LITERAL_SHORT, LITERAL_INT, LITERAL_FLOAT, LITERAL_LONG, LITERAL_DOUBLE, ARRAY_DECLARATOR, TYPE_ARGUMENTS, Constant Field Values

CLASS_DEF

public static final int CLASS_DEF

A class declaration.

For example:

 public class MyClass
   implements Serializable
 {
 }
 

parses as:

 +--CLASS_DEF
     |
     +--MODIFIERS
         |
         +--LITERAL_PUBLIC (public)
     +--LITERAL_CLASS (class)
     +--IDENT (MyClass)
     +--EXTENDS_CLAUSE
     +--IMPLEMENTS_CLAUSE
         |
         +--IDENT (Serializable)
     +--OBJBLOCK
         |
         +--LCURLY ({)
         +--RCURLY (})
 

See Also:

Java Language Specification, Chapter 8, MODIFIERS, IDENT, EXTENDS_CLAUSE, IMPLEMENTS_CLAUSE, OBJBLOCK, LITERAL_NEW, Constant Field Values

INTERFACE_DEF

public static final int INTERFACE_DEF

An interface declaration.

For example:

   public interface MyInterface
   {
   }

 

parses as:

 +--INTERFACE_DEF
     |
     +--MODIFIERS
         |
         +--LITERAL_PUBLIC (public)
     +--LITERAL_INTERFACE (interface)
     +--IDENT (MyInterface)
     +--EXTENDS_CLAUSE
     +--OBJBLOCK
         |
         +--LCURLY ({)
         +--RCURLY (})
 

See Also:

Java Language Specification, Chapter 9, MODIFIERS, IDENT, EXTENDS_CLAUSE, OBJBLOCK, Constant Field Values

PACKAGE_DEF

public static final int PACKAGE_DEF

The package declaration. This is optional, but if it is included, then there is only one package declaration per source file and it must be the first non-comment in the file. A package declaration may be annotated in which case the annotations comes before the rest of the declaration (and are the first children).

For example:

   package com.puppycrawl.tools.checkstyle.api;
 

parses as:

 +--PACKAGE_DEF (package)
     |
     +--ANNOTATIONS
     +--DOT (.)
         |
         +--DOT (.)
             |
             +--DOT (.)
                 |
                 +--DOT (.)
                     |
                     +--IDENT (com)
                     +--IDENT (puppycrawl)
                 +--IDENT (tools)
             +--IDENT (checkstyle)
         +--IDENT (api)
     +--SEMI (;)
 

See Also:

Java Language Specification §7.4, DOT, IDENT, SEMI, ANNOTATIONS, FullIdent, Constant Field Values

ARRAY_DECLARATOR

public static final int ARRAY_DECLARATOR

An array declaration.

If the array declaration represents a type, then the type of the array elements is the first child. Multidimensional arrays may be regarded as arrays of arrays. In other words, the first child of the array declaration is another array declaration.

For example:

   int[] x;
 

parses as:

 +--VARIABLE_DEF
     |
     +--MODIFIERS
     +--TYPE
         |
         +--ARRAY_DECLARATOR ([)
             |
             +--LITERAL_INT (int)
     +--IDENT (x)
 +--SEMI (;)
 

The array declaration may also represent an inline array definition. In this case, the first child will be either an expression specifying the length of the array or an array initialization block.

See Also:

Java Language Specification Chapter 10, TYPE, ARRAY_INIT, Constant Field Values

EXTENDS_CLAUSE

public static final int EXTENDS_CLAUSE

An extends clause. This appear as part of class and interface definitions. This element appears even if the extends keyword is not explicitly used. The child is an optional identifier.

For example:

parses as:

 +--EXTENDS_CLAUSE
     |
     +--DOT (.)
         |
         +--DOT (.)
             |
             +--IDENT (java)
             +--IDENT (util)
         +--IDENT (LinkedList)
 

See Also:

IDENT, DOT, CLASS_DEF, INTERFACE_DEF, FullIdent, Constant Field Values

IMPLEMENTS_CLAUSE

public static final int IMPLEMENTS_CLAUSE

An implements clause. This always appears in a class or enum declaration, even if there are no implemented interfaces. The children are a comma separated list of zero or more identifiers.

For example:

 implements Serializable, Comparable
 

parses as:

 +--IMPLEMENTS_CLAUSE
     |
     +--IDENT (Serializable)
     +--COMMA (,)
     +--IDENT (Comparable)
 

See Also:

IDENT, DOT, COMMA, CLASS_DEF, ENUM_DEF, Constant Field Values

PARAMETERS

public static final int PARAMETERS

A list of parameters to a method or constructor. The children are zero or more parameter declarations separated by commas.

For example

 int start, int end
 

parses as:

 +--PARAMETERS
     |
     +--PARAMETER_DEF
         |
         +--MODIFIERS
         +--TYPE
             |
             +--LITERAL_INT (int)
         +--IDENT (start)
     +--COMMA (,)
     +--PARAMETER_DEF
         |
         +--MODIFIERS
         +--TYPE
             |
             +--LITERAL_INT (int)
         +--IDENT (end)
 

See Also:

PARAMETER_DEF, COMMA, METHOD_DEF, CTOR_DEF, Constant Field Values

PARAMETER_DEF

public static final int PARAMETER_DEF

A parameter declaration. The last parameter in a list of parameters may be variable length (indicated by the ELLIPSIS child node immediately after the TYPE child).

See Also:

MODIFIERS, TYPE, IDENT, PARAMETERS, ELLIPSIS, Constant Field Values

LABELED_STAT

public static final int LABELED_STAT

A labeled statement.

For example:

 outside: ;
 

parses as:

 +--LABELED_STAT (:)
     |
     +--IDENT (outside)
     +--EMPTY_STAT (;)
 

See Also:

Java Language Specification, §14.7, SLIST, Constant Field Values

TYPECAST

public static final int TYPECAST

A type-cast.

For example:

 (String)it.next()
 

parses as:

 +--TYPECAST (()
     |
     +--TYPE
         |
         +--IDENT (String)
     +--RPAREN ())
     +--METHOD_CALL (()
         |
         +--DOT (.)
             |
             +--IDENT (it)
             +--IDENT (next)
         +--ELIST
         +--RPAREN ())
 

See Also:

Java Language Specification, §15.16, EXPR, TYPE, TYPE_ARGUMENTS, RPAREN, Constant Field Values

INDEX_OP

public static final int INDEX_OP

The array index operator.

For example:

 ar[2] = 5;
 

parses as:

 +--EXPR
     |
     +--ASSIGN (=)
         |
         +--INDEX_OP ([)
             |
             +--IDENT (ar)
             +--EXPR
                 |
                 +--NUM_INT (2)
         +--NUM_INT (5)
 +--SEMI (;)
 

See Also:

EXPR, Constant Field Values

POST_INC

public static final int POST_INC

The ++ (postfix increment) operator.

See Also:

Java Language Specification, §15.14.1, EXPR, INC, Constant Field Values

POST_DEC

public static final int POST_DEC

The -- (postfix decrement) operator.

See Also:

Java Language Specification, §15.14.2, EXPR, DEC, Constant Field Values

METHOD_CALL

public static final int METHOD_CALL

A method call. A method call may have type arguments however these are attached to the appropriate node in the qualified method name.

For example:

 Math.random()
 

parses as:

 +--METHOD_CALL (()
     |
     +--DOT (.)
         |
         +--IDENT (Math)
         +--IDENT (random)
     +--ELIST
     +--RPAREN ())
 

See Also:

IDENT, TYPE_ARGUMENTS, DOT, ELIST, RPAREN, FullIdent, Constant Field Values

EXPR

public static final int EXPR

An expression. Operators with lower precedence appear at a higher level in the tree than operators with higher precedence. Parentheses are siblings to the operator they enclose.

For example:

 x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1<<3);
 

parses as:

 +--EXPR
     |
     +--ASSIGN (=)
         |
         +--IDENT (x)
         +--PLUS (+)
             |
             +--PLUS (+)
                 |
                 +--PLUS (+)
                     |
                     +--PLUS (+)
                         |
                         +--NUM_INT (4)
                         +--STAR (*)
                             |
                             +--NUM_INT (3)
                             +--NUM_INT (5)
                     +--DIV (/)
                         |
                         +--LPAREN (()
                         +--PLUS (+)
                             |
                             +--NUM_INT (30)
                             +--NUM_INT (26)
                         +--RPAREN ())
                         +--NUM_INT (4)
                 +--MOD (%)
                     |
                     +--NUM_INT (5)
                     +--NUM_INT (4)
             +--LPAREN (()
             +--SL (<<)
                 |
                 +--NUM_INT (1)
                 +--NUM_INT (3)
             +--RPAREN ())
 +--SEMI (;)
 

See Also:

ELIST, ASSIGN, LPAREN, RPAREN, Constant Field Values

ARRAY_INIT

public static final int ARRAY_INIT

An array initialization. This may occur as part of an array declaration or inline with new.

For example:

   int[] y =
     {
       1,
       2,
     };
 

parses as:

 +--VARIABLE_DEF
     |
     +--MODIFIERS
     +--TYPE
         |
         +--ARRAY_DECLARATOR ([)
             |
             +--LITERAL_INT (int)
     +--IDENT (y)
     +--ASSIGN (=)
         |
         +--ARRAY_INIT ({)
             |
             +--EXPR
                 |
                 +--NUM_INT (1)
             +--COMMA (,)
             +--EXPR
                 |
                 +--NUM_INT (2)
             +--COMMA (,)
             +--RCURLY (})
 +--SEMI (;)
 

Also consider:

   int[] z = new int[]
     {
       1,
       2,
     };
 

which parses as:

 +--VARIABLE_DEF
     |
     +--MODIFIERS
     +--TYPE
         |
         +--ARRAY_DECLARATOR ([)
             |
             +--LITERAL_INT (int)
     +--IDENT (z)
     +--ASSIGN (=)
         |
         +--EXPR
             |
             +--LITERAL_NEW (new)
                 |
                 +--LITERAL_INT (int)
                 +--ARRAY_DECLARATOR ([)
                 +--ARRAY_INIT ({)
                     |
                     +--EXPR
                         |
                         +--NUM_INT (1)
                     +--COMMA (,)
                     +--EXPR
                         |
                         +--NUM_INT (2)
                     +--COMMA (,)
                     +--RCURLY (})
 

See Also:

ARRAY_DECLARATOR, TYPE, LITERAL_NEW, COMMA, Constant Field Values

IMPORT

public static final int IMPORT

An import declaration. Import declarations are option, but must appear after the package declaration and before the first type declaration.

For example:

   import java.io.IOException;
 

parses as:

 +--IMPORT (import)
     |
     +--DOT (.)
         |
         +--DOT (.)
             |
             +--IDENT (java)
             +--IDENT (io)
         +--IDENT (IOException)
     +--SEMI (;)
 

See Also:

Java Language Specification §7.5, DOT, IDENT, STAR, SEMI, FullIdent, Constant Field Values

UNARY_MINUS

public static final int UNARY_MINUS

The + (unary plus) operator.

See Also:

Java Language Specification, §15.15.3, EXPR, Constant Field Values

UNARY_PLUS

public static final int UNARY_PLUS

The - (unary minus) operator.

See Also:

Java Language Specification, §15.15.4, EXPR, Constant Field Values

CASE_GROUP

public static final int CASE_GROUP

A group of case clauses. Case clauses with no associated statements are grouped together into a case group. The last child is a statement list containing the statements to execute upon a match.

For example:

 case 0:
 case 1:
 case 2:
   x = 3;
   break;
 

parses as:

 +--CASE_GROUP
     |
     +--LITERAL_CASE (case)
         |
         +--EXPR
             |
             +--NUM_INT (0)
     +--LITERAL_CASE (case)
         |
         +--EXPR
             |
             +--NUM_INT (1)
     +--LITERAL_CASE (case)
         |
         +--EXPR
             |
             +--NUM_INT (2)
     +--SLIST
         |
         +--EXPR
             |
             +--ASSIGN (=)
                 |
                 +--IDENT (x)
                 +--NUM_INT (3)
         +--SEMI (;)
         +--LITERAL_BREAK (break)
             |
             +--SEMI (;)
 

See Also:

LITERAL_CASE, LITERAL_DEFAULT, LITERAL_SWITCH, Constant Field Values

ELIST

public static final int ELIST

An expression list. The children are a comma separated list of expressions.

See Also:

LITERAL_NEW, FOR_INIT, FOR_ITERATOR, EXPR, METHOD_CALL, CTOR_CALL, SUPER_CTOR_CALL, Constant Field Values

FOR_INIT

public static final int FOR_INIT

A for loop initializer. This is a child of LITERAL_FOR. The children of this element may be a comma separated list of variable declarations, an expression list, or empty.

See Also:

VARIABLE_DEF, ELIST, LITERAL_FOR, Constant Field Values

FOR_CONDITION

public static final int FOR_CONDITION

A for loop condition. This is a child of LITERAL_FOR. The child of this element is an optional expression.

See Also:

EXPR, LITERAL_FOR, Constant Field Values

FOR_ITERATOR

public static final int FOR_ITERATOR

A for loop iterator. This is a child of LITERAL_FOR. The child of this element is an optional expression list.

See Also:

ELIST, LITERAL_FOR, Constant Field Values

EMPTY_STAT

public static final int EMPTY_STAT

The empty statement. This goes in place of an SLIST for a for or while loop body.

See Also:

Java Language Specification, §14.6, LITERAL_FOR, LITERAL_WHILE, Constant Field Values

FINAL

public static final int FINAL

The final keyword.

See Also:

MODIFIERS, Constant Field Values

ABSTRACT

public static final int ABSTRACT

The abstract keyword.

See Also:

MODIFIERS, Constant Field Values

STRICTFP

public static final int STRICTFP

The strictfp keyword.

See Also:

MODIFIERS, Constant Field Values

SUPER_CTOR_CALL

public static final int SUPER_CTOR_CALL

A super constructor call.

See Also:

ELIST, RPAREN, SEMI, CTOR_CALL, Constant Field Values

CTOR_CALL

public static final int CTOR_CALL

A constructor call.

For example:

 this(1);
 

parses as:

 +--CTOR_CALL (this)
     |
     +--LPAREN (()
     +--ELIST
         |
         +--EXPR
             |
             +--NUM_INT (1)
     +--RPAREN ())
     +--SEMI (;)
 

See Also:

ELIST, RPAREN, SEMI, SUPER_CTOR_CALL, Constant Field Values

SEMI

public static final int SEMI

The statement terminator (;). Depending on the context, this make occur as a sibling, a child, or not at all.

See Also:

PACKAGE_DEF, IMPORT, SLIST, ARRAY_INIT, LITERAL_FOR, Constant Field Values

RBRACK

public static final int RBRACK

The ] symbol.

See Also:

INDEX_OP, ARRAY_DECLARATOR, Constant Field Values

LITERAL_VOID

public static final int LITERAL_VOID

The void keyword.

See Also:

TYPE, Constant Field Values

LITERAL_BOOLEAN

public static final int LITERAL_BOOLEAN

The boolean keyword.

See Also:

TYPE, Constant Field Values

LITERAL_BYTE

public static final int LITERAL_BYTE

The byte keyword.

See Also:

TYPE, Constant Field Values

LITERAL_CHAR

public static final int LITERAL_CHAR

The char keyword.

See Also:

TYPE, Constant Field Values

LITERAL_SHORT

public static final int LITERAL_SHORT

The short keyword.

See Also:

TYPE, Constant Field Values

LITERAL_INT

public static final int LITERAL_INT

The int keyword.

See Also:

TYPE, Constant Field Values

LITERAL_FLOAT

public static final int LITERAL_FLOAT

The float keyword.

See Also:

TYPE, Constant Field Values

LITERAL_LONG

public static final int LITERAL_LONG

The long keyword.

See Also:

TYPE, Constant Field Values

LITERAL_DOUBLE

public static final int LITERAL_DOUBLE

The double keyword.

See Also:

TYPE, Constant Field Values

IDENT

public static final int IDENT

An identifier. These can be names of types, subpackages, fields, methods, parameters, and local variables.

See Also:

Constant Field Values

DOT

public static final int DOT

The . (dot) operator.

See Also:

FullIdent, Constant Field Values

STAR

public static final int STAR

The * (multiplication or wildcard) operator.

See Also:

Java Language Specification, §7.5.2, Java Language Specification, §15.17.1, EXPR, IMPORT, Constant Field Values

LITERAL_PRIVATE

public static final int LITERAL_PRIVATE

The private keyword.

See Also:

MODIFIERS, Constant Field Values

LITERAL_PUBLIC

public static final int LITERAL_PUBLIC

The public keyword.

See Also:

MODIFIERS, Constant Field Values

LITERAL_PROTECTED

public static final int LITERAL_PROTECTED

The protected keyword.

See Also:

MODIFIERS,