Remove ?line macros

While we are it, also re-ident the files.

1 files changed, 278 insertions, 278 deletions

diff --git a/lib/debugger/test/trycatch_SUITE.erl b/lib/debugger/test/trycatch_SUITE.erl
index fe9868aafb..2857cac9a3 100644
--- a/lib/debugger/test/trycatch_SUITE.erl
+++ b/lib/debugger/test/trycatch_SUITE.erl
@@ -60,40 +60,40 @@ end_per_testcase(_Case, _Config) ->
     ok.
 
 init_per_suite(Config) when is_list(Config) ->
-    ?line test_lib:interpret(?MODULE),
-    ?line true = lists:member(?MODULE, int:interpreted()),
+    test_lib:interpret(?MODULE),
+    true = lists:member(?MODULE, int:interpreted()),
     Config.
 
 end_per_suite(Config) when is_list(Config) ->
     ok.
 
 basic(Conf) when is_list(Conf) ->
-    ?line 2 =
+    2 =
 	try my_div(4, 2)
 	catch
             Class:Reason -> {Class,Reason}
 	end,
-    ?line error =
+    error =
         try my_div(1, 0)
         catch
             error:badarith -> error
         end,
-    ?line error =
+    error =
         try 1/0
         catch
             error:badarith -> error
         end,
-    ?line ok =
+    ok =
         try my_add(53, atom)
         catch
             error:badarith -> ok
         end,
-    ?line exit_nisse =
+    exit_nisse =
         try exit(nisse)
 	catch
             exit:nisse -> exit_nisse
         end,
-    ?line ok =
+    ok =
         try throw(kalle)
         catch
             kalle -> ok
@@ -102,26 +102,26 @@ basic(Conf) when is_list(Conf) ->
     %% Try some stuff where the compiler will optimize away the try.
 
     V = id({a,variable}),
-    ?line V = try V catch nisse -> error end,
-    ?line 42 = try 42 catch nisse -> error end,
-    ?line [V] = try [V] catch nisse -> error end,
-    ?line {ok,V} = try {ok,V} catch nisse -> error end,
+    V = try V catch nisse -> error end,
+    42 = try 42 catch nisse -> error end,
+    [V] = try [V] catch nisse -> error end,
+    {ok,V} = try {ok,V} catch nisse -> error end,
 
     %% Same idea, but use an after too.
 
-    ?line V = try V catch nisse -> error after after_call() end,
-    ?line after_clean(),
-    ?line 42 = try 42 after after_call() end,
-    ?line after_clean(),
-    ?line [V] = try [V] catch nisse -> error after after_call() end,
-    ?line after_clean(),
-    ?line {ok,V} = try {ok,V} after after_call() end,
+    V = try V catch nisse -> error after after_call() end,
+    after_clean(),
+    42 = try 42 after after_call() end,
+    after_clean(),
+    [V] = try [V] catch nisse -> error after after_call() end,
+    after_clean(),
+    {ok,V} = try {ok,V} after after_call() end,
 
     %% Try/of
-    ?line ok = try V of
-              {a,variable} -> ok
-              catch nisse -> erro
-          end,
+    ok = try V of
+	     {a,variable} -> ok
+	 catch nisse -> erro
+	 end,
 
     ok.
 
@@ -132,24 +132,24 @@ after_clean() ->
     after_was_called = erase(basic).
 
 lean_throw(Conf) when is_list(Conf) ->
-    ?line {throw,kalle} =
+    {throw,kalle} =
         try throw(kalle)
         catch
             Kalle -> {throw,Kalle}
         end,
-    ?line {exit,kalle} =
+    {exit,kalle} =
         try exit(kalle)
         catch
             Throw1 -> {throw,Throw1};
 	    exit:Reason1 -> {exit,Reason1}
         end,
-    ?line {exit,kalle} =
+    {exit,kalle} =
         try exit(kalle)
         catch
 	    exit:Reason2 -> {exit,Reason2};
             Throw2 -> {throw,Throw2}
         end,
-    ?line {exit,kalle} =
+    {exit,kalle} =
         try try exit(kalle)
             catch
                 Throw3 -> {throw,Throw3}
@@ -160,25 +160,25 @@ lean_throw(Conf) when is_list(Conf) ->
     ok.
 
 try_of(Conf) when is_list(Conf) ->
-    ?line {ok,{some,content}} =
+    {ok,{some,content}} =
 	try_of_1({value,{good,{some,content}}}),
-    ?line {error,[other,content]} =
+    {error,[other,content]} =
 	try_of_1({value,{bad,[other,content]}}),
-    ?line {caught,{exit,{ex,it,[reason]}}} =
+    {caught,{exit,{ex,it,[reason]}}} =
 	try_of_1({exit,{ex,it,[reason]}}),
-    ?line {caught,{throw,[term,{in,a,{tuple}}]}} =
+    {caught,{throw,[term,{in,a,{tuple}}]}} =
 	try_of_1({throw,[term,{in,a,{tuple}}]}),
-    ?line {caught,{error,[bad,arg]}} =
+    {caught,{error,[bad,arg]}} =
 	try_of_1({error,[bad,arg]}),
-    ?line {caught,{error,badarith}} =
+    {caught,{error,badarith}} =
 	try_of_1({'div',{1,0}}),
-    ?line {caught,{error,badarith}} =
+    {caught,{error,badarith}} =
 	try_of_1({'add',{a,0}}),
-    ?line {caught,{error,badarg}} =
+    {caught,{error,badarg}} =
 	try_of_1({'abs',x}),
-    ?line {caught,{error,function_clause}} =
+    {caught,{error,function_clause}} =
 	try_of_1(illegal),
-    ?line {error,{try_clause,{some,other_garbage}}} =
+    {error,{try_clause,{some,other_garbage}}} =
 	try try_of_1({value,{some,other_garbage}})
         catch error:Reason -> {error,Reason}
         end,
@@ -190,33 +190,33 @@ try_of_1(X) ->
 	{bad,Y} -> {error,Y}
     catch
 	Class:Reason ->
-             {caught,{Class,Reason}}
+	    {caught,{Class,Reason}}
     end.
 
 try_after(Conf) when is_list(Conf) ->
-    ?line {{ok,[some,value],undefined},finalized} =
+    {{ok,[some,value],undefined},finalized} =
 	try_after_1({value,{ok,[some,value]}},finalized),
-    ?line {{error,badarith,undefined},finalized} =
+    {{error,badarith,undefined},finalized} =
 	try_after_1({'div',{1,0}},finalized),
-    ?line {{error,badarith,undefined},finalized} =
+    {{error,badarith,undefined},finalized} =
 	try_after_1({'add',{1,a}},finalized),
-    ?line {{error,badarg,undefined},finalized} =
+    {{error,badarg,undefined},finalized} =
 	try_after_1({'abs',a},finalized),
-    ?line {{error,[the,{reason}],undefined},finalized} =
+    {{error,[the,{reason}],undefined},finalized} =
 	try_after_1({error,[the,{reason}]},finalized),
-    ?line {{throw,{thrown,[reason]},undefined},finalized} =
+    {{throw,{thrown,[reason]},undefined},finalized} =
 	try_after_1({throw,{thrown,[reason]}},finalized),
-    ?line {{exit,{exited,{reason}},undefined},finalized} =
+    {{exit,{exited,{reason}},undefined},finalized} =
 	try_after_1({exit,{exited,{reason}}},finalized),
-    ?line {{error,function_clause,undefined},finalized} =
+    {{error,function_clause,undefined},finalized} =
 	try_after_1(function_clause,finalized),
-    ?line ok =
+    ok =
 	try try_after_1({'add',{1,1}}, finalized)
         catch
             error:{try_clause,2} -> ok
 	end,
-    ?line finalized = erase(try_after),
-    ?line ok =
+    finalized = erase(try_after),
+    ok =
         try try foo({exit,[reaso,{n}]})
             after put(try_after, finalized)
             end
@@ -243,7 +243,7 @@ try_after_1(X, Y) ->
 
 after_bind(Conf) when is_list(Conf) ->
     V = [make_ref(),self()|value],
-    ?line {value,{value,V}} =
+    {value,{value,V}} =
 	after_bind_1({value,V}, V, {value,V}),
     ok.
 
@@ -267,35 +267,35 @@ after_bind_1(X, V, Y) ->
 -endif.
 
 catch_oops(Conf) when is_list(Conf) ->
-    V = {v,[a,l|u],{e},self()},
-    ?line {value,V} = catch_oops_1({value,V}),
-    ?line {value,1} = catch_oops_1({'div',{1,1}}),
-    ?line {error,badarith} = catch_oops_1({'div',{1,0}}),
-    ?line {error,function_clause} = catch_oops_1(function_clause),
-    ?line {throw,V} = catch_oops_1({throw,V}),
-    ?line {exit,V} = catch_oops_1({exit,V}),
-    ok.
+	V = {v,[a,l|u],{e},self()},
+	{value,V} = catch_oops_1({value,V}),
+	{value,1} = catch_oops_1({'div',{1,1}}),
+	{error,badarith} = catch_oops_1({'div',{1,0}}),
+	{error,function_clause} = catch_oops_1(function_clause),
+	{throw,V} = catch_oops_1({throw,V}),
+	{exit,V} = catch_oops_1({exit,V}),
+	ok.
 
 catch_oops_1(X) ->
-    Ref = make_ref(),
-    try try foo({error,Ref})
-        catch
-            error:Ref ->
-	        foo(X)
-        end of
-        Value -> {value,Value}
-    catch
-        Class:Data -> {Class,Data}
-    end.
+	Ref = make_ref(),
+	try try foo({error,Ref})
+	    catch
+		error:Ref ->
+		    foo(X)
+	    end of
+	    Value -> {value,Value}
+	catch
+	    Class:Data -> {Class,Data}
+	end.
 
 
 
 after_oops(Conf) when is_list(Conf) ->
     V = {self(),make_ref()},
-    ?line {{value,V},V} = after_oops_1({value,V}, {value,V}),
-    ?line {{exit,V},V} = after_oops_1({exit,V}, {value,V}),
-    ?line {{error,V},undefined} = after_oops_1({value,V}, {error,V}),
-    ?line {{error,function_clause},undefined} =
+    {{value,V},V} = after_oops_1({value,V}, {value,V}),
+    {{exit,V},V} = after_oops_1({exit,V}, {value,V}),
+    {{error,V},undefined} = after_oops_1({value,V}, {error,V}),
+    {{error,function_clause},undefined} =
 	after_oops_1({exit,V}, function_clause),
     ok.
 
@@ -316,37 +316,37 @@ after_oops_1(X, Y) ->
 
 eclectic(Conf) when is_list(Conf) ->
     V = {make_ref(),3.1415926535,[[]|{}]},
-    ?line {{value,{value,V},V},V} =
+    {{value,{value,V},V},V} =
 	eclectic_1({foo,{value,{value,V}}}, undefined, {value,V}),
-    ?line {{'EXIT',{V,[{?MODULE,foo,_,_}|_]}},V} =
+    {{'EXIT',{V,[{?MODULE,foo,_,_}|_]}},V} =
 	eclectic_1({catch_foo,{error,V}}, undefined, {value,V}),
-    ?line {{error,{exit,V},{'EXIT',V}},V} =
+    {{error,{exit,V},{'EXIT',V}},V} =
 	eclectic_1({foo,{error,{exit,V}}}, error, {value,V}),
-    ?line {{value,{value,V},V},{'EXIT',{badarith,[{?MODULE,my_add,_,_}|_]}}} =
+    {{value,{value,V},V},{'EXIT',{badarith,[{?MODULE,my_add,_,_}|_]}}} =
 	eclectic_1({foo,{value,{value,V}}}, undefined, {'add',{0,a}}),
-    ?line {{'EXIT',V},V} =
+    {{'EXIT',V},V} =
 	eclectic_1({catch_foo,{exit,V}}, undefined, {throw,V}),
-    ?line {{error,{'div',{1,0}},{'EXIT',{badarith,[{?MODULE,my_div,_,_}|_]}}},
-	   {'EXIT',V}} =
+    {{error,{'div',{1,0}},{'EXIT',{badarith,[{?MODULE,my_div,_,_}|_]}}},
+     {'EXIT',V}} =
 	eclectic_1({foo,{error,{'div',{1,0}}}}, error, {exit,V}),
-    ?line {{{error,V},{'EXIT',{V,[{?MODULE,foo,_,_}|_]}}},{'EXIT',V}} =
+    {{{error,V},{'EXIT',{V,[{?MODULE,foo,_,_}|_]}}},{'EXIT',V}} =
 	eclectic_1({catch_foo,{throw,{error,V}}}, undefined, {exit,V}),
     %%
-    ?line {{value,{value,{value,V},V}},V} =
+    {{value,{value,{value,V},V}},V} =
 	eclectic_2({value,{value,V}}, undefined, {value,V}),
-    ?line {{value,{throw,{value,V},V}},V} =
+    {{value,{throw,{value,V},V}},V} =
 	eclectic_2({throw,{value,V}}, throw, {value,V}),
-    ?line {{caught,{'EXIT',V}},undefined} =
+    {{caught,{'EXIT',V}},undefined} =
 	eclectic_2({value,{value,V}}, undefined, {exit,V}),
-    ?line {{caught,{'EXIT',{V,[{?MODULE,foo,_,_}|_]}}},undefined} =
+    {{caught,{'EXIT',{V,[{?MODULE,foo,_,_}|_]}}},undefined} =
 	eclectic_2({error,{value,V}}, throw, {error,V}),
-    ?line {{caught,{'EXIT',{badarg,[{erlang,abs,[V],_}|_]}}},V} =
+    {{caught,{'EXIT',{badarg,[{erlang,abs,[V],_}|_]}}},V} =
 	eclectic_2({value,{'abs',V}}, undefined, {value,V}),
-    ?line {{caught,{'EXIT',{badarith,[{?MODULE,my_add,_,_}|_]}}},V} =
+    {{caught,{'EXIT',{badarith,[{?MODULE,my_add,_,_}|_]}}},V} =
 	eclectic_2({exit,{'add',{0,a}}}, exit, {value,V}),
-    ?line {{caught,{'EXIT',V}},undefined} =
+    {{caught,{'EXIT',V}},undefined} =
 	eclectic_2({value,{error,V}}, undefined, {exit,V}),
-    ?line {{caught,{'EXIT',{V,[{?MODULE,foo,_,_}|_]}}},undefined} =
+    {{caught,{'EXIT',{V,[{?MODULE,foo,_,_}|_]}}},undefined} =
 	eclectic_2({throw,{'div',{1,0}}}, throw, {error,V}),
     ok.
 
@@ -374,42 +374,42 @@ eclectic_2(X, C, Y) ->
     Catch =
 	case
             catch
-            {Done,
-             try foo(X) of
-                 V -> {value,V,foo(V)}
-             catch
-                 C:D -> {C,D,foo(D)}
-             after
-                 put(eclectic, foo(Y))
-             end} of
-            {Done,Z} -> {value,Z};
-            Z -> {caught,Z}
-        end,
+		{Done,
+		 try foo(X) of
+		     V -> {value,V,foo(V)}
+		 catch
+		     C:D -> {C,D,foo(D)}
+		 after
+		     put(eclectic, foo(Y))
+		 end} of
+		{Done,Z} -> {value,Z};
+		Z -> {caught,Z}
+	    end,
     {Catch,erase(eclectic)}.
 
 rethrow(Conf) when is_list(Conf) ->
     V = {a,[b,{c,self()},make_ref]},
-    ?line {value2,value1} =
+    {value2,value1} =
 	rethrow_1({value,V}, V),
-    ?line {caught2,{error,V}} =
+    {caught2,{error,V}} =
 	rethrow_2({error,V}, undefined),
-    ?line {caught2,{exit,V}} =
+    {caught2,{exit,V}} =
 	rethrow_1({exit,V}, error),
-    ?line {caught2,{throw,V}} =
+    {caught2,{throw,V}} =
 	rethrow_1({throw,V}, undefined),
-    ?line {caught2,{throw,V}} =
+    {caught2,{throw,V}} =
 	rethrow_2({throw,V}, undefined),
-    ?line {caught2,{error,badarith}} =
+    {caught2,{error,badarith}} =
 	rethrow_1({'add',{0,a}}, throw),
-    ?line {caught2,{error,function_clause}} =
+    {caught2,{error,function_clause}} =
 	rethrow_2(function_clause, undefined),
-    ?line {caught2,{error,{try_clause,V}}} =
+    {caught2,{error,{try_clause,V}}} =
 	rethrow_1({value,V}, exit),
-    ?line {value2,{caught1,V}} =
+    {value2,{caught1,V}} =
 	rethrow_1({error,V}, error),
-    ?line {value2,{caught1,V}} =
+    {value2,{caught1,V}} =
 	rethrow_1({exit,V}, exit),
-    ?line {value2,caught1} =
+    {value2,caught1} =
 	rethrow_2({throw,V}, V),
     ok.
 
@@ -439,91 +439,91 @@ rethrow_2(X, C1) ->
 
 nested_of(Conf) when is_list(Conf) ->
     V = {[self()|make_ref()],1.4142136},
-    ?line {{value,{value1,{V,x2}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{value,{value1,{V,x2}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,{V,x1}},
 		    {value,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{throw,{V,x2}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{caught,{throw,{V,x2}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,{V,x1}},
 		    {throw,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,badarith}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,{V,x1}},
 		    {throw,{V,x2}}, {'div',{1,0}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{error,badarith}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,{V,x1}},
 		    {throw,{V,x2}}, {'div',{1,0}}, {'add',{0,b}}),
     %%
-    ?line {{caught,{error,{try_clause,{V,x1}}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,{try_clause,{V,x1}}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,try_clause},
 		    void, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{exit,{V,x3}}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+    {{caught,{exit,{V,x3}}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,try_clause},
 		    void, {exit,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{throw,{V,x4}}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{throw,{V,x4}}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_of_1({{value,{V,x1}},void,try_clause},
 		    void, {exit,{V,x3}}, {throw,{V,x4}}),
     %%
-    ?line {{value,{caught1,{V,x2}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{value,{caught1,{V,x2}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_of_1({{error,{V,x1}},error,{V,x1}},
 		    {value,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,badarith}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_of_1({{error,{V,x1}},error,{V,x1}},
 		    {'add',{1,c}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,badarith}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_of_1({{error,{V,x1}},error,{V,x1}},
 		    {'add',{1,c}}, {'div',{17,0}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarg}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{error,badarg}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_of_1({{error,{V,x1}},error,{V,x1}},
 		    {'add',{1,c}}, {'div',{17,0}}, {'abs',V}),
     %%
-    ?line {{caught,{error,badarith}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,badarith}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_of_1({{'add',{2,c}},rethrow,void},
 		    void, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarg}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,badarg}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_of_1({{'add',{2,c}},rethrow,void},
 		    void, {'abs',V}, {value,{V,x4}}),
-    ?line {{caught,{error,function_clause}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{error,function_clause}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_of_1({{'add',{2,c}},rethrow,void},
 		    void, {'abs',V}, function_clause),
     ok.
@@ -564,97 +564,97 @@ nested_of_1({X1,C1,V1},
 
 nested_catch(Conf) when is_list(Conf) ->
     V = {[make_ref(),1.4142136,self()]},
-    ?line {{value,{value1,{V,x2}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{value,{value1,{V,x2}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,{V,x1}},
-		    {value,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{throw,{V,x2}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+		       {value,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
+    {{caught,{throw,{V,x2}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,{V,x1}},
-		    {throw,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+		       {throw,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
+    {{caught,{error,badarith}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,{V,x1}},
-		    {throw,{V,x2}}, {'div',{1,0}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   undefined,
-	   finalized} =
+		       {throw,{V,x2}}, {'div',{1,0}}, {value,{V,x4}}),
+    {{caught,{error,badarith}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,{V,x1}},
-		    {throw,{V,x2}}, {'div',{1,0}}, {'add',{0,b}}),
+		       {throw,{V,x2}}, {'div',{1,0}}, {'add',{0,b}}),
     %%
-    ?line {{caught,{error,{try_clause,{V,x1}}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,{try_clause,{V,x1}}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,try_clause},
-		    void, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{exit,{V,x3}}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+		       void, {value,{V,x3}}, {value,{V,x4}}),
+    {{caught,{exit,{V,x3}}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,try_clause},
-		    void, {exit,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{throw,{V,x4}}},
-	   undefined,
-	   undefined,
-	   finalized} =
+		       void, {exit,{V,x3}}, {value,{V,x4}}),
+    {{caught,{throw,{V,x4}}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_catch_1({{value,{V,x1}},void,try_clause},
-		    void, {exit,{V,x3}}, {throw,{V,x4}}),
+		       void, {exit,{V,x3}}, {throw,{V,x4}}),
     %%
-    ?line {{value,{caught1,{V,x2}}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{value,{caught1,{V,x2}}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_catch_1({{error,{V,x1}},error,{V,x1}},
-		    {value,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+		       {value,{V,x2}}, {value,{V,x3}}, {value,{V,x4}}),
+    {{caught,{error,badarith}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_catch_1({{error,{V,x1}},error,{V,x1}},
-		    {'add',{1,c}}, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+		       {'add',{1,c}}, {value,{V,x3}}, {value,{V,x4}}),
+    {{caught,{error,badarith}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_catch_1({{error,{V,x1}},error,{V,x1}},
-		    {'add',{1,c}}, {'div',{17,0}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarg}},
-	   undefined,
-	   undefined,
-	   finalized} =
+		       {'add',{1,c}}, {'div',{17,0}}, {value,{V,x4}}),
+    {{caught,{error,badarg}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_catch_1({{error,{V,x1}},error,{V,x1}},
-		    {'add',{1,c}}, {'div',{17,0}}, {'abs',V}),
+		       {'add',{1,c}}, {'div',{17,0}}, {'abs',V}),
     %%
-    ?line {{caught,{error,badarith}},
-	   {V,x3},
-	   {V,x4},
-	   finalized} =
+    {{caught,{error,badarith}},
+     {V,x3},
+     {V,x4},
+     finalized} =
 	nested_catch_1({{'add',{2,c}},rethrow,void},
-		    void, {value,{V,x3}}, {value,{V,x4}}),
-    ?line {{caught,{error,badarg}},
-	   undefined,
-	   {V,x4},
-	   finalized} =
+		       void, {value,{V,x3}}, {value,{V,x4}}),
+    {{caught,{error,badarg}},
+     undefined,
+     {V,x4},
+     finalized} =
 	nested_catch_1({{'add',{2,c}},rethrow,void},
-		    void, {'abs',V}, {value,{V,x4}}),
-    ?line {{caught,{error,function_clause}},
-	   undefined,
-	   undefined,
-	   finalized} =
+		       void, {'abs',V}, {value,{V,x4}}),
+    {{caught,{error,function_clause}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_catch_1({{'add',{2,c}},rethrow,void},
-		    void, {'abs',V}, function_clause),
+		       void, {'abs',V}, function_clause),
     ok.
 
 nested_catch_1({X1,C1,V1},
-	    X2, X3, X4) ->
+	       X2, X3, X4) ->
     erase(nested3),
     erase(nested4),
     erase(nested),
@@ -687,73 +687,73 @@ nested_catch_1({X1,C1,V1},
 
 nested_after(Conf) when is_list(Conf) ->
     V = [{make_ref(),1.4142136,self()}],
-    ?line {value,
-	   {V,x3},
-	   {value1,{V,x2}},
-	   finalized} =
+    {value,
+     {V,x3},
+     {value1,{V,x2}},
+     finalized} =
 	nested_after_1({{value,{V,x1}},void,{V,x1}},
 		       {value,{V,x2}}, {value,{V,x3}}),
-    ?line {{caught,{error,{V,x2}}},
-	   {V,x3},
-	   undefined,
-	   finalized} =
+    {{caught,{error,{V,x2}}},
+     {V,x3},
+     undefined,
+     finalized} =
 	nested_after_1({{value,{V,x1}},void,{V,x1}},
 		       {error,{V,x2}}, {value,{V,x3}}),
-    ?line {{caught,{exit,{V,x3}}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{exit,{V,x3}}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_after_1({{value,{V,x1}},void,{V,x1}},
 		       {error,{V,x2}}, {exit,{V,x3}}),
     %%
-    ?line {{caught,{error,{try_clause,{V,x1}}}},
-	   {V,x3},
-	   undefined,
-	   finalized} =
+    {{caught,{error,{try_clause,{V,x1}}}},
+     {V,x3},
+     undefined,
+     finalized} =
 	nested_after_1({{value,{V,x1}},void,try_clause},
 		       void, {value,{V,x3}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{error,badarith}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_after_1({{value,{V,x1}},void,try_clause},
 		       void, {'div',{17,0}}),
     %%
-    ?line {value,
-	   {V,x3},
-	   {caught1,{V,x2}},
-	   finalized} =
+    {value,
+     {V,x3},
+     {caught1,{V,x2}},
+     finalized} =
 	nested_after_1({{throw,{V,x1}},throw,{V,x1}},
 		       {value,{V,x2}}, {value,{V,x3}}),
-    ?line {{caught,{error,badarith}},
-	   {V,x3},
-	   undefined,
-	   finalized} =
+    {{caught,{error,badarith}},
+     {V,x3},
+     undefined,
+     finalized} =
 	nested_after_1({{throw,{V,x1}},throw,{V,x1}},
 		       {'add',{a,b}}, {value,{V,x3}}),
-    ?line {{caught,{error,badarg}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{error,badarg}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_after_1({{throw,{V,x1}},throw,{V,x1}},
 		       {'add',{a,b}}, {'abs',V}),
     %%
-    ?line {{caught,{throw,{V,x1}}},
-	   {V,x3},
-	   undefined,
-	   finalized} =
+    {{caught,{throw,{V,x1}}},
+     {V,x3},
+     undefined,
+     finalized} =
 	nested_after_1({{throw,{V,x1}},rethrow,void},
 		       void, {value,{V,x3}}),
-    ?line {{caught,{error,badarith}},
-	   undefined,
-	   undefined,
-	   finalized} =
+    {{caught,{error,badarith}},
+     undefined,
+     undefined,
+     finalized} =
 	nested_after_1({{throw,{V,x1}},rethrow,void},
 		       void, {'div',{1,0}}),
     ok.
 
 nested_after_1({X1,C1,V1},
-	    X2, X3) ->
+	       X2, X3) ->
     erase(nested3),
     erase(nested4),
     erase(nested),