Method spawn

crates/vm/src/stdlib/posix.rs:1721–1880

(self, spawnp: bool, vm: &VirtualMachine)

    #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]
    impl PosixSpawnArgs {
        fn spawn(self, spawnp: bool, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
            use nix::sys::signal;

            use crate::TryFromBorrowedObject;

            let path = self
                .path
                .clone()
                .into_cstring(vm)
                .map_err(|_| vm.new_value_error("path should not have nul bytes"))?;

            let mut file_actions =
                nix::spawn::PosixSpawnFileActions::init().map_err(|e| e.into_pyexception(vm))?;
            if let Some(it) = self.file_actions {
                for action in it.iter(vm)? {
                    let action = action?;
                    let (id, args) = action.split_first().ok_or_else(|| {
                        vm.new_type_error("Each file_actions element must be a non-empty tuple")
                    })?;
                    let id = i32::try_from_borrowed_object(vm, id)?;
                    let id = PosixSpawnFileActionIdentifier::try_from(id)
                        .map_err(|_| vm.new_type_error("Unknown file_actions identifier"))?;
                    let args: crate::function::FuncArgs = args.to_vec().into();
                    let ret = match id {
                        PosixSpawnFileActionIdentifier::Open => {
                            let (fd, path, oflag, mode): (_, OsPath, _, _) = args.bind(vm)?;
                            let path = CString::new(path.into_bytes()).map_err(|_| {
                                vm.new_value_error(
                                    "POSIX_SPAWN_OPEN path should not have nul bytes",
                                )
                            })?;
                            let oflag = nix::fcntl::OFlag::from_bits_retain(oflag);
                            let mode = nix::sys::stat::Mode::from_bits_retain(mode);
                            file_actions.add_open(fd, &*path, oflag, mode)
                        }
                        PosixSpawnFileActionIdentifier::Close => {
                            let (fd,) = args.bind(vm)?;
                            file_actions.add_close(fd)
                        }
                        PosixSpawnFileActionIdentifier::Dup2 => {
                            let (fd, newfd) = args.bind(vm)?;
                            file_actions.add_dup2(fd, newfd)
                        }
                    };
                    if let Err(err) = ret {
                        let err = err.into();
                        return Err(OSErrorBuilder::with_filename(&err, self.path, vm));
                    }
                }
            }

            let mut attrp =
                nix::spawn::PosixSpawnAttr::init().map_err(|e| e.into_pyexception(vm))?;
            let mut flags = nix::spawn::PosixSpawnFlags::empty();

            if let Some(sigs) = self.setsigdef {
                let mut set = signal::SigSet::empty();
                for sig in sigs.iter(vm)? {