From b57e89092409193457aa2ad026c895d5559d428d Mon Sep 17 00:00:00 2001
From: Hans Bolinder <hasse@erlang.org>
Date: Mon, 15 May 2017 14:16:52 +0200
Subject: stdlib: Add io_lib:limit_term/2

The term returned by io_lib:limit_term(Term, Depth) should return
the same string if substituted for Term in
io_lib:format("~P", [Term, Depth]) or io_lib:format("~W", [Term, Depth]).
---
 lib/stdlib/src/io_lib.erl | 115 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 115 insertions(+)

(limited to 'lib/stdlib/src')

diff --git a/lib/stdlib/src/io_lib.erl b/lib/stdlib/src/io_lib.erl
index 5ed2f4d888..9d447418f8 100644
--- a/lib/stdlib/src/io_lib.erl
+++ b/lib/stdlib/src/io_lib.erl
@@ -84,6 +84,8 @@
 -export([write_unicode_string/1, write_unicode_char/1,
          deep_unicode_char_list/1]).
 
+-export([limit_term/2]).
+
 -export_type([chars/0, latin1_string/0, continuation/0,
               fread_error/0, fread_item/0, format_spec/0]).
 
@@ -911,3 +913,116 @@ binrev(L) ->
 
 binrev(L, T) ->
     list_to_binary(lists:reverse(L, T)).
+
+-spec limit_term(term(), non_neg_integer()) -> term().
+
+%% The intention is to mimic the depth limitation of io_lib:write()
+%% and io_lib_pretty:print(). The leaves ('...') should never be
+%% seen when printed with the same depth. Bitstrings are never
+%% truncated, which is OK as long as they are not sent to other nodes.
+limit_term(Term, Depth) ->
+    try test_limit(Term, Depth) of
+        ok -> Term
+    catch
+        throw:limit ->
+            limit(Term, Depth)
+    end.
+
+limit(_, 0) -> '...';
+limit([H|T]=L, D) ->
+    if
+	D =:= 1 -> '...';
+	true ->
+            case printable_list(L) of
+                true -> L;
+                false ->
+                    [limit(H, D-1)|limit_tail(T, D-1)]
+            end
+    end;
+limit(Term, D) when is_map(Term) ->
+    limit_map(Term, D);
+limit({}=T, _D) -> T;
+limit(T, D) when is_tuple(T) ->
+    if
+	D =:= 1 -> '...';
+	true ->
+            list_to_tuple([limit(element(1, T), D-1)|
+                           limit_tail(tl(tuple_to_list(T)), D-1)])
+    end;
+limit(<<_/bitstring>>=Term, D) -> limit_bitstring(Term, D);
+limit(Term, _D) -> Term.
+
+limit_tail([], _D) -> [];
+limit_tail(_, 1) -> ['...'];
+limit_tail([H|T], D) ->
+    [limit(H, D-1)|limit_tail(T, D-1)];
+limit_tail(Other, D) ->
+    limit(Other, D-1).
+
+%% Cannot limit maps properly since there is no guarantee that
+%% maps:from_list() creates a map with the same internal ordering of
+%% the selected associations as in Map.
+limit_map(Map, D) ->
+    maps:from_list(erts_internal:maps_to_list(Map, D)).
+%%     maps:from_list(limit_map_body(erts_internal:maps_to_list(Map, D), D)).
+
+%% limit_map_body(_, 0) -> [{'...', '...'}];
+%% limit_map_body([], _) -> [];
+%% limit_map_body([{K,V}], D) -> [limit_map_assoc(K, V, D)];
+%% limit_map_body([{K,V}|KVs], D) ->
+%%     [limit_map_assoc(K, V, D) | limit_map_body(KVs, D-1)].
+
+%% limit_map_assoc(K, V, D) ->
+%%     {limit(K, D-1), limit(V, D-1)}.
+
+limit_bitstring(B, _D) -> B. %% Keeps all printable binaries.
+
+test_limit(_, 0) -> throw(limit);
+test_limit([H|T]=L, D) when is_integer(D) ->
+    if
+	D =:= 1 -> throw(limit);
+	true ->
+            case printable_list(L) of
+                true -> ok;
+                false ->
+                    test_limit(H, D-1),
+                    test_limit_tail(T, D-1)
+            end
+    end;
+test_limit(Term, D) when is_map(Term) ->
+    test_limit_map(Term, D);
+test_limit({}, _D) -> ok;
+test_limit(T, D) when is_tuple(T) ->
+    test_limit_tuple(T, 1, tuple_size(T), D);
+test_limit(<<_/bitstring>>=Term, D) -> test_limit_bitstring(Term, D);
+test_limit(_Term, _D) -> ok.
+
+test_limit_tail([], _D) -> ok;
+test_limit_tail(_, 1) -> throw(limit);
+test_limit_tail([H|T], D) ->
+    test_limit(H, D-1),
+    test_limit_tail(T, D-1);
+test_limit_tail(Other, D) ->
+    test_limit(Other, D-1).
+
+test_limit_tuple(_T, I, Sz, _D) when I > Sz -> ok;
+test_limit_tuple(_, _, _, 1) -> throw(limit);
+test_limit_tuple(T, I, Sz, D) ->
+    test_limit(element(I, T), D-1),
+    test_limit_tuple(T, I+1, Sz, D-1).
+
+test_limit_map(_Map, _D) -> ok.
+%%     test_limit_map_body(erts_internal:maps_to_list(Map, D), D).
+
+%% test_limit_map_body(_, 0) -> throw(limit);
+%% test_limit_map_body([], _) -> ok;
+%% test_limit_map_body([{K,V}], D) -> test_limit_map_assoc(K, V, D);
+%% test_limit_map_body([{K,V}|KVs], D) ->
+%%     test_limit_map_assoc(K, V, D),
+%%     test_limit_map_body(KVs, D-1).
+
+%% test_limit_map_assoc(K, V, D) ->
+%%     test_limit(K, D-1),
+%%     test_limit(V, D-1).
+
+test_limit_bitstring(_, _) -> ok.
-- 
cgit v1.2.3