Use result

shellgei · Jan 11, 2025 · 68c8f64 · 68c8f64
1 parent b2fa7dd
commit 68c8f64
Show file tree

Hide file tree

Showing 10 changed files with 49 additions and 48 deletions.
diff --git a/src/elements/command.rs b/src/elements/command.rs
@@ -95,24 +95,25 @@ fn eat_blank_with_comment(feeder: &mut Feeder, core: &mut ShellCore, ans_text: &
 }
 
 fn eat_redirect(feeder: &mut Feeder, core: &mut ShellCore,
-                     ans: &mut Vec<Redirect>, ans_text: &mut String) -> bool {
-    if let Some(r) = Redirect::parse(feeder, core) {
+                     ans: &mut Vec<Redirect>, ans_text: &mut String) -> Result<bool, String> {
+    if let Some(r) = Redirect::parse(feeder, core)? {
         *ans_text += &r.text.clone();
         ans.push(r);
-        true
+        Ok(true)
     }else{
-        false
+        Ok(false)
     }
 }
 
 pub fn eat_redirects(feeder: &mut Feeder, core: &mut ShellCore,
-                     ans_redirects: &mut Vec<Redirect>, ans_text: &mut String) {
+                     ans_redirects: &mut Vec<Redirect>, ans_text: &mut String) -> Result<(), String> {
     loop {
         eat_blank_with_comment(feeder, core, ans_text);
-        if ! eat_redirect(feeder, core, ans_redirects, ans_text){
+        if ! eat_redirect(feeder, core, ans_redirects, ans_text)? {
             break;
         }
     }
+    Ok(())
 }
 
 pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Box<dyn Command>> {

diff --git a/src/elements/command/simple.rs b/src/elements/command/simple.rs
@@ -94,18 +94,18 @@ impl SimpleCommand {
             .collect()
     }
 
-    fn eat_word(feeder: &mut Feeder, ans: &mut SimpleCommand, core: &mut ShellCore) -> bool {
-        let w = match Word::parse(feeder, core) {
+    fn eat_word(feeder: &mut Feeder, ans: &mut SimpleCommand, core: &mut ShellCore) -> Result<bool, String> {
+        let w = match Word::parse(feeder, core)? {
             Some(w) => w,
-            _       => return false,
+            _       => return Ok(false),
         };
 
         if ans.words.is_empty() && reserved(&w.text) {
-            return false;
+            return Ok(false);
         }
         ans.text += &w.text;
         ans.words.push(w);
-        true
+        Ok(true)
     }
 
     pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<SimpleCommand> {
@@ -114,7 +114,7 @@ impl SimpleCommand {
 
         loop {
             command::eat_redirects(feeder, core, &mut ans.redirects, &mut ans.text);
-            if ! Self::eat_word(feeder, &mut ans, core) {
+            if ! Self::eat_word(feeder, &mut ans, core).ok()? {
                 break;
             }
         }

diff --git a/src/elements/io/redirect.rs b/src/elements/io/redirect.rs
@@ -133,18 +133,18 @@ impl Redirect {
         }
     }
 
-    fn eat_right(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> bool {
+    fn eat_right(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> Result<bool, String> {
         let blank_len = feeder.scanner_blank(core);
         ans.text += &feeder.consume(blank_len);
 
-        let w = match Word::parse(feeder, core) {
+        let w = match Word::parse(feeder, core)? {
             Some(w) => w,
-            _       => return false,
+            _       => return Ok(false),
         };
 
         ans.text += &w.text.clone();
         ans.right = w;
-        true
+        Ok(true)
     }
 
     fn eat_left(feeder: &mut Feeder, ans: &mut Self, core: &mut ShellCore) -> bool {
@@ -159,18 +159,18 @@ impl Redirect {
         ans.left.parse::<RawFd>().is_ok()
     }
 
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Redirect> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Redirect>, String> {
         let mut ans = Self::new();
         feeder.set_backup(); //追加
 
         if Self::eat_left(feeder, &mut ans, core) &&
            Self::eat_symbol(feeder, &mut ans, core) &&
-           Self::eat_right(feeder, &mut ans, core) {
+           Self::eat_right(feeder, &mut ans, core)? {
             feeder.pop_backup();
-            Some(ans)
+            Ok(Some(ans))
         }else{
             feeder.rewind(); //追加
-            None
+            Ok(None)
         }
     }
 }
diff --git a/src/elements/subword.rs b/src/elements/subword.rs
@@ -75,11 +75,11 @@ pub trait Subword {
     fn is_name(&self) -> bool {false}
 }
 
-pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Box<dyn Subword>> {
-    if let Some(a) = SingleQuoted::parse(feeder, core){ Some(Box::new(a)) }
-    else if let Some(a) = EscapedChar::parse(feeder, core){ Some(Box::new(a)) }
-    else if let Some(a) = Parameter::parse(feeder, core){ Some(Box::new(a)) }
-    else if let Some(a) = VarName::parse(feeder, core){ Some(Box::new(a)) }
-    else if let Some(a) = SimpleSubword::parse(feeder){ Some(Box::new(a)) }
-    else{ None }
+pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Box<dyn Subword>>, String> {
+    if let Some(a) = SingleQuoted::parse(feeder, core)?{ Ok(Some(Box::new(a))) }
+    else if let Some(a) = EscapedChar::parse(feeder, core)?{ Ok(Some(Box::new(a))) }
+    else if let Some(a) = Parameter::parse(feeder, core)?{ Ok(Some(Box::new(a))) }
+    else if let Some(a) = VarName::parse(feeder, core)?{ Ok(Some(Box::new(a))) }
+    else if let Some(a) = SimpleSubword::parse(feeder)?{ Ok(Some(Box::new(a))) }
+    else{ Ok(None) }
 }
diff --git a/src/elements/subword/escaped_char.rs b/src/elements/subword/escaped_char.rs
@@ -32,10 +32,10 @@ impl Subword for EscapedChar {
 }
 
 impl EscapedChar {
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Self> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Self>, String> {
         match feeder.scanner_escaped_char(core) {
-            0 => None,
-            n => Some(EscapedChar{ text: feeder.consume(n) }),
+            0 => Ok(None),
+            n => Ok(Some(EscapedChar{ text: feeder.consume(n) })),
         }
     }
 }
diff --git a/src/elements/subword/parameter.rs b/src/elements/subword/parameter.rs
@@ -21,10 +21,10 @@ impl Subword for Parameter {
 }
 
 impl Parameter {
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Self> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Self>, String> {
         match feeder.scanner_dollar_special_and_positional_param(core) {
-            0 => None,
-            n => Some(Self { text: feeder.consume(n) } ),
+            0 => Ok(None),
+            n => Ok( Some(Self { text: feeder.consume(n) } ) ),
         }
     }
 }
diff --git a/src/elements/subword/simple.rs b/src/elements/subword/simple.rs
@@ -16,17 +16,17 @@ impl Subword for SimpleSubword {
 }
 
 impl SimpleSubword {
-    pub fn parse(feeder: &mut Feeder) -> Option<Self> {
+    pub fn parse(feeder: &mut Feeder) -> Result<Option<Self>, String> {
         let len = feeder.scanner_subword_symbol();
         if len > 0 {
-            return Some( Self{ text :feeder.consume(len) } );
+            return Ok( Some( Self{ text :feeder.consume(len) } ) );
         }
 
         let len = feeder.scanner_subword();
         if len > 0 {
-            return Some( Self{ text :feeder.consume(len) } );
+            return Ok( Some( Self{ text :feeder.consume(len) } ) );
         }
 
-        None
+        Ok(None)
     }
 }
diff --git a/src/elements/subword/single_quoted.rs b/src/elements/subword/single_quoted.rs
@@ -29,12 +29,12 @@ impl Subword for SingleQuoted {
 }
 
 impl SingleQuoted {
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Self> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Self>, String> {
         match feeder.scanner_single_quoted_subword(core) {
-            0 => None,
+            0 => Ok(None),
             n => {
                 let s = feeder.consume(n);
-                Some(SingleQuoted{ text: s })
+                Ok(Some(SingleQuoted{ text: s }))
             },
         }
     }

diff --git a/src/elements/subword/varname.rs b/src/elements/subword/varname.rs
@@ -17,10 +17,10 @@ impl Subword for VarName {
 }
 
 impl VarName {
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Self> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Self>, String> {
         match feeder.scanner_name(core) {
-            0 => None,
-            n => Some( Self{ text: feeder.consume(n) } ),
+            0 => Ok(None),
+            n => Ok( Some( Self{ text: feeder.consume(n) } ) ),
         }
     }
 }
diff --git a/src/elements/word.rs b/src/elements/word.rs
@@ -107,20 +107,20 @@ impl Word {
             .collect()
     }
 
-    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Word> {
+    pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Result<Option<Word>, String> {
         if feeder.starts_with("#") {
-            return None;
+            return Ok(None);
         }
 
         let mut subwords = vec![];
-        while let Some(sw) = subword::parse(feeder, core) {
+        while let Some(sw) = subword::parse(feeder, core)? {
             subwords.push(sw);
         }
 
         let ans = Word::from(subwords);
         match ans.text.len() {
-            0 => None,
-            _ => Some(ans),
+            0 => Ok(None),
+            _ => Ok(Some(ans)),
         }
     }
 }