implemented builtins: readonly, unset, true, false, and : (no-op)

2026-02-24 17:57:09 -05:00
parent fee45145c8
commit 2f0cb931d6
5 changed files with 234 additions and 108 deletions
--- a/src/builtin/export.rs
+++ b/src/builtin/export.rs
@@ -1,87 +0,0 @@
-use crate::{
-  jobs::JobBldr,
-  libsh::error::ShResult,
-  parse::{NdRule, Node},
-  prelude::*,
-  procio::{borrow_fd, IoStack},
-  state::{self, read_vars, write_vars, VarFlags},
-};
-
-use super::setup_builtin;
-
-pub fn export(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
-  let NdRule::Command {
-    assignments: _,
-    argv,
-  } = node.class
-  else {
-    unreachable!()
-  };
-
-  let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
-
-  if argv.is_empty() {
-    // Display the environment variables
-    let mut env_output = env::vars()
-      .map(|var| format!("{}={}", var.0, var.1)) // Get all of them, zip them into one string
-      .collect::<Vec<_>>();
-    env_output.sort(); // Sort them alphabetically
-    let mut env_output = env_output.join("\n"); // Join them with newlines
-    env_output.push('\n'); // Push a final newline
-
-    let stdout = borrow_fd(STDOUT_FILENO);
-    write(stdout, env_output.as_bytes())?; // Write it
-  } else {
-    for (arg, _) in argv {
-      if let Some((var, val)) = arg.split_once('=') {
-        write_vars(|v| v.set_var(var, val, VarFlags::EXPORT)); // Export an assignment like
-                                                               // 'foo=bar'
-      } else {
-        write_vars(|v| v.export_var(&arg)); // Export an existing variable, if
-                                            // any
-      }
-    }
-  }
-  state::set_status(0);
-  Ok(())
-}
-
-pub fn local(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
-  let NdRule::Command {
-    assignments: _,
-    argv,
-  } = node.class
-  else {
-    unreachable!()
-  };
-
-  let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
-
-  if argv.is_empty() {
-    // Display the local variables
-    let vars_output = read_vars(|v| {
-      let mut vars = v
-        .flatten_vars()
-        .into_iter()
-        .map(|(k, v)| format!("{}={}", k, v))
-        .collect::<Vec<String>>();
-      vars.sort();
-      let mut vars_joined = vars.join("\n");
-      vars_joined.push('\n');
-      vars_joined
-    });
-
-    let stdout = borrow_fd(STDOUT_FILENO);
-    write(stdout, vars_output.as_bytes())?; // Write it
-  } else {
-    for (arg, _) in argv {
-      if let Some((var, val)) = arg.split_once('=') {
-        write_vars(|v| v.set_var(var, val, VarFlags::LOCAL));
-      } else {
-        write_vars(|v| v.set_var(&arg, "", VarFlags::LOCAL)); // Create an uninitialized local variable
-      }
-    }
-  }
-  state::set_status(0);
-  Ok(())
-}
--- a/src/builtin/mod.rs
+++ b/src/builtin/mod.rs
@@ -8,13 +8,13 @@ use crate::{
    execute::prepare_argv,
    lex::{Span, Tk},
  },
-  procio::{IoFrame, IoStack, RedirGuard},
+  procio::{IoFrame, IoStack, RedirGuard}, state,
 };

 pub mod alias;
 pub mod cd;
 pub mod echo;
-pub mod export;
+pub mod varcmds;
 pub mod flowctl;
 pub mod jobctl;
 pub mod pwd;
@@ -29,10 +29,10 @@ pub mod dirstack;
 pub mod exec;
 pub mod eval;

-pub const BUILTINS: [&str; 28] = [
+pub const BUILTINS: [&str; 33] = [
  "echo", "cd", "read", "export", "local", "pwd", "source", "shift", "jobs", "fg", "bg", "disown", "alias", "unalias",
  "return", "break", "continue", "exit", "zoltraak", "shopt", "builtin", "command", "trap",
-	"pushd", "popd", "dirs", "exec", "eval"
+	"pushd", "popd", "dirs", "exec", "eval", "true", "false", ":", "readonly", "unset"
 ];

 /// Sets up a builtin command
@@ -93,3 +93,18 @@ pub fn setup_builtin(
  // io_frame.restore()
  Ok((argv, guard))
 }
+
+pub fn true_builtin() -> ShResult<()> {
+	state::set_status(0);
+	Ok(())
+}
+
+pub fn false_builtin() -> ShResult<()> {
+	state::set_status(1);
+	Ok(())
+}
+
+pub fn noop_builtin() -> ShResult<()> {
+	state::set_status(0);
+	Ok(())
+}
--- a/src/builtin/varcmds.rs
+++ b/src/builtin/varcmds.rs
@@ -0,0 +1,163 @@
+use crate::{
+  jobs::JobBldr,
+  libsh::error::{ShErr, ShErrKind, ShResult},
+  parse::{NdRule, Node},
+  prelude::*,
+  procio::{IoStack, borrow_fd},
+  state::{self, VarFlags, read_vars, write_vars},
+};
+
+use super::setup_builtin;
+
+pub fn readonly(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
+  let NdRule::Command {
+    assignments: _,
+    argv,
+  } = node.class
+  else {
+    unreachable!()
+  };
+
+  let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
+
+  if argv.is_empty() {
+    // Display the local variables
+    let vars_output = read_vars(|v| {
+      let mut vars = v
+        .flatten_vars()
+        .into_iter()
+				.filter(|(_, v)| v.flags().contains(VarFlags::READONLY))
+        .map(|(k, v)| format!("{}={}", k, v))
+        .collect::<Vec<String>>();
+      vars.sort();
+      let mut vars_joined = vars.join("\n");
+      vars_joined.push('\n');
+      vars_joined
+    });
+
+    let stdout = borrow_fd(STDOUT_FILENO);
+    write(stdout, vars_output.as_bytes())?; // Write it
+  } else {
+    for (arg, _) in argv {
+      if let Some((var, val)) = arg.split_once('=') {
+        write_vars(|v| v.set_var(var, val, VarFlags::READONLY))?;
+      } else {
+        write_vars(|v| v.set_var(&arg, "", VarFlags::READONLY))?;
+      }
+    }
+  }
+
+	state::set_status(0);
+	Ok(())
+}
+
+pub fn unset(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
+	let blame = node.get_span().clone();
+  let NdRule::Command {
+    assignments: _,
+    argv,
+  } = node.class
+  else {
+    unreachable!()
+  };
+
+  let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
+
+	if argv.is_empty() {
+		return Err(ShErr::full(
+			ShErrKind::SyntaxErr,
+			"unset: Expected at least one argument",
+			blame
+		));
+	}
+
+	for (arg,span) in argv {
+		if !read_vars(|v| v.var_exists(&arg)) {
+			return Err(ShErr::full(
+				ShErrKind::ExecFail,
+				format!("unset: No such variable '{arg}'"),
+				span
+			));
+		}
+		write_vars(|v| v.unset_var(&arg))?;
+	}
+
+	state::set_status(0);
+	Ok(())
+}
+
+pub fn export(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
+  let NdRule::Command {
+    assignments: _,
+    argv,
+  } = node.class
+  else {
+    unreachable!()
+  };
+
+  let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
+
+  if argv.is_empty() {
+    // Display the environment variables
+    let mut env_output = env::vars()
+      .map(|var| format!("{}={}", var.0, var.1)) // Get all of them, zip them into one string
+      .collect::<Vec<_>>();
+    env_output.sort(); // Sort them alphabetically
+    let mut env_output = env_output.join("\n"); // Join them with newlines
+    env_output.push('\n'); // Push a final newline
+
+    let stdout = borrow_fd(STDOUT_FILENO);
+    write(stdout, env_output.as_bytes())?; // Write it
+  } else {
+    for (arg, _) in argv {
+      if let Some((var, val)) = arg.split_once('=') {
+        write_vars(|v| v.set_var(var, val, VarFlags::EXPORT))?;
+      } else {
+        write_vars(|v| v.export_var(&arg)); // Export an existing variable, if
+                                            // any
+      }
+    }
+  }
+  state::set_status(0);
+  Ok(())
+}
+
+pub fn local(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
+  let NdRule::Command {
+    assignments: _,
+    argv,
+  } = node.class
+  else {
+    unreachable!()
+  };
+
+  let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
+
+  if argv.is_empty() {
+    // Display the local variables
+    let vars_output = read_vars(|v| {
+      let mut vars = v
+        .flatten_vars()
+        .into_iter()
+        .map(|(k, v)| format!("{}={}", k, v))
+        .collect::<Vec<String>>();
+      vars.sort();
+      let mut vars_joined = vars.join("\n");
+      vars_joined.push('\n');
+      vars_joined
+    });
+
+    let stdout = borrow_fd(STDOUT_FILENO);
+    write(stdout, vars_output.as_bytes())?; // Write it
+  } else {
+    for (arg, _) in argv {
+      if let Some((var, val)) = arg.split_once('=') {
+        write_vars(|v| v.set_var(var, val, VarFlags::LOCAL))?;
+      } else {
+        write_vars(|v| v.set_var(&arg, "", VarFlags::LOCAL))?;
+      }
+    }
+  }
+  state::set_status(0);
+  Ok(())
+}