use engine::{ActorId, Input, Output, VirtualPath};
use os::ExitStatus;
use os::OperatingSystem as _;
use os::environment::Environment;
use os::windows::Windows;
use os::windows::command::WindowsCommandContext;
pub fn resolve_path(cwd: &VirtualPath, argument: &str) -> Result<VirtualPath, os::OsError> {
if argument.is_empty() {
return Err(os::OsError::InvalidPathArgument(argument.to_owned()));
}
let normalized = os::windows::path::normalize(argument);
os::runtime::resolve_path_name(&normalized, cwd)
}
pub fn display_path(path: &VirtualPath) -> String {
os::windows::path::display(path)
}
#[allow(clippy::too_many_arguments)]
pub fn run_external(
os: &Windows,
actor: ActorId,
cwd: &VirtualPath,
environment: &Environment,
name: &str,
argv: &[String],
stdin: &mut dyn Input,
stdout: &mut dyn Output,
stderr: &mut dyn Output,
) -> Option<ExitStatus> {
let (_object, binding) = os.resolve(name, actor, cwd, environment)?;
let pid = os.allocate_pid();
let process = os.record_process(actor, pid, name, &argv[1..], cwd).ok();
let mut context = WindowsCommandContext {
os,
actor,
cwd,
argv,
environment,
stdin,
stdout,
stderr,
};
let status = match binding.execute(&mut context) {
Ok(status) => status,
Err(error) => {
let _ = stderr.write(format!("{name}: {error}\n").as_bytes());
ExitStatus::FAILURE
}
};
if let Some(process) = process {
let _ = os.finish_process(actor, process, status);
}
Some(status)
}
pub fn write_redirect(
os: &Windows,
actor: ActorId,
cwd: &VirtualPath,
path_str: &str,
bytes: &[u8],
append: bool,
) -> Result<(), os::OsError> {
let path = resolve_path(cwd, path_str)?;
let engine = os.engine();
let actor = Some(actor);
if let Ok(object) = engine.lookup(actor, &path) {
if append {
engine.append(actor, object, bytes.to_vec())?;
} else {
engine.write(actor, object, bytes.to_vec())?;
}
return Ok(());
}
let parent_path = path.parent().expect("path has parent").clone();
let parent = engine.lookup(actor, &parent_path)?;
let name = engine::Name::new(path.name().expect("path has name"))?;
engine.create_file(actor, parent, name, Some(bytes.to_vec()))?;
Ok(())
}
pub fn read_redirect(
os: &Windows,
actor: ActorId,
cwd: &VirtualPath,
path_str: &str,
) -> Option<Vec<u8>> {
let path = resolve_path(cwd, path_str).ok()?;
let actor = Some(actor);
let object = os.engine().lookup(actor, &path).ok()?;
os.engine().read(actor, object).ok().flatten()
}