File 3331-Pass-Anno-to-ExternalFunctionHandler-in-er... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 3331-Pass-Anno-to-ExternalFunctionHandler-in-erl_eval.patch of Package erlang (Revision 6bc8bdb9448218a96809a06da74b3d6e)

Currently displaying revision 6bc8bdb9448218a96809a06da74b3d6e , Show latest

From 1499ec5ad07906ab892424dfd93180834e2b4bd1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Valim?= <jose.valim@dashbit.co>
Date: Fri, 14 Jan 2022 18:08:42 +0100
Subject: [PATCH] Pass Anno to ExternalFunctionHandler in erl_eval

This allows code using `erl_eval` to provide better
stacktraces if desired. For this purpose, we also
make sure all errors raised from `erl_eval` pass
through the ExternalFunctionHandler.
---
 lib/debugger/src/dbg_ieval.erl                |   9 +-
 .../src/big_external_type.erl                 |   2 +-
 .../opaque_SUITE_data/src/big_local_type.erl  |   2 +-
 .../src/big_external_type.erl                 |   2 +-
 .../small_SUITE_data/src/big_local_type.erl   |   2 +-
 lib/stdlib/doc/src/erl_eval.xml               |  11 +-
 lib/stdlib/doc/src/shell.xml                  |   8 +
 lib/stdlib/src/erl_eval.erl                   | 484 +++++++++---------
 lib/stdlib/src/erl_parse.yrl                  |   2 +-
 lib/stdlib/src/eval_bits.erl                  | 132 ++---
 lib/stdlib/src/ms_transform.erl               |   2 +-
 lib/stdlib/test/erl_eval_SUITE.erl            | 197 ++++++-
 lib/stdlib/test/shell_SUITE.erl               |   2 +
 lib/syntax_tools/src/erl_syntax.erl           |   2 +-
 14 files changed, 509 insertions(+), 348 deletions(-)

diff --git a/lib/debugger/src/dbg_ieval.erl b/lib/debugger/src/dbg_ieval.erl
index e03ca7fa11..18f226967d 100644
--- a/lib/debugger/src/dbg_ieval.erl
+++ b/lib/debugger/src/dbg_ieval.erl
@@ -1043,9 +1043,7 @@ expr({bin,Line,Fs}, Bs0, Ieval0) ->
 Ieval = Ieval0#ieval{line=Line,top=false},
 try
 	eval_bits:expr_grp(Fs, Bs0,
-			 fun (E, B) -> expr(E, B, Ieval) end,
-			 [],
-			 false)
+			 fun (E, B) -> expr(E, B, Ieval) end)
 catch
 	Class:Reason ->
 	 exception(Class, Reason, Bs0, Ieval)
@@ -1504,7 +1502,7 @@ guard_expr({bin,_,Flds}, Bs) ->
 			 fun(E,B) ->
 				 {value,V} = guard_expr(E,B),
 				 {value,V,B}
-			 end, [], false),
+			 end),
 {value,V}.
 
 %% guard_case_clauses(Value, Clauses, Bindings, Error, Ieval)
 %% Error = try_clause | case_clause
@@ -1583,8 +1581,7 @@ match1({map,_,Fields}, Map, Bs, BBs) when is_map(Map) ->
 match1({bin,_,Fs}, B, Bs0, BBs) when is_bitstring(B) ->
 try eval_bits:match_bits(Fs, B, Bs0, BBs,
 			 match_fun(BBs),
-			 fun(E, Bs) -> expr(E, Bs, #ieval{}) end,
-			 false)
+			 fun(E, Bs) -> expr(E, Bs, #ieval{}) end)
 catch
 	_:_ -> throw(nomatch)
 end;
diff --git a/lib/dialyzer/test/opaque_SUITE_data/src/big_external_type.erl b/lib/dialyzer/test/opaque_SUITE_data/src/big_external_type.erl
index d286a378ed..7ad3f9366b 100644
--- a/lib/dialyzer/test/opaque_SUITE_data/src/big_external_type.erl
+++ b/lib/dialyzer/test/opaque_SUITE_data/src/big_external_type.erl
@@ -409,7 +409,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/dialyzer/test/opaque_SUITE_data/src/big_local_type.erl b/lib/dialyzer/test/opaque_SUITE_data/src/big_local_type.erl
index 7daceb5260..958ebeff93 100644
--- a/lib/dialyzer/test/opaque_SUITE_data/src/big_local_type.erl
+++ b/lib/dialyzer/test/opaque_SUITE_data/src/big_local_type.erl
@@ -406,7 +406,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/dialyzer/test/small_SUITE_data/src/big_external_type.erl b/lib/dialyzer/test/small_SUITE_data/src/big_external_type.erl
index 9ad4810a5e..3fa55dcc9c 100644
--- a/lib/dialyzer/test/small_SUITE_data/src/big_external_type.erl
+++ b/lib/dialyzer/test/small_SUITE_data/src/big_external_type.erl
@@ -412,7 +412,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/dialyzer/test/small_SUITE_data/src/big_local_type.erl b/lib/dialyzer/test/small_SUITE_data/src/big_local_type.erl
index fe567ff10d..89e0942ab5 100644
--- a/lib/dialyzer/test/small_SUITE_data/src/big_local_type.erl
+++ b/lib/dialyzer/test/small_SUITE_data/src/big_local_type.erl
@@ -409,7 +409,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/stdlib/doc/src/erl_eval.xml b/lib/stdlib/doc/src/erl_eval.xml
index 41566d9aec..71347b4319 100644
--- a/lib/stdlib/doc/src/erl_eval.xml
+++ b/lib/stdlib/doc/src/erl_eval.xml
@@ -273,10 +273,13 @@ Func(Name, Arguments, Bindings)</code>
 <taglist>
 <tag><c>{value,Func}</c></tag>
 <item>
- This defines a non-local function handler that is called with:
- <code type="none">
-Func(FuncSpec, Arguments)</code>
- <c>FuncSpec</c> is the name of the function on the form
+ This defines a non-local function handler. The function
+ may be called with two arguments:
+ <code type="none">Func(FuncSpec, Arguments)</code>
+ or three arguments:
+ <code type="none">Func(Anno, FuncSpec, Arguments)</code>
+ <c>Anno</c> is the <c>erl_anno:anno()</c> of the node,
+ <c>FuncSpec</c> is the name of the function on the form
 <c>{Module,Function}</c> or a fun, and <c>Arguments</c> is a
 list of the evaluated arguments. The function
 handler returns the value of the function. To
diff --git a/lib/stdlib/doc/src/shell.xml b/lib/stdlib/doc/src/shell.xml
index dc68af4328..39912a4bcf 100644
--- a/lib/stdlib/doc/src/shell.xml
+++ b/lib/stdlib/doc/src/shell.xml
@@ -789,6 +789,14 @@ q - quit erlang
 manual page. (Arguments in <c>ArgList</c> are evaluated before the
 callback functions are called.)
 
+ From OTP 25.0, if there are errors evaluating Erlang constructs,
+ such as <c>badmatch</c> during pattern matching or <c>bad_generator</c>
+ in a comprehension, the evaluator will dispatch to
+ <c>erlang:raise(error, Reason, Stacktrace)</c>. This call will be
+ checked against the <c>non_local_allowed/3</c> callback function.
+ You can either forbid it, allow it, or redirect to another call of
+ your choice.
+
 Argument <c>State</c> is a tuple
 <c>{ShellState,ExprState}</c>. The return value <c>NewState</c>
 has the same form. This can be used to carry a state between calls
diff --git a/lib/stdlib/src/erl_eval.erl b/lib/stdlib/src/erl_eval.erl
index 7a809c4402..fc2e2a4194 100644
--- a/lib/stdlib/src/erl_eval.erl
+++ b/lib/stdlib/src/erl_eval.erl
@@ -61,8 +61,9 @@
 
 -type(func_spec() :: {Module :: module(), Function :: atom()} | function()).
 -type(nlfun_handler() :: fun((FuncSpec :: func_spec(),
- Arguments :: [term()]) ->
- term())).
+ Arguments :: [term()]) -> term())
+ | fun((Anno :: erl_anno:anno(), FuncSpec :: func_spec(),
+ Arguments :: [term()]) -> term())).
 -type(non_local_function_handler() :: {value, nlfun_handler()}
 | none).
 
@@ -197,9 +198,9 @@ fun_data(F) when is_function(F) ->
 case erlang:fun_info(F, module) of
 {module,?MODULE} ->
 case erlang:fun_info(F, env) of
- {env,[{FBs,_FLf,_FEf,_FUVs,FCs}]} ->
+ {env,[{_FAnno,FBs,_FLf,_FEf,_FUVs,FCs}]} ->
 {fun_data,FBs,FCs};
- {env,[{FBs,_FLf,_FEf,_FUVs,FCs,FName}]} ->
+ {env,[{_FAnno,FBs,_FLf,_FEf,_FUVs,FCs,FName}]} ->
 {named_fun_data,FBs,FName,FCs}
 end;
 _ ->
@@ -232,12 +233,12 @@ expr(Expr, Bs, Lf, Ef, Rbs) ->
 FunUsedVars :: erl_lint:fun_used_vars(),
 Value :: value(),
 NewBindings :: binding_struct()).
-expr({var,_,V}, Bs, _Lf, _Ef, RBs, _FUVs) ->
+expr({var,Anno,V}, Bs, _Lf, Ef, RBs, _FUVs) ->
 case binding(V, Bs) of
 	{value,Val} ->
 ret_expr(Val, Bs, RBs);
 	unbound -> % Cannot not happen if checked by erl_lint
-	 erlang:raise(error, {unbound,V}, ?STACKTRACE)
+ apply_error({unbound,V}, ?STACKTRACE, Anno, Bs, Ef, RBs)
 end;
 expr({char,_,C}, Bs, _Lf, _Ef, RBs, _FUVs) ->
 ret_expr(C, Bs, RBs);
@@ -251,10 +252,10 @@ expr({string,_,S}, Bs, _Lf, _Ef, RBs, _FUVs) ->
 ret_expr(S, Bs, RBs);
 expr({nil, _}, Bs, _Lf, _Ef, RBs, _FUVs) ->
 ret_expr([], Bs, RBs);
-expr({cons,_,H0,T0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({cons,Anno,H0,T0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,H,Bs1} = expr(H0, Bs0, Lf, Ef, none, FUVs),
 {value,T,Bs2} = expr(T0, Bs0, Lf, Ef, none, FUVs),
- ret_expr([H|T], merge_bindings(Bs1, Bs2), RBs);
+ ret_expr([H|T], merge_bindings(Bs1, Bs2, Anno, Ef), RBs);
 expr({lc,_,E,Qs}, Bs, Lf, Ef, RBs, FUVs) ->
 eval_lc(E, Qs, Bs, Lf, Ef, RBs, FUVs);
 expr({bc,_,E,Qs}, Bs, Lf, Ef, RBs, FUVs) ->
@@ -262,17 +263,17 @@ expr({bc,_,E,Qs}, Bs, Lf, Ef, RBs, FUVs) ->
 expr({tuple,_,Es}, Bs0, Lf, Ef, RBs, FUVs) ->
 {Vs,Bs} = expr_list(Es, Bs0, Lf, Ef, FUVs),
 ret_expr(list_to_tuple(Vs), Bs, RBs);
-expr({record_field,_,_,Name,_}, _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
-expr({record_index,_,Name,_}, _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
-expr({record,_,Name,_}, _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
-expr({record,_,_,Name,_}, _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, {undef_record,Name}, ?STACKTRACE);
+expr({record_field,Anno,_,Name,_}, Bs, _Lf, Ef, RBs, _FUVs) ->
+ apply_error({undef_record,Name}, ?STACKTRACE, Anno, Bs, Ef, RBs);
+expr({record_index,Anno,Name,_}, Bs, _Lf, Ef, RBs, _FUVs) ->
+ apply_error({undef_record,Name}, ?STACKTRACE, Anno, Bs, Ef, RBs);
+expr({record,Anno,Name,_}, Bs, _Lf, Ef, RBs, _FUVs) ->
+ apply_error({undef_record,Name}, ?STACKTRACE, Anno, Bs, Ef, RBs);
+expr({record,Anno,_,Name,_}, Bs, _Lf, Ef, RBs, _FUVs) ->
+ apply_error({undef_record,Name}, ?STACKTRACE, Anno, Bs, Ef, RBs);
 
 %% map
-expr({map,_,Binding,Es}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({map,Anno,Binding,Es}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value, Map0, Bs1} = expr(Binding, Bs0, Lf, Ef, none, FUVs),
 {Vs,Bs2} = eval_map_fields(Es, Bs0, Lf, Ef, FUVs),
 _ = maps:put(k, v, Map0),			%Validate map.
@@ -281,7 +282,7 @@ expr({map,_,Binding,Es}, Bs0, Lf, Ef, RBs, FUVs) ->
 			 ({map_exact,K,V}, Mi) ->
 			 maps:update(K, V, Mi)
 		 end, Map0, Vs),
- ret_expr(Map1, merge_bindings(Bs2, Bs1), RBs);
+ ret_expr(Map1, merge_bindings(Bs2, Bs1, Anno, Ef), RBs);
 expr({map,_,Es}, Bs0, Lf, Ef, RBs, FUVs) ->
 {Vs,Bs} = eval_map_fields(Es, Bs0, Lf, Ef, FUVs),
 ret_expr(lists:foldl(fun
@@ -290,13 +291,13 @@ expr({map,_,Es}, Bs0, Lf, Ef, RBs, FUVs) ->
 
 expr({block,_,Es}, Bs, Lf, Ef, RBs, FUVs) ->
 exprs(Es, Bs, Lf, Ef, RBs, FUVs);
-expr({'if',_,Cs}, Bs, Lf, Ef, RBs, FUVs) ->
- if_clauses(Cs, Bs, Lf, Ef, RBs, FUVs);
-expr({'case',_,E,Cs}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({'if',Anno,Cs}, Bs, Lf, Ef, RBs, FUVs) ->
+ if_clauses(Cs, Anno, Bs, Lf, Ef, RBs, FUVs);
+expr({'case',Anno,E,Cs}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,Val,Bs} = expr(E, Bs0, Lf, Ef, none, FUVs),
- case_clauses(Val, Cs, Bs, Lf, Ef, RBs, FUVs);
-expr({'try',_,B,Cases,Catches,AB}, Bs, Lf, Ef, RBs, FUVs) ->
- try_clauses(B, Cases, Catches, AB, Bs, Lf, Ef, RBs, FUVs);
+ case_clauses(Val, Cs, Anno, Bs, Lf, Ef, RBs, FUVs);
+expr({'try',Anno,B,Cases,Catches,AB}, Bs, Lf, Ef, RBs, FUVs) ->
+ try_clauses(B, Cases, Catches, AB, Anno, Bs, Lf, Ef, RBs, FUVs);
 expr({'receive',_,Cs}, Bs, Lf, Ef, RBs, FUVs) ->
 receive_clauses(Cs, Bs, Lf, Ef, RBs, FUVs);
 expr({'receive',_, Cs, E, TB}, Bs0, Lf, Ef, RBs, FUVs) ->
@@ -306,12 +307,12 @@ expr({'fun',_Anno,{function,Mod0,Name0,Arity0}}, Bs0, Lf, Ef, RBs, FUVs) ->
 {[Mod,Name,Arity],Bs} = expr_list([Mod0,Name0,Arity0], Bs0, Lf, Ef, FUVs),
 F = erlang:make_fun(Mod, Name, Arity),
 ret_expr(F, Bs, RBs);
-expr({'fun',_Anno,{function,Name,Arity}}, _Bs0, _Lf, _Ef, _RBs, _FUVs) -> % R8
+expr({'fun',Anno,{function,Name,Arity}}, Bs0, _Lf, Ef, RBs, _FUVs) -> % R8
 %% Don't know what to do...
- erlang:raise(error, undef, [{?MODULE,Name,Arity}|?STACKTRACE]);
+ apply_error(undef, [{?MODULE,Name,Arity}|?STACKTRACE], Anno, Bs0, Ef, RBs);
 expr({'fun',Anno,{clauses,Cs}} = Ex, Bs, Lf, Ef, RBs, FUVs) ->
 {En,NewFUVs} = fun_used_bindings(Ex, Cs, Bs, FUVs),
- Info = {En,Lf,Ef,NewFUVs,Cs},
+ Info = {Anno,En,Lf,Ef,NewFUVs,Cs},
 
 %% This is a really ugly hack!
 F =
@@ -350,13 +351,13 @@ expr({'fun',Anno,{clauses,Cs}} = Ex, Bs, Lf, Ef, RBs, FUVs) ->
 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 ->
 L = erl_anno:location(Anno),
-	 erlang:raise(error, {'argument_limit',{'fun',L,to_terms(Cs)}},
-			 ?STACKTRACE)
+ Reason = {'argument_limit',{'fun',L,to_terms(Cs)}},
+ apply_error(Reason, ?STACKTRACE, Anno, Bs, Ef, RBs)
 end,
 ret_expr(F, Bs, RBs);
 expr({named_fun,Anno,Name,Cs} = Ex, Bs, Lf, Ef, RBs, FUVs) ->
 {En,NewFUVs} = fun_used_bindings(Ex, Cs, Bs, FUVs),
- Info = {En,Lf,Ef,NewFUVs,Cs,Name},
+ Info = {Anno,En,Lf,Ef,NewFUVs,Cs,Name},
 
 %% This is a really ugly hack!
 F =
@@ -400,9 +401,8 @@ expr({named_fun,Anno,Name,Cs} = Ex, Bs, Lf, Ef, RBs, FUVs) ->
 RF, Info) end;
 _Other ->
 L = erl_anno:location(Anno),
- erlang:raise(error, {'argument_limit',
- {named_fun,L,Name,to_terms(Cs)}},
- ?STACKTRACE)
+ Reason = {'argument_limit',{named_fun,L,Name,to_terms(Cs)}},
+ apply_error(Reason, ?STACKTRACE, Anno, Bs, Ef, RBs)
 end,
 ret_expr(F, Bs, RBs);
 expr({call,_,{remote,_,{atom,_,qlc},{atom,_,q}},[{lc,_,_E,_Qs}=LC | As0]},
@@ -422,33 +422,33 @@ expr({call,A1,{remote,A2,{record_field,_,{atom,_,''},{atom,_,qlc}=Mod},
 [{lc,_,_E,_Qs} | As0]=As},
 Bs, Lf, Ef, RBs, FUVs) when length(As0) =< 1 ->
 expr({call,A1,{remote,A2,Mod,Func},As}, Bs, Lf, Ef, RBs, FUVs);
-expr({call,_,{remote,_,Mod,Func},As0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({call,Anno,{remote,_,Mod,Func},As0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,M,Bs1} = expr(Mod, Bs0, Lf, Ef, none, FUVs),
 {value,F,Bs2} = expr(Func, Bs0, Lf, Ef, none, FUVs),
- {As,Bs3} = expr_list(As0, merge_bindings(Bs1, Bs2), Lf, Ef, FUVs),
+ {As,Bs3} = expr_list(As0, merge_bindings(Bs1, Bs2, Anno, Ef), Lf, Ef, FUVs),
 %% M could be a parameterized module (not an atom).
 case is_atom(M) andalso erl_internal:bif(M, F, length(As)) of
 true ->
- bif(F, As, Bs3, Ef, RBs);
+ bif(F, As, Anno, Bs3, Ef, RBs);
 false ->
- do_apply(M, F, As, Bs3, Ef, RBs)
+ do_apply(M, F, As, Anno, Bs3, Ef, RBs)
 end;
-expr({call,_,{atom,_,Func},As0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({call,Anno,{atom,_,Func},As0}, Bs0, Lf, Ef, RBs, FUVs) ->
 case erl_internal:bif(Func, length(As0)) of
 true ->
 {As,Bs} = expr_list(As0, Bs0, Lf, Ef),
- bif(Func, As, Bs, Ef, RBs);
+ bif(Func, As, Anno, Bs, Ef, RBs);
 false ->
- local_func(Func, As0, Bs0, Lf, Ef, RBs, FUVs)
+ local_func(Func, As0, Anno, Bs0, Lf, Ef, RBs, FUVs)
 end;
-expr({call,_,Func0,As0}, Bs0, Lf, Ef, RBs, FUVs) -> % function or {Mod,Fun}
+expr({call,Anno,Func0,As0}, Bs0, Lf, Ef, RBs, FUVs) -> % function or {Mod,Fun}
 {value,Func,Bs1} = expr(Func0, Bs0, Lf, Ef, none, FUVs),
 {As,Bs2} = expr_list(As0, Bs1, Lf, Ef, FUVs),
 case Func of
 	{M,F} when is_atom(M), is_atom(F) ->
-	 erlang:raise(error, {badfun,Func}, ?STACKTRACE);
+ apply_error({badfun,Func}, ?STACKTRACE, Anno, Bs0, Ef, RBs);
 	_ ->
-	 do_apply(Func, As, Bs2, Ef, RBs)
+	 do_apply(Func, As, Anno, Bs2, Ef, RBs)
 end;
 expr({'catch',_,Expr}, Bs0, Lf, Ef, RBs, FUVs) ->
 try expr(Expr, Bs0, Lf, Ef, none, FUVs) of
@@ -462,46 +462,50 @@ expr({'catch',_,Expr}, Bs0, Lf, Ef, RBs, FUVs) ->
 error:Reason:Stacktrace ->
 ret_expr({'EXIT',{Reason,Stacktrace}}, Bs0, RBs)
 end;
-expr({match,_,Lhs,Rhs0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({match,Anno,Lhs,Rhs0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,Rhs,Bs1} = expr(Rhs0, Bs0, Lf, Ef, none, FUVs),
- case match(Lhs, Rhs, Bs1) of
+ case match(Lhs, Rhs, Anno, Bs1, Bs1, Ef) of
 	{match,Bs} ->
 ret_expr(Rhs, Bs, RBs);
-	nomatch -> erlang:raise(error, {badmatch,Rhs}, ?STACKTRACE)
+	nomatch -> apply_error({badmatch,Rhs}, ?STACKTRACE, Anno, Bs0, Ef, RBs)
 end;
-expr({op,_,Op,A0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({op,Anno,Op,A0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,A,Bs} = expr(A0, Bs0, Lf, Ef, none, FUVs),
- eval_op(Op, A, Bs, Ef, RBs);
-expr({op,_,'andalso',L0,R0}, Bs0, Lf, Ef, RBs, FUVs) ->
+ eval_op(Op, A, Anno, Bs, Ef, RBs);
+expr({op,Anno,'andalso',L0,R0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,L,Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 V = case L of
 	 true ->
 		{value,R,_} = expr(R0, Bs1, Lf, Ef, none, FUVs),
 		R;
 	 false -> false;
-	 _ -> erlang:raise(error, {badarg,L}, ?STACKTRACE)
+	 _ -> apply_error({badarg,L}, ?STACKTRACE, Anno, Bs0, Ef, RBs)
 	end,
 ret_expr(V, Bs1, RBs);
-expr({op,_,'orelse',L0,R0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({op,Anno,'orelse',L0,R0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,L,Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 V = case L of
 	 true -> true;
 	 false ->
 		{value,R,_} = expr(R0, Bs1, Lf, Ef, none, FUVs),
 		R;
-	 _ -> erlang:raise(error, {badarg,L}, ?STACKTRACE)
+	 _ -> apply_error({badarg,L}, ?STACKTRACE, Anno, Bs0, Ef, RBs)
 	end,
 ret_expr(V, Bs1, RBs);
-expr({op,_,Op,L0,R0}, Bs0, Lf, Ef, RBs, FUVs) ->
+expr({op,Anno,Op,L0,R0}, Bs0, Lf, Ef, RBs, FUVs) ->
 {value,L,Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 {value,R,Bs2} = expr(R0, Bs0, Lf, Ef, none, FUVs),
- eval_op(Op, L, R, merge_bindings(Bs1, Bs2), Ef, RBs);
+ eval_op(Op, L, R, Anno, merge_bindings(Bs1, Bs2, Anno, Ef), Ef, RBs);
 expr({bin,_,Fs}, Bs0, Lf, Ef, RBs, FUVs) ->
 EvalFun = fun(E, B) -> expr(E, B, Lf, Ef, none, FUVs) end,
- {value,V,Bs} = eval_bits:expr_grp(Fs, Bs0, EvalFun),
+ ErrorFun = fun(A, R, S) -> apply_error(R, S, A, Bs0, Ef, RBs) end,
+ {value,V,Bs} = eval_bits:expr_grp(Fs, Bs0, EvalFun, ErrorFun),
 ret_expr(V, Bs, RBs);
-expr({remote,_,_,_}, _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, {badexpr,':'}, ?STACKTRACE).
+expr({remote,Anno,_,_}, Bs0, _Lf, Ef, RBs, _FUVs) ->
+ apply_error({badexpr,':'}, ?STACKTRACE, Anno, Bs0, Ef, RBs).
+
+apply_error(Reason, Stack, Anno, Bs0, Ef, RBs) ->
+ do_apply(erlang, raise, [error, Reason, Stack], Anno, Bs0, Ef, RBs).
 
 find_maxline(LC) ->
 put('$erl_eval_max_line', 0),
@@ -584,62 +588,62 @@ unhide_calls([E | Es], MaxLine, D) ->
 unhide_calls(E, _MaxLine, _D) ->
 E.
 
-%% local_func(Function, Arguments, Bindings, LocalFuncHandler,
+%% local_func(Function, Arguments, Anno, Bindings, LocalFuncHandler,
 %% ExternalFuncHandler, RBs, FunUsedVars) ->
 %%	{value,Value,Bindings} | Value when
 %%	LocalFuncHandler = {value,F} | {value,F,Eas} |
 %% {eval,F} | {eval,F,Eas} | none.
 
-local_func(Func, As0, Bs0, {value,F}, Ef, value, FUVs) ->
+local_func(Func, As0, _Anno, Bs0, {value,F}, Ef, value, FUVs) ->
 {As1,_Bs1} = expr_list(As0, Bs0, {value,F}, Ef, FUVs),
 %% Make tail recursive calls when possible.
 F(Func, As1);
-local_func(Func, As0, Bs0, {value,F}, Ef, RBs, FUVs) ->
+local_func(Func, As0, _Anno, Bs0, {value,F}, Ef, RBs, FUVs) ->
 {As1,Bs1} = expr_list(As0, Bs0, {value,F}, Ef, FUVs),
 ret_expr(F(Func, As1), Bs1, RBs);
-local_func(Func, As0, Bs0, {value,F,Eas}, Ef, RBs, FUVs) ->
+local_func(Func, As0, Anno, Bs0, {value,F,Eas}, Ef, RBs, FUVs) ->
 Fun = fun(Name, Args) -> apply(F, [Name,Args|Eas]) end,
- local_func(Func, As0, Bs0, {value, Fun}, Ef, RBs, FUVs);
-local_func(Func, As, Bs, {eval,F}, _Ef, RBs, _FUVs) ->
- local_func2(F(Func, As, Bs), RBs);
-local_func(Func, As, Bs, {eval,F,Eas}, _Ef, RBs, _FUVs) ->
- local_func2(apply(F, [Func,As,Bs|Eas]), RBs);
+ local_func(Func, As0, Anno, Bs0, {value, Fun}, Ef, RBs, FUVs);
+local_func(Func, As, Anno, Bs, {eval,F}, _Ef, RBs, _FUVs) ->
+ local_func2(F(Func, As, Bs), Anno, RBs);
+local_func(Func, As, Anno, Bs, {eval,F,Eas}, _Ef, RBs, _FUVs) ->
+ local_func2(apply(F, [Func,As,Bs|Eas]), Anno, RBs);
 %% These two clauses are for backwards compatibility.
-local_func(Func, As0, Bs0, {M,F}, Ef, RBs, FUVs) ->
+local_func(Func, As0, _Anno, Bs0, {M,F}, Ef, RBs, FUVs) ->
 {As1,Bs1} = expr_list(As0, Bs0, {M,F}, Ef, FUVs),
 ret_expr(M:F(Func,As1), Bs1, RBs);
-local_func(Func, As, _Bs, {M,F,Eas}, _Ef, RBs, _FUVs) ->
- local_func2(apply(M, F, [Func,As|Eas]), RBs);
+local_func(Func, As, Anno, _Bs, {M,F,Eas}, _Ef, RBs, _FUVs) ->
+ local_func2(apply(M, F, [Func,As|Eas]), Anno, RBs);
 %% Default unknown function handler to undefined function.
-local_func(Func, As0, _Bs0, none, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, undef, [{?MODULE,Func,length(As0)}|?STACKTRACE]).
+local_func(Func, As0, Anno, Bs0, none, Ef, RBs, _FUVs) ->
+ apply_error(undef, [{?MODULE,Func,length(As0)}|?STACKTRACE], Anno, Bs0, Ef, RBs).
 
-local_func2({value,V,Bs}, RBs) ->
+local_func2({value,V,Bs}, _Anno, RBs) ->
 ret_expr(V, Bs, RBs);
-local_func2({eval,F,As,Bs}, RBs) -> % This reply is not documented.
+local_func2({eval,F,As,Bs}, Anno, RBs) -> % This reply is not documented.
 %% The shell found F. erl_eval tries to do a tail recursive call,
 %% something the shell cannot do. Do not use Ef here.
- do_apply(F, As, Bs, none, RBs).
+ do_apply(F, As, Anno, Bs, none, RBs).
 
 %% bif(Name, Arguments, RBs)
 %% Evaluate the Erlang auto-imported function Name. erlang:apply/2,3
 %% are "hidden" from the external function handler.
 
-bif(apply, [erlang,apply,As], Bs, Ef, RBs) ->
- bif(apply, As, Bs, Ef, RBs);
-bif(apply, [M,F,As], Bs, Ef, RBs) ->
- do_apply(M, F, As, Bs, Ef, RBs);
-bif(apply, [F,As], Bs, Ef, RBs) ->
- do_apply(F, As, Bs, Ef, RBs);
-bif(Name, As, Bs, Ef, RBs) ->
- do_apply(erlang, Name, As, Bs, Ef, RBs).
+bif(apply, [erlang,apply,As], Anno, Bs, Ef, RBs) ->
+ bif(apply, As, Anno, Bs, Ef, RBs);
+bif(apply, [M,F,As], Anno, Bs, Ef, RBs) ->
+ do_apply(M, F, As, Anno, Bs, Ef, RBs);
+bif(apply, [F,As], Anno, Bs, Ef, RBs) ->
+ do_apply(F, As, Anno, Bs, Ef, RBs);
+bif(Name, As, Anno, Bs, Ef, RBs) ->
+ do_apply(erlang, Name, As, Anno, Bs, Ef, RBs).
 
 %% do_apply(Func, Arguments, Bindings, ExternalFuncHandler, RBs) ->
 %%	{value,Value,Bindings} | Value when
 %%	ExternalFuncHandler = {value,F} | none,
 %% Func = fun()
 
-do_apply(Func, As, Bs0, Ef, RBs) ->
+do_apply(Func, As, Anno, Bs0, Ef, RBs) ->
 Env = if
 is_function(Func) ->
 case {erlang:fun_info(Func, module),
@@ -653,7 +657,7 @@ do_apply(Func, As, Bs0, Ef, RBs) ->
 no_env
 end,
 case {Env,Ef} of
- {{env,[{FBs,FLf,FEf,FFUVs,FCs}]},_} ->
+ {{env,[{FAnno,FBs,FLf,FEf,FFUVs,FCs}]},_} ->
 %% If we are evaluting within another function body
 %% (RBs =/= none), we return RBs when this function body
 %% has been evalutated, otherwise we return Bs0, the
@@ -664,20 +668,20 @@ do_apply(Func, As, Bs0, Ef, RBs) ->
 end,
 case {erlang:fun_info(Func, arity), length(As)} of
 {{arity, Arity}, Arity} ->
- eval_fun(FCs, As, FBs, FLf, FEf, NRBs, FFUVs);
+ eval_fun(FCs, As, FAnno, FBs, FLf, FEf, NRBs, FFUVs);
 _ ->
- erlang:raise(error, {badarity,{Func,As}},?STACKTRACE)
+ apply_error({badarity,{Func,As}}, ?STACKTRACE, Anno, Bs0, Ef, RBs)
 end;
- {{env,[{FBs,FLf,FEf,FFUVs,FCs,FName}]},_} ->
+ {{env,[{FAnno,FBs,FLf,FEf,FFUVs,FCs,FName}]},_} ->
 NRBs = if
 RBs =:= none -> Bs0;
 true -> RBs
 end,
 case {erlang:fun_info(Func, arity), length(As)} of
 {{arity, Arity}, Arity} ->
- eval_named_fun(FCs, As, FBs, FLf, FEf, FName, Func, NRBs, FFUVs);
+ eval_named_fun(FCs, As, FAnno, FBs, FLf, FEf, FName, Func, NRBs, FFUVs);
 _ ->
- erlang:raise(error, {badarity,{Func,As}},?STACKTRACE)
+ apply_error({badarity,{Func,As}}, ?STACKTRACE, Anno, Bs0, Ef, RBs)
 end;
 {no_env,none} when RBs =:= value ->
 %% Make tail recursive calls when possible.
@@ -685,12 +689,12 @@ do_apply(Func, As, Bs0, Ef, RBs) ->
 {no_env,none} ->
 ret_expr(apply(Func, As), Bs0, RBs);
 {no_env,{value,F}} when RBs =:= value ->
- F(Func,As);
+ do_apply(F, Anno, Func, As);
 {no_env,{value,F}} ->
- ret_expr(F(Func, As), Bs0, RBs)
+ ret_expr(do_apply(F, Anno, Func, As), Bs0, RBs)
 end.
 
-do_apply(Mod, Func, As, Bs0, Ef, RBs) ->
+do_apply(Mod, Func, As, Anno, Bs0, Ef, RBs) ->
 case Ef of
 none when RBs =:= value ->
 %% Make tail recursive calls when possible.
@@ -698,11 +702,16 @@ do_apply(Mod, Func, As, Bs0, Ef, RBs) ->
 none ->
 ret_expr(apply(Mod, Func, As), Bs0, RBs);
 {value,F} when RBs =:= value ->
- F({Mod,Func}, As);
+ do_apply(F, Anno, {Mod,Func}, As);
 {value,F} ->
- ret_expr(F({Mod,Func}, As), Bs0, RBs)
+ ret_expr(do_apply(F, Anno, {Mod,Func}, As), Bs0, RBs)
 end.
 
+do_apply(F, Anno, FunOrModFun, Args) when is_function(F, 3) ->
+ F(Anno, FunOrModFun, Args);
+do_apply(F, _Anno, FunOrModFun, Args) when is_function(F, 2) ->
+ F(FunOrModFun, Args).
+
 %% eval_lc(Expr, [Qualifier], Bindings, LocalFunctionHandler,
 %% ExternalFuncHandler, RetBindings) ->
 %%	{value,Value,Bindings} | Value
@@ -710,14 +719,14 @@ do_apply(Mod, Func, As, Bs0, Ef, RBs) ->
 eval_lc(E, Qs, Bs, Lf, Ef, RBs, FUVs) ->
 ret_expr(lists:reverse(eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, [])), Bs, RBs).
 
-eval_lc1(E, [{generate,_,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+eval_lc1(E, [{generate,Anno,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
 {value,L1,_Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 CompFun = fun(Bs, Acc) -> eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
- eval_generate(L1, P, Bs0, Lf, Ef, CompFun, Acc0);
-eval_lc1(E, [{b_generate,_,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+ eval_generate(L1, P, Anno, Bs0, Lf, Ef, CompFun, Acc0);
+eval_lc1(E, [{b_generate,Anno,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
 {value,Bin,_Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 CompFun = fun(Bs, Acc) -> eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
- eval_b_generate(Bin, P, Bs0, Lf, Ef, CompFun, Acc0);
+ eval_b_generate(Bin, P, Anno, Bs0, Lf, Ef, CompFun, Acc0);
 eval_lc1(E, [F|Qs], Bs0, Lf, Ef, FUVs, Acc) ->
 CompFun = fun(Bs) -> eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
 eval_filter(F, Bs0, Lf, Ef, CompFun, FUVs, Acc);
@@ -732,14 +741,14 @@ eval_lc1(E, [], Bs, Lf, Ef, FUVs, Acc) ->
 eval_bc(E, Qs, Bs, Lf, Ef, RBs, FUVs) ->
 ret_expr(eval_bc1(E, Qs, Bs, Lf, Ef, FUVs, <<>>), Bs, RBs).
 
-eval_bc1(E, [{b_generate,_,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+eval_bc1(E, [{b_generate,Anno,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
 {value,Bin,_Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 CompFun = fun(Bs, Acc) -> eval_bc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
- eval_b_generate(Bin, P, Bs0, Lf, Ef, CompFun, Acc0);
-eval_bc1(E, [{generate,_,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+ eval_b_generate(Bin, P, Anno, Bs0, Lf, Ef, CompFun, Acc0);
+eval_bc1(E, [{generate,Anno,P,L0}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
 {value,List,_Bs1} = expr(L0, Bs0, Lf, Ef, none, FUVs),
 CompFun = fun(Bs, Acc) -> eval_bc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
- eval_generate(List, P, Bs0, Lf, Ef, CompFun, Acc0);
+ eval_generate(List, P, Anno, Bs0, Lf, Ef, CompFun, Acc0);
 eval_bc1(E, [F|Qs], Bs0, Lf, Ef, FUVs, Acc) ->
 CompFun = fun(Bs) -> eval_bc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
 eval_filter(F, Bs0, Lf, Ef, CompFun, FUVs, Acc);
@@ -747,35 +756,36 @@ eval_bc1(E, [], Bs, Lf, Ef, FUVs, Acc) ->
 {value,V,_} = expr(E, Bs, Lf, Ef, none, FUVs),
 <<Acc/bitstring,V/bitstring>>.
 
-eval_generate([V|Rest], P, Bs0, Lf, Ef, CompFun, Acc) ->
- case match(P, V, new_bindings(Bs0), Bs0) of
+eval_generate([V|Rest], P, Anno, Bs0, Lf, Ef, CompFun, Acc) ->
+ case match(P, V, Anno, new_bindings(Bs0), Bs0, Ef) of
 	{match,Bsn} ->
 	 Bs2 = add_bindings(Bsn, Bs0),
 	 NewAcc = CompFun(Bs2, Acc),
-	 eval_generate(Rest, P, Bs0, Lf, Ef, CompFun, NewAcc);
+	 eval_generate(Rest, P, Anno, Bs0, Lf, Ef, CompFun, NewAcc);
 	nomatch ->
-	 eval_generate(Rest, P, Bs0, Lf, Ef, CompFun, Acc)
+	 eval_generate(Rest, P, Anno, Bs0, Lf, Ef, CompFun, Acc)
 	end;
-eval_generate([], _P, _Bs0, _Lf, _Ef, _CompFun, Acc) ->
+eval_generate([], _P, _Anno, _Bs0, _Lf, _Ef, _CompFun, Acc) ->
 Acc;
-eval_generate(Term, _P, _Bs0, _Lf, _Ef, _CompFun, _Acc) ->
- erlang:raise(error, {bad_generator,Term}, ?STACKTRACE).
+eval_generate(Term, _P, Anno, Bs0, _Lf, Ef, _CompFun, _Acc) ->
+ apply_error({bad_generator,Term}, ?STACKTRACE, Anno, Bs0, Ef, none).
 
-eval_b_generate(<<_/bitstring>>=Bin, P, Bs0, Lf, Ef, CompFun, Acc) ->
- Mfun = match_fun(Bs0),
+eval_b_generate(<<_/bitstring>>=Bin, P, Anno, Bs0, Lf, Ef, CompFun, Acc) ->
+ Mfun = match_fun(Bs0, Ef),
 Efun = fun(Exp, Bs) -> expr(Exp, Bs, Lf, Ef, none) end,
- case eval_bits:bin_gen(P, Bin, new_bindings(Bs0), Bs0, Mfun, Efun) of
+ ErrorFun = fun(A, R, S) -> apply_error(R, S, A, Bs0, Ef, none) end,
+ case eval_bits:bin_gen(P, Bin, new_bindings(Bs0), Bs0, Mfun, Efun, ErrorFun) of
 	{match, Rest, Bs1} ->
 	 Bs2 = add_bindings(Bs1, Bs0),
 	 NewAcc = CompFun(Bs2, Acc),
-	 eval_b_generate(Rest, P, Bs0, Lf, Ef, CompFun, NewAcc);
+	 eval_b_generate(Rest, P, Anno, Bs0, Lf, Ef, CompFun, NewAcc);
 	{nomatch, Rest} ->
-	 eval_b_generate(Rest, P, Bs0, Lf, Ef, CompFun, Acc);
+	 eval_b_generate(Rest, P, Anno, Bs0, Lf, Ef, CompFun, Acc);
 	done ->
 	 Acc
 end;
-eval_b_generate(Term, _P, _Bs0, _Lf, _Ef, _CompFun, _Acc) ->
- erlang:raise(error, {bad_generator,Term}, ?STACKTRACE).
+eval_b_generate(Term, _P, Anno, Bs0, _Lf, Ef, _CompFun, _Acc) ->
+ apply_error({bad_generator,Term}, ?STACKTRACE, Anno, Bs0, Ef, none).
 
 eval_filter(F, Bs0, Lf, Ef, CompFun, FUVs, Acc) ->
 case erl_lint:is_guard_test(F) of
@@ -789,7 +799,7 @@ eval_filter(F, Bs0, Lf, Ef, CompFun, FUVs, Acc) ->
 		{value,true,Bs1} -> CompFun(Bs1);
 		{value,false,_} -> Acc;
 		{value,V,_} ->
- erlang:raise(error, {bad_filter,V}, ?STACKTRACE)
+ apply_error({bad_filter,V}, ?STACKTRACE, element(2, F), Bs0, Ef, none)
 	 end
 end.
 
@@ -824,48 +834,48 @@ ret_expr(V, Bs, none) ->
 ret_expr(V, _Bs, RBs) when is_list(RBs); is_map(RBs) ->
 {value,V,RBs}.
 
-%% eval_fun(Arguments, {Bindings,LocalFunctionHandler,
+%% eval_fun(Arguments, {Anno,Bindings,LocalFunctionHandler,
 %% ExternalFunctionHandler,FunUsedVars,Clauses}) -> Value
 %% This function is called when the fun is called from compiled code
 %% or from apply.
 
-eval_fun(As, {Bs0,Lf,Ef,FUVs,Cs}) ->
- eval_fun(Cs, As, Bs0, Lf, Ef, value, FUVs).
+eval_fun(As, {Anno,Bs0,Lf,Ef,FUVs,Cs}) ->
+ eval_fun(Cs, As, Anno, Bs0, Lf, Ef, value, FUVs).
 
-eval_fun([{clause,_,H,G,B}|Cs], As, Bs0, Lf, Ef, RBs, FUVs) ->
- case match_list(H, As, new_bindings(Bs0), Bs0) of
+eval_fun([{clause,_,H,G,B}|Cs], As, Anno, Bs0, Lf, Ef, RBs, FUVs) ->
+ case match_list(H, As, Anno, new_bindings(Bs0), Bs0, Ef) of
 	{match,Bsn} -> % The new bindings for the head
 	 Bs1 = add_bindings(Bsn, Bs0), % which then shadow!
 	 case guard(G, Bs1, Lf, Ef) of
 		true -> exprs(B, Bs1, Lf, Ef, RBs, FUVs);
-		false -> eval_fun(Cs, As, Bs0, Lf, Ef, RBs, FUVs)
+		false -> eval_fun(Cs, As, Anno, Bs0, Lf, Ef, RBs, FUVs)
 	 end;
 	nomatch ->
-	 eval_fun(Cs, As, Bs0, Lf, Ef, RBs, FUVs)
+	 eval_fun(Cs, As, Anno, Bs0, Lf, Ef, RBs, FUVs)
 end;
-eval_fun([], As, _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, function_clause,
-		 [{?MODULE,'-inside-an-interpreted-fun-',As}|?STACKTRACE]).
+eval_fun([], As, Anno, Bs, _Lf, Ef, RBs, _FUVs) ->
+ Stack = [{?MODULE,'-inside-an-interpreted-fun-',As}|?STACKTRACE],
+ apply_error(function_clause, Stack, Anno, Bs, Ef, RBs).
 
 
-eval_named_fun(As, Fun, {Bs0,Lf,Ef,FUVs,Cs,Name}) ->
- eval_named_fun(Cs, As, Bs0, Lf, Ef, Name, Fun, value, FUVs).
+eval_named_fun(As, Fun, {Anno,Bs0,Lf,Ef,FUVs,Cs,Name}) ->
+ eval_named_fun(Cs, As, Anno, Bs0, Lf, Ef, Name, Fun, value, FUVs).
 
-eval_named_fun([{clause,_,H,G,B}|Cs], As, Bs0, Lf, Ef, Name, Fun, RBs, FUVs) ->
+eval_named_fun([{clause,_,H,G,B}|Cs], As, Anno, Bs0, Lf, Ef, Name, Fun, RBs, FUVs) ->
 Bs1 = add_binding(Name, Fun, Bs0),
- case match_list(H, As, new_bindings(Bs0), Bs1) of
+ case match_list(H, As, Anno, new_bindings(Bs0), Bs1, Ef) of
 {match,Bsn} -> % The new bindings for the head
 Bs2 = add_bindings(Bsn, Bs1), % which then shadow!
 case guard(G, Bs2, Lf, Ef) of
 true -> exprs(B, Bs2, Lf, Ef, RBs, FUVs);
- false -> eval_named_fun(Cs, As, Bs0, Lf, Ef, Name, Fun, RBs, FUVs)
+ false -> eval_named_fun(Cs, As, Anno, Bs0, Lf, Ef, Name, Fun, RBs, FUVs)
 end;
 nomatch ->
- eval_named_fun(Cs, As, Bs0, Lf, Ef, Name, Fun, RBs, FUVs)
+ eval_named_fun(Cs, As, Anno, Bs0, Lf, Ef, Name, Fun, RBs, FUVs)
 end;
-eval_named_fun([], As, _Bs, _Lf, _Ef, _Name, _Fun, _RBs, _FUVs) ->
- erlang:raise(error, function_clause,
- [{?MODULE,'-inside-an-interpreted-fun-',As}|?STACKTRACE]).
+eval_named_fun([], As, Anno, Bs, _Lf, Ef, _Name, _Fun, RBs, _FUVs) ->
+ Stack = [{?MODULE,'-inside-an-interpreted-fun-',As}|?STACKTRACE],
+ apply_error(function_clause, Stack, Anno, Bs, Ef, RBs).
 
 
 %% expr_list(ExpressionList, Bindings)
@@ -908,31 +918,31 @@ expr_list(Es, Bs, Lf, Ef, FUVs) ->
 
 expr_list([E|Es], Vs, BsOrig, Bs0, Lf, Ef, FUVs) ->
 {value,V,Bs1} = expr(E, BsOrig, Lf, Ef, none, FUVs),
- expr_list(Es, [V|Vs], BsOrig, merge_bindings(Bs1, Bs0), Lf, Ef, FUVs);
+ expr_list(Es, [V|Vs], BsOrig, merge_bindings(Bs1, Bs0, element(2, E), Ef), Lf, Ef, FUVs);
 expr_list([], Vs, _, Bs, _Lf, _Ef, _FUVs) ->
 {reverse(Vs),Bs}.
 
-eval_op(Op, Arg1, Arg2, Bs, Ef, RBs) ->
- do_apply(erlang, Op, [Arg1,Arg2], Bs, Ef, RBs).
+eval_op(Op, Arg1, Arg2, Anno, Bs, Ef, RBs) ->
+ do_apply(erlang, Op, [Arg1,Arg2], Anno, Bs, Ef, RBs).
 
-eval_op(Op, Arg, Bs, Ef, RBs) ->
- do_apply(erlang, Op, [Arg], Bs, Ef, RBs).
+eval_op(Op, Arg, Anno, Bs, Ef, RBs) ->
+ do_apply(erlang, Op, [Arg], Anno, Bs, Ef, RBs).
 
-%% if_clauses(Clauses, Bindings, LocalFuncHandler, ExtFuncHandler, RBs)
+%% if_clauses(Clauses, Anno, Bindings, LocalFuncHandler, ExtFuncHandler, RBs)
 
-if_clauses([{clause,_,[],G,B}|Cs], Bs, Lf, Ef, RBs, FUVs) ->
+if_clauses([{clause,_,[],G,B}|Cs], Anno, Bs, Lf, Ef, RBs, FUVs) ->
 case guard(G, Bs, Lf, Ef) of
 	true -> exprs(B, Bs, Lf, Ef, RBs, FUVs);
-	false -> if_clauses(Cs, Bs, Lf, Ef, RBs, FUVs)
+	false -> if_clauses(Cs, Anno, Bs, Lf, Ef, RBs, FUVs)
 end;
-if_clauses([], _Bs, _Lf, _Ef, _RBs, _FUVs) ->
- erlang:raise(error, if_clause, ?STACKTRACE).
+if_clauses([], Anno, Bs, _Lf, Ef, RBs, _FUVs) ->
+ apply_error(if_clause, ?STACKTRACE, Anno, Bs, Ef, RBs).
 
-%% try_clauses(Body, CaseClauses, CatchClauses, AfterBody, Bindings,
+%% try_clauses(Body, CaseClauses, CatchClauses, AfterBody, Anno, Bindings,
 %% LocalFuncHandler, ExtFuncHandler, RBs)
 
-try_clauses(B, Cases, Catches, AB, Bs, Lf, Ef, RBs, FUVs) ->
- check_stacktrace_vars(Catches, Bs),
+try_clauses(B, Cases, Catches, AB, Anno, Bs, Lf, Ef, RBs, FUVs) ->
+ check_stacktrace_vars(Catches, Anno, Bs, Ef, RBs),
 try exprs(B, Bs, Lf, Ef, none, FUVs) of
 	{value,V,Bs1} when Cases =:= [] ->
 	 ret_expr(V, Bs1, RBs);
@@ -941,7 +951,7 @@ try_clauses(B, Cases, Catches, AB, Bs, Lf, Ef, RBs, FUVs) ->
 		{B2,Bs2} ->
 		 exprs(B2, Bs2, Lf, Ef, RBs, FUVs);
 		nomatch ->
-		 erlang:raise(error, {try_clause,V}, ?STACKTRACE)
+ apply_error({try_clause, V}, ?STACKTRACE, Anno, Bs, Ef, RBs)
 	 end
 catch
 	Class:Reason:Stacktrace when Catches =:= [] ->
@@ -962,36 +972,36 @@ try_clauses(B, Cases, Catches, AB, Bs, Lf, Ef, RBs, FUVs) ->
 	end
 end.
 
-check_stacktrace_vars([{clause,_,[{tuple,_,[_,_,STV]}],_,_}|Cs], Bs) ->
+
+check_stacktrace_vars([{clause,_,[{tuple,_,[_,_,STV]}],_,_}|Cs], Anno, Bs, Ef, RBs) ->
 case STV of
 {var,_,V} ->
 case binding(V, Bs) of
 {value, _} ->
- erlang:raise(error, stacktrace_bound, ?STACKTRACE);
+ apply_error(stacktrace_bound, ?STACKTRACE, Anno, Bs, Ef, RBs);
 unbound ->
- check_stacktrace_vars(Cs, Bs)
+ check_stacktrace_vars(Cs, Anno, Bs, Ef, RBs)
 end;
 _ ->
- erlang:raise(error,
- {illegal_stacktrace_variable,STV},
- ?STACKTRACE)
+ Reason = {illegal_stacktrace_variable,STV},
+ apply_error(Reason, ?STACKTRACE, Anno, Bs, Ef, RBs)
 end;
-check_stacktrace_vars([], _Bs) ->
+check_stacktrace_vars([], _Anno, _Bs, _Ef, _RBs) ->
 ok.
 
-%% case_clauses(Value, Clauses, Bindings, LocalFuncHandler, ExtFuncHandler,
-%% RBs)
+%% case_clauses(Value, Clauses, Anno, Bindings, LocalFuncHandler,
+%% ExtFuncHandler, RBs)
 
-case_clauses(Val, Cs, Bs, Lf, Ef, RBs, FUVs) ->
+case_clauses(Val, Cs, Anno, Bs, Lf, Ef, RBs, FUVs) ->
 case match_clause(Cs, [Val], Bs, Lf, Ef) of
 	{B, Bs1} ->
 	 exprs(B, Bs1, Lf, Ef, RBs, FUVs);
 	nomatch ->
-	 erlang:raise(error, {case_clause,Val}, ?STACKTRACE)
+	 apply_error({case_clause,Val}, ?STACKTRACE, Anno, Bs, Ef, RBs)
 end.
 
 %%
-%% receive_clauses(Clauses, Bindings, LocalFuncHnd,ExtFuncHnd, RBs)
+%% receive_clauses(Clauses, Bindings, LocalFuncHnd, ExtFuncHnd, RBs)
 %%
 receive_clauses(Cs, Bs, Lf, Ef, RBs, FUVs) ->
 receive_clauses(infinity, Cs, unused, Bs, Lf, Ef, RBs, FUVs).
@@ -1023,8 +1033,8 @@ receive_clauses(T, Cs, TB, Bs, Lf, Ef, RBs, FUVs) ->
 match_clause(Cs, Vs, Bs, Lf) ->
 match_clause(Cs, Vs, Bs, Lf, none).
 
-match_clause([{clause,_,H,G,B}|Cs], Vals, Bs, Lf, Ef) ->
- case match_list(H, Vals, Bs) of
+match_clause([{clause,Anno,H,G,B}|Cs], Vals, Bs, Lf, Ef) ->
+ case match_list(H, Vals, Anno, Bs, Bs, Ef) of
 	{match, Bs1} ->
 	 case guard(G, Bs1, Lf, Ef) of
 		true -> {B, Bs1};
@@ -1062,7 +1072,7 @@ guard0([G|Gs], Bs0, Lf, Ef) ->
 {value,false,_} -> false
 	 end;
 	false ->
-	 erlang:raise(error, guard_expr, ?STACKTRACE)
+ apply_error(guard_expr, ?STACKTRACE, element(2, G), Bs0, Ef, none)
 end;
 guard0([], _Bs, _Lf, _Ef) -> true.
 
@@ -1101,23 +1111,19 @@ type_test(record) -> is_record;
 type_test(map) -> is_map;
 type_test(Test) -> Test.
 
-
-%% match(Pattern, Term, Bindings) ->
-%%	{match,NewBindings} | nomatch
+%% match(Pattern, Term, Anno, NewBindings, Bindings, ExternalFunHnd) ->
+%% {match,NewBindings} | nomatch
 %% or erlang:error({illegal_pattern, Pattern}).
-%% Try to match Pattern against Term with the current bindings.
-
-match(Pat, Term, Bs) ->
- match(Pat, Term, Bs, Bs).
-
+%%
+%% Try to match Pattern against Term with the current bindings.
 %% Bs are the bindings that are augmented with new bindings. BBs are
 %% the bindings used for "binsize" variables (in <<X:Y>>, Y is a
 %% binsize variable).
 
-match(Pat, Term, Bs, BBs) ->
- case catch match1(Pat, Term, Bs, BBs) of
+match(Pat, Term, Anno, Bs, BBs, Ef) ->
+ case catch match1(Pat, Term, Bs, BBs, Ef) of
 	invalid ->
-	 erlang:raise(error, {illegal_pattern,to_term(Pat)}, ?STACKTRACE);
+ apply_error({illegal_pattern,to_term(Pat)}, ?STACKTRACE, Anno, Bs, Ef, none);
 	Other ->
 	 Other
 end.
@@ -1126,29 +1132,29 @@ string_to_conses([], _, Tail) -> Tail;
 string_to_conses([E|Rest], Anno, Tail) ->
 {cons, Anno, {integer, Anno, E}, string_to_conses(Rest, Anno, Tail)}.
 
-match1({atom,_,A0}, A, Bs, _BBs) ->
+match1({atom,_,A0}, A, Bs, _BBs, _Ef) ->
 case A of
 	A0 -> {match,Bs};
 	_ -> throw(nomatch)
 end;
-match1({integer,_,I0}, I, Bs, _BBs) ->
+match1({integer,_,I0}, I, Bs, _BBs, _Ef) ->
 case I of
 	I0 -> {match,Bs};
 	_ -> throw(nomatch)
 end;
-match1({float,_,F0}, F, Bs, _BBs) ->
+match1({float,_,F0}, F, Bs, _BBs, _Ef) ->
 case F of
 	F0 -> {match,Bs};
 	_ -> throw(nomatch)
 end;
-match1({char,_,C0}, C, Bs, _BBs) ->
+match1({char,_,C0}, C, Bs, _BBs, _Ef) ->
 case C of
 	C0 -> {match,Bs};
 	_ -> throw(nomatch)
 end;
-match1({var,_,'_'}, _, Bs, _BBs) ->		%Anonymous variable matches
+match1({var,_,'_'}, _, Bs, _BBs, _Ef) ->		%Anonymous variable matches
 {match,Bs};					% everything, no new bindings
-match1({var,_,Name}, Term, Bs, _BBs) ->
+match1({var,_,Name}, Term, Bs, _BBs, _Ef) ->
 case binding(Name, Bs) of
 	{value,Term} ->
 	 {match,Bs};
@@ -1157,34 +1163,34 @@ match1({var,_,Name}, Term, Bs, _BBs) ->
 	unbound ->
 	 {match,add_binding(Name, Term, Bs)}
 end;
-match1({match,_,Pat1,Pat2}, Term, Bs0, BBs) ->
- {match, Bs1} = match1(Pat1, Term, Bs0, BBs),
- match1(Pat2, Term, Bs1, BBs);
-match1({string,_,S0}, S, Bs, _BBs) ->
+match1({match,_,Pat1,Pat2}, Term, Bs0, BBs, Ef) ->
+ {match, Bs1} = match1(Pat1, Term, Bs0, BBs, Ef),
+ match1(Pat2, Term, Bs1, BBs, Ef);
+match1({string,_,S0}, S, Bs, _BBs, _Ef) ->
 case S of
 	S0 -> {match,Bs};
 	_ -> throw(nomatch)
 end;
-match1({nil,_}, Nil, Bs, _BBs) ->
+match1({nil,_}, Nil, Bs, _BBs, _Ef) ->
 case Nil of
 	[] -> {match,Bs};
 	_ -> throw(nomatch)
 end;
-match1({cons,_,H,T}, [H1|T1], Bs0, BBs) ->
- {match,Bs} = match1(H, H1, Bs0, BBs),
- match1(T, T1, Bs, BBs);
-match1({cons,_,_,_}, _, _Bs, _BBs) ->
+match1({cons,_,H,T}, [H1|T1], Bs0, BBs, Ef) ->
+ {match,Bs} = match1(H, H1, Bs0, BBs, Ef),
+ match1(T, T1, Bs, BBs, Ef);
+match1({cons,_,_,_}, _, _Bs, _BBs, _Ef) ->
 throw(nomatch);
-match1({tuple,_,Elts}, Tuple, Bs, BBs)
+match1({tuple,_,Elts}, Tuple, Bs, BBs, Ef)
 when length(Elts) =:= tuple_size(Tuple) ->
- match_tuple(Elts, Tuple, 1, Bs, BBs);
-match1({tuple,_,_}, _, _Bs, _BBs) ->
+ match_tuple(Elts, Tuple, 1, Bs, BBs, Ef);
+match1({tuple,_,_}, _, _Bs, _BBs, _Ef) ->
 throw(nomatch);
-match1({map,_,Fs}, #{}=Map, Bs, BBs) ->
- match_map(Fs, Map, Bs, BBs);
-match1({map,_,_}, _, _Bs, _BBs) ->
+match1({map,_,Fs}, #{}=Map, Bs, BBs, Ef) ->
+ match_map(Fs, Map, Bs, BBs, Ef);
+match1({map,_,_}, _, _Bs, _BBs, _Ef) ->
 throw(nomatch);
-match1({bin, _, Fs}, <<_/bitstring>>=B, Bs0, BBs) ->
+match1({bin, _, Fs}, <<_/bitstring>>=B, Bs0, BBs, Ef) ->
 EvalFun = fun(E, Bs) ->
 case erl_lint:is_guard_expr(E) of
 true -> ok;
@@ -1197,74 +1203,72 @@ match1({bin, _, Fs}, <<_/bitstring>>=B, Bs0, BBs) ->
 throw(invalid)
 end
 end,
- eval_bits:match_bits(Fs, B, Bs0, BBs, match_fun(BBs), EvalFun);
-match1({bin,_,_}, _, _Bs, _BBs) ->
+ ErrorFun = fun(A, R, S) -> apply_error(R, S, A, Bs0, Ef, none) end,
+ eval_bits:match_bits(Fs, B, Bs0, BBs, match_fun(BBs, Ef), EvalFun, ErrorFun);
+match1({bin,_,_}, _, _Bs, _BBs, _Ef) ->
 throw(nomatch);
-match1({op,_,'++',{nil,_},R}, Term, Bs, BBs) ->
- match1(R, Term, Bs, BBs);
-match1({op,_,'++',{cons,Ai,{integer,A2,I},T},R}, Term, Bs, BBs) ->
- match1({cons,Ai,{integer,A2,I},{op,Ai,'++',T,R}}, Term, Bs, BBs);
-match1({op,_,'++',{cons,Ai,{char,A2,C},T},R}, Term, Bs, BBs) ->
- match1({cons,Ai,{char,A2,C},{op,Ai,'++',T,R}}, Term, Bs, BBs);
-match1({op,_,'++',{string,Ai,L},R}, Term, Bs, BBs) ->
- match1(string_to_conses(L, Ai, R), Term, Bs, BBs);
-match1({op,Anno,Op,A}, Term, Bs, BBs) ->
+match1({op,_,'++',{nil,_},R}, Term, Bs, BBs, Ef) ->
+ match1(R, Term, Bs, BBs, Ef);
+match1({op,_,'++',{cons,Ai,{integer,A2,I},T},R}, Term, Bs, BBs, Ef) ->
+ match1({cons,Ai,{integer,A2,I},{op,Ai,'++',T,R}}, Term, Bs, BBs, Ef);
+match1({op,_,'++',{cons,Ai,{char,A2,C},T},R}, Term, Bs, BBs, Ef) ->
+ match1({cons,Ai,{char,A2,C},{op,Ai,'++',T,R}}, Term, Bs, BBs, Ef);
+match1({op,_,'++',{string,Ai,L},R}, Term, Bs, BBs, Ef) ->
+ match1(string_to_conses(L, Ai, R), Term, Bs, BBs, Ef);
+match1({op,Anno,Op,A}, Term, Bs, BBs, Ef) ->
 case partial_eval({op,Anno,Op,A}) of
 	{op,Anno,Op,A} ->
 	 throw(invalid);
 	X ->
-	 match1(X, Term, Bs, BBs)
+	 match1(X, Term, Bs, BBs, Ef)
 end;
-match1({op,Anno,Op,L,R}, Term, Bs, BBs) ->
+match1({op,Anno,Op,L,R}, Term, Bs, BBs, Ef) ->
 case partial_eval({op,Anno,Op,L,R}) of
 	{op,Anno,Op,L,R} ->
 	 throw(invalid);
 	X ->
-	 match1(X, Term, Bs, BBs)
+	 match1(X, Term, Bs, BBs, Ef)
 end;
-match1(_, _, _Bs, _BBs) ->
+match1(_, _, _Bs, _BBs, _Ef) ->
 throw(invalid).
 
-match_fun(BBs) ->
- fun(match, {L,R,Bs}) -> match1(L, R, Bs, BBs);
+match_fun(BBs, Ef) ->
+ fun(match, {L,R,Bs}) -> match1(L, R, Bs, BBs, Ef);
 (binding, {Name,Bs}) -> binding(Name, Bs);
 (add_binding, {Name,Val,Bs}) -> add_binding(Name, Val, Bs)
 end.
 
-match_tuple([E|Es], Tuple, I, Bs0, BBs) ->
- {match,Bs} = match1(E, element(I, Tuple), Bs0, BBs),
- match_tuple(Es, Tuple, I+1, Bs, BBs);
-match_tuple([], _, _, Bs, _BBs) ->
+match_tuple([E|Es], Tuple, I, Bs0, BBs, Ef) ->
+ {match,Bs} = match1(E, element(I, Tuple), Bs0, BBs, Ef),
+ match_tuple(Es, Tuple, I+1, Bs, BBs, Ef);
+match_tuple([], _, _, Bs, _BBs, _Ef) ->
 {match,Bs}.
 
-match_map([{map_field_exact, _, K, V}|Fs], Map, Bs0, BBs) ->
+match_map([{map_field_exact, _, K, V}|Fs], Map, Bs0, BBs, Ef) ->
 Vm = try
 	{value, Ke, _} = expr(K, BBs),
 	maps:get(Ke,Map)
 catch error:_ ->
 	throw(nomatch)
 end,
- {match, Bs} = match1(V, Vm, Bs0, BBs),
- match_map(Fs, Map, Bs, BBs);
-match_map([], _, Bs, _) ->
+ {match, Bs} = match1(V, Vm, Bs0, BBs, Ef),
+ match_map(Fs, Map, Bs, BBs, Ef);
+match_map([], _, Bs, _, _) ->
 {match, Bs}.
 
-%% match_list(PatternList, TermList, Bindings) ->
+%% match_list(PatternList, TermList, Anno, NewBindings, Bindings, ExternalFunHnd) ->
 %%	{match,NewBindings} | nomatch
 %% Try to match a list of patterns against a list of terms with the
 %% current bindings.
 
-match_list(Ps, Ts, Bs) ->
- match_list(Ps, Ts, Bs, Bs).
-
-match_list([P|Ps], [T|Ts], Bs0, BBs) ->
- case match(P, T, Bs0, BBs) of
-	{match,Bs1} -> match_list(Ps, Ts, Bs1, BBs);
+match_list([P|Ps], [T|Ts], Anno, Bs0, BBs, Ef) ->
+ case match(P, T, Anno, Bs0, BBs, Ef) of
+	{match,Bs1} -> match_list(Ps, Ts, Anno, Bs1, BBs, Ef);
 	nomatch -> nomatch
 end;
-match_list([], [], Bs, _BBs) ->
+match_list([], [], _Anno, Bs, _BBs, _Ef) ->
 {match,Bs};
-match_list(_, _, _Bs, _BBs) ->
+match_list(_, _, _Anno, _Bs, _BBs, _Ef) ->
 nomatch.
 
 %% new_bindings()
@@ -1313,17 +1317,17 @@ add_bindings(Bs1, Bs2) ->
 foldl(fun ({Name,Val}, Bs) -> orddict:store(Name, Val, Bs) end,
 	 Bs2, orddict:to_list(Bs1)).
 
-merge_bindings(Bs1, Bs2) when is_map(Bs1), is_map(Bs2) ->
+merge_bindings(Bs1, Bs2, Anno, Ef) when is_map(Bs1), is_map(Bs2) ->
 maps:merge_with(fun
 	(_K, V, V) -> V;
-	(_K, _, V) -> erlang:raise(error, {badmatch,V}, ?STACKTRACE)
+	(_K, _, V) -> apply_error({badmatch,V}, ?STACKTRACE, Anno, Bs1, Ef, none)
 end, Bs2, Bs1);
-merge_bindings(Bs1, Bs2) ->
+merge_bindings(Bs1, Bs2, Anno, Ef) ->
 foldl(fun ({Name,Val}, Bs) ->
 		 case orddict:find(Name, Bs) of
 		 {ok,Val} -> Bs;		%Already with SAME value
 		 {ok,V1} ->
-			 erlang:raise(error, {badmatch,V1}, ?STACKTRACE);
+			 apply_error({badmatch,V1}, ?STACKTRACE, Anno, Bs1, Ef, none);
 		 error -> orddict:store(Name, Val, Bs)
 		 end end,
 	 Bs2, orddict:to_list(Bs1)).
@@ -1413,10 +1417,10 @@ expr_fixup([E0|Es0]) ->
 expr_fixup(T) ->
 T.
 
-string_fixup(Ann, String, Token) ->
- Text = erl_anno:text(Ann),
+string_fixup(Anno, String, Token) ->
+ Text = erl_anno:text(Anno),
 FixupTag = fixup_tag(Text, String),
- fixup_ast(FixupTag, Ann, String, Token).
+ fixup_ast(FixupTag, Anno, String, Token).
 
 reset_token_anno(Tokens) ->
 [setelement(2, T, (reset_anno())(element(2, T))) || T <- Tokens].
@@ -1503,7 +1507,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/stdlib/src/erl_parse.yrl b/lib/stdlib/src/erl_parse.yrl
index 33569d4a8d..f562c6d50a 100644
--- a/lib/stdlib/src/erl_parse.yrl
+++ b/lib/stdlib/src/erl_parse.yrl
@@ -1397,7 +1397,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/stdlib/src/eval_bits.erl b/lib/stdlib/src/eval_bits.erl
index 966bc65902..09ec175dc4 100644
--- a/lib/stdlib/src/eval_bits.erl
+++ b/lib/stdlib/src/eval_bits.erl
@@ -22,8 +22,8 @@
 
 %% Avoid warning for local function error/1 clashing with autoimported BIF.
 -compile({no_auto_import,[error/1]}).
--export([expr_grp/3,expr_grp/5,match_bits/6, 
-	 match_bits/7,bin_gen/6]).
+-export([expr_grp/3,expr_grp/4,match_bits/6,
+	 match_bits/7,bin_gen/6,bin_gen/7]).
 
 -define(STACKTRACE,
 element(2, erlang:process_info(self(), current_stacktrace))).
@@ -40,11 +40,13 @@
 %% lookup a variable in the bindings, or add a new binding
 %%
 %% @type field(). Represents a field in a "bin".
+%%
+%% @type errorfun(). A closure invoked in case of errors.
 
 %%% Part 1: expression evaluation (binary construction)
 
 %% @spec expr_grp(Fields::[field()], Bindings::bindings(), 
-%% EvalFun::evalfun(), term(), term()) ->
+%% EvalFun::evalfun(), ErrorFun::errorfun()) ->
 %% {value, binary(), bindings()}
 %%
 %% @doc Returns a tuple with {value,Bin,Bs} where Bin is the binary
@@ -52,29 +54,23 @@
 %% contains the present bindings. This function can also throw an
 %% exception if the construction fails.
 
-expr_grp(Fields, Bindings, EvalFun, [], _) ->
- expr_grp(Fields, Bindings, EvalFun, <<>>);
-expr_grp(Fields, Bindings, EvalFun, ListOfBits, _) ->
- Bin = convert_list(ListOfBits),
- expr_grp(Fields, Bindings, EvalFun, Bin).
-
-convert_list(List) ->
- << <<X:1>> || X <- List >>.
+expr_grp(Fields, Bindings, EvalFun, ErrorFun) ->
+ expr_grp(Fields, Bindings, EvalFun, ErrorFun, <<>>).
 
 expr_grp(Fields, Bindings, EvalFun) ->
- expr_grp(Fields, Bindings, EvalFun, <<>>).
+ expr_grp(Fields, Bindings, EvalFun, fun default_error/3, <<>>).
 
-expr_grp(FS, Bs0, Ef, Acc) ->
+expr_grp(FS, Bs0, EvalFun, ErrorFun, Acc) ->
 %% Separate the evaluation of values, sizes, and TLS:s from the
 %% creation of the binary in order to mimic compiled code when it
 %% comes to loops and failures.
- {ListOfEvalField,Bs1} = expr_grp1(FS, Bs0, Ef, []),
+ {ListOfEvalField,Bs1} = expr_grp1(FS, Bs0, EvalFun, ErrorFun, []),
 {value,create_binary(ListOfEvalField, Acc),Bs1}.
 
-expr_grp1([Field | FS], Bs0, Ef, ListOfEvalField) ->
- {EvalField,Bs} = eval_field(Field, Bs0, Ef),
- expr_grp1(FS, Bs, Ef, [EvalField|ListOfEvalField]);
-expr_grp1([], Bs, _Ef, ListOfFieldData) ->
+expr_grp1([Field | FS], Bs0, EvalFun, ErrorFun, ListOfEvalField) ->
+ {EvalField,Bs} = eval_field(Field, Bs0, EvalFun, ErrorFun),
+ expr_grp1(FS, Bs, EvalFun, ErrorFun, [EvalField|ListOfEvalField]);
+expr_grp1([], Bs, _EvalFun, _ErrorFun, ListOfFieldData) ->
 {lists:reverse(ListOfFieldData),Bs}.
 
 create_binary([EvalField|ListOfEvalField], Acc) ->
@@ -83,44 +79,44 @@ create_binary([EvalField|ListOfEvalField], Acc) ->
 create_binary([], Acc) ->
 Acc.
 
-eval_field({bin_element, _, {string, _, S}, {integer,_,8}, [integer,{unit,1},unsigned,big]}, Bs0, _Fun) ->
+eval_field({bin_element, _, {string, _, S}, {integer,_,8}, [integer,{unit,1},unsigned,big]}, Bs0, _Fun, _ErrorFun) ->
 Latin1 = [C band 16#FF || C <- S],
 {fun() -> list_to_binary(Latin1) end,Bs0};
-eval_field({bin_element, _, {string, _, S}, default, default}, Bs0, _Fun) ->
+eval_field({bin_element, _, {string, _, S}, default, default}, Bs0, _Fun, _ErrorFun) ->
 Latin1 = [C band 16#FF || C <- S],
 {fun() ->list_to_binary(Latin1) end,Bs0};
-eval_field({bin_element, Anno, {string, _, S}, Size0, Options0}, Bs0, Fun) ->
+eval_field({bin_element, Anno, {string, _, S}, Size0, Options0}, Bs0, Fun, ErrorFun) ->
 {Size1,[Type,{unit,Unit},Sign,Endian]} =
- make_bit_type(Anno, Size0, Options0),
+ make_bit_type(Anno, Size0, Options0, ErrorFun),
 {value,Size,Bs1} = Fun(Size1, Bs0),
 {fun() ->
- Res = << <<(eval_exp_field1(C, Size, Unit,
- Type, Endian, Sign))/bitstring>> ||
+ Res = << <<(eval_exp_field1(Anno, C, Size, Unit,
+ Type, Endian, Sign, ErrorFun))/bitstring>> ||
 C <- S >>,
 case S of
 "" -> % find errors also when the string is empty
- _ = eval_exp_field1(0, Size, Unit, Type, Endian, Sign),
+ _ = eval_exp_field1(Anno, 0, Size, Unit, Type, Endian, Sign, ErrorFun),
 ok;
 _ ->
 ok
 end,
 Res
 end,Bs1};
-eval_field({bin_element,Anno,E,Size0,Options0}, Bs0, Fun) ->
+eval_field({bin_element,Anno,E,Size0,Options0}, Bs0, Fun, ErrorFun) ->
 {value,V,Bs1} = Fun(E, Bs0),
 {Size1,[Type,{unit,Unit},Sign,Endian]} = 
- make_bit_type(Anno, Size0, Options0),
+ make_bit_type(Anno, Size0, Options0, ErrorFun),
 {value,Size,Bs} = Fun(Size1, Bs1),
- {fun() -> eval_exp_field1(V, Size, Unit, Type, Endian, Sign) end,Bs}.
+ {fun() -> eval_exp_field1(Anno, V, Size, Unit, Type, Endian, Sign, ErrorFun) end,Bs}.
 
-eval_exp_field1(V, Size, Unit, Type, Endian, Sign) ->
+eval_exp_field1(Anno, V, Size, Unit, Type, Endian, Sign, ErrorFun) ->
 try
 	eval_exp_field(V, Size, Unit, Type, Endian, Sign)
 catch
 	error:system_limit ->
-	 erlang:raise(error, system_limit, ?STACKTRACE);
+ ErrorFun(Anno, system_limit, ?STACKTRACE);
 	error:_ ->
-	 erlang:raise(error, badarg, ?STACKTRACE)
+ ErrorFun(Anno, badarg, ?STACKTRACE)
 end.
 
 eval_exp_field(Val, Size, Unit, integer, little, signed) ->
@@ -169,7 +165,8 @@ eval_exp_field(Val, Size, Unit, binary, _, _) ->
 %%% Part 2: matching in binary comprehensions
 %% @spec bin_gen(BinPattern::{bin,integer(),[field()]}, Bin::binary(),
 %% GlobalEnv::bindings(), LocalEnv::bindings(), 
-%% MatchFun::matchfun(), EvalFun::evalfun()) -> 
+%% MatchFun::matchfun(), EvalFun::evalfun(),
+%% ErrorFun::errorfun()) ->
 %% {match, binary(), bindings()} | {nomatch, binary()} | done
 %%
 %% @doc Used to perform matching in a comprehension. If the match
@@ -178,25 +175,28 @@ eval_exp_field(Val, Size, Unit, binary, _, _) ->
 %% If nothing remains of the binary the atom 'done' is returned.
 
 bin_gen({bin,_,Fs}, Bin, Bs0, BBs0, Mfun, Efun) ->
- bin_gen(Fs, Bin, Bs0, BBs0, Mfun, Efun, true).
+ bin_gen(Fs, Bin, Bs0, BBs0, Mfun, Efun, fun default_error/3, true).
 
-bin_gen([F|Fs], Bin, Bs0, BBs0, Mfun, Efun, Flag)
+bin_gen({bin,_,Fs}, Bin, Bs0, BBs0, Mfun, Efun, ErrorFun) ->
+ bin_gen(Fs, Bin, Bs0, BBs0, Mfun, Efun, ErrorFun, true).
+
+bin_gen([F|Fs], Bin, Bs0, BBs0, Mfun, Efun, ErrorFun, Flag)
 when is_function(Mfun, 2), is_function(Efun, 2) ->
- case bin_gen_field(F, Bin, Bs0, BBs0, Mfun, Efun) of
+ case bin_gen_field(F, Bin, Bs0, BBs0, Mfun, Efun, ErrorFun) of
 {match,Bs,BBs,Rest} ->
- bin_gen(Fs, Rest, Bs, BBs, Mfun, Efun, Flag);
+ bin_gen(Fs, Rest, Bs, BBs, Mfun, Efun, ErrorFun, Flag);
 {nomatch,Rest} ->
- bin_gen(Fs, Rest, Bs0, BBs0, Mfun, Efun, false);
+ bin_gen(Fs, Rest, Bs0, BBs0, Mfun, Efun, ErrorFun, false);
 done ->
 done
 end;
-bin_gen([], Bin, Bs0, _BBs0, _Mfun, _Efun, true) ->
+bin_gen([], Bin, Bs0, _BBs0, _Mfun, _Efun, _ErrorFun, true) ->
 {match, Bin, Bs0};
-bin_gen([], Bin, _Bs0, _BBs0, _Mfun, _Efun, false) ->
+bin_gen([], Bin, _Bs0, _BBs0, _Mfun, _Efun, _ErrorFun, false) ->
 {nomatch, Bin}.
 
 bin_gen_field({bin_element,_,{string,_,S},default,default},
- Bin, Bs, BBs, _Mfun, _Efun) ->
+ Bin, Bs, BBs, _Mfun, _Efun, _ErrorFun) ->
 Bits = try list_to_binary(S)
 catch _:_ -> <<>>
 end,
@@ -210,9 +210,9 @@ bin_gen_field({bin_element,_,{string,_,S},default,default},
 done
 end;
 bin_gen_field({bin_element,Anno,{string,SAnno,S},Size0,Options0},
- Bin0, Bs0, BBs0, Mfun, Efun) ->
+ Bin0, Bs0, BBs0, Mfun, Efun, ErrorFun) ->
 {Size1, [Type,{unit,Unit},Sign,Endian]} =
- make_bit_type(Anno, Size0, Options0),
+ make_bit_type(Anno, Size0, Options0, ErrorFun),
 case catch Efun(Size1, BBs0) of
 {value, Size, _BBs} -> % 
 F = fun(C, Bin, Bs, BBs) ->
@@ -222,9 +222,9 @@ bin_gen_field({bin_element,Anno,{string,SAnno,S},Size0,Options0},
 bin_gen_field_string(S, Bin0, Bs0, BBs0, F)
 end;
 bin_gen_field({bin_element,Anno,VE,Size0,Options0},
- Bin, Bs0, BBs0, Mfun, Efun) ->
+ Bin, Bs0, BBs0, Mfun, Efun, ErrorFun) ->
 {Size1, [Type,{unit,Unit},Sign,Endian]} = 
- make_bit_type(Anno, Size0, Options0),
+ make_bit_type(Anno, Size0, Options0, ErrorFun),
 V = erl_eval:partial_eval(VE),
 NewV = coerce_to_float(V, Type),
 case catch Efun(Size1, BBs0) of
@@ -264,41 +264,42 @@ bin_gen_field1(Bin, Type, Size, Unit, Sign, Endian, NewV, Bs0, BBs0, Mfun) ->
 %%% Part 3: binary pattern matching 
 %% @spec match_bits(Fields::[field()], Bin::binary(),
 %% GlobalEnv::bindings(), LocalEnv::bindings(), 
-%% MatchFun::matchfun(),EvalFun::evalfun(), term()) ->
-%% {match, bindings()} 
+%% MatchFun::matchfun(),EvalFun::evalfun(),
+%% ErrorFun::errorfun()) ->
+%% {match, bindings()}
 %% @doc Used to perform matching. If the match succeeds a new
 %% environment is returned. If the match have some syntactic or
 %% semantic problem which would have been caught at compile time this
 %% function throws 'invalid', if the matching fails for other reasons
 %% the function throws 'nomatch'
 
-match_bits(Fs, Bin, Bs0, BBs, Mfun, Efun, _) ->
- match_bits(Fs, Bin, Bs0, BBs, Mfun, Efun).
+match_bits(Fs, Bin, Bs0, BBs, Mfun, Efun) ->
+ match_bits(Fs, Bin, Bs0, BBs, Mfun, Efun, fun default_error/3).
 
-match_bits(Fs, Bin, Bs0, BBs, Mfun, Efun)
- when is_function(Mfun, 2), is_function(Efun, 2) ->
- case catch match_bits_1(Fs, Bin, Bs0, BBs, Mfun, Efun) of
+match_bits(Fs, Bin, Bs0, BBs, Mfun, Efun, ErrorFun)
+ when is_function(Mfun, 2), is_function(Efun, 2), is_function(ErrorFun, 3) ->
+ case catch match_bits_1(Fs, Bin, Bs0, BBs, Mfun, Efun, ErrorFun) of
 {match,Bs} -> {match,Bs};
 invalid -> throw(invalid);
 _Error -> throw(nomatch)
 end.
 
-match_bits_1([], <<>>, Bs, _BBs, _Mfun, _Efun) -> 
+match_bits_1([], <<>>, Bs, _BBs, _Mfun, _Efun, _ErrorFun) ->
 {match,Bs};
-match_bits_1([F|Fs], Bits0, Bs0, BBs0, Mfun, Efun) ->
- {Bs,BBs,Bits} = match_field_1(F, Bits0, Bs0, BBs0, Mfun, Efun),
- match_bits_1(Fs, Bits, Bs, BBs, Mfun, Efun).
+match_bits_1([F|Fs], Bits0, Bs0, BBs0, Mfun, Efun, ErrorFun) ->
+ {Bs,BBs,Bits} = match_field_1(F, Bits0, Bs0, BBs0, Mfun, Efun, ErrorFun),
+ match_bits_1(Fs, Bits, Bs, BBs, Mfun, Efun, ErrorFun).
 
 match_field_1({bin_element,_,{string,_,S},default,default},
- Bin, Bs, BBs, _Mfun, _Efun) ->
+ Bin, Bs, BBs, _Mfun, _Efun, _ErrorFun) ->
 Bits = list_to_binary(S), % fails if there are characters > 255
 Size = byte_size(Bits),
 <<Bits:Size/binary,Rest/binary-unit:1>> = Bin,
 {Bs,BBs,Rest};
 match_field_1({bin_element,Anno,{string,SAnno,S},Size0,Options0},
- Bin0, Bs0, BBs0, Mfun, Efun) ->
+ Bin0, Bs0, BBs0, Mfun, Efun, ErrorFun) ->
 {Size1, [Type,{unit,Unit},Sign,Endian]} =
- make_bit_type(Anno, Size0, Options0),
+ make_bit_type(Anno, Size0, Options0, ErrorFun),
 Size2 = erl_eval:partial_eval(Size1),
 {value, Size, _BBs} = Efun(Size2, BBs0),
 F = fun(C, Bin, Bs, BBs) ->
@@ -307,9 +308,9 @@ match_field_1({bin_element,Anno,{string,SAnno,S},Size0,Options0},
 end,
 match_field_string(S, Bin0, Bs0, BBs0, F);
 match_field_1({bin_element,Anno,VE,Size0,Options0},
- Bin, Bs0, BBs0, Mfun, Efun) ->
+ Bin, Bs0, BBs0, Mfun, Efun, ErrorFun) ->
 {Size1, [Type,{unit,Unit},Sign,Endian]} = 
- make_bit_type(Anno, Size0, Options0),
+ make_bit_type(Anno, Size0, Options0, ErrorFun),
 V = erl_eval:partial_eval(VE),
 NewV = coerce_to_float(V, Type),
 Size2 = erl_eval:partial_eval(Size1),
@@ -410,15 +411,18 @@ get_float(Bin, Size, big) ->
 {Val,Rest}.
 
 %% Identical to the one in sys_pre_expand.
-make_bit_type(Anno, default, Type0) ->
+make_bit_type(Anno, default, Type0, ErrorFun) ->
 case erl_bits:set_bit_type(default, Type0) of
 {ok,all,Bt} -> {{atom,Anno,all},erl_bits:as_list(Bt)};
 	{ok,undefined,Bt} -> {{atom,Anno,undefined},erl_bits:as_list(Bt)};
 {ok,Size,Bt} -> {{integer,Anno,Size},erl_bits:as_list(Bt)};
- {error,Reason} -> erlang:raise(error, Reason, ?STACKTRACE)
+ {error,Reason} -> ErrorFun(Anno, Reason, ?STACKTRACE)
 end;
-make_bit_type(_Anno, Size, Type0) -> %Size evaluates to an integer or 'all'
+make_bit_type(Anno, Size, Type0, ErrorFun) -> %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} -> erlang:raise(error, Reason, ?STACKTRACE)
+ {error,Reason} -> ErrorFun(Anno, Reason, ?STACKTRACE)
 end.
+
+default_error(_Anno, Reason, Stacktrace) ->
+ erlang:raise(error, Reason, Stacktrace).
diff --git a/lib/stdlib/src/ms_transform.erl b/lib/stdlib/src/ms_transform.erl
index b9fa534a69..51d4600d40 100644
--- a/lib/stdlib/src/ms_transform.erl
+++ b/lib/stdlib/src/ms_transform.erl
@@ -1126,7 +1126,7 @@ normalise({bin,_,Fs}) ->
 	eval_bits:expr_grp(Fs, [],
 			 fun(E, _) ->
 				 {value, normalise(E), []}
-			 end, [], true),
+			 end),
 B;
 normalise({cons,_,Head,Tail}) ->
 [normalise(Head)|normalise(Tail)];
diff --git a/lib/stdlib/test/erl_eval_SUITE.erl b/lib/stdlib/test/erl_eval_SUITE.erl
index f4d58e61c5..16a92f7ff5 100644
--- a/lib/stdlib/test/erl_eval_SUITE.erl
+++ b/lib/stdlib/test/erl_eval_SUITE.erl
@@ -43,6 +43,7 @@
 otp_13228/1,
 otp_14826/1,
 funs/1,
+ custom_stacktrace/1,
 	 try_catch/1,
 	 eval_expr_5/1,
 	 zero_width/1,
@@ -91,7 +92,7 @@ all() ->
 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_14826,
- funs, try_catch, eval_expr_5, zero_width,
+ funs, custom_stacktrace, try_catch, eval_expr_5, zero_width,
 eep37, eep43, otp_15035, otp_16439, otp_14708, otp_16545, otp_16865].
 
 groups() -> 
@@ -1000,7 +1001,7 @@ 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,7},
+ {erl_eval,eval_fun,8},
 ?MODULE]),
 backtrace_check("B.",
 {unbound_var, 'B'},
@@ -1012,11 +1013,11 @@ otp_14826(_Config) ->
 backtrace_check("1/0.",
 badarith,
 [{erlang,'/',[1,0],[]},
- {erl_eval,do_apply,6}]),
+ {erl_eval,do_apply,7}]),
 backtrace_catch("catch 1/0.",
 badarith,
 [{erlang,'/',[1,0],[]},
- {erl_eval,do_apply,6}]),
+ {erl_eval,do_apply,7}]),
 check(fun() -> catch exit(foo) end,
 "catch exit(foo).",
 {'EXIT', foo}),
@@ -1026,33 +1027,33 @@ otp_14826(_Config) ->
 backtrace_check("try 1/0 after foo end.",
 badarith,
 [{erlang,'/',[1,0],[]},
- {erl_eval,do_apply,6}]),
+ {erl_eval,do_apply,7}]),
 backtrace_catch("catch (try 1/0 after foo end).",
 badarith,
 [{erlang,'/',[1,0],[]},
- {erl_eval,do_apply,6}]),
+ {erl_eval,do_apply,7}]),
 backtrace_catch("try catch 1/0 after foo end.",
 badarith,
 [{erlang,'/',[1,0],[]},
- {erl_eval,do_apply,6}]),
+ {erl_eval,do_apply,7}]),
 backtrace_check("try a of b -> bar after foo end.",
 {try_clause,a},
- [{erl_eval,try_clauses,9}]),
+ [{erl_eval,try_clauses,10}]),
 check(fun() -> X = try foo:bar() catch A:B:C -> {A,B} end, X end,
 "try foo:bar() catch A:B:C -> {A,B} end.",
 {error, undef}),
 backtrace_check("C = 4, try foo:bar() catch A:B:C -> {A,B,C} end.",
 stacktrace_bound,
- [{erl_eval,check_stacktrace_vars,2},
- {erl_eval,try_clauses,9}],
+ [{erl_eval,check_stacktrace_vars,5},
+ {erl_eval,try_clauses,10}],
 none, none),
 backtrace_catch("catch (try a of b -> bar after foo end).",
 {try_clause,a},
- [{erl_eval,try_clauses,9}]),
+ [{erl_eval,try_clauses,10}]),
 backtrace_check("try 1/0 catch exit:a -> foo end.",
 badarith,
 [{erlang,'/',[1,0],[]},
- {erl_eval,do_apply,6}]),
+ {erl_eval,do_apply,7}]),
 Es = [{'try',1,[{call,1,{remote,1,{atom,1,foo},{atom,1,bar}},[]}],
 [],
 [{clause,1,[{tuple,1,[{var,1,'A'},{var,1,'B'},{atom,1,'C'}]}],
@@ -1062,8 +1063,8 @@ otp_14826(_Config) ->
 ct:fail(stacktrace_variable)
 catch
 error:{illegal_stacktrace_variable,{atom,1,'C'}}:S ->
- [{erl_eval,check_stacktrace_vars,2,_},
- {erl_eval,try_clauses,9,_}|_] = S
+ [{erl_eval,check_stacktrace_vars,5,_},
+ {erl_eval,try_clauses,10,_}|_] = S
 end,
 backtrace_check("{1,1} = {A = 1, A = 2}.",
 {badmatch, 1},
@@ -1073,40 +1074,40 @@ otp_14826(_Config) ->
 [{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),
+ [{erl_eval,match,6}], none, none),
 backtrace_check("case a of b -> ok end.",
 {case_clause,a},
- [{erl_eval,case_clauses,7}, ?MODULE]),
+ [{erl_eval,case_clauses,8}, ?MODULE]),
 backtrace_check("if a =:= b -> ok end.",
 if_clause,
- [{erl_eval,if_clauses,6}, ?MODULE]),
+ [{erl_eval,if_clauses,7}, ?MODULE]),
 backtrace_check("fun A(b) -> ok end(a).",
 function_clause,
 [{erl_eval,'-inside-an-interpreted-fun-',[a],[]},
- {erl_eval,eval_named_fun,9},
+ {erl_eval,eval_named_fun,10},
 ?MODULE]),
 backtrace_check("[A || A <- a].",
 {bad_generator, a},
- [{erl_eval,eval_generate,7}, {erl_eval, eval_lc, 7}]),
+ [{erl_eval,eval_generate,8}, {erl_eval, eval_lc, 7}]),
 backtrace_check("<< <<A>> || <<A>> <= a>>.",
 {bad_generator, a},
- [{erl_eval,eval_b_generate,7}, {erl_eval, eval_bc, 7}]),
+ [{erl_eval,eval_b_generate,8}, {erl_eval, eval_bc, 7}]),
 backtrace_check("[A || A <- [1], begin a end].",
 {bad_filter, a},
- [{erl_eval,eval_filter,7}, {erl_eval, eval_generate, 7}]),
+ [{erl_eval,eval_filter,7}, {erl_eval, eval_generate, 8}]),
 fun() ->
 {'EXIT', {{badarity, {_Fun, []}}, BT}} =
 (catch parse_and_run("fun(A) -> A end().")),
- check_backtrace([{erl_eval,do_apply,5}, ?MODULE], BT)
+ check_backtrace([{erl_eval,do_apply,6}, ?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)
+ check_backtrace([{erl_eval,do_apply,6}, ?MODULE], BT)
 end(),
 backtrace_check("foo().",
 undef,
- [{erl_eval,foo,0},{erl_eval,local_func,7}],
+ [{erl_eval,foo,0},{erl_eval,local_func,8}],
 none, none),
 backtrace_check("a orelse false.",
 {badarg, a},
@@ -1141,16 +1142,16 @@ otp_14826(_Config) ->
 %% eval_bits
 backtrace_check("<<100:8/bitstring>>.",
 badarg,
- [{eval_bits,eval_exp_field1,6},
+ [{eval_bits,eval_exp_field1,8},
 eval_bits,eval_bits,erl_eval]),
 backtrace_check("<<100:8/foo>>.",
 {undefined_bittype,foo},
- [{eval_bits,make_bit_type,3},eval_bits,
+ [{eval_bits,make_bit_type,4},eval_bits,
 eval_bits,eval_bits],
 none, none),
 backtrace_check("B = <<\"foo\">>, <<B/binary-unit:7>>.",
 badarg,
- [{eval_bits,eval_exp_field1,6},
+ [{eval_bits,eval_exp_field1,8},
 eval_bits,eval_bits,erl_eval],
 none, none),
 ok.
@@ -1172,13 +1173,143 @@ simple1() ->
 WillNeverHappen -> WillNeverHappen
 end.
 
+custom_stacktrace(Config) when is_list(Config) ->
+ EFH = {value, fun custom_stacktrace_eval_handler/3},
+
+ backtrace_check("1 + atom.", badarith,
+ [{erlang,'+',[1,atom]}, mystack(1)], none, EFH),
+ backtrace_check("\n1 + atom.", badarith,
+ [{erlang,'+',[1,atom]}, mystack(2)], none, EFH),
+
+ backtrace_check("lists:flatten(atom).", function_clause,
+ [{lists,flatten,[atom]}, mystack(1)], none, EFH),
+
+ backtrace_check("invalid andalso true.", {badarg, invalid},
+ [mystack(1)], none, EFH),
+ backtrace_check("invalid orelse true.", {badarg, invalid},
+ [mystack(1)], none, EFH),
+
+ backtrace_check("invalid = valid.", {badmatch, valid},
+ [erl_eval, mystack(1)], none, EFH),
+
+ backtrace_check("1:2.", {badexpr, ':'},
+ [erl_eval, mystack(1)], none, EFH),
+
+ backtrace_check("Unknown.", {unbound, 'Unknown'},
+ [erl_eval, mystack(1)], none, EFH),
+
+ backtrace_check("#unknown{}.", {undef_record,unknown},
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("#unknown{foo=bar}.", {undef_record,unknown},
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("#unknown.index.", {undef_record,unknown},
+ [erl_eval, mystack(1)], none, EFH),
+
+ backtrace_check("fun foo/2.", undef,
+ [{erl_eval, foo, 2}, erl_eval, mystack(1)], none, EFH),
+ backtrace_check("foo(1, 2).", undef,
+ [{erl_eval, foo, 2}, erl_eval, mystack(1)], none, EFH),
+
+ fun() ->
+ {'EXIT', {{badarity, {_Fun, []}}, BT}} =
+ (catch parse_and_run("fun(A) -> A end().", none, EFH)),
+ check_backtrace([erl_eval, mystack(1)], BT)
+ end(),
+
+ fun() ->
+ {'EXIT', {{badarity, {_Fun, []}}, BT}} =
+ (catch parse_and_run("fun F(A) -> A end().", none, EFH)),
+ check_backtrace([erl_eval, mystack(1)], BT)
+ end(),
+
+ backtrace_check("[X || X <- 1].", {bad_generator, 1},
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("[X || <<X>> <= 1].", {bad_generator, 1},
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("<<X || X <- 1>>.", {bad_generator, 1},
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("<<X || <<X>> <= 1>>.", {bad_generator, 1},
+ [erl_eval, mystack(1)], none, EFH),
+
+ backtrace_check("if false -> true end.", if_clause,
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("case 0 of 1 -> true end.", {case_clause, 0},
+ [erl_eval, mystack(1)], none, EFH),
+ backtrace_check("try 0 of 1 -> true after ok end.", {try_clause, 0},
+ [mystack(1)], none, EFH),
+
+ backtrace_check("fun(0) -> 1 end(1).", function_clause,
+ [{erl_eval,'-inside-an-interpreted-fun-', [1]}, erl_eval, mystack(1)],
+ none, EFH),
+ backtrace_check("fun F(0) -> 1 end(1).", function_clause,
+ [{erl_eval,'-inside-an-interpreted-fun-', [1]}, erl_eval, mystack(1)],
+ none, EFH),
+
+ fun() ->
+ {'EXIT', {{illegal_pattern,_}, BT}} =
+ (catch parse_and_run("make_ref() = 1.", none, EFH)),
+ check_backtrace([erl_eval, mystack(1)], BT)
+ end(),
+
+ %% eval_bits
+ backtrace_check("<<100:8/bitstring>>.",
+ badarg,
+ [{eval_bits,eval_exp_field1,8}, mystack(1)],
+ none, EFH),
+ backtrace_check("<<100:8/foo>>.",
+ {undefined_bittype,foo},
+ [{eval_bits,make_bit_type,4}, mystack(1)],
+ none, EFH),
+ backtrace_check("B = <<\"foo\">>, <<B/binary-unit:7>>.",
+ badarg,
+ [{eval_bits,eval_exp_field1,8}, mystack(1)],
+ none, EFH),
+
+ ok.
+
+mystack(Line) ->
+ {my_module, my_function, 0, [{file, "evaluator"}, {line, Line}]}.
+
+custom_stacktrace_eval_handler(Ann, FunOrModFun, Args) ->
+ try
+ case FunOrModFun of
+ {Mod, Fun} -> apply(Mod, Fun, Args);
+ Fun -> apply(Fun, Args)
+ end
+ catch
+ Kind:Reason:Stacktrace ->
+ %% Take everything up to the evaluation function
+ Pruned =
+ lists:takewhile(fun
+ ({erl_eval_SUITE,backtrace_check,5,_}) -> false;
+ (_) -> true
+ end, Stacktrace),
+ %% Now we prune any shared code path from erl_eval
+ {current_stacktrace, Current} =
+ erlang:process_info(self(), current_stacktrace),
+ Reversed = drop_common(lists:reverse(Current), lists:reverse(Pruned)),
+ Location = [{file, "evaluator"}, {line, erl_anno:line(Ann)}],
+ %% Add our file+line information at the bottom
+ Custom = lists:reverse([{my_module, my_function, 0, Location} | Reversed]),
+ erlang:raise(Kind, Reason, Custom)
+ end.
+
+drop_common([H | T1], [H | T2]) -> drop_common(T1, T2);
+drop_common([H | T1], T2) -> drop_common(T1, T2);
+drop_common([], [{?MODULE, custom_stacktrace_eval_handler, _, _} | T2]) -> T2;
+drop_common([], T2) -> T2.
+
 %% Simple cases, just to cover some code.
 funs(Config) when is_list(Config) ->
 do_funs(none, none),
 do_funs(lfh(), none),
+ do_funs(none, efh()),
 do_funs(lfh(), efh()),
+ do_funs(none, ann_efh()),
+ do_funs(lfh(), ann_efh()),
 
 error_check("nix:foo().", {access_not_allowed,nix}, lfh(), efh()),
+ error_check("nix:foo().", {access_not_allowed,nix}, lfh(), ann_efh()),
 error_check("bar().", undef, none, none),
 
 check(fun() -> F1 = fun(F,N) -> ?MODULE:count_down(F, N) end,
@@ -1217,6 +1348,15 @@ funs(Config) when is_list(Config) ->
 error_check("apply(timer, sleep, [1]).", got_it, none, EFH),
 error_check("begin F = fun(T) -> timer:sleep(T) end,F(1) end.",
 got_it, none, EFH),
+
+ AnnEF = fun(1, {timer,sleep}, As) when length(As) == 1 -> exit({got_it,sleep});
+ (1, {M,F}, As) -> apply(M, F, As)
+ end,
+ AnnEFH = {value, AnnEF},
+ error_check("apply(timer, sleep, [1]).", got_it, none, AnnEFH),
+ error_check("begin F = fun(T) -> timer:sleep(T) end,F(1) end.",
+ got_it, none, AnnEFH),
+
 error_check("fun c/1.", undef),
 error_check("fun a:b/0().", undef),
 
@@ -1398,6 +1538,9 @@ local_func_value(F, As) when is_atom(F) ->
 efh() ->
 {value, fun(F, As) -> external_func(F, As) end}.
 
+ann_efh() ->
+ {value, fun(_Ann, F, As) -> external_func(F, As) end}.
+
 external_func({M,_}, _As) when M == nix ->
 exit({{access_not_allowed,M},[mfa]});
 external_func(F, As) when is_function(F) ->
diff --git a/lib/stdlib/test/shell_SUITE.erl b/lib/stdlib/test/shell_SUITE.erl
index 56f1bb5b6f..89b745057f 100644
--- a/lib/stdlib/test/shell_SUITE.erl
+++ b/lib/stdlib/test/shell_SUITE.erl
@@ -256,6 +256,8 @@ restricted_local(Config) when is_list(Config) ->
 local_allowed(_,_,State) ->
 {false,State}.
 
+ non_local_allowed({erlang,raise},[error, _, _],State) ->
+ {true,State};
 non_local_allowed({shell,stop_restricted},[],State) ->
 {true,State};
 non_local_allowed(_,_,State) ->
diff --git a/lib/syntax_tools/src/erl_syntax.erl b/lib/syntax_tools/src/erl_syntax.erl
index 354b65c9a3..f62cfb4108 100644
--- a/lib/syntax_tools/src/erl_syntax.erl
+++ b/lib/syntax_tools/src/erl_syntax.erl
@@ -7310,7 +7310,7 @@ concrete(Node) ->
 		eval_bits:expr_grp(Fs, [],
 				 fun(F, _) ->
 					 {value, concrete(F), []}
-				 end, [], true),
+				 end),
 	 B;
 arity_qualifier ->
 A = erl_syntax:arity_qualifier_argument(Node),
-- 
2.34.1

Places

File 3331-Pass-Anno-to-ExternalFunctionHandler-in-erl_eval.patch of Package erlang (Revision 6bc8bdb9448218a96809a06da74b3d6e)

Places