// $ANTLR : "SSL.g" -> "SSLParser.java"$
package org.jakstab.ssl.parser;
import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.collections.AST;
import java.util.Hashtable;
import antlr.ASTFactory;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;
import java.util.*;
@SuppressWarnings("all")
public class SSLParser extends antlr.LLkParser implements SSLParserTokenTypes
{
// Begin parser
protected SSLParser(TokenBuffer tokenBuf, int k) {
super(tokenBuf,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public SSLParser(TokenBuffer tokenBuf) {
this(tokenBuf,3);
}
protected SSLParser(TokenStream lexer, int k) {
super(lexer,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public SSLParser(TokenStream lexer) {
this(lexer,3);
}
public SSLParser(ParserSharedInputState state) {
super(state,3);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public final void start() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST start_AST = null;
try { // for error handling
specification();
astFactory.addASTChild(currentAST, returnAST);
match(Token.EOF_TYPE);
start_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_0);
} else {
throw ex;
}
}
returnAST = start_AST;
}
public final void specification() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST specification_AST = null;
try { // for error handling
{
_loop2308:
do {
if ((_tokenSet_1.member(LA(1)))) {
part();
astFactory.addASTChild(currentAST, returnAST);
match(SEMI);
}
else {
break _loop2308;
}
} while (true);
}
if ( inputState.guessing==0 ) {
specification_AST = (AST)currentAST.root;
specification_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SEMI,"SEMI")).add(specification_AST));
currentAST.root = specification_AST;
currentAST.child = specification_AST!=null &&specification_AST.getFirstChild()!=null ?
specification_AST.getFirstChild() : specification_AST;
currentAST.advanceChildToEnd();
}
specification_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_0);
} else {
throw ex;
}
}
returnAST = specification_AST;
}
public final void part() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST part_AST = null;
try { // for error handling
switch ( LA(1)) {
case LITERAL_INTEGER:
case LITERAL_FLOAT:
{
registers_decl();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
break;
}
case LITERAL_OPERAND:
{
operands_decl();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
break;
}
case LITERAL_ENDIANNESS:
{
endianness();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
break;
}
case LITERAL_FAST:
{
fast_list();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
break;
}
default:
if ((LA(1)==NAME) && (LA(2)==EQUATE) && (LA(3)==NUM)) {
const_def();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
}
else if ((LA(1)==NAME) && (LA(2)==LPAREN)) {
function_def();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
}
else if ((LA(1)==NAME) && (LA(2)==EQUATE) && (LA(3)==NAME||LA(3)==LCURLY)) {
table_def();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
}
else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {
instr_def();
astFactory.addASTChild(currentAST, returnAST);
part_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = part_AST;
}
public final void const_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST const_def_AST = null;
AST v_AST = null;
try { // for error handling
AST tmp102_AST = null;
tmp102_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp102_AST);
match(NAME);
match(EQUATE);
const_expr();
v_AST = (AST)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
const_def_AST = (AST)currentAST.root;
const_def_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CONSTANT,"CONSTANT")).add(const_def_AST));
currentAST.root = const_def_AST;
currentAST.child = const_def_AST!=null &&const_def_AST.getFirstChild()!=null ?
const_def_AST.getFirstChild() : const_def_AST;
currentAST.advanceChildToEnd();
}
const_def_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = const_def_AST;
}
public final void registers_decl() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST registers_decl_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case LITERAL_INTEGER:
{
AST tmp104_AST = null;
tmp104_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp104_AST);
match(LITERAL_INTEGER);
break;
}
case LITERAL_FLOAT:
{
AST tmp105_AST = null;
tmp105_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp105_AST);
match(LITERAL_FLOAT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
register_decl();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2319:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
register_decl();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2319;
}
} while (true);
}
if ( inputState.guessing==0 ) {
registers_decl_AST = (AST)currentAST.root;
registers_decl_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(REGDECL,"REGDECL")).add(registers_decl_AST));
currentAST.root = registers_decl_AST;
currentAST.child = registers_decl_AST!=null &®isters_decl_AST.getFirstChild()!=null ?
registers_decl_AST.getFirstChild() : registers_decl_AST;
currentAST.advanceChildToEnd();
}
registers_decl_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = registers_decl_AST;
}
public final void operands_decl() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST operands_decl_AST = null;
try { // for error handling
AST tmp107_AST = null;
tmp107_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp107_AST);
match(LITERAL_OPERAND);
operand_decl();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2328:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
operand_decl();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2328;
}
} while (true);
}
operands_decl_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = operands_decl_AST;
}
public final void endianness() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST endianness_AST = null;
try { // for error handling
AST tmp109_AST = null;
tmp109_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp109_AST);
match(LITERAL_ENDIANNESS);
{
switch ( LA(1)) {
case LITERAL_BIG:
{
AST tmp110_AST = null;
tmp110_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp110_AST);
match(LITERAL_BIG);
break;
}
case LITERAL_LITTLE:
{
AST tmp111_AST = null;
tmp111_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp111_AST);
match(LITERAL_LITTLE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
endianness_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = endianness_AST;
}
public final void function_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST function_def_AST = null;
try { // for error handling
AST tmp112_AST = null;
tmp112_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp112_AST);
match(NAME);
match(LPAREN);
param_list();
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
match(LCURLY);
rt_list();
astFactory.addASTChild(currentAST, returnAST);
match(RCURLY);
if ( inputState.guessing==0 ) {
function_def_AST = (AST)currentAST.root;
function_def_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FUNCTION,"FUNCTION")).add(function_def_AST));
currentAST.root = function_def_AST;
currentAST.child = function_def_AST!=null &&function_def_AST.getFirstChild()!=null ?
function_def_AST.getFirstChild() : function_def_AST;
currentAST.advanceChildToEnd();
}
function_def_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = function_def_AST;
}
public final void table_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST table_def_AST = null;
try { // for error handling
AST tmp117_AST = null;
tmp117_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp117_AST);
match(NAME);
match(EQUATE);
table_expr();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
table_def_AST = (AST)currentAST.root;
table_def_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TABLE,"TABLE")).add(table_def_AST));
currentAST.root = table_def_AST;
currentAST.child = table_def_AST!=null &&table_def_AST.getFirstChild()!=null ?
table_def_AST.getFirstChild() : table_def_AST;
currentAST.advanceChildToEnd();
}
table_def_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = table_def_AST;
}
public final void instr_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST instr_def_AST = null;
try { // for error handling
instr_name();
astFactory.addASTChild(currentAST, returnAST);
param_list();
astFactory.addASTChild(currentAST, returnAST);
rt_list();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
instr_def_AST = (AST)currentAST.root;
instr_def_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTR,"INSTR")).add(instr_def_AST));
currentAST.root = instr_def_AST;
currentAST.child = instr_def_AST!=null &&instr_def_AST.getFirstChild()!=null ?
instr_def_AST.getFirstChild() : instr_def_AST;
currentAST.advanceChildToEnd();
}
instr_def_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = instr_def_AST;
}
public final void fast_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST fast_list_AST = null;
try { // for error handling
AST tmp119_AST = null;
tmp119_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp119_AST);
match(LITERAL_FAST);
fast_entry();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2427:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
fast_entry();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2427;
}
} while (true);
}
fast_list_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = fast_list_AST;
}
public final void num() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST num_AST = null;
try { // for error handling
AST tmp121_AST = null;
tmp121_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp121_AST);
match(NUM);
num_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_5);
} else {
throw ex;
}
}
returnAST = num_AST;
}
public final void const_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST const_expr_AST = null;
try { // for error handling
AST tmp122_AST = null;
tmp122_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp122_AST);
match(NUM);
{
_loop2315:
do {
if ((LA(1)==PLUS||LA(1)==MINUS)) {
{
switch ( LA(1)) {
case PLUS:
{
AST tmp123_AST = null;
tmp123_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp123_AST);
match(PLUS);
break;
}
case MINUS:
{
AST tmp124_AST = null;
tmp124_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp124_AST);
match(MINUS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
AST tmp125_AST = null;
tmp125_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp125_AST);
match(NUM);
}
else {
break _loop2315;
}
} while (true);
}
const_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = const_expr_AST;
}
public final void register_decl() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST register_decl_AST = null;
try { // for error handling
if ((LA(1)==REG_ID) && (LA(2)==INDEX)) {
AST tmp126_AST = null;
tmp126_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp126_AST);
match(REG_ID);
AST tmp127_AST = null;
tmp127_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp127_AST);
match(INDEX);
num();
astFactory.addASTChild(currentAST, returnAST);
register_decl_AST = (AST)currentAST.root;
}
else if ((LA(1)==REG_ID) && (LA(2)==LSQUARE)) {
AST tmp128_AST = null;
tmp128_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp128_AST);
match(REG_ID);
AST tmp129_AST = null;
tmp129_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp129_AST);
match(LSQUARE);
num();
astFactory.addASTChild(currentAST, returnAST);
AST tmp130_AST = null;
tmp130_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp130_AST);
match(RSQUARE);
AST tmp131_AST = null;
tmp131_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp131_AST);
match(INDEX);
num();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case LITERAL_COVERS:
{
AST tmp132_AST = null;
tmp132_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp132_AST);
match(LITERAL_COVERS);
AST tmp133_AST = null;
tmp133_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp133_AST);
match(REG_ID);
AST tmp134_AST = null;
tmp134_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp134_AST);
match(TO);
AST tmp135_AST = null;
tmp135_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp135_AST);
match(REG_ID);
break;
}
case LITERAL_SHARES:
{
AST tmp136_AST = null;
tmp136_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp136_AST);
match(LITERAL_SHARES);
AST tmp137_AST = null;
tmp137_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp137_AST);
match(REG_ID);
AST tmp138_AST = null;
tmp138_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp138_AST);
match(AT);
AST tmp139_AST = null;
tmp139_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp139_AST);
match(LSQUARE);
num();
astFactory.addASTChild(currentAST, returnAST);
AST tmp140_AST = null;
tmp140_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp140_AST);
match(TO);
num();
astFactory.addASTChild(currentAST, returnAST);
AST tmp141_AST = null;
tmp141_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp141_AST);
match(RSQUARE);
break;
}
case SEMI:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
register_decl_AST = (AST)currentAST.root;
}
else if ((LA(1)==LSQUARE)) {
AST tmp142_AST = null;
tmp142_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp142_AST);
match(LSQUARE);
register_list();
astFactory.addASTChild(currentAST, returnAST);
AST tmp143_AST = null;
tmp143_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp143_AST);
match(RSQUARE);
AST tmp144_AST = null;
tmp144_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp144_AST);
match(LSQUARE);
num();
astFactory.addASTChild(currentAST, returnAST);
AST tmp145_AST = null;
tmp145_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp145_AST);
match(RSQUARE);
AST tmp146_AST = null;
tmp146_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp146_AST);
match(INDEX);
num();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case TO:
{
AST tmp147_AST = null;
tmp147_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp147_AST);
match(TO);
num();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case SEMI:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
register_decl_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_6);
} else {
throw ex;
}
}
returnAST = register_decl_AST;
}
public final void register_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST register_list_AST = null;
try { // for error handling
AST tmp148_AST = null;
tmp148_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp148_AST);
match(REG_ID);
{
_loop2325:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
AST tmp150_AST = null;
tmp150_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp150_AST);
match(REG_ID);
}
else {
break _loop2325;
}
} while (true);
}
register_list_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_7);
} else {
throw ex;
}
}
returnAST = register_list_AST;
}
public final void operand_decl() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST operand_decl_AST = null;
try { // for error handling
if ((LA(1)==NAME) && (LA(2)==EQUATE)) {
AST tmp151_AST = null;
tmp151_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp151_AST);
match(NAME);
AST tmp152_AST = null;
tmp152_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp152_AST);
match(EQUATE);
match(LCURLY);
param_list();
astFactory.addASTChild(currentAST, returnAST);
match(RCURLY);
operand_decl_AST = (AST)currentAST.root;
}
else if ((LA(1)==NAME) && (LA(2)==NAME||LA(2)==LSQUARE||LA(2)==ASSIGNTYPE)) {
AST tmp155_AST = null;
tmp155_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp155_AST);
match(NAME);
param_list();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case LSQUARE:
{
AST tmp156_AST = null;
tmp156_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp156_AST);
match(LSQUARE);
param_list();
astFactory.addASTChild(currentAST, returnAST);
AST tmp157_AST = null;
tmp157_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp157_AST);
match(RSQUARE);
break;
}
case ASSIGNTYPE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
AST tmp158_AST = null;
tmp158_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp158_AST);
match(ASSIGNTYPE);
expr();
astFactory.addASTChild(currentAST, returnAST);
operand_decl_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_6);
} else {
throw ex;
}
}
returnAST = operand_decl_AST;
}
public final void param_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST param_list_AST = null;
Token t = null;
AST t_AST = null;
try { // for error handling
{
boolean synPredMatched2375 = false;
if (((LA(1)==NAME) && (_tokenSet_8.member(LA(2))) && (_tokenSet_9.member(LA(3))))) {
int _m2375 = mark();
synPredMatched2375 = true;
inputState.guessing++;
try {
{
match(NAME);
}
}
catch (RecognitionException pe) {
synPredMatched2375 = false;
}
rewind(_m2375);
inputState.guessing--;
}
if ( synPredMatched2375 ) {
AST tmp159_AST = null;
tmp159_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp159_AST);
match(NAME);
{
_loop2377:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
t = LT(1);
t_AST = astFactory.create(t);
astFactory.addASTChild(currentAST, t_AST);
match(NAME);
}
else {
break _loop2377;
}
} while (true);
}
}
else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_9.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if ( inputState.guessing==0 ) {
param_list_AST = (AST)currentAST.root;
param_list_AST = (AST)astFactory.make( (new ASTArray(2)).add((AST)astFactory.create(COMMA,",")).add(param_list_AST));
currentAST.root = param_list_AST;
currentAST.child = param_list_AST!=null &¶m_list_AST.getFirstChild()!=null ?
param_list_AST.getFirstChild() : param_list_AST;
currentAST.advanceChildToEnd();
}
param_list_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_10);
} else {
throw ex;
}
}
returnAST = param_list_AST;
}
public final void expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST expr_AST = null;
try { // for error handling
log_expr();
astFactory.addASTChild(currentAST, returnAST);
expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_12);
} else {
throw ex;
}
}
returnAST = expr_AST;
}
public final void rt_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST rt_list_AST = null;
try { // for error handling
{
int _cnt2370=0;
_loop2370:
do {
if ((_tokenSet_13.member(LA(1)))) {
rt();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt2370>=1 ) { break _loop2370; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt2370++;
} while (true);
}
if ( inputState.guessing==0 ) {
rt_list_AST = (AST)currentAST.root;
rt_list_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RTL,"RTL")).add(rt_list_AST));
currentAST.root = rt_list_AST;
currentAST.child = rt_list_AST!=null &&rt_list_AST.getFirstChild()!=null ?
rt_list_AST.getFirstChild() : rt_list_AST;
currentAST.advanceChildToEnd();
}
rt_list_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_14);
} else {
throw ex;
}
}
returnAST = rt_list_AST;
}
public final void table_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST table_expr_AST = null;
try { // for error handling
boolean synPredMatched2337 = false;
if (((LA(1)==NAME||LA(1)==LCURLY) && (_tokenSet_15.member(LA(2))) && (_tokenSet_16.member(LA(3))))) {
int _m2337 = mark();
synPredMatched2337 = true;
inputState.guessing++;
try {
{
str_table_expr();
}
}
catch (RecognitionException pe) {
synPredMatched2337 = false;
}
rewind(_m2337);
inputState.guessing--;
}
if ( synPredMatched2337 ) {
str_table_expr();
astFactory.addASTChild(currentAST, returnAST);
table_expr_AST = (AST)currentAST.root;
}
else if ((LA(1)==LCURLY) && (LA(2)==QUOTE) && (_tokenSet_17.member(LA(3)))) {
op_str_table();
astFactory.addASTChild(currentAST, returnAST);
table_expr_AST = (AST)currentAST.root;
}
else if ((LA(1)==LCURLY) && (LA(2)==QUOTE) && (_tokenSet_18.member(LA(3)))) {
expr_str_table();
astFactory.addASTChild(currentAST, returnAST);
table_expr_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = table_expr_AST;
}
public final void str_table_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST str_table_expr_AST = null;
try { // for error handling
str_table();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2340:
do {
if ((LA(1)==NAME||LA(1)==LCURLY)) {
str_table();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
str_table_expr_AST = (AST)currentAST.root;
str_table_expr_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CROSSP,"CROSSP")).add(str_table_expr_AST));
currentAST.root = str_table_expr_AST;
currentAST.child = str_table_expr_AST!=null &&str_table_expr_AST.getFirstChild()!=null ?
str_table_expr_AST.getFirstChild() : str_table_expr_AST;
currentAST.advanceChildToEnd();
}
}
else {
break _loop2340;
}
} while (true);
}
str_table_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = str_table_expr_AST;
}
public final void op_str_table() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST op_str_table_AST = null;
AST t_AST = null;
try { // for error handling
AST tmp161_AST = null;
tmp161_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp161_AST);
match(LCURLY);
op_str_entry();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2347:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
op_str_entry();
t_AST = (AST)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2347;
}
} while (true);
}
match(RCURLY);
op_str_table_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = op_str_table_AST;
}
public final void expr_str_table() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST expr_str_table_AST = null;
AST t_AST = null;
try { // for error handling
AST tmp164_AST = null;
tmp164_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp164_AST);
match(LCURLY);
expr_str_entry();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2352:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
expr_str_entry();
t_AST = (AST)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2352;
}
} while (true);
}
match(RCURLY);
expr_str_table_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_4);
} else {
throw ex;
}
}
returnAST = expr_str_table_AST;
}
public final void str_table() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST str_table_AST = null;
try { // for error handling
switch ( LA(1)) {
case NAME:
{
AST tmp167_AST = null;
tmp167_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp167_AST);
match(NAME);
str_table_AST = (AST)currentAST.root;
break;
}
case LCURLY:
{
AST tmp168_AST = null;
tmp168_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp168_AST);
match(LCURLY);
str_entry();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2343:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
str_entry();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2343;
}
} while (true);
}
match(RCURLY);
str_table_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_19);
} else {
throw ex;
}
}
returnAST = str_table_AST;
}
public final void str_entry() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST str_entry_AST = null;
try { // for error handling
if ((LA(1)==NAME)) {
AST tmp171_AST = null;
tmp171_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp171_AST);
match(NAME);
str_entry_AST = (AST)currentAST.root;
}
else if ((LA(1)==QUOTE) && (LA(2)==QUOTE)) {
AST tmp172_AST = null;
tmp172_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp172_AST);
match(QUOTE);
match(QUOTE);
if ( inputState.guessing==0 ) {
str_entry_AST = (AST)currentAST.root;
str_entry_AST = (AST)astFactory.make( (new ASTArray(2)).add(str_entry_AST).add(astFactory.create(NAME,"")));
currentAST.root = str_entry_AST;
currentAST.child = str_entry_AST!=null &&str_entry_AST.getFirstChild()!=null ?
str_entry_AST.getFirstChild() : str_entry_AST;
currentAST.advanceChildToEnd();
}
str_entry_AST = (AST)currentAST.root;
}
else if ((LA(1)==QUOTE) && (LA(2)==NAME)) {
AST tmp174_AST = null;
tmp174_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp174_AST);
match(QUOTE);
AST tmp175_AST = null;
tmp175_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp175_AST);
match(NAME);
match(QUOTE);
str_entry_AST = (AST)currentAST.root;
}
else if ((LA(1)==QUOTE) && (LA(2)==DECOR)) {
AST tmp177_AST = null;
tmp177_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp177_AST);
match(QUOTE);
AST tmp178_AST = null;
tmp178_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp178_AST);
match(DECOR);
match(QUOTE);
str_entry_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_20);
} else {
throw ex;
}
}
returnAST = str_entry_AST;
}
public final void op_str_entry() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST op_str_entry_AST = null;
try { // for error handling
AST tmp180_AST = null;
tmp180_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp180_AST);
match(QUOTE);
bin_oper();
astFactory.addASTChild(currentAST, returnAST);
match(QUOTE);
op_str_entry_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_20);
} else {
throw ex;
}
}
returnAST = op_str_entry_AST;
}
public final void bin_oper() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST bin_oper_AST = null;
try { // for error handling
switch ( LA(1)) {
case MOD:
{
AST tmp182_AST = null;
tmp182_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp182_AST);
match(MOD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MUL:
{
AST tmp183_AST = null;
tmp183_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp183_AST);
match(MUL);
bin_oper_AST = (AST)currentAST.root;
break;
}
case DIV:
{
AST tmp184_AST = null;
tmp184_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp184_AST);
match(DIV);
bin_oper_AST = (AST)currentAST.root;
break;
}
case SMUL:
{
AST tmp185_AST = null;
tmp185_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp185_AST);
match(SMUL);
bin_oper_AST = (AST)currentAST.root;
break;
}
case SDIV:
{
AST tmp186_AST = null;
tmp186_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp186_AST);
match(SDIV);
bin_oper_AST = (AST)currentAST.root;
break;
}
case SMOD:
{
AST tmp187_AST = null;
tmp187_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp187_AST);
match(SMOD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case PLUS:
{
AST tmp188_AST = null;
tmp188_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp188_AST);
match(PLUS);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MINUS:
{
AST tmp189_AST = null;
tmp189_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp189_AST);
match(MINUS);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LITERAL_rlc:
{
AST tmp190_AST = null;
tmp190_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp190_AST);
match(LITERAL_rlc);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LITERAL_rrc:
{
AST tmp191_AST = null;
tmp191_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp191_AST);
match(LITERAL_rrc);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LITERAL_rl:
{
AST tmp192_AST = null;
tmp192_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp192_AST);
match(LITERAL_rl);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LITERAL_rr:
{
AST tmp193_AST = null;
tmp193_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp193_AST);
match(LITERAL_rr);
bin_oper_AST = (AST)currentAST.root;
break;
}
case RSHIFT:
{
AST tmp194_AST = null;
tmp194_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp194_AST);
match(RSHIFT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LSHIFT:
{
AST tmp195_AST = null;
tmp195_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp195_AST);
match(LSHIFT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case RSHIFTA:
{
AST tmp196_AST = null;
tmp196_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp196_AST);
match(RSHIFTA);
bin_oper_AST = (AST)currentAST.root;
break;
}
case OR:
{
AST tmp197_AST = null;
tmp197_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp197_AST);
match(OR);
bin_oper_AST = (AST)currentAST.root;
break;
}
case ORNOT:
{
AST tmp198_AST = null;
tmp198_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp198_AST);
match(ORNOT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case AND:
{
AST tmp199_AST = null;
tmp199_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp199_AST);
match(AND);
bin_oper_AST = (AST)currentAST.root;
break;
}
case ANDNOT:
{
AST tmp200_AST = null;
tmp200_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp200_AST);
match(ANDNOT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case XOR:
{
AST tmp201_AST = null;
tmp201_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp201_AST);
match(XOR);
bin_oper_AST = (AST)currentAST.root;
break;
}
case XORNOT:
{
AST tmp202_AST = null;
tmp202_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp202_AST);
match(XORNOT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MUL_F:
{
AST tmp203_AST = null;
tmp203_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp203_AST);
match(MUL_F);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MUL_FD:
{
AST tmp204_AST = null;
tmp204_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp204_AST);
match(MUL_FD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MUL_FQ:
{
AST tmp205_AST = null;
tmp205_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp205_AST);
match(MUL_FQ);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MUL_FSD:
{
AST tmp206_AST = null;
tmp206_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp206_AST);
match(MUL_FSD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MUL_FDQ:
{
AST tmp207_AST = null;
tmp207_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp207_AST);
match(MUL_FDQ);
bin_oper_AST = (AST)currentAST.root;
break;
}
case DIV_F:
{
AST tmp208_AST = null;
tmp208_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp208_AST);
match(DIV_F);
bin_oper_AST = (AST)currentAST.root;
break;
}
case DIV_FD:
{
AST tmp209_AST = null;
tmp209_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp209_AST);
match(DIV_FD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case DIV_FQ:
{
AST tmp210_AST = null;
tmp210_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp210_AST);
match(DIV_FQ);
bin_oper_AST = (AST)currentAST.root;
break;
}
case PLUS_F:
{
AST tmp211_AST = null;
tmp211_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp211_AST);
match(PLUS_F);
bin_oper_AST = (AST)currentAST.root;
break;
}
case PLUS_FD:
{
AST tmp212_AST = null;
tmp212_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp212_AST);
match(PLUS_FD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case PLUS_FQ:
{
AST tmp213_AST = null;
tmp213_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp213_AST);
match(PLUS_FQ);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MINUS_F:
{
AST tmp214_AST = null;
tmp214_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp214_AST);
match(MINUS_F);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MINUS_FD:
{
AST tmp215_AST = null;
tmp215_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp215_AST);
match(MINUS_FD);
bin_oper_AST = (AST)currentAST.root;
break;
}
case MINUS_FQ:
{
AST tmp216_AST = null;
tmp216_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp216_AST);
match(MINUS_FQ);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LITERAL_pow:
{
AST tmp217_AST = null;
tmp217_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp217_AST);
match(LITERAL_pow);
bin_oper_AST = (AST)currentAST.root;
break;
}
case EQ:
{
AST tmp218_AST = null;
tmp218_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp218_AST);
match(EQ);
bin_oper_AST = (AST)currentAST.root;
break;
}
case NE:
{
AST tmp219_AST = null;
tmp219_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp219_AST);
match(NE);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LT:
{
AST tmp220_AST = null;
tmp220_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp220_AST);
match(LT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case GT:
{
AST tmp221_AST = null;
tmp221_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp221_AST);
match(GT);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LE:
{
AST tmp222_AST = null;
tmp222_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp222_AST);
match(LE);
bin_oper_AST = (AST)currentAST.root;
break;
}
case GE:
{
AST tmp223_AST = null;
tmp223_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp223_AST);
match(GE);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LTU:
{
AST tmp224_AST = null;
tmp224_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp224_AST);
match(LTU);
bin_oper_AST = (AST)currentAST.root;
break;
}
case GTU:
{
AST tmp225_AST = null;
tmp225_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp225_AST);
match(GTU);
bin_oper_AST = (AST)currentAST.root;
break;
}
case LEU:
{
AST tmp226_AST = null;
tmp226_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp226_AST);
match(LEU);
bin_oper_AST = (AST)currentAST.root;
break;
}
case GEU:
{
AST tmp227_AST = null;
tmp227_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp227_AST);
match(GEU);
bin_oper_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_21);
} else {
throw ex;
}
}
returnAST = bin_oper_AST;
}
public final void expr_str_entry() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST expr_str_entry_AST = null;
try { // for error handling
AST tmp228_AST = null;
tmp228_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp228_AST);
match(QUOTE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(QUOTE);
expr_str_entry_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_20);
} else {
throw ex;
}
}
returnAST = expr_str_entry_AST;
}
public final void instr_name() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST instr_name_AST = null;
try { // for error handling
instr_name_head();
astFactory.addASTChild(currentAST, returnAST);
instr_name_tail();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2357:
do {
if ((LA(1)==DECOR)) {
instr_name_decor();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2357;
}
} while (true);
}
if ( inputState.guessing==0 ) {
instr_name_AST = (AST)currentAST.root;
instr_name_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTR_NAME,"INSTR_NAME")).add(instr_name_AST));
currentAST.root = instr_name_AST;
currentAST.child = instr_name_AST!=null &&instr_name_AST.getFirstChild()!=null ?
instr_name_AST.getFirstChild() : instr_name_AST;
currentAST.advanceChildToEnd();
}
instr_name_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_13);
} else {
throw ex;
}
}
returnAST = instr_name_AST;
}
public final void instr_name_head() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST instr_name_head_AST = null;
try { // for error handling
boolean synPredMatched2360 = false;
if (((_tokenSet_2.member(LA(1))) && (LA(2)==NAME||LA(2)==LSQUARE) && (_tokenSet_22.member(LA(3))))) {
int _m2360 = mark();
synPredMatched2360 = true;
inputState.guessing++;
try {
{
instr_name_elem();
}
}
catch (RecognitionException pe) {
synPredMatched2360 = false;
}
rewind(_m2360);
inputState.guessing--;
}
if ( synPredMatched2360 ) {
instr_name_elem();
astFactory.addASTChild(currentAST, returnAST);
instr_name_tail();
astFactory.addASTChild(currentAST, returnAST);
instr_name_head_AST = (AST)currentAST.root;
}
else if ((LA(1)==NAME) && (_tokenSet_23.member(LA(2))) && (_tokenSet_24.member(LA(3)))) {
AST tmp230_AST = null;
tmp230_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp230_AST);
match(NAME);
instr_name_head_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_23);
} else {
throw ex;
}
}
returnAST = instr_name_head_AST;
}
public final void instr_name_tail() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST instr_name_tail_AST = null;
try { // for error handling
boolean synPredMatched2366 = false;
if (((_tokenSet_2.member(LA(1))) && (LA(2)==NAME||LA(2)==LSQUARE) && (_tokenSet_22.member(LA(3))))) {
int _m2366 = mark();
synPredMatched2366 = true;
inputState.guessing++;
try {
{
instr_name_elem();
}
}
catch (RecognitionException pe) {
synPredMatched2366 = false;
}
rewind(_m2366);
inputState.guessing--;
}
if ( synPredMatched2366 ) {
instr_name_elem();
astFactory.addASTChild(currentAST, returnAST);
instr_name_tail();
astFactory.addASTChild(currentAST, returnAST);
instr_name_tail_AST = (AST)currentAST.root;
}
else if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_25.member(LA(3)))) {
instr_name_tail_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_23);
} else {
throw ex;
}
}
returnAST = instr_name_tail_AST;
}
public final void instr_name_decor() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST instr_name_decor_AST = null;
try { // for error handling
AST tmp231_AST = null;
tmp231_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp231_AST);
match(DECOR);
instr_name_decor_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_26);
} else {
throw ex;
}
}
returnAST = instr_name_decor_AST;
}
public final void instr_name_elem() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST instr_name_elem_AST = null;
try { // for error handling
switch ( LA(1)) {
case PRIME:
{
AST tmp232_AST = null;
tmp232_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp232_AST);
match(PRIME);
AST tmp233_AST = null;
tmp233_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp233_AST);
match(NAME);
match(PRIME);
instr_name_elem_AST = (AST)currentAST.root;
break;
}
case QUOTE:
{
match(QUOTE);
AST tmp236_AST = null;
tmp236_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp236_AST);
match(NAME);
match(QUOTE);
instr_name_elem_AST = (AST)currentAST.root;
break;
}
case NAME:
{
AST tmp238_AST = null;
tmp238_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp238_AST);
match(NAME);
AST tmp239_AST = null;
tmp239_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp239_AST);
match(LSQUARE);
{
switch ( LA(1)) {
case NUM:
{
num();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case NAME:
{
AST tmp240_AST = null;
tmp240_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp240_AST);
match(NAME);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RSQUARE);
instr_name_elem_AST = (AST)currentAST.root;
break;
}
case DOLLAR:
{
match(DOLLAR);
AST tmp243_AST = null;
tmp243_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp243_AST);
match(NAME);
AST tmp244_AST = null;
tmp244_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp244_AST);
match(LSQUARE);
{
switch ( LA(1)) {
case NUM:
{
num();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case NAME:
{
AST tmp245_AST = null;
tmp245_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp245_AST);
match(NAME);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RSQUARE);
instr_name_elem_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_23);
} else {
throw ex;
}
}
returnAST = instr_name_elem_AST;
}
public final void rt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST rt_AST = null;
try { // for error handling
switch ( LA(1)) {
case ASSIGNTYPE:
case LITERAL_MEMSET:
case LITERAL_MEMCPY:
{
assign_rt();
astFactory.addASTChild(currentAST, returnAST);
rt_AST = (AST)currentAST.root;
break;
}
case NAME:
{
AST tmp247_AST = null;
tmp247_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp247_AST);
match(NAME);
match(LPAREN);
expr_list();
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
if ( inputState.guessing==0 ) {
rt_AST = (AST)currentAST.root;
rt_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FUNCTION,"FUNCTION")).add(rt_AST));
currentAST.root = rt_AST;
currentAST.child = rt_AST!=null &&rt_AST.getFirstChild()!=null ?
rt_AST.getFirstChild() : rt_AST;
currentAST.advanceChildToEnd();
}
rt_AST = (AST)currentAST.root;
break;
}
case LITERAL_halt:
{
AST tmp250_AST = null;
tmp250_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp250_AST);
match(LITERAL_halt);
rt_AST = (AST)currentAST.root;
break;
}
case UNDERSCORE:
{
match(UNDERSCORE);
rt_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_27);
} else {
throw ex;
}
}
returnAST = rt_AST;
}
public final void assign_rt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST assign_rt_AST = null;
try { // for error handling
switch ( LA(1)) {
case ASSIGNTYPE:
{
AST tmp252_AST = null;
tmp252_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp252_AST);
match(ASSIGNTYPE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(EQUATE);
expr();
astFactory.addASTChild(currentAST, returnAST);
assign_rt_AST = (AST)currentAST.root;
break;
}
case LITERAL_MEMSET:
{
AST tmp254_AST = null;
tmp254_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp254_AST);
match(LITERAL_MEMSET);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COMMA);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COMMA);
expr();
astFactory.addASTChild(currentAST, returnAST);
assign_rt_AST = (AST)currentAST.root;
break;
}
case LITERAL_MEMCPY:
{
AST tmp257_AST = null;
tmp257_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp257_AST);
match(LITERAL_MEMCPY);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COMMA);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COMMA);
expr();
astFactory.addASTChild(currentAST, returnAST);
assign_rt_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_27);
} else {
throw ex;
}
}
returnAST = assign_rt_AST;
}
public final void expr_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST expr_list_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case NUM:
case NAME:
case REG_ID:
case LSQUARE:
case LPAREN:
case REG_IDX:
case MEM_IDX:
case FLOATNUM:
case NOT:
case FNEG:
case LNOT:
{
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2424:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2424;
}
} while (true);
}
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr_list_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_28);
} else {
throw ex;
}
}
returnAST = expr_list_AST;
}
public final void var() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST var_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case REG_ID:
{
AST tmp261_AST = null;
tmp261_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp261_AST);
match(REG_ID);
break;
}
case REG_IDX:
{
AST tmp262_AST = null;
tmp262_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp262_AST);
match(REG_IDX);
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
break;
}
case MEM_IDX:
{
AST tmp265_AST = null;
tmp265_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp265_AST);
match(MEM_IDX);
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
break;
}
case NAME:
{
AST tmp268_AST = null;
tmp268_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp268_AST);
match(NAME);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop2382:
do {
switch ( LA(1)) {
case AT:
{
AST tmp269_AST = null;
tmp269_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp269_AST);
match(AT);
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COLON);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
break;
}
case PRIME:
{
AST tmp273_AST = null;
tmp273_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp273_AST);
match(PRIME);
break;
}
default:
{
break _loop2382;
}
}
} while (true);
}
var_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_0);
} else {
throw ex;
}
}
returnAST = var_AST;
}
public final void primary_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST primary_expr_AST = null;
try { // for error handling
switch ( LA(1)) {
case NUM:
{
AST tmp274_AST = null;
tmp274_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp274_AST);
match(NUM);
primary_expr_AST = (AST)currentAST.root;
break;
}
case FLOATNUM:
{
AST tmp275_AST = null;
tmp275_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp275_AST);
match(FLOATNUM);
primary_expr_AST = (AST)currentAST.root;
break;
}
case REG_ID:
{
AST tmp276_AST = null;
tmp276_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp276_AST);
match(REG_ID);
primary_expr_AST = (AST)currentAST.root;
break;
}
case REG_IDX:
{
AST tmp277_AST = null;
tmp277_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp277_AST);
match(REG_IDX);
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
primary_expr_AST = (AST)currentAST.root;
break;
}
case MEM_IDX:
{
AST tmp280_AST = null;
tmp280_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp280_AST);
match(MEM_IDX);
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
primary_expr_AST = (AST)currentAST.root;
break;
}
case LPAREN:
{
match(LPAREN);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
primary_expr_AST = (AST)currentAST.root;
break;
}
case LSQUARE:
{
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
AST tmp286_AST = null;
tmp286_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp286_AST);
match(QUEST);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COLON);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
primary_expr_AST = (AST)currentAST.root;
break;
}
default:
if ((LA(1)==NAME) && (_tokenSet_29.member(LA(2)))) {
AST tmp289_AST = null;
tmp289_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp289_AST);
match(NAME);
primary_expr_AST = (AST)currentAST.root;
}
else if ((LA(1)==NAME) && (LA(2)==LSQUARE)) {
AST tmp290_AST = null;
tmp290_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp290_AST);
match(NAME);
AST tmp291_AST = null;
tmp291_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp291_AST);
match(LSQUARE);
{
switch ( LA(1)) {
case NAME:
{
AST tmp292_AST = null;
tmp292_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp292_AST);
match(NAME);
break;
}
case NUM:
{
AST tmp293_AST = null;
tmp293_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp293_AST);
match(NUM);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RSQUARE);
primary_expr_AST = (AST)currentAST.root;
}
else if ((LA(1)==NAME) && (LA(2)==LPAREN)) {
AST tmp295_AST = null;
tmp295_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp295_AST);
match(NAME);
match(LPAREN);
expr_list();
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
if ( inputState.guessing==0 ) {
primary_expr_AST = (AST)currentAST.root;
primary_expr_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(BUILTIN,"BUILTIN")).add(primary_expr_AST));
currentAST.root = primary_expr_AST;
currentAST.child = primary_expr_AST!=null &&primary_expr_AST.getFirstChild()!=null ?
primary_expr_AST.getFirstChild() : primary_expr_AST;
currentAST.advanceChildToEnd();
}
primary_expr_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_29);
} else {
throw ex;
}
}
returnAST = primary_expr_AST;
}
public final void postfix_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST postfix_expr_AST = null;
AST primary_AST = null;
AST width_AST = null;
try { // for error handling
primary_expr();
primary_AST = (AST)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop2392:
do {
switch ( LA(1)) {
case AT:
{
AST tmp298_AST = null;
tmp298_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp298_AST);
match(AT);
match(LSQUARE);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(COLON);
expr();
astFactory.addASTChild(currentAST, returnAST);
match(RSQUARE);
break;
}
case S_E:
{
AST tmp302_AST = null;
tmp302_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp302_AST);
match(S_E);
break;
}
case LCURLY:
{
{
AST tmp303_AST = null;
tmp303_AST = astFactory.create(LT(1));
match(LCURLY);
num();
width_AST = (AST)returnAST;
AST tmp304_AST = null;
tmp304_AST = astFactory.create(LT(1));
match(RCURLY);
}
if ( inputState.guessing==0 ) {
postfix_expr_AST = (AST)currentAST.root;
postfix_expr_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(CAST,"CAST")).add(width_AST).add(postfix_expr_AST));
currentAST.root = postfix_expr_AST;
currentAST.child = postfix_expr_AST!=null &&postfix_expr_AST.getFirstChild()!=null ?
postfix_expr_AST.getFirstChild() : postfix_expr_AST;
currentAST.advanceChildToEnd();
}
break;
}
default:
{
break _loop2392;
}
}
} while (true);
}
postfix_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_30);
} else {
throw ex;
}
}
returnAST = postfix_expr_AST;
}
public final void lookup_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST lookup_expr_AST = null;
try { // for error handling
postfix_expr();
astFactory.addASTChild(currentAST, returnAST);
{
boolean synPredMatched2396 = false;
if (((LA(1)==NAME) && (LA(2)==LSQUARE) && (LA(3)==NAME))) {
int _m2396 = mark();
synPredMatched2396 = true;
inputState.guessing++;
try {
{
match(NAME);
match(LSQUARE);
match(NAME);
match(RSQUARE);
}
}
catch (RecognitionException pe) {
synPredMatched2396 = false;
}
rewind(_m2396);
inputState.guessing--;
}
if ( synPredMatched2396 ) {
AST tmp305_AST = null;
tmp305_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp305_AST);
match(NAME);
match(LSQUARE);
AST tmp307_AST = null;
tmp307_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp307_AST);
match(NAME);
match(RSQUARE);
lookup_expr();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
lookup_expr_AST = (AST)currentAST.root;
lookup_expr_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(LOOKUP_OP,"LOOKUP_OP")).add(lookup_expr_AST));
currentAST.root = lookup_expr_AST;
currentAST.child = lookup_expr_AST!=null &&lookup_expr_AST.getFirstChild()!=null ?
lookup_expr_AST.getFirstChild() : lookup_expr_AST;
currentAST.advanceChildToEnd();
}
}
else if ((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))) && (_tokenSet_32.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lookup_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_30);
} else {
throw ex;
}
}
returnAST = lookup_expr_AST;
}
public final void unary_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST unary_expr_AST = null;
try { // for error handling
{
_loop2399:
do {
switch ( LA(1)) {
case NOT:
{
AST tmp309_AST = null;
tmp309_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp309_AST);
match(NOT);
break;
}
case FNEG:
{
AST tmp310_AST = null;
tmp310_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp310_AST);
match(FNEG);
break;
}
case LNOT:
{
AST tmp311_AST = null;
tmp311_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp311_AST);
match(LNOT);
break;
}
default:
{
break _loop2399;
}
}
} while (true);
}
lookup_expr();
astFactory.addASTChild(currentAST, returnAST);
unary_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_30);
} else {
throw ex;
}
}
returnAST = unary_expr_AST;
}
public final void fp_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST fp_expr_AST = null;
try { // for error handling
unary_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2403:
do {
if (((LA(1) >= MUL_F && LA(1) <= LITERAL_pow))) {
{
switch ( LA(1)) {
case MUL_F:
{
AST tmp312_AST = null;
tmp312_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp312_AST);
match(MUL_F);
break;
}
case MUL_FD:
{
AST tmp313_AST = null;
tmp313_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp313_AST);
match(MUL_FD);
break;
}
case MUL_FQ:
{
AST tmp314_AST = null;
tmp314_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp314_AST);
match(MUL_FQ);
break;
}
case MUL_FSD:
{
AST tmp315_AST = null;
tmp315_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp315_AST);
match(MUL_FSD);
break;
}
case MUL_FDQ:
{
AST tmp316_AST = null;
tmp316_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp316_AST);
match(MUL_FDQ);
break;
}
case DIV_F:
{
AST tmp317_AST = null;
tmp317_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp317_AST);
match(DIV_F);
break;
}
case DIV_FD:
{
AST tmp318_AST = null;
tmp318_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp318_AST);
match(DIV_FD);
break;
}
case DIV_FQ:
{
AST tmp319_AST = null;
tmp319_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp319_AST);
match(DIV_FQ);
break;
}
case PLUS_F:
{
AST tmp320_AST = null;
tmp320_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp320_AST);
match(PLUS_F);
break;
}
case PLUS_FD:
{
AST tmp321_AST = null;
tmp321_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp321_AST);
match(PLUS_FD);
break;
}
case PLUS_FQ:
{
AST tmp322_AST = null;
tmp322_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp322_AST);
match(PLUS_FQ);
break;
}
case MINUS_F:
{
AST tmp323_AST = null;
tmp323_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp323_AST);
match(MINUS_F);
break;
}
case MINUS_FD:
{
AST tmp324_AST = null;
tmp324_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp324_AST);
match(MINUS_FD);
break;
}
case MINUS_FQ:
{
AST tmp325_AST = null;
tmp325_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp325_AST);
match(MINUS_FQ);
break;
}
case LITERAL_pow:
{
AST tmp326_AST = null;
tmp326_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp326_AST);
match(LITERAL_pow);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
unary_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2403;
}
} while (true);
}
fp_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_33);
} else {
throw ex;
}
}
returnAST = fp_expr_AST;
}
public final void arith_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST arith_expr_AST = null;
try { // for error handling
fp_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2407:
do {
if ((_tokenSet_34.member(LA(1)))) {
{
switch ( LA(1)) {
case MOD:
{
AST tmp327_AST = null;
tmp327_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp327_AST);
match(MOD);
break;
}
case MUL:
{
AST tmp328_AST = null;
tmp328_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp328_AST);
match(MUL);
break;
}
case DIV:
{
AST tmp329_AST = null;
tmp329_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp329_AST);
match(DIV);
break;
}
case SMUL:
{
AST tmp330_AST = null;
tmp330_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp330_AST);
match(SMUL);
break;
}
case SDIV:
{
AST tmp331_AST = null;
tmp331_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp331_AST);
match(SDIV);
break;
}
case SMOD:
{
AST tmp332_AST = null;
tmp332_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp332_AST);
match(SMOD);
break;
}
case PLUS:
{
AST tmp333_AST = null;
tmp333_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp333_AST);
match(PLUS);
break;
}
case MINUS:
{
AST tmp334_AST = null;
tmp334_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp334_AST);
match(MINUS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
fp_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2407;
}
} while (true);
}
arith_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_35);
} else {
throw ex;
}
}
returnAST = arith_expr_AST;
}
public final void bit_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST bit_expr_AST = null;
try { // for error handling
arith_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2411:
do {
if (((LA(1) >= LITERAL_rlc && LA(1) <= XORNOT))) {
{
switch ( LA(1)) {
case LITERAL_rlc:
{
AST tmp335_AST = null;
tmp335_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp335_AST);
match(LITERAL_rlc);
break;
}
case LITERAL_rrc:
{
AST tmp336_AST = null;
tmp336_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp336_AST);
match(LITERAL_rrc);
break;
}
case LITERAL_rl:
{
AST tmp337_AST = null;
tmp337_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp337_AST);
match(LITERAL_rl);
break;
}
case LITERAL_rr:
{
AST tmp338_AST = null;
tmp338_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp338_AST);
match(LITERAL_rr);
break;
}
case RSHIFT:
{
AST tmp339_AST = null;
tmp339_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp339_AST);
match(RSHIFT);
break;
}
case LSHIFT:
{
AST tmp340_AST = null;
tmp340_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp340_AST);
match(LSHIFT);
break;
}
case RSHIFTA:
{
AST tmp341_AST = null;
tmp341_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp341_AST);
match(RSHIFTA);
break;
}
case OR:
{
AST tmp342_AST = null;
tmp342_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp342_AST);
match(OR);
break;
}
case ORNOT:
{
AST tmp343_AST = null;
tmp343_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp343_AST);
match(ORNOT);
break;
}
case AND:
{
AST tmp344_AST = null;
tmp344_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp344_AST);
match(AND);
break;
}
case ANDNOT:
{
AST tmp345_AST = null;
tmp345_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp345_AST);
match(ANDNOT);
break;
}
case XOR:
{
AST tmp346_AST = null;
tmp346_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp346_AST);
match(XOR);
break;
}
case XORNOT:
{
AST tmp347_AST = null;
tmp347_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp347_AST);
match(XORNOT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
arith_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2411;
}
} while (true);
}
bit_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_36);
} else {
throw ex;
}
}
returnAST = bit_expr_AST;
}
public final void cond_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST cond_expr_AST = null;
try { // for error handling
bit_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2415:
do {
if (((LA(1) >= EQ && LA(1) <= GEU))) {
{
switch ( LA(1)) {
case EQ:
{
AST tmp348_AST = null;
tmp348_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp348_AST);
match(EQ);
break;
}
case NE:
{
AST tmp349_AST = null;
tmp349_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp349_AST);
match(NE);
break;
}
case LT:
{
AST tmp350_AST = null;
tmp350_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp350_AST);
match(LT);
break;
}
case GT:
{
AST tmp351_AST = null;
tmp351_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp351_AST);
match(GT);
break;
}
case LE:
{
AST tmp352_AST = null;
tmp352_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp352_AST);
match(LE);
break;
}
case GE:
{
AST tmp353_AST = null;
tmp353_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp353_AST);
match(GE);
break;
}
case LTU:
{
AST tmp354_AST = null;
tmp354_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp354_AST);
match(LTU);
break;
}
case GTU:
{
AST tmp355_AST = null;
tmp355_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp355_AST);
match(GTU);
break;
}
case LEU:
{
AST tmp356_AST = null;
tmp356_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp356_AST);
match(LEU);
break;
}
case GEU:
{
AST tmp357_AST = null;
tmp357_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp357_AST);
match(GEU);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
bit_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2415;
}
} while (true);
}
cond_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_37);
} else {
throw ex;
}
}
returnAST = cond_expr_AST;
}
public final void log_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST log_expr_AST = null;
try { // for error handling
cond_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop2419:
do {
if ((LA(1)==LAND||LA(1)==LOR)) {
{
switch ( LA(1)) {
case LAND:
{
AST tmp358_AST = null;
tmp358_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp358_AST);
match(LAND);
break;
}
case LOR:
{
AST tmp359_AST = null;
tmp359_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp359_AST);
match(LOR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
cond_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop2419;
}
} while (true);
}
log_expr_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_12);
} else {
throw ex;
}
}
returnAST = log_expr_AST;
}
public final void fast_entry() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
AST fast_entry_AST = null;
try { // for error handling
AST tmp360_AST = null;
tmp360_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp360_AST);
match(NAME);
AST tmp361_AST = null;
tmp361_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp361_AST);
match(INDEX);
AST tmp362_AST = null;
tmp362_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp362_AST);
match(NAME);
fast_entry_AST = (AST)currentAST.root;
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex);
recover(ex,_tokenSet_6);
} else {
throw ex;
}
}
returnAST = fast_entry_AST;
}
public static final String[] _tokenNames = {
"<0>",
"EOF",
"<2>",
"NULL_TREE_LOOKAHEAD",
"SEMI",
"NUM",
"NAME",
"EQUATE",
"PLUS",
"MINUS",
"\"INTEGER\"",
"\"FLOAT\"",
"COMMA",
"REG_ID",
"INDEX",
"LSQUARE",
"RSQUARE",
"\"COVERS\"",
"TO",
"\"SHARES\"",
"AT",
"\"OPERAND\"",
"LCURLY",
"RCURLY",
"ASSIGNTYPE",
"\"ENDIANNESS\"",
"\"BIG\"",
"\"LITTLE\"",
"LPAREN",
"RPAREN",
"QUOTE",
"DECOR",
"MOD",
"MUL",
"DIV",
"SMUL",
"SDIV",
"SMOD",
"\"rlc\"",
"\"rrc\"",
"\"rl\"",
"\"rr\"",
"RSHIFT",
"LSHIFT",
"RSHIFTA",
"OR",
"ORNOT",
"AND",
"ANDNOT",
"XOR",
"XORNOT",
"MUL_F",
"MUL_FD",
"MUL_FQ",
"MUL_FSD",
"MUL_FDQ",
"DIV_F",
"DIV_FD",
"DIV_FQ",
"PLUS_F",
"PLUS_FD",
"PLUS_FQ",
"MINUS_F",
"MINUS_FD",
"MINUS_FQ",
"\"pow\"",
"EQ",
"NE",
"LT",
"GT",
"LE",
"GE",
"LTU",
"GTU",
"LEU",
"GEU",
"PRIME",
"DOLLAR",
"\"halt\"",
"UNDERSCORE",
"\"MEMSET\"",
"\"MEMCPY\"",
"\"r\"",
"\"m\"",
"COLON",
"FLOATNUM",
"QUEST",
"S_E",
"NOT",
"FNEG",
"LNOT",
"\"and\"",
"\"or\"",
"\"FAST\"",
"CONSTANT",
"TABLE",
"CROSSP",
"FUNCTION",
"INSTR",
"INSTR_NAME",
"LOOKUP_OP",
"RTL",
"BUILTIN",
"CAST",
"REGDECL",
"WS",
"COMMENT",
"DIGITS",
"HEXDIGITS",
"FLOAT_OR_NUM",
"ASSIGN",
"THEN",
"ASSIGNTYPE_OR_MUL",
"DOT"
};
protected void buildTokenTypeASTClassMap() {
tokenTypeToASTClassMap=null;
};
private static final long[] mk_tokenSet_0() {
long[] data = { 2L, 0L};
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = { 1109396544L, 536883200L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
private static final long[] mk_tokenSet_2() {
long[] data = { 1073741888L, 12288L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
private static final long[] mk_tokenSet_3() {
long[] data = { 3238035520L, 258048L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
private static final long[] mk_tokenSet_4() {
long[] data = { 16L, 0L};
return data;
}
public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
private static final long[] mk_tokenSet_5() {
long[] data = { 9375760L, 0L};
return data;
}
public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
private static final long[] mk_tokenSet_6() {
long[] data = { 4112L, 0L};
return data;
}
public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
private static final long[] mk_tokenSet_7() {
long[] data = { 65536L, 0L};
return data;
}
public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
private static final long[] mk_tokenSet_8() {
long[] data = { 562139200L, 245760L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
private static final long[] mk_tokenSet_9() {
long[] data = { 289517680L, 120569856L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
private static final long[] mk_tokenSet_10() {
long[] data = { 562135104L, 245760L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
private static final long[] mk_tokenSet_11() {
long[] data = { -2358132750L, 1068498943L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
private static final long[] mk_tokenSet_12() {
long[] data = { 1635848400L, 5488640L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
private static final long[] mk_tokenSet_13() {
long[] data = { 16777280L, 245760L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
private static final long[] mk_tokenSet_14() {
long[] data = { 8388624L, 0L};
return data;
}
public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
private static final long[] mk_tokenSet_15() {
long[] data = { 1077936208L, 0L};
return data;
}
public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
private static final long[] mk_tokenSet_16() {
long[] data = { 3269467218L, 536883200L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
private static final long[] mk_tokenSet_17() {
long[] data = { -4294966528L, 4095L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
private static final long[] mk_tokenSet_18() {
long[] data = { 268476512L, 120324096L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
private static final long[] mk_tokenSet_19() {
long[] data = { 4194384L, 0L};
return data;
}
public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
private static final long[] mk_tokenSet_20() {
long[] data = { 8392704L, 0L};
return data;
}
public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
private static final long[] mk_tokenSet_21() {
long[] data = { 1073741824L, 0L};
return data;
}
public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
private static final long[] mk_tokenSet_22() {
long[] data = { 1073774688L, 4096L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
private static final long[] mk_tokenSet_23() {
long[] data = { 3238002752L, 258048L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
private static final long[] mk_tokenSet_24() {
long[] data = { 2432741488L, 120569856L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
private static final long[] mk_tokenSet_25() {
long[] data = { -210714638L, 1068498943L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
private static final long[] mk_tokenSet_26() {
long[] data = { 2164260928L, 245760L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
private static final long[] mk_tokenSet_27() {
long[] data = { 25165904L, 245760L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
private static final long[] mk_tokenSet_28() {
long[] data = { 536870912L, 0L};
return data;
}
public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
private static final long[] mk_tokenSet_29() {
long[] data = { -2653875248L, 416534527L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
private static final long[] mk_tokenSet_30() {
long[] data = { -2659118128L, 408145919L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
private static final long[] mk_tokenSet_31() {
long[] data = { -2349744142L, 1073741823L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
private static final long[] mk_tokenSet_32() {
long[] data = { -933902L, 1073741823L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
private static final long[] mk_tokenSet_33() {
long[] data = { 2251797154567120L, 408145916L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
private static final long[] mk_tokenSet_34() {
long[] data = { 270582940416L, 0L};
return data;
}
public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
private static final long[] mk_tokenSet_35() {
long[] data = { 2251526571626704L, 408145916L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
private static final long[] mk_tokenSet_36() {
long[] data = { 1635848400L, 408145916L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
private static final long[] mk_tokenSet_37() {
long[] data = { 1635848400L, 408141824L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
}