Fix

shellgei · Jan 15, 2025 · 9401ef7 · 9401ef7
1 parent f66481f
commit 9401ef7
Show file tree

Hide file tree

Showing 14 changed files with 58 additions and 72 deletions.
diff --git a/src/core/builtins/parameter.rs b/src/core/builtins/parameter.rs
@@ -46,7 +46,7 @@ fn set_local(arg: &str, core: &mut ShellCore, layer: usize) -> Result<(), ExecEr
     }
 }
 
-fn set_local_array(arg: &str, core: &mut ShellCore, layer: usize) -> Result<(), String> {
+fn set_local_array(arg: &str, core: &mut ShellCore, layer: usize) -> Result<(), ExecError> {
     let mut feeder = Feeder::new(arg);
     if feeder.scanner_name(core) == feeder.len() { // name only
         let name = feeder.consume(feeder.len());
@@ -56,13 +56,13 @@ fn set_local_array(arg: &str, core: &mut ShellCore, layer: usize) -> Result<(),
     let mut sub = match Substitution::parse(&mut feeder, core) {
         Some(s) => s,
         _ => {
-            return Err(format!("local: `{}': not a valid identifier", arg));
+            return Err(ExecError::Other(format!("local: `{}': not a valid identifier", arg)));
         },
     };
 
     match sub.eval(core, Some(layer), false) {
         true  => Ok(()),
-        false => Err(format!("local: `{}': evaluation error", arg)),
+        false => Err(ExecError::Other(format!("local: `{}': evaluation error", arg))),
     }
 }
 
@@ -112,7 +112,8 @@ pub fn declare(core: &mut ShellCore, args: &mut Vec<String>) -> i32 {
             return 1; //TODO: error message
         }
         if let Err(e) = core.db.set_array(&name, vec![], None) {
-            error::print(&e, core);
+            let msg = format!("{:?}", &e);
+            error::print(&msg, core);
             return 1;
         }
 
@@ -124,7 +125,8 @@ pub fn declare(core: &mut ShellCore, args: &mut Vec<String>) -> i32 {
             return 1; //TODO: error message
         }
         if let Err(e) = core.db.set_assoc(&name, None) {
-            error::print(&e, core);
+            let msg = format!("{:?}", &e);
+            error::print(&msg, core);
             return 1;
         }
 

diff --git a/src/core/builtins/printf.rs b/src/core/builtins/printf.rs
@@ -83,7 +83,7 @@ pub fn printf(core: &mut ShellCore, args: &mut Vec<String>) -> i32 {
         let s = match output(&args[3], &mut args[4..].to_vec()) {
             Ok(ans) => ans,
             Err(e) => {
-                let msg = format!("printf: {}", e);
+                let msg = format!("printf: {:?}", e);
                 error::print(&msg, core);
                 return 1;
             },
@@ -99,7 +99,7 @@ pub fn printf(core: &mut ShellCore, args: &mut Vec<String>) -> i32 {
                 _ => core.db.set_assoc_elem(&name, &subscript, &s, None),
             };
             if let Err(e) = result {
-                let msg = format!("printf: {}", e);
+                let msg = format!("printf: {:?}", e);
                 error::print(&msg, core);
                 return 2;
             }
@@ -115,7 +115,7 @@ pub fn printf(core: &mut ShellCore, args: &mut Vec<String>) -> i32 {
     let s = match output(&args[1], &mut args[2..].to_vec()) {
         Ok(ans) => ans,
         Err(e) => {
-            let msg = format!("printf: {}", e);
+            let msg = format!("printf: {:?}", e);
             error::print(&msg, core);
             return 1;
         },

diff --git a/src/core/database.rs b/src/core/database.rs
@@ -184,28 +184,28 @@ impl DataBase {
         SingleData::set_value(&mut self.params[layer], name, val)
     }
 
-    pub fn set_array_elem(&mut self, name: &str, val: &String, pos: usize, layer: Option<usize>) -> Result<(), String> {
+    pub fn set_array_elem(&mut self, name: &str, val: &String, pos: usize, layer: Option<usize>) -> Result<(), ExecError> {
         Self::name_check(name)?;
         self.write_check(name)?;
         let layer = self.get_target_layer(name, layer);
         ArrayData::set_elem(&mut self.params[layer], name, pos, val)
     }
 
-    pub fn set_assoc_elem(&mut self, name: &str, key: &String, val: &String, layer: Option<usize>) -> Result<(), String> {
+    pub fn set_assoc_elem(&mut self, name: &str, key: &String, val: &String, layer: Option<usize>) -> Result<(), ExecError> {
         Self::name_check(name)?;
         self.write_check(name)?;
         let layer = self.get_target_layer(name, layer);
         AssocData::set_elem(&mut self.params[layer], name, key, val)
     }
 
-    pub fn set_array(&mut self, name: &str, v: Vec<String>, layer: Option<usize>) -> Result<(), String> {
+    pub fn set_array(&mut self, name: &str, v: Vec<String>, layer: Option<usize>) -> Result<(), ExecError> {
         Self::name_check(name)?;
         self.write_check(name)?;
         let layer = self.get_target_layer(name, layer);
         ArrayData::set_new_entry(&mut self.params[layer], name, v)
     }
 
-    pub fn set_assoc(&mut self, name: &str, layer: Option<usize>) -> Result<(), String> {
+    pub fn set_assoc(&mut self, name: &str, layer: Option<usize>) -> Result<(), ExecError> {
         Self::name_check(name)?;
         self.write_check(name)?;
         let layer = self.get_target_layer(name, layer);

diff --git a/src/core/database/data.rs b/src/core/database/data.rs
@@ -34,10 +34,10 @@ pub trait Data {
     }
 
     fn set_as_single(&mut self, _: &str) -> Result<(), ExecError> {Err(ExecError::Other("Undefined call".to_string()))}
-    fn set_as_array(&mut self, _: &str, _: &str) -> Result<(), String> {Err("not an array".to_string())}
-    fn set_as_assoc(&mut self, _: &str, _: &str) -> Result<(), String> {Err("not an associative table".to_string())}
+    fn set_as_array(&mut self, _: &str, _: &str) -> Result<(), ExecError> {Err(ExecError::Other("not an array".to_string()))}
+    fn set_as_assoc(&mut self, _: &str, _: &str) -> Result<(), ExecError> {Err(ExecError::Other("not an associative table".to_string()))}
 
-    fn get_as_single(&mut self) -> Result<String, String> {Err("not a single variable".to_string())}
+    fn get_as_single(&mut self) -> Result<String, ExecError> {Err(ExecError::Other("not a single variable".to_string()))}
     fn get_as_array(&mut self, key: &str) -> Result<String, ExecError> {
         Err(ExecError::OperandExpected(key.to_string()))
     }
@@ -55,7 +55,7 @@ pub trait Data {
         Err(ExecError::ArrayIndexInvalid(pos.to_string()))
     }
 
-    fn get_all_as_array(&mut self) -> Result<Vec<String>, String> {Err("not an array".to_string())}
+    fn get_all_as_array(&mut self) -> Result<Vec<String>, ExecError> {Err(ExecError::Other("not an array".to_string()))}
 
     fn is_special(&self) -> bool {false}
     fn is_single(&self) -> bool {false}

diff --git a/src/core/database/data/array.rs b/src/core/database/data/array.rs
@@ -36,12 +36,12 @@ impl Data for ArrayData {
         formatted
     }
 
-    fn set_as_array(&mut self, key: &str, value: &str) -> Result<(), String> {
+    fn set_as_array(&mut self, key: &str, value: &str) -> Result<(), ExecError> {
         if let Ok(n) = key.parse::<usize>() {
             self.body.insert(n, value.to_string());
             return Ok(());
         }
-        Err("invalid index".to_string())
+        Err(ExecError::Other("invalid index".to_string()))
     }
 
     fn get_as_array(&mut self, key: &str) -> Result<String, ExecError> {
@@ -53,26 +53,26 @@ impl Data for ArrayData {
         Ok( self.body.get(&n).unwrap_or(&"".to_string()).clone() )
     }
 
-    fn get_all_as_array(&mut self) -> Result<Vec<String>, String> {
+    fn get_all_as_array(&mut self) -> Result<Vec<String>, ExecError> {
         Ok(self.values().clone())
     }
 
-    fn get_as_single(&mut self) -> Result<String, String> {
-        self.body.get(&0).map(|v| Ok(v.clone())).ok_or("No entry".to_string())?
+    fn get_as_single(&mut self) -> Result<String, ExecError> {
+        self.body.get(&0).map(|v| Ok(v.clone())).ok_or(ExecError::Other("No entry".to_string()))?
     }
 
     fn is_array(&self) -> bool {true}
     fn len(&mut self) -> usize { self.body.len() }
 }
 
 impl ArrayData {
-    pub fn set_new_entry(db_layer: &mut HashMap<String, Box<dyn Data>>, name: &str, v: Vec<String>) -> Result<(), String> {
+    pub fn set_new_entry(db_layer: &mut HashMap<String, Box<dyn Data>>, name: &str, v: Vec<String>) -> Result<(), ExecError> {
         db_layer.insert(name.to_string(), Box::new(ArrayData::from(v)));
         Ok(())
     }
 
     pub fn set_elem(db_layer: &mut HashMap<String, Box<dyn Data>>,
-                        name: &str, pos: usize, val: &String) -> Result<(), String> {
+                        name: &str, pos: usize, val: &String) -> Result<(), ExecError> {
         match db_layer.get_mut(name) {
             Some(d) => d.set_as_array(&pos.to_string(), val),
             None    => {

diff --git a/src/core/database/data/assoc.rs b/src/core/database/data/assoc.rs
@@ -36,7 +36,7 @@ impl Data for AssocData {
         formatted
     }
 
-    fn set_as_assoc(&mut self, key: &str, value: &str) -> Result<(), String> {
+    fn set_as_assoc(&mut self, key: &str, value: &str) -> Result<(), ExecError> {
         self.body.insert(key.to_string(), value.to_string());
         self.last = Some(value.to_string());
         Ok(())
@@ -53,23 +53,23 @@ impl Data for AssocData {
         }
     }
 
-    fn get_as_single(&mut self) -> Result<String, String> { self.last.clone().ok_or("No last input".to_string()) }
+    fn get_as_single(&mut self) -> Result<String, ExecError> { self.last.clone().ok_or(ExecError::Other("No last input".to_string())) }
 
     fn is_assoc(&self) -> bool {true}
     fn len(&mut self) -> usize { self.body.len() }
 }
 
 impl AssocData {
-    pub fn set_new_entry(db_layer: &mut HashMap<String, Box<dyn Data>>, name: &str) -> Result<(), String> {
+    pub fn set_new_entry(db_layer: &mut HashMap<String, Box<dyn Data>>, name: &str) -> Result<(), ExecError> {
         db_layer.insert(name.to_string(), Box::new(AssocData::default()));
         Ok(())
     }
 
     pub fn set_elem(db_layer: &mut HashMap<String, Box<dyn Data>>, name: &str,
-                     key: &String, val: &String) -> Result<(), String> {
+                     key: &String, val: &String) -> Result<(), ExecError> {
         match db_layer.get_mut(name) {
             Some(v) => v.set_as_assoc(key, val), 
-            _ => Err("TODO".to_string()),
+            _ => Err(ExecError::Other("TODO".to_string())),
         }
     }
 

diff --git a/src/core/database/data/single.rs b/src/core/database/data/single.rs
@@ -26,7 +26,7 @@ impl Data for SingleData {
         Ok(())
     }
 
-    fn get_as_single(&mut self) -> Result<String, String> { Ok(self.body.clone()) }
+    fn get_as_single(&mut self) -> Result<String, ExecError> { Ok(self.body.clone()) }
     fn len(&mut self) -> usize { self.body.chars().count() }
     fn is_single(&self) -> bool {true}
 }

diff --git a/src/core/database/data/special.rs b/src/core/database/data/special.rs
@@ -2,6 +2,7 @@
 //SPDXLicense-Identifier: BSD-3-Clause
 
 use crate::core::{DataBase, HashMap};
+use crate::error::ExecError;
 use super::Data;
 
 #[derive(Debug, Clone)]
@@ -28,7 +29,7 @@ impl Data for SpecialData {
         self.internal_data.join(" ")
     }
 
-    fn get_as_single(&mut self) -> Result<String, String> {
+    fn get_as_single(&mut self) -> Result<String, ExecError> {
         Ok( (self.function)(&mut self.internal_data) )
     }
 

diff --git a/src/elements/command/arithmetic.rs b/src/elements/command/arithmetic.rs
@@ -48,14 +48,6 @@ impl ArithmeticCommand {
         let mut ans = String::new();
         for a in &mut self.expressions {
             ans = a.eval(core)?;
-            /*
-            match a.eval(core) {
-                Ok(s) => ans = s,
-                Err(e) => {
-                    eprintln!("{}", &e);
-                    return None;
-                },
-            }*/
         }
         Ok(ans)
     }

diff --git a/src/elements/expr/arithmetic.rs b/src/elements/expr/arithmetic.rs
@@ -99,21 +99,11 @@ impl ArithmeticExpr {
             Ok(b) => b,
             _     => {
                 return Err(ExecError::InvalidBase(base_str));
-                /*
-                let msg = format!("sush: {0}: invalid arithmetic base (error token is \"{0}\")", base_str);
-                eprintln!("{}", &msg);
-                return Err(msg);
-                */
             },
         };
 
         if base <= 1 || base > 64 {
             return Err(ExecError::InvalidBase(base_str));
-            /*
-            let msg = format!("sush: {0}: invalid arithmetic base (error token is \"{0}\")", base_str);
-            eprintln!("{}", &msg);
-            return Err(msg);
-            */
         }
 
         let mut tmp = n.abs();

diff --git a/src/elements/expr/arithmetic/array_elem.rs b/src/elements/expr/arithmetic/array_elem.rs
@@ -9,11 +9,6 @@ use crate::elements::subscript::Subscript;
 pub fn to_operand(name: &String, sub: &mut Subscript, pre_increment: i64, post_increment: i64,
                    core: &mut ShellCore) -> Result<ArithElem, ExecError> {
     let key = sub.eval(core, name)?;
-    /*
-    let key = match sub.eval(core, name) {
-        Some(s) => s, 
-        None => return Err(format!("{}: wrong substitution", &name)),
-    };*/
 
     let mut value_str = core.db.get_array_elem(name, &key)?;
     if value_str == "" {
@@ -27,30 +22,34 @@ pub fn to_operand(name: &String, sub: &mut Subscript, pre_increment: i64, post_i
 
     if pre_increment != 0 {
         value_num += pre_increment;
+        set_value(name, &key, value_num, core)?;
+        /*
         match set_value(name, &key, value_num, core) {
             Ok(()) => {},
             Err(e) => return Err(ExecError::Other(e)),
-        }
+        }*/
     }
 
     let ans = Ok( ArithElem::Integer(value_num) );
 
     if post_increment != 0 {
         value_num += post_increment;
+        set_value(name, &key, value_num, core)?;
+        /*
         match set_value(name, &key, value_num, core) {
             Ok(()) => {},
             Err(e) => return Err(ExecError::Other(e)),
-        }
+        }*/
     }
     ans
 }
 
 fn set_value(name: &String, key: &String, new_value: i64,
-                     core: &mut ShellCore) -> Result<(), String> {
+                     core: &mut ShellCore) -> Result<(), ExecError> {
     if let Ok(n) = key.parse::<i64>() {
         return match n >= 0 {
             true  => core.db.set_array_elem(name, &(new_value.to_string()), n as usize, None),
-            false => Err("negative index".to_string()),
+            false => Err(ExecError::Other("negative index".to_string())),
         };
     }