use crate::wchar; use crate::wchar_ffi::WCharToFFI; #[rustfmt::skip] use ::std::pin::Pin; #[rustfmt::skip] use ::std::slice; use crate::env::flags::EnvMode; pub use crate::wait_handle::{ WaitHandleRef, WaitHandleRefFFI, WaitHandleStore, WaitHandleStoreFFI, }; use crate::wchar::{wstr, WString}; use crate::wchar_ffi::WCharFromFFI; use autocxx::prelude::*; use cxx::SharedPtr; use libc::pid_t; // autocxx has been hacked up to know about this. pub type wchar_t = u32; include_cpp! { #include "builtin.h" #include "common.h" #include "env.h" #include "event.h" #include "fallback.h" #include "fds.h" #include "flog.h" #include "function.h" #include "highlight.h" #include "io.h" #include "parse_constants.h" #include "parser.h" #include "parse_util.h" #include "path.h" #include "proc.h" #include "tokenizer.h" #include "wildcard.h" #include "wutil.h" // We need to block these types so when exposing C++ to Rust. block!("WaitHandleStoreFFI") block!("WaitHandleRefFFI") safety!(unsafe_ffi) generate_pod!("wcharz_t") generate!("wcstring_list_ffi_t") generate!("make_fd_nonblocking") generate!("wperror") generate_pod!("pipes_ffi_t") generate!("environment_t") generate!("env_stack_t") generate!("env_var_t") generate!("make_pipes_ffi") generate!("get_flog_file_fd") generate!("log_extra_to_flog_file") generate!("parse_util_unescape_wildcards") generate!("fish_wcwidth") generate!("fish_wcswidth") generate!("wildcard_match") generate!("wgettext_ptr") generate!("block_t") generate!("parser_t") generate!("job_t") generate!("process_t") generate!("library_data_t") generate_pod!("library_data_pod_t") generate!("proc_wait_any") generate!("output_stream_t") generate!("io_streams_t") generate_pod!("RustFFIJobList") generate_pod!("RustFFIProcList") generate_pod!("RustBuiltin") generate!("builtin_exists") generate!("builtin_missing_argument") generate!("builtin_unknown_option") generate!("builtin_print_help") generate!("builtin_print_error_trailer") generate!("builtin_get_names_ffi") generate!("escape_string") generate!("sig2wcs") generate!("wcs2sig") generate!("signal_get_desc") generate!("fd_event_signaller_t") generate!("signal_handle") generate!("signal_check_cancel") generate!("block_t") generate!("block_type_t") generate!("statuses_t") generate!("io_chain_t") generate!("env_var_t") generate!("function_properties_t") generate!("function_properties_ref_t") generate!("function_get_props_autoload") generate!("function_get_definition_file") generate!("function_get_copy_definition_file") generate!("function_get_definition_lineno") generate!("function_get_copy_definition_lineno") generate!("function_get_annotated_definition") generate!("function_is_copy") generate!("function_exists") generate!("path_get_paths_ffi") generate!("colorize_shell") } impl parser_t { pub fn get_wait_handles_mut(&mut self) -> &mut WaitHandleStore { let ptr = self.get_wait_handles_void() as *mut Box; assert!(!ptr.is_null()); unsafe { (*ptr).from_ffi_mut() } } pub fn get_wait_handles(&self) -> &WaitHandleStore { let ptr = self.get_wait_handles_void() as *const Box; assert!(!ptr.is_null()); unsafe { (*ptr).from_ffi() } } pub fn get_block_at_index(&self, i: usize) -> Option<&block_t> { let b = self.block_at_index(i); unsafe { b.as_ref() } } pub fn get_jobs(&self) -> &[SharedPtr] { let ffi_jobs = self.ffi_jobs(); unsafe { slice::from_raw_parts(ffi_jobs.jobs, ffi_jobs.count) } } pub fn libdata_pod(&mut self) -> &mut library_data_pod_t { let libdata = self.pin().ffi_libdata_pod(); unsafe { &mut *libdata } } pub fn remove_var(&mut self, var: &wstr, flags: c_int) -> c_int { self.pin().remove_var_ffi(&var.to_ffi(), flags) } pub fn job_get_from_pid(&self, pid: pid_t) -> Option<&job_t> { let job = self.ffi_job_get_from_pid(pid.into()); unsafe { job.as_ref() } } /// Helper to get a variable as a string, using the default flags. pub fn var_as_string(&mut self, name: &wstr) -> Option { self.pin().vars().unpin().get_as_string(name) } pub fn get_var_stack(&mut self) -> &mut env_stack_t { self.pin().vars().unpin() } pub fn get_var_stack_env(&mut self) -> &environment_t { self.vars_env_ffi() } pub fn set_var(&mut self, name: &wstr, value: &[&wstr], flags: EnvMode) -> libc::c_int { self.get_var_stack().set_var(name, value, flags) } } impl environment_t { /// Helper to get a variable as a string, using the default flags. pub fn get_as_string(&self, name: &wstr) -> Option { self.get_as_string_flags(name, EnvMode::DEFAULT) } /// Helper to get a variable as a string, using the given flags. pub fn get_as_string_flags(&self, name: &wstr, flags: EnvMode) -> Option { self.get_or_null(&name.to_ffi(), flags.bits()) .as_ref() .map(|s| s.as_string().from_ffi()) } } impl env_stack_t { /// Helper to get a variable as a string, using the default flags. pub fn get_as_string(&self, name: &wstr) -> Option { self.get_as_string_flags(name, EnvMode::DEFAULT) } /// Helper to get a variable as a string, using the given flags. pub fn get_as_string_flags(&self, name: &wstr, flags: EnvMode) -> Option { self.get_or_null(&name.to_ffi(), flags.bits()) .as_ref() .map(|s| s.as_string().from_ffi()) } /// Helper to set a value. pub fn set_var(&mut self, name: &wstr, value: &[&wstr], flags: EnvMode) -> libc::c_int { use crate::wchar_ffi::{wstr_to_u32string, W0String}; let strings: Vec = value.iter().map(wstr_to_u32string).collect(); let ptrs: Vec<*const u32> = strings.iter().map(|s| s.as_ptr()).collect(); self.pin() .set_ffi( &name.to_ffi(), flags.bits(), ptrs.as_ptr() as *const c_void, ptrs.len(), ) .into() } } impl job_t { #[allow(clippy::mut_from_ref)] pub fn get_procs(&self) -> &mut [UniquePtr] { let ffi_procs = self.ffi_processes(); unsafe { slice::from_raw_parts_mut(ffi_procs.procs, ffi_procs.count) } } } impl process_t { /// \return the wait handle for the process, if it exists. pub fn get_wait_handle(&self) -> Option { let handle_ptr = self.get_wait_handle_void() as *const Box; if handle_ptr.is_null() { None } else { let handle: &WaitHandleRefFFI = unsafe { &*handle_ptr }; Some(handle.from_ffi().clone()) } } /// \return the wait handle for the process, creating it if necessary. pub fn make_wait_handle(&mut self, jid: u64) -> Option { let handle_ref = self.pin().make_wait_handle_void(jid) as *const Box; if handle_ref.is_null() { None } else { let handle: &WaitHandleRefFFI = unsafe { &*handle_ref }; Some(handle.from_ffi().clone()) } } } /// Allow wcharz_t to be "into" wstr. impl From for &wchar::wstr { fn from(w: wcharz_t) -> Self { let len = w.length(); let v = unsafe { slice::from_raw_parts(w.str_ as *const u32, len) }; wchar::wstr::from_slice(v).expect("Invalid UTF-32") } } /// Allow wcharz_t to be "into" WString. impl From for wchar::WString { fn from(w: wcharz_t) -> Self { let len = w.length(); let v = unsafe { slice::from_raw_parts(w.str_ as *const u32, len).to_vec() }; Self::from_vec(v).expect("Invalid UTF-32") } } /// A bogus trait for turning &mut Foo into Pin<&mut Foo>. /// autocxx enforces that non-const methods must be called through Pin, /// but this means we can't pass around mutable references to types like parser_t. /// We also don't want to assert that parser_t is Unpin. /// So we just allow constructing a pin from a mutable reference; none of the C++ code. /// It's worth considering disabling this in cxx; for now we use this trait. /// Eventually parser_t and io_streams_t will not require Pin so we just unsafe-it away. pub trait Repin { fn pin(&mut self) -> Pin<&mut Self> { unsafe { Pin::new_unchecked(self) } } fn unpin(self: Pin<&mut Self>) -> &mut Self { unsafe { self.get_unchecked_mut() } } } // Implement Repin for our types. impl Repin for block_t {} impl Repin for env_stack_t {} impl Repin for io_streams_t {} impl Repin for job_t {} impl Repin for output_stream_t {} impl Repin for parser_t {} impl Repin for process_t {} impl Repin for function_properties_ref_t {} pub use autocxx::c_int; pub use ffi::*; pub use libc::c_char; /// A version of [`* const core::ffi::c_void`] (or [`* const libc::c_void`], if you prefer) that /// implements `Copy` and `Clone`, because those two don't. Used to represent a `void *` ptr for ffi /// purposes. #[repr(transparent)] #[derive(Copy, Clone)] pub struct void_ptr(pub *const core::ffi::c_void); impl core::fmt::Debug for void_ptr { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{:p}", &self.0) } } unsafe impl Send for void_ptr {} unsafe impl Sync for void_ptr {} impl core::convert::From<*const core::ffi::c_void> for void_ptr { fn from(value: *const core::ffi::c_void) -> Self { Self(value as *const _) } } impl core::convert::From<*const u8> for void_ptr { fn from(value: *const u8) -> Self { Self(value as *const _) } } impl core::convert::From<*const autocxx::c_void> for void_ptr { fn from(value: *const autocxx::c_void) -> Self { Self(value as *const _) } }