%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2010-2013. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%%
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%%
%% %CopyrightEnd%
%%
%%
%% 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([codec/1,
codec/2,
dict/1,
dict/2,
format/1,
flatten/1]).
-export_type([opt/0]).
%% Options passed to codec/2.
-type opt() :: {include|outdir|name|prefix|inherits, string()}
| return
| verbose
| debug.
%% Literal dictionary or path. A NL of CR identifies the former.
-type dict() :: iolist()
| binary().
%% Name of a literal dictionary if otherwise unspecified.
-define(DEFAULT_DICT_NAME, "dictionary.dia").
%% ===========================================================================
%% codec/1-2
%%
%% Parse a dictionary file and generate a codec module. Input
%% dictionary can be either a path or the dictionary itself: the
%% occurrence of \n or \r in the argument is used to distinguish the
%% two.
-spec codec(File, [opt()])
-> ok
| {ok, Ret}
| {error, Reason}
when File :: dict(),
Ret :: list(), %% [Erl, Hrl | Debug], Debug = [] | [ParseD, Forms]
Reason :: string().
codec(File, Opts) ->
case to_dict(File, Opts) of
{ok, {Dict, Dictish}} ->
make(file(Dictish), Opts, Dict);
{error, _} = E ->
E
end.
codec(File) ->
codec(File, []).
file({path, Path}) ->
Path;
file(_) ->
?DEFAULT_DICT_NAME.
%% dict/2
%%
%% Parse a dictionary file and return the orddict that a codec module
%% returns from dict/0.
-spec dict(File, [opt()])
-> {ok, orddict:orddict()}
| {error, string()}
when File :: dict().
dict(File, Opts) ->
case to_dict(File, Opts) of
{ok, {Dict, _}} ->
{ok, Dict};
{error, _} = E ->
E
end.
dict(File) ->
dict(File, []).
%% to_dict/2
to_dict(File, Opts) ->
Dictish = maybe_path(File),
case diameter_dict_util:parse(Dictish, Opts) of
{ok, Dict} ->
{ok, {Dict, Dictish}};
{error = E, Reason} ->
{E, diameter_dict_util:format_error(Reason)}
end.
maybe_path(File) ->
Bin = iolist_to_binary([File]),
case is_path(Bin) of
true -> {path, File};
false -> Bin
end.
%% Interpret anything containing \n or \r as a literal dictionary,
%% otherwise a path. (Which might be the wrong guess in the worst case.)
is_path(Bin) ->
try
[throw(C) || <<C>> <= Bin, $\n == C orelse $\r == C],
true
catch
throw:_ -> false
end.
%% format/1
%%
%% Turn an orddict returned by dict/1-2 back into a dictionary.
-spec format(orddict:orddict())
-> iolist().
format(Dict) ->
diameter_dict_util:format(Dict).
%% flatten/1
%%
%% Reconstitute a dictionary without @inherits.
-spec flatten(orddict:orddict())
-> orddict:orddict().
flatten(Dict) ->
lists:foldl(fun flatten/2, Dict, [[avp_types, import_avps],
[grouped, import_groups],
[enum, import_enums]]).
flatten([_,_] = Keys, Dict) ->
[Values, Imports] = [orddict:fetch(K, Dict) || K <- Keys],
Vs = lists:append([Values | [V || {_,V} <- Imports]]),
lists:foldl(fun store/2,
Dict,
lists:zip([inherits | Keys], [[], Vs, []])).
store({Key, Value}, Dict) ->
orddict:store(Key, Value, Dict).
%% ===========================================================================
make(File, Opts, Dict) ->
ok(lists:foldl(fun(M,A) -> [make(File, Opts, Dict, M) | A] end,
[],
lists:append([[dict, forms] || lists:member(debug, Opts)])
++ [erl, hrl])).
%% The order in which results are generated (dict/forms/erl/hrl) is
%% intentional, in order of more processing (except for hrl, which
%% isn't needed by diameter itself), since an error raises an
%% exception. The order of return results is the reverse.
ok([ok,_|_]) ->
ok;
ok([_,_|_] = L) ->
{ok, L}.
make(File, Opts, Dict, Mode) ->
try
diameter_codegen:from_dict(File, Dict, Opts, Mode)
catch
error: Reason ->
erlang:error({Reason, Mode, erlang:get_stacktrace()})
end.
