Example #1
0
    // $ANTLR start "assignmentExpressionNoIn"
    // AS3_ex.g3:2203:1: assignmentExpressionNoIn : ( conditionalExpressionNoIn | leftHandSideExpression assignmentOperator assignmentExpressionNoIn );
    public AS3_exParser.assignmentExpressionNoIn_return assignmentExpressionNoIn() // throws RecognitionException [1]
    {   
        AS3_exParser.assignmentExpressionNoIn_return retval = new AS3_exParser.assignmentExpressionNoIn_return();
        retval.Start = input.LT(1);
        int assignmentExpressionNoIn_StartIndex = input.Index();
        object root_0 = null;

        AS3_exParser.conditionalExpressionNoIn_return conditionalExpressionNoIn240 = null;

        AS3_exParser.leftHandSideExpression_return leftHandSideExpression241 = null;

        AS3_exParser.assignmentOperator_return assignmentOperator242 = null;

        AS3_exParser.assignmentExpressionNoIn_return assignmentExpressionNoIn243 = null;



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 103) ) 
    	    {
    	    	return retval; 
    	    }
            // AS3_ex.g3:2204:5: ( conditionalExpressionNoIn | leftHandSideExpression assignmentOperator assignmentExpressionNoIn )
            int alt115 = 2;
            alt115 = dfa115.Predict(input);
            switch (alt115) 
            {
                case 1 :
                    // AS3_ex.g3:2204:9: conditionalExpressionNoIn
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_conditionalExpressionNoIn_in_assignmentExpressionNoIn10258);
                    	conditionalExpressionNoIn240 = conditionalExpressionNoIn();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditionalExpressionNoIn240.Tree);

                    }
                    break;
                case 2 :
                    // AS3_ex.g3:2205:9: leftHandSideExpression assignmentOperator assignmentExpressionNoIn
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_leftHandSideExpression_in_assignmentExpressionNoIn10268);
                    	leftHandSideExpression241 = leftHandSideExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, leftHandSideExpression241.Tree);
                    	PushFollow(FOLLOW_assignmentOperator_in_assignmentExpressionNoIn10271);
                    	assignmentOperator242 = assignmentOperator();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignmentOperator242.Tree);
                    	PushFollow(FOLLOW_assignmentExpressionNoIn_in_assignmentExpressionNoIn10274);
                    	assignmentExpressionNoIn243 = assignmentExpressionNoIn();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignmentExpressionNoIn243.Tree);

                    }
                    break;

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

            if ( state.backtracking==0 )
            {	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 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 103, assignmentExpressionNoIn_StartIndex); 
            }
        }
        return retval;
    }
Example #2
0
    // $ANTLR start "assignmentExpressionNoIn"
    // AS3_ex.g3:3026:1: assignmentExpressionNoIn : ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn ) ;
    public AS3_exParser.assignmentExpressionNoIn_return assignmentExpressionNoIn() // throws RecognitionException [1]
    {   
        AS3_exParser.assignmentExpressionNoIn_return retval = new AS3_exParser.assignmentExpressionNoIn_return();
        retval.Start = input.LT(1);
        int assignmentExpressionNoIn_StartIndex = input.Index();
        object root_0 = null;

        AS3_exParser.leftHandSideExpression_return leftHandSideExpression251 = null;

        AS3_exParser.assignmentOperator_return assignmentOperator252 = null;

        AS3_exParser.assignmentExpressionNoIn_return assignmentExpressionNoIn253 = null;

        AS3_exParser.conditionalExpressionNoIn_return conditionalExpressionNoIn254 = null;




            WrapOptions options=mPrinter.getExpressionWrapOptions();
            bool pushedWrapInfo=false;

        try 
        {
            if ( (state.backtracking > 0) && AlreadyParsedRule(input, 103) ) 
            {
                return retval; 
            }
            // AS3_ex.g3:3031:5: ( ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn ) )
            // AS3_ex.g3:3031:8: ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn )
            {
                root_0 = (object)adaptor.GetNilNode();

                if ( state.backtracking == 0 ) 
                {
                  pushedWrapInfo=pushWrapInfo(options, true);
                }
                // AS3_ex.g3:3032:8: ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn )
                int alt122 = 2;
                alt122 = dfa122.Predict(input);
                switch (alt122) 
                {
                    case 1 :
                        // AS3_ex.g3:3033:9: ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn
                        {
                            PushFollow(FOLLOW_leftHandSideExpression_in_assignmentExpressionNoIn11523);
                            leftHandSideExpression251 = leftHandSideExpression();
                            state.followingStackPointer--;
                            if (state.failed) return retval;
                            if ( state.backtracking == 0 ) adaptor.AddChild(root_0, leftHandSideExpression251.Tree);
                            PushFollow(FOLLOW_assignmentOperator_in_assignmentExpressionNoIn11526);
                            assignmentOperator252 = assignmentOperator();
                            state.followingStackPointer--;
                            if (state.failed) return retval;
                            if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignmentOperator252.Tree);
                            PushFollow(FOLLOW_assignmentExpressionNoIn_in_assignmentExpressionNoIn11529);
                            assignmentExpressionNoIn253 = assignmentExpressionNoIn();
                            state.followingStackPointer--;
                            if (state.failed) return retval;
                            if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignmentExpressionNoIn253.Tree);

                        }
                        break;
                    case 2 :
                        // AS3_ex.g3:3034:8: conditionalExpressionNoIn
                        {
                            PushFollow(FOLLOW_conditionalExpressionNoIn_in_assignmentExpressionNoIn11538);
                            conditionalExpressionNoIn254 = conditionalExpressionNoIn();
                            state.followingStackPointer--;
                            if (state.failed) return retval;
                            if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditionalExpressionNoIn254.Tree);

                        }
                        break;

                }

                if ( state.backtracking == 0 ) 
                {
                  if (pushedWrapInfo)
                            mPrinter.popWrapContext();
                }

            }

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

            if ( state.backtracking==0 )
            {   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 
        {
            if ( state.backtracking > 0 ) 
            {
                Memoize(input, 103, assignmentExpressionNoIn_StartIndex); 
            }
        }
        return retval;
    }