From dcf51be48cda1d3216873f72a9acad5cffd83905 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:41:30 +0900 Subject: [PATCH 1/9] Refactor parameter parsing logic: Replace direct push with match arms to handle different cases and continue on default --- src/parser/parser.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index c2f28acc..5fe5db8d 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -45,10 +45,14 @@ pub fn extract_parameters(tokens: &[Token]) -> Vec { None }; - params.push(ParameterNode { name, param_type, initial_value }); - i += 6; // Move to the next token + params.push(ParameterNode { + name, + param_type, + initial_value, + }); + } + _ => continue, } - i += 1; } params From ca1e7ef3a5d79a5950953ea261ee9333518fd1d9 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:42:00 +0900 Subject: [PATCH 2/9] Refactor initial value extraction logic: Replace index-based lookups with token stream handling using peek and next methods for improved clarity and flexibility --- src/parser/parser.rs | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index 5fe5db8d..79481e98 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -30,20 +30,16 @@ pub fn extract_parameters(tokens: &[Token]) -> Vec { continue; // Skip if no name exists }; - // parameter type - let param_type = if let Some(TokenType::TypeInt(_)) = tokens.get(i + 3) - .map(|t| &t.token_type) { - tokens[i + 3].lexeme.clone() - } else { - "unknown".to_string() // If you don't have type information, you don't know - }; - - let initial_value = if let Some(TokenType::EQUAL) = tokens.get(i + 4) - .map(|t| &t.token_type) { - Some(tokens[i + 5].lexeme.clone()) - } else { - None - }; + let initial_value = if let Some(Token { token_type: TokenType::EQUAL, .. }) = tokens.peek() { + tokens.next(); + if let Some(Token { lexeme, .. }) = tokens.next() { + Some(lexeme.clone()) + } else { + None + } + } else { + None + }; params.push(ParameterNode { name, From b4b066937e2ec5bf952379ea716e77df3c3de317 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:42:23 +0900 Subject: [PATCH 3/9] Refactor token iteration: Replace while loop with while let and match for more efficient token processing, improving readability and handling of token types --- src/parser/parser.rs | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index 79481e98..4c30d778 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -21,14 +21,21 @@ pub fn extract_parameters(tokens: &[Token]) -> Vec { let mut params = vec![]; let mut i = 0; - while i < tokens.len() { - if matches!(tokens[i].token_type, TokenType::VAR) { - // parameter name - let name = if let Some(TokenType::IDENTIFIER(name)) = tokens.get(i + 1).map(|t| &t.token_type) { - name.clone() - } else { - continue; // Skip if no name exists - }; + while let Some(token) = tokens.next() { + match &token.token_type { + TokenType::RPAREN => break, + TokenType::VAR => { + let name = if let Some(Token { token_type: TokenType::IDENTIFIER(name), .. }) = tokens.next() { + name.clone() + } else { + continue; + }; + + let param_type = if let Some(Token { token_type: TokenType::TypeInt(_), lexeme, .. }) = tokens.next() { + lexeme.clone() + } else { + "unknown".to_string() + }; let initial_value = if let Some(Token { token_type: TokenType::EQUAL, .. }) = tokens.peek() { tokens.next(); From d12850650ca831f173485712e296572c5942811d Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:42:49 +0900 Subject: [PATCH 4/9] Remove the let mut i = 0; initialization, simplifying the code by removing unnecessary index tracking --- src/parser/parser.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index 4c30d778..9ee7cf9b 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -19,7 +19,6 @@ pub fn param(parameter: String, param_type: String, initial_value: Option Vec { let mut params = vec![]; - let mut i = 0; while let Some(token) = tokens.next() { match &token.token_type { From 444bb0c30a485052a34e9172818b45629612ad24 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:43:17 +0900 Subject: [PATCH 5/9] Refactor parameter extraction function: Change function signature to accept a mutable Peekable iterator for token processing, replacing the token slice approach --- src/parser/parser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index 9ee7cf9b..31f1cd81 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -17,7 +17,7 @@ pub fn param(parameter: String, param_type: String, initial_value: Option Vec { +pub fn extract_parameters(tokens: &mut Peekable>) -> Vec { let mut params = vec![]; while let Some(token) = tokens.next() { From e4688dac9046f1e331ba26bc1c125a49fc6ece1d Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:43:30 +0900 Subject: [PATCH 6/9] Add necessary imports: Include Peekable from std::iter and Iter from std::slice for token iteration in the extract_parameters function --- src/parser/parser.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index 31f1cd81..9cbbe22b 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -1,3 +1,5 @@ +use std::iter::Peekable; +use std::slice::Iter; use crate::lexer::*; use crate::parser::ast::*; From 9452f2f5ac5193b26f08d334574e30b39941e8d5 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:44:04 +0900 Subject: [PATCH 7/9] Implement parse_function function: Parse a function definition from tokens using a Peekable iterator, extracting the function name, parameters, and body --- src/parser/parser.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/parser/parser.rs b/src/parser/parser.rs index 9cbbe22b..dd769f0c 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -107,6 +107,33 @@ pub fn extract_body<'a>(tokens: &mut std::iter::Peekable>) -> Option { + let function_name = if let Some(Token { token_type: TokenType::IDENTIFIER(name), .. }) = tokens.next() { + name.clone() + } else { + return None; + }; + + let parameters = if let Some(Token { token_type: TokenType::LPAREN, .. }) = tokens.next() { + extract_parameters(tokens) + } else { + vec![] + }; + + let body = if let Some(Token { token_type: TokenType::LBRACE, .. }) = tokens.next() { + extract_body(tokens) + } else { + vec![] + }; + + Some(ASTNode::Function(FunctionNode { + name: function_name, + parameters, + body, + })) +} + + // VAR parsing fn parse_var(tokens: &mut std::iter::Peekable>) -> Option { if let Some(Token { token_type: TokenType::IDENTIFIER(name), .. }) = tokens.next() { From 3004ee6363d6b40dfd642abe48647c0bddfc2d66 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:44:44 +0900 Subject: [PATCH 8/9] Remove direct call to extract_parameters with a token slice: Replace it with the updated version of extract_parameters that accepts a mutable Peekable iterator --- src/main.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/main.rs b/src/main.rs index 358e613e..b1c8b3df 100644 --- a/src/main.rs +++ b/src/main.rs @@ -104,8 +104,6 @@ fn run_wave_file(file_path: &str) { .map(|token| token.lexeme.clone()) .unwrap_or_default(); - let params = extract_parameters(&tokens); - let mut peekable_tokens = tokens.iter().peekable(); let body = extract_body(&mut peekable_tokens); From c8c7d12ea6d3599fa73c7a724916adf467f21700 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Fri, 17 Jan 2025 17:45:02 +0900 Subject: [PATCH 9/9] Update parameter extraction: Call extract_parameters with a mutable Peekable iterator (peekable_tokens) instead of a token slice --- src/main.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main.rs b/src/main.rs index b1c8b3df..cc1ebc50 100644 --- a/src/main.rs +++ b/src/main.rs @@ -105,6 +105,9 @@ fn run_wave_file(file_path: &str) { .unwrap_or_default(); let mut peekable_tokens = tokens.iter().peekable(); + + let params = extract_parameters(&mut peekable_tokens); + let body = extract_body(&mut peekable_tokens); let ast = function(function_name, params, body);