1 files changed, 92 insertions, 80 deletions
diff --git a/lib/diameter/src/compiler/diameter_make.erl b/lib/diameter/src/compiler/diameter_make.erl
index 4431b88c4d..16e30c1ffb 100644
--- a/lib/diameter/src/compiler/diameter_make.erl
+++ b/lib/diameter/src/compiler/diameter_make.erl
@@ -18,103 +18,115 @@
 %%
 
 %%
-%% Driver for the encoder generator utility.
+%% Module alternative to diameterc for dictionary compilation.
+%%
+%% Eg. 1> diameter_make:codec("mydict.dia").
+%%
+%%     $ erl -noinput \
+%%           -boot start_clean \
+%%           -eval 'ok = diameter_make:codec("mydict.dia")' \
+%%           -s init stop
 %%
 
 -module(diameter_make).
 
--export([spec/0,
-         hrl/0,
-         erl/0]).
+-export([codec/1,
+         codec/2,
+         dict/1,
+         dict/2,
+         format/1,
+         reformat/1]).
 
--spec spec() -> no_return().
--spec hrl()  -> no_return().
--spec erl()  -> no_return().
+-export_type([opt/0]).
 
-spec() ->
-    make(spec).
+-type opt() :: {include|outdir|name|prefix|inherits, string()}
+             | verbose
+             | debug.
 
-hrl() ->
-    make(hrl).
+%% ===========================================================================
 
-erl() ->
-    make(erl).
+%% codec/1-2
+%%
+%% Parse a dictionary file and generate a codec module.
+
+-spec codec(Path, [opt()])
+   -> ok
+    | {error, Reason}
+ when Path :: string(),
+      Reason :: string().
+
+codec(File, Opts) ->
+    case dict(File, Opts) of
+        {ok, Dict} ->
+            make(File,
+                 Opts,
+                 Dict,
+                 [spec || _ <- [1], lists:member(debug, Opts)] ++ [erl, hrl]);
+        {error, _} = E ->
+            E
+    end.
 
-%% make/1
+codec(File) ->
+    codec(File, []).
 
-make(Mode) ->
-    Args = init:get_plain_arguments(),
-    Opts = try options(Args) catch throw: help -> help(Mode) end,
-    Files = proplists:get_value(files, Opts, []),
-    lists:foreach(fun(F) -> from_file(F, Mode, Opts) end, Files),
-    halt(0).
+%% dict/2
+%%
+%% Parse a dictionary file and return the orddict that a codec module
+%% returns from dict/0.
+
+-spec dict(string(), [opt()])
+   -> {ok, orddict:orddict()}
+    | {error, string()}.
+
+dict(Path, Opts) ->
+    case diameter_dict_util:parse({path, Path}, Opts) of
+        {ok, _} = Ok ->
+            Ok;
+        {error = E, Reason} ->
+            {E, diameter_dict_util:format_error(Reason)}
+    end.
 
-%% from_file/3
+dict(File) ->
+    dict(File, []).
 
-from_file(F, Mode, Opts) ->
-    try to_spec(F, Mode, Opts) of
-        Spec ->
-            from_spec(F, Spec, Mode, Opts)
-    catch
-        error: Reason ->
-            io:format("==> ~p parse failure:~n~p~n",
-                      [F, {Reason, erlang:get_stacktrace()}]),
-            halt(1)
-    end.
+%% format/1
+%%
+%% Turn an orddict returned by dict/1-2 back into a dictionary file
+%% in the form of an iolist().
 
-%% to_spec/2
+-spec format(orddict:orddict())
+   -> iolist().
 
-%% Try to read the input as an already parsed file or else parse it.
-to_spec(F, spec, Opts) ->
-    diameter_spec_util:parse(F, Opts);
-to_spec(F, _, _) ->
-    {ok, [Spec]} = file:consult(F),
-    Spec.
+format(Dict) ->
+    diameter_dict_util:format(Dict).
 
-%% from_spec/4
+%% reformat/1
+%%
+%% Parse a dictionary file and return its formatted equivalent.
+
+-spec reformat(File)
+   -> {ok, iolist()}
+    | {error, Reason}
+ when File :: string(),
+      Reason :: string().
+
+reformat(File) ->
+    case dict(File) of
+        {ok, Dict} ->
+            {ok, format(Dict)};
+        {error, _} = No ->
+            No
+    end.
 
-from_spec(File, Spec, Mode, Opts) ->
+%% ===========================================================================
+
+make(_, _, _, []) ->
+    ok;
+make(File, Opts, Dict, [Mode | Rest]) ->
     try
-        diameter_codegen:from_spec(File, Spec, Opts, Mode)
+        ok = diameter_codegen:from_dict(File, Dict, Opts, Mode),
+        make(File, Opts, Dict, Rest)
     catch
         error: Reason ->
-            io:format("==> ~p codegen failure:~n~p~n~p~n",
-                      [Mode, File, {Reason, erlang:get_stacktrace()}]),
-            halt(1)
+            erlang:error({Reason, Mode, erlang:get_stacktrace()})
     end.
-
-%% options/1
-
-options(["-v" | Rest]) ->
-    [verbose | options(Rest)];
-
-options(["-o", Outdir | Rest]) ->
-    [{outdir, Outdir} | options(Rest)];
-
-options(["-i", Incdir | Rest]) ->
-    [{include, Incdir} | options(Rest)];
-
-options(["-h" | _]) ->
-    throw(help);
-
-options(["--" | Fs]) ->
-    [{files, Fs}];
-
-options(["-" ++ _ = Opt | _]) ->
-    io:fwrite("==> unknown option: ~s~n", [Opt]),
-    throw(help);
-
-options(Fs) ->  %% trailing arguments
-    options(["--" | Fs]).
-
-%% help/1
-
-help(M) ->
-    io:fwrite("Usage: ~p ~p [Options] [--] File ...~n"
-              "Options:~n"
-              " -v              verbose output~n"
-              " -h              shows this help message~n"
-              " -o OutDir       where to put the output files~n"
-              " -i IncludeDir   where to search for beams to import~n",
-              [?MODULE, M]),
-    halt(1).