latest pushes

src/parser/mod.rs

@@ -0,0 +1 @@
+pub mod parser;

src/parser/parser.rs

@@ -0,0 +1,268 @@
+// Copyright (C) 2024 Bellande Architecture Mechanism Research Innovation Center, Ronaldson Bellande
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::utilities::{ASTNode, Token};
+
+pub struct Parser {
+    tokens: Vec<Token>,
+    position: usize,
+}
+
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Self {
+        Parser {
+            tokens,
+            position: 0,
+        }
+    }
+
+    pub fn parse(&mut self) -> Result<Vec<ASTNode>, String> {
+        let mut nodes = Vec::new();
+        while self.position < self.tokens.len() {
+            nodes.push(self.parse_statement()?);
+            self.consume_if(Token::Semicolon);
+            self.consume_if(Token::NewLine);
+        }
+        Ok(nodes)
+    }
+
+    fn parse_statement(&mut self) -> Result<ASTNode, String> {
+        match &self.tokens[self.position] {
+            Token::Word(_) => self.parse_command_or_assignment(),
+            Token::LeftParen => self.parse_block(),
+            Token::If => self.parse_if(),
+            Token::While => self.parse_while(),
+            Token::For => self.parse_for(),
+            Token::Function => self.parse_function(),
+            _ => Err(format!(
+                "Unexpected token: {:?}",
+                self.tokens[self.position]
+            )),
+        }
+    }
+
+    fn parse_command_or_assignment(&mut self) -> Result<ASTNode, String> {
+        let name = match &self.tokens[self.position] {
+            Token::Word(w) => w.clone(),
+            _ => {
+                return Err(format!(
+                    "Expected word, found {:?}",
+                    self.tokens[self.position]
+                ))
+            }
+        };
+        self.position += 1;
+
+        if self.position < self.tokens.len() && self.tokens[self.position] == Token::Assignment {
+            self.position += 1;
+            let value = match &self.tokens[self.position] {
+                Token::Word(w) => w.clone(),
+                _ => String::new(), // Allow empty assignments
+            };
+            if self.position < self.tokens.len() {
+                self.position += 1;
+            }
+            Ok(ASTNode::Assignment { name, value })
+        } else {
+            let mut args = Vec::new();
+            while self.position < self.tokens.len()
+                && !matches!(
+                    self.tokens[self.position],
+                    Token::Pipe
+                        | Token::Redirect(_)
+                        | Token::Semicolon
+                        | Token::NewLine
+                        | Token::Ampersand
+                        | Token::Assignment
+                )
+            {
+                if let Token::Word(w) = &self.tokens[self.position] {
+                    args.push(w.clone());
+                    self.position += 1;
+                } else {
+                    break;
+                }
+            }
+            Ok(ASTNode::Command { name, args })
+        }
+    }
+
+    fn parse_pipeline_or_redirect(&mut self, left: ASTNode) -> Result<ASTNode, String> {
+        if self.position >= self.tokens.len() {
+            return Ok(left);
+        }
+
+        match &self.tokens[self.position] {
+            Token::Pipe => {
+                self.position += 1;
+                let right = self.parse_command_or_assignment()?;
+                let pipeline = ASTNode::Pipeline(vec![left, right]);
+                self.parse_pipeline_or_redirect(pipeline)
+            }
+            Token::Redirect(direction) => {
+                self.position += 1;
+                let target = match &self.tokens[self.position] {
+                    Token::Word(w) => w.clone(),
+                    _ => {
+                        return Err(format!(
+                            "Expected word after redirect, found {:?}",
+                            self.tokens[self.position]
+                        ))
+                    }
+                };
+                self.position += 1;
+                let redirect = ASTNode::Redirect {
+                    node: Box::new(left),
+                    direction: direction.clone(),
+                    target,
+                };
+                self.parse_pipeline_or_redirect(redirect)
+            }
+            Token::Ampersand => {
+                self.position += 1;
+                Ok(ASTNode::Background(Box::new(left)))
+            }
+            _ => Ok(left),
+        }
+    }
+
+    fn parse_if(&mut self) -> Result<ASTNode, String> {
+        self.position += 1; // Consume 'if'
+        let condition = Box::new(self.parse_command()?);
+        self.expect_token(Token::Then)?;
+        let then_block = Box::new(self.parse_block()?);
+        let else_block = if self.consume_if(Token::Else) {
+            Some(Box::new(self.parse_block()?))
+        } else {
+            None
+        };
+        self.expect_token(Token::Fi)?;
+        Ok(ASTNode::If {
+            condition,
+            then_block,
+            else_block,
+        })
+    }
+
+    fn parse_while(&mut self) -> Result<ASTNode, String> {
+        self.position += 1; // Consume 'while'
+        let condition = Box::new(self.parse_command()?);
+        self.expect_token(Token::Do)?;
+        let block = Box::new(self.parse_block()?);
+        self.expect_token(Token::Done)?;
+        Ok(ASTNode::While { condition, block })
+    }
+
+    fn parse_for(&mut self) -> Result<ASTNode, String> {
+        self.position += 1; // Consume 'for'
+        let var = match &self.tokens[self.position] {
+            Token::Word(w) => w.clone(),
+            _ => return Err("Expected variable name after 'for'".to_string()),
+        };
+        self.position += 1;
+        self.expect_token(Token::In)?;
+        let mut list = Vec::new();
+        while self.position < self.tokens.len() && self.tokens[self.position] != Token::Do {
+            if let Token::Word(w) = &self.tokens[self.position] {
+                list.push(w.clone());
+                self.position += 1;
+            } else {
+                break;
+            }
+        }
+        self.expect_token(Token::Do)?;
+        let block = Box::new(self.parse_block()?);
+        self.expect_token(Token::Done)?;
+        Ok(ASTNode::For { var, list, block })
+    }
+
+    fn parse_block(&mut self) -> Result<ASTNode, String> {
+        let mut statements = Vec::new();
+        while self.position < self.tokens.len()
+            && !matches!(
+                self.tokens[self.position],
+                Token::Fi | Token::Done | Token::Else
+            )
+        {
+            statements.push(self.parse_statement()?);
+            self.consume_if(Token::Semicolon);
+            self.consume_if(Token::NewLine);
+        }
+        Ok(ASTNode::Block(statements))
+    }
+
+    fn parse_command(&mut self) -> Result<ASTNode, String> {
+        let mut args = Vec::new();
+        while self.position < self.tokens.len()
+            && !matches!(
+                self.tokens[self.position],
+                Token::Then | Token::Do | Token::Done | Token::Fi | Token::Else
+            )
+        {
+            if let Token::Word(w) = &self.tokens[self.position] {
+                args.push(w.clone());
+                self.position += 1;
+            } else {
+                break;
+            }
+        }
+        if args.is_empty() {
+            Err("Expected command".to_string())
+        } else {
+            Ok(ASTNode::Command {
+                name: args[0].clone(),
+                args: args[1..].to_vec(),
+            })
+        }
+    }
+
+    fn parse_function(&mut self) -> Result<ASTNode, String> {
+        self.position += 1; // Consume 'function'
+        let name = match &self.tokens[self.position] {
+            Token::Word(w) => w.clone(),
+            _ => {
+                return Err(format!(
+                    "Expected function name, found {:?}",
+                    self.tokens[self.position]
+                ))
+            }
+        };
+        self.position += 1;
+        let body = Box::new(self.parse_block()?);
+        Ok(ASTNode::Function { name, body })
+    }
+
+    fn expect_token(&mut self, expected: Token) -> Result<(), String> {
+        if self.position < self.tokens.len() && self.tokens[self.position] == expected {
+            self.position += 1;
+            Ok(())
+        } else {
+            Err(format!(
+                "Expected {:?}, found {:?}",
+                expected,
+                self.tokens.get(self.position)
+            ))
+        }
+    }
+
+    fn consume_if(&mut self, token: Token) -> bool {
+        if self.position < self.tokens.len() && self.tokens[self.position] == token {
+            self.position += 1;
+            true
+        } else {
+            false
+        }
+    }
+}