The R13B03 release.OTP_R13B03

1 files changed, 646 insertions, 0 deletions

diff --git a/lib/stdlib/src/io_lib_pretty.erl b/lib/stdlib/src/io_lib_pretty.erl
new file mode 100644
index 0000000000..169410796b
--- /dev/null
+++ b/lib/stdlib/src/io_lib_pretty.erl
@@ -0,0 +1,646 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-2009. 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(io_lib_pretty).
+
+%%% Pretty printing Erlang terms
+%%%
+%%% In this module "print" means the formatted printing while "write"
+%%% means just writing out onto one line.
+
+-export([print/1,print/2,print/3,print/4,print/5,print/6]).
+
+%%%
+%%% Exported functions
+%%%
+
+%% print(Term) -> [Chars]
+%% print(Term, Column, LineLength, Depth) -> [Chars]
+%% Depth = -1 gives unlimited print depth. Use io_lib:write for atomic terms.
+
+print(Term) ->
+    print(Term, 1, 80, -1).
+
+%% print(Term, RecDefFun) -> [Chars]
+%% print(Term, Depth, RecDefFun) -> [Chars]
+%% RecDefFun = fun(Tag, NoFields) -> [FieldTag] | no
+%% Used by the shell for printing records.
+print(Term, RecDefFun) ->
+    print(Term, -1, RecDefFun).
+
+print(Term, Depth, RecDefFun) ->
+    print(Term, 1, 80, Depth, RecDefFun).
+
+print(Term, Col, Ll, D) ->
+    print(Term, Col, Ll, D, _M=-1, no_fun).
+
+print(Term, Col, Ll, D, RecDefFun) ->
+    print(Term, Col, Ll, D, _M=-1, RecDefFun).
+
+print(_, _, _, 0, _M, _RF) -> "...";
+print(Term, Col, Ll, D, M, RecDefFun) when Col =< 0 ->
+    print(Term, 1, Ll, D, M, RecDefFun);
+print(Term, Col, Ll, D, M0, RecDefFun) when is_tuple(Term); 
+                                            is_list(Term) ->
+    If = {_S, Len} = print_length(Term, D, RecDefFun),
+    M = max_cs(M0, Len),
+    if
+        Len < Ll - Col, Len =< M ->
+            write(If);
+        true ->
+            TInd = while_fail([-1, 4], 
+                              fun(I) -> cind(If, Col, Ll, M, I, 0, 0) end, 
+                              1),
+            pp(If, Col, Ll, M, TInd, indent(Col), 0, 0)
+    end;
+print(<<_/bitstring>>=Term, Col, Ll, D, M0, RecDefFun) ->
+    If = {_S, Len} = print_length(Term, D, RecDefFun),
+    M = max_cs(M0, Len),
+    if
+        Len < Ll - Col, Len =< M ->
+            write(If);
+        true ->
+            TInd = while_fail([-1, 4], 
+                              fun(I) -> cind(If, Col, Ll, M, I, 0, 0) end, 
+                              1),
+            pp(If, Col, Ll, M, TInd, indent(Col), 0, 0)
+    end;
+print(Term, _Col, _Ll, _D, _M, _RF) ->
+    io_lib:write(Term).
+
+%%%
+%%% Local functions
+%%%
+
+max_cs(M, Len) when M < 0 ->
+    Len;
+max_cs(M, _Len) ->
+    M.
+
+-define(ATM(T), is_list(element(1, T))).
+-define(ATM_FLD(Field), ?ATM(element(4, element(1, Field)))).
+
+pp({_S, Len} = If, Col, Ll, M, _TInd, _Ind, LD, W) 
+                      when Len < Ll - Col - LD, Len + W + LD =< M ->
+    write(If);
+pp({{list,L}, _Len}, Col, Ll, M, TInd, Ind, LD, W) ->
+    [$[, pp_list(L, Col + 1, Ll, M, TInd, indent(1, Ind), LD, $|, W + 1), $]];
+pp({{tuple,true,L}, _Len}, Col, Ll, M, TInd, Ind, LD, W) ->
+    [${, pp_tag_tuple(L, Col, Ll, M, TInd, Ind, LD, W + 1), $}];
+pp({{tuple,false,L}, _Len}, Col, Ll, M, TInd, Ind, LD, W) ->
+    [${, pp_list(L, Col + 1, Ll, M, TInd, indent(1, Ind), LD, $,, W + 1), $}];
+pp({{record,[{Name,NLen} | L]}, _Len}, Col, Ll, M, TInd, Ind, LD, W) ->
+    [Name, ${, pp_record(L, NLen, Col, Ll, M, TInd, Ind, LD, W + NLen+1), $}];
+pp({{bin,S}, _Len}, Col, Ll, M, _TInd, Ind, LD, W) ->
+    pp_binary(S, Col + 2, Ll, M, indent(2, Ind), LD, W);
+pp({S, _Len}, _Col, _Ll, _M, _TInd, _Ind, _LD, _W) ->
+    S.
+
+%%  Print a tagged tuple by indenting the rest of the elements
+%%  differently to the tag. Tuple has size >= 2.
+pp_tag_tuple([{Tag,Tlen} | L], Col, Ll, M, TInd, Ind, LD, W) ->
+    TagInd = Tlen + 2,
+    Tcol = Col + TagInd,
+    S = $,,
+    if
+        TInd > 0, TagInd > TInd ->
+            Col1 = Col + TInd,
+            Indent = indent(TInd, Ind),
+            [Tag|pp_tail(L, Col1, Tcol, Ll, M, TInd, Indent, LD, S, W+Tlen)];
+        true ->
+            Indent = indent(TagInd, Ind),
+            [Tag, S | pp_list(L, Tcol, Ll, M, TInd, Indent, LD, S, W+Tlen+1)]
+    end.
+
+pp_record([], _Nlen, _Col, _Ll, _M, _TInd, _Ind, _LD, _W) ->
+    "";
+pp_record({dots, _}, _Nlen, _Col, _Ll, _M, _TInd, _Ind, _LD, _W) ->
+    "...";
+pp_record([F | Fs], Nlen, Col0, Ll, M, TInd, Ind0, LD, W0) ->
+    Nind = Nlen + 1,
+    {Col, Ind, S, W} = rec_indent(Nind, TInd, Col0, Ind0, W0),
+    {FS, FW} = pp_field(F, Col, Ll, M, TInd, Ind, last_depth(Fs, LD), W),
+    [S, FS | pp_fields_tail(Fs, Col, Col + FW, Ll, M, TInd, Ind, LD, W + FW)].
+
+pp_fields_tail([], _Col0, _Col, _Ll, _M, _TInd, _Ind, _LD, _W) ->
+    "";
+pp_fields_tail({dots, _}, _Col0, _Col, _M, _Ll, _TInd, _Ind, _LD, _W) ->
+    ",...";
+pp_fields_tail([{_, Len}=F | Fs], Col0, Col, Ll, M, TInd, Ind, LD, W) ->
+    LD1 = last_depth(Fs, LD),
+    ELen = 1 + Len,
+    if
+        LD1 =:= 0, ELen + 1 < Ll - Col, W + ELen + 1 =< M, ?ATM_FLD(F);
+        LD1 > 0, ELen < Ll - Col - LD1, W + ELen + LD1 =< M, ?ATM_FLD(F) ->
+            [$,, write_field(F) |
+             pp_fields_tail(Fs, Col0, Col+ELen, Ll, M, TInd, Ind, LD, W+ELen)];
+        true ->
+            {FS, FW} = pp_field(F, Col0, Ll, M, TInd, Ind, LD1, 0),
+            [$,, $\n, Ind, FS |
+             pp_fields_tail(Fs, Col0, Col0 + FW, Ll, M, TInd, Ind, LD, FW)]
+    end.
+
+pp_field({_, Len}=Fl, Col, Ll, M, _TInd, _Ind, LD, W) 
+         when Len < Ll - Col - LD, Len + W + LD =< M ->
+    {write_field(Fl), if
+                          ?ATM_FLD(Fl) -> 
+                              Len;
+                          true -> 
+                              Ll % force nl
+                      end};
+pp_field({{field, Name, NameL, F}, _Len}, Col0, Ll, M, TInd, Ind0, LD, W0) ->
+    {Col, Ind, S, W} = rec_indent(NameL, TInd, Col0, Ind0, W0 + NameL),
+    {[Name, " = ", S | pp(F, Col, Ll, M, TInd, Ind, LD, W)], Ll}. % force nl
+
+rec_indent(RInd, TInd, Col0, Ind0, W0) ->
+    Nl = (TInd > 0) and (RInd > TInd),
+    DCol = case Nl of
+               true -> TInd;
+               false -> RInd
+           end,
+    Col = Col0 + DCol,
+    Ind = indent(DCol, Ind0),
+    S = case Nl of
+            true -> [$\n | Ind];
+            false -> ""
+        end,
+    W = case Nl of
+            true -> 0;
+            false -> W0
+        end,
+    {Col, Ind, S, W}.
+
+pp_list({dots, _}, _Col0, _Ll, _M, _TInd, _Ind, _LD, _S, _W) ->
+    "...";
+pp_list([E | Es], Col0, Ll, M, TInd, Ind, LD, S, W) ->
+    {ES, WE} = pp_element(E, Col0, Ll, M, TInd, Ind, last_depth(Es, LD), W),
+    [ES | pp_tail(Es, Col0, Col0 + WE, Ll, M, TInd, Ind, LD, S, W + WE)].
+
+pp_tail([], _Col0, _Col, _Ll, _M, _TInd, _Ind, _LD, _S, _W) ->
+    "";
+pp_tail([{_, Len}=E | Es], Col0, Col, Ll, M, TInd, Ind, LD, S, W) ->
+    LD1 = last_depth(Es, LD),
+    ELen = 1 + Len,
+    if 
+        LD1 =:= 0, ELen + 1 < Ll - Col, W + ELen + 1 =< M, ?ATM(E);
+        LD1 > 0, ELen < Ll - Col - LD1, W + ELen + LD1 =< M, ?ATM(E) ->
+            [$,, write(E) | 
+             pp_tail(Es, Col0, Col + ELen, Ll, M, TInd, Ind, LD, S, W+ELen)];
+        true ->
+            {ES, WE} = pp_element(E, Col0, Ll, M, TInd, Ind, LD1, 0),
+            [$,, $\n, Ind, ES | 
+             pp_tail(Es, Col0, Col0 + WE, Ll, M, TInd, Ind, LD, S, WE)]
+    end;
+pp_tail({dots, _}, _Col0, _Col, _Ll, _M, _TInd, _Ind, _LD, S, _W) ->
+    [S | "..."];
+pp_tail({_, Len}=E, _Col0, Col, Ll, M, _TInd, _Ind, LD, S, W) 
+                  when Len + 1 < Ll - Col - (LD + 1), 
+                       Len + 1 + W + (LD + 1) =< M, 
+                       ?ATM(E) ->
+    [S | write(E)];
+pp_tail(E, Col0, _Col, Ll, M, TInd, Ind, LD, S, _W) ->
+    [S, $\n, Ind | pp(E, Col0, Ll, M, TInd, Ind, LD + 1, 0)].
+
+pp_element({_, Len}=E, Col, Ll, M, _TInd, _Ind, LD, W) 
+           when Len < Ll - Col - LD, Len + W + LD =< M, ?ATM(E) ->
+    {write(E), Len};
+pp_element(E, Col, Ll, M, TInd, Ind, LD, W) ->
+    {pp(E, Col, Ll, M, TInd, Ind, LD, W), Ll}. % force nl
+
+%% Reuse the list created by io_lib:write_binary()...
+pp_binary([LT,LT,S,GT,GT], Col, Ll, M, Ind, LD, W) ->
+    N = erlang:max(8, erlang:min(Ll - Col, M - 4 - W) - LD),
+    [LT,LT,pp_binary(S, N, N, Ind),GT,GT].
+
+pp_binary([BS, $, | S], N, N0, Ind) ->
+    Len = length(BS) + 1,
+    case N - Len of
+        N1 when N1 < 0 ->
+            [$\n, Ind, BS, $, | pp_binary(S, N0 - Len, N0, Ind)];
+        N1 ->
+            [BS, $, | pp_binary(S, N1, N0, Ind)]
+    end;
+pp_binary([BS1, $:, BS2]=S, N, _N0, Ind) 
+         when length(BS1) + length(BS2) + 1 > N ->
+    [$\n, Ind, S];
+pp_binary(S, N, _N0, Ind) ->
+    case iolist_size(S) > N of
+        true ->
+            [$\n, Ind, S];
+        false ->
+            S
+    end.
+
+write({{tuple, _IsTagged, L}, _}) ->
+    [${, write_list(L, $,), $}];
+write({{list, L}, _}) ->
+    [$[, write_list(L, $|), $]];
+write({{record, [{Name,_} | L]}, _}) ->
+    [Name, ${, write_fields(L), $}];
+write({{bin, S}, _}) ->
+    S;
+write({S, _}) ->
+    S.
+
+write_fields([]) ->
+    "";
+write_fields({dots, _}) ->
+    "...";
+write_fields([F | Fs]) ->
+    [write_field(F) | write_fields_tail(Fs)].
+
+write_fields_tail([]) ->
+    "";
+write_fields_tail({dots, _}) ->
+    ",...";
+write_fields_tail([F | Fs]) ->
+    [$,, write_field(F) | write_fields_tail(Fs)].
+
+write_field({{field, Name, _NameL, F}, _}) ->
+    [Name, " = " | write(F)].
+
+write_list({dots, _}, _S) ->
+    "...";
+write_list([E | Es], S) ->
+    [write(E) | write_tail(Es, S)].
+
+write_tail([], _S) ->
+    [];
+write_tail([E | Es], S) ->
+    [$,, write(E) | write_tail(Es, S)];
+write_tail({dots, _}, S) ->
+    [S | "..."];
+write_tail(E, S) ->
+    [S | write(E)].
+
+%% The depth (D) is used for extracting and counting the characters to
+%% print. The structure is kept so that the returned intermediate
+%% format can be formatted. The separators (list, tuple, record) are
+%% counted but need to be added later.
+
+%% D =/= 0
+print_length([], _D, _RF) ->
+    {"[]", 2};
+print_length({}, _D, _RF) ->
+    {"{}", 2};
+print_length(List, D, RF) when is_list(List) ->
+    case printable_list(List, D) of
+        true ->
+            S = io_lib:write_string(List, $"), %"
+            {S, length(S)};
+        %% Truncated lists could break some existing code.
+        % {true, Prefix} ->
+        %    S = io_lib:write_string(Prefix, $"), %"
+        %    {[S | "..."], 3 + length(S)};
+        false ->
+            print_length_list(List, D, RF)
+    end;
+print_length(Fun, _D, _RF) when is_function(Fun) ->
+    S = io_lib:write(Fun),
+    {S, iolist_size(S)};
+print_length(R, D, RF) when is_atom(element(1, R)), 
+                            is_function(RF) ->
+    case RF(element(1, R), tuple_size(R) - 1) of
+        no -> 
+            print_length_tuple(R, D, RF);
+        RDefs ->
+            print_length_record(R, D, RF, RDefs)
+    end;
+print_length(Tuple, D, RF) when is_tuple(Tuple) ->
+    print_length_tuple(Tuple, D, RF);
+print_length(<<>>, _D, _RF) ->
+    {"<<>>", 4};
+print_length(<<_/bitstring>>, 1, _RF) ->
+    {"<<...>>", 7};
+print_length(<<_/bitstring>>=Bin, D, _RF) ->
+    case bit_size(Bin) rem 8 of
+        0 ->
+	    D1 = D - 1, 
+	    case printable_bin(Bin, D1) of
+	        List when is_list(List) ->
+                    S = io_lib:write_string(List, $"),
+	            {[$<,$<,S,$>,$>], 4 + length(S)};
+	        {true, Prefix} -> 
+	            S = io_lib:write_string(Prefix, $"), 
+	            {[$<,$<, S | "...>>"], 4 + length(S)};
+	        false ->
+	            S = io_lib:write(Bin, D),
+	            {{bin,S}, iolist_size(S)}
+	    end;
+        _ ->
+           S = io_lib:write(Bin, D),
+	   {{bin,S}, iolist_size(S)}
+    end;    
+print_length(Term, _D, _RF) ->
+    S = io_lib:write(Term),
+    {S, iolist_size(S)}.
+
+print_length_tuple(_Tuple, 1, _RF) ->
+    {"{...}", 5};
+print_length_tuple(Tuple, D, RF) ->
+    L = print_length_list1(tuple_to_list(Tuple), D, RF),
+    IsTagged = is_atom(element(1, Tuple)) and (tuple_size(Tuple) > 1),
+    {{tuple,IsTagged,L}, list_length(L, 2)}.
+
+print_length_record(_Tuple, 1, _RF, _RDefs) ->
+    {"{...}", 5};
+print_length_record(Tuple, D, RF, RDefs) ->
+    Name = [$# | io_lib:write_atom(element(1, Tuple))],
+    NameL = length(Name),
+    L = print_length_fields(RDefs, D - 1, tl(tuple_to_list(Tuple)), RF),
+    {{record, [{Name,NameL} | L]}, list_length(L, NameL + 2)}.
+
+print_length_fields([], _D, [], _RF) ->
+    [];
+print_length_fields(_, 1, _, _RF) -> 
+    {dots, 3};
+print_length_fields([Def | Defs], D, [E | Es], RF) ->
+    [print_length_field(Def, D - 1, E, RF) | 
+     print_length_fields(Defs, D - 1, Es, RF)].
+
+print_length_field(Def, D, E, RF) ->
+    Name = io_lib:write_atom(Def),
+    {S, L} = print_length(E, D, RF),
+    NameL = length(Name) + 3,
+    {{field, Name, NameL, {S, L}}, NameL + L}.
+
+print_length_list(List, D, RF) -> 
+    L = print_length_list1(List, D, RF),
+    {{list, L}, list_length(L, 2)}.
+
+print_length_list1([], _D, _RF) ->
+    [];
+print_length_list1(_, 1, _RF) ->
+    {dots, 3};
+print_length_list1([E | Es], D, RF) ->
+    [print_length(E, D - 1, RF) | print_length_list1(Es, D - 1, RF)];
+print_length_list1(E, D, RF) ->
+    print_length(E, D - 1, RF).
+
+list_length([], Acc) ->
+    Acc;
+list_length([{_, Len} | Es], Acc) ->
+    list_length_tail(Es, Acc + Len);
+list_length({_, Len}, Acc) ->
+    Acc + Len.
+
+list_length_tail([], Acc) ->
+    Acc;
+list_length_tail([{_,Len} | Es], Acc) ->
+    list_length_tail(Es, Acc + 1 + Len);
+list_length_tail({_, Len}, Acc) ->
+    Acc + 1 + Len.
+
+%% ?CHARS printable characters has depth 1.
+-define(CHARS, 4).
+
+printable_list(L, D) when D < 0 ->
+    io_lib:printable_list(L);
+printable_list(_L, 1) ->
+    false;
+printable_list(L, _D) ->
+    io_lib:printable_list(L).
+%% Truncated lists could break some existing code.
+% printable_list(L, D) ->
+%     Len = ?CHARS * (D - 1),
+%     case printable_list1(L, Len) of
+%         all ->
+%             true;
+%         N when is_integer(N), Len - N >= D - 1 ->
+%             {L1, _} = lists:split(Len - N, L),
+%             {true, L1};
+%         N when is_integer(N) ->
+%             false
+%     end.
+
+printable_bin(Bin, D) when D >= 0, ?CHARS * D =< byte_size(Bin) ->
+    printable_bin(Bin, erlang:min(?CHARS * D, byte_size(Bin)), D);
+printable_bin(Bin, D) ->
+    printable_bin(Bin, byte_size(Bin), D).
+
+printable_bin(Bin, Len, D) ->
+    N = erlang:min(20, Len),
+    L = binary_to_list(Bin, 1, N),
+    case printable_list1(L, N) of
+        all when N =:= byte_size(Bin)  ->
+            L;
+        all when N =:= Len -> % N < byte_size(Bin)
+            {true, L};
+        all ->
+            case printable_bin1(Bin, 1 + N, Len - N) of
+                0 when byte_size(Bin) =:= Len ->
+                    binary_to_list(Bin);
+                NC when D > 0, Len - NC >= D ->
+                    {true, binary_to_list(Bin, 1, Len - NC)};
+                NC when is_integer(NC) ->
+                    false
+            end;
+        NC when is_integer(NC), D > 0, N - NC >= D ->
+            {true, binary_to_list(Bin, 1, N - NC)};
+        NC when is_integer(NC) ->
+            false
+    end.
+
+printable_bin1(_Bin, _Start, 0) ->
+    0;
+printable_bin1(Bin, Start, Len) ->
+    N = erlang:min(10000, Len),
+    L = binary_to_list(Bin, Start, Start + N - 1),
+    case printable_list1(L, N) of
+        all ->
+            printable_bin1(Bin, Start + N, Len - N);
+        NC when is_integer(NC) ->
+            Len - (N - NC)
+    end.
+
+%% -> all | integer() >=0. Adopted from io_lib.erl.
+% printable_list1([_ | _], 0) -> 0;
+printable_list1([C | Cs], N) when is_integer(C), C >= $\s, C =< $~ ->
+    printable_list1(Cs, N - 1);
+printable_list1([C | Cs], N) when is_integer(C), C >= $\240, C =< $\377 ->
+    printable_list1(Cs, N - 1);
+printable_list1([$\n | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([$\r | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([$\t | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([$\v | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([$\b | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([$\f | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([$\e | Cs], N) -> printable_list1(Cs, N - 1);
+printable_list1([], _) -> all;
+printable_list1(_, N) -> N.
+
+%% Throw 'no_good' if the indentation exceeds half the line length
+%% unless there is room for M characters on the line.
+
+cind({_S, Len}, Col, Ll, M, Ind, LD, W) when Len < Ll - Col - LD,
+                                             Len + W + LD =< M ->
+    Ind;
+cind({{list,L}, _Len}, Col, Ll, M, Ind, LD, W) ->
+    cind_list(L, Col + 1, Ll, M, Ind, LD, W + 1);
+cind({{tuple,true,L}, _Len}, Col, Ll, M, Ind, LD, W) ->
+    cind_tag_tuple(L, Col, Ll, M, Ind, LD, W + 1);
+cind({{tuple,false,L}, _Len}, Col, Ll, M, Ind, LD, W) ->
+    cind_list(L, Col + 1, Ll, M, Ind, LD, W + 1);
+cind({{record,[{_Name,NLen} | L]}, _Len}, Col, Ll, M, Ind, LD, W) ->
+    cind_record(L, NLen, Col, Ll, M, Ind, LD, W + NLen + 1);
+cind({{bin,_S}, _Len}, _Col, _Ll, _M, Ind, _LD, _W) ->
+    Ind;
+cind({_S, _Len}, _Col, _Ll, _M, Ind, _LD, _W) ->
+    Ind.
+
+cind_tag_tuple([{_Tag,Tlen} | L], Col, Ll, M, Ind, LD, W) ->
+    TagInd = Tlen + 2,
+    Tcol = Col + TagInd,
+    if
+        Ind > 0, TagInd > Ind ->
+            Col1 = Col + Ind,
+            if
+                M + Col1 =< Ll; Col1 =< Ll div 2 ->
+                    cind_tail(L, Col1, Tcol, Ll, M, Ind, LD, W + Tlen);
+                true ->
+                    throw(no_good)
+            end;
+        M + Tcol < Ll; Tcol < Ll div 2 ->
+            cind_list(L, Tcol, Ll, M, Ind, LD, W + Tlen + 1);
+        true ->
+            throw(no_good)
+    end.
+
+cind_record([F | Fs], Nlen, Col0, Ll, M, Ind, LD, W0) ->
+    Nind = Nlen + 1,
+    {Col, W} = cind_rec(Nind, Col0, Ll, M, Ind, W0),
+    FW = cind_field(F, Col, Ll, M, Ind, last_depth(Fs, LD), W),
+    cind_fields_tail(Fs, Col, Col + FW, Ll, M, Ind, LD, W + FW);
+cind_record(_, _Nlen, _Col, _Ll, _M, Ind, _LD, _W) ->
+    Ind.
+
+cind_fields_tail([{_, Len}=F | Fs], Col0, Col, Ll, M, Ind, LD, W) ->
+    LD1 = last_depth(Fs, LD),
+    ELen = 1 + Len,
+    if
+        LD1 =:= 0, ELen + 1 < Ll - Col, W + ELen + 1 =< M, ?ATM_FLD(F);
+        LD1 > 0, ELen < Ll - Col - LD1, W + ELen + LD1 =< M, ?ATM_FLD(F) ->
+            cind_fields_tail(Fs, Col0, Col + ELen, Ll, M, Ind, LD, W + ELen);
+        true ->
+            FW = cind_field(F, Col0, Ll, M, Ind, LD1, 0),
+            cind_fields_tail(Fs, Col0, Col + FW, Ll, M, Ind, LD, FW)
+    end;
+cind_fields_tail(_, _Col0, _Col, _Ll, _M, Ind, _LD, _W) ->
+    Ind.
+
+cind_field({{field, _N, _NL, _F}, Len}=Fl, Col, Ll, M, _Ind, LD, W) 
+         when Len < Ll - Col - LD, Len + W + LD =< M ->
+    if
+        ?ATM_FLD(Fl) ->
+            Len;
+        true ->
+            Ll
+    end;
+cind_field({{field, _Name, NameL, F}, _Len}, Col0, Ll, M, Ind, LD, W0) ->
+    {Col, W} = cind_rec(NameL, Col0, Ll, M, Ind, W0 + NameL),
+    cind(F, Col, Ll, M, Ind, LD, W),
+    Ll.
+
+cind_rec(RInd, Col0, Ll, M, Ind, W0) ->
+    Nl = (Ind > 0) and (RInd > Ind),
+    DCol = case Nl of
+               true -> Ind;
+               false -> RInd
+           end,
+    Col = Col0 + DCol,
+    if
+        M + Col =< Ll; Col =< Ll div 2 ->        
+            W = case Nl of
+                    true -> 0;
+                    false -> W0
+                end,
+            {Col, W};
+        true ->
+            throw(no_good)
+    end.
+
+cind_list({dots, _}, _Col0, _Ll, _M, Ind, _LD, _W) ->
+    Ind;
+cind_list([E | Es], Col0, Ll, M, Ind, LD, W) ->
+    WE = cind_element(E, Col0, Ll, M, Ind, last_depth(Es, LD), W),
+    cind_tail(Es, Col0, Col0 + WE, Ll, M, Ind, LD, W + WE).
+
+cind_tail([], _Col0, _Col, _Ll, _M, Ind, _LD, _W) ->
+    Ind;
+cind_tail([{_, Len}=E | Es], Col0, Col, Ll, M, Ind, LD, W) ->
+    LD1 = last_depth(Es, LD),
+    ELen = 1 + Len,
+    if 
+        LD1 =:= 0, ELen + 1 < Ll - Col, W + ELen + 1 =< M, ?ATM(E);
+        LD1 > 0, ELen < Ll - Col - LD1, W + ELen + LD1 =< M, ?ATM(E) ->
+            cind_tail(Es, Col0, Col + ELen, Ll, M, Ind, LD, W + ELen);
+        true -> 
+            WE = cind_element(E, Col0, Ll, M, Ind, LD1, 0),
+            cind_tail(Es, Col0, Col0 + WE, Ll, M, Ind, LD, WE)
+    end;
+cind_tail({dots, _}, _Col0, _Col, _Ll, _M, Ind, _LD, _W) ->
+    Ind;
+cind_tail({_, Len}=E, _Col0, Col, Ll, M, Ind, LD, W)
+                  when Len + 1 < Ll - Col - (LD + 1), 
+                       Len + 1 + W + (LD + 1) =< M, 
+                       ?ATM(E) ->
+    Ind;
+cind_tail(E, _Col0, Col, Ll, M, Ind, LD, _W) ->
+    cind(E, Col, Ll, M, Ind, LD + 1, 0).
+
+cind_element({_, Len}=E, Col, Ll, M, _Ind, LD, W)
+           when Len < Ll - Col - LD, Len + W + LD =< M, ?ATM(E) ->
+    Len;
+cind_element(E, Col, Ll, M, Ind, LD, W) ->
+    cind(E, Col, Ll, M, Ind, LD, W),
+    Ll.
+
+last_depth([_ | _], _LD) ->
+    0;
+last_depth(_, LD) ->
+    LD + 1.
+
+while_fail([], _F, V) ->
+    V;
+while_fail([A | As], F, V) ->
+    try F(A) catch _ -> while_fail(As, F, V) end.
+
+indent(N) when is_integer(N), N > 0 ->
+    chars($\s, N-1).
+
+indent(1, Ind) -> % Optimization of common case
+    [$\s | Ind];
+indent(4, Ind) -> % Optimization of common case
+    S2 = [$\s, $\s],
+    [S2, S2 | Ind];
+indent(N, Ind) when is_integer(N), N > 0 ->
+    [chars($\s, N) | Ind].
+
+%% A deep version of string:chars/2
+chars(_C, 0) ->
+    [];
+chars(C, 2) ->
+    [C, C];
+chars(C, 3) ->
+    [C, C, C];
+chars(C, N) when (N band 1) =:= 0 ->
+    S = chars(C, N bsr 1),
+    [S | S];
+chars(C, N) ->
+    S = chars(C, N bsr 1),
+    [C, S | S].