Restructure loop_* to clarify S handling

1 files changed, 176 insertions, 133 deletions

diff --git a/lib/stdlib/src/gen_statem.erl b/lib/stdlib/src/gen_statem.erl
index f9e2e5f7d2..36476b56ae 100644
--- a/lib/stdlib/src/gen_statem.erl
+++ b/lib/stdlib/src/gen_statem.erl
@@ -97,7 +97,7 @@
 	%% * Postponing the current event is performed
 	%%   iff 'postpone' is 'true'.
 	%% * A state timer is started iff 'timeout' is set.
-	%% * Pending events are processed or if there are
+	%% * Pending events are handled or if there are
 	%%   no pending events the server goes into receive
 	%%   or hibernate (iff 'hibernate' is 'true')
 	%%
@@ -523,12 +523,15 @@ send(Proc, Msg) ->
 	    ok
     end.
 
-%% Here init_it/6 and enter_loop/5,6,7 functions converge
+%% Here the init_it/6 and enter_loop/5,6,7 functions converge
 enter(Module, Opts, CallbackMode, State, Data, Server, Actions, Parent) ->
     %% The values should already have been type checked
     Name = gen:get_proc_name(Server),
     Debug = gen:debug_options(Name, Opts),
-    PrevState = make_ref(), % Will be discarded by loop_event_actions/9
+    P = Events = [],
+    Event = {internal,initial_state},
+    %% We enforce {postpone,false} to ensure that
+    %% our fake Event gets discarded, thought it might get logged
     NewActions =
 	if
 	    is_list(Actions) ->
@@ -540,15 +543,17 @@ enter(Module, Opts, CallbackMode, State, Data, Server, Actions, Parent) ->
       callback_mode => CallbackMode,
       module => Module,
       name => Name,
-      state => PrevState,
+      %% All fields below will be replaced according to the arguments to
+      %% loop_event_actions/10 when it finally loops back to loop/3
+      state => State,
       data => Data,
-      timer => undefined,
-      postponed => [],
-      hibernate => false},
+      postponed => P,
+      hibernate => false,
+      timer => undefined},
+    NewDebug = sys_debug(Debug, S, {enter,Event,State}),
     loop_event_actions(
-      Parent, Debug, S, [],
-      {event,undefined}, % Will be discarded thanks to {postpone,false}
-      PrevState, State, Data, NewActions).
+      Parent, NewDebug, S, Events,
+      State, Data, P, Event, State, NewActions).
 
 %%%==========================================================================
 %%%  gen callbacks
@@ -681,13 +686,13 @@ print_event(Dev, {out,Reply,{To,_Tag}}, #{name := Name}) ->
     io:format(
       Dev, "*DBG* ~p sent ~p to ~p~n",
       [Name,Reply,To]);
-print_event(Dev, {Tag,Event,NewState}, #{name := Name, state := State}) ->
+print_event(Dev, {Tag,Event,NextState}, #{name := Name, state := State}) ->
     StateString =
-	case NewState of
+	case NextState of
 	    State ->
 		io_lib:format("~p", [State]);
 	    _ ->
-		io_lib:format("~p => ~p", [State,NewState])
+		io_lib:format("~p => ~p", [State,NextState])
 	end,
     io:format(
       Dev, "*DBG* ~p ~w ~s in state ~s~n",
@@ -697,8 +702,8 @@ event_string(Event) ->
     case Event of
 	{{call,{Pid,_Tag}},Request} ->
 	    io_lib:format("call ~p from ~w", [Request,Pid]);
-	{Tag,Content} ->
-	    io_lib:format("~w ~p", [Tag,Content])
+	{EventType,EventContent} ->
+	    io_lib:format("~w ~p", [EventType,EventContent])
     end.
 
 sys_debug(Debug, S, Entry) ->
@@ -754,7 +759,8 @@ loop_receive(Parent, Debug, #{timer := Timer} = S) ->
 		    %% but this will stand out in the crash report...
 		    ?TERMINATE(exit, Reason, Debug, S, [EXIT]);
 		{timeout,Timer,Content} when Timer =/= undefined ->
-		    loop_event(Parent, Debug, S, {timeout,Content});
+		    loop_receive_result(
+		      Parent, Debug, S, {timeout,Content});
 		_ ->
 		    %% Cancel Timer if running
 		    case Timer of
@@ -782,30 +788,81 @@ loop_receive(Parent, Debug, #{timer := Timer} = S) ->
 			    _ ->
 				{info,Msg}
 			end,
-		    loop_event(Parent, Debug, S, Event)
+		    loop_receive_result(Parent, Debug, S, Event)
 	    end
     end.
 
-loop_event(Parent, Debug, S, Event) ->
-    %% The timer field and the hibernate flag in S
-    %% are now invalid and ignored until we get back to loop/3
+loop_receive_result(
+  Parent, Debug,
+  #{state := State,
+    data := Data,
+    postponed := P} = S,
+  Event) ->
+    %% The S map is now dismantled and will not be restored
+    %% until we return to loop/3 or have to terminate.
+    %%
+    %% The fields 'callback_mode', 'module', and 'name' are still valid.
+    %% The fields 'state', 'data', and 'postponed' are held in arguments.
+    %% The fields 'timer' and 'hibernate' will be recalculated.
+    %%
     NewDebug = sys_debug(Debug, S, {in,Event}),
-    %% Here the queue of not yet processed events is created
-    loop_events(Parent, NewDebug, S, [Event], false).
+    %% Here the queue of not yet handled events is created
+    Events = [],
+    Hibernate = false,
+    loop_event(
+      Parent, NewDebug, S, Events, State, Data, P, Event, Hibernate).
 
-%% Process first the event queue, or if it is empty
-%% loop back to receive a new event
-loop_events(Parent, Debug, S, [], _Hibernate) ->
-    loop(Parent, Debug, S);
+%% Process the event queue, or if it is empty
+%% loop back to loop/3 to receive a new event
+loop_events(
+  Parent, Debug, S, [Event|Events],
+  State, Data, P, Hibernate, _Timeout) ->
+    %%
+    %% If there was a state timer requested we just ignore that
+    %% since we have events to handle which cancels the timer
+    loop_event(
+      Parent, Debug, S, Events, State, Data, P, Event, Hibernate);
 loop_events(
+  Parent, Debug, S, [],
+  State, Data, P, Hibernate, Timeout) ->
+    case Timeout of
+	{timeout,0,EventContent} ->
+	    %% Immediate timeout - simulate it
+	    %% so we do not get the timeout message
+	    %% after any received event
+	    loop_event(
+	      Parent, Debug, S, [],
+	      State, Data, P, {timeout,EventContent}, Hibernate);
+	{timeout,Time,EventContent} ->
+	    %% Actually start a timer
+	    Timer = erlang:start_timer(Time, self(), EventContent),
+	    loop_events_done(
+	      Parent, Debug, S, Timer, State, Data, P, Hibernate);
+	undefined ->
+	    %% No state timeout has been requested
+	    Timer = undefined,
+	    loop_events_done(
+	      Parent, Debug, S, Timer, State, Data, P, Hibernate)
+    end.
+%%
+loop_events_done(Parent, Debug, S, Timer, State, Data, P, Hibernate) ->
+    NewS =
+	S#{
+	  state := State,
+	  data := Data,
+	  postponed := P,
+	  hibernate := Hibernate,
+	  timer := Timer},
+    loop(Parent, Debug, NewS).
+
+loop_event(
   Parent, Debug,
   #{callback_mode := CallbackMode,
-    module := Module,
-    state := State,
-    data := Data} = S,
-  [{Type,Content} = Event|Events] = Q,
-  Hibernate) ->
-    %% If the Hibernate flag is true here it can only be
+    module := Module} = S,
+  Events,
+  State, Data, P, {Type,Content} = Event, Hibernate) ->
+    %%
+    %% If 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
@@ -813,6 +870,7 @@ loop_events(
     %% would have happened if we actually hibernated
     %% and immediately was awakened
     Hibernate andalso garbage_collect(),
+    %%
     try
 	case CallbackMode of
 	    state_functions ->
@@ -822,11 +880,11 @@ loop_events(
 	end of
 	Result ->
 	    loop_event_result(
-	      Parent, Debug, S, Events, Event, Result)
+	      Parent, Debug, S, Events, State, Data, P, Event, Result)
     catch
 	Result ->
 	    loop_event_result(
-	      Parent, Debug, S, Events, Event, Result);
+	      Parent, Debug, S, Events, State, Data, P, Event, Result);
 	error:badarg when CallbackMode =:= state_functions ->
 	    case erlang:get_stacktrace() of
 		[{erlang,apply,[Module,State,_],_}|Stacktrace] ->
@@ -835,9 +893,9 @@ loop_events(
 		      error,
 		      {undef_state_function,{Module,State,Args}},
 		      Stacktrace,
-		      Debug, S, Q);
+		      Debug, S, [Event|Events]);
 		Stacktrace ->
-		    terminate(error, badarg, Stacktrace, Debug, S, Q)
+		    terminate(error, badarg, Stacktrace, Debug, S, [Event|Events])
 	    end;
 	error:undef ->
 	    %% Process an undef to check for the simple mistake
@@ -852,7 +910,7 @@ loop_events(
 		      error,
 		      {undef_state_function,{Module,State,Args}},
 		      Stacktrace,
-		      Debug, S, Q);
+		      Debug, S, [Event|Events]);
 		[{Module,handle_event,
 		  [Type,Content,State,Data]=Args,
 		  _}
@@ -863,40 +921,42 @@ loop_events(
 		      {undef_state_function,
 		       {Module,handle_event,Args}},
 		      Stacktrace,
-		      Debug, S, Q);
+		      Debug, S, [Event|Events]);
 		Stacktrace ->
-		    terminate(error, undef, Stacktrace, Debug, S, Q)
+		    terminate(
+		      error, undef, Stacktrace, Debug, S, [Event|Events])
 	    end;
 	Class:Reason ->
 	    Stacktrace = erlang:get_stacktrace(),
-	    terminate(Class, Reason, Stacktrace, Debug, S, Q)
+	    terminate(Class, Reason, Stacktrace, Debug, S, [Event|Events])
     end.
 
 %% Interpret all callback return variants
 loop_event_result(
-  Parent, Debug,
-  #{state := State, data := Data} = S,
-  Events, Event, Result) ->
-    %% From now until we loop back to the loop_events/4
-    %% the state and data fields in S are old
+  Parent, Debug, S, Events, State, Data, P, Event, Result) ->
     case Result of
 	stop ->
-	    ?TERMINATE(exit, normal, Debug, S, [Event|Events]);
+	    NewS = S#{state := State, data := Data, postponed := P},
+	    Q = [Event|Events],
+	    ?TERMINATE(exit, normal, Debug, NewS, Q);
 	{stop,Reason} ->
-	    ?TERMINATE(exit, Reason, Debug, S, [Event|Events]);
+	    NewS = S#{state := State, data := Data, postponed := P},
+	    Q = [Event|Events],
+	    ?TERMINATE(exit, Reason, Debug, NewS, Q);
 	{stop,Reason,NewData} ->
-	    NewS = S#{data := NewData},
+	    NewS = S#{state := State, data := NewData, postponed := P},
 	    Q = [Event|Events],
 	    ?TERMINATE(exit, Reason, Debug, NewS, Q);
 	{stop_and_reply,Reason,Replies} ->
+	    NewS = S#{state := State, data := Data, postponed := P},
 	    Q = [Event|Events],
 	    [Class,NewReason,Stacktrace,NewDebug] =
 		reply_then_terminate(
-		  exit, Reason, ?STACKTRACE(), Debug, S, Q, Replies),
+		  exit, Reason, ?STACKTRACE(), Debug, NewS, Q, Replies),
 	    %% Since we got back here Replies was bad
-	    terminate(Class, NewReason, Stacktrace, NewDebug, S, Q);
+	    terminate(Class, NewReason, Stacktrace, NewDebug, NewS, Q);
 	{stop_and_reply,Reason,Replies,NewData} ->
-	    NewS = S#{data := NewData},
+	    NewS = S#{state := State, data := NewData, postponed := P},
 	    Q = [Event|Events],
 	    [Class,NewReason,Stacktrace,NewDebug] =
 		reply_then_terminate(
@@ -905,41 +965,43 @@ loop_event_result(
 	    terminate(Class, NewReason, Stacktrace, NewDebug, NewS, Q);
 	{next_state,NextState,NewData} ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, []);
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, []);
 	{next_state,NextState,NewData,Actions} ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions);
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions);
 	{keep_state,NewData} ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, State, NewData, []);
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, State, []);
 	{keep_state,NewData,Actions} ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, State, NewData, Actions);
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, State, Actions);
 	keep_state_and_data ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, State, Data, []);
+	      Parent, Debug, S, Events,
+	      State, Data, P, Event, State, []);
 	{keep_state_and_data,Actions} ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, State, Data, Actions);
+	      Parent, Debug, S, Events,
+	      State, Data, P, Event, State, Actions);
 	_ ->
+	    NewS = S#{state := State, data := Data, postponed := P},
+	    Q = [Event|Events],
 	    ?TERMINATE(
-	      error, {bad_return_value,Result}, Debug, S, [Event|Events])
+	      error, {bad_return_value,Result}, Debug, NewS, Q)
     end.
 
 loop_event_actions(
-  Parent, Debug, S, Events, Event, State, NextState, NewData, Actions) ->
-    Postpone = false, % Shall we postpone this event, true or false
+  Parent, Debug, S, Events, State, NewData, P, Event, NextState, Actions) ->
+    Postpone = false, % Shall we postpone this event; boolean()
     Hibernate = false,
     Timeout = undefined,
     NextEvents = [],
     loop_event_actions(
-      Parent, Debug, S, Events, Event, State, NextState, NewData,
+      Parent, Debug, S, Events, State, NewData, P, Event, NextState,
       if
 	  is_list(Actions) ->
 	      Actions;
@@ -948,10 +1010,10 @@ loop_event_actions(
       end,
       Postpone, Hibernate, Timeout, NextEvents).
 %%
-%% Process all action()s
+%% Process all actions
 loop_event_actions(
-  Parent, Debug, S, Events, Event,
-  State, NextState, NewData, [Action|Actions],
+  Parent, Debug, S, Events,
+  State, NewData, P, Event, NextState, [Action|Actions],
   Postpone, Hibernate, Timeout, NextEvents) ->
     case Action of
 	%% Actual actions
@@ -960,85 +1022,99 @@ loop_event_actions(
 		true ->
 		    NewDebug = do_reply(Debug, S, From, Reply),
 		    loop_event_actions(
-		      Parent, NewDebug, S, Events, Event,
-		      State, NextState, NewData, Actions,
+		      Parent, NewDebug, S, Events,
+		      State, NewData, P, Event, NextState, Actions,
 		      Postpone, Hibernate, Timeout, NextEvents);
 		false ->
+		    NewS =
+			S#{state := State, data := NewData, postponed := P},
+		    Q = [Event|Events],
 		    ?TERMINATE(
-		       error, {bad_action,Action}, Debug, S, [Event|Events])
+		       error, {bad_action,Action}, Debug, NewS, Q)
 	    end;
 	{next_event,Type,Content} ->
 	    case event_type(Type) of
 		true ->
 		    loop_event_actions(
-		      Parent, Debug, S, Events, Event,
-		      State, NextState, NewData, Actions,
+		      Parent, Debug, S, Events,
+		      State, NewData, P, Event, NextState, Actions,
 		      Postpone, Hibernate, Timeout,
 		      [{Type,Content}|NextEvents]);
 		false ->
+		    NewS =
+			S#{state := State, data := NewData, postponed := P},
+		    Q = [Event|Events],
 		    ?TERMINATE(
-		       error, {bad_action,Action}, Debug, S, [Event|Events])
+		       error, {bad_action,Action}, Debug, NewS, Q)
 	    end;
 	%% Actions that set options
 	{postpone,NewPostpone} when is_boolean(NewPostpone) ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      NewPostpone, Hibernate, Timeout, NextEvents);
 	{postpone,_} ->
+	    NewS = S#{state := State, data := NewData, postponed := P},
+	    Q = [Event|Events],
 	    ?TERMINATE(
-	       error, {bad_action,Action}, Debug, S, [Event|Events]);
+	       error, {bad_action,Action}, Debug, NewS, Q);
 	postpone ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      true, Hibernate, Timeout, NextEvents);
 	{hibernate,NewHibernate} when is_boolean(NewHibernate) ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      Postpone, NewHibernate, Timeout, NextEvents);
 	{hibernate,_} ->
+	    NewS = S#{state := State, data := NewData, postponed := P},
+	    Q = [Event|Events],
 	    ?TERMINATE(
-	       error, {bad_action,Action}, Debug, S, [Event|Events]);
+	       error, {bad_action,Action}, Debug, NewS, Q);
 	hibernate ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      Postpone, true, Timeout, NextEvents);
 	{timeout,infinity,_} -> % Clear timer - it will never trigger
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      Postpone, Hibernate, undefined, NextEvents);
 	{timeout,Time,_} = NewTimeout when is_integer(Time), Time >= 0 ->
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      Postpone, Hibernate, NewTimeout, NextEvents);
 	{timeout,_,_} ->
+	    NewS = S#{state := State, data := NewData, postponed := P},
+	    Q = [Event|Events],
 	    ?TERMINATE(
-	       error, {bad_action,Action}, Debug, S, [Event|Events]);
+	       error, {bad_action,Action}, Debug, NewS, Q);
 	infinity -> % Clear timer - it will never trigger
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      Postpone, Hibernate, undefined, NextEvents);
 	Time when is_integer(Time), Time >= 0 ->
 	    NewTimeout = {timeout,Time,Time},
 	    loop_event_actions(
-	      Parent, Debug, S, Events, Event,
-	      State, NextState, NewData, Actions,
+	      Parent, Debug, S, Events,
+	      State, NewData, P, Event, NextState, Actions,
 	      Postpone, Hibernate, NewTimeout, NextEvents);
 	_ ->
+	    NewS = S#{state := State, data := NewData, postponed := P},
+	    Q = [Event|Events],
 	    ?TERMINATE(
-	       error, {bad_action,Action}, Debug, S, [Event|Events])
+	       error, {bad_action,Action}, Debug, NewS, Q)
     end;
 %%
 %% End of actions list
 loop_event_actions(
-  Parent, Debug, #{postponed := P0} = S, Events, Event,
-  State, NextState, NewData, [],
+  Parent, Debug, S, Events,
+  State, NewData, P0, Event, NextState, [],
   Postpone, Hibernate, Timeout, NextEvents) ->
     %%
     %% All options have been collected and next_events are buffered.
@@ -1059,7 +1135,7 @@ loop_event_actions(
 		{lists:reverse(P1, Events),[]}
 	end,
     %% Place next events first in queue
-    Q3 = lists:reverse(NextEvents, Q2),
+    Q = lists:reverse(NextEvents, Q2),
     %%
     NewDebug =
 	sys_debug(
@@ -1070,41 +1146,8 @@ loop_event_actions(
 	      false ->
 		  {consume,Event,NextState}
 	  end),
-    %% Have a peek on the event queue so we can avoid starting
-    %% the state timer unless we have to
-    {Q,Timer} =
-	case Timeout of
-	    undefined ->
-		%% No state timeout has been requested
-		{Q3,undefined};
-	    {timeout,Time,EventContent} ->
-		%% A state timeout has been requested
-		case Q3 of
-		    [] when Time =:= 0 ->
-			%% Immediate timeout - simulate it
-			%% so we do not get the timeout message
-			%% after any received event
-			{[{timeout,EventContent}],undefined};
-		    [] ->
-			%% Actually start a timer
-			{Q3,erlang:start_timer(Time, self(), EventContent)};
-		    _ ->
-			%% Do not start a timer since any queued
-			%% event cancels the state timer so we pretend
-			%% that the timer has been started and cancelled
-			{Q3,undefined}
-		end
-	end,
-    %% Loop to top of event queue loop; process next event
     loop_events(
-      Parent, NewDebug,
-      S#{
-	state := NextState,
-	data := NewData,
-	timer := Timer,
-	postponed := P,
-	hibernate := Hibernate},
-      Q, Hibernate).
+      Parent, NewDebug, S, Q, NextState, NewData, P, Hibernate, Timeout).
 
 %%---------------------------------------------------------------------------
 %% Server helpers