From b4f53143b0e05fd3061cdf2e65e17a6a2904090b Mon Sep 17 00:00:00 2001 From: ridiculousfish Date: Fri, 24 Jul 2015 00:50:58 -0700 Subject: Migrate source files into src/ directory This change moves source files into a src/ directory, and puts object files into an obj/ directory. The Makefile and xcode project are updated accordingly. Fixes #1866 --- src/event.h | 176 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 src/event.h (limited to 'src/event.h') diff --git a/src/event.h b/src/event.h new file mode 100644 index 00000000..645eeda4 --- /dev/null +++ b/src/event.h @@ -0,0 +1,176 @@ +/** \file event.h + + Functions for handling event triggers + + Because most of these functions can be called by signal + handler, it is important to make it well defined when these + functions produce output or perform memory allocations, since + such functions may not be safely called by signal handlers. + + +*/ +#ifndef FISH_EVENT_H +#define FISH_EVENT_H + +#include + +#include "common.h" + +/** + The signal number that is used to match any signal +*/ +#define EVENT_ANY_SIGNAL -1 + +/** + The process id that is used to match any process id +*/ +#define EVENT_ANY_PID 0 + +/** + Enumeration of event types +*/ +enum +{ + EVENT_ANY, /**< Matches any event type (Not always any event, as the function name may limit the choice as well */ + EVENT_SIGNAL, /**< An event triggered by a signal */ + EVENT_VARIABLE, /**< An event triggered by a variable update */ + EVENT_EXIT, /**< An event triggered by a job or process exit */ + EVENT_JOB_ID, /**< An event triggered by a job exit */ + EVENT_GENERIC, /**< A generic event */ +} +; + +/** + The structure which represents an event. The event_t struct has + several event-related use-cases: + + - When used as a parameter to event_add, it represents a class of events, and function_name is the name of the function which will be called whenever an event matching the specified class occurs. This is also how events are stored internally. + - When used as a parameter to event_get, event_remove and event_fire, it represents a class of events, and if the function_name field is non-zero, only events which call the specified function will be returned. +*/ +struct event_t +{ +public: + + /** Type of event */ + int type; + + /** The type-specific parameter. The int types are one of the following: + + signal: Signal number for signal-type events.Use EVENT_ANY_SIGNAL to match any signal + pid: Process id for process-type events. Use EVENT_ANY_PID to match any pid. + job_id: Job id for EVENT_JOB_ID type events + */ + union + { + int signal; + int job_id; + pid_t pid; + } param1; + + /** The string types are one of the following: + + variable: Variable name for variable-type events. + param: The parameter describing this generic event. + */ + wcstring str_param1; + + /** + The name of the event handler function + */ + wcstring function_name; + + /** + The argument list. Only used when sending a new event using + event_fire. In all other situations, the value of this variable + is ignored. + */ + wcstring_list_t arguments; + + event_t(int t); + ~event_t(); + + static event_t signal_event(int sig); + static event_t variable_event(const wcstring &str); + static event_t generic_event(const wcstring &str); +}; + +/** + Add an event handler + + May not be called by a signal handler, since it may allocate new memory. +*/ +void event_add_handler(const event_t &event); + +/** + Remove all events matching the specified criterion. + + May not be called by a signal handler, since it may free allocated memory. +*/ +void event_remove(const event_t &event); + +/** + Return all events which match the specified event class + + This function is safe to call from a signal handler _ONLY_ if the + out parameter is null. + + \param criterion Is the class of events to return. If the criterion has a non-null function_name, only events which trigger the specified function will return. + \param out the list to add events to. May be 0, in which case no events will be added, but the result count will still be valid + + \return the number of found matches +*/ +int event_get(const event_t &criterion, std::vector *out); + +/** + Returns whether an event listener is registered for the given signal. + This is safe to call from a signal handler. +*/ +bool event_is_signal_observed(int signal); + +/** + Fire the specified event. The function_name field of the event must + be set to 0. If the event is of type EVENT_SIGNAL, no the event is + queued, and will be dispatched the next time event_fire is + called. If event is a null-pointer, all pending events are + dispatched. + + This function is safe to call from a signal handler _ONLY_ if the + event parameter is for a signal. Signal events not be fired, by the + call to event_fire, instead they will be fired the next time + event_fire is called with anull argument. This is needed to make + sure that no code evaluation is ever performed by a signal handler. + + \param event the specific event whose handlers should fire. If + null, then all delayed events will be fired. +*/ +void event_fire(const event_t *event); + +/** Like event_fire, but takes a signal directly. */ +void event_fire_signal(int signal); + +/** + Initialize the event-handling library +*/ +void event_init(); + +/** + Destroy the event-handling library +*/ +void event_destroy(); + +/** + Free all memory used by the specified event +*/ +void event_free(event_t *e); + +/** + Returns a string describing the specified event. +*/ +wcstring event_get_desc(const event_t &e); + +/** + Fire a generic event with the specified name +*/ +void event_fire_generic(const wchar_t *name, wcstring_list_t *args = NULL); + +#endif -- cgit v1.2.3