Merge branch 'richcarl/syntax_tools/add-merl'

* richcarl/syntax_tools/add-merl:
  Make merl compatible with OTP 18.0
  Add tests for merl in syntax_tools
  Include Merl in Syntax Tools

1 files changed, 104 insertions, 0 deletions

diff --git a/lib/syntax_tools/examples/merl/merl_build.erl b/lib/syntax_tools/examples/merl/merl_build.erl
new file mode 100644
index 0000000000..c539f8e2af
--- /dev/null
+++ b/lib/syntax_tools/examples/merl/merl_build.erl
@@ -0,0 +1,104 @@
+%% ---------------------------------------------------------------------
+%% Licensed under the Apache License, Version 2.0 (the "License"); you may
+%% not use this file except in compliance with the License. You may obtain
+%% a copy of the License at <http://www.apache.org/licenses/LICENSE-2.0>
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% @author Richard Carlsson <[email protected]>
+%% @copyright 2012 Richard Carlsson
+%% @doc Making it simple to build a module with merl
+
+-module(merl_build).
+
+-export([init_module/1, module_forms/1, add_function/4, add_record/3,
+         add_import/3, add_attribute/3, set_file/2]).
+
+-import(merl, [term/1]).
+
+-include("merl.hrl").
+
+-type filename() :: string().
+
+-record(module, { name          :: atom()
+                , file          :: filename()
+                , exports=[]    :: [{atom(), integer()}]
+                , imports=[]    :: [{atom(), [{atom(), integer()}]}]
+                , attributes=[] :: [{filename(), atom(), [term()]}]
+                , records=[]    :: [{filename(), atom(),
+                                     [{atom(), merl:tree()}]}]
+                , functions=[]  :: [{filename(), atom(), [merl:tree()]}]
+                }).
+
+%% TODO: init module from a list of forms (from various sources)
+
+%% @doc Create a new module representation, using the given module name.
+init_module(Name) when is_atom(Name) ->
+    %% use the module name as the default file name - better than nothing
+    #module{name=Name, file=atom_to_list(Name)}.
+
+%% @doc Get the list of syntax tree forms for a module representation. This can
+%% be passed to compile/2.
+module_forms(#module{name=Name,
+                     exports=Xs,
+                     imports=Is,
+                     records=Rs,
+                     attributes=As,
+                     functions=Fs})
+  when is_atom(Name), Name =/= undefined ->
+    Module = ?Q("-module('@Name@')."),
+    Exported = [erl_syntax:arity_qualifier(term(N), term(A))
+                || {N,A} <- ordsets:from_list(Xs)],
+    Export = ?Q("-export(['@_Exported'/1])."),
+    Imports = [?Q("-import('@M@', ['@_NAs'/1]).")
+               || {M, Ns} <- Is,
+                  NAs <- [[erl_syntax:arity_qualifier(term(N), term(A))
+                           || {N,A} <- ordsets:from_list(Ns)]]
+              ],
+    Attrs = [?Q("-file(\"'@File@\",1). -'@N@'('@T@').")
+             || {File, N, T} <- lists:reverse(As)],
+    Records = [?Q("-file(\"'@File@\",1). -record('@N@',{'@_RFs'=[]}).")
+               || {File, N, Es} <- lists:reverse(Rs),
+                  RFs <- [[erl_syntax:record_field(term(F), V)
+                           || {F,V} <- Es]]
+              ],
+    Functions = [?Q("-file(\"'@File@\",1). '@_F'() -> [].")
+                 || {File, N, Cs} <- lists:reverse(Fs),
+                    F <- [erl_syntax:function(term(N), Cs)]],
+    lists:flatten([Module, Export, Imports, Attrs, Records, Functions]).
+
+%% @doc Set the source file name for all subsequently added functions,
+%% records, and attributes.
+set_file(Filename, #module{}=M) ->
+    M#module{file=filename:flatten(Filename)}.
+
+%% @doc Add a function to a module representation.
+add_function(Exported, Name, Clauses,
+             #module{file=File, exports=Xs, functions=Fs}=M)
+  when is_boolean(Exported), is_atom(Name), Clauses =/= [] ->
+    Arity = length(erl_syntax:clause_patterns(hd(Clauses))),
+    Xs1 = case Exported of
+              true -> [{Name,Arity} | Xs];
+              false -> Xs
+          end,
+    M#module{exports=Xs1, functions=[{File, Name, Clauses} | Fs]}.
+
+%% @doc Add a record declaration to a module representation.
+add_record(Name, Fields, #module{file=File, records=Rs}=M)
+  when is_atom(Name) ->
+    M#module{records=[{File, Name, Fields} | Rs]}.
+
+%% @doc Add a "wild" attribute, such as `-compile(Opts)' to a module
+%% representation. Note that such attributes can only have a single argument.
+add_attribute(Name, Term, #module{file=File, attributes=As}=M)
+  when is_atom(Name) ->
+    M#module{attributes=[{File, Name, Term} | As]}.
+
+%% @doc Add an import declaration to a module representation.
+add_import(From, Names, #module{imports=Is}=M)
+  when is_atom(From), is_list(Names) ->
+    M#module{imports=[{From, Names} | Is]}.