Reduce number of loop variables hence code mass

1 files changed, 154 insertions, 239 deletions

diff --git a/lib/stdlib/src/gen_statem.erl b/lib/stdlib/src/gen_statem.erl
index 6ad025d6c9..15c01c1006 100644
--- a/lib/stdlib/src/gen_statem.erl
+++ b/lib/stdlib/src/gen_statem.erl
@@ -632,8 +632,8 @@ enter(Module, Opts, State, Data, Server, Actions, Parent) ->
       postponed => P,
       %%
       %% The following fields are finally set from to the arguments to
-      %% loop_event_actions/11 when it finally loops back to loop/3
-      %% in loop_events/10
+      %% loop_event_actions/9 when it finally loops back to loop/3
+      %% in loop_event_result/11
       timer_refs => TimerRefs,
       timer_types => TimerTypes,
       hibernate => Hibernate,
@@ -643,7 +643,7 @@ enter(Module, Opts, State, Data, Server, Actions, Parent) ->
     case call_callback_mode(S) of
 	{ok,NewS} ->
 	    loop_event_actions(
-	      Parent, NewDebug, NewS, TimerRefs, TimerTypes, CancelTimers,
+	      Parent, NewDebug, NewS,
 	      Events, Event, State, Data, NewActions, true);
 	{Class,Reason,Stacktrace} ->
 	    terminate(
@@ -843,78 +843,66 @@ loop_hibernate(Parent, Debug, S) ->
        {wakeup_from_hibernate,3}}).
 
 %% Entry point for wakeup_from_hibernate/3
-loop_receive(
-  Parent, Debug,
-  #{timer_refs := TimerRefs,
-    timer_types := TimerTypes,
-    cancel_timers := CancelTimers} = S) ->
-    loop_receive(Parent, Debug, S, TimerRefs, TimerTypes, CancelTimers).
-%%
-loop_receive(
-  Parent, Debug,
-  #{hibernate := Hibernate} = S,
-  TimerRefs, TimerTypes, CancelTimers) ->
-    %% The fields 'timer_refs', 'timer_types' and 'cancel_timers'
-    %% are now invalid in state map S - they will be recalculated
-    %% and restored when we return to loop/3
-    %%
+loop_receive(Parent, Debug, S) ->
     receive
 	Msg ->
 	    case Msg of
 		{system,Pid,Req} ->
+		    #{hibernate := Hibernate} = S,
 		    %% Does not return but tail recursively calls
 		    %% system_continue/3 that jumps to loop/3
 		    sys:handle_system_msg(
-		      Req, Pid, Parent, ?MODULE, Debug,
-		      S#{
-			timer_refs := TimerRefs,
-			timer_types := TimerTypes,
-			cancel_timers := CancelTimers},
+		      Req, Pid, Parent, ?MODULE, Debug, S,
 		      Hibernate);
 		{'EXIT',Parent,Reason} = EXIT ->
-		    %% EXIT is not a 2-tuple and therefore
-		    %% not an event and has no event_type(),
-		    %% but this will stand out in the crash report...
-		    terminate(
-		      exit, Reason, ?STACKTRACE(), Debug,
-		      S#{
-			timer_refs := TimerRefs,
-			timer_types := TimerTypes,
-			cancel_timers := CancelTimers},
-		      [EXIT]);
+		    %% EXIT is not a 2-tuple therefore
+		    %% not an event but this will stand out
+		    %% in the crash report...
+		    Q = [EXIT],
+		    terminate(exit, Reason, ?STACKTRACE(), Debug, S, Q);
 		{timeout,TimerRef,TimerMsg} ->
+		    #{timer_refs := TimerRefs,
+		      timer_types := TimerTypes,
+		      hibernate := Hibernate} = S,
 		    case TimerRefs of
 			#{TimerRef := TimerType} ->
-			    %% We know of this timer, is it a running
-			    %% timer or a timer being cancelled but
+			    %% We know of this timer; is it a running
+			    %% timer or a timer being cancelled that
 			    %% managed to send a late timeout message?
 			    case TimerTypes of
 				#{TimerType := TimerRef} ->
-				    %% The timer type maps to this
+				    %% The timer type maps back to this
 				    %% timer ref, so it was a running timer
 				    Event = {TimerType,TimerMsg},
 				    %% Unregister the triggered timeout
+				    NewTimerRefs =
+					maps:remove(TimerRef, TimerRefs),
+				    NewTimerTypes =
+					maps:remove(TimerType, TimerTypes),
 				    loop_receive_result(
-				      Parent, Debug, S,
-				      maps:remove(TimerRef, TimerRefs),
-				      maps:remove(TimerType, TimerTypes),
-				      CancelTimers, Event);
+				      Parent, Debug,
+				      S#{
+					timer_refs := NewTimerRefs,
+					timer_types := NewTimerTypes},
+				      Hibernate,
+				      Event);
 				_ ->
 				    %% This was a late timeout message
 				    %% from timer being cancelled, so
-				    %% ignore it and expect a cancel
-				    %% ack shortly
-				    loop_receive(
-				      Parent, Debug, S,
-				      TimerRefs, TimerTypes, CancelTimers)
+				    %% ignore it and expect a cancel_timer
+				    %% msg shortly
+				    loop_receive(Parent, Debug, S)
 			    end;
 			_ ->
+			    %% Not our timer; present it as an event
 			    Event = {info,Msg},
 			    loop_receive_result(
-			      Parent, Debug, S,
-			      TimerRefs, TimerTypes, CancelTimers, Event)
+			      Parent, Debug, S, Hibernate, Event)
 		    end;
 		{cancel_timer,TimerRef,_} ->
+		    #{timer_refs := TimerRefs,
+		      cancel_timers := CancelTimers,
+		      hibernate := Hibernate} = S,
 		    case TimerRefs of
 			#{TimerRef := _} ->
 			    %% We must have requested a cancel
@@ -922,36 +910,29 @@ loop_receive(
 			    %% removed from TimerTypes
 			    NewTimerRefs =
 				maps:remove(TimerRef, TimerRefs),
+			    NewCancelTimers = CancelTimers - 1,
+			    NewS =
+				S#{
+				  timer_refs := NewTimerRefs,
+				  cancel_timers := NewCancelTimers},
 			    if
-				Hibernate =:= true, CancelTimers =:= 0 ->
-				    loop_hibernate(
-				      Parent, Debug,
-				      S#{
-					timer_refs := NewTimerRefs,
-					timer_types := TimerTypes,
-					cancel_timers := CancelTimers});
-				CancelTimers > 0 ->
-				    loop_receive(
-				      Parent, Debug, S,
-				      NewTimerRefs, TimerTypes,
-				      CancelTimers - 1);
-				true ->
-				    terminate(
-				      error, impossible_message,
-				      ?STACKTRACE(), Debug,
-				      S#{
-					timer_refs := TimerRefs,
-					timer_types := TimerTypes,
-					cancel_timers := CancelTimers},
-				      [Msg])
+				Hibernate =:= true, NewCancelTimers =:= 0 ->
+				    %% No more cancel_timer msgs to expect;
+				    %% we can hibernate
+				    loop_hibernate(Parent, Debug, NewS);
+				NewCancelTimers >= 0 -> % Assert
+				    loop_receive(Parent, Debug, NewS)
 			    end;
 			_ ->
+			    %% Not our cancel_timer msg;
+			    %% present it as an event
 			    Event = {info,Msg},
 			    loop_receive_result(
-			      Parent, Debug, S,
-			      TimerRefs, TimerTypes, CancelTimers, Event)
+			      Parent, Debug, S, Hibernate, Event)
 		    end;
 		_ ->
+		    %% External msg
+		    #{hibernate := Hibernate} = S,
 		    Event =
 			case Msg of
 			    {'$gen_call',From,Request} ->
@@ -962,116 +943,105 @@ loop_receive(
 				{info,Msg}
 			end,
 		    loop_receive_result(
-		      Parent, Debug, S,
-		      TimerRefs, TimerTypes, CancelTimers, Event)
+		      Parent, Debug, S, Hibernate, Event)
 	    end
     end.
 
 loop_receive_result(
-  Parent, Debug, #{state := State} = S,
-  TimerRefs, TimerTypes, CancelTimers, Event) ->
-    %% The field 'hibernate' is now invalid in state map S
-    %% - it will be recalculated and restored when we return to loop/3
-    %%
+  Parent, Debug, #{state := State} = S, Hibernate, Event) ->
+    %% From now the 'hibernate' field in S is invalid
+    %% and will be restored when looping back
+    %% in loop_event_result/11
     NewDebug = sys_debug(Debug, S, State, {in,Event}),
-    %% Here the queue of not yet handled events is created
+    %% Here is the queue of not yet handled events created
     Events = [],
-    Hibernate = false,
-    loop_event(
-      Parent, NewDebug, S, TimerRefs, TimerTypes, CancelTimers,
-      Events, Event, Hibernate).
+    loop_event(Parent, NewDebug, S, Events, Event, Hibernate).
 
 %% Entry point for handling an event, received or enqueued
 loop_event(
-  Parent, Debug, #{state := State, data := Data} = S,
-  TimerRefs, TimerTypes, CancelTimers,
+  Parent, Debug,
+  #{state := State, data := Data, timer_types := TimerTypes,
+    cancel_timers := CancelTimers} = S_0,
   Events, {Type,Content} = Event, Hibernate) ->
     %%
-    %% If Hibernate is true here it can only be
+    %% If (this old) Hibernate is true here it can only be
     %% because it was set from an event action
-    %% and we did not go into hibernation since there
-    %% were events in queue, so we do what the user
+    %% and we did not go into hibernation since there were
+    %% events in queue, so we do what the user
     %% might rely on i.e collect garbage which
     %% would have happened if we actually hibernated
     %% and immediately was awakened
     Hibernate andalso garbage_collect(),
-    %% So now the old Hibernate is dead, and a new one emerges
-    %% within loop_event_actions
-    case call_state_function(S, Type, Content, State, Data) of
-	{ok,Result,NewS} ->
+    case call_state_function(S_0, Type, Content, State, Data) of
+	{ok,Result,S_1} ->
 	    %% Cancel event timeout
-	    {NewTimerTypes,NewCancelTimers} =
-		cancel_timer_by_type(timeout, TimerTypes, CancelTimers),
-	    %% The timer is removed from NewTimerTypes but
-	    %% remains in TimerRefs until we get the cancel_timers msg
-	    {NewData,NextState,Actions,EnterCall} =
+	    S_2 =
+		case
+		    cancel_timer_by_type(timeout, TimerTypes, CancelTimers)
+		of
+		    {_,CancelTimers} ->
+			%% No timer cancelled
+			S_1;
+		    {NewTimerTypes,NewCancelTimers} ->
+			%% The timer is removed from NewTimerTypes but
+			%% remains in TimerRefs until we get
+			%% the cancel_timer msg
+			S_1#{
+			  timer_types := NewTimerTypes,
+			  cancel_timers := NewCancelTimers}
+		end,
+	    {NextState,NewData,Actions,EnterCall} =
 		parse_event_result(
-		  true, Debug, NewS,
-		  TimerRefs, NewTimerTypes, NewCancelTimers,
-		  Events, Event, State, Data, false, Result),
+		  true, Debug, S_2,
+		  Events, Event, State, Data, Result),
 	    loop_event_actions(
-	      Parent, Debug, NewS,
-	      TimerRefs, NewTimerTypes, NewCancelTimers,
+	      Parent, Debug, S_2,
 	      Events, Event, NextState, NewData, Actions, EnterCall);
 	{Class,Reason,Stacktrace} ->
 	    terminate(
-	      Class, Reason, Stacktrace, Debug,
-	      S#{
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
+	      Class, Reason, Stacktrace, Debug, S_0,
 	      [Event|Events])
     end.
 
 loop_event_actions(
   Parent, Debug,
   #{state := State, state_enter := StateEnter} = S,
-  TimerRefs, TimerTypes, CancelTimers,
   Events, Event, NextState, NewData,
   Actions, EnterCall) ->
+    %% Hibernate is reborn here as false being
+    %% the default value from parse_actions/4
     case parse_actions(Debug, S, State, Actions) of
 	{ok,NewDebug,Hibernate,TimeoutsR,Postpone,NextEventsR} ->
 	    if
 		StateEnter, EnterCall ->
 		    loop_event_enter(
 		      Parent, NewDebug, S,
-		      TimerRefs, TimerTypes, CancelTimers,
 		      Events, Event, NextState, NewData,
 		      Hibernate, TimeoutsR, Postpone, NextEventsR);
 		true ->
 		    loop_event_result(
 		      Parent, NewDebug, S,
-		      TimerRefs, TimerTypes, CancelTimers,
 		      Events, Event, NextState, NewData,
 		      Hibernate, TimeoutsR, Postpone, NextEventsR)
 	    end;
 	{Class,Reason,Stacktrace} ->
 	    terminate(
-	      Class, Reason, Stacktrace, Debug,
-	      S#{
-		data := NewData,
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := false},
+	      Class, Reason, Stacktrace, Debug, S,
 	      [Event|Events])
     end.
 
 loop_event_enter(
   Parent, Debug, #{state := State} = S,
-  TimerRefs, TimerTypes, CancelTimers,
   Events, Event, NextState, NewData,
   Hibernate, TimeoutsR, Postpone, NextEventsR) ->
     case call_state_function(S, enter, State, NextState, NewData) of
 	{ok,Result,NewS} ->
 	    case parse_event_result(
-		   false, Debug, NewS, TimerRefs, TimerTypes, CancelTimers,
-		   Events, Event, NextState, NewData, Hibernate, Result) of
-		{NewerData,_,Actions,EnterCall} ->
+		   false, Debug, NewS,
+		   Events, Event, NextState, NewData, Result) of
+		{_,NewerData,Actions,EnterCall} ->
 		    loop_event_enter_actions(
 		      Parent, Debug, NewS,
-		      TimerRefs, TimerTypes, CancelTimers,
 		      Events, Event, NextState, NewerData,
 		      Hibernate, TimeoutsR, Postpone, NextEventsR,
 		      Actions, EnterCall)
@@ -1082,16 +1052,12 @@ loop_event_enter(
 	      S#{
 		state := NextState,
 		data := NewData,
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
 		hibernate := Hibernate},
 	      [Event|Events])
     end.
 
 loop_event_enter_actions(
   Parent, Debug, #{state_enter := StateEnter} = S,
-  TimerRefs, TimerTypes, CancelTimers,
   Events, Event, NextState, NewData,
   Hibernate, TimeoutsR, Postpone, NextEventsR,
   Actions, EnterCall) ->
@@ -1104,13 +1070,11 @@ loop_event_enter_actions(
 		StateEnter, EnterCall ->
 		    loop_event_enter(
 		      Parent, NewDebug, S,
-		      TimerRefs, TimerTypes, CancelTimers,
 		      Events, Event, NextState, NewData,
 		      NewHibernate, NewTimeoutsR, Postpone, NextEventsR);
 		true ->
 		    loop_event_result(
 		      Parent, NewDebug, S,
-		      TimerRefs, TimerTypes, CancelTimers,
 		      Events, Event, NextState, NewData,
 		      NewHibernate, NewTimeoutsR, Postpone, NextEventsR)
 	    end;
@@ -1120,89 +1084,71 @@ loop_event_enter_actions(
 	      S#{
 		state := NextState,
 		data := NewData,
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
 		hibernate := Hibernate},
 	      [Event|Events])
     end.
 
 loop_event_result(
-  Parent, Debug,
-  #{state := State, postponed := P_0} = S,
-  TimerRefs_0, TimerTypes_0, CancelTimers_0,
-  Events, Event, NextState, NewData,
+  Parent, Debug_0,
+  #{state := State, postponed := P_0,
+    timer_refs := TimerRefs_0, timer_types := TimerTypes_0,
+    cancel_timers := CancelTimers_0} = S_0,
+  Events_0, Event_0, NextState, NewData,
   Hibernate, TimeoutsR, Postpone, NextEventsR) ->
     %%
     %% All options have been collected and next_events are buffered.
     %% Do the actual state transition.
     %%
-    {NewDebug,P_1} = % Move current event to postponed if Postpone
+    {Debug_1,P_1} = % Move current event to postponed if Postpone
 	case Postpone of
 	    true ->
-		{sys_debug(Debug, S, State, {postpone,Event,State}),
-		 [Event|P_0]};
+		{sys_debug(Debug_0, S_0, State, {postpone,Event_0,State}),
+		 [Event_0|P_0]};
 	    false ->
-		{sys_debug(Debug, S, State, {consume,Event,State}),
+		{sys_debug(Debug_0, S_0, State, {consume,Event_0,State}),
 		 P_0}
 	end,
-    {Events_1,NewP,{TimerTypes_1,CancelTimers_1}} =
+    {Events_1,P_2,{TimerTypes_1,CancelTimers_1}} =
 	%% Move all postponed events to queue and cancel the
 	%% state timeout if the state changes
 	if
 	    NextState =:= State ->
-		{Events,P_1,{TimerTypes_0,CancelTimers_0}};
+		{Events_0,P_1,{TimerTypes_0,CancelTimers_0}};
 	    true ->
-		{lists:reverse(P_1, Events),[],
+		{lists:reverse(P_1, Events_0),
+		 [],
 		 cancel_timer_by_type(
 		   state_timeout, TimerTypes_0, CancelTimers_0)}
 		    %% The state timer is removed from TimerTypes_1
 		    %% but remains in TimerRefs_0 until we get
 		    %% the cancel_timer msg
 	end,
-    {TimerRefs_2,TimerTypes_2,NewCancelTimers,TimeoutEvents} =
-	%% Stop and start timers non-event timers
+    {TimerRefs_2,TimerTypes_2,CancelTimers_2,TimeoutEvents} =
+	%% Stop and start non-event timers
 	parse_timers(TimerRefs_0, TimerTypes_1, CancelTimers_1, TimeoutsR),
     %% Place next events last in reversed queue
     Events_2R = lists:reverse(Events_1, NextEventsR),
     %% Enqueue immediate timeout events and start event timer
-    {NewTimerRefs,NewTimerTypes,Events_3R} =
+    {TimerRefs_3,TimerTypes_3,Events_3R} =
 	process_timeout_events(
 	  TimerRefs_2, TimerTypes_2, TimeoutEvents, Events_2R),
-    NewEvents = lists:reverse(Events_3R),
-    loop_events(
-      Parent, NewDebug, S, NewTimerRefs, NewTimerTypes, NewCancelTimers,
-      NewEvents, Hibernate, NextState, NewData, NewP).
-
-%% Loop until out of enqueued events
-%%
-loop_events(
-  Parent, Debug, S, TimerRefs, TimerTypes, CancelTimers,
-  [] = _Events, Hibernate, State, Data, P) ->
-    %% Update S and loop back to loop/3 to receive a new event
-    NewS =
-	S#{
-	  state := State,
-	  data := Data,
-	  postponed := P,
-	  timer_refs := TimerRefs,
-	  timer_types := TimerTypes,
-	  cancel_timers := CancelTimers,
+    S_1 =
+	S_0#{
+	  state := NextState,
+	  data := NewData,
+	  postponed := P_2,
+	  timer_refs := TimerRefs_3,
+	  timer_types := TimerTypes_3,
+	  cancel_timers := CancelTimers_2,
 	  hibernate := Hibernate},
-    loop(Parent, Debug, NewS);
-loop_events(
-  Parent, Debug, S, TimerRefs, TimerTypes, CancelTimers,
-  [Event|Events], Hibernate, State, Data, P) ->
-    %% Update S and continue with enqueued events
-    NewS =
-	S#{
-	  state := State,
-	  data := Data,
-	  postponed := P},
-    loop_event(
-      Parent, Debug, NewS, TimerRefs, TimerTypes, CancelTimers,
-      Events, Event, Hibernate).
-
+    case lists:reverse(Events_3R) of
+	[] ->
+	    %% Get a new event
+	    loop(Parent, Debug_1, S_1);
+	[Event|Events] ->
+	    %% Loop until out of enqueued events
+	    loop_event(Parent, Debug_1, S_1, Events, Event, Hibernate)
+    end.
 
 
 %%---------------------------------------------------------------------------
@@ -1272,8 +1218,7 @@ parse_callback_mode(_, _CBMode, StateEnter) ->
 
 
 call_state_function(
-  #{callback_mode := undefined} = S,
-  Type, Content, State, Data) ->
+  #{callback_mode := undefined} = S, Type, Content, State, Data) ->
     case call_callback_mode(S) of
 	{ok,NewS} ->
 	    call_state_function(NewS, Type, Content, State, Data);
@@ -1281,8 +1226,7 @@ call_state_function(
 	    Error
     end;
 call_state_function(
-  #{callback_mode := CallbackMode,
-    module := Module} = S,
+  #{callback_mode := CallbackMode, module := Module} = S,
   Type, Content, State, Data) ->
     try
 	case CallbackMode of
@@ -1339,105 +1283,74 @@ call_state_function(
 
 %% Interpret all callback return variants
 parse_event_result(
-  AllowStateChange, Debug, S, TimerRefs, TimerTypes, CancelTimers,
-  Events, Event, State, Data, Hibernate, Result) ->
+  AllowStateChange, Debug, S,
+  Events, Event, State, Data, Result) ->
     case Result of
 	stop ->
 	    terminate(
 	      exit, normal, ?STACKTRACE(), Debug,
-	      S#{
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
+	      S#{state := State, data := Data},
 	      [Event|Events]);
 	{stop,Reason} ->
 	    terminate(
 	      exit, Reason, ?STACKTRACE(), Debug,
-	      S#{
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
+	      S#{state := State, data := Data},
 	      [Event|Events]);
 	{stop,Reason,NewData} ->
 	    terminate(
 	      exit, Reason, ?STACKTRACE(), Debug,
-	      S#{
-		data := NewData,
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
+	      S#{state := State, data := NewData},
 	      [Event|Events]);
 	%%
 	{stop_and_reply,Reason,Replies} ->
-	    Q = [Event|Events],
 	    reply_then_terminate(
 	      exit, Reason, ?STACKTRACE(), Debug,
-	      S#{
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
-	      Q, Replies);
+	      S#{state := State, data := Data},
+	      [Event|Events], Replies);
 	{stop_and_reply,Reason,Replies,NewData} ->
-	    Q = [Event|Events],
 	    reply_then_terminate(
 	      exit, Reason, ?STACKTRACE(), Debug,
-	      S#{
-		data := NewData,
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
-	      Q, Replies);
+	      S#{state := State, data := NewData},
+	      [Event|Events], Replies);
 	%%
 	{next_state,State,NewData} ->
-	    {NewData,State,[],false};
+	    {State,NewData,[],false};
 	{next_state,NextState,NewData} when AllowStateChange ->
-	    {NewData,NextState,[],true};
+	    {NextState,NewData,[],true};
 	{next_state,State,NewData,Actions} ->
-	    {NewData,State,Actions,false};
+	    {State,NewData,Actions,false};
 	{next_state,NextState,NewData,Actions} when AllowStateChange ->
-	    {NewData,NextState,Actions,true};
+	    {NextState,NewData,Actions,true};
 	%%
 	{keep_state,NewData} ->
-	    {NewData,State,[],false};
+	    {State,NewData,[],false};
 	{keep_state,NewData,Actions} ->
-	    {NewData,State,Actions,false};
+	    {State,NewData,Actions,false};
 	keep_state_and_data ->
-	    {Data,State,[],false};
+	    {State,Data,[],false};
 	{keep_state_and_data,Actions} ->
-	    {Data,State,Actions,false};
+	    {State,Data,Actions,false};
 	%%
 	{repeat_state,NewData} ->
-	    {NewData,State,[],true};
+	    {State,NewData,[],true};
 	{repeat_state,NewData,Actions} ->
-	    {NewData,State,Actions,true};
+	    {State,NewData,Actions,true};
 	repeat_state_and_data ->
-	    {Data,State,[],true};
+	    {State,Data,[],true};
 	{repeat_state_and_data,Actions} ->
-	    {Data,State,Actions,true};
+	    {State,Data,Actions,true};
 	%%
 	_ ->
 	    terminate(
 	      error,
 	      {bad_return_from_state_function,Result},
-	      ?STACKTRACE(),
-	      Debug,
-	      S#{
-		timer_refs := TimerRefs,
-		timer_types := TimerTypes,
-		cancel_timers := CancelTimers,
-		hibernate := Hibernate},
+	      ?STACKTRACE(), Debug,
+	      S#{state := State, data := Data},
 	      [Event|Events])
     end.
 
 
-parse_enter_actions(
-  Debug, S, State, Actions,
-  Hibernate, TimeoutsR) ->
+parse_enter_actions(Debug, S, State, Actions, Hibernate, TimeoutsR) ->
     Postpone = forbidden,
     NextEventsR = forbidden,
     parse_actions(
@@ -1484,9 +1397,10 @@ parse_actions(
 	     {bad_action_from_state_function,Action},
 	     ?STACKTRACE()};
 	hibernate ->
+	    NewHibernate = true,
 	    parse_actions(
 	      Debug, S, State, Actions,
-	      true, TimeoutsR, Postpone, NextEventsR);
+	      NewHibernate, TimeoutsR, Postpone, NextEventsR);
 	{state_timeout,Time,_} = StateTimeout
 	  when is_integer(Time), Time >= 0;
 	       Time =:= infinity ->
@@ -1529,9 +1443,10 @@ parse_actions(
 	     {bad_action_from_state_function,Action},
 	     ?STACKTRACE()};
 	postpone when Postpone =/= forbidden ->
+	    NewPostpone = true,
 	    parse_actions(
 	      Debug, S, State, Actions,
-	      Hibernate, TimeoutsR, true, NextEventsR);
+	      Hibernate, TimeoutsR, NewPostpone, NextEventsR);
 	{next_event,Type,Content} ->
 	    case event_type(Type) of
 		true when NextEventsR =/= forbidden ->