From a7f085fb07d6b49bf7d8e082b9e2e39ea7c1b39d Mon Sep 17 00:00:00 2001 From: Leo Dev Date: Thu, 9 May 2024 20:27:23 +0200 Subject: [PATCH] round brackets --- src/transpiler.rs | 130 ++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 109 insertions(+), 21 deletions(-) diff --git a/src/transpiler.rs b/src/transpiler.rs index e972c8a..5a6f79c 100644 --- a/src/transpiler.rs +++ b/src/transpiler.rs @@ -3,60 +3,148 @@ use crate::parser::{Parser, AstType}; pub fn transpile(input: String, indent: u32, state: LexerState) -> String { let mut result = String::new(); + if indent == 0 { result += "type int = i32;\n"; } else { - result += " ".repeat((indent as usize)*2).as_str(); - } + result += " ".repeat((indent as usize) * 2).as_str(); + } + let lexer_out = lex(input.as_str(), false, state); + match lexer_out { Ok(tokens) => { let mut full_ast = Parser::new(tokens.clone()); + while full_ast.tokens.len() > full_ast.index as usize { let ast = full_ast.next(); println!("{ast}"); + if ast.ast_type == AstType::FunctionDeceleration { - result += format!("fn {}({}) -> {} {}", ast.tokens[1].value, ast.tokens[2].value, ast.tokens[0].value, transpile(ast.tokens[3].value.clone(), indent+1, LexerState{line:ast.tokens[3].line,column:ast.tokens[3].column})).as_str(); + result += format!( + "fn {}({}) -> {} {}", + ast.tokens[1].value, + transpile_round(ast.tokens[2].value.clone(), LexerState { + line: ast.tokens[2].line, + column: ast.tokens[2].column + }), + ast.tokens[0].value, + transpile( + ast.tokens[3].value.clone(), + indent + 1, + LexerState { + line: ast.tokens[3].line, + column: ast.tokens[3].column + } + ) + ) + .as_str(); } else if ast.ast_type == AstType::VoidFunctionDeceleration { - result += format!("fn {}({}) {}", ast.tokens[1].value, ast.tokens[2].value, transpile(ast.tokens[3].value.clone(), indent+1, LexerState{line:ast.tokens[3].line,column:ast.tokens[3].column})).as_str(); + result += format!( + "fn {}({}) {}", + ast.tokens[1].value, + transpile_round(ast.tokens[2].value.clone(), LexerState { + line: ast.tokens[2].line, + column: ast.tokens[2].column + }), + transpile( + ast.tokens[3].value.clone(), + indent + 1, + LexerState { + line: ast.tokens[3].line, + column: ast.tokens[3].column + } + ) + ) + .as_str(); } else if ast.ast_type == AstType::VariableDeceleration { result += format!("let {}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str(); } else if ast.ast_type == AstType::MutVariableDeceleration { result += format!("let mut {}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str(); } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round { - result += format!("({})", ast.tokens[0].value).as_str(); + result += format!( + "({})", + transpile_round(ast.tokens[0].value.clone(), LexerState { + line: ast.tokens[0].line, + column: ast.tokens[0].column + }) + ) + .as_str(); } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Curly { - if ast.tokens[0].token_type==TokenType::Newline { - result += (ast.tokens[0].value.as_str().to_owned() + (" ".repeat((indent as usize)*2).as_str())).as_str() - } - else { - result += ast.tokens[0].value.as_str() + if ast.tokens[0].token_type == TokenType::Newline { + result += (ast.tokens[0].value.as_str().to_owned() + + (" ".repeat((indent as usize) * 2).as_str())) + .as_str(); + } else { + result += ast.tokens[0].value.as_str(); } } else { - if ast.tokens[0].token_type==TokenType::Newline { - result += (ast.tokens[0].value.as_str().to_owned() + (" ".repeat((indent as usize)*2).as_str())).as_str() - } else if ast.tokens[0].token_type==TokenType::Semicolon { + if ast.tokens[0].token_type == TokenType::Newline { + result += (ast.tokens[0].value.as_str().to_owned() + + (" ".repeat((indent as usize) * 2).as_str())) + .as_str(); + } else if ast.tokens[0].token_type == TokenType::Semicolon { result += ";\n"; - result += " ".repeat((indent as usize)*2).as_str(); + result += " ".repeat((indent as usize) * 2).as_str(); } else { - result += ast.tokens[0].value.as_str() + result += ast.tokens[0].value.as_str(); } } - } + result = result.trim_end().to_string(); + if indent > 0 { result += "\n"; - result += " ".repeat((indent as usize-1)*2).as_str(); - return "{\n".to_owned()+result.as_str()+"}" + result += " ".repeat((indent as usize - 1) * 2).as_str(); + return "{\n".to_owned() + result.as_str() + "}"; } else { - return result + return result; } - }, + } + Err((state, _tokens)) => { + println!("Invalid syntax at code.ws:{}:{}", state.line, state.column); + return "".to_string(); + } + } +} + +pub fn transpile_round(input: String, state: LexerState) -> String { + let mut result = String::new(); + let lexer_out = lex(input.as_str(), false, state); + + match lexer_out { + Ok(tokens) => { + let mut full_ast = Parser::new(tokens.clone()); + + while full_ast.tokens.len() > full_ast.index as usize { + let ast = full_ast.next(); + println!("{ast}"); + + if ast.ast_type == AstType::VariableDeceleration { + result += format!("{}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str(); + } else if ast.ast_type == AstType::MutVariableDeceleration { + result += format!("mut {}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str(); + } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round { + result += format!( + "({})", + transpile_round(ast.tokens[0].value.clone(), LexerState { + line: ast.tokens[0].line, + column: ast.tokens[0].column + }) + ) + .as_str(); + } else { + result += ast.tokens[0].value.as_str() + } + } + + result = result.trim_end().to_string(); + result + } Err((state, _tokens)) => { println!("Invalid syntax at code.ws:{}:{}", state.line, state.column); return "".to_string(); } } - }