dbidwell/stationeers_lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Merge pull request #19 from dbidwell94/pre-release

Browse Source 
Pre release.. finish Math syscalls, various bug fixes, cleanup logging
This commit is contained in:
Devin Bidwell
2025-12-06 22:51:35 -07:00
committed by GitHub
parent f13edfc350 fd685a2fa0
commit 653026d6c1
14 changed files with 1025 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
ModData/About/About.xml Normal file
View File

@@ -0,0 +1,70 @@
<?xml version="1.0" encoding="utf-8"?>
<ModMetadata xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Name>StationeersSlang</Name>
<Author>JoeDiertay</Author>
<Version>0.1.0</Version>
<Description>
Slang (Stationeers Language) is a high-level programming language that compiles directly into IC10 within the game.
Features:
- In-Game Compilation: Write C-style code directly in the IC editor.
- Automatic Register Management: Define variables with 'let' (e.g., let x = 10) without managing r0-r15.
- Standard Control Flow: Use if/else, while, loop, break, and continue.
- Functions: Define and call functions with arguments.
- Smart Editor: Real-time syntax highlighting and error checking (red text for errors).
- Persistent Source: Your high-level source code is saved inside the chip data, so you can edit it later.
- Constant Folding: Mathematical operations on constants are calculated at compile time to save instructions.
- Device Aliasing: Easy device mapping (e.g., device sensor = "d0").
Installation:
This is a StationeersLaunchPad Plugin Mod. It requires BepInEx to be installed.
Usage:
1. Open any IC10 housing or editor.
2. Write Slang code.
3. Press Confirm to compile and run.
</Description>
<Tags>
<Tag>Logic</Tag>
<Tag>Scripting</Tag>
<Tag>Code</Tag>
<Tag>BepInEx</Tag>
<Tag>StationeersLaunchPad</Tag>
<Tag>Quality of Life</Tag>
</Tags>
<InGameDescription><![CDATA[
<size=30><color=#ffff00>Slang - High Level Language Compiler</color></size>
A modern programming experience for Stationeers. Write C-style code that compiles to MIPS assembly instantly.
<color=#ffa500><b>Features</b></color>
- <b>In-Game Compilation:</b> Write high-level logic directly in the chip editor.
- <b>Automatic Registers:</b> Stop juggling <color=#add8e6>r0-r15</color>. Just use <color=#569cd6>let</color> variables.
- <b>Control Flow:</b> Full support for <color=#c586c0>if</color>, <color=#c586c0>else</color>, <color=#c586c0>while</color>, and <color=#c586c0>loop</color>.
- <b>Smart Editor:</b> Integrated syntax highlighting and real-time error checking.
- <b>Persistent Code:</b> Your Slang source code is saved with the chip, so you never lose your work.
- <b>Optimization:</b> The compiler automatically optimizes constant math (e.g., <color=#b5cea8>1 + 2</color> becomes <color=#b5cea8>3</color>).
<color=#ffa500><b>Example Code</b></color>
<color=#569cd6>device</color> sensor = <color=#ce9178>"d0"</color>;
<color=#569cd6>const</color> MAX_TEMP = <color=#b5cea8>300k</color>;
<color=#c586c0>loop</color> {
<color=#569cd6>let</color> temp = sensor.Temperature;
<color=#c586c0>if</color> (temp > MAX_TEMP) {
<color=#6a9955>// Do logic here</color>
}
yield();
}
<b><color=#ffff00>Installation</color></b>
This is a <color=#ffa500>StationeersLaunchPad</color> Plugin Mod. It requires BepInEx to be installed.
See: https://github.com/StationeersLaunchPad/StationeersLaunchPad
Source Code: https://github.com/dbidwell94/stationeers_lang
]]>
</InGameDescription>
<Dependencies>
<Dependency>IC10Editor</Dependency>
</Dependencies>
<LoadAfter>IC10Editor</LoadAfter>
</ModMetadata>

BIN
ModData/About/Preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 481 KiB

BIN
ModData/About/thumb.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 481 KiB

0
ModData/Bepinex Normal file
View File

14
build.sh
View File

@@ -5,6 +5,7 @@ set -e
RUST_DIR="rust_compiler"
CSHARP_DIR="csharp_mod"
RELEASE_DIR="release"
METADATA_DIR="ModData"
export RUSTFLAGS="--remap-path-prefix=${PWD}=. --remap-path-prefix=${HOME}/.cargo=~/.cargo"
@@ -39,9 +40,13 @@ echo "--------------------"
RUST_WIN_EXE="$RUST_DIR/target/x86_64-pc-windows-gnu/release/slang.exe"
RUST_WIN_DLL="$RUST_DIR/target/x86_64-pc-windows-gnu/release/slang.dll"
RUST_LINUX_BIN="$RUST_DIR/target/x86_64-unknown-linux-gnu/release/slang"
CHARP_DLL="$CSHARP_DIR/bin/Release/net48/StationeersSlang.dll"
CSHARP_DLL="$CSHARP_DIR/bin/Release/net48/StationeersSlang.dll"
# Remove the release directory if it exists so we have a fresh build dir
if [[ -d "$RELEASE_DIR" ]]; then
rm -rd "$RELEASE_DIR"
fi
# Check if the release dir exists, if not: create it.
if [[ ! -d "$RELEASE_DIR" ]]; then
mkdir "$RELEASE_DIR"
fi
@@ -51,6 +56,9 @@ cp "$RUST_WIN_EXE" "$RELEASE_DIR/slang.exe"
# This is the linux executable
cp "$RUST_LINUX_BIN" "$RELEASE_DIR/slang"
# This is the DLL mod itself
cp "$CHARP_DLL" "$RELEASE_DIR/StationeersSlang.dll"
cp "$CSHARP_DLL" "$RELEASE_DIR/StationeersSlang.dll"
# This is the rust-only compiler for use in injecting into the mod
cp "$RUST_WIN_DLL" "$RELEASE_DIR/rust_slang.dll"
# This is the whole bundled workshop release version of the mod
cp -r "$METADATA_DIR" "$RELEASE_DIR/workshop"
cp "$CSHARP_DLL" "$RELEASE_DIR/workshop/StationeersSlang.dll"

36
csharp_mod/Formatter.cs
View File

@@ -72,8 +72,6 @@ public class SlangFormatter : ICodeFormatter
public override StyledLine ParseLine(string line)
{
L.Debug($"Parsing line for syntax highlighting: {line}");
// We create the line first
var styledLine = new StyledLine(line);
@@ -83,7 +81,6 @@ public class SlangFormatter : ICodeFormatter
// We call update to create the basic tokens
styledLine.Update(tokens);
// CRITICAL FIX: We must manually re-attach metadata because StyledLine.Update() drops it.
ReattachMetadata(styledLine, tokens);
return styledLine;
@@ -170,34 +167,35 @@ public class SlangFormatter : ICodeFormatter
if (line is null)
continue;
// 1. Get base syntax tokens
var allTokens = Marshal.TokenizeLine(line.Text);
// 1. Get base syntax tokens, converting to a dictionary for ease in deduping error tokens
var allTokensDict = Marshal.TokenizeLine(line.Text).ToDictionary((k) => k.Column);
// 2. Overlay error tokens if diagnostics exist for this line
// 2. Replace valid tokens with error tokens if present
if (dict.ContainsKey(lineIndex))
{
foreach (var lineDiagnostic in dict[lineIndex])
{
allTokens.Add(
new SemanticToken(
line: (int)lineIndex,
column: Math.Abs((int)lineDiagnostic.Range.StartCol),
length: Math.Abs(
(int)(lineDiagnostic.Range.EndCol - lineDiagnostic.Range.StartCol)
),
type: 0,
style: ICodeFormatter.ColorError,
data: lineDiagnostic.Message,
isError: true
)
var column = Math.Abs((int)lineDiagnostic.Range.StartCol);
allTokensDict[column] = new SemanticToken(
line: (int)lineIndex,
column,
length: Math.Abs(
(int)(lineDiagnostic.Range.EndCol - lineDiagnostic.Range.StartCol)
),
type: 0,
style: ICodeFormatter.ColorError,
data: lineDiagnostic.Message,
isError: true
);
}
}
var allTokens = allTokensDict.Values.ToList();
// 3. Update the line (this clears existing tokens and uses the list we just built)
line.Update(allTokens);
// 4. CRITICAL FIX: Re-attach metadata that Update() dropped
ReattachMetadata(line, allTokens);
}

1
csharp_mod/Marshal.cs
View File

@@ -147,7 +147,6 @@ public static class Marshal
};
var tokens = Ffi.tokenize_line(strRef);
L.Debug($"Tokenized line '{inputString}' into {tokens.len} tokens.");
return tokens.ToTokenList();
}
}

388
rust_compiler/libs/compiler/src/test/math_syscall.rs Normal file
View File

@@ -0,0 +1,388 @@
use crate::compile;
use anyhow::Result;
use indoc::indoc;
use pretty_assertions::assert_eq;
#[test]
fn test_acos() -> Result<()> {
let compiled = compile! {
debug
"
let i = acos(123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
acos r15 123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_asin() -> Result<()> {
let compiled = compile! {
debug
"
let i = asin(123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
asin r15 123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_atan() -> Result<()> {
let compiled = compile! {
debug
"
let i = atan(123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
atan r15 123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_atan2() -> Result<()> {
let compiled = compile! {
debug
"
let i = atan2(123, 456);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
atan2 r15 123 456
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_abs() -> Result<()> {
let compiled = compile! {
debug
"
let i = abs(-123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
abs r15 -123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_ceil() -> Result<()> {
let compiled = compile! {
debug
"
let i = ceil(123.90);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
ceil r15 123.90
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_cos() -> Result<()> {
let compiled = compile! {
debug
"
let i = cos(123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
cos r15 123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_floor() -> Result<()> {
let compiled = compile! {
debug
"
let i = floor(123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
floor r15 123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_log() -> Result<()> {
let compiled = compile! {
debug
"
let i = log(123);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
log r15 123
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_max() -> Result<()> {
let compiled = compile! {
debug
"
let i = max(123, 456);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
max r15 123 456
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_min() -> Result<()> {
let compiled = compile! {
debug
"
let i = min(123, 456);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
min r15 123 456
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_rand() -> Result<()> {
let compiled = compile! {
debug
"
let i = rand();
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
rand r15
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_sin() -> Result<()> {
let compiled = compile! {
debug
"
let i = sin(3);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
sin r15 3
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_sqrt() -> Result<()> {
let compiled = compile! {
debug
"
let i = sqrt(3);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
sqrt r15 3
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_tan() -> Result<()> {
let compiled = compile! {
debug
"
let i = tan(3);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
tan r15 3
move r8 r15 #i
"
}
);
Ok(())
}
#[test]
fn test_trunc() -> Result<()> {
let compiled = compile! {
debug
"
let i = trunc(3.234);
"
};
assert_eq!(
compiled,
indoc! {
"
j main
main:
trunc r15 3.234
move r8 r15 #i
"
}
);
Ok(())
}

1
rust_compiler/libs/compiler/src/test/mod.rs
View File

@@ -47,4 +47,5 @@ mod declaration_literal;
mod function_declaration;
mod logic_expression;
mod loops;
mod math_syscall;
mod syscall;

471
rust_compiler/libs/compiler/src/v1.rs
View File

@@ -3,7 +3,7 @@ use crate::variable_manager::{self, LocationRequest, VariableLocation, VariableS
use helpers::prelude::*;
use parser::{
Parser as ASTParser,
sys_call::{SysCall, System},
sys_call::{Math, SysCall, System},
tree_node::{
AssignmentExpression, BinaryExpression, BlockExpression, ConstDeclarationExpression,
DeviceDeclarationExpression, Expression, FunctionExpression, IfExpression,
@@ -97,12 +97,7 @@ impl From<Error> for lsp_types::Diagnostic {
severity: Some(DiagnosticSeverity::ERROR),
..Default::default()
},
ScopeError(e) => Diagnostic {
message: e.to_string(),
range: Range::default(),
severity: Some(DiagnosticSeverity::ERROR),
..Default::default()
},
ScopeError(e) => e.into(),
DuplicateIdentifier(_, span)
| UnknownIdentifier(_, span)
| InvalidDevice(_, span)
@@ -271,6 +266,10 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
node: SysCall::System(system),
span,
}) => self.expression_syscall_system(system, span, scope),
Expression::Syscall(Spanned {
node: SysCall::Math(math),
..
}) => self.expression_syscall_math(math, scope),
Expression::While(expr_while) => {
self.expression_while(expr_while.node, scope)?;
Ok(None)
@@ -284,7 +283,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
Ok(None)
}
Expression::DeviceDeclaration(expr_dev) => {
self.expression_device(expr_dev.node, expr_dev.span)?;
self.expression_device(expr_dev.node)?;
Ok(None)
}
Expression::Declaration(var_name, decl_expr) => {
@@ -304,7 +303,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Invocation returns result in r15 (RETURN_REGISTER).
// If used as an expression, we must move it to a temp to avoid overwrite.
let temp_name = self.next_temp_name();
let temp_loc = scope.add_variable(&temp_name, LocationRequest::Temp)?;
let temp_loc = scope.add_variable(&temp_name, LocationRequest::Temp, None)?;
self.emit_variable_assignment(
&temp_name,
&temp_loc,
@@ -326,7 +325,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
Expression::Literal(spanned_lit) => match spanned_lit.node {
Literal::Number(num) => {
let temp_name = self.next_temp_name();
let loc = scope.add_variable(&temp_name, LocationRequest::Temp)?;
let loc = scope.add_variable(&temp_name, LocationRequest::Temp, None)?;
self.emit_variable_assignment(&temp_name, &loc, num.to_string())?;
Ok(Some(CompilationResult {
location: loc,
@@ -336,7 +335,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
Literal::Boolean(b) => {
let val = if b { "1" } else { "0" };
let temp_name = self.next_temp_name();
let loc = scope.add_variable(&temp_name, LocationRequest::Temp)?;
let loc = scope.add_variable(&temp_name, LocationRequest::Temp, None)?;
self.emit_variable_assignment(&temp_name, &loc, val)?;
Ok(Some(CompilationResult {
location: loc,
@@ -346,7 +345,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
_ => Ok(None), // String literals don't return values in this context typically
},
Expression::Variable(name) => {
match scope.get_location_of(&name.node) {
match scope.get_location_of(&name.node, Some(name.span)) {
Ok(loc) => Ok(Some(CompilationResult {
location: loc,
temp_name: None, // User variable, do not free
@@ -378,7 +377,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// 2. Allocate a temp register for the result
let result_name = self.next_temp_name();
let loc = scope.add_variable(&result_name, LocationRequest::Temp)?;
let loc = scope.add_variable(&result_name, LocationRequest::Temp, None)?;
let reg = self.resolve_register(&loc)?;
// 3. Emit load instruction: l rX device member
@@ -386,7 +385,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// 4. Cleanup
if let Some(c) = cleanup {
scope.free_temp(c)?;
scope.free_temp(c, None)?;
}
Ok(Some(CompilationResult {
@@ -410,13 +409,13 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Compile negation as 0 - inner
let (inner_str, cleanup) = self.compile_operand(*inner_expr, scope)?;
let result_name = self.next_temp_name();
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp)?;
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp, None)?;
let result_reg = self.resolve_register(&result_loc)?;
self.write_output(format!("sub {result_reg} 0 {inner_str}"))?;
if let Some(name) = cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
Ok(Some(CompilationResult {
@@ -506,7 +505,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
&& let Expression::Literal(spanned_lit) = &box_expr.node
&& let Literal::Number(neg_num) = &spanned_lit.node
{
let loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let loc = scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
self.emit_variable_assignment(&name_str, &loc, format!("-{neg_num}"))?;
return Ok(Some(CompilationResult {
location: loc,
@@ -517,16 +516,22 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
let (loc, temp_name) = match expr.node {
Expression::Literal(spanned_lit) => match spanned_lit.node {
Literal::Number(num) => {
let var_location =
scope.add_variable(name_str.clone(), LocationRequest::Persist)?;
let var_location = scope.add_variable(
name_str.clone(),
LocationRequest::Persist,
Some(name_span),
)?;
self.emit_variable_assignment(&name_str, &var_location, num)?;
(var_location, None)
}
Literal::Boolean(b) => {
let val = if b { "1" } else { "0" };
let var_location =
scope.add_variable(name_str.clone(), LocationRequest::Persist)?;
let var_location = scope.add_variable(
name_str.clone(),
LocationRequest::Persist,
Some(name_span),
)?;
self.emit_variable_assignment(&name_str, &var_location, val)?;
(var_location, None)
@@ -536,7 +541,8 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
Expression::Invocation(invoke_expr) => {
self.expression_function_invocation(invoke_expr, scope)?;
let loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let loc =
scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
self.emit_variable_assignment(
&name_str,
&loc,
@@ -546,26 +552,22 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
}
Expression::Syscall(spanned_call) => {
let sys_call = spanned_call.node;
let SysCall::System(call) = sys_call else {
// Math syscalls might be handled differently or here
// For now assuming System returns value
return Err(Error::Unknown(
"Math syscall not yet supported in declaration".into(),
Some(spanned_call.span),
));
let res = match sys_call {
SysCall::System(s) => {
self.expression_syscall_system(s, spanned_call.span, scope)?
}
SysCall::Math(m) => self.expression_syscall_math(m, scope)?,
};
if self
.expression_syscall_system(call, spanned_call.span, scope)?
.is_none()
{
if res.is_none() {
return Err(Error::Unknown(
"SysCall did not return a value".into(),
Some(spanned_call.span),
));
};
let loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let loc =
scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
self.emit_variable_assignment(
&name_str,
&loc,
@@ -577,7 +579,8 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Support assigning binary expressions to variables directly
Expression::Binary(bin_expr) => {
let result = self.expression_binary(bin_expr, scope)?;
let var_loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let var_loc =
scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
if let CompilationResult {
location: VariableLocation::Constant(Literal::Number(num)),
@@ -593,14 +596,15 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Free the temp result
if let Some(name) = result.temp_name {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
(var_loc, None)
}
}
Expression::Logical(log_expr) => {
let result = self.expression_logical(log_expr, scope)?;
let var_loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let var_loc =
scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
// Move result from temp to new persistent variable
let result_reg = self.resolve_register(&result.location)?;
@@ -608,12 +612,12 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Free the temp result
if let Some(name) = result.temp_name {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
(var_loc, None)
}
Expression::Variable(name) => {
let src_loc_res = scope.get_location_of(&name.node);
let src_loc_res = scope.get_location_of(&name.node, Some(name.span));
let src_loc = match src_loc_res {
Ok(l) => l,
@@ -624,7 +628,8 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
}
};
let var_loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let var_loc =
scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
// Handle loading from stack if necessary
let src_str = match src_loc {
@@ -675,13 +680,14 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
));
};
let var_loc = scope.add_variable(&name_str, LocationRequest::Persist)?;
let var_loc =
scope.add_variable(&name_str, LocationRequest::Persist, Some(name_span))?;
let result_reg = self.resolve_register(&comp_res.location)?;
self.emit_variable_assignment(&name_str, &var_loc, result_reg)?;
if let Some(temp) = comp_res.temp_name {
scope.free_temp(temp)?;
scope.free_temp(temp, None)?;
}
(var_loc, None)
@@ -730,7 +736,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
};
Ok(CompilationResult {
location: scope.define_const(const_name.node, value)?,
location: scope.define_const(const_name.node, value, Some(const_name.span))?,
temp_name: None,
})
}
@@ -747,7 +753,8 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
match assignee.node {
Expression::Variable(identifier) => {
let location = match scope.get_location_of(&identifier.node) {
let location = match scope.get_location_of(&identifier.node, Some(identifier.span))
{
Ok(l) => l,
Err(_) => {
self.errors.push(Error::UnknownIdentifier(
@@ -791,7 +798,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
}
if let Some(name) = cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
}
Expression::MemberAccess(access) => {
@@ -804,10 +811,10 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
self.write_output(format!("s {} {} {}", device_str, member.node, val_str))?;
if let Some(c) = dev_cleanup {
scope.free_temp(c)?;
scope.free_temp(c, None)?;
}
if let Some(c) = val_cleanup {
scope.free_temp(c)?;
scope.free_temp(c, None)?;
}
}
_ => {
@@ -855,7 +862,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// backup all used registers to the stack
let active_registers = stack.registers().cloned().collect::<Vec<_>>();
for register in &active_registers {
stack.add_variable(format!("temp_{register}"), LocationRequest::Stack)?;
stack.add_variable(format!("temp_{register}"), LocationRequest::Stack, None)?;
self.write_output(format!("push r{register}"))?;
}
for arg in arguments {
@@ -872,14 +879,15 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
_ => {}
},
Expression::Variable(var_name) => {
let loc = match stack.get_location_of(var_name.node.clone()) {
Ok(l) => l,
Err(_) => {
self.errors
.push(Error::UnknownIdentifier(var_name.node, var_name.span));
VariableLocation::Temporary(0)
}
};
let loc =
match stack.get_location_of(var_name.node.clone(), Some(var_name.span)) {
Ok(l) => l,
Err(_) => {
self.errors
.push(Error::UnknownIdentifier(var_name.node, var_name.span));
VariableLocation::Temporary(0)
}
};
match loc {
VariableLocation::Persistant(reg) | VariableLocation::Temporary(reg) => {
@@ -916,7 +924,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
let reg_str = self.resolve_register(&result.location)?;
self.write_output(format!("push {reg_str}"))?;
if let Some(name) = result.temp_name {
stack.free_temp(name)?;
stack.free_temp(name, None)?;
}
}
Expression::Logical(log_expr) => {
@@ -925,7 +933,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
let reg_str = self.resolve_register(&result.location)?;
self.write_output(format!("push {reg_str}"))?;
if let Some(name) = result.temp_name {
stack.free_temp(name)?;
stack.free_temp(name, None)?;
}
}
Expression::MemberAccess(access) => {
@@ -947,7 +955,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
let reg_str = self.resolve_register(&result.location)?;
self.write_output(format!("push {reg_str}"))?;
if let Some(name) = result.temp_name {
stack.free_temp(name)?;
stack.free_temp(name, None)?;
}
} else {
self.write_output("push 0")?; // Should fail ideally
@@ -970,7 +978,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
for register in active_registers {
let VariableLocation::Stack(stack_offset) = stack
.get_location_of(format!("temp_{register}"))
.get_location_of(format!("temp_{register}"), None)
.map_err(Error::ScopeError)?
else {
// This shouldn't happen if we just added it
@@ -996,14 +1004,12 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
Ok(())
}
fn expression_device(
&mut self,
expr: DeviceDeclarationExpression,
span: Span,
) -> Result<(), Error> {
fn expression_device(&mut self, expr: DeviceDeclarationExpression) -> Result<(), Error> {
if self.devices.contains_key(&expr.name.node) {
self.errors
.push(Error::DuplicateIdentifier(expr.name.node.clone(), span));
self.errors.push(Error::DuplicateIdentifier(
expr.name.node.clone(),
expr.name.span,
));
// We can overwrite or ignore. Let's ignore new declaration to avoid cascading errors?
// Actually, for recovery, maybe we want to allow it so subsequent uses work?
// But we already have it.
@@ -1033,7 +1039,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
self.write_output(format!("beq {cond_str} 0 {else_label}"))?;
if let Some(name) = cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
// Compile Body
@@ -1108,7 +1114,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
self.write_output(format!("beq {cond_str} 0 {end_label}"))?;
if let Some(name) = cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
// Compile Body
@@ -1221,7 +1227,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
VariableLocation::Stack(offset) => {
// If it's on the stack, we must load it into a temp to use it as an operand
let temp_name = self.next_temp_name();
let temp_loc = scope.add_variable(&temp_name, LocationRequest::Temp)?;
let temp_loc = scope.add_variable(&temp_name, LocationRequest::Temp, None)?;
let temp_reg = self.resolve_register(&temp_loc)?;
self.write_output(format!(
@@ -1343,7 +1349,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Allocate result register
let result_name = self.next_temp_name();
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp)?;
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp, None)?;
let result_reg = self.resolve_register(&result_loc)?;
// Emit instruction: op result lhs rhs
@@ -1351,10 +1357,10 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Clean up operand temps
if let Some(name) = lhs_cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
if let Some(name) = rhs_cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
Ok(CompilationResult {
@@ -1373,14 +1379,14 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
let (inner_str, cleanup) = self.compile_operand(*inner, scope)?;
let result_name = self.next_temp_name();
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp)?;
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp, None)?;
let result_reg = self.resolve_register(&result_loc)?;
// seq rX rY 0 => if rY == 0 set rX = 1 else rX = 0
self.write_output(format!("seq {result_reg} {inner_str} 0"))?;
if let Some(name) = cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
Ok(CompilationResult {
@@ -1408,7 +1414,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Allocate result register
let result_name = self.next_temp_name();
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp)?;
let result_loc = scope.add_variable(&result_name, LocationRequest::Temp, None)?;
let result_reg = self.resolve_register(&result_loc)?;
// Emit instruction: op result lhs rhs
@@ -1416,10 +1422,10 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// Clean up operand temps
if let Some(name) = lhs_cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
if let Some(name) = rhs_cleanup {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
Ok(CompilationResult {
@@ -1478,7 +1484,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
if let Some(comp_res) = result
&& let Some(name) = comp_res.temp_name
{
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
Ok(())
}) {
@@ -1511,49 +1517,51 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
};
match expr.node {
Expression::Variable(var_name) => match scope.get_location_of(&var_name.node) {
Ok(loc) => match loc {
VariableLocation::Temporary(reg) | VariableLocation::Persistant(reg) => {
self.write_output(format!(
"move r{} r{reg} {}",
VariableScope::RETURN_REGISTER,
debug!(self, "#returnValue")
))?;
}
VariableLocation::Constant(lit) => {
let str = extract_literal(lit, false)?;
self.write_output(format!(
"move r{} {str} {}",
VariableScope::RETURN_REGISTER,
debug!(self, "#returnValue")
))?
}
VariableLocation::Stack(offset) => {
self.write_output(format!(
"sub r{} sp {offset}",
VariableScope::TEMP_STACK_REGISTER
))?;
self.write_output(format!(
"get r{} db r{}",
VariableScope::RETURN_REGISTER,
VariableScope::TEMP_STACK_REGISTER
))?;
}
VariableLocation::Device(_) => {
return Err(Error::Unknown(
"You can not return a device from a function.".into(),
Some(var_name.span),
Expression::Variable(var_name) => {
match scope.get_location_of(&var_name.node, Some(var_name.span)) {
Ok(loc) => match loc {
VariableLocation::Temporary(reg) | VariableLocation::Persistant(reg) => {
self.write_output(format!(
"move r{} r{reg} {}",
VariableScope::RETURN_REGISTER,
debug!(self, "#returnValue")
))?;
}
VariableLocation::Constant(lit) => {
let str = extract_literal(lit, false)?;
self.write_output(format!(
"move r{} {str} {}",
VariableScope::RETURN_REGISTER,
debug!(self, "#returnValue")
))?
}
VariableLocation::Stack(offset) => {
self.write_output(format!(
"sub r{} sp {offset}",
VariableScope::TEMP_STACK_REGISTER
))?;
self.write_output(format!(
"get r{} db r{}",
VariableScope::RETURN_REGISTER,
VariableScope::TEMP_STACK_REGISTER
))?;
}
VariableLocation::Device(_) => {
return Err(Error::Unknown(
"You can not return a device from a function.".into(),
Some(var_name.span),
));
}
},
Err(_) => {
self.errors.push(Error::UnknownIdentifier(
var_name.node.clone(),
var_name.span,
));
// Proceed with dummy
}
},
Err(_) => {
self.errors.push(Error::UnknownIdentifier(
var_name.node.clone(),
var_name.span,
));
// Proceed with dummy
}
},
}
Expression::Literal(spanned_lit) => match spanned_lit.node {
Literal::Number(num) => {
self.emit_variable_assignment(
@@ -1581,7 +1589,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
result_reg
))?;
if let Some(name) = result.temp_name {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
}
Expression::Logical(log_expr) => {
@@ -1593,7 +1601,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
result_reg
))?;
if let Some(name) = result.temp_name {
scope.free_temp(name)?;
scope.free_temp(name, None)?;
}
}
Expression::MemberAccess(access) => {
@@ -1609,7 +1617,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
let reg = self.resolve_register(&res.location)?;
self.write_output(format!("move r{} {}", VariableScope::RETURN_REGISTER, reg))?;
if let Some(temp) = res.temp_name {
scope.free_temp(temp)?;
scope.free_temp(temp, None)?;
}
}
}
@@ -1636,7 +1644,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
($($to_clean:expr),*) => {
$(
if let Some(to_clean) = $to_clean {
scope.free_temp(to_clean)?;
scope.free_temp(to_clean, None)?;
}
)*
};
@@ -1884,6 +1892,200 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
}
}
fn expression_syscall_math<'v>(
&mut self,
expr: Math,
scope: &mut VariableScope<'v>,
) -> Result<Option<CompilationResult>, Error> {
macro_rules! cleanup {
($($to_clean:expr),*) => {
$(
if let Some(to_clean) = $to_clean {
scope.free_temp(to_clean, None)?;
}
)*
};
}
match expr {
Math::Acos(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("acos r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Asin(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("asin r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Atan(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("atan r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Atan2(expr1, expr2) => {
let (var1, var1_cleanup) = self.compile_operand(*expr1, scope)?;
let (var2, var2_cleanup) = self.compile_operand(*expr2, scope)?;
self.write_output(format!(
"atan2 r{} {} {}",
VariableScope::RETURN_REGISTER,
var1,
var2
))?;
cleanup!(var1_cleanup, var2_cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Abs(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("abs r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Ceil(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("ceil r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Cos(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("cos r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Floor(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("floor r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Log(expr) => {
let (var, cleanup) = self.compile_operand(*expr, scope)?;
self.write_output(format!("log r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(cleanup);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Max(expr1, expr2) => {
let (var1, clean1) = self.compile_operand(*expr1, scope)?;
let (var2, clean2) = self.compile_operand(*expr2, scope)?;
self.write_output(format!(
"max r{} {} {}",
VariableScope::RETURN_REGISTER,
var1,
var2
))?;
cleanup!(clean1, clean2);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Min(expr1, expr2) => {
let (var1, clean1) = self.compile_operand(*expr1, scope)?;
let (var2, clean2) = self.compile_operand(*expr2, scope)?;
self.write_output(format!(
"min r{} {} {}",
VariableScope::RETURN_REGISTER,
var1,
var2
))?;
cleanup!(clean1, clean2);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Rand => {
self.write_output(format!("rand r{}", VariableScope::RETURN_REGISTER))?;
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Sin(expr) => {
let (var, clean) = self.compile_operand(*expr, scope)?;
self.write_output(format!("sin r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(clean);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Sqrt(expr) => {
let (var, clean) = self.compile_operand(*expr, scope)?;
self.write_output(format!("sqrt r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(clean);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Tan(expr) => {
let (var, clean) = self.compile_operand(*expr, scope)?;
self.write_output(format!("tan r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(clean);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
Math::Trunc(expr) => {
let (var, clean) = self.compile_operand(*expr, scope)?;
self.write_output(format!("trunc r{} {}", VariableScope::RETURN_REGISTER, var))?;
cleanup!(clean);
Ok(Some(CompilationResult {
location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
temp_name: None,
}))
}
}
}
/// Compile a function declaration.
/// Calees are responsible for backing up any registers they wish to use.
fn expression_function<'v>(
@@ -1926,7 +2128,11 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
.rev()
.take(VariableScope::PERSIST_REGISTER_COUNT as usize)
{
let loc = block_scope.add_variable(var_name.node.clone(), LocationRequest::Persist)?;
let loc = block_scope.add_variable(
var_name.node.clone(),
LocationRequest::Persist,
Some(var_name.span),
)?;
// we don't need to imcrement the stack offset as it's already on the stack from the
// previous scope
@@ -1959,11 +2165,19 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
// anything as they already exist on the stack, but we DO need to let our block_scope be
// aware that the variables exist on the stack (left to right)
for var_name in arguments.iter().take(arguments.len() - saved_variables) {
block_scope.add_variable(var_name.node.clone(), LocationRequest::Stack)?;
block_scope.add_variable(
var_name.node.clone(),
LocationRequest::Stack,
Some(var_name.span),
)?;
}
self.write_output("push ra")?;
block_scope.add_variable(format!("{}_ra", name.node), LocationRequest::Stack)?;
block_scope.add_variable(
format!("{}_ra", name.node),
LocationRequest::Stack,
Some(name.span),
)?;
for expr in body.0 {
match expr.node {
@@ -1976,7 +2190,7 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
if let Some(comp_res) = result
&& let Some(name) = comp_res.temp_name
{
block_scope.free_temp(name)?;
block_scope.free_temp(name, None)?;
}
Ok(())
}) {
@@ -1987,7 +2201,8 @@ impl<'a, W: std::io::Write> Compiler<'a, W> {
}
// Get the saved return address and save it back into `ra`
let ra_res = block_scope.get_location_of(format!("{}_ra", name.node));
let ra_res = block_scope.get_location_of(format!("{}_ra", name.node), Some(name.span));
let ra_stack_offset = match ra_res {
Ok(VariableLocation::Stack(offset)) => offset,
_ => {

55
rust_compiler/libs/compiler/src/variable_manager.rs
View File

@@ -3,7 +3,8 @@
// r1 - r7 : Temporary Variables
// r8 - r14 : Persistant Variables
use parser::tree_node::Literal;
use lsp_types::{Diagnostic, DiagnosticSeverity};
use parser::tree_node::{Literal, Span};
use quick_error::quick_error;
use std::collections::{HashMap, VecDeque};
@@ -13,18 +14,33 @@ const PERSIST: [u8; 7] = [8, 9, 10, 11, 12, 13, 14];
quick_error! {
#[derive(Debug)]
pub enum Error {
DuplicateVariable(var: String) {
DuplicateVariable(var: String, span: Option<Span>) {
display("{var} already exists.")
}
UnknownVariable(var: String) {
UnknownVariable(var: String, span: Option<Span>) {
display("{var} does not exist.")
}
Unknown(reason: String) {
Unknown(reason: String, span: Option<Span>) {
display("{reason}")
}
}
}
impl From<Error> for lsp_types::Diagnostic {
fn from(value: Error) -> Self {
match value {
Error::DuplicateVariable(_, span)
| Error::UnknownVariable(_, span)
| Error::Unknown(_, span) => Diagnostic {
range: span.map(lsp_types::Range::from).unwrap_or_default(),
severity: Some(DiagnosticSeverity::ERROR),
message: value.to_string(),
..Default::default()
},
}
}
}
/// A request to store a variable at a specific register type
pub enum LocationRequest {
#[allow(dead_code)]
@@ -112,10 +128,11 @@ impl<'a> VariableScope<'a> {
&mut self,
var_name: impl Into<String>,
location: LocationRequest,
span: Option<Span>,
) -> Result<VariableLocation, Error> {
let var_name = var_name.into();
if self.var_lookup_table.contains_key(var_name.as_str()) {
return Err(Error::DuplicateVariable(var_name));
return Err(Error::DuplicateVariable(var_name, span));
}
let var_location = match location {
LocationRequest::Temp => {
@@ -151,10 +168,11 @@ impl<'a> VariableScope<'a> {
&mut self,
var_name: impl Into<String>,
value: Literal,
span: Option<Span>,
) -> Result<VariableLocation, Error> {
let var_name = var_name.into();
if self.var_lookup_table.contains_key(&var_name) {
return Err(Error::DuplicateVariable(var_name));
return Err(Error::DuplicateVariable(var_name, span));
}
let new_value = VariableLocation::Constant(value);
@@ -163,7 +181,11 @@ impl<'a> VariableScope<'a> {
Ok(new_value)
}
pub fn get_location_of(&self, var_name: impl Into<String>) -> Result<VariableLocation, Error> {
pub fn get_location_of(
&self,
var_name: impl Into<String>,
span: Option<Span>,
) -> Result<VariableLocation, Error> {
let var_name = var_name.into();
// 1. Check this scope
@@ -180,7 +202,7 @@ impl<'a> VariableScope<'a> {
// 2. Recursively check parent
if let Some(parent) = self.parent {
let loc = parent.get_location_of(var_name)?;
let loc = parent.get_location_of(var_name, span)?;
if let VariableLocation::Stack(parent_offset) = loc {
return Ok(VariableLocation::Stack(parent_offset + self.stack_offset));
@@ -188,7 +210,7 @@ impl<'a> VariableScope<'a> {
return Ok(loc);
}
Err(Error::UnknownVariable(var_name))
Err(Error::UnknownVariable(var_name, span))
}
pub fn has_parent(&self) -> bool {
@@ -196,10 +218,14 @@ impl<'a> VariableScope<'a> {
}
#[allow(dead_code)]
pub fn free_temp(&mut self, var_name: impl Into<String>) -> Result<(), Error> {
pub fn free_temp(
&mut self,
var_name: impl Into<String>,
span: Option<Span>,
) -> Result<(), Error> {
let var_name = var_name.into();
let Some(location) = self.var_lookup_table.remove(var_name.as_str()) else {
return Err(Error::UnknownVariable(var_name));
return Err(Error::UnknownVariable(var_name, span));
};
match location {
@@ -207,9 +233,10 @@ impl<'a> VariableScope<'a> {
self.temporary_vars.push_back(t);
}
VariableLocation::Persistant(_) => {
return Err(Error::UnknownVariable(String::from(
"Attempted to free a `let` variable.",
)));
return Err(Error::UnknownVariable(
String::from("Attempted to free a `let` variable."),
span,
));
}
_ => {}
};

131
rust_compiler/libs/parser/src/lib.rs
View File

@@ -4,7 +4,7 @@ mod test;
pub mod sys_call;
pub mod tree_node;
use crate::sys_call::System;
use crate::sys_call::{Math, System};
use quick_error::quick_error;
use std::io::SeekFrom;
use sys_call::SysCall;
@@ -1349,11 +1349,24 @@ impl<'a> Parser<'a> {
}
fn literal(&mut self) -> Result<Literal, Error> {
let current_token = self.current_token.as_ref().ok_or(Error::UnexpectedEOF)?;
let current_token = self.current_token.clone().ok_or(Error::UnexpectedEOF)?;
let literal = match current_token.token_type {
TokenType::Number(num) => Literal::Number(num),
TokenType::String(ref string) => Literal::String(string.clone()),
TokenType::Boolean(boolean) => Literal::Boolean(boolean),
TokenType::Symbol(Symbol::Minus) => match self.get_next()? {
Some(Token {
token_type: TokenType::Number(num),
..
}) => Literal::Number(-*num),
Some(wrong_token) => {
return Err(Error::UnexpectedToken(
Self::token_to_span(wrong_token),
wrong_token.clone(),
));
}
None => return Err(Error::UnexpectedEOF),
},
_ => {
return Err(Error::UnexpectedToken(
self.current_span(),
@@ -1636,6 +1649,7 @@ impl<'a> Parser<'a> {
let invocation = self.invocation()?;
match invocation.name.node.as_str() {
// System SysCalls
"yield" => {
check_length(self, &invocation.arguments, 0)?;
Ok(SysCall::System(sys_call::System::Yield))
@@ -1809,6 +1823,119 @@ impl<'a> Parser<'a> {
expr,
)))
}
// Math SysCalls
"acos" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let tmp = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Acos(boxed!(tmp))))
}
"asin" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let tmp = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Asin(boxed!(tmp))))
}
"atan" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let expr = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Atan(boxed!(expr))))
}
"atan2" => {
check_length(self, &invocation.arguments, 2)?;
let mut args = invocation.arguments.into_iter();
let arg1 = args.next().ok_or(Error::UnexpectedEOF)?;
let arg2 = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Atan2(boxed!(arg1), boxed!(arg2))))
}
"abs" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let expr = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Abs(boxed!(expr))))
}
"ceil" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Ceil(boxed!(arg))))
}
"cos" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Cos(boxed!(arg))))
}
"floor" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Floor(boxed!(arg))))
}
"log" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Log(boxed!(arg))))
}
"max" => {
check_length(self, &invocation.arguments, 2)?;
let mut args = invocation.arguments.into_iter();
let arg1 = args.next().ok_or(Error::UnexpectedEOF)?;
let arg2 = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Max(boxed!(arg1), boxed!(arg2))))
}
"min" => {
check_length(self, &invocation.arguments, 2)?;
let mut args = invocation.arguments.into_iter();
let arg1 = args.next().ok_or(Error::UnexpectedEOF)?;
let arg2 = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Min(boxed!(arg1), boxed!(arg2))))
}
"rand" => {
check_length(self, &invocation.arguments, 0)?;
Ok(SysCall::Math(Math::Rand))
}
"sin" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Sin(boxed!(arg))))
}
"sqrt" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Sqrt(boxed!(arg))))
}
"tan" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Tan(boxed!(arg))))
}
"trunc" => {
check_length(self, &invocation.arguments, 1)?;
let mut args = invocation.arguments.into_iter();
let arg = args.next().ok_or(Error::UnexpectedEOF)?;
Ok(SysCall::Math(Math::Trunc(boxed!(arg))))
}
_ => Err(Error::UnsupportedKeyword(
self.current_span(),
self.current_token.clone().ok_or(Error::UnexpectedEOF)?,

31
rust_compiler/libs/parser/src/sys_call.rs
View File

@@ -10,67 +10,67 @@ documented! {
/// `acos r? a(r?|num)`
/// ## Slang
/// `(number|var).acos();`
Acos(LiteralOrVariable),
Acos(Box<Spanned<Expression>>),
/// Returns the angle in radians whose sine is the specified number.
/// ## IC10
/// `asin r? a(r?|num)`
/// ## Slang
/// `(number|var).asin();`
Asin(LiteralOrVariable),
Asin(Box<Spanned<Expression>>),
/// Returns the angle in radians whose tangent is the specified number.
/// ## IC10
/// `atan r? a(r?|num)`
/// ## Slang
/// `(number|var).atan();`
Atan(LiteralOrVariable),
Atan(Box<Spanned<Expression>>),
/// Returns the angle in radians whose tangent is the quotient of the specified numbers.
/// ## IC10
/// `atan2 r? a(r?|num) b(r?|num)`
/// ## Slang
/// `(number|var).atan2((number|var));`
Atan2(LiteralOrVariable, LiteralOrVariable),
Atan2(Box<Spanned<Expression>>, Box<Spanned<Expression>>),
/// Gets the absolute value of a number.
/// ## IC10
/// `abs r? a(r?|num)`
/// ## Slang
/// `(number|var).abs();`
Abs(LiteralOrVariable),
Abs(Box<Spanned<Expression>>),
/// Rounds a number up to the nearest whole number.
/// ## IC10
/// `ceil r? a(r?|num)`
/// ## Slang
/// `(number|var).ceil();`
Ceil(LiteralOrVariable),
Ceil(Box<Spanned<Expression>>),
/// Returns the cosine of the specified angle in radians.
/// ## IC10
/// `cos r? a(r?|num)`
/// ## Slang
/// `(number|var).cos();`
Cos(LiteralOrVariable),
Cos(Box<Spanned<Expression>>),
/// Rounds a number down to the nearest whole number.
/// ## IC10
/// `floor r? a(r?|num)`
/// ## Slang
/// `(number|var).floor();`
Floor(LiteralOrVariable),
Floor(Box<Spanned<Expression>>),
/// Computes the natural logarithm of a number.
/// ## IC10
/// `log r? a(r?|num)`
/// ## Slang
/// `(number|var).log();`
Log(LiteralOrVariable),
Log(Box<Spanned<Expression>>),
/// Computes the maximum of two numbers.
/// ## IC10
/// `max r? a(r?|num) b(r?|num)`
/// ## Slang
/// `(number|var).max((number|var));`
Max(LiteralOrVariable, LiteralOrVariable),
Max(Box<Spanned<Expression>>, Box<Spanned<Expression>>),
/// Computes the minimum of two numbers.
/// ## IC10
/// `min r? a(r?|num) b(r?|num)`
/// ## Slang
/// `(number|var).min((number|var));`
Min(LiteralOrVariable, LiteralOrVariable),
Min(Box<Spanned<Expression>>, Box<Spanned<Expression>>),
/// Gets a random number between 0 and 1.
/// ## IC10
/// `rand r?`
@@ -82,25 +82,25 @@ documented! {
/// `sin r? a(r?|num)`
/// ## Slang
/// `(number|var).sin();`
Sin(LiteralOrVariable),
Sin(Box<Spanned<Expression>>),
/// Computes the square root of a number.
/// ## IC10
/// `sqrt r? a(r?|num)`
/// ## Slang
/// `(number|var).sqrt();`
Sqrt(LiteralOrVariable),
Sqrt(Box<Spanned<Expression>>),
/// Returns the tangent of the specified angle in radians.
/// ## IC10
/// `tan r? a(r?|num)`
/// ## Slang
/// `(number|var).tan();`
Tan(LiteralOrVariable),
Tan(Box<Spanned<Expression>>),
/// Truncates a number by removing the decimal portion.
/// ## IC10
/// `trunc r? a(r?|num)`
/// ## Slang
/// `(number|var).trunc();`
Trunc(LiteralOrVariable),
Trunc(Box<Spanned<Expression>>),
}
}
@@ -231,6 +231,7 @@ impl std::fmt::Display for System {
}
}
#[allow(clippy::large_enum_variant)]
#[derive(Debug, PartialEq, Eq)]
/// This represents built in functions that cannot be overwritten, but can be invoked by the user as functions.
pub enum SysCall {

9
rust_compiler/libs/parser/src/test/mod.rs
View File

@@ -151,3 +151,12 @@ fn test_const_hash_expression() -> Result<()> {
assert_eq!("(const i = hash(\"item\"))", expr.to_string());
Ok(())
}
#[test]
fn test_negative_literal_const() -> Result<()> {
let expr = parser!(r#"const i = -123"#).parse()?.unwrap();
assert_eq!("(const i = -123)", expr.to_string());
Ok(())
}