    001    // $ANTLR 3.3 Nov 30, 2010 12:46:29 C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g 2014-11-20 09:03:04
    002
    003    package org.apache.tapestry5.internal.antlr;
    004
    005
    006    import org.antlr.runtime.*;
    007    import java.util.Stack;
    008    import java.util.List;
    009    import java.util.ArrayList;
    010    import java.util.Map;
    011    import java.util.HashMap;
    012
    013    import org.antlr.runtime.tree.*;
    014
    015    public class PropertyExpressionParser extends org.apache.tapestry5.internal.antlr.BaseParser {
    016        public static final String[] tokenNames = new String[] {
    017            "<invalid>", "<EOR>", "<DOWN>", "<UP>", "INTEGER", "DEREF", "RANGEOP", "DECIMAL", "LETTER", "DIGIT", "SIGN", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", "COMMA", "BANG", "LBRACE", "RBRACE", "COLON", "QUOTE", "A", "E", "F", "H", "I", "L", "N", "R", "S", "T", "U", "NULL", "TRUE", "FALSE", "THIS", "JAVA_ID_START", "JAVA_ID_PART", "IDENTIFIER", "SAFEDEREF", "WS", "STRING", "NUMBER_OR_RANGEOP", "INVOKE", "LIST", "MAP", "NOT"
    018        };
    019        public static final int EOF=-1;
    020        public static final int INTEGER=4;
    021        public static final int DEREF=5;
    022        public static final int RANGEOP=6;
    023        public static final int DECIMAL=7;
    024        public static final int LETTER=8;
    025        public static final int DIGIT=9;
    026        public static final int SIGN=10;
    027        public static final int LPAREN=11;
    028        public static final int RPAREN=12;
    029        public static final int LBRACKET=13;
    030        public static final int RBRACKET=14;
    031        public static final int COMMA=15;
    032        public static final int BANG=16;
    033        public static final int LBRACE=17;
    034        public static final int RBRACE=18;
    035        public static final int COLON=19;
    036        public static final int QUOTE=20;
    037        public static final int A=21;
    038        public static final int E=22;
    039        public static final int F=23;
    040        public static final int H=24;
    041        public static final int I=25;
    042        public static final int L=26;
    043        public static final int N=27;
    044        public static final int R=28;
    045        public static final int S=29;
    046        public static final int T=30;
    047        public static final int U=31;
    048        public static final int NULL=32;
    049        public static final int TRUE=33;
    050        public static final int FALSE=34;
    051        public static final int THIS=35;
    052        public static final int JAVA_ID_START=36;
    053        public static final int JAVA_ID_PART=37;
    054        public static final int IDENTIFIER=38;
    055        public static final int SAFEDEREF=39;
    056        public static final int WS=40;
    057        public static final int STRING=41;
    058        public static final int NUMBER_OR_RANGEOP=42;
    059        public static final int INVOKE=43;
    060        public static final int LIST=44;
    061        public static final int MAP=45;
    062        public static final int NOT=46;
    063
    064        // delegates
    065        // delegators
    066
    067
    068            public PropertyExpressionParser(TokenStream input) {
    069                this(input, new RecognizerSharedState());
    070            }
    071            public PropertyExpressionParser(TokenStream input, RecognizerSharedState state) {
    072                super(input, state);
    073
    074            }
    075
    076        protected TreeAdaptor adaptor = new CommonTreeAdaptor();
    077
    078        public void setTreeAdaptor(TreeAdaptor adaptor) {
    079            this.adaptor = adaptor;
    080        }
    081        public TreeAdaptor getTreeAdaptor() {
    082            return adaptor;
    083        }
    084
    085        public String[] getTokenNames() { return PropertyExpressionParser.tokenNames; }
    086        public String getGrammarFileName() { return "C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g"; }
    087
    088
    089        public static class start_return extends ParserRuleReturnScope {
    090            CommonTree tree;
    091            public Object getTree() { return tree; }
    092        };
    093
    094        // $ANTLR start "start"
    095        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:45:1: start : expression EOF ;
    096        public final PropertyExpressionParser.start_return start() throws RecognitionException {
    097            PropertyExpressionParser.start_return retval = new PropertyExpressionParser.start_return();
    098            retval.start = input.LT(1);
    099
    100            CommonTree root_0 = null;
    101
    102            Token EOF2=null;
    103            PropertyExpressionParser.expression_return expression1 = null;
    104
    105
    106            CommonTree EOF2_tree=null;
    107
    108            try {
    109                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:45:8: ( expression EOF )
    110                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:45:10: expression EOF
    111                {
    112                root_0 = (CommonTree)adaptor.nil();
    113
    114                pushFollow(FOLLOW_expression_in_start130);
    115                expression1=expression();
    116
    117                state._fsp--;
    118                if (state.failed) return retval;
    119                if ( state.backtracking==0 ) root_0 = (CommonTree)adaptor.becomeRoot(expression1.getTree(), root_0);
    120                EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_start133); if (state.failed) return retval;
    121
    122                }
    123
    124                retval.stop = input.LT(-1);
    125
    126                if ( state.backtracking==0 ) {
    127
    128                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    129                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    130                }
    131            }
    132            catch (RecognitionException re) {
    133                reportError(re);
    134                recover(input,re);
    135            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    136
    137            }
    138            finally {
    139            }
    140            return retval;
    141        }
    142        // $ANTLR end "start"
    143
    144        public static class expression_return extends ParserRuleReturnScope {
    145            CommonTree tree;
    146            public Object getTree() { return tree; }
    147        };
    148
    149        // $ANTLR start "expression"
    150        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:47:1: expression : ( keyword | rangeOp | constant | propertyChain | list | notOp | map );
    151        public final PropertyExpressionParser.expression_return expression() throws RecognitionException {
    152            PropertyExpressionParser.expression_return retval = new PropertyExpressionParser.expression_return();
    153            retval.start = input.LT(1);
    154
    155            CommonTree root_0 = null;
    156
    157            PropertyExpressionParser.keyword_return keyword3 = null;
    158
    159            PropertyExpressionParser.rangeOp_return rangeOp4 = null;
    160
    161            PropertyExpressionParser.constant_return constant5 = null;
    162
    163            PropertyExpressionParser.propertyChain_return propertyChain6 = null;
    164
    165            PropertyExpressionParser.list_return list7 = null;
    166
    167            PropertyExpressionParser.notOp_return notOp8 = null;
    168
    169            PropertyExpressionParser.map_return map9 = null;
    170
    171
    172
    173            try {
    174                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:48:2: ( keyword | rangeOp | constant | propertyChain | list | notOp | map )
    175                int alt1=7;
    176                alt1 = dfa1.predict(input);
    177                switch (alt1) {
    178                    case 1 :
    179                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:48:4: keyword
    180                        {
    181                        root_0 = (CommonTree)adaptor.nil();
    182
    183                        pushFollow(FOLLOW_keyword_in_expression145);
    184                        keyword3=keyword();
    185
    186                        state._fsp--;
    187                        if (state.failed) return retval;
    188                        if ( state.backtracking==0 ) adaptor.addChild(root_0, keyword3.getTree());
    189
    190                        }
    191                        break;
    192                    case 2 :
    193                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:49:4: rangeOp
    194                        {
    195                        root_0 = (CommonTree)adaptor.nil();
    196
    197                        pushFollow(FOLLOW_rangeOp_in_expression150);
    198                        rangeOp4=rangeOp();
    199
    200                        state._fsp--;
    201                        if (state.failed) return retval;
    202                        if ( state.backtracking==0 ) adaptor.addChild(root_0, rangeOp4.getTree());
    203
    204                        }
    205                        break;
    206                    case 3 :
    207                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:50:4: constant
    208                        {
    209                        root_0 = (CommonTree)adaptor.nil();
    210
    211                        pushFollow(FOLLOW_constant_in_expression155);
    212                        constant5=constant();
    213
    214                        state._fsp--;
    215                        if (state.failed) return retval;
    216                        if ( state.backtracking==0 ) adaptor.addChild(root_0, constant5.getTree());
    217
    218                        }
    219                        break;
    220                    case 4 :
    221                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:51:4: propertyChain
    222                        {
    223                        root_0 = (CommonTree)adaptor.nil();
    224
    225                        pushFollow(FOLLOW_propertyChain_in_expression160);
    226                        propertyChain6=propertyChain();
    227
    228                        state._fsp--;
    229                        if (state.failed) return retval;
    230                        if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyChain6.getTree());
    231
    232                        }
    233                        break;
    234                    case 5 :
    235                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:52:4: list
    236                        {
    237                        root_0 = (CommonTree)adaptor.nil();
    238
    239                        pushFollow(FOLLOW_list_in_expression165);
    240                        list7=list();
    241
    242                        state._fsp--;
    243                        if (state.failed) return retval;
    244                        if ( state.backtracking==0 ) adaptor.addChild(root_0, list7.getTree());
    245
    246                        }
    247                        break;
    248                    case 6 :
    249                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:53:4: notOp
    250                        {
    251                        root_0 = (CommonTree)adaptor.nil();
    252
    253                        pushFollow(FOLLOW_notOp_in_expression170);
    254                        notOp8=notOp();
    255
    256                        state._fsp--;
    257                        if (state.failed) return retval;
    258                        if ( state.backtracking==0 ) adaptor.addChild(root_0, notOp8.getTree());
    259
    260                        }
    261                        break;
    262                    case 7 :
    263                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:54:4: map
    264                        {
    265                        root_0 = (CommonTree)adaptor.nil();
    266
    267                        pushFollow(FOLLOW_map_in_expression175);
    268                        map9=map();
    269
    270                        state._fsp--;
    271                        if (state.failed) return retval;
    272                        if ( state.backtracking==0 ) adaptor.addChild(root_0, map9.getTree());
    273
    274                        }
    275                        break;
    276
    277                }
    278                retval.stop = input.LT(-1);
    279
    280                if ( state.backtracking==0 ) {
    281
    282                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    283                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    284                }
    285            }
    286            catch (RecognitionException re) {
    287                reportError(re);
    288                recover(input,re);
    289            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    290
    291            }
    292            finally {
    293            }
    294            return retval;
    295        }
    296        // $ANTLR end "expression"
    297
    298        public static class keyword_return extends ParserRuleReturnScope {
    299            CommonTree tree;
    300            public Object getTree() { return tree; }
    301        };
    302
    303        // $ANTLR start "keyword"
    304        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:57:1: keyword : ( NULL | TRUE | FALSE | THIS );
    305        public final PropertyExpressionParser.keyword_return keyword() throws RecognitionException {
    306            PropertyExpressionParser.keyword_return retval = new PropertyExpressionParser.keyword_return();
    307            retval.start = input.LT(1);
    308
    309            CommonTree root_0 = null;
    310
    311            Token set10=null;
    312
    313            CommonTree set10_tree=null;
    314
    315            try {
    316                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:57:9: ( NULL | TRUE | FALSE | THIS )
    317                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:
    318                {
    319                root_0 = (CommonTree)adaptor.nil();
    320
    321                set10=(Token)input.LT(1);
    322                if ( (input.LA(1)>=NULL && input.LA(1)<=THIS) ) {
    323                    input.consume();
    324                    if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set10));
    325                    state.errorRecovery=false;state.failed=false;
    326                }
    327                else {
    328                    if (state.backtracking>0) {state.failed=true; return retval;}
    329                    MismatchedSetException mse = new MismatchedSetException(null,input);
    330                    throw mse;
    331                }
    332
    333
    334                }
    335
    336                retval.stop = input.LT(-1);
    337
    338                if ( state.backtracking==0 ) {
    339
    340                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    341                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    342                }
    343            }
    344            catch (RecognitionException re) {
    345                reportError(re);
    346                recover(input,re);
    347            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    348
    349            }
    350            finally {
    351            }
    352            return retval;
    353        }
    354        // $ANTLR end "keyword"
    355
    356        public static class constant_return extends ParserRuleReturnScope {
    357            CommonTree tree;
    358            public Object getTree() { return tree; }
    359        };
    360
    361        // $ANTLR start "constant"
    362        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:59:1: constant : ( INTEGER | DECIMAL | STRING );
    363        public final PropertyExpressionParser.constant_return constant() throws RecognitionException {
    364            PropertyExpressionParser.constant_return retval = new PropertyExpressionParser.constant_return();
    365            retval.start = input.LT(1);
    366
    367            CommonTree root_0 = null;
    368
    369            Token set11=null;
    370
    371            CommonTree set11_tree=null;
    372
    373            try {
    374                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:59:9: ( INTEGER | DECIMAL | STRING )
    375                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:
    376                {
    377                root_0 = (CommonTree)adaptor.nil();
    378
    379                set11=(Token)input.LT(1);
    380                if ( input.LA(1)==INTEGER||input.LA(1)==DECIMAL||input.LA(1)==STRING ) {
    381                    input.consume();
    382                    if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set11));
    383                    state.errorRecovery=false;state.failed=false;
    384                }
    385                else {
    386                    if (state.backtracking>0) {state.failed=true; return retval;}
    387                    MismatchedSetException mse = new MismatchedSetException(null,input);
    388                    throw mse;
    389                }
    390
    391
    392                }
    393
    394                retval.stop = input.LT(-1);
    395
    396                if ( state.backtracking==0 ) {
    397
    398                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    399                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    400                }
    401            }
    402            catch (RecognitionException re) {
    403                reportError(re);
    404                recover(input,re);
    405            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    406
    407            }
    408            finally {
    409            }
    410            return retval;
    411        }
    412        // $ANTLR end "constant"
    413
    414        public static class propertyChain_return extends ParserRuleReturnScope {
    415            CommonTree tree;
    416            public Object getTree() { return tree; }
    417        };
    418
    419        // $ANTLR start "propertyChain"
    420        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:61:1: propertyChain : ( term DEREF propertyChain -> ^( DEREF term propertyChain ) | term SAFEDEREF propertyChain -> ^( SAFEDEREF term propertyChain ) | term );
    421        public final PropertyExpressionParser.propertyChain_return propertyChain() throws RecognitionException {
    422            PropertyExpressionParser.propertyChain_return retval = new PropertyExpressionParser.propertyChain_return();
    423            retval.start = input.LT(1);
    424
    425            CommonTree root_0 = null;
    426
    427            Token DEREF13=null;
    428            Token SAFEDEREF16=null;
    429            PropertyExpressionParser.term_return term12 = null;
    430
    431            PropertyExpressionParser.propertyChain_return propertyChain14 = null;
    432
    433            PropertyExpressionParser.term_return term15 = null;
    434
    435            PropertyExpressionParser.propertyChain_return propertyChain17 = null;
    436
    437            PropertyExpressionParser.term_return term18 = null;
    438
    439
    440            CommonTree DEREF13_tree=null;
    441            CommonTree SAFEDEREF16_tree=null;
    442            RewriteRuleTokenStream stream_DEREF=new RewriteRuleTokenStream(adaptor,"token DEREF");
    443            RewriteRuleTokenStream stream_SAFEDEREF=new RewriteRuleTokenStream(adaptor,"token SAFEDEREF");
    444            RewriteRuleSubtreeStream stream_term=new RewriteRuleSubtreeStream(adaptor,"rule term");
    445            RewriteRuleSubtreeStream stream_propertyChain=new RewriteRuleSubtreeStream(adaptor,"rule propertyChain");
    446            try {
    447                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:62:2: ( term DEREF propertyChain -> ^( DEREF term propertyChain ) | term SAFEDEREF propertyChain -> ^( SAFEDEREF term propertyChain ) | term )
    448                int alt2=3;
    449                int LA2_0 = input.LA(1);
    450
    451                if ( (LA2_0==IDENTIFIER) ) {
    452                    int LA2_1 = input.LA(2);
    453
    454                    if ( (synpred12_PropertyExpressionParser()) ) {
    455                        alt2=1;
    456                    }
    457                    else if ( (synpred13_PropertyExpressionParser()) ) {
    458                        alt2=2;
    459                    }
    460                    else if ( (true) ) {
    461                        alt2=3;
    462                    }
    463                    else {
    464                        if (state.backtracking>0) {state.failed=true; return retval;}
    465                        NoViableAltException nvae =
    466                            new NoViableAltException("", 2, 1, input);
    467
    468                        throw nvae;
    469                    }
    470                }
    471                else {
    472                    if (state.backtracking>0) {state.failed=true; return retval;}
    473                    NoViableAltException nvae =
    474                        new NoViableAltException("", 2, 0, input);
    475
    476                    throw nvae;
    477                }
    478                switch (alt2) {
    479                    case 1 :
    480                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:62:4: term DEREF propertyChain
    481                        {
    482                        pushFollow(FOLLOW_term_in_propertyChain222);
    483                        term12=term();
    484
    485                        state._fsp--;
    486                        if (state.failed) return retval;
    487                        if ( state.backtracking==0 ) stream_term.add(term12.getTree());
    488                        DEREF13=(Token)match(input,DEREF,FOLLOW_DEREF_in_propertyChain224); if (state.failed) return retval;
    489                        if ( state.backtracking==0 ) stream_DEREF.add(DEREF13);
    490
    491                        pushFollow(FOLLOW_propertyChain_in_propertyChain226);
    492                        propertyChain14=propertyChain();
    493
    494                        state._fsp--;
    495                        if (state.failed) return retval;
    496                        if ( state.backtracking==0 ) stream_propertyChain.add(propertyChain14.getTree());
    497
    498
    499                        // AST REWRITE
    500                        // elements: term, propertyChain, DEREF
    501                        // token labels:
    502                        // rule labels: retval
    503                        // token list labels:
    504                        // rule list labels:
    505                        // wildcard labels:
    506                        if ( state.backtracking==0 ) {
    507                        retval.tree = root_0;
    508                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    509
    510                        root_0 = (CommonTree)adaptor.nil();
    511                        // 62:29: -> ^( DEREF term propertyChain )
    512                        {
    513                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:62:32: ^( DEREF term propertyChain )
    514                            {
    515                            CommonTree root_1 = (CommonTree)adaptor.nil();
    516                            root_1 = (CommonTree)adaptor.becomeRoot(stream_DEREF.nextNode(), root_1);
    517
    518                            adaptor.addChild(root_1, stream_term.nextTree());
    519                            adaptor.addChild(root_1, stream_propertyChain.nextTree());
    520
    521                            adaptor.addChild(root_0, root_1);
    522                            }
    523
    524                        }
    525
    526                        retval.tree = root_0;}
    527                        }
    528                        break;
    529                    case 2 :
    530                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:63:4: term SAFEDEREF propertyChain
    531                        {
    532                        pushFollow(FOLLOW_term_in_propertyChain241);
    533                        term15=term();
    534
    535                        state._fsp--;
    536                        if (state.failed) return retval;
    537                        if ( state.backtracking==0 ) stream_term.add(term15.getTree());
    538                        SAFEDEREF16=(Token)match(input,SAFEDEREF,FOLLOW_SAFEDEREF_in_propertyChain243); if (state.failed) return retval;
    539                        if ( state.backtracking==0 ) stream_SAFEDEREF.add(SAFEDEREF16);
    540
    541                        pushFollow(FOLLOW_propertyChain_in_propertyChain245);
    542                        propertyChain17=propertyChain();
    543
    544                        state._fsp--;
    545                        if (state.failed) return retval;
    546                        if ( state.backtracking==0 ) stream_propertyChain.add(propertyChain17.getTree());
    547
    548
    549                        // AST REWRITE
    550                        // elements: SAFEDEREF, term, propertyChain
    551                        // token labels:
    552                        // rule labels: retval
    553                        // token list labels:
    554                        // rule list labels:
    555                        // wildcard labels:
    556                        if ( state.backtracking==0 ) {
    557                        retval.tree = root_0;
    558                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    559
    560                        root_0 = (CommonTree)adaptor.nil();
    561                        // 63:33: -> ^( SAFEDEREF term propertyChain )
    562                        {
    563                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:63:36: ^( SAFEDEREF term propertyChain )
    564                            {
    565                            CommonTree root_1 = (CommonTree)adaptor.nil();
    566                            root_1 = (CommonTree)adaptor.becomeRoot(stream_SAFEDEREF.nextNode(), root_1);
    567
    568                            adaptor.addChild(root_1, stream_term.nextTree());
    569                            adaptor.addChild(root_1, stream_propertyChain.nextTree());
    570
    571                            adaptor.addChild(root_0, root_1);
    572                            }
    573
    574                        }
    575
    576                        retval.tree = root_0;}
    577                        }
    578                        break;
    579                    case 3 :
    580                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:64:4: term
    581                        {
    582                        root_0 = (CommonTree)adaptor.nil();
    583
    584                        pushFollow(FOLLOW_term_in_propertyChain260);
    585                        term18=term();
    586
    587                        state._fsp--;
    588                        if (state.failed) return retval;
    589                        if ( state.backtracking==0 ) adaptor.addChild(root_0, term18.getTree());
    590
    591                        }
    592                        break;
    593
    594                }
    595                retval.stop = input.LT(-1);
    596
    597                if ( state.backtracking==0 ) {
    598
    599                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    600                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    601                }
    602            }
    603            catch (RecognitionException re) {
    604                reportError(re);
    605                recover(input,re);
    606            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    607
    608            }
    609            finally {
    610            }
    611            return retval;
    612        }
    613        // $ANTLR end "propertyChain"
    614
    615        public static class term_return extends ParserRuleReturnScope {
    616            CommonTree tree;
    617            public Object getTree() { return tree; }
    618        };
    619
    620        // $ANTLR start "term"
    621        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:67:1: term : ( IDENTIFIER | methodInvocation );
    622        public final PropertyExpressionParser.term_return term() throws RecognitionException {
    623            PropertyExpressionParser.term_return retval = new PropertyExpressionParser.term_return();
    624            retval.start = input.LT(1);
    625
    626            CommonTree root_0 = null;
    627
    628            Token IDENTIFIER19=null;
    629            PropertyExpressionParser.methodInvocation_return methodInvocation20 = null;
    630
    631
    632            CommonTree IDENTIFIER19_tree=null;
    633
    634            try {
    635                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:67:6: ( IDENTIFIER | methodInvocation )
    636                int alt3=2;
    637                int LA3_0 = input.LA(1);
    638
    639                if ( (LA3_0==IDENTIFIER) ) {
    640                    int LA3_1 = input.LA(2);
    641
    642                    if ( (LA3_1==LPAREN) ) {
    643                        alt3=2;
    644                    }
    645                    else if ( (LA3_1==EOF||(LA3_1>=DEREF && LA3_1<=RANGEOP)||LA3_1==RPAREN||(LA3_1>=RBRACKET && LA3_1<=COMMA)||(LA3_1>=RBRACE && LA3_1<=COLON)||LA3_1==SAFEDEREF) ) {
    646                        alt3=1;
    647                    }
    648                    else {
    649                        if (state.backtracking>0) {state.failed=true; return retval;}
    650                        NoViableAltException nvae =
    651                            new NoViableAltException("", 3, 1, input);
    652
    653                        throw nvae;
    654                    }
    655                }
    656                else {
    657                    if (state.backtracking>0) {state.failed=true; return retval;}
    658                    NoViableAltException nvae =
    659                        new NoViableAltException("", 3, 0, input);
    660
    661                    throw nvae;
    662                }
    663                switch (alt3) {
    664                    case 1 :
    665                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:67:8: IDENTIFIER
    666                        {
    667                        root_0 = (CommonTree)adaptor.nil();
    668
    669                        IDENTIFIER19=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_term272); if (state.failed) return retval;
    670                        if ( state.backtracking==0 ) {
    671                        IDENTIFIER19_tree = (CommonTree)adaptor.create(IDENTIFIER19);
    672                        adaptor.addChild(root_0, IDENTIFIER19_tree);
    673                        }
    674
    675                        }
    676                        break;
    677                    case 2 :
    678                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:68:4: methodInvocation
    679                        {
    680                        root_0 = (CommonTree)adaptor.nil();
    681
    682                        pushFollow(FOLLOW_methodInvocation_in_term277);
    683                        methodInvocation20=methodInvocation();
    684
    685                        state._fsp--;
    686                        if (state.failed) return retval;
    687                        if ( state.backtracking==0 ) adaptor.addChild(root_0, methodInvocation20.getTree());
    688
    689                        }
    690                        break;
    691
    692                }
    693                retval.stop = input.LT(-1);
    694
    695                if ( state.backtracking==0 ) {
    696
    697                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    698                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    699                }
    700            }
    701            catch (RecognitionException re) {
    702                reportError(re);
    703                recover(input,re);
    704            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    705
    706            }
    707            finally {
    708            }
    709            return retval;
    710        }
    711        // $ANTLR end "term"
    712
    713        public static class methodInvocation_return extends ParserRuleReturnScope {
    714            CommonTree tree;
    715            public Object getTree() { return tree; }
    716        };
    717
    718        // $ANTLR start "methodInvocation"
    719        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:71:1: methodInvocation : (id= IDENTIFIER LPAREN RPAREN -> ^( INVOKE $id) | id= IDENTIFIER LPAREN expressionList RPAREN -> ^( INVOKE $id expressionList ) );
    720        public final PropertyExpressionParser.methodInvocation_return methodInvocation() throws RecognitionException {
    721            PropertyExpressionParser.methodInvocation_return retval = new PropertyExpressionParser.methodInvocation_return();
    722            retval.start = input.LT(1);
    723
    724            CommonTree root_0 = null;
    725
    726            Token id=null;
    727            Token LPAREN21=null;
    728            Token RPAREN22=null;
    729            Token LPAREN23=null;
    730            Token RPAREN25=null;
    731            PropertyExpressionParser.expressionList_return expressionList24 = null;
    732
    733
    734            CommonTree id_tree=null;
    735            CommonTree LPAREN21_tree=null;
    736            CommonTree RPAREN22_tree=null;
    737            CommonTree LPAREN23_tree=null;
    738            CommonTree RPAREN25_tree=null;
    739            RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
    740            RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
    741            RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
    742            RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
    743            try {
    744                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:72:2: (id= IDENTIFIER LPAREN RPAREN -> ^( INVOKE $id) | id= IDENTIFIER LPAREN expressionList RPAREN -> ^( INVOKE $id expressionList ) )
    745                int alt4=2;
    746                int LA4_0 = input.LA(1);
    747
    748                if ( (LA4_0==IDENTIFIER) ) {
    749                    int LA4_1 = input.LA(2);
    750
    751                    if ( (LA4_1==LPAREN) ) {
    752                        int LA4_2 = input.LA(3);
    753
    754                        if ( (LA4_2==RPAREN) ) {
    755                            alt4=1;
    756                        }
    757                        else if ( (LA4_2==INTEGER||LA4_2==DECIMAL||LA4_2==LBRACKET||(LA4_2>=BANG && LA4_2<=LBRACE)||(LA4_2>=NULL && LA4_2<=THIS)||LA4_2==IDENTIFIER||LA4_2==STRING) ) {
    758                            alt4=2;
    759                        }
    760                        else {
    761                            if (state.backtracking>0) {state.failed=true; return retval;}
    762                            NoViableAltException nvae =
    763                                new NoViableAltException("", 4, 2, input);
    764
    765                            throw nvae;
    766                        }
    767                    }
    768                    else {
    769                        if (state.backtracking>0) {state.failed=true; return retval;}
    770                        NoViableAltException nvae =
    771                            new NoViableAltException("", 4, 1, input);
    772
    773                        throw nvae;
    774                    }
    775                }
    776                else {
    777                    if (state.backtracking>0) {state.failed=true; return retval;}
    778                    NoViableAltException nvae =
    779                        new NoViableAltException("", 4, 0, input);
    780
    781                    throw nvae;
    782                }
    783                switch (alt4) {
    784                    case 1 :
    785                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:72:4: id= IDENTIFIER LPAREN RPAREN
    786                        {
    787                        id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodInvocation291); if (state.failed) return retval;
    788                        if ( state.backtracking==0 ) stream_IDENTIFIER.add(id);
    789
    790                        LPAREN21=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_methodInvocation293); if (state.failed) return retval;
    791                        if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN21);
    792
    793                        RPAREN22=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_methodInvocation295); if (state.failed) return retval;
    794                        if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN22);
    795
    796
    797
    798                        // AST REWRITE
    799                        // elements: id
    800                        // token labels: id
    801                        // rule labels: retval
    802                        // token list labels:
    803                        // rule list labels:
    804                        // wildcard labels:
    805                        if ( state.backtracking==0 ) {
    806                        retval.tree = root_0;
    807                        RewriteRuleTokenStream stream_id=new RewriteRuleTokenStream(adaptor,"token id",id);
    808                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    809
    810                        root_0 = (CommonTree)adaptor.nil();
    811                        // 72:32: -> ^( INVOKE $id)
    812                        {
    813                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:72:35: ^( INVOKE $id)
    814                            {
    815                            CommonTree root_1 = (CommonTree)adaptor.nil();
    816                            root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INVOKE, "INVOKE"), root_1);
    817
    818                            adaptor.addChild(root_1, stream_id.nextNode());
    819
    820                            adaptor.addChild(root_0, root_1);
    821                            }
    822
    823                        }
    824
    825                        retval.tree = root_0;}
    826                        }
    827                        break;
    828                    case 2 :
    829                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:73:4: id= IDENTIFIER LPAREN expressionList RPAREN
    830                        {
    831                        id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodInvocation311); if (state.failed) return retval;
    832                        if ( state.backtracking==0 ) stream_IDENTIFIER.add(id);
    833
    834                        LPAREN23=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_methodInvocation313); if (state.failed) return retval;
    835                        if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN23);
    836
    837                        pushFollow(FOLLOW_expressionList_in_methodInvocation315);
    838                        expressionList24=expressionList();
    839
    840                        state._fsp--;
    841                        if (state.failed) return retval;
    842                        if ( state.backtracking==0 ) stream_expressionList.add(expressionList24.getTree());
    843                        RPAREN25=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_methodInvocation317); if (state.failed) return retval;
    844                        if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN25);
    845
    846
    847
    848                        // AST REWRITE
    849                        // elements: expressionList, id
    850                        // token labels: id
    851                        // rule labels: retval
    852                        // token list labels:
    853                        // rule list labels:
    854                        // wildcard labels:
    855                        if ( state.backtracking==0 ) {
    856                        retval.tree = root_0;
    857                        RewriteRuleTokenStream stream_id=new RewriteRuleTokenStream(adaptor,"token id",id);
    858                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    859
    860                        root_0 = (CommonTree)adaptor.nil();
    861                        // 73:47: -> ^( INVOKE $id expressionList )
    862                        {
    863                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:73:50: ^( INVOKE $id expressionList )
    864                            {
    865                            CommonTree root_1 = (CommonTree)adaptor.nil();
    866                            root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INVOKE, "INVOKE"), root_1);
    867
    868                            adaptor.addChild(root_1, stream_id.nextNode());
    869                            adaptor.addChild(root_1, stream_expressionList.nextTree());
    870
    871                            adaptor.addChild(root_0, root_1);
    872                            }
    873
    874                        }
    875
    876                        retval.tree = root_0;}
    877                        }
    878                        break;
    879
    880                }
    881                retval.stop = input.LT(-1);
    882
    883                if ( state.backtracking==0 ) {
    884
    885                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    886                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    887                }
    888            }
    889            catch (RecognitionException re) {
    890                reportError(re);
    891                recover(input,re);
    892            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    893
    894            }
    895            finally {
    896            }
    897            return retval;
    898        }
    899        // $ANTLR end "methodInvocation"
    900
    901        public static class expressionList_return extends ParserRuleReturnScope {
    902            CommonTree tree;
    903            public Object getTree() { return tree; }
    904        };
    905
    906        // $ANTLR start "expressionList"
    907        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:76:1: expressionList : expression ( COMMA expression )* ;
    908        public final PropertyExpressionParser.expressionList_return expressionList() throws RecognitionException {
    909            PropertyExpressionParser.expressionList_return retval = new PropertyExpressionParser.expressionList_return();
    910            retval.start = input.LT(1);
    911
    912            CommonTree root_0 = null;
    913
    914            Token COMMA27=null;
    915            PropertyExpressionParser.expression_return expression26 = null;
    916
    917            PropertyExpressionParser.expression_return expression28 = null;
    918
    919
    920            CommonTree COMMA27_tree=null;
    921
    922            try {
    923                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:77:2: ( expression ( COMMA expression )* )
    924                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:77:4: expression ( COMMA expression )*
    925                {
    926                root_0 = (CommonTree)adaptor.nil();
    927
    928                pushFollow(FOLLOW_expression_in_expressionList341);
    929                expression26=expression();
    930
    931                state._fsp--;
    932                if (state.failed) return retval;
    933                if ( state.backtracking==0 ) adaptor.addChild(root_0, expression26.getTree());
    934                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:77:15: ( COMMA expression )*
    935                loop5:
    936                do {
    937                    int alt5=2;
    938                    int LA5_0 = input.LA(1);
    939
    940                    if ( (LA5_0==COMMA) ) {
    941                        alt5=1;
    942                    }
    943
    944
    945                    switch (alt5) {
    946                    case 1 :
    947                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:77:16: COMMA expression
    948                        {
    949                        COMMA27=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList344); if (state.failed) return retval;
    950                        pushFollow(FOLLOW_expression_in_expressionList347);
    951                        expression28=expression();
    952
    953                        state._fsp--;
    954                        if (state.failed) return retval;
    955                        if ( state.backtracking==0 ) adaptor.addChild(root_0, expression28.getTree());
    956
    957                        }
    958                        break;
    959
    960                    default :
    961                        break loop5;
    962                    }
    963                } while (true);
    964
    965
    966                }
    967
    968                retval.stop = input.LT(-1);
    969
    970                if ( state.backtracking==0 ) {
    971
    972                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    973                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    974                }
    975            }
    976            catch (RecognitionException re) {
    977                reportError(re);
    978                recover(input,re);
    979            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    980
    981            }
    982            finally {
    983            }
    984            return retval;
    985        }
    986        // $ANTLR end "expressionList"
    987
    988        public static class rangeOp_return extends ParserRuleReturnScope {
    989            CommonTree tree;
    990            public Object getTree() { return tree; }
    991        };
    992
    993        // $ANTLR start "rangeOp"
    994        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:80:1: rangeOp : from= rangeopArg RANGEOP to= rangeopArg -> ^( RANGEOP $from $to) ;
    995        public final PropertyExpressionParser.rangeOp_return rangeOp() throws RecognitionException {
    996            PropertyExpressionParser.rangeOp_return retval = new PropertyExpressionParser.rangeOp_return();
    997            retval.start = input.LT(1);
    998
    999            CommonTree root_0 = null;
    1000
    1001            Token RANGEOP29=null;
    1002            PropertyExpressionParser.rangeopArg_return from = null;
    1003
    1004            PropertyExpressionParser.rangeopArg_return to = null;
    1005
    1006
    1007            CommonTree RANGEOP29_tree=null;
    1008            RewriteRuleTokenStream stream_RANGEOP=new RewriteRuleTokenStream(adaptor,"token RANGEOP");
    1009            RewriteRuleSubtreeStream stream_rangeopArg=new RewriteRuleSubtreeStream(adaptor,"rule rangeopArg");
    1010            try {
    1011                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:81:2: (from= rangeopArg RANGEOP to= rangeopArg -> ^( RANGEOP $from $to) )
    1012                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:81:4: from= rangeopArg RANGEOP to= rangeopArg
    1013                {
    1014                pushFollow(FOLLOW_rangeopArg_in_rangeOp363);
    1015                from=rangeopArg();
    1016
    1017                state._fsp--;
    1018                if (state.failed) return retval;
    1019                if ( state.backtracking==0 ) stream_rangeopArg.add(from.getTree());
    1020                RANGEOP29=(Token)match(input,RANGEOP,FOLLOW_RANGEOP_in_rangeOp366); if (state.failed) return retval;
    1021                if ( state.backtracking==0 ) stream_RANGEOP.add(RANGEOP29);
    1022
    1023                pushFollow(FOLLOW_rangeopArg_in_rangeOp370);
    1024                to=rangeopArg();
    1025
    1026                state._fsp--;
    1027                if (state.failed) return retval;
    1028                if ( state.backtracking==0 ) stream_rangeopArg.add(to.getTree());
    1029
    1030
    1031                // AST REWRITE
    1032                // elements: from, RANGEOP, to
    1033                // token labels:
    1034                // rule labels: to, from, retval
    1035                // token list labels:
    1036                // rule list labels:
    1037                // wildcard labels:
    1038                if ( state.backtracking==0 ) {
    1039                retval.tree = root_0;
    1040                RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
    1041                RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
    1042                RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    1043
    1044                root_0 = (CommonTree)adaptor.nil();
    1045                // 81:43: -> ^( RANGEOP $from $to)
    1046                {
    1047                    // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:81:46: ^( RANGEOP $from $to)
    1048                    {
    1049                    CommonTree root_1 = (CommonTree)adaptor.nil();
    1050                    root_1 = (CommonTree)adaptor.becomeRoot(stream_RANGEOP.nextNode(), root_1);
    1051
    1052                    adaptor.addChild(root_1, stream_from.nextTree());
    1053                    adaptor.addChild(root_1, stream_to.nextTree());
    1054
    1055                    adaptor.addChild(root_0, root_1);
    1056                    }
    1057
    1058                }
    1059
    1060                retval.tree = root_0;}
    1061                }
    1062
    1063                retval.stop = input.LT(-1);
    1064
    1065                if ( state.backtracking==0 ) {
    1066
    1067                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1068                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1069                }
    1070            }
    1071            catch (RecognitionException re) {
    1072                reportError(re);
    1073                recover(input,re);
    1074            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1075
    1076            }
    1077            finally {
    1078            }
    1079            return retval;
    1080        }
    1081        // $ANTLR end "rangeOp"
    1082
    1083        public static class rangeopArg_return extends ParserRuleReturnScope {
    1084            CommonTree tree;
    1085            public Object getTree() { return tree; }
    1086        };
    1087
    1088        // $ANTLR start "rangeopArg"
    1089        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:84:1: rangeopArg : ( INTEGER | propertyChain );
    1090        public final PropertyExpressionParser.rangeopArg_return rangeopArg() throws RecognitionException {
    1091            PropertyExpressionParser.rangeopArg_return retval = new PropertyExpressionParser.rangeopArg_return();
    1092            retval.start = input.LT(1);
    1093
    1094            CommonTree root_0 = null;
    1095
    1096            Token INTEGER30=null;
    1097            PropertyExpressionParser.propertyChain_return propertyChain31 = null;
    1098
    1099
    1100            CommonTree INTEGER30_tree=null;
    1101
    1102            try {
    1103                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:85:2: ( INTEGER | propertyChain )
    1104                int alt6=2;
    1105                int LA6_0 = input.LA(1);
    1106
    1107                if ( (LA6_0==INTEGER) ) {
    1108                    alt6=1;
    1109                }
    1110                else if ( (LA6_0==IDENTIFIER) ) {
    1111                    alt6=2;
    1112                }
    1113                else {
    1114                    if (state.backtracking>0) {state.failed=true; return retval;}
    1115                    NoViableAltException nvae =
    1116                        new NoViableAltException("", 6, 0, input);
    1117
    1118                    throw nvae;
    1119                }
    1120                switch (alt6) {
    1121                    case 1 :
    1122                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:85:4: INTEGER
    1123                        {
    1124                        root_0 = (CommonTree)adaptor.nil();
    1125
    1126                        INTEGER30=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_rangeopArg396); if (state.failed) return retval;
    1127                        if ( state.backtracking==0 ) {
    1128                        INTEGER30_tree = (CommonTree)adaptor.create(INTEGER30);
    1129                        adaptor.addChild(root_0, INTEGER30_tree);
    1130                        }
    1131
    1132                        }
    1133                        break;
    1134                    case 2 :
    1135                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:86:4: propertyChain
    1136                        {
    1137                        root_0 = (CommonTree)adaptor.nil();
    1138
    1139                        pushFollow(FOLLOW_propertyChain_in_rangeopArg401);
    1140                        propertyChain31=propertyChain();
    1141
    1142                        state._fsp--;
    1143                        if (state.failed) return retval;
    1144                        if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyChain31.getTree());
    1145
    1146                        }
    1147                        break;
    1148
    1149                }
    1150                retval.stop = input.LT(-1);
    1151
    1152                if ( state.backtracking==0 ) {
    1153
    1154                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1155                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1156                }
    1157            }
    1158            catch (RecognitionException re) {
    1159                reportError(re);
    1160                recover(input,re);
    1161            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1162
    1163            }
    1164            finally {
    1165            }
    1166            return retval;
    1167        }
    1168        // $ANTLR end "rangeopArg"
    1169
    1170        public static class list_return extends ParserRuleReturnScope {
    1171            CommonTree tree;
    1172            public Object getTree() { return tree; }
    1173        };
    1174
    1175        // $ANTLR start "list"
    1176        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:89:1: list : ( LBRACKET RBRACKET -> ^( LIST ) | LBRACKET expressionList RBRACKET -> ^( LIST expressionList ) );
    1177        public final PropertyExpressionParser.list_return list() throws RecognitionException {
    1178            PropertyExpressionParser.list_return retval = new PropertyExpressionParser.list_return();
    1179            retval.start = input.LT(1);
    1180
    1181            CommonTree root_0 = null;
    1182
    1183            Token LBRACKET32=null;
    1184            Token RBRACKET33=null;
    1185            Token LBRACKET34=null;
    1186            Token RBRACKET36=null;
    1187            PropertyExpressionParser.expressionList_return expressionList35 = null;
    1188
    1189
    1190            CommonTree LBRACKET32_tree=null;
    1191            CommonTree RBRACKET33_tree=null;
    1192            CommonTree LBRACKET34_tree=null;
    1193            CommonTree RBRACKET36_tree=null;
    1194            RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
    1195            RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
    1196            RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
    1197            try {
    1198                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:89:6: ( LBRACKET RBRACKET -> ^( LIST ) | LBRACKET expressionList RBRACKET -> ^( LIST expressionList ) )
    1199                int alt7=2;
    1200                int LA7_0 = input.LA(1);
    1201
    1202                if ( (LA7_0==LBRACKET) ) {
    1203                    int LA7_1 = input.LA(2);
    1204
    1205                    if ( (LA7_1==RBRACKET) ) {
    1206                        alt7=1;
    1207                    }
    1208                    else if ( (LA7_1==INTEGER||LA7_1==DECIMAL||LA7_1==LBRACKET||(LA7_1>=BANG && LA7_1<=LBRACE)||(LA7_1>=NULL && LA7_1<=THIS)||LA7_1==IDENTIFIER||LA7_1==STRING) ) {
    1209                        alt7=2;
    1210                    }
    1211                    else {
    1212                        if (state.backtracking>0) {state.failed=true; return retval;}
    1213                        NoViableAltException nvae =
    1214                            new NoViableAltException("", 7, 1, input);
    1215
    1216                        throw nvae;
    1217                    }
    1218                }
    1219                else {
    1220                    if (state.backtracking>0) {state.failed=true; return retval;}
    1221                    NoViableAltException nvae =
    1222                        new NoViableAltException("", 7, 0, input);
    1223
    1224                    throw nvae;
    1225                }
    1226                switch (alt7) {
    1227                    case 1 :
    1228                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:89:8: LBRACKET RBRACKET
    1229                        {
    1230                        LBRACKET32=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_list413); if (state.failed) return retval;
    1231                        if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET32);
    1232
    1233                        RBRACKET33=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_list415); if (state.failed) return retval;
    1234                        if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET33);
    1235
    1236
    1237
    1238                        // AST REWRITE
    1239                        // elements:
    1240                        // token labels:
    1241                        // rule labels: retval
    1242                        // token list labels:
    1243                        // rule list labels:
    1244                        // wildcard labels:
    1245                        if ( state.backtracking==0 ) {
    1246                        retval.tree = root_0;
    1247                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    1248
    1249                        root_0 = (CommonTree)adaptor.nil();
    1250                        // 89:26: -> ^( LIST )
    1251                        {
    1252                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:89:29: ^( LIST )
    1253                            {
    1254                            CommonTree root_1 = (CommonTree)adaptor.nil();
    1255                            root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LIST, "LIST"), root_1);
    1256
    1257                            adaptor.addChild(root_0, root_1);
    1258                            }
    1259
    1260                        }
    1261
    1262                        retval.tree = root_0;}
    1263                        }
    1264                        break;
    1265                    case 2 :
    1266                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:90:4: LBRACKET expressionList RBRACKET
    1267                        {
    1268                        LBRACKET34=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_list426); if (state.failed) return retval;
    1269                        if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET34);
    1270
    1271                        pushFollow(FOLLOW_expressionList_in_list428);
    1272                        expressionList35=expressionList();
    1273
    1274                        state._fsp--;
    1275                        if (state.failed) return retval;
    1276                        if ( state.backtracking==0 ) stream_expressionList.add(expressionList35.getTree());
    1277                        RBRACKET36=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_list430); if (state.failed) return retval;
    1278                        if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET36);
    1279
    1280
    1281
    1282                        // AST REWRITE
    1283                        // elements: expressionList
    1284                        // token labels:
    1285                        // rule labels: retval
    1286                        // token list labels:
    1287                        // rule list labels:
    1288                        // wildcard labels:
    1289                        if ( state.backtracking==0 ) {
    1290                        retval.tree = root_0;
    1291                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    1292
    1293                        root_0 = (CommonTree)adaptor.nil();
    1294                        // 90:37: -> ^( LIST expressionList )
    1295                        {
    1296                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:90:40: ^( LIST expressionList )
    1297                            {
    1298                            CommonTree root_1 = (CommonTree)adaptor.nil();
    1299                            root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LIST, "LIST"), root_1);
    1300
    1301                            adaptor.addChild(root_1, stream_expressionList.nextTree());
    1302
    1303                            adaptor.addChild(root_0, root_1);
    1304                            }
    1305
    1306                        }
    1307
    1308                        retval.tree = root_0;}
    1309                        }
    1310                        break;
    1311
    1312                }
    1313                retval.stop = input.LT(-1);
    1314
    1315                if ( state.backtracking==0 ) {
    1316
    1317                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1318                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1319                }
    1320            }
    1321            catch (RecognitionException re) {
    1322                reportError(re);
    1323                recover(input,re);
    1324            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1325
    1326            }
    1327            finally {
    1328            }
    1329            return retval;
    1330        }
    1331        // $ANTLR end "list"
    1332
    1333        public static class notOp_return extends ParserRuleReturnScope {
    1334            CommonTree tree;
    1335            public Object getTree() { return tree; }
    1336        };
    1337
    1338        // $ANTLR start "notOp"
    1339        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:93:1: notOp : BANG expression -> ^( NOT expression ) ;
    1340        public final PropertyExpressionParser.notOp_return notOp() throws RecognitionException {
    1341            PropertyExpressionParser.notOp_return retval = new PropertyExpressionParser.notOp_return();
    1342            retval.start = input.LT(1);
    1343
    1344            CommonTree root_0 = null;
    1345
    1346            Token BANG37=null;
    1347            PropertyExpressionParser.expression_return expression38 = null;
    1348
    1349
    1350            CommonTree BANG37_tree=null;
    1351            RewriteRuleTokenStream stream_BANG=new RewriteRuleTokenStream(adaptor,"token BANG");
    1352            RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
    1353            try {
    1354                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:93:8: ( BANG expression -> ^( NOT expression ) )
    1355                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:93:10: BANG expression
    1356                {
    1357                BANG37=(Token)match(input,BANG,FOLLOW_BANG_in_notOp451); if (state.failed) return retval;
    1358                if ( state.backtracking==0 ) stream_BANG.add(BANG37);
    1359
    1360                pushFollow(FOLLOW_expression_in_notOp453);
    1361                expression38=expression();
    1362
    1363                state._fsp--;
    1364                if (state.failed) return retval;
    1365                if ( state.backtracking==0 ) stream_expression.add(expression38.getTree());
    1366
    1367
    1368                // AST REWRITE
    1369                // elements: expression
    1370                // token labels:
    1371                // rule labels: retval
    1372                // token list labels:
    1373                // rule list labels:
    1374                // wildcard labels:
    1375                if ( state.backtracking==0 ) {
    1376                retval.tree = root_0;
    1377                RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    1378
    1379                root_0 = (CommonTree)adaptor.nil();
    1380                // 93:26: -> ^( NOT expression )
    1381                {
    1382                    // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:93:29: ^( NOT expression )
    1383                    {
    1384                    CommonTree root_1 = (CommonTree)adaptor.nil();
    1385                    root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(NOT, "NOT"), root_1);
    1386
    1387                    adaptor.addChild(root_1, stream_expression.nextTree());
    1388
    1389                    adaptor.addChild(root_0, root_1);
    1390                    }
    1391
    1392                }
    1393
    1394                retval.tree = root_0;}
    1395                }
    1396
    1397                retval.stop = input.LT(-1);
    1398
    1399                if ( state.backtracking==0 ) {
    1400
    1401                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1402                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1403                }
    1404            }
    1405            catch (RecognitionException re) {
    1406                reportError(re);
    1407                recover(input,re);
    1408            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1409
    1410            }
    1411            finally {
    1412            }
    1413            return retval;
    1414        }
    1415        // $ANTLR end "notOp"
    1416
    1417        public static class map_return extends ParserRuleReturnScope {
    1418            CommonTree tree;
    1419            public Object getTree() { return tree; }
    1420        };
    1421
    1422        // $ANTLR start "map"
    1423        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:96:1: map : ( LBRACE RBRACE -> ^( MAP ) | LBRACE mapEntryList RBRACE -> ^( MAP mapEntryList ) );
    1424        public final PropertyExpressionParser.map_return map() throws RecognitionException {
    1425            PropertyExpressionParser.map_return retval = new PropertyExpressionParser.map_return();
    1426            retval.start = input.LT(1);
    1427
    1428            CommonTree root_0 = null;
    1429
    1430            Token LBRACE39=null;
    1431            Token RBRACE40=null;
    1432            Token LBRACE41=null;
    1433            Token RBRACE43=null;
    1434            PropertyExpressionParser.mapEntryList_return mapEntryList42 = null;
    1435
    1436
    1437            CommonTree LBRACE39_tree=null;
    1438            CommonTree RBRACE40_tree=null;
    1439            CommonTree LBRACE41_tree=null;
    1440            CommonTree RBRACE43_tree=null;
    1441            RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
    1442            RewriteRuleTokenStream stream_LBRACE=new RewriteRuleTokenStream(adaptor,"token LBRACE");
    1443            RewriteRuleSubtreeStream stream_mapEntryList=new RewriteRuleSubtreeStream(adaptor,"rule mapEntryList");
    1444            try {
    1445                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:96:6: ( LBRACE RBRACE -> ^( MAP ) | LBRACE mapEntryList RBRACE -> ^( MAP mapEntryList ) )
    1446                int alt8=2;
    1447                int LA8_0 = input.LA(1);
    1448
    1449                if ( (LA8_0==LBRACE) ) {
    1450                    int LA8_1 = input.LA(2);
    1451
    1452                    if ( (LA8_1==RBRACE) ) {
    1453                        alt8=1;
    1454                    }
    1455                    else if ( (LA8_1==INTEGER||LA8_1==DECIMAL||(LA8_1>=NULL && LA8_1<=THIS)||LA8_1==IDENTIFIER||LA8_1==STRING) ) {
    1456                        alt8=2;
    1457                    }
    1458                    else {
    1459                        if (state.backtracking>0) {state.failed=true; return retval;}
    1460                        NoViableAltException nvae =
    1461                            new NoViableAltException("", 8, 1, input);
    1462
    1463                        throw nvae;
    1464                    }
    1465                }
    1466                else {
    1467                    if (state.backtracking>0) {state.failed=true; return retval;}
    1468                    NoViableAltException nvae =
    1469                        new NoViableAltException("", 8, 0, input);
    1470
    1471                    throw nvae;
    1472                }
    1473                switch (alt8) {
    1474                    case 1 :
    1475                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:96:8: LBRACE RBRACE
    1476                        {
    1477                        LBRACE39=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_map472); if (state.failed) return retval;
    1478                        if ( state.backtracking==0 ) stream_LBRACE.add(LBRACE39);
    1479
    1480                        RBRACE40=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_map474); if (state.failed) return retval;
    1481                        if ( state.backtracking==0 ) stream_RBRACE.add(RBRACE40);
    1482
    1483
    1484
    1485                        // AST REWRITE
    1486                        // elements:
    1487                        // token labels:
    1488                        // rule labels: retval
    1489                        // token list labels:
    1490                        // rule list labels:
    1491                        // wildcard labels:
    1492                        if ( state.backtracking==0 ) {
    1493                        retval.tree = root_0;
    1494                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    1495
    1496                        root_0 = (CommonTree)adaptor.nil();
    1497                        // 96:22: -> ^( MAP )
    1498                        {
    1499                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:96:25: ^( MAP )
    1500                            {
    1501                            CommonTree root_1 = (CommonTree)adaptor.nil();
    1502                            root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(MAP, "MAP"), root_1);
    1503
    1504                            adaptor.addChild(root_0, root_1);
    1505                            }
    1506
    1507                        }
    1508
    1509                        retval.tree = root_0;}
    1510                        }
    1511                        break;
    1512                    case 2 :
    1513                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:97:4: LBRACE mapEntryList RBRACE
    1514                        {
    1515                        LBRACE41=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_map485); if (state.failed) return retval;
    1516                        if ( state.backtracking==0 ) stream_LBRACE.add(LBRACE41);
    1517
    1518                        pushFollow(FOLLOW_mapEntryList_in_map487);
    1519                        mapEntryList42=mapEntryList();
    1520
    1521                        state._fsp--;
    1522                        if (state.failed) return retval;
    1523                        if ( state.backtracking==0 ) stream_mapEntryList.add(mapEntryList42.getTree());
    1524                        RBRACE43=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_map489); if (state.failed) return retval;
    1525                        if ( state.backtracking==0 ) stream_RBRACE.add(RBRACE43);
    1526
    1527
    1528
    1529                        // AST REWRITE
    1530                        // elements: mapEntryList
    1531                        // token labels:
    1532                        // rule labels: retval
    1533                        // token list labels:
    1534                        // rule list labels:
    1535                        // wildcard labels:
    1536                        if ( state.backtracking==0 ) {
    1537                        retval.tree = root_0;
    1538                        RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    1539
    1540                        root_0 = (CommonTree)adaptor.nil();
    1541                        // 97:31: -> ^( MAP mapEntryList )
    1542                        {
    1543                            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:97:34: ^( MAP mapEntryList )
    1544                            {
    1545                            CommonTree root_1 = (CommonTree)adaptor.nil();
    1546                            root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(MAP, "MAP"), root_1);
    1547
    1548                            adaptor.addChild(root_1, stream_mapEntryList.nextTree());
    1549
    1550                            adaptor.addChild(root_0, root_1);
    1551                            }
    1552
    1553                        }
    1554
    1555                        retval.tree = root_0;}
    1556                        }
    1557                        break;
    1558
    1559                }
    1560                retval.stop = input.LT(-1);
    1561
    1562                if ( state.backtracking==0 ) {
    1563
    1564                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1565                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1566                }
    1567            }
    1568            catch (RecognitionException re) {
    1569                reportError(re);
    1570                recover(input,re);
    1571            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1572
    1573            }
    1574            finally {
    1575            }
    1576            return retval;
    1577        }
    1578        // $ANTLR end "map"
    1579
    1580        public static class mapEntryList_return extends ParserRuleReturnScope {
    1581            CommonTree tree;
    1582            public Object getTree() { return tree; }
    1583        };
    1584
    1585        // $ANTLR start "mapEntryList"
    1586        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:100:1: mapEntryList : mapEntry ( COMMA mapEntry )* ;
    1587        public final PropertyExpressionParser.mapEntryList_return mapEntryList() throws RecognitionException {
    1588            PropertyExpressionParser.mapEntryList_return retval = new PropertyExpressionParser.mapEntryList_return();
    1589            retval.start = input.LT(1);
    1590
    1591            CommonTree root_0 = null;
    1592
    1593            Token COMMA45=null;
    1594            PropertyExpressionParser.mapEntry_return mapEntry44 = null;
    1595
    1596            PropertyExpressionParser.mapEntry_return mapEntry46 = null;
    1597
    1598
    1599            CommonTree COMMA45_tree=null;
    1600
    1601            try {
    1602                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:100:14: ( mapEntry ( COMMA mapEntry )* )
    1603                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:100:16: mapEntry ( COMMA mapEntry )*
    1604                {
    1605                root_0 = (CommonTree)adaptor.nil();
    1606
    1607                pushFollow(FOLLOW_mapEntry_in_mapEntryList511);
    1608                mapEntry44=mapEntry();
    1609
    1610                state._fsp--;
    1611                if (state.failed) return retval;
    1612                if ( state.backtracking==0 ) adaptor.addChild(root_0, mapEntry44.getTree());
    1613                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:100:25: ( COMMA mapEntry )*
    1614                loop9:
    1615                do {
    1616                    int alt9=2;
    1617                    int LA9_0 = input.LA(1);
    1618
    1619                    if ( (LA9_0==COMMA) ) {
    1620                        alt9=1;
    1621                    }
    1622
    1623
    1624                    switch (alt9) {
    1625                    case 1 :
    1626                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:100:26: COMMA mapEntry
    1627                        {
    1628                        COMMA45=(Token)match(input,COMMA,FOLLOW_COMMA_in_mapEntryList514); if (state.failed) return retval;
    1629                        pushFollow(FOLLOW_mapEntry_in_mapEntryList517);
    1630                        mapEntry46=mapEntry();
    1631
    1632                        state._fsp--;
    1633                        if (state.failed) return retval;
    1634                        if ( state.backtracking==0 ) adaptor.addChild(root_0, mapEntry46.getTree());
    1635
    1636                        }
    1637                        break;
    1638
    1639                    default :
    1640                        break loop9;
    1641                    }
    1642                } while (true);
    1643
    1644
    1645                }
    1646
    1647                retval.stop = input.LT(-1);
    1648
    1649                if ( state.backtracking==0 ) {
    1650
    1651                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1652                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1653                }
    1654            }
    1655            catch (RecognitionException re) {
    1656                reportError(re);
    1657                recover(input,re);
    1658            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1659
    1660            }
    1661            finally {
    1662            }
    1663            return retval;
    1664        }
    1665        // $ANTLR end "mapEntryList"
    1666
    1667        public static class mapEntry_return extends ParserRuleReturnScope {
    1668            CommonTree tree;
    1669            public Object getTree() { return tree; }
    1670        };
    1671
    1672        // $ANTLR start "mapEntry"
    1673        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:102:1: mapEntry : mapKey COLON expression ;
    1674        public final PropertyExpressionParser.mapEntry_return mapEntry() throws RecognitionException {
    1675            PropertyExpressionParser.mapEntry_return retval = new PropertyExpressionParser.mapEntry_return();
    1676            retval.start = input.LT(1);
    1677
    1678            CommonTree root_0 = null;
    1679
    1680            Token COLON48=null;
    1681            PropertyExpressionParser.mapKey_return mapKey47 = null;
    1682
    1683            PropertyExpressionParser.expression_return expression49 = null;
    1684
    1685
    1686            CommonTree COLON48_tree=null;
    1687
    1688            try {
    1689                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:102:10: ( mapKey COLON expression )
    1690                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:102:13: mapKey COLON expression
    1691                {
    1692                root_0 = (CommonTree)adaptor.nil();
    1693
    1694                pushFollow(FOLLOW_mapKey_in_mapEntry528);
    1695                mapKey47=mapKey();
    1696
    1697                state._fsp--;
    1698                if (state.failed) return retval;
    1699                if ( state.backtracking==0 ) adaptor.addChild(root_0, mapKey47.getTree());
    1700                COLON48=(Token)match(input,COLON,FOLLOW_COLON_in_mapEntry530); if (state.failed) return retval;
    1701                pushFollow(FOLLOW_expression_in_mapEntry533);
    1702                expression49=expression();
    1703
    1704                state._fsp--;
    1705                if (state.failed) return retval;
    1706                if ( state.backtracking==0 ) adaptor.addChild(root_0, expression49.getTree());
    1707
    1708                }
    1709
    1710                retval.stop = input.LT(-1);
    1711
    1712                if ( state.backtracking==0 ) {
    1713
    1714                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1715                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1716                }
    1717            }
    1718            catch (RecognitionException re) {
    1719                reportError(re);
    1720                recover(input,re);
    1721            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1722
    1723            }
    1724            finally {
    1725            }
    1726            return retval;
    1727        }
    1728        // $ANTLR end "mapEntry"
    1729
    1730        public static class mapKey_return extends ParserRuleReturnScope {
    1731            CommonTree tree;
    1732            public Object getTree() { return tree; }
    1733        };
    1734
    1735        // $ANTLR start "mapKey"
    1736        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:104:1: mapKey : ( keyword | constant | propertyChain );
    1737        public final PropertyExpressionParser.mapKey_return mapKey() throws RecognitionException {
    1738            PropertyExpressionParser.mapKey_return retval = new PropertyExpressionParser.mapKey_return();
    1739            retval.start = input.LT(1);
    1740
    1741            CommonTree root_0 = null;
    1742
    1743            PropertyExpressionParser.keyword_return keyword50 = null;
    1744
    1745            PropertyExpressionParser.constant_return constant51 = null;
    1746
    1747            PropertyExpressionParser.propertyChain_return propertyChain52 = null;
    1748
    1749
    1750
    1751            try {
    1752                // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:104:8: ( keyword | constant | propertyChain )
    1753                int alt10=3;
    1754                switch ( input.LA(1) ) {
    1755                case NULL:
    1756                case TRUE:
    1757                case FALSE:
    1758                case THIS:
    1759                    {
    1760                    alt10=1;
    1761                    }
    1762                    break;
    1763                case INTEGER:
    1764                case DECIMAL:
    1765                case STRING:
    1766                    {
    1767                    alt10=2;
    1768                    }
    1769                    break;
    1770                case IDENTIFIER:
    1771                    {
    1772                    alt10=3;
    1773                    }
    1774                    break;
    1775                default:
    1776                    if (state.backtracking>0) {state.failed=true; return retval;}
    1777                    NoViableAltException nvae =
    1778                        new NoViableAltException("", 10, 0, input);
    1779
    1780                    throw nvae;
    1781                }
    1782
    1783                switch (alt10) {
    1784                    case 1 :
    1785                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:104:10: keyword
    1786                        {
    1787                        root_0 = (CommonTree)adaptor.nil();
    1788
    1789                        pushFollow(FOLLOW_keyword_in_mapKey542);
    1790                        keyword50=keyword();
    1791
    1792                        state._fsp--;
    1793                        if (state.failed) return retval;
    1794                        if ( state.backtracking==0 ) adaptor.addChild(root_0, keyword50.getTree());
    1795
    1796                        }
    1797                        break;
    1798                    case 2 :
    1799                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:104:20: constant
    1800                        {
    1801                        root_0 = (CommonTree)adaptor.nil();
    1802
    1803                        pushFollow(FOLLOW_constant_in_mapKey546);
    1804                        constant51=constant();
    1805
    1806                        state._fsp--;
    1807                        if (state.failed) return retval;
    1808                        if ( state.backtracking==0 ) adaptor.addChild(root_0, constant51.getTree());
    1809
    1810                        }
    1811                        break;
    1812                    case 3 :
    1813                        // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:104:31: propertyChain
    1814                        {
    1815                        root_0 = (CommonTree)adaptor.nil();
    1816
    1817                        pushFollow(FOLLOW_propertyChain_in_mapKey550);
    1818                        propertyChain52=propertyChain();
    1819
    1820                        state._fsp--;
    1821                        if (state.failed) return retval;
    1822                        if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyChain52.getTree());
    1823
    1824                        }
    1825                        break;
    1826
    1827                }
    1828                retval.stop = input.LT(-1);
    1829
    1830                if ( state.backtracking==0 ) {
    1831
    1832                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
    1833                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    1834                }
    1835            }
    1836            catch (RecognitionException re) {
    1837                reportError(re);
    1838                recover(input,re);
    1839            retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    1840
    1841            }
    1842            finally {
    1843            }
    1844            return retval;
    1845        }
    1846        // $ANTLR end "mapKey"
    1847
    1848        // $ANTLR start synpred2_PropertyExpressionParser
    1849        public final void synpred2_PropertyExpressionParser_fragment() throws RecognitionException {
    1850            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:49:4: ( rangeOp )
    1851            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:49:4: rangeOp
    1852            {
    1853            pushFollow(FOLLOW_rangeOp_in_synpred2_PropertyExpressionParser150);
    1854            rangeOp();
    1855
    1856            state._fsp--;
    1857            if (state.failed) return ;
    1858
    1859            }
    1860        }
    1861        // $ANTLR end synpred2_PropertyExpressionParser
    1862
    1863        // $ANTLR start synpred3_PropertyExpressionParser
    1864        public final void synpred3_PropertyExpressionParser_fragment() throws RecognitionException {
    1865            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:50:4: ( constant )
    1866            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:50:4: constant
    1867            {
    1868            pushFollow(FOLLOW_constant_in_synpred3_PropertyExpressionParser155);
    1869            constant();
    1870
    1871            state._fsp--;
    1872            if (state.failed) return ;
    1873
    1874            }
    1875        }
    1876        // $ANTLR end synpred3_PropertyExpressionParser
    1877
    1878        // $ANTLR start synpred4_PropertyExpressionParser
    1879        public final void synpred4_PropertyExpressionParser_fragment() throws RecognitionException {
    1880            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:51:4: ( propertyChain )
    1881            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:51:4: propertyChain
    1882            {
    1883            pushFollow(FOLLOW_propertyChain_in_synpred4_PropertyExpressionParser160);
    1884            propertyChain();
    1885
    1886            state._fsp--;
    1887            if (state.failed) return ;
    1888
    1889            }
    1890        }
    1891        // $ANTLR end synpred4_PropertyExpressionParser
    1892
    1893        // $ANTLR start synpred12_PropertyExpressionParser
    1894        public final void synpred12_PropertyExpressionParser_fragment() throws RecognitionException {
    1895            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:62:4: ( term DEREF propertyChain )
    1896            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:62:4: term DEREF propertyChain
    1897            {
    1898            pushFollow(FOLLOW_term_in_synpred12_PropertyExpressionParser222);
    1899            term();
    1900
    1901            state._fsp--;
    1902            if (state.failed) return ;
    1903            match(input,DEREF,FOLLOW_DEREF_in_synpred12_PropertyExpressionParser224); if (state.failed) return ;
    1904            pushFollow(FOLLOW_propertyChain_in_synpred12_PropertyExpressionParser226);
    1905            propertyChain();
    1906
    1907            state._fsp--;
    1908            if (state.failed) return ;
    1909
    1910            }
    1911        }
    1912        // $ANTLR end synpred12_PropertyExpressionParser
    1913
    1914        // $ANTLR start synpred13_PropertyExpressionParser
    1915        public final void synpred13_PropertyExpressionParser_fragment() throws RecognitionException {
    1916            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:63:4: ( term SAFEDEREF propertyChain )
    1917            // C:\\Users\\kaosko\\Documents\\personal\\git-tapestry5\\tapestry-core\\src\\main\\antlr\\org\\apache\\tapestry5\\internal\\antlr\\PropertyExpressionParser.g:63:4: term SAFEDEREF propertyChain
    1918            {
    1919            pushFollow(FOLLOW_term_in_synpred13_PropertyExpressionParser241);
    1920            term();
    1921
    1922            state._fsp--;
    1923            if (state.failed) return ;
    1924            match(input,SAFEDEREF,FOLLOW_SAFEDEREF_in_synpred13_PropertyExpressionParser243); if (state.failed) return ;
    1925            pushFollow(FOLLOW_propertyChain_in_synpred13_PropertyExpressionParser245);
    1926            propertyChain();
    1927
    1928            state._fsp--;
    1929            if (state.failed) return ;
    1930
    1931            }
    1932        }
    1933        // $ANTLR end synpred13_PropertyExpressionParser
    1934
    1935        // Delegated rules
    1936
    1937        public final boolean synpred4_PropertyExpressionParser() {
    1938            state.backtracking++;
    1939            int start = input.mark();
    1940            try {
    1941                synpred4_PropertyExpressionParser_fragment(); // can never throw exception
    1942            } catch (RecognitionException re) {
    1943                System.err.println("impossible: "+re);
    1944            }
    1945            boolean success = !state.failed;
    1946            input.rewind(start);
    1947            state.backtracking--;
    1948            state.failed=false;
    1949            return success;
    1950        }
    1951        public final boolean synpred12_PropertyExpressionParser() {
    1952            state.backtracking++;
    1953            int start = input.mark();
    1954            try {
    1955                synpred12_PropertyExpressionParser_fragment(); // can never throw exception
    1956            } catch (RecognitionException re) {
    1957                System.err.println("impossible: "+re);
    1958            }
    1959            boolean success = !state.failed;
    1960            input.rewind(start);
    1961            state.backtracking--;
    1962            state.failed=false;
    1963            return success;
    1964        }
    1965        public final boolean synpred3_PropertyExpressionParser() {
    1966            state.backtracking++;
    1967            int start = input.mark();
    1968            try {
    1969                synpred3_PropertyExpressionParser_fragment(); // can never throw exception
    1970            } catch (RecognitionException re) {
    1971                System.err.println("impossible: "+re);
    1972            }
    1973            boolean success = !state.failed;
    1974            input.rewind(start);
    1975            state.backtracking--;
    1976            state.failed=false;
    1977            return success;
    1978        }
    1979        public final boolean synpred2_PropertyExpressionParser() {
    1980            state.backtracking++;
    1981            int start = input.mark();
    1982            try {
    1983                synpred2_PropertyExpressionParser_fragment(); // can never throw exception
    1984            } catch (RecognitionException re) {
    1985                System.err.println("impossible: "+re);
    1986            }
    1987            boolean success = !state.failed;
    1988            input.rewind(start);
    1989            state.backtracking--;
    1990            state.failed=false;
    1991            return success;
    1992        }
    1993        public final boolean synpred13_PropertyExpressionParser() {
    1994            state.backtracking++;
    1995            int start = input.mark();
    1996            try {
    1997                synpred13_PropertyExpressionParser_fragment(); // can never throw exception
    1998            } catch (RecognitionException re) {
    1999                System.err.println("impossible: "+re);
    2000            }
    2001            boolean success = !state.failed;
    2002            input.rewind(start);
    2003            state.backtracking--;
    2004            state.failed=false;
    2005            return success;
    2006        }
    2007
    2008
    2009        protected DFA1 dfa1 = new DFA1(this);
    2010        static final String DFA1_eotS =
    2011            "\12\uffff";
    2012        static final String DFA1_eofS =
    2013            "\12\uffff";
    2014        static final String DFA1_minS =
    2015            "\1\4\1\uffff\2\0\6\uffff";
    2016        static final String DFA1_maxS =
    2017            "\1\51\1\uffff\2\0\6\uffff";
    2018        static final String DFA1_acceptS =
    2019            "\1\uffff\1\1\2\uffff\1\3\1\5\1\6\1\7\1\2\1\4";
    2020        static final String DFA1_specialS =
    2021            "\2\uffff\1\0\1\1\6\uffff}>";
    2022        static final String[] DFA1_transitionS = {
    2023                "\1\2\2\uffff\1\4\5\uffff\1\5\2\uffff\1\6\1\7\16\uffff\4\1\2"+
    2024                "\uffff\1\3\2\uffff\1\4",
    2025                "",
    2026                "\1\uffff",
    2027                "\1\uffff",
    2028                "",
    2029                "",
    2030                "",
    2031                "",
    2032                "",
    2033                ""
    2034        };
    2035
    2036        static final short[] DFA1_eot = DFA.unpackEncodedString(DFA1_eotS);
    2037        static final short[] DFA1_eof = DFA.unpackEncodedString(DFA1_eofS);
    2038        static final char[] DFA1_min = DFA.unpackEncodedStringToUnsignedChars(DFA1_minS);
    2039        static final char[] DFA1_max = DFA.unpackEncodedStringToUnsignedChars(DFA1_maxS);
    2040        static final short[] DFA1_accept = DFA.unpackEncodedString(DFA1_acceptS);
    2041        static final short[] DFA1_special = DFA.unpackEncodedString(DFA1_specialS);
    2042        static final short[][] DFA1_transition;
    2043
    2044        static {
    2045            int numStates = DFA1_transitionS.length;
    2046            DFA1_transition = new short[numStates][];
    2047            for (int i=0; i<numStates; i++) {
    2048                DFA1_transition[i] = DFA.unpackEncodedString(DFA1_transitionS[i]);
    2049            }
    2050        }
    2051
    2052        class DFA1 extends DFA {
    2053
    2054            public DFA1(BaseRecognizer recognizer) {
    2055                this.recognizer = recognizer;
    2056                this.decisionNumber = 1;
    2057                this.eot = DFA1_eot;
    2058                this.eof = DFA1_eof;
    2059                this.min = DFA1_min;
    2060                this.max = DFA1_max;
    2061                this.accept = DFA1_accept;
    2062                this.special = DFA1_special;
    2063                this.transition = DFA1_transition;
    2064            }
    2065            public String getDescription() {
    2066                return "47:1: expression : ( keyword | rangeOp | constant | propertyChain | list | notOp | map );";
    2067            }
    2068            public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
    2069                TokenStream input = (TokenStream)_input;
    2070                    int _s = s;
    2071                switch ( s ) {
    2072                        case 0 :
    2073                            int LA1_2 = input.LA(1);
    2074
    2075
    2076                            int index1_2 = input.index();
    2077                            input.rewind();
    2078                            s = -1;
    2079                            if ( (synpred2_PropertyExpressionParser()) ) {s = 8;}
    2080
    2081                            else if ( (synpred3_PropertyExpressionParser()) ) {s = 4;}
    2082
    2083
    2084                            input.seek(index1_2);
    2085                            if ( s>=0 ) return s;
    2086                            break;
    2087                        case 1 :
    2088                            int LA1_3 = input.LA(1);
    2089
    2090
    2091                            int index1_3 = input.index();
    2092                            input.rewind();
    2093                            s = -1;
    2094                            if ( (synpred2_PropertyExpressionParser()) ) {s = 8;}
    2095
    2096                            else if ( (synpred4_PropertyExpressionParser()) ) {s = 9;}
    2097
    2098
    2099                            input.seek(index1_3);
    2100                            if ( s>=0 ) return s;
    2101                            break;
    2102                }
    2103                if (state.backtracking>0) {state.failed=true; return -1;}
    2104                NoViableAltException nvae =
    2105                    new NoViableAltException(getDescription(), 1, _s, input);
    2106                error(nvae);
    2107                throw nvae;
    2108            }
    2109        }
    2110
    2111
    2112        public static final BitSet FOLLOW_expression_in_start130 = new BitSet(new long[]{0x0000000000000000L});
    2113        public static final BitSet FOLLOW_EOF_in_start133 = new BitSet(new long[]{0x0000000000000002L});
    2114        public static final BitSet FOLLOW_keyword_in_expression145 = new BitSet(new long[]{0x0000000000000002L});
    2115        public static final BitSet FOLLOW_rangeOp_in_expression150 = new BitSet(new long[]{0x0000000000000002L});
    2116        public static final BitSet FOLLOW_constant_in_expression155 = new BitSet(new long[]{0x0000000000000002L});
    2117        public static final BitSet FOLLOW_propertyChain_in_expression160 = new BitSet(new long[]{0x0000000000000002L});
    2118        public static final BitSet FOLLOW_list_in_expression165 = new BitSet(new long[]{0x0000000000000002L});
    2119        public static final BitSet FOLLOW_notOp_in_expression170 = new BitSet(new long[]{0x0000000000000002L});
    2120        public static final BitSet FOLLOW_map_in_expression175 = new BitSet(new long[]{0x0000000000000002L});
    2121        public static final BitSet FOLLOW_set_in_keyword0 = new BitSet(new long[]{0x0000000000000002L});
    2122        public static final BitSet FOLLOW_set_in_constant0 = new BitSet(new long[]{0x0000000000000002L});
    2123        public static final BitSet FOLLOW_term_in_propertyChain222 = new BitSet(new long[]{0x0000000000000020L});
    2124        public static final BitSet FOLLOW_DEREF_in_propertyChain224 = new BitSet(new long[]{0x0000004000000000L});
    2125        public static final BitSet FOLLOW_propertyChain_in_propertyChain226 = new BitSet(new long[]{0x0000000000000002L});
    2126        public static final BitSet FOLLOW_term_in_propertyChain241 = new BitSet(new long[]{0x0000008000000000L});
    2127        public static final BitSet FOLLOW_SAFEDEREF_in_propertyChain243 = new BitSet(new long[]{0x0000004000000000L});
    2128        public static final BitSet FOLLOW_propertyChain_in_propertyChain245 = new BitSet(new long[]{0x0000000000000002L});
    2129        public static final BitSet FOLLOW_term_in_propertyChain260 = new BitSet(new long[]{0x0000000000000002L});
    2130        public static final BitSet FOLLOW_IDENTIFIER_in_term272 = new BitSet(new long[]{0x0000000000000002L});
    2131        public static final BitSet FOLLOW_methodInvocation_in_term277 = new BitSet(new long[]{0x0000000000000002L});
    2132        public static final BitSet FOLLOW_IDENTIFIER_in_methodInvocation291 = new BitSet(new long[]{0x0000000000000800L});
    2133        public static final BitSet FOLLOW_LPAREN_in_methodInvocation293 = new BitSet(new long[]{0x0000000000001000L});
    2134        public static final BitSet FOLLOW_RPAREN_in_methodInvocation295 = new BitSet(new long[]{0x0000000000000002L});
    2135        public static final BitSet FOLLOW_IDENTIFIER_in_methodInvocation311 = new BitSet(new long[]{0x0000000000000800L});
    2136        public static final BitSet FOLLOW_LPAREN_in_methodInvocation313 = new BitSet(new long[]{0x0000024F00032090L});
    2137        public static final BitSet FOLLOW_expressionList_in_methodInvocation315 = new BitSet(new long[]{0x0000000000001000L});
    2138        public static final BitSet FOLLOW_RPAREN_in_methodInvocation317 = new BitSet(new long[]{0x0000000000000002L});
    2139        public static final BitSet FOLLOW_expression_in_expressionList341 = new BitSet(new long[]{0x0000000000008002L});
    2140        public static final BitSet FOLLOW_COMMA_in_expressionList344 = new BitSet(new long[]{0x0000024F00032090L});
    2141        public static final BitSet FOLLOW_expression_in_expressionList347 = new BitSet(new long[]{0x0000000000008002L});
    2142        public static final BitSet FOLLOW_rangeopArg_in_rangeOp363 = new BitSet(new long[]{0x0000000000000040L});
    2143        public static final BitSet FOLLOW_RANGEOP_in_rangeOp366 = new BitSet(new long[]{0x0000004000000010L});
    2144        public static final BitSet FOLLOW_rangeopArg_in_rangeOp370 = new BitSet(new long[]{0x0000000000000002L});
    2145        public static final BitSet FOLLOW_INTEGER_in_rangeopArg396 = new BitSet(new long[]{0x0000000000000002L});
    2146        public static final BitSet FOLLOW_propertyChain_in_rangeopArg401 = new BitSet(new long[]{0x0000000000000002L});
    2147        public static final BitSet FOLLOW_LBRACKET_in_list413 = new BitSet(new long[]{0x0000000000004000L});
    2148        public static final BitSet FOLLOW_RBRACKET_in_list415 = new BitSet(new long[]{0x0000000000000002L});
    2149        public static final BitSet FOLLOW_LBRACKET_in_list426 = new BitSet(new long[]{0x0000024F00032090L});
    2150        public static final BitSet FOLLOW_expressionList_in_list428 = new BitSet(new long[]{0x0000000000004000L});
    2151        public static final BitSet FOLLOW_RBRACKET_in_list430 = new BitSet(new long[]{0x0000000000000002L});
    2152        public static final BitSet FOLLOW_BANG_in_notOp451 = new BitSet(new long[]{0x0000024F00032090L});
    2153        public static final BitSet FOLLOW_expression_in_notOp453 = new BitSet(new long[]{0x0000000000000002L});
    2154        public static final BitSet FOLLOW_LBRACE_in_map472 = new BitSet(new long[]{0x0000000000040000L});
    2155        public static final BitSet FOLLOW_RBRACE_in_map474 = new BitSet(new long[]{0x0000000000000002L});
    2156        public static final BitSet FOLLOW_LBRACE_in_map485 = new BitSet(new long[]{0x0000024F00000090L});
    2157        public static final BitSet FOLLOW_mapEntryList_in_map487 = new BitSet(new long[]{0x0000000000040000L});
    2158        public static final BitSet FOLLOW_RBRACE_in_map489 = new BitSet(new long[]{0x0000000000000002L});
    2159        public static final BitSet FOLLOW_mapEntry_in_mapEntryList511 = new BitSet(new long[]{0x0000000000008002L});
    2160        public static final BitSet FOLLOW_COMMA_in_mapEntryList514 = new BitSet(new long[]{0x0000024F00000090L});
    2161        public static final BitSet FOLLOW_mapEntry_in_mapEntryList517 = new BitSet(new long[]{0x0000000000008002L});
    2162        public static final BitSet FOLLOW_mapKey_in_mapEntry528 = new BitSet(new long[]{0x0000000000080000L});
    2163        public static final BitSet FOLLOW_COLON_in_mapEntry530 = new BitSet(new long[]{0x0000024F00032090L});
    2164        public static final BitSet FOLLOW_expression_in_mapEntry533 = new BitSet(new long[]{0x0000000000000002L});
    2165        public static final BitSet FOLLOW_keyword_in_mapKey542 = new BitSet(new long[]{0x0000000000000002L});
    2166        public static final BitSet FOLLOW_constant_in_mapKey546 = new BitSet(new long[]{0x0000000000000002L});
    2167        public static final BitSet FOLLOW_propertyChain_in_mapKey550 = new BitSet(new long[]{0x0000000000000002L});
    2168        public static final BitSet FOLLOW_rangeOp_in_synpred2_PropertyExpressionParser150 = new BitSet(new long[]{0x0000000000000002L});
    2169        public static final BitSet FOLLOW_constant_in_synpred3_PropertyExpressionParser155 = new BitSet(new long[]{0x0000000000000002L});
    2170        public static final BitSet FOLLOW_propertyChain_in_synpred4_PropertyExpressionParser160 = new BitSet(new long[]{0x0000000000000002L});
    2171        public static final BitSet FOLLOW_term_in_synpred12_PropertyExpressionParser222 = new BitSet(new long[]{0x0000000000000020L});
    2172        public static final BitSet FOLLOW_DEREF_in_synpred12_PropertyExpressionParser224 = new BitSet(new long[]{0x0000004000000000L});
    2173        public static final BitSet FOLLOW_propertyChain_in_synpred12_PropertyExpressionParser226 = new BitSet(new long[]{0x0000000000000002L});
    2174        public static final BitSet FOLLOW_term_in_synpred13_PropertyExpressionParser241 = new BitSet(new long[]{0x0000008000000000L});
    2175        public static final BitSet FOLLOW_SAFEDEREF_in_synpred13_PropertyExpressionParser243 = new BitSet(new long[]{0x0000004000000000L});
    2176        public static final BitSet FOLLOW_propertyChain_in_synpred13_PropertyExpressionParser245 = new BitSet(new long[]{0x0000000000000002L});
    2177
    2178    }