Boo.Lang.Parser.BooParserBase.simple_stmt C# (CSharp) Method

simple_stmt() protected method

protected simple_stmt ( StatementCollection container ) : void
container StatementCollection
return void
        protected void simple_stmt(
		StatementCollection container
	)
        {
            Statement s = null;
                _compact = true;

            try {      // for error handling
            {
                if (((LA(1)==THEN||LA(1)==ID) && (tokenSet_24_.member(LA(2))))&&(IsValidMacroArgument(LA(2))))
                {
                    s=closure_macro_stmt();
                }
                else {
                    bool synPredMatched321 = false;
                    if (((tokenSet_34_.member(LA(1))) && (tokenSet_86_.member(LA(2)))))
                    {
                        int _m321 = mark();
                        synPredMatched321 = true;
                        inputState.guessing++;
                        try {
                            {
                                slicing_expression();
                                match(ASSIGN);
                            }
                        }
                        catch (RecognitionException)
                        {
                            synPredMatched321 = false;
                        }
                        rewind(_m321);
                        inputState.guessing--;
                    }
                    if ( synPredMatched321 )
                    {
                        s=assignment_or_method_invocation();
                    }
                    else if ((LA(1)==RETURN)) {
                        s=return_expression_stmt();
                    }
                    else {
                        bool synPredMatched323 = false;
                        if (((LA(1)==ID) && (LA(2)==AS||LA(2)==COMMA)))
                        {
                            int _m323 = mark();
                            synPredMatched323 = true;
                            inputState.guessing++;
                            try {
                                {
                                    declaration();
                                    match(COMMA);
                                }
                            }
                            catch (RecognitionException)
                            {
                                synPredMatched323 = false;
                            }
                            rewind(_m323);
                            inputState.guessing--;
                        }
                        if ( synPredMatched323 )
                        {
                            s=unpack();
                        }
                        else if ((LA(1)==ID) && (LA(2)==AS)) {
                            s=declaration_stmt();
                        }
                        else if ((tokenSet_80_.member(LA(1))) && (tokenSet_87_.member(LA(2)))) {
                            {
                                {
                                    switch ( LA(1) )
                                    {
                                    case GOTO:
                                    {
                                        s=goto_stmt();
                                        break;
                                    }
                                    case COLON:
                                    {
                                        s=label_stmt();
                                        break;
                                    }
                                    case YIELD:
                                    {
                                        s=yield_stmt();
                                        break;
                                    }
                                    case BREAK:
                                    {
                                        s=break_stmt();
                                        break;
                                    }
                                    case CONTINUE:
                                    {
                                        s=continue_stmt();
                                        break;
                                    }
                                    case RAISE:
                                    {
                                        s=raise_stmt();
                                        break;
                                    }
                                    case ESEPARATOR:
                                    case CAST:
                                    case CHAR:
                                    case FALSE:
                                    case NULL:
                                    case SELF:
                                    case SUPER:
                                    case THEN:
                                    case TRUE:
                                    case TYPEOF:
                                    case TRIPLE_QUOTED_STRING:
                                    case LPAREN:
                                    case DOUBLE_QUOTED_STRING:
                                    case SINGLE_QUOTED_STRING:
                                    case ID:
                                    case MULTIPLY:
                                    case LBRACK:
                                    case SPLICE_BEGIN:
                                    case DOT:
                                    case LBRACE:
                                    case QQ_BEGIN:
                                    case SUBTRACT:
                                    case LONG:
                                    case INCREMENT:
                                    case DECREMENT:
                                    case ONES_COMPLEMENT:
                                    case INT:
                                    case BACKTICK_QUOTED_STRING:
                                    case RE_LITERAL:
                                    case DOUBLE:
                                    case FLOAT:
                                    case TIMESPAN:
                                    {
                                        s=expression_stmt();
                                        break;
                                    }
                                    default:
                                    {
                                        throw new NoViableAltException(LT(1), getFilename());
                                    }
                                     }
                                }
                            }
                        }
                        else
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                        }}
                    }
                    if (0==inputState.guessing)
                    {

                                if (null != s)
                                {
                                    container.Add(s);
                                }

                    }
                    if (0==inputState.guessing)
                    {
                        _compact=false;
                    }
                }
                catch (RecognitionException ex)
                {
                    if (0 == inputState.guessing)
                    {
                        reportError(ex, "simple_stmt");
                        recover(ex,tokenSet_19_);
                    }
                    else
                    {
                        throw ex;
                    }
                }
        }
BooParserBase