jaitools.jiffle.parser.TransformExpressions Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt-jiffle Show documentation
Show all versions of jt-jiffle Show documentation
Jiffle is a raster algebra language that can be used to
create new images from logical and mathematical expressions involving
source images and user defined variables. It is intended to let users
concentrate on algorithms rather than tedious boiler-plate code.
The newest version!
// $ANTLR 3.3 Nov 30, 2010 12:46:29 jaitools/jiffle/parser/TransformExpressions.g 2011-03-08 17:37:58
package jaitools.jiffle.parser;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
/**
* Converts calls to proxy functions into the associated variables and
* converts ternary conditional expressions to if calls.
*
* @author Michael Bedward
*/
public class TransformExpressions extends ErrorHandlingTreeParser {
public static final String[] tokenNames = new String[] {
"", "", "", "", "JIFFLE_OPTION", "IMAGE_SCOPE_VAR_DECL", "EXPR_LIST", "DECLARED_LIST", "PAR", "FUNC_CALL", "IF_CALL", "BLOCK", "IMAGE_POS", "BAND_REF", "PIXEL_REF", "ABS_POS", "REL_POS", "PREFIX", "POSTFIX", "SEQUENCE", "CONSTANT", "IMAGE_WRITE", "VAR_DEST", "VAR_SOURCE", "VAR_IMAGE_SCOPE", "VAR_PIXEL_SCOPE", "VAR_PROVIDED", "VAR_LOOP", "VAR_LIST", "LIST_NEW", "OPTIONS", "LCURLY", "RCURLY", "ID", "EQ", "SEMI", "INIT", "BREAKIF", "LPAR", "RPAR", "WHILE", "UNTIL", "FOREACH", "IN", "COMMA", "COLON", "IF", "APPEND", "TIMESEQ", "DIVEQ", "MODEQ", "PLUSEQ", "MINUSEQ", "QUESTION", "OR", "XOR", "AND", "LOGICALEQ", "NE", "GT", "GE", "LE", "LT", "PLUS", "MINUS", "TIMES", "DIV", "MOD", "NOT", "INCR", "DECR", "POW", "LSQUARE", "RSQUARE", "ABS_POS_PREFIX", "INT_LITERAL", "FLOAT_LITERAL", "TRUE", "FALSE", "NULL", "COMMENT", "INT_TYPE", "FLOAT_TYPE", "DOUBLE_TYPE", "BOOLEAN_TYPE", "Letter", "UNDERSCORE", "Digit", "Dot", "NonZeroDigit", "FloatExp", "WS", "ESC_SEQ", "CHAR", "HEX_DIGIT", "UNICODE_ESC", "OCTAL_ESC"
};
public static final int EOF=-1;
public static final int JIFFLE_OPTION=4;
public static final int IMAGE_SCOPE_VAR_DECL=5;
public static final int EXPR_LIST=6;
public static final int DECLARED_LIST=7;
public static final int PAR=8;
public static final int FUNC_CALL=9;
public static final int IF_CALL=10;
public static final int BLOCK=11;
public static final int IMAGE_POS=12;
public static final int BAND_REF=13;
public static final int PIXEL_REF=14;
public static final int ABS_POS=15;
public static final int REL_POS=16;
public static final int PREFIX=17;
public static final int POSTFIX=18;
public static final int SEQUENCE=19;
public static final int CONSTANT=20;
public static final int IMAGE_WRITE=21;
public static final int VAR_DEST=22;
public static final int VAR_SOURCE=23;
public static final int VAR_IMAGE_SCOPE=24;
public static final int VAR_PIXEL_SCOPE=25;
public static final int VAR_PROVIDED=26;
public static final int VAR_LOOP=27;
public static final int VAR_LIST=28;
public static final int LIST_NEW=29;
public static final int OPTIONS=30;
public static final int LCURLY=31;
public static final int RCURLY=32;
public static final int ID=33;
public static final int EQ=34;
public static final int SEMI=35;
public static final int INIT=36;
public static final int BREAKIF=37;
public static final int LPAR=38;
public static final int RPAR=39;
public static final int WHILE=40;
public static final int UNTIL=41;
public static final int FOREACH=42;
public static final int IN=43;
public static final int COMMA=44;
public static final int COLON=45;
public static final int IF=46;
public static final int APPEND=47;
public static final int TIMESEQ=48;
public static final int DIVEQ=49;
public static final int MODEQ=50;
public static final int PLUSEQ=51;
public static final int MINUSEQ=52;
public static final int QUESTION=53;
public static final int OR=54;
public static final int XOR=55;
public static final int AND=56;
public static final int LOGICALEQ=57;
public static final int NE=58;
public static final int GT=59;
public static final int GE=60;
public static final int LE=61;
public static final int LT=62;
public static final int PLUS=63;
public static final int MINUS=64;
public static final int TIMES=65;
public static final int DIV=66;
public static final int MOD=67;
public static final int NOT=68;
public static final int INCR=69;
public static final int DECR=70;
public static final int POW=71;
public static final int LSQUARE=72;
public static final int RSQUARE=73;
public static final int ABS_POS_PREFIX=74;
public static final int INT_LITERAL=75;
public static final int FLOAT_LITERAL=76;
public static final int TRUE=77;
public static final int FALSE=78;
public static final int NULL=79;
public static final int COMMENT=80;
public static final int INT_TYPE=81;
public static final int FLOAT_TYPE=82;
public static final int DOUBLE_TYPE=83;
public static final int BOOLEAN_TYPE=84;
public static final int Letter=85;
public static final int UNDERSCORE=86;
public static final int Digit=87;
public static final int Dot=88;
public static final int NonZeroDigit=89;
public static final int FloatExp=90;
public static final int WS=91;
public static final int ESC_SEQ=92;
public static final int CHAR=93;
public static final int HEX_DIGIT=94;
public static final int UNICODE_ESC=95;
public static final int OCTAL_ESC=96;
// delegates
// delegators
public TransformExpressions(TreeNodeStream input) {
this(input, new RecognizerSharedState());
}
public TransformExpressions(TreeNodeStream input, RecognizerSharedState state) {
super(input, state);
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor(TreeAdaptor adaptor) {
this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
return adaptor;
}
public String[] getTokenNames() { return TransformExpressions.tokenNames; }
public String getGrammarFileName() { return "jaitools/jiffle/parser/TransformExpressions.g"; }
private boolean isProxy(String name) {
try {
return FunctionLookup.getInfo(name, null).isProxy();
} catch (UndefinedFunctionException ex) {
// If the function is not defined we let it pass here. It
// will be picked up later by the function checking parser.
return false;
}
}
private String getRuntimeExpr(String name) {
try {
return FunctionLookup.getInfo(name, null).getRuntimeExpr();
} catch (UndefinedFunctionException ex) {
// getting here means a mistake in the grammar action code
throw new RuntimeException(ex);
}
}
public static class start_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "start"
// jaitools/jiffle/parser/TransformExpressions.g:68:1: start : ( jiffleOption )* ( varDeclaration )* ( statement )+ ;
public final TransformExpressions.start_return start() throws RecognitionException {
TransformExpressions.start_return retval = new TransformExpressions.start_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
TransformExpressions.jiffleOption_return jiffleOption1 = null;
TransformExpressions.varDeclaration_return varDeclaration2 = null;
TransformExpressions.statement_return statement3 = null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:68:17: ( ( jiffleOption )* ( varDeclaration )* ( statement )+ )
// jaitools/jiffle/parser/TransformExpressions.g:68:19: ( jiffleOption )* ( varDeclaration )* ( statement )+
{
root_0 = (CommonTree)adaptor.nil();
// jaitools/jiffle/parser/TransformExpressions.g:68:19: ( jiffleOption )*
loop1:
do {
int alt1=2;
switch ( input.LA(1) ) {
case JIFFLE_OPTION:
{
alt1=1;
}
break;
}
switch (alt1) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:68:19: jiffleOption
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_jiffleOption_in_start94);
jiffleOption1=jiffleOption();
state._fsp--;
adaptor.addChild(root_0, jiffleOption1.getTree());
}
break;
default :
break loop1;
}
} while (true);
// jaitools/jiffle/parser/TransformExpressions.g:68:33: ( varDeclaration )*
loop2:
do {
int alt2=2;
switch ( input.LA(1) ) {
case IMAGE_SCOPE_VAR_DECL:
{
alt2=1;
}
break;
}
switch (alt2) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:68:33: varDeclaration
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_varDeclaration_in_start97);
varDeclaration2=varDeclaration();
state._fsp--;
adaptor.addChild(root_0, varDeclaration2.getTree());
}
break;
default :
break loop2;
}
} while (true);
// jaitools/jiffle/parser/TransformExpressions.g:68:49: ( statement )+
int cnt3=0;
loop3:
do {
int alt3=2;
switch ( input.LA(1) ) {
case DECLARED_LIST:
case PAR:
case FUNC_CALL:
case IF_CALL:
case BLOCK:
case IMAGE_POS:
case PREFIX:
case POSTFIX:
case CONSTANT:
case IMAGE_WRITE:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_LOOP:
case VAR_LIST:
case EQ:
case WHILE:
case UNTIL:
case FOREACH:
case APPEND:
case TIMESEQ:
case DIVEQ:
case MODEQ:
case PLUSEQ:
case MINUSEQ:
case QUESTION:
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
case POW:
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
{
alt3=1;
}
break;
}
switch (alt3) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:68:49: statement
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_statement_in_start100);
statement3=statement();
state._fsp--;
adaptor.addChild(root_0, statement3.getTree());
}
break;
default :
if ( cnt3 >= 1 ) break loop3;
EarlyExitException eee =
new EarlyExitException(3, input);
throw eee;
}
cnt3++;
} while (true);
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "start"
public static class jiffleOption_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "jiffleOption"
// jaitools/jiffle/parser/TransformExpressions.g:72:1: jiffleOption : ^( JIFFLE_OPTION ( . )+ ) ;
public final TransformExpressions.jiffleOption_return jiffleOption() throws RecognitionException {
TransformExpressions.jiffleOption_return retval = new TransformExpressions.jiffleOption_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree JIFFLE_OPTION4=null;
CommonTree wildcard5=null;
CommonTree JIFFLE_OPTION4_tree=null;
CommonTree wildcard5_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:72:17: ( ^( JIFFLE_OPTION ( . )+ ) )
// jaitools/jiffle/parser/TransformExpressions.g:72:19: ^( JIFFLE_OPTION ( . )+ )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
JIFFLE_OPTION4=(CommonTree)match(input,JIFFLE_OPTION,FOLLOW_JIFFLE_OPTION_in_jiffleOption131);
JIFFLE_OPTION4_tree = (CommonTree)adaptor.dupNode(JIFFLE_OPTION4);
root_1 = (CommonTree)adaptor.becomeRoot(JIFFLE_OPTION4_tree, root_1);
match(input, Token.DOWN, null);
// jaitools/jiffle/parser/TransformExpressions.g:72:35: ( . )+
int cnt4=0;
loop4:
do {
int alt4=2;
switch ( input.LA(1) ) {
case JIFFLE_OPTION:
case IMAGE_SCOPE_VAR_DECL:
case EXPR_LIST:
case DECLARED_LIST:
case PAR:
case FUNC_CALL:
case IF_CALL:
case BLOCK:
case IMAGE_POS:
case BAND_REF:
case PIXEL_REF:
case ABS_POS:
case REL_POS:
case PREFIX:
case POSTFIX:
case SEQUENCE:
case CONSTANT:
case IMAGE_WRITE:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_PROVIDED:
case VAR_LOOP:
case VAR_LIST:
case LIST_NEW:
case OPTIONS:
case LCURLY:
case RCURLY:
case ID:
case EQ:
case SEMI:
case INIT:
case BREAKIF:
case LPAR:
case RPAR:
case WHILE:
case UNTIL:
case FOREACH:
case IN:
case COMMA:
case COLON:
case IF:
case APPEND:
case TIMESEQ:
case DIVEQ:
case MODEQ:
case PLUSEQ:
case MINUSEQ:
case QUESTION:
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
case NOT:
case INCR:
case DECR:
case POW:
case LSQUARE:
case RSQUARE:
case ABS_POS_PREFIX:
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
case COMMENT:
case INT_TYPE:
case FLOAT_TYPE:
case DOUBLE_TYPE:
case BOOLEAN_TYPE:
case Letter:
case UNDERSCORE:
case Digit:
case Dot:
case NonZeroDigit:
case FloatExp:
case WS:
case ESC_SEQ:
case CHAR:
case HEX_DIGIT:
case UNICODE_ESC:
case OCTAL_ESC:
{
alt4=1;
}
break;
case UP:
{
alt4=2;
}
break;
}
switch (alt4) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:72:35: .
{
_last = (CommonTree)input.LT(1);
wildcard5=(CommonTree)input.LT(1);
matchAny(input);
wildcard5_tree = (CommonTree)adaptor.dupTree(wildcard5);
adaptor.addChild(root_1, wildcard5_tree);
}
break;
default :
if ( cnt4 >= 1 ) break loop4;
EarlyExitException eee =
new EarlyExitException(4, input);
throw eee;
}
cnt4++;
} while (true);
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "jiffleOption"
public static class varDeclaration_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "varDeclaration"
// jaitools/jiffle/parser/TransformExpressions.g:76:1: varDeclaration : ^( IMAGE_SCOPE_VAR_DECL id= . expression ) ;
public final TransformExpressions.varDeclaration_return varDeclaration() throws RecognitionException {
TransformExpressions.varDeclaration_return retval = new TransformExpressions.varDeclaration_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree IMAGE_SCOPE_VAR_DECL6=null;
CommonTree id=null;
TransformExpressions.expression_return expression7 = null;
CommonTree IMAGE_SCOPE_VAR_DECL6_tree=null;
CommonTree id_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:76:17: ( ^( IMAGE_SCOPE_VAR_DECL id= . expression ) )
// jaitools/jiffle/parser/TransformExpressions.g:76:19: ^( IMAGE_SCOPE_VAR_DECL id= . expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
IMAGE_SCOPE_VAR_DECL6=(CommonTree)match(input,IMAGE_SCOPE_VAR_DECL,FOLLOW_IMAGE_SCOPE_VAR_DECL_in_varDeclaration163);
IMAGE_SCOPE_VAR_DECL6_tree = (CommonTree)adaptor.dupNode(IMAGE_SCOPE_VAR_DECL6);
root_1 = (CommonTree)adaptor.becomeRoot(IMAGE_SCOPE_VAR_DECL6_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
id=(CommonTree)input.LT(1);
matchAny(input);
id_tree = (CommonTree)adaptor.dupTree(id);
adaptor.addChild(root_1, id_tree);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_varDeclaration169);
expression7=expression();
state._fsp--;
adaptor.addChild(root_1, expression7.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "varDeclaration"
public static class block_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "block"
// jaitools/jiffle/parser/TransformExpressions.g:80:1: block : ^( BLOCK ( blockStatement )* ) ;
public final TransformExpressions.block_return block() throws RecognitionException {
TransformExpressions.block_return retval = new TransformExpressions.block_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree BLOCK8=null;
TransformExpressions.blockStatement_return blockStatement9 = null;
CommonTree BLOCK8_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:80:17: ( ^( BLOCK ( blockStatement )* ) )
// jaitools/jiffle/parser/TransformExpressions.g:80:19: ^( BLOCK ( blockStatement )* )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
BLOCK8=(CommonTree)match(input,BLOCK,FOLLOW_BLOCK_in_block207);
BLOCK8_tree = (CommonTree)adaptor.dupNode(BLOCK8);
root_1 = (CommonTree)adaptor.becomeRoot(BLOCK8_tree, root_1);
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null);
// jaitools/jiffle/parser/TransformExpressions.g:80:27: ( blockStatement )*
loop5:
do {
int alt5=2;
switch ( input.LA(1) ) {
case DECLARED_LIST:
case PAR:
case FUNC_CALL:
case IF_CALL:
case BLOCK:
case IMAGE_POS:
case PREFIX:
case POSTFIX:
case CONSTANT:
case IMAGE_WRITE:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_LOOP:
case VAR_LIST:
case EQ:
case BREAKIF:
case WHILE:
case UNTIL:
case FOREACH:
case APPEND:
case TIMESEQ:
case DIVEQ:
case MODEQ:
case PLUSEQ:
case MINUSEQ:
case QUESTION:
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
case POW:
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
{
alt5=1;
}
break;
}
switch (alt5) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:80:27: blockStatement
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_blockStatement_in_block209);
blockStatement9=blockStatement();
state._fsp--;
adaptor.addChild(root_1, blockStatement9.getTree());
}
break;
default :
break loop5;
}
} while (true);
match(input, Token.UP, null);
}adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "block"
public static class blockStatement_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "blockStatement"
// jaitools/jiffle/parser/TransformExpressions.g:84:1: blockStatement : ( statement | ^( BREAKIF expression ) );
public final TransformExpressions.blockStatement_return blockStatement() throws RecognitionException {
TransformExpressions.blockStatement_return retval = new TransformExpressions.blockStatement_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree BREAKIF11=null;
TransformExpressions.statement_return statement10 = null;
TransformExpressions.expression_return expression12 = null;
CommonTree BREAKIF11_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:84:17: ( statement | ^( BREAKIF expression ) )
int alt6=2;
switch ( input.LA(1) ) {
case DECLARED_LIST:
case PAR:
case FUNC_CALL:
case IF_CALL:
case BLOCK:
case IMAGE_POS:
case PREFIX:
case POSTFIX:
case CONSTANT:
case IMAGE_WRITE:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_LOOP:
case VAR_LIST:
case EQ:
case WHILE:
case UNTIL:
case FOREACH:
case APPEND:
case TIMESEQ:
case DIVEQ:
case MODEQ:
case PLUSEQ:
case MINUSEQ:
case QUESTION:
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
case POW:
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
{
alt6=1;
}
break;
case BREAKIF:
{
alt6=2;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 6, 0, input);
throw nvae;
}
switch (alt6) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:84:19: statement
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_statement_in_blockStatement238);
statement10=statement();
state._fsp--;
adaptor.addChild(root_0, statement10.getTree());
}
break;
case 2 :
// jaitools/jiffle/parser/TransformExpressions.g:85:19: ^( BREAKIF expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
BREAKIF11=(CommonTree)match(input,BREAKIF,FOLLOW_BREAKIF_in_blockStatement259);
BREAKIF11_tree = (CommonTree)adaptor.dupNode(BREAKIF11);
root_1 = (CommonTree)adaptor.becomeRoot(BREAKIF11_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_blockStatement261);
expression12=expression();
state._fsp--;
adaptor.addChild(root_1, expression12.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "blockStatement"
public static class statement_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "statement"
// jaitools/jiffle/parser/TransformExpressions.g:89:1: statement : ( block | assignmentExpression | ^( WHILE loopCondition statement ) | ^( UNTIL loopCondition statement ) | ^( FOREACH ID loopSet statement ) | expression );
public final TransformExpressions.statement_return statement() throws RecognitionException {
TransformExpressions.statement_return retval = new TransformExpressions.statement_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree WHILE15=null;
CommonTree UNTIL18=null;
CommonTree FOREACH21=null;
CommonTree ID22=null;
TransformExpressions.block_return block13 = null;
TransformExpressions.assignmentExpression_return assignmentExpression14 = null;
TransformExpressions.loopCondition_return loopCondition16 = null;
TransformExpressions.statement_return statement17 = null;
TransformExpressions.loopCondition_return loopCondition19 = null;
TransformExpressions.statement_return statement20 = null;
TransformExpressions.loopSet_return loopSet23 = null;
TransformExpressions.statement_return statement24 = null;
TransformExpressions.expression_return expression25 = null;
CommonTree WHILE15_tree=null;
CommonTree UNTIL18_tree=null;
CommonTree FOREACH21_tree=null;
CommonTree ID22_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:89:17: ( block | assignmentExpression | ^( WHILE loopCondition statement ) | ^( UNTIL loopCondition statement ) | ^( FOREACH ID loopSet statement ) | expression )
int alt7=6;
switch ( input.LA(1) ) {
case BLOCK:
{
alt7=1;
}
break;
case EQ:
case TIMESEQ:
case DIVEQ:
case MODEQ:
case PLUSEQ:
case MINUSEQ:
{
alt7=2;
}
break;
case WHILE:
{
alt7=3;
}
break;
case UNTIL:
{
alt7=4;
}
break;
case FOREACH:
{
alt7=5;
}
break;
case DECLARED_LIST:
case PAR:
case FUNC_CALL:
case IF_CALL:
case IMAGE_POS:
case PREFIX:
case POSTFIX:
case CONSTANT:
case IMAGE_WRITE:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_LOOP:
case VAR_LIST:
case APPEND:
case QUESTION:
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
case POW:
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
{
alt7=6;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 7, 0, input);
throw nvae;
}
switch (alt7) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:89:19: block
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_block_in_statement294);
block13=block();
state._fsp--;
adaptor.addChild(root_0, block13.getTree());
}
break;
case 2 :
// jaitools/jiffle/parser/TransformExpressions.g:90:19: assignmentExpression
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_assignmentExpression_in_statement314);
assignmentExpression14=assignmentExpression();
state._fsp--;
adaptor.addChild(root_0, assignmentExpression14.getTree());
}
break;
case 3 :
// jaitools/jiffle/parser/TransformExpressions.g:91:19: ^( WHILE loopCondition statement )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
WHILE15=(CommonTree)match(input,WHILE,FOLLOW_WHILE_in_statement335);
WHILE15_tree = (CommonTree)adaptor.dupNode(WHILE15);
root_1 = (CommonTree)adaptor.becomeRoot(WHILE15_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_loopCondition_in_statement337);
loopCondition16=loopCondition();
state._fsp--;
adaptor.addChild(root_1, loopCondition16.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_statement_in_statement339);
statement17=statement();
state._fsp--;
adaptor.addChild(root_1, statement17.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 4 :
// jaitools/jiffle/parser/TransformExpressions.g:92:19: ^( UNTIL loopCondition statement )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
UNTIL18=(CommonTree)match(input,UNTIL,FOLLOW_UNTIL_in_statement361);
UNTIL18_tree = (CommonTree)adaptor.dupNode(UNTIL18);
root_1 = (CommonTree)adaptor.becomeRoot(UNTIL18_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_loopCondition_in_statement363);
loopCondition19=loopCondition();
state._fsp--;
adaptor.addChild(root_1, loopCondition19.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_statement_in_statement365);
statement20=statement();
state._fsp--;
adaptor.addChild(root_1, statement20.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 5 :
// jaitools/jiffle/parser/TransformExpressions.g:93:19: ^( FOREACH ID loopSet statement )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
FOREACH21=(CommonTree)match(input,FOREACH,FOLLOW_FOREACH_in_statement387);
FOREACH21_tree = (CommonTree)adaptor.dupNode(FOREACH21);
root_1 = (CommonTree)adaptor.becomeRoot(FOREACH21_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
ID22=(CommonTree)match(input,ID,FOLLOW_ID_in_statement389);
ID22_tree = (CommonTree)adaptor.dupNode(ID22);
adaptor.addChild(root_1, ID22_tree);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_loopSet_in_statement391);
loopSet23=loopSet();
state._fsp--;
adaptor.addChild(root_1, loopSet23.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_statement_in_statement393);
statement24=statement();
state._fsp--;
adaptor.addChild(root_1, statement24.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 6 :
// jaitools/jiffle/parser/TransformExpressions.g:94:19: expression
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_statement414);
expression25=expression();
state._fsp--;
adaptor.addChild(root_0, expression25.getTree());
}
break;
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "statement"
public static class loopCondition_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "loopCondition"
// jaitools/jiffle/parser/TransformExpressions.g:98:1: loopCondition : expression ;
public final TransformExpressions.loopCondition_return loopCondition() throws RecognitionException {
TransformExpressions.loopCondition_return retval = new TransformExpressions.loopCondition_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
TransformExpressions.expression_return expression26 = null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:98:17: ( expression )
// jaitools/jiffle/parser/TransformExpressions.g:98:19: expression
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_loopCondition442);
expression26=expression();
state._fsp--;
adaptor.addChild(root_0, expression26.getTree());
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "loopCondition"
public static class loopSet_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "loopSet"
// jaitools/jiffle/parser/TransformExpressions.g:102:1: loopSet : ( ^( SEQUENCE expression expression ) | listLiteral | VAR_LIST );
public final TransformExpressions.loopSet_return loopSet() throws RecognitionException {
TransformExpressions.loopSet_return retval = new TransformExpressions.loopSet_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree SEQUENCE27=null;
CommonTree VAR_LIST31=null;
TransformExpressions.expression_return expression28 = null;
TransformExpressions.expression_return expression29 = null;
TransformExpressions.listLiteral_return listLiteral30 = null;
CommonTree SEQUENCE27_tree=null;
CommonTree VAR_LIST31_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:102:17: ( ^( SEQUENCE expression expression ) | listLiteral | VAR_LIST )
int alt8=3;
switch ( input.LA(1) ) {
case SEQUENCE:
{
alt8=1;
}
break;
case DECLARED_LIST:
{
alt8=2;
}
break;
case VAR_LIST:
{
alt8=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 8, 0, input);
throw nvae;
}
switch (alt8) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:102:19: ^( SEQUENCE expression expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
SEQUENCE27=(CommonTree)match(input,SEQUENCE,FOLLOW_SEQUENCE_in_loopSet477);
SEQUENCE27_tree = (CommonTree)adaptor.dupNode(SEQUENCE27);
root_1 = (CommonTree)adaptor.becomeRoot(SEQUENCE27_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_loopSet479);
expression28=expression();
state._fsp--;
adaptor.addChild(root_1, expression28.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_loopSet481);
expression29=expression();
state._fsp--;
adaptor.addChild(root_1, expression29.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 2 :
// jaitools/jiffle/parser/TransformExpressions.g:103:19: listLiteral
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_listLiteral_in_loopSet502);
listLiteral30=listLiteral();
state._fsp--;
adaptor.addChild(root_0, listLiteral30.getTree());
}
break;
case 3 :
// jaitools/jiffle/parser/TransformExpressions.g:104:19: VAR_LIST
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
VAR_LIST31=(CommonTree)match(input,VAR_LIST,FOLLOW_VAR_LIST_in_loopSet522);
VAR_LIST31_tree = (CommonTree)adaptor.dupNode(VAR_LIST31);
adaptor.addChild(root_0, VAR_LIST31_tree);
}
break;
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "loopSet"
public static class expressionList_return extends TreeRuleReturnScope {
public List argTypes;
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "expressionList"
// jaitools/jiffle/parser/TransformExpressions.g:108:1: expressionList returns [List argTypes] : ^( EXPR_LIST (e= expression )* ) ;
public final TransformExpressions.expressionList_return expressionList() throws RecognitionException {
TransformExpressions.expressionList_return retval = new TransformExpressions.expressionList_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree EXPR_LIST32=null;
TransformExpressions.expression_return e = null;
CommonTree EXPR_LIST32_tree=null;
retval.argTypes = new ArrayList();
try {
// jaitools/jiffle/parser/TransformExpressions.g:110:17: ( ^( EXPR_LIST (e= expression )* ) )
// jaitools/jiffle/parser/TransformExpressions.g:110:19: ^( EXPR_LIST (e= expression )* )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
EXPR_LIST32=(CommonTree)match(input,EXPR_LIST,FOLLOW_EXPR_LIST_in_expressionList573);
EXPR_LIST32_tree = (CommonTree)adaptor.dupNode(EXPR_LIST32);
root_1 = (CommonTree)adaptor.becomeRoot(EXPR_LIST32_tree, root_1);
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null);
// jaitools/jiffle/parser/TransformExpressions.g:110:31: (e= expression )*
loop9:
do {
int alt9=2;
switch ( input.LA(1) ) {
case DECLARED_LIST:
case PAR:
case FUNC_CALL:
case IF_CALL:
case IMAGE_POS:
case PREFIX:
case POSTFIX:
case CONSTANT:
case IMAGE_WRITE:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_LOOP:
case VAR_LIST:
case APPEND:
case QUESTION:
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
case POW:
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
{
alt9=1;
}
break;
}
switch (alt9) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:110:32: e= expression
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expressionList578);
e=expression();
state._fsp--;
adaptor.addChild(root_1, e.getTree());
retval.argTypes.add((e!=null?((CommonTree)e.start):null).getType() == VAR_LIST ? "List" : "D");
}
break;
default :
break loop9;
}
} while (true);
match(input, Token.UP, null);
}adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "expressionList"
public static class assignmentExpression_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "assignmentExpression"
// jaitools/jiffle/parser/TransformExpressions.g:117:1: assignmentExpression : ^( assignmentOp identifier expression ) ;
public final TransformExpressions.assignmentExpression_return assignmentExpression() throws RecognitionException {
TransformExpressions.assignmentExpression_return retval = new TransformExpressions.assignmentExpression_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
TransformExpressions.assignmentOp_return assignmentOp33 = null;
TransformExpressions.identifier_return identifier34 = null;
TransformExpressions.expression_return expression35 = null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:118:17: ( ^( assignmentOp identifier expression ) )
// jaitools/jiffle/parser/TransformExpressions.g:118:19: ^( assignmentOp identifier expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_assignmentOp_in_assignmentExpression648);
assignmentOp33=assignmentOp();
state._fsp--;
root_1 = (CommonTree)adaptor.becomeRoot(assignmentOp33.getTree(), root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_identifier_in_assignmentExpression650);
identifier34=identifier();
state._fsp--;
adaptor.addChild(root_1, identifier34.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_assignmentExpression652);
expression35=expression();
state._fsp--;
adaptor.addChild(root_1, expression35.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "assignmentExpression"
public static class assignmentOp_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "assignmentOp"
// jaitools/jiffle/parser/TransformExpressions.g:122:1: assignmentOp : ( EQ | TIMESEQ | DIVEQ | MODEQ | PLUSEQ | MINUSEQ );
public final TransformExpressions.assignmentOp_return assignmentOp() throws RecognitionException {
TransformExpressions.assignmentOp_return retval = new TransformExpressions.assignmentOp_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree set36=null;
CommonTree set36_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:122:17: ( EQ | TIMESEQ | DIVEQ | MODEQ | PLUSEQ | MINUSEQ )
// jaitools/jiffle/parser/TransformExpressions.g:
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
set36=(CommonTree)input.LT(1);
if ( input.LA(1)==EQ||(input.LA(1)>=TIMESEQ && input.LA(1)<=MINUSEQ) ) {
input.consume();
set36_tree = (CommonTree)adaptor.dupNode(set36);
adaptor.addChild(root_0, set36_tree);
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "assignmentOp"
public static class expression_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "expression"
// jaitools/jiffle/parser/TransformExpressions.g:131:1: expression : ( ^( FUNC_CALL ID expressionList ) -> {isProxy($ID.text)}? VAR_PROVIDED[ getRuntimeExpr($ID.text) ] -> ^( FUNC_CALL ID expressionList ) | ^( QUESTION e1= expression e2= expression e3= expression ) -> ^( IF_CALL ^( EXPR_LIST $e1 $e2 $e3) ) | ^( IF_CALL expressionList ) | ^( IMAGE_WRITE identifier expression ) | ^( IMAGE_POS identifier ( bandSpecifier )? ( pixelSpecifier )? ) | ^( logicalOp expression expression ) | ^( arithmeticOp expression expression ) | ^( POW expression expression ) | ^( PREFIX prefixOp expression ) | ^( POSTFIX incdecOp expression ) | ^( PAR expression ) | listOperation | listLiteral | literal | identifier );
public final TransformExpressions.expression_return expression() throws RecognitionException {
TransformExpressions.expression_return retval = new TransformExpressions.expression_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree FUNC_CALL37=null;
CommonTree ID38=null;
CommonTree QUESTION40=null;
CommonTree IF_CALL41=null;
CommonTree IMAGE_WRITE43=null;
CommonTree IMAGE_POS46=null;
CommonTree POW56=null;
CommonTree PREFIX59=null;
CommonTree POSTFIX62=null;
CommonTree PAR65=null;
TransformExpressions.expression_return e1 = null;
TransformExpressions.expression_return e2 = null;
TransformExpressions.expression_return e3 = null;
TransformExpressions.expressionList_return expressionList39 = null;
TransformExpressions.expressionList_return expressionList42 = null;
TransformExpressions.identifier_return identifier44 = null;
TransformExpressions.expression_return expression45 = null;
TransformExpressions.identifier_return identifier47 = null;
TransformExpressions.bandSpecifier_return bandSpecifier48 = null;
TransformExpressions.pixelSpecifier_return pixelSpecifier49 = null;
TransformExpressions.logicalOp_return logicalOp50 = null;
TransformExpressions.expression_return expression51 = null;
TransformExpressions.expression_return expression52 = null;
TransformExpressions.arithmeticOp_return arithmeticOp53 = null;
TransformExpressions.expression_return expression54 = null;
TransformExpressions.expression_return expression55 = null;
TransformExpressions.expression_return expression57 = null;
TransformExpressions.expression_return expression58 = null;
TransformExpressions.prefixOp_return prefixOp60 = null;
TransformExpressions.expression_return expression61 = null;
TransformExpressions.incdecOp_return incdecOp63 = null;
TransformExpressions.expression_return expression64 = null;
TransformExpressions.expression_return expression66 = null;
TransformExpressions.listOperation_return listOperation67 = null;
TransformExpressions.listLiteral_return listLiteral68 = null;
TransformExpressions.literal_return literal69 = null;
TransformExpressions.identifier_return identifier70 = null;
CommonTree FUNC_CALL37_tree=null;
CommonTree ID38_tree=null;
CommonTree QUESTION40_tree=null;
CommonTree IF_CALL41_tree=null;
CommonTree IMAGE_WRITE43_tree=null;
CommonTree IMAGE_POS46_tree=null;
CommonTree POW56_tree=null;
CommonTree PREFIX59_tree=null;
CommonTree POSTFIX62_tree=null;
CommonTree PAR65_tree=null;
RewriteRuleNodeStream stream_QUESTION=new RewriteRuleNodeStream(adaptor,"token QUESTION");
RewriteRuleNodeStream stream_ID=new RewriteRuleNodeStream(adaptor,"token ID");
RewriteRuleNodeStream stream_FUNC_CALL=new RewriteRuleNodeStream(adaptor,"token FUNC_CALL");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
try {
// jaitools/jiffle/parser/TransformExpressions.g:132:17: ( ^( FUNC_CALL ID expressionList ) -> {isProxy($ID.text)}? VAR_PROVIDED[ getRuntimeExpr($ID.text) ] -> ^( FUNC_CALL ID expressionList ) | ^( QUESTION e1= expression e2= expression e3= expression ) -> ^( IF_CALL ^( EXPR_LIST $e1 $e2 $e3) ) | ^( IF_CALL expressionList ) | ^( IMAGE_WRITE identifier expression ) | ^( IMAGE_POS identifier ( bandSpecifier )? ( pixelSpecifier )? ) | ^( logicalOp expression expression ) | ^( arithmeticOp expression expression ) | ^( POW expression expression ) | ^( PREFIX prefixOp expression ) | ^( POSTFIX incdecOp expression ) | ^( PAR expression ) | listOperation | listLiteral | literal | identifier )
int alt12=15;
switch ( input.LA(1) ) {
case FUNC_CALL:
{
alt12=1;
}
break;
case QUESTION:
{
alt12=2;
}
break;
case IF_CALL:
{
alt12=3;
}
break;
case IMAGE_WRITE:
{
alt12=4;
}
break;
case IMAGE_POS:
{
alt12=5;
}
break;
case OR:
case XOR:
case AND:
case LOGICALEQ:
case NE:
case GT:
case GE:
case LE:
case LT:
{
alt12=6;
}
break;
case PLUS:
case MINUS:
case TIMES:
case DIV:
case MOD:
{
alt12=7;
}
break;
case POW:
{
alt12=8;
}
break;
case PREFIX:
{
alt12=9;
}
break;
case POSTFIX:
{
alt12=10;
}
break;
case PAR:
{
alt12=11;
}
break;
case APPEND:
{
alt12=12;
}
break;
case DECLARED_LIST:
{
alt12=13;
}
break;
case INT_LITERAL:
case FLOAT_LITERAL:
case TRUE:
case FALSE:
case NULL:
{
alt12=14;
}
break;
case CONSTANT:
case VAR_DEST:
case VAR_SOURCE:
case VAR_IMAGE_SCOPE:
case VAR_PIXEL_SCOPE:
case VAR_LOOP:
case VAR_LIST:
{
alt12=15;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:132:19: ^( FUNC_CALL ID expressionList )
{
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
FUNC_CALL37=(CommonTree)match(input,FUNC_CALL,FOLLOW_FUNC_CALL_in_expression825);
stream_FUNC_CALL.add(FUNC_CALL37);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
ID38=(CommonTree)match(input,ID,FOLLOW_ID_in_expression827);
stream_ID.add(ID38);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expressionList_in_expression829);
expressionList39=expressionList();
state._fsp--;
stream_expressionList.add(expressionList39.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
// AST REWRITE
// elements: ID, FUNC_CALL, expressionList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
root_0 = (CommonTree)adaptor.nil();
// 135:19: -> {isProxy($ID.text)}? VAR_PROVIDED[ getRuntimeExpr($ID.text) ]
if (isProxy((ID38!=null?ID38.getText():null))) {
adaptor.addChild(root_0, (CommonTree)adaptor.create(VAR_PROVIDED, getRuntimeExpr((ID38!=null?ID38.getText():null))));
}
else // 136:19: -> ^( FUNC_CALL ID expressionList )
{
// jaitools/jiffle/parser/TransformExpressions.g:136:22: ^( FUNC_CALL ID expressionList )
{
CommonTree root_1 = (CommonTree)adaptor.nil();
root_1 = (CommonTree)adaptor.becomeRoot(stream_FUNC_CALL.nextNode(), root_1);
adaptor.addChild(root_1, stream_ID.nextNode());
adaptor.addChild(root_1, stream_expressionList.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// jaitools/jiffle/parser/TransformExpressions.g:139:19: ^( QUESTION e1= expression e2= expression e3= expression )
{
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
QUESTION40=(CommonTree)match(input,QUESTION,FOLLOW_QUESTION_in_expression944);
stream_QUESTION.add(QUESTION40);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression948);
e1=expression();
state._fsp--;
stream_expression.add(e1.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression952);
e2=expression();
state._fsp--;
stream_expression.add(e2.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression956);
e3=expression();
state._fsp--;
stream_expression.add(e3.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
// AST REWRITE
// elements: e3, e1, e2
// token labels:
// rule labels: e3, retval, e1, e2
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
root_0 = (CommonTree)adaptor.nil();
// 140:19: -> ^( IF_CALL ^( EXPR_LIST $e1 $e2 $e3) )
{
// jaitools/jiffle/parser/TransformExpressions.g:140:22: ^( IF_CALL ^( EXPR_LIST $e1 $e2 $e3) )
{
CommonTree root_1 = (CommonTree)adaptor.nil();
root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(IF_CALL, "IF_CALL"), root_1);
// jaitools/jiffle/parser/TransformExpressions.g:140:32: ^( EXPR_LIST $e1 $e2 $e3)
{
CommonTree root_2 = (CommonTree)adaptor.nil();
root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EXPR_LIST, "EXPR_LIST"), root_2);
adaptor.addChild(root_2, stream_e1.nextTree());
adaptor.addChild(root_2, stream_e2.nextTree());
adaptor.addChild(root_2, stream_e3.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// jaitools/jiffle/parser/TransformExpressions.g:143:19: ^( IF_CALL expressionList )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
IF_CALL41=(CommonTree)match(input,IF_CALL,FOLLOW_IF_CALL_in_expression1018);
IF_CALL41_tree = (CommonTree)adaptor.dupNode(IF_CALL41);
root_1 = (CommonTree)adaptor.becomeRoot(IF_CALL41_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expressionList_in_expression1020);
expressionList42=expressionList();
state._fsp--;
adaptor.addChild(root_1, expressionList42.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 4 :
// jaitools/jiffle/parser/TransformExpressions.g:144:19: ^( IMAGE_WRITE identifier expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
IMAGE_WRITE43=(CommonTree)match(input,IMAGE_WRITE,FOLLOW_IMAGE_WRITE_in_expression1042);
IMAGE_WRITE43_tree = (CommonTree)adaptor.dupNode(IMAGE_WRITE43);
root_1 = (CommonTree)adaptor.becomeRoot(IMAGE_WRITE43_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_identifier_in_expression1044);
identifier44=identifier();
state._fsp--;
adaptor.addChild(root_1, identifier44.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1046);
expression45=expression();
state._fsp--;
adaptor.addChild(root_1, expression45.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 5 :
// jaitools/jiffle/parser/TransformExpressions.g:145:19: ^( IMAGE_POS identifier ( bandSpecifier )? ( pixelSpecifier )? )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
IMAGE_POS46=(CommonTree)match(input,IMAGE_POS,FOLLOW_IMAGE_POS_in_expression1068);
IMAGE_POS46_tree = (CommonTree)adaptor.dupNode(IMAGE_POS46);
root_1 = (CommonTree)adaptor.becomeRoot(IMAGE_POS46_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_identifier_in_expression1070);
identifier47=identifier();
state._fsp--;
adaptor.addChild(root_1, identifier47.getTree());
// jaitools/jiffle/parser/TransformExpressions.g:145:42: ( bandSpecifier )?
int alt10=2;
switch ( input.LA(1) ) {
case BAND_REF:
{
alt10=1;
}
break;
}
switch (alt10) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:145:42: bandSpecifier
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_bandSpecifier_in_expression1072);
bandSpecifier48=bandSpecifier();
state._fsp--;
adaptor.addChild(root_1, bandSpecifier48.getTree());
}
break;
}
// jaitools/jiffle/parser/TransformExpressions.g:145:57: ( pixelSpecifier )?
int alt11=2;
switch ( input.LA(1) ) {
case PIXEL_REF:
{
alt11=1;
}
break;
}
switch (alt11) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:145:57: pixelSpecifier
{
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_pixelSpecifier_in_expression1075);
pixelSpecifier49=pixelSpecifier();
state._fsp--;
adaptor.addChild(root_1, pixelSpecifier49.getTree());
}
break;
}
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 6 :
// jaitools/jiffle/parser/TransformExpressions.g:146:19: ^( logicalOp expression expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_logicalOp_in_expression1098);
logicalOp50=logicalOp();
state._fsp--;
root_1 = (CommonTree)adaptor.becomeRoot(logicalOp50.getTree(), root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1100);
expression51=expression();
state._fsp--;
adaptor.addChild(root_1, expression51.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1102);
expression52=expression();
state._fsp--;
adaptor.addChild(root_1, expression52.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 7 :
// jaitools/jiffle/parser/TransformExpressions.g:147:19: ^( arithmeticOp expression expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_arithmeticOp_in_expression1124);
arithmeticOp53=arithmeticOp();
state._fsp--;
root_1 = (CommonTree)adaptor.becomeRoot(arithmeticOp53.getTree(), root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1126);
expression54=expression();
state._fsp--;
adaptor.addChild(root_1, expression54.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1128);
expression55=expression();
state._fsp--;
adaptor.addChild(root_1, expression55.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 8 :
// jaitools/jiffle/parser/TransformExpressions.g:148:19: ^( POW expression expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
POW56=(CommonTree)match(input,POW,FOLLOW_POW_in_expression1150);
POW56_tree = (CommonTree)adaptor.dupNode(POW56);
root_1 = (CommonTree)adaptor.becomeRoot(POW56_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1152);
expression57=expression();
state._fsp--;
adaptor.addChild(root_1, expression57.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1154);
expression58=expression();
state._fsp--;
adaptor.addChild(root_1, expression58.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 9 :
// jaitools/jiffle/parser/TransformExpressions.g:149:19: ^( PREFIX prefixOp expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
PREFIX59=(CommonTree)match(input,PREFIX,FOLLOW_PREFIX_in_expression1176);
PREFIX59_tree = (CommonTree)adaptor.dupNode(PREFIX59);
root_1 = (CommonTree)adaptor.becomeRoot(PREFIX59_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_prefixOp_in_expression1178);
prefixOp60=prefixOp();
state._fsp--;
adaptor.addChild(root_1, prefixOp60.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1180);
expression61=expression();
state._fsp--;
adaptor.addChild(root_1, expression61.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 10 :
// jaitools/jiffle/parser/TransformExpressions.g:150:19: ^( POSTFIX incdecOp expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
POSTFIX62=(CommonTree)match(input,POSTFIX,FOLLOW_POSTFIX_in_expression1202);
POSTFIX62_tree = (CommonTree)adaptor.dupNode(POSTFIX62);
root_1 = (CommonTree)adaptor.becomeRoot(POSTFIX62_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_incdecOp_in_expression1204);
incdecOp63=incdecOp();
state._fsp--;
adaptor.addChild(root_1, incdecOp63.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1206);
expression64=expression();
state._fsp--;
adaptor.addChild(root_1, expression64.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 11 :
// jaitools/jiffle/parser/TransformExpressions.g:151:19: ^( PAR expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
PAR65=(CommonTree)match(input,PAR,FOLLOW_PAR_in_expression1228);
PAR65_tree = (CommonTree)adaptor.dupNode(PAR65);
root_1 = (CommonTree)adaptor.becomeRoot(PAR65_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_expression1230);
expression66=expression();
state._fsp--;
adaptor.addChild(root_1, expression66.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 12 :
// jaitools/jiffle/parser/TransformExpressions.g:152:19: listOperation
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_listOperation_in_expression1251);
listOperation67=listOperation();
state._fsp--;
adaptor.addChild(root_0, listOperation67.getTree());
}
break;
case 13 :
// jaitools/jiffle/parser/TransformExpressions.g:153:19: listLiteral
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_listLiteral_in_expression1271);
listLiteral68=listLiteral();
state._fsp--;
adaptor.addChild(root_0, listLiteral68.getTree());
}
break;
case 14 :
// jaitools/jiffle/parser/TransformExpressions.g:154:19: literal
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_literal_in_expression1291);
literal69=literal();
state._fsp--;
adaptor.addChild(root_0, literal69.getTree());
}
break;
case 15 :
// jaitools/jiffle/parser/TransformExpressions.g:155:19: identifier
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_identifier_in_expression1311);
identifier70=identifier();
state._fsp--;
adaptor.addChild(root_0, identifier70.getTree());
}
break;
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "expression"
public static class listOperation_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "listOperation"
// jaitools/jiffle/parser/TransformExpressions.g:159:1: listOperation : ^( APPEND VAR_LIST expression ) ;
public final TransformExpressions.listOperation_return listOperation() throws RecognitionException {
TransformExpressions.listOperation_return retval = new TransformExpressions.listOperation_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree APPEND71=null;
CommonTree VAR_LIST72=null;
TransformExpressions.expression_return expression73 = null;
CommonTree APPEND71_tree=null;
CommonTree VAR_LIST72_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:159:17: ( ^( APPEND VAR_LIST expression ) )
// jaitools/jiffle/parser/TransformExpressions.g:159:19: ^( APPEND VAR_LIST expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
APPEND71=(CommonTree)match(input,APPEND,FOLLOW_APPEND_in_listOperation1340);
APPEND71_tree = (CommonTree)adaptor.dupNode(APPEND71);
root_1 = (CommonTree)adaptor.becomeRoot(APPEND71_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
VAR_LIST72=(CommonTree)match(input,VAR_LIST,FOLLOW_VAR_LIST_in_listOperation1342);
VAR_LIST72_tree = (CommonTree)adaptor.dupNode(VAR_LIST72);
adaptor.addChild(root_1, VAR_LIST72_tree);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_listOperation1344);
expression73=expression();
state._fsp--;
adaptor.addChild(root_1, expression73.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "listOperation"
public static class listLiteral_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "listLiteral"
// jaitools/jiffle/parser/TransformExpressions.g:163:1: listLiteral : ^( DECLARED_LIST expressionList ) ;
public final TransformExpressions.listLiteral_return listLiteral() throws RecognitionException {
TransformExpressions.listLiteral_return retval = new TransformExpressions.listLiteral_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree DECLARED_LIST74=null;
TransformExpressions.expressionList_return expressionList75 = null;
CommonTree DECLARED_LIST74_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:163:17: ( ^( DECLARED_LIST expressionList ) )
// jaitools/jiffle/parser/TransformExpressions.g:163:19: ^( DECLARED_LIST expressionList )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
DECLARED_LIST74=(CommonTree)match(input,DECLARED_LIST,FOLLOW_DECLARED_LIST_in_listLiteral1376);
DECLARED_LIST74_tree = (CommonTree)adaptor.dupNode(DECLARED_LIST74);
root_1 = (CommonTree)adaptor.becomeRoot(DECLARED_LIST74_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expressionList_in_listLiteral1378);
expressionList75=expressionList();
state._fsp--;
adaptor.addChild(root_1, expressionList75.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "listLiteral"
public static class identifier_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "identifier"
// jaitools/jiffle/parser/TransformExpressions.g:167:1: identifier : ( VAR_SOURCE | VAR_DEST | VAR_IMAGE_SCOPE | VAR_PIXEL_SCOPE | VAR_LOOP | VAR_LIST | CONSTANT );
public final TransformExpressions.identifier_return identifier() throws RecognitionException {
TransformExpressions.identifier_return retval = new TransformExpressions.identifier_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree set76=null;
CommonTree set76_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:167:17: ( VAR_SOURCE | VAR_DEST | VAR_IMAGE_SCOPE | VAR_PIXEL_SCOPE | VAR_LOOP | VAR_LIST | CONSTANT )
// jaitools/jiffle/parser/TransformExpressions.g:
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
set76=(CommonTree)input.LT(1);
if ( input.LA(1)==CONSTANT||(input.LA(1)>=VAR_DEST && input.LA(1)<=VAR_PIXEL_SCOPE)||(input.LA(1)>=VAR_LOOP && input.LA(1)<=VAR_LIST) ) {
input.consume();
set76_tree = (CommonTree)adaptor.dupNode(set76);
adaptor.addChild(root_0, set76_tree);
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "identifier"
public static class logicalOp_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "logicalOp"
// jaitools/jiffle/parser/TransformExpressions.g:177:1: logicalOp : ( OR | XOR | AND | LOGICALEQ | NE | GT | GE | LT | LE );
public final TransformExpressions.logicalOp_return logicalOp() throws RecognitionException {
TransformExpressions.logicalOp_return retval = new TransformExpressions.logicalOp_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree set77=null;
CommonTree set77_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:177:17: ( OR | XOR | AND | LOGICALEQ | NE | GT | GE | LT | LE )
// jaitools/jiffle/parser/TransformExpressions.g:
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
set77=(CommonTree)input.LT(1);
if ( (input.LA(1)>=OR && input.LA(1)<=LT) ) {
input.consume();
set77_tree = (CommonTree)adaptor.dupNode(set77);
adaptor.addChild(root_0, set77_tree);
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "logicalOp"
public static class arithmeticOp_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "arithmeticOp"
// jaitools/jiffle/parser/TransformExpressions.g:189:1: arithmeticOp : ( PLUS | MINUS | TIMES | DIV | MOD );
public final TransformExpressions.arithmeticOp_return arithmeticOp() throws RecognitionException {
TransformExpressions.arithmeticOp_return retval = new TransformExpressions.arithmeticOp_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree set78=null;
CommonTree set78_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:189:17: ( PLUS | MINUS | TIMES | DIV | MOD )
// jaitools/jiffle/parser/TransformExpressions.g:
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
set78=(CommonTree)input.LT(1);
if ( (input.LA(1)>=PLUS && input.LA(1)<=MOD) ) {
input.consume();
set78_tree = (CommonTree)adaptor.dupNode(set78);
adaptor.addChild(root_0, set78_tree);
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "arithmeticOp"
public static class prefixOp_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "prefixOp"
// jaitools/jiffle/parser/TransformExpressions.g:197:1: prefixOp : ( PLUS | MINUS | NOT | incdecOp );
public final TransformExpressions.prefixOp_return prefixOp() throws RecognitionException {
TransformExpressions.prefixOp_return retval = new TransformExpressions.prefixOp_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree PLUS79=null;
CommonTree MINUS80=null;
CommonTree NOT81=null;
TransformExpressions.incdecOp_return incdecOp82 = null;
CommonTree PLUS79_tree=null;
CommonTree MINUS80_tree=null;
CommonTree NOT81_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:197:17: ( PLUS | MINUS | NOT | incdecOp )
int alt13=4;
switch ( input.LA(1) ) {
case PLUS:
{
alt13=1;
}
break;
case MINUS:
{
alt13=2;
}
break;
case NOT:
{
alt13=3;
}
break;
case INCR:
case DECR:
{
alt13=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 13, 0, input);
throw nvae;
}
switch (alt13) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:197:19: PLUS
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
PLUS79=(CommonTree)match(input,PLUS,FOLLOW_PLUS_in_prefixOp1864);
PLUS79_tree = (CommonTree)adaptor.dupNode(PLUS79);
adaptor.addChild(root_0, PLUS79_tree);
}
break;
case 2 :
// jaitools/jiffle/parser/TransformExpressions.g:198:19: MINUS
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
MINUS80=(CommonTree)match(input,MINUS,FOLLOW_MINUS_in_prefixOp1884);
MINUS80_tree = (CommonTree)adaptor.dupNode(MINUS80);
adaptor.addChild(root_0, MINUS80_tree);
}
break;
case 3 :
// jaitools/jiffle/parser/TransformExpressions.g:199:19: NOT
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
NOT81=(CommonTree)match(input,NOT,FOLLOW_NOT_in_prefixOp1904);
NOT81_tree = (CommonTree)adaptor.dupNode(NOT81);
adaptor.addChild(root_0, NOT81_tree);
}
break;
case 4 :
// jaitools/jiffle/parser/TransformExpressions.g:200:19: incdecOp
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_incdecOp_in_prefixOp1924);
incdecOp82=incdecOp();
state._fsp--;
adaptor.addChild(root_0, incdecOp82.getTree());
}
break;
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "prefixOp"
public static class incdecOp_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "incdecOp"
// jaitools/jiffle/parser/TransformExpressions.g:204:1: incdecOp : ( INCR | DECR );
public final TransformExpressions.incdecOp_return incdecOp() throws RecognitionException {
TransformExpressions.incdecOp_return retval = new TransformExpressions.incdecOp_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree set83=null;
CommonTree set83_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:204:17: ( INCR | DECR )
// jaitools/jiffle/parser/TransformExpressions.g:
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
set83=(CommonTree)input.LT(1);
if ( (input.LA(1)>=INCR && input.LA(1)<=DECR) ) {
input.consume();
set83_tree = (CommonTree)adaptor.dupNode(set83);
adaptor.addChild(root_0, set83_tree);
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "incdecOp"
public static class pixelSpecifier_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "pixelSpecifier"
// jaitools/jiffle/parser/TransformExpressions.g:209:1: pixelSpecifier : ^( PIXEL_REF pixelPos pixelPos ) ;
public final TransformExpressions.pixelSpecifier_return pixelSpecifier() throws RecognitionException {
TransformExpressions.pixelSpecifier_return retval = new TransformExpressions.pixelSpecifier_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree PIXEL_REF84=null;
TransformExpressions.pixelPos_return pixelPos85 = null;
TransformExpressions.pixelPos_return pixelPos86 = null;
CommonTree PIXEL_REF84_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:209:17: ( ^( PIXEL_REF pixelPos pixelPos ) )
// jaitools/jiffle/parser/TransformExpressions.g:209:19: ^( PIXEL_REF pixelPos pixelPos )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
PIXEL_REF84=(CommonTree)match(input,PIXEL_REF,FOLLOW_PIXEL_REF_in_pixelSpecifier2005);
PIXEL_REF84_tree = (CommonTree)adaptor.dupNode(PIXEL_REF84);
root_1 = (CommonTree)adaptor.becomeRoot(PIXEL_REF84_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_pixelPos_in_pixelSpecifier2007);
pixelPos85=pixelPos();
state._fsp--;
adaptor.addChild(root_1, pixelPos85.getTree());
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_pixelPos_in_pixelSpecifier2009);
pixelPos86=pixelPos();
state._fsp--;
adaptor.addChild(root_1, pixelPos86.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "pixelSpecifier"
public static class bandSpecifier_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "bandSpecifier"
// jaitools/jiffle/parser/TransformExpressions.g:213:1: bandSpecifier : ^( BAND_REF expression ) ;
public final TransformExpressions.bandSpecifier_return bandSpecifier() throws RecognitionException {
TransformExpressions.bandSpecifier_return retval = new TransformExpressions.bandSpecifier_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree BAND_REF87=null;
TransformExpressions.expression_return expression88 = null;
CommonTree BAND_REF87_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:213:17: ( ^( BAND_REF expression ) )
// jaitools/jiffle/parser/TransformExpressions.g:213:19: ^( BAND_REF expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
BAND_REF87=(CommonTree)match(input,BAND_REF,FOLLOW_BAND_REF_in_bandSpecifier2039);
BAND_REF87_tree = (CommonTree)adaptor.dupNode(BAND_REF87);
root_1 = (CommonTree)adaptor.becomeRoot(BAND_REF87_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_bandSpecifier2041);
expression88=expression();
state._fsp--;
adaptor.addChild(root_1, expression88.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "bandSpecifier"
public static class pixelPos_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "pixelPos"
// jaitools/jiffle/parser/TransformExpressions.g:217:1: pixelPos : ( ^( ABS_POS expression ) | ^( REL_POS expression ) );
public final TransformExpressions.pixelPos_return pixelPos() throws RecognitionException {
TransformExpressions.pixelPos_return retval = new TransformExpressions.pixelPos_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree ABS_POS89=null;
CommonTree REL_POS91=null;
TransformExpressions.expression_return expression90 = null;
TransformExpressions.expression_return expression92 = null;
CommonTree ABS_POS89_tree=null;
CommonTree REL_POS91_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:217:17: ( ^( ABS_POS expression ) | ^( REL_POS expression ) )
int alt14=2;
switch ( input.LA(1) ) {
case ABS_POS:
{
alt14=1;
}
break;
case REL_POS:
{
alt14=2;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 14, 0, input);
throw nvae;
}
switch (alt14) {
case 1 :
// jaitools/jiffle/parser/TransformExpressions.g:217:19: ^( ABS_POS expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
ABS_POS89=(CommonTree)match(input,ABS_POS,FOLLOW_ABS_POS_in_pixelPos2076);
ABS_POS89_tree = (CommonTree)adaptor.dupNode(ABS_POS89);
root_1 = (CommonTree)adaptor.becomeRoot(ABS_POS89_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_pixelPos2078);
expression90=expression();
state._fsp--;
adaptor.addChild(root_1, expression90.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
case 2 :
// jaitools/jiffle/parser/TransformExpressions.g:218:19: ^( REL_POS expression )
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
{
CommonTree _save_last_1 = _last;
CommonTree _first_1 = null;
CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
REL_POS91=(CommonTree)match(input,REL_POS,FOLLOW_REL_POS_in_pixelPos2100);
REL_POS91_tree = (CommonTree)adaptor.dupNode(REL_POS91);
root_1 = (CommonTree)adaptor.becomeRoot(REL_POS91_tree, root_1);
match(input, Token.DOWN, null);
_last = (CommonTree)input.LT(1);
pushFollow(FOLLOW_expression_in_pixelPos2102);
expression92=expression();
state._fsp--;
adaptor.addChild(root_1, expression92.getTree());
match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
}
}
break;
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "pixelPos"
public static class literal_return extends TreeRuleReturnScope {
CommonTree tree;
public Object getTree() { return tree; }
};
// $ANTLR start "literal"
// jaitools/jiffle/parser/TransformExpressions.g:222:1: literal : ( INT_LITERAL | FLOAT_LITERAL | TRUE | FALSE | NULL );
public final TransformExpressions.literal_return literal() throws RecognitionException {
TransformExpressions.literal_return retval = new TransformExpressions.literal_return();
retval.start = input.LT(1);
CommonTree root_0 = null;
CommonTree _first_0 = null;
CommonTree _last = null;
CommonTree set93=null;
CommonTree set93_tree=null;
try {
// jaitools/jiffle/parser/TransformExpressions.g:222:17: ( INT_LITERAL | FLOAT_LITERAL | TRUE | FALSE | NULL )
// jaitools/jiffle/parser/TransformExpressions.g:
{
root_0 = (CommonTree)adaptor.nil();
_last = (CommonTree)input.LT(1);
set93=(CommonTree)input.LT(1);
if ( (input.LA(1)>=INT_LITERAL && input.LA(1)<=NULL) ) {
input.consume();
set93_tree = (CommonTree)adaptor.dupNode(set93);
adaptor.addChild(root_0, set93_tree);
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
}
return retval;
}
// $ANTLR end "literal"
// Delegated rules
public static final BitSet FOLLOW_jiffleOption_in_start94 = new BitSet(new long[]{0xFFFF87041BF61FB0L,0x000000000000F88FL});
public static final BitSet FOLLOW_varDeclaration_in_start97 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_statement_in_start100 = new BitSet(new long[]{0xFFFF87041BF61FA2L,0x000000000000F88FL});
public static final BitSet FOLLOW_JIFFLE_OPTION_in_jiffleOption131 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_IMAGE_SCOPE_VAR_DECL_in_varDeclaration163 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_varDeclaration169 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BLOCK_in_block207 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_blockStatement_in_block209 = new BitSet(new long[]{0xFFFF87241BF61FA8L,0x000000000000F88FL});
public static final BitSet FOLLOW_statement_in_blockStatement238 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_BREAKIF_in_blockStatement259 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_blockStatement261 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_block_in_statement294 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_assignmentExpression_in_statement314 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_WHILE_in_statement335 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_loopCondition_in_statement337 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_statement_in_statement339 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_UNTIL_in_statement361 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_loopCondition_in_statement363 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_statement_in_statement365 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_FOREACH_in_statement387 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_statement389 = new BitSet(new long[]{0x0000000010080080L});
public static final BitSet FOLLOW_loopSet_in_statement391 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_statement_in_statement393 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_expression_in_statement414 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_expression_in_loopCondition442 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SEQUENCE_in_loopSet477 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_loopSet479 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_loopSet481 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_listLiteral_in_loopSet502 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_VAR_LIST_in_loopSet522 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_EXPR_LIST_in_expressionList573 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_expressionList578 = new BitSet(new long[]{0xFFFF87041BF61FA8L,0x000000000000F88FL});
public static final BitSet FOLLOW_assignmentOp_in_assignmentExpression648 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_identifier_in_assignmentExpression650 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_assignmentExpression652 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_set_in_assignmentOp0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_FUNC_CALL_in_expression825 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_expression827 = new BitSet(new long[]{0x0000000000000040L});
public static final BitSet FOLLOW_expressionList_in_expression829 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_QUESTION_in_expression944 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_expression948 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression952 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression956 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_IF_CALL_in_expression1018 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expressionList_in_expression1020 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_IMAGE_WRITE_in_expression1042 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_identifier_in_expression1044 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression1046 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_IMAGE_POS_in_expression1068 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_identifier_in_expression1070 = new BitSet(new long[]{0x0000000000006008L});
public static final BitSet FOLLOW_bandSpecifier_in_expression1072 = new BitSet(new long[]{0x0000000000004008L});
public static final BitSet FOLLOW_pixelSpecifier_in_expression1075 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_logicalOp_in_expression1098 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_expression1100 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression1102 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_arithmeticOp_in_expression1124 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_expression1126 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression1128 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_POW_in_expression1150 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_expression1152 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression1154 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PREFIX_in_expression1176 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_prefixOp_in_expression1178 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression1180 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_POSTFIX_in_expression1202 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_incdecOp_in_expression1204 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_expression1206 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PAR_in_expression1228 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_expression1230 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_listOperation_in_expression1251 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_listLiteral_in_expression1271 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_literal_in_expression1291 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_identifier_in_expression1311 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_APPEND_in_listOperation1340 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_VAR_LIST_in_listOperation1342 = new BitSet(new long[]{0xFFFF87041BF61FA0L,0x000000000000F88FL});
public static final BitSet FOLLOW_expression_in_listOperation1344 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_DECLARED_LIST_in_listLiteral1376 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expressionList_in_listLiteral1378 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_set_in_identifier0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_logicalOp0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_arithmeticOp0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PLUS_in_prefixOp1864 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_MINUS_in_prefixOp1884 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOT_in_prefixOp1904 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_incdecOp_in_prefixOp1924 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_set_in_incdecOp0 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PIXEL_REF_in_pixelSpecifier2005 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_pixelPos_in_pixelSpecifier2007 = new BitSet(new long[]{0x0000000000018000L});
public static final BitSet FOLLOW_pixelPos_in_pixelSpecifier2009 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BAND_REF_in_bandSpecifier2039 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_bandSpecifier2041 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ABS_POS_in_pixelPos2076 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_pixelPos2078 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_REL_POS_in_pixelPos2100 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_expression_in_pixelPos2102 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L});
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy