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

type_reference() protected method

protected type_reference ( ) : TypeReference
return TypeReference
        protected TypeReference type_reference()
        {
            TypeReference tr;

                tr = null;
                IToken id = null;
                TypeReferenceCollection arguments = null;
                GenericTypeDefinitionReference gtdr = null;

            try {      // for error handling
            {
                switch ( LA(1) )
                {
                case SPLICE_BEGIN:
                {
                    tr=splice_type_reference();
                    break;
                }
                case LPAREN:
                {
                    tr=array_type_reference();
                    break;
                }
                default:
                    bool synPredMatched249 = false;
                    if (((LA(1)==CALLABLE) && (LA(2)==LPAREN)))
                    {
                        int _m249 = mark();
                        synPredMatched249 = true;
                        inputState.guessing++;
                        try {
                            {
                                match(CALLABLE);
                                match(LPAREN);
                            }
                        }
                        catch (RecognitionException)
                        {
                            synPredMatched249 = false;
                        }
                        rewind(_m249);
                        inputState.guessing--;
                    }
                    if ( synPredMatched249 )
                    {
                        {
                            tr=callable_type_reference();
                        }
                    }
                    else if ((tokenSet_40_.member(LA(1))) && (tokenSet_41_.member(LA(2)))) {
                        {
                            id=type_name();
                            {
                                if ((LA(1)==LBRACK) && (tokenSet_42_.member(LA(2))))
                                {
                                    {
                                        match(LBRACK);
                                        {
                                            switch ( LA(1) )
                                            {
                                            case OF:
                                            {
                                                match(OF);
                                                break;
                                            }
                                            case CALLABLE:
                                            case CHAR:
                                            case THEN:
                                            case LPAREN:
                                            case ID:
                                            case MULTIPLY:
                                            case SPLICE_BEGIN:
                                            {
                                                break;
                                            }
                                            default:
                                            {
                                                throw new NoViableAltException(LT(1), getFilename());
                                            }
                                             }
                                        }
                                        {
                                            switch ( LA(1) )
                                            {
                                            case MULTIPLY:
                                            {
                                                {
                                                    match(MULTIPLY);
                                                    if (0==inputState.guessing)
                                                    {

                                                                                    gtdr = new GenericTypeDefinitionReference(ToLexicalInfo(id));
                                                                                    gtdr.Name = id.getText();
                                                                                    gtdr.GenericPlaceholders = 1;
                                                                                    tr = gtdr;

                                                    }
                                                    {    // ( ... )*
                                                        for (;;)
                                                        {
                                                            if ((LA(1)==COMMA))
                                                            {
                                                                match(COMMA);
                                                                match(MULTIPLY);
                                                                if (0==inputState.guessing)
                                                                {

                                                                                                    gtdr.GenericPlaceholders++;

                                                                }
                                                            }
                                                            else
                                                            {
                                                                goto _loop258_breakloop;
                                                            }

                                                        }
            _loop258_breakloop:														;
                                                    }    // ( ... )*
                                                    match(RBRACK);
                                                }
                                                break;
                                            }
                                            case CALLABLE:
                                            case CHAR:
                                            case THEN:
                                            case LPAREN:
                                            case ID:
                                            case SPLICE_BEGIN:
                                            {
                                                {
                                                    if (0==inputState.guessing)
                                                    {

                                                                                    GenericTypeReference gtr = new GenericTypeReference(ToLexicalInfo(id), id.getText());
                                                                                    arguments = gtr.GenericArguments;
                                                                                    tr = gtr;

                                                    }
                                                    type_reference_list(arguments);
                                                    match(RBRACK);
                                                }
                                                break;
                                            }
                                            default:
                                            {
                                                throw new NoViableAltException(LT(1), getFilename());
                                            }
                                             }
                                        }
                                    }
                                }
                                else if ((LA(1)==OF) && (LA(2)==MULTIPLY)) {
                                    {
                                        match(OF);
                                        match(MULTIPLY);
                                        if (0==inputState.guessing)
                                        {

                                                                gtdr = new GenericTypeDefinitionReference(ToLexicalInfo(id));
                                                                gtdr.Name = id.getText();
                                                                gtdr.GenericPlaceholders = 1;
                                                                tr = gtdr;

                                        }
                                    }
                                }
                                else if ((LA(1)==OF) && (tokenSet_43_.member(LA(2)))) {
                                    {
                                        match(OF);
                                        tr=type_reference();
                                        if (0==inputState.guessing)
                                        {

                                                                GenericTypeReference gtr = new GenericTypeReference(ToLexicalInfo(id), id.getText());
                                                                gtr.GenericArguments.Add(tr);
                                                                tr = gtr;

                                        }
                                    }
                                }
                                else if ((tokenSet_41_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) {
                                    if (0==inputState.guessing)
                                    {

                                                        SimpleTypeReference str = new SimpleTypeReference(ToLexicalInfo(id));
                                                        str.Name = id.getText();
                                                        tr = str;

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

                            }
                            {
                                if ((LA(1)==NULLABLE_SUFFIX) && (tokenSet_41_.member(LA(2))))
                                {
                                    match(NULLABLE_SUFFIX);
                                    if (0==inputState.guessing)
                                    {

                                                        GenericTypeReference ntr = new GenericTypeReference(tr.LexicalInfo, "System.Nullable");
                                                        ntr.GenericArguments.Add(tr);
                                                        tr = ntr;

                                    }
                                }
                                else if ((tokenSet_41_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) {
                                }
                                else
                                {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }

                            }
                        }
                    }
                else
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                break; }
            }
            {    // ( ... )*
                for (;;)
                {
                    if ((LA(1)==MULTIPLY) && (tokenSet_41_.member(LA(2))))
                    {
                        match(MULTIPLY);
                        if (0==inputState.guessing)
                        {
                            tr = CodeFactory.EnumerableTypeReferenceFor(tr);
                        }
                    }
                    else if ((LA(1)==EXPONENTIATION) && (tokenSet_41_.member(LA(2)))) {
                        match(EXPONENTIATION);
                        if (0==inputState.guessing)
                        {
                            tr = CodeFactory.EnumerableTypeReferenceFor(CodeFactory.EnumerableTypeReferenceFor(tr));
                        }
                    }
                    else
                    {
                        goto _loop264_breakloop;
                    }

                }
            _loop264_breakloop:				;
            }    // ( ... )*
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "type_reference");
                recover(ex,tokenSet_41_);
            }
            else
            {
                throw ex;
            }
            }
            return tr;
        }
BooParserBase