Inheritance: RecognitionException
Ejemplo n.º 1
0
        private void mOR () {
            this.Enter_OR ();
            this.EnterRule ("OR", 1);
            this.TraceIn ("OR", 1);
            try {
                int _type = OR;
                int _channel = DefaultTokenChannel;
                // D:\\Compilers\\Verification\\LTLParser.g:46:4: ( '||' | 'or' )
                int alt1 = 2;
                try {
                    this.DebugEnterDecision (1, decisionCanBacktrack [1]);
                    int LA1_0 = this.input.LA (1);

                    if ((LA1_0 == '|'))
                        alt1 = 1;
                    else if ((LA1_0 == 'o'))
                        alt1 = 2;
                    else {
                        NoViableAltException nvae = new NoViableAltException ("", 1, 0, this.input);

                        this.DebugRecognitionException (nvae);
                        throw nvae;
                    }
                }
                finally {
                    this.DebugExitDecision (1);
                }
                switch (alt1) {
                    case 1 :
                        this.DebugEnterAlt (1);
                        // D:\\Compilers\\Verification\\LTLParser.g:46:6: '||'
                    {
                        this.DebugLocation (46, 6);
                        this.Match ("||");
                    }
                        break;
                    case 2 :
                        this.DebugEnterAlt (2);
                        // D:\\Compilers\\Verification\\LTLParser.g:46:13: 'or'
                    {
                        this.DebugLocation (46, 13);
                        this.Match ("or");
                    }
                        break;
                }
                this.state.type = _type;
                this.state.channel = _channel;
            }
            finally {
                this.TraceOut ("OR", 1);
                this.LeaveRule ("OR", 1);
                this.Leave_OR ();
            }
        }
Ejemplo n.º 2
0
 protected virtual void NoViableAlt(int s, IIntStream input)
 {
     if (this.recognizer.state.backtracking > 0)
     {
         this.recognizer.state.failed = true;
     }
     else
     {
         NoViableAltException nvae = new NoViableAltException(this.Description, this.decisionNumber, s, input);
         this.Error(nvae);
         throw nvae;
     }
 }
Ejemplo n.º 3
0
 protected virtual void NoViableAlt(int s, IIntStream input)
 {
     if (this.recognizer.state.backtracking > 0)
     {
         this.recognizer.state.failed = true;
     }
     else
     {
         NoViableAltException nvae = new NoViableAltException(this.Description, this.decisionNumber, s, input);
         this.Error(nvae);
         throw nvae;
     }
 }
Ejemplo n.º 4
0
        protected virtual void NoViableAlt(int s, IIntStream input)
        {
            if (recognizer.state.backtracking > 0)
            {
                recognizer.state.failed = true;
                return;
            }
            NoViableAltException nvae =
                new NoViableAltException(Description,
                                         decisionNumber,
                                         s,
                                         input);

            Error(nvae);
            throw nvae;
        }
Ejemplo n.º 5
0
        public override string GetErrorMessage(RecognitionException e, string[] tokenNames)
        {
            string msg = null;

            if (e is MismatchedTokenException)
            {
                MismatchedTokenException mte = (MismatchedTokenException)e;
                msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting " + GetCharErrorDisplay(mte.Expecting);
            }
            else if (e is NoViableAltException)
            {
                NoViableAltException nvae = (NoViableAltException)e;
                // for development, can add "decision=<<"+nvae.grammarDecisionDescription+">>"
                // and "(decision="+nvae.decisionNumber+") and
                // "state "+nvae.stateNumber
                msg = "no viable alternative at character " + GetCharErrorDisplay(e.Character);
            }
            else if (e is EarlyExitException)
            {
                EarlyExitException eee = (EarlyExitException)e;
                // for development, can add "(decision="+eee.decisionNumber+")"
                msg = "required (...)+ loop did not match anything at character " + GetCharErrorDisplay(e.Character);
            }
            else if (e is MismatchedNotSetException)
            {
                MismatchedNotSetException mse = (MismatchedNotSetException)e;
                msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + mse.Expecting;
            }
            else if (e is MismatchedSetException)
            {
                MismatchedSetException mse = (MismatchedSetException)e;
                msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + mse.Expecting;
            }
            else if (e is MismatchedRangeException)
            {
                MismatchedRangeException mre = (MismatchedRangeException)e;
                msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " +
                      GetCharErrorDisplay(mre.A) + ".." + GetCharErrorDisplay(mre.B);
            }
            else
            {
                msg = base.GetErrorMessage(e, tokenNames);
            }
            return(msg);
        }
		// $ANTLR start "entityChain"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:232:1: entityChain : ( thisKeyword | filteredEntity ) ( '.' filteredEntity )* ;
		public entityChain_return entityChain() // throws RecognitionException [1]
		{
			var retval = new entityChain_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken char_literal77 = null;
			thisKeyword_return thisKeyword75 = default( thisKeyword_return );

			filteredEntity_return filteredEntity76 = default( filteredEntity_return );

			filteredEntity_return filteredEntity78 = default( filteredEntity_return );


			CommonTree char_literal77_tree = null;

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:2: ( ( thisKeyword | filteredEntity ) ( '.' filteredEntity )* )
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:5: ( thisKeyword | filteredEntity ) ( '.' filteredEntity )*
				{
					root_0 = (CommonTree)adaptor.GetNilNode();

					// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:5: ( thisKeyword | filteredEntity )
					int alt28 = 2;
					int LA28_0 = input.LA( 1 );

					if ( ( LA28_0 == 91 ) )
						alt28 = 1;
					else if ( ( LA28_0 == ID ) )
						alt28 = 2;
					else
					{
						var nvae_d28s0 =
								new NoViableAltException( "", 28, 0, input );

						throw nvae_d28s0;
					}
					switch ( alt28 )
					{
						case 1:
							// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:7: thisKeyword
							{
								PushFollow( FOLLOW_thisKeyword_in_entityChain1224 );
								thisKeyword75 = thisKeyword();
								state.followingStackPointer--;

								adaptor.AddChild( root_0, thisKeyword75.Tree );
							}
							break;
						case 2:
							// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:21: filteredEntity
							{
								PushFollow( FOLLOW_filteredEntity_in_entityChain1228 );
								filteredEntity76 = filteredEntity();
								state.followingStackPointer--;

								adaptor.AddChild( root_0, filteredEntity76.Tree );
							}
							break;
					}

					// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:38: ( '.' filteredEntity )*
					do
					{
						int alt29 = 2;
						int LA29_0 = input.LA( 1 );

						if ( ( LA29_0 == 90 ) )
							alt29 = 1;


						switch ( alt29 )
						{
							case 1:
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:40: '.' filteredEntity
								{
									char_literal77 = (IToken)Match( input, 90, FOLLOW_90_in_entityChain1234 );
									char_literal77_tree = (CommonTree)adaptor.Create( char_literal77 );
									root_0 = (CommonTree)adaptor.BecomeRoot( char_literal77_tree, root_0 );

									PushFollow( FOLLOW_filteredEntity_in_entityChain1237 );
									filteredEntity78 = filteredEntity();
									state.followingStackPointer--;

									adaptor.AddChild( root_0, filteredEntity78.Tree );
								}
								break;

							default:
								goto loop29;
						}
					} while ( true );

					loop29:
					; // Stops C# compiler whining that label 'loop29' has no statements
				}

				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
		// $ANTLR start "rootLevelStatement"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:71:1: rootLevelStatement : ( formulaDeclaration | classDeclaration );
		public rootLevelStatement_return rootLevelStatement() // throws RecognitionException [1]
		{
			var retval = new rootLevelStatement_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			formulaDeclaration_return formulaDeclaration2 = default( formulaDeclaration_return );

			classDeclaration_return classDeclaration3 = default( classDeclaration_return );


			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:72:2: ( formulaDeclaration | classDeclaration )
				int alt2 = 2;
				int LA2_0 = input.LA( 1 );

				if ( ( LA2_0 == ID ) )
					alt2 = 1;
				else if ( ( LA2_0 == 57 ) )
					alt2 = 2;
				else
				{
					var nvae_d2s0 =
							new NoViableAltException( "", 2, 0, input );

					throw nvae_d2s0;
				}
				switch ( alt2 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:72:4: formulaDeclaration
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_formulaDeclaration_in_rootLevelStatement242 );
							formulaDeclaration2 = formulaDeclaration();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, formulaDeclaration2.Tree );
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:73:4: classDeclaration
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_classDeclaration_in_rootLevelStatement248 );
							classDeclaration3 = classDeclaration();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, classDeclaration3.Tree );
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
		// $ANTLR start "modulusOp"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:185:1: modulusOp : (x= 'mod' -> OP_MODULUS[$x] | x= '%' -> OP_MODULUS[$x] );
		public modulusOp_return modulusOp() // throws RecognitionException [1]
		{
			var retval = new modulusOp_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken x = null;

			CommonTree x_tree = null;
			var stream_78 = new RewriteRuleTokenStream( adaptor, "token 78" );
			var stream_77 = new RewriteRuleTokenStream( adaptor, "token 77" );

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:186:2: (x= 'mod' -> OP_MODULUS[$x] | x= '%' -> OP_MODULUS[$x] )
				int alt25 = 2;
				int LA25_0 = input.LA( 1 );

				if ( ( LA25_0 == 77 ) )
					alt25 = 1;
				else if ( ( LA25_0 == 78 ) )
					alt25 = 2;
				else
				{
					var nvae_d25s0 =
							new NoViableAltException( "", 25, 0, input );

					throw nvae_d25s0;
				}
				switch ( alt25 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:186:4: x= 'mod'
						{
							x = (IToken)Match( input, 77, FOLLOW_77_in_modulusOp957 );
							stream_77.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 186:12: -> OP_MODULUS[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_MODULUS, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:187:4: x= '%'
						{
							x = (IToken)Match( input, 78, FOLLOW_78_in_modulusOp969 );
							stream_78.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 187:12: -> OP_MODULUS[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_MODULUS, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
		// $ANTLR start "orOp"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:177:1: orOp : (x= 'or' -> OP_OR[$x] | x= '||' -> OP_OR[$x] );
		public orOp_return orOp() // throws RecognitionException [1]
		{
			var retval = new orOp_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken x = null;

			CommonTree x_tree = null;
			var stream_73 = new RewriteRuleTokenStream( adaptor, "token 73" );
			var stream_74 = new RewriteRuleTokenStream( adaptor, "token 74" );

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:178:2: (x= 'or' -> OP_OR[$x] | x= '||' -> OP_OR[$x] )
				int alt23 = 2;
				int LA23_0 = input.LA( 1 );

				if ( ( LA23_0 == 73 ) )
					alt23 = 1;
				else if ( ( LA23_0 == 74 ) )
					alt23 = 2;
				else
				{
					var nvae_d23s0 =
							new NoViableAltException( "", 23, 0, input );

					throw nvae_d23s0;
				}
				switch ( alt23 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:178:4: x= 'or'
						{
							x = (IToken)Match( input, 73, FOLLOW_73_in_orOp898 );
							stream_73.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 178:11: -> OP_OR[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_OR, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:179:4: x= '||'
						{
							x = (IToken)Match( input, 74, FOLLOW_74_in_orOp910 );
							stream_74.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 179:11: -> OP_OR[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_OR, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
		// $ANTLR start "multiplicativeExpr"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:150:1: multiplicativeExpr : unaryExpr ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )* ;
		public multiplicativeExpr_return multiplicativeExpr() // throws RecognitionException [1]
		{
			var retval = new multiplicativeExpr_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			unaryExpr_return unaryExpr58 = default( unaryExpr_return );

			multiplyOp_return multiplyOp59 = default( multiplyOp_return );

			divideOp_return divideOp60 = default( divideOp_return );

			modulusOp_return modulusOp61 = default( modulusOp_return );

			unaryExpr_return unaryExpr62 = default( unaryExpr_return );


			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:2: ( unaryExpr ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )* )
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:4: unaryExpr ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )*
				{
					root_0 = (CommonTree)adaptor.GetNilNode();

					PushFollow( FOLLOW_unaryExpr_in_multiplicativeExpr749 );
					unaryExpr58 = unaryExpr();
					state.followingStackPointer--;

					adaptor.AddChild( root_0, unaryExpr58.Tree );
					// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:14: ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )*
					do
					{
						int alt18 = 2;
						int LA18_0 = input.LA( 1 );

						if ( ( ( LA18_0 >= 77 && LA18_0 <= 78 ) || ( LA18_0 >= 88 && LA18_0 <= 89 ) ) )
							alt18 = 1;


						switch ( alt18 )
						{
							case 1:
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:16: ( multiplyOp | divideOp | modulusOp ) unaryExpr
								{
									// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:16: ( multiplyOp | divideOp | modulusOp )
									int alt17 = 3;
									switch ( input.LA( 1 ) )
									{
										case 88:
											{
												alt17 = 1;
											}
											break;
										case 89:
											{
												alt17 = 2;
											}
											break;
										case 77:
										case 78:
											{
												alt17 = 3;
											}
											break;
										default:
											var nvae_d17s0 =
													new NoViableAltException( "", 17, 0, input );

											throw nvae_d17s0;
									}

									switch ( alt17 )
									{
										case 1:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:18: multiplyOp
											{
												PushFollow( FOLLOW_multiplyOp_in_multiplicativeExpr755 );
												multiplyOp59 = multiplyOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( multiplyOp59.Tree, root_0 );
											}
											break;
										case 2:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:32: divideOp
											{
												PushFollow( FOLLOW_divideOp_in_multiplicativeExpr760 );
												divideOp60 = divideOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( divideOp60.Tree, root_0 );
											}
											break;
										case 3:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:44: modulusOp
											{
												PushFollow( FOLLOW_modulusOp_in_multiplicativeExpr765 );
												modulusOp61 = modulusOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( modulusOp61.Tree, root_0 );
											}
											break;
									}

									PushFollow( FOLLOW_unaryExpr_in_multiplicativeExpr770 );
									unaryExpr62 = unaryExpr();
									state.followingStackPointer--;

									adaptor.AddChild( root_0, unaryExpr62.Tree );
								}
								break;

							default:
								goto loop18;
						}
					} while ( true );

					loop18:
					; // Stops C# compiler whining that label 'loop18' has no statements
				}

				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
		// $ANTLR start "relationalExpr"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:144:1: relationalExpr : additiveExpr ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )* ;
		public relationalExpr_return relationalExpr() // throws RecognitionException [1]
		{
			var retval = new relationalExpr_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			additiveExpr_return additiveExpr48 = default( additiveExpr_return );

			ltOp_return ltOp49 = default( ltOp_return );

			gtOp_return gtOp50 = default( gtOp_return );

			lteOp_return lteOp51 = default( lteOp_return );

			gteOp_return gteOp52 = default( gteOp_return );

			additiveExpr_return additiveExpr53 = default( additiveExpr_return );


			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:2: ( additiveExpr ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )* )
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:4: additiveExpr ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )*
				{
					root_0 = (CommonTree)adaptor.GetNilNode();

					PushFollow( FOLLOW_additiveExpr_in_relationalExpr679 );
					additiveExpr48 = additiveExpr();
					state.followingStackPointer--;

					adaptor.AddChild( root_0, additiveExpr48.Tree );
					// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:17: ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )*
					do
					{
						int alt14 = 2;
						int LA14_0 = input.LA( 1 );

						if ( ( ( LA14_0 >= 82 && LA14_0 <= 85 ) ) )
							alt14 = 1;


						switch ( alt14 )
						{
							case 1:
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:19: ( ltOp | gtOp | lteOp | gteOp ) additiveExpr
								{
									// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:19: ( ltOp | gtOp | lteOp | gteOp )
									int alt13 = 4;
									switch ( input.LA( 1 ) )
									{
										case 82:
											{
												alt13 = 1;
											}
											break;
										case 83:
											{
												alt13 = 2;
											}
											break;
										case 84:
											{
												alt13 = 3;
											}
											break;
										case 85:
											{
												alt13 = 4;
											}
											break;
										default:
											var nvae_d13s0 =
													new NoViableAltException( "", 13, 0, input );

											throw nvae_d13s0;
									}

									switch ( alt13 )
									{
										case 1:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:21: ltOp
											{
												PushFollow( FOLLOW_ltOp_in_relationalExpr685 );
												ltOp49 = ltOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( ltOp49.Tree, root_0 );
											}
											break;
										case 2:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:29: gtOp
											{
												PushFollow( FOLLOW_gtOp_in_relationalExpr690 );
												gtOp50 = gtOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( gtOp50.Tree, root_0 );
											}
											break;
										case 3:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:37: lteOp
											{
												PushFollow( FOLLOW_lteOp_in_relationalExpr695 );
												lteOp51 = lteOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( lteOp51.Tree, root_0 );
											}
											break;
										case 4:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:46: gteOp
											{
												PushFollow( FOLLOW_gteOp_in_relationalExpr700 );
												gteOp52 = gteOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( gteOp52.Tree, root_0 );
											}
											break;
									}

									PushFollow( FOLLOW_additiveExpr_in_relationalExpr705 );
									additiveExpr53 = additiveExpr();
									state.followingStackPointer--;

									adaptor.AddChild( root_0, additiveExpr53.Tree );
								}
								break;

							default:
								goto loop14;
						}
					} while ( true );

					loop14:
					; // Stops C# compiler whining that label 'loop14' has no statements
				}

				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 12
0
	private int SpecialStateTransition20(DFA dfa, int s, IIntStream _input)
	{
		ITokenStream input = (ITokenStream)_input;
		int _s = s;
		s = -1;
		int LA20_1 = input.LA(1);
		int index20_1 = input.Index;
		switch (_s)
		{
		case 0:
			{
				input.Rewind();
				if ((EvaluatePredicate(synpred12_AS3_fragment))) {s = 62;}

				else if ((true)) {s = 2;}

				input.Seek(index20_1);
				break;
			}

		default:
			break;
		}

		if (s >= 0)
			return s;

		if (state.backtracking > 0) {state.failed=true; return -1;}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 20, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
Ejemplo n.º 13
0
 /** <summary>A hook for debugging interface</summary> */
 public virtual void Error(NoViableAltException nvae)
 {
 }
Ejemplo n.º 14
0
        /// <summary>
        /// What error message should be generated for the various exception types?
        ///
        /// Not very object-oriented code, but I like having all error message generation
        /// within one method rather than spread among all of the exception classes. This
        /// also makes it much easier for the exception handling because the exception
        /// classes do not have to have pointers back to this object to access utility
        /// routines and so on. Also, changing the message for an exception type would be
        /// difficult because you would have to subclassing exception, but then somehow get
        /// ANTLR to make those kinds of exception objects instead of the default.
        ///
        /// This looks weird, but trust me--it makes the most sense in terms of flexibility.
        ///
        /// For grammar debugging, you will want to override this to add more information
        /// such as the stack frame with GetRuleInvocationStack(e, this.GetType().Fullname)
        /// and, for no viable alts, the decision description and state etc...
        ///
        /// Override this to change the message generated for one or more exception types.
        /// </summary>
        public virtual string GetErrorMessage(RecognitionException e, string[] tokenNames)
        {
            string msg = e.Message;

            if (e is UnwantedTokenException)
            {
                UnwantedTokenException ute = (UnwantedTokenException)e;
                string tokenName           = "<unknown>";
                if (ute.Expecting == Token.EOF)
                {
                    tokenName = "EOF";
                }
                else
                {
                    tokenName = tokenNames[ute.Expecting];
                }
                msg = "extraneous input " + GetTokenErrorDisplay(ute.UnexpectedToken) +
                      " expecting " + tokenName;
            }
            else if (e is MissingTokenException)
            {
                MissingTokenException mte = (MissingTokenException)e;
                string tokenName          = "<unknown>";
                if (mte.Expecting == Token.EOF)
                {
                    tokenName = "EOF";
                }
                else
                {
                    tokenName = tokenNames[mte.Expecting];
                }
                msg = "missing " + tokenName + " at " + GetTokenErrorDisplay(e.Token);
            }
            else if (e is MismatchedTokenException)
            {
                MismatchedTokenException mte = (MismatchedTokenException)e;
                string tokenName             = "<unknown>";
                if (mte.Expecting == Token.EOF)
                {
                    tokenName = "EOF";
                }
                else
                {
                    tokenName = tokenNames[mte.Expecting];
                }
                msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting " + tokenName;
            }
            else if (e is MismatchedTreeNodeException)
            {
                MismatchedTreeNodeException mtne = (MismatchedTreeNodeException)e;
                string tokenName = "<unknown>";
                if (mtne.expecting == Token.EOF)
                {
                    tokenName = "EOF";
                }
                else
                {
                    tokenName = tokenNames[mtne.expecting];
                }
                // The ternary operator is only necessary because of a bug in the .NET framework
                msg = "mismatched tree node: " + ((mtne.Node != null && mtne.Node.ToString() != null) ?
                                                  mtne.Node : string.Empty) + " expecting " + tokenName;
            }
            else if (e is NoViableAltException)
            {
                NoViableAltException nvae = (NoViableAltException)e;
                // for development, can add "decision=<<"+nvae.grammarDecisionDescription+">>"
                // and "(decision="+nvae.decisionNumber+") and
                // "state "+nvae.stateNumber
                msg = "no viable alternative at input " + GetTokenErrorDisplay(e.Token);
            }
            else if (e is EarlyExitException)
            {
                EarlyExitException eee = (EarlyExitException)e;
                // for development, can add "(decision="+eee.decisionNumber+")"
                msg = "required (...)+ loop did not match anything at input " + GetTokenErrorDisplay(e.Token);
            }
            else if (e is MismatchedSetException)
            {
                MismatchedSetException mse = (MismatchedSetException)e;
                msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting set " + mse.expecting;
            }
            else if (e is MismatchedNotSetException)
            {
                MismatchedNotSetException mse = (MismatchedNotSetException)e;
                msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting set " + mse.expecting;
            }
            else if (e is FailedPredicateException)
            {
                FailedPredicateException fpe = (FailedPredicateException)e;
                msg = "rule " + fpe.ruleName + " failed predicate: {" + fpe.predicateText + "}?";
            }
            return(msg);
        }
		// $ANTLR start "classLevelStatement"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:88:1: classLevelStatement : ( propertyDeclaration | relationshipDeclaration );
		public classLevelStatement_return classLevelStatement() // throws RecognitionException [1]
		{
			var retval = new classLevelStatement_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			propertyDeclaration_return propertyDeclaration15 = default( propertyDeclaration_return );

			relationshipDeclaration_return relationshipDeclaration16 = default( relationshipDeclaration_return );


			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:89:2: ( propertyDeclaration | relationshipDeclaration )
				int alt5 = 2;
				int LA5_0 = input.LA( 1 );

				if ( ( LA5_0 == 62 ) )
					alt5 = 1;
				else if ( ( LA5_0 == 67 ) )
					alt5 = 2;
				else
				{
					var nvae_d5s0 =
							new NoViableAltException( "", 5, 0, input );

					throw nvae_d5s0;
				}
				switch ( alt5 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:89:4: propertyDeclaration
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_propertyDeclaration_in_classLevelStatement354 );
							propertyDeclaration15 = propertyDeclaration();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, propertyDeclaration15.Tree );
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:90:4: relationshipDeclaration
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_relationshipDeclaration_in_classLevelStatement359 );
							relationshipDeclaration16 = relationshipDeclaration();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, relationshipDeclaration16.Tree );
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 16
0
		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
Ejemplo n.º 17
0
	public AstParserRuleReturnScope<CommonTree, IToken> compilationUnit()
	{
		EnterRule_compilationUnit();
		EnterRule("compilationUnit", 1);
		TraceIn("compilationUnit", 1);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		AstParserRuleReturnScope<CommonTree, IToken> as2CompilationUnit1 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> as3CompilationUnit2 = default(AstParserRuleReturnScope<CommonTree, IToken>);

		RewriteRuleSubtreeStream stream_as2CompilationUnit=new RewriteRuleSubtreeStream(adaptor,"rule as2CompilationUnit");
		RewriteRuleSubtreeStream stream_as3CompilationUnit=new RewriteRuleSubtreeStream(adaptor,"rule as3CompilationUnit");
		try { DebugEnterRule(GrammarFileName, "compilationUnit");
		DebugLocation(114, 1);
		try
		{
			// AS3.g:115:2: ( ( as2CompilationUnit | as3CompilationUnit ) -> ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? ) )
			DebugEnterAlt(1);
			// AS3.g:115:4: ( as2CompilationUnit | as3CompilationUnit )
			{
			DebugLocation(115, 4);
			// AS3.g:115:4: ( as2CompilationUnit | as3CompilationUnit )
			int alt1=2;
			try { DebugEnterSubRule(1);
			try { DebugEnterDecision(1, false);
			int LA1_1 = input.LA(1);

			if ((LA1_1==CLASS||LA1_1==DYNAMIC||LA1_1==IDENT||LA1_1==IMPORT||(LA1_1>=INCLUDE_DIRECTIVE && LA1_1<=INTERFACE)||LA1_1==INTERNAL||LA1_1==PRIVATE||(LA1_1>=PROTECTED && LA1_1<=PUBLIC)||LA1_1==STATIC||(LA1_1>=244 && LA1_1<=246)||LA1_1==250||LA1_1==252))
			{
				alt1 = 1;
			}
			else if ((LA1_1==PACKAGE))
			{
				alt1 = 2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 1, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(1); }
			switch (alt1)
			{
			case 1:
				DebugEnterAlt(1);
				// AS3.g:115:6: as2CompilationUnit
				{
				DebugLocation(115, 6);
				PushFollow(Follow._as2CompilationUnit_in_compilationUnit476);
				as2CompilationUnit1=as2CompilationUnit();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) stream_as2CompilationUnit.Add(as2CompilationUnit1.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// AS3.g:116:5: as3CompilationUnit
				{
				DebugLocation(116, 5);
				PushFollow(Follow._as3CompilationUnit_in_compilationUnit482);
				as3CompilationUnit2=as3CompilationUnit();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) stream_as3CompilationUnit.Add(as3CompilationUnit2.Tree);

				}
				break;

			}
			} finally { DebugExitSubRule(1); }



			{
			// AST REWRITE
			// elements: as2CompilationUnit, as3CompilationUnit
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if (state.backtracking == 0) {
			retval.Tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);

			root_0 = (CommonTree)adaptor.Nil();
			// 117:5: -> ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? )
			{
				DebugLocation(117, 8);
				// AS3.g:117:8: ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? )
				{
				CommonTree root_1 = (CommonTree)adaptor.Nil();
				DebugLocation(117, 10);
				root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(COMPILATION_UNIT, "COMPILATION_UNIT"), root_1);

				DebugLocation(117, 27);
				// AS3.g:117:27: ( as2CompilationUnit )?
				if (stream_as2CompilationUnit.HasNext)
				{
					DebugLocation(117, 27);
					adaptor.AddChild(root_1, stream_as2CompilationUnit.NextTree());

				}
				stream_as2CompilationUnit.Reset();
				DebugLocation(117, 47);
				// AS3.g:117:47: ( as3CompilationUnit )?
				if (stream_as3CompilationUnit.HasNext)
				{
					DebugLocation(117, 47);
					adaptor.AddChild(root_1, stream_as3CompilationUnit.NextTree());

				}
				stream_as3CompilationUnit.Reset();

				adaptor.AddChild(root_0, root_1);
				}

			}

			retval.Tree = root_0;
			}
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("compilationUnit", 1);
			LeaveRule("compilationUnit", 1);
			LeaveRule_compilationUnit();
		}
		DebugLocation(118, 1);
		} finally { DebugExitRule(GrammarFileName, "compilationUnit"); }
		return retval;

	}
		// $ANTLR start "equalityExpr"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:141:1: equalityExpr : relationalExpr ( ( equalsOp | notEqualsOp ) relationalExpr )* ;
		public equalityExpr_return equalityExpr() // throws RecognitionException [1]
		{
			var retval = new equalityExpr_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			relationalExpr_return relationalExpr44 = default( relationalExpr_return );

			equalsOp_return equalsOp45 = default( equalsOp_return );

			notEqualsOp_return notEqualsOp46 = default( notEqualsOp_return );

			relationalExpr_return relationalExpr47 = default( relationalExpr_return );


			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:2: ( relationalExpr ( ( equalsOp | notEqualsOp ) relationalExpr )* )
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:4: relationalExpr ( ( equalsOp | notEqualsOp ) relationalExpr )*
				{
					root_0 = (CommonTree)adaptor.GetNilNode();

					PushFollow( FOLLOW_relationalExpr_in_equalityExpr650 );
					relationalExpr44 = relationalExpr();
					state.followingStackPointer--;

					adaptor.AddChild( root_0, relationalExpr44.Tree );
					// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:19: ( ( equalsOp | notEqualsOp ) relationalExpr )*
					do
					{
						int alt12 = 2;
						int LA12_0 = input.LA( 1 );

						if ( ( LA12_0 == 68 || ( LA12_0 >= 79 && LA12_0 <= 81 ) ) )
							alt12 = 1;


						switch ( alt12 )
						{
							case 1:
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:21: ( equalsOp | notEqualsOp ) relationalExpr
								{
									// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:21: ( equalsOp | notEqualsOp )
									int alt11 = 2;
									int LA11_0 = input.LA( 1 );

									if ( ( LA11_0 == 68 || LA11_0 == 79 ) )
										alt11 = 1;
									else if ( ( ( LA11_0 >= 80 && LA11_0 <= 81 ) ) )
										alt11 = 2;
									else
									{
										var nvae_d11s0 =
												new NoViableAltException( "", 11, 0, input );

										throw nvae_d11s0;
									}
									switch ( alt11 )
									{
										case 1:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:23: equalsOp
											{
												PushFollow( FOLLOW_equalsOp_in_equalityExpr656 );
												equalsOp45 = equalsOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( equalsOp45.Tree, root_0 );
											}
											break;
										case 2:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:35: notEqualsOp
											{
												PushFollow( FOLLOW_notEqualsOp_in_equalityExpr661 );
												notEqualsOp46 = notEqualsOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( notEqualsOp46.Tree, root_0 );
											}
											break;
									}

									PushFollow( FOLLOW_relationalExpr_in_equalityExpr666 );
									relationalExpr47 = relationalExpr();
									state.followingStackPointer--;

									adaptor.AddChild( root_0, relationalExpr47.Tree );
								}
								break;

							default:
								goto loop12;
						}
					} while ( true );

					loop12:
					; // Stops C# compiler whining that label 'loop12' has no statements
				}

				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 19
0
	private AstParserRuleReturnScope<CommonTree, IToken> parameterDeclaration()
	{
		EnterRule_parameterDeclaration();
		EnterRule("parameterDeclaration", 34);
		TraceIn("parameterDeclaration", 34);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		AstParserRuleReturnScope<CommonTree, IToken> basicParameterDeclaration112 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> parameterRestDeclaration113 = default(AstParserRuleReturnScope<CommonTree, IToken>);

		try { DebugEnterRule(GrammarFileName, "parameterDeclaration");
		DebugLocation(339, 1);
		try
		{
			// AS3.g:340:2: ( basicParameterDeclaration | parameterRestDeclaration )
			int alt27=2;
			try { DebugEnterDecision(27, false);
			int LA27_1 = input.LA(1);

			if ((LA27_1==AS||LA27_1==CONST||LA27_1==DYNAMIC||LA27_1==GET||LA27_1==IDENT||LA27_1==IS||LA27_1==NAMESPACE||LA27_1==SET||LA27_1==SUPER||LA27_1==USE||LA27_1==XML))
			{
				alt27 = 1;
			}
			else if ((LA27_1==REST))
			{
				alt27 = 2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 27, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(27); }
			switch (alt27)
			{
			case 1:
				DebugEnterAlt(1);
				// AS3.g:340:4: basicParameterDeclaration
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(340, 4);
				PushFollow(Follow._basicParameterDeclaration_in_parameterDeclaration1862);
				basicParameterDeclaration112=basicParameterDeclaration();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, basicParameterDeclaration112.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// AS3.g:340:32: parameterRestDeclaration
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(340, 32);
				PushFollow(Follow._parameterRestDeclaration_in_parameterDeclaration1866);
				parameterRestDeclaration113=parameterRestDeclaration();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, parameterRestDeclaration113.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("parameterDeclaration", 34);
			LeaveRule("parameterDeclaration", 34);
			LeaveRule_parameterDeclaration();
		}
		DebugLocation(341, 1);
		} finally { DebugExitRule(GrammarFileName, "parameterDeclaration"); }
		return retval;

	}
		// $ANTLR start "additiveExpr"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:147:1: additiveExpr : multiplicativeExpr ( ( addOp | subtractOp ) multiplicativeExpr )* ;
		public additiveExpr_return additiveExpr() // throws RecognitionException [1]
		{
			var retval = new additiveExpr_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			multiplicativeExpr_return multiplicativeExpr54 = default( multiplicativeExpr_return );

			addOp_return addOp55 = default( addOp_return );

			subtractOp_return subtractOp56 = default( subtractOp_return );

			multiplicativeExpr_return multiplicativeExpr57 = default( multiplicativeExpr_return );


			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:2: ( multiplicativeExpr ( ( addOp | subtractOp ) multiplicativeExpr )* )
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:4: multiplicativeExpr ( ( addOp | subtractOp ) multiplicativeExpr )*
				{
					root_0 = (CommonTree)adaptor.GetNilNode();

					PushFollow( FOLLOW_multiplicativeExpr_in_additiveExpr719 );
					multiplicativeExpr54 = multiplicativeExpr();
					state.followingStackPointer--;

					adaptor.AddChild( root_0, multiplicativeExpr54.Tree );
					// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:23: ( ( addOp | subtractOp ) multiplicativeExpr )*
					do
					{
						int alt16 = 2;
						int LA16_0 = input.LA( 1 );

						if ( ( ( LA16_0 >= 86 && LA16_0 <= 87 ) ) )
							alt16 = 1;


						switch ( alt16 )
						{
							case 1:
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:25: ( addOp | subtractOp ) multiplicativeExpr
								{
									// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:25: ( addOp | subtractOp )
									int alt15 = 2;
									int LA15_0 = input.LA( 1 );

									if ( ( LA15_0 == 86 ) )
										alt15 = 1;
									else if ( ( LA15_0 == 87 ) )
										alt15 = 2;
									else
									{
										var nvae_d15s0 =
												new NoViableAltException( "", 15, 0, input );

										throw nvae_d15s0;
									}
									switch ( alt15 )
									{
										case 1:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:27: addOp
											{
												PushFollow( FOLLOW_addOp_in_additiveExpr725 );
												addOp55 = addOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( addOp55.Tree, root_0 );
											}
											break;
										case 2:
											// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:36: subtractOp
											{
												PushFollow( FOLLOW_subtractOp_in_additiveExpr730 );
												subtractOp56 = subtractOp();
												state.followingStackPointer--;

												root_0 = (CommonTree)adaptor.BecomeRoot( subtractOp56.Tree, root_0 );
											}
											break;
									}

									PushFollow( FOLLOW_multiplicativeExpr_in_additiveExpr735 );
									multiplicativeExpr57 = multiplicativeExpr();
									state.followingStackPointer--;

									adaptor.AddChild( root_0, multiplicativeExpr57.Tree );
								}
								break;

							default:
								goto loop16;
						}
					} while ( true );

					loop16:
					; // Stops C# compiler whining that label 'loop16' has no statements
				}

				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 21
0
	private AstParserRuleReturnScope<CommonTree, IToken> statement()
	{
		EnterRule_statement();
		EnterRule("statement", 41);
		TraceIn("statement", 41);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		AstParserRuleReturnScope<CommonTree, IToken> block130 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> declarationStatement131 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> expressionStatement132 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> ifStatement133 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> forEachStatement134 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> whileStatement135 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> doWhileStatement136 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> withStatement137 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> switchStatement138 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> breakStatement139 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> continueStatement140 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> returnStatement141 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> throwStatement142 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> tryStatement143 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> defaultXMLNamespaceStatement144 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> semi145 = default(AstParserRuleReturnScope<CommonTree, IToken>);

		try { DebugEnterRule(GrammarFileName, "statement");
		DebugLocation(371, 1);
		try
		{
			// AS3.g:372:2: ( ( LCURLY )=> block | declarationStatement | expressionStatement | ifStatement | forEachStatement | whileStatement | doWhileStatement | withStatement | switchStatement | breakStatement | continueStatement | returnStatement | throwStatement | tryStatement | defaultXMLNamespaceStatement | semi )
			int alt34=16;
			try { DebugEnterDecision(34, false);
			switch (input.LA(1))
			{
			case LCURLY:
				{
				int LA34_2 = input.LA(2);

				if ((EvaluatePredicate(synpred13_AS3_fragment)))
				{
					alt34 = 1;
				}
				else if ((true))
				{
					alt34 = 3;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 34, 1, input, 2);
					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case CONST:
			case VAR:
				{
				alt34 = 2;
				}
				break;
			case AS:
			case BNOT:
			case DEC:
			case DECIMAL_LITERAL:
			case DYNAMIC:
			case E4X_ATTRI:
			case FALSE:
			case FLOAT_LITERAL:
			case FUNCTION:
			case GET:
			case HEX_LITERAL:
			case IDENT:
			case INC:
			case INTERNAL:
			case IS:
			case LBRACK:
			case LNOT:
			case LPAREN:
			case MINUS:
			case NAMESPACE:
			case NEW:
			case NULL:
			case OCTAL_LITERAL:
			case PLUS:
			case PRIVATE:
			case PROTECTED:
			case PUBLIC:
			case REGEX_LITERAL:
			case SET:
			case STRING_LITERAL_DOUBLE:
			case STRING_LITERAL_SINGLE:
			case SUPER:
			case TRUE:
			case USE:
			case XML:
			case XML_LITERAL:
			case 243:
			case 255:
			case 256:
			case 257:
				{
				alt34 = 3;
				}
				break;
			case IF:
				{
				alt34 = 4;
				}
				break;
			case FOR:
				{
				alt34 = 5;
				}
				break;
			case WHILE:
				{
				alt34 = 6;
				}
				break;
			case DO:
				{
				alt34 = 7;
				}
				break;
			case WITH:
				{
				alt34 = 8;
				}
				break;
			case SWITCH:
				{
				alt34 = 9;
				}
				break;
			case BREAK:
				{
				alt34 = 10;
				}
				break;
			case CONTINUE:
				{
				alt34 = 11;
				}
				break;
			case RETURN:
				{
				alt34 = 12;
				}
				break;
			case 253:
				{
				alt34 = 13;
				}
				break;
			case 254:
				{
				alt34 = 14;
				}
				break;
			case DEFAULT:
				{
				alt34 = 15;
				}
				break;
			case SEMI:
				{
				alt34 = 16;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 34, 0, input, 1);
					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(34); }
			switch (alt34)
			{
			case 1:
				DebugEnterAlt(1);
				// AS3.g:372:4: ( LCURLY )=> block
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(372, 16);
				PushFollow(Follow._block_in_statement2037);
				block130=block();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, block130.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// AS3.g:374:4: declarationStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(374, 4);
				PushFollow(Follow._declarationStatement_in_statement2043);
				declarationStatement131=declarationStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, declarationStatement131.Tree);

				}
				break;
			case 3:
				DebugEnterAlt(3);
				// AS3.g:376:4: expressionStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(376, 4);
				PushFollow(Follow._expressionStatement_in_statement2050);
				expressionStatement132=expressionStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, expressionStatement132.Tree);

				}
				break;
			case 4:
				DebugEnterAlt(4);
				// AS3.g:378:4: ifStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(378, 4);
				PushFollow(Follow._ifStatement_in_statement2056);
				ifStatement133=ifStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, ifStatement133.Tree);

				}
				break;
			case 5:
				DebugEnterAlt(5);
				// AS3.g:380:4: forEachStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(380, 4);
				PushFollow(Follow._forEachStatement_in_statement2062);
				forEachStatement134=forEachStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, forEachStatement134.Tree);

				}
				break;
			case 6:
				DebugEnterAlt(6);
				// AS3.g:382:4: whileStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(382, 4);
				PushFollow(Follow._whileStatement_in_statement2068);
				whileStatement135=whileStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, whileStatement135.Tree);

				}
				break;
			case 7:
				DebugEnterAlt(7);
				// AS3.g:384:4: doWhileStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(384, 4);
				PushFollow(Follow._doWhileStatement_in_statement2074);
				doWhileStatement136=doWhileStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, doWhileStatement136.Tree);

				}
				break;
			case 8:
				DebugEnterAlt(8);
				// AS3.g:386:4: withStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(386, 4);
				PushFollow(Follow._withStatement_in_statement2081);
				withStatement137=withStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, withStatement137.Tree);

				}
				break;
			case 9:
				DebugEnterAlt(9);
				// AS3.g:388:4: switchStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(388, 4);
				PushFollow(Follow._switchStatement_in_statement2088);
				switchStatement138=switchStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, switchStatement138.Tree);

				}
				break;
			case 10:
				DebugEnterAlt(10);
				// AS3.g:390:4: breakStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(390, 4);
				PushFollow(Follow._breakStatement_in_statement2095);
				breakStatement139=breakStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, breakStatement139.Tree);

				}
				break;
			case 11:
				DebugEnterAlt(11);
				// AS3.g:392:4: continueStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(392, 4);
				PushFollow(Follow._continueStatement_in_statement2101);
				continueStatement140=continueStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, continueStatement140.Tree);

				}
				break;
			case 12:
				DebugEnterAlt(12);
				// AS3.g:394:4: returnStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(394, 4);
				PushFollow(Follow._returnStatement_in_statement2107);
				returnStatement141=returnStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, returnStatement141.Tree);

				}
				break;
			case 13:
				DebugEnterAlt(13);
				// AS3.g:396:4: throwStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(396, 4);
				PushFollow(Follow._throwStatement_in_statement2113);
				throwStatement142=throwStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, throwStatement142.Tree);

				}
				break;
			case 14:
				DebugEnterAlt(14);
				// AS3.g:398:4: tryStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(398, 4);
				PushFollow(Follow._tryStatement_in_statement2120);
				tryStatement143=tryStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, tryStatement143.Tree);

				}
				break;
			case 15:
				DebugEnterAlt(15);
				// AS3.g:400:4: defaultXMLNamespaceStatement
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(400, 4);
				PushFollow(Follow._defaultXMLNamespaceStatement_in_statement2127);
				defaultXMLNamespaceStatement144=defaultXMLNamespaceStatement();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, defaultXMLNamespaceStatement144.Tree);

				}
				break;
			case 16:
				DebugEnterAlt(16);
				// AS3.g:402:9: semi
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(402, 9);
				PushFollow(Follow._semi_in_statement2142);
				semi145=semi();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, semi145.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("statement", 41);
			LeaveRule("statement", 41);
			LeaveRule_statement();
		}
		DebugLocation(404, 1);
		} finally { DebugExitRule(GrammarFileName, "statement"); }
		return retval;

	}
		// $ANTLR start "primaryExpr"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:159:1: primaryExpr : ( '(' expression ')' | number | booleanValue | LITERAL | functionCall | entityChain );
		public primaryExpr_return primaryExpr() // throws RecognitionException [1]
		{
			var retval = new primaryExpr_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken char_literal67 = null;
			IToken char_literal69 = null;
			IToken LITERAL72 = null;
			expression_return expression68 = default( expression_return );

			number_return number70 = default( number_return );

			booleanValue_return booleanValue71 = default( booleanValue_return );

			functionCall_return functionCall73 = default( functionCall_return );

			entityChain_return entityChain74 = default( entityChain_return );


			CommonTree char_literal67_tree = null;
			CommonTree char_literal69_tree = null;
			CommonTree LITERAL72_tree = null;

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:160:2: ( '(' expression ')' | number | booleanValue | LITERAL | functionCall | entityChain )
				int alt21 = 6;
				switch ( input.LA( 1 ) )
				{
					case 69:
						{
							alt21 = 1;
						}
						break;
					case INT:
					case FLOAT:
						{
							alt21 = 2;
						}
						break;
					case 95:
					case 96:
						{
							alt21 = 3;
						}
						break;
					case LITERAL:
						{
							alt21 = 4;
						}
						break;
					case ID:
						{
							int LA21_5 = input.LA( 2 );

							if ( ( LA21_5 == 69 ) )
								alt21 = 5;
							else if ( ( LA21_5 == 60 || LA21_5 == 63 || LA21_5 == 68 || LA21_5 == 70 || ( LA21_5 >= 73 && LA21_5 <= 90 ) || ( LA21_5 >= 92 && LA21_5 <= 94 ) ) )
								alt21 = 6;
							else
							{
								var nvae_d21s5 =
										new NoViableAltException( "", 21, 5, input );

								throw nvae_d21s5;
							}
						}
						break;
					case 91:
						{
							alt21 = 6;
						}
						break;
					default:
						var nvae_d21s0 =
								new NoViableAltException( "", 21, 0, input );

						throw nvae_d21s0;
				}

				switch ( alt21 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:160:4: '(' expression ')'
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							char_literal67 = (IToken)Match( input, 69, FOLLOW_69_in_primaryExpr819 );
							PushFollow( FOLLOW_expression_in_primaryExpr822 );
							expression68 = expression();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, expression68.Tree );
							char_literal69 = (IToken)Match( input, 70, FOLLOW_70_in_primaryExpr824 );
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:161:4: number
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_number_in_primaryExpr830 );
							number70 = number();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, number70.Tree );
						}
						break;
					case 3:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:162:4: booleanValue
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_booleanValue_in_primaryExpr835 );
							booleanValue71 = booleanValue();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, booleanValue71.Tree );
						}
						break;
					case 4:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:163:4: LITERAL
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							LITERAL72 = (IToken)Match( input, LITERAL, FOLLOW_LITERAL_in_primaryExpr840 );
							LITERAL72_tree = (CommonTree)adaptor.Create( LITERAL72 );
							adaptor.AddChild( root_0, LITERAL72_tree );
						}
						break;
					case 5:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:164:4: functionCall
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_functionCall_in_primaryExpr845 );
							functionCall73 = functionCall();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, functionCall73.Tree );
						}
						break;
					case 6:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:165:4: entityChain
						{
							root_0 = (CommonTree)adaptor.GetNilNode();

							PushFollow( FOLLOW_entityChain_in_primaryExpr850 );
							entityChain74 = entityChain();
							state.followingStackPointer--;

							adaptor.AddChild( root_0, entityChain74.Tree );
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 23
0
	private AstParserRuleReturnScope<CommonTree, IToken> forInClauseDecl()
	{
		EnterRule_forInClauseDecl();
		EnterRule("forInClauseDecl", 62);
		TraceIn("forInClauseDecl", 62);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		AstParserRuleReturnScope<CommonTree, IToken> varOrConst206 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> ident207 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> typeExpression208 = default(AstParserRuleReturnScope<CommonTree, IToken>);
		AstParserRuleReturnScope<CommonTree, IToken> ident209 = default(AstParserRuleReturnScope<CommonTree, IToken>);

		try { DebugEnterRule(GrammarFileName, "forInClauseDecl");
		DebugLocation(522, 1);
		try
		{
			// AS3.g:523:2: ( varOrConst ident ( typeExpression )? | ident )
			int alt45=2;
			try { DebugEnterDecision(45, false);
			int LA45_1 = input.LA(1);

			if ((LA45_1==CONST||LA45_1==VAR))
			{
				alt45 = 1;
			}
			else if ((LA45_1==AS||LA45_1==DYNAMIC||LA45_1==GET||LA45_1==IDENT||LA45_1==IS||LA45_1==NAMESPACE||LA45_1==SET||LA45_1==SUPER||LA45_1==USE||LA45_1==XML))
			{
				alt45 = 2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 45, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(45); }
			switch (alt45)
			{
			case 1:
				DebugEnterAlt(1);
				// AS3.g:523:4: varOrConst ident ( typeExpression )?
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(523, 4);
				PushFollow(Follow._varOrConst_in_forInClauseDecl2840);
				varOrConst206=varOrConst();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, varOrConst206.Tree);
				DebugLocation(523, 15);
				PushFollow(Follow._ident_in_forInClauseDecl2842);
				ident207=ident();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, ident207.Tree);
				DebugLocation(523, 21);
				// AS3.g:523:21: ( typeExpression )?
				int alt44=2;
				try { DebugEnterSubRule(44);
				try { DebugEnterDecision(44, false);
				int LA44_1 = input.LA(1);

				if ((LA44_1==COLON))
				{
					alt44 = 1;
				}
				} finally { DebugExitDecision(44); }
				switch (alt44)
				{
				case 1:
					DebugEnterAlt(1);
					// AS3.g:523:21: typeExpression
					{
					DebugLocation(523, 21);
					PushFollow(Follow._typeExpression_in_forInClauseDecl2844);
					typeExpression208=typeExpression();
					PopFollow();
					if (state.failed) return retval;
					if (state.backtracking == 0) adaptor.AddChild(root_0, typeExpression208.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(44); }


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// AS3.g:524:11: ident
				{
				root_0 = (CommonTree)adaptor.Nil();

				DebugLocation(524, 11);
				PushFollow(Follow._ident_in_forInClauseDecl2858);
				ident209=ident();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, ident209.Tree);

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("forInClauseDecl", 62);
			LeaveRule("forInClauseDecl", 62);
			LeaveRule_forInClauseDecl();
		}
		DebugLocation(525, 1);
		} finally { DebugExitRule(GrammarFileName, "forInClauseDecl"); }
		return retval;

	}
		// $ANTLR start "andOp"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:181:1: andOp : (x= 'and' -> OP_AND[$x] | x= '&&' -> OP_AND[$x] );
		public andOp_return andOp() // throws RecognitionException [1]
		{
			var retval = new andOp_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken x = null;

			CommonTree x_tree = null;
			var stream_75 = new RewriteRuleTokenStream( adaptor, "token 75" );
			var stream_76 = new RewriteRuleTokenStream( adaptor, "token 76" );

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:182:2: (x= 'and' -> OP_AND[$x] | x= '&&' -> OP_AND[$x] )
				int alt24 = 2;
				int LA24_0 = input.LA( 1 );

				if ( ( LA24_0 == 75 ) )
					alt24 = 1;
				else if ( ( LA24_0 == 76 ) )
					alt24 = 2;
				else
				{
					var nvae_d24s0 =
							new NoViableAltException( "", 24, 0, input );

					throw nvae_d24s0;
				}
				switch ( alt24 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:182:4: x= 'and'
						{
							x = (IToken)Match( input, 75, FOLLOW_75_in_andOp927 );
							stream_75.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 182:12: -> OP_AND[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_AND, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:183:4: x= '&&'
						{
							x = (IToken)Match( input, 76, FOLLOW_76_in_andOp939 );
							stream_76.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 183:12: -> OP_AND[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_AND, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 25
0
	private AstParserRuleReturnScope<CommonTree, IToken> typeExpression()
	{
		EnterRule_typeExpression();
		EnterRule("typeExpression", 71);
		TraceIn("typeExpression", 71);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken COLON232 = default(IToken);
		IToken string_literal234 = default(IToken);
		IToken STAR235 = default(IToken);
		AstParserRuleReturnScope<CommonTree, IToken> typeIdentifier233 = default(AstParserRuleReturnScope<CommonTree, IToken>);

		CommonTree COLON232_tree = default(CommonTree);
		CommonTree string_literal234_tree = default(CommonTree);
		CommonTree STAR235_tree = default(CommonTree);
		RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON");
		RewriteRuleITokenStream stream_257=new RewriteRuleITokenStream(adaptor,"token 257");
		RewriteRuleITokenStream stream_STAR=new RewriteRuleITokenStream(adaptor,"token STAR");
		RewriteRuleSubtreeStream stream_typeIdentifier=new RewriteRuleSubtreeStream(adaptor,"rule typeIdentifier");
		try { DebugEnterRule(GrammarFileName, "typeExpression");
		DebugLocation(567, 4);
		try
		{
			// AS3.g:568:2: ( COLON ( typeIdentifier | 'void' | STAR ) -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? ) )
			DebugEnterAlt(1);
			// AS3.g:569:3: COLON ( typeIdentifier | 'void' | STAR )
			{
			DebugLocation(569, 3);
			COLON232=(IToken)Match(input,COLON,Follow._COLON_in_typeExpression3075); if (state.failed) return retval; 
			if (state.backtracking == 0) stream_COLON.Add(COLON232);

			DebugLocation(569, 9);
			// AS3.g:569:9: ( typeIdentifier | 'void' | STAR )
			int alt49=3;
			try { DebugEnterSubRule(49);
			try { DebugEnterDecision(49, false);
			switch (input.LA(1))
			{
			case AS:
			case DYNAMIC:
			case GET:
			case IDENT:
			case IS:
			case NAMESPACE:
			case SET:
			case SUPER:
			case USE:
			case XML:
				{
				alt49 = 1;
				}
				break;
			case 257:
				{
				alt49 = 2;
				}
				break;
			case STAR:
				{
				alt49 = 3;
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 49, 0, input, 1);
					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(49); }
			switch (alt49)
			{
			case 1:
				DebugEnterAlt(1);
				// AS3.g:569:10: typeIdentifier
				{
				DebugLocation(569, 10);
				PushFollow(Follow._typeIdentifier_in_typeExpression3078);
				typeIdentifier233=typeIdentifier();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) stream_typeIdentifier.Add(typeIdentifier233.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// AS3.g:569:27: 'void'
				{
				DebugLocation(569, 27);
				string_literal234=(IToken)Match(input,257,Follow._257_in_typeExpression3082); if (state.failed) return retval; 
				if (state.backtracking == 0) stream_257.Add(string_literal234);


				}
				break;
			case 3:
				DebugEnterAlt(3);
				// AS3.g:569:36: STAR
				{
				DebugLocation(569, 36);
				STAR235=(IToken)Match(input,STAR,Follow._STAR_in_typeExpression3086); if (state.failed) return retval; 
				if (state.backtracking == 0) stream_STAR.Add(STAR235);


				}
				break;

			}
			} finally { DebugExitSubRule(49); }



			{
			// AST REWRITE
			// elements: COLON, typeIdentifier, 257, STAR
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if (state.backtracking == 0) {
			retval.Tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);

			root_0 = (CommonTree)adaptor.Nil();
			// 570:3: -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? )
			{
				DebugLocation(570, 6);
				// AS3.g:570:6: ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? )
				{
				CommonTree root_1 = (CommonTree)adaptor.Nil();
				DebugLocation(570, 8);
				root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(TYPE_SPEC, "TYPE_SPEC"), root_1);

				DebugLocation(570, 18);
				adaptor.AddChild(root_1, stream_COLON.NextNode());
				DebugLocation(570, 24);
				// AS3.g:570:24: ( typeIdentifier )?
				if (stream_typeIdentifier.HasNext)
				{
					DebugLocation(570, 24);
					adaptor.AddChild(root_1, stream_typeIdentifier.NextTree());

				}
				stream_typeIdentifier.Reset();
				DebugLocation(570, 40);
				// AS3.g:570:40: ( 'void' )?
				if (stream_257.HasNext)
				{
					DebugLocation(570, 40);
					adaptor.AddChild(root_1, stream_257.NextNode());

				}
				stream_257.Reset();
				DebugLocation(570, 48);
				// AS3.g:570:48: ( STAR )?
				if (stream_STAR.HasNext)
				{
					DebugLocation(570, 48);
					adaptor.AddChild(root_1, stream_STAR.NextNode());

				}
				stream_STAR.Reset();

				adaptor.AddChild(root_0, root_1);
				}

			}

			retval.Tree = root_0;
			}
			}

			}

			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("typeExpression", 71);
			LeaveRule("typeExpression", 71);
			LeaveRule_typeExpression();
		}
		DebugLocation(571, 4);
		} finally { DebugExitRule(GrammarFileName, "typeExpression"); }
		return retval;

	}
		// $ANTLR start "equalsOp"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:189:1: equalsOp : (x= '==' -> OP_EQ[$x] | x= '=' -> OP_EQ[$x] );
		public equalsOp_return equalsOp() // throws RecognitionException [1]
		{
			var retval = new equalsOp_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken x = null;

			CommonTree x_tree = null;
			var stream_79 = new RewriteRuleTokenStream( adaptor, "token 79" );
			var stream_68 = new RewriteRuleTokenStream( adaptor, "token 68" );

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:190:2: (x= '==' -> OP_EQ[$x] | x= '=' -> OP_EQ[$x] )
				int alt26 = 2;
				int LA26_0 = input.LA( 1 );

				if ( ( LA26_0 == 79 ) )
					alt26 = 1;
				else if ( ( LA26_0 == 68 ) )
					alt26 = 2;
				else
				{
					var nvae_d26s0 =
							new NoViableAltException( "", 26, 0, input );

					throw nvae_d26s0;
				}
				switch ( alt26 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:190:4: x= '=='
						{
							x = (IToken)Match( input, 79, FOLLOW_79_in_equalsOp988 );
							stream_79.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 190:11: -> OP_EQ[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_EQ, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:191:4: x= '='
						{
							x = (IToken)Match( input, 68, FOLLOW_68_in_equalsOp1001 );
							stream_68.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 191:11: -> OP_EQ[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_EQ, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 27
0
    // $ANTLR start "expr"
    // Interp.g:34:1: expr returns [Element ret] : ( assignment | structdec | structobjdec | print );
    public InterpParser.expr_return expr() // throws RecognitionException [1]
    {   
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.structdec_return structdec3 = null;

        InterpParser.structobjdec_return structobjdec4 = null;

        InterpParser.print_return print5 = null;



        try 
    	{
            // Interp.g:35:3: ( assignment | structdec | structobjdec | print )
            int alt2 = 4;
            switch ( input.LA(1) ) 
            {
            case VARIABLE:
            	{
                int LA2_1 = input.LA(2);

                if ( (LA2_1 == ASSIGNMENT || LA2_1 == 19) )
                {
                    alt2 = 1;
                }
                else if ( (LA2_1 == VARIABLE) )
                {
                    alt2 = 3;
                }
                else 
                {
                    NoViableAltException nvae_d2s1 =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae_d2s1;
                }
                }
                break;
            case 16:
            	{
                alt2 = 2;
                }
                break;
            case 20:
            	{
                alt2 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // Interp.g:35:5: assignment
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_assignment_in_expr92);
                    	assignment2 = assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, assignment2.Tree);
                    	retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    // Interp.g:36:5: structdec
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_structdec_in_expr100);
                    	structdec3 = structdec();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, structdec3.Tree);
                    	retval.ret = ((structdec3 != null) ? structdec3.ret : null);

                    }
                    break;
                case 3 :
                    // Interp.g:37:5: structobjdec
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_structobjdec_in_expr108);
                    	structobjdec4 = structobjdec();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, structobjdec4.Tree);
                    	 retval.ret = ((structobjdec4 != null) ? structobjdec4.ret : null);

                    }
                    break;
                case 4 :
                    // Interp.g:38:5: print
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_print_in_expr116);
                    	print5 = print();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, print5.Tree);
                    	 retval.ret = ((print5 != null) ? print5.ret : null); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
		// $ANTLR start "notEqualsOp"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:193:1: notEqualsOp : (x= '!=' -> OP_NE[$x] | x= '<>' -> OP_NE[$x] );
		public notEqualsOp_return notEqualsOp() // throws RecognitionException [1]
		{
			var retval = new notEqualsOp_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken x = null;

			CommonTree x_tree = null;
			var stream_80 = new RewriteRuleTokenStream( adaptor, "token 80" );
			var stream_81 = new RewriteRuleTokenStream( adaptor, "token 81" );

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:194:2: (x= '!=' -> OP_NE[$x] | x= '<>' -> OP_NE[$x] )
				int alt27 = 2;
				int LA27_0 = input.LA( 1 );

				if ( ( LA27_0 == 80 ) )
					alt27 = 1;
				else if ( ( LA27_0 == 81 ) )
					alt27 = 2;
				else
				{
					var nvae_d27s0 =
							new NoViableAltException( "", 27, 0, input );

					throw nvae_d27s0;
				}
				switch ( alt27 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:194:4: x= '!='
						{
							x = (IToken)Match( input, 80, FOLLOW_80_in_notEqualsOp1019 );
							stream_80.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 194:11: -> OP_NE[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_NE, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:195:4: x= '<>'
						{
							x = (IToken)Match( input, 81, FOLLOW_81_in_notEqualsOp1031 );
							stream_81.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 195:11: -> OP_NE[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( OP_NE, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 29
0
    // $ANTLR start "assignment"
    // Interp.g:40:1: assignment returns [AssignmentOperationElement ret] : ( variable | structassign ) ASSIGNMENT ( var_or_int_literal | matrixoperation | addition | multiplication ) END_OF_STATEMENT ;
    public InterpParser.assignment_return assignment() // throws RecognitionException [1]
    {   
        InterpParser.assignment_return retval = new InterpParser.assignment_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        IToken ASSIGNMENT8 = null;
        IToken END_OF_STATEMENT13 = null;
        InterpParser.variable_return variable6 = null;

        InterpParser.structassign_return structassign7 = null;

        InterpParser.var_or_int_literal_return var_or_int_literal9 = null;

        InterpParser.matrixoperation_return matrixoperation10 = null;

        InterpParser.addition_return addition11 = null;

        InterpParser.multiplication_return multiplication12 = null;


        object ASSIGNMENT8_tree=null;
        object END_OF_STATEMENT13_tree=null;


          retval.ret = new AssignmentOperationElement();

        try 
    	{
            // Interp.g:44:3: ( ( variable | structassign ) ASSIGNMENT ( var_or_int_literal | matrixoperation | addition | multiplication ) END_OF_STATEMENT )
            // Interp.g:44:5: ( variable | structassign ) ASSIGNMENT ( var_or_int_literal | matrixoperation | addition | multiplication ) END_OF_STATEMENT
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// Interp.g:44:5: ( variable | structassign )
            	int alt3 = 2;
            	int LA3_0 = input.LA(1);

            	if ( (LA3_0 == VARIABLE) )
            	{
            	    int LA3_1 = input.LA(2);

            	    if ( (LA3_1 == ASSIGNMENT) )
            	    {
            	        alt3 = 1;
            	    }
            	    else if ( (LA3_1 == 19) )
            	    {
            	        alt3 = 2;
            	    }
            	    else 
            	    {
            	        NoViableAltException nvae_d3s1 =
            	            new NoViableAltException("", 3, 1, input);

            	        throw nvae_d3s1;
            	    }
            	}
            	else 
            	{
            	    NoViableAltException nvae_d3s0 =
            	        new NoViableAltException("", 3, 0, input);

            	    throw nvae_d3s0;
            	}
            	switch (alt3) 
            	{
            	    case 1 :
            	        // Interp.g:44:6: variable
            	        {
            	        	PushFollow(FOLLOW_variable_in_assignment138);
            	        	variable6 = variable();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, variable6.Tree);
            	        	retval.ret.setLhs(((variable6 != null) ? variable6.ret : null)); 

            	        }
            	        break;
            	    case 2 :
            	        // Interp.g:45:5: structassign
            	        {
            	        	PushFollow(FOLLOW_structassign_in_assignment146);
            	        	structassign7 = structassign();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, structassign7.Tree);
            	        	retval.ret.setStructLhs(((structassign7 != null) ? structassign7.ret : null));

            	        }
            	        break;

            	}

            	ASSIGNMENT8=(IToken)Match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_assignment153); 
            		ASSIGNMENT8_tree = (object)adaptor.Create(ASSIGNMENT8);
            		adaptor.AddChild(root_0, ASSIGNMENT8_tree);

            	// Interp.g:47:5: ( var_or_int_literal | matrixoperation | addition | multiplication )
            	int alt4 = 4;
            	switch ( input.LA(1) ) 
            	{
            	case VARIABLE:
            		{
            	    switch ( input.LA(2) ) 
            	    {
            	    case END_OF_STATEMENT:
            	    	{
            	        alt4 = 1;
            	        }
            	        break;
            	    case MULTIPLY:
            	    	{
            	        alt4 = 4;
            	        }
            	        break;
            	    case PLUS:
            	    	{
            	        alt4 = 3;
            	        }
            	        break;
            	    	default:
            	    	    NoViableAltException nvae_d4s1 =
            	    	        new NoViableAltException("", 4, 1, input);

            	    	    throw nvae_d4s1;
            	    }

            	    }
            	    break;
            	case INT_LITERAL:
            		{
            	    switch ( input.LA(2) ) 
            	    {
            	    case END_OF_STATEMENT:
            	    	{
            	        alt4 = 1;
            	        }
            	        break;
            	    case MULTIPLY:
            	    	{
            	        alt4 = 4;
            	        }
            	        break;
            	    case PLUS:
            	    	{
            	        alt4 = 3;
            	        }
            	        break;
            	    	default:
            	    	    NoViableAltException nvae_d4s2 =
            	    	        new NoViableAltException("", 4, 2, input);

            	    	    throw nvae_d4s2;
            	    }

            	    }
            	    break;
            	case 12:
            		{
            	    alt4 = 2;
            	    }
            	    break;
            		default:
            		    NoViableAltException nvae_d4s0 =
            		        new NoViableAltException("", 4, 0, input);

            		    throw nvae_d4s0;
            	}

            	switch (alt4) 
            	{
            	    case 1 :
            	        // Interp.g:47:6: var_or_int_literal
            	        {
            	        	PushFollow(FOLLOW_var_or_int_literal_in_assignment161);
            	        	var_or_int_literal9 = var_or_int_literal();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, var_or_int_literal9.Tree);
            	        	retval.ret.setRhs(((var_or_int_literal9 != null) ? var_or_int_literal9.ret : null)); 

            	        }
            	        break;
            	    case 2 :
            	        // Interp.g:48:7: matrixoperation
            	        {
            	        	PushFollow(FOLLOW_matrixoperation_in_assignment171);
            	        	matrixoperation10 = matrixoperation();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, matrixoperation10.Tree);
            	        	 retval.ret.setRhs(((matrixoperation10 != null) ? matrixoperation10.ret : null));

            	        }
            	        break;
            	    case 3 :
            	        // Interp.g:49:7: addition
            	        {
            	        	PushFollow(FOLLOW_addition_in_assignment182);
            	        	addition11 = addition();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, addition11.Tree);
            	        	retval.ret.setRhs(((addition11 != null) ? addition11.ret : null));

            	        }
            	        break;
            	    case 4 :
            	        // Interp.g:50:7: multiplication
            	        {
            	        	PushFollow(FOLLOW_multiplication_in_assignment192);
            	        	multiplication12 = multiplication();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, multiplication12.Tree);
            	        	retval.ret.setRhs(((multiplication12 != null) ? multiplication12.ret : null));

            	        }
            	        break;

            	}

            	END_OF_STATEMENT13=(IToken)Match(input,END_OF_STATEMENT,FOLLOW_END_OF_STATEMENT_in_assignment202); 
            		END_OF_STATEMENT13_tree = (object)adaptor.Create(END_OF_STATEMENT13);
            		adaptor.AddChild(root_0, END_OF_STATEMENT13_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
		// $ANTLR start "booleanValue"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:269:1: booleanValue : (x= 'true' -> TRUE[$x] | x= 'false' -> FALSE[$x] );
		public booleanValue_return booleanValue() // throws RecognitionException [1]
		{
			var retval = new booleanValue_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken x = null;

			CommonTree x_tree = null;
			var stream_96 = new RewriteRuleTokenStream( adaptor, "token 96" );
			var stream_95 = new RewriteRuleTokenStream( adaptor, "token 95" );

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:270:2: (x= 'true' -> TRUE[$x] | x= 'false' -> FALSE[$x] )
				int alt34 = 2;
				int LA34_0 = input.LA( 1 );

				if ( ( LA34_0 == 95 ) )
					alt34 = 1;
				else if ( ( LA34_0 == 96 ) )
					alt34 = 2;
				else
				{
					var nvae_d34s0 =
							new NoViableAltException( "", 34, 0, input );

					throw nvae_d34s0;
				}
				switch ( alt34 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:270:4: x= 'true'
						{
							x = (IToken)Match( input, 95, FOLLOW_95_in_booleanValue1440 );
							stream_95.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 270:13: -> TRUE[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( TRUE, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:271:4: x= 'false'
						{
							x = (IToken)Match( input, 96, FOLLOW_96_in_booleanValue1452 );
							stream_96.Add( x );


							// AST REWRITE
							// elements:          
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 271:14: -> FALSE[$x]
							{
								adaptor.AddChild( root_0, adaptor.Create( FALSE, x ) );
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}
Ejemplo n.º 31
0
    // $ANTLR start "var_or_int_literal"
    // Interp.g:53:1: var_or_int_literal returns [Element ret] : ( variable | int_literal ) ;
    public InterpParser.var_or_int_literal_return var_or_int_literal() // throws RecognitionException [1]
    {   
        InterpParser.var_or_int_literal_return retval = new InterpParser.var_or_int_literal_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.variable_return variable14 = null;

        InterpParser.int_literal_return int_literal15 = null;



        try 
    	{
            // Interp.g:54:3: ( ( variable | int_literal ) )
            // Interp.g:54:6: ( variable | int_literal )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// Interp.g:54:6: ( variable | int_literal )
            	int alt5 = 2;
            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == VARIABLE) )
            	{
            	    alt5 = 1;
            	}
            	else if ( (LA5_0 == INT_LITERAL) )
            	{
            	    alt5 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d5s0 =
            	        new NoViableAltException("", 5, 0, input);

            	    throw nvae_d5s0;
            	}
            	switch (alt5) 
            	{
            	    case 1 :
            	        // Interp.g:54:7: variable
            	        {
            	        	PushFollow(FOLLOW_variable_in_var_or_int_literal218);
            	        	variable14 = variable();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, variable14.Tree);
            	        	 retval.ret = ((variable14 != null) ? variable14.ret : null); 

            	        }
            	        break;
            	    case 2 :
            	        // Interp.g:55:7: int_literal
            	        {
            	        	PushFollow(FOLLOW_int_literal_in_var_or_int_literal229);
            	        	int_literal15 = int_literal();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, int_literal15.Tree);
            	        	retval.ret = ((int_literal15 != null) ? int_literal15.ret : null); 

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
Ejemplo n.º 32
0
    protected internal int DFA8_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            IIntStream input = _input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA8_6 = input.LA(1);

                   	s = -1;
                   	if ( ((LA8_6 >= '\u0000' && LA8_6 <= '\uFFFF')) ) { s = 40; }

                   	else s = 39;

                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA8_7 = input.LA(1);

                   	s = -1;
                   	if ( ((LA8_7 >= '\u0000' && LA8_7 <= '\uFFFF')) ) { s = 42; }

                   	else s = 41;

                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA8_0 = input.LA(1);

                   	s = -1;
                   	if ( (LA8_0 == 'G') ) { s = 1; }

                   	else if ( (LA8_0 == 'S') ) { s = 2; }

                   	else if ( (LA8_0 == '[') ) { s = 3; }

                   	else if ( ((LA8_0 >= '\t' && LA8_0 <= '\n') || LA8_0 == '\r' || LA8_0 == ' ') ) { s = 4; }

                   	else if ( (LA8_0 == '%') ) { s = 5; }

                   	else if ( (LA8_0 == '\"') ) { s = 6; }

                   	else if ( (LA8_0 == '\'') ) { s = 7; }

                   	else if ( (LA8_0 == 'C') ) { s = 8; }

                   	else if ( (LA8_0 == 'D') ) { s = 9; }

                   	else if ( (LA8_0 == 'I') ) { s = 10; }

                   	else if ( (LA8_0 == 'P') ) { s = 11; }

                   	else if ( (LA8_0 == 'W') ) { s = 12; }

                   	else if ( (LA8_0 == 'B') ) { s = 13; }

                   	else if ( (LA8_0 == 'F') ) { s = 14; }

                   	else if ( (LA8_0 == 'U') ) { s = 15; }

                   	else if ( (LA8_0 == 'E') ) { s = 16; }

                   	else if ( (LA8_0 == 'M') ) { s = 17; }

                   	else if ( (LA8_0 == 'R') ) { s = 18; }

                   	else if ( (LA8_0 == 'T') ) { s = 19; }

                   	else if ( (LA8_0 == 'N') ) { s = 20; }

                   	else if ( (LA8_0 == 'L') ) { s = 21; }

                   	else if ( (LA8_0 == 'A' || LA8_0 == 'H' || (LA8_0 >= 'J' && LA8_0 <= 'K') || LA8_0 == 'O' || LA8_0 == 'Q' || LA8_0 == 'V' || (LA8_0 >= 'X' && LA8_0 <= 'Z') || LA8_0 == '_' || (LA8_0 >= 'a' && LA8_0 <= 'z')) ) { s = 22; }

                   	else if ( ((LA8_0 >= '0' && LA8_0 <= '9')) ) { s = 23; }

                   	else if ( (LA8_0 == '+') ) { s = 24; }

                   	else if ( (LA8_0 == '-') ) { s = 25; }

                   	else if ( (LA8_0 == '*') ) { s = 26; }

                   	else if ( (LA8_0 == '/') ) { s = 27; }

                   	else if ( (LA8_0 == '=') ) { s = 28; }

                   	else if ( ((LA8_0 >= '\u0000' && LA8_0 <= '\b') || (LA8_0 >= '\u000B' && LA8_0 <= '\f') || (LA8_0 >= '\u000E' && LA8_0 <= '\u001F') || LA8_0 == '!' || (LA8_0 >= '#' && LA8_0 <= '$') || LA8_0 == '&' || (LA8_0 >= '(' && LA8_0 <= ')') || LA8_0 == ',' || LA8_0 == '.' || (LA8_0 >= ':' && LA8_0 <= '<') || (LA8_0 >= '>' && LA8_0 <= '@') || (LA8_0 >= '\\' && LA8_0 <= '^') || LA8_0 == '`' || (LA8_0 >= '{' && LA8_0 <= '\uFFFF')) ) { s = 29; }

                   	if ( s >= 0 ) return s;
                   	break;
        }
        NoViableAltException nvae8 =
            new NoViableAltException(dfa.Description, 8, _s, input);
        dfa.Error(nvae8);
        throw nvae8;
    }
Ejemplo n.º 33
0
	private void mTYPE()
	{
		EnterRule_TYPE();
		EnterRule("TYPE", 5);
		TraceIn("TYPE", 5);
		try
		{
			int _type = TYPE;
			int _channel = DefaultTokenChannel;
			// FuncProtoToShim.g:35:6: ( ( 'integer' | 'float' | 'key' | 'vector' | 'rotation' | 'string' | 'list' ) )
			DebugEnterAlt(1);
			// FuncProtoToShim.g:35:8: ( 'integer' | 'float' | 'key' | 'vector' | 'rotation' | 'string' | 'list' )
			{
			DebugLocation(35, 8);
			// FuncProtoToShim.g:35:8: ( 'integer' | 'float' | 'key' | 'vector' | 'rotation' | 'string' | 'list' )
			int alt2=7;
			try { DebugEnterSubRule(2);
			try { DebugEnterDecision(2, false);
			switch (input.LA(1))
			{
			case 'i':
				{
				alt2 = 1;
				}
				break;
			case 'f':
				{
				alt2 = 2;
				}
				break;
			case 'k':
				{
				alt2 = 3;
				}
				break;
			case 'v':
				{
				alt2 = 4;
				}
				break;
			case 'r':
				{
				alt2 = 5;
				}
				break;
			case 's':
				{
				alt2 = 6;
				}
				break;
			case 'l':
				{
				alt2 = 7;
				}
				break;
			default:
				{
					NoViableAltException nvae = new NoViableAltException("", 2, 0, input);
					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(2); }
			switch (alt2)
			{
			case 1:
				DebugEnterAlt(1);
				// FuncProtoToShim.g:35:9: 'integer'
				{
				DebugLocation(35, 9);
				Match("integer"); 


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// FuncProtoToShim.g:35:19: 'float'
				{
				DebugLocation(35, 19);
				Match("float"); 


				}
				break;
			case 3:
				DebugEnterAlt(3);
				// FuncProtoToShim.g:35:27: 'key'
				{
				DebugLocation(35, 27);
				Match("key"); 


				}
				break;
			case 4:
				DebugEnterAlt(4);
				// FuncProtoToShim.g:35:33: 'vector'
				{
				DebugLocation(35, 33);
				Match("vector"); 


				}
				break;
			case 5:
				DebugEnterAlt(5);
				// FuncProtoToShim.g:35:42: 'rotation'
				{
				DebugLocation(35, 42);
				Match("rotation"); 


				}
				break;
			case 6:
				DebugEnterAlt(6);
				// FuncProtoToShim.g:35:53: 'string'
				{
				DebugLocation(35, 53);
				Match("string"); 


				}
				break;
			case 7:
				DebugEnterAlt(7);
				// FuncProtoToShim.g:35:62: 'list'
				{
				DebugLocation(35, 62);
				Match("list"); 


				}
				break;

			}
			} finally { DebugExitSubRule(2); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("TYPE", 5);
			LeaveRule("TYPE", 5);
			LeaveRule_TYPE();
		}
	}
Ejemplo n.º 34
0
	private int SpecialStateTransition5(DFA dfa, int s, IIntStream _input)
	{
		IIntStream input = _input;
		int _s = s;
		switch (s)
		{
			case 0:
				int LA5_31 = input.LA(1);

				s = -1;
				if ( ((LA5_31>='\u0000' && LA5_31<='\uFFFF')) ) {s = 63;}

				else s = 62;

				if ( s>=0 ) return s;
				break;
		}
		NoViableAltException nvae = new NoViableAltException(dfa.Description, 5, _s, input);
		dfa.Error(nvae);
		throw nvae;
	}
		// $ANTLR start "propertyModifiers"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:100:1: propertyModifiers : ( exclusivePropertyModifier -> ^( MODIFIERS exclusivePropertyModifier ) | ( propertyModifier )+ -> ^( MODIFIERS ( propertyModifier )+ ) );
		public propertyModifiers_return propertyModifiers() // throws RecognitionException [1]
		{
			var retval = new propertyModifiers_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			exclusivePropertyModifier_return exclusivePropertyModifier21 = default( exclusivePropertyModifier_return );

			propertyModifier_return propertyModifier22 = default( propertyModifier_return );


			var stream_propertyModifier = new RewriteRuleSubtreeStream( adaptor, "rule propertyModifier" );
			var stream_exclusivePropertyModifier = new RewriteRuleSubtreeStream( adaptor, "rule exclusivePropertyModifier" );
			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:2: ( exclusivePropertyModifier -> ^( MODIFIERS exclusivePropertyModifier ) | ( propertyModifier )+ -> ^( MODIFIERS ( propertyModifier )+ ) )
				int alt8 = 2;
				int LA8_0 = input.LA( 1 );

				if ( ( LA8_0 == 64 ) )
					alt8 = 1;
				else if ( ( ( LA8_0 >= 65 && LA8_0 <= 66 ) ) )
					alt8 = 2;
				else
				{
					var nvae_d8s0 =
							new NoViableAltException( "", 8, 0, input );

					throw nvae_d8s0;
				}
				switch ( alt8 )
				{
					case 1:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:4: exclusivePropertyModifier
						{
							PushFollow( FOLLOW_exclusivePropertyModifier_in_propertyModifiers419 );
							exclusivePropertyModifier21 = exclusivePropertyModifier();
							state.followingStackPointer--;

							stream_exclusivePropertyModifier.Add( exclusivePropertyModifier21.Tree );


							// AST REWRITE
							// elements:          exclusivePropertyModifier
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 101:30: -> ^( MODIFIERS exclusivePropertyModifier )
							{
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:33: ^( MODIFIERS exclusivePropertyModifier )
								{
									var root_1 = (CommonTree)adaptor.GetNilNode();
									root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( MODIFIERS, "MODIFIERS" ), root_1 );

									adaptor.AddChild( root_1, stream_exclusivePropertyModifier.NextTree() );

									adaptor.AddChild( root_0, root_1 );
								}
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
					case 2:
						// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: ( propertyModifier )+
						{
							// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: ( propertyModifier )+
							int cnt7 = 0;
							do
							{
								int alt7 = 2;
								int LA7_0 = input.LA( 1 );

								if ( ( ( LA7_0 >= 65 && LA7_0 <= 66 ) ) )
									alt7 = 1;


								switch ( alt7 )
								{
									case 1:
										// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: propertyModifier
										{
											PushFollow( FOLLOW_propertyModifier_in_propertyModifiers434 );
											propertyModifier22 = propertyModifier();
											state.followingStackPointer--;

											stream_propertyModifier.Add( propertyModifier22.Tree );
										}
										break;

									default:
										if ( cnt7 >= 1 ) goto loop7;
										var eee7 =
												new EarlyExitException( 7, input );
										throw eee7;
								}
								cnt7++;
							} while ( true );

							loop7:
							; // Stops C# compiler whining that label 'loop7' has no statements


							// AST REWRITE
							// elements:          propertyModifier
							// token labels:      
							// rule labels:       retval
							// token list labels: 
							// rule list labels:  
							// wildcard labels: 
							retval.Tree = root_0;
							var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );

							root_0 = (CommonTree)adaptor.GetNilNode();
							// 102:22: -> ^( MODIFIERS ( propertyModifier )+ )
							{
								// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:25: ^( MODIFIERS ( propertyModifier )+ )
								{
									var root_1 = (CommonTree)adaptor.GetNilNode();
									root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( MODIFIERS, "MODIFIERS" ), root_1 );

									if ( !( stream_propertyModifier.HasNext() ) ) throw new RewriteEarlyExitException();
									while ( stream_propertyModifier.HasNext() )
										adaptor.AddChild( root_1, stream_propertyModifier.NextTree() );
									stream_propertyModifier.Reset();

									adaptor.AddChild( root_0, root_1 );
								}
							}

							retval.Tree = root_0;
							retval.Tree = root_0;
						}
						break;
				}
				retval.Stop = input.LT( -1 );

				retval.Tree = adaptor.RulePostProcessing( root_0 );
				adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
			}
			catch ( RecognitionException re )
			{
				ReportError( re );
				Recover( input, re );
				// Conversion of the second argument necessary, but harmless
				retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
			}
			finally {}
			return retval;
		}