From 466215a381695b7ecbf29b07b558684cfd43ec8f Mon Sep 17 00:00:00 2001
From: LunaStev <96914208+LunaStev@users.noreply.github.com>
Date: Tue, 26 Nov 2024 14:50:15 +0900
Subject: [PATCH] rollback
---
src/parser.rs | 315 ++++++++++++++++++--------------------------------
1 file changed, 113 insertions(+), 202 deletions(-)
diff --git a/src/parser.rs b/src/parser.rs
index 82d1433..0a80faf 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,4 +1,4 @@
-use crate::ast::ASTNode;
+use std::thread::sleep;
use crate::lexer::{Lexer, Token, TokenType};
#[derive(Debug)]
@@ -13,11 +13,9 @@ impl<'a> Parser<'a> {
Parser { lexer, current_token }
}
- pub fn parse(&mut self) -> Vec<ASTNode> {
- let mut nodes = Vec::new();
-
+ pub fn parse(&mut self) {
while self.current_token.token_type != TokenType::EOF {
- let node = match self.current_token.token_type {
+ match self.current_token.token_type {
TokenType::FUN => self.function(),
TokenType::VAR => self.variable(),
TokenType::IF => self.if_statement(),
@@ -25,31 +23,25 @@ impl<'a> Parser<'a> {
TokenType::FOR => self.for_statement(),
TokenType::IMPORT => self.import_statement(),
TokenType::PRINT | TokenType::PRINTLN => self.print_statement(),
- _ => {
- self.advance();
- continue;
- }
- };
- nodes.push(node);
+ _ => self.advance(),
+ }
}
-
- nodes
}
fn advance(&mut self) {
self.current_token = self.lexer.next_token();
}
- fn function(&mut self) -> ASTNode {
+ fn function(&mut self) {
+ // 함수 구문 처리
self.advance(); // `fun`
- let name = if let TokenType::IDENTIFIER(name) = &self.current_token.token_type {
- let name = name.clone();
+ if let TokenType::IDENTIFIER(name) = &self.current_token.token_type {
+ println!("Parsing function: {}", name);
self.advance();
- name
} else {
panic!("Expected function name after 'fun'");
- };
+ }
if self.current_token.token_type != TokenType::LPAREN {
panic!("Expected '(' after function name");
@@ -61,6 +53,7 @@ impl<'a> Parser<'a> {
if let TokenType::IDENTIFIER(param_name) = &self.current_token.token_type {
params.push(param_name.clone());
self.advance();
+
if self.current_token.token_type == TokenType::COMMA {
self.advance();
}
@@ -68,115 +61,101 @@ impl<'a> Parser<'a> {
panic!("Expected parameter name in function parameter list");
}
}
- self.advance(); // `)`
+ self.advance();
if self.current_token.token_type != TokenType::LBRACE {
- panic!("Expected LBRACE at the beginning of function body");
+ panic!("Expected 'LBRACE' at the beginning of function body");
}
self.advance();
- let mut body = Vec::new();
while self.current_token.token_type != TokenType::RBRACE {
- body.push(self.parse_statement());
+ self.advance();
}
- self.advance(); // `}`
+ self.advance();
- ASTNode::Function {
- name,
- params,
- body,
- }
}
- fn variable(&mut self) -> ASTNode {
+ fn variable(&mut self) {
+ // 변수 구문 처리
self.advance(); // `var`
- let name = if let TokenType::IDENTIFIER(var_name) = &self.current_token.token_type {
- let var_name = var_name.clone(); // 먼저 불변 참조로 값을 추출
- self.advance(); // advance() 호출은 그 후에
- var_name
+ if let TokenType::IDENTIFIER(var_name) = &self.current_token.token_type {
+ println!("Parsing variable: {}", var_name);
+ self.advance();
} else {
- panic!("Expected variable name");
+ panic!("Expected variable name after 'var'");
};
if self.current_token.token_type == TokenType::COLON {
self.advance();
- let var_type = match &self.current_token.token_type {
- TokenType::TYPE_INT(int_type) => format!("{:?}", int_type),
- TokenType::TYPE_FLOAT(float_type) => format!("{:?}", float_type),
- TokenType::TYPE_STRING => "String".to_string(),
- _ => panic!("Expected a valid type after ':'"),
- };
- self.advance();
-
- if self.current_token.token_type != TokenType::EQUAL {
- panic!("Expected '=' after variable name");
- }
- self.advance();
-
- let value = match &self.current_token.token_type {
- TokenType::NUMBER(value) => value.to_string(),
- TokenType::STRING(value) => value.clone(),
- _ => panic!("Expected a numeric or string initial value after '='"),
- };
- self.advance();
-
- if self.current_token.token_type != TokenType::SEMICOLON {
- panic!("Expected ';' at the end of variable declaration");
- }
- self.advance();
-
- ASTNode::Variable {
- name,
- var_type,
- value,
+ match &self.current_token.token_type {
+ TokenType::TYPE_INT(int_type) => {
+ println!("Type of variable: {:?}", int_type);
+ self.advance();
+ },
+ TokenType::TYPE_FLOAT(float_type) => {
+ println!("Type of variable: {:?}", float_type);
+ self.advance();
+ },
+ TokenType::TYPE_STRING => {
+ println!("Type of variable: String");
+ self.advance();
+ },
+ _ => {
+ panic!("Expected a valid type after ':'");
+ }
}
} else {
panic!("Expected ':' after variable name");
}
- }
- fn print_statement(&mut self) -> ASTNode {
- let is_println = matches!(self.current_token.token_type, TokenType::PRINTLN);
- self.advance(); // Move past `print` or `println`
-
- let value = match &self.current_token.token_type {
- TokenType::STRING(content) => {
- let content = content.clone();
- self.advance(); // Move past the string literal
- ASTNode::Literal {
- value: content,
- is_println,
- }
+ if self.current_token.token_type != TokenType::EQUAL {
+ panic!("Expected '=' after variable name");
+ }
+ self.advance();
+
+ match &self.current_token.token_type {
+ TokenType::NUMBER(value) => {
+ println!("Initial value: {}", value);
+ self.advance();
},
- TokenType::NUMBER(num) => {
- let num = num.to_string();
- self.advance(); // Move past the number literal
- ASTNode::Literal {
- value: num,
- is_println,
- }
+ TokenType::STRING(value) => {
+ println!("Initial value: \"{}\"", value);
+ self.advance();
},
- _ => panic!("Expected a literal (string or number) after print/println"),
- };
+ _ => panic!("Expected a numeric inital value after '='"),
+ }
if self.current_token.token_type != TokenType::SEMICOLON {
- panic!("Expected ';' at the end of print/println statement");
+ panic!("Expected ';' at the end of variable declaration");
}
- self.advance(); // Move past the semicolon
+ self.advance();
- // Return the Print node that uses the value from the Literal
- ASTNode::Print {
- message: match value {
- ASTNode::Literal { value, .. } => value,
- _ => unreachable!(), // This should never happen
- },
- }
}
+ fn print_statement(&mut self) {
+ self.advance();
+ if let TokenType::STRING(_) = &self.current_token.token_type {
+ // It's a string, proceed with extracting the string.
+ } else {
+ panic!("Expected a string literal after print/println");
+ }
+ let message = match &self.current_token.token_type {
+ TokenType::STRING(s) => s,
+ _ => panic!("Expected a string"),
+ };
+
+ if self.current_token.token_type == TokenType::PRINTLN {
+ println!("{}", message);
+ } else {
+ print!("{}", message);
+ }
+ self.advance();
+ }
- fn if_statement(&mut self) -> ASTNode {
+ fn if_statement(&mut self) {
+ // if 구문 처리
self.advance(); // `if`
if self.current_token.token_type != TokenType::LPAREN {
@@ -184,8 +163,12 @@ impl<'a> Parser<'a> {
}
self.advance();
- // 여기서 조건 노드 파싱 로직 필요 (예: 변수 또는 표현식)
- let condition = self.parse_expression();
+ if let TokenType::NUMBER(value) = &self.current_token.token_type {
+ println!("Condition value: {}", value);
+ self.advance();
+ } else {
+ panic!("Expected a condition after '('");
+ }
if self.current_token.token_type != TokenType::RPAREN {
panic!("Expected ')' after condition");
@@ -193,41 +176,32 @@ impl<'a> Parser<'a> {
self.advance();
if self.current_token.token_type != TokenType::LBRACE {
- panic!("Expected LBRACE at the beginning of if body");
+ panic!("Expected 'LBRACE' at the beginning of if body");
}
self.advance();
- let mut body = Vec::new();
while self.current_token.token_type != TokenType::RBRACE {
- body.push(self.parse_statement());
+ self.advance();
}
- self.advance(); // `}`
+ self.advance();
- let else_body = if self.current_token.token_type == TokenType::ELSE {
+ if self.current_token.token_type == TokenType::ELSE {
self.advance();
+
if self.current_token.token_type != TokenType::LBRACE {
- panic!("Expected LBRACE at the beginning of else body");
+ panic!("Expected 'LBRACE' at the beginning of else body");
}
self.advance();
- let mut else_body = Vec::new();
while self.current_token.token_type != TokenType::RBRACE {
- else_body.push(self.parse_statement());
+ self.advance();
}
- self.advance(); // `}`
- Some(else_body)
- } else {
- None
- };
-
- ASTNode::If {
- condition: Box::new(condition),
- body,
- else_body,
+ self.advance();
}
}
- fn while_statement(&mut self) -> ASTNode {
+ fn while_statement(&mut self) {
+ // while 구문 처리
self.advance(); // `while`
if self.current_token.token_type != TokenType::LPAREN {
@@ -235,7 +209,12 @@ impl<'a> Parser<'a> {
}
self.advance();
- let condition = self.parse_expression();
+ if let TokenType::NUMBER(value) = &self.current_token.token_type {
+ println!("Condition value: {}", value);
+ self.advance();
+ } else {
+ panic!("Expected a conditon after '('");
+ }
if self.current_token.token_type != TokenType::RPAREN {
panic!("Expected ')' after condition");
@@ -243,57 +222,30 @@ impl<'a> Parser<'a> {
self.advance();
if self.current_token.token_type != TokenType::LBRACE {
- panic!("Expected LBRACE at the beginning of while body");
+ panic!("Expected 'LBRACE' at the beginning of while body");
}
self.advance();
- let mut body = Vec::new();
while self.current_token.token_type != TokenType::RBRACE {
- body.push(self.parse_statement());
- }
- self.advance(); // `}`
-
- ASTNode::While {
- condition: Box::new(condition),
- body,
+ self.advance();
}
+ self.advance();
}
- fn for_statement(&mut self) -> ASTNode {
- self.advance(); // `for`
+ fn for_statement(&mut self) {
+ // for 구문 처리
+ self.advance(); // 'for'
if self.current_token.token_type != TokenType::LPAREN {
panic!("Expected '(' after 'for'");
}
- self.advance();
-
- // `for` 구문 파싱 로직 추가 필요 (초기화, 조건, 증감식 등)
- if self.current_token.token_type != TokenType::RPAREN {
- panic!("Expected ')' after for conditions");
- }
- self.advance();
- if self.current_token.token_type != TokenType::LBRACE {
- panic!("Expected LBRACE at the beginning of for body");
- }
self.advance();
-
- let mut body = Vec::new();
- while self.current_token.token_type != TokenType::RBRACE {
- body.push(self.parse_statement());
- }
- self.advance(); // `}`
-
- ASTNode::For {
- init: None,
- condition: None,
- increment: None,
- body,
- }
}
- fn import_statement(&mut self) -> ASTNode {
+ fn import_statement(&mut self) {
+ // import 구문 처리
self.advance(); // `import`
if self.current_token.token_type != TokenType::LPAREN {
@@ -301,64 +253,23 @@ impl<'a> Parser<'a> {
}
self.advance();
- let module_name = if let TokenType::STRING(name) = &self.current_token.token_type {
- name.clone()
+ if let TokenType::STRING(module_name) = &self.current_token.token_type {
+ println!("Importing module: {}", module_name); // 모듈 이름 출력
+ self.advance();
} else {
- panic!("Expected module name string after '('");
- };
- self.advance(); // 모듈명 건너뜀
+ panic!("Expected a module name string after '('");
+ }
+ // ')' 토큰 체크
if self.current_token.token_type != TokenType::RPAREN {
panic!("Expected ')' after module name");
}
- self.advance(); // `)` 건너뜀
+ self.advance(); // ')' 건너뜀
+ // 문장의 끝을 의미하는 `;` 체크
if self.current_token.token_type != TokenType::SEMICOLON {
panic!("Expected ';' at the end of import statement");
}
self.advance(); // `;` 건너뜀
-
- ASTNode::Import {
- module_name,
- }
}
-
- pub fn parse_expression(&mut self) -> ASTNode {
- match self.current_token.token_type {
- TokenType::NUMBER(num) => {
- self.advance(); // 숫자 파싱 후 다음 토큰으로 이동
- ASTNode::Number(num)
- }
- TokenType::STRING(ref content) => {
- let content_clone = content.clone();
-
- self.advance();
-
- ASTNode::String(content_clone)
- }
- TokenType::VAR => {
- let var_name = self.current_token.lexeme.to_string();
- self.advance(); // 변수 이름 후 이동
- ASTNode::Variable {
- name: var_name,
- var_type: "unknown".to_string(),
- value: "undefined".to_string(),
- }
- }
- _ => panic!("Unexpected token while parsing expression"),
- }
- }
-
- pub fn parse_statement(&mut self) -> ASTNode {
- match self.current_token.token_type {
- TokenType::PRINT | TokenType::PRINTLN => self.print_statement(),
- TokenType::IF => self.if_statement(),
- TokenType::WHILE => self.while_statement(),
- TokenType::FOR => self.for_statement(),
- TokenType::VAR => self.variable(),
- TokenType::FUN => self.function(),
- TokenType::IMPORT => self.import_statement(),
- _ => panic!("Unexpected token in statement parsing"),
- }
- }
-}
\ No newline at end of file
+}