feat: Implement $* parameters; make $# respect function arguments

Author: TheOnlyMrCat

src/exec.rs

@@ -1013,12 +1013,34 @@ impl ShellContext {
             .skip(1)
             .cloned()
             .collect(),
-            Parameter::Pound => vec![format!("{}", config.positional_args.len() - 1)],
+            Parameter::Star => match self.function_args.last() {
+                Some(args) => args,
+                None => &config.positional_args,
+            }
+            .iter()
+            .skip(1)
+            .map(|word| {
+                crate::parser::parse_word(word)
+                    .map_err(|e| {
+                        ProcessExit::ExecError(CommandExecError::BadStarPositional { err: e })
+                    })
+                    .and_then(|word| self.evaluate_tl_word(&word, config))
+            })
+            .flatten_ok()
+            .collect::<Result<Vec<_>, _>>()?,
+            Parameter::Pound => vec![format!(
+                "{}",
+                match self.function_args.last() {
+                    Some(args) => args,
+                    None => &config.positional_args,
+                }
+                .len()
+                    - 1
+            )],
             Parameter::Dollar => vec![format!("{}", std::process::id())],
             Parameter::Question => vec![format!("{}", self.exit_code)],
             Parameter::Bang => vec![format!("{}", self.pid)],
 
-            Parameter::Star => todo!(), // Like @ but runs evaluate_word on each word
             Parameter::Dash => todo!(), // Options of current run invocation. Perhaps could be useful?
         })
     }

src/out.rs

@@ -378,6 +378,9 @@ pub fn process_finish(output_stream: &StandardStream, status: &ProcessExit) {
     fn exec_error(error: &CommandExecError) -> String {
         match error {
             CommandExecError::CommandFailed { err } => format!("{}", err),
+            CommandExecError::BadStarPositional { err } => {
+                format!("Could not parse positional parameter: {}", err)
+            } //TODO: Which parameter in particular?
             CommandExecError::InvalidGlob { glob, err } => {
                 format!("Invalid glob pattern: {}: {}", glob, err)
             }

src/parser/mod.rs

@@ -16,6 +16,8 @@ pub mod token;
 use ast::AtomicTopLevelCommand;
 use lexer::Lexer;
 
+use self::ast::ComplexWord;
+
 #[derive(Debug, Clone)]
 pub struct RunscriptSource {
     pub path: PathBuf,
@@ -67,6 +69,12 @@ pub fn parse_command(command: &str) -> Result<AtomicTopLevelCommand, ParseError>
     parser.complete_command().map(Option::unwrap)
 }
 
+pub fn parse_word(word: &str) -> Result<ComplexWord, ParseError> {
+    let lexer = Lexer::new(word.chars());
+    let mut parser = Parser::<_>::new(lexer);
+    parser.word().map(Option::unwrap)
+}
+
 pub fn parse_runscript(source: RunscriptSource) -> Result<Runscript, RunscriptParseError> {
     let line_indices = source
         .source

src/process.rs

@@ -5,8 +5,11 @@ use std::str::Utf8Error;
 
 use glob::PatternError;
 
+use crate::parser::parse::ParseError;
+
 #[derive(Debug)]
 pub enum CommandExecError {
+    BadStarPositional { err: ParseError },
     InvalidGlob { glob: String, err: PatternError },
     NoGlobMatches { glob: String },
     CommandFailed { err: std::io::Error },