Boo.Lang.Parser.BooParserBase.interface_method C# (CSharp) Méthode

interface_method() protected méthode

protected interface_method ( TypeMemberCollection container ) : void
container TypeMemberCollection
Résultat void
        protected void interface_method(
		TypeMemberCollection container
	)
        {
            IToken  begin = null;

                Method m = null;
                TypeReference rt = null;
                Expression nameSplice = null;
                IToken id = null;

            try {      // for error handling
            match(DEF);
            {
                switch ( LA(1) )
                {
                case EVENT:
                case GET:
                case INTERNAL:
                case PUBLIC:
                case PROTECTED:
                case REF:
                case SET:
                case YIELD:
                case ID:
                {
                    id=member();
                    break;
                }
                case SPLICE_BEGIN:
                {
                    {
                        begin = LT(1);
                        match(SPLICE_BEGIN);
                        nameSplice=atom();
                    }
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            if (0==inputState.guessing)
            {

                        IToken token = id ?? begin;
                        m = new Method(ToLexicalInfo(token));
                        m.Name = token.getText();
                        AddAttributes(m.Attributes);
                        if (nameSplice != null) {
                            container.Add(new SpliceTypeMember(m, nameSplice));
                        } else {
                            container.Add(m);
                        }

            }
            {
                switch ( LA(1) )
                {
                case LBRACK:
                {
                    {
                        match(LBRACK);
                        {
                            switch ( LA(1) )
                            {
                            case OF:
                            {
                                match(OF);
                                break;
                            }
                            case ID:
                            {
                                break;
                            }
                            default:
                            {
                                throw new NoViableAltException(LT(1), getFilename());
                            }
                             }
                        }
                        generic_parameter_declaration_list(m.GenericParameters);
                        match(RBRACK);
                    }
                    break;
                }
                case OF:
                {
                    {
                        match(OF);
                        generic_parameter_declaration(m.GenericParameters);
                    }
                    break;
                }
                case LPAREN:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            match(LPAREN);
            parameter_declaration_list(m.Parameters);
            match(RPAREN);
            {
                switch ( LA(1) )
                {
                case AS:
                {
                    match(AS);
                    rt=type_reference();
                    if (0==inputState.guessing)
                    {
                        m.ReturnType=rt;
                    }
                    break;
                }
                case EOL:
                case EOS:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case EOL:
                case EOS:
                {
                    {
                        eos();
                        docstring(m);
                    }
                    break;
                }
                case COLON:
                {
                    {
                        empty_block(m);
                        {
                            switch ( LA(1) )
                            {
                            case EOL:
                            case EOS:
                            {
                                eos();
                                break;
                            }
                            case DEDENT:
                            case DEF:
                            case EVENT:
                            case SELF:
                            case ID:
                            case LBRACK:
                            {
                                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, "interface_method");
                recover(ex,tokenSet_56_);
            }
            else
            {
                throw ex;
            }
            }
        }
BooParserBase