00001
00002
00003 package edu.mit.csail.sdg.squander.specfile.parser;
00004
00005
00006 import org.antlr.runtime.*;
00007 import java.util.Stack;
00008 import java.util.List;
00009 import java.util.ArrayList;
00010 import java.util.Map;
00011 import java.util.HashMap;
00012
00013 import org.antlr.runtime.tree.*;
00014
00015 @SuppressWarnings({"unused"})
00016 public class SpecFileParser extends Parser {
00017 public static final String[] tokenNames = new String[] {
00018 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "SPECFILE", "SPECFIELD", "FUNCFIELD", "INVARIANT", "PARAMS", "Identifier", "StringLiteral", "Letter", "JavaIDDigit", "EscapeSequence", "UnicodeEscape", "OctalEscape", "HexDigit", "WS", "'<'", "'>'", "'{'", "'}'", "'private'", "'public'", "'protected'", "'class'", "'interface'", "'@SpecField'", "'('", "')'", "';'", "'@FuncField'", "'@Invariant'", "','"
00019 };
00020 public static final int T__29=29;
00021 public static final int T__28=28;
00022 public static final int T__27=27;
00023 public static final int T__26=26;
00024 public static final int T__25=25;
00025 public static final int T__24=24;
00026 public static final int SPECFILE=4;
00027 public static final int T__23=23;
00028 public static final int T__22=22;
00029 public static final int T__21=21;
00030 public static final int T__20=20;
00031 public static final int INVARIANT=7;
00032 public static final int EOF=-1;
00033 public static final int HexDigit=16;
00034 public static final int Identifier=9;
00035 public static final int StringLiteral=10;
00036 public static final int T__19=19;
00037 public static final int T__30=30;
00038 public static final int T__31=31;
00039 public static final int T__32=32;
00040 public static final int WS=17;
00041 public static final int T__33=33;
00042 public static final int T__18=18;
00043 public static final int SPECFIELD=5;
00044 public static final int UnicodeEscape=14;
00045 public static final int JavaIDDigit=12;
00046 public static final int OctalEscape=15;
00047 public static final int EscapeSequence=13;
00048 public static final int Letter=11;
00049 public static final int FUNCFIELD=6;
00050 public static final int PARAMS=8;
00051
00052
00053
00054
00055
00056 public SpecFileParser(TokenStream input) {
00057 this(input, new RecognizerSharedState());
00058 }
00059 public SpecFileParser(TokenStream input, RecognizerSharedState state) {
00060 super(input, state);
00061 this.state.ruleMemo = new HashMap[28+1];
00062
00063
00064 }
00065
00066 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
00067
00068 public void setTreeAdaptor(TreeAdaptor adaptor) {
00069 this.adaptor = adaptor;
00070 }
00071 public TreeAdaptor getTreeAdaptor() {
00072 return adaptor;
00073 }
00074
00075 public String[] getTokenNames() { return SpecFileParser.tokenNames; }
00076 public String getGrammarFileName() { return "SpecFile.g"; }
00077
00078
00079
00080 public static final class Node extends CommonTree {
00081 public Node(Token t) {
00082 super(t);
00083 }
00084
00085 public Node(Node node) {
00086 super(node);
00087 }
00088
00089 @Override
00090 public Tree dupNode() {
00091 return new Node(this);
00092 }
00093 };
00094
00095
00096 public static final class NodeAdaptor extends CommonTreeAdaptor {
00097 @Override
00098 public Object create(Token payload) {
00099 return new Node(payload);
00100 }
00101 };
00102
00103
00104 public void displayRecognitionError(String[] tokenNames, RecognitionException e) {
00105 throw new SpecFileParserException(e);
00106 }
00107
00108
00109 public static class specfile_return extends ParserRuleReturnScope {
00110 Node tree;
00111 public Object getTree() { return tree; }
00112 };
00113
00114
00115
00116 public final SpecFileParser.specfile_return specfile() throws RecognitionException {
00117 SpecFileParser.specfile_return retval = new SpecFileParser.specfile_return();
00118 retval.start = input.LT(1);
00119 int specfile_StartIndex = input.index();
00120 Node root_0 = null;
00121
00122 Token Identifier2=null;
00123 Token char_literal3=null;
00124 Token char_literal5=null;
00125 Token char_literal6=null;
00126 Token char_literal10=null;
00127 SpecFileParser.type_return type1 = null;
00128
00129 SpecFileParser.params_return params4 = null;
00130
00131 SpecFileParser.specfield_return specfield7 = null;
00132
00133 SpecFileParser.funcfield_return funcfield8 = null;
00134
00135 SpecFileParser.invariant_return invariant9 = null;
00136
00137
00138 Node Identifier2_tree=null;
00139 Node char_literal3_tree=null;
00140 Node char_literal5_tree=null;
00141 Node char_literal6_tree=null;
00142 Node char_literal10_tree=null;
00143 RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
00144 RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20");
00145 RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19");
00146 RewriteRuleTokenStream stream_18=new RewriteRuleTokenStream(adaptor,"token 18");
00147 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
00148 RewriteRuleSubtreeStream stream_funcfield=new RewriteRuleSubtreeStream(adaptor,"rule funcfield");
00149 RewriteRuleSubtreeStream stream_invariant=new RewriteRuleSubtreeStream(adaptor,"rule invariant");
00150 RewriteRuleSubtreeStream stream_params=new RewriteRuleSubtreeStream(adaptor,"rule params");
00151 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
00152 RewriteRuleSubtreeStream stream_specfield=new RewriteRuleSubtreeStream(adaptor,"rule specfield");
00153 try {
00154 if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }
00155
00156
00157 {
00158 pushFollow(FOLLOW_type_in_specfile105);
00159 type1=type();
00160
00161 state._fsp--;
00162 if (state.failed) return retval;
00163 if ( state.backtracking==0 ) stream_type.add(type1.getTree());
00164 Identifier2=(Token)match(input,Identifier,FOLLOW_Identifier_in_specfile107); if (state.failed) return retval;
00165 if ( state.backtracking==0 ) stream_Identifier.add(Identifier2);
00166
00167
00168 int alt1=2;
00169 int LA1_0 = input.LA(1);
00170
00171 if ( (LA1_0==18) ) {
00172 alt1=1;
00173 }
00174 switch (alt1) {
00175 case 1 :
00176
00177 {
00178 char_literal3=(Token)match(input,18,FOLLOW_18_in_specfile110); if (state.failed) return retval;
00179 if ( state.backtracking==0 ) stream_18.add(char_literal3);
00180
00181 pushFollow(FOLLOW_params_in_specfile112);
00182 params4=params();
00183
00184 state._fsp--;
00185 if (state.failed) return retval;
00186 if ( state.backtracking==0 ) stream_params.add(params4.getTree());
00187 char_literal5=(Token)match(input,19,FOLLOW_19_in_specfile114); if (state.failed) return retval;
00188 if ( state.backtracking==0 ) stream_19.add(char_literal5);
00189
00190
00191 }
00192 break;
00193
00194 }
00195
00196 char_literal6=(Token)match(input,20,FOLLOW_20_in_specfile118); if (state.failed) return retval;
00197 if ( state.backtracking==0 ) stream_20.add(char_literal6);
00198
00199
00200 loop2:
00201 do {
00202 int alt2=2;
00203 int LA2_0 = input.LA(1);
00204
00205 if ( (LA2_0==27) ) {
00206 alt2=1;
00207 }
00208
00209
00210 switch (alt2) {
00211 case 1 :
00212
00213 {
00214 pushFollow(FOLLOW_specfield_in_specfile120);
00215 specfield7=specfield();
00216
00217 state._fsp--;
00218 if (state.failed) return retval;
00219 if ( state.backtracking==0 ) stream_specfield.add(specfield7.getTree());
00220
00221 }
00222 break;
00223
00224 default :
00225 break loop2;
00226 }
00227 } while (true);
00228
00229
00230 loop3:
00231 do {
00232 int alt3=2;
00233 int LA3_0 = input.LA(1);
00234
00235 if ( (LA3_0==31) ) {
00236 alt3=1;
00237 }
00238
00239
00240 switch (alt3) {
00241 case 1 :
00242
00243 {
00244 pushFollow(FOLLOW_funcfield_in_specfile123);
00245 funcfield8=funcfield();
00246
00247 state._fsp--;
00248 if (state.failed) return retval;
00249 if ( state.backtracking==0 ) stream_funcfield.add(funcfield8.getTree());
00250
00251 }
00252 break;
00253
00254 default :
00255 break loop3;
00256 }
00257 } while (true);
00258
00259
00260 loop4:
00261 do {
00262 int alt4=2;
00263 int LA4_0 = input.LA(1);
00264
00265 if ( (LA4_0==32) ) {
00266 alt4=1;
00267 }
00268
00269
00270 switch (alt4) {
00271 case 1 :
00272
00273 {
00274 pushFollow(FOLLOW_invariant_in_specfile126);
00275 invariant9=invariant();
00276
00277 state._fsp--;
00278 if (state.failed) return retval;
00279 if ( state.backtracking==0 ) stream_invariant.add(invariant9.getTree());
00280
00281 }
00282 break;
00283
00284 default :
00285 break loop4;
00286 }
00287 } while (true);
00288
00289 char_literal10=(Token)match(input,21,FOLLOW_21_in_specfile129); if (state.failed) return retval;
00290 if ( state.backtracking==0 ) stream_21.add(char_literal10);
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301 if ( state.backtracking==0 ) {
00302 retval.tree = root_0;
00303 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00304
00305 root_0 = (Node)adaptor.nil();
00306
00307 {
00308
00309 {
00310 Node root_1 = (Node)adaptor.nil();
00311 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(SPECFILE, "SPECFILE"), root_1);
00312
00313 adaptor.addChild(root_1, stream_type.nextTree());
00314 adaptor.addChild(root_1, stream_Identifier.nextNode());
00315
00316 if ( stream_params.hasNext() ) {
00317 adaptor.addChild(root_1, stream_params.nextTree());
00318
00319 }
00320 stream_params.reset();
00321
00322 while ( stream_specfield.hasNext() ) {
00323 adaptor.addChild(root_1, stream_specfield.nextTree());
00324
00325 }
00326 stream_specfield.reset();
00327
00328 while ( stream_funcfield.hasNext() ) {
00329 adaptor.addChild(root_1, stream_funcfield.nextTree());
00330
00331 }
00332 stream_funcfield.reset();
00333
00334 while ( stream_invariant.hasNext() ) {
00335 adaptor.addChild(root_1, stream_invariant.nextTree());
00336
00337 }
00338 stream_invariant.reset();
00339
00340 adaptor.addChild(root_0, root_1);
00341 }
00342
00343 }
00344
00345 retval.tree = root_0;}
00346 }
00347
00348 retval.stop = input.LT(-1);
00349
00350 if ( state.backtracking==0 ) {
00351
00352 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00353 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00354 }
00355 }
00356 catch (RecognitionException re) {
00357 reportError(re);
00358 recover(input,re);
00359 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00360
00361 }
00362 finally {
00363 if ( state.backtracking>0 ) { memoize(input, 1, specfile_StartIndex); }
00364 }
00365 return retval;
00366 }
00367
00368
00369 public static class type_return extends ParserRuleReturnScope {
00370 Node tree;
00371 public Object getTree() { return tree; }
00372 };
00373
00374
00375
00376 public final SpecFileParser.type_return type() throws RecognitionException {
00377 SpecFileParser.type_return retval = new SpecFileParser.type_return();
00378 retval.start = input.LT(1);
00379 int type_StartIndex = input.index();
00380 Node root_0 = null;
00381
00382 SpecFileParser.mod_return mod11 = null;
00383
00384 SpecFileParser.cls_return cls12 = null;
00385
00386
00387
00388 try {
00389 if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }
00390
00391
00392 {
00393 root_0 = (Node)adaptor.nil();
00394
00395
00396 int alt5=2;
00397 int LA5_0 = input.LA(1);
00398
00399 if ( ((LA5_0>=22 && LA5_0<=24)) ) {
00400 alt5=1;
00401 }
00402 switch (alt5) {
00403 case 1 :
00404
00405 {
00406 pushFollow(FOLLOW_mod_in_type162);
00407 mod11=mod();
00408
00409 state._fsp--;
00410 if (state.failed) return retval;
00411 if ( state.backtracking==0 ) adaptor.addChild(root_0, mod11.getTree());
00412
00413 }
00414 break;
00415
00416 }
00417
00418 pushFollow(FOLLOW_cls_in_type165);
00419 cls12=cls();
00420
00421 state._fsp--;
00422 if (state.failed) return retval;
00423 if ( state.backtracking==0 ) adaptor.addChild(root_0, cls12.getTree());
00424
00425 }
00426
00427 retval.stop = input.LT(-1);
00428
00429 if ( state.backtracking==0 ) {
00430
00431 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00432 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00433 }
00434 }
00435 catch (RecognitionException re) {
00436 reportError(re);
00437 recover(input,re);
00438 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00439
00440 }
00441 finally {
00442 if ( state.backtracking>0 ) { memoize(input, 2, type_StartIndex); }
00443 }
00444 return retval;
00445 }
00446
00447
00448 public static class mod_return extends ParserRuleReturnScope {
00449 Node tree;
00450 public Object getTree() { return tree; }
00451 };
00452
00453
00454
00455 public final SpecFileParser.mod_return mod() throws RecognitionException {
00456 SpecFileParser.mod_return retval = new SpecFileParser.mod_return();
00457 retval.start = input.LT(1);
00458 int mod_StartIndex = input.index();
00459 Node root_0 = null;
00460
00461 Token set13=null;
00462
00463 Node set13_tree=null;
00464
00465 try {
00466 if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }
00467
00468
00469 {
00470 root_0 = (Node)adaptor.nil();
00471
00472 set13=(Token)input.LT(1);
00473 if ( (input.LA(1)>=22 && input.LA(1)<=24) ) {
00474 input.consume();
00475 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Node)adaptor.create(set13));
00476 state.errorRecovery=false;state.failed=false;
00477 }
00478 else {
00479 if (state.backtracking>0) {state.failed=true; return retval;}
00480 MismatchedSetException mse = new MismatchedSetException(null,input);
00481 throw mse;
00482 }
00483
00484
00485 }
00486
00487 retval.stop = input.LT(-1);
00488
00489 if ( state.backtracking==0 ) {
00490
00491 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00492 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00493 }
00494 }
00495 catch (RecognitionException re) {
00496 reportError(re);
00497 recover(input,re);
00498 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00499
00500 }
00501 finally {
00502 if ( state.backtracking>0 ) { memoize(input, 3, mod_StartIndex); }
00503 }
00504 return retval;
00505 }
00506
00507
00508 public static class cls_return extends ParserRuleReturnScope {
00509 Node tree;
00510 public Object getTree() { return tree; }
00511 };
00512
00513
00514
00515 public final SpecFileParser.cls_return cls() throws RecognitionException {
00516 SpecFileParser.cls_return retval = new SpecFileParser.cls_return();
00517 retval.start = input.LT(1);
00518 int cls_StartIndex = input.index();
00519 Node root_0 = null;
00520
00521 Token set14=null;
00522
00523 Node set14_tree=null;
00524
00525 try {
00526 if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }
00527
00528
00529 {
00530 root_0 = (Node)adaptor.nil();
00531
00532 set14=(Token)input.LT(1);
00533 if ( (input.LA(1)>=25 && input.LA(1)<=26) ) {
00534 input.consume();
00535 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Node)adaptor.create(set14));
00536 state.errorRecovery=false;state.failed=false;
00537 }
00538 else {
00539 if (state.backtracking>0) {state.failed=true; return retval;}
00540 MismatchedSetException mse = new MismatchedSetException(null,input);
00541 throw mse;
00542 }
00543
00544
00545 }
00546
00547 retval.stop = input.LT(-1);
00548
00549 if ( state.backtracking==0 ) {
00550
00551 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00552 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00553 }
00554 }
00555 catch (RecognitionException re) {
00556 reportError(re);
00557 recover(input,re);
00558 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00559
00560 }
00561 finally {
00562 if ( state.backtracking>0 ) { memoize(input, 4, cls_StartIndex); }
00563 }
00564 return retval;
00565 }
00566
00567
00568 public static class specfield_return extends ParserRuleReturnScope {
00569 Node tree;
00570 public Object getTree() { return tree; }
00571 };
00572
00573
00574
00575 public final SpecFileParser.specfield_return specfield() throws RecognitionException {
00576 SpecFileParser.specfield_return retval = new SpecFileParser.specfield_return();
00577 retval.start = input.LT(1);
00578 int specfield_StartIndex = input.index();
00579 Node root_0 = null;
00580
00581 Token string_literal15=null;
00582 Token char_literal16=null;
00583 Token StringLiteral17=null;
00584 Token char_literal18=null;
00585 Token char_literal19=null;
00586 Token string_literal20=null;
00587 Token char_literal21=null;
00588 Token char_literal22=null;
00589 Token char_literal24=null;
00590 Token char_literal25=null;
00591 Token char_literal26=null;
00592 SpecFileParser.strings_return strings23 = null;
00593
00594
00595 Node string_literal15_tree=null;
00596 Node char_literal16_tree=null;
00597 Node StringLiteral17_tree=null;
00598 Node char_literal18_tree=null;
00599 Node char_literal19_tree=null;
00600 Node string_literal20_tree=null;
00601 Node char_literal21_tree=null;
00602 Node char_literal22_tree=null;
00603 Node char_literal24_tree=null;
00604 Node char_literal25_tree=null;
00605 Node char_literal26_tree=null;
00606 RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
00607 RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
00608 RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20");
00609 RewriteRuleTokenStream stream_30=new RewriteRuleTokenStream(adaptor,"token 30");
00610 RewriteRuleTokenStream stream_27=new RewriteRuleTokenStream(adaptor,"token 27");
00611 RewriteRuleTokenStream stream_28=new RewriteRuleTokenStream(adaptor,"token 28");
00612 RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
00613 RewriteRuleSubtreeStream stream_strings=new RewriteRuleSubtreeStream(adaptor,"rule strings");
00614 try {
00615 if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }
00616
00617 int alt8=2;
00618 int LA8_0 = input.LA(1);
00619
00620 if ( (LA8_0==27) ) {
00621 int LA8_1 = input.LA(2);
00622
00623 if ( (LA8_1==28) ) {
00624 int LA8_2 = input.LA(3);
00625
00626 if ( (LA8_2==StringLiteral) ) {
00627 alt8=1;
00628 }
00629 else if ( (LA8_2==20) ) {
00630 alt8=2;
00631 }
00632 else {
00633 if (state.backtracking>0) {state.failed=true; return retval;}
00634 NoViableAltException nvae =
00635 new NoViableAltException("", 8, 2, input);
00636
00637 throw nvae;
00638 }
00639 }
00640 else {
00641 if (state.backtracking>0) {state.failed=true; return retval;}
00642 NoViableAltException nvae =
00643 new NoViableAltException("", 8, 1, input);
00644
00645 throw nvae;
00646 }
00647 }
00648 else {
00649 if (state.backtracking>0) {state.failed=true; return retval;}
00650 NoViableAltException nvae =
00651 new NoViableAltException("", 8, 0, input);
00652
00653 throw nvae;
00654 }
00655 switch (alt8) {
00656 case 1 :
00657
00658 {
00659 string_literal15=(Token)match(input,27,FOLLOW_27_in_specfield202); if (state.failed) return retval;
00660 if ( state.backtracking==0 ) stream_27.add(string_literal15);
00661
00662 char_literal16=(Token)match(input,28,FOLLOW_28_in_specfield204); if (state.failed) return retval;
00663 if ( state.backtracking==0 ) stream_28.add(char_literal16);
00664
00665 StringLiteral17=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_specfield206); if (state.failed) return retval;
00666 if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral17);
00667
00668 char_literal18=(Token)match(input,29,FOLLOW_29_in_specfield208); if (state.failed) return retval;
00669 if ( state.backtracking==0 ) stream_29.add(char_literal18);
00670
00671
00672 int alt6=2;
00673 int LA6_0 = input.LA(1);
00674
00675 if ( (LA6_0==30) ) {
00676 alt6=1;
00677 }
00678 switch (alt6) {
00679 case 1 :
00680
00681 {
00682 char_literal19=(Token)match(input,30,FOLLOW_30_in_specfield210); if (state.failed) return retval;
00683 if ( state.backtracking==0 ) stream_30.add(char_literal19);
00684
00685
00686 }
00687 break;
00688
00689 }
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700 if ( state.backtracking==0 ) {
00701 retval.tree = root_0;
00702 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00703
00704 root_0 = (Node)adaptor.nil();
00705
00706 {
00707
00708 {
00709 Node root_1 = (Node)adaptor.nil();
00710 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(SPECFIELD, "SPECFIELD"), root_1);
00711
00712 adaptor.addChild(root_1, stream_StringLiteral.nextNode());
00713
00714 adaptor.addChild(root_0, root_1);
00715 }
00716
00717 }
00718
00719 retval.tree = root_0;}
00720 }
00721 break;
00722 case 2 :
00723
00724 {
00725 string_literal20=(Token)match(input,27,FOLLOW_27_in_specfield230); if (state.failed) return retval;
00726 if ( state.backtracking==0 ) stream_27.add(string_literal20);
00727
00728 char_literal21=(Token)match(input,28,FOLLOW_28_in_specfield232); if (state.failed) return retval;
00729 if ( state.backtracking==0 ) stream_28.add(char_literal21);
00730
00731 char_literal22=(Token)match(input,20,FOLLOW_20_in_specfield234); if (state.failed) return retval;
00732 if ( state.backtracking==0 ) stream_20.add(char_literal22);
00733
00734 pushFollow(FOLLOW_strings_in_specfield236);
00735 strings23=strings();
00736
00737 state._fsp--;
00738 if (state.failed) return retval;
00739 if ( state.backtracking==0 ) stream_strings.add(strings23.getTree());
00740 char_literal24=(Token)match(input,21,FOLLOW_21_in_specfield238); if (state.failed) return retval;
00741 if ( state.backtracking==0 ) stream_21.add(char_literal24);
00742
00743 char_literal25=(Token)match(input,29,FOLLOW_29_in_specfield240); if (state.failed) return retval;
00744 if ( state.backtracking==0 ) stream_29.add(char_literal25);
00745
00746
00747 int alt7=2;
00748 int LA7_0 = input.LA(1);
00749
00750 if ( (LA7_0==30) ) {
00751 alt7=1;
00752 }
00753 switch (alt7) {
00754 case 1 :
00755
00756 {
00757 char_literal26=(Token)match(input,30,FOLLOW_30_in_specfield242); if (state.failed) return retval;
00758 if ( state.backtracking==0 ) stream_30.add(char_literal26);
00759
00760
00761 }
00762 break;
00763
00764 }
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775 if ( state.backtracking==0 ) {
00776 retval.tree = root_0;
00777 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00778
00779 root_0 = (Node)adaptor.nil();
00780
00781 {
00782
00783 {
00784 Node root_1 = (Node)adaptor.nil();
00785 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(SPECFIELD, "SPECFIELD"), root_1);
00786
00787 adaptor.addChild(root_1, stream_strings.nextTree());
00788
00789 adaptor.addChild(root_0, root_1);
00790 }
00791
00792 }
00793
00794 retval.tree = root_0;}
00795 }
00796 break;
00797
00798 }
00799 retval.stop = input.LT(-1);
00800
00801 if ( state.backtracking==0 ) {
00802
00803 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
00804 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
00805 }
00806 }
00807 catch (RecognitionException re) {
00808 reportError(re);
00809 recover(input,re);
00810 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
00811
00812 }
00813 finally {
00814 if ( state.backtracking>0 ) { memoize(input, 5, specfield_StartIndex); }
00815 }
00816 return retval;
00817 }
00818
00819
00820 public static class funcfield_return extends ParserRuleReturnScope {
00821 Node tree;
00822 public Object getTree() { return tree; }
00823 };
00824
00825
00826
00827 public final SpecFileParser.funcfield_return funcfield() throws RecognitionException {
00828 SpecFileParser.funcfield_return retval = new SpecFileParser.funcfield_return();
00829 retval.start = input.LT(1);
00830 int funcfield_StartIndex = input.index();
00831 Node root_0 = null;
00832
00833 Token string_literal27=null;
00834 Token char_literal28=null;
00835 Token StringLiteral29=null;
00836 Token char_literal30=null;
00837 Token char_literal31=null;
00838 Token string_literal32=null;
00839 Token char_literal33=null;
00840 Token char_literal34=null;
00841 Token char_literal36=null;
00842 Token char_literal37=null;
00843 Token char_literal38=null;
00844 SpecFileParser.strings_return strings35 = null;
00845
00846
00847 Node string_literal27_tree=null;
00848 Node char_literal28_tree=null;
00849 Node StringLiteral29_tree=null;
00850 Node char_literal30_tree=null;
00851 Node char_literal31_tree=null;
00852 Node string_literal32_tree=null;
00853 Node char_literal33_tree=null;
00854 Node char_literal34_tree=null;
00855 Node char_literal36_tree=null;
00856 Node char_literal37_tree=null;
00857 Node char_literal38_tree=null;
00858 RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
00859 RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
00860 RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20");
00861 RewriteRuleTokenStream stream_30=new RewriteRuleTokenStream(adaptor,"token 30");
00862 RewriteRuleTokenStream stream_31=new RewriteRuleTokenStream(adaptor,"token 31");
00863 RewriteRuleTokenStream stream_28=new RewriteRuleTokenStream(adaptor,"token 28");
00864 RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
00865 RewriteRuleSubtreeStream stream_strings=new RewriteRuleSubtreeStream(adaptor,"rule strings");
00866 try {
00867 if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }
00868
00869 int alt11=2;
00870 int LA11_0 = input.LA(1);
00871
00872 if ( (LA11_0==31) ) {
00873 int LA11_1 = input.LA(2);
00874
00875 if ( (LA11_1==28) ) {
00876 int LA11_2 = input.LA(3);
00877
00878 if ( (LA11_2==StringLiteral) ) {
00879 alt11=1;
00880 }
00881 else if ( (LA11_2==20) ) {
00882 alt11=2;
00883 }
00884 else {
00885 if (state.backtracking>0) {state.failed=true; return retval;}
00886 NoViableAltException nvae =
00887 new NoViableAltException("", 11, 2, input);
00888
00889 throw nvae;
00890 }
00891 }
00892 else {
00893 if (state.backtracking>0) {state.failed=true; return retval;}
00894 NoViableAltException nvae =
00895 new NoViableAltException("", 11, 1, input);
00896
00897 throw nvae;
00898 }
00899 }
00900 else {
00901 if (state.backtracking>0) {state.failed=true; return retval;}
00902 NoViableAltException nvae =
00903 new NoViableAltException("", 11, 0, input);
00904
00905 throw nvae;
00906 }
00907 switch (alt11) {
00908 case 1 :
00909
00910 {
00911 string_literal27=(Token)match(input,31,FOLLOW_31_in_funcfield264); if (state.failed) return retval;
00912 if ( state.backtracking==0 ) stream_31.add(string_literal27);
00913
00914 char_literal28=(Token)match(input,28,FOLLOW_28_in_funcfield266); if (state.failed) return retval;
00915 if ( state.backtracking==0 ) stream_28.add(char_literal28);
00916
00917 StringLiteral29=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_funcfield268); if (state.failed) return retval;
00918 if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral29);
00919
00920 char_literal30=(Token)match(input,29,FOLLOW_29_in_funcfield270); if (state.failed) return retval;
00921 if ( state.backtracking==0 ) stream_29.add(char_literal30);
00922
00923
00924 int alt9=2;
00925 int LA9_0 = input.LA(1);
00926
00927 if ( (LA9_0==30) ) {
00928 alt9=1;
00929 }
00930 switch (alt9) {
00931 case 1 :
00932
00933 {
00934 char_literal31=(Token)match(input,30,FOLLOW_30_in_funcfield272); if (state.failed) return retval;
00935 if ( state.backtracking==0 ) stream_30.add(char_literal31);
00936
00937
00938 }
00939 break;
00940
00941 }
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952 if ( state.backtracking==0 ) {
00953 retval.tree = root_0;
00954 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
00955
00956 root_0 = (Node)adaptor.nil();
00957
00958 {
00959
00960 {
00961 Node root_1 = (Node)adaptor.nil();
00962 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(FUNCFIELD, "FUNCFIELD"), root_1);
00963
00964 adaptor.addChild(root_1, stream_StringLiteral.nextNode());
00965
00966 adaptor.addChild(root_0, root_1);
00967 }
00968
00969 }
00970
00971 retval.tree = root_0;}
00972 }
00973 break;
00974 case 2 :
00975
00976 {
00977 string_literal32=(Token)match(input,31,FOLLOW_31_in_funcfield292); if (state.failed) return retval;
00978 if ( state.backtracking==0 ) stream_31.add(string_literal32);
00979
00980 char_literal33=(Token)match(input,28,FOLLOW_28_in_funcfield294); if (state.failed) return retval;
00981 if ( state.backtracking==0 ) stream_28.add(char_literal33);
00982
00983 char_literal34=(Token)match(input,20,FOLLOW_20_in_funcfield296); if (state.failed) return retval;
00984 if ( state.backtracking==0 ) stream_20.add(char_literal34);
00985
00986 pushFollow(FOLLOW_strings_in_funcfield298);
00987 strings35=strings();
00988
00989 state._fsp--;
00990 if (state.failed) return retval;
00991 if ( state.backtracking==0 ) stream_strings.add(strings35.getTree());
00992 char_literal36=(Token)match(input,21,FOLLOW_21_in_funcfield300); if (state.failed) return retval;
00993 if ( state.backtracking==0 ) stream_21.add(char_literal36);
00994
00995 char_literal37=(Token)match(input,29,FOLLOW_29_in_funcfield302); if (state.failed) return retval;
00996 if ( state.backtracking==0 ) stream_29.add(char_literal37);
00997
00998
00999 int alt10=2;
01000 int LA10_0 = input.LA(1);
01001
01002 if ( (LA10_0==30) ) {
01003 alt10=1;
01004 }
01005 switch (alt10) {
01006 case 1 :
01007
01008 {
01009 char_literal38=(Token)match(input,30,FOLLOW_30_in_funcfield304); if (state.failed) return retval;
01010 if ( state.backtracking==0 ) stream_30.add(char_literal38);
01011
01012
01013 }
01014 break;
01015
01016 }
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027 if ( state.backtracking==0 ) {
01028 retval.tree = root_0;
01029 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01030
01031 root_0 = (Node)adaptor.nil();
01032
01033 {
01034
01035 {
01036 Node root_1 = (Node)adaptor.nil();
01037 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(FUNCFIELD, "FUNCFIELD"), root_1);
01038
01039 adaptor.addChild(root_1, stream_strings.nextTree());
01040
01041 adaptor.addChild(root_0, root_1);
01042 }
01043
01044 }
01045
01046 retval.tree = root_0;}
01047 }
01048 break;
01049
01050 }
01051 retval.stop = input.LT(-1);
01052
01053 if ( state.backtracking==0 ) {
01054
01055 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01056 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01057 }
01058 }
01059 catch (RecognitionException re) {
01060 reportError(re);
01061 recover(input,re);
01062 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01063
01064 }
01065 finally {
01066 if ( state.backtracking>0 ) { memoize(input, 6, funcfield_StartIndex); }
01067 }
01068 return retval;
01069 }
01070
01071
01072 public static class invariant_return extends ParserRuleReturnScope {
01073 Node tree;
01074 public Object getTree() { return tree; }
01075 };
01076
01077
01078
01079 public final SpecFileParser.invariant_return invariant() throws RecognitionException {
01080 SpecFileParser.invariant_return retval = new SpecFileParser.invariant_return();
01081 retval.start = input.LT(1);
01082 int invariant_StartIndex = input.index();
01083 Node root_0 = null;
01084
01085 Token string_literal39=null;
01086 Token char_literal40=null;
01087 Token StringLiteral41=null;
01088 Token char_literal42=null;
01089 Token char_literal43=null;
01090 Token string_literal44=null;
01091 Token char_literal45=null;
01092 Token char_literal46=null;
01093 Token char_literal48=null;
01094 Token char_literal49=null;
01095 Token char_literal50=null;
01096 SpecFileParser.strings_return strings47 = null;
01097
01098
01099 Node string_literal39_tree=null;
01100 Node char_literal40_tree=null;
01101 Node StringLiteral41_tree=null;
01102 Node char_literal42_tree=null;
01103 Node char_literal43_tree=null;
01104 Node string_literal44_tree=null;
01105 Node char_literal45_tree=null;
01106 Node char_literal46_tree=null;
01107 Node char_literal48_tree=null;
01108 Node char_literal49_tree=null;
01109 Node char_literal50_tree=null;
01110 RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
01111 RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
01112 RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20");
01113 RewriteRuleTokenStream stream_30=new RewriteRuleTokenStream(adaptor,"token 30");
01114 RewriteRuleTokenStream stream_32=new RewriteRuleTokenStream(adaptor,"token 32");
01115 RewriteRuleTokenStream stream_28=new RewriteRuleTokenStream(adaptor,"token 28");
01116 RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
01117 RewriteRuleSubtreeStream stream_strings=new RewriteRuleSubtreeStream(adaptor,"rule strings");
01118 try {
01119 if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }
01120
01121 int alt14=2;
01122 int LA14_0 = input.LA(1);
01123
01124 if ( (LA14_0==32) ) {
01125 int LA14_1 = input.LA(2);
01126
01127 if ( (LA14_1==28) ) {
01128 int LA14_2 = input.LA(3);
01129
01130 if ( (LA14_2==StringLiteral) ) {
01131 alt14=1;
01132 }
01133 else if ( (LA14_2==20) ) {
01134 alt14=2;
01135 }
01136 else {
01137 if (state.backtracking>0) {state.failed=true; return retval;}
01138 NoViableAltException nvae =
01139 new NoViableAltException("", 14, 2, input);
01140
01141 throw nvae;
01142 }
01143 }
01144 else {
01145 if (state.backtracking>0) {state.failed=true; return retval;}
01146 NoViableAltException nvae =
01147 new NoViableAltException("", 14, 1, input);
01148
01149 throw nvae;
01150 }
01151 }
01152 else {
01153 if (state.backtracking>0) {state.failed=true; return retval;}
01154 NoViableAltException nvae =
01155 new NoViableAltException("", 14, 0, input);
01156
01157 throw nvae;
01158 }
01159 switch (alt14) {
01160 case 1 :
01161
01162 {
01163 string_literal39=(Token)match(input,32,FOLLOW_32_in_invariant326); if (state.failed) return retval;
01164 if ( state.backtracking==0 ) stream_32.add(string_literal39);
01165
01166 char_literal40=(Token)match(input,28,FOLLOW_28_in_invariant328); if (state.failed) return retval;
01167 if ( state.backtracking==0 ) stream_28.add(char_literal40);
01168
01169 StringLiteral41=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_invariant330); if (state.failed) return retval;
01170 if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral41);
01171
01172 char_literal42=(Token)match(input,29,FOLLOW_29_in_invariant332); if (state.failed) return retval;
01173 if ( state.backtracking==0 ) stream_29.add(char_literal42);
01174
01175
01176 int alt12=2;
01177 int LA12_0 = input.LA(1);
01178
01179 if ( (LA12_0==30) ) {
01180 alt12=1;
01181 }
01182 switch (alt12) {
01183 case 1 :
01184
01185 {
01186 char_literal43=(Token)match(input,30,FOLLOW_30_in_invariant334); if (state.failed) return retval;
01187 if ( state.backtracking==0 ) stream_30.add(char_literal43);
01188
01189
01190 }
01191 break;
01192
01193 }
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204 if ( state.backtracking==0 ) {
01205 retval.tree = root_0;
01206 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01207
01208 root_0 = (Node)adaptor.nil();
01209
01210 {
01211
01212 {
01213 Node root_1 = (Node)adaptor.nil();
01214 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(INVARIANT, "INVARIANT"), root_1);
01215
01216 adaptor.addChild(root_1, stream_StringLiteral.nextNode());
01217
01218 adaptor.addChild(root_0, root_1);
01219 }
01220
01221 }
01222
01223 retval.tree = root_0;}
01224 }
01225 break;
01226 case 2 :
01227
01228 {
01229 string_literal44=(Token)match(input,32,FOLLOW_32_in_invariant354); if (state.failed) return retval;
01230 if ( state.backtracking==0 ) stream_32.add(string_literal44);
01231
01232 char_literal45=(Token)match(input,28,FOLLOW_28_in_invariant356); if (state.failed) return retval;
01233 if ( state.backtracking==0 ) stream_28.add(char_literal45);
01234
01235 char_literal46=(Token)match(input,20,FOLLOW_20_in_invariant358); if (state.failed) return retval;
01236 if ( state.backtracking==0 ) stream_20.add(char_literal46);
01237
01238 pushFollow(FOLLOW_strings_in_invariant360);
01239 strings47=strings();
01240
01241 state._fsp--;
01242 if (state.failed) return retval;
01243 if ( state.backtracking==0 ) stream_strings.add(strings47.getTree());
01244 char_literal48=(Token)match(input,21,FOLLOW_21_in_invariant362); if (state.failed) return retval;
01245 if ( state.backtracking==0 ) stream_21.add(char_literal48);
01246
01247 char_literal49=(Token)match(input,29,FOLLOW_29_in_invariant364); if (state.failed) return retval;
01248 if ( state.backtracking==0 ) stream_29.add(char_literal49);
01249
01250
01251 int alt13=2;
01252 int LA13_0 = input.LA(1);
01253
01254 if ( (LA13_0==30) ) {
01255 alt13=1;
01256 }
01257 switch (alt13) {
01258 case 1 :
01259
01260 {
01261 char_literal50=(Token)match(input,30,FOLLOW_30_in_invariant366); if (state.failed) return retval;
01262 if ( state.backtracking==0 ) stream_30.add(char_literal50);
01263
01264
01265 }
01266 break;
01267
01268 }
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279 if ( state.backtracking==0 ) {
01280 retval.tree = root_0;
01281 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01282
01283 root_0 = (Node)adaptor.nil();
01284
01285 {
01286
01287 {
01288 Node root_1 = (Node)adaptor.nil();
01289 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(INVARIANT, "INVARIANT"), root_1);
01290
01291 adaptor.addChild(root_1, stream_strings.nextTree());
01292
01293 adaptor.addChild(root_0, root_1);
01294 }
01295
01296 }
01297
01298 retval.tree = root_0;}
01299 }
01300 break;
01301
01302 }
01303 retval.stop = input.LT(-1);
01304
01305 if ( state.backtracking==0 ) {
01306
01307 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01308 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01309 }
01310 }
01311 catch (RecognitionException re) {
01312 reportError(re);
01313 recover(input,re);
01314 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01315
01316 }
01317 finally {
01318 if ( state.backtracking>0 ) { memoize(input, 7, invariant_StartIndex); }
01319 }
01320 return retval;
01321 }
01322
01323
01324 public static class params_return extends ParserRuleReturnScope {
01325 Node tree;
01326 public Object getTree() { return tree; }
01327 };
01328
01329
01330
01331 public final SpecFileParser.params_return params() throws RecognitionException {
01332 SpecFileParser.params_return retval = new SpecFileParser.params_return();
01333 retval.start = input.LT(1);
01334 int params_StartIndex = input.index();
01335 Node root_0 = null;
01336
01337 Token Identifier51=null;
01338 Token char_literal52=null;
01339 Token Identifier53=null;
01340
01341 Node Identifier51_tree=null;
01342 Node char_literal52_tree=null;
01343 Node Identifier53_tree=null;
01344 RewriteRuleTokenStream stream_33=new RewriteRuleTokenStream(adaptor,"token 33");
01345 RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
01346
01347 try {
01348 if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }
01349
01350
01351 {
01352 Identifier51=(Token)match(input,Identifier,FOLLOW_Identifier_in_params388); if (state.failed) return retval;
01353 if ( state.backtracking==0 ) stream_Identifier.add(Identifier51);
01354
01355
01356 loop15:
01357 do {
01358 int alt15=2;
01359 int LA15_0 = input.LA(1);
01360
01361 if ( (LA15_0==33) ) {
01362 alt15=1;
01363 }
01364
01365
01366 switch (alt15) {
01367 case 1 :
01368
01369 {
01370 char_literal52=(Token)match(input,33,FOLLOW_33_in_params391); if (state.failed) return retval;
01371 if ( state.backtracking==0 ) stream_33.add(char_literal52);
01372
01373 Identifier53=(Token)match(input,Identifier,FOLLOW_Identifier_in_params393); if (state.failed) return retval;
01374 if ( state.backtracking==0 ) stream_Identifier.add(Identifier53);
01375
01376
01377 }
01378 break;
01379
01380 default :
01381 break loop15;
01382 }
01383 } while (true);
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394 if ( state.backtracking==0 ) {
01395 retval.tree = root_0;
01396 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01397
01398 root_0 = (Node)adaptor.nil();
01399
01400 {
01401
01402 {
01403 Node root_1 = (Node)adaptor.nil();
01404 root_1 = (Node)adaptor.becomeRoot((Node)adaptor.create(PARAMS, "PARAMS"), root_1);
01405
01406
01407 while ( stream_Identifier.hasNext() ) {
01408 adaptor.addChild(root_1, stream_Identifier.nextNode());
01409
01410 }
01411 stream_Identifier.reset();
01412
01413 adaptor.addChild(root_0, root_1);
01414 }
01415
01416 }
01417
01418 retval.tree = root_0;}
01419 }
01420
01421 retval.stop = input.LT(-1);
01422
01423 if ( state.backtracking==0 ) {
01424
01425 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01426 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01427 }
01428 }
01429 catch (RecognitionException re) {
01430 reportError(re);
01431 recover(input,re);
01432 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01433
01434 }
01435 finally {
01436 if ( state.backtracking>0 ) { memoize(input, 8, params_StartIndex); }
01437 }
01438 return retval;
01439 }
01440
01441
01442 public static class strings_return extends ParserRuleReturnScope {
01443 Node tree;
01444 public Object getTree() { return tree; }
01445 };
01446
01447
01448
01449 public final SpecFileParser.strings_return strings() throws RecognitionException {
01450 SpecFileParser.strings_return retval = new SpecFileParser.strings_return();
01451 retval.start = input.LT(1);
01452 int strings_StartIndex = input.index();
01453 Node root_0 = null;
01454
01455 Token StringLiteral54=null;
01456 Token char_literal55=null;
01457 Token StringLiteral56=null;
01458
01459 Node StringLiteral54_tree=null;
01460 Node char_literal55_tree=null;
01461 Node StringLiteral56_tree=null;
01462 RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
01463 RewriteRuleTokenStream stream_33=new RewriteRuleTokenStream(adaptor,"token 33");
01464
01465 try {
01466 if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }
01467
01468
01469 {
01470 StringLiteral54=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_strings430); if (state.failed) return retval;
01471 if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral54);
01472
01473
01474 loop16:
01475 do {
01476 int alt16=2;
01477 int LA16_0 = input.LA(1);
01478
01479 if ( (LA16_0==33) ) {
01480 alt16=1;
01481 }
01482
01483
01484 switch (alt16) {
01485 case 1 :
01486
01487 {
01488 char_literal55=(Token)match(input,33,FOLLOW_33_in_strings433); if (state.failed) return retval;
01489 if ( state.backtracking==0 ) stream_33.add(char_literal55);
01490
01491 StringLiteral56=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_strings435); if (state.failed) return retval;
01492 if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral56);
01493
01494
01495 }
01496 break;
01497
01498 default :
01499 break loop16;
01500 }
01501 } while (true);
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512 if ( state.backtracking==0 ) {
01513 retval.tree = root_0;
01514 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
01515
01516 root_0 = (Node)adaptor.nil();
01517
01518 {
01519
01520 while ( stream_StringLiteral.hasNext() ) {
01521 adaptor.addChild(root_0, stream_StringLiteral.nextNode());
01522
01523 }
01524 stream_StringLiteral.reset();
01525
01526 }
01527
01528 retval.tree = root_0;}
01529 }
01530
01531 retval.stop = input.LT(-1);
01532
01533 if ( state.backtracking==0 ) {
01534
01535 retval.tree = (Node)adaptor.rulePostProcessing(root_0);
01536 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
01537 }
01538 }
01539 catch (RecognitionException re) {
01540 reportError(re);
01541 recover(input,re);
01542 retval.tree = (Node)adaptor.errorNode(input, retval.start, input.LT(-1), re);
01543
01544 }
01545 finally {
01546 if ( state.backtracking>0 ) { memoize(input, 9, strings_StartIndex); }
01547 }
01548 return retval;
01549 }
01550
01551
01552
01553
01554
01555
01556
01557 public static final BitSet FOLLOW_type_in_specfile105 = new BitSet(new long[]{0x0000000000000200L});
01558 public static final BitSet FOLLOW_Identifier_in_specfile107 = new BitSet(new long[]{0x0000000000140000L});
01559 public static final BitSet FOLLOW_18_in_specfile110 = new BitSet(new long[]{0x0000000000000200L});
01560 public static final BitSet FOLLOW_params_in_specfile112 = new BitSet(new long[]{0x0000000000080000L});
01561 public static final BitSet FOLLOW_19_in_specfile114 = new BitSet(new long[]{0x0000000000100000L});
01562 public static final BitSet FOLLOW_20_in_specfile118 = new BitSet(new long[]{0x0000000188200000L});
01563 public static final BitSet FOLLOW_specfield_in_specfile120 = new BitSet(new long[]{0x0000000188200000L});
01564 public static final BitSet FOLLOW_funcfield_in_specfile123 = new BitSet(new long[]{0x0000000180200000L});
01565 public static final BitSet FOLLOW_invariant_in_specfile126 = new BitSet(new long[]{0x0000000100200000L});
01566 public static final BitSet FOLLOW_21_in_specfile129 = new BitSet(new long[]{0x0000000000000002L});
01567 public static final BitSet FOLLOW_mod_in_type162 = new BitSet(new long[]{0x0000000006000000L});
01568 public static final BitSet FOLLOW_cls_in_type165 = new BitSet(new long[]{0x0000000000000002L});
01569 public static final BitSet FOLLOW_set_in_mod0 = new BitSet(new long[]{0x0000000000000002L});
01570 public static final BitSet FOLLOW_set_in_cls0 = new BitSet(new long[]{0x0000000000000002L});
01571 public static final BitSet FOLLOW_27_in_specfield202 = new BitSet(new long[]{0x0000000010000000L});
01572 public static final BitSet FOLLOW_28_in_specfield204 = new BitSet(new long[]{0x0000000000000400L});
01573 public static final BitSet FOLLOW_StringLiteral_in_specfield206 = new BitSet(new long[]{0x0000000020000000L});
01574 public static final BitSet FOLLOW_29_in_specfield208 = new BitSet(new long[]{0x0000000040000002L});
01575 public static final BitSet FOLLOW_30_in_specfield210 = new BitSet(new long[]{0x0000000000000002L});
01576 public static final BitSet FOLLOW_27_in_specfield230 = new BitSet(new long[]{0x0000000010000000L});
01577 public static final BitSet FOLLOW_28_in_specfield232 = new BitSet(new long[]{0x0000000000100000L});
01578 public static final BitSet FOLLOW_20_in_specfield234 = new BitSet(new long[]{0x0000000000000400L});
01579 public static final BitSet FOLLOW_strings_in_specfield236 = new BitSet(new long[]{0x0000000000200000L});
01580 public static final BitSet FOLLOW_21_in_specfield238 = new BitSet(new long[]{0x0000000020000000L});
01581 public static final BitSet FOLLOW_29_in_specfield240 = new BitSet(new long[]{0x0000000040000002L});
01582 public static final BitSet FOLLOW_30_in_specfield242 = new BitSet(new long[]{0x0000000000000002L});
01583 public static final BitSet FOLLOW_31_in_funcfield264 = new BitSet(new long[]{0x0000000010000000L});
01584 public static final BitSet FOLLOW_28_in_funcfield266 = new BitSet(new long[]{0x0000000000000400L});
01585 public static final BitSet FOLLOW_StringLiteral_in_funcfield268 = new BitSet(new long[]{0x0000000020000000L});
01586 public static final BitSet FOLLOW_29_in_funcfield270 = new BitSet(new long[]{0x0000000040000002L});
01587 public static final BitSet FOLLOW_30_in_funcfield272 = new BitSet(new long[]{0x0000000000000002L});
01588 public static final BitSet FOLLOW_31_in_funcfield292 = new BitSet(new long[]{0x0000000010000000L});
01589 public static final BitSet FOLLOW_28_in_funcfield294 = new BitSet(new long[]{0x0000000000100000L});
01590 public static final BitSet FOLLOW_20_in_funcfield296 = new BitSet(new long[]{0x0000000000000400L});
01591 public static final BitSet FOLLOW_strings_in_funcfield298 = new BitSet(new long[]{0x0000000000200000L});
01592 public static final BitSet FOLLOW_21_in_funcfield300 = new BitSet(new long[]{0x0000000020000000L});
01593 public static final BitSet FOLLOW_29_in_funcfield302 = new BitSet(new long[]{0x0000000040000002L});
01594 public static final BitSet FOLLOW_30_in_funcfield304 = new BitSet(new long[]{0x0000000000000002L});
01595 public static final BitSet FOLLOW_32_in_invariant326 = new BitSet(new long[]{0x0000000010000000L});
01596 public static final BitSet FOLLOW_28_in_invariant328 = new BitSet(new long[]{0x0000000000000400L});
01597 public static final BitSet FOLLOW_StringLiteral_in_invariant330 = new BitSet(new long[]{0x0000000020000000L});
01598 public static final BitSet FOLLOW_29_in_invariant332 = new BitSet(new long[]{0x0000000040000002L});
01599 public static final BitSet FOLLOW_30_in_invariant334 = new BitSet(new long[]{0x0000000000000002L});
01600 public static final BitSet FOLLOW_32_in_invariant354 = new BitSet(new long[]{0x0000000010000000L});
01601 public static final BitSet FOLLOW_28_in_invariant356 = new BitSet(new long[]{0x0000000000100000L});
01602 public static final BitSet FOLLOW_20_in_invariant358 = new BitSet(new long[]{0x0000000000000400L});
01603 public static final BitSet FOLLOW_strings_in_invariant360 = new BitSet(new long[]{0x0000000000200000L});
01604 public static final BitSet FOLLOW_21_in_invariant362 = new BitSet(new long[]{0x0000000020000000L});
01605 public static final BitSet FOLLOW_29_in_invariant364 = new BitSet(new long[]{0x0000000040000002L});
01606 public static final BitSet FOLLOW_30_in_invariant366 = new BitSet(new long[]{0x0000000000000002L});
01607 public static final BitSet FOLLOW_Identifier_in_params388 = new BitSet(new long[]{0x0000000200000002L});
01608 public static final BitSet FOLLOW_33_in_params391 = new BitSet(new long[]{0x0000000000000200L});
01609 public static final BitSet FOLLOW_Identifier_in_params393 = new BitSet(new long[]{0x0000000200000002L});
01610 public static final BitSet FOLLOW_StringLiteral_in_strings430 = new BitSet(new long[]{0x0000000200000002L});
01611 public static final BitSet FOLLOW_33_in_strings433 = new BitSet(new long[]{0x0000000000000400L});
01612 public static final BitSet FOLLOW_StringLiteral_in_strings435 = new BitSet(new long[]{0x0000000200000002L});
01613
01614 }