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

if_stmt() protected method

protected if_stmt ( ) : IfStatement
return IfStatement
        protected IfStatement if_stmt()
        {
            IfStatement returnValue;

            IToken  it = null;
            IToken  ei = null;
            IToken  et = null;

                returnValue = null;

                IfStatement s = null;
                Expression e = null;

            try {      // for error handling
            it = LT(1);
            match(IF);
            e=expression();
            if (0==inputState.guessing)
            {

                        returnValue = s = new IfStatement(ToLexicalInfo(it));
                        s.Condition = e;
                        s.TrueBlock = new Block();

            }
            compound_stmt(s.TrueBlock);
            {    // ( ... )*
                for (;;)
                {
                    if ((LA(1)==ELIF))
                    {
                        ei = LT(1);
                        match(ELIF);
                        e=expression();
                        if (0==inputState.guessing)
                        {

                                        s.FalseBlock = new Block();

                                        IfStatement elif = new IfStatement(ToLexicalInfo(ei));
                                        elif.TrueBlock = new Block();
                                        elif.Condition = e;

                                        s.FalseBlock.Add(elif);
                                        s = elif;

                        }
                        compound_stmt(s.TrueBlock);
                    }
                    else
                    {
                        goto _loop411_breakloop;
                    }

                }
            _loop411_breakloop:				;
            }    // ( ... )*
            {
                switch ( LA(1) )
                {
                case ELSE:
                {
                    et = LT(1);
                    match(ELSE);
                    if (0==inputState.guessing)
                    {
                        s.FalseBlock = new Block(ToLexicalInfo(et));
                    }
                    compound_stmt(s.FalseBlock);
                    break;
                }
                case EOF:
                case DEDENT:
                case ESEPARATOR:
                case ASSEMBLY_ATTRIBUTE_BEGIN:
                case MODULE_ATTRIBUTE_BEGIN:
                case ABSTRACT:
                case BREAK:
                case CONTINUE:
                case CALLABLE:
                case CAST:
                case CHAR:
                case CLASS:
                case DEF:
                case ENUM:
                case EVENT:
                case FINAL:
                case FOR:
                case FALSE:
                case GOTO:
                case INTERFACE:
                case INTERNAL:
                case IF:
                case NEW:
                case NULL:
                case OVERRIDE:
                case PARTIAL:
                case PUBLIC:
                case PROTECTED:
                case PRIVATE:
                case RAISE:
                case RETURN:
                case SELF:
                case SUPER:
                case STATIC:
                case STRUCT:
                case THEN:
                case TRY:
                case TRANSIENT:
                case TRUE:
                case TYPEOF:
                case UNLESS:
                case VIRTUAL:
                case WHILE:
                case YIELD:
                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 COLON:
                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:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "if_stmt");
                recover(ex,tokenSet_82_);
            }
            else
            {
                throw ex;
            }
            }
            return returnValue;
        }
BooParserBase