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

interface_definition() protected method

protected interface_definition ( TypeMemberCollection container ) : void
container TypeMemberCollection
return void
        protected void interface_definition(
		TypeMemberCollection container
	)
        {
            IToken  id = null;
            IToken  begin = null;

                InterfaceDefinition itf = null;
                TypeMemberCollection members = null;
                GenericParameterDeclarationCollection genericParameters = null;
                Expression nameSplice = null;

            try {      // for error handling
            match(INTERFACE);
            {
                switch ( LA(1) )
                {
                case ID:
                {
                    id = LT(1);
                    match(ID);
                    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;
                        itf = new InterfaceDefinition(ToLexicalInfo(token));
                        itf.Name = token.getText();
                        itf.Modifiers = _modifiers;
                        AddAttributes(itf.Attributes);
                        if (id != null) {
                            container.Add(itf);
                        } else {
                            container.Add(new SpliceTypeMember(itf, nameSplice));
                        }
                        members = itf.Members;
                        genericParameters = itf.GenericParameters;

            }
            {
                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(genericParameters);
                    match(RBRACK);
                    break;
                }
                case LPAREN:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case LPAREN:
                {
                    base_types(itf.BaseTypes);
                    break;
                }
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            begin_with_doc(itf);
            {
                switch ( LA(1) )
                {
                case PASS:
                {
                    {
                        match(PASS);
                        eos();
                    }
                    break;
                }
                case DEF:
                case EVENT:
                case SELF:
                case ID:
                case LBRACK:
                {
                    { // ( ... )+
                        int _cnt90=0;
                        for (;;)
                        {
                            if ((tokenSet_37_.member(LA(1))))
                            {
                                attributes();
                                {
                                    switch ( LA(1) )
                                    {
                                    case DEF:
                                    {
                                        interface_method(members);
                                        break;
                                    }
                                    case EVENT:
                                    {
                                        event_declaration(members);
                                        break;
                                    }
                                    case SELF:
                                    case ID:
                                    {
                                        interface_property(members);
                                        break;
                                    }
                                    default:
                                    {
                                        throw new NoViableAltException(LT(1), getFilename());
                                    }
                                     }
                                }
                            }
                            else
                            {
                                if (_cnt90 >= 1) { goto _loop90_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
                            }

                            _cnt90++;
                        }
            _loop90_breakloop:						;
                    }    // ( ... )+
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            end(itf);
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "interface_definition");
                recover(ex,tokenSet_22_);
            }
            else
            {
                throw ex;
            }
            }
        }
BooParserBase