diff --git a/src/builtins/function.rs b/src/builtins/function.rs index 085b638e8..a4336b8cb 100644 --- a/src/builtins/function.rs +++ b/src/builtins/function.rs @@ -10,7 +10,7 @@ use crate::parse_tree::NodeRef; use crate::parser_keywords::parser_keywords_is_reserved; use crate::proc::{InternalJobId, Pid}; -use crate::signal::Signal; +use crate::signal::RawSignal; use crate::{err_fmt, err_str, function}; use nix::unistd::getpid; use std::sync::Arc; @@ -130,7 +130,7 @@ fn add_named_argument( opts.description = w.woptarg.unwrap().to_owned(); } 's' => { - let Some(signal) = Signal::parse(w.woptarg.unwrap()) else { + let Some(signal) = RawSignal::parse(w.woptarg.unwrap()) else { err_fmt!("Unknown signal '%s'", w.woptarg.unwrap()) .cmd(cmd) .finish(streams); diff --git a/src/env/var.rs b/src/env/var.rs index 7cad6b3c8..8098d595e 100644 --- a/src/env/var.rs +++ b/src/env/var.rs @@ -1,4 +1,4 @@ -use crate::signal::Signal; +use crate::signal::RawSignal; use bitflags::bitflags; use fish_common::assert_sorted_by_name; use fish_wcstringutil::join_strings; @@ -85,7 +85,7 @@ pub struct Statuses { /// Signal from the most recent process in the last job that was terminated by a signal. /// None if all processes exited normally. - pub kill_signal: Option, + pub kill_signal: Option, /// Pipestatus value. pub pipestatus: Vec, diff --git a/src/event.rs b/src/event.rs index 59641045c..e7c8b0916 100644 --- a/src/event.rs +++ b/src/event.rs @@ -12,7 +12,7 @@ prelude::*, proc::{InternalJobId, Pid}, reader::reader_update_termsize, - signal::{Signal, signal_check_cancel, signal_handle}, + signal::{RawSignal, signal_check_cancel, signal_handle}, }; use fish_common::{ScopeGuard, escape}; use fish_widestring::str2wcstring; @@ -37,7 +37,7 @@ pub enum EventDescription { /// well). Any, /// An event triggered by a signal. - Signal { signal: Signal }, + Signal { signal: RawSignal }, /// An event triggered by a variable update. Variable { name: WString }, /// An event triggered by a process exit. @@ -357,13 +357,13 @@ pub fn acquire_pending(&self) -> u64 { /// temporarily moved here. There was no mutex around this in the cpp code. TODO: Move it back. static BLOCKED_EVENTS: Mutex> = Mutex::new(Vec::new()); -fn inc_signal_observed(sig: Signal) { +fn inc_signal_observed(sig: RawSignal) { if let Some(sig) = OBSERVED_SIGNALS.get(usize::from(sig)) { sig.fetch_add(1, Ordering::Relaxed); } } -fn dec_signal_observed(sig: Signal) { +fn dec_signal_observed(sig: RawSignal) { if let Some(sig) = OBSERVED_SIGNALS.get(usize::from(sig)) { sig.fetch_sub(1, Ordering::Relaxed); } @@ -548,7 +548,7 @@ pub fn fire_delayed(parser: &mut Parser) { while signals != 0 { let sig = signals.trailing_zeros() as i32; signals &= !(1_u64 << sig); - let sig = Signal::new(sig); + let sig = RawSignal::new(sig); // HACK: The only variables we change in response to a *signal* are $COLUMNS and $LINES. // Do that now. diff --git a/src/job_group.rs b/src/job_group.rs index ecd8715ce..260f01862 100644 --- a/src/job_group.rs +++ b/src/job_group.rs @@ -1,7 +1,7 @@ use crate::global_safety::RelaxedAtomicBool; use crate::prelude::*; use crate::proc::{JobGroupRef, Pid}; -use crate::signal::Signal; +use crate::signal::RawSignal; use nix::sys::termios::Termios; use std::cell::RefCell; use std::num::NonZeroU32; @@ -118,15 +118,15 @@ pub fn has_job_id(&self) -> bool { } /// Gets the cancellation signal, if any. - pub fn get_cancel_signal(&self) -> Option { + pub fn get_cancel_signal(&self) -> Option { match self.signal.load(Ordering::Relaxed) { 0 => None, - s => Some(Signal::new(s)), + s => Some(RawSignal::new(s)), } } /// Mark that a process in this group got a signal and should cancel. - pub fn cancel_with_signal(&self, signal: Signal) { + pub fn cancel_with_signal(&self, signal: RawSignal) { // We only assign the signal if one hasn't yet been assigned. This means the first signal to // register wins over any that come later. self.signal diff --git a/src/parse_execution.rs b/src/parse_execution.rs index a7f48b21c..160ba5ace 100644 --- a/src/parse_execution.rs +++ b/src/parse_execution.rs @@ -50,7 +50,7 @@ }, reader::fish_is_unwinding_for_exit, redirection::{RedirectionMode, RedirectionSpec, RedirectionSpecList}, - signal::Signal, + signal::RawSignal, timer::push_timer, tokenizer::{PipeOrRedir, TokenType, variable_assignment_equals_pos}, trace::{trace_if_enabled, trace_if_enabled_with_args}, @@ -85,7 +85,7 @@ pub struct ExecutionContext { // If set, one of our processes received a cancellation signal (INT or QUIT) so we are // unwinding. - cancel_signal: Option, + cancel_signal: Option, /// The block IO chain. /// For example, in `begin; foo ; end < file.txt` this would have the 'file.txt' IO. diff --git a/src/parser.rs b/src/parser.rs index 1627044a9..d45d2a12e 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -23,7 +23,7 @@ parse_tree::{NodeRef, ParsedSourceRef, SourceLineCache, parse_source}, prelude::*, proc::{InternalJobId, JobGroupRef, JobList, JobRef, Pid, ProcStatus, job_reap}, - signal::{Signal, signal_check_cancel, signal_clear_cancel}, + signal::{RawSignal, signal_check_cancel, signal_clear_cancel}, wait_handle::WaitHandleStore, }; use assert_matches::assert_matches; @@ -637,7 +637,7 @@ pub fn eval_node( if self.cancel_behavior == CancelBehavior::Clear && self.block_list.is_empty() { signal_clear_cancel(); } else { - return EvalRes::new(ProcStatus::from_signal(Signal::new(sig))); + return EvalRes::new(ProcStatus::from_signal(RawSignal::new(sig))); } } @@ -649,7 +649,7 @@ pub fn eval_node( // Did fish itself get a signal? let sig = signal_check_cancel(); if sig != 0 { - return Some(Signal::new(sig)); + return Some(RawSignal::new(sig)); } // Has this job group been cancelled? jg.as_ref().and_then(|jg| jg.get_cancel_signal()) @@ -698,7 +698,7 @@ pub fn eval_node( let sig = signal_check_cancel(); if sig != 0 { - EvalRes::new(ProcStatus::from_signal(Signal::new(sig))) + EvalRes::new(ProcStatus::from_signal(RawSignal::new(sig))) } else { let status = ProcStatus::from_exit_code(self.last_status()); let break_expand = reason == EndExecutionReason::Error; diff --git a/src/proc.rs b/src/proc.rs index 24ce46a5e..0c82861aa 100644 --- a/src/proc.rs +++ b/src/proc.rs @@ -17,7 +17,7 @@ prelude::*, reader::{fish_is_unwinding_for_exit, reader_schedule_prompt_repaint}, redirection::RedirectionSpecList, - signal::{Signal, signal_set_handlers_once}, + signal::{RawSignal, signal_set_handlers_once}, topic_monitor::{GenerationsList, Topic, topic_monitor_principal}, wait_handle::{WaitHandle, WaitHandleRef, WaitHandleStore}, wutil::{perror_nix, wbasename}, @@ -173,7 +173,7 @@ pub fn from_exit_code(ret: i32) -> ProcStatus { } /// Construct directly from a signal. - pub fn from_signal(signal: Signal) -> ProcStatus { + pub fn from_signal(signal: RawSignal) -> ProcStatus { ProcStatus::new(Some(Self::w_exitcode(0 /* ret */, signal.code()))) } @@ -911,7 +911,7 @@ pub fn statuses(&self) -> Option { continue; } if status.signal_exited() { - st.kill_signal = Some(Signal::new(status.signal_code())); + st.kill_signal = Some(RawSignal::new(status.signal_code())); } laststatus = status.status_value(); has_status = true; @@ -1105,7 +1105,7 @@ fn handle_child_status(job: &Job, proc: &Process, status: ProcStatus) { if [SIGINT, SIGQUIT].contains(&sig) { if is_interactive_session() { // Mark the job group as cancelled. - job.group().cancel_with_signal(Signal::new(sig)); + job.group().cancel_with_signal(RawSignal::new(sig)); } else if !event::is_signal_observed(sig) { // Deliver the SIGINT or SIGQUIT signal to ourself since we're not interactive. let act = @@ -1475,7 +1475,7 @@ fn summary_command(j: &Job, p: Option<&Process>) -> WString { Some(p) => { // We are summarizing a process which exited with a signal. // Arguments are the signal name and description. - let sig = Signal::new(p.status().signal_code()); + let sig = RawSignal::new(p.status().signal_code()); buffer.push(' '); buffer += &escape(sig.name())[..]; diff --git a/src/signal.rs b/src/signal.rs index 3dfcd9668..8a1085588 100644 --- a/src/signal.rs +++ b/src/signal.rs @@ -251,7 +251,7 @@ pub fn signal_set_handlers_once(interactive: bool) { } /// Mark that a signal is being handled. -pub fn signal_handle(sig: Signal) { +pub fn signal_handle(sig: RawSignal) { let sig = sig.code(); let mut act: libc::sigaction = unsafe { std::mem::zeroed() }; @@ -340,7 +340,7 @@ pub fn wait(&self) { /// Struct describing an entry for the lookup table used to convert between signal names and signal /// ids, etc. struct LookupEntry { - signal: Signal, + signal: RawSignal, name: &'static wstr, desc: LocalizableString, // Note: this needs to be localized via gettext before presenting it to the user. } @@ -348,7 +348,7 @@ struct LookupEntry { impl LookupEntry { const fn new(signal: i32, name: &'static wstr, desc: LocalizableString) -> Self { Self { - signal: Signal::new(signal), + signal: RawSignal::new(signal), name, desc, } @@ -472,15 +472,15 @@ fn match_signal_name(canonical: &wstr, mut name: &wstr) -> bool { #[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)] /// A wrapper around the system signal code. -pub struct Signal(NonZeroI32); +pub struct RawSignal(NonZeroI32); -impl Signal { +impl RawSignal { /// Creates a new `Signal` to represent the passed system signal code `sig`. /// Panics if `sig` is zero. pub const fn new(sig: i32) -> Self { match NonZeroI32::new(sig) { None => panic!("Invalid zero signal value!"), - Some(result) => Signal(result), + Some(result) => RawSignal(result), } } @@ -517,7 +517,7 @@ pub fn code(&self) -> i32 { /// recognized, `None` is returned. /// This also accepts integer codes via fish_wcstoi(). /// Previously sig2wcs(). - pub fn parse(name: &wstr) -> Option { + pub fn parse(name: &wstr) -> Option { for entry in SIGNAL_TABLE.iter() { if match_signal_name(entry.name, name) { return Some(entry.signal); @@ -526,7 +526,7 @@ pub fn parse(name: &wstr) -> Option { if let Ok(num) = fish_wcstoi(name) { if num > 0 { - return Some(Signal::new(num)); + return Some(RawSignal::new(num)); } } None @@ -534,58 +534,58 @@ pub fn parse(name: &wstr) -> Option { } // Allow signals to be compared against i32. -impl PartialEq for Signal { +impl PartialEq for RawSignal { fn eq(&self, other: &i32) -> bool { self.code() == *other } } -impl From for i32 { - fn from(value: Signal) -> Self { +impl From for i32 { + fn from(value: RawSignal) -> Self { value.code() } } -impl From for usize { - fn from(value: Signal) -> Self { +impl From for usize { + fn from(value: RawSignal) -> Self { usize::try_from(value.code()).unwrap() } } -impl From for NonZeroI32 { - fn from(value: Signal) -> Self { +impl From for NonZeroI32 { + fn from(value: RawSignal) -> Self { value.0 } } #[cfg(test)] mod tests { - use super::Signal; + use super::RawSignal; use crate::prelude::*; #[test] fn test_signal_name() { - let sig = Signal::new(libc::SIGINT); + let sig = RawSignal::new(libc::SIGINT); assert_eq!(sig.name(), "SIGINT"); } #[rustfmt::skip] #[test] fn test_signal_parse() { - assert_eq!(Signal::parse(L!("SIGHUP")), Some(Signal::new(libc::SIGHUP))); - assert_eq!(Signal::parse(L!("sigwinch")), Some(Signal::new(libc::SIGWINCH))); - assert_eq!(Signal::parse(L!("TSTP")), Some(Signal::new(libc::SIGTSTP))); - assert_eq!(Signal::parse(L!("TstP")), Some(Signal::new(libc::SIGTSTP))); - assert_eq!(Signal::parse(L!("sigCONT")), Some(Signal::new(libc::SIGCONT))); - assert_eq!(Signal::parse(L!("SIGFOO")), None); - assert_eq!(Signal::parse(L!("")), None); - assert_eq!(Signal::parse(L!("SIG")), None); - assert_eq!(Signal::parse(L!("سلام")), None); + assert_eq!(RawSignal::parse(L!("SIGHUP")), Some(RawSignal::new(libc::SIGHUP))); + assert_eq!(RawSignal::parse(L!("sigwinch")), Some(RawSignal::new(libc::SIGWINCH))); + assert_eq!(RawSignal::parse(L!("TSTP")), Some(RawSignal::new(libc::SIGTSTP))); + assert_eq!(RawSignal::parse(L!("TstP")), Some(RawSignal::new(libc::SIGTSTP))); + assert_eq!(RawSignal::parse(L!("sigCONT")), Some(RawSignal::new(libc::SIGCONT))); + assert_eq!(RawSignal::parse(L!("SIGFOO")), None); + assert_eq!(RawSignal::parse(L!("")), None); + assert_eq!(RawSignal::parse(L!("SIG")), None); + assert_eq!(RawSignal::parse(L!("سلام")), None); - assert_eq!(Signal::parse(&libc::SIGINT.to_wstring()), Some(Signal::new(libc::SIGINT))); - assert_eq!(Signal::parse(L!("0")), None); - assert_eq!(Signal::parse(L!("-0")), None); - assert_eq!(Signal::parse(L!("-1")), None); + assert_eq!(RawSignal::parse(&libc::SIGINT.to_wstring()), Some(RawSignal::new(libc::SIGINT))); + assert_eq!(RawSignal::parse(L!("0")), None); + assert_eq!(RawSignal::parse(L!("-0")), None); + assert_eq!(RawSignal::parse(L!("-1")), None); } #[test]