path: root/lib/diameter/src/base/diameter_info.erl

%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2010-2014. 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%
%%

%%
%% Generic functions for formatting table listings and more. Used by
%% diameter_dbg.
%%

-module(diameter_info).

-export([usage/1,
         format/1,
         format/2,
         format/3,
         format/4,
         table/2,
         tables/1,
         tables/2,
         split/2,
         split/3,
         tab2list/1,
         modules/1,
         versions/1,
         version_info/1,
         attrs/2,
         compiled/1,
         procs/1,
         latest/1,
         list/1]).

%% Support for rolling your own.
-export([sep/0,
         sep/1,
         widest/1,
         p/1,
         p/3]).

-compile({no_auto_import,[max/2]}).

-export([collect/2]).

-define(LONG_TIMEOUT, 30000).
-define(VALUES(Rec), tl(tuple_to_list(Rec))).

%%% ----------------------------------------------------------
%%% # usage(String)
%%% ----------------------------------------------------------

usage(Usage) ->
    sep($+),
    io:format("+ ~p~n", [?MODULE]),
    io:format("~n~s~n~n", [compact(Usage)]),
    sep($+).

%%%
%%% The function format/3, for pretty-printing tables, comes in
%%% several flavours.
%%%

%%% ----------------------------------------------------------
%%% # format(TableName, Fields, SplitFun)
%%%
%%% Input:  TableName = atom() name of table.
%%%
%%%         Fields    = List of field names for the records maintained
%%%                     in the specified table. Can be empty, in which
%%%                     case entries are listed unadorned of field names
%%%                     and SplitFun is unused.
%%%                   | Integer, equivalent to a list with this many '' atoms.
%%%                   | Arity 1 fun mapping a table entry to a Fields list
%%%                     or a tuple {Fields, Values} of lists of the same
%%%                     length.
%%%
%%%                   If Fields is a list then its length must be the same
%%%                   as or one less than the size of the tuples contained
%%%                   in the table. (The values printed then being those
%%%                   in the tuple or record in question.)
%%%
%%%         SplitFun  = Arity 3 fun applied as
%%%
%%%                       SplitFun(TableName, Fields, Values)
%%%
%%%                     in order to obtain a tuple
%%%
%%%                       {Field, RestFields, Value, RestValues}
%%%
%%%                     for which Field/Value will be formatted on
%%%                     STDOUT. (This is to allow a value to be
%%%                     transformed before being output by returning a
%%%                     new value and/or replacing the remainder of
%%%                     the list.) The returned lists must have the
%%%                     same length and Field here is an atom, '' causing
%%%                     a value to be listed unadorned of the field name.
%%%
%%%                     Field can also be list of field names, in
%%%                     which case Value must be a record of the
%%%                     corresponding type.
%%%
%%%                   | Arity 2 fun applied as SplitFun(Fields, Values).
%%%
%%% Output:  Count | undefined
%%%
%%%          Count = Number of entries output.
%%%
%%% Description: Pretty-print records in a named table.
%%% ----------------------------------------------------------

format(Table, Fields, SFun)
  when is_atom(Table), is_function(SFun, 2) ->
    ft(ets:info(Table), Table, SFun, Fields);

format(Table, Fields, SFun)
  when is_atom(Table), is_function(SFun, 3) ->
    format(Table, Fields, fun(Fs,Vs) -> SFun(Table, Fs, Vs) end);

%%% ----------------------------------------------------------
%%% # format(Recs, Fields, SplitFun)
%%%
%%% Input:  Recs     = list of records/tuples
%%%         Fields   = As for format(Table, Fields, SplitFun), a table
%%%                    entry there being a member of Recs.
%%%         SplitFun = Arity 3 fun applied as above but with the TableName
%%%                    replaced by the first element of the records in
%%%                    question.
%%%                  | Arity 2 fun as for format/3.
%%%
%%% Output: length(Recs)
%%%
%%% Description: Pretty print records/tuples.
%%% ----------------------------------------------------------

format(Recs, Fields, SFun)
  when is_list(Recs), is_function(SFun, 3) ->
    lists:foldl(fun(R,A) -> f(recsplit(SFun, R), 0, Fields, R, A) end,
                0,
                Recs);

format(Recs, Fields, SFun)
  when is_list(Recs), is_function(SFun, 2) ->
    lists:foldl(fun(R,A) -> f(SFun, 0, Fields, R, A) end,
                0,
                Recs);

%%% ----------------------------------------------------------
%%% # format(Tables, SplitFun, CollectFun)
%%%
%%% Input:  Tables = list of {TableName, Fields}.
%%%         SplitFun = As for format(Table, Fields, SplitFun).
%%%         CollectFun = arity 1 fun mapping a table name to a list
%%%                      of elements. A non-list can be returned to indicate
%%%                      that the table in question doesn't exist.
%%%
%%% Output: Number of entries output.
%%%
%%% Description: Pretty-print records in a named tables as collected
%%%              from known nodes. Each table listing is preceeded by
%%%              a banner.
%%% ----------------------------------------------------------

format(Tables, SFun, CFun)
  when is_list(Tables), is_function(CFun, 1) ->
    format_remote(Tables,
                  SFun,
                  rpc:multicall(nodes(known),
                                ?MODULE,
                                collect,
                                [CFun, lists:map(fun({T,_}) -> T end, Tables)],
                                ?LONG_TIMEOUT));

%%% ----------------------------------------------------------
%%% # format(LocalTables, RemoteTables, SplitFun, CollectFun)
%%% # format(LocalTables, RemoteTables, SplitFun)
%%%
%%% Input:  LocalTables = list of {TableName, Fields}.
%%%                     | list of {TableName, Recs, Fields}
%%%         RemoteTable = list of {TableName, Fields}.
%%%         SplitFun, CollectFun = As for format(Table, CollectFun, SplitFun).
%%%
%%% Output: Number of entries output.
%%%
%%% Description: Pretty-print records in a named tables as collected
%%%              from local and remote nodes. Each table listing is
%%%              preceeded by a banner.
%%% ----------------------------------------------------------

format(Local, Remote, SFun) ->
    format(Local, Remote, SFun, fun tab2list/1).

format(Local, Remote, SFun, CFun)
  when is_list(Local), is_list(Remote), is_function(CFun, 1) ->
    format_local(Local, SFun) + format(Remote, SFun, CFun).

%%% ----------------------------------------------------------
%%% # format(Tables, SplitFun)
%%% ----------------------------------------------------------

format(Tables, SFun)
  when is_list(Tables), (is_function(SFun, 2) or is_function(SFun, 3)) ->
    format(Tables, SFun, fun tab2list/1);

format(Tables, CFun)
  when is_list(Tables), is_function(CFun, 1) ->
    format(Tables, fun split/2, CFun).

%%% ----------------------------------------------------------
%%% # format(Table|Tables)
%%% ----------------------------------------------------------

format(Table)
  when is_atom(Table) ->
    format(Table, [], fun split/2);

format(Tables)
  when is_list(Tables) ->
    format(Tables, fun split/2, fun tab2list/1).

%%% ----------------------------------------------------------
%%% # split(TableName, Fields, Values)
%%%
%%% Description: format/3 SplitFun that does nothing special.
%%% ----------------------------------------------------------

split([F|FT], [V|VT]) ->
    {F, FT, V, VT}.

split(_, Fs, Vs) ->
    split(Fs, Vs).

%%% ----------------------------------------------------------
%%% # tab2list(TableName)
%%%
%%% Description: format/4 CollectFun that extracts records from an
%%%              existing ets table.
%%% ----------------------------------------------------------

tab2list(Table) ->
    case ets:info(Table) of
        undefined = No ->
            No;
        _ ->
            ets:tab2list(Table)
    end.

list(Table) ->
    l(tab2list(Table)).

l(undefined = No) ->
    No;
l(List)
  when is_list(List) ->
    io:format("~p~n", [List]),
    length(List).

%%% ----------------------------------------------------------
%%% # table(TableName, Fields)
%%% ----------------------------------------------------------

table(Table, Fields) ->
    format(Table, Fields, fun split/2).

%%% ----------------------------------------------------------
%%% # tables(LocalTables, RemoteTables)
%%% ----------------------------------------------------------

tables(Local, Remote) ->
    format(Local, Remote, fun split/2).

%%% ----------------------------------------------------------
%%% # tables(Tables)
%%% ----------------------------------------------------------

tables(Tables) ->
    format(Tables, fun split/2).

%%% ----------------------------------------------------------
%%% # modules(Prefix|Prefixes)
%%%
%%% Input: Prefix = atom()
%%%
%%% Description: Return the list of all loaded modules with the
%%%              specified prefix.
%%% ----------------------------------------------------------

modules(Prefix)
  when is_atom(Prefix) ->
    lists:sort(mods(Prefix));

modules(Prefixes)
  when is_list(Prefixes) ->
    lists:sort(lists:flatmap(fun modules/1, Prefixes)).

mods(Prefix) ->
    P = atom_to_list(Prefix),
    lists:filter(fun(M) ->
                         lists:prefix(P, atom_to_list(M))
                 end,
                 erlang:loaded()).

%%% ----------------------------------------------------------
%%% # versions(Modules|Prefix)
%%%
%%% Output: Number of modules listed.
%%%
%%% Description: List the versions of the specified modules.
%%% ----------------------------------------------------------

versions(Modules) ->
    {SysInfo, OsInfo, ModInfo} = version_info(Modules),
    sep(),
    print_sys_info(SysInfo),
    sep(),
    print_os_info(OsInfo),
    sep(),
    print_mod_info(ModInfo),
    sep().

%%% ----------------------------------------------------------
%%% # attrs(Modules|Prefix, Attr|FormatFun)
%%%
%%% Output: Number of modules listed.
%%%
%%% Description: List an attribute from module_info.
%%% ----------------------------------------------------------

attrs(Modules, Attr)
  when is_atom(Attr) ->
    attrs(Modules, fun(W,M) -> attr(W, M, Attr, fun attr/1) end);

attrs(Modules, Fun)
  when is_list(Modules) ->
    sep(),
    W = 2 + widest(Modules),
    N = lists:foldl(fun(M,A) -> Fun(W,M), A+1 end, 0, Modules),
    sep(),
    N;

attrs(Prefix, Fun) ->
    attrs(modules(Prefix), Fun).

%% attr/1

attr(T) when is_atom(T) ->
    atom_to_list(T);
attr(N) when is_integer(N) ->
    integer_to_list(N);
attr(V) ->
    case is_list(V) andalso lists:all(fun is_char/1, V) of
        true ->  %% string
            V;
        false ->
            io_lib:format("~p", [V])
    end.

is_char(C) ->
    0 =< C andalso C < 256.

%% attr/4

attr(Width, Mod, Attr, VFun) ->
    io:format(": ~*s~s~n", [-Width, Mod, attr(Mod, Attr, VFun)]).

attr(Mod, Attr, VFun) ->
    Key = key(Attr),
    try
        VFun(val(Attr, keyfetch(Attr, Mod:module_info(Key))))
    catch
        _:_ ->
            "-"
    end.

attr(Mod, Attr) ->
    attr(Mod, Attr, fun attr/1).

key(time) -> compile;
key(_)    -> attributes.

val(time, {_,_,_,_,_,_} = T) ->
    lists:flatten(io_lib:format("~p-~2..0B-~2..0B ~2..0B:~2..0B:~2..0B",
                                tuple_to_list(T)));
val(_, [V]) ->
    V.

%%% ----------------------------------------------------------
%%% # compiled(Modules|Prefix)
%%%
%%% Output: Number of modules listed.
%%%
%%% Description: List the compile times of the specified modules.
%%% ----------------------------------------------------------

compiled(Modules)
  when is_list(Modules) ->
    attrs(Modules, fun compiled/2);

compiled(Prefix) ->
    compiled(modules(Prefix)).

compiled(Width, Mod) ->
    io:format(": ~*s~19s  ~s~n", [-Width,
                                  Mod,
                                  attr(Mod, time),
                                  opt(attr(Mod, date))]).

opt("-") ->
    "";
opt(D) ->
    "(" ++ D ++ ")".

%%% ----------------------------------------------------------
%%% # procs(Pred|Prefix|Prefixes|Pid|Pids)
%%%
%%% Input:  Pred = arity 2 fun returning true|false when applied to a
%%%                pid and its process info.
%%%
%%% Output: Number of processes listed.
%%%
%%% Description: List process info for all local processes that test
%%%              true with the specified predicate. With the prefix
%%%              form, those processes that are either currently
%%%              executing in, started executing in, or have a
%%%              registered name with a specified prefix are listed.
%%%              With the pid forms, only those process that are local
%%%              are listed and those that are dead list only the pid
%%%              itself.
%%% ----------------------------------------------------------

procs(Pred)
  when is_function(Pred, 2) ->
    procs(Pred, erlang:processes());

procs([]) ->
    0;

procs(Prefix)
  when is_atom(Prefix) ->
    procs(fun(_,I) -> info(fun pre1/2, I, atom_to_list(Prefix)) end);

procs(Prefixes)
  when is_atom(hd(Prefixes)) ->
    procs(fun(_,I) -> info(fun pre/2, I, Prefixes) end);

procs(Pid)
  when is_pid(Pid) ->
    procs(fun true2/2, [Pid]);

procs(Pids)
  when is_list(Pids) ->
    procs(fun true2/2, Pids).

true2(_,_) ->
    true.

%% procs/2

procs(Pred, Pids) ->
    Procs = lists:foldl(fun(P,A) ->
                                procs_acc(Pred, P, catch process_info(P), A)
                        end,
                        [],
                        Pids),
    sep(0 < length(Procs)),
    lists:foldl(fun(T,N) -> p(T), sep(), N+1 end, 0, Procs).

procs_acc(_, Pid, undefined, Acc) ->  %% dead
    [[{pid, Pid}] | Acc];
procs_acc(Pred, Pid, Info, Acc)
  when is_list(Info) ->
    p_acc(Pred(Pid, Info), Pid, Info, Acc);
procs_acc(_, _, _, Acc) ->
    Acc.

p_acc(true, Pid, Info, Acc) ->
    [[{pid, Pid} | Info] | Acc];
p_acc(false, _, _, Acc) ->
    Acc.

%% info/3

info(Pred, Info, T) ->
    lists:any(fun(I) -> i(Pred, I, T) end, Info).

i(Pred, {K, {M,_,_}}, T)
  when K == current_function;
       K == initial_call ->
    Pred(M,T);
i(Pred, {registered_name, N}, T) ->
    Pred(N,T);
i(_,_,_) ->
    false.

pre1(A, Pre) ->
    lists:prefix(Pre, atom_to_list(A)).

pre(A, Prefixes) ->
    lists:any(fun(P) -> pre1(A, atom_to_list(P)) end, Prefixes).

%%% ----------------------------------------------------------
%%% # latest(Modules|Prefix)
%%%
%%% Output: {Mod, {Y,M,D,HH,MM,SS}, Version}
%%%
%%% Description: Return the compile time of the most recently compiled
%%%              module from the specified non-empty list. The modules
%%%              are assumed to exist.
%%% ----------------------------------------------------------

latest(Prefix)
  when is_atom(Prefix) ->
    latest(modules(Prefix));

latest([_|_] = Modules) ->
    {Mod, T}
        = hd(lists:sort(fun latest/2, lists:map(fun compile_time/1, Modules))),
    {Mod, T, app_vsn(Mod)}.

app_vsn(Mod) ->
    keyfetch(app_vsn, Mod:module_info(attributes)).

compile_time(Mod) ->
    T = keyfetch(time, Mod:module_info(compile)),
    {Mod, T}.

latest({_,T1},{_,T2}) ->
    T1 > T2.

%%% ----------------------------------------------------------
%%% version_info(Modules|Prefix)
%%%
%%% Output: {SysInfo, OSInfo, [ModInfo]}
%%%
%%%         SysInfo = {Arch, Vers}
%%%         OSInfo  = {Vers, {Fam, Name}}
%%%         ModInfo = {Vsn, AppVsn, Time, CompilerVsn}
%%% ----------------------------------------------------------

version_info(Prefix)
  when is_atom(Prefix) ->
    version_info(modules(Prefix));

version_info(Mods)
  when is_list(Mods)  ->
    {sys_info(), os_info(), [{M, mod_version_info(M)} || M <- Mods]}.

mod_version_info(Mod) ->
    try
        Info = Mod:module_info(),
        [[Vsn], AppVsn] = get_values(attributes, [vsn, app_vsn], Info),
        [Ver, Time] = get_values(compile, [version, time], Info),
        [Vsn, AppVsn, Ver, Time]
    catch
        _:_ ->
            []
    end.

get_values(Attr, Keys, Info) ->
    As   = proplists:get_value(Attr, Info),
    [proplists:get_value(K, As, "?") || K <- Keys].

sys_info() ->
    [A,V] = [chomp(erlang:system_info(K)) || K <- [system_architecture,
                                                   system_version]],
    {A,V}.

os_info() ->
    {os:version(), os:type()}.

chomp(S) ->
    string:strip(S, right, $\n).

print_sys_info({Arch, Ver}) ->
    io:format("System info:~n"
              "   architecture : ~s~n"
              "   version      : ~s~n",
              [Arch, Ver]).

print_os_info({Vsn, {Fam, Name}}) ->
    io:format("OS info:~n"
              "   family  : ~s ~s~n"
              "   version : ~s~n",
              [str(Fam), bkt(str(Name)), vsn(Vsn)]).

print_mod_info(Mods) ->
    io:format("Module info:~n", []),
    lists:foreach(fun print_mod/1, Mods).

print_mod({Mod, []}) ->
    io:format("   ~w:~n", [Mod]);
print_mod({Mod, [Vsn, AppVsn, Ver, {Year, Month, Day, Hour, Min, Sec}]}) ->
    Time = io_lib:format("~w-~2..0w-~2..0w ~2..0w:~2..0w:~2..0w",
                         [Year, Month, Day, Hour, Min, Sec]),
    io:format("   ~w:~n"
              "      vsn      : ~s~n"
              "      app_vsn  : ~s~n"
              "      compiled : ~s~n"
              "      compiler : ~s~n",
              [Mod, str(Vsn), str(AppVsn), Time, Ver]).

str(A)
  when is_atom(A) ->
    atom_to_list(A);
str(S)
  when is_list(S) ->
    S;
str(T) ->
    io_lib:format("~p", [T]).

bkt("" = S) ->
    S;
bkt(S) ->
    [$[, S, $]].

vsn(T) when is_tuple(T) ->
    case [[$., integer_to_list(N)] || N <- tuple_to_list(T)] of
        [[$.,S] | Rest] ->
            [S | Rest];
        [] = S ->
            S
    end;
vsn(T) ->
    str(T).

%%% ----------------------------------------------------------
%%% ----------------------------------------------------------

%% p/1

p(Info) ->
    W = 2 + widest([K || {K,_} <- Info]),
    lists:foreach(fun({K,V}) -> p(W,K,V) end, Info).

p(Width, Key, Value) ->
    io:format(": ~*s: ~p~n", [-Width, Key, Value]).

%% sep/[01]

sep() ->
    sep($#).

sep(true) ->
    sep();
sep(false) ->
    ok;

sep(Ch) ->
    io:format("~c~65c~n", [Ch, $-]).

%% widest/1

widest(List) ->
    lists:foldl(fun widest/2, 0, List).

widest(T, Max)
  when is_atom(T) ->
    widest(atom_to_list(T), Max);

widest(T, Max)
  when is_integer(T) ->
    widest(integer_to_list(T), Max);

widest(T, Max)
  when is_list(T) ->  %% string
    max(length(T), Max).

pt(T) ->
    io:format(": ~p~n", [T]).

recsplit(SFun, Rec) ->
    fun(Fs,Vs) -> SFun(element(1, Rec), Fs, Vs) end.

max(A, B) ->
    if A > B -> A; true -> B end.

keyfetch(Key, List) ->
    {Key,V} = lists:keyfind(Key, 1, List),
    V.

%% ft/4

ft(undefined = No, _, _, _) ->
    No;

ft(_, Table, SFun, Fields) ->
    ets:foldl(fun(R,A) ->
                      f(SFun, 0, Fields, R, A)
              end,
              0,
              Table).

%% f/5

f(SFun, Width, Fields, Rec, Count) ->
    ff(SFun, Width, fields(Fields, Rec), Rec, Count).

ff(SFun, Width, Fields, Rec, Count) ->
    sep(0 == Count),
    f(SFun, Width, Fields, Rec),
    sep(),
    Count+1.

fields(N, _)
  when is_integer(N), N >= 0 ->
    lists:duplicate(N, '');     %% list values unadorned
fields(Fields, R)
  when is_function(Fields, 1) ->
    fields(Fields(R), R);
fields({Fields, Values} = T, _)
  when length(Fields) == length(Values) ->
    T;
fields(Fields, _)
  when is_list(Fields) ->
    Fields.                     %% list field/value pairs, or tuples if []

%% f/4

%% Empty fields list: just print the entry.
f(_, _, [], Rec)
  when is_tuple(Rec) ->
    pt(Rec);

%% Otherwise list field names/values.
f(SFun, Width, {Fields, Values}, _) ->
    f(SFun, Width, Fields, Values);

f(SFun, Width, Fields, Rec)
  when is_tuple(Rec) ->
    f(SFun, Width, Fields, values(Fields, Rec));

f(_, _, [], []) ->
    ok;

f(SFun, Width, [HF | _] = Fields, Values) ->
    {F, FT, V, VT} = SFun(Fields, Values),
    if is_list(F) -> %% V is a record
            break($>, HF),
            f(SFun, Width, F, values(F,V)),
            break($<, HF),
            f(SFun, Width, FT, VT);
       F == '' ->    %% no field name: just list value
            pt(V),
            f(SFun, Width, FT, VT);
       true ->       %% list field/value.
            W = max(Width, 1 + widest(Fields)),
            p(W, F, V),
            f(SFun, W, FT, VT)
    end.

values(Fields, Rec)
  when length(Fields) == size(Rec) - 1 ->
    ?VALUES(Rec);
values(Fields, T)
  when length(Fields) == size(T) ->
    tuple_to_list(T).

%% format_local/2

format_local(Tables, SFun) ->
    lists:foldl(fun(T,A) -> fl(SFun, T, A) end, 0, Tables).

fl(SFun, {Table, Recs, Fields}, Count) ->
    sep(),
    io:format("# ~p~n", [Table]),
    N = fmt(Recs, Fields, SFun),
    sep(0 == N),
    Count + N;

fl(SFun, {Table, Fields}, Count) ->
    fl(SFun, {Table, Table, Fields}, Count).

%% fmt/3

fmt(T, Fields, SFun) ->
    case format(T, Fields, SFun) of
        undefined ->
            0;
        N ->
            N
    end.

%% break/2

break(C, T) ->
    io:format("~c ~p~n", [C, T]).

%% collect/2
%%
%% Output: {[{TableName, Recs}, ...], node()}

collect(CFun, TableNames) ->
    {lists:foldl(fun(N,A) -> c(CFun, N, A) end, [], TableNames), node()}.

c(CFun, TableName, Acc) ->
    case CFun(TableName) of
        Recs when is_list(Recs) ->
            [{TableName, Recs} | Acc];
        _ ->
            Acc
    end.

%% format_remote/3

format_remote(Tables, SFun, {Replies, BadNodes}) ->
    N = lists:foldl(fun(T,A) -> fr(Tables, SFun, T, A) end,
                    0,
                    Replies),
    sep(0 == N andalso [] /= BadNodes),
    lists:foreach(fun(Node) -> io:format("# no reply from ~p~n", [Node]) end,
                  BadNodes),
    sep([] /= BadNodes),
    N.

fr(Tables, SFun, {List, Node}, Count)
  when is_list(List) ->  %% guard against {badrpc, Reason}
    lists:foldl(fun({T,Recs}, C) -> fr(Tables, SFun, Node, T, Recs,C) end,
                Count,
                List);
fr(_, _, _, Count) ->
    Count.

fr(Tables, SFun, Node, Table, Recs, Count) ->
    Fields = keyfetch(Table, Tables),
    sep(),
    io:format("# ~p@~p~n", [Table, Node]),
    N = format(Recs, Fields, tblsplit(SFun, Table)),
    sep(0 == N),
    Count + N.

tblsplit(SFun, Table)
  when is_function(SFun, 3) ->
    fun(Fs,Vs) -> SFun(Table, Fs, Vs) end;
tblsplit(SFun, _)
  when is_function(SFun, 2) ->
    SFun.

%% compact/1
%%
%% Strip whitespace from both ends of a string.

compact(Str) ->
    compact(Str, true).

compact([Ch|Rest], B)
  when Ch == $\n;
       Ch == $ ;
       Ch == $\t;
       Ch == $\v;
       Ch == $\r ->
    compact(Rest, B);

compact(Str, false) ->
    Str;

compact(Str, true) ->
    lists:reverse(compact(lists:reverse(Str), false)).