Example #1
0
    // $ANTLR start "leftHandSideExpression"
    // AS3_ex.g3:2409:1: leftHandSideExpression : memberExpression ( arguments | L= LBRACK expression R= RBRACK | D= DOT ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | E= XML_ELLIPSIS ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | D= DOT parExpression | typePostfixSyntax )* ;
    public AS3_exParser.leftHandSideExpression_return leftHandSideExpression() // throws RecognitionException [1]
    {   
        AS3_exParser.leftHandSideExpression_return retval = new AS3_exParser.leftHandSideExpression_return();
        retval.Start = input.LT(1);
        int leftHandSideExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken L = null;
        IToken R = null;
        IToken D = null;
        IToken op = null;
        IToken E = null;
        AS3_exParser.memberExpression_return memberExpression305 = null;

        AS3_exParser.arguments_return arguments306 = null;

        AS3_exParser.expression_return expression307 = null;

        AS3_exParser.eitherIdentifier_return eitherIdentifier308 = null;

        AS3_exParser.eitherIdentifier_return eitherIdentifier309 = null;

        AS3_exParser.eitherIdentifier_return eitherIdentifier310 = null;

        AS3_exParser.eitherIdentifier_return eitherIdentifier311 = null;

        AS3_exParser.parExpression_return parExpression312 = null;

        AS3_exParser.typePostfixSyntax_return typePostfixSyntax313 = null;


        object L_tree=null;
        object R_tree=null;
        object D_tree=null;
        object op_tree=null;
        object E_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 131) ) 
    	    {
    	    	return retval; 
    	    }
            // AS3_ex.g3:2410:5: ( memberExpression ( arguments | L= LBRACK expression R= RBRACK | D= DOT ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | E= XML_ELLIPSIS ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | D= DOT parExpression | typePostfixSyntax )* )
            // AS3_ex.g3:2410:9: memberExpression ( arguments | L= LBRACK expression R= RBRACK | D= DOT ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | E= XML_ELLIPSIS ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | D= DOT parExpression | typePostfixSyntax )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_memberExpression_in_leftHandSideExpression11868);
            	memberExpression305 = memberExpression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, memberExpression305.Tree);
            	// AS3_ex.g3:2411:5: ( arguments | L= LBRACK expression R= RBRACK | D= DOT ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | E= XML_ELLIPSIS ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier | D= DOT parExpression | typePostfixSyntax )*
            	do 
            	{
            	    int alt146 = 7;
            	    alt146 = dfa146.Predict(input);
            	    switch (alt146) 
            		{
            			case 1 :
            			    // AS3_ex.g3:2412:7: arguments
            			    {
            			    	PushFollow(FOLLOW_arguments_in_leftHandSideExpression11883);
            			    	arguments306 = arguments();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments306.Tree);

            			    }
            			    break;
            			case 2 :
            			    // AS3_ex.g3:2413:9: L= LBRACK expression R= RBRACK
            			    {
            			    	L=(IToken)Match(input,LBRACK,FOLLOW_LBRACK_in_leftHandSideExpression11895); 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);InsertWS(mPrinter.GetAdvancedSpacesInsideArrayReferenceBrackets());
            			    	}
            			    	PushFollow(FOLLOW_expression_in_leftHandSideExpression11899);
            			    	expression307 = expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression307.Tree);
            			    	R=(IToken)Match(input,RBRACK,FOLLOW_RBRACK_in_leftHandSideExpression11903); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{R_tree = (object)adaptor.Create(R);
            			    		adaptor.AddChild(root_0, R_tree);
            			    	}
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  InsertWS(mPrinter.GetAdvancedSpacesInsideArrayReferenceBrackets());Emit((CommonToken)R);
            			    	}

            			    }
            			    break;
            			case 3 :
            			    // AS3_ex.g3:2415:9: D= DOT ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier
            			    {
            			    	D=(IToken)Match(input,DOT,FOLLOW_DOT_in_leftHandSideExpression11918); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{D_tree = (object)adaptor.Create(D);
            			    		adaptor.AddChild(root_0, D_tree);
            			    	}
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  Emit((CommonToken)D);
            			    	}
            			    	// AS3_ex.g3:2415:40: ( eitherIdentifier op= XML_NS_OP )?
            			    	int alt144 = 2;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	    case IDENTIFIER:
            			    	    	{
            			    	        int LA144_1 = input.LA(2);

            			    	        if ( (synpred307_AS3_ex()) )
            			    	        {
            			    	            alt144 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case XML_AT:
            			    	    	{
            			    	        int LA144_2 = input.LA(2);

            			    	        if ( (synpred307_AS3_ex()) )
            			    	        {
            			    	            alt144 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case AS:
            			    	    case BREAK:
            			    	    case CASE:
            			    	    case CATCH:
            			    	    case CLASS:
            			    	    case CONST:
            			    	    case CONTINUE:
            			    	    case DEFAULT:
            			    	    case DELETE:
            			    	    case DO:
            			    	    case ELSE:
            			    	    case EXTENDS:
            			    	    case FALSE:
            			    	    case FINALLY:
            			    	    case FOR:
            			    	    case FUNCTION:
            			    	    case IF:
            			    	    case IMPLEMENTS:
            			    	    case IMPORT:
            			    	    case IN:
            			    	    case INSTANCEOF:
            			    	    case INTERFACE:
            			    	    case INTERNAL:
            			    	    case IS:
            			    	    case NEW:
            			    	    case NULL:
            			    	    case PACKAGE:
            			    	    case PRIVATE:
            			    	    case PROTECTED:
            			    	    case PUBLIC:
            			    	    case RETURN:
            			    	    case SUPER:
            			    	    case SWITCH:
            			    	    case THIS:
            			    	    case THROW:
            			    	    case TRUE:
            			    	    case TRY:
            			    	    case TYPEOF:
            			    	    case USE:
            			    	    case VAR:
            			    	    case VOID:
            			    	    case WHILE:
            			    	    case WITH:
            			    	    case INCLUDE:
            			    	    	{
            			    	        int LA144_3 = input.LA(2);

            			    	        if ( (synpred307_AS3_ex()) )
            			    	        {
            			    	            alt144 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case NATIVE:
            			    	    case TO:
            			    	    case EACH:
            			    	    case GET:
            			    	    case SET:
            			    	    case NAMESPACE:
            			    	    case DYNAMIC:
            			    	    case FINAL:
            			    	    case OVERRIDE:
            			    	    case STATIC:
            			    	    	{
            			    	        int LA144_4 = input.LA(2);

            			    	        if ( (synpred307_AS3_ex()) )
            			    	        {
            			    	            alt144 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case STAR:
            			    	    	{
            			    	        int LA144_5 = input.LA(2);

            			    	        if ( (synpred307_AS3_ex()) )
            			    	        {
            			    	            alt144 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	}

            			    	switch (alt144) 
            			    	{
            			    	    case 1 :
            			    	        // AS3_ex.g3:2415:41: eitherIdentifier op= XML_NS_OP
            			    	        {
            			    	        	PushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression11923);
            			    	        	eitherIdentifier308 = eitherIdentifier();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, eitherIdentifier308.Tree);
            			    	        	op=(IToken)Match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_leftHandSideExpression11927); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{op_tree = (object)adaptor.Create(op);
            			    	        		adaptor.AddChild(root_0, op_tree);
            			    	        	}
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  Emit((CommonToken)op);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression11934);
            			    	eitherIdentifier309 = eitherIdentifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, eitherIdentifier309.Tree);

            			    }
            			    break;
            			case 4 :
            			    // AS3_ex.g3:2416:9: E= XML_ELLIPSIS ( eitherIdentifier op= XML_NS_OP )? eitherIdentifier
            			    {
            			    	E=(IToken)Match(input,XML_ELLIPSIS,FOLLOW_XML_ELLIPSIS_in_leftHandSideExpression11946); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{E_tree = (object)adaptor.Create(E);
            			    		adaptor.AddChild(root_0, E_tree);
            			    	}
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  Emit((CommonToken)E);
            			    	}
            			    	// AS3_ex.g3:2416:48: ( eitherIdentifier op= XML_NS_OP )?
            			    	int alt145 = 2;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	    case IDENTIFIER:
            			    	    	{
            			    	        int LA145_1 = input.LA(2);

            			    	        if ( (synpred309_AS3_ex()) )
            			    	        {
            			    	            alt145 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case XML_AT:
            			    	    	{
            			    	        int LA145_2 = input.LA(2);

            			    	        if ( (synpred309_AS3_ex()) )
            			    	        {
            			    	            alt145 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case AS:
            			    	    case BREAK:
            			    	    case CASE:
            			    	    case CATCH:
            			    	    case CLASS:
            			    	    case CONST:
            			    	    case CONTINUE:
            			    	    case DEFAULT:
            			    	    case DELETE:
            			    	    case DO:
            			    	    case ELSE:
            			    	    case EXTENDS:
            			    	    case FALSE:
            			    	    case FINALLY:
            			    	    case FOR:
            			    	    case FUNCTION:
            			    	    case IF:
            			    	    case IMPLEMENTS:
            			    	    case IMPORT:
            			    	    case IN:
            			    	    case INSTANCEOF:
            			    	    case INTERFACE:
            			    	    case INTERNAL:
            			    	    case IS:
            			    	    case NEW:
            			    	    case NULL:
            			    	    case PACKAGE:
            			    	    case PRIVATE:
            			    	    case PROTECTED:
            			    	    case PUBLIC:
            			    	    case RETURN:
            			    	    case SUPER:
            			    	    case SWITCH:
            			    	    case THIS:
            			    	    case THROW:
            			    	    case TRUE:
            			    	    case TRY:
            			    	    case TYPEOF:
            			    	    case USE:
            			    	    case VAR:
            			    	    case VOID:
            			    	    case WHILE:
            			    	    case WITH:
            			    	    case INCLUDE:
            			    	    	{
            			    	        int LA145_3 = input.LA(2);

            			    	        if ( (synpred309_AS3_ex()) )
            			    	        {
            			    	            alt145 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case NATIVE:
            			    	    case TO:
            			    	    case EACH:
            			    	    case GET:
            			    	    case SET:
            			    	    case NAMESPACE:
            			    	    case DYNAMIC:
            			    	    case FINAL:
            			    	    case OVERRIDE:
            			    	    case STATIC:
            			    	    	{
            			    	        int LA145_4 = input.LA(2);

            			    	        if ( (synpred309_AS3_ex()) )
            			    	        {
            			    	            alt145 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	    case STAR:
            			    	    	{
            			    	        int LA145_5 = input.LA(2);

            			    	        if ( (synpred309_AS3_ex()) )
            			    	        {
            			    	            alt145 = 1;
            			    	        }
            			    	        }
            			    	        break;
            			    	}

            			    	switch (alt145) 
            			    	{
            			    	    case 1 :
            			    	        // AS3_ex.g3:2416:49: eitherIdentifier op= XML_NS_OP
            			    	        {
            			    	        	PushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression11950);
            			    	        	eitherIdentifier310 = eitherIdentifier();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, eitherIdentifier310.Tree);
            			    	        	op=(IToken)Match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_leftHandSideExpression11954); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{op_tree = (object)adaptor.Create(op);
            			    	        		adaptor.AddChild(root_0, op_tree);
            			    	        	}
            			    	        	if ( state.backtracking == 0 ) 
            			    	        	{
            			    	        	  Emit((CommonToken)op);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression11961);
            			    	eitherIdentifier311 = eitherIdentifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, eitherIdentifier311.Tree);

            			    }
            			    break;
            			case 5 :
            			    // AS3_ex.g3:2417:9: D= DOT parExpression
            			    {
            			    	D=(IToken)Match(input,DOT,FOLLOW_DOT_in_leftHandSideExpression11973); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{D_tree = (object)adaptor.Create(D);
            			    		adaptor.AddChild(root_0, D_tree);
            			    	}
            			    	if ( state.backtracking == 0 ) 
            			    	{
            			    	  Emit((CommonToken)D);
            			    	}
            			    	PushFollow(FOLLOW_parExpression_in_leftHandSideExpression11977);
            			    	parExpression312 = parExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parExpression312.Tree);

            			    }
            			    break;
            			case 6 :
            			    // AS3_ex.g3:2418:9: typePostfixSyntax
            			    {
            			    	PushFollow(FOLLOW_typePostfixSyntax_in_leftHandSideExpression11987);
            			    	typePostfixSyntax313 = typePostfixSyntax();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typePostfixSyntax313.Tree);

            			    }
            			    break;

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

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


            }

            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, 131, leftHandSideExpression_StartIndex); 
            }
        }
        return retval;
    }
Example #2
0
    // $ANTLR start "leftHandSideExpression"
    // AS3_ex.g3:3369:1: leftHandSideExpression : memberExpression ( arguments | L= LBRACK expression R= RBRACK | E= XML_ELLIPSIS eitherIdentifier | D= DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | op= XML_NS_OP expression )* ;
    public AS3_exParser.leftHandSideExpression_return leftHandSideExpression() // throws RecognitionException [1]
    {   
        AS3_exParser.leftHandSideExpression_return retval = new AS3_exParser.leftHandSideExpression_return();
        retval.Start = input.LT(1);
        int leftHandSideExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken L = null;
        IToken R = null;
        IToken E = null;
        IToken D = null;
        IToken op = null;
        AS3_exParser.memberExpression_return memberExpression316 = null;

        AS3_exParser.arguments_return arguments317 = null;

        AS3_exParser.expression_return expression318 = null;

        AS3_exParser.eitherIdentifier_return eitherIdentifier319 = null;

        AS3_exParser.eitherIdentifier_return eitherIdentifier320 = null;

        AS3_exParser.parExpression_return parExpression321 = null;

        AS3_exParser.typePostfixSyntax_return typePostfixSyntax322 = null;

        AS3_exParser.expression_return expression323 = null;


        object L_tree=null;
        object R_tree=null;
        object E_tree=null;
        object D_tree=null;
        object op_tree=null;


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

        try 
        {
            if ( (state.backtracking > 0) && AlreadyParsedRule(input, 131) ) 
            {
                return retval; 
            }
            // AS3_ex.g3:3374:5: ( memberExpression ( arguments | L= LBRACK expression R= RBRACK | E= XML_ELLIPSIS eitherIdentifier | D= DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | op= XML_NS_OP expression )* )
            // AS3_ex.g3:3374:7: memberExpression ( arguments | L= LBRACK expression R= RBRACK | E= XML_ELLIPSIS eitherIdentifier | D= DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | op= XML_NS_OP expression )*
            {
                root_0 = (object)adaptor.GetNilNode();

                if ( state.backtracking == 0 ) 
                {
                  pushedWrapInfo=pushWrapInfo(options, true);
                }
                PushFollow(FOLLOW_memberExpression_in_leftHandSideExpression13646);
                memberExpression316 = memberExpression();
                state.followingStackPointer--;
                if (state.failed) return retval;
                if ( state.backtracking == 0 ) adaptor.AddChild(root_0, memberExpression316.Tree);
                // AS3_ex.g3:3376:5: ( arguments | L= LBRACK expression R= RBRACK | E= XML_ELLIPSIS eitherIdentifier | D= DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | op= XML_NS_OP expression )*
                do 
                {
                    int alt152 = 7;
                    alt152 = dfa152.Predict(input);
                    switch (alt152) 
                    {
                        case 1 :
                            // AS3_ex.g3:3377:7: arguments
                            {
                                PushFollow(FOLLOW_arguments_in_leftHandSideExpression13661);
                                arguments317 = arguments();
                                state.followingStackPointer--;
                                if (state.failed) return retval;
                                if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments317.Tree);

                            }
                            break;
                        case 2 :
                            // AS3_ex.g3:3378:9: L= LBRACK expression R= RBRACK
                            {
                                L=(IToken)Match(input,LBRACK,FOLLOW_LBRACK_in_leftHandSideExpression13673); 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);insertWS(mPrinter.getAdvancedSpacesInsideArrayReferenceBrackets());
                                }
                                PushFollow(FOLLOW_expression_in_leftHandSideExpression13677);
                                expression318 = expression();
                                state.followingStackPointer--;
                                if (state.failed) return retval;
                                if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression318.Tree);
                                R=(IToken)Match(input,RBRACK,FOLLOW_RBRACK_in_leftHandSideExpression13681); if (state.failed) return retval;
                                if ( state.backtracking == 0 )
                                {R_tree = (object)adaptor.Create(R);
                                    adaptor.AddChild(root_0, R_tree);
                                }
                                if ( state.backtracking == 0 ) 
                                {
                                  insertWS(mPrinter.getAdvancedSpacesInsideArrayReferenceBrackets());emit(R);
                                }

                            }
                            break;
                        case 3 :
                            // AS3_ex.g3:3381:9: E= XML_ELLIPSIS eitherIdentifier
                            {
                                E=(IToken)Match(input,XML_ELLIPSIS,FOLLOW_XML_ELLIPSIS_in_leftHandSideExpression13697); if (state.failed) return retval;
                                if ( state.backtracking == 0 )
                                {E_tree = (object)adaptor.Create(E);
                                    adaptor.AddChild(root_0, E_tree);
                                }
                                if ( state.backtracking == 0 ) 
                                {
                                  wrapEmit(E, ASPrettyPrinter.Break_Other_Connectors_code);
                                }
                                PushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression13700);
                                eitherIdentifier319 = eitherIdentifier();
                                state.followingStackPointer--;
                                if (state.failed) return retval;
                                if ( state.backtracking == 0 ) adaptor.AddChild(root_0, eitherIdentifier319.Tree);
                                if ( state.backtracking == 0 ) 
                                {
                                  popIndent();
                                }

                            }
                            break;
                        case 4 :
                            // AS3_ex.g3:3382:9: D= DOT ( eitherIdentifier | parExpression )
                            {
                                D=(IToken)Match(input,DOT,FOLLOW_DOT_in_leftHandSideExpression13714); if (state.failed) return retval;
                                if ( state.backtracking == 0 )
                                {D_tree = (object)adaptor.Create(D);
                                    adaptor.AddChild(root_0, D_tree);
                                }
                                // AS3_ex.g3:3382:15: ( eitherIdentifier | parExpression )
                                int alt151 = 2;
                                int LA151_0 = input.LA(1);

                                if ( ((LA151_0 >= AS && LA151_0 <= STATIC) || LA151_0 == STAR || LA151_0 == XML_AT || LA151_0 == IDENTIFIER) )
                                {
                                    alt151 = 1;
                                }
                                else if ( (LA151_0 == LPAREN) )
                                {
                                    alt151 = 2;
                                }
                                else 
                                {
                                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                                    NoViableAltException nvae_d151s0 =
                                        new NoViableAltException("", 151, 0, input);

                                    throw nvae_d151s0;
                                }
                                switch (alt151) 
                                {
                                    case 1 :
                                        // AS3_ex.g3:3382:16: eitherIdentifier
                                        {
                                            if ( state.backtracking == 0 ) 
                                            {
                                              wrapEmit(D, ASPrettyPrinter.Break_Function_Calls_code);
                                            }
                                            PushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression13719);
                                            eitherIdentifier320 = eitherIdentifier();
                                            state.followingStackPointer--;
                                            if (state.failed) return retval;
                                            if ( state.backtracking == 0 ) adaptor.AddChild(root_0, eitherIdentifier320.Tree);

                                        }
                                        break;
                                    case 2 :
                                        // AS3_ex.g3:3382:94: parExpression
                                        {
                                            if ( state.backtracking == 0 ) 
                                            {
                                              wrapEmit(D, ASPrettyPrinter.Break_Other_Connectors_code);
                                            }
                                            PushFollow(FOLLOW_parExpression_in_leftHandSideExpression13725);
                                            parExpression321 = parExpression();
                                            state.followingStackPointer--;
                                            if (state.failed) return retval;
                                            if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parExpression321.Tree);

                                        }
                                        break;

                                }

                                if ( state.backtracking == 0 ) 
                                {
                                  popIndent();
                                }

                            }
                            break;
                        case 5 :
                            // AS3_ex.g3:3383:9: typePostfixSyntax
                            {
                                PushFollow(FOLLOW_typePostfixSyntax_in_leftHandSideExpression13738);
                                typePostfixSyntax322 = typePostfixSyntax();
                                state.followingStackPointer--;
                                if (state.failed) return retval;
                                if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typePostfixSyntax322.Tree);

                            }
                            break;
                        case 6 :
                            // AS3_ex.g3:3384:9: op= XML_NS_OP expression
                            {
                                op=(IToken)Match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_leftHandSideExpression13750); if (state.failed) return retval;
                                if ( state.backtracking == 0 )
                                {op_tree = (object)adaptor.Create(op);
                                    adaptor.AddChild(root_0, op_tree);
                                }
                                if ( state.backtracking == 0 ) 
                                {
                                  wrapEmit(op, ASPrettyPrinter.Break_Other_Connectors_code);
                                }
                                PushFollow(FOLLOW_expression_in_leftHandSideExpression13754);
                                expression323 = expression();
                                state.followingStackPointer--;
                                if (state.failed) return retval;
                                if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression323.Tree);
                                if ( state.backtracking == 0 ) 
                                {
                                  popIndent();
                                }

                            }
                            break;

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

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

                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, 131, leftHandSideExpression_StartIndex); 
            }
        }
        return retval;
    }