Mono.CSharp.Evaluator.ToplevelOrStatement C# (CSharp) Method

        InputKind ToplevelOrStatement(SeekableStreamReader seekable)
        {
            Tokenizer tokenizer = new Tokenizer (seekable, (CompilationUnit) Location.SourceFiles [0], ctx);

            int t = tokenizer.token ();
            switch (t){
            case Token.EOF:
                return InputKind.EOF;

            // These are toplevels
            case Token.EXTERN:
            case Token.OPEN_BRACKET:
            case Token.ABSTRACT:
            case Token.CLASS:
            case Token.ENUM:
            case Token.INTERFACE:
            case Token.INTERNAL:
            case Token.NAMESPACE:
            case Token.PRIVATE:
            case Token.PROTECTED:
            case Token.PUBLIC:
            case Token.SEALED:
            case Token.STATIC:
            case Token.STRUCT:
                return InputKind.CompilationUnit;

            // Definitely expression
            case Token.FIXED:
            case Token.BOOL:
            case Token.BYTE:
            case Token.CHAR:
            case Token.DECIMAL:
            case Token.DOUBLE:
            case Token.FLOAT:
            case Token.INT:
            case Token.LONG:
            case Token.NEW:
            case Token.OBJECT:
            case Token.SBYTE:
            case Token.SHORT:
            case Token.STRING:
            case Token.UINT:
            case Token.ULONG:
                return InputKind.StatementOrExpression;

            // These need deambiguation help
            case Token.USING:
                t = tokenizer.token ();
                if (t == Token.EOF)
                    return InputKind.EOF;

                if (t == Token.IDENTIFIER)
                    return InputKind.CompilationUnit;
                return InputKind.StatementOrExpression;

            // Distinguish between:
            //    delegate opt_anonymous_method_signature block
            //    delegate type
            case Token.DELEGATE:
                t = tokenizer.token ();
                if (t == Token.EOF)
                    return InputKind.EOF;
                if (t == Token.OPEN_PARENS || t == Token.OPEN_BRACE)
                    return InputKind.StatementOrExpression;
                return InputKind.CompilationUnit;

            // Distinguih between:
            //    unsafe block
            //    unsafe as modifier of a type declaration
            case Token.UNSAFE:
                t = tokenizer.token ();
                if (t == Token.EOF)
                    return InputKind.EOF;
                if (t == Token.OPEN_PARENS)
                    return InputKind.StatementOrExpression;
                return InputKind.CompilationUnit;

                // These are errors: we list explicitly what we had
            // from the grammar, ERROR and then everything else

            case Token.READONLY:
            case Token.OVERRIDE:
            case Token.ERROR:
                return InputKind.Error;

            // This catches everything else allowed by
            // expressions.  We could add one-by-one use cases
            // if needed.
            default:
                return InputKind.StatementOrExpression;
            }
        }