stringa ad albero di sintassi astratto

Question

Vorrei convertire una stringa contenente un'espressione di Erlang valida nella sua rappresentazione astratta della struttura della sintassi, senza alcun risultato fino ad ora.

Di seguito è riportato un esempio di ciò che vorrei fare. Dopo la compilazione, alling z:z(). genera il modulo zed, che chiamando zed:zed(). restituisce il risultato dell'applicazione di lists:reverse nell'elenco fornito.

-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 potrebbe essere "[1,2,3].", o "begin A=4, B=2+3, [A,B] end.", o qualcosa di simile.

(Si noti che questo è solo un esempio di quello che vorrei fare, in modo da valutare String non è un'opzione per me.)

---

EDIT:

Specifica ListAST come di seguito genera un enorme monster-error-errore dict-digraph e dice "error interno in lint_module".

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

---

EDIT2:

Questa soluzione funziona per termini semplici:

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

Answer 1

Nel tuo esempio EDIT:

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

il ListAST è in realtà un elenco di AST: s (perché parse_exprs, come indica il nome, analizza molteplici espressioni (ogni terminati da un punto). Dato che la tua stringa conteneva una singola espressione, hai ottenuto un elenco di un elemento. Tutto quello che devi fare è che corrisponda a quello fuori:

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

quindi non ha nulla a che fare con erl_syntax (che accetta tutti gli alberi erl_parse); è solo che hai avuto un extra list wrapper attorno a ListAST, che ha causato il vomito del compilatore.

Answer 2

Zoltan

In questo modo si ottiene l'AST:

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

Alcuni commenti in cima alla mia testa.

Non ho davvero utilizzato le librerie erl_syntax ma penso che rendono difficile leggere e "vedere" ciò che si sta tentando di creare. Probabilmente importerei le funzioni o definirò la mia API per renderla più breve e più leggibile. Ma in genere io preferisco tendenzialmente funzioni più brevi e nomi variabili.

L'AST creato da erl_syntax e quello "standard" creato da erl_parse e utilizzato nel compilatore sono diversi e non può essere impostato su. Quindi devi scegliere uno di loro e seguirlo.

L'esempio nel vostro secondo EDIT funzionerà per i termini, ma non nel caso più generale:

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

Questo perché erl_parse: ritorna parse_term/1 il termine effettivo rappresentato dai gettoni, mentre l'altro funzioni erl_parse parse_form e parse_exprs restituiscono gli AST. Inserendoli in erl_syntax: l'abstract farà cose divertenti.

A seconda di ciò che si sta tentando di fare, potrebbe essere effettivamente più semplice scrivere ed estrarre il file e compilarlo piuttosto che lavorare direttamente con i moduli astratti. Questo va contro i miei sentimenti radicati, ma generare gli AST di erlang non è banale. Che tipo di codice intendi produrre?

<shameless_plug>

Se non hai paura di liste si potrebbe provare a utilizzare LFE (lisp aromatizzato Erlang) per generare il codice come con tutte le lische non v'è alcuna forma astratta speciale, è tutto homoiconic e molto più facile da lavorare.

</shameless_plug>