/* Thread command's finish-state machine, for GDB, the GNU debugger. Copyright (C) 2015 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #ifndef THREAD_FSM_H #define THREAD_FSM_H #include "mi/mi-common.h" /* For enum async_reply_reason. */ struct return_value_info; struct thread_fsm_ops; /* A thread finite-state machine structure contains the necessary info and callbacks to manage the state machine protocol of a thread's execution command. */ struct thread_fsm { /* Pointer of the virtual table of methods. */ struct thread_fsm_ops *ops; /* Whether the FSM is done successfully. */ int finished; }; /* 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); /* 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); /* Called after handle_inferior_event decides the target is done (that is, after stop_waiting). The FSM is given a chance to decide whether the command is done and thus the target should stop, or whether there's still more to do and thus the thread 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); /* 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); }; /* Initialize FSM. */ extern void thread_fsm_ctor (struct thread_fsm *fsm, struct thread_fsm_ops *ops); /* 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); /* Calls the FSM's should_stop method. */ extern int thread_fsm_should_stop (struct thread_fsm *fsm); /* Calls the FSM's return_value method. */ extern struct return_value_info * thread_fsm_return_value (struct thread_fsm *fsm); /* Marks the FSM as completed successfully. */ extern void thread_fsm_set_finished (struct thread_fsm *fsm); /* Returns true if the FSM completed successfully. */ extern int thread_fsm_finished_p (struct thread_fsm *fsm); /* Calls the FSM's reply_reason method. */ extern enum async_reply_reason thread_fsm_async_reply_reason (struct thread_fsm *fsm); #endif /* THREAD_FSM_H */