aboutsummaryrefslogtreecommitdiffstats
path: root/erts/emulator/test/trace_local_SUITE.erl
diff options
context:
space:
mode:
authorErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
committerErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
commit84adefa331c4159d432d22840663c38f155cd4c1 (patch)
treebff9a9c66adda4df2106dfd0e5c053ab182a12bd /erts/emulator/test/trace_local_SUITE.erl
downloadotp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz
otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2
otp-84adefa331c4159d432d22840663c38f155cd4c1.zip
The R13B03 release.OTP_R13B03
Diffstat (limited to 'erts/emulator/test/trace_local_SUITE.erl')
-rw-r--r--erts/emulator/test/trace_local_SUITE.erl1259
1 files changed, 1259 insertions, 0 deletions
diff --git a/erts/emulator/test/trace_local_SUITE.erl b/erts/emulator/test/trace_local_SUITE.erl
new file mode 100644
index 0000000000..24005774ba
--- /dev/null
+++ b/erts/emulator/test/trace_local_SUITE.erl
@@ -0,0 +1,1259 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2000-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(trace_local_SUITE).
+-compile({nowarn_deprecated_function, {erlang,hash,2}}).
+
+-export([basic_test/0, bit_syntax_test/0, return_test/0,
+ on_and_off_test/0, stack_grow_test/0,
+ info_test/0, delete_test/1, exception_test/1,
+ not_run/1]).
+
+-export([exported/1, exported_wrap/1, loop/4, apply_slave_async/5,
+ match/2, clause/2, id/1, undef/1, lists_reverse/2]).
+
+%%
+%% Define to run outside of test server
+%%
+%% (rotten feature)
+%%
+%%-define(STANDALONE,1).
+
+%%
+%% Define for debug output
+%%
+%%-define(debug,1).
+
+-ifdef(STANDALONE).
+-define(config(A,B),config(A,B)).
+-export([config/2]).
+-define(DEFAULT_RECEIVE_TIMEOUT, 1000).
+-else.
+-include("test_server.hrl").
+-define(DEFAULT_RECEIVE_TIMEOUT, infinity).
+-endif.
+
+-ifdef(debug).
+-ifdef(STANDALONE).
+-define(line, erlang:display({?MODULE,?LINE}), ).
+-endif.
+-define(dbgformat(A,B),io:format(A,B)).
+-else.
+-ifdef(STANDALONE).
+-define(line, noop, ).
+-endif.
+-define(dbgformat(A,B),noop).
+-endif.
+
+-ifdef(STANDALONE).
+config(priv_dir,_) ->
+ ".".
+-else.
+
+%%% When run in test server %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-export([all/1, basic/1, bit_syntax/1,
+ return/1, on_and_off/1, stack_grow/1,info/1, delete/1,
+ exception/1, exception_apply/1,
+ exception_function/1, exception_apply_function/1,
+ exception_nocatch/1, exception_nocatch_apply/1,
+ exception_nocatch_function/1, exception_nocatch_apply_function/1,
+ exception_meta/1, exception_meta_apply/1,
+ exception_meta_function/1, exception_meta_apply_function/1,
+ exception_meta_nocatch/1, exception_meta_nocatch_apply/1,
+ exception_meta_nocatch_function/1,
+ exception_meta_nocatch_apply_function/1,
+ init_per_testcase/2, fin_per_testcase/2]).
+init_per_testcase(_Case, Config) ->
+ ?line Dog=test_server:timetrap(test_server:minutes(2)),
+ [{watchdog, Dog}|Config].
+
+fin_per_testcase(_Case, Config) ->
+ shutdown(),
+ Dog=?config(watchdog, Config),
+ test_server:timetrap_cancel(Dog),
+ ok.
+all(doc) ->
+ ["Test tracing of local function calls and return traces."];
+all(suite) ->
+ case test_server:is_native(?MODULE) of
+ true -> [not_run];
+ false -> [basic, bit_syntax, return, on_and_off, stack_grow, info, delete,
+ exception, exception_apply,
+ exception_function, exception_apply_function,
+ exception_nocatch, exception_nocatch_apply,
+ exception_nocatch_function,
+ exception_nocatch_apply_function,
+ exception_meta, exception_meta_apply,
+ exception_meta_function, exception_meta_apply_function,
+ exception_meta_nocatch, exception_meta_nocatch_apply,
+ exception_meta_nocatch_function,
+ exception_meta_nocatch_apply_function]
+ end.
+
+not_run(Config) when is_list(Config) ->
+ {skipped,"Native code"}.
+
+basic(doc) ->
+ ["Tests basic local call-trace"];
+basic(Config) when is_list(Config) ->
+ basic_test().
+
+bit_syntax(doc) ->
+ "OTP-7399: Make sure that code that uses the optimized bit syntax matching "
+ "can be traced without crashing the emulator.";
+bit_syntax(Config) when is_list(Config) ->
+ bit_syntax_test().
+
+return(doc) ->
+ ["Tests the different types of return trace"];
+return(Config) when is_list(Config) ->
+ return_test().
+
+on_and_off(doc) ->
+ ["Tests turning trace parameters on and off, "
+ "both for trace and trace_pattern"];
+on_and_off(Config) when is_list(Config) ->
+ on_and_off_test().
+
+stack_grow(doc) ->
+ ["Tests the stack growth during return traces"];
+stack_grow(Config) when is_list(Config) ->
+ stack_grow_test().
+
+info(doc) ->
+ ["Tests the trace_info BIF"];
+info(Config) when is_list(Config) ->
+ info_test().
+
+delete(doc) ->
+ ["Tests putting trace on deleted modules"];
+delete(Config) when is_list(Config) ->
+ delete_test(Config).
+
+exception(doc) ->
+ ["Tests exception_trace"];
+exception(Config) when is_list(Config) ->
+ exception_test([]).
+
+exception_apply(doc) ->
+ ["Tests exception_trace"];
+exception_apply(Config) when is_list(Config) ->
+ exception_test([apply]).
+
+exception_function(doc) ->
+ ["Tests exception_trace"];
+exception_function(Config) when is_list(Config) ->
+ exception_test([function]).
+
+exception_apply_function(doc) ->
+ ["Tests exception_trace"];
+exception_apply_function(Config) when is_list(Config) ->
+ exception_test([apply,function]).
+
+exception_nocatch(doc) ->
+ ["Tests exception_trace"];
+exception_nocatch(Config) when is_list(Config) ->
+ exception_test([nocatch]).
+
+exception_nocatch_apply(doc) ->
+ ["Tests exception_trace"];
+exception_nocatch_apply(Config) when is_list(Config) ->
+ exception_test([nocatch,apply]).
+
+exception_nocatch_function(doc) ->
+ ["Tests exception_trace"];
+exception_nocatch_function(Config) when is_list(Config) ->
+ exception_test([nocatch,function]).
+
+exception_nocatch_apply_function(doc) ->
+ ["Tests exception_trace"];
+exception_nocatch_apply_function(Config) when is_list(Config) ->
+ exception_test([nocatch,apply,function]).
+
+exception_meta(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta(Config) when is_list(Config) ->
+ exception_test([meta]).
+
+exception_meta_apply(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_apply(Config) when is_list(Config) ->
+ exception_test([meta,apply]).
+
+exception_meta_function(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_function(Config) when is_list(Config) ->
+ exception_test([meta,function]).
+
+exception_meta_apply_function(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_apply_function(Config) when is_list(Config) ->
+ exception_test([meta,apply,function]).
+
+exception_meta_nocatch(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_nocatch(Config) when is_list(Config) ->
+ exception_test([meta,nocatch]).
+
+exception_meta_nocatch_apply(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_nocatch_apply(Config) when is_list(Config) ->
+ exception_test([meta,nocatch,apply]).
+
+exception_meta_nocatch_function(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_nocatch_function(Config) when is_list(Config) ->
+ exception_test([meta,nocatch,function]).
+
+exception_meta_nocatch_apply_function(doc) ->
+ ["Tests meta exception_trace"];
+exception_meta_nocatch_apply_function(Config) when is_list(Config) ->
+ exception_test([meta,nocatch,apply,function]).
+
+-endif.
+
+
+
+%%% Message patterns and expect functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-define(pCT(P,M,F,A), {trace, P,call,{M,F,A}}).
+-define(pCTT(P,M,F,A), {trace_ts,P,call,{M,F,A},{_,_,_}}).
+-define(pRF(P,M,F,A,V), {trace, P,return_from,{M,F,A},V}).
+-define(pRFT(P,M,F,A,V),{trace_ts,P,return_from,{M,F,A},V,{_,_,_}}).
+-define(pEF(P,M,F,A,V), {trace, P,exception_from,{M,F,A},V}).
+-define(pEFT(P,M,F,A,V),{trace_ts,P,exception_from,{M,F,A},V,{_,_,_}}).
+-define(pRT(P,M,F,A), {trace, P,return_to,{M,F,A}}).
+-define(pRTT(P,M,F,A), {trace_ts,P,return_to,{M,F,A},{_,_,_}}).
+
+-define(CT(M,F,A), ?pCT(_,M,F,A) = receive_next()).
+-define(CTT(M,F,A), ?pCTT(_,M,F,A) = receive_next()).
+-define(RF(M,F,A,V), ?pRF(_,M,F,A,V) = receive_next()).
+-define(RFT(M,F,A,V), ?pRFT(_,M,F,A,V) = receive_next()).
+-define(EF(M,F,A,V), ?pEF(_,M,F,A,V) = receive_next()).
+-define(EFT(M,F,A,V), ?pEFT(_,M,F,A,V) = receive_next()).
+-define(RT(M,F,A), ?pRT(_,M,F,A) = receive_next()).
+-define(RTT(M,F,A), ?pRTT(_,M,F,A) = receive_next()).
+-define(NM, receive_no_next(100)).
+
+expect() ->
+ {Pid,_} = get(slave),
+ expect_receive(Pid).
+
+expect(Msg) ->
+ {Pid,_} = get(slave),
+ expect_pid(Pid, Msg).
+
+
+
+expect_pid(_Pid, []) ->
+ ok;
+expect_pid(Pid, [Line|T]) when is_integer(Line) ->
+ put(test_server_loc, {?MODULE,Line}),
+ expect_pid(Pid, T);
+expect_pid(Pid, [true|[_|_]=T]) ->
+ expect_pid(Pid, T);
+expect_pid(Pid, [false|[_|T]]) ->
+ expect_pid(Pid, T);
+expect_pid(Pid, [H|T]) ->
+ expect_pid(Pid, H),
+ expect_pid(Pid, T);
+expect_pid(Pid, Msg) when is_tuple(Msg) ->
+ same(Msg, expect_receive(Pid));
+expect_pid(Pid, Fun) when is_function(Fun, 1) ->
+ case Fun(expect_receive(Pid)) of
+ next ->
+ expect_pid(Pid, Fun);
+ done ->
+ ok;
+ Other ->
+ expect_pid(Pid, Other)
+ end.
+
+expect_receive(Pid) when is_pid(Pid) ->
+ receive
+ Msg when is_tuple(Msg),
+ element(1, Msg) == trace,
+ element(2, Msg) =/= Pid;
+ %%
+ is_tuple(Msg),
+ element(1, Msg) == trace_ts,
+ element(2, Msg) =/= Pid ->
+ expect_receive(Pid);
+ Msg ->
+ expect_msg(Pid, Msg)
+ after 100 ->
+ {nm}
+ end.
+
+expect_msg(P, ?pCT(P,M,F,Args)) -> {ct,{M,F},Args};
+expect_msg(P, ?pCTT(P,M,F,Args)) -> {ctt,{M,F},Args};
+expect_msg(P, ?pRF(P,M,F,Arity,V)) -> {rf,{M,F,Arity},V};
+expect_msg(P, ?pRFT(P,M,F,Arity,V)) -> {rft,{M,F,Arity},V};
+expect_msg(P, ?pEF(P,M,F,Arity,V)) -> {ef,{M,F,Arity},V};
+expect_msg(P, ?pEFT(P,M,F,Arity,V)) -> {eft,{M,F,Arity},V};
+expect_msg(P, ?pRT(P,M,F,Arity)) -> {rt,{M,F,Arity}};
+expect_msg(P, ?pRTT(P,M,F,Arity)) -> {rtt,{M,F,Arity}};
+expect_msg(P, Msg) when is_tuple(Msg) ->
+ case tuple_to_list(Msg) of
+ [trace,P|T] ->
+ list_to_tuple([trace|T]);
+ [trace_ts,P|[_|_]=T] ->
+ list_to_tuple([trace_ts|reverse(tl(reverse(T)))]);
+ _ ->
+ Msg
+ end.
+
+same(A, B) ->
+ case [A|B] of
+ [X|X] ->
+ ok
+ end.
+
+
+
+%%% tests %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+basic_test() ->
+ ?line setup([call]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[],[local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported,[1]),
+ ?line ?CT(?MODULE,local,[1]),
+ ?line ?CT(?MODULE,local2,[1]),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[],[]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line [1,1,1,1] = lambda_slave(fun() ->
+ exported_wrap(1)
+ end),
+ ?line ?NM,
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[],[local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line [1,1,1,1] = lambda_slave(fun() ->
+ exported_wrap(1)
+ end),
+ ?line ?CT(?MODULE,_,_), %% The fun
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported,[1]),
+ ?line ?CT(?MODULE,local,[1]),
+ ?line ?CT(?MODULE,local2,[1]),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},false,[local]),
+ ?line shutdown(),
+ ?line ?NM,
+ ok.
+
+%% OTP-7399.
+bit_syntax_test() ->
+ ?line setup([call]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[],[local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+
+ ?line lambda_slave(fun() ->
+ 6 = bs_sum_a(<<1,2,3>>, 0),
+ 10 = bs_sum_b(0, <<1,2,3,4>>),
+ 26 = bs_sum_c(<<3:4,5:4,7:4,11:4>>, 0)
+ end),
+ ?line ?CT(?MODULE,_,[]), %Ignore call to the fun.
+
+ ?line ?CT(?MODULE,bs_sum_a,[<<1,2,3>>,0]),
+ ?line ?CT(?MODULE,bs_sum_a,[<<2,3>>,1]),
+ ?line ?CT(?MODULE,bs_sum_a,[<<3>>,3]),
+ ?line ?CT(?MODULE,bs_sum_a,[<<>>,6]),
+
+ ?line ?CT(?MODULE,bs_sum_b,[0,<<1,2,3,4>>]),
+ ?line ?CT(?MODULE,bs_sum_b,[1,<<2,3,4>>]),
+ ?line ?CT(?MODULE,bs_sum_b,[3,<<3,4>>]),
+ ?line ?CT(?MODULE,bs_sum_b,[6,<<4>>]),
+ ?line ?CT(?MODULE,bs_sum_b,[10,<<>>]),
+
+ ?line ?CT(?MODULE,bs_sum_c,[<<3:4,5:4,7:4,11:4>>, 0]),
+ ?line ?CT(?MODULE,bs_sum_c,[<<5:4,7:4,11:4>>, 3]),
+ ?line ?CT(?MODULE,bs_sum_c,[<<7:4,11:4>>, 8]),
+ ?line ?CT(?MODULE,bs_sum_c,[<<11:4>>, 15]),
+ ?line ?CT(?MODULE,bs_sum_c,[<<>>, 26]),
+
+ ?line erlang:trace_pattern({?MODULE,'_','_'},false,[local]),
+ ?line shutdown(),
+ ?line ?NM,
+
+ ok.
+
+bs_sum_a(<<H,T/binary>>, Acc) -> bs_sum_a(T, H+Acc);
+bs_sum_a(<<>>, Acc) -> Acc.
+
+bs_sum_b(Acc, <<H,T/binary>>) -> bs_sum_b(H+Acc, T);
+bs_sum_b(Acc, <<>>) -> Acc.
+
+bs_sum_c(<<H:4,T/bits>>, Acc) -> bs_sum_c(T, H+Acc);
+bs_sum_c(<<>>, Acc) -> Acc.
+
+return_test() ->
+ ?line setup([call]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[{'_',[],[{return_trace}]}],
+ [local]),
+ ?line erlang:trace_pattern({erlang,hash,'_'},[{'_',[],[{return_trace}]}],
+ [local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported,[1]),
+ ?line ?CT(?MODULE,local,[1]),
+ ?line ?CT(?MODULE,local2,[1]),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line ?RF(erlang,hash,2,1),
+ ?line ?RF(?MODULE,local_tail,1,[1,1]),
+ ?line ?RF(?MODULE,local2,1,[1,1]),
+ ?line ?RF(?MODULE,local,1,[1,1,1]),
+ ?line ?RF(?MODULE,exported,1,[1,1,1,1]),
+ ?line ?RF(?MODULE,exported_wrap,1,[1,1,1,1]),
+ ?line shutdown(),
+ ?line setup([call,return_to]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[],
+ [local]),
+ ?line erlang:trace_pattern({erlang,hash,'_'},[],
+ [local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported,[1]),
+ ?line ?CT(?MODULE,local,[1]),
+ ?line ?CT(?MODULE,local2,[1]),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line ?RT(?MODULE,local_tail,1),
+ ?line ?RT(?MODULE,local,1),
+ ?line ?RT(?MODULE,exported,1),
+ ?line ?RT(?MODULE,slave,2),
+ ?line shutdown(),
+ ?line setup([call,return_to]),
+ ?line erlang:trace_pattern({?MODULE,'_','_'},[{'_',[],[{return_trace}]}],
+ [local]),
+ ?line erlang:trace_pattern({erlang,hash,'_'},[{'_',[],[{return_trace}]}],
+ [local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported,[1]),
+ ?line ?CT(?MODULE,local,[1]),
+ ?line ?CT(?MODULE,local2,[1]),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line ?RF(erlang,hash,2,1),
+ ?line ?RT(?MODULE,local_tail,1),
+ ?line ?RF(?MODULE,local_tail,1,[1,1]),
+ ?line ?RF(?MODULE,local2,1,[1,1]),
+ ?line ?RT(?MODULE,local,1),
+ ?line ?RF(?MODULE,local,1,[1,1,1]),
+ ?line ?RT(?MODULE,exported,1),
+ ?line ?RF(?MODULE,exported,1,[1,1,1,1]),
+ ?line ?RF(?MODULE,exported_wrap,1,[1,1,1,1]),
+ ?line ?RT(?MODULE,slave,2),
+ ?line shutdown(),
+ ?line ?NM,
+ ok.
+
+on_and_off_test() ->
+ ?line Pid = setup([call]),
+ ?line 1 = erlang:trace_pattern({?MODULE,local_tail,1},[],[local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line LocalTail = fun() ->
+ local_tail(1)
+ end,
+ ?line [1,1] = lambda_slave(LocalTail),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line erlang:trace(Pid,true,[return_to]),
+ ?line [1,1] = lambda_slave(LocalTail),
+ ?line ?CT(?MODULE,local_tail,[1]),
+ ?line ?RT(?MODULE,_,_),
+ ?line 0 = erlang:trace_pattern({?MODULE,local_tail,1},[],[global]),
+ ?line [1,1] = lambda_slave(LocalTail),
+ ?line ?NM,
+ ?line 1 = erlang:trace_pattern({?MODULE,exported_wrap,1},[],[global]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line 1 = erlang:trace_pattern({?MODULE,exported_wrap,1},[],[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?RT(?MODULE,slave,2),
+ ?line 1 = erlang:trace_pattern({erlang,hash,2},[],[local]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line ?RT(?MODULE,local_tail,1),
+ ?line ?RT(?MODULE,slave,2),
+ ?line erlang:trace(Pid,true,[timestamp]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CTT(?MODULE,exported_wrap,[1]),
+ ?line ?CTT(erlang,hash,[1,1]),
+ ?line ?RTT(?MODULE,local_tail,1),
+ ?line ?RTT(?MODULE,slave,2),
+ ?line erlang:trace(Pid,false,[return_to,timestamp]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line erlang:trace(Pid,true,[return_to]),
+ ?line 1 = erlang:trace_pattern({erlang,hash,2},[],[]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line ?RT(?MODULE,slave,2),
+ ?line 1 = erlang:trace_pattern({?MODULE,exported_wrap,1},[],[]),
+ ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+ ?line ?CT(?MODULE,exported_wrap,[1]),
+ ?line ?CT(erlang,hash,[1,1]),
+ ?line shutdown(),
+ ?line erlang:trace_pattern({'_','_','_'},false,[local]),
+ ?line N = erlang:trace_pattern({erlang,'_','_'},true,[local]),
+ ?line case erlang:trace_pattern({erlang,'_','_'},false,[local]) of
+ N ->
+ ok;
+ Else ->
+ exit({number_mismatch, {expected, N}, {got, Else}})
+ end,
+ ?line case erlang:trace_pattern({erlang,'_','_'},false,[local]) of
+ N ->
+ ok;
+ Else2 ->
+ exit({number_mismatch, {expected, N}, {got, Else2}})
+ end,
+ ?line M = erlang:trace_pattern({erlang,'_','_'},true,[]),
+ ?line case erlang:trace_pattern({erlang,'_','_'},false,[]) of
+ M ->
+ ok;
+ Else3 ->
+ exit({number_mismatch, {expected, N}, {got, Else3}})
+ end,
+ ?line case erlang:trace_pattern({erlang,'_','_'},false,[]) of
+ M ->
+ ok;
+ Else4 ->
+ exit({number_mismatch, {expected, N}, {got, Else4}})
+ end,
+ ?line ?NM,
+ ok.
+
+
+stack_grow_test() ->
+ ?line setup([call,return_to]),
+ ?line 1 = erlang:trace_pattern({?MODULE,loop,4},
+ [{'_',[],[{return_trace}]}],[local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line Num = 1 bsl 15,
+ ?line Fun =
+ fun(_F,0) -> ok;
+ (F,N) ->
+ receive _A ->
+ receive _B ->
+ receive _C ->
+ F(F,N-1)
+ end
+ end
+ end
+ end,
+ ?line apply_slave_async(?MODULE,loop,[{hej,hopp},[a,b,c],4.5,Num]),
+ ?line Fun(Fun,Num + 1),
+ ?line ?NM,
+ ok.
+
+
+info_test() ->
+ ?line Flags1 = lists:sort([call,return_to]),
+ ?line Pid = setup(Flags1),
+ ?line Prog = [{['$1'],[{is_integer,'$1'}],[{message, false}]},
+ {'_',[],[]}],
+ ?line erlang:trace_pattern({?MODULE,exported_wrap,1},Prog,[local]),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+ ?line Self = self(),
+ ?line {flags,L} = erlang:trace_info(Pid,flags),
+ ?line case lists:sort(L) of
+ Flags1 ->
+ ok;
+ Wrong1 ->
+ exit({bad_result, {erlang,trace_info,[Pid,flags]},
+ {expected, Flags1}, {got, Wrong1}})
+ end,
+ ?line {tracer,Tracer} = erlang:trace_info(Pid,tracer),
+ ?line case Tracer of
+ Self ->
+ ok;
+ Wrong2 ->
+ exit({bad_result, {erlang,trace_info,[Pid,tracer]},
+ {expected, Self}, {got, Wrong2}})
+ end,
+ ?line {traced,local} = erlang:trace_info({?MODULE,exported_wrap,1},traced),
+ ?line {match_spec, MS} =
+ erlang:trace_info({?MODULE,exported_wrap,1},match_spec),
+ ?line case MS of
+ Prog ->
+ ok;
+ Wrong3 ->
+ exit({bad_result, {erlang,trace_info,
+ [{?MODULE,exported_wrap,1},
+ match_spec]},
+ {expected, Prog}, {got, Wrong3}})
+ end,
+ ?line erlang:garbage_collect(self()),
+ ?line receive
+ after 1 ->
+ ok
+ end,
+ ?line io:format("~p~n",[MS]),
+ ?line {match_spec,MS2} =
+ erlang:trace_info({?MODULE,exported_wrap,1},match_spec),
+ ?line io:format("~p~n",[MS2]),
+ ?line erlang:trace_pattern({?MODULE,exported_wrap,1},[],[]),
+ ?line {traced,global} =
+ erlang:trace_info({?MODULE,exported_wrap,1},traced),
+ ?line {match_spec,[]} =
+ erlang:trace_info({?MODULE,exported_wrap,1},match_spec),
+ ?line {traced,undefined} =
+ erlang:trace_info({?MODULE,exported_wrap,2},traced),
+ ?line {match_spec,undefined} =
+ erlang:trace_info({?MODULE,exported_wrap,2},match_spec),
+ ?line {traced,false} = erlang:trace_info({?MODULE,exported,1},traced),
+ ?line {match_spec,false} =
+ erlang:trace_info({?MODULE,exported,1},match_spec),
+ ?line shutdown(),
+ ok.
+
+delete_test(Config) ->
+ ?line Priv = ?config(priv_dir, Config),
+ ?line Data = ?config(data_dir, Config),
+ ?line File = filename:join(Data, "trace_local_dummy"),
+ ?line {ok,trace_local_dummy} = c:c(File, [{outdir,Priv}]),
+ ?line code:purge(trace_local_dummy),
+ ?line code:delete(trace_local_dummy),
+ ?line 0 = erlang:trace_pattern({trace_local_dummy,'_','_'},true,[local]),
+ ?line ?NM,
+ ok.
+
+
+
+%%% exception_test %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+exception_test(Opts) ->
+ ?line {ProcFlags,PatFlags} =
+ case proplists:get_bool(meta, Opts) of
+ true -> {[timestamp],[meta]};
+ false -> {[call,return_to,timestamp],[local]}
+ end,
+ ?line case proplists:get_bool(nocatch, Opts) of
+ false ->
+ ?line Exceptions = exceptions(),
+ ?line exception_test_setup(ProcFlags, PatFlags),
+ ?line lists:foreach(
+ fun ({Func,Args}) ->
+ ?line exception_test(Opts, Func, Args)
+ end,
+ Exceptions),
+ ?line shutdown();
+ true ->
+ ?line Exceptions = exceptions(),
+ ?line lists:foreach(
+ fun ({Func,Args}) ->
+ ?line exception_test_setup(
+ [procs|ProcFlags],
+ PatFlags),
+ ?line exception_test(Opts, Func, Args),
+ ?line shutdown()
+ end,
+ Exceptions)
+ end,
+ ?line ok.
+
+exceptions() ->
+ ?line Ref = make_ref(),
+ ?line N = case os:type() of
+ vxworks ->
+ ?line 2000; % Limited memory on themachines, not actually
+ % VxWorks' fault /PaN
+ _ ->
+ ?line 200000
+ end,
+ ?line LiL = seq(1, N-1, N), % Long Improper List
+ ?line LL = seq(1, N, []), % Long List
+ [{{erlang,exit}, [done]},
+ {{erlang,error}, [1.0]},
+ {{erlang,error}, [Ref,[]]},
+ {{erlang,throw}, [4711]},
+ {{erlang,'++'}, [[17],seventeen]},
+ {{erlang,'++'}, [Ref,[125.125]]},
+ {{?MODULE,match}, [ref,Ref]},
+ {{?MODULE,match}, [Ref,Ref]},
+ {{?MODULE,clause}, [ref,Ref]},
+ {{?MODULE,clause}, [Ref,Ref]},
+ {{?MODULE,id}, [4711.0]},
+ {{?MODULE,undef}, [[Ref|Ref]]},
+ {{?MODULE,lists_reverse}, [LiL,[]]},
+ {{?MODULE,lists_reverse}, [LL,[]]}].
+
+exception_test_setup(ProcFlags, PatFlags) ->
+ ?line Pid = setup(ProcFlags),
+ ?line io:format("=== exception_test_setup(~p, ~p): ~p~n",
+ [ProcFlags,PatFlags,Pid]),
+ ?line Mprog = [{'_',[],[{exception_trace}]}],
+ ?line erlang:trace_pattern({?MODULE,'_','_'}, Mprog, PatFlags),
+ ?line erlang:trace_pattern({?MODULE,slave,'_'},false,PatFlags),
+ ?line [1,1,1,1,1] =
+ [erlang:trace_pattern({erlang,F,A}, Mprog, PatFlags)
+ || {F,A} <- [{exit,1},{error,1},{error,2},{throw,1},{'++',2}]],
+ ?line 1 = erlang:trace_pattern({lists,reverse,2}, Mprog, PatFlags),
+ ?line ok.
+
+-record(exc_opts, {nocatch=false, meta=false}).
+
+exception_test(Opts, Func0, Args0) ->
+ ?line io:format("=== exception_test(~p, ~p, ~p)~n",
+ [Opts,Func0,abbr(Args0)]),
+ ?line Apply = proplists:get_bool(apply, Opts),
+ ?line Function = proplists:get_bool(function, Opts),
+ ?line Nocatch = proplists:get_bool(nocatch, Opts),
+ ?line Meta = proplists:get_bool(meta, Opts),
+ ?line ExcOpts = #exc_opts{nocatch=Nocatch,meta=Meta},
+
+ %% Func0 and Args0 are for the innermost call, now we will
+ %% wrap them in wrappers...
+ ?line {Func1,Args1} =
+ case Function of
+ true -> {fun exc/2,[Func0,Args0]};
+ false -> {Func0,Args0}
+ end,
+
+ ?line {Func,Args} =
+ case Apply of
+ true -> {{erlang,apply},[Func1,Args1]};
+ false -> {Func1,Args1}
+ end,
+
+ ?line R1 = exc_slave(ExcOpts, Func, Args),
+ ?line Stack2 = [{?MODULE,exc_top,3},{?MODULE,slave,2}],
+ ?line Stack3 = [{?MODULE,exc,2}|Stack2],
+ ?line Rs =
+ case x_exc_top(ExcOpts, Func, Args) of % Emulation
+ {crash,{Reason,Stack}}=R when is_list(Stack) ->
+ [R,
+ {crash,{Reason,Stack++Stack2}},
+ {crash,{Reason,Stack++Stack3}}];
+ R ->
+ [R]
+ end,
+ ?line exception_validate(R1, Rs),
+ ?line case R1 of
+ {crash,Crash} ->
+ ?line expect({trace_ts,exit,Crash});
+ _ when not Meta ->
+ ?line expect({rtt,{?MODULE,slave,2}});
+ _ ->
+ ok
+ end,
+ ?line expect({nm}).
+
+exception_validate(R1, [R2|Rs]) ->
+ case [R1|R2] of
+ [R|R] ->
+ ok;
+ [{crash,{badarg,[{lists,reverse,[L1a,L1b]}|T]}}|
+ {crash,{badarg,[{lists,reverse,[L2a,L2b]}|T]}}] ->
+ same({crash,{badarg,[{lists,reverse,
+ [lists:reverse(L1b, L1a),[]]}|T]}},
+ {crash,{badarg,[{lists,reverse,
+ [lists:reverse(L2b, L2a),[]]}|T]}});
+ _ when is_list(Rs), Rs =/= [] ->
+ exception_validate(R1, Rs)
+ end.
+
+
+
+%%% Tracee target functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+loop(D1,D2,D3,0) ->
+ io:format("~p~n",[[D1,D2,D3]]),
+ 0;
+loop(D1,D2,D3,N) ->
+ max(N,loop(D1,D2,D3,N-1)).
+
+max(A, B) when A > B -> A;
+max(_, B) -> B.
+
+exported_wrap(Val) ->
+ exported(Val).
+
+exported(Val) ->
+ [Val | local(Val)]. %% Non tail recursive local call
+
+local(Val) ->
+ [Val | local2(Val)]. %% Non tail recursive local call
+
+local2(Val) ->
+ local_tail(Val). %% Tail recursive call
+
+local_tail(Val) ->
+ [Val , erlang:hash(1,1)].
+
+
+
+%%% exc_slave/3 tracee target functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+exc_top(ExcOpts, Func, Args) ->
+ case ExcOpts#exc_opts.nocatch of
+ false ->
+ try exc_jump(Func, Args) of
+ Value ->
+ {value,Value}
+ catch
+ Class:Reason ->
+ {Class,Reason}
+ end;
+ true ->
+ {value,exc_jump(Func, Args)}
+ end.
+
+%% x_* functions emulate the non-x_* ones.
+%% x_* functions below x_exc_top
+%% return {value,Value} or {Class,Reason}.
+%% The only possible place for exception
+%% is below exc/2.
+x_exc_top(ExcOpts, Func, Args) ->
+ ?line Rtt = not ExcOpts#exc_opts.meta,
+ ?line expect({ctt,{?MODULE,exc_top},[ExcOpts,Func,Args]}),
+ ?line case x_exc_jump(ExcOpts, Func, Args) of
+ Result when not ExcOpts#exc_opts.nocatch ->
+ ?line expect([Rtt,{rtt,{?MODULE,exc_top,3}},
+ ?LINE,{rft,{?MODULE,exc_top,3},Result}]),
+ ?line Result;
+ {value,_}=Result ->
+
+ ?line expect([Rtt,{rtt,{?MODULE,exc_top,3}},
+ ?LINE,{rft,{?MODULE,exc_top,3},Result}]),
+ ?line Result;
+ {exit,Reason}=CR ->
+ ?line expect({eft,{?MODULE,exc_top,3},CR}),
+ ?line {crash,Reason};
+ {error,Reason}=CR ->
+ ?line expect({eft,{?MODULE,exc_top,3},CR}),
+ ?line {crash,{Reason,x_exc_stacktrace()}};
+ CR ->
+ ?line expect({eft,{?MODULE,exc_top,3},CR}),
+ ?line {crash,CR}
+ end.
+
+exc_jump(Func, Args) ->
+ exc(Func, Args, jump).
+
+x_exc_jump(ExcOpts, Func, Args) ->
+ ?line expect({ctt,{?MODULE,exc_jump},[Func,Args]}),
+ ?line case x_exc(ExcOpts, Func, Args, jump) of
+ {value,Value}=Result ->
+ ?line expect({rft,{?MODULE,exc_jump,2},Value}),
+ ?line Result;
+ CR ->
+ ?line expect({eft,{?MODULE,exc_jump,2},CR}),
+ ?line CR
+ end.
+
+exc(Func, Args, jump) ->
+ exc(Func, Args, do);
+exc(Func, Args, do) ->
+ exc(Func, Args).
+
+x_exc(ExcOpts, Func, Args, jump) ->
+ ?line expect({ctt,{?MODULE,exc},[Func,Args,jump]}),
+ ?line case x_exc(ExcOpts, Func, Args, do) of
+ {value,Value}=Result ->
+ ?line expect({rft,{?MODULE,exc,3},Value}),
+ ?line Result;
+ CR ->
+ ?line expect({eft,{?MODULE,exc,3},CR}),
+ ?line CR
+ end;
+x_exc(ExcOpts, Func, Args, do) ->
+ ?line expect({ctt,{?MODULE,exc},[Func,Args,do]}),
+ ?line case x_exc(ExcOpts, Func, Args) of
+ {value,Value}=Result ->
+ ?line expect({rft,{?MODULE,exc,3},Value}),
+ ?line Result;
+ CR ->
+ ?line expect({eft,{?MODULE,exc,3},CR}),
+ ?line CR
+ end.
+
+exc({erlang,apply}, [{M,F},A]) ->
+ erlang:apply(M, F, id(A));
+exc({erlang,apply}, [F,A]) ->
+ erlang:apply(F, id(A));
+exc({erlang,error}, [E]) ->
+ erlang:error(id(E));
+exc({erlang,error}, [E,S]) ->
+ erlang:error(E, id(S));
+exc({erlang,exit}, [E]) ->
+ erlang:exit(id(E));
+exc({erlang,throw}, [E]) ->
+ erlang:throw(id(E));
+exc({erlang,'++'}, [A,B]) ->
+ erlang:'++'(A, id(B));
+exc({?MODULE,match}, [A,B]) ->
+ match(A, id(B));
+exc({?MODULE,clause}, [A,B]) ->
+ clause(A, id(B));
+exc({?MODULE,id}, [E]) ->
+ id(id(E));
+exc({?MODULE,undef}, [E]) ->
+ undef(id(E));
+exc({?MODULE,lists_reverse}, [A,B]) ->
+ lists_reverse(A, id(B));
+exc(Func, [A,B]) when is_function(Func, 2) ->
+ Func(A, id(B)).
+
+x_exc(ExcOpts, {erlang,apply}=Func0, [{_,_}=Func,Args]=Args0) ->
+ ?line expect({ctt,{?MODULE,exc},[Func0,Args0]}),
+ ?line x_exc_body(ExcOpts, Func, Args, true);
+x_exc(ExcOpts, {erlang,apply}=Func0, [Func,Args]=Args0)
+ when is_function(Func, 2)->
+ ?line expect({ctt,{?MODULE,exc},[Func0,Args0]}),
+ ?line x_exc_func(ExcOpts, Func, Args, Args);
+x_exc(ExcOpts, {_,_}=Func, Args) ->
+ ?line expect({ctt,{?MODULE,exc},[Func,Args]}),
+ ?line x_exc_body(ExcOpts, Func, Args, false);
+x_exc(ExcOpts, Func0, [_,Args]=Args0)
+ when is_function(Func0, 2) ->
+ ?line expect({ctt,{?MODULE,exc},[Func0,Args0]}),
+ ?line x_exc_func(ExcOpts, Func0, Args0, Args).
+
+x_exc_func(ExcOpts, Func, [Func1,Args1]=Args, Id) ->
+ %% Assumes the called fun =:= fun exc/2,
+ %% will utterly fail otherwise.
+ ?line Rtt = not ExcOpts#exc_opts.meta,
+ ?line {module,M} = erlang:fun_info(Func, module),
+ ?line {name,F} = erlang:fun_info(Func, name),
+ ?line expect([{ctt,{?MODULE,id},[Id]},
+ ?LINE,{rft,{?MODULE,id,1},Id},
+ ?LINE,Rtt,{rtt,{?MODULE,exc,2}},
+ ?LINE,{ctt,{M,F},Args}]),
+ ?line case x_exc(ExcOpts, Func1, Args1) of
+ {value,Value}=Result ->
+ ?line expect([{rft,{M,F,2},Value},
+ ?LINE,{rft,{?MODULE,exc,2},Value}]),
+ ?line Result;
+ CR ->
+ ?line expect([{eft,{M,F,2},CR},
+ ?LINE,{eft,{?MODULE,exc,2},CR}]),
+ ?line CR
+ end.
+
+x_exc_body(ExcOpts, {M,F}=Func, Args, Apply) ->
+ ?line Nocatch = ExcOpts#exc_opts.nocatch,
+ ?line Rtt = not ExcOpts#exc_opts.meta,
+ ?line Id = case Apply of
+ true -> Args;
+ false -> lists:last(Args)
+ end,
+ ?line expect([{ctt,{?MODULE,id},[Id]},
+ ?LINE,{rft,{?MODULE,id,1},Id},
+ ?LINE,Rtt,{rtt,{?MODULE,exc,2}},
+ ?LINE,{ctt,{M,F},Args}]),
+ ?line Arity = length(Args),
+ ?line try exc(Func, Args) of
+ Value ->
+ ?line x_exc_value(Rtt, M, F, Args, Arity, Value),
+ ?line case expect() of
+ {rtt,{M,F,Arity}} when Rtt, Apply ->
+ %% We may get the above when
+ %% applying a BIF.
+ ?line expect({rft,{?MODULE,exc,2},Value});
+ {rtt,{?MODULE,exc,2}} when Rtt, not Apply ->
+ %% We may get the above when
+ %% calling a BIF.
+ ?line expect({rft,{?MODULE,exc,2},Value});
+ {rft,{?MODULE,exc,2},Value} ->
+ ?line ok
+ end,
+ ?line {value,Value}
+ catch
+ Thrown when Nocatch ->
+ ?line CR = {error,{nocatch,Thrown}},
+ ?line x_exc_exception(Rtt, M, F, Args, Arity, CR),
+ ?line expect({eft,{?MODULE,exc,2},CR}),
+ ?line CR;
+ Class:Reason ->
+ ?line CR = {Class,Reason},
+ ?line x_exc_exception(Rtt, M, F, Args, Arity, CR),
+ ?line expect({eft,{?MODULE,exc,2},CR}),
+ ?line CR
+ end.
+
+x_exc_value(Rtt, ?MODULE, lists_reverse, [La,Lb], 2, R) ->
+ ?line L = lists:reverse(Lb, La),
+ ?line expect([fun ({ctt,{lists,reverse},[L1,L2]}) ->
+ ?line same(L, lists:reverse(L2, L1)),
+ ?line next;
+ (Msg) ->
+ ?line same({rft,{lists,reverse,2},R}, Msg),
+ ?line same(R, lists:reverse(L, [])),
+ ?line done
+ end,
+ ?LINE,Rtt,{rtt,{?MODULE,lists_reverse,2}},
+ ?LINE,{rft,{?MODULE,lists_reverse,2},R}]);
+x_exc_value(_Rtt, M, F, _, Arity, Value) ->
+ ?line expect({rft,{M,F,Arity},Value}).
+
+x_exc_exception(_Rtt, ?MODULE, lists_reverse, [La,Lb], 2, CR) ->
+ ?line L = lists:reverse(Lb, La),
+ ?line expect([fun ({ctt,{lists,reverse},[L1,L2]}) ->
+ ?line same(L, lists:reverse(L2, L1)),
+ ?line next;
+ (Msg) ->
+ ?line same({eft,{lists,reverse,2},CR}, Msg),
+ ?line done
+ end,
+ ?LINE,{eft,{?MODULE,lists_reverse,2},CR}]);
+x_exc_exception(Rtt, ?MODULE, undef, [_], 1, {Class,Reason}=CR) ->
+ ?line expect([{ctt,{erlang,Class},[Reason]},
+ ?LINE,{eft,{erlang,Class,1},CR},
+ ?LINE,Rtt,{rtt,{error_handler,crash,1}},
+ ?LINE,{eft,{?MODULE,undef,1},CR}]);
+x_exc_exception(_Rtt, M, F, _, Arity, CR) ->
+ ?line expect({eft,{M,F,Arity},CR}).
+
+x_exc_stacktrace() ->
+ x_exc_stacktrace(erlang:get_stacktrace()).
+%% Truncate stacktrace to below exc/2
+x_exc_stacktrace([{?MODULE,x_exc,4}|_]) -> [];
+x_exc_stacktrace([{?MODULE,x_exc_func,4}|_]) -> [];
+x_exc_stacktrace([{?MODULE,x_exc_body,4}|_]) -> [];
+x_exc_stacktrace([{?MODULE,exc,2}|_]) -> [];
+x_exc_stacktrace([H|T]) ->
+ [H|x_exc_stacktrace(T)].
+
+
+
+match(A, B) ->
+ A = B.
+
+clause(A, A) ->
+ A.
+
+id(Id) ->
+ Id.
+
+undef(X) ->
+ ?MODULE:undef(X, X). % undef
+
+lists_reverse(A, B) ->
+ lists:reverse(A, B).
+
+
+
+%%% Tracee (slave) handling %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+slave(Dest, Sync) ->
+ Dest ! Sync,
+ receive
+ {From,Tag,{apply,M,F,A}} when is_pid(From) ->
+ ?line ?dbgformat("Apply: ~p:~p/~p (~p)~n",[M,F,length(A),A]),
+ ?line Res = apply(M,F,A),
+ ?line ?dbgformat("done Apply: ~p:~p/~p (~p)~n",[M,F,length(A),A]),
+ From ! {Tag,Res},
+ slave(From, Tag);
+ {From,Tag,{lambda,Fun}} when is_pid(From) ->
+ Res = Fun(),
+ From ! {Tag,Res},
+ slave(From, Tag);
+ {From,Tag,{exc_top,Catch,Func,Args}} when is_pid(From) ->
+ ?line ?dbgformat("Exc: ~p ~p~p ~n",[Catch,Func,Args]),
+ ?line Res = exc_top(Catch, Func, Args),
+ ?line ?dbgformat("done Exc: ~p ~p~p ~n",[Catch,Func,Args]),
+ From ! {Tag,Res},
+ slave(From,Tag);
+ die ->
+ exit(normal)
+ end.
+
+setup(ProcFlags) ->
+ trace_off(),
+ flush(100),
+ Self = self(),
+ Sync = make_ref(),
+ Pid = spawn(fun () -> slave(Self, Sync) end),
+ Mref = erlang:monitor(process, Pid),
+ receive
+ Sync ->
+ put(slave, {Pid,Mref}),
+ case ProcFlags of
+ [] -> ok;
+ _ ->
+ erlang:trace(Pid, true, ProcFlags)
+ end,
+ Pid
+ end.
+
+shutdown() ->
+ trace_off(),
+ {Pid,Mref} = get(slave),
+ try erlang:is_process_alive(Pid) of
+ true ->
+ Pid ! die,
+ receive
+ {'DOWN',Mref,process,Pid,Reason} ->
+ Reason
+ end;
+ _ ->
+ not_alive
+ catch _:_ ->
+ undefined
+ end.
+
+trace_off() ->
+ erlang:trace_pattern({'_','_','_'},false,[]),
+ erlang:trace_pattern({'_','_','_'},false,[local]),
+ erlang:trace_pattern({'_','_','_'},false,[meta]),
+ erlang:trace(all, false, [all]).
+
+
+apply_slave_async(M,F,A) ->
+ {Pid,Mref} = get(slave),
+ spawn(?MODULE,apply_slave_async,[M,F,A,Pid,Mref]),
+ Pid.
+
+apply_slave_async(M,F,A,Pid,Mref) ->
+ Tag = make_ref(),
+ Pid ! {self(),Tag,{apply,M,F,A}},
+ result(Tag, Mref).
+
+apply_slave(M,F,A) ->
+ request({apply,M,F,A}).
+
+lambda_slave(Fun) ->
+ request({lambda,Fun}).
+
+exc_slave(Opts, Func, Args) ->
+ try request({exc_top,Opts,Func,Args})
+ catch
+ Reason ->
+ {crash,Reason}
+ end.
+
+request(Request) ->
+ Tag = make_ref(),
+ {Pid,Mref} = get(slave),
+ Pid ! {self(),Tag,Request},
+ result(Tag, Mref).
+
+result(Tag, Mref) ->
+ receive
+ {Tag,Result} ->
+ receive
+ Tag ->
+ Result
+ end;
+ {'DOWN',Mref,process,_Pid,Reason} ->
+ throw(Reason)
+ end.
+
+
+
+%%% Some receive helpers %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+receive_next() ->
+ receive_next(?DEFAULT_RECEIVE_TIMEOUT).
+
+receive_next(TO) ->
+ receive
+ M ->
+ M
+ after TO ->
+ ?t:fail(timeout)
+ end.
+
+receive_no_next(TO) ->
+ receive M ->
+ ?t:fail({unexpected_message,[M|flush(TO)]})
+ after TO ->
+ ok
+ end.
+
+flush(T) ->
+ receive
+ M ->
+ [M|flush(T)]
+ after T ->
+ []
+ end.
+
+
+
+%%% Helpers %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+%% Do not build garbage
+%%
+seq(M, N, R) when M =< N ->
+ seq(M, N-1, [N|R]);
+seq(_, _, R) -> R.
+
+%% Do not call traced lists:reverse
+reverse(L) ->
+ reverse(L, []).
+%%
+reverse([], R) -> R;
+reverse([H|T], R) ->
+ reverse(T, [H|R]).
+
+%% Abbreviate large complex terms to avoid croaking printout
+%%
+abbr(Term) ->
+ abbr(Term, 20).
+%%
+abbr(Tuple, N) when is_tuple(Tuple) ->
+ list_to_tuple(abbr_tuple(Tuple, N, 1));
+abbr(List, N) when is_list(List) ->
+ abbr_list(List, N, []);
+abbr(Term, _) -> Term.
+%%
+abbr_tuple(Tuple, N, J) when J =< size(Tuple) ->
+ if J > N; N =< 0 ->
+ ['...'];
+ true ->
+ [abbr(element(J, Tuple), N-1)|abbr_tuple(Tuple, J+1, N)]
+ end;
+abbr_tuple(_, _, _) ->
+ [].
+%%
+abbr_list(_, 0, R) ->
+ case io_lib:printable_list(R) of
+ true ->
+ reverse(R, "...");
+ false ->
+ reverse(R, '...')
+ end;
+abbr_list([H|T], N, R) ->
+ M = N-1,
+ abbr_list(T, M, [abbr(H, M)|R]);
+abbr_list(T, _, R) ->
+ reverse(R, T).