added the ability to export existing variables

src/builtin/export.rs

@@ -1,4 +1,4 @@
-use crate::{jobs::JobBldr, libsh::error::{Note, ShErr, ShErrKind, ShResult}, parse::{NdRule, Node}, prelude::*, procio::{borrow_fd, IoStack}, state};
+use crate::{jobs::JobBldr, libsh::error::ShResult, parse::{NdRule, Node}, prelude::*, procio::{borrow_fd, IoStack}, state::{self, write_vars}};
 
 use super::setup_builtin;
 
@@ -21,20 +21,12 @@ pub fn export(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult
 		let stdout = borrow_fd(STDOUT_FILENO);
 		write(stdout, env_output.as_bytes())?; // Write it
 	} else {
-		for (arg,span) in argv {
+		for (arg,_) in argv {
-			let Some((var,val)) = arg.split_once('=') else {
+			if let Some((var,val)) = arg.split_once('=') {
-				return Err(
+				write_vars(|v| v.set_var(var, val, true)); // Export an assignment like 'foo=bar'
-					ShErr::full(
+			} else {
-						ShErrKind::SyntaxErr,
+				write_vars(|v| v.export_var(&arg)); // Export an existing variable, if any
-						"export: Expected an assignment in export args",
+			}
-						span.into()
-					)
-					.with_note(
-						Note::new("Arguments for export should be formatted like 'foo=bar'")
-					)
-				)
-			};
-			env::set_var(var, val);
 		}
 	}
 	io_frame.unwrap().restore()?;

src/parse/execute.rs

@@ -447,7 +447,7 @@ impl Dispatcher {
 					let var = var.span.as_str();
 					let val = val.span.as_str();
 					match kind {
-						AssignKind::Eq => write_vars(|v| v.new_var(var, val)),
+						AssignKind::Eq => write_vars(|v| v.set_var(var, val, false)),
 						AssignKind::PlusEq => todo!(),
 						AssignKind::MinusEq => todo!(),
 						AssignKind::MultEq => todo!(),

src/state.rs

@@ -87,9 +87,31 @@ impl LogTab {
 	}
 }
 
-#[derive(Clone)]
+#[derive(Clone,Debug)]
+pub struct Var {
+	export: bool,
+	value: String
+}
+
+impl Var {
+	pub fn new(value: String) -> Self {
+		Self { export: false, value }
+	}
+	pub fn mark_for_export(&mut self) {
+		self.export = true;
+	}
+}
+
+impl Deref for Var {
+	type Target = String;
+	fn deref(&self) -> &Self::Target {
+		&self.value
+	}
+}
+
+#[derive(Clone,Debug)]
 pub struct VarTab {
-	vars: HashMap<String,String>,
+	vars: HashMap<String,Var>,
 	params: HashMap<char,String>,
 	sh_argv: VecDeque<String>, // Using a VecDeque makes the implementation of `shift` straightforward
 }
@@ -201,10 +223,10 @@ impl VarTab {
 		self.update_arg_params();
 		arg
 	}
-	pub fn vars(&self) -> &HashMap<String,String> {
+	pub fn vars(&self) -> &HashMap<String,Var> {
 		&self.vars
 	}
-	pub fn vars_mut(&mut self) -> &mut HashMap<String,String> {
+	pub fn vars_mut(&mut self) -> &mut HashMap<String,Var> {
 		&mut self.vars
 	}
 	pub fn params(&self) -> &HashMap<char,String> {
@@ -213,6 +235,12 @@ impl VarTab {
 	pub fn params_mut(&mut self) -> &mut HashMap<char,String> {
 		&mut self.params
 	}
+	pub fn export_var(&mut self, var_name: &str) {
+		if let Some(var) = self.vars.get_mut(var_name) {
+			var.mark_for_export();
+			env::set_var(var_name, &var.value);
+		}
+	}
 	pub fn get_var(&self, var: &str) -> String {
 		if var.chars().count() == 1 {
 			let param = self.get_param(get_char(var, 0).unwrap());
@@ -226,8 +254,20 @@ impl VarTab {
 			std::env::var(var).unwrap_or_default()
 		}
 	}
-	pub fn new_var(&mut self, var: &str, val: &str) {
+	pub fn set_var(&mut self, var_name: &str, val: &str, export: bool) {
-		self.vars.insert(var.to_string(), val.to_string());
+		if let Some(var) = self.vars.get_mut(var_name) {
+			var.value = val.to_string();
+			if var.export {
+				env::set_var(var_name, val);
+			}
+		} else {
+			let mut var = Var::new(val.to_string());
+			if export {
+				var.mark_for_export();
+				env::set_var(var_name, &*var);
+			}
+			self.vars.insert(var_name.to_string(), var);
+		}
 	}
 	pub fn set_param(&mut self, param: char, val: &str) {
 		self.params.insert(param,val.to_string());

src/tests/expand.rs

@@ -5,7 +5,7 @@ use super::*;
 #[test]
 fn simple_expansion() {
 	let varsub = "$foo";
-	write_vars(|v| v.new_var("foo", "this is the value of the variable".into()));
+	write_vars(|v| v.set_var("foo", "this is the value of the variable".into()));
 
 	let mut tokens: Vec<Tk> = LexStream::new(Arc::new(varsub.to_string()), LexFlags::empty())
 		.map(|tk| tk.unwrap())