String zum abstrakten Syntaxbaum

Question

Ich möchte einen String, der einen gültigen Erlang-Ausdruck enthält, in seine abstrakte Syntaxbaumdarstellung konvertieren, bisher jedoch ohne Erfolg.

Unten ist ein Beispiel, was ich gerne machen würde. Nach dem Kompilieren generiert alling z:z(). das Modul zed, das durch Aufruf von zed:zed(). das Ergebnis der Anwendung lists:reverse auf die angegebene Liste zurückgibt.

-module(z). 
-export([z/0]). 

z() -> 
    ModuleAST = erl_syntax:attribute(erl_syntax:atom(module), 
            [erl_syntax:atom("zed")]), 

    ExportAST = erl_syntax:attribute(erl_syntax:atom(export), 
            [erl_syntax:list(
            [erl_syntax:arity_qualifier(
            erl_syntax:atom("zed"), 
            erl_syntax:integer(0))])]), 

    %ListAST = ?(String), % This is where I would put my AST 
    ListAST = erl_syntax:list([erl_syntax:integer(1), erl_syntax:integer(2)]), 

    FunctionAST = erl_syntax:function(erl_syntax:atom("zed"), 
            [erl_syntax:clause(
            [], none, 
            [erl_syntax:application(
             erl_syntax:atom(lists), 
             erl_syntax:atom(reverse), 
             [ListAST] 
        )])]), 

    Forms = [erl_syntax:revert(AST) || AST <- [ModuleAST, ExportAST, FunctionAST]], 

    case compile:forms(Forms) of 
    {ok,ModuleName,Binary}   -> code:load_binary(ModuleName, "z", Binary); 
    {ok,ModuleName,Binary,_Warnings} -> code:load_binary(ModuleName, "z", Binary) 
    end. 

String konnte gleich "[1,2,3]." oder "begin A=4, B=2+3, [A,B] end.", oder irgendetwas sein.

(Beachten Sie, dass dies nur ein Beispiel dafür, was Ich mag, so zu tun, würde String Bewertung ist keine Option für mich.)

---

EDIT:

Angeben ListAST wie unten erzeugt ein riesiges Dict-Digraph-Fehler-Monster und sagt "interner Fehler in lint_module".

String = "[1,2,3].", 
{ok, Ts, _} = erl_scan:string(String), 
{ok, ListAST} = erl_parse:parse_exprs(Ts), 

---

EDIT2:

Diese Lösung funktioniert für einfache Worte:

{ok, Ts, _} = erl_scan:string(String), 
{ok, Term} = erl_parse:parse_term(Ts), 
ListAST = erl_syntax:abstract(Term), 

Answer 1

In Ihrem EDIT Beispiel:

String = "[1,2,3].", 
{ok, Ts, _} = erl_scan:string(String), 
{ok, ListAST} = erl_parse:parse_exprs(Ts), 

die ListAST ist eigentlich eine Liste von AST: s (weil parse_exprs, wie der Name schon sagt, mehrere Ausdrücke (jeweils durch einen Punkt beendet parst). Da Ihre Zeichenfolge einen einzelnen Ausdruck enthielt, haben Sie eine Liste mit einem Element erhalten. Alles, was Sie tun müssen, ist, dass passen heraus:

{ok, [ListAST]} = erl_parse:parse_exprs(Ts), 

so hat es nichts mit erl_syntax zu tun (die alle erl_parse Bäume akzeptiert); Es ist nur so, dass Sie einen zusätzlichen Listen-Wrapper um den ListAST herum hatten, der den Compiler zum Kotzen brachte.

Answer 2

Zoltan

Dies ist, wie wir das AST erhalten:

11> String = "fun() -> io:format(\"blah~n\") end.". 
"fun() -> io:format(\"blah~n\") end." 
12> {ok, Tokens, _} = erl_scan:string(String).  
{ok,[{'fun',1}, 
    {'(',1}, 
    {')',1}, 
    {'->',1}, 
    {atom,1,io}, 
    {':',1}, 
    {atom,1,format}, 
    {'(',1}, 
    {string,1,"blah~n"}, 
    {')',1}, 
    {'end',1}, 
    {dot,1}], 
    1} 
13> {ok, AbsForm} = erl_parse:parse_exprs(Tokens). 
{ok,[{'fun',1, 
      {clauses,[{clause,1,[],[], 
           [{call,1, 
            {remote,1,{atom,1,io},{atom,1,format}}, 
            [{string,1,"blah~n"}]}]}]}}]} 
14> 

Answer 3

Einige Kommentare von der Spitze meines Kopfes.

Ich habe die Bibliotheken von erl_syntax nicht wirklich benutzt, aber ich denke, sie machen es schwierig zu lesen und zu sehen, was Sie zu bauen versuchen. Ich würde wahrscheinlich die Funktionen importieren oder meine eigene API definieren, um sie kürzer und lesbarer zu machen. Aber dann tendiere ich im Allgemeinen dazu, kürzere Funktions- und Variablennamen zu bevorzugen.

Der AST erstellt von erl_syntax und der "Standard" erstellt von erl_parse und verwendet im Compiler sind unterschiedlich und kann nicht gemischt werden. Sie müssen also eine von ihnen wählen und dabei bleiben.aber nicht in dem allgemeineren Fall

Das Beispiel in Ihrem zweiten EDIT wird nach Begriffen arbeiten: Diese

{ok, Ts, _} = erl_scan:string(String), 
{ok, Term} = erl_parse:parse_term(Ts), 
ListAST = erl_syntax:abstract(Term), 

weil erl_parse: parse_term/1 kehrt die tatsächliche Laufzeit durch die Token dargestellt, während die andere erl_parse Funktionen parse_form und parse_exprs geben die ASTs zurück. Putting sie in erl_syntax: Zusammenfassung wird lustige Dinge tun.

Je nachdem, was Sie versuchen zu tun, könnte es tatsächlich einfacher zu schreiben und Erlang-Datei tatsächlich und kompilieren, anstatt direkt mit den abstrakten Formen arbeiten. Das widerspricht meinen tief verwurzelten Gefühlen, aber die Erlang-ASTs zu erzeugen, ist nicht trivial. Welche Art von Code möchten Sie produzieren?

<shameless_plug>

Wenn Sie keine Angst vor Listen sind Sie könnten versuchen, LFE mit (Lispeln aromatisierte erlang) Code zu erzeugen, wie mit allen lispelt es keine spezielle abstrakte Form ist, es ist alles homoiconic und viel einfacher zu handhaben.

</shameless_plug>