list_to_term(String) ->

{ok, T, _} = erl_scan:string(String++"."),

case erl_parse:parse_term(T) of

{ok, Term} ->

Term;

        {error, Error} ->

Error

end.

using System;

using IronPython.Hosting; //缺少引用的去下载一个: http://ironpython.codeplex.com/

using Microsoft.Scripting.Hosting;

namespace ConsoleApplication2

{

class Program

{

static void Main(string[] args)

{

ScriptEngine engine = Python.CreateEngine();

var Result = engine.Execute("2*(1+3)");

Console.WriteLine(Result);

Console.ReadLine();

}

}

}

%%%
%%% distel_ie - an interactive erlang shell
%%%
%%% Some of the code has shamelessly been stolen from Luke Gorrie 
%%% [luke@bluetail.com] - ripped from its elegance and replaced by bugs. 
%%% It just goes to show that you can't trust anyone these days. And
%%% as if that wasn't enough, I'll even blame Luke: "He _made_ me do it!"
%%%
%%% So, without any remorse, I hereby declare this code to be:
%%%
%%% copyright (c) 2002 david wallin [david.wallin@ul.ie].
%%%
%%% (it's probably going to be released onto an unexpecting public under
%%%  some sort of BSD license).

-module(distel_ie).

-export([
     evaluate/2,

     test1/0,
     test2/0,
     test3/0,
     test4/0,
     test5/0,

     ensure_registered/0,

     start/0,
     start/1,
     init/1,
     loop/1
    ]).
-compile(export_all).
-define(FMT(X), list_to_binary(lists:flatten(io_lib:format("~p", [X])))).


%%
%% ensure_registered/0
ensure_registered() ->
    case whereis(distel_ie) of
           undefined -> start() ;
           Pid  ->
              group_leader(group_leader(), Pid),
              ok
    end.

%%
%% start/0

start() ->
    start([]).


%%
%% start/1

start(Options) ->
    spawn(?MODULE, init, [Options]).


%%
%% init/1

init(Options) ->
    register(distel_ie, self()),
    Defs = ets:new(definitions, [set]),
    Line = 12,
    Bindings = [],
    State = {Defs, Line, Bindings},
    loop(State).


%%
%% loop/1

loop({Defs, Line, Bindings}) ->
    receive 
    {evaluate, Emacs, String} -> 
        case catch evaluate(String, {Defs, Line, Bindings}) of
        {'EXIT', Rsn} ->
            Emacs ! {ok, list_to_binary(
                   io_lib:format("EXIT: ~p", [Rsn]))},
            ?MODULE:loop({Defs, Line, Bindings});
        {Result, {NL, NB}} ->
            Emacs ! Result,
            ?MODULE:loop({Defs, NL, NB})
        end;
    forget_bindings ->
        put(distel_ie_bindings, []),
        ?MODULE:loop({Defs, Line, []}) ;
    Unknown ->
        io:format("distel_ie: unknown message recvd '~p'\n", [Unknown]),
        ?MODULE:loop({Defs, Line, Bindings})

    end.


%%
%% evaluate/2

evaluate(String, {Defs, Line, Bindings}) ->
    case parse_expr(String) of
    %% ok, so it is an expression :
    {ok, Parse} ->
        RemoteParse = add_remote_call_info(Parse, Defs),
            case catch erl_eval:exprs(RemoteParse, Bindings) of
                {value, V, NewBinds} ->
            {{ok, ?FMT(V)}, {Line, NewBinds}};
                Error ->
            {?FMT(Error), {Line, Bindings}}
        end;
    %% try and treat it as a form / definition instead :
    Other ->
        case parse_form(String) of
        {ok, Parse} -> 
            {ok, Name, Arity} = get_function_name(Parse),
            ets:insert(Defs, {Name, Parse}),
            FunTrees = lists:flatten(
                 lists:reverse(ets:match(Defs,{'_', '$1'}))),
            %% Line isn't really used yet
            NewLine = Line,
            compile_load(FunTrees),
            Def = list_to_binary(atom_to_list(Name) ++ "/" ++ 
                     integer_to_list(Arity)),
            {{ok, Def}, {NewLine, Bindings}} ;
        Error ->
            {{error, ?FMT({Error, Other})}, {Line, Bindings}}
        end
    end.

%%
%% parse_expr/1

parse_expr(String) ->
    case erl_scan:string(String) of
    {ok, Tokens, _} ->
        catch erl_parse:parse_exprs(Tokens) ;
    {error, {_Line, erl_parse, Rsn}} ->
        {error, lists:flatten(Rsn)};
    {error, Error, _} ->
        {error, Error}
    end.

%%
%% parse_form/1

parse_form(String) ->
    case erl_scan:string(String) of
    {ok, Tokens, _} ->
        catch erl_parse:parse_form(Tokens) ;
    {error, {_Line, erl_parse, Rsn}} ->
        {error, lists:flatten(Rsn)};
    {error, Error, _} ->
        {error, Error}
    end.


%%
%% defun/1

defun(String) ->
    {ok, Tokens, _} = erl_scan:string(String),
    {ok, Parse} = erl_parse:parse_form(Tokens),
    compile_load([Parse]).


%%
%% compile_load/1

compile_load(Parse) ->

    Header = [{attribute,9,module,distel_ie_internal},
          {attribute,11,compile,export_all},
          {attribute,12,export,[]}],

    EOF = [{eof,20}],

    SyntaxTree = Header ++ Parse ++ EOF,

    {ok, Mod, Binary} = compile:forms(SyntaxTree),
    File = "heltigenomfelfelsomfansomentyskindianenbefjadradgerman",
    code:load_binary(Mod, File, Binary).


%%
%% add_remote_call_info/2
%%
%% TODO: this is gonna need more work, e.g. it needs to recurse into 
%% lists (cons) and tuples ... +more

add_remote_call_info([], _Defs) -> [] ;
add_remote_call_info({var, L, Var}, Defs) ->
    {var, L, Var} ;
add_remote_call_info({atom, L, Atom}, Defs) ->
    {atom, L, Atom} ;
add_remote_call_info({integer, L, Value}, Defs) ->
    {integer, L, Value} ;
add_remote_call_info({string, L, String}, Defs) ->
    {string, L, String} ;
add_remote_call_info([{call, L, {atom, L2, Name}, Body} | Rs], Defs) ->
    B = add_remote_call_info(Body, Defs),
    IsBuiltin = erlang:is_builtin(erlang, Name, length(B)),
    Call = case IsBuiltin of 
           true ->
           {call, L, {atom, L2, Name}, B} ;
           false ->
           Arity = length(Body),
           case find_module(Name, Arity) of 
               {ok, Mod} ->
                {call, L, {remote, L2, 
                      {atom, L2, Mod}, 
                      {atom, L2, Name}}, B} ;
               {error, _} ->
               {call, L, {atom, L2, Name}, B}
           end
       end,
    [Call | add_remote_call_info(Rs, Defs)] ;

add_remote_call_info([{tuple, L, Values} | Rs], Defs) ->
    F = fun(X) -> add_remote_call_info(X, Defs) end,
    [{tuple, L, lists:map(F, Values)} | add_remote_call_info(Rs, Defs)] ;


add_remote_call_info([{Type, L, Hdr, Body} | Rs], Defs) when list(Body) ->
    B = add_remote_call_info(Body, Defs),
    [{Type, L, Hdr, B} | add_remote_call_info(Rs, Defs)] ;

add_remote_call_info([{Type, L, Hd, Tl} | Rs], Defs) ->
    [{Type, L, Hd, Tl} | add_remote_call_info(Rs, Defs)] ;

add_remote_call_info([R | Rs], Defs) ->
    [add_remote_call_info(R, Defs) | add_remote_call_info(Rs, Defs) ];

add_remote_call_info(X, Defs) ->
    X.


%%
%% find_module/2

find_module(Function, Arity) ->
    Mods = [distel_ie_internal, distel_ie, c],
    F = fun(M) -> not is_exported(Function, Arity, M) end,
    case lists:dropwhile(F, Mods) of
    [] ->
        search_modules(Function, Arity, code:all_loaded()) ;
    [M | _] ->
        {ok, M}
    end.


%%
%% is_exported/3

is_exported(Function, Arity, Module) ->
    case code:is_loaded(Module) of
    false ->
        false;
    _ ->
        Info = Module:module_info(),
        {value, {exports, Exports}} = lists:keysearch(exports, 1, Info),
        lists:member({Function, Arity}, Exports)
    end.


%%
%% search_modules/3

search_modules(Function, Arity, []) ->
    {error, not_found};
search_modules(Function, Arity, [{M, _} | Ms]) ->
    case is_exported(Function, Arity, M) of
    true ->
        {ok, M} ;
    false ->
        search_modules(Function, Arity, Ms)
    end.
    

%%
%% get_function_name/1

get_function_name({function, _, Name, Arity, _}) -> 
    {ok, Name, Arity} ;

get_function_name(Unknown) ->
    {error, Unknown}.


%%% ------------------------------------------------------------------- [tests]
    
%%
%% test1/0

test1() ->
    Defun = "sista(W) -> lists:last(W).",
    defun(Defun).

%%
%% test2/0

test2() ->
    
    Prefix = [
          {attribute,9,module,compile_and_load_me},
          {attribute,11,compile,export_all},
          {attribute,12,export,[]}
         ],
    
    Postfix = [{eof,20}],
    
    String = "sista([]) -> [] ;\n\nsista(W) -> lists:last(W).\n",
%    String = "sista([], _) -> [] ;\n\nsista(W, _) -> lists:last(W).\n",
    
    {ok, Tokens, _} = erl_scan:string(String, 23),
    {ok, Tree} = erl_parse:parse_form(Tokens),
    
    io:format("tree : '~p'\n", [Tree]),
    
    SyntaxTree = Prefix ++ [Tree] ++ Postfix,
    
    io:format("syntaxtree : '~p'\n", [SyntaxTree]),
    
    {ok, Mod, Binary} = compile:forms(SyntaxTree),
    code:load_binary(Mod, "spam", Binary),
    compile_and_load_me:sista([1,2,galapremiere]).


%%
%% test3/0

test3() ->

    Sista = "sista(W) -> lists:last(W).\n",
    defun(Sista),
    distel_ie_internal:sista([1,2,galapremiere]),
    NySista = "en_till_sista(W) -> lists:last(W).\n",
    defun(NySista),
    distel_ie_internal:en_till_sista([1,2,onestepbeyond]).


%%
%% test4/0

test4() ->

    Defs = ets:new(definitions, [set]),

    Define = "nisse([]) -> [] ;\n\nnisse(W) -> lists:last(W).",
    Expr = "nisse([1,2,3]).",
%    Expr = "distel_ie_internal:nisse([1,2,3]).",
%    Expr = "lists:last([1,2,3]).",
    
    D = evaluate(Define, {Defs, 10, []}),
    io:format("nisse defined: '~p'\n", [D]),
    io:format("is_loaded: '~p'\n", [code:is_loaded(distel_ie_internal)]),
    evaluate(Expr, {Defs, 10, []}).


%%
%% test5/0

test5() ->

    Defs = ets:new(definitions, [set]),
    
    Define = "nisse([]) -> [] ;\n\nnisse(W) -> lists:last(W).",
    Expr = "nisse([1,2,3]).",

    evaluate(Define, {Defs, 10, []}),
%    ets:insert(Defs, {nisse, nil}),

    {ok, Tokens, _} = erl_scan:string(Expr, 23),
    {ok, Tree} = erl_parse:parse_exprs(Tokens),

    io:format("original tree : '~p'\n", [Tree]),
    
    RemoteTree = add_remote_call_info(Tree, Defs),
    io:format("remote tree : '~p'\n", [RemoteTree]).