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

ast_literal_closure() public method

public ast_literal_closure ( QuasiquoteExpression e ) : void
e QuasiquoteExpression
return void
        public void ast_literal_closure(
		QuasiquoteExpression e
	)
        {
            IToken  c = null;

            Block block = null;
            Node node = null;

            try {      // for error handling
            bool synPredMatched473 = false;
            if (((tokenSet_5_.member(LA(1))) && (tokenSet_111_.member(LA(2)))))
            {
                int _m473 = mark();
                synPredMatched473 = true;
                inputState.guessing++;
                try {
                    {
                        expression();
                        {
                            switch ( LA(1) )
                            {
                            case COLON:
                            {
                                match(COLON);
                                break;
                            }
                            case QQ_END:
                            {
                                match(QQ_END);
                                break;
                            }
                            default:
                            {
                                throw new NoViableAltException(LT(1), getFilename());
                            }
                             }
                        }
                    }
                }
                catch (RecognitionException)
                {
                    synPredMatched473 = false;
                }
                rewind(_m473);
                inputState.guessing--;
            }
            if ( synPredMatched473 )
            {
                {
                    node=expression();
                    if (0==inputState.guessing)
                    {
                        e.Node = node;
                    }
                    {
                        switch ( LA(1) )
                        {
                        case COLON:
                        {
                            c = LT(1);
                            match(COLON);
                            node=expression();
                            if (0==inputState.guessing)
                            {

                                                e.Node = new ExpressionPair(ToLexicalInfo(c), (Expression)e.Node, (Expression)node);

                            }
                            break;
                        }
                        case QQ_END:
                        {
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                }
            }
            else if ((LA(1)==IMPORT)) {
                {
                    node=import_directive_();
                    if (0==inputState.guessing)
                    {

                                    e.Node = node;

                    }
                }
            }
            else if ((tokenSet_102_.member(LA(1))) && (tokenSet_99_.member(LA(2)))) {
                {
                    if (0==inputState.guessing)
                    {
                        block = new Block();
                    }
                    internal_closure_stmt(block);
                    {    // ( ... )*
                        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(block);
                                        break;
                                    }
                                    case EOL:
                                    case EOS:
                                    case QQ_END:
                                    {
                                        break;
                                    }
                                    default:
                                    {
                                        throw new NoViableAltException(LT(1), getFilename());
                                    }
                                     }
                                }
                            }
                            else
                            {
                                goto _loop480_breakloop;
                            }

                        }
            _loop480_breakloop:						;
                    }    // ( ... )*
                    if (0==inputState.guessing)
                    {

                                    e.Node = block;
                                    if (block.Statements.Count == 1)
                                    {
                                        e.Node = block.Statements[0];
                                    }

                    }
                }
            }
            else
            {
                throw new NoViableAltException(LT(1), getFilename());
            }

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