Merge branch 'sd/202412_2' into sd/202412_3

Author: ryuichiueda

src/elements/io/redirect.rs

@@ -114,7 +114,7 @@ impl Redirect {
         Redirect {
             text: String::new(),
             symbol: String::new(),
-            right: Word::new(),
+            right: Word::new(vec![]),
             left: String::new(),
             left_fd: -1,
             left_backup: -1,

src/elements/job.rs

@@ -16,16 +16,14 @@ pub struct Job {
 
 impl Job {
     pub fn exec(&mut self, core: &mut ShellCore, bg: bool) {
-        let pgid = if core.is_subshell { //17〜21行目を追加
-            unistd::getpgrp() //自身のPGID
-        }else{
-            Pid::from_raw(0)
+        let pgid = match core.is_subshell {
+            true  => unistd::getpgrp(),
+            false => Pid::from_raw(0),
         };
 
-        if bg {
-            self.exec_bg(core, pgid);
-        }else{
-            self.exec_fg(core, pgid);
+        match bg {
+            true  => self.exec_bg(core, pgid),
+            false => self.exec_fg(core, pgid),
         }
     }
 
@@ -136,6 +134,9 @@ impl Job {
                 }
             }
         }
+
+        let com_num = feeder.scanner_comment();
+        ans.text += &feeder.consume(com_num);
 
         if ans.pipelines.len() > 0 {
 //            dbg!("{:?}", &ans); // デバッグ用にansの内容を出力

src/elements/script.rs

@@ -52,21 +52,26 @@ impl Script {
         len != 0
     }
 
-    fn check_nest(feeder: &mut Feeder, jobnum: usize) -> Status {
+    fn check_nest(&self, feeder: &mut Feeder) -> Status {
         let nest = feeder.nest.last().expect("SUSHI INTERNAL ERROR (empty nest)");
 
-        match ( nest.1.iter().find(|e| feeder.starts_with(e)), jobnum ) {
+        if nest.0 == "" && feeder.len() == 0 {
+            return Status::NormalEnd;
+        }
+
+        match ( nest.1.iter().find(|e| feeder.starts_with(e)), self.jobs.len() ) {
             ( Some(end), 0 ) => return Status::UnexpectedSymbol(end.to_string()),
             ( Some(_), _)    => return Status::NormalEnd,
             ( None, _)       => {}, 
         }
 
-        let ng_ends = vec!["(", ")", "}", "then", "else", "if", "fi", "elif", "do", "done", "while", "||", "&&", "|", "&", ";"];
-        match ( ng_ends.iter().find(|e| feeder.starts_with(e)), nest.1.len() ) {
-            (Some(end), _) => return Status::UnexpectedSymbol(end.to_string()),
-            (None, 0)      => return Status::NormalEnd,
-            (None, _)      => return Status::NeedMoreLine,
+        if feeder.len() > 0 {
+            let remaining = feeder.consume(feeder.len());
+            let first_token = remaining.split(" ").nth(0).unwrap().to_string();
+            return Status::UnexpectedSymbol(first_token);
         }
+
+        Status::NeedMoreLine
     }
 
     pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Script> {
@@ -76,10 +81,8 @@ impl Script {
             while Self::eat_job(feeder, core, &mut ans) 
                && Self::eat_job_end(feeder, &mut ans) {}
 
-            match Self::check_nest(feeder, ans.jobs.len()){
-                Status::NormalEnd => {
-                    return Some(ans)
-                },
+            match ans.check_nest(feeder){
+                Status::NormalEnd => return Some(ans),
                 Status::UnexpectedSymbol(s) => {
                     eprintln!("Unexpected token: {}", s);
                     core.set_param("?", "2");

src/elements/subword.rs

@@ -2,14 +2,12 @@
 //SPDX-License-Identifier: BSD-3-Clause
 
 mod escaped_char;
-mod parameter;
 mod simple;
 mod single_quoted;
 
 use crate::{Feeder, ShellCore};
 use std::fmt;
 use self::escaped_char::EscapedChar;
-use self::parameter::Parameter;
 use self::simple::SimpleSubword;
 use self::single_quoted::SingleQuoted;
 use std::fmt::Debug;
@@ -43,7 +41,6 @@ pub trait Subword {
 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) = SimpleSubword::parse(feeder){ Some(Box::new(a)) }
     else{ None }
 }

src/elements/word.rs

@@ -22,15 +22,15 @@ impl Word {
         Some( Self::make_args(&mut ws) )
     }
 
-    pub fn make_args(words: &mut Vec<Word>) -> Vec<String> {
+    fn make_args(words: &mut Vec<Word>) -> Vec<String> {
         words.iter_mut()
               .map(|w| w.make_unquoted_word())
               .filter(|w| *w != None)
               .map(|w| w.unwrap())
               .collect()
     }
 
-    pub fn make_unquoted_word(&mut self) -> Option<String> {
+    fn make_unquoted_word(&mut self) -> Option<String> {
         let sw: Vec<Option<String>> = self.subwords.iter_mut()
             .map(|s| s.make_unquoted_string()) //""や''はNoneにならずに空文字として残る
             .filter(|s| *s != None)
@@ -43,32 +43,27 @@ impl Word {
         Some(sw.into_iter().map(|s| s.unwrap()).collect::<String>())
     }
 
-    pub fn new() -> Word {
+    pub fn new(subwords: Vec<Box::<dyn Subword>>) -> Word {
         Word {
-            text: String::new(),
-            subwords: vec![],
+            text: subwords.iter().map(|s| s.get_text()).collect(),
+            subwords: subwords,
         }
     }
 
-    fn push(&mut self, subword: &Box<dyn Subword>) {
-        self.text += &subword.get_text().to_string();
-        self.subwords.push(subword.clone());
-    }
-
     pub fn parse(feeder: &mut Feeder, core: &mut ShellCore) -> Option<Word> {
         if feeder.starts_with("#") {
             return None;
         }
 
-        let mut ans = Word::new();
+        let mut subwords = vec![];
         while let Some(sw) = subword::parse(feeder, core) {
-            ans.push(&sw);
+            subwords.push(sw);
         }
 
-        if ans.text.len() == 0 {
-            None
-        }else{
-            Some(ans)
+        let ans = Word::new(subwords);
+        match ans.text.len() {
+            0 => None,
+            _ => Some(ans),
         }
     }
 }

src/elements/word/brace_expansion.rs

@@ -2,7 +2,7 @@
 //SPDX-License-Identifier: BSD-3-Clause
 
 use crate::elements::subword::Subword;
-use crate::elements::word::Word;
+use super::Word;
 
 fn after_dollar(s: &str) -> bool {
     s == "$" || s == "$$"
@@ -14,21 +14,19 @@ pub fn eval(word: &mut Word) -> Vec<Word> {
     let mut skip_until = 0;
     for i in open_brace_pos(word) {
         if i < skip_until { //ブレース展開の終わりまで処理をスキップ
-             continue;
+            continue;
         }
 
-        if let Some(d) = parse(&word.subwords[i..]) {
-            let shift_d: Vec<usize> = d.iter().map(|e| e+i).collect();
-
-            if i > 0 && after_dollar(word.subwords[i-1].get_text()) {
-                skip_until = *shift_d.last().unwrap();
-                continue;
-            }
+        let d = parse(&word.subwords[i..], i);
+        if d.len() <= 2 {
+            continue;
+        }
 
-            return expand(&word.subwords, &shift_d);
+        match i > 0 && after_dollar(word.subwords[i-1].get_text()) {
+            true  => skip_until = *d.last().unwrap(),
+            false => return expand(&word.subwords, &d),
         }
     }
-
     vec![word.clone()]
 }
 
@@ -52,56 +50,43 @@ fn open_brace_pos(w: &Word) -> Vec<usize> {
         .collect()
 }
 
-pub fn parse(subwords: &[Box<dyn Subword>]) -> Option<Vec<usize>> {
+fn parse(subwords: &[Box<dyn Subword>], start: usize) -> Vec<usize> {
     let mut stack = vec![];
     for sw in subwords {
-        stack.push(Some(sw.get_text()));
+        stack.push(sw.get_text());
         if sw.get_text() == "}" {
-            match get_delimiters(&mut stack) {
-                Some(ds) => return Some(ds),
-                _        => {},
+            let ds = get_delimiters(&mut stack, start);
+            if ds.len() > 2 {
+                return ds;
             }
         }
     }
-    None
+    vec![]
 }
 
-fn get_delimiters(stack: &mut Vec<Option<&str>>) -> Option<Vec<usize>> {
-    let mut comma_pos = vec![];
+fn get_delimiters(stack: &mut Vec<&str>, start: usize) -> Vec<usize> {
+    let mut delimiter_pos = vec![start, stack.len()-1+start];
     for i in (1..stack.len()-1).rev() {
-        if stack[i] == Some(",") {
-            comma_pos.push(i);
-        }else if stack[i] == Some("{") { // find an inner brace expcomma_posion
-            stack[i..].iter_mut().for_each(|e| *e = None);
-            return None;
+        if stack[i] == "," {
+            delimiter_pos.insert(1, start+i);
+        }else if stack[i] == "{" { // find an inner brace expcomma_posion
+            stack[i..].iter_mut().for_each(|e| *e = "");
+            return vec![];
         }
     }
-
-    if comma_pos.len() > 0 {
-        comma_pos.reverse();
-        comma_pos.insert(0, 0); // add "{" pos
-        comma_pos.push(stack.len()-1); // add "}" pos
-        Some(comma_pos)
-    }else{
-        None
-    }
+    delimiter_pos
 }
 
-pub fn expand(subwords: &Vec<Box<dyn Subword>>, delimiters: &Vec<usize>) -> Vec<Word> {
+fn expand(subwords: &Vec<Box<dyn Subword>>, delimiters: &Vec<usize>) -> Vec<Word> {
     let left = &subwords[..delimiters[0]];
     let mut right = subwords[(delimiters.last().unwrap()+1)..].to_vec();
     invalidate_brace(&mut right);
 
     let mut ans = vec![];
-    let mut from = delimiters[0] + 1;
-    for to in &delimiters[1..] {
-        let mut w = Word::new();
-        w.subwords.extend(left.to_vec());
-        w.subwords.extend(subwords[from..*to].to_vec());
-        w.subwords.extend(right.to_vec());
-        w.text = w.subwords.iter().map(|s| s.get_text()).collect();
+    for i in 0..(delimiters.len()-1) {
+        let center = &subwords[ (delimiters[i]+1)..delimiters[i+1] ];
+        let mut w = Word::new([ left, &center, &right ].concat() );
         ans.append(&mut eval(&mut w));
-        from = *to + 1;
     }
     ans
 }