Simplify

Author: ryuichiueda

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sush"
-version = "0.7.3"
+version = "0.7.4"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/elements/arithmetic_expression/calculator.rs

@@ -60,31 +60,6 @@ fn unary_operation(op: &str, stack: &mut Vec<Elem>, core: &mut ShellCore) -> Res
 }
 
 pub fn calculate(elements: &Vec<Elem>, core: &mut ShellCore) -> Result<Elem, String> {
-    let mut comma_pos = vec![];
-    for (i, e) in elements.iter().enumerate() {
-        match e {
-            Elem::BinaryOp(c) => {
-                if c == "," {
-                    comma_pos.push(i);
-                }
-            },
-            _ => {},
-        }
-    }
-
-    let mut left = 0;
-    for i in 0..comma_pos.len() {
-        let right = comma_pos[i];
-        if let Err(e) = calculate_sub(&elements[left..right], core) {
-            return Err(e);
-        }
-        left = right + 1;
-    }
-
-    calculate_sub(&elements[left..], core)
-}
-
-fn calculate_sub(elements: &[Elem], core: &mut ShellCore) -> Result<Elem, String> {
     if elements.len() == 0 {
         return Ok(Elem::Integer(0));
     }

src/elements/arithmetic_expression/parser.rs

@@ -162,7 +162,8 @@ impl ArithmeticExpr {
         loop {
             Self::eat_blank(feeder, &mut ans, core);
 
-            if feeder.starts_with(":") {
+            if feeder.starts_with(":")
+            || feeder.starts_with(",") {
                 break;
             }
 

src/elements/command/arithmetic.rs

@@ -8,22 +8,24 @@ use crate::elements::arithmetic_expression::ArithmeticExpr;
 #[derive(Debug, Clone)]
 pub struct ArithmeticCommand {
     text: String,
-    arith: Option<ArithmeticExpr>,
+    arith: Vec<ArithmeticExpr>,
     redirects: Vec<Redirect>,
     force_fork: bool,
 }
 
 impl Command for ArithmeticCommand {
     fn run(&mut self, core: &mut ShellCore, _: bool) {
-        if self.arith.is_none() {
-            core.data.set_param("?", "0");
-            return;
-        }
+        let mut ans = true;
 
-        let ans = match self.arith.as_mut().unwrap().eval(core) {
-            Some(s) => s != "0",
-            None    => false,
-        };
+        for a in &mut self.arith {
+            match a.eval(core) {
+                Some(s) => ans = s != "0",
+                None    => {
+                    ans = false;
+                    break;
+                },
+            }
+        }
 
         core.data.set_param("?", if ans {"0"} else {"1"} );
     }
@@ -39,7 +41,7 @@ impl ArithmeticCommand {
     fn new() -> ArithmeticCommand {
         ArithmeticCommand {
             text: String::new(),
-            arith: None,
+            arith: vec![],
             redirects: vec![],
             force_fork: false,
         }
@@ -54,20 +56,29 @@ impl ArithmeticCommand {
         let mut ans = Self::new();
         ans.text = feeder.consume(2);
 
-        if let Some(c) = ArithmeticExpr::parse(feeder, core) {
-            if ! feeder.starts_with("))") {
-                feeder.rewind();
-                return None;
-            }
+        loop {
+            if let Some(c) = ArithmeticExpr::parse(feeder, core) {
+                if feeder.starts_with(",") {
+                    ans.text += &c.text;
+                    ans.text += &feeder.consume(1);
+                    ans.arith.push(c);
+                    continue;
+                }
 
-            ans.text += &c.text;
-            ans.text += &feeder.consume(2);
-            ans.arith = Some(c);
-            feeder.pop_backup();
-            return Some(ans);
-        }
+                if feeder.starts_with("))") {
+                    ans.text += &c.text;
+                    ans.text += &feeder.consume(2);
+                    ans.arith.push(c);
+                    feeder.pop_backup();
+                    return Some(ans);
+                }
 
+                break;
+            }else{
+                break;
+            }
+        }
         feeder.rewind();
-        None
+        return None;
     }
 }

src/elements/subword/arithmetic.rs

@@ -8,26 +8,30 @@ use crate::elements::subword::Subword;
 #[derive(Debug, Clone)]
 pub struct Arithmetic {
     pub text: String,
-    pub arith: ArithmeticExpr,
+    pub arith: Vec<ArithmeticExpr>,
 }
 
 impl Subword for Arithmetic {
     fn get_text(&self) -> &str { &self.text.as_ref() }
     fn boxed_clone(&self) -> Box<dyn Subword> {Box::new(self.clone())}
 
     fn substitute(&mut self, core: &mut ShellCore) -> bool {
-        match self.arith.eval(core) {
-            Some(s) => {self.text = s; true},
-            None    => false,
+        for a in &mut self.arith {
+            match a.eval(core) {
+                Some(s) => self.text = s,
+                None    => return false,
+            }
         }
+
+        true
     }
 }
 
 impl Arithmetic {
     fn new() -> Self {
         Self {
             text: String::new(),
-            arith: ArithmeticExpr::new(),
+            arith: vec![],
         }
     }
 
@@ -40,19 +44,29 @@ impl Arithmetic {
         let mut ans = Self::new();
         ans.text = feeder.consume(3);
 
-        if let Some(c) = ArithmeticExpr::parse(feeder, core) {
-            if ! feeder.starts_with("))") {
-                feeder.rewind();
-                return None;
-            }
+        loop {
+            if let Some(c) = ArithmeticExpr::parse(feeder, core) {
+                if feeder.starts_with(",") {
+                    ans.text += &c.text;
+                    ans.text += &feeder.consume(1);
+                    ans.arith.push(c);
+                    continue;
+                }
 
-            ans.text += &c.text;
-            ans.text += &feeder.consume(2);
-            ans.arith = c;
-            feeder.pop_backup();
-            return Some(ans);
-        }
+                if feeder.starts_with("))") {
+                    ans.text += &c.text;
+                    ans.text += &feeder.consume(2);
+                    ans.arith.push(c);
+                    feeder.pop_backup();
+                    return Some(ans);
+                }
 
+                break;
+            }else{
+                break;
+            }
+        }
+
         feeder.rewind();
         None
     }

src/feeder/scanner.rs

@@ -203,7 +203,7 @@ impl Feeder {
                                            ">", "=", "&", "|", "^", "/", "%"], core);
         self.scanner_one_of(&["<<=", ">>=",
             "&&", "||", "**", "==", "!=", "*=", "/=", "%=", "+=", "-=", "&=", "^=", "|=",
-            ">>", "<<", "<=", ">=", "&", "^", "=", "+", "-", "/", "*", "%", "<", ">", "|", "^", ","])
+            ">>", "<<", "<=", ">=", "&", "^", "=", "+", "-", "/", "*", "%", "<", ">", "|", "^"/*, ","*/])
     }
 
     pub fn scanner_uint(&mut self, core: &mut ShellCore) -> usize {