use std::fs;
use std::io;
use std::path::Path;
use crate::shell::ast::Command;
use crate::shell::environment::ShellEnv;
#[derive(Debug, Clone)]
pub struct ExecResult {
pub command: Command,
pub stdout: String,
pub stderr: String,
pub exit_code: i32,
}
pub fn is_inproc_builtin(name: &str) -> bool {
matches!(
name,
"cd" | "pushd"
| "popd"
| "export"
| "echo"
| "@echo"
| "mkdir"
| "rm"
| "umask"
| "ulimit"
| ":"
)
}
pub fn run_inproc_builtin(
cmd: &Command,
env: &mut ShellEnv,
stdin: Option<&str>,
) -> Result<ExecResult, String> {
if cmd.args.is_empty() {
return Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
});
}
match cmd.args[0].as_str() {
"cd" => builtin_cd(cmd, env),
"pushd" => builtin_pushd(cmd, env),
"popd" => builtin_popd(cmd, env),
"export" => builtin_export(cmd, env),
"echo" | "@echo" => builtin_echo(cmd, env, stdin),
"mkdir" => builtin_mkdir(cmd, env),
"rm" => builtin_rm(cmd, env),
"umask" => builtin_umask(cmd, env),
"ulimit" => builtin_ulimit(cmd, env),
":" => Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
}),
_ => Err(format!("unsupported builtin '{}'", cmd.args[0])),
}
}
fn builtin_cd(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 2 {
return Err("'cd' supports exactly one argument".into());
}
env.change_dir(&cmd.args[1]);
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_pushd(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 2 {
return Err("'pushd' supports exactly one argument".into());
}
env.pushd(&cmd.args[1])?;
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_popd(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 1 {
return Err("'popd' supports exactly one argument".into());
}
env.popd();
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_export(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() == 1 {
let mut output = String::new();
for (k, v) in &env.env {
output.push_str(k);
output.push('=');
output.push_str(v);
output.push('\n');
}
return Ok(ExecResult {
command: cmd.clone(),
stdout: output,
stderr: String::new(),
exit_code: 0,
});
}
let mut i = 1usize;
let mut unset_next = false;
let mut clear_env = false;
while i < cmd.args.len() {
let arg = cmd.args[i].as_str();
if unset_next {
env.env.remove(arg);
unset_next = false;
i += 1;
continue;
}
if arg == "-u" {
unset_next = true;
i += 1;
continue;
}
if arg == "-i" {
clear_env = true;
i += 1;
continue;
}
if clear_env {
env.env.clear();
clear_env = false;
}
let Some((key, value)) = arg.split_once('=') else {
return Err(format!("'export' malformed assignment '{arg}'"));
};
env.env.insert(key.to_string(), value.to_string());
i += 1;
}
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
fn builtin_echo(
cmd: &Command,
_env: &mut ShellEnv,
stdin: Option<&str>,
) -> Result<ExecResult, String> {
let mut args = cmd.args.iter().skip(1).peekable();
let mut interpret_escape = false;
let mut add_newline = true;
let mut payload = Vec::new();
while let Some(arg) = args.peek() {
match arg.as_str() {
"-e" => {
interpret_escape = true;
args.next();
}
"-n" => {
add_newline = false;
args.next();
}
_ => break,
}
}
for arg in args {
payload.push(decode_echo(arg, interpret_escape));
}
if let Some(text) = stdin {
if payload.is_empty() {
payload = vec![text.to_string()];
}
}
let mut out = String::new();
if !payload.is_empty() {
out.push_str(&payload.join(" "));
}
if add_newline {
out.push('\n');
}
Ok(ExecResult {
command: cmd.clone(),
stdout: out,
stderr: String::new(),
exit_code: 0,
})
}
fn decode_echo(input: &str, interpret_escape: bool) -> String {
if !interpret_escape {
return input.to_string();
}
let mut out = String::new();
let mut chars = input.chars().peekable();
while let Some(ch) = chars.next() {
if ch != '\\' {
out.push(ch);
continue;
}
match chars.next() {
Some('n') => out.push('\n'),
Some('t') => out.push('\t'),
Some('r') => out.push('\r'),
Some('0') => out.push('\0'),
Some(other) => out.push(other),
None => out.push('\\'),
}
}
out
}
fn builtin_mkdir(cmd: &Command, _env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() < 2 {
return Err("mkdir: missing operand".into());
}
let mut recursive = false;
let mut paths = Vec::new();
let mut i = 1usize;
while i < cmd.args.len() {
let arg = &cmd.args[i];
if arg == "-p" {
recursive = true;
i += 1;
continue;
}
if arg == "--" {
i += 1;
paths.extend_from_slice(&cmd.args[i..]);
break;
}
paths.push(arg.clone());
i += 1;
}
if paths.is_empty() {
return Err("mkdir: missing operand".into());
}
let mut stderr = String::new();
let mut exit_code = 0;
for path in paths {
let result = if recursive {
fs::create_dir_all(path)
} else {
fs::create_dir(path)
};
if let Err(err) = result {
exit_code = 1;
stderr.push_str(&format!("mkdir: {err}\n"));
}
}
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr,
exit_code,
})
}
fn builtin_rm(cmd: &Command, _env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() < 2 {
return Err("rm: missing operand".into());
}
let mut force = false;
let mut recursive = false;
let mut paths = Vec::new();
let mut i = 1usize;
while i < cmd.args.len() {
let arg = &cmd.args[i];
if arg == "-f" {
force = true;
i += 1;
continue;
}
if arg == "-r" || arg == "-R" || arg == "--recursive" {
recursive = true;
i += 1;
continue;
}
if arg == "--" {
i += 1;
paths.extend_from_slice(&cmd.args[i..]);
break;
}
paths.push(arg.clone());
i += 1;
}
if paths.is_empty() {
return Err("rm: missing operand".into());
}
let mut stderr = String::new();
let mut exit_code = 0;
for path in paths {
let target = Path::new(&path);
let result = if target.is_dir() {
if recursive {
fs::remove_dir_all(&path)
} else {
Err(io::Error::other("is a directory"))
}
} else {
if force && !target.exists() {
Ok(())
} else {
fs::remove_file(&path)
}
};
if let Err(err) = result {
exit_code = 1;
if !force {
stderr.push_str(&format!("rm: {path}: {err}\n"));
}
}
}
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr,
exit_code,
})
}
fn builtin_umask(cmd: &Command, _env: &mut ShellEnv) -> Result<ExecResult, String> {
if cmd.args.len() != 2 {
return Err("umask supports exactly one argument".into());
}
let value =
u16::from_str_radix(&cmd.args[1], 8).map_err(|_| "invalid octal umask".to_string())?;
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
}
.with_umask(value))
}
fn builtin_ulimit(cmd: &Command, env: &mut ShellEnv) -> Result<ExecResult, String> {
#[cfg(not(unix))]
{
return Err("'ulimit' is not supported on this platform".into());
}
#[cfg(unix)]
{
use std::str::FromStr;
if cmd.args.len() != 3 {
return Err("ulimit requires two arguments".into());
}
if cmd.args[1] != "-n" {
return Err(format!("ulimit does not support option: {}", cmd.args[1]));
}
let limit = if cmd.args[2] == "unlimited" {
u64::MAX
} else {
u64::from_str(&cmd.args[2]).map_err(|_| "invalid ulimit value".to_string())?
};
env.env
.insert("LIT_INTERNAL_ULIMIT_n".into(), limit.to_string());
Ok(ExecResult {
command: cmd.clone(),
stdout: String::new(),
stderr: String::new(),
exit_code: 0,
})
}
}
impl ExecResult {
fn with_umask(self, value: u16) -> Self {
let _ = value;
self
}
}
#[cfg(test)]
mod tests {
use super::builtin_echo;
#[test]
fn decode_escaped_newline() {
let cmd = crate::shell::ast::Command {
args: vec!["echo".into(), "a\\nb".into()],
redirects: Vec::new(),
};
let mut env = crate::shell::environment::ShellEnv::new(
std::env::current_dir().unwrap(),
std::collections::HashMap::new(),
false,
);
let res = builtin_echo(&cmd, &mut env, None).unwrap();
assert_eq!(res.stdout, "a\\nb\n");
}
}