Coverage Report - org.apache.tapestry5.internal.antlr.PropertyExpressionParser
 
Classes in this File Line Coverage Branch Coverage Complexity
PropertyExpressionParser
86%
655/763
67%
279/417
7.6
PropertyExpressionParser$constant_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$expressionList_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$expression_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$keyword_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$list_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$methodInvocation_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$notOp_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$propertyChain_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$rangeOp_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$rangeopArg_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$start_return
100%
2/2
N/A
N/A
7.6
PropertyExpressionParser$term_return
100%
2/2
N/A
N/A
7.6
 
 1   
 // $ANTLR 3.1.1 org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g 2009-05-08 07:24:04
 2   
 
 3   
 package org.apache.tapestry5.internal.antlr;
 4   
 
 5   
 
 6   
 import org.antlr.runtime.*;
 7   
 import java.util.Stack;
 8   
 import java.util.List;
 9   
 import java.util.ArrayList;
 10   
 import java.util.Map;
 11   
 import java.util.HashMap;
 12   
 
 13   
 import org.antlr.runtime.tree.*;
 14   
 
 15   
 public class PropertyExpressionParser extends org.apache.tapestry5.internal.antlr.BaseParser {
 16  2 
     public static final String[] tokenNames = new String[] {
 17   
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "INTEGER", "DEREF", "RANGEOP", "DECIMAL", "LETTER", "DIGIT", "SIGN", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", "COMMA", "BANG", "QUOTE", "A", "E", "F", "H", "I", "L", "N", "R", "S", "T", "U", "NULL", "TRUE", "FALSE", "THIS", "IDENTIFIER", "SAFEDEREF", "WS", "STRING", "NUMBER_OR_RANGEOP", "INVOKE", "LIST", "NOT"
 18   
     };
 19   
     public static final int COMMA=15;
 20   
     public static final int LETTER=8;
 21   
     public static final int H=21;
 22   
     public static final int LIST=39;
 23   
     public static final int RANGEOP=6;
 24   
     public static final int WS=35;
 25   
     public static final int STRING=36;
 26   
     public static final int BANG=16;
 27   
     public static final int FALSE=31;
 28   
     public static final int I=22;
 29   
     public static final int INVOKE=38;
 30   
     public static final int LBRACKET=13;
 31   
     public static final int A=18;
 32   
     public static final int F=20;
 33   
     public static final int U=28;
 34   
     public static final int QUOTE=17;
 35   
     public static final int N=24;
 36   
     public static final int DECIMAL=7;
 37   
     public static final int THIS=32;
 38   
     public static final int SAFEDEREF=34;
 39   
     public static final int NUMBER_OR_RANGEOP=37;
 40   
     public static final int S=26;
 41   
     public static final int INTEGER=4;
 42   
     public static final int R=25;
 43   
     public static final int EOF=-1;
 44   
     public static final int L=23;
 45   
     public static final int RBRACKET=14;
 46   
     public static final int NULL=29;
 47   
     public static final int RPAREN=12;
 48   
     public static final int LPAREN=11;
 49   
     public static final int SIGN=10;
 50   
     public static final int DIGIT=9;
 51   
     public static final int IDENTIFIER=33;
 52   
     public static final int DEREF=5;
 53   
     public static final int T=27;
 54   
     public static final int NOT=40;
 55   
     public static final int TRUE=30;
 56   
     public static final int E=19;
 57   
 
 58   
     // delegates
 59   
     // delegators
 60   
 
 61   
 
 62   
         public PropertyExpressionParser(TokenStream input) {
 63  1446 
             this(input, new RecognizerSharedState());
 64  1446 
         }
 65   
         public PropertyExpressionParser(TokenStream input, RecognizerSharedState state) {
 66  1446 
             super(input, state);
 67   
 
 68  1446 
         }
 69   
 
 70  1446 
     protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 71   
 
 72   
     public void setTreeAdaptor(TreeAdaptor adaptor) {
 73  0 
         this.adaptor = adaptor;
 74  0 
     }
 75   
     public TreeAdaptor getTreeAdaptor() {
 76  0 
         return adaptor;
 77   
     }
 78   
 
 79  2 
     public String[] getTokenNames() { return PropertyExpressionParser.tokenNames; }
 80  0 
     public String getGrammarFileName() { return "org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g"; }
 81   
 
 82   
 
 83  1446 
     public static class start_return extends ParserRuleReturnScope {
 84   
         CommonTree tree;
 85  1442 
         public Object getTree() { return tree; }
 86   
     };
 87   
 
 88   
     // $ANTLR start "start"
 89   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:43:1: start : expression EOF ;
 90   
     public final PropertyExpressionParser.start_return start() throws RecognitionException {
 91  1446 
         PropertyExpressionParser.start_return retval = new PropertyExpressionParser.start_return();
 92  1446 
         retval.start = input.LT(1);
 93   
 
 94  1444 
         CommonTree root_0 = null;
 95   
 
 96  1444 
         Token EOF2=null;
 97  1444 
         PropertyExpressionParser.expression_return expression1 = null;
 98   
 
 99   
 
 100  1444 
         CommonTree EOF2_tree=null;
 101   
 
 102   
         try {
 103   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:43:8: ( expression EOF )
 104   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:43:10: expression EOF
 105   
             {
 106  1444 
             root_0 = (CommonTree)adaptor.nil();
 107   
 
 108  1444 
             pushFollow(FOLLOW_expression_in_start122);
 109  1444 
             expression1=expression();
 110   
 
 111  1442 
             state._fsp--;
 112  1442 
             if (state.failed) return retval;
 113  1442 
             if ( state.backtracking==0 ) root_0 = (CommonTree)adaptor.becomeRoot(expression1.getTree(), root_0);
 114  1442 
             EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_start125); if (state.failed) return retval;
 115   
 
 116   
             }
 117   
 
 118  1442 
             retval.stop = input.LT(-1);
 119   
 
 120  1442 
             if ( state.backtracking==0 ) {
 121   
 
 122  1442 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 123  1442 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 124   
             }
 125   
         }
 126  0 
         catch (RecognitionException re) {
 127  0 
             reportError(re);
 128  0 
             recover(input,re);
 129  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 130   
 
 131   
         }
 132  2 
         finally {
 133  1442 
         }
 134  1442 
         return retval;
 135   
     }
 136   
     // $ANTLR end "start"
 137   
 
 138  1778 
     public static class expression_return extends ParserRuleReturnScope {
 139   
         CommonTree tree;
 140  1488 
         public Object getTree() { return tree; }
 141   
     };
 142   
 
 143   
     // $ANTLR start "expression"
 144   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:45:1: expression : ( keyword | rangeOp | constant | propertyChain | list | notOp );
 145   
     public final PropertyExpressionParser.expression_return expression() throws RecognitionException {
 146  1778 
         PropertyExpressionParser.expression_return retval = new PropertyExpressionParser.expression_return();
 147  1778 
         retval.start = input.LT(1);
 148   
 
 149  1778 
         CommonTree root_0 = null;
 150   
 
 151  1778 
         PropertyExpressionParser.keyword_return keyword3 = null;
 152   
 
 153  1778 
         PropertyExpressionParser.rangeOp_return rangeOp4 = null;
 154   
 
 155  1778 
         PropertyExpressionParser.constant_return constant5 = null;
 156   
 
 157  1778 
         PropertyExpressionParser.propertyChain_return propertyChain6 = null;
 158   
 
 159  1778 
         PropertyExpressionParser.list_return list7 = null;
 160   
 
 161  1778 
         PropertyExpressionParser.notOp_return notOp8 = null;
 162   
 
 163   
 
 164   
 
 165   
         try {
 166   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:46:2: ( keyword | rangeOp | constant | propertyChain | list | notOp )
 167  1778 
             int alt1=6;
 168  1778 
             switch ( input.LA(1) ) {
 169   
             case NULL:
 170   
             case TRUE:
 171   
             case FALSE:
 172   
             case THIS:
 173   
                 {
 174  212 
                 alt1=1;
 175   
                 }
 176  212 
                 break;
 177   
             case INTEGER:
 178   
                 {
 179  92 
                 int LA1_2 = input.LA(2);
 180   
 
 181  92 
                 if ( (synpred2_PropertyExpressionParser()) ) {
 182  18 
                     alt1=2;
 183   
                 }
 184  74 
                 else if ( (synpred3_PropertyExpressionParser()) ) {
 185  74 
                     alt1=3;
 186   
                 }
 187   
                 else {
 188  0 
                     if (state.backtracking>0) {state.failed=true; return retval;}
 189  0 
                     NoViableAltException nvae =
 190   
                         new NoViableAltException("", 1, 2, input);
 191   
 
 192  0 
                     throw nvae;
 193   
                 }
 194   
                 }
 195  92 
                 break;
 196   
             case IDENTIFIER:
 197   
                 {
 198  1310 
                 int LA1_3 = input.LA(2);
 199   
 
 200  1310 
                 if ( (synpred2_PropertyExpressionParser()) ) {
 201  2 
                     alt1=2;
 202   
                 }
 203  1308 
                 else if ( (synpred4_PropertyExpressionParser()) ) {
 204  1306 
                     alt1=4;
 205   
                 }
 206   
                 else {
 207  2 
                     if (state.backtracking>0) {state.failed=true; return retval;}
 208  2 
                     NoViableAltException nvae =
 209   
                         new NoViableAltException("", 1, 3, input);
 210   
 
 211  2 
                     throw nvae;
 212   
                 }
 213   
                 }
 214  1308 
                 break;
 215   
             case DECIMAL:
 216   
             case STRING:
 217   
                 {
 218  120 
                 alt1=3;
 219   
                 }
 220  120 
                 break;
 221   
             case LBRACKET:
 222   
                 {
 223  22 
                 alt1=5;
 224   
                 }
 225  22 
                 break;
 226   
             case BANG:
 227   
                 {
 228  22 
                 alt1=6;
 229   
                 }
 230  22 
                 break;
 231   
             default:
 232  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 233  0 
                 NoViableAltException nvae =
 234   
                     new NoViableAltException("", 1, 0, input);
 235   
 
 236  0 
                 throw nvae;
 237   
             }
 238   
 
 239  1776 
             switch (alt1) {
 240   
                 case 1 :
 241   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:46:4: keyword
 242   
                     {
 243  212 
                     root_0 = (CommonTree)adaptor.nil();
 244   
 
 245  212 
                     pushFollow(FOLLOW_keyword_in_expression137);
 246  212 
                     keyword3=keyword();
 247   
 
 248  212 
                     state._fsp--;
 249  212 
                     if (state.failed) return retval;
 250  212 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, keyword3.getTree());
 251   
 
 252   
                     }
 253   
                     break;
 254   
                 case 2 :
 255   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:47:4: rangeOp
 256   
                     {
 257  20 
                     root_0 = (CommonTree)adaptor.nil();
 258   
 
 259  20 
                     pushFollow(FOLLOW_rangeOp_in_expression142);
 260  20 
                     rangeOp4=rangeOp();
 261   
 
 262  20 
                     state._fsp--;
 263  20 
                     if (state.failed) return retval;
 264  20 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, rangeOp4.getTree());
 265   
 
 266   
                     }
 267   
                     break;
 268   
                 case 3 :
 269   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:48:4: constant
 270   
                     {
 271  194 
                     root_0 = (CommonTree)adaptor.nil();
 272   
 
 273  194 
                     pushFollow(FOLLOW_constant_in_expression147);
 274  194 
                     constant5=constant();
 275   
 
 276  194 
                     state._fsp--;
 277  194 
                     if (state.failed) return retval;
 278  194 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, constant5.getTree());
 279   
 
 280   
                     }
 281   
                     break;
 282   
                 case 4 :
 283   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:49:4: propertyChain
 284   
                     {
 285  1306 
                     root_0 = (CommonTree)adaptor.nil();
 286   
 
 287  1306 
                     pushFollow(FOLLOW_propertyChain_in_expression152);
 288  1306 
                     propertyChain6=propertyChain();
 289   
 
 290  1306 
                     state._fsp--;
 291  1306 
                     if (state.failed) return retval;
 292  1306 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyChain6.getTree());
 293   
 
 294   
                     }
 295   
                     break;
 296   
                 case 5 :
 297   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:50:4: list
 298   
                     {
 299  22 
                     root_0 = (CommonTree)adaptor.nil();
 300   
 
 301  22 
                     pushFollow(FOLLOW_list_in_expression157);
 302  22 
                     list7=list();
 303   
 
 304  22 
                     state._fsp--;
 305  22 
                     if (state.failed) return retval;
 306  22 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, list7.getTree());
 307   
 
 308   
                     }
 309   
                     break;
 310   
                 case 6 :
 311   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:51:4: notOp
 312   
                     {
 313  22 
                     root_0 = (CommonTree)adaptor.nil();
 314   
 
 315  22 
                     pushFollow(FOLLOW_notOp_in_expression162);
 316  22 
                     notOp8=notOp();
 317   
 
 318  22 
                     state._fsp--;
 319  22 
                     if (state.failed) return retval;
 320  22 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, notOp8.getTree());
 321   
 
 322   
                     }
 323   
                     break;
 324   
 
 325   
             }
 326  1776 
             retval.stop = input.LT(-1);
 327   
 
 328  1776 
             if ( state.backtracking==0 ) {
 329   
 
 330  1488 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 331  1488 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 332   
             }
 333   
         }
 334  2 
         catch (RecognitionException re) {
 335  2 
             reportError(re);
 336  0 
             recover(input,re);
 337  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 338   
 
 339   
         }
 340  2 
         finally {
 341  1776 
         }
 342  1776 
         return retval;
 343   
     }
 344   
     // $ANTLR end "expression"
 345   
 
 346  212 
     public static class keyword_return extends ParserRuleReturnScope {
 347   
         CommonTree tree;
 348  180 
         public Object getTree() { return tree; }
 349   
     };
 350   
 
 351   
     // $ANTLR start "keyword"
 352   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:54:1: keyword : ( NULL | TRUE | FALSE | THIS );
 353   
     public final PropertyExpressionParser.keyword_return keyword() throws RecognitionException {
 354  212 
         PropertyExpressionParser.keyword_return retval = new PropertyExpressionParser.keyword_return();
 355  212 
         retval.start = input.LT(1);
 356   
 
 357  212 
         CommonTree root_0 = null;
 358   
 
 359  212 
         Token set9=null;
 360   
 
 361  212 
         CommonTree set9_tree=null;
 362   
 
 363   
         try {
 364   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:54:9: ( NULL | TRUE | FALSE | THIS )
 365   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:
 366   
             {
 367  212 
             root_0 = (CommonTree)adaptor.nil();
 368   
 
 369  212 
             set9=(Token)input.LT(1);
 370  212 
             if ( (input.LA(1)>=NULL && input.LA(1)<=THIS) ) {
 371  212 
                 input.consume();
 372  212 
                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set9));
 373  212 
                 state.errorRecovery=false;state.failed=false;
 374   
             }
 375   
             else {
 376  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 377  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 378  0 
                 throw mse;
 379   
             }
 380   
 
 381   
 
 382   
             }
 383   
 
 384  212 
             retval.stop = input.LT(-1);
 385   
 
 386  212 
             if ( state.backtracking==0 ) {
 387   
 
 388  180 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 389  180 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 390   
             }
 391   
         }
 392  0 
         catch (RecognitionException re) {
 393  0 
             reportError(re);
 394  0 
             recover(input,re);
 395  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 396   
 
 397   
         }
 398  0 
         finally {
 399  212 
         }
 400  212 
         return retval;
 401   
     }
 402   
     // $ANTLR end "keyword"
 403   
 
 404  268 
     public static class constant_return extends ParserRuleReturnScope {
 405   
         CommonTree tree;
 406  82 
         public Object getTree() { return tree; }
 407   
     };
 408   
 
 409   
     // $ANTLR start "constant"
 410   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:56:1: constant : ( INTEGER | DECIMAL | STRING );
 411   
     public final PropertyExpressionParser.constant_return constant() throws RecognitionException {
 412  268 
         PropertyExpressionParser.constant_return retval = new PropertyExpressionParser.constant_return();
 413  268 
         retval.start = input.LT(1);
 414   
 
 415  268 
         CommonTree root_0 = null;
 416   
 
 417  268 
         Token set10=null;
 418   
 
 419  268 
         CommonTree set10_tree=null;
 420   
 
 421   
         try {
 422   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:56:9: ( INTEGER | DECIMAL | STRING )
 423   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:
 424   
             {
 425  268 
             root_0 = (CommonTree)adaptor.nil();
 426   
 
 427  268 
             set10=(Token)input.LT(1);
 428  268 
             if ( input.LA(1)==INTEGER||input.LA(1)==DECIMAL||input.LA(1)==STRING ) {
 429  268 
                 input.consume();
 430  268 
                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set10));
 431  268 
                 state.errorRecovery=false;state.failed=false;
 432   
             }
 433   
             else {
 434  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 435  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 436  0 
                 throw mse;
 437   
             }
 438   
 
 439   
 
 440   
             }
 441   
 
 442  268 
             retval.stop = input.LT(-1);
 443   
 
 444  268 
             if ( state.backtracking==0 ) {
 445   
 
 446  82 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 447  82 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 448   
             }
 449   
         }
 450  0 
         catch (RecognitionException re) {
 451  0 
             reportError(re);
 452  0 
             recover(input,re);
 453  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 454   
 
 455   
         }
 456  0 
         finally {
 457  268 
         }
 458  268 
         return retval;
 459   
     }
 460   
     // $ANTLR end "constant"
 461   
 
 462  5730 
     public static class propertyChain_return extends ParserRuleReturnScope {
 463   
         CommonTree tree;
 464  1474 
         public Object getTree() { return tree; }
 465   
     };
 466   
 
 467   
     // $ANTLR start "propertyChain"
 468   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:58:1: propertyChain : ( term DEREF propertyChain -> ^( DEREF term propertyChain ) | term SAFEDEREF propertyChain -> ^( SAFEDEREF term propertyChain ) | term );
 469   
     public final PropertyExpressionParser.propertyChain_return propertyChain() throws RecognitionException {
 470  5730 
         PropertyExpressionParser.propertyChain_return retval = new PropertyExpressionParser.propertyChain_return();
 471  5730 
         retval.start = input.LT(1);
 472   
 
 473  5730 
         CommonTree root_0 = null;
 474   
 
 475  5730 
         Token DEREF12=null;
 476  5730 
         Token SAFEDEREF15=null;
 477  5730 
         PropertyExpressionParser.term_return term11 = null;
 478   
 
 479  5730 
         PropertyExpressionParser.propertyChain_return propertyChain13 = null;
 480   
 
 481  5730 
         PropertyExpressionParser.term_return term14 = null;
 482   
 
 483  5730 
         PropertyExpressionParser.propertyChain_return propertyChain16 = null;
 484   
 
 485  5730 
         PropertyExpressionParser.term_return term17 = null;
 486   
 
 487   
 
 488  5730 
         CommonTree DEREF12_tree=null;
 489  5730 
         CommonTree SAFEDEREF15_tree=null;
 490  5730 
         RewriteRuleTokenStream stream_DEREF=new RewriteRuleTokenStream(adaptor,"token DEREF");
 491  5730 
         RewriteRuleTokenStream stream_SAFEDEREF=new RewriteRuleTokenStream(adaptor,"token SAFEDEREF");
 492  5730 
         RewriteRuleSubtreeStream stream_term=new RewriteRuleSubtreeStream(adaptor,"rule term");
 493  5730 
         RewriteRuleSubtreeStream stream_propertyChain=new RewriteRuleSubtreeStream(adaptor,"rule propertyChain");
 494   
         try {
 495   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:59:2: ( term DEREF propertyChain -> ^( DEREF term propertyChain ) | term SAFEDEREF propertyChain -> ^( SAFEDEREF term propertyChain ) | term )
 496  5730 
             int alt2=3;
 497  5730 
             int LA2_0 = input.LA(1);
 498   
 
 499  5730 
             if ( (LA2_0==IDENTIFIER) ) {
 500  5730 
                 int LA2_1 = input.LA(2);
 501   
 
 502  5730 
                 if ( (synpred11_PropertyExpressionParser()) ) {
 503  894 
                     alt2=1;
 504   
                 }
 505  4836 
                 else if ( (synpred12_PropertyExpressionParser()) ) {
 506  6 
                     alt2=2;
 507   
                 }
 508   
                 else if ( (true) ) {
 509  4830 
                     alt2=3;
 510   
                 }
 511   
                 else {
 512   
                     if (state.backtracking>0) {state.failed=true; return retval;}
 513   
                     NoViableAltException nvae =
 514   
                         new NoViableAltException("", 2, 1, input);
 515   
 
 516   
                     throw nvae;
 517   
                 }
 518  5730 
             }
 519   
             else {
 520  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 521  0 
                 NoViableAltException nvae =
 522   
                     new NoViableAltException("", 2, 0, input);
 523   
 
 524  0 
                 throw nvae;
 525   
             }
 526  5730 
             switch (alt2) {
 527   
                 case 1 :
 528   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:59:4: term DEREF propertyChain
 529   
                     {
 530  894 
                     pushFollow(FOLLOW_term_in_propertyChain210);
 531  894 
                     term11=term();
 532   
 
 533  894 
                     state._fsp--;
 534  894 
                     if (state.failed) return retval;
 535  894 
                     if ( state.backtracking==0 ) stream_term.add(term11.getTree());
 536  894 
                     DEREF12=(Token)match(input,DEREF,FOLLOW_DEREF_in_propertyChain212); if (state.failed) return retval;
 537  894 
                     if ( state.backtracking==0 ) stream_DEREF.add(DEREF12);
 538   
 
 539  894 
                     pushFollow(FOLLOW_propertyChain_in_propertyChain214);
 540  894 
                     propertyChain13=propertyChain();
 541   
 
 542  894 
                     state._fsp--;
 543  894 
                     if (state.failed) return retval;
 544  894 
                     if ( state.backtracking==0 ) stream_propertyChain.add(propertyChain13.getTree());
 545   
 
 546   
 
 547   
                     // AST REWRITE
 548   
                     // elements: term, DEREF, propertyChain
 549   
                     // token labels:
 550   
                     // rule labels: retval
 551   
                     // token list labels:
 552   
                     // rule list labels:
 553  894 
                     if ( state.backtracking==0 ) {
 554  274 
                     retval.tree = root_0;
 555  274 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 556   
 
 557  274 
                     root_0 = (CommonTree)adaptor.nil();
 558   
                     // 59:29: -> ^( DEREF term propertyChain )
 559   
                     {
 560   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:59:32: ^( DEREF term propertyChain )
 561   
                         {
 562  274 
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 563  274 
                         root_1 = (CommonTree)adaptor.becomeRoot(stream_DEREF.nextNode(), root_1);
 564   
 
 565  274 
                         adaptor.addChild(root_1, stream_term.nextTree());
 566  274 
                         adaptor.addChild(root_1, stream_propertyChain.nextTree());
 567   
 
 568  274 
                         adaptor.addChild(root_0, root_1);
 569   
                         }
 570   
 
 571   
                     }
 572   
 
 573  274 
                     retval.tree = root_0;}
 574   
                     }
 575   
                     break;
 576   
                 case 2 :
 577   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:60:4: term SAFEDEREF propertyChain
 578   
                     {
 579  6 
                     pushFollow(FOLLOW_term_in_propertyChain229);
 580  6 
                     term14=term();
 581   
 
 582  6 
                     state._fsp--;
 583  6 
                     if (state.failed) return retval;
 584  6 
                     if ( state.backtracking==0 ) stream_term.add(term14.getTree());
 585  6 
                     SAFEDEREF15=(Token)match(input,SAFEDEREF,FOLLOW_SAFEDEREF_in_propertyChain231); if (state.failed) return retval;
 586  6 
                     if ( state.backtracking==0 ) stream_SAFEDEREF.add(SAFEDEREF15);
 587   
 
 588  6 
                     pushFollow(FOLLOW_propertyChain_in_propertyChain233);
 589  6 
                     propertyChain16=propertyChain();
 590   
 
 591  6 
                     state._fsp--;
 592  6 
                     if (state.failed) return retval;
 593  6 
                     if ( state.backtracking==0 ) stream_propertyChain.add(propertyChain16.getTree());
 594   
 
 595   
 
 596   
                     // AST REWRITE
 597   
                     // elements: SAFEDEREF, propertyChain, term
 598   
                     // token labels:
 599   
                     // rule labels: retval
 600   
                     // token list labels:
 601   
                     // rule list labels:
 602  6 
                     if ( state.backtracking==0 ) {
 603  2 
                     retval.tree = root_0;
 604  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 605   
 
 606  2 
                     root_0 = (CommonTree)adaptor.nil();
 607   
                     // 60:33: -> ^( SAFEDEREF term propertyChain )
 608   
                     {
 609   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:60:36: ^( SAFEDEREF term propertyChain )
 610   
                         {
 611  2 
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 612  2 
                         root_1 = (CommonTree)adaptor.becomeRoot(stream_SAFEDEREF.nextNode(), root_1);
 613   
 
 614  2 
                         adaptor.addChild(root_1, stream_term.nextTree());
 615  2 
                         adaptor.addChild(root_1, stream_propertyChain.nextTree());
 616   
 
 617  2 
                         adaptor.addChild(root_0, root_1);
 618   
                         }
 619   
 
 620   
                     }
 621   
 
 622  2 
                     retval.tree = root_0;}
 623   
                     }
 624   
                     break;
 625   
                 case 3 :
 626   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:61:4: term
 627   
                     {
 628  4830 
                     root_0 = (CommonTree)adaptor.nil();
 629   
 
 630  4830 
                     pushFollow(FOLLOW_term_in_propertyChain248);
 631  4830 
                     term17=term();
 632   
 
 633  4830 
                     state._fsp--;
 634  4830 
                     if (state.failed) return retval;
 635  4826 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, term17.getTree());
 636   
 
 637   
                     }
 638   
                     break;
 639   
 
 640   
             }
 641  5726 
             retval.stop = input.LT(-1);
 642   
 
 643  5726 
             if ( state.backtracking==0 ) {
 644   
 
 645  1474 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 646  1474 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 647   
             }
 648   
         }
 649  0 
         catch (RecognitionException re) {
 650  0 
             reportError(re);
 651  0 
             recover(input,re);
 652  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 653   
 
 654   
         }
 655  0 
         finally {
 656  5726 
         }
 657  5726 
         return retval;
 658   
     }
 659   
     // $ANTLR end "propertyChain"
 660   
 
 661  16296 
     public static class term_return extends ParserRuleReturnScope {
 662   
         CommonTree tree;
 663  1474 
         public Object getTree() { return tree; }
 664   
     };
 665   
 
 666   
     // $ANTLR start "term"
 667   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:64:1: term : ( IDENTIFIER | methodInvocation );
 668   
     public final PropertyExpressionParser.term_return term() throws RecognitionException {
 669  16296 
         PropertyExpressionParser.term_return retval = new PropertyExpressionParser.term_return();
 670  16296 
         retval.start = input.LT(1);
 671   
 
 672  16296 
         CommonTree root_0 = null;
 673   
 
 674  16296 
         Token IDENTIFIER18=null;
 675  16296 
         PropertyExpressionParser.methodInvocation_return methodInvocation19 = null;
 676   
 
 677   
 
 678  16296 
         CommonTree IDENTIFIER18_tree=null;
 679   
 
 680   
         try {
 681   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:64:6: ( IDENTIFIER | methodInvocation )
 682  16296 
             int alt3=2;
 683  16296 
             int LA3_0 = input.LA(1);
 684   
 
 685  16296 
             if ( (LA3_0==IDENTIFIER) ) {
 686  16296 
                 int LA3_1 = input.LA(2);
 687   
 
 688  16296 
                 if ( (LA3_1==LPAREN) ) {
 689  864 
                     alt3=2;
 690   
                 }
 691  15432 
                 else if ( (LA3_1==EOF||(LA3_1>=DEREF && LA3_1<=RANGEOP)||LA3_1==RPAREN||(LA3_1>=RBRACKET && LA3_1<=COMMA)||LA3_1==SAFEDEREF) ) {
 692  15432 
                     alt3=1;
 693   
                 }
 694   
                 else {
 695  0 
                     if (state.backtracking>0) {state.failed=true; return retval;}
 696  0 
                     NoViableAltException nvae =
 697   
                         new NoViableAltException("", 3, 1, input);
 698   
 
 699  0 
                     throw nvae;
 700   
                 }
 701  16296 
             }
 702   
             else {
 703  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 704  0 
                 NoViableAltException nvae =
 705   
                     new NoViableAltException("", 3, 0, input);
 706   
 
 707  0 
                 throw nvae;
 708   
             }
 709  16296 
             switch (alt3) {
 710   
                 case 1 :
 711   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:64:8: IDENTIFIER
 712   
                     {
 713  15432 
                     root_0 = (CommonTree)adaptor.nil();
 714   
 
 715  15432 
                     IDENTIFIER18=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_term260); if (state.failed) return retval;
 716  15432 
                     if ( state.backtracking==0 ) {
 717  1414 
                     IDENTIFIER18_tree = (CommonTree)adaptor.create(IDENTIFIER18);
 718  1414 
                     adaptor.addChild(root_0, IDENTIFIER18_tree);
 719   
                     }
 720   
 
 721   
                     }
 722   
                     break;
 723   
                 case 2 :
 724   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:65:4: methodInvocation
 725   
                     {
 726  864 
                     root_0 = (CommonTree)adaptor.nil();
 727   
 
 728  864 
                     pushFollow(FOLLOW_methodInvocation_in_term265);
 729  864 
                     methodInvocation19=methodInvocation();
 730   
 
 731  864 
                     state._fsp--;
 732  864 
                     if (state.failed) return retval;
 733  852 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, methodInvocation19.getTree());
 734   
 
 735   
                     }
 736   
                     break;
 737   
 
 738   
             }
 739  16284 
             retval.stop = input.LT(-1);
 740   
 
 741  16284 
             if ( state.backtracking==0 ) {
 742   
 
 743  1474 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 744  1474 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 745   
             }
 746   
         }
 747  0 
         catch (RecognitionException re) {
 748  0 
             reportError(re);
 749  0 
             recover(input,re);
 750  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 751   
 
 752   
         }
 753  0 
         finally {
 754  16284 
         }
 755  16284 
         return retval;
 756   
     }
 757   
     // $ANTLR end "term"
 758   
 
 759  864 
     public static class methodInvocation_return extends ParserRuleReturnScope {
 760   
         CommonTree tree;
 761  60 
         public Object getTree() { return tree; }
 762   
     };
 763   
 
 764   
     // $ANTLR start "methodInvocation"
 765   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:68:1: methodInvocation : (id= IDENTIFIER LPAREN RPAREN -> ^( INVOKE $id) | id= IDENTIFIER LPAREN expressionList RPAREN -> ^( INVOKE $id expressionList ) );
 766   
     public final PropertyExpressionParser.methodInvocation_return methodInvocation() throws RecognitionException {
 767  864 
         PropertyExpressionParser.methodInvocation_return retval = new PropertyExpressionParser.methodInvocation_return();
 768  864 
         retval.start = input.LT(1);
 769   
 
 770  864 
         CommonTree root_0 = null;
 771   
 
 772  864 
         Token id=null;
 773  864 
         Token LPAREN20=null;
 774  864 
         Token RPAREN21=null;
 775  864 
         Token LPAREN22=null;
 776  864 
         Token RPAREN24=null;
 777  864 
         PropertyExpressionParser.expressionList_return expressionList23 = null;
 778   
 
 779   
 
 780  864 
         CommonTree id_tree=null;
 781  864 
         CommonTree LPAREN20_tree=null;
 782  864 
         CommonTree RPAREN21_tree=null;
 783  864 
         CommonTree LPAREN22_tree=null;
 784  864 
         CommonTree RPAREN24_tree=null;
 785  864 
         RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
 786  864 
         RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
 787  864 
         RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
 788  864 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 789   
         try {
 790   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:69:2: (id= IDENTIFIER LPAREN RPAREN -> ^( INVOKE $id) | id= IDENTIFIER LPAREN expressionList RPAREN -> ^( INVOKE $id expressionList ) )
 791  864 
             int alt4=2;
 792  864 
             int LA4_0 = input.LA(1);
 793   
 
 794  864 
             if ( (LA4_0==IDENTIFIER) ) {
 795  864 
                 int LA4_1 = input.LA(2);
 796   
 
 797  864 
                 if ( (LA4_1==LPAREN) ) {
 798  864 
                     int LA4_2 = input.LA(3);
 799   
 
 800  864 
                     if ( (LA4_2==RPAREN) ) {
 801  708 
                         alt4=1;
 802   
                     }
 803  156 
                     else if ( (LA4_2==INTEGER||LA4_2==DECIMAL||LA4_2==LBRACKET||LA4_2==BANG||(LA4_2>=NULL && LA4_2<=IDENTIFIER)||LA4_2==STRING) ) {
 804  144 
                         alt4=2;
 805   
                     }
 806   
                     else {
 807  12 
                         if (state.backtracking>0) {state.failed=true; return retval;}
 808  0 
                         NoViableAltException nvae =
 809   
                             new NoViableAltException("", 4, 2, input);
 810   
 
 811  0 
                         throw nvae;
 812   
                     }
 813  852 
                 }
 814   
                 else {
 815  0 
                     if (state.backtracking>0) {state.failed=true; return retval;}
 816  0 
                     NoViableAltException nvae =
 817   
                         new NoViableAltException("", 4, 1, input);
 818   
 
 819  0 
                     throw nvae;
 820   
                 }
 821  852 
             }
 822   
             else {
 823  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 824  0 
                 NoViableAltException nvae =
 825   
                     new NoViableAltException("", 4, 0, input);
 826   
 
 827  0 
                 throw nvae;
 828   
             }
 829  852 
             switch (alt4) {
 830   
                 case 1 :
 831   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:69:4: id= IDENTIFIER LPAREN RPAREN
 832   
                     {
 833  708 
                     id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodInvocation279); if (state.failed) return retval;
 834  708 
                     if ( state.backtracking==0 ) stream_IDENTIFIER.add(id);
 835   
 
 836  708 
                     LPAREN20=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_methodInvocation281); if (state.failed) return retval;
 837  708 
                     if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN20);
 838   
 
 839  708 
                     RPAREN21=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_methodInvocation283); if (state.failed) return retval;
 840  708 
                     if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN21);
 841   
 
 842   
 
 843   
 
 844   
                     // AST REWRITE
 845   
                     // elements: id
 846   
                     // token labels: id
 847   
                     // rule labels: retval
 848   
                     // token list labels:
 849   
                     // rule list labels:
 850  708 
                     if ( state.backtracking==0 ) {
 851  44 
                     retval.tree = root_0;
 852  44 
                     RewriteRuleTokenStream stream_id=new RewriteRuleTokenStream(adaptor,"token id",id);
 853  44 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 854   
 
 855  44 
                     root_0 = (CommonTree)adaptor.nil();
 856   
                     // 69:32: -> ^( INVOKE $id)
 857   
                     {
 858   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:69:35: ^( INVOKE $id)
 859   
                         {
 860  44 
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 861  44 
                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INVOKE, "INVOKE"), root_1);
 862   
 
 863  44 
                         adaptor.addChild(root_1, stream_id.nextNode());
 864   
 
 865  44 
                         adaptor.addChild(root_0, root_1);
 866   
                         }
 867   
 
 868   
                     }
 869   
 
 870  44 
                     retval.tree = root_0;}
 871   
                     }
 872   
                     break;
 873   
                 case 2 :
 874   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:70:4: id= IDENTIFIER LPAREN expressionList RPAREN
 875   
                     {
 876  144 
                     id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodInvocation299); if (state.failed) return retval;
 877  144 
                     if ( state.backtracking==0 ) stream_IDENTIFIER.add(id);
 878   
 
 879  144 
                     LPAREN22=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_methodInvocation301); if (state.failed) return retval;
 880  144 
                     if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN22);
 881   
 
 882  144 
                     pushFollow(FOLLOW_expressionList_in_methodInvocation303);
 883  144 
                     expressionList23=expressionList();
 884   
 
 885  144 
                     state._fsp--;
 886  144 
                     if (state.failed) return retval;
 887  144 
                     if ( state.backtracking==0 ) stream_expressionList.add(expressionList23.getTree());
 888  144 
                     RPAREN24=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_methodInvocation305); if (state.failed) return retval;
 889  144 
                     if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN24);
 890   
 
 891   
 
 892   
 
 893   
                     // AST REWRITE
 894   
                     // elements: id, expressionList
 895   
                     // token labels: id
 896   
                     // rule labels: retval
 897   
                     // token list labels:
 898   
                     // rule list labels:
 899  144 
                     if ( state.backtracking==0 ) {
 900  16 
                     retval.tree = root_0;
 901  16 
                     RewriteRuleTokenStream stream_id=new RewriteRuleTokenStream(adaptor,"token id",id);
 902  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 903   
 
 904  16 
                     root_0 = (CommonTree)adaptor.nil();
 905   
                     // 70:47: -> ^( INVOKE $id expressionList )
 906   
                     {
 907   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:70:50: ^( INVOKE $id expressionList )
 908   
                         {
 909  16 
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 910  16 
                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INVOKE, "INVOKE"), root_1);
 911   
 
 912  16 
                         adaptor.addChild(root_1, stream_id.nextNode());
 913  16 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 914   
 
 915  16 
                         adaptor.addChild(root_0, root_1);
 916   
                         }
 917   
 
 918   
                     }
 919   
 
 920  16 
                     retval.tree = root_0;}
 921   
                     }
 922   
                     break;
 923   
 
 924   
             }
 925  852 
             retval.stop = input.LT(-1);
 926   
 
 927  852 
             if ( state.backtracking==0 ) {
 928   
 
 929  60 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 930  60 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 931   
             }
 932   
         }
 933  0 
         catch (RecognitionException re) {
 934  0 
             reportError(re);
 935  0 
             recover(input,re);
 936  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 937   
 
 938   
         }
 939  0 
         finally {
 940  852 
         }
 941  852 
         return retval;
 942   
     }
 943   
     // $ANTLR end "methodInvocation"
 944   
 
 945  164 
     public static class expressionList_return extends ParserRuleReturnScope {
 946   
         CommonTree tree;
 947  20 
         public Object getTree() { return tree; }
 948   
     };
 949   
 
 950   
     // $ANTLR start "expressionList"
 951   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:73:1: expressionList : expression ( COMMA expression )* ;
 952   
     public final PropertyExpressionParser.expressionList_return expressionList() throws RecognitionException {
 953  164 
         PropertyExpressionParser.expressionList_return retval = new PropertyExpressionParser.expressionList_return();
 954  164 
         retval.start = input.LT(1);
 955   
 
 956  164 
         CommonTree root_0 = null;
 957   
 
 958  164 
         Token COMMA26=null;
 959  164 
         PropertyExpressionParser.expression_return expression25 = null;
 960   
 
 961  164 
         PropertyExpressionParser.expression_return expression27 = null;
 962   
 
 963   
 
 964  164 
         CommonTree COMMA26_tree=null;
 965   
 
 966   
         try {
 967   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:74:2: ( expression ( COMMA expression )* )
 968   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:74:4: expression ( COMMA expression )*
 969   
             {
 970  164 
             root_0 = (CommonTree)adaptor.nil();
 971   
 
 972  164 
             pushFollow(FOLLOW_expression_in_expressionList329);
 973  164 
             expression25=expression();
 974   
 
 975  164 
             state._fsp--;
 976  164 
             if (state.failed) return retval;
 977  164 
             if ( state.backtracking==0 ) adaptor.addChild(root_0, expression25.getTree());
 978   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:74:15: ( COMMA expression )*
 979   
             loop5:
 980   
             do {
 981  312 
                 int alt5=2;
 982  312 
                 int LA5_0 = input.LA(1);
 983   
 
 984  312 
                 if ( (LA5_0==COMMA) ) {
 985  148 
                     alt5=1;
 986   
                 }
 987   
 
 988   
 
 989  312 
                 switch (alt5) {
 990   
                     case 1 :
 991   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:74:16: COMMA expression
 992   
                         {
 993  148 
                         COMMA26=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList332); if (state.failed) return retval;
 994  148 
                         pushFollow(FOLLOW_expression_in_expressionList335);
 995  148 
                         expression27=expression();
 996   
 
 997  148 
                         state._fsp--;
 998  148 
                         if (state.failed) return retval;
 999  148 
                         if ( state.backtracking==0 ) adaptor.addChild(root_0, expression27.getTree());
 1000   
 
 1001   
                         }
 1002   
                         break;
 1003   
 
 1004   
                     default :
 1005  164 
                         break loop5;
 1006   
                 }
 1007  148 
             } while (true);
 1008   
 
 1009   
 
 1010   
             }
 1011   
 
 1012  164 
             retval.stop = input.LT(-1);
 1013   
 
 1014  164 
             if ( state.backtracking==0 ) {
 1015   
 
 1016  20 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1017  20 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1018   
             }
 1019   
         }
 1020  0 
         catch (RecognitionException re) {
 1021  0 
             reportError(re);
 1022  0 
             recover(input,re);
 1023  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1024   
 
 1025   
         }
 1026  0 
         finally {
 1027  164 
         }
 1028  164 
         return retval;
 1029   
     }
 1030   
     // $ANTLR end "expressionList"
 1031   
 
 1032  1422 
     public static class rangeOp_return extends ParserRuleReturnScope {
 1033   
         CommonTree tree;
 1034  20 
         public Object getTree() { return tree; }
 1035   
     };
 1036   
 
 1037   
     // $ANTLR start "rangeOp"
 1038   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:77:1: rangeOp : from= rangeopArg RANGEOP to= rangeopArg -> ^( RANGEOP $from $to) ;
 1039   
     public final PropertyExpressionParser.rangeOp_return rangeOp() throws RecognitionException {
 1040  1422 
         PropertyExpressionParser.rangeOp_return retval = new PropertyExpressionParser.rangeOp_return();
 1041  1422 
         retval.start = input.LT(1);
 1042   
 
 1043  1422 
         CommonTree root_0 = null;
 1044   
 
 1045  1422 
         Token RANGEOP28=null;
 1046  1422 
         PropertyExpressionParser.rangeopArg_return from = null;
 1047   
 
 1048  1422 
         PropertyExpressionParser.rangeopArg_return to = null;
 1049   
 
 1050   
 
 1051  1422 
         CommonTree RANGEOP28_tree=null;
 1052  1422 
         RewriteRuleTokenStream stream_RANGEOP=new RewriteRuleTokenStream(adaptor,"token RANGEOP");
 1053  1422 
         RewriteRuleSubtreeStream stream_rangeopArg=new RewriteRuleSubtreeStream(adaptor,"rule rangeopArg");
 1054   
         try {
 1055   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:78:2: (from= rangeopArg RANGEOP to= rangeopArg -> ^( RANGEOP $from $to) )
 1056   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:78:4: from= rangeopArg RANGEOP to= rangeopArg
 1057   
             {
 1058  1422 
             pushFollow(FOLLOW_rangeopArg_in_rangeOp352);
 1059  1422 
             from=rangeopArg();
 1060   
 
 1061  1422 
             state._fsp--;
 1062  1422 
             if (state.failed) return retval;
 1063  1420 
             if ( state.backtracking==0 ) stream_rangeopArg.add(from.getTree());
 1064  1420 
             RANGEOP28=(Token)match(input,RANGEOP,FOLLOW_RANGEOP_in_rangeOp355); if (state.failed) return retval;
 1065  40 
             if ( state.backtracking==0 ) stream_RANGEOP.add(RANGEOP28);
 1066   
 
 1067  40 
             pushFollow(FOLLOW_rangeopArg_in_rangeOp359);
 1068  40 
             to=rangeopArg();
 1069   
 
 1070  40 
             state._fsp--;
 1071  40 
             if (state.failed) return retval;
 1072  40 
             if ( state.backtracking==0 ) stream_rangeopArg.add(to.getTree());
 1073   
 
 1074   
 
 1075   
             // AST REWRITE
 1076   
             // elements: to, from, RANGEOP
 1077   
             // token labels:
 1078   
             // rule labels: to, from, retval
 1079   
             // token list labels:
 1080   
             // rule list labels:
 1081  40 
             if ( state.backtracking==0 ) {
 1082  20 
             retval.tree = root_0;
 1083  20 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"token to",to!=null?to.tree:null);
 1084  20 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"token from",from!=null?from.tree:null);
 1085  20 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 1086   
 
 1087  20 
             root_0 = (CommonTree)adaptor.nil();
 1088   
             // 78:43: -> ^( RANGEOP $from $to)
 1089   
             {
 1090   
                 // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:78:46: ^( RANGEOP $from $to)
 1091   
                 {
 1092  20 
                 CommonTree root_1 = (CommonTree)adaptor.nil();
 1093  20 
                 root_1 = (CommonTree)adaptor.becomeRoot(stream_RANGEOP.nextNode(), root_1);
 1094   
 
 1095  20 
                 adaptor.addChild(root_1, stream_from.nextTree());
 1096  20 
                 adaptor.addChild(root_1, stream_to.nextTree());
 1097   
 
 1098  20 
                 adaptor.addChild(root_0, root_1);
 1099   
                 }
 1100   
 
 1101   
             }
 1102   
 
 1103  20 
             retval.tree = root_0;}
 1104   
             }
 1105   
 
 1106  40 
             retval.stop = input.LT(-1);
 1107   
 
 1108  40 
             if ( state.backtracking==0 ) {
 1109   
 
 1110  20 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1111  20 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1112   
             }
 1113   
         }
 1114  0 
         catch (RecognitionException re) {
 1115  0 
             reportError(re);
 1116  0 
             recover(input,re);
 1117  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1118   
 
 1119   
         }
 1120  0 
         finally {
 1121  40 
         }
 1122  40 
         return retval;
 1123   
     }
 1124   
     // $ANTLR end "rangeOp"
 1125   
 
 1126  1462 
     public static class rangeopArg_return extends ParserRuleReturnScope {
 1127   
         CommonTree tree;
 1128  40 
         public Object getTree() { return tree; }
 1129   
     };
 1130   
 
 1131   
     // $ANTLR start "rangeopArg"
 1132   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:81:1: rangeopArg : ( INTEGER | propertyChain );
 1133   
     public final PropertyExpressionParser.rangeopArg_return rangeopArg() throws RecognitionException {
 1134  1462 
         PropertyExpressionParser.rangeopArg_return retval = new PropertyExpressionParser.rangeopArg_return();
 1135  1462 
         retval.start = input.LT(1);
 1136   
 
 1137  1462 
         CommonTree root_0 = null;
 1138   
 
 1139  1462 
         Token INTEGER29=null;
 1140  1462 
         PropertyExpressionParser.propertyChain_return propertyChain30 = null;
 1141   
 
 1142   
 
 1143  1462 
         CommonTree INTEGER29_tree=null;
 1144   
 
 1145   
         try {
 1146   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:82:2: ( INTEGER | propertyChain )
 1147  1462 
             int alt6=2;
 1148  1462 
             int LA6_0 = input.LA(1);
 1149   
 
 1150  1462 
             if ( (LA6_0==INTEGER) ) {
 1151  146 
                 alt6=1;
 1152   
             }
 1153  1316 
             else if ( (LA6_0==IDENTIFIER) ) {
 1154  1316 
                 alt6=2;
 1155   
             }
 1156   
             else {
 1157  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 1158  0 
                 NoViableAltException nvae =
 1159   
                     new NoViableAltException("", 6, 0, input);
 1160   
 
 1161  0 
                 throw nvae;
 1162   
             }
 1163  1462 
             switch (alt6) {
 1164   
                 case 1 :
 1165   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:82:4: INTEGER
 1166   
                     {
 1167  146 
                     root_0 = (CommonTree)adaptor.nil();
 1168   
 
 1169  146 
                     INTEGER29=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_rangeopArg385); if (state.failed) return retval;
 1170  146 
                     if ( state.backtracking==0 ) {
 1171  36 
                     INTEGER29_tree = (CommonTree)adaptor.create(INTEGER29);
 1172  36 
                     adaptor.addChild(root_0, INTEGER29_tree);
 1173   
                     }
 1174   
 
 1175   
                     }
 1176   
                     break;
 1177   
                 case 2 :
 1178   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:83:4: propertyChain
 1179   
                     {
 1180  1316 
                     root_0 = (CommonTree)adaptor.nil();
 1181   
 
 1182  1316 
                     pushFollow(FOLLOW_propertyChain_in_rangeopArg390);
 1183  1316 
                     propertyChain30=propertyChain();
 1184   
 
 1185  1316 
                     state._fsp--;
 1186  1316 
                     if (state.failed) return retval;
 1187  1314 
                     if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyChain30.getTree());
 1188   
 
 1189   
                     }
 1190   
                     break;
 1191   
 
 1192   
             }
 1193  1460 
             retval.stop = input.LT(-1);
 1194   
 
 1195  1460 
             if ( state.backtracking==0 ) {
 1196   
 
 1197  40 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1198  40 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1199   
             }
 1200   
         }
 1201  0 
         catch (RecognitionException re) {
 1202  0 
             reportError(re);
 1203  0 
             recover(input,re);
 1204  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1205   
 
 1206   
         }
 1207  0 
         finally {
 1208  1460 
         }
 1209  1460 
         return retval;
 1210   
     }
 1211   
     // $ANTLR end "rangeopArg"
 1212   
 
 1213  22 
     public static class list_return extends ParserRuleReturnScope {
 1214   
         CommonTree tree;
 1215  6 
         public Object getTree() { return tree; }
 1216   
     };
 1217   
 
 1218   
     // $ANTLR start "list"
 1219   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:86:1: list : ( LBRACKET RBRACKET -> ^( LIST ) | LBRACKET expressionList RBRACKET -> ^( LIST expressionList ) );
 1220   
     public final PropertyExpressionParser.list_return list() throws RecognitionException {
 1221  22 
         PropertyExpressionParser.list_return retval = new PropertyExpressionParser.list_return();
 1222  22 
         retval.start = input.LT(1);
 1223   
 
 1224  22 
         CommonTree root_0 = null;
 1225   
 
 1226  22 
         Token LBRACKET31=null;
 1227  22 
         Token RBRACKET32=null;
 1228  22 
         Token LBRACKET33=null;
 1229  22 
         Token RBRACKET35=null;
 1230  22 
         PropertyExpressionParser.expressionList_return expressionList34 = null;
 1231   
 
 1232   
 
 1233  22 
         CommonTree LBRACKET31_tree=null;
 1234  22 
         CommonTree RBRACKET32_tree=null;
 1235  22 
         CommonTree LBRACKET33_tree=null;
 1236  22 
         CommonTree RBRACKET35_tree=null;
 1237  22 
         RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
 1238  22 
         RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
 1239  22 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 1240   
         try {
 1241   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:86:6: ( LBRACKET RBRACKET -> ^( LIST ) | LBRACKET expressionList RBRACKET -> ^( LIST expressionList ) )
 1242  22 
             int alt7=2;
 1243  22 
             int LA7_0 = input.LA(1);
 1244   
 
 1245  22 
             if ( (LA7_0==LBRACKET) ) {
 1246  22 
                 int LA7_1 = input.LA(2);
 1247   
 
 1248  22 
                 if ( (LA7_1==RBRACKET) ) {
 1249  2 
                     alt7=1;
 1250   
                 }
 1251  20 
                 else if ( (LA7_1==INTEGER||LA7_1==DECIMAL||LA7_1==LBRACKET||LA7_1==BANG||(LA7_1>=NULL && LA7_1<=IDENTIFIER)||LA7_1==STRING) ) {
 1252  20 
                     alt7=2;
 1253   
                 }
 1254   
                 else {
 1255  0 
                     if (state.backtracking>0) {state.failed=true; return retval;}
 1256  0 
                     NoViableAltException nvae =
 1257   
                         new NoViableAltException("", 7, 1, input);
 1258   
 
 1259  0 
                     throw nvae;
 1260   
                 }
 1261  22 
             }
 1262   
             else {
 1263  0 
                 if (state.backtracking>0) {state.failed=true; return retval;}
 1264  0 
                 NoViableAltException nvae =
 1265   
                     new NoViableAltException("", 7, 0, input);
 1266   
 
 1267  0 
                 throw nvae;
 1268   
             }
 1269  22 
             switch (alt7) {
 1270   
                 case 1 :
 1271   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:86:8: LBRACKET RBRACKET
 1272   
                     {
 1273  2 
                     LBRACKET31=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_list402); if (state.failed) return retval;
 1274  2 
                     if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET31);
 1275   
 
 1276  2 
                     RBRACKET32=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_list404); if (state.failed) return retval;
 1277  2 
                     if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET32);
 1278   
 
 1279   
 
 1280   
 
 1281   
                     // AST REWRITE
 1282   
                     // elements:
 1283   
                     // token labels:
 1284   
                     // rule labels: retval
 1285   
                     // token list labels:
 1286   
                     // rule list labels:
 1287  2 
                     if ( state.backtracking==0 ) {
 1288  2 
                     retval.tree = root_0;
 1289  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 1290   
 
 1291  2 
                     root_0 = (CommonTree)adaptor.nil();
 1292   
                     // 86:26: -> ^( LIST )
 1293   
                     {
 1294   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:86:29: ^( LIST )
 1295   
                         {
 1296  2 
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 1297  2 
                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LIST, "LIST"), root_1);
 1298   
 
 1299  2 
                         adaptor.addChild(root_0, root_1);
 1300   
                         }
 1301   
 
 1302   
                     }
 1303   
 
 1304  2 
                     retval.tree = root_0;}
 1305   
                     }
 1306   
                     break;
 1307   
                 case 2 :
 1308   
                     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:87:4: LBRACKET expressionList RBRACKET
 1309   
                     {
 1310  20 
                     LBRACKET33=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_list415); if (state.failed) return retval;
 1311  20 
                     if ( state.backtracking==0 ) stream_LBRACKET.add(LBRACKET33);
 1312   
 
 1313  20 
                     pushFollow(FOLLOW_expressionList_in_list417);
 1314  20 
                     expressionList34=expressionList();
 1315   
 
 1316  20 
                     state._fsp--;
 1317  20 
                     if (state.failed) return retval;
 1318  20 
                     if ( state.backtracking==0 ) stream_expressionList.add(expressionList34.getTree());
 1319  20 
                     RBRACKET35=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_list419); if (state.failed) return retval;
 1320  20 
                     if ( state.backtracking==0 ) stream_RBRACKET.add(RBRACKET35);
 1321   
 
 1322   
 
 1323   
 
 1324   
                     // AST REWRITE
 1325   
                     // elements: expressionList
 1326   
                     // token labels:
 1327   
                     // rule labels: retval
 1328   
                     // token list labels:
 1329   
                     // rule list labels:
 1330  20 
                     if ( state.backtracking==0 ) {
 1331  4 
                     retval.tree = root_0;
 1332  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 1333   
 
 1334  4 
                     root_0 = (CommonTree)adaptor.nil();
 1335   
                     // 87:37: -> ^( LIST expressionList )
 1336   
                     {
 1337   
                         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:87:40: ^( LIST expressionList )
 1338   
                         {
 1339  4 
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 1340  4 
                         root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LIST, "LIST"), root_1);
 1341   
 
 1342  4 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 1343   
 
 1344  4 
                         adaptor.addChild(root_0, root_1);
 1345   
                         }
 1346   
 
 1347   
                     }
 1348   
 
 1349  4 
                     retval.tree = root_0;}
 1350   
                     }
 1351   
                     break;
 1352   
 
 1353   
             }
 1354  22 
             retval.stop = input.LT(-1);
 1355   
 
 1356  22 
             if ( state.backtracking==0 ) {
 1357   
 
 1358  6 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1359  6 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1360   
             }
 1361   
         }
 1362  0 
         catch (RecognitionException re) {
 1363  0 
             reportError(re);
 1364  0 
             recover(input,re);
 1365  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1366   
 
 1367   
         }
 1368  0 
         finally {
 1369  22 
         }
 1370  22 
         return retval;
 1371   
     }
 1372   
     // $ANTLR end "list"
 1373   
 
 1374  22 
     public static class notOp_return extends ParserRuleReturnScope {
 1375   
         CommonTree tree;
 1376  6 
         public Object getTree() { return tree; }
 1377   
     };
 1378   
 
 1379   
     // $ANTLR start "notOp"
 1380   
     // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:91:1: notOp : BANG expression -> ^( NOT expression ) ;
 1381   
     public final PropertyExpressionParser.notOp_return notOp() throws RecognitionException {
 1382  22 
         PropertyExpressionParser.notOp_return retval = new PropertyExpressionParser.notOp_return();
 1383  22 
         retval.start = input.LT(1);
 1384   
 
 1385  22 
         CommonTree root_0 = null;
 1386   
 
 1387  22 
         Token BANG36=null;
 1388  22 
         PropertyExpressionParser.expression_return expression37 = null;
 1389   
 
 1390   
 
 1391  22 
         CommonTree BANG36_tree=null;
 1392  22 
         RewriteRuleTokenStream stream_BANG=new RewriteRuleTokenStream(adaptor,"token BANG");
 1393  22 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1394   
         try {
 1395   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:91:8: ( BANG expression -> ^( NOT expression ) )
 1396   
             // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:91:10: BANG expression
 1397   
             {
 1398  22 
             BANG36=(Token)match(input,BANG,FOLLOW_BANG_in_notOp442); if (state.failed) return retval;
 1399  22 
             if ( state.backtracking==0 ) stream_BANG.add(BANG36);
 1400   
 
 1401  22 
             pushFollow(FOLLOW_expression_in_notOp444);
 1402  22 
             expression37=expression();
 1403   
 
 1404  22 
             state._fsp--;
 1405  22 
             if (state.failed) return retval;
 1406  22 
             if ( state.backtracking==0 ) stream_expression.add(expression37.getTree());
 1407   
 
 1408   
 
 1409   
             // AST REWRITE
 1410   
             // elements: expression
 1411   
             // token labels:
 1412   
             // rule labels: retval
 1413   
             // token list labels:
 1414   
             // rule list labels:
 1415  22 
             if ( state.backtracking==0 ) {
 1416  6 
             retval.tree = root_0;
 1417  6 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);
 1418   
 
 1419  6 
             root_0 = (CommonTree)adaptor.nil();
 1420   
             // 91:26: -> ^( NOT expression )
 1421   
             {
 1422   
                 // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:91:29: ^( NOT expression )
 1423   
                 {
 1424  6 
                 CommonTree root_1 = (CommonTree)adaptor.nil();
 1425  6 
                 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(NOT, "NOT"), root_1);
 1426   
 
 1427  6 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 1428   
 
 1429  6 
                 adaptor.addChild(root_0, root_1);
 1430   
                 }
 1431   
 
 1432   
             }
 1433   
 
 1434  6 
             retval.tree = root_0;}
 1435   
             }
 1436   
 
 1437  22 
             retval.stop = input.LT(-1);
 1438   
 
 1439  22 
             if ( state.backtracking==0 ) {
 1440   
 
 1441  6 
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1442  6 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1443   
             }
 1444   
         }
 1445  0 
         catch (RecognitionException re) {
 1446  0 
             reportError(re);
 1447  0 
             recover(input,re);
 1448  0 
             retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1449   
 
 1450   
         }
 1451  0 
         finally {
 1452  22 
         }
 1453  22 
         return retval;
 1454   
     }
 1455   
     // $ANTLR end "notOp"
 1456   
 
 1457   
     // $ANTLR start synpred2_PropertyExpressionParser
 1458   
     public final void synpred2_PropertyExpressionParser_fragment() throws RecognitionException {
 1459   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:47:4: ( rangeOp )
 1460   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:47:4: rangeOp
 1461   
         {
 1462  1402 
         pushFollow(FOLLOW_rangeOp_in_synpred2_PropertyExpressionParser142);
 1463  1402 
         rangeOp();
 1464   
 
 1465  1402 
         state._fsp--;
 1466  1402 
         if (state.failed) return ;
 1467   
 
 1468   
         }
 1469  20 
     }
 1470   
     // $ANTLR end synpred2_PropertyExpressionParser
 1471   
 
 1472   
     // $ANTLR start synpred3_PropertyExpressionParser
 1473   
     public final void synpred3_PropertyExpressionParser_fragment() throws RecognitionException {
 1474   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:48:4: ( constant )
 1475   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:48:4: constant
 1476   
         {
 1477  74 
         pushFollow(FOLLOW_constant_in_synpred3_PropertyExpressionParser147);
 1478  74 
         constant();
 1479   
 
 1480  74 
         state._fsp--;
 1481  74 
         if (state.failed) return ;
 1482   
 
 1483   
         }
 1484  74 
     }
 1485   
     // $ANTLR end synpred3_PropertyExpressionParser
 1486   
 
 1487   
     // $ANTLR start synpred4_PropertyExpressionParser
 1488   
     public final void synpred4_PropertyExpressionParser_fragment() throws RecognitionException {
 1489   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:49:4: ( propertyChain )
 1490   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:49:4: propertyChain
 1491   
         {
 1492  1308 
         pushFollow(FOLLOW_propertyChain_in_synpred4_PropertyExpressionParser152);
 1493  1308 
         propertyChain();
 1494   
 
 1495  1308 
         state._fsp--;
 1496  1308 
         if (state.failed) return ;
 1497   
 
 1498   
         }
 1499  1306 
     }
 1500   
     // $ANTLR end synpred4_PropertyExpressionParser
 1501   
 
 1502   
     // $ANTLR start synpred11_PropertyExpressionParser
 1503   
     public final void synpred11_PropertyExpressionParser_fragment() throws RecognitionException {
 1504   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:59:4: ( term DEREF propertyChain )
 1505   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:59:4: term DEREF propertyChain
 1506   
         {
 1507  5730 
         pushFollow(FOLLOW_term_in_synpred11_PropertyExpressionParser210);
 1508  5730 
         term();
 1509   
 
 1510  5730 
         state._fsp--;
 1511  5730 
         if (state.failed) return ;
 1512  5726 
         match(input,DEREF,FOLLOW_DEREF_in_synpred11_PropertyExpressionParser212); if (state.failed) return ;
 1513  894 
         pushFollow(FOLLOW_propertyChain_in_synpred11_PropertyExpressionParser214);
 1514  894 
         propertyChain();
 1515   
 
 1516  894 
         state._fsp--;
 1517  894 
         if (state.failed) return ;
 1518   
 
 1519   
         }
 1520  894 
     }
 1521   
     // $ANTLR end synpred11_PropertyExpressionParser
 1522   
 
 1523   
     // $ANTLR start synpred12_PropertyExpressionParser
 1524   
     public final void synpred12_PropertyExpressionParser_fragment() throws RecognitionException {
 1525   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:60:4: ( term SAFEDEREF propertyChain )
 1526   
         // org/apache/tapestry5/internal/antlr/PropertyExpressionParser.g:60:4: term SAFEDEREF propertyChain
 1527   
         {
 1528  4836 
         pushFollow(FOLLOW_term_in_synpred12_PropertyExpressionParser229);
 1529  4836 
         term();
 1530   
 
 1531  4836 
         state._fsp--;
 1532  4836 
         if (state.failed) return ;
 1533  4832 
         match(input,SAFEDEREF,FOLLOW_SAFEDEREF_in_synpred12_PropertyExpressionParser231); if (state.failed) return ;
 1534  6 
         pushFollow(FOLLOW_propertyChain_in_synpred12_PropertyExpressionParser233);
 1535  6 
         propertyChain();
 1536   
 
 1537  6 
         state._fsp--;
 1538  6 
         if (state.failed) return ;
 1539   
 
 1540   
         }
 1541  6 
     }
 1542   
     // $ANTLR end synpred12_PropertyExpressionParser
 1543   
 
 1544   
     // Delegated rules
 1545   
 
 1546   
     public final boolean synpred4_PropertyExpressionParser() {
 1547  1308 
         state.backtracking++;
 1548  1308 
         int start = input.mark();
 1549   
         try {
 1550  1308 
             synpred4_PropertyExpressionParser_fragment(); // can never throw exception
 1551  0 
         } catch (RecognitionException re) {
 1552  0 
             System.err.println("impossible: "+re);
 1553  1308 
         }
 1554  1308 
         boolean success = !state.failed;
 1555  1308 
         input.rewind(start);
 1556  1308 
         state.backtracking--;
 1557  1308 
         state.failed=false;
 1558  1308 
         return success;
 1559   
     }
 1560   
     public final boolean synpred12_PropertyExpressionParser() {
 1561  4836 
         state.backtracking++;
 1562  4836 
         int start = input.mark();
 1563   
         try {
 1564  4836 
             synpred12_PropertyExpressionParser_fragment(); // can never throw exception
 1565  0 
         } catch (RecognitionException re) {
 1566  0 
             System.err.println("impossible: "+re);
 1567  4836 
         }
 1568  4836 
         boolean success = !state.failed;
 1569  4836 
         input.rewind(start);
 1570  4836 
         state.backtracking--;
 1571  4836 
         state.failed=false;
 1572  4836 
         return success;
 1573   
     }
 1574   
     public final boolean synpred11_PropertyExpressionParser() {
 1575  5730 
         state.backtracking++;
 1576  5730 
         int start = input.mark();
 1577   
         try {
 1578  5730 
             synpred11_PropertyExpressionParser_fragment(); // can never throw exception
 1579  0 
         } catch (RecognitionException re) {
 1580  0 
             System.err.println("impossible: "+re);
 1581  5730 
         }
 1582  5730 
         boolean success = !state.failed;
 1583  5730 
         input.rewind(start);
 1584  5730 
         state.backtracking--;
 1585  5730 
         state.failed=false;
 1586  5730 
         return success;
 1587   
     }
 1588   
     public final boolean synpred3_PropertyExpressionParser() {
 1589  74 
         state.backtracking++;
 1590  74 
         int start = input.mark();
 1591   
         try {
 1592  74 
             synpred3_PropertyExpressionParser_fragment(); // can never throw exception
 1593  0 
         } catch (RecognitionException re) {
 1594  0 
             System.err.println("impossible: "+re);
 1595  74 
         }
 1596  74 
         boolean success = !state.failed;
 1597  74 
         input.rewind(start);
 1598  74 
         state.backtracking--;
 1599  74 
         state.failed=false;
 1600  74 
         return success;
 1601   
     }
 1602   
     public final boolean synpred2_PropertyExpressionParser() {
 1603  1402 
         state.backtracking++;
 1604  1402 
         int start = input.mark();
 1605   
         try {
 1606  1402 
             synpred2_PropertyExpressionParser_fragment(); // can never throw exception
 1607  0 
         } catch (RecognitionException re) {
 1608  0 
             System.err.println("impossible: "+re);
 1609  1402 
         }
 1610  1402 
         boolean success = !state.failed;
 1611  1402 
         input.rewind(start);
 1612  1402 
         state.backtracking--;
 1613  1402 
         state.failed=false;
 1614  1402 
         return success;
 1615   
     }
 1616   
 
 1617   
 
 1618   
 
 1619   
 
 1620  2 
     public static final BitSet FOLLOW_expression_in_start122 = new BitSet(new long[]{0x0000000000000000L});
 1621  2 
     public static final BitSet FOLLOW_EOF_in_start125 = new BitSet(new long[]{0x0000000000000002L});
 1622  2 
     public static final BitSet FOLLOW_keyword_in_expression137 = new BitSet(new long[]{0x0000000000000002L});
 1623  2 
     public static final BitSet FOLLOW_rangeOp_in_expression142 = new BitSet(new long[]{0x0000000000000002L});
 1624  2 
     public static final BitSet FOLLOW_constant_in_expression147 = new BitSet(new long[]{0x0000000000000002L});
 1625  2 
     public static final BitSet FOLLOW_propertyChain_in_expression152 = new BitSet(new long[]{0x0000000000000002L});
 1626  2 
     public static final BitSet FOLLOW_list_in_expression157 = new BitSet(new long[]{0x0000000000000002L});
 1627  2 
     public static final BitSet FOLLOW_notOp_in_expression162 = new BitSet(new long[]{0x0000000000000002L});
 1628  2 
     public static final BitSet FOLLOW_set_in_keyword0 = new BitSet(new long[]{0x0000000000000002L});
 1629  2 
     public static final BitSet FOLLOW_set_in_constant0 = new BitSet(new long[]{0x0000000000000002L});
 1630  2 
     public static final BitSet FOLLOW_term_in_propertyChain210 = new BitSet(new long[]{0x0000000000000020L});
 1631  2 
     public static final BitSet FOLLOW_DEREF_in_propertyChain212 = new BitSet(new long[]{0x0000000200000000L});
 1632  2 
     public static final BitSet FOLLOW_propertyChain_in_propertyChain214 = new BitSet(new long[]{0x0000000000000002L});
 1633  2 
     public static final BitSet FOLLOW_term_in_propertyChain229 = new BitSet(new long[]{0x0000000400000000L});
 1634  2 
     public static final BitSet FOLLOW_SAFEDEREF_in_propertyChain231 = new BitSet(new long[]{0x0000000200000000L});
 1635  2 
     public static final BitSet FOLLOW_propertyChain_in_propertyChain233 = new BitSet(new long[]{0x0000000000000002L});
 1636  2 
     public static final BitSet FOLLOW_term_in_propertyChain248 = new BitSet(new long[]{0x0000000000000002L});
 1637  2 
     public static final BitSet FOLLOW_IDENTIFIER_in_term260 = new BitSet(new long[]{0x0000000000000002L});
 1638  2 
     public static final BitSet FOLLOW_methodInvocation_in_term265 = new BitSet(new long[]{0x0000000000000002L});
 1639  2 
     public static final BitSet FOLLOW_IDENTIFIER_in_methodInvocation279 = new BitSet(new long[]{0x0000000000000800L});
 1640  2 
     public static final BitSet FOLLOW_LPAREN_in_methodInvocation281 = new BitSet(new long[]{0x0000000000001000L});
 1641  2 
     public static final BitSet FOLLOW_RPAREN_in_methodInvocation283 = new BitSet(new long[]{0x0000000000000002L});
 1642  2 
     public static final BitSet FOLLOW_IDENTIFIER_in_methodInvocation299 = new BitSet(new long[]{0x0000000000000800L});
 1643  2 
     public static final BitSet FOLLOW_LPAREN_in_methodInvocation301 = new BitSet(new long[]{0x00000013E0012090L});
 1644  2 
     public static final BitSet FOLLOW_expressionList_in_methodInvocation303 = new BitSet(new long[]{0x0000000000001000L});
 1645  2 
     public static final BitSet FOLLOW_RPAREN_in_methodInvocation305 = new BitSet(new long[]{0x0000000000000002L});
 1646  2 
     public static final BitSet FOLLOW_expression_in_expressionList329 = new BitSet(new long[]{0x0000000000008002L});
 1647  2 
     public static final BitSet FOLLOW_COMMA_in_expressionList332 = new BitSet(new long[]{0x00000013E0012090L});
 1648  2 
     public static final BitSet FOLLOW_expression_in_expressionList335 = new BitSet(new long[]{0x0000000000008002L});
 1649  2 
     public static final BitSet FOLLOW_rangeopArg_in_rangeOp352 = new BitSet(new long[]{0x0000000000000040L});
 1650  2 
     public static final BitSet FOLLOW_RANGEOP_in_rangeOp355 = new BitSet(new long[]{0x0000000200000010L});
 1651  2 
     public static final BitSet FOLLOW_rangeopArg_in_rangeOp359 = new BitSet(new long[]{0x0000000000000002L});
 1652  2 
     public static final BitSet FOLLOW_INTEGER_in_rangeopArg385 = new BitSet(new long[]{0x0000000000000002L});
 1653  2 
     public static final BitSet FOLLOW_propertyChain_in_rangeopArg390 = new BitSet(new long[]{0x0000000000000002L});
 1654  2 
     public static final BitSet FOLLOW_LBRACKET_in_list402 = new BitSet(new long[]{0x0000000000004000L});
 1655  2 
     public static final BitSet FOLLOW_RBRACKET_in_list404 = new BitSet(new long[]{0x0000000000000002L});
 1656  2 
     public static final BitSet FOLLOW_LBRACKET_in_list415 = new BitSet(new long[]{0x00000013E0012090L});
 1657  2 
     public static final BitSet FOLLOW_expressionList_in_list417 = new BitSet(new long[]{0x0000000000004000L});
 1658  2 
     public static final BitSet FOLLOW_RBRACKET_in_list419 = new BitSet(new long[]{0x0000000000000002L});
 1659  2 
     public static final BitSet FOLLOW_BANG_in_notOp442 = new BitSet(new long[]{0x00000013E0012090L});
 1660  2 
     public static final BitSet FOLLOW_expression_in_notOp444 = new BitSet(new long[]{0x0000000000000002L});
 1661  2 
     public static final BitSet FOLLOW_rangeOp_in_synpred2_PropertyExpressionParser142 = new BitSet(new long[]{0x0000000000000002L});
 1662  2 
     public static final BitSet FOLLOW_constant_in_synpred3_PropertyExpressionParser147 = new BitSet(new long[]{0x0000000000000002L});
 1663  2 
     public static final BitSet FOLLOW_propertyChain_in_synpred4_PropertyExpressionParser152 = new BitSet(new long[]{0x0000000000000002L});
 1664  2 
     public static final BitSet FOLLOW_term_in_synpred11_PropertyExpressionParser210 = new BitSet(new long[]{0x0000000000000020L});
 1665  2 
     public static final BitSet FOLLOW_DEREF_in_synpred11_PropertyExpressionParser212 = new BitSet(new long[]{0x0000000200000000L});
 1666  2 
     public static final BitSet FOLLOW_propertyChain_in_synpred11_PropertyExpressionParser214 = new BitSet(new long[]{0x0000000000000002L});
 1667  2 
     public static final BitSet FOLLOW_term_in_synpred12_PropertyExpressionParser229 = new BitSet(new long[]{0x0000000400000000L});
 1668  2 
     public static final BitSet FOLLOW_SAFEDEREF_in_synpred12_PropertyExpressionParser231 = new BitSet(new long[]{0x0000000200000000L});
 1669  2 
     public static final BitSet FOLLOW_propertyChain_in_synpred12_PropertyExpressionParser233 = new BitSet(new long[]{0x0000000000000002L});
 1670   
 
 1671   
 }
Report generated by Cobertura 1.9 on 5/8/09 7:24 AM.