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

stmt() protected method

protected stmt ( StatementCollection container ) : void
container StatementCollection
return void
        protected void stmt(
		StatementCollection container
	)
        {
            Statement s = null;
                StatementModifier m = null;

            try {      // for error handling
            {
                switch ( LA(1) )
                {
                case DEF:
                {
                    s=nested_function();
                    break;
                }
                case FOR:
                {
                    s=for_stmt();
                    break;
                }
                case WHILE:
                {
                    s=while_stmt();
                    break;
                }
                case IF:
                {
                    s=if_stmt();
                    break;
                }
                case UNLESS:
                {
                    s=unless_stmt();
                    break;
                }
                case TRY:
                {
                    s=try_stmt();
                    break;
                }
                case RETURN:
                {
                    s=return_stmt();
                    break;
                }
                default:
                    bool synPredMatched308 = false;
                    if ((((LA(1)==THEN||LA(1)==ID) && (tokenSet_4_.member(LA(2))))&&(IsValidMacroArgument(LA(2)))))
                    {
                        int _m308 = mark();
                        synPredMatched308 = true;
                        inputState.guessing++;
                        try {
                            {
                                macro_name();
                                {
                                    if ((tokenSet_5_.member(LA(1))))
                                    {
                                        expression();
                                    }
                                    else {
                                    }

                                }
                            }
                        }
                        catch (RecognitionException)
                        {
                            synPredMatched308 = false;
                        }
                        rewind(_m308);
                        inputState.guessing--;
                    }
                    if ( synPredMatched308 )
                    {
                        s=macro_stmt();
                    }
                    else {
                        bool synPredMatched312 = false;
                        if (((tokenSet_34_.member(LA(1))) && (tokenSet_79_.member(LA(2)))))
                        {
                            int _m312 = mark();
                            synPredMatched312 = true;
                            inputState.guessing++;
                            try {
                                {
                                    slicing_expression();
                                    {
                                        switch ( LA(1) )
                                        {
                                        case ASSIGN:
                                        {
                                            match(ASSIGN);
                                            break;
                                        }
                                        case DEF:
                                        case DO:
                                        case COLON:
                                        {
                                            {
                                                switch ( LA(1) )
                                                {
                                                case COLON:
                                                {
                                                    match(COLON);
                                                    break;
                                                }
                                                case DO:
                                                {
                                                    match(DO);
                                                    break;
                                                }
                                                case DEF:
                                                {
                                                    match(DEF);
                                                    break;
                                                }
                                                default:
                                                {
                                                    throw new NoViableAltException(LT(1), getFilename());
                                                }
                                                 }
                                            }
                                            break;
                                        }
                                        default:
                                        {
                                            throw new NoViableAltException(LT(1), getFilename());
                                        }
                                         }
                                    }
                                }
                            }
                            catch (RecognitionException)
                            {
                                synPredMatched312 = false;
                            }
                            rewind(_m312);
                            inputState.guessing--;
                        }
                        if ( synPredMatched312 )
                        {
                            s=assignment_or_method_invocation_with_block_stmt();
                        }
                        else {
                            bool synPredMatched314 = false;
                            if (((LA(1)==ID) && (LA(2)==AS||LA(2)==COMMA)))
                            {
                                int _m314 = mark();
                                synPredMatched314 = true;
                                inputState.guessing++;
                                try {
                                    {
                                        declaration();
                                        match(COMMA);
                                    }
                                }
                                catch (RecognitionException)
                                {
                                    synPredMatched314 = false;
                                }
                                rewind(_m314);
                                inputState.guessing--;
                            }
                            if ( synPredMatched314 )
                            {
                                s=unpack_stmt();
                            }
                            else if ((LA(1)==ID) && (LA(2)==AS)) {
                                s=declaration_stmt();
                            }
                            else if ((tokenSet_80_.member(LA(1))) && (tokenSet_81_.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());
                                        }
                                         }
                                    }
                                    {
                                        switch ( LA(1) )
                                        {
                                        case IF:
                                        case UNLESS:
                                        case WHILE:
                                        {
                                            m=stmt_modifier();
                                            if (0==inputState.guessing)
                                            {
                                                if (s != null) s.Modifier = m;
                                            }
                                            break;
                                        }
                                        case EOL:
                                        case EOS:
                                        {
                                            break;
                                        }
                                        default:
                                        {
                                            throw new NoViableAltException(LT(1), getFilename());
                                        }
                                         }
                                    }
                                    eos();
                                }
                            }
                        else
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                        }}break; }
                    }
                    if (0==inputState.guessing)
                    {

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

                    }
                }
                catch (RecognitionException ex)
                {
                    if (0 == inputState.guessing)
                    {
                        reportError(ex, "stmt");
                        recover(ex,tokenSet_82_);
                    }
                    else
                    {
                        throw ex;
                    }
                }
        }
BooParserBase