1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
//! Emulated wait status for non-Unix #[cfg(unix) platforms
//!
//! Separate module to facilitate testing against a real Unix implementation.
use core::ffi::NonZero_c_int;
use crate::ffi::c_int;
use crate::fmt;
use super::ExitStatusError;
/// Emulated wait status for use by `process_unsupported.rs`
///
/// Uses the "traditional unix" encoding. For use on platfors which are `#[cfg(unix)]`
/// but do not actually support subprocesses at all.
///
/// These platforms aren't Unix, but are simply pretending to be for porting convenience.
/// So, we provide a faithful pretence here.
#[derive(PartialEq, Eq, Clone, Copy, Debug, Default)]
pub struct ExitStatus {
wait_status: c_int,
}
/// Converts a raw `c_int` to a type-safe `ExitStatus` by wrapping it
impl From<c_int> for ExitStatus {
fn from(wait_status: c_int) -> ExitStatus {
ExitStatus { wait_status }
}
}
impl fmt::Display for ExitStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "emulated wait status: {}", self.wait_status)
}
}
impl ExitStatus {
pub fn code(&self) -> Option<i32> {
// Linux and FreeBSD both agree that values linux 0x80
// count as "WIFEXITED" even though this is quite mad.
// Likewise the macros disregard all the high bits, so are happy to declare
// out-of-range values to be WIFEXITED, WIFSTOPPED, etc.
let w = self.wait_status;
if (w & 0x7f) == 0 { Some((w & 0xff00) >> 8) } else { None }
}
#[allow(unused)]
pub fn exit_ok(&self) -> Result<(), ExitStatusError> {
// This assumes that WIFEXITED(status) && WEXITSTATUS==0 corresponds to status==0. This is
// true on all actual versions of Unix, is widely assumed, and is specified in SuS
// https://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html. If it is not
// true for a platform pretending to be Unix, the tests (our doctests, and also
// process_unix/tests.rs) will spot it. `ExitStatusError::code` assumes this too.
match NonZero_c_int::try_from(self.wait_status) {
/* was nonzero */ Ok(failure) => Err(ExitStatusError(failure)),
/* was zero, couldn't convert */ Err(_) => Ok(()),
}
}
pub fn signal(&self) -> Option<i32> {
let signal = self.wait_status & 0x007f;
if signal > 0 && signal < 0x7f { Some(signal) } else { None }
}
pub fn core_dumped(&self) -> bool {
self.signal().is_some() && (self.wait_status & 0x80) != 0
}
pub fn stopped_signal(&self) -> Option<i32> {
let w = self.wait_status;
if (w & 0xff) == 0x7f { Some((w & 0xff00) >> 8) } else { None }
}
pub fn continued(&self) -> bool {
self.wait_status == 0xffff
}
pub fn into_raw(&self) -> c_int {
self.wait_status
}
}
#[cfg(test)]
#[path = "wait_status/tests.rs"] // needed because of strange layout of process_unsupported
mod tests;
|
