From d9d74881405a793e3256105670e03a7dfdb7414f Mon Sep 17 00:00:00 2001
From: Ryuichi Ueda <ryuichiueda@gmail.com>
Date: Mon, 16 Sep 2024 20:21:38 +0900
Subject: [PATCH] Implement && and ||

---
 src/elements/expr/conditional.rs | 39 ++++++++++++++++++++------------
 1 file changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/elements/expr/conditional.rs b/src/elements/expr/conditional.rs
index 7b525e42..e64d3ba1 100644
--- a/src/elements/expr/conditional.rs
+++ b/src/elements/expr/conditional.rs
@@ -65,32 +65,42 @@ pub struct ConditionalExpr {
 impl ConditionalExpr {
     pub fn eval(&mut self, core: &mut ShellCore) -> Result<Elem, String> {
 
-        let mut stack = vec![];
         let mut from = 0;
+        let mut next = true;
+        let mut last = Elem::Ans(true);
         for i in 0..self.elements.len() {
             match self.elements[i] {
                 Elem::And | Elem::Or => {
-                    let rev_pol = match Self::rev_polish(&self.elements[from..i]) {
-                        Ok(ans) => ans,
-                        Err(e) => return Err(e),
-                    };
-
-                    stack = match Self::calculate(&rev_pol, core) {
-                        Ok(s)  => s, 
-                        Err(e) => return Err(e),
-                    };
-
+                    if next {
+                        last = match Self::calculate(&self.elements[from..i], core) {
+                            Ok(elem) => elem, 
+                            Err(e)   => return Err(e),
+                        };
+                    }
                     from = i + 1;
+                    next = match (&self.elements[i], &last) {
+                        (Elem::And, Elem::Ans(ans)) => *ans,
+                        (Elem::Or, Elem::Ans(ans))  => !ans,
+                        _ => panic!("SUSH INTERNAL ERROR"),
+                    };
                 },
                 _ => {},
             }
         }
 
-        let rev_pol = match Self::rev_polish(&self.elements[from..]) {
+        if next { 
+            Self::calculate(&self.elements[from..], core)
+        }else {
+            Ok(last)
+        }
+    }
+
+    fn calculate(elems: &[Elem], core: &mut ShellCore) -> Result<Elem, String> {
+        let rev_pol = match Self::rev_polish(elems) {
             Ok(ans) => ans,
             Err(e) => return Err(e),
         };
-        stack = match Self::calculate(&rev_pol, core) {
+        let mut stack = match Self::reduce(&rev_pol, core) {
             Ok(s)  => s, 
             Err(e) => return Err(e),
         };
@@ -121,8 +131,7 @@ impl ConditionalExpr {
         Ok(ans)
     }
 
-    fn calculate(rev_pol: &[Elem], core: &mut ShellCore) -> Result<Vec<Elem>, String> {
-        dbg!("{:?}", &rev_pol);
+    fn reduce(rev_pol: &[Elem], core: &mut ShellCore) -> Result<Vec<Elem>, String> {
         let mut stack = vec![];
 
         for e in rev_pol {