Boo.Lang.Parser.BooParserBase.ast_literal_block C# (CSharp) Метод

ast_literal_block() публичный Метод

public ast_literal_block ( QuasiquoteExpression e ) : void
e QuasiquoteExpression
Результат void
        public void ast_literal_block(
		QuasiquoteExpression e
	)
        {
            // TODO: either cache or construct these objects on demand
            TypeMemberCollection collection = new TypeMemberCollection();
            Block b = new Block();
            StatementCollection statements = b.Statements;
            Node node = null;

            try {      // for error handling
            bool synPredMatched451 = false;
            if (((tokenSet_108_.member(LA(1))) && (tokenSet_109_.member(LA(2)))))
            {
                int _m451 = mark();
                synPredMatched451 = true;
                inputState.guessing++;
                try {
                    {
                        ast_literal_module_prediction();
                    }
                }
                catch (RecognitionException)
                {
                    synPredMatched451 = false;
                }
                rewind(_m451);
                inputState.guessing--;
            }
            if ( synPredMatched451 )
            {
                {
                    ast_literal_module(e);
                }
            }
            else {
                bool synPredMatched461 = false;
                if (((tokenSet_35_.member(LA(1))) && (tokenSet_36_.member(LA(2)))))
                {
                    int _m461 = mark();
                    synPredMatched461 = true;
                    inputState.guessing++;
                    try {
                        {
                            attributes();
                            {
                                if ((tokenSet_31_.member(LA(1))) && (true))
                                {
                                    type_member_modifier();
                                }
                                else if ((tokenSet_110_.member(LA(1))) && (true)) {
                                    {
                                        modifiers();
                                        {
                                            switch ( LA(1) )
                                            {
                                            case CLASS:
                                            {
                                                match(CLASS);
                                                break;
                                            }
                                            case ENUM:
                                            {
                                                match(ENUM);
                                                break;
                                            }
                                            case STRUCT:
                                            {
                                                match(STRUCT);
                                                break;
                                            }
                                            case INTERFACE:
                                            {
                                                match(INTERFACE);
                                                break;
                                            }
                                            case EVENT:
                                            {
                                                match(EVENT);
                                                break;
                                            }
                                            case DEF:
                                            {
                                                match(DEF);
                                                break;
                                            }
                                            case CALLABLE:
                                            {
                                                match(CALLABLE);
                                                break;
                                            }
                                            case ID:
                                            case SPLICE_BEGIN:
                                            {
                                                {
                                                    {
                                                        switch ( LA(1) )
                                                        {
                                                        case ID:
                                                        {
                                                            match(ID);
                                                            break;
                                                        }
                                                        case SPLICE_BEGIN:
                                                        {
                                                            splice_expression();
                                                            break;
                                                        }
                                                        default:
                                                        {
                                                            throw new NoViableAltException(LT(1), getFilename());
                                                        }
                                                         }
                                                    }
                                                    {
                                                        switch ( LA(1) )
                                                        {
                                                        case AS:
                                                        {
                                                            match(AS);
                                                            type_reference();
                                                            break;
                                                        }
                                                        case COLON:
                                                        {
                                                            break;
                                                        }
                                                        default:
                                                        {
                                                            throw new NoViableAltException(LT(1), getFilename());
                                                        }
                                                         }
                                                    }
                                                    begin_with_doc(null);
                                                    {
                                                        switch ( LA(1) )
                                                        {
                                                        case GET:
                                                        {
                                                            match(GET);
                                                            break;
                                                        }
                                                        case SET:
                                                        {
                                                            match(SET);
                                                            break;
                                                        }
                                                        default:
                                                        {
                                                            throw new NoViableAltException(LT(1), getFilename());
                                                        }
                                                         }
                                                    }
                                                }
                                                break;
                                            }
                                            default:
                                            {
                                                throw new NoViableAltException(LT(1), getFilename());
                                            }
                                             }
                                        }
                                    }
                                }
                                else
                                {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }

                            }
                        }
                    }
                    catch (RecognitionException)
                    {
                        synPredMatched461 = false;
                    }
                    rewind(_m461);
                    inputState.guessing--;
                }
                if ( synPredMatched461 )
                {
                    {
                        { // ( ... )+
                            int _cnt464=0;
                            for (;;)
                            {
                                if ((tokenSet_35_.member(LA(1))))
                                {
                                    type_definition_member(collection);
                                }
                                else
                                {
                                    if (_cnt464 >= 1) { goto _loop464_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
                                }

                                _cnt464++;
                            }
            _loop464_breakloop:							;
                        }    // ( ... )+
                        if (0==inputState.guessing)
                        {

                                        if (collection.Count == 1) {
                                            e.Node = collection[0];
                                        } else {
                                            Module m = CodeFactory.NewQuasiquoteModule(e.LexicalInfo);
                                            m.Members = collection;
                                            e.Node = m;
                                        }

                        }
                    }
                }
                else if ((tokenSet_17_.member(LA(1))) && (tokenSet_89_.member(LA(2)))) {
                    { // ( ... )+
                        int _cnt466=0;
                        for (;;)
                        {
                            if ((tokenSet_17_.member(LA(1))))
                            {
                                stmt(statements);
                            }
                            else
                            {
                                if (_cnt466 >= 1) { goto _loop466_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
                            }

                            _cnt466++;
                        }
            _loop466_breakloop:						;
                    }    // ( ... )+
                    if (0==inputState.guessing)
                    {
                        e.Node = b.Statements.Count > 1 ? b : b.Statements[0];
                    }
                }
                else
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                }
            }
            catch (RecognitionException ex)
            {
                if (0 == inputState.guessing)
                {
                    reportError(ex, "ast_literal_block");
                    recover(ex,tokenSet_65_);
                }
                else
                {
                    throw ex;
                }
            }
        }
BooParserBase