C++-ify struct thread_fsm

This C++-ifies struct thread_fsm, replacing the "ops" structure with
virtual methods, and changing all the implementations to derive from
thread_fsm.

gdb/ChangeLog
2019-02-07  Tom Tromey  <tom@tromey.com>

	* thread.c (thread_cancel_execution_command): Update.
	* thread-fsm.h (struct thread_fsm): Add constructor, destructor,
	methods.
	(struct thread_fsm_ops): Remove.
	(thread_fsm_ctor, thread_fsm_delete, thread_fsm_clean_up)
	(thread_fsm_should_stop, thread_fsm_return_value)
	(thread_fsm_set_finished, thread_fsm_finished_p)
	(thread_fsm_async_reply_reason, thread_fsm_should_notify_stop):
	Don't declare.
	* mi/mi-interp.c (mi_on_normal_stop_1): Update.
	* infrun.c (clear_proceed_status_thread)
	(clean_up_just_stopped_threads_fsms, fetch_inferior_event)
	(print_stop_event): Update.
	* infcmd.c (struct step_command_fsm): Inherit from thread_fsm.
	Add constructor.
	(step_command_fsm_ops): Remove.
	(new_step_command_fsm): Remove.
	(step_1): Update.
	(step_command_fsm::should_stop): Rename from
	step_command_fsm_should_stop.
	(step_command_fsm::clean_up): Rename from
	step_command_fsm_clean_up.
	(step_command_fsm::do_async_reply_reason): Rename from
	step_command_fsm_async_reply_reason.
	(struct until_next_fsm): Inherit from thread_fsm.  Add
	constructor.
	(until_next_fsm_ops): Remove.
	(new_until_next_fsm): Remove.
	(until_next_fsm::should_stop): Rename from
	until_next_fsm_should_stop.
	(until_next_fsm::clean_up): Rename from until_next_fsm_clean_up.
	(until_next_fsm::do_async_reply_reason): Rename from
	until_next_fsm_async_reply_reason.
	(struct finish_command_fsm): Inherit from thread_fsm.  Add
	constructor.  Change type of breakpoint.
	(finish_command_fsm_ops): Remove.
	(new_finish_command_fsm): Remove.
	(finish_command_fsm::should_stop): Rename from
	finish_command_fsm_should_stop.
	(finish_command_fsm::clean_up): Rename from
	finish_command_fsm_clean_up.
	(finish_command_fsm::return_value): Rename from
	finish_command_fsm_return_value.
	(finish_command_fsm::do_async_reply_reason): Rename from
	finish_command_fsm_async_reply_reason.
	(finish_command): Update.
	* infcall.c (struct call_thread_fsm): Inherit from thread_fsm.
	Add constructor.
	(call_thread_fsm_ops): Remove.
	(call_thread_fsm::call_thread_fsm): Rename from
	new_call_thread_fsm.
	(call_thread_fsm::should_stop): Rename from
	call_thread_fsm_should_stop.
	(call_thread_fsm::should_notify_stop): Rename from
	call_thread_fsm_should_notify_stop.
	(run_inferior_call, call_function_by_hand_dummy): Update.
	* cli/cli-interp.c (should_print_stop_to_console): Update.
	* breakpoint.c (struct until_break_fsm): Inherit from thread_fsm.
	Add constructor.  Change type of location_breakpoint,
	caller_breakpoint.
	(until_break_fsm_ops): Remove.
	(new_until_break_fsm): Remove.
	(until_break_fsm::should_stop): Rename from
	until_break_fsm_should_stop.
	(until_break_fsm::clean_up): Rename from
	until_break_fsm_clean_up.
	(until_break_fsm::do_async_reply_reason): Rename from
	until_break_fsm_async_reply_reason.
	(until_break_command): Update.
	* thread-fsm.c: Remove.
	* Makefile.in (COMMON_SFILES): Remove thread-fsm.c.

1 files changed, 52 insertions, 54 deletions

diff --git a/gdb/thread-fsm.h b/gdb/thread-fsm.h
index 3f63dbd2641..57837bfdfb1 100644
--- a/gdb/thread-fsm.h
+++ b/gdb/thread-fsm.h
@@ -30,34 +30,24 @@ struct thread_fsm_ops;
 
 struct thread_fsm
 {
-  /* Pointer of the virtual table of methods.  */
-  struct thread_fsm_ops *ops;
+  explicit thread_fsm (struct interp *cmd_interp)
+    : command_interp (cmd_interp)
+  {
+  }
 
-  /* Whether the FSM is done successfully.  */
-  int finished;
-
-  /* The interpreter that issued the execution command that caused
-     this thread to resume.  If the top level interpreter is MI/async,
-     and the execution command was a CLI command (next/step/etc.),
-     we'll want to print stop event output to the MI console channel
-     (the stepped-to line, etc.), as if the user entered the execution
-     command on a real GDB console.  */
-  struct interp *command_interp;
-};
-
-/* The virtual table of a thread_fsm.  */
-
-struct thread_fsm_ops
-{
   /* The destructor.  This should simply free heap allocated data
      structures.  Cleaning up target resources (like, e.g.,
      breakpoints) should be done in the clean_up method.  */
-  void (*dtor) (struct thread_fsm *self);
+  virtual ~thread_fsm () = default;
+
+  DISABLE_COPY_AND_ASSIGN (thread_fsm);
 
   /* Called to clean up target resources after the FSM.  E.g., if the
      FSM created internal breakpoints, this is where they should be
      deleted.  */
-  void (*clean_up) (struct thread_fsm *self, struct thread_info *thread);
+  virtual void clean_up (struct thread_info *thread)
+  {
+  }
 
   /* Called after handle_inferior_event decides the target is done
      (that is, after stop_waiting).  The FSM is given a chance to
@@ -66,50 +56,58 @@ struct thread_fsm_ops
      should be re-resumed.  This is a good place to cache target data
      too.  For example, the "finish" command saves the just-finished
      function's return value here.  */
-  int (*should_stop) (struct thread_fsm *self, struct thread_info *thread);
+  virtual bool should_stop (struct thread_info *thread) = 0;
 
   /* If this FSM saved a function's return value, you can use this
      method to retrieve it.  Otherwise, this returns NULL.  */
-  struct return_value_info *(*return_value) (struct thread_fsm *self);
-
-  /* The async_reply_reason that is broadcast to MI clients if this
-     FSM finishes successfully.  */
-  enum async_reply_reason (*async_reply_reason) (struct thread_fsm *self);
+  virtual struct return_value_info *return_value ()
+  {
+    return nullptr;
+  }
+
+  enum async_reply_reason async_reply_reason ()
+  {
+    /* If we didn't finish, then the stop reason must come from
+       elsewhere.  E.g., a breakpoint hit or a signal intercepted.  */
+    gdb_assert (finished_p ());
+    return do_async_reply_reason ();
+  }
 
   /* Whether the stop should be notified to the user/frontend.  */
-  int (*should_notify_stop) (struct thread_fsm *self);
-};
-/* Initialize FSM.  */
-extern void thread_fsm_ctor (struct thread_fsm *self,
-			     struct thread_fsm_ops *ops,
-			     struct interp *cmd_interp);
-
-/* Calls the FSM's dtor method, and then frees FSM.  */
-extern void thread_fsm_delete (struct thread_fsm *fsm);
-
-/* Calls the FSM's clean_up method.  */
-extern void thread_fsm_clean_up (struct thread_fsm *fsm,
-				 struct thread_info *thread);
+  virtual bool should_notify_stop ()
+  {
+    return true;
+  }
 
-/* Calls the FSM's should_stop method.  */
-extern int thread_fsm_should_stop (struct thread_fsm *fsm,
-				   struct thread_info *thread);
+  void set_finished ()
+  {
+    finished = true;
+  }
 
-/* Calls the FSM's return_value method.  */
-extern struct return_value_info *
-  thread_fsm_return_value (struct thread_fsm *fsm);
+  bool finished_p () const
+  {
+    return finished;
+  }
 
-/* Marks the FSM as completed successfully.  */
-extern void thread_fsm_set_finished (struct thread_fsm *fsm);
+  /* The interpreter that issued the execution command that caused
+     this thread to resume.  If the top level interpreter is MI/async,
+     and the execution command was a CLI command (next/step/etc.),
+     we'll want to print stop event output to the MI console channel
+     (the stepped-to line, etc.), as if the user entered the execution
+     command on a real GDB console.  */
+  struct interp *command_interp = nullptr;
 
-/* Returns true if the FSM completed successfully.  */
-extern int thread_fsm_finished_p (struct thread_fsm *fsm);
+protected:
 
-/* Calls the FSM's reply_reason method.  */
-extern enum async_reply_reason
-  thread_fsm_async_reply_reason (struct thread_fsm *fsm);
+  /* Whether the FSM is done successfully.  */
+  bool finished = false;
 
-/* Calls the FSM's should_notify_stop method.  */
-extern int thread_fsm_should_notify_stop (struct thread_fsm *self);
+  /* The async_reply_reason that is broadcast to MI clients if this
+     FSM finishes successfully.  */
+  virtual enum async_reply_reason do_async_reply_reason ()
+  {
+    gdb_assert_not_reached (_("should not call async_reply_reason here"));
+  }
+};
 
 #endif /* THREAD_FSM_H */