public class ExpressionParser extends antlr.LLkParser implements ExpressionParserTokenTypes
ExpressionLexer
). More specifically, the parser does the
following:
nextToken
method.
This method tokenizes the lexer's input stream of characters and
returns the next found Token
object.
expression()
method as an entry point.
Compiler
to compile the expression into a
Java class.
This grammar is highly specific to ANTLR 2.7.4 and it may not be valid in future versions of ANTLR. This is due to the fact that the generated code and the grammar syntax of ANTLR can change between versions. These factors are the most important constraints defining the structure of the resulting grammar. As a result, it is possible that the grammar will require changes to run in future versions of ANTLR.
Please note that this is a generated file using ANTLR 2.7.4 and a
grammar specified in expression.g
.
Modifier and Type | Field and Description |
---|---|
static java.lang.String[] |
_tokenNames |
static antlr.collections.impl.BitSet |
_tokenSet_0 |
static antlr.collections.impl.BitSet |
_tokenSet_1 |
static antlr.collections.impl.BitSet |
_tokenSet_10 |
static antlr.collections.impl.BitSet |
_tokenSet_11 |
static antlr.collections.impl.BitSet |
_tokenSet_12 |
static antlr.collections.impl.BitSet |
_tokenSet_13 |
static antlr.collections.impl.BitSet |
_tokenSet_14 |
static antlr.collections.impl.BitSet |
_tokenSet_15 |
static antlr.collections.impl.BitSet |
_tokenSet_16 |
static antlr.collections.impl.BitSet |
_tokenSet_17 |
static antlr.collections.impl.BitSet |
_tokenSet_18 |
static antlr.collections.impl.BitSet |
_tokenSet_19 |
static antlr.collections.impl.BitSet |
_tokenSet_2 |
static antlr.collections.impl.BitSet |
_tokenSet_20 |
static antlr.collections.impl.BitSet |
_tokenSet_21 |
static antlr.collections.impl.BitSet |
_tokenSet_22 |
static antlr.collections.impl.BitSet |
_tokenSet_23 |
static antlr.collections.impl.BitSet |
_tokenSet_24 |
static antlr.collections.impl.BitSet |
_tokenSet_3 |
static antlr.collections.impl.BitSet |
_tokenSet_4 |
static antlr.collections.impl.BitSet |
_tokenSet_5 |
static antlr.collections.impl.BitSet |
_tokenSet_6 |
static antlr.collections.impl.BitSet |
_tokenSet_7 |
static antlr.collections.impl.BitSet |
_tokenSet_8 |
static antlr.collections.impl.BitSet |
_tokenSet_9 |
private static java.lang.String |
AST_CLASS
Name of the specialized AST class to use when parsing.
|
private SymbolResolver |
resolver
Object which resolves constants for the parser
|
astFactory, inputState, returnAST, tokenNames, tokenTypeToASTClassMap, traceDepth
AND, ASSIGN, BIT_AND, BIT_COMP, BIT_OR, BIT_XOR, BOOL_FALSE, BOOL_TRUE, CAST, COMMA, DEC_LITERAL, DIGIT, DIVIDE, DOT, DSTRING, EOF, EQUALS, GOTO, GT, GTE, HASH, HEX_LITERAL, HEXDIGIT, IDENTITY, IS_NULL, LETTER, LPARENS, LSHIFT, LT, LTE, METH_BOOLEAN, METH_DOUBLE, METH_INT, METH_LONG, METH_OBJ, MINUS, MODULO, MULTIPLY, NOT, NOT_EQ, NOT_NULL, NULL, NULL_TREE_LOOKAHEAD, NUM_LITERAL, OR, PLUS, POSPARM, RPARENS, RSHIFT, SSTRING, STRING, SYM_CHAR, SYMBOL, UN_MINUS, VALID_SYM_CHAR, WS, ZRSHIFT
Modifier | Constructor and Description |
---|---|
|
ExpressionParser(ExpressionLexer lexer,
SymbolResolver resolver)
Create a new parser instance, given a lexer instance and a symbol
resolver.
|
|
ExpressionParser(ExpressionLexer lexer,
SymbolResolver resolver,
boolean noAssignment)
Create a new parser instance, given a lexer instance, a symbol resolver,
and an indication of whether assignments are allowed.
|
|
ExpressionParser(antlr.ParserSharedInputState state) |
|
ExpressionParser(antlr.TokenBuffer tokenBuf) |
protected |
ExpressionParser(antlr.TokenBuffer tokenBuf,
int k) |
|
ExpressionParser(antlr.TokenStream lexer) |
protected |
ExpressionParser(antlr.TokenStream lexer,
int k) |
Modifier and Type | Method and Description |
---|---|
void |
bit_and_expr()
Implements the 5th lowest precedence level of expressions:
&
(the bitwise AND operator). |
void |
bit_or_expr()
Implements the 3rd lowest precedence level of expressions:
|
(the inclusive OR operator). |
void |
bit_xor_expr()
Implements the 4th lowest precedence level of expressions:
^
(the exclusive OR operator). |
protected void |
buildTokenTypeASTClassMap() |
java.lang.String |
cast()
Implements a cast operator which consists of a valid Java class name
enclosed in parenthesis.
|
void |
compare_expr()
Implements the 7th lowest precedence level of expressions - the comparison
operators.
|
int |
convertFunctionToTokenType(Function func)
Reads the return value (as a class) from a function and determines
which kind of method call this represents.
|
void |
convertNullTest(antlr.CommonAST ast)
Implements special processing for
NULL equality and
inequality tests. |
void |
equality_expr()
Implements the 6th lowest precedence level of expressions - the equality
operators.
|
void |
expr()
Implements the lowest (1st) precedence level of expressions:
OR (the logical OR operator). |
java.lang.Class |
expression()
Parses an infix expression and creates an AST that is verified suitable
for compilation.
|
(package private) java.lang.Class[] |
generateSignature(ExtraAst ast,
boolean ignoreFirst)
Walks the children (optionally ignoring the first child if it
represents the target instance upon which the method is being
called) and for each one uses
Verifier.resolveDataType(com.goldencode.expr.ExtraAst) to
determine the class of the resulting expression and builds the
corresponding method signature. |
void |
literal()
Matches all variations of expression literals (constants).
|
void |
log_and_expr()
Implements the 2nd lowest precedence level of expressions:
AND
(the logical AND operator). |
static void |
main(java.lang.String[] args)
Provides a command line interface for an end user to drive and/or test
the ExpressionParser class.
|
void |
method(ExtraAst ast)
Implements the logic for matching and resolving variables and function
calls embedded in expressions.
|
private static long[] |
mk_tokenSet_0() |
private static long[] |
mk_tokenSet_1() |
private static long[] |
mk_tokenSet_10() |
private static long[] |
mk_tokenSet_11() |
private static long[] |
mk_tokenSet_12() |
private static long[] |
mk_tokenSet_13() |
private static long[] |
mk_tokenSet_14() |
private static long[] |
mk_tokenSet_15() |
private static long[] |
mk_tokenSet_16() |
private static long[] |
mk_tokenSet_17() |
private static long[] |
mk_tokenSet_18() |
private static long[] |
mk_tokenSet_19() |
private static long[] |
mk_tokenSet_2() |
private static long[] |
mk_tokenSet_20() |
private static long[] |
mk_tokenSet_21() |
private static long[] |
mk_tokenSet_22() |
private static long[] |
mk_tokenSet_23() |
private static long[] |
mk_tokenSet_24() |
private static long[] |
mk_tokenSet_3() |
private static long[] |
mk_tokenSet_4() |
private static long[] |
mk_tokenSet_5() |
private static long[] |
mk_tokenSet_6() |
private static long[] |
mk_tokenSet_7() |
private static long[] |
mk_tokenSet_8() |
private static long[] |
mk_tokenSet_9() |
void |
primary_expr(boolean topLevel)
Implements the 12th and highest precendence level of expressions, the
parenthesis precedence operators,
literal() and method(com.goldencode.expr.ExtraAst) . |
void |
prod_expr()
Implements the 10th lowest precedence level of expressions - the
multiplicative operators.
|
static java.lang.Class |
resolveClass(java.lang.String s)
Convert a
String (which is a class name or a primitive
type) into the corresponding Java Class object. |
void |
setSymbolResolver(SymbolResolver resolver)
Sets the object which will be used to resolve constants at parse time.
|
void |
shift_expr()
Implements the 8th lowest precedence level of expressions - the shift
operators.
|
void |
sum_expr()
Implements the 9th lowest precedence level of expressions - the additive
operators.
|
void |
un_expr()
Implements the 11th lowest precedence level of expressions - the unary
operators.
|
static void |
visit(antlr.CommonAST ast,
int level)
Simple walker to print out the contents of an AST for debugging.
|
addMessageListener, addParserListener, addParserMatchListener, addParserTokenListener, addSemanticPredicateListener, addSyntacticPredicateListener, addTraceListener, consumeUntil, consumeUntil, defaultDebuggingSetup, getAST, getASTFactory, getFilename, getInputState, getTokenName, getTokenNames, getTokenTypeToASTClassMap, isDebugMode, mark, match, match, matchNot, panic, recover, removeMessageListener, removeParserListener, removeParserMatchListener, removeParserTokenListener, removeSemanticPredicateListener, removeSyntacticPredicateListener, removeTraceListener, reportError, reportError, reportWarning, rewind, setASTFactory, setASTNodeClass, setASTNodeType, setDebugMode, setFilename, setIgnoreInvalidDebugCalls, setInputState, setTokenBuffer, traceIndent
private static final java.lang.String AST_CLASS
private SymbolResolver resolver
public static final java.lang.String[] _tokenNames
public static final antlr.collections.impl.BitSet _tokenSet_0
public static final antlr.collections.impl.BitSet _tokenSet_1
public static final antlr.collections.impl.BitSet _tokenSet_2
public static final antlr.collections.impl.BitSet _tokenSet_3
public static final antlr.collections.impl.BitSet _tokenSet_4
public static final antlr.collections.impl.BitSet _tokenSet_5
public static final antlr.collections.impl.BitSet _tokenSet_6
public static final antlr.collections.impl.BitSet _tokenSet_7
public static final antlr.collections.impl.BitSet _tokenSet_8
public static final antlr.collections.impl.BitSet _tokenSet_9
public static final antlr.collections.impl.BitSet _tokenSet_10
public static final antlr.collections.impl.BitSet _tokenSet_11
public static final antlr.collections.impl.BitSet _tokenSet_12
public static final antlr.collections.impl.BitSet _tokenSet_13
public static final antlr.collections.impl.BitSet _tokenSet_14
public static final antlr.collections.impl.BitSet _tokenSet_15
public static final antlr.collections.impl.BitSet _tokenSet_16
public static final antlr.collections.impl.BitSet _tokenSet_17
public static final antlr.collections.impl.BitSet _tokenSet_18
public static final antlr.collections.impl.BitSet _tokenSet_19
public static final antlr.collections.impl.BitSet _tokenSet_20
public static final antlr.collections.impl.BitSet _tokenSet_21
public static final antlr.collections.impl.BitSet _tokenSet_22
public static final antlr.collections.impl.BitSet _tokenSet_23
public static final antlr.collections.impl.BitSet _tokenSet_24
public ExpressionParser(ExpressionLexer lexer, SymbolResolver resolver)
lexer
- Expression lexer.resolver
- Object which resolves constants during lexing.setSymbolResolver(com.goldencode.expr.SymbolResolver)
public ExpressionParser(ExpressionLexer lexer, SymbolResolver resolver, boolean noAssignment)
lexer
- Expression lexer.resolver
- Object which resolves constants during lexing.noAssignment
- If false
, assignment operations are permitted;
if true
, the ASSIGN (=
) operator is
converted to the EQUALS (==
) operator.setSymbolResolver(com.goldencode.expr.SymbolResolver)
protected ExpressionParser(antlr.TokenBuffer tokenBuf, int k)
public ExpressionParser(antlr.TokenBuffer tokenBuf)
protected ExpressionParser(antlr.TokenStream lexer, int k)
public ExpressionParser(antlr.TokenStream lexer)
public ExpressionParser(antlr.ParserSharedInputState state)
public void setSymbolResolver(SymbolResolver resolver)
resolver
- Object which will resolve constants at parse time.public void convertNullTest(antlr.CommonAST ast)
NULL
equality and
inequality tests. If a NULL
token is detected on either
side of either of the operators, the result will be rooted at an
IS_NULL
(equality) or NOT_NULL
(inequality)
node. The operand that is NULL
will be dropped and the
other operand will be the only child.
This is separated from the main processing and really is a kind of post-processing of the entire tree.
public int convertFunctionToTokenType(Function func)
Java Return Parser Type --------------------------- --------------------- java.lang.Boolean METH_BOOLEAN java.lang.Double METH_DOUBLE java.lang.Long METH_LONG java.lang.Integer METH_INT anything else METH_OBJ
func
- The object representing the function call.java.lang.Class[] generateSignature(ExtraAst ast, boolean ignoreFirst)
Verifier.resolveDataType(com.goldencode.expr.ExtraAst)
to
determine the class of the resulting expression and builds the
corresponding method signature.
This rule also handles the special case of a parameter expression being
rooted at a CAST
token which is really just a parse-time
unary operator that overrides the type of the resulting parameter's
entry in the signature array. Once this override is done, the
CAST
AST is removed and the single child node is
re-parented at the method call AST directly. This allows a cast to
be used to force the correct match on the right method during method
resolution and the compiler handles any runtime casting that is needed.
ast
- The AST node representing the method call.ignoreFirst
- If true
the first child is the target instance
upon which the method is being called and must be ignored.
false
if the first child is the first parameter
to the method call.public static java.lang.Class resolveClass(java.lang.String s) throws java.lang.IllegalArgumentException
String
(which is a class name or a primitive
type) into the corresponding Java Class
object.s
- The class or primitive type name.java.lang.IllegalArgumentException
- If reflection cannot find the associated class.public static void visit(antlr.CommonAST ast, int level)
ast
- The current node to print.level
- The number of levels down from the root (0 == root node),
which determines the indention level to print.public static void main(java.lang.String[] args)
Syntax:
java ExpressionParser <expression> [no-assignment]
args
- List of command line arguments.public final java.lang.Class expression() throws antlr.RecognitionException, antlr.TokenStreamException
The AST is structured with operator nodes as the root nodes and each operator (unary or binary) has the matching number of child nodes (1 or 2 respectively). Each child node is an operand and the semantics of left and right operands (for binary operators) is maintained.
Non-operator nodes in the tree can be literals or method calls (this
is how variables and functions are both implemented). The list of
literals can be seen in the literal()
rule. Method resolution
supports full method chaining although all method calls (or chains
thereof) must start on an instance of a well known object which is
a 'variable' (an object instance that can be resolved by a method call
and is exposed by the resolver). All method support is implemented via
the method(com.goldencode.expr.ExtraAst)
rule.
All of the following operators are supported and the precedence order follows that of the Java programming language. Alternative syntax, where applicable, is shown in parentheses.
lowest conditional OR : or (||) | conditional AND : and (&&) | bitwise inclusive OR : | | bitwise exclusive OR : ^ | bitwise AND : & | equality : ==, != | relational : <, >, ≤, ≥ | shift : <<, >>, >>> | additive : +, - | multiplicative : *, /, % | unary operators : -, !, ~, #() | method call : method_name(...), object.method_name(...) highest parentheses : (...)
To handle the precedence issue, each precedence level (see the table
above) is handled in a separate rule. Starting at in this top level
entry point, the lowest precedence rule is referenced. This reference is
made with an optional OR
operator. If this operator is
present, it is the root of the resulting tree. This means it is the
last operator to be evaluated since its operands will be processed
first. This is the proper definition of lowest precedence. If this
operator is present, then a second operand is expected.
Each precedence level is similarly constructed, the left operand being required, all operators being optional and each operator choice an equal alternative. If any of the operators exists, then it is the root of the subtree and a right operand is expected. This holds true for all rules that process binary operators. Please note that this left-mandatory and optional right side (operator + right operand) is critical for allowing an expression to be as simple as a single variable, function call or literal. Alternatively, it can expand into a highly nested set of recursively parsed expressions that all evaluate to a single scalar result.
At the bottom of the hierarchy of rules are unary operators, these are implemented as an optional prefix operator and a mandatory right operand.
The final level is the primary expression. This is where the precedence
operator parenthesis is handled. It also is where we allow a single
literal, variable, or function reference. While the literals are fairly
easily defined, variables and functions are complicated by the fact that
they are used defined symbols and there is inherent ambiguity in the
definitions for each of these. See primary_expr(boolean)
for more details
details on how this is resolved.
Ambiguity is primarily caused by the potential overlap in the rules
referenced from primary_expr(boolean)
. This is caused by the fact that
multiple rule references made there must all allow for a user-defined
symbol to appear in the token stream. Multiple rules all requiring
the same definition to appear is the definition of ambiguity!
See that rule for more details on the solution.
The expr()
is called as the only rule reference.
This rule implements the only assignment type syntax that is possible in
this parser. In other words, assignments can only occur at the top-level
of an expression and cannot be placed inline. Note that the assignment
operator ASSIGN
is dropped from the resulting tree and
any variable setter method call is used as the true root node with
the required expression to the right of the assignment operator as its
only child. If the variable and assignment operator aren't present, this
rule matches a single expression.
The resulting tree will have been completely verified for validity
using Verifier.resolveDataType(com.goldencode.expr.ExtraAst)
.
antlr.RecognitionException
antlr.TokenStreamException
public final void primary_expr(boolean topLevel) throws antlr.RecognitionException, antlr.TokenStreamException
literal()
and method(com.goldencode.expr.ExtraAst)
.
This rule is different in structure from the previous levels, as there is
just a set of alternatives and one of them allows direct recursion back
to the expr
expression entry point. In addition, the method
calls can be arbitrarily chained into long sequences of methods, each being
called on the result of the last method's returned object.
If a SYMBOL
is matched in the first position, the symbol
resolver is asked to resolve the symbol to a literal as if it were a
constant. If it succeeds, we set the token's type to the appropriate
literal type, depending upon the type of object returned by the resolver.
We also set the token's text to the string value of the literal. If the
resolver returns null
, we assume the symbol represents a
variable or method call and the real work is deferred to the rule
references. Constants are optionally preceded by a qualifier symbol. If
present, this token's string is passed to the symbol resolver to be used
during the resolution of the constant. It is up to the symbol resolver
to derive meaning from the qualifier string within the context of its
implementation.
This is only called by the un_expr()
rule.
See the rule expr()
for more details.
topLevel
- true
when we're called as an assignment; otherwise
false
.antlr.RecognitionException
antlr.TokenStreamException
public final void expr() throws antlr.RecognitionException, antlr.TokenStreamException
OR
(the logical OR operator). Valid expressions can contain
sub-expressions and this entry point is properly recursive without causing
any ambiguity.
This rule is designed to allow recursion (the highest precedence levels
method(com.goldencode.expr.ExtraAst)
and primary_expr(boolean)
reference this rule again,
allowing infinite nesting of sub-expressions, with proper parsing,
evaluation and tree building.
This is only called by the top level expression()
rule. This
method calls the log_and_expr()
rule.
Implements special processing for NULL
equality and inequality
tests. If a NULL
token is detected on either side of either
of the operators, the result will be rooted at an IS_NULL
(equality) or NOT_NULL
(inequality) node. The operand that
is NULL
will be dropped and the other operand will be the
only child. This must be implemented after the entire tree is created
and the method convertNullTest(antlr.CommonAST)
is used to implement this
processing.
antlr.RecognitionException
antlr.TokenStreamException
public final void log_and_expr() throws antlr.RecognitionException, antlr.TokenStreamException
AND
(the logical AND operator).
This is only called by the expr()
rule. This method calls the
bit_or_expr()
rule.
antlr.RecognitionException
antlr.TokenStreamException
public final void bit_or_expr() throws antlr.RecognitionException, antlr.TokenStreamException
|
(the inclusive OR operator).
This is only called by the log_and_expr()
rule. This method
calls the bit_xor_expr()
rule.
antlr.RecognitionException
antlr.TokenStreamException
public final void bit_xor_expr() throws antlr.RecognitionException, antlr.TokenStreamException
^
(the exclusive OR operator).
This is only called by the bit_or_expr()
rule. This method
calls the bit_and_expr()
rule.
antlr.RecognitionException
antlr.TokenStreamException
public final void bit_and_expr() throws antlr.RecognitionException, antlr.TokenStreamException
&
(the bitwise AND operator).
This is only called by the bit_xor_expr()
rule. This method
calls the equality_expr()
rule.
antlr.RecognitionException
antlr.TokenStreamException
public final void equality_expr() throws antlr.RecognitionException, antlr.TokenStreamException
This is only called by the bit_and_expr()
rule. This method
calls the compare_expr()
rule.
Provides the following operators:
== (equality) != (inequality)
antlr.RecognitionException
antlr.TokenStreamException
public final void compare_expr() throws antlr.RecognitionException, antlr.TokenStreamException
This is only called by the equality_expr()
rule. This method calls
the shift_expr()
rule.
Provides the following operators:
> (greater than) < (less than) ≥ (greater than or equal to) ≤ (less than or equal to)
antlr.RecognitionException
antlr.TokenStreamException
public final void shift_expr() throws antlr.RecognitionException, antlr.TokenStreamException
This is only called by the compare_expr()
rule. This method calls
the sum_expr()
rule.
Provides the following operators:
>> (shift right with sign extension) << (shift left) >>> (shift right with zero extension)
antlr.RecognitionException
antlr.TokenStreamException
public final void sum_expr() throws antlr.RecognitionException, antlr.TokenStreamException
This is only called by the shift_expr()
rule. This method calls
the prod_expr()
rule.
Provides the following operators:
+ (binary plus) - (binary minus)
antlr.RecognitionException
antlr.TokenStreamException
public final void prod_expr() throws antlr.RecognitionException, antlr.TokenStreamException
This is only called by the sum_expr()
rule. This method calls
the un_expr()
rule.
Provides the following operators:
* (multiply) / (divide) % (modulus)
antlr.RecognitionException
antlr.TokenStreamException
public final void un_expr() throws antlr.RecognitionException, antlr.TokenStreamException
This is only called by the prod_expr()
rule. This method calls
the primary_expr(boolean)
rule.
Provides the following operators:
- unary minus ~ bitwise complement ! logical NOT #(classname) cast operator
antlr.RecognitionException
antlr.TokenStreamException
public final java.lang.String cast() throws antlr.RecognitionException, antlr.TokenStreamException
Note that this operator is formatted similar to a Java cast but it is prepended with a pound sign as in:
#(java.lang.String)This was done to eliminate ambiguity since our lexer and parser were both designed to operate on multipart symbol names such that it expects
DOT
and SYMBOL
tokens to be separated. Since
class names match this same form AND such names can be arbitrarily long,
this parser's design is not well suited to resolving this ambiguity
(we can't use syntactic predicates since we rely upon init rules for
data initialization and syntactic predicates make such init rules
conditional). Though it is not optimal, using the hash/pound sign works
well and eliminates all ambiguity.antlr.RecognitionException
antlr.TokenStreamException
public final void literal() throws antlr.RecognitionException, antlr.TokenStreamException
NUM_LITERAL DEC_LITERAL STRING BOOL_TRUE BOOL_FALSE NULL
antlr.RecognitionException
antlr.TokenStreamException
public final void method(ExtraAst ast) throws antlr.RecognitionException, antlr.TokenStreamException
The following are the possible resulting root nodes:
METH_OBJ METH_BOOLEAN METH_DOUBLE METH_LONG METH_INTThe if an AST is passed in, it will be set as the first child and represents the object upon which this method is to be called. All other children represent the method parameters and are used to match the signature of the method (number, order and type of parameters).
The matching portion of this rule comes in 2 parts:
LPARENS
and the last is always
RPARENS
. In between is an optional expression,
optionally followed by any number of [COMMA
expression] constructs. This is the parameter list and it can
contain any kind of expression. This recursive call to the top
level expression entry point allows the full variety of all
possible expressions to be specified as parameters.
Note that in the resulting AST, the parentheses and commas used to define the parameter list are discarded. In other words, they do not appear in the AST as nodes. Instead, each parameter (which can be a complete expression subtree or a simple single node like an lvalue) is created as a separate child node of the function type token. All parameters are maintained as child nodes in the exact order of the function call itself, so this is essentially the signature of the function. It it also the proper AST definition to enable simple evaluation of functions with any arbitrary signature.
ast
- The target object or null
if no target object
exists.antlr.RecognitionException
antlr.TokenStreamException
protected void buildTokenTypeASTClassMap()
private static final long[] mk_tokenSet_0()
private static final long[] mk_tokenSet_1()
private static final long[] mk_tokenSet_2()
private static final long[] mk_tokenSet_3()
private static final long[] mk_tokenSet_4()
private static final long[] mk_tokenSet_5()
private static final long[] mk_tokenSet_6()
private static final long[] mk_tokenSet_7()
private static final long[] mk_tokenSet_8()
private static final long[] mk_tokenSet_9()
private static final long[] mk_tokenSet_10()
private static final long[] mk_tokenSet_11()
private static final long[] mk_tokenSet_12()
private static final long[] mk_tokenSet_13()
private static final long[] mk_tokenSet_14()
private static final long[] mk_tokenSet_15()
private static final long[] mk_tokenSet_16()
private static final long[] mk_tokenSet_17()
private static final long[] mk_tokenSet_18()
private static final long[] mk_tokenSet_19()
private static final long[] mk_tokenSet_20()
private static final long[] mk_tokenSet_21()
private static final long[] mk_tokenSet_22()
private static final long[] mk_tokenSet_23()
private static final long[] mk_tokenSet_24()