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