通过核心Erlang将Erlang编译为Javascript

所以我开始在LuvvieScript上取得进展，然后在Twitter上开始了这一切。。。

Anthony Ramine指出我做得不对，我应该通过核心Erlang而不是Erlang AST从Erlang编译到JavaScript。对我来说，这既是一个引人注目的选择，也是一个没有吸引力的选择。。。推特不是讨论的合适媒介，我想我会把它写在这里，并得到一些建议

战略概述 LuvvieScript有三个核心需求：

• Erlang的有效子集，可编译为相同且性能良好的Javascript
• 完整的源代码映射，以便可以在浏览器中以LuvViesScript而不是Javascript进行调试
• 一个“运行时”客户端javascript环境（带有服务器端命令），用于在（一种页内管理器…）中执行LuvvieScript模块

第三种选择超出了本次辩论的范围，但前两种是核心选择

有一个懒惰的gits推论——我希望使用尽可能多的Erlang和Javascript语法工具（lexer、解析器、标记器、AST转换等），并编写最少的代码

当前思维 代码当前的编写方式如下所示：

• 将代码编译为Erlang AST（具有行号）
• 标记代码（保留注释和空白），并使用这些标记构建一个字典，将行/列信息映射到标记
• 将字典和AST合并，得到一行/列AST（一些Fanning将对不同算术的FN进行分组）
• 将这个新的Erlang AST转换为在SpiderMonkey解析器中实现的Javascript AST 原料药
• 在Javascript AST中使用诸如brushtail之类的Javascript UTIL来变异尾部调用
• 使用像ESCodeGen这样的Javascript UTIL来发出Javascript

基本上，我得到的Erlang AST类似于：

 [{function,
      {19,{1,9}},
      atom1_fn,0,
      [{clause,
           {19,none},
           [],
           [[]],
           [{match,
                {20,none},
                [{var,{20,{5,6}},'D'}],
                [{atom,{20,{11,15}},blue}]},
            {var,{21,{5,6}},'D'}]}]}]},

然后我将其转换为Javascript JSON AST，如下所示：

{
    "type": "Program",
    "body": [
        {
            "type": "VariableDeclaration",
            "declarations": [
                {
                    "type": "VariableDeclarator",
                    "id": {
                        "type": "Identifier",
                        "name": "answer",
                        "loc": {
                            "start": {
                                "line": 2,
                                "column": 4
                            },
                            "end": {
                                "line": 2,
                                "column": 10
                            }
                        }
                    },
                    "init": {
                        "type": "BinaryExpression",
                        "operator": "*",
                        "left": {
                            "type": "Literal",
                            "value": 6,
                            "raw": "6",
                            "loc": {
                                "start": {
                                    "line": 2,
                                    "column": 13
                                },
                                "end": {
                                    "line": 2,
                                    "column": 14
                                }
                            }
                        },
                        "right": {
                            "type": "Literal",
                            "value": 7,
                            "raw": "7",
                            "loc": {
                                "start": {
                                    "line": 2,
                                    "column": 17
                                },
                                "end": {
                                    "line": 2,
                                    "column": 18
                                }
                            }
                        },
                        "loc": {
                            "start": {
                                "line": 2,
                                "column": 13
                            },
                            "end": {
                                "line": 2,
                                "column": 18
                            }
                        }
                    },
                    "loc": {
                        "start": {
                            "line": 2,
                            "column": 4
                        },
                        "end": {
                            "line": 2,
                            "column": 18
                        }
                    }
                }
            ],
            "kind": "var",
            "loc": {
                "start": {
                    "line": 2,
                    "column": 0
                },
                "end": {
                    "line": 2,
                    "column": 19
                }
            }
        }
    ],
    "loc": {
        "start": {
            "line": 2,
            "column": 0
          },
        "end": {
            "line": 2,
            "column": 19
           }
    }
}

厄尔尼诺问题 Anthony的观点是明确的-Core Erlang是一种比Erlang更简单、更规则的语言，应该比普通Erlang更容易转换为Javascript，但它的文档记录不是很好

我可以很容易地获得核心Erlang的类似AST的表示：

{c_module,[],
    {c_literal,[],basic_types},
    [{c_var,[],{atom1_fn,0}},
     {c_var,[],{atom2_fn,0}},
     {c_var,[],{bish_fn,1}},
     {c_var,[],{boolean_fn,0}},
     {c_var,[],{float_fn,0}},
     {c_var,[],{int_fn,0}},
     {c_var,[],{module_info,0}},
     {c_var,[],{module_info,1}},
     {c_var,[],{string_fn,0}}],
    [],
    [{{c_var,[],{int_fn,0}},{c_fun,[],[],{c_literal,[],1}}},
     {{c_var,[],{float_fn,0}},{c_fun,[],[],{c_literal,[],2.3}}},
     {{c_var,[],{boolean_fn,0}},{c_fun,[],[],{c_literal,[],true}}},
     {{c_var,[],{atom1_fn,0}},{c_fun,[],[],{c_literal,[],blue}}},
     {{c_var,[],{atom2_fn,0}},{c_fun,[],[],{c_literal,[],'Blue 4 U'}}},
     {{c_var,[],{string_fn,0}},{c_fun,[],[],{c_literal,[],"string theory"}}},
     {{c_var,[],{bish_fn,1}},
      {c_fun,[],
          [{c_var,[],'_cor0'}],
          {c_case,[],
              {c_var,[],'_cor0'},
              [{c_clause,[],
                   [{c_literal,[],bash}],
                   {c_literal,[],true},
                   {c_literal,[],berk}},
               {c_clause,[],
                   [{c_literal,[],bosh}],
                   {c_literal,[],true},
                   {c_literal,[],bork}},
               {c_clause,
                   [compiler_generated],
                       [{c_var,[],'_cor1'}],
                   {c_literal,[],true},
                   {c_primop,[],
                       {c_literal,[],match_fail},
                       [{c_tuple,[],
                            [{c_literal,[],case_clause},
                             {c_var,[],'_cor1'}]}]}}]}}},
     {{c_var,[],{module_info,0}},
      {c_fun,[],[],
          {c_call,[],
              {c_literal,[],erlang},
              {c_literal,[],get_module_info},
              [{c_literal,[],basic_types}]}}},
     {{c_var,[],{module_info,1}},
      {c_fun,[],
          [{c_var,[],'_cor0'}],
          {c_call,[],
              {c_literal,[],erlang},
              {c_literal,[],get_module_info},
              [{c_literal,[],basic_types},{c_var,[],'_cor0'}]}}}]}

但是没有行col/nos，所以我可以得到一个生成JS的AST，但关键是不能生成SourceMaps

问题1如何获取所需的行信息-（我已经可以从“普通”Erlang令牌获取列信息…）

Erlang Core在生产过程中与普通Erlang略有不同，因为它开始用函数调用中的变量名替换自己的内部变量名，这也会导致一些源映射问题。例如，Erlang子句：

bish_fn(A) ->
    case A of
        bash -> berk;
        bosh -> bork
    end.

Erlang AST很好地保留了这些名称：

 [{function,
      {31,{1,8}},
      bish_fn,1,
      [{clause,
           {31,none},
           [{var,{31,{11,12}},'A'}],
           [[]],
           [{'case',
                {32,none},
                [{var,{32,{11,12}},'A'}],
                [{clause,
                     {33,none},
                     [{atom,{33,{9,13}},bash}],
                     [[]],
                     [{atom,{34,{13,17}},berk}]},
                 {clause,
                     {35,none},
                     [{atom,{35,{9,13}},bosh}],
                     [[]],
                     [{atom,{36,{13,17}},bork}]}]}]}]}]},

Core Erlang已经改变了函数中调用的参数的名称：

'bish_fn'/1 =
    %% Line 30
    fun (_cor0) ->
    %% Line 31
    case _cor0 of
      %% Line 32
      <'bash'> when 'true' ->
          'berk'
      %% Line 33
      <'bosh'> when 'true' ->
          'bork'
      ( <_cor1> when 'true' ->
        primop 'match_fail'
            ({'case_clause',_cor1})
        -| ['compiler_generated'] )
    end

然后我在这个从

编译器.erl

获取的函数中使用

core\u scan

和

core\u parse

：

compile(File) ->
    case file:read_file(File) of
        {ok,Bin} ->
            case core_scan:string(binary_to_list(Bin)) of
                {ok,Toks,_} ->
                    case core_parse:parse(Toks) of
                        {ok, Mod} ->
                            {ok, Mod};
                        {error,E} ->
                            {error, {parse, E}}
                    end;
                {error,E,_} ->
                    {error, {scan, E}}
            end;
        {error,E} ->
            {error,{read, E}}
    end.

问题是我如何/我可以让工具链发出带注释的AST。我想我需要自己添加这些选项：（

行号是作为注释提供的。如果你看一下cerl模块，我真的建议你使用它，你会发现所有的东西几乎都包含一个注释列表。其中一个注释是一个表示行号的未加修饰的数字。如果我没有记错的话，Core AST和atom1_fn var都在第10行ST将如下所示：

{c_var，[10]，{atom1_fn，0}

不，你必须自己做所有的簿记工作。没有什么可以帮你做的

我不确定我是否理解这个问题

Anthony所说的关于Core Erlang的一切都是正确的。这正是我选择Core Erlang作为Joxa目标语言的原因。我从中得到的教训是，尽管Core Erlang是一种非常容易实现的目标语言，但它有两个主要缺点，这两个缺点不利于它

透析器仅在beam文件的抽象代码块中使用Erlang AST。编译到Core Erlang时，无法将此类AST放入该抽象代码块。因此，如果您以Core Erlang为目标，透析器将无法为您工作。无论您是否生成正确的规范属性，这都是正确的

您失去了对在Erlang AST上工作的工具的使用。例如，编译到Erlang源代码的能力。核心Erlang到/从源代码编译器有很多错误，根本无法工作。这是在许多实用领域的一个重大胜利

出于上述原因，我实际上正在将Joxa重新定位到Erlang AST

顺便说一句，你可能对这个项目感兴趣。它是一个用于Erlang AST的JavaScript编译器，已经存在并且正在工作。尽管我对它没有太多经验

---

**编辑：您实际上可以看到从erlang源代码生成的core erlang AST。这对学习如何编译到core有很大帮助。

erlware\u commons中的
ec\u compile
repo有很多实用函数可以帮助您实现这一点。
如何获得核心erlang？我一直在使用

dialyzer_utils:get_core_from_src(File)

在这里，我得到了一个很好的结构，带有c_let c_variable等和很好的行号。但是，我注意到它与我在执行c（“，[to_Core]）时得到的核心Erlang不同。例如，我得到了每个记录访问的c_案例，这在由c（“，[to_Core]）生成的.Core文件中得到了优化

将核心Erlang作为内部结构由Erlang处理的推荐方法是什么

我先尝试了其他方法，但没有设置行号。
Eric，问题是我是用Erlang编译的-我没有使用cerl.erl，因为我没有在编译器中构建核心Erlang AST-这是一个
dialyzer_utils:get_core_from_src(File)