ProfileTreeGrammar.cs revision 324c4644fee44b9898524c09511bd33c3f12e2df 
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;
11using BigInteger = java.math.BigInteger;
12using Console = System.Console;
13
14
15using System.Collections.Generic;
16using Antlr.Runtime;
17using Antlr.Runtime.Tree;
18using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;using Stack = System.Collections.Generic.Stack<object>;
19using List = System.Collections.IList;
20using ArrayList = System.Collections.Generic.List<object>;
21
22using Antlr.Runtime.Debug;
23using IOException = System.IO.IOException;
24[System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.1.2")]
25[System.CLSCompliant(false)]
26public 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; } }
58		public virtual void IncRuleLevel() { ruleLevel++; }
59		public virtual void DecRuleLevel() { ruleLevel--; }
60		public ProfileTreeGrammar( ITreeNodeStream input )
61			: this( input, new Profiler(null), new RecognizerSharedState() )
62		{
63		}
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
71	public ProfileTreeGrammar( ITreeNodeStream input, IDebugEventListener dbg )
72		: base( input, dbg, new RecognizerSharedState() )
73	{
74		Profiler p = (Profiler)dbg;
75		p.setParser(this);
76	}
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
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	}
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 )* ;
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 ( . )+ ) );
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 );
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 ) ;
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