コード例 #1
0
ファイル: ASParser.cs プロジェクト: nomilogic/fdplugins
        // throws RecognitionException [1]
        // $ANTLR start multiplicativeExpression
        // C:\\Users\\sephiroth\\Documents\\Visual Studio 2005\\Projects\\CodeReformatter\\CodeReformatter\\AS.g:1403:1: multiplicativeExpression : unaryExpression (op= multiplicativeOperator unaryExpression )* ;
        public multiplicativeExpression_return multiplicativeExpression()
        {
            multiplicativeExpression_return retval = new multiplicativeExpression_return();
            retval.start = input.LT(1);
            int multiplicativeExpression_StartIndex = input.Index();
            CommonTree root_0 = null;

            multiplicativeOperator_return op = null;

            unaryExpression_return unaryExpression271 = null;

            unaryExpression_return unaryExpression272 = null;

            try
            {
            if ( (backtracking > 0) && AlreadyParsedRule(input, 106) )
            {
                return retval;
            }
            // C:\\Users\\sephiroth\\Documents\\Visual Studio 2005\\Projects\\CodeReformatter\\CodeReformatter\\AS.g:1404:4: ( unaryExpression (op= multiplicativeOperator unaryExpression )* )
            // C:\\Users\\sephiroth\\Documents\\Visual Studio 2005\\Projects\\CodeReformatter\\CodeReformatter\\AS.g:1404:4: unaryExpression (op= multiplicativeOperator unaryExpression )*
            {
                root_0 = (CommonTree)adaptor.GetNilNode();

                PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4826);
                unaryExpression271 = unaryExpression();
                followingStackPointer_--;
                if (failed) return retval;
                if ( backtracking==0 ) adaptor.AddChild(root_0, unaryExpression271.Tree);
                // C:\\Users\\sephiroth\\Documents\\Visual Studio 2005\\Projects\\CodeReformatter\\CodeReformatter\\AS.g:1405:3: (op= multiplicativeOperator unaryExpression )*
                do
                {
                    int alt79 = 2;
                    int LA79_0 = input.LA(1);

                    if ( (LA79_0 == STAR || (LA79_0 >= DIV && LA79_0 <= MOD)) )
                    {
                        alt79 = 1;
                    }

                    switch (alt79)
                    {
                        case 1 :
                            // C:\\Users\\sephiroth\\Documents\\Visual Studio 2005\\Projects\\CodeReformatter\\CodeReformatter\\AS.g:1406:4: op= multiplicativeOperator unaryExpression
                            {
                                PushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression4838);
                                op = multiplicativeOperator();
                                followingStackPointer_--;
                                if (failed) return retval;
                                if ( backtracking==0 ) root_0 = (CommonTree)adaptor.BecomeRoot(op.Tree, root_0);
                                if ( backtracking == 0 )
                                {

                                  											if(options.SpaceBetweenOperators) buffer.Append(" ");
                                  											buffer.Append(((CommonTree)op.Tree).Text );
                                  											if(options.SpaceBetweenOperators) buffer.Append(" ");

                                }
                                PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4846);
                                unaryExpression272 = unaryExpression();
                                followingStackPointer_--;
                                if (failed) return retval;
                                if ( backtracking==0 ) adaptor.AddChild(root_0, unaryExpression272.Tree);

                            }
                            break;

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

                loop79:
                    ;	// Stops C# compiler whinging that label 'loop79' has no statements

            }

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

            if ( backtracking==0 )
            {	retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
                adaptor.SetTokenBoundaries(retval.Tree, retval.start, retval.stop);
            }
            }

            catch (NoViableAltException e)
            {
                Debug.WriteLine("NoValiable alt: token=" + e.Token + " (decision=" + e.decisionNumber + " state " + e.stateNumber + ")" + " decision=<<" + e.grammarDecisionDescription + ">>");
                throw e;
            }
            catch (MismatchedTokenException e)
            {
                Debug.WriteLine("[" + e.Line + ":" + e.Index + "]: " + e.Message + ". Unexpected " + e.UnexpectedType.ToString() +  "( expecting: "+ e.expecting + " )");
                throw e;
            }
            catch(RecognitionException e)
            {
                Debug.WriteLine("RecognitionException: " + e);
                throw e;
            }
            finally
            {
            if ( backtracking > 0 )
            {
                Memoize(input, 106, multiplicativeExpression_StartIndex);
            }
            }
            return retval;
        }
コード例 #2
0
ファイル: NLinqParser.cs プロジェクト: pusp/o2platform
    // $ANTLR start multiplicativeExpression
    // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:128:1: multiplicativeExpression returns [Expression value] : left= unaryExpression ( ( '*' | '/' | '%' ) right= unaryExpression )* ;
    public multiplicativeExpression_return multiplicativeExpression() // throws RecognitionException [1]
    {   
        multiplicativeExpression_return retval = new multiplicativeExpression_return();
        retval.start = input.LT(1);
        
        CommonTree root_0 = null;
    
        IToken char_literal19 = null;
        IToken char_literal20 = null;
        IToken char_literal21 = null;
        unaryExpression_return left = null;

        unaryExpression_return right = null;
        
        
        CommonTree char_literal19_tree=null;
        CommonTree char_literal20_tree=null;
        CommonTree char_literal21_tree=null;
    
        
        BinaryExpressionType type = BinaryExpressionType.Unknown;
    
        try 
    	{
            // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:132:2: (left= unaryExpression ( ( '*' | '/' | '%' ) right= unaryExpression )* )
            // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:132:4: left= unaryExpression ( ( '*' | '/' | '%' ) right= unaryExpression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();
            
            	PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression472);
            	left = unaryExpression();
            	followingStackPointer_--;
            	
            	adaptor.AddChild(root_0, left.Tree);
            	 retval.value =  left.value; 
            	// C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:132:51: ( ( '*' | '/' | '%' ) right= unaryExpression )*
            	do 
            	{
            	    int alt12 = 2;
            	    switch ( input.LA(1) ) 
            	    {
            	    case 29:
            	    	{
            	        alt12 = 1;
            	        }
            	        break;
            	    case 30:
            	    	{
            	        alt12 = 1;
            	        }
            	        break;
            	    case 31:
            	    	{
            	        alt12 = 1;
            	        }
            	        break;
            	    
            	    }
            	
            	    switch (alt12) 
            		{
            			case 1 :
            			    // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:133:4: ( '*' | '/' | '%' ) right= unaryExpression
            			    {
            			    	// C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:133:4: ( '*' | '/' | '%' )
            			    	int alt11 = 3;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	case 29:
            			    		{
            			    	    alt11 = 1;
            			    	    }
            			    	    break;
            			    	case 30:
            			    		{
            			    	    alt11 = 2;
            			    	    }
            			    	    break;
            			    	case 31:
            			    		{
            			    	    alt11 = 3;
            			    	    }
            			    	    break;
            			    		default:
            			    		    NoViableAltException nvae_d11s0 =
            			    		        new NoViableAltException("133:4: ( '*' | '/' | '%' )", 11, 0, input);
            			    	
            			    		    throw nvae_d11s0;
            			    	}
            			    	
            			    	switch (alt11) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:133:6: '*'
            			    	        {
            			    	        	char_literal19 = (IToken)input.LT(1);
            			    	        	Match(input,29,FOLLOW_29_in_multiplicativeExpression483); 
            			    	        	char_literal19_tree = (CommonTree)adaptor.Create(char_literal19);
            			    	        	adaptor.AddChild(root_0, char_literal19_tree);

            			    	        	 type = BinaryExpressionType.Times; 
            			    	        
            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:134:6: '/'
            			    	        {
            			    	        	char_literal20 = (IToken)input.LT(1);
            			    	        	Match(input,30,FOLLOW_30_in_multiplicativeExpression493); 
            			    	        	char_literal20_tree = (CommonTree)adaptor.Create(char_literal20);
            			    	        	adaptor.AddChild(root_0, char_literal20_tree);

            			    	        	 type = BinaryExpressionType.Div; 
            			    	        
            			    	        }
            			    	        break;
            			    	    case 3 :
            			    	        // C:\\Documents and Settings\\Sébastien Ros\\Mes documents\\Développement\\NLinq\\NLinq.g:135:6: '%'
            			    	        {
            			    	        	char_literal21 = (IToken)input.LT(1);
            			    	        	Match(input,31,FOLLOW_31_in_multiplicativeExpression503); 
            			    	        	char_literal21_tree = (CommonTree)adaptor.Create(char_literal21);
            			    	        	adaptor.AddChild(root_0, char_literal21_tree);

            			    	        	 type = BinaryExpressionType.Modulo; 
            			    	        
            			    	        }
            			    	        break;
            			    	
            			    	}

            			    	PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression515);
            			    	right = unaryExpression();
            			    	followingStackPointer_--;
            			    	
            			    	adaptor.AddChild(root_0, right.Tree);
            			    	 retval.value =  new BinaryExpression(type, left.value, right.value); 
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop12;
            	    }
            	} while (true);
            	
            	loop12:
            		;	// Stops C# compiler whinging that label 'loop12' has no statements

            
            }
    
            retval.stop = input.LT(-1);
            
            	retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, retval.start, retval.stop);
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }