From 0f7dd6fb1cac3c3289d28fff43e3402d41c108bc Mon Sep 17 00:00:00 2001 From: Devin Bidwell Date: Mon, 17 Mar 2025 11:12:25 -0700 Subject: [PATCH] wip --- src/compiler/mod.rs | 22 +++++------- src/parser/mod.rs | 86 ++++++++++++++++++++++----------------------- 2 files changed, 52 insertions(+), 56 deletions(-) diff --git a/src/compiler/mod.rs b/src/compiler/mod.rs index 7b0896a..f547ba0 100644 --- a/src/compiler/mod.rs +++ b/src/compiler/mod.rs @@ -104,8 +104,8 @@ impl<'a> Compiler<'a> { } fn write_output(&mut self, output: impl Into) -> Result<(), CompileError> { - self.output.write(output.into().as_bytes())?; - self.output.write(b"\n")?; + self.output.write_all(output.into().as_bytes())?; + self.output.write_all(b"\n")?; self.current_line += 1; Ok(()) @@ -206,7 +206,7 @@ impl<'a> Compiler<'a> { compiler.push_stack(&format!("{op}ExpressionLeft"))?; } Expression::Variable(var_name) => { - let var_offset = compiler.get_variable_index(&var_name)?; + let var_offset = compiler.get_variable_index(&var_name)? + 1; compiler.write_output(format!("sub r15 sp {var_offset}"))?; compiler.write_output("get r15 db r15")?; compiler.write_output("push r15")?; @@ -232,7 +232,7 @@ impl<'a> Compiler<'a> { compiler.push_stack(&format!("{op}ExpressionRight"))?; } Expression::Variable(var_name) => { - let var_offset = compiler.get_variable_index(&var_name)?; + let var_offset = compiler.get_variable_index(&var_name)? + 1; compiler.write_output(format!("sub r15 sp {}", var_offset))?; compiler.write_output("get r15 db r15")?; compiler.write_output("push r15")?; @@ -283,18 +283,16 @@ impl<'a> Compiler<'a> { fn invocation_expression(&mut self, expr: InvocationExpression) -> Result<(), CompileError> { let function_name = expr.name; - let function_line = self + let function_line = *self .function_locations .get(&function_name) - .ok_or(CompileError::MissingFunction(function_name.clone()))? - .clone(); + .ok_or(CompileError::MissingFunction(function_name.clone()))?; let mut to_write = String::new(); self.push_stack(&format!("{function_name}ReturnAddress"))?; - let mut iter_index = 0; - for arg in expr.arguments { + for (iter_index, arg) in expr.arguments.into_iter().enumerate() { match arg { Expression::Literal(Literal::Number(num)) => { to_write.push_str(&format!("push {}\n", num)); @@ -313,14 +311,12 @@ impl<'a> Compiler<'a> { _ => todo!("something is up with the arguments"), } self.push_stack(&format!("{function_name}Invocation{iter_index}"))?; - - iter_index += 1; } // push the return address onto the stack. Current + to write + pushing the return address let return_addr = self.current_line + to_write.lines().count() + 2; self.write_output(format!("push {return_addr}"))?; - self.output.write(to_write.as_bytes())?; + self.output.write_all(to_write.as_bytes())?; self.current_line = return_addr - 1; self.write_output(format!("j {function_line}"))?; @@ -336,7 +332,7 @@ impl<'a> Compiler<'a> { self.function_locations.insert(func_name, self.current_line); for arg in expression.arguments.iter().rev() { - self.push_stack(&arg)?; + self.push_stack(arg)?; } for expr in expression.body.0 { diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 612a87e..99d4e3e 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -342,7 +342,7 @@ impl Parser { // build the expressions and operators vectors while token_matches!(current_token, TokenType::Symbol(s) if s.is_operator()) { // We are guaranteed to have an operator symbol here as we checked in the while loop - let operator = extract_token_data!(current_token, TokenType::Symbol(ref s), s.clone()); + let operator = extract_token_data!(current_token, TokenType::Symbol(s), s); operators.push(operator); self.assign_next()?; expressions.push(self.get_binary_child_node()?); @@ -613,8 +613,8 @@ impl Parser { fn literal(&mut self) -> Result { let current_token = token_from_option!(self.current_token); let literal = match current_token.token_type { - TokenType::Number(ref num) => Literal::Number(num.clone()), - TokenType::String(ref string) => Literal::String(string.clone()), + TokenType::Number(num) => Literal::Number(num), + TokenType::String(string) => Literal::String(string), _ => return Err(ParseError::UnexpectedToken(current_token.clone())), }; @@ -741,15 +741,15 @@ impl Parser { match invocation.name.as_str() { // system calls - "yield" => return Ok(SysCall::System(sys_call::System::Yield)), + "yield" => Ok(SysCall::System(sys_call::System::Yield)), "sleep" => { check_length(self, &invocation.arguments, 1)?; let mut arg = invocation.arguments.iter(); let argument = literal_or_variable!(arg.next()); - return Ok(SysCall::System(sys_call::System::Sleep(argument))); + Ok(SysCall::System(sys_call::System::Sleep(argument))) } "loadFromDevice" => { - check_length(&self, &invocation.arguments, 2)?; + check_length(self, &invocation.arguments, 2)?; let mut args = invocation.arguments.iter(); let device = literal_or_variable!(args.next()); @@ -760,13 +760,13 @@ impl Parser { )); }; - return Ok(SysCall::System(sys_call::System::LoadFromDevice( + Ok(SysCall::System(sys_call::System::LoadFromDevice( device, variable.clone(), - ))); + ))) } "setOnDevice" => { - check_length(&self, &invocation.arguments, 3)?; + check_length(self, &invocation.arguments, 3)?; let mut args = invocation.arguments.iter(); let device = literal_or_variable!(args.next()); @@ -781,95 +781,95 @@ impl Parser { let variable = literal_or_variable!(args.next()); - return Ok(SysCall::System(sys_call::System::SetOnDevice( + Ok(SysCall::System(sys_call::System::SetOnDevice( device, logic_type, variable, - ))); + ))) } // math calls "acos" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Acos(arg))); + Ok(SysCall::Math(sys_call::Math::Acos(arg))) } "asin" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Asin(arg))); + Ok(SysCall::Math(sys_call::Math::Asin(arg))) } "atan" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Atan(arg))); + Ok(SysCall::Math(sys_call::Math::Atan(arg))) } "atan2" => { - check_length(&self, &invocation.arguments, 2)?; + check_length(self, &invocation.arguments, 2)?; let mut args = invocation.arguments.iter(); let arg1 = literal_or_variable!(args.next()); let arg2 = literal_or_variable!(args.next()); - return Ok(SysCall::Math(sys_call::Math::Atan2(arg1, arg2))); + Ok(SysCall::Math(sys_call::Math::Atan2(arg1, arg2))) } "abs" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Abs(arg))); + Ok(SysCall::Math(sys_call::Math::Abs(arg))) } "ceil" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Ceil(arg))); + Ok(SysCall::Math(sys_call::Math::Ceil(arg))) } "cos" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Cos(arg))); + Ok(SysCall::Math(sys_call::Math::Cos(arg))) } "floor" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Floor(arg))); + Ok(SysCall::Math(sys_call::Math::Floor(arg))) } "log" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Log(arg))); + Ok(SysCall::Math(sys_call::Math::Log(arg))) } "max" => { - check_length(&self, &invocation.arguments, 2)?; + check_length(self, &invocation.arguments, 2)?; let mut args = invocation.arguments.iter(); let arg1 = literal_or_variable!(args.next()); let arg2 = literal_or_variable!(args.next()); - return Ok(SysCall::Math(sys_call::Math::Max(arg1, arg2))); + Ok(SysCall::Math(sys_call::Math::Max(arg1, arg2))) } "min" => { - check_length(&self, &invocation.arguments, 2)?; + check_length(self, &invocation.arguments, 2)?; let mut args = invocation.arguments.iter(); let arg1 = literal_or_variable!(args.next()); let arg2 = literal_or_variable!(args.next()); - return Ok(SysCall::Math(sys_call::Math::Min(arg1, arg2))); + Ok(SysCall::Math(sys_call::Math::Min(arg1, arg2))) } "rand" => { - check_length(&self, &invocation.arguments, 0)?; - return Ok(SysCall::Math(sys_call::Math::Rand)); + check_length(self, &invocation.arguments, 0)?; + Ok(SysCall::Math(sys_call::Math::Rand)) } "sin" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Sin(arg))); + Ok(SysCall::Math(sys_call::Math::Sin(arg))) } "sqrt" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Sqrt(arg))); + Ok(SysCall::Math(sys_call::Math::Sqrt(arg))) } "tan" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Tan(arg))); + Ok(SysCall::Math(sys_call::Math::Tan(arg))) } "trunc" => { - check_length(&self, &invocation.arguments, 1)?; + check_length(self, &invocation.arguments, 1)?; let arg = literal_or_variable!(invocation.arguments.first()); - return Ok(SysCall::Math(sys_call::Math::Trunc(arg))); + Ok(SysCall::Math(sys_call::Math::Trunc(arg))) } _ => todo!(), }