Esempio n. 1
0
    // $ANTLR start "primaryExpressionHelper"
    // AS3_ex.g3:2548:1: primaryExpressionHelper : (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | identifierLiteral | xmlPrimaryExpression | parExpression | conditionalCompilerOption | l= LT type g= GT ( arrayLiteral )? );
    public AS3_exParser.primaryExpressionHelper_return primaryExpressionHelper() // throws RecognitionException [1]
    {   
        AS3_exParser.primaryExpressionHelper_return retval = new AS3_exParser.primaryExpressionHelper_return();
        retval.Start = input.LT(1);
        int primaryExpressionHelper_StartIndex = input.Index();
        object root_0 = null;

        IToken T = null;
        IToken S = null;
        IToken l = null;
        IToken g = null;
        AS3_exParser.literal_return literal326 = null;

        AS3_exParser.arrayLiteral_return arrayLiteral327 = null;

        AS3_exParser.objectLiteral_return objectLiteral328 = null;

        AS3_exParser.identifierLiteral_return identifierLiteral329 = null;

        AS3_exParser.xmlPrimaryExpression_return xmlPrimaryExpression330 = null;

        AS3_exParser.parExpression_return parExpression331 = null;

        AS3_exParser.conditionalCompilerOption_return conditionalCompilerOption332 = null;

        AS3_exParser.type_return type333 = null;

        AS3_exParser.arrayLiteral_return arrayLiteral334 = null;


        object T_tree=null;
        object S_tree=null;
        object l_tree=null;
        object g_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 142) ) 
    	    {
    	    	return retval; 
    	    }
            // AS3_ex.g3:2549:5: (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | identifierLiteral | xmlPrimaryExpression | parExpression | conditionalCompilerOption | l= LT type g= GT ( arrayLiteral )? )
            int alt155 = 10;
            alt155 = dfa155.Predict(input);
            switch (alt155) 
            {
                case 1 :
                    // AS3_ex.g3:2549:9: T= THIS
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	T=(IToken)Match(input,THIS,FOLLOW_THIS_in_primaryExpressionHelper13037); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{T_tree = (object)adaptor.Create(T);
                    		adaptor.AddChild(root_0, T_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  Emit((CommonToken)T);
                    	}

                    }
                    break;
                case 2 :
                    // AS3_ex.g3:2550:9: S= SUPER
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	S=(IToken)Match(input,SUPER,FOLLOW_SUPER_in_primaryExpressionHelper13051); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{S_tree = (object)adaptor.Create(S);
                    		adaptor.AddChild(root_0, S_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  Emit((CommonToken)S);
                    	}

                    }
                    break;
                case 3 :
                    // AS3_ex.g3:2551:9: literal
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_literal_in_primaryExpressionHelper13063);
                    	literal326 = literal();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal326.Tree);

                    }
                    break;
                case 4 :
                    // AS3_ex.g3:2552:9: arrayLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_arrayLiteral_in_primaryExpressionHelper13075);
                    	arrayLiteral327 = arrayLiteral();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arrayLiteral327.Tree);

                    }
                    break;
                case 5 :
                    // AS3_ex.g3:2553:9: objectLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_objectLiteral_in_primaryExpressionHelper13086);
                    	objectLiteral328 = objectLiteral();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, objectLiteral328.Tree);

                    }
                    break;
                case 6 :
                    // AS3_ex.g3:2554:9: identifierLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifierLiteral_in_primaryExpressionHelper13098);
                    	identifierLiteral329 = identifierLiteral();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifierLiteral329.Tree);

                    }
                    break;
                case 7 :
                    // AS3_ex.g3:2555:9: xmlPrimaryExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_xmlPrimaryExpression_in_primaryExpressionHelper13109);
                    	xmlPrimaryExpression330 = xmlPrimaryExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, xmlPrimaryExpression330.Tree);

                    }
                    break;
                case 8 :
                    // AS3_ex.g3:2556:9: parExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_parExpression_in_primaryExpressionHelper13119);
                    	parExpression331 = parExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parExpression331.Tree);

                    }
                    break;
                case 9 :
                    // AS3_ex.g3:2557:9: conditionalCompilerOption
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_conditionalCompilerOption_in_primaryExpressionHelper13130);
                    	conditionalCompilerOption332 = conditionalCompilerOption();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditionalCompilerOption332.Tree);

                    }
                    break;
                case 10 :
                    // AS3_ex.g3:2558:6: l= LT type g= GT ( arrayLiteral )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	l=(IToken)Match(input,LT,FOLLOW_LT_in_primaryExpressionHelper13139); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{l_tree = (object)adaptor.Create(l);
                    		adaptor.AddChild(root_0, l_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  Emit((CommonToken)l);
                    	}
                    	PushFollow(FOLLOW_type_in_primaryExpressionHelper13143);
                    	type333 = type();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type333.Tree);
                    	g=(IToken)Match(input,GT,FOLLOW_GT_in_primaryExpressionHelper13147); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{g_tree = (object)adaptor.Create(g);
                    		adaptor.AddChild(root_0, g_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  Emit((CommonToken)g);
                    	}
                    	// AS3_ex.g3:2558:71: ( arrayLiteral )?
                    	int alt154 = 2;
                    	alt154 = dfa154.Predict(input);
                    	switch (alt154) 
                    	{
                    	    case 1 :
                    	        // AS3_ex.g3:2558:72: arrayLiteral
                    	        {
                    	        	PushFollow(FOLLOW_arrayLiteral_in_primaryExpressionHelper13152);
                    	        	arrayLiteral334 = arrayLiteral();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arrayLiteral334.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    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, 142, primaryExpressionHelper_StartIndex); 
            }
        }
        return retval;
    }
Esempio n. 2
0
    // $ANTLR start "primaryExpressionHelper"
    // AS3_ex.g3:3521:1: primaryExpressionHelper : (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | ( identifierLiteral x= XML_NS_OP )? identifierLiteral | xmlPrimaryExpression | parExpression | l= LT type g= GT ( arrayLiteral )? );
    public AS3_exParser.primaryExpressionHelper_return primaryExpressionHelper() // throws RecognitionException [1]
    {   
        AS3_exParser.primaryExpressionHelper_return retval = new AS3_exParser.primaryExpressionHelper_return();
        retval.Start = input.LT(1);
        int primaryExpressionHelper_StartIndex = input.Index();
        object root_0 = null;

        IToken T = null;
        IToken S = null;
        IToken x = null;
        IToken l = null;
        IToken g = null;
        AS3_exParser.literal_return literal336 = null;

        AS3_exParser.arrayLiteral_return arrayLiteral337 = null;

        AS3_exParser.objectLiteral_return objectLiteral338 = null;

        AS3_exParser.identifierLiteral_return identifierLiteral339 = null;

        AS3_exParser.identifierLiteral_return identifierLiteral340 = null;

        AS3_exParser.xmlPrimaryExpression_return xmlPrimaryExpression341 = null;

        AS3_exParser.parExpression_return parExpression342 = null;

        AS3_exParser.type_return type343 = null;

        AS3_exParser.arrayLiteral_return arrayLiteral344 = null;


        object T_tree=null;
        object S_tree=null;
        object x_tree=null;
        object l_tree=null;
        object g_tree=null;

        try 
        {
            if ( (state.backtracking > 0) && AlreadyParsedRule(input, 142) ) 
            {
                return retval; 
            }
            // AS3_ex.g3:3522:5: (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | ( identifierLiteral x= XML_NS_OP )? identifierLiteral | xmlPrimaryExpression | parExpression | l= LT type g= GT ( arrayLiteral )? )
            int alt162 = 9;
            alt162 = dfa162.Predict(input);
            switch (alt162) 
            {
                case 1 :
                    // AS3_ex.g3:3522:9: T= THIS
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        T=(IToken)Match(input,THIS,FOLLOW_THIS_in_primaryExpressionHelper14802); if (state.failed) return retval;
                        if ( state.backtracking == 0 )
                        {T_tree = (object)adaptor.Create(T);
                            adaptor.AddChild(root_0, T_tree);
                        }
                        if ( state.backtracking == 0 ) 
                        {
                          emit(T);
                        }

                    }
                    break;
                case 2 :
                    // AS3_ex.g3:3523:9: S= SUPER
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        S=(IToken)Match(input,SUPER,FOLLOW_SUPER_in_primaryExpressionHelper14816); if (state.failed) return retval;
                        if ( state.backtracking == 0 )
                        {S_tree = (object)adaptor.Create(S);
                            adaptor.AddChild(root_0, S_tree);
                        }
                        if ( state.backtracking == 0 ) 
                        {
                          emit(S);
                        }

                    }
                    break;
                case 3 :
                    // AS3_ex.g3:3524:9: literal
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_literal_in_primaryExpressionHelper14828);
                        literal336 = literal();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal336.Tree);

                    }
                    break;
                case 4 :
                    // AS3_ex.g3:3525:9: arrayLiteral
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_arrayLiteral_in_primaryExpressionHelper14840);
                        arrayLiteral337 = arrayLiteral();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arrayLiteral337.Tree);

                    }
                    break;
                case 5 :
                    // AS3_ex.g3:3526:9: objectLiteral
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_objectLiteral_in_primaryExpressionHelper14851);
                        objectLiteral338 = objectLiteral();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, objectLiteral338.Tree);

                    }
                    break;
                case 6 :
                    // AS3_ex.g3:3527:9: ( identifierLiteral x= XML_NS_OP )? identifierLiteral
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        // AS3_ex.g3:3527:9: ( identifierLiteral x= XML_NS_OP )?
                        int alt160 = 2;
                        int LA160_0 = input.LA(1);

                        if ( (LA160_0 == IDENTIFIER) )
                        {
                            int LA160_1 = input.LA(2);

                            if ( (LA160_1 == XML_NS_OP) )
                            {
                                int LA160_3 = input.LA(3);

                                if ( (synpred390_AS3_ex()) )
                                {
                                    alt160 = 1;
                                }
                            }
                        }
                        else if ( (LA160_0 == NATIVE || LA160_0 == TO || (LA160_0 >= EACH && LA160_0 <= NAMESPACE) || (LA160_0 >= DYNAMIC && LA160_0 <= STATIC)) )
                        {
                            int LA160_2 = input.LA(2);

                            if ( (LA160_2 == XML_NS_OP) )
                            {
                                int LA160_3 = input.LA(3);

                                if ( (synpred390_AS3_ex()) )
                                {
                                    alt160 = 1;
                                }
                            }
                        }
                        switch (alt160) 
                        {
                            case 1 :
                                // AS3_ex.g3:3527:10: identifierLiteral x= XML_NS_OP
                                {
                                    PushFollow(FOLLOW_identifierLiteral_in_primaryExpressionHelper14864);
                                    identifierLiteral339 = identifierLiteral();
                                    state.followingStackPointer--;
                                    if (state.failed) return retval;
                                    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifierLiteral339.Tree);
                                    x=(IToken)Match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_primaryExpressionHelper14868); if (state.failed) return retval;
                                    if ( state.backtracking == 0 )
                                    {x_tree = (object)adaptor.Create(x);
                                        adaptor.AddChild(root_0, x_tree);
                                    }
                                    if ( state.backtracking == 0 ) 
                                    {
                                      emit(x);
                                    }

                                }
                                break;

                        }

                        PushFollow(FOLLOW_identifierLiteral_in_primaryExpressionHelper14874);
                        identifierLiteral340 = identifierLiteral();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifierLiteral340.Tree);

                    }
                    break;
                case 7 :
                    // AS3_ex.g3:3528:9: xmlPrimaryExpression
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_xmlPrimaryExpression_in_primaryExpressionHelper14885);
                        xmlPrimaryExpression341 = xmlPrimaryExpression();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, xmlPrimaryExpression341.Tree);

                    }
                    break;
                case 8 :
                    // AS3_ex.g3:3529:9: parExpression
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_parExpression_in_primaryExpressionHelper14895);
                        parExpression342 = parExpression();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parExpression342.Tree);

                    }
                    break;
                case 9 :
                    // AS3_ex.g3:3530:9: l= LT type g= GT ( arrayLiteral )?
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        l=(IToken)Match(input,LT,FOLLOW_LT_in_primaryExpressionHelper14908); if (state.failed) return retval;
                        if ( state.backtracking == 0 )
                        {l_tree = (object)adaptor.Create(l);
                            adaptor.AddChild(root_0, l_tree);
                        }
                        if ( state.backtracking == 0 ) 
                        {
                          emit(l);
                        }
                        PushFollow(FOLLOW_type_in_primaryExpressionHelper14912);
                        type343 = type();
                        state.followingStackPointer--;
                        if (state.failed) return retval;
                        if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type343.Tree);
                        g=(IToken)Match(input,GT,FOLLOW_GT_in_primaryExpressionHelper14916); if (state.failed) return retval;
                        if ( state.backtracking == 0 )
                        {g_tree = (object)adaptor.Create(g);
                            adaptor.AddChild(root_0, g_tree);
                        }
                        if ( state.backtracking == 0 ) 
                        {
                          emit(g);
                        }
                        // AS3_ex.g3:3530:48: ( arrayLiteral )?
                        int alt161 = 2;
                        alt161 = dfa161.Predict(input);
                        switch (alt161) 
                        {
                            case 1 :
                                // AS3_ex.g3:3530:49: arrayLiteral
                                {
                                    PushFollow(FOLLOW_arrayLiteral_in_primaryExpressionHelper14921);
                                    arrayLiteral344 = arrayLiteral();
                                    state.followingStackPointer--;
                                    if (state.failed) return retval;
                                    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arrayLiteral344.Tree);

                                }
                                break;

                        }


                    }
                    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, 142, primaryExpressionHelper_StartIndex); 
            }
        }
        return retval;
    }