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

array_or_expression() защищенный Метод

protected array_or_expression ( ) : Expression
Результат Expression
        protected Expression array_or_expression()
        {
            Expression e;

            IToken  c = null;
            IToken  t = null;

                e = null;
                ArrayLiteralExpression tle = null;

            try {      // for error handling
            switch ( LA(1) )
            {
            case COMMA:
            {
                {
                    c = LT(1);
                    match(COMMA);
                    if (0==inputState.guessing)
                    {
                        e = new ArrayLiteralExpression(ToLexicalInfo(c));
                    }
                }
                break;
            }
            case ESEPARATOR:
            case CAST:
            case CHAR:
            case FALSE:
            case NOT:
            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:
            {
                {
                    e=expression();
                    {
                        switch ( LA(1) )
                        {
                        case COMMA:
                        {
                            t = LT(1);
                            match(COMMA);
                            if (0==inputState.guessing)
                            {

                                                tle = new ArrayLiteralExpression(e.LexicalInfo);
                                                tle.Items.Add(e);

                            }
                            {
                                if ((tokenSet_5_.member(LA(1))) && (tokenSet_75_.member(LA(2))))
                                {
                                    e=expression();
                                    if (0==inputState.guessing)
                                    {
                                        tle.Items.Add(e);
                                    }
                                    {    // ( ... )*
                                        for (;;)
                                        {
                                            if ((LA(1)==COMMA) && (tokenSet_5_.member(LA(2))))
                                            {
                                                match(COMMA);
                                                e=expression();
                                                if (0==inputState.guessing)
                                                {
                                                    tle.Items.Add(e);
                                                }
                                            }
                                            else
                                            {
                                                goto _loop428_breakloop;
                                            }

                                        }
            _loop428_breakloop:										;
                                    }    // ( ... )*
                                    {
                                        switch ( LA(1) )
                                        {
                                        case COMMA:
                                        {
                                            match(COMMA);
                                            break;
                                        }
                                        case EOF:
                                        case DEDENT:
                                        case ESEPARATOR:
                                        case EOL:
                                        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 DO:
                                        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 EOS:
                                        case LPAREN:
                                        case RPAREN:
                                        case DOUBLE_QUOTED_STRING:
                                        case SINGLE_QUOTED_STRING:
                                        case ID:
                                        case MULTIPLY:
                                        case LBRACK:
                                        case SPLICE_BEGIN:
                                        case DOT:
                                        case COLON:
                                        case LBRACE:
                                        case RBRACE:
                                        case QQ_BEGIN:
                                        case QQ_END:
                                        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());
                                        }
                                         }
                                    }
                                }
                                else if ((tokenSet_76_.member(LA(1))) && (tokenSet_77_.member(LA(2)))) {
                                }
                                else
                                {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }

                            }
                            if (0==inputState.guessing)
                            {

                                                e = tle;

                            }
                            break;
                        }
                        case EOF:
                        case DEDENT:
                        case ESEPARATOR:
                        case EOL:
                        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 DO:
                        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 EOS:
                        case LPAREN:
                        case RPAREN:
                        case DOUBLE_QUOTED_STRING:
                        case SINGLE_QUOTED_STRING:
                        case ID:
                        case MULTIPLY:
                        case LBRACK:
                        case SPLICE_BEGIN:
                        case DOT:
                        case COLON:
                        case LBRACE:
                        case RBRACE:
                        case QQ_BEGIN:
                        case QQ_END:
                        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());
                        }
                         }
                    }
                }
                break;
            }
            default:
            {
                throw new NoViableAltException(LT(1), getFilename());
            }
             }
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "array_or_expression");
                recover(ex,tokenSet_76_);
            }
            else
            {
                throw ex;
            }
            }
            return e;
        }
BooParserBase