Mirrors/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell synced 2025-01-22 09:45:47 +00:00
Code Issues Projects Releases Packages Wiki Activity
fish-shell/src/event.cpp

550 lines
20 KiB
C++
Raw Normal View History

retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
// Functions for handling event triggers.
add (or restore) config.h to all files The autoconf-generated config.h contains a number of directives which may alter the behaviour of system headers on certain platforms. Always include it in every C++ file as the first include. Closes #2993.
2016-05-18 22:30:21 +00:00
#include "config.h" // IWYU pragma: keep
Run clang-format on all files The main change here is to reorder headers.
2019-10-13 22:50:48 +00:00
#include "event.h"
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
#include <signal.h>
more IWYU fixes I'm starting to wonder if IWYU is worth the effort. Nonetheless, this makes it lint clean on macOS and reduces the number of warnings on FreeBSD and Linux.
2017-02-13 04:24:22 +00:00
#include <stddef.h>
add better support for IWYU and fix things Remove the "make iwyu" build target. Move the functionality into the recently introduced lint.fish script. Fix a lot, but not all, of the include-what-you-use errors. Specifically, it fixes all of the IWYU errors on my OS X server but only removes some of them on my Ubuntu 14.04 server. Fixes #2957
2016-04-21 06:00:54 +00:00
#include <unistd.h>
lint cleanups
2017-02-11 02:47:02 +00:00
add better support for IWYU and fix things Remove the "make iwyu" build target. Move the functionality into the recently introduced lint.fish script. Fix a lot, but not all, of the include-what-you-use errors. Specifically, it fixes all of the IWYU errors on my OS X server but only removes some of them on my Ubuntu 14.04 server. Fixes #2957
2016-04-21 06:00:54 +00:00
#include <algorithm>
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
#include <atomic>
lint cleanups
2017-02-11 02:47:02 +00:00
#include <functional>
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
#include <memory>
Initial pass with Include What You Use
2015-07-25 15:14:25 +00:00
#include <string>
lint cleanups
2017-02-11 02:47:02 +00:00
#include <type_traits>
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
#include "common.h"
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
#include "fallback.h" // IWYU pragma: keep
#include "input_common.h"
Initial pass with Include What You Use
2015-07-25 15:14:25 +00:00
#include "io.h"
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
#include "parser.h"
#include "proc.h"
#include "signal.h"
Update termsize before a sigwinch handler This could have been one iteration off, e.g. ```fish function on-winch --on-signal winch echo $LINES end ``` Resize the terminal, it'll print e.g. 24 then run `echo $LINES` interactively, it might have a different answer. This isn't beautiful, but it works. A better solution might be to make the termsize vars electric and just always update them on read?
2021-04-14 15:17:22 +00:00
#include "termsize.h"
Remove proc_create_event Switch to a set of factory functions inside event_t. No user-visible change here.
2021-05-17 22:33:33 +00:00
#include "wcstringutil.h"
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
#include "wutil.h" // IWYU pragma: keep
Remove translate.c. The gettext fallback functionality is moved to fallback.c, the wide wrapper is moved to wutil.c darcs-hash:20060719225549-ac50b-0a55e805b04f4fe0afa99ea580901d62f39cdef5.gz
2006-07-19 22:55:49 +00:00
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
class pending_signals_t {
static constexpr size_t SIGNAL_COUNT = NSIG;
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
/// A counter that is incremented each time a pending signal is received.
std::atomic<uint32_t> counter_{0};
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
/// List of pending signals.
std::array<std::atomic<bool>, SIGNAL_COUNT> received_{};
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
/// The last counter visible in acquire_pending().
/// This is not accessed from a signal handler.
owning_lock<uint32_t> last_counter_{0};
Reformat all files This runs build_tools/style.fish, which runs clang-format on C++, fish_indent on fish and (new) black on python. If anything is wrong with the formatting, we should fix the tools, but automated formatting is worth it.
2019-05-05 10:09:25 +00:00
public:
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
pending_signals_t() = default;
/// No copying.
pending_signals_t(const pending_signals_t &);
void operator=(const pending_signals_t &);
/// Mark a signal as pending. This may be called from a signal handler.
/// We expect only one signal handler to execute at once.
/// Also note that these may be coalesced.
void mark(int which) {
if (which >= 0 && static_cast<size_t>(which) < received_.size()) {
// Must mark our received first, then pending.
received_[which].store(true, std::memory_order_relaxed);
uint32_t count = counter_.load(std::memory_order_relaxed);
counter_.store(1 + count, std::memory_order_release);
}
}
/// \return the list of signals that were set, clearing them.
std::bitset<SIGNAL_COUNT> acquire_pending() {
auto current = last_counter_.acquire();
// Check the counter first. If it hasn't changed, no signals have been received.
uint32_t count = counter_.load(std::memory_order_acquire);
if (count == *current) {
return {};
}
Reformat all files This runs build_tools/style.fish, which runs clang-format on C++, fish_indent on fish and (new) black on python. If anything is wrong with the formatting, we should fix the tools, but automated formatting is worth it.
2019-05-05 10:09:25 +00:00
// The signal count has changed. Store the new counter and fetch all the signals that are
// set.
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
*current = count;
std::bitset<SIGNAL_COUNT> result{};
uint32_t bit = 0;
for (auto &signal : received_) {
bool val = signal.load(std::memory_order_relaxed);
if (val) {
result.set(bit);
signal.store(false, std::memory_order_relaxed);
}
bit++;
}
return result;
}
};
static pending_signals_t s_pending_signals;
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
/// List of event handlers.
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
static owning_lock<event_handler_list_t> s_event_handlers;
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
/// Variables (one per signal) set when a signal is observed. This is inspected by a signal handler.
Make set_signal_observed thread-safe
2019-06-03 07:02:22 +00:00
static volatile sig_atomic_t s_observed_signals[NSIG] = {};
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
static void set_signal_observed(int sig, bool val) {
[clang-tidy] Convert C casts to C++ ones Found with google-readability-casting Signed-off-by: Rosen Penev <rosenp@gmail.com>
2019-11-19 01:08:16 +00:00
if (sig >= 0 &&
static_cast<size_t>(sig) < sizeof s_observed_signals / sizeof *s_observed_signals) {
Rename events and simplify signal event handling - Rename 'events' to 's_event_handlers' - Stop inspecting the s_event_handlers list upon receiving a signal. Instead, maintain the set of signals that are observed in a separate static array. This lets us avoid mucking with STL data structures in a signal handler, and so avoid blocking signals in event.cpp
2014-12-29 08:34:36 +00:00
s_observed_signals[sig] = val;
}
}
Prune job exit handlers after running While pid values may be reused, it is logical to assume that fish event handlers coded against a particular job or process id mean just the job that is currently referred to be any given pid/pgrp rather than in perpetuity. This trims the list of registered event handlers nice and early, and as a bonus avoids the issue described in #7721. The cleanup song-and-dance is extremely ugly due to the repeated locking and unlocking of the event handler list. Closes #7221.
2021-03-06 04:32:57 +00:00
/// Tests if one event instance matches the definition of an event class.
/// In case of a match, \p only_once indicates that the event cannot match again by nature.
static bool handler_matches(const event_handler_t &classv, const event_t &instance,
bool &only_once) {
only_once = false;
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
if (classv.desc.type == event_type_t::any) return true;
if (classv.desc.type != instance.desc.type) return false;
Remove trailing whitespaces and change tabs to spaces
2012-11-18 10:23:22 +00:00
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
switch (classv.desc.type) {
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::signal: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return classv.desc.param1.signal == instance.desc.param1.signal;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::variable: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return instance.desc.str_param1 == classv.desc.str_param1;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
case event_type_t::process_exit: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
if (classv.desc.param1.pid == EVENT_ANY_PID) return true;
Prune job exit handlers after running While pid values may be reused, it is logical to assume that fish event handlers coded against a particular job or process id mean just the job that is currently referred to be any given pid/pgrp rather than in perpetuity. This trims the list of registered event handlers nice and early, and as a bonus avoids the issue described in #7721. The cleanup song-and-dance is extremely ugly due to the repeated locking and unlocking of the event handler list. Closes #7221.
2021-03-06 04:32:57 +00:00
only_once = true;
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return classv.desc.param1.pid == instance.desc.param1.pid;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
case event_type_t::job_exit: {
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
const auto &jobspec = classv.desc.param1.jobspec;
if (jobspec.pid == EVENT_ANY_PID) return true;
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
only_once = true;
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
return jobspec.internal_job_id == instance.desc.param1.jobspec.internal_job_id;
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
}
Rename event_type_t::job_exit to event_type_t::caller_exit "job_exit" events, despite their name, can only be created via the '--on-job-exit caller' misfeature of function. Rename it to make it clear that this event type is specifically for caller-exit.
2020-02-09 00:08:26 +00:00
case event_type_t::caller_exit: {
Prune job exit handlers after running While pid values may be reused, it is logical to assume that fish event handlers coded against a particular job or process id mean just the job that is currently referred to be any given pid/pgrp rather than in perpetuity. This trims the list of registered event handlers nice and early, and as a bonus avoids the issue described in #7721. The cleanup song-and-dance is extremely ugly due to the repeated locking and unlocking of the event handler list. Closes #7221.
2021-03-06 04:32:57 +00:00
only_once = true;
Fix up --on-job-exit caller The `function --on-job-exit caller` feature allows a command substitution to observe when the parent job exits. This has never worked very well - in particular it is based on job IDs, so a function that observes this will run multiple times. Implement it properly. Do this by having a not-recycled "internal job id". This is only used by psub, but ensure it works properly none-the-less.
2020-02-08 23:43:21 +00:00
return classv.desc.param1.caller_id == instance.desc.param1.caller_id;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::generic: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return classv.desc.str_param1 == instance.desc.str_param1;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Fix `switch` nesting in handler_matches I guess this worked, but whoops.
2019-03-12 22:27:13 +00:00
case event_type_t::any:
default: {
lint: missing default in switch statements
2016-10-30 00:25:48 +00:00
DIE("unexpected classv.type");
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return false;
lint: missing default in switch statements
2016-10-30 00:25:48 +00:00
}
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
/// Test if specified event is blocked.
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
static int event_is_blocked(parser_t &parser, const event_t &e) {
Remove some unused variables
2019-05-13 01:23:00 +00:00
(void)e;
Refactor block_t storage in parser_t from a linked list to a vector
2013-12-21 01:41:21 +00:00
const block_t *block;
size_t idx = 0;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
while ((block = parser.block_at_index(idx++))) {
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
if (event_block_list_blocks_type(block->event_blocks)) return true;
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
return event_block_list_blocks_type(parser.global_event_blocks);
Initial blocking implementation darcs-hash:20051211222101-ac50b-6e11220bd608187fbb32a0313b5b73dbdc8354fc.gz
2005-12-11 22:21:01 +00:00
}
Eliminate more calls to principal_parser() Require a parser to get a job from its pgid.
2020-02-08 20:39:03 +00:00
wcstring event_get_desc(const parser_t &parser, const event_t &evt) {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
const event_description_t &ed = evt.desc;
switch (ed.type) {
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::signal: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return format_string(_(L"signal handler for %ls (%ls)"), sig2wcs(ed.param1.signal),
signal_get_desc(ed.param1.signal));
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::variable: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return format_string(_(L"handler for variable '%ls'"), ed.str_param1.c_str());
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
case event_type_t::process_exit: {
return format_string(_(L"exit handler for process %d"), ed.param1.pid);
}
case event_type_t::job_exit: {
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
const auto &jobspec = ed.param1.jobspec;
if (const job_t *j = parser.job_get_from_pid(jobspec.pid)) {
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
return format_string(_(L"exit handler for job %d, '%ls'"), j->job_id(),
j->command_wcstr());
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
} else {
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
return format_string(_(L"exit handler for job with pid %d"), jobspec.pid);
Fix indentation of switch statements
2012-11-19 08:31:03 +00:00
}
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
Rename event_type_t::job_exit to event_type_t::caller_exit "job_exit" events, despite their name, can only be created via the '--on-job-exit caller' misfeature of function. Rename it to make it clear that this event type is specifically for caller-exit.
2020-02-09 00:08:26 +00:00
case event_type_t::caller_exit: {
return _(L"exit handler for command substitution caller");
Fix indentation of switch statements
2012-11-19 08:31:03 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::generic: {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return format_string(_(L"handler for generic event '%ls'"), ed.str_param1.c_str());
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
}
Reformat all files This runs build_tools/style.fish, which runs clang-format on C++, fish_indent on fish and (new) black on python. If anything is wrong with the formatting, we should fix the tools, but automated formatting is worth it.
2019-05-05 10:09:25 +00:00
case event_type_t::any: {
DIE("Unreachable");
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
default:
event.cpp: die if invalid event type passed Fixes the build with -Wreturn-type.
2019-03-04 23:27:56 +00:00
DIE("Unknown event type");
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Generalize the stack tracing code, add support for showing events and command substitutions in stack traces darcs-hash:20060201154911-ac50b-707358ea50231661c05a92b40ca109ec801081e6.gz
2006-02-01 15:49:11 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
void event_add_handler(std::shared_ptr<event_handler_t> eh) {
if (eh->desc.type == event_type_t::signal) {
Remove the useless second parameter from signal_handle It was always set to 1.
2019-06-28 17:33:03 +00:00
signal_handle(eh->desc.param1.signal);
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
set_signal_observed(eh->desc.param1.signal, true);
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
s_event_handlers.acquire()->push_back(std::move(eh));
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
void event_remove_function_handlers(const wcstring &name) {
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
auto handlers = s_event_handlers.acquire();
auto begin = handlers->begin(), end = handlers->end();
handlers->erase(std::remove_if(begin, end,
[&](const shared_ptr<event_handler_t> &eh) {
return eh->function_name == name;
}),
end);
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
event_handler_list_t event_get_function_handlers(const wcstring &name) {
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
auto handlers = s_event_handlers.acquire();
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
event_handler_list_t result;
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
for (const shared_ptr<event_handler_t> &eh : *handlers) {
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
if (eh->function_name == name) {
result.push_back(eh);
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Remove trailing whitespaces and change tabs to spaces
2012-11-18 10:23:22 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return result;
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
bool event_is_signal_observed(int sig) {
// We are in a signal handler! Don't allocate memory, etc.
Rename events and simplify signal event handling - Rename 'events' to 's_event_handlers' - Stop inspecting the s_event_handlers list upon receiving a signal. Instead, maintain the set of signals that are observed in a separate static array. This lets us avoid mucking with STL data structures in a signal handler, and so avoid blocking signals in event.cpp
2014-12-29 08:34:36 +00:00
bool result = false;
[clang-tidy] Convert C casts to C++ ones Found with google-readability-casting Signed-off-by: Rosen Penev <rosenp@gmail.com>
2019-11-19 01:08:16 +00:00
if (sig >= 0 && static_cast<unsigned long>(sig) <
sizeof(s_observed_signals) / sizeof(*s_observed_signals)) {
Rename events and simplify signal event handling - Rename 'events' to 's_event_handlers' - Stop inspecting the s_event_handlers list upon receiving a signal. Instead, maintain the set of signals that are observed in a separate static array. This lets us avoid mucking with STL data structures in a signal handler, and so avoid blocking signals in event.cpp
2014-12-29 08:34:36 +00:00
result = s_observed_signals[sig];
Signal handling cleanup and improved safety Fixes issue where you couldn't control-C out of a loop (https://github.com/ridiculousfish/fishfish/issues/13) Also stops doing memory allocation in the signal handler (oops) https://github.com/ridiculousfish/fishfish/issues/27
2012-06-04 21:20:01 +00:00
}
Rename events and simplify signal event handling - Rename 'events' to 's_event_handlers' - Stop inspecting the s_event_handlers list upon receiving a signal. Instead, maintain the set of signals that are observed in a separate static array. This lets us avoid mucking with STL data structures in a signal handler, and so avoid blocking signals in event.cpp
2014-12-29 08:34:36 +00:00
return result;
Signal handling cleanup and improved safety Fixes issue where you couldn't control-C out of a loop (https://github.com/ridiculousfish/fishfish/issues/13) Also stops doing memory allocation in the signal handler (oops) https://github.com/ridiculousfish/fishfish/issues/27
2012-06-04 21:20:01 +00:00
}
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
/// Perform the specified event. Since almost all event firings will not be matched by even a single
/// event handler, we make sure to optimize the 'no matches' path. This means that nothing is
/// allocated/initialized unless needed.
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
static void event_fire_internal(parser_t &parser, const event_t &event) {
auto &ld = parser.libdata();
Make is_event and other globals part of parser_t libdata
2019-05-13 01:02:57 +00:00
assert(ld.is_event >= 0 && "is_event should not be negative");
scoped_push<decltype(ld.is_event)> inc_event{&ld.is_event, ld.is_event + 1};
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
Add support for fish_trace variable to trace execution This adds support for `fish_trace`, a new variable intended to serve the same purpose as `set -x` as in bash. Setting this variable to anything non-empty causes execution to be traced. In the future we may give more specific meaning to the value of the variable. The user's prompt is not traced unless you run it explicitly. Events are also not traced because it is noisy; however autoloading is. Fixes #3427
2019-10-19 01:08:22 +00:00
// Suppress fish_trace during events.
scoped_push<bool> suppress_trace{&ld.suppress_fish_trace, true};
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
// Capture the event handlers that match this event.
Prune job exit handlers after running While pid values may be reused, it is logical to assume that fish event handlers coded against a particular job or process id mean just the job that is currently referred to be any given pid/pgrp rather than in perpetuity. This trims the list of registered event handlers nice and early, and as a bonus avoids the issue described in #7721. The cleanup song-and-dance is extremely ugly due to the repeated locking and unlocking of the event handler list. Closes #7221.
2021-03-06 04:32:57 +00:00
struct firing_handler_t {
std::shared_ptr<event_handler_t> handler;
bool delete_after_call;
};
std::vector<firing_handler_t> fire;
{
for (const auto &handler : *s_event_handlers.acquire()) {
// Check if this event is a match.
bool only_once = false;
if (!handler_matches(*handler, event, only_once)) {
continue;
}
// If the nature of the event means it can't be fired more than once, deregister the
// event. This also works around a bug where jobs run without job control (no separate
// pgrp) cause handlers to run for each subsequent job started without job control
// (#7721). We can't erase it here because we check if the event is still extant before
// actually calling it below, so we instead push it along with its "delete after
// calling" value.
fire.push_back(firing_handler_t{handler, only_once});
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Remove trailing whitespaces and change tabs to spaces
2012-11-18 10:23:22 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
// Iterate over our list of matching events. Fire the ones that are still present.
Prune job exit handlers after running While pid values may be reused, it is logical to assume that fish event handlers coded against a particular job or process id mean just the job that is currently referred to be any given pid/pgrp rather than in perpetuity. This trims the list of registered event handlers nice and early, and as a bonus avoids the issue described in #7721. The cleanup song-and-dance is extremely ugly due to the repeated locking and unlocking of the event handler list. Closes #7221.
2021-03-06 04:32:57 +00:00
for (const auto &firing_event : fire) {
auto &handler = firing_event.handler;
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
// Only fire if this event is still present.
// TODO: this is kind of crazy. We want to support removing (and thereby suppressing) an
// event handler from another, but we also don't want to hold the lock across callouts. How
// can we make this less silly?
Optimize pruning of job/proc exit handlers Pre-emptively delete the handler while we have possession of the lock before calling the event itself. It's crude, but it works.
2021-03-06 04:40:06 +00:00
{
auto event_handlers = s_event_handlers.acquire();
if (!contains(*event_handlers, handler)) {
continue;
}
// Delete the event before firing it so we don't have to lock and unlock the event
// handlers list when handing control off to the handler.
if (firing_event.delete_after_call) {
FLOGF(event, L"Pruning handler '%ls' before firing", event.desc.str_param1.c_str());
for (auto event_handler = event_handlers->begin();
event_handler != event_handlers->end(); ++event_handler) {
if (event_handler->get() == firing_event.handler.get()) {
event_handlers->erase(event_handler);
break;
}
}
}
Clean up event_t handling Use shared_ptr instead of the silly killme list
2017-01-22 00:48:07 +00:00
}
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
// Construct a buffer to evaluate, starting with the function name and then all the
// arguments.
wcstring buffer = handler->function_name;
for (const wcstring &arg : event.arguments) {
buffer.push_back(L' ');
buffer.append(escape_string(arg, ESCAPE_ALL));
Migrate to std::vector in event class
2011-12-27 08:06:07 +00:00
}
Event handling and job reaping updates darcs-hash:20051011192343-ac50b-aa3f5ae5e2b34d122f10e3b59ceb6fdd447f4ae3.gz
2005-10-11 19:23:43 +00:00
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
// Event handlers are not part of the main flow of code, so they are marked as
// non-interactive.
Eliminate shell_is_interactive We used to have a global notion of "is the shell interactive" but soon we will want to have multiple independent execution threads, only some of which may be interactive. Start tracking this data per-parser.
2019-05-27 21:52:48 +00:00
scoped_push<bool> interactive{&ld.is_interactive, false};
Make $status and $pipestatus per-parser Another step towards allowing multiple parsers to execute in parallel.
2019-05-12 21:00:44 +00:00
auto prev_statuses = parser.get_last_statuses();
Remove trailing whitespaces and change tabs to spaces
2012-11-18 10:23:22 +00:00
Add event flog I needed this, and it should be there. [ci skip]
2020-10-06 14:53:25 +00:00
FLOGF(event, L"Firing event '%ls'", event.desc.str_param1.c_str());
Stop creating subclasses of block_t Move all block_t creation methods to static methods, and stop creating subclasses (all of which are now empty).
2019-05-19 21:40:06 +00:00
block_t *b = parser.push_block(block_t::event_block(event));
Default parser_t::eval()'s block type to top This is the parameter value at every call site except one. Just make it the default.
2019-12-23 00:27:03 +00:00
parser.eval(buffer, io_chain_t());
Clean up parser_t's block stack Currently the block stack is just a vector of pointers. Clients must manually use new() to allocate a block, and then transfer ownership to the stack (so must NOT delete it). Give the parser itself responsibility for allocating blocks too, so that it takes over both allocation and deletion. Use unique_ptr to make deletion less error-prone.
2017-01-21 23:35:35 +00:00
parser.pop_block(b);
Make $status and $pipestatus per-parser Another step towards allowing multiple parsers to execute in parallel.
2019-05-12 21:00:44 +00:00
parser.set_last_statuses(std::move(prev_statuses));
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
/// Handle all pending signal events.
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
void event_fire_delayed(parser_t &parser) {
auto &ld = parser.libdata();
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
// Do not invoke new event handlers from within event handlers.
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
if (ld.is_event) return;
Fix interactive --on-signal INT handlers f8ba0ac5bf4b introduced a bug where INT handlers would themselves be cancelled, due to the signal. Defer processing handlers until the parser is ready to execute more fish script. Fixes the interactive case of #6649.
2020-03-01 21:27:34 +00:00
// Do not invoke new event handlers if we are unwinding (#6649).
Rework how signals trigger cancellation When fish receives a "cancellation inducing" signal (SIGINT in particular) it has to unwind execution - for example while loops or whatever else that is executing. There are two ways this may come about: 1. The fish process received the signal 2. A child process received the signal An example of the second case is: some_command | some_function Here `some_command` is the tty owner and so will receive control-C, but then fish has to cancel function execution. Prior to this change, these were handled uniformly: both would just set a cancellation signal inside the parser. However in the future we will have multiple parsers and it may not be obvious which one to set the flag in. So instead distinguish these cases: if a process receives SIGINT we mark the signal in its job group, and if fish receives it we set a global variable.
2020-07-12 18:35:27 +00:00
if (signal_check_cancel()) return;
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
Make the list of blocked events const These are events that have been queued but not yet fired. There's no reason to modify the events after creating them. Mark them as const to ensure that doesn't happen.
2020-07-19 19:03:10 +00:00
std::vector<shared_ptr<const event_t>> to_send;
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
to_send.swap(ld.blocked_events);
assert(ld.blocked_events.empty());
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
// Append all signal events to to_send.
auto signals = s_pending_signals.acquire_pending();
if (signals.any()) {
Reformat all files This runs build_tools/style.fish, which runs clang-format on C++, fish_indent on fish and (new) black on python. If anything is wrong with the formatting, we should fix the tools, but automated formatting is worth it.
2019-05-05 10:09:25 +00:00
for (uint32_t sig = 0; sig < signals.size(); sig++) {
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
if (signals.test(sig)) {
Update termsize before a sigwinch handler This could have been one iteration off, e.g. ```fish function on-winch --on-signal winch echo $LINES end ``` Resize the terminal, it'll print e.g. 24 then run `echo $LINES` interactively, it might have a different answer. This isn't beautiful, but it works. A better solution might be to make the termsize vars electric and just always update them on read?
2021-04-14 15:17:22 +00:00
// HACK: The only variables we change in response to a *signal*
// are $COLUMNS and $LINES.
// Do that now.
if (sig == SIGWINCH) {
(void)termsize_container_t::shared().updating(parser);
}
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
auto e = std::make_shared<event_t>(event_type_t::signal);
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
e->desc.param1.signal = sig;
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
e->arguments.push_back(sig2wcs(sig));
to_send.push_back(std::move(e));
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
}
}
Remove trailing whitespaces and change tabs to spaces
2012-11-18 10:23:22 +00:00
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
// Fire or re-block all events.
for (const auto &evt : to_send) {
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
if (event_is_blocked(parser, *evt)) {
ld.blocked_events.push_back(evt);
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
} else {
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
event_fire_internal(parser, *evt);
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
}
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
void event_enqueue_signal(int signal) {
// Beware, we are in a signal handler
s_pending_signals.mark(signal);
Signal handling cleanup and improved safety Fixes issue where you couldn't control-C out of a loop (https://github.com/ridiculousfish/fishfish/issues/13) Also stops doing memory allocation in the signal handler (oops) https://github.com/ridiculousfish/fishfish/issues/27
2012-06-04 21:20:01 +00:00
}
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
void event_fire(parser_t &parser, const event_t &event) {
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
// Fire events triggered by signals.
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
event_fire_delayed(parser);
Reimplement signal handling event machinery Prior to this fix, fish had a signal_list_t that accumulated signals. Signals were added to an array of integers, with an overflow flag. The event machinery would attempt to atomically "swap in" the other list. After this fix, there is a single list of pending signal events, as an array of atomic booleans. The signal handler sets the boolean corresponding to its signal.
2019-02-21 03:36:29 +00:00
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
if (event_is_blocked(parser, event)) {
parser.libdata().blocked_events.push_back(std::make_shared<event_t>(event));
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
} else {
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
event_fire_internal(parser, event);
Apply new indentation, brace, and whitespace style
2012-11-19 00:30:30 +00:00
}
Initial update for new event subsystem darcs-hash:20051005223708-ac50b-8a8d7e003e1c24747f3f154cb66b6c1a1015c35b.gz
2005-10-05 22:37:08 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
static const wchar_t *event_name_for_type(event_type_t type) {
switch (type) {
case event_type_t::any:
return L"any";
case event_type_t::signal:
return L"signal";
case event_type_t::variable:
return L"variable";
case event_type_t::process_exit:
return L"process-exit";
case event_type_t::job_exit:
return L"job-exit";
case event_type_t::caller_exit:
return L"caller-exit";
case event_type_t::generic:
return L"generic";
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
return L"";
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
const wchar_t *const event_filter_names[] = {L"signal", L"variable", L"exit",
L"process-exit", L"job-exit", L"caller-exit",
L"generic", nullptr};
static bool filter_matches_event(const wcstring &filter, event_type_t type) {
if (filter.empty()) return true;
switch (type) {
case event_type_t::any:
return false;
case event_type_t::signal:
return filter == L"signal";
case event_type_t::variable:
return filter == L"variable";
case event_type_t::process_exit:
return filter == L"process-exit" || filter == L"exit";
case event_type_t::job_exit:
return filter == L"job-exit" || filter == L"exit";
case event_type_t::caller_exit:
return filter == L"process-exit" || filter == L"exit";
case event_type_t::generic:
return filter == L"generic";
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
DIE("Unreachable");
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
}
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
void event_print(io_streams_t &streams, const wcstring &type_filter) {
Make the list of event handlers thread safe
2019-06-03 19:33:10 +00:00
event_handler_list_t tmp = *s_event_handlers.acquire();
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
std::sort(tmp.begin(), tmp.end(),
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
[](const shared_ptr<event_handler_t> &e1, const shared_ptr<event_handler_t> &e2) {
const event_description_t &d1 = e1->desc;
const event_description_t &d2 = e2->desc;
if (d1.type != d2.type) {
return d1.type < d2.type;
}
switch (d1.type) {
case event_type_t::signal:
return d1.signal < d2.signal;
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
case event_type_t::process_exit:
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
return d1.param1.pid < d2.param1.pid;
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
case event_type_t::job_exit:
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
return d1.param1.jobspec.pid < d2.param1.jobspec.pid;
Rename event_type_t::job_exit to event_type_t::caller_exit "job_exit" events, despite their name, can only be created via the '--on-job-exit caller' misfeature of function. Rename it to make it clear that this event type is specifically for caller-exit.
2020-02-09 00:08:26 +00:00
case event_type_t::caller_exit:
Fix up --on-job-exit caller The `function --on-job-exit caller` feature allows a command substitution to observe when the parent job exits. This has never worked very well - in particular it is based on job IDs, so a function that observes this will run multiple times. Implement it properly. Do this by having a not-recycled "internal job id". This is only used by psub, but ensure it works properly none-the-less.
2020-02-08 23:43:21 +00:00
return d1.param1.caller_id < d2.param1.caller_id;
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
case event_type_t::variable:
case event_type_t::any:
case event_type_t::generic:
return d1.str_param1 < d2.str_param1;
}
Fix a "no return value" warning
2019-02-23 22:09:17 +00:00
DIE("Unreachable");
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
});
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
maybe_t<event_type_t> last_type{};
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
for (const shared_ptr<event_handler_t> &evt : tmp) {
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
// If we have a filter, skip events that don't match.
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
if (!filter_matches_event(type_filter, evt->desc.type)) {
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
continue;
}
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
if (!last_type || *last_type != evt->desc.type) {
Reformat all files This runs build_tools/style.fish, which runs clang-format on C++, fish_indent on fish and (new) black on python. If anything is wrong with the formatting, we should fix the tools, but automated formatting is worth it.
2019-05-05 10:09:25 +00:00
if (last_type) streams.out.append(L"\n");
Remove some useless casts I think the warnings from -Wuseless-cast are mostly platform-specific but I hope these are correct.
2020-09-08 20:33:44 +00:00
last_type = evt->desc.type;
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
streams.out.append_format(L"Event %ls\n", event_name_for_type(*last_type));
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
switch (evt->desc.type) {
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::signal:
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
streams.out.append_format(L"%ls %ls\n", sig2wcs(evt->desc.param1.signal),
evt->function_name.c_str());
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
break;
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
case event_type_t::process_exit:
case event_type_t::job_exit:
Rename event_type_t::job_exit to event_type_t::caller_exit "job_exit" events, despite their name, can only be created via the '--on-job-exit caller' misfeature of function. Rename it to make it clear that this event type is specifically for caller-exit.
2020-02-09 00:08:26 +00:00
break;
case event_type_t::caller_exit:
streams.out.append_format(L"caller-exit %ls\n", evt->function_name.c_str());
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
break;
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
case event_type_t::variable:
case event_type_t::generic:
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
streams.out.append_format(L"%ls %ls\n", evt->desc.str_param1.c_str(),
evt->function_name.c_str());
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
break;
Reformat all files This runs build_tools/style.fish, which runs clang-format on C++, fish_indent on fish and (new) black on python. If anything is wrong with the formatting, we should fix the tools, but automated formatting is worth it.
2019-05-05 10:09:25 +00:00
case event_type_t::any:
DIE("Unreachable");
Clean up and document functions --handlers
2018-03-10 10:08:33 +00:00
default:
streams.out.append_format(L"%ls\n", evt->function_name.c_str());
break;
add option --handlers to functions to display function hooks
2018-01-31 17:47:23 +00:00
}
}
}
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
void event_fire_generic(parser_t &parser, const wchar_t *name, const wcstring_list_t *args) {
Eliminate the CHECK() macro This thing was pretty useless.
2019-05-28 00:24:19 +00:00
assert(name && "Null name");
Get event_t off of halloc (!)
2012-02-09 03:02:25 +00:00
Convert event_type_t to an enum class
2019-02-21 06:42:58 +00:00
event_t ev(event_type_t::generic);
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
ev.desc.str_param1 = name;
retyle event module to match project style Reduces lint errors from 39 to 30 (-23%). Line count from 915 to 670 (-27%). Another step in resolving issue #2902.
2016-04-29 02:19:50 +00:00
if (args) ev.arguments = *args;
Make events per-parser This makes the following changes: 1. Events in background threads are executed in those threads, instead of being silently dropped 2. Blocked events are now per-parser instead of global 3. Events are posted in builtin_set instead of within the environment stack The last one means that we no longer support event handlers for implicit sets like (example) argv. Instead only the `set` builtin (and also `cd`) post variable-change events. Events from universal variable changes are still not fully rationalized.
2019-06-03 09:31:13 +00:00
event_fire(parser, ev);
Add a 'generic' type of event that can be emited from any piece of code or by the user. Use this event layer to perform interactive configuration startup at the correct time. darcs-hash:20070819164230-75c98-f91b8a73de7bbbb500d80770ddf4d2d46ae592cc.gz
2007-08-19 16:42:30 +00:00
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
event_description_t event_description_t::signal(int sig) {
event_description_t event(event_type_t::signal);
Get event_t off of halloc (!)
2012-02-09 03:02:25 +00:00
event.param1.signal = sig;
return event;
}
Add a 'generic' type of event that can be emited from any piece of code or by the user. Use this event layer to perform interactive configuration startup at the correct time. darcs-hash:20070819164230-75c98-f91b8a73de7bbbb500d80770ddf4d2d46ae592cc.gz
2007-08-19 16:42:30 +00:00
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
event_description_t event_description_t::variable(wcstring str) {
event_description_t event(event_type_t::variable);
event.str_param1 = std::move(str);
Get event_t off of halloc (!)
2012-02-09 03:02:25 +00:00
return event;
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
event_description_t event_description_t::generic(wcstring str) {
event_description_t event(event_type_t::generic);
event.str_param1 = std::move(str);
Get event_t off of halloc (!)
2012-02-09 03:02:25 +00:00
return event;
}
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
Remove proc_create_event Switch to a set of factory functions inside event_t. No user-visible change here.
2021-05-17 22:33:33 +00:00
// static
Cleanup events Prior to this fix, an "event" was used as both a predicate on which events to match, and also as the event itself. Re-express these concepts distinctly: an event is something that happened, an event_handler is the predicate and name of the function to execute.
2019-02-23 09:04:05 +00:00
event_t event_t::variable(wcstring name, wcstring_list_t args) {
event_t evt{event_type_t::variable};
evt.desc.str_param1 = std::move(name);
evt.arguments = std::move(args);
return evt;
}
Remove proc_create_event Switch to a set of factory functions inside event_t. No user-visible change here.
2021-05-17 22:33:33 +00:00
// static
event_t event_t::process_exit(pid_t pid, int status) {
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
event_t evt{event_type_t::process_exit};
Remove proc_create_event Switch to a set of factory functions inside event_t. No user-visible change here.
2021-05-17 22:33:33 +00:00
evt.desc.param1.pid = pid;
evt.arguments.reserve(3);
evt.arguments.push_back(L"PROCESS_EXIT");
evt.arguments.push_back(to_string(pid));
evt.arguments.push_back(to_string(status));
return evt;
}
// static
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
event_t event_t::job_exit(pid_t pid, internal_job_id_t jid) {
Separate on-job-exit and and on-process-exit events It is possible to run a function when a process exits via `function --on-process-exit`, or when a job exits via `function --on-job-exits`. Internally these were distinguished by the pid in the event: if it was positive, then it was a process exit. If negative, it represents a pgid and is a job exit. If zero, it fires for both jobs and processes, which is pretty weird. Switch to tracking these explicitly. Separate out the --on-process-exit and --on-job-exit event types into separate types. Stop negating pgids as well.
2021-05-19 18:29:03 +00:00
event_t evt{event_type_t::job_exit};
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
evt.desc.param1.jobspec = {pid, jid};
Remove proc_create_event Switch to a set of factory functions inside event_t. No user-visible change here.
2021-05-17 22:33:33 +00:00
evt.arguments.reserve(3);
evt.arguments.push_back(L"JOB_EXIT");
Allow on-job-exit handlers to be added for any pid in the job Prior to this change, a function with an on-job-exit event handler must be added with the pgid of the job. But sometimes the pgid of the job is fish itself (if job control is disabled) and the previous commit made last_pid an actual pid from the job, instead of its pgroup. Switch on-job-exit to accept any pid from the job (except fish itself). This allows it to be used directly with $last_pid, except that it now works if job control is off. This is implemented by "resolving" the pid to the internal job id at the point the event handler is added. Also switch to passing the last pid of the job, rather than its pgroup. This aligns better with $last_pid.
2021-05-20 18:25:32 +00:00
evt.arguments.push_back(to_string(pid));
Remove proc_create_event Switch to a set of factory functions inside event_t. No user-visible change here.
2021-05-17 22:33:33 +00:00
evt.arguments.push_back(L"0"); // historical
return evt;
}
// static
event_t event_t::caller_exit(uint64_t caller_id, int job_id) {
event_t evt{event_type_t::caller_exit};
evt.desc.param1.caller_id = caller_id;
evt.arguments.reserve(3);
evt.arguments.push_back(L"JOB_EXIT");
evt.arguments.push_back(to_string(job_id));
evt.arguments.push_back(L"0"); // historical
return evt;
}
Reference in a new issue Copy permalink