stdlib: Improve erl_eval's stacktraces

The call "erlang:get_stacktrace()" is not handled explicitly. If there
are issues, they can probably be ignored since erlang:get_stacktrace/1
will be deprecated and removed.

4 files changed, 257 insertions, 78 deletions

diff --git a/lib/stdlib/doc/src/io.xml b/lib/stdlib/doc/src/io.xml
index 64fcf4379f..72c774e6ef 100644
--- a/lib/stdlib/doc/src/io.xml
+++ b/lib/stdlib/doc/src/io.xml
@@ -257,8 +257,9 @@ ok</pre>
 \x{400}
 ok
 5> <input>io:fwrite("~s~n",[[1024]]).</input>
-** exception exit: {badarg,[{io,format,[&lt;0.26.0&gt;,"~s~n",[[1024]]]},
-   ...</pre>
+** exception error: bad argument
+     in function  io:format/3
+        called as io:format(&lt;0.53.0>,"~s~n",[[1024]])</pre>
           </item>
           <tag><c>w</c></tag>
           <item>
@@ -454,12 +455,9 @@ ok</pre>
 abc def 'abc def'  {foo,1} A
 ok
 2> <input>io:fwrite("~s", [65]).</input>
-** exception exit: {badarg,[{io,format,[&lt;0.22.0>,"~s","A"]},
-                            {erl_eval,do_apply,5},
-                            {shell,exprs,6},
-                            {shell,eval_exprs,6},
-                            {shell,eval_loop,3}]}
-     in function  io:o_request/2</pre>
+** exception error: bad argument
+     in function  io:format/3
+        called as io:format(&lt;0.53.0>,"~s","A")</pre>
         <p>In this example, an attempt was made to output the single
           character 65 with the aid of the string formatting directive
           <c>"~s"</c>.</p>
diff --git a/lib/stdlib/src/erl_eval.erl b/lib/stdlib/src/erl_eval.erl
index eafee346eb..489f65290a 100644
--- a/lib/stdlib/src/erl_eval.erl
+++ b/lib/stdlib/src/erl_eval.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1996-2016. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2018. All Rights Reserved.
 %% 
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -69,6 +69,9 @@
 -type(non_local_function_handler() :: {value, nlfun_handler()}
                                     | none).
 
+-define(STACKTRACE,
+        element(2, erlang:process_info(self(), current_stacktrace))).
+
 %% exprs(ExpressionSeq, Bindings)
 %% exprs(ExpressionSeq, Bindings, LocalFuncHandler)
 %% exprs(ExpressionSeq, Bindings, LocalFuncHandler, ExternalFuncHandler)
@@ -90,7 +93,7 @@ exprs(Exprs, Bs) ->
         ok -> 
             exprs(Exprs, Bs, none, none, none);
         {error,{_Line,_Mod,Error}} ->
-	    erlang:raise(error, Error, [{?MODULE,exprs,2}])
+	    erlang:raise(error, Error, ?STACKTRACE)
     end.
 
 -spec(exprs(Expressions, Bindings, LocalFunctionHandler) ->
@@ -141,7 +144,7 @@ expr(E, Bs) ->
         ok -> 
             expr(E, Bs, none, none, none);
         {error,{_Line,_Mod,Error}} ->
-	    erlang:raise(error, Error, [{?MODULE,expr,2}])
+	    erlang:raise(error, Error, ?STACKTRACE)
     end.
 
 -spec(expr(Expression, Bindings, LocalFunctionHandler) ->
@@ -182,7 +185,7 @@ check_command(Es, Bs) ->
 
 fun_data(F) when is_function(F) ->
     case erlang:fun_info(F, module) of
-        {module,erl_eval} ->
+        {module,?MODULE} ->
             case erlang:fun_info(F, env) of
                 {env,[{FBs,_FLf,_FEf,FCs}]} ->
                     {fun_data,FBs,FCs};
@@ -209,8 +212,8 @@ expr({var,_,V}, Bs, _Lf, _Ef, RBs) ->
     case binding(V, Bs) of
 	{value,Val} ->
             ret_expr(Val, Bs, RBs);
-	unbound -> % Should not happen.
-	    erlang:raise(error, {unbound,V}, stacktrace())
+	unbound -> % Cannot not happen if checked by erl_lint
+	    erlang:raise(error, {unbound,V}, ?STACKTRACE)
     end;
 expr({char,_,C}, Bs, _Lf, _Ef, RBs) ->
     ret_expr(C, Bs, RBs);
@@ -236,13 +239,13 @@ expr({tuple,_,Es}, Bs0, Lf, Ef, RBs) ->
     {Vs,Bs} = expr_list(Es, Bs0, Lf, Ef),
     ret_expr(list_to_tuple(Vs), Bs, RBs);
 expr({record_field,_,_,Name,_}, _Bs, _Lf, _Ef, _RBs) ->
-    erlang:raise(error, {undef_record,Name}, stacktrace());
+    erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
 expr({record_index,_,Name,_}, _Bs, _Lf, _Ef, _RBs) ->
-    erlang:raise(error, {undef_record,Name}, stacktrace());
+    erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
 expr({record,_,Name,_}, _Bs, _Lf, _Ef, _RBs) ->
-    erlang:raise(error, {undef_record,Name}, stacktrace());
+    erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
 expr({record,_,_,Name,_}, _Bs, _Lf, _Ef, _RBs) ->
-    erlang:raise(error, {undef_record,Name}, stacktrace());
+    erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
 
 %% map
 expr({map,_,Binding,Es}, Bs0, Lf, Ef, RBs) ->
@@ -281,7 +284,7 @@ expr({'fun',_Line,{function,Mod0,Name0,Arity0}}, Bs0, Lf, Ef, RBs) ->
     ret_expr(F, Bs, RBs);    
 expr({'fun',_Line,{function,Name,Arity}}, _Bs0, _Lf, _Ef, _RBs) -> % R8
     %% Don't know what to do...
-    erlang:raise(error, undef, [{erl_eval,Name,Arity}|stacktrace()]);
+    erlang:raise(error, undef, [{?MODULE,Name,Arity}|?STACKTRACE]);
 expr({'fun',Line,{clauses,Cs}} = Ex, Bs, Lf, Ef, RBs) ->
     %% Save only used variables in the function environment.
     %% {value,L,V} are hidden while lint finds used variables.
@@ -326,7 +329,7 @@ expr({'fun',Line,{clauses,Cs}} = Ex, Bs, Lf, Ef, RBs) ->
            eval_fun([A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T], Info) end;
 	_Other ->
 	    erlang:raise(error, {'argument_limit',{'fun',Line,Cs}},
-			 stacktrace())
+			 ?STACKTRACE)
     end,
     ret_expr(F, Bs, RBs);
 expr({named_fun,Line,Name,Cs} = Ex, Bs, Lf, Ef, RBs) ->
@@ -378,7 +381,7 @@ expr({named_fun,Line,Name,Cs} = Ex, Bs, Lf, Ef, RBs) ->
                           RF, Info) end;
         _Other ->
             erlang:raise(error, {'argument_limit',{named_fun,Line,Name,Cs}},
-                         stacktrace())
+                         ?STACKTRACE)
     end,
     ret_expr(F, Bs, RBs);
 expr({call,_,{remote,_,{atom,_,qlc},{atom,_,q}},[{lc,_,_E,_Qs}=LC | As0]}, 
@@ -422,25 +425,28 @@ expr({call,_,Func0,As0}, Bs0, Lf, Ef, RBs) -> % function or {Mod,Fun}
     {As,Bs2} = expr_list(As0, Bs1, Lf, Ef),
     case Func of
 	{M,F} when is_atom(M), is_atom(F) ->
-	    erlang:raise(error, {badfun,Func}, stacktrace());
+	    erlang:raise(error, {badfun,Func}, ?STACKTRACE);
 	_ ->
 	    do_apply(Func, As, Bs2, Ef, RBs)
     end;
 expr({'catch',_,Expr}, Bs0, Lf, Ef, RBs) ->
-    Ref = make_ref(),
-    case catch {Ref,expr(Expr, Bs0, Lf, Ef, none)} of
-	{Ref,{value,V,Bs}} ->	  % Nothing was thrown (guaranteed).
-            ret_expr(V, Bs, RBs);
-	Other ->
-            ret_expr(Other, Bs0, RBs)
+    try expr(Expr, Bs0, Lf, Ef, none) of
+        {value,V,Bs} ->
+            ret_expr(V, Bs, RBs)
+    catch
+        throw:Term ->
+            ret_expr(Term, Bs0, RBs);
+        exit:Reason ->
+            ret_expr({'EXIT',Reason}, Bs0, RBs);
+        error:Reason:Stacktrace ->
+            ret_expr({'EXIT',{Reason,Stacktrace}}, Bs0, RBs)
     end;
 expr({match,_,Lhs,Rhs0}, Bs0, Lf, Ef, RBs) ->
     {value,Rhs,Bs1} = expr(Rhs0, Bs0, Lf, Ef, none),
     case match(Lhs, Rhs, Bs1) of
 	{match,Bs} ->
             ret_expr(Rhs, Bs, RBs);
-	nomatch ->
-	    erlang:raise(error, {badmatch,Rhs}, stacktrace())
+	nomatch -> erlang:raise(error, {badmatch,Rhs}, ?STACKTRACE)
     end;
 expr({op,_,Op,A0}, Bs0, Lf, Ef, RBs) ->
     {value,A,Bs} = expr(A0, Bs0, Lf, Ef, none),
@@ -452,7 +458,7 @@ expr({op,_,'andalso',L0,R0}, Bs0, Lf, Ef, RBs) ->
 		{value,R,_} = expr(R0, Bs1, Lf, Ef, none),
 		R;
 	    false -> false;
-	    _ -> erlang:raise(error, {badarg,L}, stacktrace())
+	    _ -> erlang:raise(error, {badarg,L}, ?STACKTRACE)
 	end,
     ret_expr(V, Bs1, RBs);
 expr({op,_,'orelse',L0,R0}, Bs0, Lf, Ef, RBs) ->
@@ -462,7 +468,7 @@ expr({op,_,'orelse',L0,R0}, Bs0, Lf, Ef, RBs) ->
 	    false ->
 		{value,R,_} = expr(R0, Bs1, Lf, Ef, none),
 		R;
-	    _ -> erlang:raise(error, {badarg,L}, stacktrace())
+	    _ -> erlang:raise(error, {badarg,L}, ?STACKTRACE)
 	end,
     ret_expr(V, Bs1, RBs);
 expr({op,_,Op,L0,R0}, Bs0, Lf, Ef, RBs) ->
@@ -474,7 +480,7 @@ expr({bin,_,Fs}, Bs0, Lf, Ef, RBs) ->
     {value,V,Bs} = eval_bits:expr_grp(Fs, Bs0, EvalFun),
     ret_expr(V, Bs, RBs);
 expr({remote,_,_,_}, _Bs, _Lf, _Ef, _RBs) ->
-    erlang:raise(error, {badexpr,':'}, stacktrace());
+    erlang:raise(error, {badexpr,':'}, ?STACKTRACE);
 expr({value,_,Val}, Bs, _Lf, _Ef, RBs) ->    % Special case straight values.
     ret_expr(Val, Bs, RBs).
 
@@ -570,7 +576,7 @@ local_func(Func, As, _Bs, {M,F,Eas}, _Ef, RBs) ->
     local_func2(apply(M, F, [Func,As|Eas]), RBs);
 %% Default unknown function handler to undefined function.
 local_func(Func, As0, _Bs0, none, _Ef, _RBs) ->
-    erlang:raise(error, undef, [{erl_eval,Func,length(As0)}|stacktrace()]).
+    erlang:raise(error, undef, [{?MODULE,Func,length(As0)}|?STACKTRACE]).
 
 local_func2({value,V,Bs}, RBs) ->
     ret_expr(V, Bs, RBs);
@@ -637,7 +643,7 @@ do_apply(Func, As, Bs0, Ef, RBs) ->
                 {{arity, Arity}, Arity} ->
                     eval_fun(FCs, As, FBs, FLf, FEf, NRBs);
                 _ ->
-                    erlang:raise(error, {badarity,{Func,As}},stacktrace())
+                    erlang:raise(error, {badarity,{Func,As}},?STACKTRACE)
             end;
         {{env,[{FBs,FLf,FEf,FCs,FName}]},_} ->
             NRBs = if
@@ -648,7 +654,7 @@ do_apply(Func, As, Bs0, Ef, RBs) ->
                 {{arity, Arity}, Arity} ->
                     eval_named_fun(FCs, As, FBs, FLf, FEf, FName, Func, NRBs);
                 _ ->
-                    erlang:raise(error, {badarity,{Func,As}},stacktrace())
+                    erlang:raise(error, {badarity,{Func,As}},?STACKTRACE)
             end;
         {no_env,none} when RBs =:= value ->
             %% Make tail recursive calls when possible.
@@ -730,7 +736,7 @@ eval_generate([V|Rest], P, Bs0, Lf, Ef, CompFun, Acc) ->
 eval_generate([], _P, _Bs0, _Lf, _Ef, _CompFun, Acc) ->
     Acc;
 eval_generate(Term, _P, _Bs0, _Lf, _Ef, _CompFun, _Acc) ->
-    erlang:raise(error, {bad_generator,Term}, stacktrace()).
+    erlang:raise(error, {bad_generator,Term}, ?STACKTRACE).
 
 eval_b_generate(<<_/bitstring>>=Bin, P, Bs0, Lf, Ef, CompFun, Acc) ->
     Mfun = match_fun(Bs0),
@@ -746,7 +752,7 @@ eval_b_generate(<<_/bitstring>>=Bin, P, Bs0, Lf, Ef, CompFun, Acc) ->
 	    Acc
     end;
 eval_b_generate(Term, _P, _Bs0, _Lf, _Ef, _CompFun, _Acc) ->
-    erlang:raise(error, {bad_generator,Term}, stacktrace()).
+    erlang:raise(error, {bad_generator,Term}, ?STACKTRACE).
 
 eval_filter(F, Bs0, Lf, Ef, CompFun, Acc) ->
     case erl_lint:is_guard_test(F) of
@@ -760,7 +766,7 @@ eval_filter(F, Bs0, Lf, Ef, CompFun, Acc) ->
 		{value,true,Bs1} -> CompFun(Bs1);
 		{value,false,_} -> Acc;
 		{value,V,_} -> 
-                    erlang:raise(error, {bad_filter,V}, stacktrace())
+                    erlang:raise(error, {bad_filter,V}, ?STACKTRACE)
 	    end
     end.
 
@@ -816,7 +822,7 @@ eval_fun([{clause,_,H,G,B}|Cs], As, Bs0, Lf, Ef, RBs) ->
     end;
 eval_fun([], As, _Bs, _Lf, _Ef, _RBs) ->
     erlang:raise(error, function_clause, 
-		 [{?MODULE,'-inside-an-interpreted-fun-',As}|stacktrace()]).
+		 [{?MODULE,'-inside-an-interpreted-fun-',As}|?STACKTRACE]).
 
 
 eval_named_fun(As, Fun, {Bs0,Lf,Ef,Cs,Name}) ->
@@ -836,7 +842,7 @@ eval_named_fun([{clause,_,H,G,B}|Cs], As, Bs0, Lf, Ef, Name, Fun, RBs) ->
     end;
 eval_named_fun([], As, _Bs, _Lf, _Ef, _Name, _Fun, _RBs) ->
     erlang:raise(error, function_clause,
-                 [{?MODULE,'-inside-an-interpreted-fun-',As}|stacktrace()]).
+                 [{?MODULE,'-inside-an-interpreted-fun-',As}|?STACKTRACE]).
 
 
 %% expr_list(ExpressionList, Bindings)
@@ -894,7 +900,7 @@ if_clauses([{clause,_,[],G,B}|Cs], Bs, Lf, Ef, RBs) ->
 	false -> if_clauses(Cs, Bs, Lf, Ef, RBs)
     end;
 if_clauses([], _Bs, _Lf, _Ef, _RBs) ->
-    erlang:raise(error, if_clause, stacktrace()).
+    erlang:raise(error, if_clause, ?STACKTRACE).
 
 %% try_clauses(Body, CaseClauses, CatchClauses, AfterBody, Bindings, 
 %%             LocalFuncHandler, ExtFuncHandler, RBs)
@@ -909,23 +915,19 @@ try_clauses(B, Cases, Catches, AB, Bs, Lf, Ef, RBs) ->
 		{B2,Bs2} ->
 		    exprs(B2, Bs2, Lf, Ef, RBs);
 		nomatch ->
-		    erlang:raise(error, {try_clause,V}, stacktrace())
+		    erlang:raise(error, {try_clause,V}, ?STACKTRACE)
 	    end
     catch
-	Class:Reason when Catches =:= [] ->
+	Class:Reason:Stacktrace when Catches =:= [] ->
 	    %% Rethrow
-	    erlang:raise(Class, Reason, stacktrace());
-	Class:Reason ->
-%%% 	    %% Set stacktrace
-%%% 	    try erlang:raise(Class, Reason, stacktrace())
-%%% 	    catch _:_ -> ok 
-%%% 	    end,
-            V = {Class,Reason,erlang:get_stacktrace()},
-	    case match_clause(Catches, [V],Bs, Lf, Ef) of
+	    erlang:raise(Class, Reason, Stacktrace);
+	Class:Reason:Stacktrace ->
+            V = {Class,Reason,Stacktrace},
+	    case match_clause(Catches, [V], Bs, Lf, Ef) of
 		{B2,Bs2} ->
 		    exprs(B2, Bs2, Lf, Ef, RBs);
 		nomatch ->
-		    erlang:raise(Class, Reason, stacktrace())
+		    erlang:raise(Class, Reason, Stacktrace)
 	    end
     after
 	if AB =:= [] -> 
@@ -943,7 +945,7 @@ case_clauses(Val, Cs, Bs, Lf, Ef, RBs) ->
 	{B, Bs1} ->
 	    exprs(B, Bs1, Lf, Ef, RBs);
 	nomatch ->
-	    erlang:raise(error, {case_clause,Val}, stacktrace())
+	    erlang:raise(error, {case_clause,Val}, ?STACKTRACE)
     end.
 
 %%
@@ -1018,7 +1020,7 @@ guard0([G|Gs], Bs0, Lf, Ef) ->
                 {value,false,_} -> false
 	    end;
 	false ->
-	    erlang:raise(error, guard_expr, stacktrace())
+	    erlang:raise(error, guard_expr, ?STACKTRACE)
     end;
 guard0([], _Bs, _Lf, _Ef) -> true.
 
@@ -1073,7 +1075,7 @@ match(Pat, Term, Bs) ->
 match(Pat, Term, Bs, BBs) ->
     case catch match1(Pat, Term, Bs, BBs) of
 	invalid ->
-	    erlang:raise(error, {illegal_pattern,Pat}, stacktrace());
+	    erlang:raise(error, {illegal_pattern,Pat}, ?STACKTRACE);
 	Other ->
 	    Other
     end.
@@ -1254,7 +1256,7 @@ merge_bindings(Bs1, Bs2) ->
 		  case orddict:find(Name, Bs) of
 		      {ok,Val} -> Bs;		%Already with SAME value
 		      {ok,V1} -> 
-			  erlang:raise(error, {badmatch,V1}, stacktrace());
+			  erlang:raise(error, {badmatch,V1}, ?STACKTRACE);
 		      error -> orddict:store(Name, Val, Bs)
 		  end end,
 	  Bs2, orddict:to_list(Bs1)).
@@ -1264,7 +1266,7 @@ merge_bindings(Bs1, Bs2) ->
 %%       fun (Name, Val, Bs) ->
 %% 	      case orddict:find(Name, Bs) of
 %% 		  {ok,Val} -> orddict:erase(Name, Bs);
-%% 		  {ok,V1} -> erlang:raise(error,{badmatch,V1},stacktrace());
+%% 		  {ok,V1} -> erlang:raise(error,{badmatch,V1},?STACKTRACE);
 %% 		  error -> Bs
 %% 	      end
 %%       end, Bs2, Bs1).
@@ -1326,7 +1328,3 @@ ret_expr(_Old, New) ->
     New.
 
 line(Expr) -> element(2, Expr).
-
-%% {?MODULE,expr,3} is still the stacktrace, despite the
-%% fact that expr() now takes two, three or four arguments...
-stacktrace() -> [{?MODULE,expr,3}].
diff --git a/lib/stdlib/src/eval_bits.erl b/lib/stdlib/src/eval_bits.erl
index 631faa3be5..bb86a65c72 100644
--- a/lib/stdlib/src/eval_bits.erl
+++ b/lib/stdlib/src/eval_bits.erl
@@ -2,7 +2,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1999-2016. All Rights Reserved.
+%% Copyright Ericsson AB 1999-2018. All Rights Reserved.
 %% 
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -25,6 +25,9 @@
 -export([expr_grp/3,expr_grp/5,match_bits/6, 
 	 match_bits/7,bin_gen/6]).
 
+-define(STACKTRACE,
+        element(2, erlang:process_info(self(), current_stacktrace))).
+
 %% Types used in this module:
 %% @type bindings(). An abstract structure for bindings between
 %% variables and values (the environment)
@@ -93,9 +96,9 @@ eval_exp_field1(V, Size, Unit, Type, Endian, Sign) ->
 	eval_exp_field(V, Size, Unit, Type, Endian, Sign)
     catch
 	error:system_limit ->
-	    error(system_limit);
+	    erlang:raise(error, system_limit, ?STACKTRACE);
 	error:_ ->
-	    error(badarg)
+	    erlang:raise(error, badarg, ?STACKTRACE)
     end.
 
 eval_exp_field(Val, Size, Unit, integer, little, signed) ->
@@ -131,7 +134,7 @@ eval_exp_field(Val, all, Unit, binary, _, _) ->
 	Size when Size rem Unit =:= 0 ->
 	    <<Val:Size/binary-unit:1>>;
 	_ ->
-	    error(badarg)
+	    erlang:raise(error, badarg, ?STACKTRACE)
     end;
 eval_exp_field(Val, Size, Unit, binary, _, _) ->
     <<Val:(Size*Unit)/binary-unit:1>>.
@@ -377,12 +380,12 @@ make_bit_type(Line, default, Type0) ->
         {ok,all,Bt} -> {{atom,Line,all},erl_bits:as_list(Bt)};
 	{ok,undefined,Bt} -> {{atom,Line,undefined},erl_bits:as_list(Bt)};
         {ok,Size,Bt} -> {{integer,Line,Size},erl_bits:as_list(Bt)};
-        {error,Reason} -> error(Reason)
+        {error,Reason} -> erlang:raise(error, Reason, ?STACKTRACE)
     end;
 make_bit_type(_Line, Size, Type0) -> %Size evaluates to an integer or 'all'
     case erl_bits:set_bit_type(Size, Type0) of
         {ok,Size,Bt} -> {Size,erl_bits:as_list(Bt)};
-        {error,Reason} -> error(Reason)
+        {error,Reason} -> erlang:raise(error, Reason, ?STACKTRACE)
     end.
 
 match_check_size(Mfun, Size, Bs) ->
@@ -405,9 +408,3 @@ match_check_size(_, {value,_,_}, _Bs, _AllowAll) ->
     ok;	%From the debugger.
 match_check_size(_, _, _Bs, _AllowAll) ->
     throw(invalid).
-
-%% error(Reason) -> exception thrown
-%%  Throw a nice-looking exception, similar to exceptions from erl_eval.
-error(Reason) ->
-    erlang:raise(error, Reason, [{erl_eval,expr,3}]).
-
diff --git a/lib/stdlib/test/erl_eval_SUITE.erl b/lib/stdlib/test/erl_eval_SUITE.erl
index c3ef4eb051..3c95b5781e 100644
--- a/lib/stdlib/test/erl_eval_SUITE.erl
+++ b/lib/stdlib/test/erl_eval_SUITE.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1998-2016. All Rights Reserved.
+%% Copyright Ericsson AB 1998-2017. All Rights Reserved.
 %% 
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -41,6 +41,7 @@
          otp_8133/1,
          otp_10622/1,
          otp_13228/1,
+         otp_14826/1,
          funs/1,
 	 try_catch/1,
 	 eval_expr_5/1,
@@ -57,6 +58,7 @@
 
 -export([count_down/2, count_down_fun/0, do_apply/2, 
          local_func/3, local_func_value/2]).
+-export([simple/0]).
 
 -ifdef(STANDALONE).
 -define(config(A,B),config(A,B)).
@@ -83,7 +85,7 @@ all() ->
      pattern_expr, match_bin, guard_3, guard_4, guard_5, lc,
      simple_cases, unary_plus, apply_atom, otp_5269,
      otp_6539, otp_6543, otp_6787, otp_6977, otp_7550,
-     otp_8133, otp_10622, otp_13228,
+     otp_8133, otp_10622, otp_13228, otp_14826,
      funs, try_catch, eval_expr_5, zero_width,
      eep37, eep43].
 
@@ -988,6 +990,153 @@ otp_13228(_Config) ->
     EFH = {value, fun({io, fwrite}, [atom]) -> io_fwrite end},
     {value, worked, []} = parse_and_run("foo(io:fwrite(atom)).", LFH, EFH).
 
+%% OTP-14826: more accurate stacktrace.
+otp_14826(_Config) ->
+    backtrace_check("fun(P) when is_pid(P) -> true end(a).",
+                    function_clause,
+                    [{erl_eval,'-inside-an-interpreted-fun-',[a],[]},
+                     {erl_eval,eval_fun,6},
+                     ?MODULE]),
+    backtrace_check("B.",
+                    {unbound_var, 'B'},
+                    [{erl_eval,expr,2}, ?MODULE]),
+    backtrace_check("B.",
+                    {unbound, 'B'},
+                    [{erl_eval,expr,5}, ?MODULE],
+                    none, none),
+    backtrace_check("1/0.",
+                    badarith,
+                    [{erlang,'/',[1,0],[]},
+                     {erl_eval,do_apply,6}]),
+    backtrace_catch("catch 1/0.",
+                    badarith,
+                    [{erlang,'/',[1,0],[]},
+                     {erl_eval,do_apply,6}]),
+    check(fun() -> catch exit(foo) end,
+          "catch exit(foo).",
+          {'EXIT', foo}),
+    check(fun() -> catch throw(foo) end,
+          "catch throw(foo).",
+          foo),
+    backtrace_check("try 1/0 after foo end.",
+                    badarith,
+                    [{erlang,'/',[1,0],[]},
+                     {erl_eval,do_apply,6}]),
+    backtrace_catch("catch (try 1/0 after foo end).",
+                    badarith,
+                    [{erlang,'/',[1,0],[]},
+                     {erl_eval,do_apply,6}]),
+    backtrace_catch("try catch 1/0 after foo end.",
+                    badarith,
+                    [{erlang,'/',[1,0],[]},
+                     {erl_eval,do_apply,6}]),
+    backtrace_check("try a of b -> bar after foo end.",
+                    {try_clause,a},
+                    [{erl_eval,try_clauses,8}]),
+    backtrace_catch("catch (try a of b -> bar after foo end).",
+                    {try_clause,a},
+                    [{erl_eval,try_clauses,8}]),
+    backtrace_check("try 1/0 catch exit:a -> foo end.",
+                    badarith,
+                    [{erlang,'/',[1,0],[]},
+                     {erl_eval,do_apply,6}]),
+    backtrace_check("{1,1} = {A = 1, A = 2}.",
+                    {badmatch, 1},
+                    [erl_eval, {lists,foldl,3}]),
+    backtrace_check("case a of a when foo:bar() -> x end.",
+                    guard_expr,
+                    [{erl_eval,guard0,4}], none, none),
+    backtrace_check("case a of foo() -> ok end.",
+                    {illegal_pattern,{call,1,{atom,1,foo},[]}},
+                    [{erl_eval,match,4}], none, none),
+    backtrace_check("case a of b -> ok end.",
+                    {case_clause,a},
+                    [{erl_eval,case_clauses,6}, ?MODULE]),
+    backtrace_check("if a =:= b -> ok end.",
+                    if_clause,
+                    [{erl_eval,if_clauses,5}, ?MODULE]),
+    backtrace_check("fun A(b) -> ok end(a).",
+                    function_clause,
+                    [{erl_eval,'-inside-an-interpreted-fun-',[a],[]},
+                     {erl_eval,eval_named_fun,8},
+                     ?MODULE]),
+    backtrace_check("[A || A <- a].",
+                    {bad_generator, a},
+                    [{erl_eval,eval_generate,7}, {erl_eval, eval_lc, 6}]),
+    backtrace_check("<< <<A>> || <<A>> <= a>>.",
+                    {bad_generator, a},
+                    [{erl_eval,eval_b_generate,7}, {erl_eval, eval_bc, 6}]),
+    backtrace_check("[A || A <- [1], begin a end].",
+                    {bad_filter, a},
+                    [{erl_eval,eval_filter,6}, {erl_eval, eval_generate, 7}]),
+    fun() ->
+            {'EXIT', {{badarity, {_Fun, []}}, BT}} =
+                (catch parse_and_run("fun(A) -> A end().")),
+            check_backtrace([{erl_eval,do_apply,5}, ?MODULE], BT)
+    end(),
+    fun() ->
+            {'EXIT', {{badarity, {_Fun, []}}, BT}} =
+                (catch parse_and_run("fun F(A) -> A end().")),
+            check_backtrace([{erl_eval,do_apply,5}, ?MODULE], BT)
+    end(),
+    backtrace_check("foo().",
+                    undef,
+                    [{erl_eval,foo,0},{erl_eval,local_func,6}],
+                    none, none),
+    backtrace_check("a orelse false.",
+                    {badarg, a},
+                    [{erl_eval,expr,5}, ?MODULE]),
+    backtrace_check("a andalso false.",
+                    {badarg, a},
+                    [{erl_eval,expr,5}, ?MODULE]),
+    backtrace_check("t = u.",
+                    {badmatch, u},
+                    [{erl_eval,expr,5}, ?MODULE]),
+    backtrace_check("{math,sqrt}(2).",
+                    {badfun, {math,sqrt}},
+                    [{erl_eval,expr,5}, ?MODULE]),
+    backtrace_check("erl_eval_SUITE:simple().",
+                    simple,
+                    [{?MODULE,simple1,0},{?MODULE,simple,0},erl_eval]),
+    Args = [{integer,1,I} || I <- lists:seq(1, 30)],
+    backtrace_check("fun(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,"
+                    "19,20,21,22,23,24,25,26,27,28,29,30) -> a end.",
+                    {argument_limit,
+                     {'fun',1,[{clause,1,Args,[],[{atom,1,a}]}]}},
+                    [{erl_eval,expr,5}, ?MODULE]),
+    backtrace_check("fun F(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,"
+                    "19,20,21,22,23,24,25,26,27,28,29,30) -> a end.",
+                    {argument_limit,
+                     {named_fun,1,'F',[{clause,1,Args,[],[{atom,1,a}]}]}},
+                    [{erl_eval,expr,5}, ?MODULE]),
+    backtrace_check("#r{}.",
+                    {undef_record,r},
+                    [{erl_eval,expr,5}, ?MODULE],
+                    none, none),
+    %% eval_bits
+    backtrace_check("<<100:8/bitstring>>.",
+                    badarg,
+                    [{eval_bits,eval_exp_field1,6},
+                     eval_bits,eval_bits,erl_eval]),
+    backtrace_check("<<100:8/foo>>.",
+                    {undefined_bittype,foo},
+                    [{eval_bits,make_bit_type,3},eval_bits,
+                     eval_bits,erl_eval],
+                    none, none),
+    backtrace_check("B = <<\"foo\">>, <<B/binary-unit:7>>.",
+                    badarg,
+                    [{eval_bits,eval_exp_field1,6},
+                     eval_bits,eval_bits,erl_eval],
+                    none, none),
+    ok.
+
+simple() ->
+    A = simple1(),
+    {A}.
+
+simple1() ->
+    erlang:error(simple).
+
 %% Simple cases, just to cover some code.
 funs(Config) when is_list(Config) ->
     do_funs(none, none),
@@ -1488,6 +1637,43 @@ error_check(String, Result, LFH, EFH) ->
             ct:fail({eval, Other, Result})
     end.
 
+backtrace_check(String, Result, Backtrace) ->
+    case catch parse_and_run(String) of
+        {'EXIT', {Result, BT}} ->
+            check_backtrace(Backtrace, BT);
+        Other ->
+            ct:fail({eval, Other, Result})
+    end.
+
+backtrace_check(String, Result, Backtrace, LFH, EFH) ->
+    case catch parse_and_run(String, LFH, EFH) of
+        {'EXIT', {Result, BT}} ->
+            check_backtrace(Backtrace, BT);
+        Other ->
+            ct:fail({eval, Other, Result})
+    end.
+
+backtrace_catch(String, Result, Backtrace) ->
+    case parse_and_run(String) of
+        {value, {'EXIT', {Result, BT}}, _Bindings} ->
+            check_backtrace(Backtrace, BT);
+        Other ->
+            ct:fail({eval, Other, Result})
+    end.
+
+check_backtrace([B1|Backtrace], [B2|BT]) ->
+    case {B1, B2} of
+        {M, {M,_,_,_}} ->
+            ok;
+        {{M,F,A}, {M,F,A,_}} ->
+            ok;
+        {B, B} ->
+            ok
+    end,
+    check_backtrace(Backtrace, BT);
+check_backtrace([], _) ->
+    ok.
+
 eval_string(String) ->
     {value, Result, _} = parse_and_run(String),
     Result.
@@ -1499,8 +1685,8 @@ parse_and_run(String) ->
 
 parse_and_run(String, LFH, EFH) ->
     {ok,Tokens,_} = erl_scan:string(String),
-    {ok, [Expr]} = erl_parse:parse_exprs(Tokens),
-    erl_eval:expr(Expr, [], LFH, EFH).
+    {ok, Exprs} = erl_parse:parse_exprs(Tokens),
+    erl_eval:exprs(Exprs, [], LFH, EFH).
 
 no_final_dot(S) ->
     case lists:reverse(S) of