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

import_directive_() protected method

protected import_directive_ ( ) : Import
return Import
        protected Import import_directive_()
        {
            Import returnValue;

            IToken  imp = null;
            IToken  dqs = null;
            IToken  sqs = null;
            IToken  alias = null;

            Expression ns = null;
            IToken id = null;
            returnValue = null;

            try {      // for error handling
            imp = LT(1);
            match(IMPORT);
            ns=namespace_expression();
            if (0==inputState.guessing)
            {
                if (ns != null) returnValue = new Import(ToLexicalInfo(imp), ns);
            }
            {
                switch ( LA(1) )
                {
                case FROM:
                {
                    match(FROM);
                    {
                        switch ( LA(1) )
                        {
                        case THEN:
                        case ID:
                        {
                            id=identifier();
                            break;
                        }
                        case DOUBLE_QUOTED_STRING:
                        {
                            dqs = LT(1);
                            match(DOUBLE_QUOTED_STRING);
                            if (0==inputState.guessing)
                            {
                                id=dqs;
                            }
                            break;
                        }
                        case SINGLE_QUOTED_STRING:
                        {
                            sqs = LT(1);
                            match(SINGLE_QUOTED_STRING);
                            if (0==inputState.guessing)
                            {
                                id=sqs;
                            }
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                    if (0==inputState.guessing)
                    {

                                    returnValue.AssemblyReference = new ReferenceExpression(ToLexicalInfo(id), id.getText());

                    }
                    break;
                }
                case EOL:
                case AS:
                case EOS:
                case QQ_END:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case AS:
                {
                    match(AS);
                    alias = LT(1);
                    match(ID);
                    if (0==inputState.guessing)
                    {

                                    returnValue.Alias = new ReferenceExpression(ToLexicalInfo(alias));
                                    returnValue.Alias.Name = alias.getText();

                    }
                    break;
                }
                case EOL:
                case EOS:
                case QQ_END:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "import_directive_");
                recover(ex,tokenSet_23_);
            }
            else
            {
                throw ex;
            }
            }
            return returnValue;
        }
BooParserBase