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

slice() protected method

protected slice ( SlicingExpression se ) : void
se SlicingExpression
return void
        protected void slice(
		SlicingExpression se
	)
        {
            Expression begin = null;
                Expression end = null;
                Expression step = null;

            try {      // for error handling
            {
                switch ( LA(1) )
                {
                case COLON:
                {
                    {
                        match(COLON);
                        if (0==inputState.guessing)
                        {
                            begin = OmittedExpression.Default;
                        }
                        {
                            switch ( LA(1) )
                            {
                            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:
                            {
                                end=expression();
                                break;
                            }
                            case COLON:
                            {
                                {
                                    match(COLON);
                                    if (0==inputState.guessing)
                                    {
                                        end = OmittedExpression.Default;
                                    }
                                    step=expression();
                                }
                                break;
                            }
                            case RBRACK:
                            case COMMA:
                            {
                                break;
                            }
                            default:
                            {
                                throw new NoViableAltException(LT(1), getFilename());
                            }
                             }
                        }
                    }
                    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:
                {
                    begin=expression();
                    {
                        switch ( LA(1) )
                        {
                        case COLON:
                        {
                            match(COLON);
                            {
                                switch ( LA(1) )
                                {
                                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:
                                {
                                    end=expression();
                                    break;
                                }
                                case RBRACK:
                                case COMMA:
                                case COLON:
                                {
                                    if (0==inputState.guessing)
                                    {
                                        end = OmittedExpression.Default;
                                    }
                                    break;
                                }
                                default:
                                {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }
                                 }
                            }
                            {
                                switch ( LA(1) )
                                {
                                case COLON:
                                {
                                    match(COLON);
                                    step=expression();
                                    break;
                                }
                                case RBRACK:
                                case COMMA:
                                {
                                    break;
                                }
                                default:
                                {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }
                                 }
                            }
                            break;
                        }
                        case RBRACK:
                        case COMMA:
                        {
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            if (0==inputState.guessing)
            {

                        se.Indices.Add(new Slice(begin, end, step));

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