10

我想将包含有效 Erlang 表达式的字符串转换为其抽象语法树表示，但到目前为止没有任何成功。

下面是我想做的一个例子。编译后，allingz:z().生成模块zed，通过调用zed:zed().返回在lists:reverse给定列表上应用的结果。

-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可以是"[1,2,3].", 或"begin A=4, B=2+3, [A,B] end.", 或任何类似的东西。

（请注意，这只是我想做的一个例子，所以评估String不是我的选择。）

编辑：

如下指定 ListAST 会生成一个巨大的 dict-digraph-error-monster，并显示“lint_module 中的内部错误”。

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

编辑2：

此解决方案适用于简单的术语：

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

3 回答 3

5

在您的编辑示例中：

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

ListAST 实际上是一个 AST:s 列表（因为 parse_exprs，顾名思义，解析多个表达式（每个表达式都以句点结尾）。由于您的字符串包含一个表达式，因此您得到了一个包含一个元素的列表。您只需要要做的是匹配：

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

所以它与 erl_syntax （它接受所有 erl_parse 树）无关；只是您在 ListAST 周围有一个额外的列表包装器，这导致编译器呕吐。

于 2009-12-30T15:07:41.357 回答
3

我头顶的一些评论。

我并没有真正使用过 erl_syntax 库，但我确实认为它们使阅读和“看到”您正在尝试构建的内容变得困难。我可能会导入这些函数或定义我自己的 API 以使其更短、更易读。但是我通常倾向于更短的函数和变量名称。

由 erl_syntax 创建的 AST 和由 erl_parse 创建并在编译器中使用的“标准”是不同的，不能混用。所以你必须选择其中之一并坚持下去。

第二次编辑中的示例适用于术语，但不适用于更一般的情况：

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

这是因为 erl_parse:parse_term/1 返回由标记表示的实际术语，而其他 erl_parse 函数 parse_form 和 parse_exprs 返回 AST。将它们放入 erl_syntax:abstract 会做一些有趣的事情。

根据您要执行的操作，实际写出 erlang 文件并编译它实际上可能比直接使用抽象形式更容易。这违背了我根深蒂固的感觉，但生成 erlang AST 并非易事。您打算生成什么类型​​的代码？

<shameless_plug>

如果你不害怕列表，你可以尝试使用 LFE（lisp 风格的 erlang）来生成代码，因为所有的 lisp 都没有特殊的抽象形式，它们都是同音的并且更容易使用。

</shameless_plug>

于 2009-12-31T01:40:12.927 回答
2

佐尔坦

这就是我们获得 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>
于 2009-12-29T11:54:57.743 回答