Change return type

shellgei · Jan 17, 2025 · cf23506 · cf23506
1 parent 98351a3
commit cf23506
Show file tree

Hide file tree

Showing 4 changed files with 17 additions and 16 deletions.
diff --git a/src/elements/expr/arithmetic/parser.rs b/src/elements/expr/arithmetic/parser.rs
@@ -65,16 +65,16 @@ impl ArithmeticExpr {
         Ok(true)
     }
 
-    fn eat_array_elem(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> bool {
+    fn eat_array_elem(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> Result<bool, ParseError> {
         let len = feeder.scanner_name(core);
         if len == 0 {
-            return false;
+            return Ok(false);
         }
 
         let name = &feeder.consume(len);
         ans.text += &name.clone();
 
-        if let Some(s) = Subscript::parse(feeder, core) {
+        if let Some(s) = Subscript::parse(feeder, core)? {
             ans.text += &s.text.clone();
             Self::eat_blank(feeder, ans, core);
             let suffix = Self::eat_suffix(feeder, ans);
@@ -85,7 +85,7 @@ impl ArithmeticExpr {
             ans.elements.push( ArithElem::Word(Word::from(name), suffix) );
         };
 
-        true
+        Ok(true)
     }
 
     fn eat_word(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> bool {
@@ -204,7 +204,7 @@ impl ArithmeticExpr {
             || Self::eat_unary_operator(feeder, &mut ans, core)
             || Self::eat_paren(feeder, core, &mut ans)?
             || Self::eat_binary_operator(feeder, &mut ans, core)
-            || Self::eat_array_elem(feeder, &mut ans, core) 
+            || Self::eat_array_elem(feeder, &mut ans, core)?
             || Self::eat_word(feeder, &mut ans, core) { 
                 continue;
             }

diff --git a/src/elements/subscript.rs b/src/elements/subscript.rs
@@ -3,6 +3,7 @@
 
 use crate::{ShellCore, Feeder};
 use crate::error::exec::ExecError;
+use crate::error::parse::ParseError;
 use super::expr::arithmetic::ArithmeticExpr;
 
 #[derive(Debug, Clone, Default)]
@@ -36,9 +37,9 @@ impl Subscript {
         Err(ExecError::ArrayIndexInvalid("".to_string()))
     }
 
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Self> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Self>, ParseError> {
         if ! feeder.starts_with("[") {
-            return None;
+            return Ok(None);
         }
 
         let mut ans = Self::default();
@@ -50,16 +51,16 @@ impl Subscript {
         }else if feeder.starts_with("*") {
             ans.text += "*";
             ans.inner_special = feeder.consume(1);
-        }else if let Ok(Some(a)) = ArithmeticExpr::parse(feeder, core, true) {
+        }else if let Some(a) = ArithmeticExpr::parse(feeder, core, true)? {
             ans.text += &a.text.clone();
             ans.inner = Some(a);
         }
 
         if ! feeder.starts_with("]") {
-            return None;
+            return Ok(None);
         }
 
         ans.text += &feeder.consume(1);
-        Some(ans)
+        Ok(Some(ans))
     }
 }
diff --git a/src/elements/substitution.rs b/src/elements/substitution.rs
@@ -177,7 +177,7 @@ impl Substitution {
         ans.name = name.clone();
         ans.text += &name;
 
-        if let Some(s) = Subscript::parse(feeder, core) {
+        if let Some(s) = Subscript::parse(feeder, core)? {
             ans.text += &s.text.clone();
             ans.index = Some(s);
         };

diff --git a/src/elements/subword/braced_param.rs b/src/elements/subword/braced_param.rs
@@ -152,17 +152,17 @@ impl BracedParam {
         Ok(())
     }
 
-    fn eat_subscript(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> bool {
-        if let Some(s) = Subscript::parse(feeder, core) {
+    fn eat_subscript(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> Result<bool, ParseError> {
+        if let Some(s) = Subscript::parse(feeder, core)? {
             ans.text += &s.text;
             if s.text.contains('@') {
                 ans.is_array = true;
             }
             ans.param.subscript = Some(s);
-            return true;
+            return Ok(true);
         }
 
-        false
+        Ok(false)
     }
 
     fn eat_subwords(feeder: &mut Feeder, ans: &mut Self, ends: Vec<&str>, core: &mut ShellCore)
@@ -241,7 +241,7 @@ impl BracedParam {
         }
 
         if Self::eat_param(feeder, &mut ans, core) {
-            Self::eat_subscript(feeder, &mut ans, core);
+            Self::eat_subscript(feeder, &mut ans, core)?;
             let _ = ValueCheck::eat(feeder, &mut ans, core)?
                  || Substr::eat(feeder, &mut ans, core)
                  || Remove::eat(feeder, &mut ans, core)?