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

closure_expression() protected method

protected closure_expression ( ) : Expression
return Expression
        protected Expression closure_expression()
        {
            Expression e;

            IToken  anchorBegin = null;
            IToken  anchorEnd = null;

                e = null;
                BlockExpression cbe = null;
                ParameterDeclarationCollection parameters = null;
                Block body = null;

            try {      // for error handling
            anchorBegin = LT(1);
            match(LBRACE);
            if (0==inputState.guessing)
            {

                            e = cbe = new BlockExpression(ToLexicalInfo(anchorBegin));
                            cbe.Annotate("inline");
                            parameters = cbe.Parameters;
                            body = cbe.Body;

            }
            {
                bool synPredMatched347 = false;
                if (((tokenSet_100_.member(LA(1))) && (tokenSet_101_.member(LA(2)))))
                {
                    int _m347 = mark();
                    synPredMatched347 = true;
                    inputState.guessing++;
                    try {
                        {
                            closure_parameters_test();
                        }
                    }
                    catch (RecognitionException)
                    {
                        synPredMatched347 = false;
                    }
                    rewind(_m347);
                    inputState.guessing--;
                }
                if ( synPredMatched347 )
                {
                    {
                        parameter_declaration_list(parameters);
                        match(BITWISE_OR);
                    }
                }
                else if ((tokenSet_102_.member(LA(1))) && (tokenSet_103_.member(LA(2)))) {
                }
                else
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }

            }
            {
                internal_closure_stmt(body);
                {    // ( ... )*
                    for (;;)
                    {
                        if ((LA(1)==EOL||LA(1)==EOS))
                        {
                            eos();
                            {
                                switch ( LA(1) )
                                {
                                case ESEPARATOR:
                                case CAST:
                                case CHAR:
                                case FALSE:
                                case NOT:
                                case NULL:
                                case RAISE:
                                case RETURN:
                                case SELF:
                                case SUPER:
                                case THEN:
                                case TRUE:
                                case TYPEOF:
                                case YIELD:
                                case TRIPLE_QUOTED_STRING:
                                case LPAREN:
                                case DOUBLE_QUOTED_STRING:
                                case SINGLE_QUOTED_STRING:
                                case ID:
                                case MULTIPLY:
                                case LBRACK:
                                case COMMA:
                                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:
                                {
                                    internal_closure_stmt(body);
                                    break;
                                }
                                case EOL:
                                case EOS:
                                case RBRACE:
                                {
                                    break;
                                }
                                default:
                                {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }
                                 }
                            }
                        }
                        else
                        {
                            goto _loop352_breakloop;
                        }

                    }
            _loop352_breakloop:					;
                }    // ( ... )*
            }
            anchorEnd = LT(1);
            match(RBRACE);
            if (0==inputState.guessing)
            {

                        body.EndSourceLocation = SourceLocationFactory.ToEndSourceLocation(anchorEnd);

            }
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "closure_expression");
                recover(ex,tokenSet_41_);
            }
            else
            {
                throw ex;
            }
            }
            return e;
        }
BooParserBase