00001
00002
00003 package edu.mit.csail.sdg.squander.parser;
00004
00005 import edu.mit.csail.sdg.squander.spec.*;
00006
00007
00008 import org.antlr.runtime.*;
00009 import java.util.Stack;
00010 import java.util.List;
00011 import java.util.ArrayList;
00012 import java.util.Map;
00013 import java.util.HashMap;
00014
00015 import org.antlr.runtime.tree.*;
00016
00155 @SuppressWarnings({"unused"})
00156 public class JFSLParser extends Parser {
00157 public static final String[] tokenNames = new String[] {
00158 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DECLARATION", "FRAME", "NULL", "DECL_SET", "DECL_SEQ", "DECL_NONE", "FRAME_LOCATION", "FRAME_ALL", "BINARY", "UNARY", "QUANTIFY", "CONDITIONAL", "ARGUMENTS", "CHAIN", "JOIN", "JOIN_REFLEXIVE", "BRACKET", "CALL", "OLD", "ARGUMENT", "AMBIGUOUS", "FIELD", "CAST", "CLASS_DESIGNATOR", "THIS_VAR", "SUPER_VAR", "IDENTIFIER", "VOID", "RETURN_VAR", "THROW_VAR", "DECLS", "OP_EQ", "OP_NEQ", "OP_OR", "OP_AND", "OP_NOT", "OP_BIT_OR", "OP_BIT_XOR", "OP_INTERSECTION", "OP_BIT_AND_OR_INTERSECTION", "OP_TRANSPOSE", "OP_BIT_NOT_OR_TRANSPOSE", "OP_CLOSURE", "OP_GT", "OP_LT", "OP_GEQ", "OP_LEQ", "OP_SHL", "OP_SHR", "OP_USHR", "OP_INSTANCEOF", "OP_PLUS", "OP_UNION", "OP_PLUS_OR_UNION", "OP_MINUS", "OP_DIFFERENCE", "OP_MINUS_OR_DIFFERENCE", "OP_RELATIONAL_OVERRIDE", "OP_RELATIONAL_COMPOSE", "OP_TIMES", "OP_DIVIDE", "OP_MOD", "OP_EQUIV", "OP_NEQUIV", "OP_IMPLIES", "OP_SET_ONE", "OP_SET_SOME", "OP_SET_NO", "OP_SET_LONE", "OP_SET_NUM", "OP_SET_SUM", "OP_SET_ALL", "OP_SET_EXISTS", "OP_SET_COMPREHENSION", "OP_SET_SUBSET", "OP_NSET_SUBSET", "LIT_TRUE", "LIT_FALSE", "LIT_NULL", "TYPE_BOOLEAN", "TYPE_CHAR", "TYPE_BYTE", "TYPE_SHORT", "TYPE_INT", "TYPE_LONG", "TYPE_FLOAT", "TYPE_DOUBLE", "TYPE_REF", "TYPE_ARRAY", "FILE", "INVARIANT", "SPECFIELD", "PACKAGE", "TYPE_DECLARATION", "TYPE_PARAMETERS", "IMPORT", "METHOD", "METHOD_PARAMETERS", "SPECCASE", "SPECIFICATION", "REQUIRES", "ENSURES", "MODIFIES", "THROWS", "HELPER", "PURE", "Identifier", "FloatingPointLiteral", "CharacterLiteral", "StringLiteral", "HexLiteral", "OctalLiteral", "DecimalLiteral", "HexDigit", "IntegerTypeSuffix", "Exponent", "FloatTypeSuffix", "EscapeSequence", "UnicodeEscape", "OctalEscape", "Letter", "JavaIDDigit", "WS", "'package'", "';'", "'.'", "'import'", "'class'", "'interface'", "'{'", "'}'", "'<'", "','", "'>'", "'@Invariant'", "'('", "')'", "'@SpecField'", "'@Requires'", "'@Ensures'", "'@Throws'", "'@Modifies'", "'@Helper'", "'@Pure'", "'public'", "'private'", "':'", "'from'", "'|'", "'set'", "'seq'", "'*'", "'true'", "'false'", "'null'", "'boolean'", "'char'", "'byte'", "'short'", "'int'", "'long'", "'float'", "'double'", "'['", "']'", "'?'", "'='", "'!'", "'||'", "'&&'", "'^'", "'&'", "'instanceof'", "'in'", "'+'", "'-'", "'#'", "'/'", "'%'", "'@'", "'++'", "'->'", "'~'", "'return'", "'throw'", "'this'", "'super'", "'@old'", "'@arg'", "'one'", "'some'", "'lone'", "'no'", "'sum'", "'all'", "'exists'"
00159 };
00160 public static final int PACKAGE=96;
00161 public static final int T__159=159;
00162 public static final int T__158=158;
00163 public static final int OP_INSTANCEOF=54;
00164 public static final int OP_SET_ALL=75;
00165 public static final int OP_GEQ=49;
00166 public static final int TYPE_INT=87;
00167 public static final int OP_SET_LONE=72;
00168 public static final int OP_SET_NO=71;
00169 public static final int T__160=160;
00170 public static final int T__167=167;
00171 public static final int OP_INTERSECTION=42;
00172 public static final int T__168=168;
00173 public static final int EOF=-1;
00174 public static final int LIT_FALSE=81;
00175 public static final int T__165=165;
00176 public static final int T__166=166;
00177 public static final int T__163=163;
00178 public static final int T__164=164;
00179 public static final int T__161=161;
00180 public static final int T__162=162;
00181 public static final int OP_MOD=65;
00182 public static final int OP_EQ=35;
00183 public static final int IMPORT=99;
00184 public static final int T__148=148;
00185 public static final int T__147=147;
00186 public static final int T__149=149;
00187 public static final int TYPE_BYTE=85;
00188 public static final int DECL_SET=7;
00189 public static final int DECL_SEQ=8;
00190 public static final int TYPE_PARAMETERS=98;
00191 public static final int T__154=154;
00192 public static final int T__155=155;
00193 public static final int T__156=156;
00194 public static final int T__157=157;
00195 public static final int T__150=150;
00196 public static final int T__151=151;
00197 public static final int T__152=152;
00198 public static final int T__153=153;
00199 public static final int T__139=139;
00200 public static final int T__138=138;
00201 public static final int T__137=137;
00202 public static final int T__136=136;
00203 public static final int THIS_VAR=28;
00204 public static final int IntegerTypeSuffix=118;
00205 public static final int OP_DIFFERENCE=59;
00206 public static final int T__141=141;
00207 public static final int T__142=142;
00208 public static final int FILE=93;
00209 public static final int T__140=140;
00210 public static final int T__145=145;
00211 public static final int T__146=146;
00212 public static final int T__143=143;
00213 public static final int T__144=144;
00214 public static final int OP_SHL=51;
00215 public static final int METHOD_PARAMETERS=101;
00216 public static final int T__128=128;
00217 public static final int T__127=127;
00218 public static final int TYPE_REF=91;
00219 public static final int WS=126;
00220 public static final int T__129=129;
00221 public static final int OP_SHR=52;
00222 public static final int SPECFIELD=95;
00223 public static final int TYPE_CHAR=84;
00224 public static final int FloatingPointLiteral=111;
00225 public static final int JavaIDDigit=125;
00226 public static final int CALL=21;
00227 public static final int SPECIFICATION=103;
00228 public static final int T__130=130;
00229 public static final int T__131=131;
00230 public static final int T__132=132;
00231 public static final int T__133=133;
00232 public static final int CLASS_DESIGNATOR=27;
00233 public static final int CHAIN=17;
00234 public static final int T__134=134;
00235 public static final int T__135=135;
00236 public static final int OP_OR=37;
00237 public static final int AMBIGUOUS=24;
00238 public static final int TYPE_LONG=88;
00239 public static final int HexDigit=117;
00240 public static final int DECLARATION=4;
00241 public static final int ENSURES=105;
00242 public static final int OP_USHR=53;
00243 public static final int ARGUMENT=23;
00244 public static final int OP_NOT=39;
00245 public static final int OP_EQUIV=66;
00246 public static final int OP_SET_SOME=70;
00247 public static final int UNARY=13;
00248 public static final int OP_NEQUIV=67;
00249 public static final int HexLiteral=114;
00250 public static final int OP_DIVIDE=64;
00251 public static final int THROW_VAR=33;
00252 public static final int StringLiteral=113;
00253 public static final int OP_SET_COMPREHENSION=77;
00254 public static final int OP_MINUS_OR_DIFFERENCE=60;
00255 public static final int OctalEscape=123;
00256 public static final int CAST=26;
00257 public static final int OP_BIT_AND_OR_INTERSECTION=43;
00258 public static final int JOIN_REFLEXIVE=19;
00259 public static final int OP_AND=38;
00260 public static final int FloatTypeSuffix=120;
00261 public static final int OctalLiteral=115;
00262 public static final int BRACKET=20;
00263 public static final int OP_RELATIONAL_COMPOSE=62;
00264 public static final int OP_BIT_XOR=41;
00265 public static final int LIT_NULL=82;
00266 public static final int MODIFIES=106;
00267 public static final int TYPE_DOUBLE=90;
00268 public static final int Identifier=110;
00269 public static final int QUANTIFY=14;
00270 public static final int OP_MINUS=58;
00271 public static final int VOID=31;
00272 public static final int OP_LT=48;
00273 public static final int OP_CLOSURE=46;
00274 public static final int DECL_NONE=9;
00275 public static final int OP_SET_SUM=74;
00276 public static final int ARGUMENTS=16;
00277 public static final int NULL=6;
00278 public static final int CONDITIONAL=15;
00279 public static final int INVARIANT=94;
00280 public static final int OLD=22;
00281 public static final int THROWS=107;
00282 public static final int FRAME_LOCATION=10;
00283 public static final int FIELD=25;
00284 public static final int OP_RELATIONAL_OVERRIDE=61;
00285 public static final int OP_PLUS_OR_UNION=57;
00286 public static final int Letter=124;
00287 public static final int EscapeSequence=121;
00288 public static final int TYPE_BOOLEAN=83;
00289 public static final int OP_TRANSPOSE=44;
00290 public static final int CharacterLiteral=112;
00291 public static final int SUPER_VAR=29;
00292 public static final int OP_GT=47;
00293 public static final int Exponent=119;
00294 public static final int LIT_TRUE=80;
00295 public static final int OP_BIT_NOT_OR_TRANSPOSE=45;
00296 public static final int T__199=199;
00297 public static final int TYPE_DECLARATION=97;
00298 public static final int T__198=198;
00299 public static final int PURE=109;
00300 public static final int T__197=197;
00301 public static final int T__196=196;
00302 public static final int T__195=195;
00303 public static final int T__194=194;
00304 public static final int T__193=193;
00305 public static final int T__192=192;
00306 public static final int T__191=191;
00307 public static final int T__190=190;
00308 public static final int IDENTIFIER=30;
00309 public static final int OP_BIT_OR=40;
00310 public static final int OP_SET_SUBSET=78;
00311 public static final int SPECCASE=102;
00312 public static final int T__184=184;
00313 public static final int T__183=183;
00314 public static final int T__186=186;
00315 public static final int T__185=185;
00316 public static final int T__188=188;
00317 public static final int T__187=187;
00318 public static final int TYPE_SHORT=86;
00319 public static final int T__189=189;
00320 public static final int OP_PLUS=55;
00321 public static final int HELPER=108;
00322 public static final int T__180=180;
00323 public static final int TYPE_FLOAT=89;
00324 public static final int OP_SET_EXISTS=76;
00325 public static final int T__182=182;
00326 public static final int OP_NSET_SUBSET=79;
00327 public static final int T__181=181;
00328 public static final int DECLS=34;
00329 public static final int DecimalLiteral=116;
00330 public static final int JOIN=18;
00331 public static final int T__175=175;
00332 public static final int T__174=174;
00333 public static final int OP_SET_NUM=73;
00334 public static final int T__173=173;
00335 public static final int T__172=172;
00336 public static final int TYPE_ARRAY=92;
00337 public static final int T__179=179;
00338 public static final int T__178=178;
00339 public static final int OP_SET_ONE=69;
00340 public static final int REQUIRES=104;
00341 public static final int T__177=177;
00342 public static final int T__176=176;
00343 public static final int UnicodeEscape=122;
00344 public static final int OP_NEQ=36;
00345 public static final int T__171=171;
00346 public static final int T__170=170;
00347 public static final int FRAME=5;
00348 public static final int OP_LEQ=50;
00349 public static final int OP_TIMES=63;
00350 public static final int FRAME_ALL=11;
00351 public static final int BINARY=12;
00352 public static final int T__169=169;
00353 public static final int OP_UNION=56;
00354 public static final int METHOD=100;
00355 public static final int RETURN_VAR=32;
00356 public static final int OP_IMPLIES=68;
00357
00358
00359
00360
00361
00362 public JFSLParser(TokenStream input) {
00363 this(input, new RecognizerSharedState());
00364 }
00365 public JFSLParser(TokenStream input, RecognizerSharedState state) {
00366 super(input, state);
00367 this.state.ruleMemo = new HashMap[210+1];
00368
00369
00370 }
00371
00372 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
00373
00374 public void setTreeAdaptor(TreeAdaptor adaptor) {
00375 this.adaptor = adaptor;
00376 }
00377 public TreeAdaptor getTreeAdaptor() {
00378 return adaptor;
00379 }
00380
00381 public String[] getTokenNames() { return JFSLParser.tokenNames; }
00382 public String getGrammarFileName() { return "JFSL.g"; }
00383
00384
00385
00386 public static final class Node extends CommonTree {
00387
00388 private boolean flag;
00389
00390
00391 private Decision decision;
00392
00393
00394 public JType jtype;
00395 public JField field;
00396
00397 public Node(Token t) {
00398 super(t);
00399 }
00400
00401 public Node(Node node) {
00402 super(node);
00403 this.flag = false;
00404 this.decision = null;
00405 }
00406
00407 public void setFlag(boolean flag) { this.flag = flag; }
00408 public boolean flag() { return flag; }
00409 public void setJType(JType jtype) { this.jtype = jtype; }
00410 public Decision decision() { return decision; }
00411
00412 public void setDecision(Decision d) {
00413 assert this.decision == null || this.decision == d : "change of decision from " + this.decision + " to " + d;
00414 this.decision = d;
00415 }
00416
00417 @Override
00418 public Tree dupNode() {
00419 return new Node(this);
00420 }
00421 };
00422
00423
00424 public static final class NodeAdaptor extends CommonTreeAdaptor {
00425 @Override
00426 public Object create(Token payload) {
00427 return new Node(payload);
00428 }
00429 };
00430
00431
00432 public static enum Decision {LOCAL, GLOBAL, TYPE, FRAGMENT, CONST};
00433
00434 public void displayRecognitionError(String[] tokenNames, RecognitionException e) {
00435 throw new JFSLParserException(e);
00436 }
00437
00438
00439 public static class clause_return extends ParserRuleReturnScope {
00440 Node tree;
00441 public Object getTree() { return tree; }
00442 };
00443
00444
00445
00446 public final JFSLParser.clause_return clause() throws RecognitionException {
00447 JFSLParser.clause_return retval = new JFSLParser.clause_return();
00448 retval.start = input.LT(1);
00449 int clause_StartIndex = input.index();
00450 Node root_0 = null;
00451
00452 Token EOF2=null;
00453 JFSLParser.expression_return expression1 = null;
00454
00455
00456 Node EOF2_tree=null;
00457
00458 try {
00459 if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }
00460
00461
00462 {
00463 root_0 = (Node)adaptor.nil();
00464
00465 pushFollow(FOLLOW_expression_in_clause720);
00466 expression1=expression();
00467
00468 state._fsp--;
00469 if (state.failed) return retval;
00470 if ( state.backtracking==0 ) adaptor.addChild(root_0, expression1.getTree());
00471 EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_clause722); if (state.failed) return retval;
00472
00473 }
00474
00475 retval.stop = input.LT(-1);
00476
00477 if ( state.backtracking==0 ) {
00478
00479 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00480 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00481 }
00482 }
00483 catch (RecognitionException re) {
00484 reportError(re);
00485 recover(input,re);
00486 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00487
00488 }
00489 finally {
00490 if ( state.backtracking>0 ) { memoize(input, 1, clause_StartIndex); }
00491 }
00492 return retval;
00493 }
00494
00495
00496 public static class specField_return extends ParserRuleReturnScope {
00497 Node tree;
00498 public Object getTree() { return tree; }
00499 };
00500
00501
00502
00503 public final JFSLParser.specField_return specField() throws RecognitionException {
00504 JFSLParser.specField_return retval = new JFSLParser.specField_return();
00505 retval.start = input.LT(1);
00506 int specField_StartIndex = input.index();
00507 Node root_0 = null;
00508
00509 Token EOF4=null;
00510 JFSLParser.declaration_return declaration3 = null;
00511
00512
00513 Node EOF4_tree=null;
00514
00515 try {
00516 if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }
00517
00518
00519 {
00520 root_0 = (Node)adaptor.nil();
00521
00522 pushFollow(FOLLOW_declaration_in_specField729);
00523 declaration3=declaration();
00524
00525 state._fsp--;
00526 if (state.failed) return retval;
00527 if ( state.backtracking==0 ) adaptor.addChild(root_0, declaration3.getTree());
00528 EOF4=(Token)match(input,EOF,FOLLOW_EOF_in_specField731); if (state.failed) return retval;
00529
00530 }
00531
00532 retval.stop = input.LT(-1);
00533
00534 if ( state.backtracking==0 ) {
00535
00536 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00537 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00538 }
00539 }
00540 catch (RecognitionException re) {
00541 reportError(re);
00542 recover(input,re);
00543 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00544
00545 }
00546 finally {
00547 if ( state.backtracking>0 ) { memoize(input, 2, specField_StartIndex); }
00548 }
00549 return retval;
00550 }
00551
00552
00553 public static class modifies_return extends ParserRuleReturnScope {
00554 Node tree;
00555 public Object getTree() { return tree; }
00556 };
00557
00558
00559
00560 public final JFSLParser.modifies_return modifies() throws RecognitionException {
00561 JFSLParser.modifies_return retval = new JFSLParser.modifies_return();
00562 retval.start = input.LT(1);
00563 int modifies_StartIndex = input.index();
00564 Node root_0 = null;
00565
00566 Token EOF6=null;
00567 JFSLParser.frame_return frame5 = null;
00568
00569
00570 Node EOF6_tree=null;
00571
00572 try {
00573 if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }
00574
00575
00576 {
00577 root_0 = (Node)adaptor.nil();
00578
00579 pushFollow(FOLLOW_frame_in_modifies738);
00580 frame5=frame();
00581
00582 state._fsp--;
00583 if (state.failed) return retval;
00584 if ( state.backtracking==0 ) adaptor.addChild(root_0, frame5.getTree());
00585 EOF6=(Token)match(input,EOF,FOLLOW_EOF_in_modifies740); if (state.failed) return retval;
00586
00587 }
00588
00589 retval.stop = input.LT(-1);
00590
00591 if ( state.backtracking==0 ) {
00592
00593 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00594 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00595 }
00596 }
00597 catch (RecognitionException re) {
00598 reportError(re);
00599 recover(input,re);
00600 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00601
00602 }
00603 finally {
00604 if ( state.backtracking>0 ) { memoize(input, 3, modifies_StartIndex); }
00605 }
00606 return retval;
00607 }
00608
00609
00610 public static class compilationUnit_return extends ParserRuleReturnScope {
00611 Node tree;
00612 public Object getTree() { return tree; }
00613 };
00614
00615
00616
00617 public final JFSLParser.compilationUnit_return compilationUnit() throws RecognitionException {
00618 JFSLParser.compilationUnit_return retval = new JFSLParser.compilationUnit_return();
00619 retval.start = input.LT(1);
00620 int compilationUnit_StartIndex = input.index();
00621 Node root_0 = null;
00622
00623 Token string_literal7=null;
00624 Token char_literal9=null;
00625 Token char_literal12=null;
00626 Token EOF13=null;
00627 JFSLParser.packageName_return packageName8 = null;
00628
00629 JFSLParser.importDeclaration_return importDeclaration10 = null;
00630
00631 JFSLParser.typeDeclaration_return typeDeclaration11 = null;
00632
00633
00634 Node string_literal7_tree=null;
00635 Node char_literal9_tree=null;
00636 Node char_literal12_tree=null;
00637 Node EOF13_tree=null;
00638 RewriteRuleTokenStream stream_127=new RewriteRuleTokenStream(adaptor,"token 127");
00639 RewriteRuleTokenStream stream_128=new RewriteRuleTokenStream(adaptor,"token 128");
00640 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
00641 RewriteRuleSubtreeStream stream_packageName=new RewriteRuleSubtreeStream(adaptor,"rule packageName");
00642 RewriteRuleSubtreeStream stream_typeDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule typeDeclaration");
00643 RewriteRuleSubtreeStream stream_importDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule importDeclaration");
00644 try {
00645 if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }
00646
00647
00648 {
00649 string_literal7=(Token)match(input,127,FOLLOW_127_in_compilationUnit760); if (state.failed) return retval;
00650 if ( state.backtracking==0 ) stream_127.add(string_literal7);
00651
00652 pushFollow(FOLLOW_packageName_in_compilationUnit762);
00653 packageName8=packageName();
00654
00655 state._fsp--;
00656 if (state.failed) return retval;
00657 if ( state.backtracking==0 ) stream_packageName.add(packageName8.getTree());
00658 char_literal9=(Token)match(input,128,FOLLOW_128_in_compilationUnit764); if (state.failed) return retval;
00659 if ( state.backtracking==0 ) stream_128.add(char_literal9);
00660
00661 pushFollow(FOLLOW_importDeclaration_in_compilationUnit770);
00662 importDeclaration10=importDeclaration();
00663
00664 state._fsp--;
00665 if (state.failed) return retval;
00666 if ( state.backtracking==0 ) stream_importDeclaration.add(importDeclaration10.getTree());
00667 pushFollow(FOLLOW_typeDeclaration_in_compilationUnit776);
00668 typeDeclaration11=typeDeclaration();
00669
00670 state._fsp--;
00671 if (state.failed) return retval;
00672 if ( state.backtracking==0 ) stream_typeDeclaration.add(typeDeclaration11.getTree());
00673
00674 loop1:
00675 do {
00676 int alt1=2;
00677 int LA1_0 = input.LA(1);
00678
00679 if ( (LA1_0==128) ) {
00680 alt1=1;
00681 }
00682
00683
00684 switch (alt1) {
00685 case 1 :
00686
00687 {
00688 char_literal12=(Token)match(input,128,FOLLOW_128_in_compilationUnit778); if (state.failed) return retval;
00689 if ( state.backtracking==0 ) stream_128.add(char_literal12);
00690
00691
00692 }
00693 break;
00694
00695 default :
00696 break loop1;
00697 }
00698 } while (true);
00699
00700 EOF13=(Token)match(input,EOF,FOLLOW_EOF_in_compilationUnit785); if (state.failed) return retval;
00701 if ( state.backtracking==0 ) stream_EOF.add(EOF13);
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712 if ( state.backtracking==0 ) {
00713 retval.tree = root_0;
00714 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00715
00716 root_0 = (Node)adaptor.nil();
00717
00718 {
00719
00720 {
00721 Node root_1 = (Node)adaptor.nil();
00722 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(FILE, "FILE"), root_1);
00723
00724 adaptor.addChild(root_1, stream_packageName.nextTree());
00725 adaptor.addChild(root_1, stream_importDeclaration.nextTree());
00726 adaptor.addChild(root_1, stream_typeDeclaration.nextTree());
00727
00728 adaptor.addChild(root_0, root_1);
00729 }
00730
00731 }
00732
00733 retval.tree = root_0;}
00734 }
00735
00736 retval.stop = input.LT(-1);
00737
00738 if ( state.backtracking==0 ) {
00739
00740 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00741 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00742 }
00743 }
00744 catch (RecognitionException re) {
00745 reportError(re);
00746 recover(input,re);
00747 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00748
00749 }
00750 finally {
00751 if ( state.backtracking>0 ) { memoize(input, 4, compilationUnit_StartIndex); }
00752 }
00753 return retval;
00754 }
00755
00756
00757 public static class packageName_return extends ParserRuleReturnScope {
00758 Node tree;
00759 public Object getTree() { return tree; }
00760 };
00761
00762
00763
00764 public final JFSLParser.packageName_return packageName() throws RecognitionException {
00765 JFSLParser.packageName_return retval = new JFSLParser.packageName_return();
00766 retval.start = input.LT(1);
00767 int packageName_StartIndex = input.index();
00768 Node root_0 = null;
00769
00770 Token Identifier14=null;
00771 Token char_literal15=null;
00772 Token Identifier16=null;
00773
00774 Node Identifier14_tree=null;
00775 Node char_literal15_tree=null;
00776 Node Identifier16_tree=null;
00777 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
00778 RewriteRuleTokenStream stream_129=new RewriteRuleTokenStream(adaptor,"token 129");
00779
00780 try {
00781 if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }
00782
00783
00784 {
00785 Identifier14=(Token)match(input,Identifier,FOLLOW_Identifier_in_packageName810); if (state.failed) return retval;
00786 if ( state.backtracking==0 ) stream_Identifier.add(Identifier14);
00787
00788
00789 loop2:
00790 do {
00791 int alt2=2;
00792 int LA2_0 = input.LA(1);
00793
00794 if ( (LA2_0==129) ) {
00795 alt2=1;
00796 }
00797
00798
00799 switch (alt2) {
00800 case 1 :
00801
00802 {
00803 char_literal15=(Token)match(input,129,FOLLOW_129_in_packageName813); if (state.failed) return retval;
00804 if ( state.backtracking==0 ) stream_129.add(char_literal15);
00805
00806 Identifier16=(Token)match(input,Identifier,FOLLOW_Identifier_in_packageName815); if (state.failed) return retval;
00807 if ( state.backtracking==0 ) stream_Identifier.add(Identifier16);
00808
00809
00810 }
00811 break;
00812
00813 default :
00814 break loop2;
00815 }
00816 } while (true);
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827 if ( state.backtracking==0 ) {
00828 retval.tree = root_0;
00829 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00830
00831 root_0 = (Node)adaptor.nil();
00832
00833 {
00834
00835 {
00836 Node root_1 = (Node)adaptor.nil();
00837 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(PACKAGE, "PACKAGE"), root_1);
00838
00839 if ( !(stream_Identifier.hasNext()) ) {
00840 throw new RewriteEarlyExitException();
00841 }
00842 while ( stream_Identifier.hasNext() ) {
00843 adaptor.addChild(root_1, stream_Identifier.nextNode());
00844
00845 }
00846 stream_Identifier.reset();
00847
00848 adaptor.addChild(root_0, root_1);
00849 }
00850
00851 }
00852
00853 retval.tree = root_0;}
00854 }
00855
00856 retval.stop = input.LT(-1);
00857
00858 if ( state.backtracking==0 ) {
00859
00860 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00861 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00862 }
00863 }
00864 catch (RecognitionException re) {
00865 reportError(re);
00866 recover(input,re);
00867 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00868
00869 }
00870 finally {
00871 if ( state.backtracking>0 ) { memoize(input, 5, packageName_StartIndex); }
00872 }
00873 return retval;
00874 }
00875
00876
00877 public static class importDeclaration_return extends ParserRuleReturnScope {
00878 Node tree;
00879 public Object getTree() { return tree; }
00880 };
00881
00882
00883
00884 public final JFSLParser.importDeclaration_return importDeclaration() throws RecognitionException {
00885 JFSLParser.importDeclaration_return retval = new JFSLParser.importDeclaration_return();
00886 retval.start = input.LT(1);
00887 int importDeclaration_StartIndex = input.index();
00888 Node root_0 = null;
00889
00890 Token string_literal17=null;
00891 Token char_literal19=null;
00892 JFSLParser.packageName_return packageName18 = null;
00893
00894
00895 Node string_literal17_tree=null;
00896 Node char_literal19_tree=null;
00897 RewriteRuleTokenStream stream_128=new RewriteRuleTokenStream(adaptor,"token 128");
00898 RewriteRuleTokenStream stream_130=new RewriteRuleTokenStream(adaptor,"token 130");
00899 RewriteRuleSubtreeStream stream_packageName=new RewriteRuleSubtreeStream(adaptor,"rule packageName");
00900 try {
00901 if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }
00902
00903
00904 {
00905
00906 loop3:
00907 do {
00908 int alt3=2;
00909 int LA3_0 = input.LA(1);
00910
00911 if ( (LA3_0==130) ) {
00912 alt3=1;
00913 }
00914
00915
00916 switch (alt3) {
00917 case 1 :
00918
00919 {
00920 string_literal17=(Token)match(input,130,FOLLOW_130_in_importDeclaration843); if (state.failed) return retval;
00921 if ( state.backtracking==0 ) stream_130.add(string_literal17);
00922
00923 pushFollow(FOLLOW_packageName_in_importDeclaration845);
00924 packageName18=packageName();
00925
00926 state._fsp--;
00927 if (state.failed) return retval;
00928 if ( state.backtracking==0 ) stream_packageName.add(packageName18.getTree());
00929 char_literal19=(Token)match(input,128,FOLLOW_128_in_importDeclaration847); if (state.failed) return retval;
00930 if ( state.backtracking==0 ) stream_128.add(char_literal19);
00931
00932
00933 }
00934 break;
00935
00936 default :
00937 break loop3;
00938 }
00939 } while (true);
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950 if ( state.backtracking==0 ) {
00951 retval.tree = root_0;
00952 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00953
00954 root_0 = (Node)adaptor.nil();
00955
00956 {
00957
00958 {
00959 Node root_1 = (Node)adaptor.nil();
00960 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(IMPORT, "IMPORT"), root_1);
00961
00962
00963 while ( stream_packageName.hasNext() ) {
00964 adaptor.addChild(root_1, stream_packageName.nextTree());
00965
00966 }
00967 stream_packageName.reset();
00968
00969 adaptor.addChild(root_0, root_1);
00970 }
00971
00972 }
00973
00974 retval.tree = root_0;}
00975 }
00976
00977 retval.stop = input.LT(-1);
00978
00979 if ( state.backtracking==0 ) {
00980
00981 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00982 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00983 }
00984 }
00985 catch (RecognitionException re) {
00986 reportError(re);
00987 recover(input,re);
00988 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00989
00990 }
00991 finally {
00992 if ( state.backtracking>0 ) { memoize(input, 6, importDeclaration_StartIndex); }
00993 }
00994 return retval;
00995 }
00996
00997
00998 public static class typeDeclaration_return extends ParserRuleReturnScope {
00999 Node tree;
01000 public Object getTree() { return tree; }
01001 };
01002
01003
01004
01005 public final JFSLParser.typeDeclaration_return typeDeclaration() throws RecognitionException {
01006 JFSLParser.typeDeclaration_return retval = new JFSLParser.typeDeclaration_return();
01007 retval.start = input.LT(1);
01008 int typeDeclaration_StartIndex = input.index();
01009 Node root_0 = null;
01010
01011 Token string_literal20=null;
01012 Token string_literal21=null;
01013 Token Identifier22=null;
01014 Token char_literal24=null;
01015 Token char_literal26=null;
01016 JFSLParser.typeParameters_return typeParameters23 = null;
01017
01018 JFSLParser.typeBodyDeclaration_return typeBodyDeclaration25 = null;
01019
01020
01021 Node string_literal20_tree=null;
01022 Node string_literal21_tree=null;
01023 Node Identifier22_tree=null;
01024 Node char_literal24_tree=null;
01025 Node char_literal26_tree=null;
01026 RewriteRuleTokenStream stream_134=new RewriteRuleTokenStream(adaptor,"token 134");
01027 RewriteRuleTokenStream stream_132=new RewriteRuleTokenStream(adaptor,"token 132");
01028 RewriteRuleTokenStream stream_133=new RewriteRuleTokenStream(adaptor,"token 133");
01029 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
01030 RewriteRuleTokenStream stream_131=new RewriteRuleTokenStream(adaptor,"token 131");
01031 RewriteRuleSubtreeStream stream_typeParameters=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters");
01032 RewriteRuleSubtreeStream stream_typeBodyDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule typeBodyDeclaration");
01033 try {
01034 if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }
01035
01036
01037 {
01038
01039 int alt4=2;
01040 int LA4_0 = input.LA(1);
01041
01042 if ( (LA4_0==131) ) {
01043 alt4=1;
01044 }
01045 else if ( (LA4_0==132) ) {
01046 alt4=2;
01047 }
01048 else {
01049 if (state.backtracking>0) {state.failed=true; return retval;}
01050 NoViableAltException nvae =
01051 new NoViableAltException("", 4, 0, input);
01052
01053 throw nvae;
01054 }
01055 switch (alt4) {
01056 case 1 :
01057
01058 {
01059 string_literal20=(Token)match(input,131,FOLLOW_131_in_typeDeclaration874); if (state.failed) return retval;
01060 if ( state.backtracking==0 ) stream_131.add(string_literal20);
01061
01062
01063 }
01064 break;
01065 case 2 :
01066
01067 {
01068 string_literal21=(Token)match(input,132,FOLLOW_132_in_typeDeclaration878); if (state.failed) return retval;
01069 if ( state.backtracking==0 ) stream_132.add(string_literal21);
01070
01071
01072 }
01073 break;
01074
01075 }
01076
01077 Identifier22=(Token)match(input,Identifier,FOLLOW_Identifier_in_typeDeclaration881); if (state.failed) return retval;
01078 if ( state.backtracking==0 ) stream_Identifier.add(Identifier22);
01079
01080
01081 int alt5=2;
01082 int LA5_0 = input.LA(1);
01083
01084 if ( (LA5_0==135) ) {
01085 alt5=1;
01086 }
01087 switch (alt5) {
01088 case 1 :
01089
01090 {
01091 pushFollow(FOLLOW_typeParameters_in_typeDeclaration883);
01092 typeParameters23=typeParameters();
01093
01094 state._fsp--;
01095 if (state.failed) return retval;
01096 if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters23.getTree());
01097
01098 }
01099 break;
01100
01101 }
01102
01103 char_literal24=(Token)match(input,133,FOLLOW_133_in_typeDeclaration890); if (state.failed) return retval;
01104 if ( state.backtracking==0 ) stream_133.add(char_literal24);
01105
01106
01107 loop6:
01108 do {
01109 int alt6=2;
01110 int LA6_0 = input.LA(1);
01111
01112 if ( (LA6_0==Identifier||LA6_0==128||(LA6_0>=131 && LA6_0<=132)||LA6_0==138||LA6_0==141) ) {
01113 alt6=1;
01114 }
01115
01116
01117 switch (alt6) {
01118 case 1 :
01119
01120 {
01121 pushFollow(FOLLOW_typeBodyDeclaration_in_typeDeclaration892);
01122 typeBodyDeclaration25=typeBodyDeclaration();
01123
01124 state._fsp--;
01125 if (state.failed) return retval;
01126 if ( state.backtracking==0 ) stream_typeBodyDeclaration.add(typeBodyDeclaration25.getTree());
01127
01128 }
01129 break;
01130
01131 default :
01132 break loop6;
01133 }
01134 } while (true);
01135
01136 char_literal26=(Token)match(input,134,FOLLOW_134_in_typeDeclaration895); if (state.failed) return retval;
01137 if ( state.backtracking==0 ) stream_134.add(char_literal26);
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148 if ( state.backtracking==0 ) {
01149 retval.tree = root_0;
01150 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01151
01152 root_0 = (Node)adaptor.nil();
01153
01154 {
01155
01156 {
01157 Node root_1 = (Node)adaptor.nil();
01158 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_DECLARATION, "TYPE_DECLARATION"), root_1);
01159
01160 adaptor.addChild(root_1, stream_Identifier.nextNode());
01161
01162 {
01163 Node root_2 = (Node)adaptor.nil();
01164 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_PARAMETERS, "TYPE_PARAMETERS"), root_2);
01165
01166
01167 if ( stream_typeParameters.hasNext() ) {
01168 adaptor.addChild(root_2, stream_typeParameters.nextTree());
01169
01170 }
01171 stream_typeParameters.reset();
01172
01173 adaptor.addChild(root_1, root_2);
01174 }
01175
01176 while ( stream_typeBodyDeclaration.hasNext() ) {
01177 adaptor.addChild(root_1, stream_typeBodyDeclaration.nextTree());
01178
01179 }
01180 stream_typeBodyDeclaration.reset();
01181
01182 adaptor.addChild(root_0, root_1);
01183 }
01184
01185 }
01186
01187 retval.tree = root_0;}
01188 }
01189
01190 retval.stop = input.LT(-1);
01191
01192 if ( state.backtracking==0 ) {
01193
01194 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01195 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01196 }
01197 }
01198 catch (RecognitionException re) {
01199 reportError(re);
01200 recover(input,re);
01201 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01202
01203 }
01204 finally {
01205 if ( state.backtracking>0 ) { memoize(input, 7, typeDeclaration_StartIndex); }
01206 }
01207 return retval;
01208 }
01209
01210
01211 public static class typeParameters_return extends ParserRuleReturnScope {
01212 Node tree;
01213 public Object getTree() { return tree; }
01214 };
01215
01216
01217
01218 public final JFSLParser.typeParameters_return typeParameters() throws RecognitionException {
01219 JFSLParser.typeParameters_return retval = new JFSLParser.typeParameters_return();
01220 retval.start = input.LT(1);
01221 int typeParameters_StartIndex = input.index();
01222 Node root_0 = null;
01223
01224 Token char_literal27=null;
01225 Token Identifier28=null;
01226 Token char_literal29=null;
01227 Token Identifier30=null;
01228 Token char_literal31=null;
01229
01230 Node char_literal27_tree=null;
01231 Node Identifier28_tree=null;
01232 Node char_literal29_tree=null;
01233 Node Identifier30_tree=null;
01234 Node char_literal31_tree=null;
01235 RewriteRuleTokenStream stream_135=new RewriteRuleTokenStream(adaptor,"token 135");
01236 RewriteRuleTokenStream stream_136=new RewriteRuleTokenStream(adaptor,"token 136");
01237 RewriteRuleTokenStream stream_137=new RewriteRuleTokenStream(adaptor,"token 137");
01238 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
01239
01240 try {
01241 if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }
01242
01243
01244 {
01245 char_literal27=(Token)match(input,135,FOLLOW_135_in_typeParameters926); if (state.failed) return retval;
01246 if ( state.backtracking==0 ) stream_135.add(char_literal27);
01247
01248 Identifier28=(Token)match(input,Identifier,FOLLOW_Identifier_in_typeParameters928); if (state.failed) return retval;
01249 if ( state.backtracking==0 ) stream_Identifier.add(Identifier28);
01250
01251
01252 loop7:
01253 do {
01254 int alt7=2;
01255 int LA7_0 = input.LA(1);
01256
01257 if ( (LA7_0==136) ) {
01258 alt7=1;
01259 }
01260
01261
01262 switch (alt7) {
01263 case 1 :
01264
01265 {
01266 char_literal29=(Token)match(input,136,FOLLOW_136_in_typeParameters931); if (state.failed) return retval;
01267 if ( state.backtracking==0 ) stream_136.add(char_literal29);
01268
01269 Identifier30=(Token)match(input,Identifier,FOLLOW_Identifier_in_typeParameters933); if (state.failed) return retval;
01270 if ( state.backtracking==0 ) stream_Identifier.add(Identifier30);
01271
01272
01273 }
01274 break;
01275
01276 default :
01277 break loop7;
01278 }
01279 } while (true);
01280
01281 char_literal31=(Token)match(input,137,FOLLOW_137_in_typeParameters937); if (state.failed) return retval;
01282 if ( state.backtracking==0 ) stream_137.add(char_literal31);
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293 if ( state.backtracking==0 ) {
01294 retval.tree = root_0;
01295 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01296
01297 root_0 = (Node)adaptor.nil();
01298
01299 {
01300 if ( !(stream_Identifier.hasNext()) ) {
01301 throw new RewriteEarlyExitException();
01302 }
01303 while ( stream_Identifier.hasNext() ) {
01304 adaptor.addChild(root_0, stream_Identifier.nextNode());
01305
01306 }
01307 stream_Identifier.reset();
01308
01309 }
01310
01311 retval.tree = root_0;}
01312 }
01313
01314 retval.stop = input.LT(-1);
01315
01316 if ( state.backtracking==0 ) {
01317
01318 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01319 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01320 }
01321 }
01322 catch (RecognitionException re) {
01323 reportError(re);
01324 recover(input,re);
01325 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01326
01327 }
01328 finally {
01329 if ( state.backtracking>0 ) { memoize(input, 8, typeParameters_StartIndex); }
01330 }
01331 return retval;
01332 }
01333
01334
01335 public static class typeParameters2_return extends ParserRuleReturnScope {
01336 Node tree;
01337 public Object getTree() { return tree; }
01338 };
01339
01340
01341
01342 public final JFSLParser.typeParameters2_return typeParameters2() throws RecognitionException {
01343 JFSLParser.typeParameters2_return retval = new JFSLParser.typeParameters2_return();
01344 retval.start = input.LT(1);
01345 int typeParameters2_StartIndex = input.index();
01346 Node root_0 = null;
01347
01348 Token char_literal32=null;
01349 Token char_literal34=null;
01350 Token char_literal36=null;
01351 JFSLParser.primary_return primary33 = null;
01352
01353 JFSLParser.primary_return primary35 = null;
01354
01355
01356 Node char_literal32_tree=null;
01357 Node char_literal34_tree=null;
01358 Node char_literal36_tree=null;
01359 RewriteRuleTokenStream stream_135=new RewriteRuleTokenStream(adaptor,"token 135");
01360 RewriteRuleTokenStream stream_136=new RewriteRuleTokenStream(adaptor,"token 136");
01361 RewriteRuleTokenStream stream_137=new RewriteRuleTokenStream(adaptor,"token 137");
01362 RewriteRuleSubtreeStream stream_primary=new RewriteRuleSubtreeStream(adaptor,"rule primary");
01363 try {
01364 if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }
01365
01366
01367 {
01368 char_literal32=(Token)match(input,135,FOLLOW_135_in_typeParameters2959); if (state.failed) return retval;
01369 if ( state.backtracking==0 ) stream_135.add(char_literal32);
01370
01371 pushFollow(FOLLOW_primary_in_typeParameters2961);
01372 primary33=primary();
01373
01374 state._fsp--;
01375 if (state.failed) return retval;
01376 if ( state.backtracking==0 ) stream_primary.add(primary33.getTree());
01377
01378 loop8:
01379 do {
01380 int alt8=2;
01381 int LA8_0 = input.LA(1);
01382
01383 if ( (LA8_0==136) ) {
01384 alt8=1;
01385 }
01386
01387
01388 switch (alt8) {
01389 case 1 :
01390
01391 {
01392 char_literal34=(Token)match(input,136,FOLLOW_136_in_typeParameters2964); if (state.failed) return retval;
01393 if ( state.backtracking==0 ) stream_136.add(char_literal34);
01394
01395 pushFollow(FOLLOW_primary_in_typeParameters2966);
01396 primary35=primary();
01397
01398 state._fsp--;
01399 if (state.failed) return retval;
01400 if ( state.backtracking==0 ) stream_primary.add(primary35.getTree());
01401
01402 }
01403 break;
01404
01405 default :
01406 break loop8;
01407 }
01408 } while (true);
01409
01410 char_literal36=(Token)match(input,137,FOLLOW_137_in_typeParameters2970); if (state.failed) return retval;
01411 if ( state.backtracking==0 ) stream_137.add(char_literal36);
01412
01413
01414
01415
01416
01417
01418
01419
01420
01421
01422 if ( state.backtracking==0 ) {
01423 retval.tree = root_0;
01424 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01425
01426 root_0 = (Node)adaptor.nil();
01427
01428 {
01429 if ( !(stream_primary.hasNext()) ) {
01430 throw new RewriteEarlyExitException();
01431 }
01432 while ( stream_primary.hasNext() ) {
01433 adaptor.addChild(root_0, stream_primary.nextTree());
01434
01435 }
01436 stream_primary.reset();
01437
01438 }
01439
01440 retval.tree = root_0;}
01441 }
01442
01443 retval.stop = input.LT(-1);
01444
01445 if ( state.backtracking==0 ) {
01446
01447 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01448 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01449 }
01450 }
01451 catch (RecognitionException re) {
01452 reportError(re);
01453 recover(input,re);
01454 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01455
01456 }
01457 finally {
01458 if ( state.backtracking>0 ) { memoize(input, 9, typeParameters2_StartIndex); }
01459 }
01460 return retval;
01461 }
01462
01463
01464 public static class typeBodyDeclaration_return extends ParserRuleReturnScope {
01465 Node tree;
01466 public Object getTree() { return tree; }
01467 };
01468
01469
01470
01471 public final JFSLParser.typeBodyDeclaration_return typeBodyDeclaration() throws RecognitionException {
01472 JFSLParser.typeBodyDeclaration_return retval = new JFSLParser.typeBodyDeclaration_return();
01473 retval.start = input.LT(1);
01474 int typeBodyDeclaration_StartIndex = input.index();
01475 Node root_0 = null;
01476
01477 Token char_literal37=null;
01478 Token string_literal39=null;
01479 Token char_literal40=null;
01480 Token char_literal42=null;
01481 Token string_literal43=null;
01482 Token char_literal44=null;
01483 Token char_literal46=null;
01484 Token Identifier47=null;
01485 Token char_literal48=null;
01486 Token char_literal50=null;
01487 Token char_literal51=null;
01488 Token char_literal53=null;
01489 Token char_literal55=null;
01490 Token char_literal56=null;
01491 JFSLParser.typeDeclaration_return typeDeclaration38 = null;
01492
01493 JFSLParser.expression_return expression41 = null;
01494
01495 JFSLParser.declaration_return declaration45 = null;
01496
01497 JFSLParser.methodParameters_return methodParameters49 = null;
01498
01499 JFSLParser.specCase_return specCase52 = null;
01500
01501 JFSLParser.specCase_return specCase54 = null;
01502
01503
01504 Node char_literal37_tree=null;
01505 Node string_literal39_tree=null;
01506 Node char_literal40_tree=null;
01507 Node char_literal42_tree=null;
01508 Node string_literal43_tree=null;
01509 Node char_literal44_tree=null;
01510 Node char_literal46_tree=null;
01511 Node Identifier47_tree=null;
01512 Node char_literal48_tree=null;
01513 Node char_literal50_tree=null;
01514 Node char_literal51_tree=null;
01515 Node char_literal53_tree=null;
01516 Node char_literal55_tree=null;
01517 Node char_literal56_tree=null;
01518 RewriteRuleTokenStream stream_134=new RewriteRuleTokenStream(adaptor,"token 134");
01519 RewriteRuleTokenStream stream_133=new RewriteRuleTokenStream(adaptor,"token 133");
01520 RewriteRuleTokenStream stream_128=new RewriteRuleTokenStream(adaptor,"token 128");
01521 RewriteRuleTokenStream stream_138=new RewriteRuleTokenStream(adaptor,"token 138");
01522 RewriteRuleTokenStream stream_139=new RewriteRuleTokenStream(adaptor,"token 139");
01523 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
01524 RewriteRuleTokenStream stream_140=new RewriteRuleTokenStream(adaptor,"token 140");
01525 RewriteRuleTokenStream stream_141=new RewriteRuleTokenStream(adaptor,"token 141");
01526 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
01527 RewriteRuleSubtreeStream stream_methodParameters=new RewriteRuleSubtreeStream(adaptor,"rule methodParameters");
01528 RewriteRuleSubtreeStream stream_specCase=new RewriteRuleSubtreeStream(adaptor,"rule specCase");
01529 RewriteRuleSubtreeStream stream_declaration=new RewriteRuleSubtreeStream(adaptor,"rule declaration");
01530 try {
01531 if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; }
01532
01533 int alt11=5;
01534 switch ( input.LA(1) ) {
01535 case 128:
01536 {
01537 alt11=1;
01538 }
01539 break;
01540 case 131:
01541 case 132:
01542 {
01543 alt11=2;
01544 }
01545 break;
01546 case 138:
01547 {
01548 alt11=3;
01549 }
01550 break;
01551 case 141:
01552 {
01553 alt11=4;
01554 }
01555 break;
01556 case Identifier:
01557 {
01558 alt11=5;
01559 }
01560 break;
01561 default:
01562 if (state.backtracking>0) {state.failed=true; return retval;}
01563 NoViableAltException nvae =
01564 new NoViableAltException("", 11, 0, input);
01565
01566 throw nvae;
01567 }
01568
01569 switch (alt11) {
01570 case 1 :
01571
01572 {
01573 root_0 = (Node)adaptor.nil();
01574
01575 char_literal37=(Token)match(input,128,FOLLOW_128_in_typeBodyDeclaration988); if (state.failed) return retval;
01576
01577 }
01578 break;
01579 case 2 :
01580
01581 {
01582 root_0 = (Node)adaptor.nil();
01583
01584 pushFollow(FOLLOW_typeDeclaration_in_typeBodyDeclaration995);
01585 typeDeclaration38=typeDeclaration();
01586
01587 state._fsp--;
01588 if (state.failed) return retval;
01589 if ( state.backtracking==0 ) adaptor.addChild(root_0, typeDeclaration38.getTree());
01590
01591 }
01592 break;
01593 case 3 :
01594
01595 {
01596 string_literal39=(Token)match(input,138,FOLLOW_138_in_typeBodyDeclaration1002); if (state.failed) return retval;
01597 if ( state.backtracking==0 ) stream_138.add(string_literal39);
01598
01599 char_literal40=(Token)match(input,139,FOLLOW_139_in_typeBodyDeclaration1004); if (state.failed) return retval;
01600 if ( state.backtracking==0 ) stream_139.add(char_literal40);
01601
01602 pushFollow(FOLLOW_expression_in_typeBodyDeclaration1006);
01603 expression41=expression();
01604
01605 state._fsp--;
01606 if (state.failed) return retval;
01607 if ( state.backtracking==0 ) stream_expression.add(expression41.getTree());
01608 char_literal42=(Token)match(input,140,FOLLOW_140_in_typeBodyDeclaration1008); if (state.failed) return retval;
01609 if ( state.backtracking==0 ) stream_140.add(char_literal42);
01610
01611
01612
01613
01614
01615
01616
01617
01618
01619
01620 if ( state.backtracking==0 ) {
01621 retval.tree = root_0;
01622 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01623
01624 root_0 = (Node)adaptor.nil();
01625
01626 {
01627
01628 {
01629 Node root_1 = (Node)adaptor.nil();
01630 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(INVARIANT, "INVARIANT"), root_1);
01631
01632 adaptor.addChild(root_1, stream_expression.nextTree());
01633
01634 adaptor.addChild(root_0, root_1);
01635 }
01636
01637 }
01638
01639 retval.tree = root_0;}
01640 }
01641 break;
01642 case 4 :
01643
01644 {
01645 string_literal43=(Token)match(input,141,FOLLOW_141_in_typeBodyDeclaration1022); if (state.failed) return retval;
01646 if ( state.backtracking==0 ) stream_141.add(string_literal43);
01647
01648 char_literal44=(Token)match(input,139,FOLLOW_139_in_typeBodyDeclaration1024); if (state.failed) return retval;
01649 if ( state.backtracking==0 ) stream_139.add(char_literal44);
01650
01651 pushFollow(FOLLOW_declaration_in_typeBodyDeclaration1026);
01652 declaration45=declaration();
01653
01654 state._fsp--;
01655 if (state.failed) return retval;
01656 if ( state.backtracking==0 ) stream_declaration.add(declaration45.getTree());
01657 char_literal46=(Token)match(input,140,FOLLOW_140_in_typeBodyDeclaration1028); if (state.failed) return retval;
01658 if ( state.backtracking==0 ) stream_140.add(char_literal46);
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669 if ( state.backtracking==0 ) {
01670 retval.tree = root_0;
01671 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01672
01673 root_0 = (Node)adaptor.nil();
01674
01675 {
01676
01677 {
01678 Node root_1 = (Node)adaptor.nil();
01679 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(SPECFIELD, "SPECFIELD"), root_1);
01680
01681 adaptor.addChild(root_1, stream_declaration.nextTree());
01682
01683 adaptor.addChild(root_0, root_1);
01684 }
01685
01686 }
01687
01688 retval.tree = root_0;}
01689 }
01690 break;
01691 case 5 :
01692
01693 {
01694 Identifier47=(Token)match(input,Identifier,FOLLOW_Identifier_in_typeBodyDeclaration1042); if (state.failed) return retval;
01695 if ( state.backtracking==0 ) stream_Identifier.add(Identifier47);
01696
01697 char_literal48=(Token)match(input,139,FOLLOW_139_in_typeBodyDeclaration1044); if (state.failed) return retval;
01698 if ( state.backtracking==0 ) stream_139.add(char_literal48);
01699
01700 pushFollow(FOLLOW_methodParameters_in_typeBodyDeclaration1046);
01701 methodParameters49=methodParameters();
01702
01703 state._fsp--;
01704 if (state.failed) return retval;
01705 if ( state.backtracking==0 ) stream_methodParameters.add(methodParameters49.getTree());
01706 char_literal50=(Token)match(input,140,FOLLOW_140_in_typeBodyDeclaration1048); if (state.failed) return retval;
01707 if ( state.backtracking==0 ) stream_140.add(char_literal50);
01708
01709 char_literal51=(Token)match(input,133,FOLLOW_133_in_typeBodyDeclaration1050); if (state.failed) return retval;
01710 if ( state.backtracking==0 ) stream_133.add(char_literal51);
01711
01712 pushFollow(FOLLOW_specCase_in_typeBodyDeclaration1052);
01713 specCase52=specCase();
01714
01715 state._fsp--;
01716 if (state.failed) return retval;
01717 if ( state.backtracking==0 ) stream_specCase.add(specCase52.getTree());
01718
01719 loop9:
01720 do {
01721 int alt9=2;
01722 int LA9_0 = input.LA(1);
01723
01724 if ( (LA9_0==128) ) {
01725 int LA9_1 = input.LA(2);
01726
01727 if ( (synpred13_JFSL()) ) {
01728 alt9=1;
01729 }
01730
01731
01732 }
01733
01734
01735 switch (alt9) {
01736 case 1 :
01737
01738 {
01739 char_literal53=(Token)match(input,128,FOLLOW_128_in_typeBodyDeclaration1055); if (state.failed) return retval;
01740 if ( state.backtracking==0 ) stream_128.add(char_literal53);
01741
01742 pushFollow(FOLLOW_specCase_in_typeBodyDeclaration1057);
01743 specCase54=specCase();
01744
01745 state._fsp--;
01746 if (state.failed) return retval;
01747 if ( state.backtracking==0 ) stream_specCase.add(specCase54.getTree());
01748
01749 }
01750 break;
01751
01752 default :
01753 break loop9;
01754 }
01755 } while (true);
01756
01757
01758 loop10:
01759 do {
01760 int alt10=2;
01761 int LA10_0 = input.LA(1);
01762
01763 if ( (LA10_0==128) ) {
01764 alt10=1;
01765 }
01766
01767
01768 switch (alt10) {
01769 case 1 :
01770
01771 {
01772 char_literal55=(Token)match(input,128,FOLLOW_128_in_typeBodyDeclaration1062); if (state.failed) return retval;
01773 if ( state.backtracking==0 ) stream_128.add(char_literal55);
01774
01775
01776 }
01777 break;
01778
01779 default :
01780 break loop10;
01781 }
01782 } while (true);
01783
01784 char_literal56=(Token)match(input,134,FOLLOW_134_in_typeBodyDeclaration1066); if (state.failed) return retval;
01785 if ( state.backtracking==0 ) stream_134.add(char_literal56);
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796 if ( state.backtracking==0 ) {
01797 retval.tree = root_0;
01798 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01799
01800 root_0 = (Node)adaptor.nil();
01801
01802 {
01803
01804 {
01805 Node root_1 = (Node)adaptor.nil();
01806 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(METHOD, "METHOD"), root_1);
01807
01808 adaptor.addChild(root_1, stream_Identifier.nextNode());
01809 adaptor.addChild(root_1, stream_methodParameters.nextTree());
01810
01811 {
01812 Node root_2 = (Node)adaptor.nil();
01813 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(SPECIFICATION, "SPECIFICATION"), root_2);
01814
01815 if ( !(stream_specCase.hasNext()) ) {
01816 throw new RewriteEarlyExitException();
01817 }
01818 while ( stream_specCase.hasNext() ) {
01819 adaptor.addChild(root_2, stream_specCase.nextTree());
01820
01821 }
01822 stream_specCase.reset();
01823
01824 adaptor.addChild(root_1, root_2);
01825 }
01826
01827 adaptor.addChild(root_0, root_1);
01828 }
01829
01830 }
01831
01832 retval.tree = root_0;}
01833 }
01834 break;
01835
01836 }
01837 retval.stop = input.LT(-1);
01838
01839 if ( state.backtracking==0 ) {
01840
01841 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01842 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01843 }
01844 }
01845 catch (RecognitionException re) {
01846 reportError(re);
01847 recover(input,re);
01848 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01849
01850 }
01851 finally {
01852 if ( state.backtracking>0 ) { memoize(input, 10, typeBodyDeclaration_StartIndex); }
01853 }
01854 return retval;
01855 }
01856
01857
01858 public static class methodParameters_return extends ParserRuleReturnScope {
01859 Node tree;
01860 public Object getTree() { return tree; }
01861 };
01862
01863
01864
01865 public final JFSLParser.methodParameters_return methodParameters() throws RecognitionException {
01866 JFSLParser.methodParameters_return retval = new JFSLParser.methodParameters_return();
01867 retval.start = input.LT(1);
01868 int methodParameters_StartIndex = input.index();
01869 Node root_0 = null;
01870
01871 Token Identifier58=null;
01872 Token char_literal59=null;
01873 Token Identifier61=null;
01874 JFSLParser.type_return type57 = null;
01875
01876 JFSLParser.type_return type60 = null;
01877
01878
01879 Node Identifier58_tree=null;
01880 Node char_literal59_tree=null;
01881 Node Identifier61_tree=null;
01882 RewriteRuleTokenStream stream_136=new RewriteRuleTokenStream(adaptor,"token 136");
01883 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
01884 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
01885 try {
01886 if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return retval; }
01887
01888
01889 {
01890
01891 int alt13=2;
01892 int LA13_0 = input.LA(1);
01893
01894 if ( (LA13_0==Identifier||(LA13_0>=159 && LA13_0<=166)) ) {
01895 alt13=1;
01896 }
01897 switch (alt13) {
01898 case 1 :
01899
01900 {
01901 pushFollow(FOLLOW_type_in_methodParameters1104);
01902 type57=type();
01903
01904 state._fsp--;
01905 if (state.failed) return retval;
01906 if ( state.backtracking==0 ) stream_type.add(type57.getTree());
01907 Identifier58=(Token)match(input,Identifier,FOLLOW_Identifier_in_methodParameters1106); if (state.failed) return retval;
01908 if ( state.backtracking==0 ) stream_Identifier.add(Identifier58);
01909
01910
01911 loop12:
01912 do {
01913 int alt12=2;
01914 int LA12_0 = input.LA(1);
01915
01916 if ( (LA12_0==136) ) {
01917 alt12=1;
01918 }
01919
01920
01921 switch (alt12) {
01922 case 1 :
01923
01924 {
01925 char_literal59=(Token)match(input,136,FOLLOW_136_in_methodParameters1109); if (state.failed) return retval;
01926 if ( state.backtracking==0 ) stream_136.add(char_literal59);
01927
01928 pushFollow(FOLLOW_type_in_methodParameters1111);
01929 type60=type();
01930
01931 state._fsp--;
01932 if (state.failed) return retval;
01933 if ( state.backtracking==0 ) stream_type.add(type60.getTree());
01934 Identifier61=(Token)match(input,Identifier,FOLLOW_Identifier_in_methodParameters1113); if (state.failed) return retval;
01935 if ( state.backtracking==0 ) stream_Identifier.add(Identifier61);
01936
01937
01938 }
01939 break;
01940
01941 default :
01942 break loop12;
01943 }
01944 } while (true);
01945
01946
01947 }
01948 break;
01949
01950 }
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960
01961 if ( state.backtracking==0 ) {
01962 retval.tree = root_0;
01963 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01964
01965 root_0 = (Node)adaptor.nil();
01966
01967 {
01968
01969 {
01970 Node root_1 = (Node)adaptor.nil();
01971 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(METHOD_PARAMETERS, "METHOD_PARAMETERS"), root_1);
01972
01973
01974 while ( stream_type.hasNext() ) {
01975 adaptor.addChild(root_1, stream_type.nextTree());
01976
01977 }
01978 stream_type.reset();
01979
01980 while ( stream_Identifier.hasNext() ) {
01981 adaptor.addChild(root_1, stream_Identifier.nextNode());
01982
01983 }
01984 stream_Identifier.reset();
01985
01986 adaptor.addChild(root_0, root_1);
01987 }
01988
01989 }
01990
01991 retval.tree = root_0;}
01992 }
01993
01994 retval.stop = input.LT(-1);
01995
01996 if ( state.backtracking==0 ) {
01997
01998 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01999 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
02000 }
02001 }
02002 catch (RecognitionException re) {
02003 reportError(re);
02004 recover(input,re);
02005 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
02006
02007 }
02008 finally {
02009 if ( state.backtracking>0 ) { memoize(input, 11, methodParameters_StartIndex); }
02010 }
02011 return retval;
02012 }
02013
02014
02015 public static class specCase_return extends ParserRuleReturnScope {
02016 Node tree;
02017 public Object getTree() { return tree; }
02018 };
02019
02020
02021
02022 public final JFSLParser.specCase_return specCase() throws RecognitionException {
02023 JFSLParser.specCase_return retval = new JFSLParser.specCase_return();
02024 retval.start = input.LT(1);
02025 int specCase_StartIndex = input.index();
02026 Node root_0 = null;
02027
02028 Token string_literal62=null;
02029 Token char_literal63=null;
02030 Token char_literal64=null;
02031 Token string_literal65=null;
02032 Token char_literal66=null;
02033 Token char_literal67=null;
02034 Token string_literal68=null;
02035 Token char_literal69=null;
02036 Token char_literal70=null;
02037 Token string_literal71=null;
02038 Token char_literal72=null;
02039 Token char_literal73=null;
02040 Token string_literal74=null;
02041 Token string_literal75=null;
02042 JFSLParser.expression_return requires = null;
02043
02044 JFSLParser.expression_return ensures = null;
02045
02046 JFSLParser.expression_return except = null;
02047
02048 JFSLParser.frame_return changes = null;
02049
02050
02051 Node string_literal62_tree=null;
02052 Node char_literal63_tree=null;
02053 Node char_literal64_tree=null;
02054 Node string_literal65_tree=null;
02055 Node char_literal66_tree=null;
02056 Node char_literal67_tree=null;
02057 Node string_literal68_tree=null;
02058 Node char_literal69_tree=null;
02059 Node char_literal70_tree=null;
02060 Node string_literal71_tree=null;
02061 Node char_literal72_tree=null;
02062 Node char_literal73_tree=null;
02063 Node string_literal74_tree=null;
02064 Node string_literal75_tree=null;
02065 RewriteRuleTokenStream stream_143=new RewriteRuleTokenStream(adaptor,"token 143");
02066 RewriteRuleTokenStream stream_144=new RewriteRuleTokenStream(adaptor,"token 144");
02067 RewriteRuleTokenStream stream_145=new RewriteRuleTokenStream(adaptor,"token 145");
02068 RewriteRuleTokenStream stream_146=new RewriteRuleTokenStream(adaptor,"token 146");
02069 RewriteRuleTokenStream stream_147=new RewriteRuleTokenStream(adaptor,"token 147");
02070 RewriteRuleTokenStream stream_139=new RewriteRuleTokenStream(adaptor,"token 139");
02071 RewriteRuleTokenStream stream_140=new RewriteRuleTokenStream(adaptor,"token 140");
02072 RewriteRuleTokenStream stream_142=new RewriteRuleTokenStream(adaptor,"token 142");
02073 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
02074 RewriteRuleSubtreeStream stream_frame=new RewriteRuleSubtreeStream(adaptor,"rule frame");
02075 try {
02076 if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return retval; }
02077
02078 int alt17=3;
02079 switch ( input.LA(1) ) {
02080 case EOF:
02081 case 128:
02082 case 134:
02083 case 142:
02084 case 143:
02085 case 144:
02086 case 145:
02087 {
02088 alt17=1;
02089 }
02090 break;
02091 case 146:
02092 {
02093 alt17=2;
02094 }
02095 break;
02096 case 147:
02097 {
02098 alt17=3;
02099 }
02100 break;
02101 default:
02102 if (state.backtracking>0) {state.failed=true; return retval;}
02103 NoViableAltException nvae =
02104 new NoViableAltException("", 17, 0, input);
02105
02106 throw nvae;
02107 }
02108
02109 switch (alt17) {
02110 case 1 :
02111
02112 {
02113
02114 int alt14=2;
02115 int LA14_0 = input.LA(1);
02116
02117 if ( (LA14_0==142) ) {
02118 alt14=1;
02119 }
02120 switch (alt14) {
02121 case 1 :
02122
02123 {
02124 string_literal62=(Token)match(input,142,FOLLOW_142_in_specCase1149); if (state.failed) return retval;
02125 if ( state.backtracking==0 ) stream_142.add(string_literal62);
02126
02127 char_literal63=(Token)match(input,139,FOLLOW_139_in_specCase1151); if (state.failed) return retval;
02128 if ( state.backtracking==0 ) stream_139.add(char_literal63);
02129
02130 pushFollow(FOLLOW_expression_in_specCase1157);
02131 requires=expression();
02132
02133 state._fsp--;
02134 if (state.failed) return retval;
02135 if ( state.backtracking==0 ) stream_expression.add(requires.getTree());
02136 char_literal64=(Token)match(input,140,FOLLOW_140_in_specCase1159); if (state.failed) return retval;
02137 if ( state.backtracking==0 ) stream_140.add(char_literal64);
02138
02139
02140 }
02141 break;
02142
02143 }
02144
02145
02146 int alt15=3;
02147 int LA15_0 = input.LA(1);
02148
02149 if ( (LA15_0==143) ) {
02150 alt15=1;
02151 }
02152 else if ( (LA15_0==144) ) {
02153 alt15=2;
02154 }
02155 switch (alt15) {
02156 case 1 :
02157
02158 {
02159 string_literal65=(Token)match(input,143,FOLLOW_143_in_specCase1170); if (state.failed) return retval;
02160 if ( state.backtracking==0 ) stream_143.add(string_literal65);
02161
02162 char_literal66=(Token)match(input,139,FOLLOW_139_in_specCase1172); if (state.failed) return retval;
02163 if ( state.backtracking==0 ) stream_139.add(char_literal66);
02164
02165 pushFollow(FOLLOW_expression_in_specCase1178);
02166 ensures=expression();
02167
02168 state._fsp--;
02169 if (state.failed) return retval;
02170 if ( state.backtracking==0 ) stream_expression.add(ensures.getTree());
02171 char_literal67=(Token)match(input,140,FOLLOW_140_in_specCase1180); if (state.failed) return retval;
02172 if ( state.backtracking==0 ) stream_140.add(char_literal67);
02173
02174
02175 }
02176 break;
02177 case 2 :
02178
02179 {
02180
02181
02182 {
02183 string_literal68=(Token)match(input,144,FOLLOW_144_in_specCase1185); if (state.failed) return retval;
02184 if ( state.backtracking==0 ) stream_144.add(string_literal68);
02185
02186 char_literal69=(Token)match(input,139,FOLLOW_139_in_specCase1187); if (state.failed) return retval;
02187 if ( state.backtracking==0 ) stream_139.add(char_literal69);
02188
02189 pushFollow(FOLLOW_expression_in_specCase1193);
02190 except=expression();
02191
02192 state._fsp--;
02193 if (state.failed) return retval;
02194 if ( state.backtracking==0 ) stream_expression.add(except.getTree());
02195 char_literal70=(Token)match(input,140,FOLLOW_140_in_specCase1195); if (state.failed) return retval;
02196 if ( state.backtracking==0 ) stream_140.add(char_literal70);
02197
02198
02199 }
02200
02201
02202 }
02203 break;
02204
02205 }
02206
02207
02208 int alt16=2;
02209 int LA16_0 = input.LA(1);
02210
02211 if ( (LA16_0==145) ) {
02212 alt16=1;
02213 }
02214 switch (alt16) {
02215 case 1 :
02216
02217 {
02218 string_literal71=(Token)match(input,145,FOLLOW_145_in_specCase1206); if (state.failed) return retval;
02219 if ( state.backtracking==0 ) stream_145.add(string_literal71);
02220
02221 char_literal72=(Token)match(input,139,FOLLOW_139_in_specCase1208); if (state.failed) return retval;
02222 if ( state.backtracking==0 ) stream_139.add(char_literal72);
02223
02224 pushFollow(FOLLOW_frame_in_specCase1214);
02225 changes=frame();
02226
02227 state._fsp--;
02228 if (state.failed) return retval;
02229 if ( state.backtracking==0 ) stream_frame.add(changes.getTree());
02230 char_literal73=(Token)match(input,140,FOLLOW_140_in_specCase1216); if (state.failed) return retval;
02231 if ( state.backtracking==0 ) stream_140.add(char_literal73);
02232
02233
02234 }
02235 break;
02236
02237 }
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248 if ( state.backtracking==0 ) {
02249 retval.tree = root_0;
02250 RewriteRuleSubtreeStream stream_ensures=new RewriteRuleSubtreeStream(adaptor,"rule ensures",ensures!=null?ensures.tree:null);
02251 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02252 RewriteRuleSubtreeStream stream_except=new RewriteRuleSubtreeStream(adaptor,"rule except",except!=null?except.tree:null);
02253 RewriteRuleSubtreeStream stream_requires=new RewriteRuleSubtreeStream(adaptor,"rule requires",requires!=null?requires.tree:null);
02254 RewriteRuleSubtreeStream stream_changes=new RewriteRuleSubtreeStream(adaptor,"rule changes",changes!=null?changes.tree:null);
02255
02256 root_0 = (Node)adaptor.nil();
02257
02258 {
02259
02260 {
02261 Node root_1 = (Node)adaptor.nil();
02262 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(SPECCASE, "SPECCASE"), root_1);
02263
02264
02265 {
02266 Node root_2 = (Node)adaptor.nil();
02267 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(REQUIRES, "REQUIRES"), root_2);
02268
02269
02270 if ( stream_requires.hasNext() ) {
02271 adaptor.addChild(root_2, stream_requires.nextTree());
02272
02273 }
02274 stream_requires.reset();
02275
02276 adaptor.addChild(root_1, root_2);
02277 }
02278
02279 {
02280 Node root_2 = (Node)adaptor.nil();
02281 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(ENSURES, "ENSURES"), root_2);
02282
02283
02284 if ( stream_ensures.hasNext() ) {
02285 adaptor.addChild(root_2, stream_ensures.nextTree());
02286
02287 }
02288 stream_ensures.reset();
02289
02290 adaptor.addChild(root_1, root_2);
02291 }
02292
02293 {
02294 Node root_2 = (Node)adaptor.nil();
02295 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(THROWS, "THROWS"), root_2);
02296
02297
02298 if ( stream_except.hasNext() ) {
02299 adaptor.addChild(root_2, stream_except.nextTree());
02300
02301 }
02302 stream_except.reset();
02303
02304 adaptor.addChild(root_1, root_2);
02305 }
02306
02307 {
02308 Node root_2 = (Node)adaptor.nil();
02309 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(MODIFIES, "MODIFIES"), root_2);
02310
02311
02312 if ( stream_changes.hasNext() ) {
02313 adaptor.addChild(root_2, stream_changes.nextTree());
02314
02315 }
02316 stream_changes.reset();
02317
02318 adaptor.addChild(root_1, root_2);
02319 }
02320
02321 adaptor.addChild(root_0, root_1);
02322 }
02323
02324 }
02325
02326 retval.tree = root_0;}
02327 }
02328 break;
02329 case 2 :
02330
02331 {
02332 string_literal74=(Token)match(input,146,FOLLOW_146_in_specCase1267); if (state.failed) return retval;
02333 if ( state.backtracking==0 ) stream_146.add(string_literal74);
02334
02335
02336
02337
02338
02339
02340
02341
02342
02343
02344 if ( state.backtracking==0 ) {
02345 retval.tree = root_0;
02346 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02347
02348 root_0 = (Node)adaptor.nil();
02349
02350 {
02351
02352 {
02353 Node root_1 = (Node)adaptor.nil();
02354 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(HELPER, "HELPER"), root_1);
02355
02356 adaptor.addChild(root_0, root_1);
02357 }
02358
02359 }
02360
02361 retval.tree = root_0;}
02362 }
02363 break;
02364 case 3 :
02365
02366 {
02367 string_literal75=(Token)match(input,147,FOLLOW_147_in_specCase1282); if (state.failed) return retval;
02368 if ( state.backtracking==0 ) stream_147.add(string_literal75);
02369
02370
02371
02372
02373
02374
02375
02376
02377
02378
02379 if ( state.backtracking==0 ) {
02380 retval.tree = root_0;
02381 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02382
02383 root_0 = (Node)adaptor.nil();
02384
02385 {
02386
02387 {
02388 Node root_1 = (Node)adaptor.nil();
02389 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(PURE, "PURE"), root_1);
02390
02391 adaptor.addChild(root_0, root_1);
02392 }
02393
02394 }
02395
02396 retval.tree = root_0;}
02397 }
02398 break;
02399
02400 }
02401 retval.stop = input.LT(-1);
02402
02403 if ( state.backtracking==0 ) {
02404
02405 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
02406 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
02407 }
02408 }
02409 catch (RecognitionException re) {
02410 reportError(re);
02411 recover(input,re);
02412 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
02413
02414 }
02415 finally {
02416 if ( state.backtracking>0 ) { memoize(input, 12, specCase_StartIndex); }
02417 }
02418 return retval;
02419 }
02420
02421
02422 public static class declaration_return extends ParserRuleReturnScope {
02423 Node tree;
02424 public Object getTree() { return tree; }
02425 };
02426
02427
02428
02429 public final JFSLParser.declaration_return declaration() throws RecognitionException {
02430 JFSLParser.declaration_return retval = new JFSLParser.declaration_return();
02431 retval.start = input.LT(1);
02432 int declaration_StartIndex = input.index();
02433 Node root_0 = null;
02434
02435 Token string_literal76=null;
02436 Token string_literal77=null;
02437 Token Identifier78=null;
02438 Token char_literal79=null;
02439 Token string_literal82=null;
02440 Token char_literal84=null;
02441 Token string_literal86=null;
02442 Token string_literal87=null;
02443 Token Identifier88=null;
02444 Token char_literal89=null;
02445 Token char_literal92=null;
02446 JFSLParser.declarationMult_return declarationMult80 = null;
02447
02448 JFSLParser.additiveExpression_return additiveExpression81 = null;
02449
02450 JFSLParser.frame_return frame83 = null;
02451
02452 JFSLParser.expression_return expression85 = null;
02453
02454 JFSLParser.declarationMult_return declarationMult90 = null;
02455
02456 JFSLParser.additiveExpression_return additiveExpression91 = null;
02457
02458 JFSLParser.expression_return expression93 = null;
02459
02460
02461 Node string_literal76_tree=null;
02462 Node string_literal77_tree=null;
02463 Node Identifier78_tree=null;
02464 Node char_literal79_tree=null;
02465 Node string_literal82_tree=null;
02466 Node char_literal84_tree=null;
02467 Node string_literal86_tree=null;
02468 Node string_literal87_tree=null;
02469 Node Identifier88_tree=null;
02470 Node char_literal89_tree=null;
02471 Node char_literal92_tree=null;
02472 RewriteRuleTokenStream stream_152=new RewriteRuleTokenStream(adaptor,"token 152");
02473 RewriteRuleTokenStream stream_150=new RewriteRuleTokenStream(adaptor,"token 150");
02474 RewriteRuleTokenStream stream_151=new RewriteRuleTokenStream(adaptor,"token 151");
02475 RewriteRuleTokenStream stream_148=new RewriteRuleTokenStream(adaptor,"token 148");
02476 RewriteRuleTokenStream stream_149=new RewriteRuleTokenStream(adaptor,"token 149");
02477 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
02478 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
02479 RewriteRuleSubtreeStream stream_frame=new RewriteRuleSubtreeStream(adaptor,"rule frame");
02480 RewriteRuleSubtreeStream stream_additiveExpression=new RewriteRuleSubtreeStream(adaptor,"rule additiveExpression");
02481 RewriteRuleSubtreeStream stream_declarationMult=new RewriteRuleSubtreeStream(adaptor,"rule declarationMult");
02482 try {
02483 if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return retval; }
02484
02485 int alt22=2;
02486 switch ( input.LA(1) ) {
02487 case 148:
02488 {
02489 int LA22_1 = input.LA(2);
02490
02491 if ( (synpred26_JFSL()) ) {
02492 alt22=1;
02493 }
02494 else if ( (true) ) {
02495 alt22=2;
02496 }
02497 else {
02498 if (state.backtracking>0) {state.failed=true; return retval;}
02499 NoViableAltException nvae =
02500 new NoViableAltException("", 22, 1, input);
02501
02502 throw nvae;
02503 }
02504 }
02505 break;
02506 case 149:
02507 {
02508 int LA22_2 = input.LA(2);
02509
02510 if ( (synpred26_JFSL()) ) {
02511 alt22=1;
02512 }
02513 else if ( (true) ) {
02514 alt22=2;
02515 }
02516 else {
02517 if (state.backtracking>0) {state.failed=true; return retval;}
02518 NoViableAltException nvae =
02519 new NoViableAltException("", 22, 2, input);
02520
02521 throw nvae;
02522 }
02523 }
02524 break;
02525 case Identifier:
02526 {
02527 int LA22_3 = input.LA(2);
02528
02529 if ( (synpred26_JFSL()) ) {
02530 alt22=1;
02531 }
02532 else if ( (true) ) {
02533 alt22=2;
02534 }
02535 else {
02536 if (state.backtracking>0) {state.failed=true; return retval;}
02537 NoViableAltException nvae =
02538 new NoViableAltException("", 22, 3, input);
02539
02540 throw nvae;
02541 }
02542 }
02543 break;
02544 default:
02545 if (state.backtracking>0) {state.failed=true; return retval;}
02546 NoViableAltException nvae =
02547 new NoViableAltException("", 22, 0, input);
02548
02549 throw nvae;
02550 }
02551
02552 switch (alt22) {
02553 case 1 :
02554
02555 {
02556
02557 int alt18=3;
02558 int LA18_0 = input.LA(1);
02559
02560 if ( (LA18_0==148) ) {
02561 alt18=1;
02562 }
02563 else if ( (LA18_0==149) ) {
02564 alt18=2;
02565 }
02566 switch (alt18) {
02567 case 1 :
02568
02569 {
02570 string_literal76=(Token)match(input,148,FOLLOW_148_in_declaration1306); if (state.failed) return retval;
02571 if ( state.backtracking==0 ) stream_148.add(string_literal76);
02572
02573
02574 }
02575 break;
02576 case 2 :
02577
02578 {
02579 string_literal77=(Token)match(input,149,FOLLOW_149_in_declaration1310); if (state.failed) return retval;
02580 if ( state.backtracking==0 ) stream_149.add(string_literal77);
02581
02582
02583 }
02584 break;
02585
02586 }
02587
02588 Identifier78=(Token)match(input,Identifier,FOLLOW_Identifier_in_declaration1314); if (state.failed) return retval;
02589 if ( state.backtracking==0 ) stream_Identifier.add(Identifier78);
02590
02591 char_literal79=(Token)match(input,150,FOLLOW_150_in_declaration1316); if (state.failed) return retval;
02592 if ( state.backtracking==0 ) stream_150.add(char_literal79);
02593
02594 pushFollow(FOLLOW_declarationMult_in_declaration1318);
02595 declarationMult80=declarationMult();
02596
02597 state._fsp--;
02598 if (state.failed) return retval;
02599 if ( state.backtracking==0 ) stream_declarationMult.add(declarationMult80.getTree());
02600 pushFollow(FOLLOW_additiveExpression_in_declaration1320);
02601 additiveExpression81=additiveExpression();
02602
02603 state._fsp--;
02604 if (state.failed) return retval;
02605 if ( state.backtracking==0 ) stream_additiveExpression.add(additiveExpression81.getTree());
02606 string_literal82=(Token)match(input,151,FOLLOW_151_in_declaration1322); if (state.failed) return retval;
02607 if ( state.backtracking==0 ) stream_151.add(string_literal82);
02608
02609 pushFollow(FOLLOW_frame_in_declaration1324);
02610 frame83=frame();
02611
02612 state._fsp--;
02613 if (state.failed) return retval;
02614 if ( state.backtracking==0 ) stream_frame.add(frame83.getTree());
02615
02616 int alt19=2;
02617 int LA19_0 = input.LA(1);
02618
02619 if ( (LA19_0==152) ) {
02620 alt19=1;
02621 }
02622 switch (alt19) {
02623 case 1 :
02624
02625 {
02626 char_literal84=(Token)match(input,152,FOLLOW_152_in_declaration1327); if (state.failed) return retval;
02627 if ( state.backtracking==0 ) stream_152.add(char_literal84);
02628
02629 pushFollow(FOLLOW_expression_in_declaration1329);
02630 expression85=expression();
02631
02632 state._fsp--;
02633 if (state.failed) return retval;
02634 if ( state.backtracking==0 ) stream_expression.add(expression85.getTree());
02635
02636 }
02637 break;
02638
02639 }
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650 if ( state.backtracking==0 ) {
02651 retval.tree = root_0;
02652 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02653
02654 root_0 = (Node)adaptor.nil();
02655
02656 {
02657
02658 {
02659 Node root_1 = (Node)adaptor.nil();
02660 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(DECLARATION, "DECLARATION"), root_1);
02661
02662
02663 {
02664 Node root_2 = (Node)adaptor.nil();
02665 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
02666
02667 adaptor.addChild(root_2, stream_Identifier.nextNode());
02668
02669 adaptor.addChild(root_1, root_2);
02670 }
02671 adaptor.addChild(root_1, stream_declarationMult.nextTree());
02672 adaptor.addChild(root_1, stream_additiveExpression.nextTree());
02673 adaptor.addChild(root_1, stream_frame.nextTree());
02674
02675 if ( stream_expression.hasNext() ) {
02676 adaptor.addChild(root_1, stream_expression.nextTree());
02677
02678 }
02679 stream_expression.reset();
02680
02681 adaptor.addChild(root_0, root_1);
02682 }
02683
02684 }
02685
02686 retval.tree = root_0;}
02687 }
02688 break;
02689 case 2 :
02690
02691 {
02692
02693 int alt20=3;
02694 int LA20_0 = input.LA(1);
02695
02696 if ( (LA20_0==148) ) {
02697 alt20=1;
02698 }
02699 else if ( (LA20_0==149) ) {
02700 alt20=2;
02701 }
02702 switch (alt20) {
02703 case 1 :
02704
02705 {
02706 string_literal86=(Token)match(input,148,FOLLOW_148_in_declaration1361); if (state.failed) return retval;
02707 if ( state.backtracking==0 ) stream_148.add(string_literal86);
02708
02709
02710 }
02711 break;
02712 case 2 :
02713
02714 {
02715 string_literal87=(Token)match(input,149,FOLLOW_149_in_declaration1365); if (state.failed) return retval;
02716 if ( state.backtracking==0 ) stream_149.add(string_literal87);
02717
02718
02719 }
02720 break;
02721
02722 }
02723
02724 Identifier88=(Token)match(input,Identifier,FOLLOW_Identifier_in_declaration1369); if (state.failed) return retval;
02725 if ( state.backtracking==0 ) stream_Identifier.add(Identifier88);
02726
02727 char_literal89=(Token)match(input,150,FOLLOW_150_in_declaration1371); if (state.failed) return retval;
02728 if ( state.backtracking==0 ) stream_150.add(char_literal89);
02729
02730 pushFollow(FOLLOW_declarationMult_in_declaration1373);
02731 declarationMult90=declarationMult();
02732
02733 state._fsp--;
02734 if (state.failed) return retval;
02735 if ( state.backtracking==0 ) stream_declarationMult.add(declarationMult90.getTree());
02736 pushFollow(FOLLOW_additiveExpression_in_declaration1375);
02737 additiveExpression91=additiveExpression();
02738
02739 state._fsp--;
02740 if (state.failed) return retval;
02741 if ( state.backtracking==0 ) stream_additiveExpression.add(additiveExpression91.getTree());
02742
02743 int alt21=2;
02744 int LA21_0 = input.LA(1);
02745
02746 if ( (LA21_0==152) ) {
02747 alt21=1;
02748 }
02749 switch (alt21) {
02750 case 1 :
02751
02752 {
02753 char_literal92=(Token)match(input,152,FOLLOW_152_in_declaration1378); if (state.failed) return retval;
02754 if ( state.backtracking==0 ) stream_152.add(char_literal92);
02755
02756 pushFollow(FOLLOW_expression_in_declaration1380);
02757 expression93=expression();
02758
02759 state._fsp--;
02760 if (state.failed) return retval;
02761 if ( state.backtracking==0 ) stream_expression.add(expression93.getTree());
02762
02763 }
02764 break;
02765
02766 }
02767
02768
02769
02770
02771
02772
02773
02774
02775
02776
02777 if ( state.backtracking==0 ) {
02778 retval.tree = root_0;
02779 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02780
02781 root_0 = (Node)adaptor.nil();
02782
02783 {
02784
02785 {
02786 Node root_1 = (Node)adaptor.nil();
02787 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(DECLARATION, "DECLARATION"), root_1);
02788
02789
02790 {
02791 Node root_2 = (Node)adaptor.nil();
02792 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
02793
02794 adaptor.addChild(root_2, stream_Identifier.nextNode());
02795
02796 adaptor.addChild(root_1, root_2);
02797 }
02798 adaptor.addChild(root_1, stream_declarationMult.nextTree());
02799 adaptor.addChild(root_1, stream_additiveExpression.nextTree());
02800 adaptor.addChild(root_1, (Node)adaptor.create(NULL, "NULL"));
02801
02802 if ( stream_expression.hasNext() ) {
02803 adaptor.addChild(root_1, stream_expression.nextTree());
02804
02805 }
02806 stream_expression.reset();
02807
02808 adaptor.addChild(root_0, root_1);
02809 }
02810
02811 }
02812
02813 retval.tree = root_0;}
02814 }
02815 break;
02816
02817 }
02818 retval.stop = input.LT(-1);
02819
02820 if ( state.backtracking==0 ) {
02821
02822 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
02823 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
02824 }
02825 }
02826 catch (RecognitionException re) {
02827 reportError(re);
02828 recover(input,re);
02829 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
02830
02831 }
02832 finally {
02833 if ( state.backtracking>0 ) { memoize(input, 13, declaration_StartIndex); }
02834 }
02835 return retval;
02836 }
02837
02838
02839 public static class declarationMult_return extends ParserRuleReturnScope {
02840 Node tree;
02841 public Object getTree() { return tree; }
02842 };
02843
02844
02845
02846 public final JFSLParser.declarationMult_return declarationMult() throws RecognitionException {
02847 JFSLParser.declarationMult_return retval = new JFSLParser.declarationMult_return();
02848 retval.start = input.LT(1);
02849 int declarationMult_StartIndex = input.index();
02850 Node root_0 = null;
02851
02852 Token string_literal95=null;
02853 Token string_literal96=null;
02854 JFSLParser.setDeclOp_return setDeclOp94 = null;
02855
02856
02857 Node string_literal95_tree=null;
02858 Node string_literal96_tree=null;
02859 RewriteRuleTokenStream stream_153=new RewriteRuleTokenStream(adaptor,"token 153");
02860 RewriteRuleTokenStream stream_154=new RewriteRuleTokenStream(adaptor,"token 154");
02861
02862 try {
02863 if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return retval; }
02864
02865 int alt23=4;
02866 switch ( input.LA(1) ) {
02867 case 193:
02868 case 194:
02869 case 195:
02870 {
02871 alt23=1;
02872 }
02873 break;
02874 case 153:
02875 {
02876 alt23=2;
02877 }
02878 break;
02879 case 154:
02880 {
02881 alt23=3;
02882 }
02883 break;
02884 case Identifier:
02885 case FloatingPointLiteral:
02886 case CharacterLiteral:
02887 case StringLiteral:
02888 case HexLiteral:
02889 case OctalLiteral:
02890 case DecimalLiteral:
02891 case 133:
02892 case 139:
02893 case 156:
02894 case 157:
02895 case 158:
02896 case 159:
02897 case 160:
02898 case 161:
02899 case 162:
02900 case 163:
02901 case 164:
02902 case 165:
02903 case 166:
02904 case 171:
02905 case 174:
02906 case 178:
02907 case 179:
02908 case 180:
02909 case 183:
02910 case 186:
02911 case 187:
02912 case 188:
02913 case 189:
02914 case 190:
02915 case 191:
02916 case 192:
02917 {
02918 alt23=4;
02919 }
02920 break;
02921 default:
02922 if (state.backtracking>0) {state.failed=true; return retval;}
02923 NoViableAltException nvae =
02924 new NoViableAltException("", 23, 0, input);
02925
02926 throw nvae;
02927 }
02928
02929 switch (alt23) {
02930 case 1 :
02931
02932 {
02933 root_0 = (Node)adaptor.nil();
02934
02935 pushFollow(FOLLOW_setDeclOp_in_declarationMult1420);
02936 setDeclOp94=setDeclOp();
02937
02938 state._fsp--;
02939 if (state.failed) return retval;
02940 if ( state.backtracking==0 ) adaptor.addChild(root_0, setDeclOp94.getTree());
02941
02942 }
02943 break;
02944 case 2 :
02945
02946 {
02947 string_literal95=(Token)match(input,153,FOLLOW_153_in_declarationMult1426); if (state.failed) return retval;
02948 if ( state.backtracking==0 ) stream_153.add(string_literal95);
02949
02950
02951
02952
02953
02954
02955
02956
02957
02958
02959 if ( state.backtracking==0 ) {
02960 retval.tree = root_0;
02961 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02962
02963 root_0 = (Node)adaptor.nil();
02964
02965 {
02966 adaptor.addChild(root_0, (Node)adaptor.create(DECL_SET, "DECL_SET"));
02967
02968 }
02969
02970 retval.tree = root_0;}
02971 }
02972 break;
02973 case 3 :
02974
02975 {
02976 string_literal96=(Token)match(input,154,FOLLOW_154_in_declarationMult1436); if (state.failed) return retval;
02977 if ( state.backtracking==0 ) stream_154.add(string_literal96);
02978
02979
02980
02981
02982
02983
02984
02985
02986
02987
02988 if ( state.backtracking==0 ) {
02989 retval.tree = root_0;
02990 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
02991
02992 root_0 = (Node)adaptor.nil();
02993
02994 {
02995 adaptor.addChild(root_0, (Node)adaptor.create(DECL_SEQ, "DECL_SEQ"));
02996
02997 }
02998
02999 retval.tree = root_0;}
03000 }
03001 break;
03002 case 4 :
03003
03004 {
03005
03006
03007
03008
03009
03010
03011
03012
03013 if ( state.backtracking==0 ) {
03014 retval.tree = root_0;
03015 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03016
03017 root_0 = (Node)adaptor.nil();
03018
03019 {
03020 adaptor.addChild(root_0, (Node)adaptor.create(DECL_NONE, "DECL_NONE"));
03021
03022 }
03023
03024 retval.tree = root_0;}
03025 }
03026 break;
03027
03028 }
03029 retval.stop = input.LT(-1);
03030
03031 if ( state.backtracking==0 ) {
03032
03033 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03034 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03035 }
03036 }
03037 catch (RecognitionException re) {
03038 reportError(re);
03039 recover(input,re);
03040 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03041
03042 }
03043 finally {
03044 if ( state.backtracking>0 ) { memoize(input, 14, declarationMult_StartIndex); }
03045 }
03046 return retval;
03047 }
03048
03049
03050 public static class frame_return extends ParserRuleReturnScope {
03051 Node tree;
03052 public Object getTree() { return tree; }
03053 };
03054
03055
03056
03057 public final JFSLParser.frame_return frame() throws RecognitionException {
03058 JFSLParser.frame_return retval = new JFSLParser.frame_return();
03059 retval.start = input.LT(1);
03060 int frame_StartIndex = input.index();
03061 Node root_0 = null;
03062
03063 Token char_literal98=null;
03064 JFSLParser.storeRef_return storeRef97 = null;
03065
03066 JFSLParser.storeRef_return storeRef99 = null;
03067
03068
03069 Node char_literal98_tree=null;
03070 RewriteRuleTokenStream stream_136=new RewriteRuleTokenStream(adaptor,"token 136");
03071 RewriteRuleSubtreeStream stream_storeRef=new RewriteRuleSubtreeStream(adaptor,"rule storeRef");
03072 try {
03073 if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return retval; }
03074
03075
03076 {
03077
03078 int alt25=2;
03079 int LA25_0 = input.LA(1);
03080
03081 if ( (LA25_0==EOF||LA25_0==140||LA25_0==152) ) {
03082 alt25=1;
03083 }
03084 else if ( (LA25_0==Identifier||LA25_0==133||LA25_0==139||LA25_0==174||LA25_0==183||(LA25_0>=186 && LA25_0<=192)) ) {
03085 alt25=2;
03086 }
03087 else {
03088 if (state.backtracking>0) {state.failed=true; return retval;}
03089 NoViableAltException nvae =
03090 new NoViableAltException("", 25, 0, input);
03091
03092 throw nvae;
03093 }
03094 switch (alt25) {
03095 case 1 :
03096
03097 {
03098 }
03099 break;
03100 case 2 :
03101
03102 {
03103 pushFollow(FOLLOW_storeRef_in_frame1467);
03104 storeRef97=storeRef();
03105
03106 state._fsp--;
03107 if (state.failed) return retval;
03108 if ( state.backtracking==0 ) stream_storeRef.add(storeRef97.getTree());
03109
03110 loop24:
03111 do {
03112 int alt24=2;
03113 int LA24_0 = input.LA(1);
03114
03115 if ( (LA24_0==136) ) {
03116 alt24=1;
03117 }
03118
03119
03120 switch (alt24) {
03121 case 1 :
03122
03123 {
03124 char_literal98=(Token)match(input,136,FOLLOW_136_in_frame1470); if (state.failed) return retval;
03125 if ( state.backtracking==0 ) stream_136.add(char_literal98);
03126
03127 pushFollow(FOLLOW_storeRef_in_frame1472);
03128 storeRef99=storeRef();
03129
03130 state._fsp--;
03131 if (state.failed) return retval;
03132 if ( state.backtracking==0 ) stream_storeRef.add(storeRef99.getTree());
03133
03134 }
03135 break;
03136
03137 default :
03138 break loop24;
03139 }
03140 } while (true);
03141
03142
03143 }
03144 break;
03145
03146 }
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157 if ( state.backtracking==0 ) {
03158 retval.tree = root_0;
03159 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03160
03161 root_0 = (Node)adaptor.nil();
03162
03163 {
03164
03165 {
03166 Node root_1 = (Node)adaptor.nil();
03167 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(FRAME, "FRAME"), root_1);
03168
03169
03170 while ( stream_storeRef.hasNext() ) {
03171 adaptor.addChild(root_1, stream_storeRef.nextTree());
03172
03173 }
03174 stream_storeRef.reset();
03175
03176 adaptor.addChild(root_0, root_1);
03177 }
03178
03179 }
03180
03181 retval.tree = root_0;}
03182 }
03183
03184 retval.stop = input.LT(-1);
03185
03186 if ( state.backtracking==0 ) {
03187
03188 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03189 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03190 }
03191 }
03192 catch (RecognitionException re) {
03193 reportError(re);
03194 recover(input,re);
03195 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03196
03197 }
03198 finally {
03199 if ( state.backtracking>0 ) { memoize(input, 15, frame_StartIndex); }
03200 }
03201 return retval;
03202 }
03203
03204
03205 public static class storeRef_return extends ParserRuleReturnScope {
03206 Node tree;
03207 public Object getTree() { return tree; }
03208 };
03209
03210
03211
03212 public final JFSLParser.storeRef_return storeRef() throws RecognitionException {
03213 JFSLParser.storeRef_return retval = new JFSLParser.storeRef_return();
03214 retval.start = input.LT(1);
03215 int storeRef_StartIndex = input.index();
03216 Node root_0 = null;
03217
03218 JFSLParser.storePrimary_return storePrimary100 = null;
03219
03220 JFSLParser.storeSelectors_return storeSelectors101 = null;
03221
03222
03223 RewriteRuleSubtreeStream stream_storeSelectors=new RewriteRuleSubtreeStream(adaptor,"rule storeSelectors");
03224 RewriteRuleSubtreeStream stream_storePrimary=new RewriteRuleSubtreeStream(adaptor,"rule storePrimary");
03225 try {
03226 if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return retval; }
03227
03228
03229 {
03230 pushFollow(FOLLOW_storePrimary_in_storeRef1497);
03231 storePrimary100=storePrimary();
03232
03233 state._fsp--;
03234 if (state.failed) return retval;
03235 if ( state.backtracking==0 ) stream_storePrimary.add(storePrimary100.getTree());
03236 pushFollow(FOLLOW_storeSelectors_in_storeRef1499);
03237 storeSelectors101=storeSelectors();
03238
03239 state._fsp--;
03240 if (state.failed) return retval;
03241 if ( state.backtracking==0 ) stream_storeSelectors.add(storeSelectors101.getTree());
03242
03243
03244
03245
03246
03247
03248
03249
03250
03251 if ( state.backtracking==0 ) {
03252 retval.tree = root_0;
03253 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03254
03255 root_0 = (Node)adaptor.nil();
03256
03257 {
03258
03259 {
03260 Node root_1 = (Node)adaptor.nil();
03261 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(FRAME_LOCATION, "FRAME_LOCATION"), root_1);
03262
03263 adaptor.addChild(root_1, stream_storePrimary.nextTree());
03264 adaptor.addChild(root_1, stream_storeSelectors.nextTree());
03265
03266 adaptor.addChild(root_0, root_1);
03267 }
03268
03269 }
03270
03271 retval.tree = root_0;}
03272 }
03273
03274 retval.stop = input.LT(-1);
03275
03276 if ( state.backtracking==0 ) {
03277
03278 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03279 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03280 }
03281 }
03282 catch (RecognitionException re) {
03283 reportError(re);
03284 recover(input,re);
03285 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03286
03287 }
03288 finally {
03289 if ( state.backtracking>0 ) { memoize(input, 16, storeRef_StartIndex); }
03290 }
03291 return retval;
03292 }
03293
03294
03295 public static class storePrimary_return extends ParserRuleReturnScope {
03296 Node tree;
03297 public Object getTree() { return tree; }
03298 };
03299
03300
03301
03302 public final JFSLParser.storePrimary_return storePrimary() throws RecognitionException {
03303 JFSLParser.storePrimary_return retval = new JFSLParser.storePrimary_return();
03304 retval.start = input.LT(1);
03305 int storePrimary_StartIndex = input.index();
03306 Node root_0 = null;
03307
03308 Token Identifier102=null;
03309 JFSLParser.common_return common103 = null;
03310
03311
03312 Node Identifier102_tree=null;
03313 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
03314
03315 try {
03316 if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return retval; }
03317
03318 int alt26=2;
03319 int LA26_0 = input.LA(1);
03320
03321 if ( (LA26_0==Identifier) ) {
03322 alt26=1;
03323 }
03324 else if ( (LA26_0==133||LA26_0==139||LA26_0==174||LA26_0==183||(LA26_0>=186 && LA26_0<=192)) ) {
03325 alt26=2;
03326 }
03327 else {
03328 if (state.backtracking>0) {state.failed=true; return retval;}
03329 NoViableAltException nvae =
03330 new NoViableAltException("", 26, 0, input);
03331
03332 throw nvae;
03333 }
03334 switch (alt26) {
03335 case 1 :
03336
03337 {
03338 Identifier102=(Token)match(input,Identifier,FOLLOW_Identifier_in_storePrimary1532); if (state.failed) return retval;
03339 if ( state.backtracking==0 ) stream_Identifier.add(Identifier102);
03340
03341
03342
03343
03344
03345
03346
03347
03348
03349
03350 if ( state.backtracking==0 ) {
03351 retval.tree = root_0;
03352 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03353
03354 root_0 = (Node)adaptor.nil();
03355
03356 {
03357
03358 {
03359 Node root_1 = (Node)adaptor.nil();
03360 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_1);
03361
03362 adaptor.addChild(root_1, stream_Identifier.nextNode());
03363
03364 adaptor.addChild(root_0, root_1);
03365 }
03366
03367 }
03368
03369 retval.tree = root_0;}
03370 }
03371 break;
03372 case 2 :
03373
03374 {
03375 root_0 = (Node)adaptor.nil();
03376
03377 pushFollow(FOLLOW_common_in_storePrimary1547);
03378 common103=common();
03379
03380 state._fsp--;
03381 if (state.failed) return retval;
03382 if ( state.backtracking==0 ) adaptor.addChild(root_0, common103.getTree());
03383
03384 }
03385 break;
03386
03387 }
03388 retval.stop = input.LT(-1);
03389
03390 if ( state.backtracking==0 ) {
03391
03392 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03393 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03394 }
03395 }
03396 catch (RecognitionException re) {
03397 reportError(re);
03398 recover(input,re);
03399 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03400
03401 }
03402 finally {
03403 if ( state.backtracking>0 ) { memoize(input, 17, storePrimary_StartIndex); }
03404 }
03405 return retval;
03406 }
03407
03408
03409 public static class storeSelectors_return extends ParserRuleReturnScope {
03410 Node tree;
03411 public Object getTree() { return tree; }
03412 };
03413
03414
03415
03416 public final JFSLParser.storeSelectors_return storeSelectors() throws RecognitionException {
03417 JFSLParser.storeSelectors_return retval = new JFSLParser.storeSelectors_return();
03418 retval.start = input.LT(1);
03419 int storeSelectors_StartIndex = input.index();
03420 Node root_0 = null;
03421
03422 JFSLParser.selector_return selector104 = null;
03423
03424 JFSLParser.storeWildCard_return storeWildCard105 = null;
03425
03426 JFSLParser.selector_return selector106 = null;
03427
03428
03429
03430 try {
03431 if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return retval; }
03432
03433 int alt29=2;
03434 int LA29_0 = input.LA(1);
03435
03436 if ( (LA29_0==129) ) {
03437 int LA29_1 = input.LA(2);
03438
03439 if ( (synpred37_JFSL()) ) {
03440 alt29=1;
03441 }
03442 else if ( (true) ) {
03443 alt29=2;
03444 }
03445 else {
03446 if (state.backtracking>0) {state.failed=true; return retval;}
03447 NoViableAltException nvae =
03448 new NoViableAltException("", 29, 1, input);
03449
03450 throw nvae;
03451 }
03452 }
03453 else if ( (LA29_0==167) ) {
03454 int LA29_2 = input.LA(2);
03455
03456 if ( (synpred37_JFSL()) ) {
03457 alt29=1;
03458 }
03459 else if ( (true) ) {
03460 alt29=2;
03461 }
03462 else {
03463 if (state.backtracking>0) {state.failed=true; return retval;}
03464 NoViableAltException nvae =
03465 new NoViableAltException("", 29, 2, input);
03466
03467 throw nvae;
03468 }
03469 }
03470 else {
03471 if (state.backtracking>0) {state.failed=true; return retval;}
03472 NoViableAltException nvae =
03473 new NoViableAltException("", 29, 0, input);
03474
03475 throw nvae;
03476 }
03477 switch (alt29) {
03478 case 1 :
03479
03480 {
03481 root_0 = (Node)adaptor.nil();
03482
03483
03484 loop27:
03485 do {
03486 int alt27=2;
03487 int LA27_0 = input.LA(1);
03488
03489 if ( (LA27_0==129) ) {
03490 int LA27_1 = input.LA(2);
03491
03492 if ( (LA27_1==155) ) {
03493 int LA27_3 = input.LA(3);
03494
03495 if ( (LA27_3==Identifier||LA27_3==133||LA27_3==139||LA27_3==174||LA27_3==183||(LA27_3>=186 && LA27_3<=192)) ) {
03496 alt27=1;
03497 }
03498
03499
03500 }
03501 else if ( (LA27_1==Identifier||LA27_1==133||LA27_1==139||(LA27_1>=159 && LA27_1<=166)||LA27_1==174||LA27_1==183||(LA27_1>=186 && LA27_1<=192)) ) {
03502 alt27=1;
03503 }
03504
03505
03506 }
03507 else if ( (LA27_0==167) ) {
03508 alt27=1;
03509 }
03510
03511
03512 switch (alt27) {
03513 case 1 :
03514
03515 {
03516 pushFollow(FOLLOW_selector_in_storeSelectors1562);
03517 selector104=selector();
03518
03519 state._fsp--;
03520 if (state.failed) return retval;
03521 if ( state.backtracking==0 ) adaptor.addChild(root_0, selector104.getTree());
03522
03523 }
03524 break;
03525
03526 default :
03527 break loop27;
03528 }
03529 } while (true);
03530
03531 pushFollow(FOLLOW_storeWildCard_in_storeSelectors1565);
03532 storeWildCard105=storeWildCard();
03533
03534 state._fsp--;
03535 if (state.failed) return retval;
03536 if ( state.backtracking==0 ) adaptor.addChild(root_0, storeWildCard105.getTree());
03537
03538 }
03539 break;
03540 case 2 :
03541
03542 {
03543 root_0 = (Node)adaptor.nil();
03544
03545
03546 int cnt28=0;
03547 loop28:
03548 do {
03549 int alt28=2;
03550 int LA28_0 = input.LA(1);
03551
03552 if ( (LA28_0==129||LA28_0==167) ) {
03553 alt28=1;
03554 }
03555
03556
03557 switch (alt28) {
03558 case 1 :
03559
03560 {
03561 pushFollow(FOLLOW_selector_in_storeSelectors1572);
03562 selector106=selector();
03563
03564 state._fsp--;
03565 if (state.failed) return retval;
03566 if ( state.backtracking==0 ) adaptor.addChild(root_0, selector106.getTree());
03567
03568 }
03569 break;
03570
03571 default :
03572 if ( cnt28 >= 1 ) break loop28;
03573 if (state.backtracking>0) {state.failed=true; return retval;}
03574 EarlyExitException eee =
03575 new EarlyExitException(28, input);
03576 throw eee;
03577 }
03578 cnt28++;
03579 } while (true);
03580
03581
03582 }
03583 break;
03584
03585 }
03586 retval.stop = input.LT(-1);
03587
03588 if ( state.backtracking==0 ) {
03589
03590 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03591 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03592 }
03593 }
03594 catch (RecognitionException re) {
03595 reportError(re);
03596 recover(input,re);
03597 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03598
03599 }
03600 finally {
03601 if ( state.backtracking>0 ) { memoize(input, 18, storeSelectors_StartIndex); }
03602 }
03603 return retval;
03604 }
03605
03606
03607 public static class storeWildCard_return extends ParserRuleReturnScope {
03608 Node tree;
03609 public Object getTree() { return tree; }
03610 };
03611
03612
03613
03614 public final JFSLParser.storeWildCard_return storeWildCard() throws RecognitionException {
03615 JFSLParser.storeWildCard_return retval = new JFSLParser.storeWildCard_return();
03616 retval.start = input.LT(1);
03617 int storeWildCard_StartIndex = input.index();
03618 Node root_0 = null;
03619
03620 Token char_literal107=null;
03621 Token char_literal108=null;
03622
03623 Node char_literal107_tree=null;
03624 Node char_literal108_tree=null;
03625 RewriteRuleTokenStream stream_129=new RewriteRuleTokenStream(adaptor,"token 129");
03626 RewriteRuleTokenStream stream_155=new RewriteRuleTokenStream(adaptor,"token 155");
03627
03628 try {
03629 if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return retval; }
03630
03631
03632 {
03633
03634
03635 {
03636 char_literal107=(Token)match(input,129,FOLLOW_129_in_storeWildCard1593); if (state.failed) return retval;
03637 if ( state.backtracking==0 ) stream_129.add(char_literal107);
03638
03639 char_literal108=(Token)match(input,155,FOLLOW_155_in_storeWildCard1595); if (state.failed) return retval;
03640 if ( state.backtracking==0 ) stream_155.add(char_literal108);
03641
03642
03643 }
03644
03645
03646
03647
03648
03649
03650
03651
03652
03653
03654 if ( state.backtracking==0 ) {
03655 retval.tree = root_0;
03656 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03657
03658 root_0 = (Node)adaptor.nil();
03659
03660 {
03661 adaptor.addChild(root_0, (Node)adaptor.create(FRAME_ALL, "FRAME_ALL"));
03662
03663 }
03664
03665 retval.tree = root_0;}
03666 }
03667
03668 retval.stop = input.LT(-1);
03669
03670 if ( state.backtracking==0 ) {
03671
03672 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03673 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03674 }
03675 }
03676 catch (RecognitionException re) {
03677 reportError(re);
03678 recover(input,re);
03679 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03680
03681 }
03682 finally {
03683 if ( state.backtracking>0 ) { memoize(input, 19, storeWildCard_StartIndex); }
03684 }
03685 return retval;
03686 }
03687
03688
03689 public static class keywordLiteral_return extends ParserRuleReturnScope {
03690 Node tree;
03691 public Object getTree() { return tree; }
03692 };
03693
03694
03695
03696 public final JFSLParser.keywordLiteral_return keywordLiteral() throws RecognitionException {
03697 JFSLParser.keywordLiteral_return retval = new JFSLParser.keywordLiteral_return();
03698 retval.start = input.LT(1);
03699 int keywordLiteral_StartIndex = input.index();
03700 Node root_0 = null;
03701
03702 Token string_literal109=null;
03703 Token string_literal110=null;
03704 Token string_literal111=null;
03705
03706 Node string_literal109_tree=null;
03707 Node string_literal110_tree=null;
03708 Node string_literal111_tree=null;
03709 RewriteRuleTokenStream stream_158=new RewriteRuleTokenStream(adaptor,"token 158");
03710 RewriteRuleTokenStream stream_157=new RewriteRuleTokenStream(adaptor,"token 157");
03711 RewriteRuleTokenStream stream_156=new RewriteRuleTokenStream(adaptor,"token 156");
03712
03713 try {
03714 if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return retval; }
03715
03716 int alt30=3;
03717 switch ( input.LA(1) ) {
03718 case 156:
03719 {
03720 alt30=1;
03721 }
03722 break;
03723 case 157:
03724 {
03725 alt30=2;
03726 }
03727 break;
03728 case 158:
03729 {
03730 alt30=3;
03731 }
03732 break;
03733 default:
03734 if (state.backtracking>0) {state.failed=true; return retval;}
03735 NoViableAltException nvae =
03736 new NoViableAltException("", 30, 0, input);
03737
03738 throw nvae;
03739 }
03740
03741 switch (alt30) {
03742 case 1 :
03743
03744 {
03745 string_literal109=(Token)match(input,156,FOLLOW_156_in_keywordLiteral1616); if (state.failed) return retval;
03746 if ( state.backtracking==0 ) stream_156.add(string_literal109);
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756
03757 if ( state.backtracking==0 ) {
03758 retval.tree = root_0;
03759 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03760
03761 root_0 = (Node)adaptor.nil();
03762
03763 {
03764 adaptor.addChild(root_0, (Node)adaptor.create(LIT_TRUE, "LIT_TRUE"));
03765
03766 }
03767
03768 retval.tree = root_0;}
03769 }
03770 break;
03771 case 2 :
03772
03773 {
03774 string_literal110=(Token)match(input,157,FOLLOW_157_in_keywordLiteral1628); if (state.failed) return retval;
03775 if ( state.backtracking==0 ) stream_157.add(string_literal110);
03776
03777
03778
03779
03780
03781
03782
03783
03784
03785
03786 if ( state.backtracking==0 ) {
03787 retval.tree = root_0;
03788 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03789
03790 root_0 = (Node)adaptor.nil();
03791
03792 {
03793 adaptor.addChild(root_0, (Node)adaptor.create(LIT_FALSE, "LIT_FALSE"));
03794
03795 }
03796
03797 retval.tree = root_0;}
03798 }
03799 break;
03800 case 3 :
03801
03802 {
03803 string_literal111=(Token)match(input,158,FOLLOW_158_in_keywordLiteral1639); if (state.failed) return retval;
03804 if ( state.backtracking==0 ) stream_158.add(string_literal111);
03805
03806
03807
03808
03809
03810
03811
03812
03813
03814
03815 if ( state.backtracking==0 ) {
03816 retval.tree = root_0;
03817 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
03818
03819 root_0 = (Node)adaptor.nil();
03820
03821 {
03822 adaptor.addChild(root_0, (Node)adaptor.create(LIT_NULL, "LIT_NULL"));
03823
03824 }
03825
03826 retval.tree = root_0;}
03827 }
03828 break;
03829
03830 }
03831 retval.stop = input.LT(-1);
03832
03833 if ( state.backtracking==0 ) {
03834
03835 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03836 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03837 }
03838 }
03839 catch (RecognitionException re) {
03840 reportError(re);
03841 recover(input,re);
03842 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
03843
03844 }
03845 finally {
03846 if ( state.backtracking>0 ) { memoize(input, 20, keywordLiteral_StartIndex); }
03847 }
03848 return retval;
03849 }
03850
03851
03852 public static class literal_return extends ParserRuleReturnScope {
03853 Node tree;
03854 public Object getTree() { return tree; }
03855 };
03856
03857
03858
03859 public final JFSLParser.literal_return literal() throws RecognitionException {
03860 JFSLParser.literal_return retval = new JFSLParser.literal_return();
03861 retval.start = input.LT(1);
03862 int literal_StartIndex = input.index();
03863 Node root_0 = null;
03864
03865 Token FloatingPointLiteral113=null;
03866 Token CharacterLiteral114=null;
03867 Token StringLiteral115=null;
03868 JFSLParser.integerLiteral_return integerLiteral112 = null;
03869
03870 JFSLParser.keywordLiteral_return keywordLiteral116 = null;
03871
03872
03873 Node FloatingPointLiteral113_tree=null;
03874 Node CharacterLiteral114_tree=null;
03875 Node StringLiteral115_tree=null;
03876
03877 try {
03878 if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return retval; }
03879
03880 int alt31=5;
03881 switch ( input.LA(1) ) {
03882 case HexLiteral:
03883 case OctalLiteral:
03884 case DecimalLiteral:
03885 {
03886 alt31=1;
03887 }
03888 break;
03889 case FloatingPointLiteral:
03890 {
03891 alt31=2;
03892 }
03893 break;
03894 case CharacterLiteral:
03895 {
03896 alt31=3;
03897 }
03898 break;
03899 case StringLiteral:
03900 {
03901 alt31=4;
03902 }
03903 break;
03904 case 156:
03905 case 157:
03906 case 158:
03907 {
03908 alt31=5;
03909 }
03910 break;
03911 default:
03912 if (state.backtracking>0) {state.failed=true; return retval;}
03913 NoViableAltException nvae =
03914 new NoViableAltException("", 31, 0, input);
03915
03916 throw nvae;
03917 }
03918
03919 switch (alt31) {
03920 case 1 :
03921
03922 {
03923 root_0 = (Node)adaptor.nil();
03924
03925 pushFollow(FOLLOW_integerLiteral_in_literal1663);
03926 integerLiteral112=integerLiteral();
03927
03928 state._fsp--;
03929 if (state.failed) return retval;
03930 if ( state.backtracking==0 ) adaptor.addChild(root_0, integerLiteral112.getTree());
03931
03932 }
03933 break;
03934 case 2 :
03935
03936 {
03937 root_0 = (Node)adaptor.nil();
03938
03939 FloatingPointLiteral113=(Token)match(input,FloatingPointLiteral,FOLLOW_FloatingPointLiteral_in_literal1669); if (state.failed) return retval;
03940 if ( state.backtracking==0 ) {
03941 FloatingPointLiteral113_tree = (Node)adaptor.create(FloatingPointLiteral113);
03942 adaptor.addChild(root_0, FloatingPointLiteral113_tree);
03943 }
03944
03945 }
03946 break;
03947 case 3 :
03948
03949 {
03950 root_0 = (Node)adaptor.nil();
03951
03952 CharacterLiteral114=(Token)match(input,CharacterLiteral,FOLLOW_CharacterLiteral_in_literal1675); if (state.failed) return retval;
03953 if ( state.backtracking==0 ) {
03954 CharacterLiteral114_tree = (Node)adaptor.create(CharacterLiteral114);
03955 adaptor.addChild(root_0, CharacterLiteral114_tree);
03956 }
03957
03958 }
03959 break;
03960 case 4 :
03961
03962 {
03963 root_0 = (Node)adaptor.nil();
03964
03965 StringLiteral115=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_literal1681); if (state.failed) return retval;
03966 if ( state.backtracking==0 ) {
03967 StringLiteral115_tree = (Node)adaptor.create(StringLiteral115);
03968 adaptor.addChild(root_0, StringLiteral115_tree);
03969 }
03970
03971 }
03972 break;
03973 case 5 :
03974
03975 {
03976 root_0 = (Node)adaptor.nil();
03977
03978 pushFollow(FOLLOW_keywordLiteral_in_literal1687);
03979 keywordLiteral116=keywordLiteral();
03980
03981 state._fsp--;
03982 if (state.failed) return retval;
03983 if ( state.backtracking==0 ) adaptor.addChild(root_0, keywordLiteral116.getTree());
03984
03985 }
03986 break;
03987
03988 }
03989 retval.stop = input.LT(-1);
03990
03991 if ( state.backtracking==0 ) {
03992
03993 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
03994 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
03995 }
03996 }
03997 catch (RecognitionException re) {
03998 reportError(re);
03999 recover(input,re);
04000 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
04001
04002 }
04003 finally {
04004 if ( state.backtracking>0 ) { memoize(input, 21, literal_StartIndex); }
04005 }
04006 return retval;
04007 }
04008
04009
04010 public static class integerLiteral_return extends ParserRuleReturnScope {
04011 Node tree;
04012 public Object getTree() { return tree; }
04013 };
04014
04015
04016
04017 public final JFSLParser.integerLiteral_return integerLiteral() throws RecognitionException {
04018 JFSLParser.integerLiteral_return retval = new JFSLParser.integerLiteral_return();
04019 retval.start = input.LT(1);
04020 int integerLiteral_StartIndex = input.index();
04021 Node root_0 = null;
04022
04023 Token set117=null;
04024
04025 Node set117_tree=null;
04026
04027 try {
04028 if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return retval; }
04029
04030
04031 {
04032 root_0 = (Node)adaptor.nil();
04033
04034 set117=(Token)input.LT(1);
04035 if ( (input.LA(1)>=HexLiteral && input.LA(1)<=DecimalLiteral) ) {
04036 input.consume();
04037 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Node)adaptor.create(set117));
04038 state.errorRecovery=false;state.failed=false;
04039 }
04040 else {
04041 if (state.backtracking>0) {state.failed=true; return retval;}
04042 MismatchedSetException mse = new MismatchedSetException(null,input);
04043 throw mse;
04044 }
04045
04046
04047 }
04048
04049 retval.stop = input.LT(-1);
04050
04051 if ( state.backtracking==0 ) {
04052
04053 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
04054 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
04055 }
04056 }
04057 catch (RecognitionException re) {
04058 reportError(re);
04059 recover(input,re);
04060 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
04061
04062 }
04063 finally {
04064 if ( state.backtracking>0 ) { memoize(input, 22, integerLiteral_StartIndex); }
04065 }
04066 return retval;
04067 }
04068
04069
04070 public static class primitiveType_return extends ParserRuleReturnScope {
04071 Node tree;
04072 public Object getTree() { return tree; }
04073 };
04074
04075
04076
04077 public final JFSLParser.primitiveType_return primitiveType() throws RecognitionException {
04078 JFSLParser.primitiveType_return retval = new JFSLParser.primitiveType_return();
04079 retval.start = input.LT(1);
04080 int primitiveType_StartIndex = input.index();
04081 Node root_0 = null;
04082
04083 Token string_literal118=null;
04084 Token string_literal119=null;
04085 Token string_literal120=null;
04086 Token string_literal121=null;
04087 Token string_literal122=null;
04088 Token string_literal123=null;
04089 Token string_literal124=null;
04090 Token string_literal125=null;
04091
04092 Node string_literal118_tree=null;
04093 Node string_literal119_tree=null;
04094 Node string_literal120_tree=null;
04095 Node string_literal121_tree=null;
04096 Node string_literal122_tree=null;
04097 Node string_literal123_tree=null;
04098 Node string_literal124_tree=null;
04099 Node string_literal125_tree=null;
04100 RewriteRuleTokenStream stream_161=new RewriteRuleTokenStream(adaptor,"token 161");
04101 RewriteRuleTokenStream stream_162=new RewriteRuleTokenStream(adaptor,"token 162");
04102 RewriteRuleTokenStream stream_163=new RewriteRuleTokenStream(adaptor,"token 163");
04103 RewriteRuleTokenStream stream_164=new RewriteRuleTokenStream(adaptor,"token 164");
04104 RewriteRuleTokenStream stream_160=new RewriteRuleTokenStream(adaptor,"token 160");
04105 RewriteRuleTokenStream stream_159=new RewriteRuleTokenStream(adaptor,"token 159");
04106 RewriteRuleTokenStream stream_166=new RewriteRuleTokenStream(adaptor,"token 166");
04107 RewriteRuleTokenStream stream_165=new RewriteRuleTokenStream(adaptor,"token 165");
04108
04109 try {
04110 if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return retval; }
04111
04112 int alt32=8;
04113 switch ( input.LA(1) ) {
04114 case 159:
04115 {
04116 alt32=1;
04117 }
04118 break;
04119 case 160:
04120 {
04121 alt32=2;
04122 }
04123 break;
04124 case 161:
04125 {
04126 alt32=3;
04127 }
04128 break;
04129 case 162:
04130 {
04131 alt32=4;
04132 }
04133 break;
04134 case 163:
04135 {
04136 alt32=5;
04137 }
04138 break;
04139 case 164:
04140 {
04141 alt32=6;
04142 }
04143 break;
04144 case 165:
04145 {
04146 alt32=7;
04147 }
04148 break;
04149 case 166:
04150 {
04151 alt32=8;
04152 }
04153 break;
04154 default:
04155 if (state.backtracking>0) {state.failed=true; return retval;}
04156 NoViableAltException nvae =
04157 new NoViableAltException("", 32, 0, input);
04158
04159 throw nvae;
04160 }
04161
04162 switch (alt32) {
04163 case 1 :
04164
04165 {
04166 string_literal118=(Token)match(input,159,FOLLOW_159_in_primitiveType1741); if (state.failed) return retval;
04167 if ( state.backtracking==0 ) stream_159.add(string_literal118);
04168
04169
04170
04171
04172
04173
04174
04175
04176
04177
04178 if ( state.backtracking==0 ) {
04179 retval.tree = root_0;
04180 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04181
04182 root_0 = (Node)adaptor.nil();
04183
04184 {
04185 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_BOOLEAN, "TYPE_BOOLEAN"));
04186
04187 }
04188
04189 retval.tree = root_0;}
04190 }
04191 break;
04192 case 2 :
04193
04194 {
04195 string_literal119=(Token)match(input,160,FOLLOW_160_in_primitiveType1750); if (state.failed) return retval;
04196 if ( state.backtracking==0 ) stream_160.add(string_literal119);
04197
04198
04199
04200
04201
04202
04203
04204
04205
04206
04207 if ( state.backtracking==0 ) {
04208 retval.tree = root_0;
04209 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04210
04211 root_0 = (Node)adaptor.nil();
04212
04213 {
04214 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_CHAR, "TYPE_CHAR"));
04215
04216 }
04217
04218 retval.tree = root_0;}
04219 }
04220 break;
04221 case 3 :
04222
04223 {
04224 string_literal120=(Token)match(input,161,FOLLOW_161_in_primitiveType1760); if (state.failed) return retval;
04225 if ( state.backtracking==0 ) stream_161.add(string_literal120);
04226
04227
04228
04229
04230
04231
04232
04233
04234
04235
04236 if ( state.backtracking==0 ) {
04237 retval.tree = root_0;
04238 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04239
04240 root_0 = (Node)adaptor.nil();
04241
04242 {
04243 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_BYTE, "TYPE_BYTE"));
04244
04245 }
04246
04247 retval.tree = root_0;}
04248 }
04249 break;
04250 case 4 :
04251
04252 {
04253 string_literal121=(Token)match(input,162,FOLLOW_162_in_primitiveType1772); if (state.failed) return retval;
04254 if ( state.backtracking==0 ) stream_162.add(string_literal121);
04255
04256
04257
04258
04259
04260
04261
04262
04263
04264
04265 if ( state.backtracking==0 ) {
04266 retval.tree = root_0;
04267 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04268
04269 root_0 = (Node)adaptor.nil();
04270
04271 {
04272 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_SHORT, "TYPE_SHORT"));
04273
04274 }
04275
04276 retval.tree = root_0;}
04277 }
04278 break;
04279 case 5 :
04280
04281 {
04282 string_literal122=(Token)match(input,163,FOLLOW_163_in_primitiveType1783); if (state.failed) return retval;
04283 if ( state.backtracking==0 ) stream_163.add(string_literal122);
04284
04285
04286
04287
04288
04289
04290
04291
04292
04293
04294 if ( state.backtracking==0 ) {
04295 retval.tree = root_0;
04296 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04297
04298 root_0 = (Node)adaptor.nil();
04299
04300 {
04301 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_INT, "TYPE_INT"));
04302
04303 }
04304
04305 retval.tree = root_0;}
04306 }
04307 break;
04308 case 6 :
04309
04310 {
04311 string_literal123=(Token)match(input,164,FOLLOW_164_in_primitiveType1794); if (state.failed) return retval;
04312 if ( state.backtracking==0 ) stream_164.add(string_literal123);
04313
04314
04315
04316
04317
04318
04319
04320
04321
04322
04323 if ( state.backtracking==0 ) {
04324 retval.tree = root_0;
04325 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04326
04327 root_0 = (Node)adaptor.nil();
04328
04329 {
04330 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_LONG, "TYPE_LONG"));
04331
04332 }
04333
04334 retval.tree = root_0;}
04335 }
04336 break;
04337 case 7 :
04338
04339 {
04340 string_literal124=(Token)match(input,165,FOLLOW_165_in_primitiveType1804); if (state.failed) return retval;
04341 if ( state.backtracking==0 ) stream_165.add(string_literal124);
04342
04343
04344
04345
04346
04347
04348
04349
04350
04351
04352 if ( state.backtracking==0 ) {
04353 retval.tree = root_0;
04354 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04355
04356 root_0 = (Node)adaptor.nil();
04357
04358 {
04359 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_FLOAT, "TYPE_FLOAT"));
04360
04361 }
04362
04363 retval.tree = root_0;}
04364 }
04365 break;
04366 case 8 :
04367
04368 {
04369 string_literal125=(Token)match(input,166,FOLLOW_166_in_primitiveType1815); if (state.failed) return retval;
04370 if ( state.backtracking==0 ) stream_166.add(string_literal125);
04371
04372
04373
04374
04375
04376
04377
04378
04379
04380
04381 if ( state.backtracking==0 ) {
04382 retval.tree = root_0;
04383 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04384
04385 root_0 = (Node)adaptor.nil();
04386
04387 {
04388 adaptor.addChild(root_0, (Node)adaptor.create(TYPE_DOUBLE, "TYPE_DOUBLE"));
04389
04390 }
04391
04392 retval.tree = root_0;}
04393 }
04394 break;
04395
04396 }
04397 retval.stop = input.LT(-1);
04398
04399 if ( state.backtracking==0 ) {
04400
04401 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
04402 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
04403 }
04404 }
04405 catch (RecognitionException re) {
04406 reportError(re);
04407 recover(input,re);
04408 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
04409
04410 }
04411 finally {
04412 if ( state.backtracking>0 ) { memoize(input, 23, primitiveType_StartIndex); }
04413 }
04414 return retval;
04415 }
04416
04417
04418 public static class typeName_return extends ParserRuleReturnScope {
04419 Node tree;
04420 public Object getTree() { return tree; }
04421 };
04422
04423
04424
04425 public final JFSLParser.typeName_return typeName() throws RecognitionException {
04426 JFSLParser.typeName_return retval = new JFSLParser.typeName_return();
04427 retval.start = input.LT(1);
04428 int typeName_StartIndex = input.index();
04429 Node root_0 = null;
04430
04431 Token Identifier126=null;
04432 Token char_literal127=null;
04433 Token Identifier128=null;
04434 JFSLParser.typeParameters_return typeParameters129 = null;
04435
04436
04437 Node Identifier126_tree=null;
04438 Node char_literal127_tree=null;
04439 Node Identifier128_tree=null;
04440 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
04441 RewriteRuleTokenStream stream_129=new RewriteRuleTokenStream(adaptor,"token 129");
04442 RewriteRuleSubtreeStream stream_typeParameters=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters");
04443 try {
04444 if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return retval; }
04445
04446
04447 {
04448 Identifier126=(Token)match(input,Identifier,FOLLOW_Identifier_in_typeName1832); if (state.failed) return retval;
04449 if ( state.backtracking==0 ) stream_Identifier.add(Identifier126);
04450
04451
04452 loop33:
04453 do {
04454 int alt33=2;
04455 int LA33_0 = input.LA(1);
04456
04457 if ( (LA33_0==129) ) {
04458 alt33=1;
04459 }
04460
04461
04462 switch (alt33) {
04463 case 1 :
04464
04465 {
04466 char_literal127=(Token)match(input,129,FOLLOW_129_in_typeName1835); if (state.failed) return retval;
04467 if ( state.backtracking==0 ) stream_129.add(char_literal127);
04468
04469 Identifier128=(Token)match(input,Identifier,FOLLOW_Identifier_in_typeName1837); if (state.failed) return retval;
04470 if ( state.backtracking==0 ) stream_Identifier.add(Identifier128);
04471
04472
04473 }
04474 break;
04475
04476 default :
04477 break loop33;
04478 }
04479 } while (true);
04480
04481
04482 int alt34=2;
04483 int LA34_0 = input.LA(1);
04484
04485 if ( (LA34_0==135) ) {
04486 int LA34_1 = input.LA(2);
04487
04488 if ( (LA34_1==Identifier) ) {
04489 alt34=1;
04490 }
04491 }
04492 switch (alt34) {
04493 case 1 :
04494
04495 {
04496 pushFollow(FOLLOW_typeParameters_in_typeName1841);
04497 typeParameters129=typeParameters();
04498
04499 state._fsp--;
04500 if (state.failed) return retval;
04501 if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters129.getTree());
04502
04503 }
04504 break;
04505
04506 }
04507
04508
04509
04510
04511
04512
04513
04514
04515
04516
04517 if ( state.backtracking==0 ) {
04518 retval.tree = root_0;
04519 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04520
04521 root_0 = (Node)adaptor.nil();
04522
04523 {
04524
04525 {
04526 Node root_1 = (Node)adaptor.nil();
04527 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_REF, "TYPE_REF"), root_1);
04528
04529 if ( !(stream_Identifier.hasNext()) ) {
04530 throw new RewriteEarlyExitException();
04531 }
04532 while ( stream_Identifier.hasNext() ) {
04533
04534 {
04535 Node root_2 = (Node)adaptor.nil();
04536 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
04537
04538 adaptor.addChild(root_2, stream_Identifier.nextNode());
04539
04540 adaptor.addChild(root_1, root_2);
04541 }
04542
04543 }
04544 stream_Identifier.reset();
04545
04546 if ( stream_typeParameters.hasNext() ) {
04547
04548 {
04549 Node root_2 = (Node)adaptor.nil();
04550 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_PARAMETERS, "TYPE_PARAMETERS"), root_2);
04551
04552 adaptor.addChild(root_2, stream_typeParameters.nextTree());
04553
04554 adaptor.addChild(root_1, root_2);
04555 }
04556
04557 }
04558 stream_typeParameters.reset();
04559
04560 adaptor.addChild(root_0, root_1);
04561 }
04562
04563 }
04564
04565 retval.tree = root_0;}
04566 }
04567
04568 retval.stop = input.LT(-1);
04569
04570 if ( state.backtracking==0 ) {
04571
04572 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
04573 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
04574 }
04575 }
04576 catch (RecognitionException re) {
04577 reportError(re);
04578 recover(input,re);
04579 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
04580
04581 }
04582 finally {
04583 if ( state.backtracking>0 ) { memoize(input, 24, typeName_StartIndex); }
04584 }
04585 return retval;
04586 }
04587
04588
04589 public static class typeDisambiguous_return extends ParserRuleReturnScope {
04590 Node tree;
04591 public Object getTree() { return tree; }
04592 };
04593
04594
04595
04596 public final JFSLParser.typeDisambiguous_return typeDisambiguous() throws RecognitionException {
04597 JFSLParser.typeDisambiguous_return retval = new JFSLParser.typeDisambiguous_return();
04598 retval.start = input.LT(1);
04599 int typeDisambiguous_StartIndex = input.index();
04600 Node root_0 = null;
04601
04602 Token char_literal131=null;
04603 Token char_literal132=null;
04604 Token char_literal134=null;
04605 Token char_literal135=null;
04606 JFSLParser.primitiveType_return primitiveType130 = null;
04607
04608 JFSLParser.typeName_return typeName133 = null;
04609
04610
04611 Node char_literal131_tree=null;
04612 Node char_literal132_tree=null;
04613 Node char_literal134_tree=null;
04614 Node char_literal135_tree=null;
04615 RewriteRuleTokenStream stream_168=new RewriteRuleTokenStream(adaptor,"token 168");
04616 RewriteRuleTokenStream stream_167=new RewriteRuleTokenStream(adaptor,"token 167");
04617 RewriteRuleSubtreeStream stream_typeName=new RewriteRuleSubtreeStream(adaptor,"rule typeName");
04618 RewriteRuleSubtreeStream stream_primitiveType=new RewriteRuleSubtreeStream(adaptor,"rule primitiveType");
04619 try {
04620 if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return retval; }
04621
04622 int alt37=2;
04623 int LA37_0 = input.LA(1);
04624
04625 if ( ((LA37_0>=159 && LA37_0<=166)) ) {
04626 alt37=1;
04627 }
04628 else if ( (LA37_0==Identifier) ) {
04629 alt37=2;
04630 }
04631 else {
04632 if (state.backtracking>0) {state.failed=true; return retval;}
04633 NoViableAltException nvae =
04634 new NoViableAltException("", 37, 0, input);
04635
04636 throw nvae;
04637 }
04638 switch (alt37) {
04639 case 1 :
04640
04641 {
04642
04643
04644 {
04645 pushFollow(FOLLOW_primitiveType_in_typeDisambiguous1878);
04646 primitiveType130=primitiveType();
04647
04648 state._fsp--;
04649 if (state.failed) return retval;
04650 if ( state.backtracking==0 ) stream_primitiveType.add(primitiveType130.getTree());
04651
04652
04653
04654
04655
04656
04657
04658
04659
04660 if ( state.backtracking==0 ) {
04661 retval.tree = root_0;
04662 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04663
04664 root_0 = (Node)adaptor.nil();
04665
04666 {
04667 adaptor.addChild(root_0, stream_primitiveType.nextTree());
04668
04669 }
04670
04671 retval.tree = root_0;}
04672 }
04673
04674
04675 loop35:
04676 do {
04677 int alt35=2;
04678 int LA35_0 = input.LA(1);
04679
04680 if ( (LA35_0==167) ) {
04681 int LA35_2 = input.LA(2);
04682
04683 if ( (LA35_2==168) ) {
04684 int LA35_3 = input.LA(3);
04685
04686 if ( (synpred56_JFSL()) ) {
04687 alt35=1;
04688 }
04689
04690
04691 }
04692
04693
04694 }
04695
04696
04697 switch (alt35) {
04698 case 1 :
04699
04700 {
04701
04702
04703 {
04704 char_literal131=(Token)match(input,167,FOLLOW_167_in_typeDisambiguous1887); if (state.failed) return retval;
04705 if ( state.backtracking==0 ) stream_167.add(char_literal131);
04706
04707 char_literal132=(Token)match(input,168,FOLLOW_168_in_typeDisambiguous1889); if (state.failed) return retval;
04708 if ( state.backtracking==0 ) stream_168.add(char_literal132);
04709
04710
04711 }
04712
04713
04714
04715
04716
04717
04718
04719
04720
04721
04722 if ( state.backtracking==0 ) {
04723 retval.tree = root_0;
04724 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04725
04726 root_0 = (Node)adaptor.nil();
04727
04728 {
04729
04730 {
04731 Node root_1 = (Node)adaptor.nil();
04732 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_ARRAY, "TYPE_ARRAY"), root_1);
04733
04734 adaptor.addChild(root_1, stream_retval.nextTree());
04735
04736 adaptor.addChild(root_0, root_1);
04737 }
04738
04739 }
04740
04741 retval.tree = root_0;}
04742 }
04743 break;
04744
04745 default :
04746 break loop35;
04747 }
04748 } while (true);
04749
04750
04751 }
04752 break;
04753 case 2 :
04754
04755 {
04756
04757
04758 {
04759 pushFollow(FOLLOW_typeName_in_typeDisambiguous1908);
04760 typeName133=typeName();
04761
04762 state._fsp--;
04763 if (state.failed) return retval;
04764 if ( state.backtracking==0 ) stream_typeName.add(typeName133.getTree());
04765
04766
04767
04768
04769
04770
04771
04772
04773
04774 if ( state.backtracking==0 ) {
04775 retval.tree = root_0;
04776 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04777
04778 root_0 = (Node)adaptor.nil();
04779
04780 {
04781 adaptor.addChild(root_0, stream_typeName.nextTree());
04782
04783 }
04784
04785 retval.tree = root_0;}
04786 }
04787
04788
04789 int cnt36=0;
04790 loop36:
04791 do {
04792 int alt36=2;
04793 int LA36_0 = input.LA(1);
04794
04795 if ( (LA36_0==167) ) {
04796 int LA36_2 = input.LA(2);
04797
04798 if ( (LA36_2==168) ) {
04799 int LA36_3 = input.LA(3);
04800
04801 if ( (synpred58_JFSL()) ) {
04802 alt36=1;
04803 }
04804
04805
04806 }
04807
04808
04809 }
04810
04811
04812 switch (alt36) {
04813 case 1 :
04814
04815 {
04816
04817
04818 {
04819 char_literal134=(Token)match(input,167,FOLLOW_167_in_typeDisambiguous1917); if (state.failed) return retval;
04820 if ( state.backtracking==0 ) stream_167.add(char_literal134);
04821
04822 char_literal135=(Token)match(input,168,FOLLOW_168_in_typeDisambiguous1919); if (state.failed) return retval;
04823 if ( state.backtracking==0 ) stream_168.add(char_literal135);
04824
04825
04826 }
04827
04828
04829
04830
04831
04832
04833
04834
04835
04836
04837 if ( state.backtracking==0 ) {
04838 retval.tree = root_0;
04839 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
04840
04841 root_0 = (Node)adaptor.nil();
04842
04843 {
04844
04845 {
04846 Node root_1 = (Node)adaptor.nil();
04847 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_ARRAY, "TYPE_ARRAY"), root_1);
04848
04849 adaptor.addChild(root_1, stream_retval.nextTree());
04850
04851 adaptor.addChild(root_0, root_1);
04852 }
04853
04854 }
04855
04856 retval.tree = root_0;}
04857 }
04858 break;
04859
04860 default :
04861 if ( cnt36 >= 1 ) break loop36;
04862 if (state.backtracking>0) {state.failed=true; return retval;}
04863 EarlyExitException eee =
04864 new EarlyExitException(36, input);
04865 throw eee;
04866 }
04867 cnt36++;
04868 } while (true);
04869
04870
04871 }
04872 break;
04873
04874 }
04875 retval.stop = input.LT(-1);
04876
04877 if ( state.backtracking==0 ) {
04878
04879 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
04880 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
04881 }
04882 }
04883 catch (RecognitionException re) {
04884 reportError(re);
04885 recover(input,re);
04886 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
04887
04888 }
04889 finally {
04890 if ( state.backtracking>0 ) { memoize(input, 25, typeDisambiguous_StartIndex); }
04891 }
04892 return retval;
04893 }
04894
04895
04896 public static class type_return extends ParserRuleReturnScope {
04897 Node tree;
04898 public Object getTree() { return tree; }
04899 };
04900
04901
04902
04903 public final JFSLParser.type_return type() throws RecognitionException {
04904 JFSLParser.type_return retval = new JFSLParser.type_return();
04905 retval.start = input.LT(1);
04906 int type_StartIndex = input.index();
04907 Node root_0 = null;
04908
04909 JFSLParser.typeDisambiguous_return typeDisambiguous136 = null;
04910
04911 JFSLParser.typeName_return typeName137 = null;
04912
04913
04914
04915 try {
04916 if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return retval; }
04917
04918 int alt38=2;
04919 alt38 = dfa38.predict(input);
04920 switch (alt38) {
04921 case 1 :
04922
04923 {
04924 root_0 = (Node)adaptor.nil();
04925
04926 pushFollow(FOLLOW_typeDisambiguous_in_type1944);
04927 typeDisambiguous136=typeDisambiguous();
04928
04929 state._fsp--;
04930 if (state.failed) return retval;
04931 if ( state.backtracking==0 ) adaptor.addChild(root_0, typeDisambiguous136.getTree());
04932
04933 }
04934 break;
04935 case 2 :
04936
04937 {
04938 root_0 = (Node)adaptor.nil();
04939
04940 pushFollow(FOLLOW_typeName_in_type1950);
04941 typeName137=typeName();
04942
04943 state._fsp--;
04944 if (state.failed) return retval;
04945 if ( state.backtracking==0 ) adaptor.addChild(root_0, typeName137.getTree());
04946
04947 }
04948 break;
04949
04950 }
04951 retval.stop = input.LT(-1);
04952
04953 if ( state.backtracking==0 ) {
04954
04955 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
04956 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
04957 }
04958 }
04959 catch (RecognitionException re) {
04960 reportError(re);
04961 recover(input,re);
04962 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
04963
04964 }
04965 finally {
04966 if ( state.backtracking>0 ) { memoize(input, 26, type_StartIndex); }
04967 }
04968 return retval;
04969 }
04970
04971
04972 public static class parExpression_return extends ParserRuleReturnScope {
04973 Node tree;
04974 public Object getTree() { return tree; }
04975 };
04976
04977
04978
04979 public final JFSLParser.parExpression_return parExpression() throws RecognitionException {
04980 JFSLParser.parExpression_return retval = new JFSLParser.parExpression_return();
04981 retval.start = input.LT(1);
04982 int parExpression_StartIndex = input.index();
04983 Node root_0 = null;
04984
04985 Token char_literal138=null;
04986 Token char_literal140=null;
04987 JFSLParser.expression_return expression139 = null;
04988
04989
04990 Node char_literal138_tree=null;
04991 Node char_literal140_tree=null;
04992
04993 try {
04994 if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return retval; }
04995
04996
04997 {
04998 root_0 = (Node)adaptor.nil();
04999
05000 char_literal138=(Token)match(input,139,FOLLOW_139_in_parExpression1984); if (state.failed) return retval;
05001 pushFollow(FOLLOW_expression_in_parExpression1987);
05002 expression139=expression();
05003
05004 state._fsp--;
05005 if (state.failed) return retval;
05006 if ( state.backtracking==0 ) adaptor.addChild(root_0, expression139.getTree());
05007 char_literal140=(Token)match(input,140,FOLLOW_140_in_parExpression1989); if (state.failed) return retval;
05008
05009 }
05010
05011 retval.stop = input.LT(-1);
05012
05013 if ( state.backtracking==0 ) {
05014
05015 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05016 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05017 }
05018 }
05019 catch (RecognitionException re) {
05020 reportError(re);
05021 recover(input,re);
05022 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05023
05024 }
05025 finally {
05026 if ( state.backtracking>0 ) { memoize(input, 27, parExpression_StartIndex); }
05027 }
05028 return retval;
05029 }
05030
05031
05032 public static class expressionList_return extends ParserRuleReturnScope {
05033 Node tree;
05034 public Object getTree() { return tree; }
05035 };
05036
05037
05038
05039 public final JFSLParser.expressionList_return expressionList() throws RecognitionException {
05040 JFSLParser.expressionList_return retval = new JFSLParser.expressionList_return();
05041 retval.start = input.LT(1);
05042 int expressionList_StartIndex = input.index();
05043 Node root_0 = null;
05044
05045 Token char_literal142=null;
05046 JFSLParser.expression_return expression141 = null;
05047
05048 JFSLParser.expression_return expression143 = null;
05049
05050
05051 Node char_literal142_tree=null;
05052
05053 try {
05054 if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return retval; }
05055
05056
05057 {
05058 root_0 = (Node)adaptor.nil();
05059
05060 pushFollow(FOLLOW_expression_in_expressionList2019);
05061 expression141=expression();
05062
05063 state._fsp--;
05064 if (state.failed) return retval;
05065 if ( state.backtracking==0 ) adaptor.addChild(root_0, expression141.getTree());
05066
05067 loop39:
05068 do {
05069 int alt39=2;
05070 int LA39_0 = input.LA(1);
05071
05072 if ( (LA39_0==136) ) {
05073 alt39=1;
05074 }
05075
05076
05077 switch (alt39) {
05078 case 1 :
05079
05080 {
05081 char_literal142=(Token)match(input,136,FOLLOW_136_in_expressionList2022); if (state.failed) return retval;
05082 pushFollow(FOLLOW_expression_in_expressionList2025);
05083 expression143=expression();
05084
05085 state._fsp--;
05086 if (state.failed) return retval;
05087 if ( state.backtracking==0 ) adaptor.addChild(root_0, expression143.getTree());
05088
05089 }
05090 break;
05091
05092 default :
05093 break loop39;
05094 }
05095 } while (true);
05096
05097
05098 }
05099
05100 retval.stop = input.LT(-1);
05101
05102 if ( state.backtracking==0 ) {
05103
05104 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05105 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05106 }
05107 }
05108 catch (RecognitionException re) {
05109 reportError(re);
05110 recover(input,re);
05111 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05112
05113 }
05114 finally {
05115 if ( state.backtracking>0 ) { memoize(input, 28, expressionList_StartIndex); }
05116 }
05117 return retval;
05118 }
05119
05120
05121 public static class arguments_return extends ParserRuleReturnScope {
05122 Node tree;
05123 public Object getTree() { return tree; }
05124 };
05125
05126
05127
05128 public final JFSLParser.arguments_return arguments() throws RecognitionException {
05129 JFSLParser.arguments_return retval = new JFSLParser.arguments_return();
05130 retval.start = input.LT(1);
05131 int arguments_StartIndex = input.index();
05132 Node root_0 = null;
05133
05134 Token char_literal144=null;
05135 Token char_literal146=null;
05136 JFSLParser.expressionList_return expressionList145 = null;
05137
05138
05139 Node char_literal144_tree=null;
05140 Node char_literal146_tree=null;
05141 RewriteRuleTokenStream stream_139=new RewriteRuleTokenStream(adaptor,"token 139");
05142 RewriteRuleTokenStream stream_140=new RewriteRuleTokenStream(adaptor,"token 140");
05143 RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
05144 try {
05145 if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return retval; }
05146
05147
05148 {
05149 char_literal144=(Token)match(input,139,FOLLOW_139_in_arguments2046); if (state.failed) return retval;
05150 if ( state.backtracking==0 ) stream_139.add(char_literal144);
05151
05152
05153 int alt40=2;
05154 int LA40_0 = input.LA(1);
05155
05156 if ( ((LA40_0>=Identifier && LA40_0<=DecimalLiteral)||LA40_0==133||LA40_0==139||(LA40_0>=156 && LA40_0<=166)||LA40_0==171||LA40_0==174||(LA40_0>=178 && LA40_0<=180)||LA40_0==183||(LA40_0>=186 && LA40_0<=199)) ) {
05157 alt40=1;
05158 }
05159 switch (alt40) {
05160 case 1 :
05161
05162 {
05163 pushFollow(FOLLOW_expressionList_in_arguments2048);
05164 expressionList145=expressionList();
05165
05166 state._fsp--;
05167 if (state.failed) return retval;
05168 if ( state.backtracking==0 ) stream_expressionList.add(expressionList145.getTree());
05169
05170 }
05171 break;
05172
05173 }
05174
05175 char_literal146=(Token)match(input,140,FOLLOW_140_in_arguments2051); if (state.failed) return retval;
05176 if ( state.backtracking==0 ) stream_140.add(char_literal146);
05177
05178
05179
05180
05181
05182
05183
05184
05185
05186
05187 if ( state.backtracking==0 ) {
05188 retval.tree = root_0;
05189 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05190
05191 root_0 = (Node)adaptor.nil();
05192
05193 {
05194
05195 {
05196 Node root_1 = (Node)adaptor.nil();
05197 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(ARGUMENTS, "ARGUMENTS"), root_1);
05198
05199
05200 if ( stream_expressionList.hasNext() ) {
05201 adaptor.addChild(root_1, stream_expressionList.nextTree());
05202
05203 }
05204 stream_expressionList.reset();
05205
05206 adaptor.addChild(root_0, root_1);
05207 }
05208
05209 }
05210
05211 retval.tree = root_0;}
05212 }
05213
05214 retval.stop = input.LT(-1);
05215
05216 if ( state.backtracking==0 ) {
05217
05218 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05219 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05220 }
05221 }
05222 catch (RecognitionException re) {
05223 reportError(re);
05224 recover(input,re);
05225 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05226
05227 }
05228 finally {
05229 if ( state.backtracking>0 ) { memoize(input, 29, arguments_StartIndex); }
05230 }
05231 return retval;
05232 }
05233
05234
05235 public static class expression_return extends ParserRuleReturnScope {
05236 Node tree;
05237 public Object getTree() { return tree; }
05238 };
05239
05240
05241
05242 public final JFSLParser.expression_return expression() throws RecognitionException {
05243 JFSLParser.expression_return retval = new JFSLParser.expression_return();
05244 retval.start = input.LT(1);
05245 int expression_StartIndex = input.index();
05246 Node root_0 = null;
05247
05248 JFSLParser.conditionalExpression_return conditionalExpression147 = null;
05249
05250
05251
05252 try {
05253 if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return retval; }
05254
05255
05256 {
05257 root_0 = (Node)adaptor.nil();
05258
05259 pushFollow(FOLLOW_conditionalExpression_in_expression2075);
05260 conditionalExpression147=conditionalExpression();
05261
05262 state._fsp--;
05263 if (state.failed) return retval;
05264 if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalExpression147.getTree());
05265
05266 }
05267
05268 retval.stop = input.LT(-1);
05269
05270 if ( state.backtracking==0 ) {
05271
05272 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05273 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05274 }
05275 }
05276 catch (RecognitionException re) {
05277 reportError(re);
05278 recover(input,re);
05279 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05280
05281 }
05282 finally {
05283 if ( state.backtracking>0 ) { memoize(input, 30, expression_StartIndex); }
05284 }
05285 return retval;
05286 }
05287
05288
05289 public static class conditionalExpression_return extends ParserRuleReturnScope {
05290 Node tree;
05291 public Object getTree() { return tree; }
05292 };
05293
05294
05295
05296 public final JFSLParser.conditionalExpression_return conditionalExpression() throws RecognitionException {
05297 JFSLParser.conditionalExpression_return retval = new JFSLParser.conditionalExpression_return();
05298 retval.start = input.LT(1);
05299 int conditionalExpression_StartIndex = input.index();
05300 Node root_0 = null;
05301
05302 Token char_literal149=null;
05303 Token char_literal151=null;
05304 JFSLParser.quantifiedExpression_return quantifiedExpression148 = null;
05305
05306 JFSLParser.expression_return expression150 = null;
05307
05308 JFSLParser.expression_return expression152 = null;
05309
05310
05311 Node char_literal149_tree=null;
05312 Node char_literal151_tree=null;
05313 RewriteRuleTokenStream stream_150=new RewriteRuleTokenStream(adaptor,"token 150");
05314 RewriteRuleTokenStream stream_169=new RewriteRuleTokenStream(adaptor,"token 169");
05315 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
05316 RewriteRuleSubtreeStream stream_quantifiedExpression=new RewriteRuleSubtreeStream(adaptor,"rule quantifiedExpression");
05317 try {
05318 if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return retval; }
05319
05320
05321 {
05322
05323
05324 {
05325 pushFollow(FOLLOW_quantifiedExpression_in_conditionalExpression2092);
05326 quantifiedExpression148=quantifiedExpression();
05327
05328 state._fsp--;
05329 if (state.failed) return retval;
05330 if ( state.backtracking==0 ) stream_quantifiedExpression.add(quantifiedExpression148.getTree());
05331
05332
05333
05334
05335
05336
05337
05338
05339
05340 if ( state.backtracking==0 ) {
05341 retval.tree = root_0;
05342 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05343
05344 root_0 = (Node)adaptor.nil();
05345
05346 {
05347 adaptor.addChild(root_0, stream_quantifiedExpression.nextTree());
05348
05349 }
05350
05351 retval.tree = root_0;}
05352 }
05353
05354
05355 int alt41=2;
05356 int LA41_0 = input.LA(1);
05357
05358 if ( (LA41_0==169) ) {
05359 int LA41_1 = input.LA(2);
05360
05361 if ( (synpred62_JFSL()) ) {
05362 alt41=1;
05363 }
05364 }
05365 switch (alt41) {
05366 case 1 :
05367
05368 {
05369 char_literal149=(Token)match(input,169,FOLLOW_169_in_conditionalExpression2105); if (state.failed) return retval;
05370 if ( state.backtracking==0 ) stream_169.add(char_literal149);
05371
05372 pushFollow(FOLLOW_expression_in_conditionalExpression2107);
05373 expression150=expression();
05374
05375 state._fsp--;
05376 if (state.failed) return retval;
05377 if ( state.backtracking==0 ) stream_expression.add(expression150.getTree());
05378 char_literal151=(Token)match(input,150,FOLLOW_150_in_conditionalExpression2109); if (state.failed) return retval;
05379 if ( state.backtracking==0 ) stream_150.add(char_literal151);
05380
05381 pushFollow(FOLLOW_expression_in_conditionalExpression2111);
05382 expression152=expression();
05383
05384 state._fsp--;
05385 if (state.failed) return retval;
05386 if ( state.backtracking==0 ) stream_expression.add(expression152.getTree());
05387
05388
05389
05390
05391
05392
05393
05394
05395
05396 if ( state.backtracking==0 ) {
05397 retval.tree = root_0;
05398 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05399
05400 root_0 = (Node)adaptor.nil();
05401
05402 {
05403
05404 {
05405 Node root_1 = (Node)adaptor.nil();
05406 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(CONDITIONAL, "CONDITIONAL"), root_1);
05407
05408 adaptor.addChild(root_1, stream_retval.nextTree());
05409 adaptor.addChild(root_1, stream_expression.nextTree());
05410 adaptor.addChild(root_1, stream_expression.nextTree());
05411
05412 adaptor.addChild(root_0, root_1);
05413 }
05414
05415 }
05416
05417 retval.tree = root_0;}
05418 }
05419 break;
05420
05421 }
05422
05423
05424 }
05425
05426 retval.stop = input.LT(-1);
05427
05428 if ( state.backtracking==0 ) {
05429
05430 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05431 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05432 }
05433 }
05434 catch (RecognitionException re) {
05435 reportError(re);
05436 recover(input,re);
05437 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05438
05439 }
05440 finally {
05441 if ( state.backtracking>0 ) { memoize(input, 31, conditionalExpression_StartIndex); }
05442 }
05443 return retval;
05444 }
05445
05446
05447 public static class quantifiedExpression_return extends ParserRuleReturnScope {
05448 Node tree;
05449 public Object getTree() { return tree; }
05450 };
05451
05452
05453
05454 public final JFSLParser.quantifiedExpression_return quantifiedExpression() throws RecognitionException {
05455 JFSLParser.quantifiedExpression_return retval = new JFSLParser.quantifiedExpression_return();
05456 retval.start = input.LT(1);
05457 int quantifiedExpression_StartIndex = input.index();
05458 Node root_0 = null;
05459
05460 Token char_literal155=null;
05461 JFSLParser.setQuantOp_return setQuantOp153 = null;
05462
05463 JFSLParser.decls_return decls154 = null;
05464
05465 JFSLParser.expression_return expression156 = null;
05466
05467 JFSLParser.logicalExpression_return logicalExpression157 = null;
05468
05469
05470 Node char_literal155_tree=null;
05471 RewriteRuleTokenStream stream_152=new RewriteRuleTokenStream(adaptor,"token 152");
05472 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
05473 RewriteRuleSubtreeStream stream_setQuantOp=new RewriteRuleSubtreeStream(adaptor,"rule setQuantOp");
05474 RewriteRuleSubtreeStream stream_decls=new RewriteRuleSubtreeStream(adaptor,"rule decls");
05475 try {
05476 if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return retval; }
05477
05478 int alt42=2;
05479 alt42 = dfa42.predict(input);
05480 switch (alt42) {
05481 case 1 :
05482
05483 {
05484 pushFollow(FOLLOW_setQuantOp_in_quantifiedExpression2147);
05485 setQuantOp153=setQuantOp();
05486
05487 state._fsp--;
05488 if (state.failed) return retval;
05489 if ( state.backtracking==0 ) stream_setQuantOp.add(setQuantOp153.getTree());
05490 pushFollow(FOLLOW_decls_in_quantifiedExpression2149);
05491 decls154=decls();
05492
05493 state._fsp--;
05494 if (state.failed) return retval;
05495 if ( state.backtracking==0 ) stream_decls.add(decls154.getTree());
05496 char_literal155=(Token)match(input,152,FOLLOW_152_in_quantifiedExpression2151); if (state.failed) return retval;
05497 if ( state.backtracking==0 ) stream_152.add(char_literal155);
05498
05499 pushFollow(FOLLOW_expression_in_quantifiedExpression2153);
05500 expression156=expression();
05501
05502 state._fsp--;
05503 if (state.failed) return retval;
05504 if ( state.backtracking==0 ) stream_expression.add(expression156.getTree());
05505
05506
05507
05508
05509
05510
05511
05512
05513
05514 if ( state.backtracking==0 ) {
05515 retval.tree = root_0;
05516 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05517
05518 root_0 = (Node)adaptor.nil();
05519
05520 {
05521
05522 {
05523 Node root_1 = (Node)adaptor.nil();
05524 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(QUANTIFY, "QUANTIFY"), root_1);
05525
05526 adaptor.addChild(root_1, stream_setQuantOp.nextTree());
05527 adaptor.addChild(root_1, stream_decls.nextTree());
05528 adaptor.addChild(root_1, stream_expression.nextTree());
05529
05530 adaptor.addChild(root_0, root_1);
05531 }
05532
05533 }
05534
05535 retval.tree = root_0;}
05536 }
05537 break;
05538 case 2 :
05539
05540 {
05541 root_0 = (Node)adaptor.nil();
05542
05543 pushFollow(FOLLOW_logicalExpression_in_quantifiedExpression2171);
05544 logicalExpression157=logicalExpression();
05545
05546 state._fsp--;
05547 if (state.failed) return retval;
05548 if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalExpression157.getTree());
05549
05550 }
05551 break;
05552
05553 }
05554 retval.stop = input.LT(-1);
05555
05556 if ( state.backtracking==0 ) {
05557
05558 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05559 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05560 }
05561 }
05562 catch (RecognitionException re) {
05563 reportError(re);
05564 recover(input,re);
05565 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05566
05567 }
05568 finally {
05569 if ( state.backtracking>0 ) { memoize(input, 32, quantifiedExpression_StartIndex); }
05570 }
05571 return retval;
05572 }
05573
05574
05575 public static class logicalExpression_return extends ParserRuleReturnScope {
05576 Node tree;
05577 public Object getTree() { return tree; }
05578 };
05579
05580
05581
05582 public final JFSLParser.logicalExpression_return logicalExpression() throws RecognitionException {
05583 JFSLParser.logicalExpression_return retval = new JFSLParser.logicalExpression_return();
05584 retval.start = input.LT(1);
05585 int logicalExpression_StartIndex = input.index();
05586 Node root_0 = null;
05587
05588 JFSLParser.conditionalOrExpression_return conditionalOrExpression158 = null;
05589
05590 JFSLParser.logicalOp_return logicalOp159 = null;
05591
05592 JFSLParser.conditionalOrExpression_return conditionalOrExpression160 = null;
05593
05594
05595 RewriteRuleSubtreeStream stream_conditionalOrExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalOrExpression");
05596 RewriteRuleSubtreeStream stream_logicalOp=new RewriteRuleSubtreeStream(adaptor,"rule logicalOp");
05597 try {
05598 if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return retval; }
05599
05600
05601 {
05602
05603
05604 {
05605 pushFollow(FOLLOW_conditionalOrExpression_in_logicalExpression2187);
05606 conditionalOrExpression158=conditionalOrExpression();
05607
05608 state._fsp--;
05609 if (state.failed) return retval;
05610 if ( state.backtracking==0 ) stream_conditionalOrExpression.add(conditionalOrExpression158.getTree());
05611
05612
05613
05614
05615
05616
05617
05618
05619
05620 if ( state.backtracking==0 ) {
05621 retval.tree = root_0;
05622 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05623
05624 root_0 = (Node)adaptor.nil();
05625
05626 {
05627 adaptor.addChild(root_0, stream_conditionalOrExpression.nextTree());
05628
05629 }
05630
05631 retval.tree = root_0;}
05632 }
05633
05634
05635 int alt43=2;
05636 int LA43_0 = input.LA(1);
05637
05638 if ( (LA43_0==135||LA43_0==170) ) {
05639 alt43=1;
05640 }
05641 switch (alt43) {
05642 case 1 :
05643
05644 {
05645 pushFollow(FOLLOW_logicalOp_in_logicalExpression2200);
05646 logicalOp159=logicalOp();
05647
05648 state._fsp--;
05649 if (state.failed) return retval;
05650 if ( state.backtracking==0 ) stream_logicalOp.add(logicalOp159.getTree());
05651 pushFollow(FOLLOW_conditionalOrExpression_in_logicalExpression2202);
05652 conditionalOrExpression160=conditionalOrExpression();
05653
05654 state._fsp--;
05655 if (state.failed) return retval;
05656 if ( state.backtracking==0 ) stream_conditionalOrExpression.add(conditionalOrExpression160.getTree());
05657
05658
05659
05660
05661
05662
05663
05664
05665
05666 if ( state.backtracking==0 ) {
05667 retval.tree = root_0;
05668 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05669
05670 root_0 = (Node)adaptor.nil();
05671
05672 {
05673
05674 {
05675 Node root_1 = (Node)adaptor.nil();
05676 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
05677
05678 adaptor.addChild(root_1, stream_logicalOp.nextTree());
05679 adaptor.addChild(root_1, stream_retval.nextTree());
05680 adaptor.addChild(root_1, stream_conditionalOrExpression.nextTree());
05681
05682 adaptor.addChild(root_0, root_1);
05683 }
05684
05685 }
05686
05687 retval.tree = root_0;}
05688 }
05689 break;
05690
05691 }
05692
05693
05694 }
05695
05696 retval.stop = input.LT(-1);
05697
05698 if ( state.backtracking==0 ) {
05699
05700 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05701 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05702 }
05703 }
05704 catch (RecognitionException re) {
05705 reportError(re);
05706 recover(input,re);
05707 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05708
05709 }
05710 finally {
05711 if ( state.backtracking>0 ) { memoize(input, 33, logicalExpression_StartIndex); }
05712 }
05713 return retval;
05714 }
05715
05716
05717 public static class logicalOp_return extends ParserRuleReturnScope {
05718 Node tree;
05719 public Object getTree() { return tree; }
05720 };
05721
05722
05723
05724 public final JFSLParser.logicalOp_return logicalOp() throws RecognitionException {
05725 JFSLParser.logicalOp_return retval = new JFSLParser.logicalOp_return();
05726 retval.start = input.LT(1);
05727 int logicalOp_StartIndex = input.index();
05728 Node root_0 = null;
05729
05730 Token char_literal161=null;
05731 Token char_literal162=null;
05732 Token char_literal163=null;
05733 Token char_literal164=null;
05734 Token char_literal165=null;
05735 Token char_literal166=null;
05736 Token char_literal167=null;
05737 Token char_literal168=null;
05738
05739 Node char_literal161_tree=null;
05740 Node char_literal162_tree=null;
05741 Node char_literal163_tree=null;
05742 Node char_literal164_tree=null;
05743 Node char_literal165_tree=null;
05744 Node char_literal166_tree=null;
05745 Node char_literal167_tree=null;
05746 Node char_literal168_tree=null;
05747 RewriteRuleTokenStream stream_170=new RewriteRuleTokenStream(adaptor,"token 170");
05748 RewriteRuleTokenStream stream_171=new RewriteRuleTokenStream(adaptor,"token 171");
05749 RewriteRuleTokenStream stream_135=new RewriteRuleTokenStream(adaptor,"token 135");
05750 RewriteRuleTokenStream stream_137=new RewriteRuleTokenStream(adaptor,"token 137");
05751
05752 try {
05753 if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return retval; }
05754
05755 int alt44=3;
05756 int LA44_0 = input.LA(1);
05757
05758 if ( (LA44_0==135) ) {
05759 int LA44_1 = input.LA(2);
05760
05761 if ( (LA44_1==170) ) {
05762 alt44=1;
05763 }
05764 else if ( (LA44_1==171) ) {
05765 alt44=2;
05766 }
05767 else {
05768 if (state.backtracking>0) {state.failed=true; return retval;}
05769 NoViableAltException nvae =
05770 new NoViableAltException("", 44, 1, input);
05771
05772 throw nvae;
05773 }
05774 }
05775 else if ( (LA44_0==170) ) {
05776 alt44=3;
05777 }
05778 else {
05779 if (state.backtracking>0) {state.failed=true; return retval;}
05780 NoViableAltException nvae =
05781 new NoViableAltException("", 44, 0, input);
05782
05783 throw nvae;
05784 }
05785 switch (alt44) {
05786 case 1 :
05787
05788 {
05789 char_literal161=(Token)match(input,135,FOLLOW_135_in_logicalOp2239); if (state.failed) return retval;
05790 if ( state.backtracking==0 ) stream_135.add(char_literal161);
05791
05792 char_literal162=(Token)match(input,170,FOLLOW_170_in_logicalOp2241); if (state.failed) return retval;
05793 if ( state.backtracking==0 ) stream_170.add(char_literal162);
05794
05795 char_literal163=(Token)match(input,137,FOLLOW_137_in_logicalOp2243); if (state.failed) return retval;
05796 if ( state.backtracking==0 ) stream_137.add(char_literal163);
05797
05798
05799
05800
05801
05802
05803
05804
05805
05806
05807 if ( state.backtracking==0 ) {
05808 retval.tree = root_0;
05809 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05810
05811 root_0 = (Node)adaptor.nil();
05812
05813 {
05814 adaptor.addChild(root_0, (Node)adaptor.create(OP_EQUIV, "OP_EQUIV"));
05815
05816 }
05817
05818 retval.tree = root_0;}
05819 }
05820 break;
05821 case 2 :
05822
05823 {
05824 char_literal164=(Token)match(input,135,FOLLOW_135_in_logicalOp2251); if (state.failed) return retval;
05825 if ( state.backtracking==0 ) stream_135.add(char_literal164);
05826
05827 char_literal165=(Token)match(input,171,FOLLOW_171_in_logicalOp2253); if (state.failed) return retval;
05828 if ( state.backtracking==0 ) stream_171.add(char_literal165);
05829
05830 char_literal166=(Token)match(input,137,FOLLOW_137_in_logicalOp2255); if (state.failed) return retval;
05831 if ( state.backtracking==0 ) stream_137.add(char_literal166);
05832
05833
05834
05835
05836
05837
05838
05839
05840
05841
05842 if ( state.backtracking==0 ) {
05843 retval.tree = root_0;
05844 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05845
05846 root_0 = (Node)adaptor.nil();
05847
05848 {
05849 adaptor.addChild(root_0, (Node)adaptor.create(OP_NEQUIV, "OP_NEQUIV"));
05850
05851 }
05852
05853 retval.tree = root_0;}
05854 }
05855 break;
05856 case 3 :
05857
05858 {
05859 char_literal167=(Token)match(input,170,FOLLOW_170_in_logicalOp2263); if (state.failed) return retval;
05860 if ( state.backtracking==0 ) stream_170.add(char_literal167);
05861
05862 char_literal168=(Token)match(input,137,FOLLOW_137_in_logicalOp2265); if (state.failed) return retval;
05863 if ( state.backtracking==0 ) stream_137.add(char_literal168);
05864
05865
05866
05867
05868
05869
05870
05871
05872
05873
05874 if ( state.backtracking==0 ) {
05875 retval.tree = root_0;
05876 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05877
05878 root_0 = (Node)adaptor.nil();
05879
05880 {
05881 adaptor.addChild(root_0, (Node)adaptor.create(OP_IMPLIES, "OP_IMPLIES"));
05882
05883 }
05884
05885 retval.tree = root_0;}
05886 }
05887 break;
05888
05889 }
05890 retval.stop = input.LT(-1);
05891
05892 if ( state.backtracking==0 ) {
05893
05894 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
05895 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
05896 }
05897 }
05898 catch (RecognitionException re) {
05899 reportError(re);
05900 recover(input,re);
05901 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
05902
05903 }
05904 finally {
05905 if ( state.backtracking>0 ) { memoize(input, 34, logicalOp_StartIndex); }
05906 }
05907 return retval;
05908 }
05909
05910
05911 public static class conditionalOrExpression_return extends ParserRuleReturnScope {
05912 Node tree;
05913 public Object getTree() { return tree; }
05914 };
05915
05916
05917
05918 public final JFSLParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
05919 JFSLParser.conditionalOrExpression_return retval = new JFSLParser.conditionalOrExpression_return();
05920 retval.start = input.LT(1);
05921 int conditionalOrExpression_StartIndex = input.index();
05922 Node root_0 = null;
05923
05924 Token string_literal170=null;
05925 JFSLParser.conditionalAndExpression_return a = null;
05926
05927 JFSLParser.conditionalAndExpression_return conditionalAndExpression169 = null;
05928
05929
05930 Node string_literal170_tree=null;
05931 RewriteRuleTokenStream stream_172=new RewriteRuleTokenStream(adaptor,"token 172");
05932 RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
05933 try {
05934 if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return retval; }
05935
05936
05937 {
05938
05939
05940 {
05941 pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression2285);
05942 conditionalAndExpression169=conditionalAndExpression();
05943
05944 state._fsp--;
05945 if (state.failed) return retval;
05946 if ( state.backtracking==0 ) stream_conditionalAndExpression.add(conditionalAndExpression169.getTree());
05947
05948
05949
05950
05951
05952
05953
05954
05955
05956 if ( state.backtracking==0 ) {
05957 retval.tree = root_0;
05958 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
05959
05960 root_0 = (Node)adaptor.nil();
05961
05962 {
05963 adaptor.addChild(root_0, stream_conditionalAndExpression.nextTree());
05964
05965 }
05966
05967 retval.tree = root_0;}
05968 }
05969
05970
05971 loop45:
05972 do {
05973 int alt45=2;
05974 int LA45_0 = input.LA(1);
05975
05976 if ( (LA45_0==172) ) {
05977 alt45=1;
05978 }
05979
05980
05981 switch (alt45) {
05982 case 1 :
05983
05984 {
05985 string_literal170=(Token)match(input,172,FOLLOW_172_in_conditionalOrExpression2300); if (state.failed) return retval;
05986 if ( state.backtracking==0 ) stream_172.add(string_literal170);
05987
05988 pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression2304);
05989 a=conditionalAndExpression();
05990
05991 state._fsp--;
05992 if (state.failed) return retval;
05993 if ( state.backtracking==0 ) stream_conditionalAndExpression.add(a.getTree());
05994
05995
05996
05997
05998
05999
06000
06001
06002
06003 if ( state.backtracking==0 ) {
06004 retval.tree = root_0;
06005 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06006 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
06007
06008 root_0 = (Node)adaptor.nil();
06009
06010 {
06011
06012 {
06013 Node root_1 = (Node)adaptor.nil();
06014 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
06015
06016 adaptor.addChild(root_1, (Node)adaptor.create(OP_OR, "OP_OR"));
06017 adaptor.addChild(root_1, stream_retval.nextTree());
06018 adaptor.addChild(root_1, stream_a.nextTree());
06019
06020 adaptor.addChild(root_0, root_1);
06021 }
06022
06023 }
06024
06025 retval.tree = root_0;}
06026 }
06027 break;
06028
06029 default :
06030 break loop45;
06031 }
06032 } while (true);
06033
06034
06035 }
06036
06037 retval.stop = input.LT(-1);
06038
06039 if ( state.backtracking==0 ) {
06040
06041 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06042 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06043 }
06044 }
06045 catch (RecognitionException re) {
06046 reportError(re);
06047 recover(input,re);
06048 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06049
06050 }
06051 finally {
06052 if ( state.backtracking>0 ) { memoize(input, 35, conditionalOrExpression_StartIndex); }
06053 }
06054 return retval;
06055 }
06056
06057
06058 public static class conditionalAndExpression_return extends ParserRuleReturnScope {
06059 Node tree;
06060 public Object getTree() { return tree; }
06061 };
06062
06063
06064
06065 public final JFSLParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
06066 JFSLParser.conditionalAndExpression_return retval = new JFSLParser.conditionalAndExpression_return();
06067 retval.start = input.LT(1);
06068 int conditionalAndExpression_StartIndex = input.index();
06069 Node root_0 = null;
06070
06071 Token string_literal172=null;
06072 JFSLParser.inclusiveOrExpression_return a = null;
06073
06074 JFSLParser.inclusiveOrExpression_return inclusiveOrExpression171 = null;
06075
06076
06077 Node string_literal172_tree=null;
06078 RewriteRuleTokenStream stream_173=new RewriteRuleTokenStream(adaptor,"token 173");
06079 RewriteRuleSubtreeStream stream_inclusiveOrExpression=new RewriteRuleSubtreeStream(adaptor,"rule inclusiveOrExpression");
06080 try {
06081 if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return retval; }
06082
06083
06084 {
06085
06086
06087 {
06088 pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2341);
06089 inclusiveOrExpression171=inclusiveOrExpression();
06090
06091 state._fsp--;
06092 if (state.failed) return retval;
06093 if ( state.backtracking==0 ) stream_inclusiveOrExpression.add(inclusiveOrExpression171.getTree());
06094
06095
06096
06097
06098
06099
06100
06101
06102
06103 if ( state.backtracking==0 ) {
06104 retval.tree = root_0;
06105 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06106
06107 root_0 = (Node)adaptor.nil();
06108
06109 {
06110 adaptor.addChild(root_0, stream_inclusiveOrExpression.nextTree());
06111
06112 }
06113
06114 retval.tree = root_0;}
06115 }
06116
06117
06118 loop46:
06119 do {
06120 int alt46=2;
06121 int LA46_0 = input.LA(1);
06122
06123 if ( (LA46_0==173) ) {
06124 alt46=1;
06125 }
06126
06127
06128 switch (alt46) {
06129 case 1 :
06130
06131 {
06132 string_literal172=(Token)match(input,173,FOLLOW_173_in_conditionalAndExpression2356); if (state.failed) return retval;
06133 if ( state.backtracking==0 ) stream_173.add(string_literal172);
06134
06135 pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2360);
06136 a=inclusiveOrExpression();
06137
06138 state._fsp--;
06139 if (state.failed) return retval;
06140 if ( state.backtracking==0 ) stream_inclusiveOrExpression.add(a.getTree());
06141
06142
06143
06144
06145
06146
06147
06148
06149
06150 if ( state.backtracking==0 ) {
06151 retval.tree = root_0;
06152 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06153 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
06154
06155 root_0 = (Node)adaptor.nil();
06156
06157 {
06158
06159 {
06160 Node root_1 = (Node)adaptor.nil();
06161 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
06162
06163 adaptor.addChild(root_1, (Node)adaptor.create(OP_AND, "OP_AND"));
06164 adaptor.addChild(root_1, stream_retval.nextTree());
06165 adaptor.addChild(root_1, stream_a.nextTree());
06166
06167 adaptor.addChild(root_0, root_1);
06168 }
06169
06170 }
06171
06172 retval.tree = root_0;}
06173 }
06174 break;
06175
06176 default :
06177 break loop46;
06178 }
06179 } while (true);
06180
06181
06182 }
06183
06184 retval.stop = input.LT(-1);
06185
06186 if ( state.backtracking==0 ) {
06187
06188 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06189 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06190 }
06191 }
06192 catch (RecognitionException re) {
06193 reportError(re);
06194 recover(input,re);
06195 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06196
06197 }
06198 finally {
06199 if ( state.backtracking>0 ) { memoize(input, 36, conditionalAndExpression_StartIndex); }
06200 }
06201 return retval;
06202 }
06203
06204
06205 public static class inclusiveOrExpression_return extends ParserRuleReturnScope {
06206 Node tree;
06207 public Object getTree() { return tree; }
06208 };
06209
06210
06211
06212 public final JFSLParser.inclusiveOrExpression_return inclusiveOrExpression() throws RecognitionException {
06213 JFSLParser.inclusiveOrExpression_return retval = new JFSLParser.inclusiveOrExpression_return();
06214 retval.start = input.LT(1);
06215 int inclusiveOrExpression_StartIndex = input.index();
06216 Node root_0 = null;
06217
06218 Token char_literal174=null;
06219 JFSLParser.exclusiveOrExpression_return a = null;
06220
06221 JFSLParser.exclusiveOrExpression_return exclusiveOrExpression173 = null;
06222
06223
06224 Node char_literal174_tree=null;
06225 RewriteRuleTokenStream stream_152=new RewriteRuleTokenStream(adaptor,"token 152");
06226 RewriteRuleSubtreeStream stream_exclusiveOrExpression=new RewriteRuleSubtreeStream(adaptor,"rule exclusiveOrExpression");
06227 try {
06228 if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return retval; }
06229
06230
06231 {
06232
06233
06234 {
06235 pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2402);
06236 exclusiveOrExpression173=exclusiveOrExpression();
06237
06238 state._fsp--;
06239 if (state.failed) return retval;
06240 if ( state.backtracking==0 ) stream_exclusiveOrExpression.add(exclusiveOrExpression173.getTree());
06241
06242
06243
06244
06245
06246
06247
06248
06249
06250 if ( state.backtracking==0 ) {
06251 retval.tree = root_0;
06252 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06253
06254 root_0 = (Node)adaptor.nil();
06255
06256 {
06257 adaptor.addChild(root_0, stream_exclusiveOrExpression.nextTree());
06258
06259 }
06260
06261 retval.tree = root_0;}
06262 }
06263
06264
06265 loop47:
06266 do {
06267 int alt47=2;
06268 int LA47_0 = input.LA(1);
06269
06270 if ( (LA47_0==152) ) {
06271 alt47=1;
06272 }
06273
06274
06275 switch (alt47) {
06276 case 1 :
06277
06278 {
06279 char_literal174=(Token)match(input,152,FOLLOW_152_in_inclusiveOrExpression2417); if (state.failed) return retval;
06280 if ( state.backtracking==0 ) stream_152.add(char_literal174);
06281
06282 pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2421);
06283 a=exclusiveOrExpression();
06284
06285 state._fsp--;
06286 if (state.failed) return retval;
06287 if ( state.backtracking==0 ) stream_exclusiveOrExpression.add(a.getTree());
06288
06289
06290
06291
06292
06293
06294
06295
06296
06297 if ( state.backtracking==0 ) {
06298 retval.tree = root_0;
06299 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06300 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
06301
06302 root_0 = (Node)adaptor.nil();
06303
06304 {
06305
06306 {
06307 Node root_1 = (Node)adaptor.nil();
06308 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
06309
06310 adaptor.addChild(root_1, (Node)adaptor.create(OP_BIT_OR, "OP_BIT_OR"));
06311 adaptor.addChild(root_1, stream_retval.nextTree());
06312 adaptor.addChild(root_1, stream_a.nextTree());
06313
06314 adaptor.addChild(root_0, root_1);
06315 }
06316
06317 }
06318
06319 retval.tree = root_0;}
06320 }
06321 break;
06322
06323 default :
06324 break loop47;
06325 }
06326 } while (true);
06327
06328
06329 }
06330
06331 retval.stop = input.LT(-1);
06332
06333 if ( state.backtracking==0 ) {
06334
06335 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06336 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06337 }
06338 }
06339 catch (RecognitionException re) {
06340 reportError(re);
06341 recover(input,re);
06342 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06343
06344 }
06345 finally {
06346 if ( state.backtracking>0 ) { memoize(input, 37, inclusiveOrExpression_StartIndex); }
06347 }
06348 return retval;
06349 }
06350
06351
06352 public static class exclusiveOrExpression_return extends ParserRuleReturnScope {
06353 Node tree;
06354 public Object getTree() { return tree; }
06355 };
06356
06357
06358
06359 public final JFSLParser.exclusiveOrExpression_return exclusiveOrExpression() throws RecognitionException {
06360 JFSLParser.exclusiveOrExpression_return retval = new JFSLParser.exclusiveOrExpression_return();
06361 retval.start = input.LT(1);
06362 int exclusiveOrExpression_StartIndex = input.index();
06363 Node root_0 = null;
06364
06365 Token char_literal176=null;
06366 JFSLParser.andExpression_return a = null;
06367
06368 JFSLParser.andExpression_return andExpression175 = null;
06369
06370
06371 Node char_literal176_tree=null;
06372 RewriteRuleTokenStream stream_174=new RewriteRuleTokenStream(adaptor,"token 174");
06373 RewriteRuleSubtreeStream stream_andExpression=new RewriteRuleSubtreeStream(adaptor,"rule andExpression");
06374 try {
06375 if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return retval; }
06376
06377
06378 {
06379
06380
06381 {
06382 pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression2458);
06383 andExpression175=andExpression();
06384
06385 state._fsp--;
06386 if (state.failed) return retval;
06387 if ( state.backtracking==0 ) stream_andExpression.add(andExpression175.getTree());
06388
06389
06390
06391
06392
06393
06394
06395
06396
06397 if ( state.backtracking==0 ) {
06398 retval.tree = root_0;
06399 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06400
06401 root_0 = (Node)adaptor.nil();
06402
06403 {
06404 adaptor.addChild(root_0, stream_andExpression.nextTree());
06405
06406 }
06407
06408 retval.tree = root_0;}
06409 }
06410
06411
06412 loop48:
06413 do {
06414 int alt48=2;
06415 int LA48_0 = input.LA(1);
06416
06417 if ( (LA48_0==174) ) {
06418 alt48=1;
06419 }
06420
06421
06422 switch (alt48) {
06423 case 1 :
06424
06425 {
06426 char_literal176=(Token)match(input,174,FOLLOW_174_in_exclusiveOrExpression2473); if (state.failed) return retval;
06427 if ( state.backtracking==0 ) stream_174.add(char_literal176);
06428
06429 pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression2477);
06430 a=andExpression();
06431
06432 state._fsp--;
06433 if (state.failed) return retval;
06434 if ( state.backtracking==0 ) stream_andExpression.add(a.getTree());
06435
06436
06437
06438
06439
06440
06441
06442
06443
06444 if ( state.backtracking==0 ) {
06445 retval.tree = root_0;
06446 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06447 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
06448
06449 root_0 = (Node)adaptor.nil();
06450
06451 {
06452
06453 {
06454 Node root_1 = (Node)adaptor.nil();
06455 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
06456
06457 adaptor.addChild(root_1, (Node)adaptor.create(OP_BIT_XOR, "OP_BIT_XOR"));
06458 adaptor.addChild(root_1, stream_retval.nextTree());
06459 adaptor.addChild(root_1, stream_a.nextTree());
06460
06461 adaptor.addChild(root_0, root_1);
06462 }
06463
06464 }
06465
06466 retval.tree = root_0;}
06467 }
06468 break;
06469
06470 default :
06471 break loop48;
06472 }
06473 } while (true);
06474
06475
06476 }
06477
06478 retval.stop = input.LT(-1);
06479
06480 if ( state.backtracking==0 ) {
06481
06482 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06483 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06484 }
06485 }
06486 catch (RecognitionException re) {
06487 reportError(re);
06488 recover(input,re);
06489 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06490
06491 }
06492 finally {
06493 if ( state.backtracking>0 ) { memoize(input, 38, exclusiveOrExpression_StartIndex); }
06494 }
06495 return retval;
06496 }
06497
06498
06499 public static class andExpression_return extends ParserRuleReturnScope {
06500 Node tree;
06501 public Object getTree() { return tree; }
06502 };
06503
06504
06505
06506 public final JFSLParser.andExpression_return andExpression() throws RecognitionException {
06507 JFSLParser.andExpression_return retval = new JFSLParser.andExpression_return();
06508 retval.start = input.LT(1);
06509 int andExpression_StartIndex = input.index();
06510 Node root_0 = null;
06511
06512 JFSLParser.equalityExpression_return a = null;
06513
06514 JFSLParser.equalityExpression_return equalityExpression177 = null;
06515
06516 JFSLParser.bitAndOp_return bitAndOp178 = null;
06517
06518
06519 RewriteRuleSubtreeStream stream_equalityExpression=new RewriteRuleSubtreeStream(adaptor,"rule equalityExpression");
06520 RewriteRuleSubtreeStream stream_bitAndOp=new RewriteRuleSubtreeStream(adaptor,"rule bitAndOp");
06521 try {
06522 if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return retval; }
06523
06524
06525 {
06526
06527
06528 {
06529 pushFollow(FOLLOW_equalityExpression_in_andExpression2516);
06530 equalityExpression177=equalityExpression();
06531
06532 state._fsp--;
06533 if (state.failed) return retval;
06534 if ( state.backtracking==0 ) stream_equalityExpression.add(equalityExpression177.getTree());
06535
06536
06537
06538
06539
06540
06541
06542
06543
06544 if ( state.backtracking==0 ) {
06545 retval.tree = root_0;
06546 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06547
06548 root_0 = (Node)adaptor.nil();
06549
06550 {
06551 adaptor.addChild(root_0, stream_equalityExpression.nextTree());
06552
06553 }
06554
06555 retval.tree = root_0;}
06556 }
06557
06558
06559 loop49:
06560 do {
06561 int alt49=2;
06562 int LA49_0 = input.LA(1);
06563
06564 if ( (LA49_0==175) ) {
06565 alt49=1;
06566 }
06567
06568
06569 switch (alt49) {
06570 case 1 :
06571
06572 {
06573 pushFollow(FOLLOW_bitAndOp_in_andExpression2531);
06574 bitAndOp178=bitAndOp();
06575
06576 state._fsp--;
06577 if (state.failed) return retval;
06578 if ( state.backtracking==0 ) stream_bitAndOp.add(bitAndOp178.getTree());
06579 pushFollow(FOLLOW_equalityExpression_in_andExpression2535);
06580 a=equalityExpression();
06581
06582 state._fsp--;
06583 if (state.failed) return retval;
06584 if ( state.backtracking==0 ) stream_equalityExpression.add(a.getTree());
06585
06586
06587
06588
06589
06590
06591
06592
06593
06594 if ( state.backtracking==0 ) {
06595 retval.tree = root_0;
06596 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06597 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
06598
06599 root_0 = (Node)adaptor.nil();
06600
06601 {
06602
06603 {
06604 Node root_1 = (Node)adaptor.nil();
06605 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
06606
06607 adaptor.addChild(root_1, stream_bitAndOp.nextTree());
06608 adaptor.addChild(root_1, stream_retval.nextTree());
06609 adaptor.addChild(root_1, stream_a.nextTree());
06610
06611 adaptor.addChild(root_0, root_1);
06612 }
06613
06614 }
06615
06616 retval.tree = root_0;}
06617 }
06618 break;
06619
06620 default :
06621 break loop49;
06622 }
06623 } while (true);
06624
06625
06626 }
06627
06628 retval.stop = input.LT(-1);
06629
06630 if ( state.backtracking==0 ) {
06631
06632 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06633 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06634 }
06635 }
06636 catch (RecognitionException re) {
06637 reportError(re);
06638 recover(input,re);
06639 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06640
06641 }
06642 finally {
06643 if ( state.backtracking>0 ) { memoize(input, 39, andExpression_StartIndex); }
06644 }
06645 return retval;
06646 }
06647
06648
06649 public static class bitAndOp_return extends ParserRuleReturnScope {
06650 Node tree;
06651 public Object getTree() { return tree; }
06652 };
06653
06654
06655
06656 public final JFSLParser.bitAndOp_return bitAndOp() throws RecognitionException {
06657 JFSLParser.bitAndOp_return retval = new JFSLParser.bitAndOp_return();
06658 retval.start = input.LT(1);
06659 int bitAndOp_StartIndex = input.index();
06660 Node root_0 = null;
06661
06662 Token char_literal179=null;
06663
06664 Node char_literal179_tree=null;
06665 RewriteRuleTokenStream stream_175=new RewriteRuleTokenStream(adaptor,"token 175");
06666
06667 try {
06668 if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return retval; }
06669
06670
06671 {
06672 char_literal179=(Token)match(input,175,FOLLOW_175_in_bitAndOp2572); if (state.failed) return retval;
06673 if ( state.backtracking==0 ) stream_175.add(char_literal179);
06674
06675
06676
06677
06678
06679
06680
06681
06682
06683
06684 if ( state.backtracking==0 ) {
06685 retval.tree = root_0;
06686 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06687
06688 root_0 = (Node)adaptor.nil();
06689
06690 {
06691 adaptor.addChild(root_0, (Node)adaptor.create(OP_BIT_AND_OR_INTERSECTION, "OP_BIT_AND_OR_INTERSECTION"));
06692
06693 }
06694
06695 retval.tree = root_0;}
06696 }
06697
06698 retval.stop = input.LT(-1);
06699
06700 if ( state.backtracking==0 ) {
06701
06702 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06703 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06704 }
06705 }
06706 catch (RecognitionException re) {
06707 reportError(re);
06708 recover(input,re);
06709 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06710
06711 }
06712 finally {
06713 if ( state.backtracking>0 ) { memoize(input, 40, bitAndOp_StartIndex); }
06714 }
06715 return retval;
06716 }
06717
06718
06719 public static class equalityExpression_return extends ParserRuleReturnScope {
06720 Node tree;
06721 public Object getTree() { return tree; }
06722 };
06723
06724
06725
06726 public final JFSLParser.equalityExpression_return equalityExpression() throws RecognitionException {
06727 JFSLParser.equalityExpression_return retval = new JFSLParser.equalityExpression_return();
06728 retval.start = input.LT(1);
06729 int equalityExpression_StartIndex = input.index();
06730 Node root_0 = null;
06731
06732 JFSLParser.equalityOp_return op = null;
06733
06734 JFSLParser.instanceOfExpression_return a = null;
06735
06736 JFSLParser.instanceOfExpression_return instanceOfExpression180 = null;
06737
06738
06739 RewriteRuleSubtreeStream stream_instanceOfExpression=new RewriteRuleSubtreeStream(adaptor,"rule instanceOfExpression");
06740 RewriteRuleSubtreeStream stream_equalityOp=new RewriteRuleSubtreeStream(adaptor,"rule equalityOp");
06741 try {
06742 if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return retval; }
06743
06744
06745 {
06746
06747
06748 {
06749 pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression2594);
06750 instanceOfExpression180=instanceOfExpression();
06751
06752 state._fsp--;
06753 if (state.failed) return retval;
06754 if ( state.backtracking==0 ) stream_instanceOfExpression.add(instanceOfExpression180.getTree());
06755
06756
06757
06758
06759
06760
06761
06762
06763
06764 if ( state.backtracking==0 ) {
06765 retval.tree = root_0;
06766 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06767
06768 root_0 = (Node)adaptor.nil();
06769
06770 {
06771 adaptor.addChild(root_0, stream_instanceOfExpression.nextTree());
06772
06773 }
06774
06775 retval.tree = root_0;}
06776 }
06777
06778
06779 loop50:
06780 do {
06781 int alt50=2;
06782 int LA50_0 = input.LA(1);
06783
06784 if ( (LA50_0==170) ) {
06785 int LA50_2 = input.LA(2);
06786
06787 if ( ((LA50_2>=Identifier && LA50_2<=DecimalLiteral)||LA50_2==133||LA50_2==139||(LA50_2>=156 && LA50_2<=166)||(LA50_2>=170 && LA50_2<=171)||LA50_2==174||(LA50_2>=178 && LA50_2<=180)||LA50_2==183||(LA50_2>=186 && LA50_2<=197)) ) {
06788 alt50=1;
06789 }
06790
06791
06792 }
06793 else if ( (LA50_0==171) ) {
06794 alt50=1;
06795 }
06796
06797
06798 switch (alt50) {
06799 case 1 :
06800
06801 {
06802 pushFollow(FOLLOW_equalityOp_in_equalityExpression2611);
06803 op=equalityOp();
06804
06805 state._fsp--;
06806 if (state.failed) return retval;
06807 if ( state.backtracking==0 ) stream_equalityOp.add(op.getTree());
06808 pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression2615);
06809 a=instanceOfExpression();
06810
06811 state._fsp--;
06812 if (state.failed) return retval;
06813 if ( state.backtracking==0 ) stream_instanceOfExpression.add(a.getTree());
06814
06815
06816
06817
06818
06819
06820
06821
06822
06823 if ( state.backtracking==0 ) {
06824 retval.tree = root_0;
06825 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06826 RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.tree:null);
06827 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
06828
06829 root_0 = (Node)adaptor.nil();
06830
06831 {
06832
06833 {
06834 Node root_1 = (Node)adaptor.nil();
06835 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
06836
06837 adaptor.addChild(root_1, stream_op.nextTree());
06838 adaptor.addChild(root_1, stream_retval.nextTree());
06839 adaptor.addChild(root_1, stream_a.nextTree());
06840
06841 adaptor.addChild(root_0, root_1);
06842 }
06843
06844 }
06845
06846 retval.tree = root_0;}
06847 }
06848 break;
06849
06850 default :
06851 break loop50;
06852 }
06853 } while (true);
06854
06855
06856 }
06857
06858 retval.stop = input.LT(-1);
06859
06860 if ( state.backtracking==0 ) {
06861
06862 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
06863 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
06864 }
06865 }
06866 catch (RecognitionException re) {
06867 reportError(re);
06868 recover(input,re);
06869 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
06870
06871 }
06872 finally {
06873 if ( state.backtracking>0 ) { memoize(input, 41, equalityExpression_StartIndex); }
06874 }
06875 return retval;
06876 }
06877
06878
06879 public static class equalityOp_return extends ParserRuleReturnScope {
06880 Node tree;
06881 public Object getTree() { return tree; }
06882 };
06883
06884
06885
06886 public final JFSLParser.equalityOp_return equalityOp() throws RecognitionException {
06887 JFSLParser.equalityOp_return retval = new JFSLParser.equalityOp_return();
06888 retval.start = input.LT(1);
06889 int equalityOp_StartIndex = input.index();
06890 Node root_0 = null;
06891
06892 Token char_literal181=null;
06893 Token char_literal182=null;
06894 Token char_literal183=null;
06895 Token char_literal184=null;
06896 Token char_literal185=null;
06897
06898 Node char_literal181_tree=null;
06899 Node char_literal182_tree=null;
06900 Node char_literal183_tree=null;
06901 Node char_literal184_tree=null;
06902 Node char_literal185_tree=null;
06903 RewriteRuleTokenStream stream_170=new RewriteRuleTokenStream(adaptor,"token 170");
06904 RewriteRuleTokenStream stream_171=new RewriteRuleTokenStream(adaptor,"token 171");
06905
06906 try {
06907 if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return retval; }
06908
06909 int alt51=3;
06910 int LA51_0 = input.LA(1);
06911
06912 if ( (LA51_0==170) ) {
06913 int LA51_1 = input.LA(2);
06914
06915 if ( (LA51_1==170) ) {
06916 alt51=1;
06917 }
06918 else if ( ((LA51_1>=Identifier && LA51_1<=DecimalLiteral)||LA51_1==133||LA51_1==139||(LA51_1>=156 && LA51_1<=166)||LA51_1==171||LA51_1==174||(LA51_1>=178 && LA51_1<=180)||LA51_1==183||(LA51_1>=186 && LA51_1<=197)) ) {
06919 alt51=3;
06920 }
06921 else {
06922 if (state.backtracking>0) {state.failed=true; return retval;}
06923 NoViableAltException nvae =
06924 new NoViableAltException("", 51, 1, input);
06925
06926 throw nvae;
06927 }
06928 }
06929 else if ( (LA51_0==171) ) {
06930 alt51=2;
06931 }
06932 else {
06933 if (state.backtracking>0) {state.failed=true; return retval;}
06934 NoViableAltException nvae =
06935 new NoViableAltException("", 51, 0, input);
06936
06937 throw nvae;
06938 }
06939 switch (alt51) {
06940 case 1 :
06941
06942 {
06943 char_literal181=(Token)match(input,170,FOLLOW_170_in_equalityOp2656); if (state.failed) return retval;
06944 if ( state.backtracking==0 ) stream_170.add(char_literal181);
06945
06946 char_literal182=(Token)match(input,170,FOLLOW_170_in_equalityOp2658); if (state.failed) return retval;
06947 if ( state.backtracking==0 ) stream_170.add(char_literal182);
06948
06949
06950
06951
06952
06953
06954
06955
06956
06957
06958 if ( state.backtracking==0 ) {
06959 retval.tree = root_0;
06960 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06961
06962 root_0 = (Node)adaptor.nil();
06963
06964 {
06965 adaptor.addChild(root_0, (Node)adaptor.create(OP_EQ, "OP_EQ"));
06966
06967 }
06968
06969 retval.tree = root_0;}
06970 }
06971 break;
06972 case 2 :
06973
06974 {
06975 char_literal183=(Token)match(input,171,FOLLOW_171_in_equalityOp2666); if (state.failed) return retval;
06976 if ( state.backtracking==0 ) stream_171.add(char_literal183);
06977
06978 char_literal184=(Token)match(input,170,FOLLOW_170_in_equalityOp2668); if (state.failed) return retval;
06979 if ( state.backtracking==0 ) stream_170.add(char_literal184);
06980
06981
06982
06983
06984
06985
06986
06987
06988
06989
06990 if ( state.backtracking==0 ) {
06991 retval.tree = root_0;
06992 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
06993
06994 root_0 = (Node)adaptor.nil();
06995
06996 {
06997 adaptor.addChild(root_0, (Node)adaptor.create(OP_NEQ, "OP_NEQ"));
06998
06999 }
07000
07001 retval.tree = root_0;}
07002 }
07003 break;
07004 case 3 :
07005
07006 {
07007 char_literal185=(Token)match(input,170,FOLLOW_170_in_equalityOp2676); if (state.failed) return retval;
07008 if ( state.backtracking==0 ) stream_170.add(char_literal185);
07009
07010
07011
07012
07013
07014
07015
07016
07017
07018
07019 if ( state.backtracking==0 ) {
07020 retval.tree = root_0;
07021 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07022
07023 root_0 = (Node)adaptor.nil();
07024
07025 {
07026 adaptor.addChild(root_0, (Node)adaptor.create(OP_EQ, "OP_EQ"));
07027
07028 }
07029
07030 retval.tree = root_0;}
07031 }
07032 break;
07033
07034 }
07035 retval.stop = input.LT(-1);
07036
07037 if ( state.backtracking==0 ) {
07038
07039 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
07040 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
07041 }
07042 }
07043 catch (RecognitionException re) {
07044 reportError(re);
07045 recover(input,re);
07046 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
07047
07048 }
07049 finally {
07050 if ( state.backtracking>0 ) { memoize(input, 42, equalityOp_StartIndex); }
07051 }
07052 return retval;
07053 }
07054
07055
07056 public static class instanceOfExpression_return extends ParserRuleReturnScope {
07057 Node tree;
07058 public Object getTree() { return tree; }
07059 };
07060
07061
07062
07063 public final JFSLParser.instanceOfExpression_return instanceOfExpression() throws RecognitionException {
07064 JFSLParser.instanceOfExpression_return retval = new JFSLParser.instanceOfExpression_return();
07065 retval.start = input.LT(1);
07066 int instanceOfExpression_StartIndex = input.index();
07067 Node root_0 = null;
07068
07069 Token string_literal187=null;
07070 JFSLParser.type_return a = null;
07071
07072 JFSLParser.relationalExpression_return relationalExpression186 = null;
07073
07074
07075 Node string_literal187_tree=null;
07076 RewriteRuleTokenStream stream_176=new RewriteRuleTokenStream(adaptor,"token 176");
07077 RewriteRuleSubtreeStream stream_relationalExpression=new RewriteRuleSubtreeStream(adaptor,"rule relationalExpression");
07078 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
07079 try {
07080 if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return retval; }
07081
07082
07083 {
07084
07085
07086 {
07087 pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression2698);
07088 relationalExpression186=relationalExpression();
07089
07090 state._fsp--;
07091 if (state.failed) return retval;
07092 if ( state.backtracking==0 ) stream_relationalExpression.add(relationalExpression186.getTree());
07093
07094
07095
07096
07097
07098
07099
07100
07101
07102 if ( state.backtracking==0 ) {
07103 retval.tree = root_0;
07104 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07105
07106 root_0 = (Node)adaptor.nil();
07107
07108 {
07109 adaptor.addChild(root_0, stream_relationalExpression.nextTree());
07110
07111 }
07112
07113 retval.tree = root_0;}
07114 }
07115
07116
07117 int alt52=2;
07118 int LA52_0 = input.LA(1);
07119
07120 if ( (LA52_0==176) ) {
07121 alt52=1;
07122 }
07123 switch (alt52) {
07124 case 1 :
07125
07126 {
07127 string_literal187=(Token)match(input,176,FOLLOW_176_in_instanceOfExpression2713); if (state.failed) return retval;
07128 if ( state.backtracking==0 ) stream_176.add(string_literal187);
07129
07130 pushFollow(FOLLOW_type_in_instanceOfExpression2717);
07131 a=type();
07132
07133 state._fsp--;
07134 if (state.failed) return retval;
07135 if ( state.backtracking==0 ) stream_type.add(a.getTree());
07136
07137
07138
07139
07140
07141
07142
07143
07144
07145 if ( state.backtracking==0 ) {
07146 retval.tree = root_0;
07147 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07148 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
07149
07150 root_0 = (Node)adaptor.nil();
07151
07152 {
07153
07154 {
07155 Node root_1 = (Node)adaptor.nil();
07156 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
07157
07158 adaptor.addChild(root_1, (Node)adaptor.create(OP_INSTANCEOF, "OP_INSTANCEOF"));
07159 adaptor.addChild(root_1, stream_retval.nextTree());
07160 adaptor.addChild(root_1, stream_a.nextTree());
07161
07162 adaptor.addChild(root_0, root_1);
07163 }
07164
07165 }
07166
07167 retval.tree = root_0;}
07168 }
07169 break;
07170
07171 }
07172
07173
07174 }
07175
07176 retval.stop = input.LT(-1);
07177
07178 if ( state.backtracking==0 ) {
07179
07180 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
07181 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
07182 }
07183 }
07184 catch (RecognitionException re) {
07185 reportError(re);
07186 recover(input,re);
07187 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
07188
07189 }
07190 finally {
07191 if ( state.backtracking>0 ) { memoize(input, 43, instanceOfExpression_StartIndex); }
07192 }
07193 return retval;
07194 }
07195
07196
07197 public static class relationalExpression_return extends ParserRuleReturnScope {
07198 Node tree;
07199 public Object getTree() { return tree; }
07200 };
07201
07202
07203
07204 public final JFSLParser.relationalExpression_return relationalExpression() throws RecognitionException {
07205 JFSLParser.relationalExpression_return retval = new JFSLParser.relationalExpression_return();
07206 retval.start = input.LT(1);
07207 int relationalExpression_StartIndex = input.index();
07208 Node root_0 = null;
07209
07210 JFSLParser.relationalOp_return op = null;
07211
07212 JFSLParser.setUnaryExpression_return a = null;
07213
07214 JFSLParser.setUnaryExpression_return setUnaryExpression188 = null;
07215
07216
07217 RewriteRuleSubtreeStream stream_relationalOp=new RewriteRuleSubtreeStream(adaptor,"rule relationalOp");
07218 RewriteRuleSubtreeStream stream_setUnaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule setUnaryExpression");
07219 try {
07220 if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return retval; }
07221
07222
07223 {
07224
07225
07226 {
07227 pushFollow(FOLLOW_setUnaryExpression_in_relationalExpression2756);
07228 setUnaryExpression188=setUnaryExpression();
07229
07230 state._fsp--;
07231 if (state.failed) return retval;
07232 if ( state.backtracking==0 ) stream_setUnaryExpression.add(setUnaryExpression188.getTree());
07233
07234
07235
07236
07237
07238
07239
07240
07241
07242 if ( state.backtracking==0 ) {
07243 retval.tree = root_0;
07244 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07245
07246 root_0 = (Node)adaptor.nil();
07247
07248 {
07249 adaptor.addChild(root_0, stream_setUnaryExpression.nextTree());
07250
07251 }
07252
07253 retval.tree = root_0;}
07254 }
07255
07256
07257 loop53:
07258 do {
07259 int alt53=2;
07260 switch ( input.LA(1) ) {
07261 case 171:
07262 {
07263 int LA53_2 = input.LA(2);
07264
07265 if ( (LA53_2==177) ) {
07266 alt53=1;
07267 }
07268
07269
07270 }
07271 break;
07272 case 135:
07273 {
07274 switch ( input.LA(2) ) {
07275 case 170:
07276 {
07277 int LA53_5 = input.LA(3);
07278
07279 if ( ((LA53_5>=Identifier && LA53_5<=DecimalLiteral)||LA53_5==133||LA53_5==139||(LA53_5>=156 && LA53_5<=166)||LA53_5==171||LA53_5==174||(LA53_5>=178 && LA53_5<=180)||LA53_5==183||(LA53_5>=186 && LA53_5<=197)) ) {
07280 alt53=1;
07281 }
07282
07283
07284 }
07285 break;
07286 case 171:
07287 {
07288 int LA53_6 = input.LA(3);
07289
07290 if ( ((LA53_6>=Identifier && LA53_6<=DecimalLiteral)||LA53_6==133||LA53_6==139||(LA53_6>=156 && LA53_6<=166)||LA53_6==171||LA53_6==174||(LA53_6>=178 && LA53_6<=179)||LA53_6==183||(LA53_6>=186 && LA53_6<=192)) ) {
07291 alt53=1;
07292 }
07293
07294
07295 }
07296 break;
07297 case Identifier:
07298 case FloatingPointLiteral:
07299 case CharacterLiteral:
07300 case StringLiteral:
07301 case HexLiteral:
07302 case OctalLiteral:
07303 case DecimalLiteral:
07304 case 133:
07305 case 139:
07306 case 156:
07307 case 157:
07308 case 158:
07309 case 159:
07310 case 160:
07311 case 161:
07312 case 162:
07313 case 163:
07314 case 164:
07315 case 165:
07316 case 166:
07317 case 174:
07318 case 178:
07319 case 179:
07320 case 180:
07321 case 183:
07322 case 186:
07323 case 187:
07324 case 188:
07325 case 189:
07326 case 190:
07327 case 191:
07328 case 192:
07329 case 193:
07330 case 194:
07331 case 195:
07332 case 196:
07333 case 197:
07334 {
07335 alt53=1;
07336 }
07337 break;
07338
07339 }
07340
07341 }
07342 break;
07343 case 137:
07344 case 177:
07345 {
07346 alt53=1;
07347 }
07348 break;
07349
07350 }
07351
07352 switch (alt53) {
07353 case 1 :
07354
07355 {
07356 pushFollow(FOLLOW_relationalOp_in_relationalExpression2773);
07357 op=relationalOp();
07358
07359 state._fsp--;
07360 if (state.failed) return retval;
07361 if ( state.backtracking==0 ) stream_relationalOp.add(op.getTree());
07362 pushFollow(FOLLOW_setUnaryExpression_in_relationalExpression2777);
07363 a=setUnaryExpression();
07364
07365 state._fsp--;
07366 if (state.failed) return retval;
07367 if ( state.backtracking==0 ) stream_setUnaryExpression.add(a.getTree());
07368
07369
07370
07371
07372
07373
07374
07375
07376
07377 if ( state.backtracking==0 ) {
07378 retval.tree = root_0;
07379 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07380 RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.tree:null);
07381 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
07382
07383 root_0 = (Node)adaptor.nil();
07384
07385 {
07386
07387 {
07388 Node root_1 = (Node)adaptor.nil();
07389 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
07390
07391 adaptor.addChild(root_1, stream_op.nextTree());
07392 adaptor.addChild(root_1, stream_retval.nextTree());
07393 adaptor.addChild(root_1, stream_a.nextTree());
07394
07395 adaptor.addChild(root_0, root_1);
07396 }
07397
07398 }
07399
07400 retval.tree = root_0;}
07401 }
07402 break;
07403
07404 default :
07405 break loop53;
07406 }
07407 } while (true);
07408
07409
07410 }
07411
07412 retval.stop = input.LT(-1);
07413
07414 if ( state.backtracking==0 ) {
07415
07416 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
07417 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
07418 }
07419 }
07420 catch (RecognitionException re) {
07421 reportError(re);
07422 recover(input,re);
07423 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
07424
07425 }
07426 finally {
07427 if ( state.backtracking>0 ) { memoize(input, 44, relationalExpression_StartIndex); }
07428 }
07429 return retval;
07430 }
07431
07432
07433 public static class inOp_return extends ParserRuleReturnScope {
07434 Node tree;
07435 public Object getTree() { return tree; }
07436 };
07437
07438
07439
07440 public final JFSLParser.inOp_return inOp() throws RecognitionException {
07441 JFSLParser.inOp_return retval = new JFSLParser.inOp_return();
07442 retval.start = input.LT(1);
07443 int inOp_StartIndex = input.index();
07444 Node root_0 = null;
07445
07446 Token string_literal189=null;
07447
07448 Node string_literal189_tree=null;
07449 RewriteRuleTokenStream stream_177=new RewriteRuleTokenStream(adaptor,"token 177");
07450
07451 try {
07452 if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return retval; }
07453
07454
07455 {
07456 string_literal189=(Token)match(input,177,FOLLOW_177_in_inOp2816); if (state.failed) return retval;
07457 if ( state.backtracking==0 ) stream_177.add(string_literal189);
07458
07459
07460
07461
07462
07463
07464
07465
07466
07467
07468 if ( state.backtracking==0 ) {
07469 retval.tree = root_0;
07470 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07471
07472 root_0 = (Node)adaptor.nil();
07473
07474 {
07475 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_SUBSET, "OP_SET_SUBSET"));
07476
07477 }
07478
07479 retval.tree = root_0;}
07480 }
07481
07482 retval.stop = input.LT(-1);
07483
07484 if ( state.backtracking==0 ) {
07485
07486 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
07487 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
07488 }
07489 }
07490 catch (RecognitionException re) {
07491 reportError(re);
07492 recover(input,re);
07493 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
07494
07495 }
07496 finally {
07497 if ( state.backtracking>0 ) { memoize(input, 45, inOp_StartIndex); }
07498 }
07499 return retval;
07500 }
07501
07502
07503 public static class relationalOp_return extends ParserRuleReturnScope {
07504 Node tree;
07505 public Object getTree() { return tree; }
07506 };
07507
07508
07509
07510 public final JFSLParser.relationalOp_return relationalOp() throws RecognitionException {
07511 JFSLParser.relationalOp_return retval = new JFSLParser.relationalOp_return();
07512 retval.start = input.LT(1);
07513 int relationalOp_StartIndex = input.index();
07514 Node root_0 = null;
07515
07516 Token char_literal190=null;
07517 Token char_literal191=null;
07518 Token char_literal192=null;
07519 Token char_literal193=null;
07520 Token char_literal194=null;
07521 Token char_literal195=null;
07522 Token char_literal197=null;
07523 Token string_literal198=null;
07524 JFSLParser.inOp_return inOp196 = null;
07525
07526
07527 Node char_literal190_tree=null;
07528 Node char_literal191_tree=null;
07529 Node char_literal192_tree=null;
07530 Node char_literal193_tree=null;
07531 Node char_literal194_tree=null;
07532 Node char_literal195_tree=null;
07533 Node char_literal197_tree=null;
07534 Node string_literal198_tree=null;
07535 RewriteRuleTokenStream stream_170=new RewriteRuleTokenStream(adaptor,"token 170");
07536 RewriteRuleTokenStream stream_171=new RewriteRuleTokenStream(adaptor,"token 171");
07537 RewriteRuleTokenStream stream_135=new RewriteRuleTokenStream(adaptor,"token 135");
07538 RewriteRuleTokenStream stream_137=new RewriteRuleTokenStream(adaptor,"token 137");
07539 RewriteRuleTokenStream stream_177=new RewriteRuleTokenStream(adaptor,"token 177");
07540
07541 try {
07542 if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return retval; }
07543
07544 int alt54=6;
07545 switch ( input.LA(1) ) {
07546 case 135:
07547 {
07548 int LA54_1 = input.LA(2);
07549
07550 if ( (LA54_1==170) ) {
07551 alt54=1;
07552 }
07553 else if ( ((LA54_1>=Identifier && LA54_1<=DecimalLiteral)||LA54_1==133||LA54_1==139||(LA54_1>=156 && LA54_1<=166)||LA54_1==171||LA54_1==174||(LA54_1>=178 && LA54_1<=180)||LA54_1==183||(LA54_1>=186 && LA54_1<=197)) ) {
07554 alt54=3;
07555 }
07556 else {
07557 if (state.backtracking>0) {state.failed=true; return retval;}
07558 NoViableAltException nvae =
07559 new NoViableAltException("", 54, 1, input);
07560
07561 throw nvae;
07562 }
07563 }
07564 break;
07565 case 137:
07566 {
07567 int LA54_2 = input.LA(2);
07568
07569 if ( (LA54_2==170) ) {
07570 alt54=2;
07571 }
07572 else if ( ((LA54_2>=Identifier && LA54_2<=DecimalLiteral)||LA54_2==133||LA54_2==139||(LA54_2>=156 && LA54_2<=166)||LA54_2==171||LA54_2==174||(LA54_2>=178 && LA54_2<=180)||LA54_2==183||(LA54_2>=186 && LA54_2<=197)) ) {
07573 alt54=4;
07574 }
07575 else {
07576 if (state.backtracking>0) {state.failed=true; return retval;}
07577 NoViableAltException nvae =
07578 new NoViableAltException("", 54, 2, input);
07579
07580 throw nvae;
07581 }
07582 }
07583 break;
07584 case 177:
07585 {
07586 alt54=5;
07587 }
07588 break;
07589 case 171:
07590 {
07591 alt54=6;
07592 }
07593 break;
07594 default:
07595 if (state.backtracking>0) {state.failed=true; return retval;}
07596 NoViableAltException nvae =
07597 new NoViableAltException("", 54, 0, input);
07598
07599 throw nvae;
07600 }
07601
07602 switch (alt54) {
07603 case 1 :
07604
07605 {
07606 char_literal190=(Token)match(input,135,FOLLOW_135_in_relationalOp2835); if (state.failed) return retval;
07607 if ( state.backtracking==0 ) stream_135.add(char_literal190);
07608
07609 char_literal191=(Token)match(input,170,FOLLOW_170_in_relationalOp2837); if (state.failed) return retval;
07610 if ( state.backtracking==0 ) stream_170.add(char_literal191);
07611
07612
07613
07614
07615
07616
07617
07618
07619
07620
07621 if ( state.backtracking==0 ) {
07622 retval.tree = root_0;
07623 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07624
07625 root_0 = (Node)adaptor.nil();
07626
07627 {
07628 adaptor.addChild(root_0, (Node)adaptor.create(OP_LEQ, "OP_LEQ"));
07629
07630 }
07631
07632 retval.tree = root_0;}
07633 }
07634 break;
07635 case 2 :
07636
07637 {
07638 char_literal192=(Token)match(input,137,FOLLOW_137_in_relationalOp2845); if (state.failed) return retval;
07639 if ( state.backtracking==0 ) stream_137.add(char_literal192);
07640
07641 char_literal193=(Token)match(input,170,FOLLOW_170_in_relationalOp2847); if (state.failed) return retval;
07642 if ( state.backtracking==0 ) stream_170.add(char_literal193);
07643
07644
07645
07646
07647
07648
07649
07650
07651
07652
07653 if ( state.backtracking==0 ) {
07654 retval.tree = root_0;
07655 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07656
07657 root_0 = (Node)adaptor.nil();
07658
07659 {
07660 adaptor.addChild(root_0, (Node)adaptor.create(OP_GEQ, "OP_GEQ"));
07661
07662 }
07663
07664 retval.tree = root_0;}
07665 }
07666 break;
07667 case 3 :
07668
07669 {
07670 char_literal194=(Token)match(input,135,FOLLOW_135_in_relationalOp2855); if (state.failed) return retval;
07671 if ( state.backtracking==0 ) stream_135.add(char_literal194);
07672
07673
07674
07675
07676
07677
07678
07679
07680
07681
07682 if ( state.backtracking==0 ) {
07683 retval.tree = root_0;
07684 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07685
07686 root_0 = (Node)adaptor.nil();
07687
07688 {
07689 adaptor.addChild(root_0, (Node)adaptor.create(OP_LT, "OP_LT"));
07690
07691 }
07692
07693 retval.tree = root_0;}
07694 }
07695 break;
07696 case 4 :
07697
07698 {
07699 char_literal195=(Token)match(input,137,FOLLOW_137_in_relationalOp2863); if (state.failed) return retval;
07700 if ( state.backtracking==0 ) stream_137.add(char_literal195);
07701
07702
07703
07704
07705
07706
07707
07708
07709
07710
07711 if ( state.backtracking==0 ) {
07712 retval.tree = root_0;
07713 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07714
07715 root_0 = (Node)adaptor.nil();
07716
07717 {
07718 adaptor.addChild(root_0, (Node)adaptor.create(OP_GT, "OP_GT"));
07719
07720 }
07721
07722 retval.tree = root_0;}
07723 }
07724 break;
07725 case 5 :
07726
07727 {
07728 root_0 = (Node)adaptor.nil();
07729
07730 pushFollow(FOLLOW_inOp_in_relationalOp2871);
07731 inOp196=inOp();
07732
07733 state._fsp--;
07734 if (state.failed) return retval;
07735 if ( state.backtracking==0 ) adaptor.addChild(root_0, inOp196.getTree());
07736
07737 }
07738 break;
07739 case 6 :
07740
07741 {
07742 char_literal197=(Token)match(input,171,FOLLOW_171_in_relationalOp2875); if (state.failed) return retval;
07743 if ( state.backtracking==0 ) stream_171.add(char_literal197);
07744
07745 string_literal198=(Token)match(input,177,FOLLOW_177_in_relationalOp2877); if (state.failed) return retval;
07746 if ( state.backtracking==0 ) stream_177.add(string_literal198);
07747
07748
07749
07750
07751
07752
07753
07754
07755
07756
07757 if ( state.backtracking==0 ) {
07758 retval.tree = root_0;
07759 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07760
07761 root_0 = (Node)adaptor.nil();
07762
07763 {
07764 adaptor.addChild(root_0, (Node)adaptor.create(OP_NSET_SUBSET, "OP_NSET_SUBSET"));
07765
07766 }
07767
07768 retval.tree = root_0;}
07769 }
07770 break;
07771
07772 }
07773 retval.stop = input.LT(-1);
07774
07775 if ( state.backtracking==0 ) {
07776
07777 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
07778 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
07779 }
07780 }
07781 catch (RecognitionException re) {
07782 reportError(re);
07783 recover(input,re);
07784 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
07785
07786 }
07787 finally {
07788 if ( state.backtracking>0 ) { memoize(input, 46, relationalOp_StartIndex); }
07789 }
07790 return retval;
07791 }
07792
07793
07794 public static class setUnaryExpression_return extends ParserRuleReturnScope {
07795 Node tree;
07796 public Object getTree() { return tree; }
07797 };
07798
07799
07800
07801 public final JFSLParser.setUnaryExpression_return setUnaryExpression() throws RecognitionException {
07802 JFSLParser.setUnaryExpression_return retval = new JFSLParser.setUnaryExpression_return();
07803 retval.start = input.LT(1);
07804 int setUnaryExpression_StartIndex = input.index();
07805 Node root_0 = null;
07806
07807 JFSLParser.setUnaryOp_return setUnaryOp199 = null;
07808
07809 JFSLParser.joinExpression_return joinExpression200 = null;
07810
07811 JFSLParser.shiftExpression_return shiftExpression201 = null;
07812
07813
07814 RewriteRuleSubtreeStream stream_setUnaryOp=new RewriteRuleSubtreeStream(adaptor,"rule setUnaryOp");
07815 RewriteRuleSubtreeStream stream_joinExpression=new RewriteRuleSubtreeStream(adaptor,"rule joinExpression");
07816 try {
07817 if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return retval; }
07818
07819 int alt55=2;
07820 int LA55_0 = input.LA(1);
07821
07822 if ( ((LA55_0>=193 && LA55_0<=197)) ) {
07823 alt55=1;
07824 }
07825 else if ( ((LA55_0>=Identifier && LA55_0<=DecimalLiteral)||LA55_0==133||LA55_0==139||(LA55_0>=156 && LA55_0<=166)||LA55_0==171||LA55_0==174||(LA55_0>=178 && LA55_0<=180)||LA55_0==183||(LA55_0>=186 && LA55_0<=192)) ) {
07826 alt55=2;
07827 }
07828 else {
07829 if (state.backtracking>0) {state.failed=true; return retval;}
07830 NoViableAltException nvae =
07831 new NoViableAltException("", 55, 0, input);
07832
07833 throw nvae;
07834 }
07835 switch (alt55) {
07836 case 1 :
07837
07838 {
07839 pushFollow(FOLLOW_setUnaryOp_in_setUnaryExpression2896);
07840 setUnaryOp199=setUnaryOp();
07841
07842 state._fsp--;
07843 if (state.failed) return retval;
07844 if ( state.backtracking==0 ) stream_setUnaryOp.add(setUnaryOp199.getTree());
07845 pushFollow(FOLLOW_joinExpression_in_setUnaryExpression2898);
07846 joinExpression200=joinExpression();
07847
07848 state._fsp--;
07849 if (state.failed) return retval;
07850 if ( state.backtracking==0 ) stream_joinExpression.add(joinExpression200.getTree());
07851
07852
07853
07854
07855
07856
07857
07858
07859
07860 if ( state.backtracking==0 ) {
07861 retval.tree = root_0;
07862 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07863
07864 root_0 = (Node)adaptor.nil();
07865
07866 {
07867
07868 {
07869 Node root_1 = (Node)adaptor.nil();
07870 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
07871
07872 adaptor.addChild(root_1, stream_setUnaryOp.nextTree());
07873 adaptor.addChild(root_1, stream_joinExpression.nextTree());
07874
07875 adaptor.addChild(root_0, root_1);
07876 }
07877
07878 }
07879
07880 retval.tree = root_0;}
07881 }
07882 break;
07883 case 2 :
07884
07885 {
07886 root_0 = (Node)adaptor.nil();
07887
07888 pushFollow(FOLLOW_shiftExpression_in_setUnaryExpression2914);
07889 shiftExpression201=shiftExpression();
07890
07891 state._fsp--;
07892 if (state.failed) return retval;
07893 if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression201.getTree());
07894
07895 }
07896 break;
07897
07898 }
07899 retval.stop = input.LT(-1);
07900
07901 if ( state.backtracking==0 ) {
07902
07903 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
07904 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
07905 }
07906 }
07907 catch (RecognitionException re) {
07908 reportError(re);
07909 recover(input,re);
07910 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
07911
07912 }
07913 finally {
07914 if ( state.backtracking>0 ) { memoize(input, 47, setUnaryExpression_StartIndex); }
07915 }
07916 return retval;
07917 }
07918
07919
07920 public static class shiftExpression_return extends ParserRuleReturnScope {
07921 Node tree;
07922 public Object getTree() { return tree; }
07923 };
07924
07925
07926
07927 public final JFSLParser.shiftExpression_return shiftExpression() throws RecognitionException {
07928 JFSLParser.shiftExpression_return retval = new JFSLParser.shiftExpression_return();
07929 retval.start = input.LT(1);
07930 int shiftExpression_StartIndex = input.index();
07931 Node root_0 = null;
07932
07933 JFSLParser.shiftOp_return op = null;
07934
07935 JFSLParser.additiveExpression_return a = null;
07936
07937 JFSLParser.additiveExpression_return additiveExpression202 = null;
07938
07939
07940 RewriteRuleSubtreeStream stream_shiftOp=new RewriteRuleSubtreeStream(adaptor,"rule shiftOp");
07941 RewriteRuleSubtreeStream stream_additiveExpression=new RewriteRuleSubtreeStream(adaptor,"rule additiveExpression");
07942 try {
07943 if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return retval; }
07944
07945
07946 {
07947
07948
07949 {
07950 pushFollow(FOLLOW_additiveExpression_in_shiftExpression2932);
07951 additiveExpression202=additiveExpression();
07952
07953 state._fsp--;
07954 if (state.failed) return retval;
07955 if ( state.backtracking==0 ) stream_additiveExpression.add(additiveExpression202.getTree());
07956
07957
07958
07959
07960
07961
07962
07963
07964
07965 if ( state.backtracking==0 ) {
07966 retval.tree = root_0;
07967 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
07968
07969 root_0 = (Node)adaptor.nil();
07970
07971 {
07972 adaptor.addChild(root_0, stream_additiveExpression.nextTree());
07973
07974 }
07975
07976 retval.tree = root_0;}
07977 }
07978
07979
07980 loop56:
07981 do {
07982 int alt56=2;
07983 int LA56_0 = input.LA(1);
07984
07985 if ( (LA56_0==135) ) {
07986 int LA56_1 = input.LA(2);
07987
07988 if ( (LA56_1==135) ) {
07989 alt56=1;
07990 }
07991
07992
07993 }
07994 else if ( (LA56_0==137) ) {
07995 int LA56_2 = input.LA(2);
07996
07997 if ( (LA56_2==137) ) {
07998 alt56=1;
07999 }
08000
08001
08002 }
08003
08004
08005 switch (alt56) {
08006 case 1 :
08007
08008 {
08009 pushFollow(FOLLOW_shiftOp_in_shiftExpression2949);
08010 op=shiftOp();
08011
08012 state._fsp--;
08013 if (state.failed) return retval;
08014 if ( state.backtracking==0 ) stream_shiftOp.add(op.getTree());
08015 pushFollow(FOLLOW_additiveExpression_in_shiftExpression2953);
08016 a=additiveExpression();
08017
08018 state._fsp--;
08019 if (state.failed) return retval;
08020 if ( state.backtracking==0 ) stream_additiveExpression.add(a.getTree());
08021
08022
08023
08024
08025
08026
08027
08028
08029
08030 if ( state.backtracking==0 ) {
08031 retval.tree = root_0;
08032 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08033 RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.tree:null);
08034 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
08035
08036 root_0 = (Node)adaptor.nil();
08037
08038 {
08039
08040 {
08041 Node root_1 = (Node)adaptor.nil();
08042 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
08043
08044 adaptor.addChild(root_1, stream_op.nextTree());
08045 adaptor.addChild(root_1, stream_retval.nextTree());
08046 adaptor.addChild(root_1, stream_a.nextTree());
08047
08048 adaptor.addChild(root_0, root_1);
08049 }
08050
08051 }
08052
08053 retval.tree = root_0;}
08054 }
08055 break;
08056
08057 default :
08058 break loop56;
08059 }
08060 } while (true);
08061
08062
08063 }
08064
08065 retval.stop = input.LT(-1);
08066
08067 if ( state.backtracking==0 ) {
08068
08069 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08070 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08071 }
08072 }
08073 catch (RecognitionException re) {
08074 reportError(re);
08075 recover(input,re);
08076 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08077
08078 }
08079 finally {
08080 if ( state.backtracking>0 ) { memoize(input, 48, shiftExpression_StartIndex); }
08081 }
08082 return retval;
08083 }
08084
08085
08086 public static class shiftOp_return extends ParserRuleReturnScope {
08087 Node tree;
08088 public Object getTree() { return tree; }
08089 };
08090
08091
08092
08093 public final JFSLParser.shiftOp_return shiftOp() throws RecognitionException {
08094 JFSLParser.shiftOp_return retval = new JFSLParser.shiftOp_return();
08095 retval.start = input.LT(1);
08096 int shiftOp_StartIndex = input.index();
08097 Node root_0 = null;
08098
08099 Token char_literal203=null;
08100 Token char_literal204=null;
08101 Token char_literal205=null;
08102 Token char_literal206=null;
08103 Token char_literal207=null;
08104 Token char_literal208=null;
08105 Token char_literal209=null;
08106
08107 Node char_literal203_tree=null;
08108 Node char_literal204_tree=null;
08109 Node char_literal205_tree=null;
08110 Node char_literal206_tree=null;
08111 Node char_literal207_tree=null;
08112 Node char_literal208_tree=null;
08113 Node char_literal209_tree=null;
08114 RewriteRuleTokenStream stream_135=new RewriteRuleTokenStream(adaptor,"token 135");
08115 RewriteRuleTokenStream stream_137=new RewriteRuleTokenStream(adaptor,"token 137");
08116
08117 try {
08118 if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return retval; }
08119
08120 int alt57=3;
08121 int LA57_0 = input.LA(1);
08122
08123 if ( (LA57_0==135) ) {
08124 alt57=1;
08125 }
08126 else if ( (LA57_0==137) ) {
08127 int LA57_2 = input.LA(2);
08128
08129 if ( (LA57_2==137) ) {
08130 int LA57_3 = input.LA(3);
08131
08132 if ( (LA57_3==137) ) {
08133 alt57=2;
08134 }
08135 else if ( ((LA57_3>=Identifier && LA57_3<=DecimalLiteral)||LA57_3==133||LA57_3==139||(LA57_3>=156 && LA57_3<=166)||LA57_3==171||LA57_3==174||(LA57_3>=178 && LA57_3<=180)||LA57_3==183||(LA57_3>=186 && LA57_3<=192)) ) {
08136 alt57=3;
08137 }
08138 else {
08139 if (state.backtracking>0) {state.failed=true; return retval;}
08140 NoViableAltException nvae =
08141 new NoViableAltException("", 57, 3, input);
08142
08143 throw nvae;
08144 }
08145 }
08146 else {
08147 if (state.backtracking>0) {state.failed=true; return retval;}
08148 NoViableAltException nvae =
08149 new NoViableAltException("", 57, 2, input);
08150
08151 throw nvae;
08152 }
08153 }
08154 else {
08155 if (state.backtracking>0) {state.failed=true; return retval;}
08156 NoViableAltException nvae =
08157 new NoViableAltException("", 57, 0, input);
08158
08159 throw nvae;
08160 }
08161 switch (alt57) {
08162 case 1 :
08163
08164 {
08165 char_literal203=(Token)match(input,135,FOLLOW_135_in_shiftOp2990); if (state.failed) return retval;
08166 if ( state.backtracking==0 ) stream_135.add(char_literal203);
08167
08168 char_literal204=(Token)match(input,135,FOLLOW_135_in_shiftOp2992); if (state.failed) return retval;
08169 if ( state.backtracking==0 ) stream_135.add(char_literal204);
08170
08171
08172
08173
08174
08175
08176
08177
08178
08179
08180 if ( state.backtracking==0 ) {
08181 retval.tree = root_0;
08182 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08183
08184 root_0 = (Node)adaptor.nil();
08185
08186 {
08187 adaptor.addChild(root_0, (Node)adaptor.create(OP_SHL, "OP_SHL"));
08188
08189 }
08190
08191 retval.tree = root_0;}
08192 }
08193 break;
08194 case 2 :
08195
08196 {
08197 char_literal205=(Token)match(input,137,FOLLOW_137_in_shiftOp3000); if (state.failed) return retval;
08198 if ( state.backtracking==0 ) stream_137.add(char_literal205);
08199
08200 char_literal206=(Token)match(input,137,FOLLOW_137_in_shiftOp3002); if (state.failed) return retval;
08201 if ( state.backtracking==0 ) stream_137.add(char_literal206);
08202
08203 char_literal207=(Token)match(input,137,FOLLOW_137_in_shiftOp3004); if (state.failed) return retval;
08204 if ( state.backtracking==0 ) stream_137.add(char_literal207);
08205
08206
08207
08208
08209
08210
08211
08212
08213
08214
08215 if ( state.backtracking==0 ) {
08216 retval.tree = root_0;
08217 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08218
08219 root_0 = (Node)adaptor.nil();
08220
08221 {
08222 adaptor.addChild(root_0, (Node)adaptor.create(OP_USHR, "OP_USHR"));
08223
08224 }
08225
08226 retval.tree = root_0;}
08227 }
08228 break;
08229 case 3 :
08230
08231 {
08232 char_literal208=(Token)match(input,137,FOLLOW_137_in_shiftOp3012); if (state.failed) return retval;
08233 if ( state.backtracking==0 ) stream_137.add(char_literal208);
08234
08235 char_literal209=(Token)match(input,137,FOLLOW_137_in_shiftOp3014); if (state.failed) return retval;
08236 if ( state.backtracking==0 ) stream_137.add(char_literal209);
08237
08238
08239
08240
08241
08242
08243
08244
08245
08246
08247 if ( state.backtracking==0 ) {
08248 retval.tree = root_0;
08249 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08250
08251 root_0 = (Node)adaptor.nil();
08252
08253 {
08254 adaptor.addChild(root_0, (Node)adaptor.create(OP_SHR, "OP_SHR"));
08255
08256 }
08257
08258 retval.tree = root_0;}
08259 }
08260 break;
08261
08262 }
08263 retval.stop = input.LT(-1);
08264
08265 if ( state.backtracking==0 ) {
08266
08267 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08268 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08269 }
08270 }
08271 catch (RecognitionException re) {
08272 reportError(re);
08273 recover(input,re);
08274 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08275
08276 }
08277 finally {
08278 if ( state.backtracking>0 ) { memoize(input, 49, shiftOp_StartIndex); }
08279 }
08280 return retval;
08281 }
08282
08283
08284 public static class additiveExpression_return extends ParserRuleReturnScope {
08285 Node tree;
08286 public Object getTree() { return tree; }
08287 };
08288
08289
08290
08291 public final JFSLParser.additiveExpression_return additiveExpression() throws RecognitionException {
08292 JFSLParser.additiveExpression_return retval = new JFSLParser.additiveExpression_return();
08293 retval.start = input.LT(1);
08294 int additiveExpression_StartIndex = input.index();
08295 Node root_0 = null;
08296
08297 JFSLParser.additiveOp_return op = null;
08298
08299 JFSLParser.sizeExpression_return a = null;
08300
08301 JFSLParser.sizeExpression_return sizeExpression210 = null;
08302
08303
08304 RewriteRuleSubtreeStream stream_sizeExpression=new RewriteRuleSubtreeStream(adaptor,"rule sizeExpression");
08305 RewriteRuleSubtreeStream stream_additiveOp=new RewriteRuleSubtreeStream(adaptor,"rule additiveOp");
08306 try {
08307 if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return retval; }
08308
08309
08310 {
08311
08312
08313 {
08314 pushFollow(FOLLOW_sizeExpression_in_additiveExpression3034);
08315 sizeExpression210=sizeExpression();
08316
08317 state._fsp--;
08318 if (state.failed) return retval;
08319 if ( state.backtracking==0 ) stream_sizeExpression.add(sizeExpression210.getTree());
08320
08321
08322
08323
08324
08325
08326
08327
08328
08329 if ( state.backtracking==0 ) {
08330 retval.tree = root_0;
08331 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08332
08333 root_0 = (Node)adaptor.nil();
08334
08335 {
08336 adaptor.addChild(root_0, stream_sizeExpression.nextTree());
08337
08338 }
08339
08340 retval.tree = root_0;}
08341 }
08342
08343
08344 loop58:
08345 do {
08346 int alt58=2;
08347 int LA58_0 = input.LA(1);
08348
08349 if ( ((LA58_0>=178 && LA58_0<=179)) ) {
08350 alt58=1;
08351 }
08352
08353
08354 switch (alt58) {
08355 case 1 :
08356
08357 {
08358 pushFollow(FOLLOW_additiveOp_in_additiveExpression3052);
08359 op=additiveOp();
08360
08361 state._fsp--;
08362 if (state.failed) return retval;
08363 if ( state.backtracking==0 ) stream_additiveOp.add(op.getTree());
08364 pushFollow(FOLLOW_sizeExpression_in_additiveExpression3056);
08365 a=sizeExpression();
08366
08367 state._fsp--;
08368 if (state.failed) return retval;
08369 if ( state.backtracking==0 ) stream_sizeExpression.add(a.getTree());
08370
08371
08372
08373
08374
08375
08376
08377
08378
08379 if ( state.backtracking==0 ) {
08380 retval.tree = root_0;
08381 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08382 RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.tree:null);
08383 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
08384
08385 root_0 = (Node)adaptor.nil();
08386
08387 {
08388
08389 {
08390 Node root_1 = (Node)adaptor.nil();
08391 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
08392
08393 adaptor.addChild(root_1, stream_op.nextTree());
08394 adaptor.addChild(root_1, stream_retval.nextTree());
08395 adaptor.addChild(root_1, stream_a.nextTree());
08396
08397 adaptor.addChild(root_0, root_1);
08398 }
08399
08400 }
08401
08402 retval.tree = root_0;}
08403 }
08404 break;
08405
08406 default :
08407 break loop58;
08408 }
08409 } while (true);
08410
08411
08412 }
08413
08414 retval.stop = input.LT(-1);
08415
08416 if ( state.backtracking==0 ) {
08417
08418 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08419 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08420 }
08421 }
08422 catch (RecognitionException re) {
08423 reportError(re);
08424 recover(input,re);
08425 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08426
08427 }
08428 finally {
08429 if ( state.backtracking>0 ) { memoize(input, 50, additiveExpression_StartIndex); }
08430 }
08431 return retval;
08432 }
08433
08434
08435 public static class additiveOp_return extends ParserRuleReturnScope {
08436 Node tree;
08437 public Object getTree() { return tree; }
08438 };
08439
08440
08441
08442 public final JFSLParser.additiveOp_return additiveOp() throws RecognitionException {
08443 JFSLParser.additiveOp_return retval = new JFSLParser.additiveOp_return();
08444 retval.start = input.LT(1);
08445 int additiveOp_StartIndex = input.index();
08446 Node root_0 = null;
08447
08448 Token char_literal211=null;
08449 Token char_literal212=null;
08450
08451 Node char_literal211_tree=null;
08452 Node char_literal212_tree=null;
08453 RewriteRuleTokenStream stream_179=new RewriteRuleTokenStream(adaptor,"token 179");
08454 RewriteRuleTokenStream stream_178=new RewriteRuleTokenStream(adaptor,"token 178");
08455
08456 try {
08457 if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return retval; }
08458
08459 int alt59=2;
08460 int LA59_0 = input.LA(1);
08461
08462 if ( (LA59_0==178) ) {
08463 alt59=1;
08464 }
08465 else if ( (LA59_0==179) ) {
08466 alt59=2;
08467 }
08468 else {
08469 if (state.backtracking>0) {state.failed=true; return retval;}
08470 NoViableAltException nvae =
08471 new NoViableAltException("", 59, 0, input);
08472
08473 throw nvae;
08474 }
08475 switch (alt59) {
08476 case 1 :
08477
08478 {
08479 char_literal211=(Token)match(input,178,FOLLOW_178_in_additiveOp3097); if (state.failed) return retval;
08480 if ( state.backtracking==0 ) stream_178.add(char_literal211);
08481
08482
08483
08484
08485
08486
08487
08488
08489
08490
08491 if ( state.backtracking==0 ) {
08492 retval.tree = root_0;
08493 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08494
08495 root_0 = (Node)adaptor.nil();
08496
08497 {
08498 adaptor.addChild(root_0, (Node)adaptor.create(OP_PLUS_OR_UNION, "OP_PLUS_OR_UNION"));
08499
08500 }
08501
08502 retval.tree = root_0;}
08503 }
08504 break;
08505 case 2 :
08506
08507 {
08508 char_literal212=(Token)match(input,179,FOLLOW_179_in_additiveOp3110); if (state.failed) return retval;
08509 if ( state.backtracking==0 ) stream_179.add(char_literal212);
08510
08511
08512
08513
08514
08515
08516
08517
08518
08519
08520 if ( state.backtracking==0 ) {
08521 retval.tree = root_0;
08522 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08523
08524 root_0 = (Node)adaptor.nil();
08525
08526 {
08527 adaptor.addChild(root_0, (Node)adaptor.create(OP_MINUS_OR_DIFFERENCE, "OP_MINUS_OR_DIFFERENCE"));
08528
08529 }
08530
08531 retval.tree = root_0;}
08532 }
08533 break;
08534
08535 }
08536 retval.stop = input.LT(-1);
08537
08538 if ( state.backtracking==0 ) {
08539
08540 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08541 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08542 }
08543 }
08544 catch (RecognitionException re) {
08545 reportError(re);
08546 recover(input,re);
08547 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08548
08549 }
08550 finally {
08551 if ( state.backtracking>0 ) { memoize(input, 51, additiveOp_StartIndex); }
08552 }
08553 return retval;
08554 }
08555
08556
08557 public static class sizeExpression_return extends ParserRuleReturnScope {
08558 Node tree;
08559 public Object getTree() { return tree; }
08560 };
08561
08562
08563
08564 public final JFSLParser.sizeExpression_return sizeExpression() throws RecognitionException {
08565 JFSLParser.sizeExpression_return retval = new JFSLParser.sizeExpression_return();
08566 retval.start = input.LT(1);
08567 int sizeExpression_StartIndex = input.index();
08568 Node root_0 = null;
08569
08570 Token char_literal213=null;
08571 JFSLParser.joinExpression_return joinExpression214 = null;
08572
08573 JFSLParser.multiplicativeExpression_return multiplicativeExpression215 = null;
08574
08575
08576 Node char_literal213_tree=null;
08577 RewriteRuleTokenStream stream_180=new RewriteRuleTokenStream(adaptor,"token 180");
08578 RewriteRuleSubtreeStream stream_joinExpression=new RewriteRuleSubtreeStream(adaptor,"rule joinExpression");
08579 try {
08580 if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return retval; }
08581
08582 int alt60=2;
08583 int LA60_0 = input.LA(1);
08584
08585 if ( (LA60_0==180) ) {
08586 alt60=1;
08587 }
08588 else if ( ((LA60_0>=Identifier && LA60_0<=DecimalLiteral)||LA60_0==133||LA60_0==139||(LA60_0>=156 && LA60_0<=166)||LA60_0==171||LA60_0==174||(LA60_0>=178 && LA60_0<=179)||LA60_0==183||(LA60_0>=186 && LA60_0<=192)) ) {
08589 alt60=2;
08590 }
08591 else {
08592 if (state.backtracking>0) {state.failed=true; return retval;}
08593 NoViableAltException nvae =
08594 new NoViableAltException("", 60, 0, input);
08595
08596 throw nvae;
08597 }
08598 switch (alt60) {
08599 case 1 :
08600
08601 {
08602 char_literal213=(Token)match(input,180,FOLLOW_180_in_sizeExpression3130); if (state.failed) return retval;
08603 if ( state.backtracking==0 ) stream_180.add(char_literal213);
08604
08605 pushFollow(FOLLOW_joinExpression_in_sizeExpression3132);
08606 joinExpression214=joinExpression();
08607
08608 state._fsp--;
08609 if (state.failed) return retval;
08610 if ( state.backtracking==0 ) stream_joinExpression.add(joinExpression214.getTree());
08611
08612
08613
08614
08615
08616
08617
08618
08619
08620 if ( state.backtracking==0 ) {
08621 retval.tree = root_0;
08622 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08623
08624 root_0 = (Node)adaptor.nil();
08625
08626 {
08627
08628 {
08629 Node root_1 = (Node)adaptor.nil();
08630 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
08631
08632 adaptor.addChild(root_1, (Node)adaptor.create(OP_SET_NUM, "OP_SET_NUM"));
08633 adaptor.addChild(root_1, stream_joinExpression.nextTree());
08634
08635 adaptor.addChild(root_0, root_1);
08636 }
08637
08638 }
08639
08640 retval.tree = root_0;}
08641 }
08642 break;
08643 case 2 :
08644
08645 {
08646 root_0 = (Node)adaptor.nil();
08647
08648 pushFollow(FOLLOW_multiplicativeExpression_in_sizeExpression3148);
08649 multiplicativeExpression215=multiplicativeExpression();
08650
08651 state._fsp--;
08652 if (state.failed) return retval;
08653 if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicativeExpression215.getTree());
08654
08655 }
08656 break;
08657
08658 }
08659 retval.stop = input.LT(-1);
08660
08661 if ( state.backtracking==0 ) {
08662
08663 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08664 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08665 }
08666 }
08667 catch (RecognitionException re) {
08668 reportError(re);
08669 recover(input,re);
08670 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08671
08672 }
08673 finally {
08674 if ( state.backtracking>0 ) { memoize(input, 52, sizeExpression_StartIndex); }
08675 }
08676 return retval;
08677 }
08678
08679
08680 public static class multiplicativeExpression_return extends ParserRuleReturnScope {
08681 Node tree;
08682 public Object getTree() { return tree; }
08683 };
08684
08685
08686
08687 public final JFSLParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
08688 JFSLParser.multiplicativeExpression_return retval = new JFSLParser.multiplicativeExpression_return();
08689 retval.start = input.LT(1);
08690 int multiplicativeExpression_StartIndex = input.index();
08691 Node root_0 = null;
08692
08693 JFSLParser.multOp_return op = null;
08694
08695 JFSLParser.setAdditiveExpression_return a = null;
08696
08697 JFSLParser.setAdditiveExpression_return setAdditiveExpression216 = null;
08698
08699
08700 RewriteRuleSubtreeStream stream_multOp=new RewriteRuleSubtreeStream(adaptor,"rule multOp");
08701 RewriteRuleSubtreeStream stream_setAdditiveExpression=new RewriteRuleSubtreeStream(adaptor,"rule setAdditiveExpression");
08702 try {
08703 if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return retval; }
08704
08705
08706 {
08707
08708
08709 {
08710 pushFollow(FOLLOW_setAdditiveExpression_in_multiplicativeExpression3166);
08711 setAdditiveExpression216=setAdditiveExpression();
08712
08713 state._fsp--;
08714 if (state.failed) return retval;
08715 if ( state.backtracking==0 ) stream_setAdditiveExpression.add(setAdditiveExpression216.getTree());
08716
08717
08718
08719
08720
08721
08722
08723
08724
08725 if ( state.backtracking==0 ) {
08726 retval.tree = root_0;
08727 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08728
08729 root_0 = (Node)adaptor.nil();
08730
08731 {
08732 adaptor.addChild(root_0, stream_setAdditiveExpression.nextTree());
08733
08734 }
08735
08736 retval.tree = root_0;}
08737 }
08738
08739
08740 loop61:
08741 do {
08742 int alt61=2;
08743 int LA61_0 = input.LA(1);
08744
08745 if ( (LA61_0==155||(LA61_0>=181 && LA61_0<=182)) ) {
08746 alt61=1;
08747 }
08748
08749
08750 switch (alt61) {
08751 case 1 :
08752
08753 {
08754 pushFollow(FOLLOW_multOp_in_multiplicativeExpression3183);
08755 op=multOp();
08756
08757 state._fsp--;
08758 if (state.failed) return retval;
08759 if ( state.backtracking==0 ) stream_multOp.add(op.getTree());
08760 pushFollow(FOLLOW_setAdditiveExpression_in_multiplicativeExpression3187);
08761 a=setAdditiveExpression();
08762
08763 state._fsp--;
08764 if (state.failed) return retval;
08765 if ( state.backtracking==0 ) stream_setAdditiveExpression.add(a.getTree());
08766
08767
08768
08769
08770
08771
08772
08773
08774
08775 if ( state.backtracking==0 ) {
08776 retval.tree = root_0;
08777 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08778 RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.tree:null);
08779 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
08780
08781 root_0 = (Node)adaptor.nil();
08782
08783 {
08784
08785 {
08786 Node root_1 = (Node)adaptor.nil();
08787 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
08788
08789 adaptor.addChild(root_1, stream_op.nextTree());
08790 adaptor.addChild(root_1, stream_retval.nextTree());
08791 adaptor.addChild(root_1, stream_a.nextTree());
08792
08793 adaptor.addChild(root_0, root_1);
08794 }
08795
08796 }
08797
08798 retval.tree = root_0;}
08799 }
08800 break;
08801
08802 default :
08803 break loop61;
08804 }
08805 } while (true);
08806
08807
08808 }
08809
08810 retval.stop = input.LT(-1);
08811
08812 if ( state.backtracking==0 ) {
08813
08814 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08815 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08816 }
08817 }
08818 catch (RecognitionException re) {
08819 reportError(re);
08820 recover(input,re);
08821 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08822
08823 }
08824 finally {
08825 if ( state.backtracking>0 ) { memoize(input, 53, multiplicativeExpression_StartIndex); }
08826 }
08827 return retval;
08828 }
08829
08830
08831 public static class multOp_return extends ParserRuleReturnScope {
08832 Node tree;
08833 public Object getTree() { return tree; }
08834 };
08835
08836
08837
08838 public final JFSLParser.multOp_return multOp() throws RecognitionException {
08839 JFSLParser.multOp_return retval = new JFSLParser.multOp_return();
08840 retval.start = input.LT(1);
08841 int multOp_StartIndex = input.index();
08842 Node root_0 = null;
08843
08844 Token char_literal217=null;
08845 Token char_literal218=null;
08846 Token char_literal219=null;
08847
08848 Node char_literal217_tree=null;
08849 Node char_literal218_tree=null;
08850 Node char_literal219_tree=null;
08851 RewriteRuleTokenStream stream_181=new RewriteRuleTokenStream(adaptor,"token 181");
08852 RewriteRuleTokenStream stream_182=new RewriteRuleTokenStream(adaptor,"token 182");
08853 RewriteRuleTokenStream stream_155=new RewriteRuleTokenStream(adaptor,"token 155");
08854
08855 try {
08856 if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return retval; }
08857
08858 int alt62=3;
08859 switch ( input.LA(1) ) {
08860 case 155:
08861 {
08862 alt62=1;
08863 }
08864 break;
08865 case 181:
08866 {
08867 alt62=2;
08868 }
08869 break;
08870 case 182:
08871 {
08872 alt62=3;
08873 }
08874 break;
08875 default:
08876 if (state.backtracking>0) {state.failed=true; return retval;}
08877 NoViableAltException nvae =
08878 new NoViableAltException("", 62, 0, input);
08879
08880 throw nvae;
08881 }
08882
08883 switch (alt62) {
08884 case 1 :
08885
08886 {
08887 char_literal217=(Token)match(input,155,FOLLOW_155_in_multOp3217); if (state.failed) return retval;
08888 if ( state.backtracking==0 ) stream_155.add(char_literal217);
08889
08890
08891
08892
08893
08894
08895
08896
08897
08898
08899 if ( state.backtracking==0 ) {
08900 retval.tree = root_0;
08901 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08902
08903 root_0 = (Node)adaptor.nil();
08904
08905 {
08906 adaptor.addChild(root_0, (Node)adaptor.create(OP_TIMES, "OP_TIMES"));
08907
08908 }
08909
08910 retval.tree = root_0;}
08911 }
08912 break;
08913 case 2 :
08914
08915 {
08916 char_literal218=(Token)match(input,181,FOLLOW_181_in_multOp3230); if (state.failed) return retval;
08917 if ( state.backtracking==0 ) stream_181.add(char_literal218);
08918
08919
08920
08921
08922
08923
08924
08925
08926
08927
08928 if ( state.backtracking==0 ) {
08929 retval.tree = root_0;
08930 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08931
08932 root_0 = (Node)adaptor.nil();
08933
08934 {
08935 adaptor.addChild(root_0, (Node)adaptor.create(OP_DIVIDE, "OP_DIVIDE"));
08936
08937 }
08938
08939 retval.tree = root_0;}
08940 }
08941 break;
08942 case 3 :
08943
08944 {
08945 char_literal219=(Token)match(input,182,FOLLOW_182_in_multOp3243); if (state.failed) return retval;
08946 if ( state.backtracking==0 ) stream_182.add(char_literal219);
08947
08948
08949
08950
08951
08952
08953
08954
08955
08956
08957 if ( state.backtracking==0 ) {
08958 retval.tree = root_0;
08959 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
08960
08961 root_0 = (Node)adaptor.nil();
08962
08963 {
08964 adaptor.addChild(root_0, (Node)adaptor.create(OP_MOD, "OP_MOD"));
08965
08966 }
08967
08968 retval.tree = root_0;}
08969 }
08970 break;
08971
08972 }
08973 retval.stop = input.LT(-1);
08974
08975 if ( state.backtracking==0 ) {
08976
08977 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
08978 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
08979 }
08980 }
08981 catch (RecognitionException re) {
08982 reportError(re);
08983 recover(input,re);
08984 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
08985
08986 }
08987 finally {
08988 if ( state.backtracking>0 ) { memoize(input, 54, multOp_StartIndex); }
08989 }
08990 return retval;
08991 }
08992
08993
08994 public static class setAdditiveExpression_return extends ParserRuleReturnScope {
08995 Node tree;
08996 public Object getTree() { return tree; }
08997 };
08998
08999
09000
09001 public final JFSLParser.setAdditiveExpression_return setAdditiveExpression() throws RecognitionException {
09002 JFSLParser.setAdditiveExpression_return retval = new JFSLParser.setAdditiveExpression_return();
09003 retval.start = input.LT(1);
09004 int setAdditiveExpression_StartIndex = input.index();
09005 Node root_0 = null;
09006
09007 JFSLParser.setAdditiveOp_return op = null;
09008
09009 JFSLParser.overrideExpression_return a = null;
09010
09011 JFSLParser.overrideExpression_return overrideExpression220 = null;
09012
09013
09014 RewriteRuleSubtreeStream stream_overrideExpression=new RewriteRuleSubtreeStream(adaptor,"rule overrideExpression");
09015 RewriteRuleSubtreeStream stream_setAdditiveOp=new RewriteRuleSubtreeStream(adaptor,"rule setAdditiveOp");
09016 try {
09017 if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return retval; }
09018
09019
09020 {
09021
09022
09023 {
09024 pushFollow(FOLLOW_overrideExpression_in_setAdditiveExpression3266);
09025 overrideExpression220=overrideExpression();
09026
09027 state._fsp--;
09028 if (state.failed) return retval;
09029 if ( state.backtracking==0 ) stream_overrideExpression.add(overrideExpression220.getTree());
09030
09031
09032
09033
09034
09035
09036
09037
09038
09039 if ( state.backtracking==0 ) {
09040 retval.tree = root_0;
09041 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09042
09043 root_0 = (Node)adaptor.nil();
09044
09045 {
09046 adaptor.addChild(root_0, stream_overrideExpression.nextTree());
09047
09048 }
09049
09050 retval.tree = root_0;}
09051 }
09052
09053
09054 loop63:
09055 do {
09056 int alt63=2;
09057 int LA63_0 = input.LA(1);
09058
09059 if ( (LA63_0==183) ) {
09060 alt63=1;
09061 }
09062
09063
09064 switch (alt63) {
09065 case 1 :
09066
09067 {
09068 pushFollow(FOLLOW_setAdditiveOp_in_setAdditiveExpression3286);
09069 op=setAdditiveOp();
09070
09071 state._fsp--;
09072 if (state.failed) return retval;
09073 if ( state.backtracking==0 ) stream_setAdditiveOp.add(op.getTree());
09074 pushFollow(FOLLOW_overrideExpression_in_setAdditiveExpression3290);
09075 a=overrideExpression();
09076
09077 state._fsp--;
09078 if (state.failed) return retval;
09079 if ( state.backtracking==0 ) stream_overrideExpression.add(a.getTree());
09080
09081
09082
09083
09084
09085
09086
09087
09088
09089 if ( state.backtracking==0 ) {
09090 retval.tree = root_0;
09091 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09092 RewriteRuleSubtreeStream stream_op=new RewriteRuleSubtreeStream(adaptor,"rule op",op!=null?op.tree:null);
09093 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
09094
09095 root_0 = (Node)adaptor.nil();
09096
09097 {
09098
09099 {
09100 Node root_1 = (Node)adaptor.nil();
09101 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
09102
09103 adaptor.addChild(root_1, stream_op.nextTree());
09104 adaptor.addChild(root_1, stream_retval.nextTree());
09105 adaptor.addChild(root_1, stream_a.nextTree());
09106
09107 adaptor.addChild(root_0, root_1);
09108 }
09109
09110 }
09111
09112 retval.tree = root_0;}
09113 }
09114 break;
09115
09116 default :
09117 break loop63;
09118 }
09119 } while (true);
09120
09121
09122 }
09123
09124 retval.stop = input.LT(-1);
09125
09126 if ( state.backtracking==0 ) {
09127
09128 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
09129 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
09130 }
09131 }
09132 catch (RecognitionException re) {
09133 reportError(re);
09134 recover(input,re);
09135 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
09136
09137 }
09138 finally {
09139 if ( state.backtracking>0 ) { memoize(input, 55, setAdditiveExpression_StartIndex); }
09140 }
09141 return retval;
09142 }
09143
09144
09145 public static class setAdditiveOp_return extends ParserRuleReturnScope {
09146 Node tree;
09147 public Object getTree() { return tree; }
09148 };
09149
09150
09151
09152 public final JFSLParser.setAdditiveOp_return setAdditiveOp() throws RecognitionException {
09153 JFSLParser.setAdditiveOp_return retval = new JFSLParser.setAdditiveOp_return();
09154 retval.start = input.LT(1);
09155 int setAdditiveOp_StartIndex = input.index();
09156 Node root_0 = null;
09157
09158 Token char_literal221=null;
09159 Token char_literal222=null;
09160 Token char_literal223=null;
09161 Token char_literal224=null;
09162
09163 Node char_literal221_tree=null;
09164 Node char_literal222_tree=null;
09165 Node char_literal223_tree=null;
09166 Node char_literal224_tree=null;
09167 RewriteRuleTokenStream stream_183=new RewriteRuleTokenStream(adaptor,"token 183");
09168 RewriteRuleTokenStream stream_179=new RewriteRuleTokenStream(adaptor,"token 179");
09169 RewriteRuleTokenStream stream_178=new RewriteRuleTokenStream(adaptor,"token 178");
09170
09171 try {
09172 if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return retval; }
09173
09174 int alt64=2;
09175 int LA64_0 = input.LA(1);
09176
09177 if ( (LA64_0==183) ) {
09178 int LA64_1 = input.LA(2);
09179
09180 if ( (LA64_1==178) ) {
09181 alt64=1;
09182 }
09183 else if ( (LA64_1==179) ) {
09184 alt64=2;
09185 }
09186 else {
09187 if (state.backtracking>0) {state.failed=true; return retval;}
09188 NoViableAltException nvae =
09189 new NoViableAltException("", 64, 1, input);
09190
09191 throw nvae;
09192 }
09193 }
09194 else {
09195 if (state.backtracking>0) {state.failed=true; return retval;}
09196 NoViableAltException nvae =
09197 new NoViableAltException("", 64, 0, input);
09198
09199 throw nvae;
09200 }
09201 switch (alt64) {
09202 case 1 :
09203
09204 {
09205 char_literal221=(Token)match(input,183,FOLLOW_183_in_setAdditiveOp3332); if (state.failed) return retval;
09206 if ( state.backtracking==0 ) stream_183.add(char_literal221);
09207
09208 char_literal222=(Token)match(input,178,FOLLOW_178_in_setAdditiveOp3334); if (state.failed) return retval;
09209 if ( state.backtracking==0 ) stream_178.add(char_literal222);
09210
09211
09212
09213
09214
09215
09216
09217
09218
09219
09220 if ( state.backtracking==0 ) {
09221 retval.tree = root_0;
09222 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09223
09224 root_0 = (Node)adaptor.nil();
09225
09226 {
09227 adaptor.addChild(root_0, (Node)adaptor.create(OP_UNION, "OP_UNION"));
09228
09229 }
09230
09231 retval.tree = root_0;}
09232 }
09233 break;
09234 case 2 :
09235
09236 {
09237 char_literal223=(Token)match(input,183,FOLLOW_183_in_setAdditiveOp3345); if (state.failed) return retval;
09238 if ( state.backtracking==0 ) stream_183.add(char_literal223);
09239
09240 char_literal224=(Token)match(input,179,FOLLOW_179_in_setAdditiveOp3347); if (state.failed) return retval;
09241 if ( state.backtracking==0 ) stream_179.add(char_literal224);
09242
09243
09244
09245
09246
09247
09248
09249
09250
09251
09252 if ( state.backtracking==0 ) {
09253 retval.tree = root_0;
09254 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09255
09256 root_0 = (Node)adaptor.nil();
09257
09258 {
09259 adaptor.addChild(root_0, (Node)adaptor.create(OP_DIFFERENCE, "OP_DIFFERENCE"));
09260
09261 }
09262
09263 retval.tree = root_0;}
09264 }
09265 break;
09266
09267 }
09268 retval.stop = input.LT(-1);
09269
09270 if ( state.backtracking==0 ) {
09271
09272 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
09273 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
09274 }
09275 }
09276 catch (RecognitionException re) {
09277 reportError(re);
09278 recover(input,re);
09279 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
09280
09281 }
09282 finally {
09283 if ( state.backtracking>0 ) { memoize(input, 56, setAdditiveOp_StartIndex); }
09284 }
09285 return retval;
09286 }
09287
09288
09289 public static class overrideExpression_return extends ParserRuleReturnScope {
09290 Node tree;
09291 public Object getTree() { return tree; }
09292 };
09293
09294
09295
09296 public final JFSLParser.overrideExpression_return overrideExpression() throws RecognitionException {
09297 JFSLParser.overrideExpression_return retval = new JFSLParser.overrideExpression_return();
09298 retval.start = input.LT(1);
09299 int overrideExpression_StartIndex = input.index();
09300 Node root_0 = null;
09301
09302 Token string_literal226=null;
09303 JFSLParser.intersectionExpression_return a = null;
09304
09305 JFSLParser.intersectionExpression_return intersectionExpression225 = null;
09306
09307
09308 Node string_literal226_tree=null;
09309 RewriteRuleTokenStream stream_184=new RewriteRuleTokenStream(adaptor,"token 184");
09310 RewriteRuleSubtreeStream stream_intersectionExpression=new RewriteRuleSubtreeStream(adaptor,"rule intersectionExpression");
09311 try {
09312 if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return retval; }
09313
09314
09315 {
09316
09317
09318 {
09319 pushFollow(FOLLOW_intersectionExpression_in_overrideExpression3370);
09320 intersectionExpression225=intersectionExpression();
09321
09322 state._fsp--;
09323 if (state.failed) return retval;
09324 if ( state.backtracking==0 ) stream_intersectionExpression.add(intersectionExpression225.getTree());
09325
09326
09327
09328
09329
09330
09331
09332
09333
09334 if ( state.backtracking==0 ) {
09335 retval.tree = root_0;
09336 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09337
09338 root_0 = (Node)adaptor.nil();
09339
09340 {
09341 adaptor.addChild(root_0, stream_intersectionExpression.nextTree());
09342
09343 }
09344
09345 retval.tree = root_0;}
09346 }
09347
09348
09349 loop65:
09350 do {
09351 int alt65=2;
09352 int LA65_0 = input.LA(1);
09353
09354 if ( (LA65_0==184) ) {
09355 alt65=1;
09356 }
09357
09358
09359 switch (alt65) {
09360 case 1 :
09361
09362 {
09363 string_literal226=(Token)match(input,184,FOLLOW_184_in_overrideExpression3385); if (state.failed) return retval;
09364 if ( state.backtracking==0 ) stream_184.add(string_literal226);
09365
09366 pushFollow(FOLLOW_intersectionExpression_in_overrideExpression3389);
09367 a=intersectionExpression();
09368
09369 state._fsp--;
09370 if (state.failed) return retval;
09371 if ( state.backtracking==0 ) stream_intersectionExpression.add(a.getTree());
09372
09373
09374
09375
09376
09377
09378
09379
09380
09381 if ( state.backtracking==0 ) {
09382 retval.tree = root_0;
09383 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09384 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
09385
09386 root_0 = (Node)adaptor.nil();
09387
09388 {
09389
09390 {
09391 Node root_1 = (Node)adaptor.nil();
09392 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
09393
09394 adaptor.addChild(root_1, (Node)adaptor.create(OP_RELATIONAL_OVERRIDE, "OP_RELATIONAL_OVERRIDE"));
09395 adaptor.addChild(root_1, stream_retval.nextTree());
09396 adaptor.addChild(root_1, stream_a.nextTree());
09397
09398 adaptor.addChild(root_0, root_1);
09399 }
09400
09401 }
09402
09403 retval.tree = root_0;}
09404 }
09405 break;
09406
09407 default :
09408 break loop65;
09409 }
09410 } while (true);
09411
09412
09413 }
09414
09415 retval.stop = input.LT(-1);
09416
09417 if ( state.backtracking==0 ) {
09418
09419 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
09420 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
09421 }
09422 }
09423 catch (RecognitionException re) {
09424 reportError(re);
09425 recover(input,re);
09426 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
09427
09428 }
09429 finally {
09430 if ( state.backtracking>0 ) { memoize(input, 57, overrideExpression_StartIndex); }
09431 }
09432 return retval;
09433 }
09434
09435
09436 public static class intersectionExpression_return extends ParserRuleReturnScope {
09437 Node tree;
09438 public Object getTree() { return tree; }
09439 };
09440
09441
09442
09443 public final JFSLParser.intersectionExpression_return intersectionExpression() throws RecognitionException {
09444 JFSLParser.intersectionExpression_return retval = new JFSLParser.intersectionExpression_return();
09445 retval.start = input.LT(1);
09446 int intersectionExpression_StartIndex = input.index();
09447 Node root_0 = null;
09448
09449 Token char_literal228=null;
09450 Token char_literal229=null;
09451 JFSLParser.composeExpression_return a = null;
09452
09453 JFSLParser.composeExpression_return composeExpression227 = null;
09454
09455
09456 Node char_literal228_tree=null;
09457 Node char_literal229_tree=null;
09458 RewriteRuleTokenStream stream_183=new RewriteRuleTokenStream(adaptor,"token 183");
09459 RewriteRuleTokenStream stream_175=new RewriteRuleTokenStream(adaptor,"token 175");
09460 RewriteRuleSubtreeStream stream_composeExpression=new RewriteRuleSubtreeStream(adaptor,"rule composeExpression");
09461 try {
09462 if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return retval; }
09463
09464
09465 {
09466
09467
09468 {
09469 pushFollow(FOLLOW_composeExpression_in_intersectionExpression3433);
09470 composeExpression227=composeExpression();
09471
09472 state._fsp--;
09473 if (state.failed) return retval;
09474 if ( state.backtracking==0 ) stream_composeExpression.add(composeExpression227.getTree());
09475
09476
09477
09478
09479
09480
09481
09482
09483
09484 if ( state.backtracking==0 ) {
09485 retval.tree = root_0;
09486 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09487
09488 root_0 = (Node)adaptor.nil();
09489
09490 {
09491 adaptor.addChild(root_0, stream_composeExpression.nextTree());
09492
09493 }
09494
09495 retval.tree = root_0;}
09496 }
09497
09498
09499 loop66:
09500 do {
09501 int alt66=2;
09502 int LA66_0 = input.LA(1);
09503
09504 if ( (LA66_0==183) ) {
09505 int LA66_2 = input.LA(2);
09506
09507 if ( (LA66_2==175) ) {
09508 alt66=1;
09509 }
09510
09511
09512 }
09513
09514
09515 switch (alt66) {
09516 case 1 :
09517
09518 {
09519 char_literal228=(Token)match(input,183,FOLLOW_183_in_intersectionExpression3448); if (state.failed) return retval;
09520 if ( state.backtracking==0 ) stream_183.add(char_literal228);
09521
09522 char_literal229=(Token)match(input,175,FOLLOW_175_in_intersectionExpression3450); if (state.failed) return retval;
09523 if ( state.backtracking==0 ) stream_175.add(char_literal229);
09524
09525 pushFollow(FOLLOW_composeExpression_in_intersectionExpression3454);
09526 a=composeExpression();
09527
09528 state._fsp--;
09529 if (state.failed) return retval;
09530 if ( state.backtracking==0 ) stream_composeExpression.add(a.getTree());
09531
09532
09533
09534
09535
09536
09537
09538
09539
09540 if ( state.backtracking==0 ) {
09541 retval.tree = root_0;
09542 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09543 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
09544
09545 root_0 = (Node)adaptor.nil();
09546
09547 {
09548
09549 {
09550 Node root_1 = (Node)adaptor.nil();
09551 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
09552
09553 adaptor.addChild(root_1, (Node)adaptor.create(OP_INTERSECTION, "OP_INTERSECTION"));
09554 adaptor.addChild(root_1, stream_retval.nextTree());
09555 adaptor.addChild(root_1, stream_a.nextTree());
09556
09557 adaptor.addChild(root_0, root_1);
09558 }
09559
09560 }
09561
09562 retval.tree = root_0;}
09563 }
09564 break;
09565
09566 default :
09567 break loop66;
09568 }
09569 } while (true);
09570
09571
09572 }
09573
09574 retval.stop = input.LT(-1);
09575
09576 if ( state.backtracking==0 ) {
09577
09578 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
09579 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
09580 }
09581 }
09582 catch (RecognitionException re) {
09583 reportError(re);
09584 recover(input,re);
09585 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
09586
09587 }
09588 finally {
09589 if ( state.backtracking>0 ) { memoize(input, 58, intersectionExpression_StartIndex); }
09590 }
09591 return retval;
09592 }
09593
09594
09595 public static class composeExpression_return extends ParserRuleReturnScope {
09596 Node tree;
09597 public Object getTree() { return tree; }
09598 };
09599
09600
09601
09602 public final JFSLParser.composeExpression_return composeExpression() throws RecognitionException {
09603 JFSLParser.composeExpression_return retval = new JFSLParser.composeExpression_return();
09604 retval.start = input.LT(1);
09605 int composeExpression_StartIndex = input.index();
09606 Node root_0 = null;
09607
09608 Token string_literal231=null;
09609 JFSLParser.unaryExpression_return a = null;
09610
09611 JFSLParser.unaryExpression_return unaryExpression230 = null;
09612
09613
09614 Node string_literal231_tree=null;
09615 RewriteRuleTokenStream stream_185=new RewriteRuleTokenStream(adaptor,"token 185");
09616 RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
09617 try {
09618 if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return retval; }
09619
09620
09621 {
09622
09623
09624 {
09625 pushFollow(FOLLOW_unaryExpression_in_composeExpression3494);
09626 unaryExpression230=unaryExpression();
09627
09628 state._fsp--;
09629 if (state.failed) return retval;
09630 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression230.getTree());
09631
09632
09633
09634
09635
09636
09637
09638
09639
09640 if ( state.backtracking==0 ) {
09641 retval.tree = root_0;
09642 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09643
09644 root_0 = (Node)adaptor.nil();
09645
09646 {
09647 adaptor.addChild(root_0, stream_unaryExpression.nextTree());
09648
09649 }
09650
09651 retval.tree = root_0;}
09652 }
09653
09654
09655 loop67:
09656 do {
09657 int alt67=2;
09658 int LA67_0 = input.LA(1);
09659
09660 if ( (LA67_0==185) ) {
09661 alt67=1;
09662 }
09663
09664
09665 switch (alt67) {
09666 case 1 :
09667
09668 {
09669 string_literal231=(Token)match(input,185,FOLLOW_185_in_composeExpression3509); if (state.failed) return retval;
09670 if ( state.backtracking==0 ) stream_185.add(string_literal231);
09671
09672 pushFollow(FOLLOW_unaryExpression_in_composeExpression3513);
09673 a=unaryExpression();
09674
09675 state._fsp--;
09676 if (state.failed) return retval;
09677 if ( state.backtracking==0 ) stream_unaryExpression.add(a.getTree());
09678
09679
09680
09681
09682
09683
09684
09685
09686
09687 if ( state.backtracking==0 ) {
09688 retval.tree = root_0;
09689 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09690 RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
09691
09692 root_0 = (Node)adaptor.nil();
09693
09694 {
09695
09696 {
09697 Node root_1 = (Node)adaptor.nil();
09698 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BINARY, "BINARY"), root_1);
09699
09700 adaptor.addChild(root_1, (Node)adaptor.create(OP_RELATIONAL_COMPOSE, "OP_RELATIONAL_COMPOSE"));
09701 adaptor.addChild(root_1, stream_retval.nextTree());
09702 adaptor.addChild(root_1, stream_a.nextTree());
09703
09704 adaptor.addChild(root_0, root_1);
09705 }
09706
09707 }
09708
09709 retval.tree = root_0;}
09710 }
09711 break;
09712
09713 default :
09714 break loop67;
09715 }
09716 } while (true);
09717
09718
09719 }
09720
09721 retval.stop = input.LT(-1);
09722
09723 if ( state.backtracking==0 ) {
09724
09725 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
09726 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
09727 }
09728 }
09729 catch (RecognitionException re) {
09730 reportError(re);
09731 recover(input,re);
09732 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
09733
09734 }
09735 finally {
09736 if ( state.backtracking>0 ) { memoize(input, 59, composeExpression_StartIndex); }
09737 }
09738 return retval;
09739 }
09740
09741
09742 public static class unaryExpression_return extends ParserRuleReturnScope {
09743 Node tree;
09744 public Object getTree() { return tree; }
09745 };
09746
09747
09748
09749 public final JFSLParser.unaryExpression_return unaryExpression() throws RecognitionException {
09750 JFSLParser.unaryExpression_return retval = new JFSLParser.unaryExpression_return();
09751 retval.start = input.LT(1);
09752 int unaryExpression_StartIndex = input.index();
09753 Node root_0 = null;
09754
09755 Token char_literal232=null;
09756 Token char_literal234=null;
09757 JFSLParser.unaryExpression_return unaryExpression233 = null;
09758
09759 JFSLParser.unaryExpression_return unaryExpression235 = null;
09760
09761 JFSLParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus236 = null;
09762
09763
09764 Node char_literal232_tree=null;
09765 Node char_literal234_tree=null;
09766 RewriteRuleTokenStream stream_179=new RewriteRuleTokenStream(adaptor,"token 179");
09767 RewriteRuleTokenStream stream_178=new RewriteRuleTokenStream(adaptor,"token 178");
09768 RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
09769 try {
09770 if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return retval; }
09771
09772 int alt68=3;
09773 switch ( input.LA(1) ) {
09774 case 178:
09775 {
09776 alt68=1;
09777 }
09778 break;
09779 case 179:
09780 {
09781 alt68=2;
09782 }
09783 break;
09784 case Identifier:
09785 case FloatingPointLiteral:
09786 case CharacterLiteral:
09787 case StringLiteral:
09788 case HexLiteral:
09789 case OctalLiteral:
09790 case DecimalLiteral:
09791 case 133:
09792 case 139:
09793 case 156:
09794 case 157:
09795 case 158:
09796 case 159:
09797 case 160:
09798 case 161:
09799 case 162:
09800 case 163:
09801 case 164:
09802 case 165:
09803 case 166:
09804 case 171:
09805 case 174:
09806 case 183:
09807 case 186:
09808 case 187:
09809 case 188:
09810 case 189:
09811 case 190:
09812 case 191:
09813 case 192:
09814 {
09815 alt68=3;
09816 }
09817 break;
09818 default:
09819 if (state.backtracking>0) {state.failed=true; return retval;}
09820 NoViableAltException nvae =
09821 new NoViableAltException("", 68, 0, input);
09822
09823 throw nvae;
09824 }
09825
09826 switch (alt68) {
09827 case 1 :
09828
09829 {
09830 char_literal232=(Token)match(input,178,FOLLOW_178_in_unaryExpression3556); if (state.failed) return retval;
09831 if ( state.backtracking==0 ) stream_178.add(char_literal232);
09832
09833 pushFollow(FOLLOW_unaryExpression_in_unaryExpression3558);
09834 unaryExpression233=unaryExpression();
09835
09836 state._fsp--;
09837 if (state.failed) return retval;
09838 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression233.getTree());
09839
09840
09841
09842
09843
09844
09845
09846
09847
09848 if ( state.backtracking==0 ) {
09849 retval.tree = root_0;
09850 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09851
09852 root_0 = (Node)adaptor.nil();
09853
09854 {
09855
09856 {
09857 Node root_1 = (Node)adaptor.nil();
09858 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
09859
09860 adaptor.addChild(root_1, (Node)adaptor.create(OP_PLUS, "OP_PLUS"));
09861 adaptor.addChild(root_1, stream_unaryExpression.nextTree());
09862
09863 adaptor.addChild(root_0, root_1);
09864 }
09865
09866 }
09867
09868 retval.tree = root_0;}
09869 }
09870 break;
09871 case 2 :
09872
09873 {
09874 char_literal234=(Token)match(input,179,FOLLOW_179_in_unaryExpression3574); if (state.failed) return retval;
09875 if ( state.backtracking==0 ) stream_179.add(char_literal234);
09876
09877 pushFollow(FOLLOW_unaryExpression_in_unaryExpression3576);
09878 unaryExpression235=unaryExpression();
09879
09880 state._fsp--;
09881 if (state.failed) return retval;
09882 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression235.getTree());
09883
09884
09885
09886
09887
09888
09889
09890
09891
09892 if ( state.backtracking==0 ) {
09893 retval.tree = root_0;
09894 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
09895
09896 root_0 = (Node)adaptor.nil();
09897
09898 {
09899
09900 {
09901 Node root_1 = (Node)adaptor.nil();
09902 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
09903
09904 adaptor.addChild(root_1, (Node)adaptor.create(OP_MINUS, "OP_MINUS"));
09905 adaptor.addChild(root_1, stream_unaryExpression.nextTree());
09906
09907 adaptor.addChild(root_0, root_1);
09908 }
09909
09910 }
09911
09912 retval.tree = root_0;}
09913 }
09914 break;
09915 case 3 :
09916
09917 {
09918 root_0 = (Node)adaptor.nil();
09919
09920 pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression3592);
09921 unaryExpressionNotPlusMinus236=unaryExpressionNotPlusMinus();
09922
09923 state._fsp--;
09924 if (state.failed) return retval;
09925 if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpressionNotPlusMinus236.getTree());
09926
09927 }
09928 break;
09929
09930 }
09931 retval.stop = input.LT(-1);
09932
09933 if ( state.backtracking==0 ) {
09934
09935 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
09936 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
09937 }
09938 }
09939 catch (RecognitionException re) {
09940 reportError(re);
09941 recover(input,re);
09942 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
09943
09944 }
09945 finally {
09946 if ( state.backtracking>0 ) { memoize(input, 60, unaryExpression_StartIndex); }
09947 }
09948 return retval;
09949 }
09950
09951
09952 public static class unaryExpressionNotPlusMinus_return extends ParserRuleReturnScope {
09953 Node tree;
09954 public Object getTree() { return tree; }
09955 };
09956
09957
09958
09959 public final JFSLParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus() throws RecognitionException {
09960 JFSLParser.unaryExpressionNotPlusMinus_return retval = new JFSLParser.unaryExpressionNotPlusMinus_return();
09961 retval.start = input.LT(1);
09962 int unaryExpressionNotPlusMinus_StartIndex = input.index();
09963 Node root_0 = null;
09964
09965 Token char_literal237=null;
09966 Token char_literal239=null;
09967 JFSLParser.unaryExpression_return unaryExpression238 = null;
09968
09969 JFSLParser.unaryExpression_return unaryExpression240 = null;
09970
09971 JFSLParser.castExpression_return castExpression241 = null;
09972
09973 JFSLParser.joinExpression_return joinExpression242 = null;
09974
09975
09976 Node char_literal237_tree=null;
09977 Node char_literal239_tree=null;
09978 RewriteRuleTokenStream stream_171=new RewriteRuleTokenStream(adaptor,"token 171");
09979 RewriteRuleTokenStream stream_186=new RewriteRuleTokenStream(adaptor,"token 186");
09980 RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
09981 try {
09982 if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return retval; }
09983
09984 int alt69=4;
09985 alt69 = dfa69.predict(input);
09986 switch (alt69) {
09987 case 1 :
09988
09989 {
09990 char_literal237=(Token)match(input,186,FOLLOW_186_in_unaryExpressionNotPlusMinus3605); if (state.failed) return retval;
09991 if ( state.backtracking==0 ) stream_186.add(char_literal237);
09992
09993 pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus3607);
09994 unaryExpression238=unaryExpression();
09995
09996 state._fsp--;
09997 if (state.failed) return retval;
09998 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression238.getTree());
09999
10000
10001
10002
10003
10004
10005
10006
10007
10008 if ( state.backtracking==0 ) {
10009 retval.tree = root_0;
10010 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10011
10012 root_0 = (Node)adaptor.nil();
10013
10014 {
10015
10016 {
10017 Node root_1 = (Node)adaptor.nil();
10018 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
10019
10020 adaptor.addChild(root_1, (Node)adaptor.create(OP_BIT_NOT_OR_TRANSPOSE, "OP_BIT_NOT_OR_TRANSPOSE"));
10021 adaptor.addChild(root_1, stream_unaryExpression.nextTree());
10022
10023 adaptor.addChild(root_0, root_1);
10024 }
10025
10026 }
10027
10028 retval.tree = root_0;}
10029 }
10030 break;
10031 case 2 :
10032
10033 {
10034 char_literal239=(Token)match(input,171,FOLLOW_171_in_unaryExpressionNotPlusMinus3623); if (state.failed) return retval;
10035 if ( state.backtracking==0 ) stream_171.add(char_literal239);
10036
10037 pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus3625);
10038 unaryExpression240=unaryExpression();
10039
10040 state._fsp--;
10041 if (state.failed) return retval;
10042 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression240.getTree());
10043
10044
10045
10046
10047
10048
10049
10050
10051
10052 if ( state.backtracking==0 ) {
10053 retval.tree = root_0;
10054 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10055
10056 root_0 = (Node)adaptor.nil();
10057
10058 {
10059
10060 {
10061 Node root_1 = (Node)adaptor.nil();
10062 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
10063
10064 adaptor.addChild(root_1, (Node)adaptor.create(OP_NOT, "OP_NOT"));
10065 adaptor.addChild(root_1, stream_unaryExpression.nextTree());
10066
10067 adaptor.addChild(root_0, root_1);
10068 }
10069
10070 }
10071
10072 retval.tree = root_0;}
10073 }
10074 break;
10075 case 3 :
10076
10077 {
10078 root_0 = (Node)adaptor.nil();
10079
10080 pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus3645);
10081 castExpression241=castExpression();
10082
10083 state._fsp--;
10084 if (state.failed) return retval;
10085 if ( state.backtracking==0 ) adaptor.addChild(root_0, castExpression241.getTree());
10086
10087 }
10088 break;
10089 case 4 :
10090
10091 {
10092 root_0 = (Node)adaptor.nil();
10093
10094 pushFollow(FOLLOW_joinExpression_in_unaryExpressionNotPlusMinus3651);
10095 joinExpression242=joinExpression();
10096
10097 state._fsp--;
10098 if (state.failed) return retval;
10099 if ( state.backtracking==0 ) adaptor.addChild(root_0, joinExpression242.getTree());
10100
10101 }
10102 break;
10103
10104 }
10105 retval.stop = input.LT(-1);
10106
10107 if ( state.backtracking==0 ) {
10108
10109 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
10110 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
10111 }
10112 }
10113 catch (RecognitionException re) {
10114 reportError(re);
10115 recover(input,re);
10116 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
10117
10118 }
10119 finally {
10120 if ( state.backtracking>0 ) { memoize(input, 61, unaryExpressionNotPlusMinus_StartIndex); }
10121 }
10122 return retval;
10123 }
10124
10125
10126 public static class castExpression_return extends ParserRuleReturnScope {
10127 Node tree;
10128 public Object getTree() { return tree; }
10129 };
10130
10131
10132
10133 public final JFSLParser.castExpression_return castExpression() throws RecognitionException {
10134 JFSLParser.castExpression_return retval = new JFSLParser.castExpression_return();
10135 retval.start = input.LT(1);
10136 int castExpression_StartIndex = input.index();
10137 Node root_0 = null;
10138
10139 Token char_literal243=null;
10140 Token char_literal245=null;
10141 JFSLParser.primitiveType_return primitiveType244 = null;
10142
10143 JFSLParser.unaryExpression_return unaryExpression246 = null;
10144
10145
10146 Node char_literal243_tree=null;
10147 Node char_literal245_tree=null;
10148 RewriteRuleTokenStream stream_139=new RewriteRuleTokenStream(adaptor,"token 139");
10149 RewriteRuleTokenStream stream_140=new RewriteRuleTokenStream(adaptor,"token 140");
10150 RewriteRuleSubtreeStream stream_primitiveType=new RewriteRuleSubtreeStream(adaptor,"rule primitiveType");
10151 RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
10152 try {
10153 if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return retval; }
10154
10155
10156 {
10157 char_literal243=(Token)match(input,139,FOLLOW_139_in_castExpression3671); if (state.failed) return retval;
10158 if ( state.backtracking==0 ) stream_139.add(char_literal243);
10159
10160 pushFollow(FOLLOW_primitiveType_in_castExpression3673);
10161 primitiveType244=primitiveType();
10162
10163 state._fsp--;
10164 if (state.failed) return retval;
10165 if ( state.backtracking==0 ) stream_primitiveType.add(primitiveType244.getTree());
10166 char_literal245=(Token)match(input,140,FOLLOW_140_in_castExpression3675); if (state.failed) return retval;
10167 if ( state.backtracking==0 ) stream_140.add(char_literal245);
10168
10169 pushFollow(FOLLOW_unaryExpression_in_castExpression3677);
10170 unaryExpression246=unaryExpression();
10171
10172 state._fsp--;
10173 if (state.failed) return retval;
10174 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression246.getTree());
10175
10176
10177
10178
10179
10180
10181
10182
10183
10184 if ( state.backtracking==0 ) {
10185 retval.tree = root_0;
10186 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10187
10188 root_0 = (Node)adaptor.nil();
10189
10190 {
10191
10192 {
10193 Node root_1 = (Node)adaptor.nil();
10194 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(CAST, "CAST"), root_1);
10195
10196 adaptor.addChild(root_1, stream_primitiveType.nextTree());
10197 adaptor.addChild(root_1, stream_unaryExpression.nextTree());
10198
10199 adaptor.addChild(root_0, root_1);
10200 }
10201
10202 }
10203
10204 retval.tree = root_0;}
10205 }
10206
10207 retval.stop = input.LT(-1);
10208
10209 if ( state.backtracking==0 ) {
10210
10211 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
10212 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
10213 }
10214 }
10215 catch (RecognitionException re) {
10216 reportError(re);
10217 recover(input,re);
10218 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
10219
10220 }
10221 finally {
10222 if ( state.backtracking>0 ) { memoize(input, 62, castExpression_StartIndex); }
10223 }
10224 return retval;
10225 }
10226
10227
10228 public static class decls_return extends ParserRuleReturnScope {
10229 Node tree;
10230 public Object getTree() { return tree; }
10231 };
10232
10233
10234
10235 public final JFSLParser.decls_return decls() throws RecognitionException {
10236 JFSLParser.decls_return retval = new JFSLParser.decls_return();
10237 retval.start = input.LT(1);
10238 int decls_StartIndex = input.index();
10239 Node root_0 = null;
10240
10241 Token Identifier247=null;
10242 Token char_literal249=null;
10243 Token char_literal252=null;
10244 Token Identifier253=null;
10245 Token char_literal255=null;
10246 JFSLParser.inOp_return inOp248 = null;
10247
10248 JFSLParser.declarationMult_return declarationMult250 = null;
10249
10250 JFSLParser.additiveExpression_return additiveExpression251 = null;
10251
10252 JFSLParser.inOp_return inOp254 = null;
10253
10254 JFSLParser.additiveExpression_return additiveExpression256 = null;
10255
10256
10257 Node Identifier247_tree=null;
10258 Node char_literal249_tree=null;
10259 Node char_literal252_tree=null;
10260 Node Identifier253_tree=null;
10261 Node char_literal255_tree=null;
10262 RewriteRuleTokenStream stream_150=new RewriteRuleTokenStream(adaptor,"token 150");
10263 RewriteRuleTokenStream stream_136=new RewriteRuleTokenStream(adaptor,"token 136");
10264 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
10265 RewriteRuleSubtreeStream stream_inOp=new RewriteRuleSubtreeStream(adaptor,"rule inOp");
10266 RewriteRuleSubtreeStream stream_additiveExpression=new RewriteRuleSubtreeStream(adaptor,"rule additiveExpression");
10267 RewriteRuleSubtreeStream stream_declarationMult=new RewriteRuleSubtreeStream(adaptor,"rule declarationMult");
10268 try {
10269 if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return retval; }
10270
10271
10272 {
10273
10274
10275 {
10276 Identifier247=(Token)match(input,Identifier,FOLLOW_Identifier_in_decls3703); if (state.failed) return retval;
10277 if ( state.backtracking==0 ) stream_Identifier.add(Identifier247);
10278
10279
10280 int alt70=2;
10281 int LA70_0 = input.LA(1);
10282
10283 if ( (LA70_0==177) ) {
10284 alt70=1;
10285 }
10286 else if ( (LA70_0==150) ) {
10287 alt70=2;
10288 }
10289 else {
10290 if (state.backtracking>0) {state.failed=true; return retval;}
10291 NoViableAltException nvae =
10292 new NoViableAltException("", 70, 0, input);
10293
10294 throw nvae;
10295 }
10296 switch (alt70) {
10297 case 1 :
10298
10299 {
10300 pushFollow(FOLLOW_inOp_in_decls3706);
10301 inOp248=inOp();
10302
10303 state._fsp--;
10304 if (state.failed) return retval;
10305 if ( state.backtracking==0 ) stream_inOp.add(inOp248.getTree());
10306
10307 }
10308 break;
10309 case 2 :
10310
10311 {
10312 char_literal249=(Token)match(input,150,FOLLOW_150_in_decls3710); if (state.failed) return retval;
10313 if ( state.backtracking==0 ) stream_150.add(char_literal249);
10314
10315
10316 }
10317 break;
10318
10319 }
10320
10321 pushFollow(FOLLOW_declarationMult_in_decls3713);
10322 declarationMult250=declarationMult();
10323
10324 state._fsp--;
10325 if (state.failed) return retval;
10326 if ( state.backtracking==0 ) stream_declarationMult.add(declarationMult250.getTree());
10327 pushFollow(FOLLOW_additiveExpression_in_decls3715);
10328 additiveExpression251=additiveExpression();
10329
10330 state._fsp--;
10331 if (state.failed) return retval;
10332 if ( state.backtracking==0 ) stream_additiveExpression.add(additiveExpression251.getTree());
10333
10334 }
10335
10336
10337 loop72:
10338 do {
10339 int alt72=2;
10340 int LA72_0 = input.LA(1);
10341
10342 if ( (LA72_0==136) ) {
10343 alt72=1;
10344 }
10345
10346
10347 switch (alt72) {
10348 case 1 :
10349
10350 {
10351 char_literal252=(Token)match(input,136,FOLLOW_136_in_decls3719); if (state.failed) return retval;
10352 if ( state.backtracking==0 ) stream_136.add(char_literal252);
10353
10354
10355
10356 {
10357 Identifier253=(Token)match(input,Identifier,FOLLOW_Identifier_in_decls3722); if (state.failed) return retval;
10358 if ( state.backtracking==0 ) stream_Identifier.add(Identifier253);
10359
10360
10361 int alt71=2;
10362 int LA71_0 = input.LA(1);
10363
10364 if ( (LA71_0==177) ) {
10365 alt71=1;
10366 }
10367 else if ( (LA71_0==150) ) {
10368 alt71=2;
10369 }
10370 else {
10371 if (state.backtracking>0) {state.failed=true; return retval;}
10372 NoViableAltException nvae =
10373 new NoViableAltException("", 71, 0, input);
10374
10375 throw nvae;
10376 }
10377 switch (alt71) {
10378 case 1 :
10379
10380 {
10381 pushFollow(FOLLOW_inOp_in_decls3725);
10382 inOp254=inOp();
10383
10384 state._fsp--;
10385 if (state.failed) return retval;
10386 if ( state.backtracking==0 ) stream_inOp.add(inOp254.getTree());
10387
10388 }
10389 break;
10390 case 2 :
10391
10392 {
10393 char_literal255=(Token)match(input,150,FOLLOW_150_in_decls3729); if (state.failed) return retval;
10394 if ( state.backtracking==0 ) stream_150.add(char_literal255);
10395
10396
10397 }
10398 break;
10399
10400 }
10401
10402 pushFollow(FOLLOW_additiveExpression_in_decls3732);
10403 additiveExpression256=additiveExpression();
10404
10405 state._fsp--;
10406 if (state.failed) return retval;
10407 if ( state.backtracking==0 ) stream_additiveExpression.add(additiveExpression256.getTree());
10408
10409 }
10410
10411
10412 }
10413 break;
10414
10415 default :
10416 break loop72;
10417 }
10418 } while (true);
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429 if ( state.backtracking==0 ) {
10430 retval.tree = root_0;
10431 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10432
10433 root_0 = (Node)adaptor.nil();
10434
10435 {
10436
10437 {
10438 Node root_1 = (Node)adaptor.nil();
10439 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(DECLS, "DECLS"), root_1);
10440
10441 if ( !(stream_Identifier.hasNext()||stream_additiveExpression.hasNext()||stream_declarationMult.hasNext()) ) {
10442 throw new RewriteEarlyExitException();
10443 }
10444 while ( stream_Identifier.hasNext()||stream_additiveExpression.hasNext()||stream_declarationMult.hasNext() ) {
10445 adaptor.addChild(root_1, stream_Identifier.nextNode());
10446 adaptor.addChild(root_1, stream_declarationMult.nextTree());
10447 adaptor.addChild(root_1, stream_additiveExpression.nextTree());
10448
10449 }
10450 stream_Identifier.reset();
10451 stream_additiveExpression.reset();
10452 stream_declarationMult.reset();
10453
10454 adaptor.addChild(root_0, root_1);
10455 }
10456
10457 }
10458
10459 retval.tree = root_0;}
10460 }
10461
10462 retval.stop = input.LT(-1);
10463
10464 if ( state.backtracking==0 ) {
10465
10466 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
10467 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
10468 }
10469 }
10470 catch (RecognitionException re) {
10471 reportError(re);
10472 recover(input,re);
10473 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
10474
10475 }
10476 finally {
10477 if ( state.backtracking>0 ) { memoize(input, 63, decls_StartIndex); }
10478 }
10479 return retval;
10480 }
10481
10482
10483 public static class relationalUnaryExpression_return extends ParserRuleReturnScope {
10484 Node tree;
10485 public Object getTree() { return tree; }
10486 };
10487
10488
10489
10490 public final JFSLParser.relationalUnaryExpression_return relationalUnaryExpression() throws RecognitionException {
10491 JFSLParser.relationalUnaryExpression_return retval = new JFSLParser.relationalUnaryExpression_return();
10492 retval.start = input.LT(1);
10493 int relationalUnaryExpression_StartIndex = input.index();
10494 Node root_0 = null;
10495
10496 Token Identifier260=null;
10497 JFSLParser.specUnaryOp_return specUnaryOp257 = null;
10498
10499 JFSLParser.parExpression_return parExpression258 = null;
10500
10501 JFSLParser.specUnaryOp_return specUnaryOp259 = null;
10502
10503
10504 Node Identifier260_tree=null;
10505 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
10506 RewriteRuleSubtreeStream stream_specUnaryOp=new RewriteRuleSubtreeStream(adaptor,"rule specUnaryOp");
10507 RewriteRuleSubtreeStream stream_parExpression=new RewriteRuleSubtreeStream(adaptor,"rule parExpression");
10508 try {
10509 if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return retval; }
10510
10511 int alt73=2;
10512 switch ( input.LA(1) ) {
10513 case 183:
10514 {
10515 int LA73_1 = input.LA(2);
10516
10517 if ( (LA73_1==174) ) {
10518 int LA73_4 = input.LA(3);
10519
10520 if ( (LA73_4==Identifier) ) {
10521 alt73=2;
10522 }
10523 else if ( (LA73_4==139) ) {
10524 alt73=1;
10525 }
10526 else {
10527 if (state.backtracking>0) {state.failed=true; return retval;}
10528 NoViableAltException nvae =
10529 new NoViableAltException("", 73, 4, input);
10530
10531 throw nvae;
10532 }
10533 }
10534 else if ( (LA73_1==186) ) {
10535 int LA73_5 = input.LA(3);
10536
10537 if ( (LA73_5==Identifier) ) {
10538 alt73=2;
10539 }
10540 else if ( (LA73_5==139) ) {
10541 alt73=1;
10542 }
10543 else {
10544 if (state.backtracking>0) {state.failed=true; return retval;}
10545 NoViableAltException nvae =
10546 new NoViableAltException("", 73, 5, input);
10547
10548 throw nvae;
10549 }
10550 }
10551 else {
10552 if (state.backtracking>0) {state.failed=true; return retval;}
10553 NoViableAltException nvae =
10554 new NoViableAltException("", 73, 1, input);
10555
10556 throw nvae;
10557 }
10558 }
10559 break;
10560 case 174:
10561 {
10562 int LA73_2 = input.LA(2);
10563
10564 if ( (LA73_2==139) ) {
10565 alt73=1;
10566 }
10567 else if ( (LA73_2==Identifier) ) {
10568 alt73=2;
10569 }
10570 else {
10571 if (state.backtracking>0) {state.failed=true; return retval;}
10572 NoViableAltException nvae =
10573 new NoViableAltException("", 73, 2, input);
10574
10575 throw nvae;
10576 }
10577 }
10578 break;
10579 case 186:
10580 {
10581 int LA73_3 = input.LA(2);
10582
10583 if ( (LA73_3==Identifier) ) {
10584 alt73=2;
10585 }
10586 else if ( (LA73_3==139) ) {
10587 alt73=1;
10588 }
10589 else {
10590 if (state.backtracking>0) {state.failed=true; return retval;}
10591 NoViableAltException nvae =
10592 new NoViableAltException("", 73, 3, input);
10593
10594 throw nvae;
10595 }
10596 }
10597 break;
10598 default:
10599 if (state.backtracking>0) {state.failed=true; return retval;}
10600 NoViableAltException nvae =
10601 new NoViableAltException("", 73, 0, input);
10602
10603 throw nvae;
10604 }
10605
10606 switch (alt73) {
10607 case 1 :
10608
10609 {
10610 pushFollow(FOLLOW_specUnaryOp_in_relationalUnaryExpression3773);
10611 specUnaryOp257=specUnaryOp();
10612
10613 state._fsp--;
10614 if (state.failed) return retval;
10615 if ( state.backtracking==0 ) stream_specUnaryOp.add(specUnaryOp257.getTree());
10616 pushFollow(FOLLOW_parExpression_in_relationalUnaryExpression3775);
10617 parExpression258=parExpression();
10618
10619 state._fsp--;
10620 if (state.failed) return retval;
10621 if ( state.backtracking==0 ) stream_parExpression.add(parExpression258.getTree());
10622
10623
10624
10625
10626
10627
10628
10629
10630
10631 if ( state.backtracking==0 ) {
10632 retval.tree = root_0;
10633 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10634
10635 root_0 = (Node)adaptor.nil();
10636
10637 {
10638
10639 {
10640 Node root_1 = (Node)adaptor.nil();
10641 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
10642
10643 adaptor.addChild(root_1, stream_specUnaryOp.nextTree());
10644 adaptor.addChild(root_1, stream_parExpression.nextTree());
10645
10646 adaptor.addChild(root_0, root_1);
10647 }
10648
10649 }
10650
10651 retval.tree = root_0;}
10652 }
10653 break;
10654 case 2 :
10655
10656 {
10657 pushFollow(FOLLOW_specUnaryOp_in_relationalUnaryExpression3791);
10658 specUnaryOp259=specUnaryOp();
10659
10660 state._fsp--;
10661 if (state.failed) return retval;
10662 if ( state.backtracking==0 ) stream_specUnaryOp.add(specUnaryOp259.getTree());
10663 Identifier260=(Token)match(input,Identifier,FOLLOW_Identifier_in_relationalUnaryExpression3793); if (state.failed) return retval;
10664 if ( state.backtracking==0 ) stream_Identifier.add(Identifier260);
10665
10666
10667
10668
10669
10670
10671
10672
10673
10674
10675 if ( state.backtracking==0 ) {
10676 retval.tree = root_0;
10677 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10678
10679 root_0 = (Node)adaptor.nil();
10680
10681 {
10682
10683 {
10684 Node root_1 = (Node)adaptor.nil();
10685 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(UNARY, "UNARY"), root_1);
10686
10687 adaptor.addChild(root_1, stream_specUnaryOp.nextTree());
10688
10689 {
10690 Node root_2 = (Node)adaptor.nil();
10691 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
10692
10693 adaptor.addChild(root_2, stream_Identifier.nextNode());
10694
10695 adaptor.addChild(root_1, root_2);
10696 }
10697
10698 adaptor.addChild(root_0, root_1);
10699 }
10700
10701 }
10702
10703 retval.tree = root_0;}
10704 }
10705 break;
10706
10707 }
10708 retval.stop = input.LT(-1);
10709
10710 if ( state.backtracking==0 ) {
10711
10712 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
10713 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
10714 }
10715 }
10716 catch (RecognitionException re) {
10717 reportError(re);
10718 recover(input,re);
10719 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
10720
10721 }
10722 finally {
10723 if ( state.backtracking>0 ) { memoize(input, 64, relationalUnaryExpression_StartIndex); }
10724 }
10725 return retval;
10726 }
10727
10728
10729 public static class joinExpression_return extends ParserRuleReturnScope {
10730 Node tree;
10731 public Object getTree() { return tree; }
10732 };
10733
10734
10735
10736 public final JFSLParser.joinExpression_return joinExpression() throws RecognitionException {
10737 JFSLParser.joinExpression_return retval = new JFSLParser.joinExpression_return();
10738 retval.start = input.LT(1);
10739 int joinExpression_StartIndex = input.index();
10740 Node root_0 = null;
10741
10742 JFSLParser.primary_return primary261 = null;
10743
10744 JFSLParser.selector_return selector262 = null;
10745
10746
10747 RewriteRuleSubtreeStream stream_selector=new RewriteRuleSubtreeStream(adaptor,"rule selector");
10748 RewriteRuleSubtreeStream stream_primary=new RewriteRuleSubtreeStream(adaptor,"rule primary");
10749 try {
10750 if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return retval; }
10751
10752
10753 {
10754 pushFollow(FOLLOW_primary_in_joinExpression3826);
10755 primary261=primary();
10756
10757 state._fsp--;
10758 if (state.failed) return retval;
10759 if ( state.backtracking==0 ) stream_primary.add(primary261.getTree());
10760
10761 loop74:
10762 do {
10763 int alt74=2;
10764 int LA74_0 = input.LA(1);
10765
10766 if ( (LA74_0==129||LA74_0==167) ) {
10767 alt74=1;
10768 }
10769
10770
10771 switch (alt74) {
10772 case 1 :
10773
10774 {
10775 pushFollow(FOLLOW_selector_in_joinExpression3828);
10776 selector262=selector();
10777
10778 state._fsp--;
10779 if (state.failed) return retval;
10780 if ( state.backtracking==0 ) stream_selector.add(selector262.getTree());
10781
10782 }
10783 break;
10784
10785 default :
10786 break loop74;
10787 }
10788 } while (true);
10789
10790
10791
10792
10793
10794
10795
10796
10797
10798
10799 if ( state.backtracking==0 ) {
10800 retval.tree = root_0;
10801 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
10802
10803 root_0 = (Node)adaptor.nil();
10804
10805 {
10806
10807 {
10808 Node root_1 = (Node)adaptor.nil();
10809 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(CHAIN, "CHAIN"), root_1);
10810
10811 adaptor.addChild(root_1, stream_primary.nextTree());
10812
10813 while ( stream_selector.hasNext() ) {
10814 adaptor.addChild(root_1, stream_selector.nextTree());
10815
10816 }
10817 stream_selector.reset();
10818
10819 adaptor.addChild(root_0, root_1);
10820 }
10821
10822 }
10823
10824 retval.tree = root_0;}
10825 }
10826
10827 retval.stop = input.LT(-1);
10828
10829 if ( state.backtracking==0 ) {
10830
10831 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
10832 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
10833 }
10834 }
10835 catch (RecognitionException re) {
10836 reportError(re);
10837 recover(input,re);
10838 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
10839
10840 }
10841 finally {
10842 if ( state.backtracking>0 ) { memoize(input, 65, joinExpression_StartIndex); }
10843 }
10844 return retval;
10845 }
10846
10847
10848 public static class common_return extends ParserRuleReturnScope {
10849 Node tree;
10850 public Object getTree() { return tree; }
10851 };
10852
10853
10854
10855 public final JFSLParser.common_return common() throws RecognitionException {
10856 JFSLParser.common_return retval = new JFSLParser.common_return();
10857 retval.start = input.LT(1);
10858 int common_StartIndex = input.index();
10859 Node root_0 = null;
10860
10861 Token string_literal264=null;
10862 Token string_literal265=null;
10863 Token string_literal266=null;
10864 Token string_literal267=null;
10865 Token string_literal268=null;
10866 Token char_literal269=null;
10867 Token char_literal271=null;
10868 Token string_literal272=null;
10869 Token char_literal273=null;
10870 Token char_literal275=null;
10871 Token char_literal277=null;
10872 Token char_literal279=null;
10873 Token char_literal281=null;
10874 JFSLParser.parExpression_return parExpression263 = null;
10875
10876 JFSLParser.expression_return expression270 = null;
10877
10878 JFSLParser.integerLiteral_return integerLiteral274 = null;
10879
10880 JFSLParser.relationalUnaryExpression_return relationalUnaryExpression276 = null;
10881
10882 JFSLParser.decls_return decls278 = null;
10883
10884 JFSLParser.expression_return expression280 = null;
10885
10886
10887 Node string_literal264_tree=null;
10888 Node string_literal265_tree=null;
10889 Node string_literal266_tree=null;
10890 Node string_literal267_tree=null;
10891 Node string_literal268_tree=null;
10892 Node char_literal269_tree=null;
10893 Node char_literal271_tree=null;
10894 Node string_literal272_tree=null;
10895 Node char_literal273_tree=null;
10896 Node char_literal275_tree=null;
10897 Node char_literal277_tree=null;
10898 Node char_literal279_tree=null;
10899 Node char_literal281_tree=null;
10900 RewriteRuleTokenStream stream_134=new RewriteRuleTokenStream(adaptor,"token 134");
10901 RewriteRuleTokenStream stream_152=new RewriteRuleTokenStream(adaptor,"token 152");
10902 RewriteRuleTokenStream stream_133=new RewriteRuleTokenStream(adaptor,"token 133");
10903 RewriteRuleTokenStream stream_139=new RewriteRuleTokenStream(adaptor,"token 139");
10904 RewriteRuleTokenStream stream_188=new RewriteRuleTokenStream(adaptor,"token 188");
10905 RewriteRuleTokenStream stream_187=new RewriteRuleTokenStream(adaptor,"token 187");
10906 RewriteRuleTokenStream stream_189=new RewriteRuleTokenStream(adaptor,"token 189");
10907 RewriteRuleTokenStream stream_140=new RewriteRuleTokenStream(adaptor,"token 140");
10908 RewriteRuleTokenStream stream_191=new RewriteRuleTokenStream(adaptor,"token 191");
10909 RewriteRuleTokenStream stream_190=new RewriteRuleTokenStream(adaptor,"token 190");
10910 RewriteRuleTokenStream stream_192=new RewriteRuleTokenStream(adaptor,"token 192");
10911 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
10912 RewriteRuleSubtreeStream stream_decls=new RewriteRuleSubtreeStream(adaptor,"rule decls");
10913 RewriteRuleSubtreeStream stream_integerLiteral=new RewriteRuleSubtreeStream(adaptor,"rule integerLiteral");
10914 try {
10915 if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return retval; }
10916
10917 int alt75=9;
10918 switch ( input.LA(1) ) {
10919 case 139:
10920 {
10921 alt75=1;
10922 }
10923 break;
10924 case 187:
10925 {
10926 alt75=2;
10927 }
10928 break;
10929 case 188:
10930 {
10931 alt75=3;
10932 }
10933 break;
10934 case 189:
10935 {
10936 alt75=4;
10937 }
10938 break;
10939 case 190:
10940 {
10941 alt75=5;
10942 }
10943 break;
10944 case 191:
10945 {
10946 alt75=6;
10947 }
10948 break;
10949 case 192:
10950 {
10951 alt75=7;
10952 }
10953 break;
10954 case 174:
10955 case 183:
10956 case 186:
10957 {
10958 alt75=8;
10959 }
10960 break;
10961 case 133:
10962 {
10963 alt75=9;
10964 }
10965 break;
10966 default:
10967 if (state.backtracking>0) {state.failed=true; return retval;}
10968 NoViableAltException nvae =
10969 new NoViableAltException("", 75, 0, input);
10970
10971 throw nvae;
10972 }
10973
10974 switch (alt75) {
10975 case 1 :
10976
10977 {
10978 root_0 = (Node)adaptor.nil();
10979
10980 pushFollow(FOLLOW_parExpression_in_common3858);
10981 parExpression263=parExpression();
10982
10983 state._fsp--;
10984 if (state.failed) return retval;
10985 if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression263.getTree());
10986
10987 }
10988 break;
10989 case 2 :
10990
10991 {
10992 string_literal264=(Token)match(input,187,FOLLOW_187_in_common3864); if (state.failed) return retval;
10993 if ( state.backtracking==0 ) stream_187.add(string_literal264);
10994
10995
10996
10997
10998
10999
11000
11001
11002
11003
11004 if ( state.backtracking==0 ) {
11005 retval.tree = root_0;
11006 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11007
11008 root_0 = (Node)adaptor.nil();
11009
11010 {
11011 adaptor.addChild(root_0, (Node)adaptor.create(RETURN_VAR, "RETURN_VAR"));
11012
11013 }
11014
11015 retval.tree = root_0;}
11016 }
11017 break;
11018 case 3 :
11019
11020 {
11021 string_literal265=(Token)match(input,188,FOLLOW_188_in_common3874); if (state.failed) return retval;
11022 if ( state.backtracking==0 ) stream_188.add(string_literal265);
11023
11024
11025
11026
11027
11028
11029
11030
11031
11032
11033 if ( state.backtracking==0 ) {
11034 retval.tree = root_0;
11035 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11036
11037 root_0 = (Node)adaptor.nil();
11038
11039 {
11040 adaptor.addChild(root_0, (Node)adaptor.create(THROW_VAR, "THROW_VAR"));
11041
11042 }
11043
11044 retval.tree = root_0;}
11045 }
11046 break;
11047 case 4 :
11048
11049 {
11050 string_literal266=(Token)match(input,189,FOLLOW_189_in_common3884); if (state.failed) return retval;
11051 if ( state.backtracking==0 ) stream_189.add(string_literal266);
11052
11053
11054
11055
11056
11057
11058
11059
11060
11061
11062 if ( state.backtracking==0 ) {
11063 retval.tree = root_0;
11064 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11065
11066 root_0 = (Node)adaptor.nil();
11067
11068 {
11069 adaptor.addChild(root_0, (Node)adaptor.create(THIS_VAR, "THIS_VAR"));
11070
11071 }
11072
11073 retval.tree = root_0;}
11074 }
11075 break;
11076 case 5 :
11077
11078 {
11079 string_literal267=(Token)match(input,190,FOLLOW_190_in_common3895); if (state.failed) return retval;
11080 if ( state.backtracking==0 ) stream_190.add(string_literal267);
11081
11082
11083
11084
11085
11086
11087
11088
11089
11090
11091 if ( state.backtracking==0 ) {
11092 retval.tree = root_0;
11093 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11094
11095 root_0 = (Node)adaptor.nil();
11096
11097 {
11098 adaptor.addChild(root_0, (Node)adaptor.create(SUPER_VAR, "SUPER_VAR"));
11099
11100 }
11101
11102 retval.tree = root_0;}
11103 }
11104 break;
11105 case 6 :
11106
11107 {
11108 string_literal268=(Token)match(input,191,FOLLOW_191_in_common3905); if (state.failed) return retval;
11109 if ( state.backtracking==0 ) stream_191.add(string_literal268);
11110
11111 char_literal269=(Token)match(input,139,FOLLOW_139_in_common3907); if (state.failed) return retval;
11112 if ( state.backtracking==0 ) stream_139.add(char_literal269);
11113
11114 pushFollow(FOLLOW_expression_in_common3909);
11115 expression270=expression();
11116
11117 state._fsp--;
11118 if (state.failed) return retval;
11119 if ( state.backtracking==0 ) stream_expression.add(expression270.getTree());
11120 char_literal271=(Token)match(input,140,FOLLOW_140_in_common3911); if (state.failed) return retval;
11121 if ( state.backtracking==0 ) stream_140.add(char_literal271);
11122
11123
11124
11125
11126
11127
11128
11129
11130
11131
11132 if ( state.backtracking==0 ) {
11133 retval.tree = root_0;
11134 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11135
11136 root_0 = (Node)adaptor.nil();
11137
11138 {
11139
11140 {
11141 Node root_1 = (Node)adaptor.nil();
11142 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(OLD, "OLD"), root_1);
11143
11144 adaptor.addChild(root_1, stream_expression.nextTree());
11145
11146 adaptor.addChild(root_0, root_1);
11147 }
11148
11149 }
11150
11151 retval.tree = root_0;}
11152 }
11153 break;
11154 case 7 :
11155
11156 {
11157 string_literal272=(Token)match(input,192,FOLLOW_192_in_common3925); if (state.failed) return retval;
11158 if ( state.backtracking==0 ) stream_192.add(string_literal272);
11159
11160 char_literal273=(Token)match(input,139,FOLLOW_139_in_common3927); if (state.failed) return retval;
11161 if ( state.backtracking==0 ) stream_139.add(char_literal273);
11162
11163 pushFollow(FOLLOW_integerLiteral_in_common3929);
11164 integerLiteral274=integerLiteral();
11165
11166 state._fsp--;
11167 if (state.failed) return retval;
11168 if ( state.backtracking==0 ) stream_integerLiteral.add(integerLiteral274.getTree());
11169 char_literal275=(Token)match(input,140,FOLLOW_140_in_common3931); if (state.failed) return retval;
11170 if ( state.backtracking==0 ) stream_140.add(char_literal275);
11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
11181 if ( state.backtracking==0 ) {
11182 retval.tree = root_0;
11183 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11184
11185 root_0 = (Node)adaptor.nil();
11186
11187 {
11188
11189 {
11190 Node root_1 = (Node)adaptor.nil();
11191 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(ARGUMENT, "ARGUMENT"), root_1);
11192
11193 adaptor.addChild(root_1, stream_integerLiteral.nextTree());
11194
11195 adaptor.addChild(root_0, root_1);
11196 }
11197
11198 }
11199
11200 retval.tree = root_0;}
11201 }
11202 break;
11203 case 8 :
11204
11205 {
11206 root_0 = (Node)adaptor.nil();
11207
11208 pushFollow(FOLLOW_relationalUnaryExpression_in_common3945);
11209 relationalUnaryExpression276=relationalUnaryExpression();
11210
11211 state._fsp--;
11212 if (state.failed) return retval;
11213 if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalUnaryExpression276.getTree());
11214
11215 }
11216 break;
11217 case 9 :
11218
11219 {
11220 char_literal277=(Token)match(input,133,FOLLOW_133_in_common3951); if (state.failed) return retval;
11221 if ( state.backtracking==0 ) stream_133.add(char_literal277);
11222
11223 pushFollow(FOLLOW_decls_in_common3953);
11224 decls278=decls();
11225
11226 state._fsp--;
11227 if (state.failed) return retval;
11228 if ( state.backtracking==0 ) stream_decls.add(decls278.getTree());
11229 char_literal279=(Token)match(input,152,FOLLOW_152_in_common3955); if (state.failed) return retval;
11230 if ( state.backtracking==0 ) stream_152.add(char_literal279);
11231
11232 pushFollow(FOLLOW_expression_in_common3957);
11233 expression280=expression();
11234
11235 state._fsp--;
11236 if (state.failed) return retval;
11237 if ( state.backtracking==0 ) stream_expression.add(expression280.getTree());
11238 char_literal281=(Token)match(input,134,FOLLOW_134_in_common3959); if (state.failed) return retval;
11239 if ( state.backtracking==0 ) stream_134.add(char_literal281);
11240
11241
11242
11243
11244
11245
11246
11247
11248
11249
11250 if ( state.backtracking==0 ) {
11251 retval.tree = root_0;
11252 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11253
11254 root_0 = (Node)adaptor.nil();
11255
11256 {
11257
11258 {
11259 Node root_1 = (Node)adaptor.nil();
11260 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(QUANTIFY, "QUANTIFY"), root_1);
11261
11262 adaptor.addChild(root_1, (Node)adaptor.create(OP_SET_COMPREHENSION, "OP_SET_COMPREHENSION"));
11263 adaptor.addChild(root_1, stream_decls.nextTree());
11264 adaptor.addChild(root_1, stream_expression.nextTree());
11265
11266 adaptor.addChild(root_0, root_1);
11267 }
11268
11269 }
11270
11271 retval.tree = root_0;}
11272 }
11273 break;
11274
11275 }
11276 retval.stop = input.LT(-1);
11277
11278 if ( state.backtracking==0 ) {
11279
11280 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
11281 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
11282 }
11283 }
11284 catch (RecognitionException re) {
11285 reportError(re);
11286 recover(input,re);
11287 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
11288
11289 }
11290 finally {
11291 if ( state.backtracking>0 ) { memoize(input, 66, common_StartIndex); }
11292 }
11293 return retval;
11294 }
11295
11296
11297 public static class primary_return extends ParserRuleReturnScope {
11298 Node tree;
11299 public Object getTree() { return tree; }
11300 };
11301
11302
11303
11304 public final JFSLParser.primary_return primary() throws RecognitionException {
11305 JFSLParser.primary_return retval = new JFSLParser.primary_return();
11306 retval.start = input.LT(1);
11307 int primary_StartIndex = input.index();
11308 Node root_0 = null;
11309
11310 Token Identifier285=null;
11311 Token char_literal286=null;
11312 Token Identifier287=null;
11313 Token char_literal290=null;
11314 Token Identifier291=null;
11315 Token Identifier292=null;
11316 JFSLParser.common_return common282 = null;
11317
11318 JFSLParser.literal_return literal283 = null;
11319
11320 JFSLParser.typeDisambiguous_return typeDisambiguous284 = null;
11321
11322 JFSLParser.typeParameters2_return typeParameters2288 = null;
11323
11324 JFSLParser.typeName_return typeName289 = null;
11325
11326 JFSLParser.arguments_return arguments293 = null;
11327
11328
11329 Node Identifier285_tree=null;
11330 Node char_literal286_tree=null;
11331 Node Identifier287_tree=null;
11332 Node char_literal290_tree=null;
11333 Node Identifier291_tree=null;
11334 Node Identifier292_tree=null;
11335 RewriteRuleTokenStream stream_183=new RewriteRuleTokenStream(adaptor,"token 183");
11336 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
11337 RewriteRuleTokenStream stream_129=new RewriteRuleTokenStream(adaptor,"token 129");
11338 RewriteRuleSubtreeStream stream_typeName=new RewriteRuleSubtreeStream(adaptor,"rule typeName");
11339 RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
11340 RewriteRuleSubtreeStream stream_typeParameters2=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters2");
11341 try {
11342 if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return retval; }
11343
11344 int alt78=6;
11345 alt78 = dfa78.predict(input);
11346 switch (alt78) {
11347 case 1 :
11348
11349 {
11350 root_0 = (Node)adaptor.nil();
11351
11352 pushFollow(FOLLOW_common_in_primary3984);
11353 common282=common();
11354
11355 state._fsp--;
11356 if (state.failed) return retval;
11357 if ( state.backtracking==0 ) adaptor.addChild(root_0, common282.getTree());
11358
11359 }
11360 break;
11361 case 2 :
11362
11363 {
11364 root_0 = (Node)adaptor.nil();
11365
11366 pushFollow(FOLLOW_literal_in_primary3990);
11367 literal283=literal();
11368
11369 state._fsp--;
11370 if (state.failed) return retval;
11371 if ( state.backtracking==0 ) adaptor.addChild(root_0, literal283.getTree());
11372
11373 }
11374 break;
11375 case 3 :
11376
11377 {
11378 root_0 = (Node)adaptor.nil();
11379
11380 pushFollow(FOLLOW_typeDisambiguous_in_primary3996);
11381 typeDisambiguous284=typeDisambiguous();
11382
11383 state._fsp--;
11384 if (state.failed) return retval;
11385 if ( state.backtracking==0 ) adaptor.addChild(root_0, typeDisambiguous284.getTree());
11386
11387 }
11388 break;
11389 case 4 :
11390
11391 {
11392 Identifier285=(Token)match(input,Identifier,FOLLOW_Identifier_in_primary4002); if (state.failed) return retval;
11393 if ( state.backtracking==0 ) stream_Identifier.add(Identifier285);
11394
11395
11396 loop76:
11397 do {
11398 int alt76=2;
11399 int LA76_0 = input.LA(1);
11400
11401 if ( (LA76_0==129) ) {
11402 int LA76_2 = input.LA(2);
11403
11404 if ( (LA76_2==Identifier) ) {
11405 int LA76_3 = input.LA(3);
11406
11407 if ( (synpred118_JFSL()) ) {
11408 alt76=1;
11409 }
11410
11411
11412 }
11413
11414
11415 }
11416
11417
11418 switch (alt76) {
11419 case 1 :
11420
11421 {
11422 char_literal286=(Token)match(input,129,FOLLOW_129_in_primary4005); if (state.failed) return retval;
11423 if ( state.backtracking==0 ) stream_129.add(char_literal286);
11424
11425 Identifier287=(Token)match(input,Identifier,FOLLOW_Identifier_in_primary4007); if (state.failed) return retval;
11426 if ( state.backtracking==0 ) stream_Identifier.add(Identifier287);
11427
11428
11429 }
11430 break;
11431
11432 default :
11433 break loop76;
11434 }
11435 } while (true);
11436
11437
11438 int alt77=2;
11439 alt77 = dfa77.predict(input);
11440 switch (alt77) {
11441 case 1 :
11442
11443 {
11444 pushFollow(FOLLOW_typeParameters2_in_primary4011);
11445 typeParameters2288=typeParameters2();
11446
11447 state._fsp--;
11448 if (state.failed) return retval;
11449 if ( state.backtracking==0 ) stream_typeParameters2.add(typeParameters2288.getTree());
11450
11451 }
11452 break;
11453
11454 }
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465 if ( state.backtracking==0 ) {
11466 retval.tree = root_0;
11467 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11468
11469 root_0 = (Node)adaptor.nil();
11470
11471 {
11472
11473 {
11474 Node root_1 = (Node)adaptor.nil();
11475 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(AMBIGUOUS, "AMBIGUOUS"), root_1);
11476
11477 if ( !(stream_Identifier.hasNext()) ) {
11478 throw new RewriteEarlyExitException();
11479 }
11480 while ( stream_Identifier.hasNext() ) {
11481
11482 {
11483 Node root_2 = (Node)adaptor.nil();
11484 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
11485
11486 adaptor.addChild(root_2, stream_Identifier.nextNode());
11487
11488 adaptor.addChild(root_1, root_2);
11489 }
11490
11491 }
11492 stream_Identifier.reset();
11493
11494 if ( stream_typeParameters2.hasNext() ) {
11495
11496 {
11497 Node root_2 = (Node)adaptor.nil();
11498 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(TYPE_PARAMETERS, "TYPE_PARAMETERS"), root_2);
11499
11500 adaptor.addChild(root_2, stream_typeParameters2.nextTree());
11501
11502 adaptor.addChild(root_1, root_2);
11503 }
11504
11505 }
11506 stream_typeParameters2.reset();
11507
11508 adaptor.addChild(root_0, root_1);
11509 }
11510
11511 }
11512
11513 retval.tree = root_0;}
11514 }
11515 break;
11516 case 5 :
11517
11518 {
11519 pushFollow(FOLLOW_typeName_in_primary4038);
11520 typeName289=typeName();
11521
11522 state._fsp--;
11523 if (state.failed) return retval;
11524 if ( state.backtracking==0 ) stream_typeName.add(typeName289.getTree());
11525 char_literal290=(Token)match(input,183,FOLLOW_183_in_primary4040); if (state.failed) return retval;
11526 if ( state.backtracking==0 ) stream_183.add(char_literal290);
11527
11528 Identifier291=(Token)match(input,Identifier,FOLLOW_Identifier_in_primary4042); if (state.failed) return retval;
11529 if ( state.backtracking==0 ) stream_Identifier.add(Identifier291);
11530
11531
11532
11533
11534
11535
11536
11537
11538
11539
11540 if ( state.backtracking==0 ) {
11541 retval.tree = root_0;
11542 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11543
11544 root_0 = (Node)adaptor.nil();
11545
11546 {
11547
11548 {
11549 Node root_1 = (Node)adaptor.nil();
11550 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(FIELD, "FIELD"), root_1);
11551
11552 adaptor.addChild(root_1, stream_typeName.nextTree());
11553
11554 {
11555 Node root_2 = (Node)adaptor.nil();
11556 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
11557
11558 adaptor.addChild(root_2, stream_Identifier.nextNode());
11559
11560 adaptor.addChild(root_1, root_2);
11561 }
11562
11563 adaptor.addChild(root_0, root_1);
11564 }
11565
11566 }
11567
11568 retval.tree = root_0;}
11569 }
11570 break;
11571 case 6 :
11572
11573 {
11574 Identifier292=(Token)match(input,Identifier,FOLLOW_Identifier_in_primary4062); if (state.failed) return retval;
11575 if ( state.backtracking==0 ) stream_Identifier.add(Identifier292);
11576
11577 pushFollow(FOLLOW_arguments_in_primary4064);
11578 arguments293=arguments();
11579
11580 state._fsp--;
11581 if (state.failed) return retval;
11582 if ( state.backtracking==0 ) stream_arguments.add(arguments293.getTree());
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592 if ( state.backtracking==0 ) {
11593 retval.tree = root_0;
11594 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11595
11596 root_0 = (Node)adaptor.nil();
11597
11598 {
11599
11600 {
11601 Node root_1 = (Node)adaptor.nil();
11602 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(CALL, "CALL"), root_1);
11603
11604 adaptor.addChild(root_1, stream_Identifier.nextNode());
11605 adaptor.addChild(root_1, stream_arguments.nextTree());
11606
11607 adaptor.addChild(root_0, root_1);
11608 }
11609
11610 }
11611
11612 retval.tree = root_0;}
11613 }
11614 break;
11615
11616 }
11617 retval.stop = input.LT(-1);
11618
11619 if ( state.backtracking==0 ) {
11620
11621 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
11622 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
11623 }
11624 }
11625 catch (RecognitionException re) {
11626 reportError(re);
11627 recover(input,re);
11628 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
11629
11630 }
11631 finally {
11632 if ( state.backtracking>0 ) { memoize(input, 67, primary_StartIndex); }
11633 }
11634 return retval;
11635 }
11636
11637
11638 public static class selector_return extends ParserRuleReturnScope {
11639 Node tree;
11640 public Object getTree() { return tree; }
11641 };
11642
11643
11644
11645 public final JFSLParser.selector_return selector() throws RecognitionException {
11646 JFSLParser.selector_return retval = new JFSLParser.selector_return();
11647 retval.start = input.LT(1);
11648 int selector_StartIndex = input.index();
11649 Node root_0 = null;
11650
11651 Token char_literal294=null;
11652 Token Identifier295=null;
11653 Token char_literal297=null;
11654 Token Identifier298=null;
11655 Token char_literal299=null;
11656 Token char_literal301=null;
11657 Token char_literal303=null;
11658 Token char_literal304=null;
11659 Token Identifier305=null;
11660 Token char_literal306=null;
11661 Token char_literal307=null;
11662 Token char_literal309=null;
11663 Token char_literal311=null;
11664 Token char_literal312=null;
11665 Token char_literal313=null;
11666 JFSLParser.arguments_return arguments296 = null;
11667
11668 JFSLParser.primitiveType_return primitiveType300 = null;
11669
11670 JFSLParser.common_return common302 = null;
11671
11672 JFSLParser.common_return common308 = null;
11673
11674 JFSLParser.expression_return expression310 = null;
11675
11676
11677 Node char_literal294_tree=null;
11678 Node Identifier295_tree=null;
11679 Node char_literal297_tree=null;
11680 Node Identifier298_tree=null;
11681 Node char_literal299_tree=null;
11682 Node char_literal301_tree=null;
11683 Node char_literal303_tree=null;
11684 Node char_literal304_tree=null;
11685 Node Identifier305_tree=null;
11686 Node char_literal306_tree=null;
11687 Node char_literal307_tree=null;
11688 Node char_literal309_tree=null;
11689 Node char_literal311_tree=null;
11690 Node char_literal312_tree=null;
11691 Node char_literal313_tree=null;
11692 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
11693 RewriteRuleTokenStream stream_129=new RewriteRuleTokenStream(adaptor,"token 129");
11694 RewriteRuleTokenStream stream_168=new RewriteRuleTokenStream(adaptor,"token 168");
11695 RewriteRuleTokenStream stream_155=new RewriteRuleTokenStream(adaptor,"token 155");
11696 RewriteRuleTokenStream stream_167=new RewriteRuleTokenStream(adaptor,"token 167");
11697 RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
11698 RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
11699 RewriteRuleSubtreeStream stream_common=new RewriteRuleSubtreeStream(adaptor,"rule common");
11700 RewriteRuleSubtreeStream stream_primitiveType=new RewriteRuleSubtreeStream(adaptor,"rule primitiveType");
11701 try {
11702 if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return retval; }
11703
11704 int alt79=8;
11705 alt79 = dfa79.predict(input);
11706 switch (alt79) {
11707 case 1 :
11708
11709 {
11710 char_literal294=(Token)match(input,129,FOLLOW_129_in_selector4090); if (state.failed) return retval;
11711 if ( state.backtracking==0 ) stream_129.add(char_literal294);
11712
11713 Identifier295=(Token)match(input,Identifier,FOLLOW_Identifier_in_selector4092); if (state.failed) return retval;
11714 if ( state.backtracking==0 ) stream_Identifier.add(Identifier295);
11715
11716 pushFollow(FOLLOW_arguments_in_selector4094);
11717 arguments296=arguments();
11718
11719 state._fsp--;
11720 if (state.failed) return retval;
11721 if ( state.backtracking==0 ) stream_arguments.add(arguments296.getTree());
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731 if ( state.backtracking==0 ) {
11732 retval.tree = root_0;
11733 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11734
11735 root_0 = (Node)adaptor.nil();
11736
11737 {
11738
11739 {
11740 Node root_1 = (Node)adaptor.nil();
11741 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(CALL, "CALL"), root_1);
11742
11743 adaptor.addChild(root_1, stream_Identifier.nextNode());
11744 adaptor.addChild(root_1, stream_arguments.nextTree());
11745
11746 adaptor.addChild(root_0, root_1);
11747 }
11748
11749 }
11750
11751 retval.tree = root_0;}
11752 }
11753 break;
11754 case 2 :
11755
11756 {
11757 char_literal297=(Token)match(input,129,FOLLOW_129_in_selector4110); if (state.failed) return retval;
11758 if ( state.backtracking==0 ) stream_129.add(char_literal297);
11759
11760 Identifier298=(Token)match(input,Identifier,FOLLOW_Identifier_in_selector4112); if (state.failed) return retval;
11761 if ( state.backtracking==0 ) stream_Identifier.add(Identifier298);
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772 if ( state.backtracking==0 ) {
11773 retval.tree = root_0;
11774 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11775
11776 root_0 = (Node)adaptor.nil();
11777
11778 {
11779
11780 {
11781 Node root_1 = (Node)adaptor.nil();
11782 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(JOIN, "JOIN"), root_1);
11783
11784
11785 {
11786 Node root_2 = (Node)adaptor.nil();
11787 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
11788
11789 adaptor.addChild(root_2, stream_Identifier.nextNode());
11790
11791 adaptor.addChild(root_1, root_2);
11792 }
11793
11794 adaptor.addChild(root_0, root_1);
11795 }
11796
11797 }
11798
11799 retval.tree = root_0;}
11800 }
11801 break;
11802 case 3 :
11803
11804 {
11805 char_literal299=(Token)match(input,129,FOLLOW_129_in_selector4130); if (state.failed) return retval;
11806 if ( state.backtracking==0 ) stream_129.add(char_literal299);
11807
11808 pushFollow(FOLLOW_primitiveType_in_selector4132);
11809 primitiveType300=primitiveType();
11810
11811 state._fsp--;
11812 if (state.failed) return retval;
11813 if ( state.backtracking==0 ) stream_primitiveType.add(primitiveType300.getTree());
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823 if ( state.backtracking==0 ) {
11824 retval.tree = root_0;
11825 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11826
11827 root_0 = (Node)adaptor.nil();
11828
11829 {
11830
11831 {
11832 Node root_1 = (Node)adaptor.nil();
11833 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(JOIN, "JOIN"), root_1);
11834
11835 adaptor.addChild(root_1, stream_primitiveType.nextTree());
11836
11837 adaptor.addChild(root_0, root_1);
11838 }
11839
11840 }
11841
11842 retval.tree = root_0;}
11843 }
11844 break;
11845 case 4 :
11846
11847 {
11848 char_literal301=(Token)match(input,129,FOLLOW_129_in_selector4146); if (state.failed) return retval;
11849 if ( state.backtracking==0 ) stream_129.add(char_literal301);
11850
11851 pushFollow(FOLLOW_common_in_selector4148);
11852 common302=common();
11853
11854 state._fsp--;
11855 if (state.failed) return retval;
11856 if ( state.backtracking==0 ) stream_common.add(common302.getTree());
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866 if ( state.backtracking==0 ) {
11867 retval.tree = root_0;
11868 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11869
11870 root_0 = (Node)adaptor.nil();
11871
11872 {
11873
11874 {
11875 Node root_1 = (Node)adaptor.nil();
11876 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(JOIN, "JOIN"), root_1);
11877
11878 adaptor.addChild(root_1, stream_common.nextTree());
11879
11880 adaptor.addChild(root_0, root_1);
11881 }
11882
11883 }
11884
11885 retval.tree = root_0;}
11886 }
11887 break;
11888 case 5 :
11889
11890 {
11891 char_literal303=(Token)match(input,129,FOLLOW_129_in_selector4162); if (state.failed) return retval;
11892 if ( state.backtracking==0 ) stream_129.add(char_literal303);
11893
11894 char_literal304=(Token)match(input,155,FOLLOW_155_in_selector4164); if (state.failed) return retval;
11895 if ( state.backtracking==0 ) stream_155.add(char_literal304);
11896
11897 Identifier305=(Token)match(input,Identifier,FOLLOW_Identifier_in_selector4166); if (state.failed) return retval;
11898 if ( state.backtracking==0 ) stream_Identifier.add(Identifier305);
11899
11900
11901
11902
11903
11904
11905
11906
11907
11908
11909 if ( state.backtracking==0 ) {
11910 retval.tree = root_0;
11911 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11912
11913 root_0 = (Node)adaptor.nil();
11914
11915 {
11916
11917 {
11918 Node root_1 = (Node)adaptor.nil();
11919 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(JOIN_REFLEXIVE, "JOIN_REFLEXIVE"), root_1);
11920
11921
11922 {
11923 Node root_2 = (Node)adaptor.nil();
11924 root_2 = (Node)adaptor.becomeRoot((Node)adaptor.create(IDENTIFIER, "IDENTIFIER"), root_2);
11925
11926 adaptor.addChild(root_2, stream_Identifier.nextNode());
11927
11928 adaptor.addChild(root_1, root_2);
11929 }
11930
11931 adaptor.addChild(root_0, root_1);
11932 }
11933
11934 }
11935
11936 retval.tree = root_0;}
11937 }
11938 break;
11939 case 6 :
11940
11941 {
11942 char_literal306=(Token)match(input,129,FOLLOW_129_in_selector4184); if (state.failed) return retval;
11943 if ( state.backtracking==0 ) stream_129.add(char_literal306);
11944
11945 char_literal307=(Token)match(input,155,FOLLOW_155_in_selector4186); if (state.failed) return retval;
11946 if ( state.backtracking==0 ) stream_155.add(char_literal307);
11947
11948 pushFollow(FOLLOW_common_in_selector4188);
11949 common308=common();
11950
11951 state._fsp--;
11952 if (state.failed) return retval;
11953 if ( state.backtracking==0 ) stream_common.add(common308.getTree());
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963 if ( state.backtracking==0 ) {
11964 retval.tree = root_0;
11965 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
11966
11967 root_0 = (Node)adaptor.nil();
11968
11969 {
11970
11971 {
11972 Node root_1 = (Node)adaptor.nil();
11973 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(JOIN_REFLEXIVE, "JOIN_REFLEXIVE"), root_1);
11974
11975 adaptor.addChild(root_1, stream_common.nextTree());
11976
11977 adaptor.addChild(root_0, root_1);
11978 }
11979
11980 }
11981
11982 retval.tree = root_0;}
11983 }
11984 break;
11985 case 7 :
11986
11987 {
11988 char_literal309=(Token)match(input,167,FOLLOW_167_in_selector4202); if (state.failed) return retval;
11989 if ( state.backtracking==0 ) stream_167.add(char_literal309);
11990
11991 pushFollow(FOLLOW_expression_in_selector4203);
11992 expression310=expression();
11993
11994 state._fsp--;
11995 if (state.failed) return retval;
11996 if ( state.backtracking==0 ) stream_expression.add(expression310.getTree());
11997 char_literal311=(Token)match(input,168,FOLLOW_168_in_selector4205); if (state.failed) return retval;
11998 if ( state.backtracking==0 ) stream_168.add(char_literal311);
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009 if ( state.backtracking==0 ) {
12010 retval.tree = root_0;
12011 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12012
12013 root_0 = (Node)adaptor.nil();
12014
12015 {
12016
12017 {
12018 Node root_1 = (Node)adaptor.nil();
12019 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BRACKET, "BRACKET"), root_1);
12020
12021 adaptor.addChild(root_1, stream_expression.nextTree());
12022
12023 adaptor.addChild(root_0, root_1);
12024 }
12025
12026 }
12027
12028 retval.tree = root_0;}
12029 }
12030 break;
12031 case 8 :
12032
12033 {
12034 char_literal312=(Token)match(input,167,FOLLOW_167_in_selector4221); if (state.failed) return retval;
12035 if ( state.backtracking==0 ) stream_167.add(char_literal312);
12036
12037 char_literal313=(Token)match(input,168,FOLLOW_168_in_selector4223); if (state.failed) return retval;
12038 if ( state.backtracking==0 ) stream_168.add(char_literal313);
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049 if ( state.backtracking==0 ) {
12050 retval.tree = root_0;
12051 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12052
12053 root_0 = (Node)adaptor.nil();
12054
12055 {
12056
12057 {
12058 Node root_1 = (Node)adaptor.nil();
12059 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(BRACKET, "BRACKET"), root_1);
12060
12061 adaptor.addChild(root_0, root_1);
12062 }
12063
12064 }
12065
12066 retval.tree = root_0;}
12067 }
12068 break;
12069
12070 }
12071 retval.stop = input.LT(-1);
12072
12073 if ( state.backtracking==0 ) {
12074
12075 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
12076 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
12077 }
12078 }
12079 catch (RecognitionException re) {
12080 reportError(re);
12081 recover(input,re);
12082 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
12083
12084 }
12085 finally {
12086 if ( state.backtracking>0 ) { memoize(input, 68, selector_StartIndex); }
12087 }
12088 return retval;
12089 }
12090
12091
12092 public static class specUnaryOp_return extends ParserRuleReturnScope {
12093 Node tree;
12094 public Object getTree() { return tree; }
12095 };
12096
12097
12098
12099 public final JFSLParser.specUnaryOp_return specUnaryOp() throws RecognitionException {
12100 JFSLParser.specUnaryOp_return retval = new JFSLParser.specUnaryOp_return();
12101 retval.start = input.LT(1);
12102 int specUnaryOp_StartIndex = input.index();
12103 Node root_0 = null;
12104
12105 Token char_literal314=null;
12106 Token char_literal315=null;
12107 Token char_literal316=null;
12108 Token char_literal317=null;
12109 Token char_literal318=null;
12110 Token char_literal319=null;
12111
12112 Node char_literal314_tree=null;
12113 Node char_literal315_tree=null;
12114 Node char_literal316_tree=null;
12115 Node char_literal317_tree=null;
12116 Node char_literal318_tree=null;
12117 Node char_literal319_tree=null;
12118 RewriteRuleTokenStream stream_174=new RewriteRuleTokenStream(adaptor,"token 174");
12119 RewriteRuleTokenStream stream_183=new RewriteRuleTokenStream(adaptor,"token 183");
12120 RewriteRuleTokenStream stream_186=new RewriteRuleTokenStream(adaptor,"token 186");
12121
12122 try {
12123 if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return retval; }
12124
12125 int alt82=2;
12126 switch ( input.LA(1) ) {
12127 case 183:
12128 {
12129 int LA82_1 = input.LA(2);
12130
12131 if ( (LA82_1==174) ) {
12132 alt82=1;
12133 }
12134 else if ( (LA82_1==186) ) {
12135 alt82=2;
12136 }
12137 else {
12138 if (state.backtracking>0) {state.failed=true; return retval;}
12139 NoViableAltException nvae =
12140 new NoViableAltException("", 82, 1, input);
12141
12142 throw nvae;
12143 }
12144 }
12145 break;
12146 case 174:
12147 {
12148 alt82=1;
12149 }
12150 break;
12151 case 186:
12152 {
12153 alt82=2;
12154 }
12155 break;
12156 default:
12157 if (state.backtracking>0) {state.failed=true; return retval;}
12158 NoViableAltException nvae =
12159 new NoViableAltException("", 82, 0, input);
12160
12161 throw nvae;
12162 }
12163
12164 switch (alt82) {
12165 case 1 :
12166
12167 {
12168
12169 int alt80=2;
12170 int LA80_0 = input.LA(1);
12171
12172 if ( (LA80_0==183) ) {
12173 alt80=1;
12174 }
12175 else if ( (LA80_0==174) ) {
12176 alt80=2;
12177 }
12178 else {
12179 if (state.backtracking>0) {state.failed=true; return retval;}
12180 NoViableAltException nvae =
12181 new NoViableAltException("", 80, 0, input);
12182
12183 throw nvae;
12184 }
12185 switch (alt80) {
12186 case 1 :
12187
12188 {
12189 char_literal314=(Token)match(input,183,FOLLOW_183_in_specUnaryOp4245); if (state.failed) return retval;
12190 if ( state.backtracking==0 ) stream_183.add(char_literal314);
12191
12192 char_literal315=(Token)match(input,174,FOLLOW_174_in_specUnaryOp4247); if (state.failed) return retval;
12193 if ( state.backtracking==0 ) stream_174.add(char_literal315);
12194
12195
12196 }
12197 break;
12198 case 2 :
12199
12200 {
12201 char_literal316=(Token)match(input,174,FOLLOW_174_in_specUnaryOp4251); if (state.failed) return retval;
12202 if ( state.backtracking==0 ) stream_174.add(char_literal316);
12203
12204
12205 }
12206 break;
12207
12208 }
12209
12210
12211
12212
12213
12214
12215
12216
12217
12218
12219 if ( state.backtracking==0 ) {
12220 retval.tree = root_0;
12221 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12222
12223 root_0 = (Node)adaptor.nil();
12224
12225 {
12226 adaptor.addChild(root_0, (Node)adaptor.create(OP_CLOSURE, "OP_CLOSURE"));
12227
12228 }
12229
12230 retval.tree = root_0;}
12231 }
12232 break;
12233 case 2 :
12234
12235 {
12236
12237 int alt81=2;
12238 int LA81_0 = input.LA(1);
12239
12240 if ( (LA81_0==183) ) {
12241 alt81=1;
12242 }
12243 else if ( (LA81_0==186) ) {
12244 alt81=2;
12245 }
12246 else {
12247 if (state.backtracking>0) {state.failed=true; return retval;}
12248 NoViableAltException nvae =
12249 new NoViableAltException("", 81, 0, input);
12250
12251 throw nvae;
12252 }
12253 switch (alt81) {
12254 case 1 :
12255
12256 {
12257 char_literal317=(Token)match(input,183,FOLLOW_183_in_specUnaryOp4263); if (state.failed) return retval;
12258 if ( state.backtracking==0 ) stream_183.add(char_literal317);
12259
12260 char_literal318=(Token)match(input,186,FOLLOW_186_in_specUnaryOp4265); if (state.failed) return retval;
12261 if ( state.backtracking==0 ) stream_186.add(char_literal318);
12262
12263
12264 }
12265 break;
12266 case 2 :
12267
12268 {
12269 char_literal319=(Token)match(input,186,FOLLOW_186_in_specUnaryOp4269); if (state.failed) return retval;
12270 if ( state.backtracking==0 ) stream_186.add(char_literal319);
12271
12272
12273 }
12274 break;
12275
12276 }
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287 if ( state.backtracking==0 ) {
12288 retval.tree = root_0;
12289 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12290
12291 root_0 = (Node)adaptor.nil();
12292
12293 {
12294 adaptor.addChild(root_0, (Node)adaptor.create(OP_TRANSPOSE, "OP_TRANSPOSE"));
12295
12296 }
12297
12298 retval.tree = root_0;}
12299 }
12300 break;
12301
12302 }
12303 retval.stop = input.LT(-1);
12304
12305 if ( state.backtracking==0 ) {
12306
12307 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
12308 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
12309 }
12310 }
12311 catch (RecognitionException re) {
12312 reportError(re);
12313 recover(input,re);
12314 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
12315
12316 }
12317 finally {
12318 if ( state.backtracking>0 ) { memoize(input, 69, specUnaryOp_StartIndex); }
12319 }
12320 return retval;
12321 }
12322
12323
12324 public static class setDeclOp_return extends ParserRuleReturnScope {
12325 Node tree;
12326 public Object getTree() { return tree; }
12327 };
12328
12329
12330
12331 public final JFSLParser.setDeclOp_return setDeclOp() throws RecognitionException {
12332 JFSLParser.setDeclOp_return retval = new JFSLParser.setDeclOp_return();
12333 retval.start = input.LT(1);
12334 int setDeclOp_StartIndex = input.index();
12335 Node root_0 = null;
12336
12337 Token string_literal320=null;
12338 Token string_literal321=null;
12339 Token string_literal322=null;
12340
12341 Node string_literal320_tree=null;
12342 Node string_literal321_tree=null;
12343 Node string_literal322_tree=null;
12344 RewriteRuleTokenStream stream_195=new RewriteRuleTokenStream(adaptor,"token 195");
12345 RewriteRuleTokenStream stream_194=new RewriteRuleTokenStream(adaptor,"token 194");
12346 RewriteRuleTokenStream stream_193=new RewriteRuleTokenStream(adaptor,"token 193");
12347
12348 try {
12349 if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return retval; }
12350
12351 int alt83=3;
12352 switch ( input.LA(1) ) {
12353 case 193:
12354 {
12355 alt83=1;
12356 }
12357 break;
12358 case 194:
12359 {
12360 alt83=2;
12361 }
12362 break;
12363 case 195:
12364 {
12365 alt83=3;
12366 }
12367 break;
12368 default:
12369 if (state.backtracking>0) {state.failed=true; return retval;}
12370 NoViableAltException nvae =
12371 new NoViableAltException("", 83, 0, input);
12372
12373 throw nvae;
12374 }
12375
12376 switch (alt83) {
12377 case 1 :
12378
12379 {
12380 string_literal320=(Token)match(input,193,FOLLOW_193_in_setDeclOp4294); if (state.failed) return retval;
12381 if ( state.backtracking==0 ) stream_193.add(string_literal320);
12382
12383
12384
12385
12386
12387
12388
12389
12390
12391
12392 if ( state.backtracking==0 ) {
12393 retval.tree = root_0;
12394 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12395
12396 root_0 = (Node)adaptor.nil();
12397
12398 {
12399 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_ONE, "OP_SET_ONE"));
12400
12401 }
12402
12403 retval.tree = root_0;}
12404 }
12405 break;
12406 case 2 :
12407
12408 {
12409 string_literal321=(Token)match(input,194,FOLLOW_194_in_setDeclOp4306); if (state.failed) return retval;
12410 if ( state.backtracking==0 ) stream_194.add(string_literal321);
12411
12412
12413
12414
12415
12416
12417
12418
12419
12420
12421 if ( state.backtracking==0 ) {
12422 retval.tree = root_0;
12423 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12424
12425 root_0 = (Node)adaptor.nil();
12426
12427 {
12428 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_SOME, "OP_SET_SOME"));
12429
12430 }
12431
12432 retval.tree = root_0;}
12433 }
12434 break;
12435 case 3 :
12436
12437 {
12438 string_literal322=(Token)match(input,195,FOLLOW_195_in_setDeclOp4318); if (state.failed) return retval;
12439 if ( state.backtracking==0 ) stream_195.add(string_literal322);
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450 if ( state.backtracking==0 ) {
12451 retval.tree = root_0;
12452 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12453
12454 root_0 = (Node)adaptor.nil();
12455
12456 {
12457 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_LONE, "OP_SET_LONE"));
12458
12459 }
12460
12461 retval.tree = root_0;}
12462 }
12463 break;
12464
12465 }
12466 retval.stop = input.LT(-1);
12467
12468 if ( state.backtracking==0 ) {
12469
12470 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
12471 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
12472 }
12473 }
12474 catch (RecognitionException re) {
12475 reportError(re);
12476 recover(input,re);
12477 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
12478
12479 }
12480 finally {
12481 if ( state.backtracking>0 ) { memoize(input, 70, setDeclOp_StartIndex); }
12482 }
12483 return retval;
12484 }
12485
12486
12487 public static class setUnaryOp_return extends ParserRuleReturnScope {
12488 Node tree;
12489 public Object getTree() { return tree; }
12490 };
12491
12492
12493
12494 public final JFSLParser.setUnaryOp_return setUnaryOp() throws RecognitionException {
12495 JFSLParser.setUnaryOp_return retval = new JFSLParser.setUnaryOp_return();
12496 retval.start = input.LT(1);
12497 int setUnaryOp_StartIndex = input.index();
12498 Node root_0 = null;
12499
12500 Token string_literal324=null;
12501 Token string_literal325=null;
12502 JFSLParser.setDeclOp_return setDeclOp323 = null;
12503
12504
12505 Node string_literal324_tree=null;
12506 Node string_literal325_tree=null;
12507 RewriteRuleTokenStream stream_197=new RewriteRuleTokenStream(adaptor,"token 197");
12508 RewriteRuleTokenStream stream_196=new RewriteRuleTokenStream(adaptor,"token 196");
12509
12510 try {
12511 if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return retval; }
12512
12513 int alt84=3;
12514 switch ( input.LA(1) ) {
12515 case 193:
12516 case 194:
12517 case 195:
12518 {
12519 alt84=1;
12520 }
12521 break;
12522 case 196:
12523 {
12524 alt84=2;
12525 }
12526 break;
12527 case 197:
12528 {
12529 alt84=3;
12530 }
12531 break;
12532 default:
12533 if (state.backtracking>0) {state.failed=true; return retval;}
12534 NoViableAltException nvae =
12535 new NoViableAltException("", 84, 0, input);
12536
12537 throw nvae;
12538 }
12539
12540 switch (alt84) {
12541 case 1 :
12542
12543 {
12544 root_0 = (Node)adaptor.nil();
12545
12546 pushFollow(FOLLOW_setDeclOp_in_setUnaryOp4341);
12547 setDeclOp323=setDeclOp();
12548
12549 state._fsp--;
12550 if (state.failed) return retval;
12551 if ( state.backtracking==0 ) adaptor.addChild(root_0, setDeclOp323.getTree());
12552
12553 }
12554 break;
12555 case 2 :
12556
12557 {
12558 string_literal324=(Token)match(input,196,FOLLOW_196_in_setUnaryOp4347); if (state.failed) return retval;
12559 if ( state.backtracking==0 ) stream_196.add(string_literal324);
12560
12561
12562
12563
12564
12565
12566
12567
12568
12569
12570 if ( state.backtracking==0 ) {
12571 retval.tree = root_0;
12572 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12573
12574 root_0 = (Node)adaptor.nil();
12575
12576 {
12577 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_NO, "OP_SET_NO"));
12578
12579 }
12580
12581 retval.tree = root_0;}
12582 }
12583 break;
12584 case 3 :
12585
12586 {
12587 string_literal325=(Token)match(input,197,FOLLOW_197_in_setUnaryOp4358); if (state.failed) return retval;
12588 if ( state.backtracking==0 ) stream_197.add(string_literal325);
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599 if ( state.backtracking==0 ) {
12600 retval.tree = root_0;
12601 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12602
12603 root_0 = (Node)adaptor.nil();
12604
12605 {
12606 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_SUM, "OP_SET_SUM"));
12607
12608 }
12609
12610 retval.tree = root_0;}
12611 }
12612 break;
12613
12614 }
12615 retval.stop = input.LT(-1);
12616
12617 if ( state.backtracking==0 ) {
12618
12619 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
12620 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
12621 }
12622 }
12623 catch (RecognitionException re) {
12624 reportError(re);
12625 recover(input,re);
12626 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
12627
12628 }
12629 finally {
12630 if ( state.backtracking>0 ) { memoize(input, 71, setUnaryOp_StartIndex); }
12631 }
12632 return retval;
12633 }
12634
12635
12636 public static class setQuantOp_return extends ParserRuleReturnScope {
12637 Node tree;
12638 public Object getTree() { return tree; }
12639 };
12640
12641
12642
12643 public final JFSLParser.setQuantOp_return setQuantOp() throws RecognitionException {
12644 JFSLParser.setQuantOp_return retval = new JFSLParser.setQuantOp_return();
12645 retval.start = input.LT(1);
12646 int setQuantOp_StartIndex = input.index();
12647 Node root_0 = null;
12648
12649 Token char_literal327=null;
12650 Token string_literal328=null;
12651 Token string_literal329=null;
12652 JFSLParser.setUnaryOp_return setUnaryOp326 = null;
12653
12654
12655 Node char_literal327_tree=null;
12656 Node string_literal328_tree=null;
12657 Node string_literal329_tree=null;
12658 RewriteRuleTokenStream stream_180=new RewriteRuleTokenStream(adaptor,"token 180");
12659 RewriteRuleTokenStream stream_198=new RewriteRuleTokenStream(adaptor,"token 198");
12660 RewriteRuleTokenStream stream_199=new RewriteRuleTokenStream(adaptor,"token 199");
12661
12662 try {
12663 if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return retval; }
12664
12665 int alt85=4;
12666 switch ( input.LA(1) ) {
12667 case 193:
12668 case 194:
12669 case 195:
12670 case 196:
12671 case 197:
12672 {
12673 alt85=1;
12674 }
12675 break;
12676 case 180:
12677 {
12678 alt85=2;
12679 }
12680 break;
12681 case 198:
12682 {
12683 alt85=3;
12684 }
12685 break;
12686 case 199:
12687 {
12688 alt85=4;
12689 }
12690 break;
12691 default:
12692 if (state.backtracking>0) {state.failed=true; return retval;}
12693 NoViableAltException nvae =
12694 new NoViableAltException("", 85, 0, input);
12695
12696 throw nvae;
12697 }
12698
12699 switch (alt85) {
12700 case 1 :
12701
12702 {
12703 root_0 = (Node)adaptor.nil();
12704
12705 pushFollow(FOLLOW_setUnaryOp_in_setQuantOp4380);
12706 setUnaryOp326=setUnaryOp();
12707
12708 state._fsp--;
12709 if (state.failed) return retval;
12710 if ( state.backtracking==0 ) adaptor.addChild(root_0, setUnaryOp326.getTree());
12711
12712 }
12713 break;
12714 case 2 :
12715
12716 {
12717 char_literal327=(Token)match(input,180,FOLLOW_180_in_setQuantOp4386); if (state.failed) return retval;
12718 if ( state.backtracking==0 ) stream_180.add(char_literal327);
12719
12720
12721
12722
12723
12724
12725
12726
12727
12728
12729 if ( state.backtracking==0 ) {
12730 retval.tree = root_0;
12731 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12732
12733 root_0 = (Node)adaptor.nil();
12734
12735 {
12736 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_NUM, "OP_SET_NUM"));
12737
12738 }
12739
12740 retval.tree = root_0;}
12741 }
12742 break;
12743 case 3 :
12744
12745 {
12746 string_literal328=(Token)match(input,198,FOLLOW_198_in_setQuantOp4397); if (state.failed) return retval;
12747 if ( state.backtracking==0 ) stream_198.add(string_literal328);
12748
12749
12750
12751
12752
12753
12754
12755
12756
12757
12758 if ( state.backtracking==0 ) {
12759 retval.tree = root_0;
12760 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12761
12762 root_0 = (Node)adaptor.nil();
12763
12764 {
12765 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_ALL, "OP_SET_ALL"));
12766
12767 }
12768
12769 retval.tree = root_0;}
12770 }
12771 break;
12772 case 4 :
12773
12774 {
12775 string_literal329=(Token)match(input,199,FOLLOW_199_in_setQuantOp4410); if (state.failed) return retval;
12776 if ( state.backtracking==0 ) stream_199.add(string_literal329);
12777
12778
12779
12780
12781
12782
12783
12784
12785
12786
12787 if ( state.backtracking==0 ) {
12788 retval.tree = root_0;
12789 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
12790
12791 root_0 = (Node)adaptor.nil();
12792
12793 {
12794 adaptor.addChild(root_0, (Node)adaptor.create(OP_SET_EXISTS, "OP_SET_EXISTS"));
12795
12796 }
12797
12798 retval.tree = root_0;}
12799 }
12800 break;
12801
12802 }
12803 retval.stop = input.LT(-1);
12804
12805 if ( state.backtracking==0 ) {
12806
12807 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
12808 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
12809 }
12810 }
12811 catch (RecognitionException re) {
12812 reportError(re);
12813 recover(input,re);
12814 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
12815
12816 }
12817 finally {
12818 if ( state.backtracking>0 ) { memoize(input, 72, setQuantOp_StartIndex); }
12819 }
12820 return retval;
12821 }
12822
12823
12824
12825 public final void synpred13_JFSL_fragment() throws RecognitionException {
12826
12827
12828 {
12829 match(input,128,FOLLOW_128_in_synpred13_JFSL1055); if (state.failed) return ;
12830 pushFollow(FOLLOW_specCase_in_synpred13_JFSL1057);
12831 specCase();
12832
12833 state._fsp--;
12834 if (state.failed) return ;
12835
12836 }
12837 }
12838
12839
12840
12841 public final void synpred26_JFSL_fragment() throws RecognitionException {
12842
12843
12844 {
12845
12846 int alt90=2;
12847 int LA90_0 = input.LA(1);
12848
12849 if ( ((LA90_0>=148 && LA90_0<=149)) ) {
12850 alt90=1;
12851 }
12852 switch (alt90) {
12853 case 1 :
12854
12855 {
12856 if ( (input.LA(1)>=148 && input.LA(1)<=149) ) {
12857 input.consume();
12858 state.errorRecovery=false;state.failed=false;
12859 }
12860 else {
12861 if (state.backtracking>0) {state.failed=true; return ;}
12862 MismatchedSetException mse = new MismatchedSetException(null,input);
12863 throw mse;
12864 }
12865
12866
12867 }
12868 break;
12869
12870 }
12871
12872 match(input,Identifier,FOLLOW_Identifier_in_synpred26_JFSL1314); if (state.failed) return ;
12873 match(input,150,FOLLOW_150_in_synpred26_JFSL1316); if (state.failed) return ;
12874 pushFollow(FOLLOW_declarationMult_in_synpred26_JFSL1318);
12875 declarationMult();
12876
12877 state._fsp--;
12878 if (state.failed) return ;
12879 pushFollow(FOLLOW_additiveExpression_in_synpred26_JFSL1320);
12880 additiveExpression();
12881
12882 state._fsp--;
12883 if (state.failed) return ;
12884 match(input,151,FOLLOW_151_in_synpred26_JFSL1322); if (state.failed) return ;
12885 pushFollow(FOLLOW_frame_in_synpred26_JFSL1324);
12886 frame();
12887
12888 state._fsp--;
12889 if (state.failed) return ;
12890
12891 int alt91=2;
12892 int LA91_0 = input.LA(1);
12893
12894 if ( (LA91_0==152) ) {
12895 alt91=1;
12896 }
12897 switch (alt91) {
12898 case 1 :
12899
12900 {
12901 match(input,152,FOLLOW_152_in_synpred26_JFSL1327); if (state.failed) return ;
12902 pushFollow(FOLLOW_expression_in_synpred26_JFSL1329);
12903 expression();
12904
12905 state._fsp--;
12906 if (state.failed) return ;
12907
12908 }
12909 break;
12910
12911 }
12912
12913
12914 }
12915 }
12916
12917
12918
12919 public final void synpred37_JFSL_fragment() throws RecognitionException {
12920
12921
12922 {
12923
12924 loop92:
12925 do {
12926 int alt92=2;
12927 int LA92_0 = input.LA(1);
12928
12929 if ( (LA92_0==129) ) {
12930 int LA92_1 = input.LA(2);
12931
12932 if ( (LA92_1==155) ) {
12933 int LA92_3 = input.LA(3);
12934
12935 if ( (LA92_3==Identifier||LA92_3==133||LA92_3==139||LA92_3==174||LA92_3==183||(LA92_3>=186 && LA92_3<=192)) ) {
12936 alt92=1;
12937 }
12938
12939
12940 }
12941 else if ( (LA92_1==Identifier||LA92_1==133||LA92_1==139||(LA92_1>=159 && LA92_1<=166)||LA92_1==174||LA92_1==183||(LA92_1>=186 && LA92_1<=192)) ) {
12942 alt92=1;
12943 }
12944
12945
12946 }
12947 else if ( (LA92_0==167) ) {
12948 alt92=1;
12949 }
12950
12951
12952 switch (alt92) {
12953 case 1 :
12954
12955 {
12956 pushFollow(FOLLOW_selector_in_synpred37_JFSL1562);
12957 selector();
12958
12959 state._fsp--;
12960 if (state.failed) return ;
12961
12962 }
12963 break;
12964
12965 default :
12966 break loop92;
12967 }
12968 } while (true);
12969
12970 pushFollow(FOLLOW_storeWildCard_in_synpred37_JFSL1565);
12971 storeWildCard();
12972
12973 state._fsp--;
12974 if (state.failed) return ;
12975
12976 }
12977 }
12978
12979
12980
12981 public final void synpred56_JFSL_fragment() throws RecognitionException {
12982
12983
12984 {
12985
12986
12987 {
12988 match(input,167,FOLLOW_167_in_synpred56_JFSL1887); if (state.failed) return ;
12989 match(input,168,FOLLOW_168_in_synpred56_JFSL1889); if (state.failed) return ;
12990
12991 }
12992
12993
12994 }
12995 }
12996
12997
12998
12999 public final void synpred58_JFSL_fragment() throws RecognitionException {
13000
13001
13002 {
13003
13004
13005 {
13006 match(input,167,FOLLOW_167_in_synpred58_JFSL1917); if (state.failed) return ;
13007 match(input,168,FOLLOW_168_in_synpred58_JFSL1919); if (state.failed) return ;
13008
13009 }
13010
13011
13012 }
13013 }
13014
13015
13016
13017 public final void synpred62_JFSL_fragment() throws RecognitionException {
13018
13019
13020 {
13021 match(input,169,FOLLOW_169_in_synpred62_JFSL2105); if (state.failed) return ;
13022 pushFollow(FOLLOW_expression_in_synpred62_JFSL2107);
13023 expression();
13024
13025 state._fsp--;
13026 if (state.failed) return ;
13027 match(input,150,FOLLOW_150_in_synpred62_JFSL2109); if (state.failed) return ;
13028 pushFollow(FOLLOW_expression_in_synpred62_JFSL2111);
13029 expression();
13030
13031 state._fsp--;
13032 if (state.failed) return ;
13033
13034 }
13035 }
13036
13037
13038
13039 public final void synpred63_JFSL_fragment() throws RecognitionException {
13040
13041
13042 {
13043 pushFollow(FOLLOW_setQuantOp_in_synpred63_JFSL2147);
13044 setQuantOp();
13045
13046 state._fsp--;
13047 if (state.failed) return ;
13048 pushFollow(FOLLOW_decls_in_synpred63_JFSL2149);
13049 decls();
13050
13051 state._fsp--;
13052 if (state.failed) return ;
13053 match(input,152,FOLLOW_152_in_synpred63_JFSL2151); if (state.failed) return ;
13054 pushFollow(FOLLOW_expression_in_synpred63_JFSL2153);
13055 expression();
13056
13057 state._fsp--;
13058 if (state.failed) return ;
13059
13060 }
13061 }
13062
13063
13064
13065 public final void synpred99_JFSL_fragment() throws RecognitionException {
13066
13067
13068 {
13069 match(input,186,FOLLOW_186_in_synpred99_JFSL3605); if (state.failed) return ;
13070 pushFollow(FOLLOW_unaryExpression_in_synpred99_JFSL3607);
13071 unaryExpression();
13072
13073 state._fsp--;
13074 if (state.failed) return ;
13075
13076 }
13077 }
13078
13079
13080
13081 public final void synpred101_JFSL_fragment() throws RecognitionException {
13082
13083
13084 {
13085 pushFollow(FOLLOW_castExpression_in_synpred101_JFSL3645);
13086 castExpression();
13087
13088 state._fsp--;
13089 if (state.failed) return ;
13090
13091 }
13092 }
13093
13094
13095
13096 public final void synpred117_JFSL_fragment() throws RecognitionException {
13097
13098
13099 {
13100 pushFollow(FOLLOW_typeDisambiguous_in_synpred117_JFSL3996);
13101 typeDisambiguous();
13102
13103 state._fsp--;
13104 if (state.failed) return ;
13105
13106 }
13107 }
13108
13109
13110
13111 public final void synpred118_JFSL_fragment() throws RecognitionException {
13112
13113
13114 {
13115 match(input,129,FOLLOW_129_in_synpred118_JFSL4005); if (state.failed) return ;
13116 match(input,Identifier,FOLLOW_Identifier_in_synpred118_JFSL4007); if (state.failed) return ;
13117
13118 }
13119 }
13120
13121
13122
13123 public final void synpred119_JFSL_fragment() throws RecognitionException {
13124
13125
13126 {
13127 pushFollow(FOLLOW_typeParameters2_in_synpred119_JFSL4011);
13128 typeParameters2();
13129
13130 state._fsp--;
13131 if (state.failed) return ;
13132
13133 }
13134 }
13135
13136
13137
13138 public final void synpred120_JFSL_fragment() throws RecognitionException {
13139
13140
13141 {
13142 match(input,Identifier,FOLLOW_Identifier_in_synpred120_JFSL4002); if (state.failed) return ;
13143
13144 loop95:
13145 do {
13146 int alt95=2;
13147 int LA95_0 = input.LA(1);
13148
13149 if ( (LA95_0==129) ) {
13150 alt95=1;
13151 }
13152
13153
13154 switch (alt95) {
13155 case 1 :
13156
13157 {
13158 match(input,129,FOLLOW_129_in_synpred120_JFSL4005); if (state.failed) return ;
13159 match(input,Identifier,FOLLOW_Identifier_in_synpred120_JFSL4007); if (state.failed) return ;
13160
13161 }
13162 break;
13163
13164 default :
13165 break loop95;
13166 }
13167 } while (true);
13168
13169
13170 int alt96=2;
13171 int LA96_0 = input.LA(1);
13172
13173 if ( (LA96_0==135) ) {
13174 alt96=1;
13175 }
13176 switch (alt96) {
13177 case 1 :
13178
13179 {
13180 pushFollow(FOLLOW_typeParameters2_in_synpred120_JFSL4011);
13181 typeParameters2();
13182
13183 state._fsp--;
13184 if (state.failed) return ;
13185
13186 }
13187 break;
13188
13189 }
13190
13191
13192 }
13193 }
13194
13195
13196
13197
13198 public final boolean synpred99_JFSL() {
13199 state.backtracking++;
13200 int start = input.mark();
13201 try {
13202 synpred99_JFSL_fragment();
13203 } catch (RecognitionException re) {
13204 System.err.println("impossible: "+re);
13205 }
13206 boolean success = !state.failed;
13207 input.rewind(start);
13208 state.backtracking--;
13209 state.failed=false;
13210 return success;
13211 }
13212 public final boolean synpred117_JFSL() {
13213 state.backtracking++;
13214 int start = input.mark();
13215 try {
13216 synpred117_JFSL_fragment();
13217 } catch (RecognitionException re) {
13218 System.err.println("impossible: "+re);
13219 }
13220 boolean success = !state.failed;
13221 input.rewind(start);
13222 state.backtracking--;
13223 state.failed=false;
13224 return success;
13225 }
13226 public final boolean synpred62_JFSL() {
13227 state.backtracking++;
13228 int start = input.mark();
13229 try {
13230 synpred62_JFSL_fragment();
13231 } catch (RecognitionException re) {
13232 System.err.println("impossible: "+re);
13233 }
13234 boolean success = !state.failed;
13235 input.rewind(start);
13236 state.backtracking--;
13237 state.failed=false;
13238 return success;
13239 }
13240 public final boolean synpred118_JFSL() {
13241 state.backtracking++;
13242 int start = input.mark();
13243 try {
13244 synpred118_JFSL_fragment();
13245 } catch (RecognitionException re) {
13246 System.err.println("impossible: "+re);
13247 }
13248 boolean success = !state.failed;
13249 input.rewind(start);
13250 state.backtracking--;
13251 state.failed=false;
13252 return success;
13253 }
13254 public final boolean synpred63_JFSL() {
13255 state.backtracking++;
13256 int start = input.mark();
13257 try {
13258 synpred63_JFSL_fragment();
13259 } catch (RecognitionException re) {
13260 System.err.println("impossible: "+re);
13261 }
13262 boolean success = !state.failed;
13263 input.rewind(start);
13264 state.backtracking--;
13265 state.failed=false;
13266 return success;
13267 }
13268 public final boolean synpred119_JFSL() {
13269 state.backtracking++;
13270 int start = input.mark();
13271 try {
13272 synpred119_JFSL_fragment();
13273 } catch (RecognitionException re) {
13274 System.err.println("impossible: "+re);
13275 }
13276 boolean success = !state.failed;
13277 input.rewind(start);
13278 state.backtracking--;
13279 state.failed=false;
13280 return success;
13281 }
13282 public final boolean synpred56_JFSL() {
13283 state.backtracking++;
13284 int start = input.mark();
13285 try {
13286 synpred56_JFSL_fragment();
13287 } catch (RecognitionException re) {
13288 System.err.println("impossible: "+re);
13289 }
13290 boolean success = !state.failed;
13291 input.rewind(start);
13292 state.backtracking--;
13293 state.failed=false;
13294 return success;
13295 }
13296 public final boolean synpred58_JFSL() {
13297 state.backtracking++;
13298 int start = input.mark();
13299 try {
13300 synpred58_JFSL_fragment();
13301 } catch (RecognitionException re) {
13302 System.err.println("impossible: "+re);
13303 }
13304 boolean success = !state.failed;
13305 input.rewind(start);
13306 state.backtracking--;
13307 state.failed=false;
13308 return success;
13309 }
13310 public final boolean synpred13_JFSL() {
13311 state.backtracking++;
13312 int start = input.mark();
13313 try {
13314 synpred13_JFSL_fragment();
13315 } catch (RecognitionException re) {
13316 System.err.println("impossible: "+re);
13317 }
13318 boolean success = !state.failed;
13319 input.rewind(start);
13320 state.backtracking--;
13321 state.failed=false;
13322 return success;
13323 }
13324 public final boolean synpred26_JFSL() {
13325 state.backtracking++;
13326 int start = input.mark();
13327 try {
13328 synpred26_JFSL_fragment();
13329 } catch (RecognitionException re) {
13330 System.err.println("impossible: "+re);
13331 }
13332 boolean success = !state.failed;
13333 input.rewind(start);
13334 state.backtracking--;
13335 state.failed=false;
13336 return success;
13337 }
13338 public final boolean synpred37_JFSL() {
13339 state.backtracking++;
13340 int start = input.mark();
13341 try {
13342 synpred37_JFSL_fragment();
13343 } catch (RecognitionException re) {
13344 System.err.println("impossible: "+re);
13345 }
13346 boolean success = !state.failed;
13347 input.rewind(start);
13348 state.backtracking--;
13349 state.failed=false;
13350 return success;
13351 }
13352 public final boolean synpred101_JFSL() {
13353 state.backtracking++;
13354 int start = input.mark();
13355 try {
13356 synpred101_JFSL_fragment();
13357 } catch (RecognitionException re) {
13358 System.err.println("impossible: "+re);
13359 }
13360 boolean success = !state.failed;
13361 input.rewind(start);
13362 state.backtracking--;
13363 state.failed=false;
13364 return success;
13365 }
13366 public final boolean synpred120_JFSL() {
13367 state.backtracking++;
13368 int start = input.mark();
13369 try {
13370 synpred120_JFSL_fragment();
13371 } catch (RecognitionException re) {
13372 System.err.println("impossible: "+re);
13373 }
13374 boolean success = !state.failed;
13375 input.rewind(start);
13376 state.backtracking--;
13377 state.failed=false;
13378 return success;
13379 }
13380
13381
13382 protected DFA38 dfa38 = new DFA38(this);
13383 protected DFA42 dfa42 = new DFA42(this);
13384 protected DFA69 dfa69 = new DFA69(this);
13385 protected DFA78 dfa78 = new DFA78(this);
13386 protected DFA77 dfa77 = new DFA77(this);
13387 protected DFA79 dfa79 = new DFA79(this);
13388 static final String DFA38_eotS =
13389 "\13\uffff";
13390 static final String DFA38_eofS =
13391 "\2\uffff\1\5\3\uffff\1\5\2\uffff\1\5\1\uffff";
13392 static final String DFA38_minS =
13393 "\1\156\1\uffff\3\156\1\uffff\1\156\1\u0088\2\156\1\u0088";
13394 static final String DFA38_maxS =
13395 "\1\u00a6\1\uffff\1\u00af\1\156\1\u00ab\1\uffff\1\u00af\1\u0089\1"+
13396 "\156\1\u00af\1\u0089";
13397 static final String DFA38_acceptS =
13398 "\1\uffff\1\1\3\uffff\1\2\5\uffff";
13399 static final String DFA38_specialS =
13400 "\13\uffff}>";
13401 static final String[] DFA38_transitionS = {
13402 "\1\2\60\uffff\10\1",
13403 "",
13404 "\1\5\22\uffff\1\3\4\uffff\1\5\1\4\1\5\3\uffff\1\5\11\uffff"+
13405 "\1\5\1\uffff\1\5\16\uffff\1\1\10\5",
13406 "\1\6",
13407 "\1\7\73\uffff\2\5",
13408 "",
13409 "\1\5\22\uffff\1\3\4\uffff\1\5\1\4\1\5\3\uffff\1\5\11\uffff"+
13410 "\1\5\1\uffff\1\5\16\uffff\1\1\10\5",
13411 "\1\10\1\11",
13412 "\1\12",
13413 "\1\5\27\uffff\3\5\3\uffff\1\5\11\uffff\1\5\1\uffff\1\5\16\uffff"+
13414 "\1\1\10\5",
13415 "\1\10\1\11"
13416 };
13417
13418 static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS);
13419 static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS);
13420 static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS);
13421 static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS);
13422 static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS);
13423 static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS);
13424 static final short[][] DFA38_transition;
13425
13426 static {
13427 int numStates = DFA38_transitionS.length;
13428 DFA38_transition = new short[numStates][];
13429 for (int i=0; i<numStates; i++) {
13430 DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]);
13431 }
13432 }
13433
13434 class DFA38 extends DFA {
13435
13436 public DFA38(BaseRecognizer recognizer) {
13437 this.recognizer = recognizer;
13438 this.decisionNumber = 38;
13439 this.eot = DFA38_eot;
13440 this.eof = DFA38_eof;
13441 this.min = DFA38_min;
13442 this.max = DFA38_max;
13443 this.accept = DFA38_accept;
13444 this.special = DFA38_special;
13445 this.transition = DFA38_transition;
13446 }
13447 public String getDescription() {
13448 return "519:1: type : ( typeDisambiguous | typeName );";
13449 }
13450 }
13451 static final String DFA42_eotS =
13452 "\47\uffff";
13453 static final String DFA42_eofS =
13454 "\47\uffff";
13455 static final String DFA42_minS =
13456 "\1\156\6\0\40\uffff";
13457 static final String DFA42_maxS =
13458 "\1\u00c7\6\0\40\uffff";
13459 static final String DFA42_acceptS =
13460 "\7\uffff\1\1\1\uffff\1\2\35\uffff";
13461 static final String DFA42_specialS =
13462 "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\40\uffff}>";
13463 static final String[] DFA42_transitionS = {
13464 "\7\11\20\uffff\1\11\5\uffff\1\11\20\uffff\13\11\4\uffff\1\11"+
13465 "\2\uffff\1\11\3\uffff\2\11\1\6\2\uffff\1\11\2\uffff\7\11\1\1"+
13466 "\1\2\1\3\1\4\1\5\2\7",
13467 "\1\uffff",
13468 "\1\uffff",
13469 "\1\uffff",
13470 "\1\uffff",
13471 "\1\uffff",
13472 "\1\uffff",
13473 "",
13474 "",
13475 "",
13476 "",
13477 "",
13478 "",
13479 "",
13480 "",
13481 "",
13482 "",
13483 "",
13484 "",
13485 "",
13486 "",
13487 "",
13488 "",
13489 "",
13490 "",
13491 "",
13492 "",
13493 "",
13494 "",
13495 "",
13496 "",
13497 "",
13498 "",
13499 "",
13500 "",
13501 "",
13502 "",
13503 "",
13504 ""
13505 };
13506
13507 static final short[] DFA42_eot = DFA.unpackEncodedString(DFA42_eotS);
13508 static final short[] DFA42_eof = DFA.unpackEncodedString(DFA42_eofS);
13509 static final char[] DFA42_min = DFA.unpackEncodedStringToUnsignedChars(DFA42_minS);
13510 static final char[] DFA42_max = DFA.unpackEncodedStringToUnsignedChars(DFA42_maxS);
13511 static final short[] DFA42_accept = DFA.unpackEncodedString(DFA42_acceptS);
13512 static final short[] DFA42_special = DFA.unpackEncodedString(DFA42_specialS);
13513 static final short[][] DFA42_transition;
13514
13515 static {
13516 int numStates = DFA42_transitionS.length;
13517 DFA42_transition = new short[numStates][];
13518 for (int i=0; i<numStates; i++) {
13519 DFA42_transition[i] = DFA.unpackEncodedString(DFA42_transitionS[i]);
13520 }
13521 }
13522
13523 class DFA42 extends DFA {
13524
13525 public DFA42(BaseRecognizer recognizer) {
13526 this.recognizer = recognizer;
13527 this.decisionNumber = 42;
13528 this.eot = DFA42_eot;
13529 this.eof = DFA42_eof;
13530 this.min = DFA42_min;
13531 this.max = DFA42_max;
13532 this.accept = DFA42_accept;
13533 this.special = DFA42_special;
13534 this.transition = DFA42_transition;
13535 }
13536 public String getDescription() {
13537 return "550:1: quantifiedExpression : ( setQuantOp decls '|' expression -> ^( QUANTIFY setQuantOp decls expression ) | logicalExpression );";
13538 }
13539 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
13540 TokenStream input = (TokenStream)_input;
13541 int _s = s;
13542 switch ( s ) {
13543 case 0 :
13544 int LA42_1 = input.LA(1);
13545
13546
13547 int index42_1 = input.index();
13548 input.rewind();
13549 s = -1;
13550 if ( (synpred63_JFSL()) ) {s = 7;}
13551
13552 else if ( (true) ) {s = 9;}
13553
13554
13555 input.seek(index42_1);
13556 if ( s>=0 ) return s;
13557 break;
13558 case 1 :
13559 int LA42_2 = input.LA(1);
13560
13561
13562 int index42_2 = input.index();
13563 input.rewind();
13564 s = -1;
13565 if ( (synpred63_JFSL()) ) {s = 7;}
13566
13567 else if ( (true) ) {s = 9;}
13568
13569
13570 input.seek(index42_2);
13571 if ( s>=0 ) return s;
13572 break;
13573 case 2 :
13574 int LA42_3 = input.LA(1);
13575
13576
13577 int index42_3 = input.index();
13578 input.rewind();
13579 s = -1;
13580 if ( (synpred63_JFSL()) ) {s = 7;}
13581
13582 else if ( (true) ) {s = 9;}
13583
13584
13585 input.seek(index42_3);
13586 if ( s>=0 ) return s;
13587 break;
13588 case 3 :
13589 int LA42_4 = input.LA(1);
13590
13591
13592 int index42_4 = input.index();
13593 input.rewind();
13594 s = -1;
13595 if ( (synpred63_JFSL()) ) {s = 7;}
13596
13597 else if ( (true) ) {s = 9;}
13598
13599
13600 input.seek(index42_4);
13601 if ( s>=0 ) return s;
13602 break;
13603 case 4 :
13604 int LA42_5 = input.LA(1);
13605
13606
13607 int index42_5 = input.index();
13608 input.rewind();
13609 s = -1;
13610 if ( (synpred63_JFSL()) ) {s = 7;}
13611
13612 else if ( (true) ) {s = 9;}
13613
13614
13615 input.seek(index42_5);
13616 if ( s>=0 ) return s;
13617 break;
13618 case 5 :
13619 int LA42_6 = input.LA(1);
13620
13621
13622 int index42_6 = input.index();
13623 input.rewind();
13624 s = -1;
13625 if ( (synpred63_JFSL()) ) {s = 7;}
13626
13627 else if ( (true) ) {s = 9;}
13628
13629
13630 input.seek(index42_6);
13631 if ( s>=0 ) return s;
13632 break;
13633 }
13634 if (state.backtracking>0) {state.failed=true; return -1;}
13635 NoViableAltException nvae =
13636 new NoViableAltException(getDescription(), 42, _s, input);
13637 error(nvae);
13638 throw nvae;
13639 }
13640 }
13641 static final String DFA69_eotS =
13642 "\37\uffff";
13643 static final String DFA69_eofS =
13644 "\37\uffff";
13645 static final String DFA69_minS =
13646 "\1\156\1\0\1\uffff\1\0\33\uffff";
13647 static final String DFA69_maxS =
13648 "\1\u00c0\1\0\1\uffff\1\0\33\uffff";
13649 static final String DFA69_acceptS =
13650 "\2\uffff\1\2\1\uffff\1\4\30\uffff\1\1\1\3";
13651 static final String DFA69_specialS =
13652 "\1\uffff\1\0\1\uffff\1\1\33\uffff}>";
13653 static final String[] DFA69_transitionS = {
13654 "\7\4\20\uffff\1\4\5\uffff\1\3\20\uffff\13\4\4\uffff\1\2\2\uffff"+
13655 "\1\4\10\uffff\1\4\2\uffff\1\1\6\4",
13656 "\1\uffff",
13657 "",
13658 "\1\uffff",
13659 "",
13660 "",
13661 "",
13662 "",
13663 "",
13664 "",
13665 "",
13666 "",
13667 "",
13668 "",
13669 "",
13670 "",
13671 "",
13672 "",
13673 "",
13674 "",
13675 "",
13676 "",
13677 "",
13678 "",
13679 "",
13680 "",
13681 "",
13682 "",
13683 "",
13684 "",
13685 ""
13686 };
13687
13688 static final short[] DFA69_eot = DFA.unpackEncodedString(DFA69_eotS);
13689 static final short[] DFA69_eof = DFA.unpackEncodedString(DFA69_eofS);
13690 static final char[] DFA69_min = DFA.unpackEncodedStringToUnsignedChars(DFA69_minS);
13691 static final char[] DFA69_max = DFA.unpackEncodedStringToUnsignedChars(DFA69_maxS);
13692 static final short[] DFA69_accept = DFA.unpackEncodedString(DFA69_acceptS);
13693 static final short[] DFA69_special = DFA.unpackEncodedString(DFA69_specialS);
13694 static final short[][] DFA69_transition;
13695
13696 static {
13697 int numStates = DFA69_transitionS.length;
13698 DFA69_transition = new short[numStates][];
13699 for (int i=0; i<numStates; i++) {
13700 DFA69_transition[i] = DFA.unpackEncodedString(DFA69_transitionS[i]);
13701 }
13702 }
13703
13704 class DFA69 extends DFA {
13705
13706 public DFA69(BaseRecognizer recognizer) {
13707 this.recognizer = recognizer;
13708 this.decisionNumber = 69;
13709 this.eot = DFA69_eot;
13710 this.eof = DFA69_eof;
13711 this.min = DFA69_min;
13712 this.max = DFA69_max;
13713 this.accept = DFA69_accept;
13714 this.special = DFA69_special;
13715 this.transition = DFA69_transition;
13716 }
13717 public String getDescription() {
13718 return "707:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression -> ^( UNARY OP_BIT_NOT_OR_TRANSPOSE unaryExpression ) | '!' unaryExpression -> ^( UNARY OP_NOT unaryExpression ) | castExpression | joinExpression );";
13719 }
13720 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
13721 TokenStream input = (TokenStream)_input;
13722 int _s = s;
13723 switch ( s ) {
13724 case 0 :
13725 int LA69_1 = input.LA(1);
13726
13727
13728 int index69_1 = input.index();
13729 input.rewind();
13730 s = -1;
13731 if ( (synpred99_JFSL()) ) {s = 29;}
13732
13733 else if ( (true) ) {s = 4;}
13734
13735
13736 input.seek(index69_1);
13737 if ( s>=0 ) return s;
13738 break;
13739 case 1 :
13740 int LA69_3 = input.LA(1);
13741
13742
13743 int index69_3 = input.index();
13744 input.rewind();
13745 s = -1;
13746 if ( (synpred101_JFSL()) ) {s = 30;}
13747
13748 else if ( (true) ) {s = 4;}
13749
13750
13751 input.seek(index69_3);
13752 if ( s>=0 ) return s;
13753 break;
13754 }
13755 if (state.backtracking>0) {state.failed=true; return -1;}
13756 NoViableAltException nvae =
13757 new NoViableAltException(getDescription(), 69, _s, input);
13758 error(nvae);
13759 throw nvae;
13760 }
13761 }
13762 static final String DFA78_eotS =
13763 "\25\uffff";
13764 static final String DFA78_eofS =
13765 "\4\uffff\1\7\6\uffff\2\7\3\uffff\2\7\1\uffff\1\7\1\uffff";
13766 static final String DFA78_minS =
13767 "\1\156\3\uffff\1\u0081\2\156\1\uffff\2\156\1\uffff\2\u0081\1\0\1"+
13768 "\uffff\2\156\1\u0081\3\156";
13769 static final String DFA78_maxS =
13770 "\1\u00c0\3\uffff\1\u00b9\1\u00c0\1\u00c5\1\uffff\1\u00c7\1\u00b3"+
13771 "\1\uffff\2\u00b9\1\0\1\uffff\1\u00c7\1\u00c5\1\u00b9\1\u00ba\1\u00c5"+
13772 "\1\u00ba";
13773 static final String DFA78_acceptS =
13774 "\1\uffff\1\1\1\2\1\3\3\uffff\1\4\2\uffff\1\6\3\uffff\1\5\6\uffff";
13775 static final String DFA78_specialS =
13776 "\15\uffff\1\0\7\uffff}>";
13777 static final String[] DFA78_transitionS = {
13778 "\1\4\6\2\20\uffff\1\1\5\uffff\1\1\20\uffff\3\2\10\3\7\uffff"+
13779 "\1\1\10\uffff\1\1\2\uffff\7\1",
13780 "",
13781 "",
13782 "",
13783 "\1\5\4\uffff\1\7\1\6\2\7\1\uffff\1\12\1\7\11\uffff\3\7\2\uffff"+
13784 "\1\7\13\uffff\1\10\14\7\1\uffff\2\7\1\11\2\7",
13785 "\1\13\26\uffff\1\7\5\uffff\1\7\17\uffff\1\7\3\uffff\10\7\7"+
13786 "\uffff\1\7\10\uffff\1\7\2\uffff\7\7",
13787 "\1\14\6\7\20\uffff\1\7\1\uffff\1\7\3\uffff\1\7\20\uffff\13"+
13788 "\7\3\uffff\2\7\2\uffff\1\7\3\uffff\3\7\2\uffff\1\7\2\uffff\14"+
13789 "\7",
13790 "",
13791 "\7\7\20\uffff\1\7\5\uffff\1\7\20\uffff\13\7\1\uffff\1\15\2"+
13792 "\uffff\1\7\2\uffff\1\7\3\uffff\3\7\2\uffff\1\7\2\uffff\16\7",
13793 "\1\16\100\uffff\1\7\2\uffff\2\7",
13794 "",
13795 "\1\5\4\uffff\1\7\1\6\2\7\1\uffff\2\7\11\uffff\3\7\2\uffff\1"+
13796 "\7\13\uffff\1\10\14\7\1\uffff\2\7\1\11\2\7",
13797 "\1\7\4\uffff\2\7\1\17\1\20\1\uffff\2\7\11\uffff\1\7\1\uffff"+
13798 "\1\7\2\uffff\1\7\13\uffff\15\7\1\uffff\5\7",
13799 "\1\uffff",
13800 "",
13801 "\1\21\6\7\20\uffff\1\7\5\uffff\1\7\20\uffff\13\7\4\uffff\1"+
13802 "\7\2\uffff\1\7\3\uffff\3\7\2\uffff\1\7\2\uffff\16\7",
13803 "\7\7\14\uffff\1\7\3\uffff\5\7\1\uffff\2\7\11\uffff\3\7\2\uffff"+
13804 "\14\7\1\10\17\7\1\22\16\7",
13805 "\1\7\5\uffff\1\7\1\17\1\23\1\uffff\2\7\13\uffff\1\7\2\uffff"+
13806 "\1\7\13\uffff\1\7\1\uffff\13\7\1\uffff\5\7",
13807 "\1\16\77\uffff\2\7\2\uffff\2\7\6\uffff\1\7",
13808 "\7\7\14\uffff\1\7\3\uffff\5\7\1\uffff\2\7\11\uffff\3\7\2\uffff"+
13809 "\14\7\1\10\17\7\1\24\16\7",
13810 "\1\16\77\uffff\2\7\2\uffff\2\7\6\uffff\1\7"
13811 };
13812
13813 static final short[] DFA78_eot = DFA.unpackEncodedString(DFA78_eotS);
13814 static final short[] DFA78_eof = DFA.unpackEncodedString(DFA78_eofS);
13815 static final char[] DFA78_min = DFA.unpackEncodedStringToUnsignedChars(DFA78_minS);
13816 static final char[] DFA78_max = DFA.unpackEncodedStringToUnsignedChars(DFA78_maxS);
13817 static final short[] DFA78_accept = DFA.unpackEncodedString(DFA78_acceptS);
13818 static final short[] DFA78_special = DFA.unpackEncodedString(DFA78_specialS);
13819 static final short[][] DFA78_transition;
13820
13821 static {
13822 int numStates = DFA78_transitionS.length;
13823 DFA78_transition = new short[numStates][];
13824 for (int i=0; i<numStates; i++) {
13825 DFA78_transition[i] = DFA.unpackEncodedString(DFA78_transitionS[i]);
13826 }
13827 }
13828
13829 class DFA78 extends DFA {
13830
13831 public DFA78(BaseRecognizer recognizer) {
13832 this.recognizer = recognizer;
13833 this.decisionNumber = 78;
13834 this.eot = DFA78_eot;
13835 this.eof = DFA78_eof;
13836 this.min = DFA78_min;
13837 this.max = DFA78_max;
13838 this.accept = DFA78_accept;
13839 this.special = DFA78_special;
13840 this.transition = DFA78_transition;
13841 }
13842 public String getDescription() {
13843 return "746:1: primary : ( common | literal | typeDisambiguous | Identifier ( '.' Identifier )* ( typeParameters2 )? -> ^( AMBIGUOUS ( ^( IDENTIFIER Identifier ) )+ ( ^( TYPE_PARAMETERS typeParameters2 ) )? ) | typeName '@' Identifier -> ^( FIELD typeName ^( IDENTIFIER Identifier ) ) | Identifier arguments -> ^( CALL Identifier arguments ) );";
13844 }
13845 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
13846 TokenStream input = (TokenStream)_input;
13847 int _s = s;
13848 switch ( s ) {
13849 case 0 :
13850 int LA78_13 = input.LA(1);
13851
13852
13853 int index78_13 = input.index();
13854 input.rewind();
13855 s = -1;
13856 if ( (synpred117_JFSL()) ) {s = 3;}
13857
13858 else if ( (synpred120_JFSL()) ) {s = 7;}
13859
13860
13861 input.seek(index78_13);
13862 if ( s>=0 ) return s;
13863 break;
13864 }
13865 if (state.backtracking>0) {state.failed=true; return -1;}
13866 NoViableAltException nvae =
13867 new NoViableAltException(getDescription(), 78, _s, input);
13868 error(nvae);
13869 throw nvae;
13870 }
13871 }
13872 static final String DFA77_eotS =
13873 "\37\uffff";
13874 static final String DFA77_eofS =
13875 "\1\2\36\uffff";
13876 static final String DFA77_minS =
13877 "\1\u0081\1\0\35\uffff";
13878 static final String DFA77_maxS =
13879 "\1\u00b9\1\0\35\uffff";
13880 static final String DFA77_acceptS =
13881 "\2\uffff\1\2\33\uffff\1\1";
13882 static final String DFA77_specialS =
13883 "\1\uffff\1\0\35\uffff}>";
13884 static final String[] DFA77_transitionS = {
13885 "\1\2\4\uffff\1\2\1\1\2\2\2\uffff\1\2\11\uffff\3\2\2\uffff\1"+
13886 "\2\13\uffff\15\2\1\uffff\5\2",
13887 "\1\uffff",
13888 "",
13889 "",
13890 "",
13891 "",
13892 "",
13893 "",
13894 "",
13895 "",
13896 "",
13897 "",
13898 "",
13899 "",
13900 "",
13901 "",
13902 "",
13903 "",
13904 "",
13905 "",
13906 "",
13907 "",
13908 "",
13909 "",
13910 "",
13911 "",
13912 "",
13913 "",
13914 "",
13915 "",
13916 ""
13917 };
13918
13919 static final short[] DFA77_eot = DFA.unpackEncodedString(DFA77_eotS);
13920 static final short[] DFA77_eof = DFA.unpackEncodedString(DFA77_eofS);
13921 static final char[] DFA77_min = DFA.unpackEncodedStringToUnsignedChars(DFA77_minS);
13922 static final char[] DFA77_max = DFA.unpackEncodedStringToUnsignedChars(DFA77_maxS);
13923 static final short[] DFA77_accept = DFA.unpackEncodedString(DFA77_acceptS);
13924 static final short[] DFA77_special = DFA.unpackEncodedString(DFA77_specialS);
13925 static final short[][] DFA77_transition;
13926
13927 static {
13928 int numStates = DFA77_transitionS.length;
13929 DFA77_transition = new short[numStates][];
13930 for (int i=0; i<numStates; i++) {
13931 DFA77_transition[i] = DFA.unpackEncodedString(DFA77_transitionS[i]);
13932 }
13933 }
13934
13935 class DFA77 extends DFA {
13936
13937 public DFA77(BaseRecognizer recognizer) {
13938 this.recognizer = recognizer;
13939 this.decisionNumber = 77;
13940 this.eot = DFA77_eot;
13941 this.eof = DFA77_eof;
13942 this.min = DFA77_min;
13943 this.max = DFA77_max;
13944 this.accept = DFA77_accept;
13945 this.special = DFA77_special;
13946 this.transition = DFA77_transition;
13947 }
13948 public String getDescription() {
13949 return "750:34: ( typeParameters2 )?";
13950 }
13951 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
13952 TokenStream input = (TokenStream)_input;
13953 int _s = s;
13954 switch ( s ) {
13955 case 0 :
13956 int LA77_1 = input.LA(1);
13957
13958
13959 int index77_1 = input.index();
13960 input.rewind();
13961 s = -1;
13962 if ( (synpred119_JFSL()) ) {s = 30;}
13963
13964 else if ( (true) ) {s = 2;}
13965
13966
13967 input.seek(index77_1);
13968 if ( s>=0 ) return s;
13969 break;
13970 }
13971 if (state.backtracking>0) {state.failed=true; return -1;}
13972 NoViableAltException nvae =
13973 new NoViableAltException(getDescription(), 77, _s, input);
13974 error(nvae);
13975 throw nvae;
13976 }
13977 }
13978 static final String DFA79_eotS =
13979 "\15\uffff";
13980 static final String DFA79_eofS =
13981 "\3\uffff\1\11\11\uffff";
13982 static final String DFA79_minS =
13983 "\1\u0081\2\156\1\u0081\1\156\10\uffff";
13984 static final String DFA79_maxS =
13985 "\1\u00a7\1\u00c0\1\u00c7\1\u00b9\1\u00c0\10\uffff";
13986 static final String DFA79_acceptS =
13987 "\5\uffff\1\4\1\3\1\10\1\7\1\2\1\1\1\5\1\6";
13988 static final String DFA79_specialS =
13989 "\15\uffff}>";
13990 static final String[] DFA79_transitionS = {
13991 "\1\1\45\uffff\1\2",
13992 "\1\3\26\uffff\1\5\5\uffff\1\5\17\uffff\1\4\3\uffff\10\6\7\uffff"+
13993 "\1\5\10\uffff\1\5\2\uffff\7\5",
13994 "\7\10\20\uffff\1\10\5\uffff\1\10\20\uffff\13\10\1\uffff\1\7"+
13995 "\2\uffff\1\10\2\uffff\1\10\3\uffff\3\10\2\uffff\1\10\2\uffff"+
13996 "\16\10",
13997 "\1\11\4\uffff\4\11\1\uffff\1\12\1\11\11\uffff\3\11\2\uffff"+
13998 "\1\11\13\uffff\15\11\1\uffff\5\11",
13999 "\1\13\26\uffff\1\14\5\uffff\1\14\42\uffff\1\14\10\uffff\1\14"+
14000 "\2\uffff\7\14",
14001 "",
14002 "",
14003 "",
14004 "",
14005 "",
14006 "",
14007 "",
14008 ""
14009 };
14010
14011 static final short[] DFA79_eot = DFA.unpackEncodedString(DFA79_eotS);
14012 static final short[] DFA79_eof = DFA.unpackEncodedString(DFA79_eofS);
14013 static final char[] DFA79_min = DFA.unpackEncodedStringToUnsignedChars(DFA79_minS);
14014 static final char[] DFA79_max = DFA.unpackEncodedStringToUnsignedChars(DFA79_maxS);
14015 static final short[] DFA79_accept = DFA.unpackEncodedString(DFA79_acceptS);
14016 static final short[] DFA79_special = DFA.unpackEncodedString(DFA79_specialS);
14017 static final short[][] DFA79_transition;
14018
14019 static {
14020 int numStates = DFA79_transitionS.length;
14021 DFA79_transition = new short[numStates][];
14022 for (int i=0; i<numStates; i++) {
14023 DFA79_transition[i] = DFA.unpackEncodedString(DFA79_transitionS[i]);
14024 }
14025 }
14026
14027 class DFA79 extends DFA {
14028
14029 public DFA79(BaseRecognizer recognizer) {
14030 this.recognizer = recognizer;
14031 this.decisionNumber = 79;
14032 this.eot = DFA79_eot;
14033 this.eof = DFA79_eof;
14034 this.min = DFA79_min;
14035 this.max = DFA79_max;
14036 this.accept = DFA79_accept;
14037 this.special = DFA79_special;
14038 this.transition = DFA79_transition;
14039 }
14040 public String getDescription() {
14041 return "756:1: selector : ( '.' Identifier arguments -> ^( CALL Identifier arguments ) | '.' Identifier -> ^( JOIN ^( IDENTIFIER Identifier ) ) | '.' primitiveType -> ^( JOIN primitiveType ) | '.' common -> ^( JOIN common ) | '.' '*' Identifier -> ^( JOIN_REFLEXIVE ^( IDENTIFIER Identifier ) ) | '.' '*' common -> ^( JOIN_REFLEXIVE common ) | '[' expression ']' -> ^( BRACKET expression ) | '[' ']' -> ^( BRACKET ) );";
14042 }
14043 }
14044
14045
14046 public static final BitSet FOLLOW_expression_in_clause720 = new BitSet(new long[]{0x0000000000000000L});
14047 public static final BitSet FOLLOW_EOF_in_clause722 = new BitSet(new long[]{0x0000000000000002L});
14048 public static final BitSet FOLLOW_declaration_in_specField729 = new BitSet(new long[]{0x0000000000000000L});
14049 public static final BitSet FOLLOW_EOF_in_specField731 = new BitSet(new long[]{0x0000000000000002L});
14050 public static final BitSet FOLLOW_frame_in_modifies738 = new BitSet(new long[]{0x0000000000000000L});
14051 public static final BitSet FOLLOW_EOF_in_modifies740 = new BitSet(new long[]{0x0000000000000002L});
14052 public static final BitSet FOLLOW_127_in_compilationUnit760 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14053 public static final BitSet FOLLOW_packageName_in_compilationUnit762 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L});
14054 public static final BitSet FOLLOW_128_in_compilationUnit764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x000000000000001CL});
14055 public static final BitSet FOLLOW_importDeclaration_in_compilationUnit770 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x000000000000001CL});
14056 public static final BitSet FOLLOW_typeDeclaration_in_compilationUnit776 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L});
14057 public static final BitSet FOLLOW_128_in_compilationUnit778 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L});
14058 public static final BitSet FOLLOW_EOF_in_compilationUnit785 = new BitSet(new long[]{0x0000000000000002L});
14059 public static final BitSet FOLLOW_Identifier_in_packageName810 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000002L});
14060 public static final BitSet FOLLOW_129_in_packageName813 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14061 public static final BitSet FOLLOW_Identifier_in_packageName815 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000002L});
14062 public static final BitSet FOLLOW_130_in_importDeclaration843 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14063 public static final BitSet FOLLOW_packageName_in_importDeclaration845 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L});
14064 public static final BitSet FOLLOW_128_in_importDeclaration847 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000004L});
14065 public static final BitSet FOLLOW_131_in_typeDeclaration874 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14066 public static final BitSet FOLLOW_132_in_typeDeclaration878 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14067 public static final BitSet FOLLOW_Identifier_in_typeDeclaration881 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x00000000000000A0L});
14068 public static final BitSet FOLLOW_typeParameters_in_typeDeclaration883 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
14069 public static final BitSet FOLLOW_133_in_typeDeclaration890 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0x000000000000245DL});
14070 public static final BitSet FOLLOW_typeBodyDeclaration_in_typeDeclaration892 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0x000000000000245DL});
14071 public static final BitSet FOLLOW_134_in_typeDeclaration895 = new BitSet(new long[]{0x0000000000000002L});
14072 public static final BitSet FOLLOW_135_in_typeParameters926 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14073 public static final BitSet FOLLOW_Identifier_in_typeParameters928 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000300L});
14074 public static final BitSet FOLLOW_136_in_typeParameters931 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14075 public static final BitSet FOLLOW_Identifier_in_typeParameters933 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000300L});
14076 public static final BitSet FOLLOW_137_in_typeParameters937 = new BitSet(new long[]{0x0000000000000002L});
14077 public static final BitSet FOLLOW_135_in_typeParameters2959 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC80407FF0000820L,0x0000000000000001L});
14078 public static final BitSet FOLLOW_primary_in_typeParameters2961 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000300L});
14079 public static final BitSet FOLLOW_136_in_typeParameters2964 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC80407FF0000820L,0x0000000000000001L});
14080 public static final BitSet FOLLOW_primary_in_typeParameters2966 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000300L});
14081 public static final BitSet FOLLOW_137_in_typeParameters2970 = new BitSet(new long[]{0x0000000000000002L});
14082 public static final BitSet FOLLOW_128_in_typeBodyDeclaration988 = new BitSet(new long[]{0x0000000000000002L});
14083 public static final BitSet FOLLOW_typeDeclaration_in_typeBodyDeclaration995 = new BitSet(new long[]{0x0000000000000002L});
14084 public static final BitSet FOLLOW_138_in_typeBodyDeclaration1002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14085 public static final BitSet FOLLOW_139_in_typeBodyDeclaration1004 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14086 public static final BitSet FOLLOW_expression_in_typeBodyDeclaration1006 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14087 public static final BitSet FOLLOW_140_in_typeBodyDeclaration1008 = new BitSet(new long[]{0x0000000000000002L});
14088 public static final BitSet FOLLOW_141_in_typeBodyDeclaration1022 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14089 public static final BitSet FOLLOW_139_in_typeBodyDeclaration1024 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0x0000000000300000L});
14090 public static final BitSet FOLLOW_declaration_in_typeBodyDeclaration1026 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14091 public static final BitSet FOLLOW_140_in_typeBodyDeclaration1028 = new BitSet(new long[]{0x0000000000000002L});
14092 public static final BitSet FOLLOW_Identifier_in_typeBodyDeclaration1042 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14093 public static final BitSet FOLLOW_139_in_typeBodyDeclaration1044 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0x0000007F80001000L});
14094 public static final BitSet FOLLOW_methodParameters_in_typeBodyDeclaration1046 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14095 public static final BitSet FOLLOW_140_in_typeBodyDeclaration1048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
14096 public static final BitSet FOLLOW_133_in_typeBodyDeclaration1050 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x00000000000FC041L});
14097 public static final BitSet FOLLOW_specCase_in_typeBodyDeclaration1052 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000041L});
14098 public static final BitSet FOLLOW_128_in_typeBodyDeclaration1055 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x00000000000FC041L});
14099 public static final BitSet FOLLOW_specCase_in_typeBodyDeclaration1057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000041L});
14100 public static final BitSet FOLLOW_128_in_typeBodyDeclaration1062 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000041L});
14101 public static final BitSet FOLLOW_134_in_typeBodyDeclaration1066 = new BitSet(new long[]{0x0000000000000002L});
14102 public static final BitSet FOLLOW_type_in_methodParameters1104 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14103 public static final BitSet FOLLOW_Identifier_in_methodParameters1106 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14104 public static final BitSet FOLLOW_136_in_methodParameters1109 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0x0000007F80000000L});
14105 public static final BitSet FOLLOW_type_in_methodParameters1111 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14106 public static final BitSet FOLLOW_Identifier_in_methodParameters1113 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14107 public static final BitSet FOLLOW_142_in_specCase1149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14108 public static final BitSet FOLLOW_139_in_specCase1151 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14109 public static final BitSet FOLLOW_expression_in_specCase1157 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14110 public static final BitSet FOLLOW_140_in_specCase1159 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000038000L});
14111 public static final BitSet FOLLOW_143_in_specCase1170 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14112 public static final BitSet FOLLOW_139_in_specCase1172 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14113 public static final BitSet FOLLOW_expression_in_specCase1178 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14114 public static final BitSet FOLLOW_140_in_specCase1180 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000020000L});
14115 public static final BitSet FOLLOW_144_in_specCase1185 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14116 public static final BitSet FOLLOW_139_in_specCase1187 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14117 public static final BitSet FOLLOW_expression_in_specCase1193 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14118 public static final BitSet FOLLOW_140_in_specCase1195 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000020000L});
14119 public static final BitSet FOLLOW_145_in_specCase1206 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14120 public static final BitSet FOLLOW_139_in_specCase1208 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0xFC80400000001820L,0x0000000000000001L});
14121 public static final BitSet FOLLOW_frame_in_specCase1214 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14122 public static final BitSet FOLLOW_140_in_specCase1216 = new BitSet(new long[]{0x0000000000000002L});
14123 public static final BitSet FOLLOW_146_in_specCase1267 = new BitSet(new long[]{0x0000000000000002L});
14124 public static final BitSet FOLLOW_147_in_specCase1282 = new BitSet(new long[]{0x0000000000000002L});
14125 public static final BitSet FOLLOW_148_in_declaration1306 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14126 public static final BitSet FOLLOW_149_in_declaration1310 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14127 public static final BitSet FOLLOW_Identifier_in_declaration1314 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
14128 public static final BitSet FOLLOW_150_in_declaration1316 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF6000820L,0x00000000000000FFL});
14129 public static final BitSet FOLLOW_declarationMult_in_declaration1318 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14130 public static final BitSet FOLLOW_additiveExpression_in_declaration1320 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000800000L});
14131 public static final BitSet FOLLOW_151_in_declaration1322 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0xFC80400001000820L,0x0000000000000001L});
14132 public static final BitSet FOLLOW_frame_in_declaration1324 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000001000000L});
14133 public static final BitSet FOLLOW_152_in_declaration1327 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14134 public static final BitSet FOLLOW_expression_in_declaration1329 = new BitSet(new long[]{0x0000000000000002L});
14135 public static final BitSet FOLLOW_148_in_declaration1361 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14136 public static final BitSet FOLLOW_149_in_declaration1365 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14137 public static final BitSet FOLLOW_Identifier_in_declaration1369 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
14138 public static final BitSet FOLLOW_150_in_declaration1371 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF6000820L,0x00000000000000FFL});
14139 public static final BitSet FOLLOW_declarationMult_in_declaration1373 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14140 public static final BitSet FOLLOW_additiveExpression_in_declaration1375 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000001000000L});
14141 public static final BitSet FOLLOW_152_in_declaration1378 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14142 public static final BitSet FOLLOW_expression_in_declaration1380 = new BitSet(new long[]{0x0000000000000002L});
14143 public static final BitSet FOLLOW_setDeclOp_in_declarationMult1420 = new BitSet(new long[]{0x0000000000000002L});
14144 public static final BitSet FOLLOW_153_in_declarationMult1426 = new BitSet(new long[]{0x0000000000000002L});
14145 public static final BitSet FOLLOW_154_in_declarationMult1436 = new BitSet(new long[]{0x0000000000000002L});
14146 public static final BitSet FOLLOW_storeRef_in_frame1467 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14147 public static final BitSet FOLLOW_136_in_frame1470 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0xFC80400000000920L,0x0000000000000001L});
14148 public static final BitSet FOLLOW_storeRef_in_frame1472 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14149 public static final BitSet FOLLOW_storePrimary_in_storeRef1497 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000008000000002L});
14150 public static final BitSet FOLLOW_storeSelectors_in_storeRef1499 = new BitSet(new long[]{0x0000000000000002L});
14151 public static final BitSet FOLLOW_Identifier_in_storePrimary1532 = new BitSet(new long[]{0x0000000000000002L});
14152 public static final BitSet FOLLOW_common_in_storePrimary1547 = new BitSet(new long[]{0x0000000000000002L});
14153 public static final BitSet FOLLOW_selector_in_storeSelectors1562 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000008000000002L});
14154 public static final BitSet FOLLOW_storeWildCard_in_storeSelectors1565 = new BitSet(new long[]{0x0000000000000002L});
14155 public static final BitSet FOLLOW_selector_in_storeSelectors1572 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000008000000002L});
14156 public static final BitSet FOLLOW_129_in_storeWildCard1593 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000008000000L});
14157 public static final BitSet FOLLOW_155_in_storeWildCard1595 = new BitSet(new long[]{0x0000000000000002L});
14158 public static final BitSet FOLLOW_156_in_keywordLiteral1616 = new BitSet(new long[]{0x0000000000000002L});
14159 public static final BitSet FOLLOW_157_in_keywordLiteral1628 = new BitSet(new long[]{0x0000000000000002L});
14160 public static final BitSet FOLLOW_158_in_keywordLiteral1639 = new BitSet(new long[]{0x0000000000000002L});
14161 public static final BitSet FOLLOW_integerLiteral_in_literal1663 = new BitSet(new long[]{0x0000000000000002L});
14162 public static final BitSet FOLLOW_FloatingPointLiteral_in_literal1669 = new BitSet(new long[]{0x0000000000000002L});
14163 public static final BitSet FOLLOW_CharacterLiteral_in_literal1675 = new BitSet(new long[]{0x0000000000000002L});
14164 public static final BitSet FOLLOW_StringLiteral_in_literal1681 = new BitSet(new long[]{0x0000000000000002L});
14165 public static final BitSet FOLLOW_keywordLiteral_in_literal1687 = new BitSet(new long[]{0x0000000000000002L});
14166 public static final BitSet FOLLOW_set_in_integerLiteral0 = new BitSet(new long[]{0x0000000000000002L});
14167 public static final BitSet FOLLOW_159_in_primitiveType1741 = new BitSet(new long[]{0x0000000000000002L});
14168 public static final BitSet FOLLOW_160_in_primitiveType1750 = new BitSet(new long[]{0x0000000000000002L});
14169 public static final BitSet FOLLOW_161_in_primitiveType1760 = new BitSet(new long[]{0x0000000000000002L});
14170 public static final BitSet FOLLOW_162_in_primitiveType1772 = new BitSet(new long[]{0x0000000000000002L});
14171 public static final BitSet FOLLOW_163_in_primitiveType1783 = new BitSet(new long[]{0x0000000000000002L});
14172 public static final BitSet FOLLOW_164_in_primitiveType1794 = new BitSet(new long[]{0x0000000000000002L});
14173 public static final BitSet FOLLOW_165_in_primitiveType1804 = new BitSet(new long[]{0x0000000000000002L});
14174 public static final BitSet FOLLOW_166_in_primitiveType1815 = new BitSet(new long[]{0x0000000000000002L});
14175 public static final BitSet FOLLOW_Identifier_in_typeName1832 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000082L});
14176 public static final BitSet FOLLOW_129_in_typeName1835 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14177 public static final BitSet FOLLOW_Identifier_in_typeName1837 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000082L});
14178 public static final BitSet FOLLOW_typeParameters_in_typeName1841 = new BitSet(new long[]{0x0000000000000002L});
14179 public static final BitSet FOLLOW_primitiveType_in_typeDisambiguous1878 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000008000000000L});
14180 public static final BitSet FOLLOW_167_in_typeDisambiguous1887 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000010000000000L});
14181 public static final BitSet FOLLOW_168_in_typeDisambiguous1889 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000008000000000L});
14182 public static final BitSet FOLLOW_typeName_in_typeDisambiguous1908 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000008000000000L});
14183 public static final BitSet FOLLOW_167_in_typeDisambiguous1917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000010000000000L});
14184 public static final BitSet FOLLOW_168_in_typeDisambiguous1919 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000008000000000L});
14185 public static final BitSet FOLLOW_typeDisambiguous_in_type1944 = new BitSet(new long[]{0x0000000000000002L});
14186 public static final BitSet FOLLOW_typeName_in_type1950 = new BitSet(new long[]{0x0000000000000002L});
14187 public static final BitSet FOLLOW_139_in_parExpression1984 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14188 public static final BitSet FOLLOW_expression_in_parExpression1987 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14189 public static final BitSet FOLLOW_140_in_parExpression1989 = new BitSet(new long[]{0x0000000000000002L});
14190 public static final BitSet FOLLOW_expression_in_expressionList2019 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14191 public static final BitSet FOLLOW_136_in_expressionList2022 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14192 public static final BitSet FOLLOW_expression_in_expressionList2025 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14193 public static final BitSet FOLLOW_139_in_arguments2046 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0001820L,0x00000000000000FFL});
14194 public static final BitSet FOLLOW_expressionList_in_arguments2048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14195 public static final BitSet FOLLOW_140_in_arguments2051 = new BitSet(new long[]{0x0000000000000002L});
14196 public static final BitSet FOLLOW_conditionalExpression_in_expression2075 = new BitSet(new long[]{0x0000000000000002L});
14197 public static final BitSet FOLLOW_quantifiedExpression_in_conditionalExpression2092 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000020000000000L});
14198 public static final BitSet FOLLOW_169_in_conditionalExpression2105 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14199 public static final BitSet FOLLOW_expression_in_conditionalExpression2107 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
14200 public static final BitSet FOLLOW_150_in_conditionalExpression2109 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14201 public static final BitSet FOLLOW_expression_in_conditionalExpression2111 = new BitSet(new long[]{0x0000000000000002L});
14202 public static final BitSet FOLLOW_setQuantOp_in_quantifiedExpression2147 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14203 public static final BitSet FOLLOW_decls_in_quantifiedExpression2149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
14204 public static final BitSet FOLLOW_152_in_quantifiedExpression2151 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14205 public static final BitSet FOLLOW_expression_in_quantifiedExpression2153 = new BitSet(new long[]{0x0000000000000002L});
14206 public static final BitSet FOLLOW_logicalExpression_in_quantifiedExpression2171 = new BitSet(new long[]{0x0000000000000002L});
14207 public static final BitSet FOLLOW_conditionalOrExpression_in_logicalExpression2187 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000040000000080L});
14208 public static final BitSet FOLLOW_logicalOp_in_logicalExpression2200 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14209 public static final BitSet FOLLOW_conditionalOrExpression_in_logicalExpression2202 = new BitSet(new long[]{0x0000000000000002L});
14210 public static final BitSet FOLLOW_135_in_logicalOp2239 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000040000000000L});
14211 public static final BitSet FOLLOW_170_in_logicalOp2241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
14212 public static final BitSet FOLLOW_137_in_logicalOp2243 = new BitSet(new long[]{0x0000000000000002L});
14213 public static final BitSet FOLLOW_135_in_logicalOp2251 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000080000000000L});
14214 public static final BitSet FOLLOW_171_in_logicalOp2253 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
14215 public static final BitSet FOLLOW_137_in_logicalOp2255 = new BitSet(new long[]{0x0000000000000002L});
14216 public static final BitSet FOLLOW_170_in_logicalOp2263 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
14217 public static final BitSet FOLLOW_137_in_logicalOp2265 = new BitSet(new long[]{0x0000000000000002L});
14218 public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression2285 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000100000000000L});
14219 public static final BitSet FOLLOW_172_in_conditionalOrExpression2300 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14220 public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression2304 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000100000000000L});
14221 public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2341 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000200000000000L});
14222 public static final BitSet FOLLOW_173_in_conditionalAndExpression2356 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14223 public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2360 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000200000000000L});
14224 public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2402 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000001000000L});
14225 public static final BitSet FOLLOW_152_in_inclusiveOrExpression2417 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14226 public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2421 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000001000000L});
14227 public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression2458 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000400000000000L});
14228 public static final BitSet FOLLOW_174_in_exclusiveOrExpression2473 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14229 public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression2477 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000400000000000L});
14230 public static final BitSet FOLLOW_equalityExpression_in_andExpression2516 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000800000000000L});
14231 public static final BitSet FOLLOW_bitAndOp_in_andExpression2531 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14232 public static final BitSet FOLLOW_equalityExpression_in_andExpression2535 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000800000000000L});
14233 public static final BitSet FOLLOW_175_in_bitAndOp2572 = new BitSet(new long[]{0x0000000000000002L});
14234 public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression2594 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x00000C0000000000L});
14235 public static final BitSet FOLLOW_equalityOp_in_equalityExpression2611 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14236 public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression2615 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x00000C0000000000L});
14237 public static final BitSet FOLLOW_170_in_equalityOp2656 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000040000000000L});
14238 public static final BitSet FOLLOW_170_in_equalityOp2658 = new BitSet(new long[]{0x0000000000000002L});
14239 public static final BitSet FOLLOW_171_in_equalityOp2666 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000040000000000L});
14240 public static final BitSet FOLLOW_170_in_equalityOp2668 = new BitSet(new long[]{0x0000000000000002L});
14241 public static final BitSet FOLLOW_170_in_equalityOp2676 = new BitSet(new long[]{0x0000000000000002L});
14242 public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression2698 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0001000000000000L});
14243 public static final BitSet FOLLOW_176_in_instanceOfExpression2713 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0x0000007F80000000L});
14244 public static final BitSet FOLLOW_type_in_instanceOfExpression2717 = new BitSet(new long[]{0x0000000000000002L});
14245 public static final BitSet FOLLOW_setUnaryExpression_in_relationalExpression2756 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0002080000000280L});
14246 public static final BitSet FOLLOW_relationalOp_in_relationalExpression2773 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14247 public static final BitSet FOLLOW_setUnaryExpression_in_relationalExpression2777 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0002080000000280L});
14248 public static final BitSet FOLLOW_177_in_inOp2816 = new BitSet(new long[]{0x0000000000000002L});
14249 public static final BitSet FOLLOW_135_in_relationalOp2835 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000040000000000L});
14250 public static final BitSet FOLLOW_170_in_relationalOp2837 = new BitSet(new long[]{0x0000000000000002L});
14251 public static final BitSet FOLLOW_137_in_relationalOp2845 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000040000000000L});
14252 public static final BitSet FOLLOW_170_in_relationalOp2847 = new BitSet(new long[]{0x0000000000000002L});
14253 public static final BitSet FOLLOW_135_in_relationalOp2855 = new BitSet(new long[]{0x0000000000000002L});
14254 public static final BitSet FOLLOW_137_in_relationalOp2863 = new BitSet(new long[]{0x0000000000000002L});
14255 public static final BitSet FOLLOW_inOp_in_relationalOp2871 = new BitSet(new long[]{0x0000000000000002L});
14256 public static final BitSet FOLLOW_171_in_relationalOp2875 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0002000000000000L});
14257 public static final BitSet FOLLOW_177_in_relationalOp2877 = new BitSet(new long[]{0x0000000000000002L});
14258 public static final BitSet FOLLOW_setUnaryOp_in_setUnaryExpression2896 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14259 public static final BitSet FOLLOW_joinExpression_in_setUnaryExpression2898 = new BitSet(new long[]{0x0000000000000002L});
14260 public static final BitSet FOLLOW_shiftExpression_in_setUnaryExpression2914 = new BitSet(new long[]{0x0000000000000002L});
14261 public static final BitSet FOLLOW_additiveExpression_in_shiftExpression2932 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000280L});
14262 public static final BitSet FOLLOW_shiftOp_in_shiftExpression2949 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14263 public static final BitSet FOLLOW_additiveExpression_in_shiftExpression2953 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000280L});
14264 public static final BitSet FOLLOW_135_in_shiftOp2990 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000080L});
14265 public static final BitSet FOLLOW_135_in_shiftOp2992 = new BitSet(new long[]{0x0000000000000002L});
14266 public static final BitSet FOLLOW_137_in_shiftOp3000 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
14267 public static final BitSet FOLLOW_137_in_shiftOp3002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
14268 public static final BitSet FOLLOW_137_in_shiftOp3004 = new BitSet(new long[]{0x0000000000000002L});
14269 public static final BitSet FOLLOW_137_in_shiftOp3012 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
14270 public static final BitSet FOLLOW_137_in_shiftOp3014 = new BitSet(new long[]{0x0000000000000002L});
14271 public static final BitSet FOLLOW_sizeExpression_in_additiveExpression3034 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x000C000000000000L});
14272 public static final BitSet FOLLOW_additiveOp_in_additiveExpression3052 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14273 public static final BitSet FOLLOW_sizeExpression_in_additiveExpression3056 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x000C000000000000L});
14274 public static final BitSet FOLLOW_178_in_additiveOp3097 = new BitSet(new long[]{0x0000000000000002L});
14275 public static final BitSet FOLLOW_179_in_additiveOp3110 = new BitSet(new long[]{0x0000000000000002L});
14276 public static final BitSet FOLLOW_180_in_sizeExpression3130 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14277 public static final BitSet FOLLOW_joinExpression_in_sizeExpression3132 = new BitSet(new long[]{0x0000000000000002L});
14278 public static final BitSet FOLLOW_multiplicativeExpression_in_sizeExpression3148 = new BitSet(new long[]{0x0000000000000002L});
14279 public static final BitSet FOLLOW_setAdditiveExpression_in_multiplicativeExpression3166 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0060000008000000L});
14280 public static final BitSet FOLLOW_multOp_in_multiplicativeExpression3183 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14281 public static final BitSet FOLLOW_setAdditiveExpression_in_multiplicativeExpression3187 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0060000008000000L});
14282 public static final BitSet FOLLOW_155_in_multOp3217 = new BitSet(new long[]{0x0000000000000002L});
14283 public static final BitSet FOLLOW_181_in_multOp3230 = new BitSet(new long[]{0x0000000000000002L});
14284 public static final BitSet FOLLOW_182_in_multOp3243 = new BitSet(new long[]{0x0000000000000002L});
14285 public static final BitSet FOLLOW_overrideExpression_in_setAdditiveExpression3266 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L});
14286 public static final BitSet FOLLOW_setAdditiveOp_in_setAdditiveExpression3286 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14287 public static final BitSet FOLLOW_overrideExpression_in_setAdditiveExpression3290 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L});
14288 public static final BitSet FOLLOW_183_in_setAdditiveOp3332 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0004000000000000L});
14289 public static final BitSet FOLLOW_178_in_setAdditiveOp3334 = new BitSet(new long[]{0x0000000000000002L});
14290 public static final BitSet FOLLOW_183_in_setAdditiveOp3345 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L});
14291 public static final BitSet FOLLOW_179_in_setAdditiveOp3347 = new BitSet(new long[]{0x0000000000000002L});
14292 public static final BitSet FOLLOW_intersectionExpression_in_overrideExpression3370 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0100000000000000L});
14293 public static final BitSet FOLLOW_184_in_overrideExpression3385 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14294 public static final BitSet FOLLOW_intersectionExpression_in_overrideExpression3389 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0100000000000000L});
14295 public static final BitSet FOLLOW_composeExpression_in_intersectionExpression3433 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L});
14296 public static final BitSet FOLLOW_183_in_intersectionExpression3448 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L});
14297 public static final BitSet FOLLOW_175_in_intersectionExpression3450 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14298 public static final BitSet FOLLOW_composeExpression_in_intersectionExpression3454 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L});
14299 public static final BitSet FOLLOW_unaryExpression_in_composeExpression3494 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0200000000000000L});
14300 public static final BitSet FOLLOW_185_in_composeExpression3509 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14301 public static final BitSet FOLLOW_unaryExpression_in_composeExpression3513 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0200000000000000L});
14302 public static final BitSet FOLLOW_178_in_unaryExpression3556 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14303 public static final BitSet FOLLOW_unaryExpression_in_unaryExpression3558 = new BitSet(new long[]{0x0000000000000002L});
14304 public static final BitSet FOLLOW_179_in_unaryExpression3574 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14305 public static final BitSet FOLLOW_unaryExpression_in_unaryExpression3576 = new BitSet(new long[]{0x0000000000000002L});
14306 public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression3592 = new BitSet(new long[]{0x0000000000000002L});
14307 public static final BitSet FOLLOW_186_in_unaryExpressionNotPlusMinus3605 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14308 public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus3607 = new BitSet(new long[]{0x0000000000000002L});
14309 public static final BitSet FOLLOW_171_in_unaryExpressionNotPlusMinus3623 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14310 public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus3625 = new BitSet(new long[]{0x0000000000000002L});
14311 public static final BitSet FOLLOW_castExpression_in_unaryExpressionNotPlusMinus3645 = new BitSet(new long[]{0x0000000000000002L});
14312 public static final BitSet FOLLOW_joinExpression_in_unaryExpressionNotPlusMinus3651 = new BitSet(new long[]{0x0000000000000002L});
14313 public static final BitSet FOLLOW_139_in_castExpression3671 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000007F80000000L});
14314 public static final BitSet FOLLOW_primitiveType_in_castExpression3673 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14315 public static final BitSet FOLLOW_140_in_castExpression3675 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14316 public static final BitSet FOLLOW_unaryExpression_in_castExpression3677 = new BitSet(new long[]{0x0000000000000002L});
14317 public static final BitSet FOLLOW_Identifier_in_decls3703 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0002000000400000L});
14318 public static final BitSet FOLLOW_inOp_in_decls3706 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF6000820L,0x00000000000000FFL});
14319 public static final BitSet FOLLOW_150_in_decls3710 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF6000820L,0x00000000000000FFL});
14320 public static final BitSet FOLLOW_declarationMult_in_decls3713 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14321 public static final BitSet FOLLOW_additiveExpression_in_decls3715 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14322 public static final BitSet FOLLOW_136_in_decls3719 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14323 public static final BitSet FOLLOW_Identifier_in_decls3722 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0002000000400000L});
14324 public static final BitSet FOLLOW_inOp_in_decls3725 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14325 public static final BitSet FOLLOW_150_in_decls3729 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14326 public static final BitSet FOLLOW_additiveExpression_in_decls3732 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000100L});
14327 public static final BitSet FOLLOW_specUnaryOp_in_relationalUnaryExpression3773 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14328 public static final BitSet FOLLOW_parExpression_in_relationalUnaryExpression3775 = new BitSet(new long[]{0x0000000000000002L});
14329 public static final BitSet FOLLOW_specUnaryOp_in_relationalUnaryExpression3791 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14330 public static final BitSet FOLLOW_Identifier_in_relationalUnaryExpression3793 = new BitSet(new long[]{0x0000000000000002L});
14331 public static final BitSet FOLLOW_primary_in_joinExpression3826 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000008000000002L});
14332 public static final BitSet FOLLOW_selector_in_joinExpression3828 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000008000000002L});
14333 public static final BitSet FOLLOW_parExpression_in_common3858 = new BitSet(new long[]{0x0000000000000002L});
14334 public static final BitSet FOLLOW_187_in_common3864 = new BitSet(new long[]{0x0000000000000002L});
14335 public static final BitSet FOLLOW_188_in_common3874 = new BitSet(new long[]{0x0000000000000002L});
14336 public static final BitSet FOLLOW_189_in_common3884 = new BitSet(new long[]{0x0000000000000002L});
14337 public static final BitSet FOLLOW_190_in_common3895 = new BitSet(new long[]{0x0000000000000002L});
14338 public static final BitSet FOLLOW_191_in_common3905 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14339 public static final BitSet FOLLOW_139_in_common3907 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14340 public static final BitSet FOLLOW_expression_in_common3909 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14341 public static final BitSet FOLLOW_140_in_common3911 = new BitSet(new long[]{0x0000000000000002L});
14342 public static final BitSet FOLLOW_192_in_common3925 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14343 public static final BitSet FOLLOW_139_in_common3927 = new BitSet(new long[]{0x0000000000000000L,0x001C000000000000L});
14344 public static final BitSet FOLLOW_integerLiteral_in_common3929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
14345 public static final BitSet FOLLOW_140_in_common3931 = new BitSet(new long[]{0x0000000000000002L});
14346 public static final BitSet FOLLOW_relationalUnaryExpression_in_common3945 = new BitSet(new long[]{0x0000000000000002L});
14347 public static final BitSet FOLLOW_133_in_common3951 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14348 public static final BitSet FOLLOW_decls_in_common3953 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
14349 public static final BitSet FOLLOW_152_in_common3955 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14350 public static final BitSet FOLLOW_expression_in_common3957 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000040L});
14351 public static final BitSet FOLLOW_134_in_common3959 = new BitSet(new long[]{0x0000000000000002L});
14352 public static final BitSet FOLLOW_common_in_primary3984 = new BitSet(new long[]{0x0000000000000002L});
14353 public static final BitSet FOLLOW_literal_in_primary3990 = new BitSet(new long[]{0x0000000000000002L});
14354 public static final BitSet FOLLOW_typeDisambiguous_in_primary3996 = new BitSet(new long[]{0x0000000000000002L});
14355 public static final BitSet FOLLOW_Identifier_in_primary4002 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000082L});
14356 public static final BitSet FOLLOW_129_in_primary4005 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14357 public static final BitSet FOLLOW_Identifier_in_primary4007 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000082L});
14358 public static final BitSet FOLLOW_typeParameters2_in_primary4011 = new BitSet(new long[]{0x0000000000000002L});
14359 public static final BitSet FOLLOW_typeName_in_primary4038 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L});
14360 public static final BitSet FOLLOW_183_in_primary4040 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14361 public static final BitSet FOLLOW_Identifier_in_primary4042 = new BitSet(new long[]{0x0000000000000002L});
14362 public static final BitSet FOLLOW_Identifier_in_primary4062 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14363 public static final BitSet FOLLOW_arguments_in_primary4064 = new BitSet(new long[]{0x0000000000000002L});
14364 public static final BitSet FOLLOW_129_in_selector4090 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14365 public static final BitSet FOLLOW_Identifier_in_selector4092 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L});
14366 public static final BitSet FOLLOW_arguments_in_selector4094 = new BitSet(new long[]{0x0000000000000002L});
14367 public static final BitSet FOLLOW_129_in_selector4110 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14368 public static final BitSet FOLLOW_Identifier_in_selector4112 = new BitSet(new long[]{0x0000000000000002L});
14369 public static final BitSet FOLLOW_129_in_selector4130 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000007F80000000L});
14370 public static final BitSet FOLLOW_primitiveType_in_selector4132 = new BitSet(new long[]{0x0000000000000002L});
14371 public static final BitSet FOLLOW_129_in_selector4146 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0xFC80400000000820L,0x0000000000000001L});
14372 public static final BitSet FOLLOW_common_in_selector4148 = new BitSet(new long[]{0x0000000000000002L});
14373 public static final BitSet FOLLOW_129_in_selector4162 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000008000000L});
14374 public static final BitSet FOLLOW_155_in_selector4164 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14375 public static final BitSet FOLLOW_Identifier_in_selector4166 = new BitSet(new long[]{0x0000000000000002L});
14376 public static final BitSet FOLLOW_129_in_selector4184 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000008000000L});
14377 public static final BitSet FOLLOW_155_in_selector4186 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0xFC80400000000820L,0x0000000000000001L});
14378 public static final BitSet FOLLOW_common_in_selector4188 = new BitSet(new long[]{0x0000000000000002L});
14379 public static final BitSet FOLLOW_167_in_selector4202 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14380 public static final BitSet FOLLOW_expression_in_selector4203 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000010000000000L});
14381 public static final BitSet FOLLOW_168_in_selector4205 = new BitSet(new long[]{0x0000000000000002L});
14382 public static final BitSet FOLLOW_167_in_selector4221 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000010000000000L});
14383 public static final BitSet FOLLOW_168_in_selector4223 = new BitSet(new long[]{0x0000000000000002L});
14384 public static final BitSet FOLLOW_183_in_specUnaryOp4245 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000400000000000L});
14385 public static final BitSet FOLLOW_174_in_specUnaryOp4247 = new BitSet(new long[]{0x0000000000000002L});
14386 public static final BitSet FOLLOW_174_in_specUnaryOp4251 = new BitSet(new long[]{0x0000000000000002L});
14387 public static final BitSet FOLLOW_183_in_specUnaryOp4263 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
14388 public static final BitSet FOLLOW_186_in_specUnaryOp4265 = new BitSet(new long[]{0x0000000000000002L});
14389 public static final BitSet FOLLOW_186_in_specUnaryOp4269 = new BitSet(new long[]{0x0000000000000002L});
14390 public static final BitSet FOLLOW_193_in_setDeclOp4294 = new BitSet(new long[]{0x0000000000000002L});
14391 public static final BitSet FOLLOW_194_in_setDeclOp4306 = new BitSet(new long[]{0x0000000000000002L});
14392 public static final BitSet FOLLOW_195_in_setDeclOp4318 = new BitSet(new long[]{0x0000000000000002L});
14393 public static final BitSet FOLLOW_setDeclOp_in_setUnaryOp4341 = new BitSet(new long[]{0x0000000000000002L});
14394 public static final BitSet FOLLOW_196_in_setUnaryOp4347 = new BitSet(new long[]{0x0000000000000002L});
14395 public static final BitSet FOLLOW_197_in_setUnaryOp4358 = new BitSet(new long[]{0x0000000000000002L});
14396 public static final BitSet FOLLOW_setUnaryOp_in_setQuantOp4380 = new BitSet(new long[]{0x0000000000000002L});
14397 public static final BitSet FOLLOW_180_in_setQuantOp4386 = new BitSet(new long[]{0x0000000000000002L});
14398 public static final BitSet FOLLOW_198_in_setQuantOp4397 = new BitSet(new long[]{0x0000000000000002L});
14399 public static final BitSet FOLLOW_199_in_setQuantOp4410 = new BitSet(new long[]{0x0000000000000002L});
14400 public static final BitSet FOLLOW_128_in_synpred13_JFSL1055 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x00000000000FC000L});
14401 public static final BitSet FOLLOW_specCase_in_synpred13_JFSL1057 = new BitSet(new long[]{0x0000000000000002L});
14402 public static final BitSet FOLLOW_set_in_synpred26_JFSL1305 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14403 public static final BitSet FOLLOW_Identifier_in_synpred26_JFSL1314 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
14404 public static final BitSet FOLLOW_150_in_synpred26_JFSL1316 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF6000820L,0x00000000000000FFL});
14405 public static final BitSet FOLLOW_declarationMult_in_synpred26_JFSL1318 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14406 public static final BitSet FOLLOW_additiveExpression_in_synpred26_JFSL1320 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000800000L});
14407 public static final BitSet FOLLOW_151_in_synpred26_JFSL1322 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L,0xFC80400001000820L,0x0000000000000001L});
14408 public static final BitSet FOLLOW_frame_in_synpred26_JFSL1324 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000001000000L});
14409 public static final BitSet FOLLOW_152_in_synpred26_JFSL1327 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14410 public static final BitSet FOLLOW_expression_in_synpred26_JFSL1329 = new BitSet(new long[]{0x0000000000000002L});
14411 public static final BitSet FOLLOW_selector_in_synpred37_JFSL1562 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000008000000002L});
14412 public static final BitSet FOLLOW_storeWildCard_in_synpred37_JFSL1565 = new BitSet(new long[]{0x0000000000000002L});
14413 public static final BitSet FOLLOW_167_in_synpred56_JFSL1887 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000010000000000L});
14414 public static final BitSet FOLLOW_168_in_synpred56_JFSL1889 = new BitSet(new long[]{0x0000000000000002L});
14415 public static final BitSet FOLLOW_167_in_synpred58_JFSL1917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000010000000000L});
14416 public static final BitSet FOLLOW_168_in_synpred58_JFSL1919 = new BitSet(new long[]{0x0000000000000002L});
14417 public static final BitSet FOLLOW_169_in_synpred62_JFSL2105 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14418 public static final BitSet FOLLOW_expression_in_synpred62_JFSL2107 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
14419 public static final BitSet FOLLOW_150_in_synpred62_JFSL2109 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14420 public static final BitSet FOLLOW_expression_in_synpred62_JFSL2111 = new BitSet(new long[]{0x0000000000000002L});
14421 public static final BitSet FOLLOW_setQuantOp_in_synpred63_JFSL2147 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14422 public static final BitSet FOLLOW_decls_in_synpred63_JFSL2149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
14423 public static final BitSet FOLLOW_152_in_synpred63_JFSL2151 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14424 public static final BitSet FOLLOW_expression_in_synpred63_JFSL2153 = new BitSet(new long[]{0x0000000000000002L});
14425 public static final BitSet FOLLOW_186_in_synpred99_JFSL3605 = new BitSet(new long[]{0x0000000000000000L,0x001FC00000000000L,0xFC9C487FF0000820L,0x00000000000000FFL});
14426 public static final BitSet FOLLOW_unaryExpression_in_synpred99_JFSL3607 = new BitSet(new long[]{0x0000000000000002L});
14427 public static final BitSet FOLLOW_castExpression_in_synpred101_JFSL3645 = new BitSet(new long[]{0x0000000000000002L});
14428 public static final BitSet FOLLOW_typeDisambiguous_in_synpred117_JFSL3996 = new BitSet(new long[]{0x0000000000000002L});
14429 public static final BitSet FOLLOW_129_in_synpred118_JFSL4005 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14430 public static final BitSet FOLLOW_Identifier_in_synpred118_JFSL4007 = new BitSet(new long[]{0x0000000000000002L});
14431 public static final BitSet FOLLOW_typeParameters2_in_synpred119_JFSL4011 = new BitSet(new long[]{0x0000000000000002L});
14432 public static final BitSet FOLLOW_Identifier_in_synpred120_JFSL4002 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000082L});
14433 public static final BitSet FOLLOW_129_in_synpred120_JFSL4005 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
14434 public static final BitSet FOLLOW_Identifier_in_synpred120_JFSL4007 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000082L});
14435 public static final BitSet FOLLOW_typeParameters2_in_synpred120_JFSL4011 = new BitSet(new long[]{0x0000000000000002L});
14436
14437 }