• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // $ANTLR 3.1.2 BuildOptions\\ProfileTreeGrammar.g3 2009-09-30 13:18:19
2 
3 // The variable 'variable' is assigned but its value is never used.
4 #pragma warning disable 219
5 // Unreachable code detected.
6 #pragma warning disable 162
7 
8 
9 //import java.util.Map;
10 //import java.util.HashMap;
11 using BigInteger = java.math.BigInteger;
12 using Console = System.Console;
13 
14 
15 using System.Collections.Generic;
16 using Antlr.Runtime;
17 using Antlr.Runtime.Tree;
18 using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;using Stack = System.Collections.Generic.Stack<object>;
19 using List = System.Collections.IList;
20 using ArrayList = System.Collections.Generic.List<object>;
21 
22 using Antlr.Runtime.Debug;
23 using IOException = System.IO.IOException;
24 [System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.1.2")]
25 [System.CLSCompliant(false)]
26 public partial class ProfileTreeGrammar : DebugTreeParser
27 {
28 	internal static readonly string[] tokenNames = new string[] {
29 		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "CALL", "FUNC", "ID", "INT", "NEWLINE", "WS", "'-'", "'%'", "'('", "')'", "'*'", "'/'", "'+'", "'='"
30 	};
31 	public const int EOF=-1;
32 	public const int T__10=10;
33 	public const int T__11=11;
34 	public const int T__12=12;
35 	public const int T__13=13;
36 	public const int T__14=14;
37 	public const int T__15=15;
38 	public const int T__16=16;
39 	public const int T__17=17;
40 	public const int CALL=4;
41 	public const int FUNC=5;
42 	public const int ID=6;
43 	public const int INT=7;
44 	public const int NEWLINE=8;
45 	public const int WS=9;
46 
47 	// delegates
48 	// delegators
49 
50 	public static readonly string[] ruleNames =
51 		new string[]
52 		{
53 			"invalidRule", "call", "expr", "prog", "stat"
54 		};
55 
56 		int ruleLevel = 0;
57 		public virtual int RuleLevel { get { return ruleLevel; } }
IncRuleLevel()58 		public virtual void IncRuleLevel() { ruleLevel++; }
DecRuleLevel()59 		public virtual void DecRuleLevel() { ruleLevel--; }
ProfileTreeGrammar( ITreeNodeStream input )60 		public ProfileTreeGrammar( ITreeNodeStream input )
61 			: this( input, new Profiler(null), new RecognizerSharedState() )
62 		{
63 		}
ProfileTreeGrammar( ITreeNodeStream input, IDebugEventListener dbg, RecognizerSharedState state )64 		public ProfileTreeGrammar( ITreeNodeStream input, IDebugEventListener dbg, RecognizerSharedState state )
65 			: base( input, dbg, state )
66 		{
67 			Profiler p = (Profiler)dbg;
68 			p.setParser(this);
69 		}
70 
ProfileTreeGrammar( ITreeNodeStream input, IDebugEventListener dbg )71 	public ProfileTreeGrammar( ITreeNodeStream input, IDebugEventListener dbg )
72 		: base( input, dbg, new RecognizerSharedState() )
73 	{
74 		Profiler p = (Profiler)dbg;
75 		p.setParser(this);
76 	}
AlreadyParsedRule( IIntStream input, int ruleIndex )77 	public virtual bool AlreadyParsedRule( IIntStream input, int ruleIndex )
78 	{
79 		((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, ProfileTreeGrammar.ruleNames[ruleIndex]);
80 		return super.AlreadyParsedRule(input, ruleIndex);
81 	}
82 
Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )83 	public virtual void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )
84 	{
85 		((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, ProfileTreeGrammar.ruleNames[ruleIndex]);
86 		super.Memoize(input, ruleIndex, ruleStartIndex);
87 	}
EvalPredicate( bool result, string predicate )88 	protected virtual bool EvalPredicate( bool result, string predicate )
89 	{
90 		dbg.SemanticPredicate( result, predicate );
91 		return result;
92 	}
93 
94 
95 	public override string[] TokenNames { get { return ProfileTreeGrammar.tokenNames; } }
96 	public override string GrammarFileName { get { return "BuildOptions\\ProfileTreeGrammar.g3"; } }
97 
98 
99 	#region Rules
100 
101 	// $ANTLR start "prog"
102 	// BuildOptions\\ProfileTreeGrammar.g3:53:0: prog : ( stat )* ;
prog( )103 	private void prog(  )
104 	{
105 		try
106 		{
107 			dbg.EnterRule( GrammarFileName, "prog" );
108 			if ( RuleLevel == 0 )
109 			{
110 				dbg.Commence();
111 			}
112 			IncRuleLevel();
113 			dbg.Location( 53, -1 );
114 
115 		try
116 		{
117 			// BuildOptions\\ProfileTreeGrammar.g3:53:9: ( ( stat )* )
118 			dbg.EnterAlt( 1 );
119 
120 			// BuildOptions\\ProfileTreeGrammar.g3:53:9: ( stat )*
121 			{
122 			dbg.Location( 53, 8 );
123 			// BuildOptions\\ProfileTreeGrammar.g3:53:9: ( stat )*
124 			try
125 			{
126 				dbg.EnterSubRule( 1 );
127 
128 			for ( ; ; )
129 			{
130 				int alt1=2;
131 				try
132 				{
133 					dbg.EnterDecision( 1 );
134 
135 				int LA1_0 = input.LA(1);
136 
137 				if ( ((LA1_0>=CALL && LA1_0<=INT)||(LA1_0>=10 && LA1_0<=11)||(LA1_0>=14 && LA1_0<=17)) )
138 				{
139 					alt1=1;
140 				}
141 
142 
143 				}
144 				finally
145 				{
146 					dbg.ExitDecision( 1 );
147 				}
148 
149 				switch ( alt1 )
150 				{
151 				case 1:
152 					dbg.EnterAlt( 1 );
153 
154 					// BuildOptions\\ProfileTreeGrammar.g3:53:0: stat
155 					{
156 					dbg.Location( 53, 8 );
157 					PushFollow(Follow._stat_in_prog48);
158 					stat();
159 
160 					state._fsp--;
161 
162 
163 					}
164 					break;
165 
166 				default:
167 					goto loop1;
168 				}
169 			}
170 
171 			loop1:
172 				;
173 
174 			}
175 			finally
176 			{
177 				dbg.ExitSubRule( 1 );
178 			}
179 
180 
181 			}
182 
183 		}
184 		catch ( RecognitionException re )
185 		{
186 			ReportError(re);
187 			Recover(input,re);
188 		}
189 		finally
190 		{
191 		}
192 		dbg.Location(54, 4);
193 
194 		}
195 		finally
196 		{
197 			dbg.ExitRule( GrammarFileName, "prog" );
198 			DecRuleLevel();
199 			if ( RuleLevel == 0 )
200 			{
201 				dbg.Terminate();
202 			}
203 		}
204 
205 		return ;
206 	}
207 	// $ANTLR end "prog"
208 
209 
210 	// $ANTLR start "stat"
211 	// BuildOptions\\ProfileTreeGrammar.g3:56:0: stat : ( expr | ^( '=' ID expr ) | ^( FUNC ( . )+ ) );
stat( )212 	private void stat(  )
213 	{
214 		CommonTree ID2=null;
215 		BigInteger expr1 = default(BigInteger);
216 		BigInteger expr3 = default(BigInteger);
217 
218 		try
219 		{
220 			dbg.EnterRule( GrammarFileName, "stat" );
221 			if ( RuleLevel == 0 )
222 			{
223 				dbg.Commence();
224 			}
225 			IncRuleLevel();
226 			dbg.Location( 56, -1 );
227 
228 		try
229 		{
230 			// BuildOptions\\ProfileTreeGrammar.g3:56:9: ( expr | ^( '=' ID expr ) | ^( FUNC ( . )+ ) )
231 			int alt3=3;
232 			try
233 			{
234 				dbg.EnterDecision( 3 );
235 
236 			switch ( input.LA(1) )
237 			{
238 			case CALL:
239 			case ID:
240 			case INT:
241 			case 10:
242 			case 11:
243 			case 14:
244 			case 15:
245 			case 16:
246 				{
247 				alt3=1;
248 				}
249 				break;
250 			case 17:
251 				{
252 				alt3=2;
253 				}
254 				break;
255 			case FUNC:
256 				{
257 				alt3=3;
258 				}
259 				break;
260 			default:
261 				{
262 					NoViableAltException nvae = new NoViableAltException("", 3, 0, input);
263 
264 					dbg.RecognitionException( nvae );
265 					throw nvae;
266 				}
267 			}
268 
269 			}
270 			finally
271 			{
272 				dbg.ExitDecision( 3 );
273 			}
274 
275 			switch ( alt3 )
276 			{
277 			case 1:
278 				dbg.EnterAlt( 1 );
279 
280 				// BuildOptions\\ProfileTreeGrammar.g3:56:9: expr
281 				{
282 				dbg.Location( 56, 8 );
283 				PushFollow(Follow._expr_in_stat63);
284 				expr1=expr();
285 
286 				state._fsp--;
287 
288 				dbg.Location( 56, 35 );
289 				 string result = expr1.ToString();
290 				                                     Console.Out.WriteLine(expr1 + " (about " + result[0] + "*10^" + (result.Length-1) + ")");
291 
292 
293 				}
294 				break;
295 			case 2:
296 				dbg.EnterAlt( 2 );
297 
298 				// BuildOptions\\ProfileTreeGrammar.g3:59:9: ^( '=' ID expr )
299 				{
300 				dbg.Location( 59, 8 );
301 				dbg.Location( 59, 10 );
302 				Match(input,17,Follow._17_in_stat98);
303 
304 				Match(input, TokenTypes.Down, null);
305 				dbg.Location( 59, 14 );
306 				ID2=(CommonTree)Match(input,ID,Follow._ID_in_stat100);
307 				dbg.Location( 59, 17 );
308 				PushFollow(Follow._expr_in_stat102);
309 				expr3=expr();
310 
311 				state._fsp--;
312 
313 
314 				Match(input, TokenTypes.Up, null);
315 				dbg.Location( 59, 35 );
316 				 globalMemory[(ID2!=null?ID2.Text:null)] = expr3;
317 
318 				}
319 				break;
320 			case 3:
321 				dbg.EnterAlt( 3 );
322 
323 				// BuildOptions\\ProfileTreeGrammar.g3:60:9: ^( FUNC ( . )+ )
324 				{
325 				dbg.Location( 60, 8 );
326 				dbg.Location( 60, 10 );
327 				Match(input,FUNC,Follow._FUNC_in_stat128);
328 
329 				Match(input, TokenTypes.Down, null);
330 				dbg.Location( 60, 15 );
331 				// BuildOptions\\ProfileTreeGrammar.g3:60:16: ( . )+
332 				int cnt2=0;
333 				try
334 				{
335 					dbg.EnterSubRule( 2 );
336 
337 				for ( ; ; )
338 				{
339 					int alt2=2;
340 					try
341 					{
342 						dbg.EnterDecision( 2 );
343 
344 					int LA2_0 = input.LA(1);
345 
346 					if ( ((LA2_0>=CALL && LA2_0<=17)) )
347 					{
348 						alt2=1;
349 					}
350 					else if ( (LA2_0==UP) )
351 					{
352 						alt2=2;
353 					}
354 
355 
356 					}
357 					finally
358 					{
359 						dbg.ExitDecision( 2 );
360 					}
361 
362 					switch ( alt2 )
363 					{
364 					case 1:
365 						dbg.EnterAlt( 1 );
366 
367 						// BuildOptions\\ProfileTreeGrammar.g3:60:0: .
368 						{
369 						dbg.Location( 60, 15 );
370 						MatchAny(input);
371 
372 						}
373 						break;
374 
375 					default:
376 						if ( cnt2 >= 1 )
377 							goto loop2;
378 
379 						EarlyExitException eee2 = new EarlyExitException( 2, input );
380 						dbg.RecognitionException( eee2 );
381 
382 						throw eee2;
383 					}
384 					cnt2++;
385 				}
386 				loop2:
387 					;
388 
389 				}
390 				finally
391 				{
392 					dbg.ExitSubRule( 2 );
393 				}
394 
395 
396 				Match(input, TokenTypes.Up, null);
397 
398 				}
399 				break;
400 
401 			}
402 		}
403 		catch ( RecognitionException re )
404 		{
405 			ReportError(re);
406 			Recover(input,re);
407 		}
408 		finally
409 		{
410 		}
411 		dbg.Location(61, 4);
412 
413 		}
414 		finally
415 		{
416 			dbg.ExitRule( GrammarFileName, "stat" );
417 			DecRuleLevel();
418 			if ( RuleLevel == 0 )
419 			{
420 				dbg.Terminate();
421 			}
422 		}
423 
424 		return ;
425 	}
426 	// $ANTLR end "stat"
427 
428 
429 	// $ANTLR start "expr"
430 	// BuildOptions\\ProfileTreeGrammar.g3:63:0: expr returns [BigInteger value] : ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ^( '/' a= expr b= expr ) | ^( '%' a= expr b= expr ) | ID | INT | call );
expr( )431 	private BigInteger expr(  )
432 	{
433 		BigInteger value = default(BigInteger);
434 
435 		CommonTree ID4=null;
436 		CommonTree INT5=null;
437 		BigInteger a = default(BigInteger);
438 		BigInteger b = default(BigInteger);
439 		BigInteger call6 = default(BigInteger);
440 
441 		try
442 		{
443 			dbg.EnterRule( GrammarFileName, "expr" );
444 			if ( RuleLevel == 0 )
445 			{
446 				dbg.Commence();
447 			}
448 			IncRuleLevel();
449 			dbg.Location( 63, -1 );
450 
451 		try
452 		{
453 			// BuildOptions\\ProfileTreeGrammar.g3:64:9: ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ^( '/' a= expr b= expr ) | ^( '%' a= expr b= expr ) | ID | INT | call )
454 			int alt4=8;
455 			try
456 			{
457 				dbg.EnterDecision( 4 );
458 
459 			switch ( input.LA(1) )
460 			{
461 			case 16:
462 				{
463 				alt4=1;
464 				}
465 				break;
466 			case 10:
467 				{
468 				alt4=2;
469 				}
470 				break;
471 			case 14:
472 				{
473 				alt4=3;
474 				}
475 				break;
476 			case 15:
477 				{
478 				alt4=4;
479 				}
480 				break;
481 			case 11:
482 				{
483 				alt4=5;
484 				}
485 				break;
486 			case ID:
487 				{
488 				alt4=6;
489 				}
490 				break;
491 			case INT:
492 				{
493 				alt4=7;
494 				}
495 				break;
496 			case CALL:
497 				{
498 				alt4=8;
499 				}
500 				break;
501 			default:
502 				{
503 					NoViableAltException nvae = new NoViableAltException("", 4, 0, input);
504 
505 					dbg.RecognitionException( nvae );
506 					throw nvae;
507 				}
508 			}
509 
510 			}
511 			finally
512 			{
513 				dbg.ExitDecision( 4 );
514 			}
515 
516 			switch ( alt4 )
517 			{
518 			case 1:
519 				dbg.EnterAlt( 1 );
520 
521 				// BuildOptions\\ProfileTreeGrammar.g3:64:9: ^( '+' a= expr b= expr )
522 				{
523 				dbg.Location( 64, 8 );
524 				dbg.Location( 64, 10 );
525 				Match(input,16,Follow._16_in_expr172);
526 
527 				Match(input, TokenTypes.Down, null);
528 				dbg.Location( 64, 15 );
529 				PushFollow(Follow._expr_in_expr176);
530 				a=expr();
531 
532 				state._fsp--;
533 
534 				dbg.Location( 64, 22 );
535 				PushFollow(Follow._expr_in_expr180);
536 				b=expr();
537 
538 				state._fsp--;
539 
540 
541 				Match(input, TokenTypes.Up, null);
542 				dbg.Location( 64, 35 );
543 				 value = a.add(b);
544 
545 				}
546 				break;
547 			case 2:
548 				dbg.EnterAlt( 2 );
549 
550 				// BuildOptions\\ProfileTreeGrammar.g3:65:9: ^( '-' a= expr b= expr )
551 				{
552 				dbg.Location( 65, 8 );
553 				dbg.Location( 65, 10 );
554 				Match(input,10,Follow._10_in_expr200);
555 
556 				Match(input, TokenTypes.Down, null);
557 				dbg.Location( 65, 15 );
558 				PushFollow(Follow._expr_in_expr204);
559 				a=expr();
560 
561 				state._fsp--;
562 
563 				dbg.Location( 65, 22 );
564 				PushFollow(Follow._expr_in_expr208);
565 				b=expr();
566 
567 				state._fsp--;
568 
569 
570 				Match(input, TokenTypes.Up, null);
571 				dbg.Location( 65, 35 );
572 				 value = a.subtract(b);
573 
574 				}
575 				break;
576 			case 3:
577 				dbg.EnterAlt( 3 );
578 
579 				// BuildOptions\\ProfileTreeGrammar.g3:66:9: ^( '*' a= expr b= expr )
580 				{
581 				dbg.Location( 66, 8 );
582 				dbg.Location( 66, 10 );
583 				Match(input,14,Follow._14_in_expr228);
584 
585 				Match(input, TokenTypes.Down, null);
586 				dbg.Location( 66, 15 );
587 				PushFollow(Follow._expr_in_expr232);
588 				a=expr();
589 
590 				state._fsp--;
591 
592 				dbg.Location( 66, 22 );
593 				PushFollow(Follow._expr_in_expr236);
594 				b=expr();
595 
596 				state._fsp--;
597 
598 
599 				Match(input, TokenTypes.Up, null);
600 				dbg.Location( 66, 35 );
601 				 value = a.multiply(b);
602 
603 				}
604 				break;
605 			case 4:
606 				dbg.EnterAlt( 4 );
607 
608 				// BuildOptions\\ProfileTreeGrammar.g3:67:9: ^( '/' a= expr b= expr )
609 				{
610 				dbg.Location( 67, 8 );
611 				dbg.Location( 67, 10 );
612 				Match(input,15,Follow._15_in_expr256);
613 
614 				Match(input, TokenTypes.Down, null);
615 				dbg.Location( 67, 15 );
616 				PushFollow(Follow._expr_in_expr260);
617 				a=expr();
618 
619 				state._fsp--;
620 
621 				dbg.Location( 67, 22 );
622 				PushFollow(Follow._expr_in_expr264);
623 				b=expr();
624 
625 				state._fsp--;
626 
627 
628 				Match(input, TokenTypes.Up, null);
629 				dbg.Location( 67, 35 );
630 				 value = a.divide(b);
631 
632 				}
633 				break;
634 			case 5:
635 				dbg.EnterAlt( 5 );
636 
637 				// BuildOptions\\ProfileTreeGrammar.g3:68:9: ^( '%' a= expr b= expr )
638 				{
639 				dbg.Location( 68, 8 );
640 				dbg.Location( 68, 10 );
641 				Match(input,11,Follow._11_in_expr284);
642 
643 				Match(input, TokenTypes.Down, null);
644 				dbg.Location( 68, 15 );
645 				PushFollow(Follow._expr_in_expr288);
646 				a=expr();
647 
648 				state._fsp--;
649 
650 				dbg.Location( 68, 22 );
651 				PushFollow(Follow._expr_in_expr292);
652 				b=expr();
653 
654 				state._fsp--;
655 
656 
657 				Match(input, TokenTypes.Up, null);
658 				dbg.Location( 68, 35 );
659 				 value = a.remainder(b);
660 
661 				}
662 				break;
663 			case 6:
664 				dbg.EnterAlt( 6 );
665 
666 				// BuildOptions\\ProfileTreeGrammar.g3:69:9: ID
667 				{
668 				dbg.Location( 69, 8 );
669 				ID4=(CommonTree)Match(input,ID,Follow._ID_in_expr311);
670 				dbg.Location( 69, 35 );
671 				 value = getValue((ID4!=null?ID4.Text:null));
672 
673 				}
674 				break;
675 			case 7:
676 				dbg.EnterAlt( 7 );
677 
678 				// BuildOptions\\ProfileTreeGrammar.g3:70:9: INT
679 				{
680 				dbg.Location( 70, 8 );
681 				INT5=(CommonTree)Match(input,INT,Follow._INT_in_expr347);
682 				dbg.Location( 70, 35 );
683 				 value = new BigInteger((INT5!=null?INT5.Text:null));
684 
685 				}
686 				break;
687 			case 8:
688 				dbg.EnterAlt( 8 );
689 
690 				// BuildOptions\\ProfileTreeGrammar.g3:71:9: call
691 				{
692 				dbg.Location( 71, 8 );
693 				PushFollow(Follow._call_in_expr382);
694 				call6=call();
695 
696 				state._fsp--;
697 
698 				dbg.Location( 71, 35 );
699 				 value = call6;
700 
701 				}
702 				break;
703 
704 			}
705 		}
706 		catch ( RecognitionException re )
707 		{
708 			ReportError(re);
709 			Recover(input,re);
710 		}
711 		finally
712 		{
713 		}
714 		dbg.Location(72, 4);
715 
716 		}
717 		finally
718 		{
719 			dbg.ExitRule( GrammarFileName, "expr" );
720 			DecRuleLevel();
721 			if ( RuleLevel == 0 )
722 			{
723 				dbg.Terminate();
724 			}
725 		}
726 
727 		return value;
728 	}
729 	// $ANTLR end "expr"
730 
731 
732 	// $ANTLR start "call"
733 	// BuildOptions\\ProfileTreeGrammar.g3:74:0: call returns [BigInteger value] : ^( CALL ID expr ) ;
call( )734 	private BigInteger call(  )
735 	{
736 		BigInteger value = default(BigInteger);
737 
738 		CommonTree ID8=null;
739 		BigInteger expr7 = default(BigInteger);
740 
741 		try
742 		{
743 			dbg.EnterRule( GrammarFileName, "call" );
744 			if ( RuleLevel == 0 )
745 			{
746 				dbg.Commence();
747 			}
748 			IncRuleLevel();
749 			dbg.Location( 74, -1 );
750 
751 		try
752 		{
753 			// BuildOptions\\ProfileTreeGrammar.g3:75:9: ( ^( CALL ID expr ) )
754 			dbg.EnterAlt( 1 );
755 
756 			// BuildOptions\\ProfileTreeGrammar.g3:75:9: ^( CALL ID expr )
757 			{
758 			dbg.Location( 75, 8 );
759 			dbg.Location( 75, 10 );
760 			Match(input,CALL,Follow._CALL_in_call430);
761 
762 			Match(input, TokenTypes.Down, null);
763 			dbg.Location( 75, 15 );
764 			ID8=(CommonTree)Match(input,ID,Follow._ID_in_call432);
765 			dbg.Location( 75, 18 );
766 			PushFollow(Follow._expr_in_call434);
767 			expr7=expr();
768 
769 			state._fsp--;
770 
771 
772 			Match(input, TokenTypes.Up, null);
773 			dbg.Location( 75, 35 );
774 			 BigInteger p = expr7;
775 			                                     CommonTree funcRoot = findFunction((ID8!=null?ID8.Text:null), p);
776 			                                     if (funcRoot == null) {
777 			                                         Console.Error.WriteLine("No match found for " + (ID8!=null?ID8.Text:null) + "(" + p + ")");
778 			                                     } else {
779 			                                         // Here we set up the local evaluator to run over the
780 			                                         // function definition with the parameter value.
781 			                                         // This re-reads a sub-AST of our input AST!
782 			                                         ProfileTreeGrammar e = new ProfileTreeGrammar(funcRoot, functionDefinitions, globalMemory, p);
783 			                                         value = e.expr();
784 			                                     }
785 
786 
787 			}
788 
789 		}
790 		catch ( RecognitionException re )
791 		{
792 			ReportError(re);
793 			Recover(input,re);
794 		}
795 		finally
796 		{
797 		}
798 		dbg.Location(87, 4);
799 
800 		}
801 		finally
802 		{
803 			dbg.ExitRule( GrammarFileName, "call" );
804 			DecRuleLevel();
805 			if ( RuleLevel == 0 )
806 			{
807 				dbg.Terminate();
808 			}
809 		}
810 
811 		return value;
812 	}
813 	// $ANTLR end "call"
814 	#endregion Rules
815 
816 
817 	#region Follow sets
818 	private static class Follow
819 	{
820 		public static readonly BitSet _stat_in_prog48 = new BitSet(new ulong[]{0x3CCF2UL});
821 		public static readonly BitSet _expr_in_stat63 = new BitSet(new ulong[]{0x2UL});
822 		public static readonly BitSet _17_in_stat98 = new BitSet(new ulong[]{0x4UL});
823 		public static readonly BitSet _ID_in_stat100 = new BitSet(new ulong[]{0x1CCD0UL});
824 		public static readonly BitSet _expr_in_stat102 = new BitSet(new ulong[]{0x8UL});
825 		public static readonly BitSet _FUNC_in_stat128 = new BitSet(new ulong[]{0x4UL});
826 		public static readonly BitSet _16_in_expr172 = new BitSet(new ulong[]{0x4UL});
827 		public static readonly BitSet _expr_in_expr176 = new BitSet(new ulong[]{0x1CCD0UL});
828 		public static readonly BitSet _expr_in_expr180 = new BitSet(new ulong[]{0x8UL});
829 		public static readonly BitSet _10_in_expr200 = new BitSet(new ulong[]{0x4UL});
830 		public static readonly BitSet _expr_in_expr204 = new BitSet(new ulong[]{0x1CCD0UL});
831 		public static readonly BitSet _expr_in_expr208 = new BitSet(new ulong[]{0x8UL});
832 		public static readonly BitSet _14_in_expr228 = new BitSet(new ulong[]{0x4UL});
833 		public static readonly BitSet _expr_in_expr232 = new BitSet(new ulong[]{0x1CCD0UL});
834 		public static readonly BitSet _expr_in_expr236 = new BitSet(new ulong[]{0x8UL});
835 		public static readonly BitSet _15_in_expr256 = new BitSet(new ulong[]{0x4UL});
836 		public static readonly BitSet _expr_in_expr260 = new BitSet(new ulong[]{0x1CCD0UL});
837 		public static readonly BitSet _expr_in_expr264 = new BitSet(new ulong[]{0x8UL});
838 		public static readonly BitSet _11_in_expr284 = new BitSet(new ulong[]{0x4UL});
839 		public static readonly BitSet _expr_in_expr288 = new BitSet(new ulong[]{0x1CCD0UL});
840 		public static readonly BitSet _expr_in_expr292 = new BitSet(new ulong[]{0x8UL});
841 		public static readonly BitSet _ID_in_expr311 = new BitSet(new ulong[]{0x2UL});
842 		public static readonly BitSet _INT_in_expr347 = new BitSet(new ulong[]{0x2UL});
843 		public static readonly BitSet _call_in_expr382 = new BitSet(new ulong[]{0x2UL});
844 		public static readonly BitSet _CALL_in_call430 = new BitSet(new ulong[]{0x4UL});
845 		public static readonly BitSet _ID_in_call432 = new BitSet(new ulong[]{0x1CCD0UL});
846 		public static readonly BitSet _expr_in_call434 = new BitSet(new ulong[]{0x8UL});
847 
848 	}
849 	#endregion Follow sets
850 }
851