Merge pull request 'Added support for CRLF windows line endings' (#11) from 41-support-windows-crlf-line-endings into master

Reviewed-on: #11

.gitea/workflows/build.yml

@@ -4,6 +4,7 @@ name: CI/CD Pipeline
 on:
   push:
     branches: ["master"]
+    tags: ["*.*.*"]
   pull_request:
     branches: ["master"]
 
@@ -57,6 +58,10 @@ jobs:
             slang-builder \
             ./build.sh
 
+      - name: Zip Workshop Folder
+        run: |
+          zip -r release/workshop.zip release/workshop/
+
       # 3. Fix Permissions
       # Docker writes files as root. We need to own them to upload them.
       - name: Fix Permissions
@@ -65,7 +70,36 @@ jobs:
 
       # 4. Upload to GitHub
       - name: Upload Release Artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: StationeersSlang-Release
           path: release/
+
+  release:
+    needs: build
+    runs-on: self-hosted
+    # ONLY run this job if we pushed a tag (e.g., v1.0.1)
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+
+      # We download the artifact from the previous 'build' job
+      - name: Download Build Artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: StationeersSlang-Release
+          path: ./release-files
+
+      - name: Create Gitea Release
+        uses: https://gitea.com/actions/gitea-release-action@v1
+        with:
+          files: |
+            ./release-files/workshop.zip
+            ./release-files/slang
+            ./release-files/slang.exe
+          name: ${{ github.ref_name }}
+          tag_name: ${{ github.ref_name }}
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Changelog.md

@@ -1,5 +1,84 @@
 # Changelog
 
+[0.4.7]
+
+- Added support for Windows CRLF endings
+
+[0.4.6]
+
+- Fixed bug in compiler where you were unable to assign a `const` value to
+  a `let` variable
+
+[0.4.5]
+
+- Fixed issue where after clicking "Cancel" on the IC10 Editor, the side-by-side
+  IC10 output would no longer update with highlighting or code updates.
+- Added ability to live-reload the mod while developing using the `ScriptEngine`
+  mod from BepInEx
+  - This required adding in cleanup code to cleanup references to the Rust DLL
+    before destroying the mod instance.
+- Added BepInEx debug logging. This will ONLY show if you have debug logs
+  enabled in the BepInEx configuration file.
+
+[0.4.4]
+
+- Added Stationpedia docs back after removing all harmony patches from the mod
+
+[0.4.3]
+
+- Removed references to the `Mod` class from SLP. This was the root of the multiplayer
+  connectivity issues. Multiplayer should now work with Slang installed.
+
+[0.4.2]
+
+- Removed all harmony patches as most functionality as been added into the
+  `IC10 Editor` mod
+- IC10 runtime errors will have been reverted back to showing as IC10 line
+  numbers instead of Slang line numbers.
+  - The IC10 line should be easily mapped to a Slang line via the side-by-side
+    IC10 compilation view.
+
+[0.4.1]
+
+- Update syscalls for `loadSlot` and `setSlot` to support expressions instead of
+  just variables for the slot index
+- Moved the main repository from GitHub to a self-hosted Gitea
+  - Restructured workflow files to support this change
+  - GitHub will still remain as a mirrored repository of the new
+    Gitea instance.
+  - This is in response to the new upcoming changes to the pricing model
+    for self-hosted GitHub action runners.
+
+[0.4.0]
+
+- First pass getting compiled IC10 to output along side the Slang source code
+  - IC10 side is currently not scrollable, and text might be cut off from the bottom,
+    requiring newlines to be added to the bottom of the Slang source if needed
+
+[0.3.4]
+
+- Added support for `loadReagent`, which maps to the `lr` IC10 instruction
+  - Shorthand is `lr`
+  - Longform is `loadReagent`
+- Update various Rust dependencies
+- Added more optimizations, prioritizing `pop` instead of `get` when available
+  when backing up / restoring registers for function invocations. This should
+  save approximately 2 lines per backed up register
+
+[0.3.3]
+
+- Fixed bug where negative temperature literals were converted to Kelvin
+  first before applying the negative
+
+[0.3.2]
+
+- Fixed stack overflow due to incorrect optimization of 'leaf' functions
+
+[0.3.1]
+
+- Fixed possible `KeyNotFoundException` in C# code due to invalid
+  dictionary access when an IC housing has an error
+
 [0.3.0]
 
 - Implemented a multi-pass optimizer

ModData/About/About.xml

@@ -2,11 +2,11 @@
 <ModMetadata xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <Name>Slang</Name>
   <Author>JoeDiertay</Author>
-  <Version>0.3.0</Version>
+  <Version>0.4.7</Version>
   <Description>
 [h1]Slang: High-Level Programming for Stationeers[/h1]
 
-Stop writing assembly. Start writing code.
+Iterate faster. Stop writing assembly. Start writing code.
 
 Slang (Stationeers Language) brings modern programming to Stationeers. It allows you to write scripts using a familiar C-style syntax (variables, functions, if/else, loops) directly in the in-game editor. When you hit confirm, Slang compiles your code into IC10 instantly.
 
@@ -15,7 +15,7 @@ Slang (Stationeers Language) brings modern programming to Stationeers. It allows
 [h2]Features[/h2]
 [list]
 [*] [b]In-Game Compilation:[/b] No external tools needed. Write Slang directly in the IC editor.
-[*] [b]No More Register Juggling:[/b] Define variables with let (e.g., let temp = 300). The compiler manages r0-r15 for you.
+[*] [b]No More Register Juggling:[/b] Define variables with let (e.g., let temp = 200c). The compiler manages r0-r15 for you.
 [*] [b]Control Flow:[/b] Write readable logic with if, else, while, loop, break, and continue.
 [*] [b]Functions:[/b] Create reusable code blocks with arguments.
 [*] [b]Smart Editor:[/b] Get real-time syntax highlighting and error checking (red text) as you type.
@@ -23,6 +23,8 @@ Slang (Stationeers Language) brings modern programming to Stationeers. It allows
 [*] [b]Optimizations:[/b] Features like Constant Folding calculate math at compile time to save instructions.
 [*] [b]Device Aliasing:[/b] Simple mapping: device sensor = "d0".
 [*] [b]Temperature Literals:[/b] Don't worry about converting Celsius to Kelvin anymore. Define your temperatures as whatever you want and append the proper suffix at the end (ex. 20c, 68f, 293.15k)
+[*] [b]Side-by-side IC10 output:[/b] Preview the compiled IC10 alongside the Slang source code. What you see is what you get.
+[*] [b]Compiler Optimizations:[/b] Slang now does its best to safely optimize the output IC10, removing labels, unnecessary moves, etc.
 [/list]
 
 [h2]Installation[/h2]
@@ -50,19 +52,14 @@ loop {
 
 [h2]Known Issues (Beta)[/h2]
 [list]
-[*] [b]Code Size:[/b] Compiled output is currently more verbose than hand-optimized assembly. Optimization passes are planned.
-[*] [b]Stack Access:[/b] Direct stack memory access is disabled to prevent conflicts with the compiler's internal memory management.
-[*] [b]Documentation:[/b] In-game tooltips for syscalls (like load, set) are WIP. Check the "Slang" entry in the Stationpedia (F1) for help.
-[*] [b]Debugging:[/b] Runtime errors currently point to the compiled IC10 line number, not your Slang source line. Source mapping is coming soon.
+[*] [b]Stack Access:[/b] Direct stack memory access is disabled to prevent conflicts with the compiler's internal memory management. A workaround is being planned.
+[*] [b]Documentation:[/b] In-game tooltips for syscalls (like load, set) are WIP. Check the "Slang" entry in the Stationpedia (F1) for help, or checkout [url=https://github.com/dbidwell94/stationeers_lang/blob/master/docs/getting-started.md]The Docs[/url] for guides on how to get started.
 [/list]
 
 [h2]Planned Features[/h2]
 [list]
-[*] Side-by-side view: Slang vs. Compiled IC10.
-[*] Compiler optimizations (dead code elimination, smarter register allocation).
 [*] Enhanced LSP features (Autocomplete, Go to Definition).
 [*] Full feature parity with all IC10 instructions.
-[*] Tutorials and beginner script examples.
 [/list]
 
 [h2]FAQ[/h2]
@@ -72,10 +69,18 @@ A: The Slang compiler is built in Rust for performance and reliability. It is co
 [b]Q: Is this compatible with my current save?[/b]
 A: Yes! Slang does not modify any existing IC10 code, it is only a compiler. As a matter of fact: if you wish to stop using Slang at any time, your compiled IC10 will still exist on the chip. However: Slang adds a comment at the bottom of your compiled IC10 which is a GZIP and base64 encoded version of your Slang source code. This might break line limits with Slang not installed. If you wish to no longer use Slang, I recommend you remove this comment from the source code after uninstalling Slang.
 
+[b]Q: Does this modify the in-game scripting language[/b]
+A: No! Slang compiles directly to IC10. Any valid Slang file will produce valid IC10. The goal of this mod is twofold:
+[list]
+[*] Allow experienced users to quickly iterate on their scripts to get back into base upgrades faster
+[*] Allow newcomers who already know C-style languages (JS/C#/Java/Rust/C/etc) to see how it maps to IC10 so they can get to understand IC10 better
+[/list]
+
 [h2]Useful Links[/h2]
 [url=https://github.com/dbidwell94/stationeers_lang]Source Code on GitHub[/url]
 [url=https://discord.gg/stationeers]Stationeers Official Discord[/url]
 [url=https://discord.gg/M4sCfYMacs]Stationeers Modding Discord[/url]
+[url=https://github.com/dbidwell94/stationeers_lang/blob/master/docs/getting-started.md]Getting Started Guide[/url]
   </Description>
   <ChangeLog xsi:nil="true" />
   <WorkshopHandle>3619985558</WorkshopHandle>
@@ -88,7 +93,7 @@ A: Yes! Slang does not modify any existing IC10 code, it is only a compiler. As
     <Tag>Quality of Life</Tag>
   </Tags>
   <DependsOn WorkshopHandle="3592775931" />
-  <OrderBefore WorkshopHandle="3592775931" />
+  <OrderAfter WorkshopHandle="3592775931" />
   <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 IC10 instantly.
@@ -118,5 +123,7 @@ A: Yes! Slang does not modify any existing IC10 code, it is only a compiler. As
         See: https://github.com/StationeersLaunchPad/StationeersLaunchPad
 
         Source Code: https://github.com/dbidwell94/stationeers_lang
+
+        Documentation: https://github.com/dbidwell94/stationeers_lang/blob/master/docs/getting-started.md
         ]]></InGameDescription>
 </ModMetadata>

README.md

@@ -1,30 +1,45 @@
-# Stationeers Language (slang)
+# Slang Language Documentation
 
-This is an ambitious attempt at creating:
+Slang is a high-level programming language that compiles to IC10 assembly for [Stationeers](https://store.steampowered.com/app/544550/Stationeers/).
+It provides a familiar C-like syntax while targeting the limited instruction set
+of in-game IC10.
 
-- A new programming language (slang)
-- A compiler to translate slang -> IC10
-- A mod to allow direct input of slang in the in-game script editor to
-  automatically compile to IC10 before running
+## Quick Links
 
-This project currently outputs 3 files:
+- [Getting Started](docs/getting-started.md) - Installation and first program
+- [Language Reference](docs/language-reference.md) - Complete syntax guide
+- [Built-in Functions](docs/builtins.md) - System calls and math functions
+- [Examples](docs/examples.md) - Real-world code samples
 
-- A Linux CLI
-- A Windows CLI
-- A Windows FFI dll
-  - Contains a single function: `compile_from_string`
+## Overview
 
-The aim of this project is to lower the amount of time it takes to code simple
-scripts in Stationeers so you can get back to engineering atmospherics or
-whatever you are working on. This project is NOT meant to fully replace IC10.
-Obviously hand-coded assembly written by an experienced programmer is more
-optimized and smaller than something that a C compiler will spit out. This is
-the same way. It WILL produce valid IC10, but for large complicated projects it
-might produce over the allowed limit of lines the in-game editor supports.
+Slang aims to reduce the time spent writing IC10 assembly by providing:
 
-Current Unknowns
+- **Familiar syntax** - C-like declarations, control flow, and expressions
+- **Device abstraction** - Named device bindings with property access
+- **Automatic register allocation** - No manual register management
+- **Built-in functions** - Math operations and device I/O as function calls
+- **Temperature literals** - Native support for Celsius, Fahrenheit, and Kelvin
 
-- Should I support a configurable script line length in-game to allow larger
-  scripts to be saved?
-- Should compilation be "behind the scenes" (in game editor will ALWAYS be what
-  you put in. IC10 will be IC10, slang will be slang)
+## Example
+
+```rust
+device gasSensor = "d0";
+device airCon = "d1";
+
+const TARGET_TEMP = 20c;
+
+loop {
+    yield();
+    airCon.On = gasSensor.Temperature > TARGET_TEMP;
+}
+```
+
+This compiles to IC10 that monitors temperature and controls an air
+conditioner.
+
+## Project Status
+
+Slang is under active development. It may produce suboptimal code for complex programs.
+It is not a replacement for IC10, for performance-critical or large scripts,
+hand-written IC10 may still be preferred.

csharp_mod/Formatter.cs

@@ -9,10 +9,33 @@ using StationeersIC10Editor;
 
 public class SlangFormatter : ICodeFormatter
 {
+    public const string SLANG_SRC = "SLANG_SRC";
     private CancellationTokenSource? _lspCancellationToken;
     private object _tokenLock = new();
 
-    // VS Code Dark Theme Palette
+    protected Editor? __Ic10Editor = null;
+
+    protected Editor Ic10Editor
+    {
+        get
+        {
+            if (__Ic10Editor == null)
+            {
+                var tab = Editor.ParentTab;
+                tab.ClearExtraEditors();
+                __Ic10Editor = new Editor(Editor.KeyHandler);
+                Ic10Editor.IsReadOnly = true;
+                tab.AddEditor(__Ic10Editor);
+            }
+
+            return __Ic10Editor;
+        }
+    }
+
+    private string ic10CompilationResult = "";
+    private List<SourceMapEntry> ic10SourceMap = new();
+
+    #region Colors
     public static readonly uint ColorControl = ColorFromHTML("#C586C0"); // Pink (if, return, loop)
     public static readonly uint ColorDeclaration = ColorFromHTML("#569CD6"); // Blue (let, device, fn)
     public static readonly uint ColorFunction = ColorFromHTML("#DCDCAA"); // Yellow (syscalls)
@@ -21,10 +44,8 @@ public class SlangFormatter : ICodeFormatter
     public static readonly uint ColorBoolean = ColorFromHTML("#569CD6"); // Blue (true/false)
     public static readonly uint ColorIdentifier = ColorFromHTML("#9CDCFE"); // Light Blue (variables)
     public static new readonly uint ColorDefault = ColorFromHTML("#D4D4D4"); // White (punctuation ; { } )
-
-    // Operators are often the same color as default text in VS Code Dark,
-    // but having a separate definition lets you tweak it (e.g. make them slightly darker or distinct)
     public static readonly uint ColorOperator = ColorFromHTML("#D4D4D4");
+    #endregion
 
     private HashSet<uint> _linesWithErrors = new();
     private int _lastLineCount = -1;
@@ -33,6 +54,7 @@ public class SlangFormatter : ICodeFormatter
         : base()
     {
         OnCodeChanged += HandleCodeChanged;
+        OnCaretMoved += UpdateIc10Formatter;
     }
 
     public static double MatchingScore(string input)
@@ -41,6 +63,11 @@ public class SlangFormatter : ICodeFormatter
         if (string.IsNullOrWhiteSpace(input))
             return 0d;
 
+        if (input.Contains(SLANG_SRC))
+        {
+            return 1.0;
+        }
+
         // Run the compiler to get diagnostics
         var diagnostics = Marshal.DiagnoseSource(input);
 
@@ -67,7 +94,28 @@ public class SlangFormatter : ICodeFormatter
 
     public override string Compile()
     {
-        return this.Lines.RawText;
+        if (!Marshal.CompileFromString(RawText, out var compilationResult, out var sourceMap))
+        {
+            return "# Compilation Error";
+        }
+
+        return compilationResult + $"\n{EncodeSource(RawText, SLANG_SRC)}";
+    }
+
+    public override void ResetCode(string code)
+    {
+        // for compatibility, we need to check for GlobalCode.SLANG_SRC
+        // `#SLANG_SRC:<code>`
+        // and replace with `# SLANG_SRC: <code>`
+        if (code.Contains(GlobalCode.SLANG_SRC))
+        {
+            code = code.Replace(GlobalCode.SLANG_SRC, $"# {SLANG_SRC}: ");
+        }
+        if (code.Contains(SLANG_SRC))
+        {
+            code = ExtractEncodedSource(code, SLANG_SRC);
+        }
+        base.ResetCode(code);
     }
 
     public override StyledLine ParseLine(string line)
@@ -86,6 +134,10 @@ public class SlangFormatter : ICodeFormatter
         return styledLine;
     }
 
+    /// <summary>
+    /// This handles calling the `HandleLsp` function by creating a new `CancellationToken` and
+    /// cancelling the current call if applicable.
+    /// </summary>
     private void HandleCodeChanged()
     {
         CancellationToken token;
@@ -101,6 +153,11 @@ public class SlangFormatter : ICodeFormatter
         _ = HandleLsp(inputSrc, token);
     }
 
+    /// <summary>
+    /// Takes a copy of the current source code and sends it to the Rust compiler in a background thread
+    /// to get diagnostic data. This also handles getting a compilation response of optimized IC10 for the
+    /// side-by-side IC10Editor to show with sourcemap highlighting.
+    /// </summary>
     private async Task HandleLsp(string inputSrc, CancellationToken cancellationToken)
     {
         try
@@ -126,6 +183,29 @@ public class SlangFormatter : ICodeFormatter
             );
 
             ApplyDiagnostics(dict);
+
+            // If we have valid code, update the IC10 output
+            if (dict.Count > 0)
+            {
+                return;
+            }
+
+            var (compilationSuccess, compiled, sourceMap) = await Task.Run(() =>
+            {
+                var successful = Marshal.CompileFromString(
+                    inputSrc,
+                    out var compiled,
+                    out var sourceMap
+                );
+                return (successful, compiled, sourceMap);
+            });
+
+            if (compilationSuccess)
+            {
+                ic10CompilationResult = compiled;
+                ic10SourceMap = sourceMap;
+                UpdateIc10Content(Ic10Editor);
+            }
         }
         catch (OperationCanceledException) { }
         catch (Exception ex)
@@ -134,7 +214,62 @@ public class SlangFormatter : ICodeFormatter
         }
     }
 
-    // This runs on the Main Thread
+    /// <summary>
+    /// Updates the underlying code in the IC10 Editor, after which will call `UpdateIc10Formatter` to
+    /// update highlighting of relavent fields.
+    /// </summary>
+    private void UpdateIc10Content(Editor editor)
+    {
+        editor.ResetCode(ic10CompilationResult);
+        UpdateIc10Formatter();
+    }
+
+    // This runs on the main thread. This function ONLY updates the highlighting of the IC10 code.
+    // If you need to update the code in the editor itself, you should use `UpdateIc10Content`.
+    private void UpdateIc10Formatter()
+    {
+        // Bail if our backing field is null. We don't want to set the field in this function. It
+        // runs way too much and we might not even have source code to use.
+        if (__Ic10Editor == null)
+            return;
+        var caretPos = Editor.CaretPos.Line;
+
+        // get the slang sourceMap at the current editor line
+        var lines = ic10SourceMap.FindAll(entry =>
+            entry.SlangSource.StartLine == caretPos || entry.SlangSource.EndLine == caretPos
+        );
+
+        Ic10Editor.ResetCode(ic10CompilationResult);
+
+        if (lines.Count() < 1)
+        {
+            Ic10Editor.Selection = new TextRange
+            {
+                End = new TextPosition { Col = 0, Line = 0 },
+                Start = new TextPosition { Col = 0, Line = 0 },
+            };
+            return;
+        }
+        // get the total range of the IC10 source for the selected Slang line
+        var max = lines.Max(line => line.Ic10Line);
+        var min = lines.Min(line => line.Ic10Line);
+
+        Ic10Editor.CaretPos = new TextPosition { Col = 0, Line = (int)max };
+
+        // highlight all the IC10 lines that are within the specified range
+        Ic10Editor.Selection.Start = new TextPosition { Col = 0, Line = (int)min };
+        Ic10Editor.Selection.End = new TextPosition
+        {
+            Col = Ic10Editor.Lines[(int)max].Text.Length,
+            Line = (int)max,
+        };
+    }
+
+    /// <summary>
+    /// Takes diagnostics from the Rust FFI compiler and applies it as semantic tokens to the
+    /// source in this editor.
+    /// This runs on the Main Thread
+    /// </summary>
     private void ApplyDiagnostics(Dictionary<uint, IGrouping<uint, Diagnostic>> dict)
     {
         HashSet<uint> linesToRefresh;

csharp_mod/GlobalCode.cs

@@ -1,30 +1,24 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
-using System.IO.Compression;
-using System.Text;
 
 namespace Slang;
 
 public static class GlobalCode
 {
-    public const string SLANG_REF = "#SLANG_REF:";
+    /// <summary>
+    /// This is the OLD way of handling saving / loading. This has been replaced with a native
+    /// save / load from IC10 Editor. However; this needs to remain for compatibility with
+    /// previous versions of code not compiled with 0.4.2 or later.
+    /// </summary>
     public const string SLANG_SRC = "#SLANG_SRC:";
 
-    // This is a Dictionary of ENCODED source code, compressed
-    // so that save file data is smaller
-    private static Dictionary<Guid, string> codeDict = new();
-
-    // This Dictionary stores the source maps for the given SLANG_REF, where
-    // the key is the IC10 line, and the value is a List of Slang ranges where that
-    // line would have come from
+    /// <summary>
+    /// This Dictionary stores the source maps for the given SLANG_REF, where
+    /// the key is the IC10 line, and the value is a List of Slang ranges where that
+    /// line would have come from
+    /// </summary>
     private static Dictionary<Guid, Dictionary<uint, List<Range>>> sourceMaps = new();
 
-    public static void ClearCache()
-    {
-        codeDict.Clear();
-    }
-
     public static void SetSourceMap(Guid reference, List<SourceMapEntry> sourceMapEntries)
     {
         var builtDictionary = new Dictionary<uint, List<Range>>();
@@ -56,6 +50,11 @@ public static class GlobalCode
             return false;
         }
 
+        if (!sourceMaps[reference].ContainsKey(icErrorLine))
+        {
+            return false;
+        }
+
         var foundRange = sourceMaps[reference][icErrorLine];
 
         if (foundRange is null)
@@ -67,81 +66,4 @@ public static class GlobalCode
         slangSpan = foundRange[0];
         return true;
     }
-
-    public static string GetSource(Guid reference)
-    {
-        if (!codeDict.ContainsKey(reference))
-        {
-            return string.Empty;
-        }
-
-        return DecodeSource(codeDict[reference]);
-    }
-
-    public static void SetSource(Guid reference, string source)
-    {
-        codeDict[reference] = EncodeSource(source);
-    }
-
-    public static string? GetEncoded(Guid reference)
-    {
-        if (!codeDict.ContainsKey(reference))
-            return null;
-
-        return codeDict[reference];
-    }
-
-    public static void SetEncoded(Guid reference, string encodedSource)
-    {
-        if (codeDict.ContainsKey(reference))
-        {
-            codeDict[reference] = encodedSource;
-        }
-        else
-        {
-            codeDict.Add(reference, encodedSource);
-        }
-    }
-
-    private static string EncodeSource(string source)
-    {
-        if (string.IsNullOrEmpty(source))
-        {
-            return "";
-        }
-
-        byte[] bytes = Encoding.UTF8.GetBytes(source);
-
-        using (var memoryStream = new MemoryStream())
-        {
-            using (var gzipStream = new GZipStream(memoryStream, CompressionMode.Compress))
-            {
-                gzipStream.Write(bytes, 0, bytes.Length);
-            }
-            return Convert.ToBase64String(memoryStream.ToArray());
-        }
-    }
-
-    private static string DecodeSource(string source)
-    {
-        if (string.IsNullOrEmpty(source))
-        {
-            return "";
-        }
-
-        byte[] compressedBytes = Convert.FromBase64String(source);
-
-        using (var memoryStream = new MemoryStream(compressedBytes))
-        {
-            using (var gzipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
-            {
-                using (var outputStream = new MemoryStream())
-                {
-                    gzipStream.CopyTo(outputStream);
-
-                    return Encoding.UTF8.GetString(outputStream.ToArray());
-                }
-            }
-        }
-    }
 }

csharp_mod/Marshal.cs

@@ -67,7 +67,9 @@ public static class Marshal
         try
         {
             _libraryHandle = LoadLibrary(ExtractNativeLibrary(Ffi.RustLib));
+            L.Debug("Rust DLL loaded successfully. Enjoy native speed compilations!");
             CodeFormatters.RegisterFormatter("Slang", typeof(SlangFormatter), true);
+
             return true;
         }
         catch (Exception ex)
@@ -91,8 +93,13 @@ public static class Marshal
 
         try
         {
-            FreeLibrary(_libraryHandle);
+            CodeFormatters.RegisterFormatter("Slang", typeof(PlainTextFormatter), true);
+            if (!FreeLibrary(_libraryHandle))
+            {
+                L.Warning("Unable to free Rust library");
+            }
             _libraryHandle = IntPtr.Zero;
+            L.Debug("Rust DLL library freed");
             return true;
         }
         catch (Exception ex)
@@ -191,9 +198,9 @@ public static class Marshal
 
         Assembly assembly = Assembly.GetExecutingAssembly();
 
-        using (Stream stream = assembly.GetManifestResourceStream(libName))
+        using (Stream resourceStream = assembly.GetManifestResourceStream(libName))
         {
-            if (stream == null)
+            if (resourceStream == null)
             {
                 L.Error(
                     $"{libName} not found. This means it was not embedded in the mod. Please contact the mod author!"
@@ -201,18 +208,85 @@ public static class Marshal
                 return "";
             }
 
+            // Check if file exists and contents are identical to avoid overwriting locked files
+            if (File.Exists(destinationPath))
+            {
+                try
+                {
+                    using (
+                        FileStream fileStream = new FileStream(
+                            destinationPath,
+                            FileMode.Open,
+                            FileAccess.Read,
+                            FileShare.ReadWrite
+                        )
+                    )
+                    {
+                        if (resourceStream.Length == fileStream.Length)
+                        {
+                            if (StreamsContentsAreEqual(resourceStream, fileStream))
+                            {
+                                L.Debug(
+                                    $"DLL {libName} already exists and matches. Skipping extraction."
+                                );
+                                return destinationPath;
+                            }
+                        }
+                    }
+                }
+                catch (IOException ex)
+                {
+                    L.Warning(
+                        $"Could not verify existing {libName}, attempting overwrite. {ex.Message}"
+                    );
+                }
+            }
+
+            resourceStream.Position = 0;
+
+            // Attempt to overwrite if missing or different
             try
             {
                 using (FileStream fileStream = new FileStream(destinationPath, FileMode.Create))
                 {
-                    stream.CopyTo(fileStream);
+                    resourceStream.CopyTo(fileStream);
                 }
                 return destinationPath;
             }
             catch (IOException e)
             {
-                L.Warning($"Could not overwrite {libName} (it might be in use): {e.Message}");
-                return "";
+                // If we fail here, the file is likely locked.
+                // However, if we are here, it means the file is DIFFERENT or we couldn't read it.
+                // As a fallback for live-reload, we can try returning the path anyway
+                // assuming the existing locked file might still work.
+                L.Warning(
+                    $"Could not overwrite {libName} (it might be in use): {e.Message}. Attempting to use existing file."
+                );
+                return destinationPath;
+            }
+        }
+    }
+
+    private static bool StreamsContentsAreEqual(Stream stream1, Stream stream2)
+    {
+        const int bufferSize = 4096;
+        byte[] buffer1 = new byte[bufferSize];
+        byte[] buffer2 = new byte[bufferSize];
+
+        while (true)
+        {
+            int count1 = stream1.Read(buffer1, 0, bufferSize);
+            int count2 = stream2.Read(buffer2, 0, bufferSize);
+
+            if (count1 != count2)
+                return false;
+            if (count1 == 0)
+                return true;
+
+            for (int i = 0; i < count1; i++)
+            {
+                if (buffer1[i] != buffer2[i])
+                    return false;
             }
         }
     }

csharp_mod/Patches.cs

@@ -1,355 +1,11 @@
 namespace Slang;
 
-using System;
-using System.Runtime.CompilerServices;
-using Assets.Scripts.Objects;
-using Assets.Scripts.Objects.Electrical;
-using Assets.Scripts.Objects.Motherboards;
 using Assets.Scripts.UI;
 using HarmonyLib;
 
-class LineErrorData
-{
-    public AsciiString SourceRef;
-    public uint IC10ErrorSource;
-    public string SlangErrorReference;
-    public Range SlangErrorSpan;
-
-    public LineErrorData(
-        AsciiString sourceRef,
-        uint ic10ErrorSource,
-        string slangErrorRef,
-        Range slangErrorSpan
-    )
-    {
-        this.SourceRef = sourceRef;
-        this.IC10ErrorSource = ic10ErrorSource;
-        this.SlangErrorReference = slangErrorRef;
-        this.SlangErrorSpan = slangErrorSpan;
-    }
-}
-
 [HarmonyPatch]
 public static class SlangPatches
 {
-    private static ProgrammableChipMotherboard? _currentlyEditingMotherboard;
-    private static AsciiString? _motherboardCachedCode;
-    private static Guid? _currentlyEditingGuid;
-
-    private static ConditionalWeakTable<ProgrammableChip, LineErrorData> _errorReferenceTable =
-        new();
-
-    [HarmonyPatch(
-        typeof(ProgrammableChipMotherboard),
-        nameof(ProgrammableChipMotherboard.InputFinished)
-    )]
-    [HarmonyPrefix]
-    public static void pgmb_InputFinished(ref string result)
-    {
-        _currentlyEditingMotherboard = null;
-        _motherboardCachedCode = null;
-        // guard to ensure we have valid IC10 before continuing
-        if (
-            !SlangPlugin.IsSlangSource(ref result)
-            || !Marshal.CompileFromString(result, out var compiled, out var sourceMap)
-            || string.IsNullOrEmpty(compiled)
-        )
-        {
-            return;
-        }
-
-        var thisRef = _currentlyEditingGuid ?? Guid.NewGuid();
-
-        // Ensure we cache this compiled code for later retreival.
-        GlobalCode.SetSource(thisRef, result);
-        GlobalCode.SetSourceMap(thisRef, sourceMap);
-
-        _currentlyEditingGuid = null;
-
-        // Append REF to the bottom
-        compiled += $"\n{GlobalCode.SLANG_REF}{thisRef}";
-        result = compiled;
-    }
-
-    [HarmonyPatch(typeof(ProgrammableChipMotherboard), nameof(ProgrammableChipMotherboard.OnEdit))]
-    [HarmonyPrefix]
-    public static void isc_OnEdit(ProgrammableChipMotherboard __instance)
-    {
-        _currentlyEditingMotherboard = __instance;
-        _motherboardCachedCode = __instance.GetSourceCode();
-        var sourceCode = System.Text.Encoding.UTF8.GetString(
-            System.Text.Encoding.ASCII.GetBytes(__instance.GetSourceCode())
-        );
-
-        if (string.IsNullOrEmpty(sourceCode))
-        {
-            return;
-        }
-
-        // Look for REF at the bottom
-        var tagIndex = sourceCode.LastIndexOf(GlobalCode.SLANG_REF);
-
-        if (tagIndex == -1)
-        {
-            // this is not slang managed code
-            return;
-        }
-
-        if (
-            !Guid.TryParse(
-                sourceCode.Substring(tagIndex + GlobalCode.SLANG_REF.Length).Trim(),
-                out Guid sourceRef
-            )
-        )
-        {
-            // not a valid Guid, not managed by slang
-            return;
-        }
-
-        _currentlyEditingGuid = sourceRef;
-        var slangSource = GlobalCode.GetSource(sourceRef);
-
-        if (string.IsNullOrEmpty(slangSource))
-        {
-            // Didn't find that source ref in the global code manager.
-            return;
-        }
-
-        __instance.SetSourceCode(slangSource);
-    }
-
-    private static void HandleSerialization(ref string sourceCode)
-    {
-        if (string.IsNullOrEmpty(sourceCode))
-            return;
-
-        // Check if the file ends with the Reference Tag
-        var tagIndex = sourceCode.LastIndexOf(GlobalCode.SLANG_REF);
-
-        if (tagIndex == -1)
-            return;
-
-        string guidString = sourceCode.Substring(tagIndex + GlobalCode.SLANG_REF.Length).Trim();
-
-        if (!Guid.TryParse(guidString, out Guid slangRefGuid))
-        {
-            L.Warning($"Found SLANG_REF but failed to parse GUID: {guidString}");
-            return;
-        }
-
-        var slangEncoded = GlobalCode.GetEncoded(slangRefGuid);
-
-        if (string.IsNullOrEmpty(slangEncoded))
-        {
-            L.Warning(
-                $"Could not find encoded source for ref {slangRefGuid}. Save will contain compiled IC10 only."
-            );
-            return;
-        }
-
-        // Extract the clean IC10 code (everything before the tag)
-        var cleanIc10 = sourceCode.Substring(0, tagIndex).TrimEnd();
-
-        // Append the encoded source tag to the bottom
-        sourceCode = $"{cleanIc10}\n{GlobalCode.SLANG_SRC}{slangEncoded}";
-    }
-
-    [HarmonyPatch(typeof(ProgrammableChip), nameof(ProgrammableChip.SerializeSave))]
-    [HarmonyPostfix]
-    public static void pgc_SerializeSave(ProgrammableChip __instance, ref ThingSaveData __result)
-    {
-        if (__result is not ProgrammableChipSaveData chipData)
-            return;
-
-        string code = chipData.SourceCode;
-        HandleSerialization(ref code);
-        chipData.SourceCode = code;
-    }
-
-    [HarmonyPatch(
-        typeof(ProgrammableChip),
-        nameof(ProgrammableChip.ErrorLineNumberString),
-        MethodType.Getter
-    )]
-    [HarmonyPostfix]
-    public static void pgc_ErrorLineNumberString(ProgrammableChip __instance, ref string __result)
-    {
-        if (
-            String.IsNullOrEmpty(__result)
-            || !uint.TryParse(__result.Trim(), out var ic10ErrorLineNumber)
-        )
-        {
-            return;
-        }
-
-        var sourceAscii = __instance.GetSourceCode();
-
-        if (_errorReferenceTable.TryGetValue(__instance, out var cache))
-        {
-            if (cache.SourceRef.Equals(sourceAscii) && cache.IC10ErrorSource == ic10ErrorLineNumber)
-            {
-                __result = cache.SlangErrorReference;
-                return;
-            }
-        }
-
-        var source = System.Text.Encoding.UTF8.GetString(
-            System.Text.Encoding.ASCII.GetBytes(__instance.GetSourceCode())
-        );
-
-        var slangIndex = source.LastIndexOf(GlobalCode.SLANG_REF);
-
-        if (
-            slangIndex < 0
-            || !Guid.TryParse(
-                source
-                    .Substring(
-                        source.LastIndexOf(GlobalCode.SLANG_REF) + GlobalCode.SLANG_REF.Length
-                    )
-                    .Trim(),
-                out var slangGuid
-            )
-            || !GlobalCode.GetSlangErrorLineFromICError(
-                slangGuid,
-                ic10ErrorLineNumber,
-                out var slangErrorLineNumber,
-                out var slangSpan
-            )
-        )
-        {
-            return;
-        }
-
-        L.Warning($"IC error at: {__result} -- Slang source error line: {slangErrorLineNumber}");
-        __result = slangErrorLineNumber.ToString();
-        _errorReferenceTable.Remove(__instance);
-        _errorReferenceTable.Add(
-            __instance,
-            new LineErrorData(
-                sourceAscii,
-                ic10ErrorLineNumber,
-                slangErrorLineNumber.ToString(),
-                slangSpan
-            )
-        );
-    }
-
-    [HarmonyPatch(
-        typeof(ProgrammableChip),
-        nameof(ProgrammableChip.SetSourceCode),
-        new Type[] { typeof(string) }
-    )]
-    [HarmonyPostfix]
-    public static void pgc_SetSourceCode_string(ProgrammableChip __instance, string sourceCode)
-    {
-        _errorReferenceTable.Remove(__instance);
-    }
-
-    [HarmonyPatch(
-        typeof(ProgrammableChip),
-        nameof(ProgrammableChip.SetSourceCode),
-        new Type[] { typeof(string), typeof(ICircuitHolder) }
-    )]
-    [HarmonyPostfix]
-    public static void pgc_SetSourceCode_string_parent(
-        ProgrammableChip __instance,
-        string sourceCode,
-        ICircuitHolder parent
-    )
-    {
-        _errorReferenceTable.Remove(__instance);
-    }
-
-    [HarmonyPatch(
-        typeof(ProgrammableChipMotherboard),
-        nameof(ProgrammableChipMotherboard.SerializeSave)
-    )]
-    [HarmonyPostfix]
-    public static void pgmb_SerializeSave(
-        ProgrammableChipMotherboard __instance,
-        ref ThingSaveData __result
-    )
-    {
-        if (__result is not ProgrammableChipMotherboardSaveData chipData)
-            return;
-
-        string code = chipData.SourceCode;
-        HandleSerialization(ref code);
-        chipData.SourceCode = code;
-    }
-
-    private static void HandleDeserialization(ref string sourceCode)
-    {
-        // Safety check for null/empty code
-        if (string.IsNullOrEmpty(sourceCode))
-            return;
-
-        // Check for the #SLANG_SRC: footer
-        int tagIndex = sourceCode.LastIndexOf(GlobalCode.SLANG_SRC);
-
-        // If the tag is missing, this is just a normal IC10 script. Do nothing.
-        if (tagIndex == -1)
-            return;
-
-        // Extract the Encoded Source (Base64)
-        string encodedSource = sourceCode.Substring(tagIndex + GlobalCode.SLANG_SRC.Length).Trim();
-
-        // Extract the IC10 Code (strip off the tag and the newline before it)
-        string ic10Code = sourceCode.Substring(0, tagIndex).TrimEnd();
-
-        // Generate a new Runtime GUID for this session
-        Guid runtimeGuid = Guid.NewGuid();
-
-        // Hydrate the Cache
-        GlobalCode.SetEncoded(runtimeGuid, encodedSource);
-
-        // Rewrite the SourceCode to the "Runtime" format (REF at bottom)
-        sourceCode = $"{ic10Code}\n{GlobalCode.SLANG_REF}{runtimeGuid}";
-    }
-
-    [HarmonyPatch(typeof(ProgrammableChip), nameof(ProgrammableChip.DeserializeSave))]
-    [HarmonyPrefix]
-    public static void pgc_DeserializeSave(ref ThingSaveData savedData)
-    {
-        if (savedData is not ProgrammableChipSaveData pcSaveData)
-            return;
-
-        string code = pcSaveData.SourceCode;
-        HandleDeserialization(ref code);
-        pcSaveData.SourceCode = code;
-    }
-
-    [HarmonyPatch(
-        typeof(ProgrammableChipMotherboard),
-        nameof(ProgrammableChipMotherboard.DeserializeSave)
-    )]
-    [HarmonyPrefix]
-    public static void pgmb_DeserializeSave(ref ThingSaveData savedData)
-    {
-        if (savedData is not ProgrammableChipMotherboardSaveData pcSaveData)
-            return;
-
-        string code = pcSaveData.SourceCode;
-        HandleDeserialization(ref code);
-        pcSaveData.SourceCode = code;
-    }
-
-    [HarmonyPatch(typeof(InputSourceCode), nameof(InputSourceCode.ButtonInputCancel))]
-    [HarmonyPrefix]
-    public static void isc_ButtonInputCancel()
-    {
-        if (_currentlyEditingMotherboard is null || _motherboardCachedCode is null)
-        {
-            return;
-        }
-
-        _currentlyEditingMotherboard.SetSourceCode(_motherboardCachedCode);
-
-        _currentlyEditingMotherboard = null;
-        _motherboardCachedCode = null;
-        _currentlyEditingGuid = null;
-    }
-
     [HarmonyPatch(typeof(Stationpedia), nameof(Stationpedia.Regenerate))]
     [HarmonyPostfix]
     public static void Stationpedia_Regenerate()

csharp_mod/Plugin.cs

@@ -1,7 +1,5 @@
-using System.Text.RegularExpressions;
 using BepInEx;
 using HarmonyLib;
-using LaunchPadBooster;
 
 namespace Slang
 {
@@ -41,45 +39,32 @@ namespace Slang
     {
         public const string PluginGuid = "com.biddydev.slang";
         public const string PluginName = "Slang";
-        public const string PluginVersion = "0.3.0";
+        public const string PluginVersion = "0.4.7";
 
-        public static Mod MOD = new Mod(PluginName, PluginVersion);
+        private static Harmony? _harmony;
 
-        private Harmony? _harmony;
-
-        private static Regex? _slangSourceCheck = null;
-
-        private static Regex SlangSourceCheck
-        {
-            get
-            {
-                if (_slangSourceCheck is null)
-                {
-                    _slangSourceCheck = new Regex(@"[;{}()]|\b(let|fn|device)\b|\/\/");
-                }
-
-                return _slangSourceCheck;
-            }
-        }
-
-        public static bool IsSlangSource(ref string input)
-        {
-            return SlangSourceCheck.IsMatch(input);
-        }
-
-        private void Awake()
+        public void Awake()
         {
             L.SetLogger(Logger);
-            this._harmony = new Harmony(PluginGuid);
+            _harmony = new Harmony(PluginGuid);
 
             // If we failed to load the compiler, bail from the rest of the patches. It won't matter,
             // as the compiler itself has failed to load.
             if (!Marshal.Init())
             {
+                L.Error("Marshal failed to init");
                 return;
             }
 
-            this._harmony.PatchAll();
+            _harmony.PatchAll();
+            L.Debug("Ran Harmony patches");
+        }
+
+        public void OnDestroy()
+        {
+            Marshal.Destroy();
+            _harmony?.UnpatchSelf();
+            L.Debug("Cleaned up Harmony patches");
         }
     }
 }

csharp_mod/stationeersSlang.csproj

@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
     <AssemblyName>StationeersSlang</AssemblyName>
     <Description>Slang Compiler Bridge</Description>
-    <Version>0.3.0</Version>
+    <Version>0.4.2</Version>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <LangVersion>latest</LangVersion>
   </PropertyGroup>
@@ -39,6 +39,10 @@
         <HintPath>./ref/Assembly-CSharp.dll</HintPath>
         <Private>False</Private>
       </Reference>
+      <Reference Include="RG.ImGui">
+        <HintPath>./ref/RG.ImGui.dll</HintPath>
+        <Private>False</Private>
+      </Reference>
 
       <Reference Include="IC10Editor.dll">
         <HintPath>./ref/IC10Editor.dll</HintPath>

docs/builtins.md

@@ -0,0 +1,302 @@
+# Built-in Functions
+
+<!--toc:start-->
+
+- [Built-in Functions](#built-in-functions)
+  - [System Functions](#system-functions)
+    - [`yield()`](#yield)
+    - [`sleep(ticks)`](#sleepticks)
+    - [`hash(prefabName)`](#hashprefabname)
+  - [Device I/O Functions](#device-io-functions)
+    - [Reading from Devices](#reading-from-devices)
+      - [Load from device](#load-from-device)
+      - [Load From Device Batched](#load-from-device-batched)
+      - [Load From Device Batched Named](#load-from-device-batched-named)
+      - [Load Slot](#load-slot)
+      - [Load Reagent](#load-reagent)
+    - [Writing to Devices](#writing-to-devices)
+      - [Set On Device](#set-on-device)
+      - [Set On Device Batched](#set-on-device-batched)
+      - [Set On Device Batched Named](#set-on-device-batched-named)
+      - [Set Slot](#set-slot)
+  - [Math Functions](#math-functions)
+    - [Trigonometric Functions](#trigonometric-functions)
+      - [Trig Example](#trig-example)
+    - [Rounding Functions](#rounding-functions)
+      - [Rounding Example](#rounding-example)
+    - [Other Math Functions](#other-math-functions)
+      - [Math Example](#math-example)
+  - [See Also](#see-also)
+  <!--toc:end-->
+
+Slang provides built-in functions for device I/O and mathematical operations.
+These map directly to IC10 instructions.
+
+## System Functions
+
+### `yield()`
+
+Pauses execution for exactly one game tick.
+
+```rust
+yield();
+```
+
+**IC10:** `yield`
+
+---
+
+### `sleep(ticks)`
+
+Pauses execution for the specified number of ticks.
+
+```rust
+sleep(10);  // Sleep for 10 ticks
+```
+
+**IC10:** `sleep ticks`
+
+---
+
+### `hash(prefabName)`
+
+Computes the in-game hash for a prefab name. The hash is computed at compile
+time and no runtime code is generated.
+
+```rust
+const AC_HASH = hash("StructureAirConditioner");
+```
+
+**Note:** This is different from IC10's `hash` instruction, which computes the
+hash at runtime.
+
+```rust
+setBatched(AC_HASH, "On", 0);
+```
+
+**IC10:** `sb -2087593337 On 0` (no hash computation at runtime)
+
+---
+
+## Device I/O Functions
+
+### Reading from Devices
+
+#### Load from device
+
+`load(device, property)` / `l(device, property)`
+
+Loads a property value from a device:
+
+```rust
+let temp = load(sensor, "Temperature");
+let temp = l(sensor, "Temperature");
+
+// Preferred: use dot notation
+let temp = sensor.Temperature;
+```
+
+**IC10:** `l r? d? var`
+
+---
+
+#### Load From Device Batched
+
+`loadBatched(deviceHash, property, batchMode)` / `lb(...)`
+
+Loads a property from all devices matching a hash, aggregated by batch mode:
+
+```rust
+const SENSOR = hash("StructureGasSensor");
+let avgTemp = loadBatched(SENSOR, "Temperature", "Average");
+let maxTemp = lb(SENSOR, "Temperature", "Maximum");
+```
+
+**Batch Modes:** `"Average"`, `"Sum"`, `"Minimum"`, `"Maximum"`
+
+**IC10:** `lb r? deviceHash logicType batchMode`
+
+---
+
+#### Load From Device Batched Named
+
+`loadBatchedNamed(deviceHash, nameHash, property, batchMode)` / `lbn(...)`
+
+Loads a property from devices matching both device hash and name hash:
+
+```rust
+const SENSOR_HASH = hash("StructureGasSensor");
+const SENSOR_NAME_HASH = hash("Outdoor Gas Sensor");
+let avgTemp = loadBatchedNamed(SENSOR_HASH, SENSOR_NAME_HASH, "Temperature", "Average");
+let maxTemp = lbn(SENSOR_HASH, SENSOR_NAME_HASH, "Temperature", "Maximum");
+```
+
+**IC10:** `lbn r? deviceHash nameHash logicType batchMode`
+
+**Note:** This function is useful when a script interfaces with a lot of
+devices, as it allows for arbitrary device access without limited to the 6 `dx` pins.
+
+---
+
+#### Load Slot
+
+`loadSlot(device, slotIndex, property)` / `ls(...)`
+
+Loads a slot property from a device:
+
+```rust
+let occupied = loadSlot(sorter, 0, "Occupied");
+let occupied = ls(sorter, 0, "Occupied");
+```
+
+**IC10:** `ls r? d? slotIndex logicSlotType`
+
+---
+
+#### Load Reagent
+
+`loadReagent(device, reagentMode, reagentHash)` / `lr(...)`
+
+Loads reagent information from a device:
+
+```rust
+let amount = loadReagent(furnace, "Contents", reagentHash);
+let amount = lr(furnace, "Contents", reagentHash);
+```
+
+**IC10:** `lr r? d? reagentMode reagentHash`
+
+---
+
+### Writing to Devices
+
+#### Set On Device
+
+`set(device, property, value)` / `s(...)`
+
+Sets a property on a device:
+
+```rust
+set(valve, "On", true);
+s(valve, "On", true);
+
+// Preferred: use dot notation
+valve.On = true;
+```
+
+**IC10:** `s d? logicType r?`
+
+---
+
+#### Set On Device Batched
+
+`setBatched(deviceHash, property, value)` / `sb(...)`
+
+Sets a property on all devices matching a hash:
+
+```rust
+const LIGHT_HASH = hash("StructureWallLight");
+setBatched(LIGHT_HASH, "On", true);
+sb(LIGHT_HASH, "On", true);
+```
+
+**IC10:** `sb deviceHash logicType r?`
+
+**Note:** This function is useful when a script interfaces with a lot of devices,
+as it allows for arbitrary device access without limited to the 6 `dx` pins.
+
+---
+
+#### Set On Device Batched Named
+
+`setBatchedNamed(deviceHash, nameHash, property, value)` / `sbn(...)`
+
+Sets a property on devices matching both device hash and name hash:
+
+```rust
+const SENSOR_HASH = hash("StructureGasSensor");
+const SENSOR_NAME_HASH = hash("Outdoor Gas Sensor");
+setBatchedNamed(SENSOR_HASH, SENSOR_NAME_HASH, "On", true);
+sbn(SENSOR_HASH, SENSOR_NAME_HASH, "On", true);
+```
+
+**IC10:** `sbn deviceHash nameHash logicType r?`
+
+---
+
+#### Set Slot
+
+`setSlot(device, slotIndex, property, value)` / `ss(...)`
+
+Sets a slot property on a device:
+
+```rust
+setSlot(sorter, 0, "Open", true);
+ss(sorter, 0, "Open", true);
+```
+
+**IC10:** `ss d? slotIndex logicSlotType r?`
+
+---
+
+## Math Functions
+
+All math functions accept numbers, variables, or expressions as arguments.
+
+### Trigonometric Functions
+
+| Function      | Description                  | IC10    |
+| ------------- | ---------------------------- | ------- |
+| `sin(x)`      | Sine of angle in radians     | `sin`   |
+| `cos(x)`      | Cosine of angle in radians   | `cos`   |
+| `tan(x)`      | Tangent of angle in radians  | `tan`   |
+| `asin(x)`     | Arc sine, returns radians    | `asin`  |
+| `acos(x)`     | Arc cosine, returns radians  | `acos`  |
+| `atan(x)`     | Arc tangent, returns radians | `atan`  |
+| `atan2(y, x)` | Two-argument arc tangent     | `atan2` |
+
+#### Trig Example
+
+```rust
+let angle = atan2(y, x);
+let sineValue = sin(angle);
+```
+
+### Rounding Functions
+
+| Function   | Description                   | IC10    |
+| ---------- | ----------------------------- | ------- |
+| `ceil(x)`  | Round up to nearest integer   | `ceil`  |
+| `floor(x)` | Round down to nearest integer | `floor` |
+| `trunc(x)` | Remove decimal portion        | `trunc` |
+| `abs(x)`   | Absolute value                | `abs`   |
+
+#### Rounding Example
+
+```rust
+let rounded = floor(3.7);  // 3
+let positive = abs(-5);    // 5
+```
+
+### Other Math Functions
+
+| Function    | Description                   | IC10   |
+| ----------- | ----------------------------- | ------ |
+| `sqrt(x)`   | Square root                   | `sqrt` |
+| `log(x)`    | Natural logarithm             | `log`  |
+| `max(a, b)` | Maximum of two values         | `max`  |
+| `min(a, b)` | Minimum of two values         | `min`  |
+| `rand()`    | Random number between 0 and 1 | `rand` |
+
+#### Math Example
+
+```rust
+let root = sqrt(16);        // 4
+let bigger = max(a, b);
+let randomVal = rand();
+```
+
+## See Also
+
+- [Language Reference](language-reference.md) — Complete syntax guide
+- [Examples](examples.md) — Real-world code samples

docs/examples.md

@@ -0,0 +1,254 @@
+# Examples
+
+Real-world Slang programs demonstrating common patterns.
+
+## Temperature Control
+
+Basic thermostat that controls an air conditioner based on room temperature:
+
+```rust
+device ac = "db";
+device roomGasSensor = "d0";
+
+const TARGET_TEMP = 22c;
+const HYSTERESIS = 1;
+
+loop {
+    yield();
+    let temp = roomGasSensor.Temperature;
+
+    if (temp > TARGET_TEMP + HYSTERESIS) {
+        ac.On = true;
+    } else if (temp < TARGET_TEMP - HYSTERESIS) {
+        ac.On = false;
+    }
+}
+```
+
+**Note:** The IC10 chip is assumed to be inserted in the air conditioner's IC slot.
+
+---
+
+## Two-Axis Solar Panel Tracking
+
+Handles two-axis solar panel tracking based on the sun's position:
+
+```rust
+device sensor = "d0";
+
+const H_PANELS = hash("StructureSolarPanelDual");
+
+loop {
+    setBatched(H_PANELS, "Horizontal", sensor.Horizontal);
+    setBatched(H_PANELS, "Vertical", sensor.Vertical + 90);
+    yield();
+}
+```
+
+**Note:** Assumes the daylight sensor is mounted with its port looking 90
+degrees east of the solar panel's data port, an offset can be added on the
+horizontal angle if needed.
+
+---
+
+## Day/Night Lighting
+
+Controls grow lights during the day and ambient lights at night:
+
+```rust
+device greenhouseSensor = "d0";
+
+const daylightSensor = hash("StructureDaylightSensor");
+const growLight = hash("StructureGrowLight");
+const wallLight = hash("StructureLightLong");
+
+loop {
+    yield();
+    let solarAngle = lb(daylightSensor, "SolarAngle", "Average");
+    let isDaylight = solarAngle < 90;
+
+    sb(growLight, "On", isDaylight);
+    sb(wallLight, "On", !isDaylight);
+}
+```
+
+---
+
+## Pressure Relief Valve
+
+Controls a volume pump based on pressure readings for emergency pressure relief:
+
+```rust
+device volumePump = "d0";
+device pipeSensor = "d1";
+
+const MAX_PRESSURE = 10_000;
+const R = 8.314;
+
+loop {
+    yield();
+
+    let pressure = pipeSensor.Pressure;
+
+    if (pressure > MAX_PRESSURE) {
+        // Use PV=nRT to calculate the amount of mols we need to move
+        // n = PV / RT
+        let molsToMove = (pressure - MAX_PRESSURE) *
+          pipeSensor.Volume / (R * pipeSensor.Temperature);
+
+        // V = nRT / P
+        let setting = molsToMove * R * pipeSensor.Temperature / pressure;
+        volumePump.Setting = setting;
+        volumePump.On = true;
+    } else {
+        volumePump.On = false;
+    }
+}
+```
+
+---
+
+## Greenhouse Environment Controller
+
+Complete greenhouse control with pressure, temperature, and lighting:
+
+```rust
+device self = "db";
+device emergencyRelief = "d0";
+device greenhouseSensor = "d1";
+device recycleValve = "d2";
+
+const MAX_INTERIOR_PRESSURE = 80;
+const MAX_INTERIOR_TEMP = 28c;
+const MIN_INTERIOR_PRESSURE = 75;
+const MIN_INTERIOR_TEMP = 25c;
+const daylightSensor = 1076425094;
+const growLight = hash("StructureGrowLight");
+const wallLight = hash("StructureLightLong");
+const lightRound = hash("StructureLightRound");
+
+let shouldPurge = false;
+
+loop {
+    yield();
+    let interiorPress = greenhouseSensor.Pressure;
+    let interiorTemp = greenhouseSensor.Temperature;
+
+    shouldPurge = (
+        interiorPress > MAX_INTERIOR_PRESSURE ||
+        interiorTemp > MAX_INTERIOR_TEMP
+    ) || shouldPurge;
+
+    emergencyRelief.On = shouldPurge;
+    recycleValve.On = !shouldPurge;
+
+    if (
+        shouldPurge && (
+          interiorPress < MIN_INTERIOR_PRESSURE &&
+          interiorTemp < MIN_INTERIOR_TEMP
+          )
+        ) {
+        shouldPurge = false;
+    }
+
+    let solarAngle = lb(daylightSensor, "SolarAngle", "Average");
+    let isDaylight = solarAngle < 90;
+
+    sb(growLight, "On", isDaylight);
+    sb(wallLight, "On", !isDaylight);
+    sb(lightRound, "On", !isDaylight);
+}
+```
+
+---
+
+## Advanced Furnace Pressure Control
+
+Automates multi-furnace pump control based on dial setting for pressure target:
+
+```rust
+const FURNACE1 = 1234;
+const DIAL1 = 1123;
+const ANALYZER1 = 1223;
+
+const FURNACE2 = 1235;
+const DIAL2 = 1124;
+const ANALYZER2 = 1224;
+
+const FURNACE3 = 1236;
+const DIAL3 = 1124;
+const ANALYZER3 = 1225;
+
+const R = 8.314;
+
+fn handleFurnace(furnace, dial, analyzer) {
+    let pressure = furnace.Pressure;
+    let targetPressure = max(dial.Setting, 0.1) * 1000;
+
+    if (abs(targetPressure - pressure) <= 0.1) {
+        furnace.On = false;
+        return;
+    }
+
+    let molsToMove = max(furnace.TotalMoles, 1) * (
+      (targetPressure / pressure) - 1
+    );
+
+    // V = nRT / P
+    if (molsToMove > 0) {
+        // Calculate volume required
+        if (analyzer.Pressure == 0) {
+            // No more gas to add
+            furnace.On = false;
+            return;
+        }
+        let volume = molsToMove * R * analyzer.Temperature / analyzer.Pressure;
+
+        furnace.On = true;
+        furnace.SettingOutput = 0;
+        furnace.SettingInput = volume;
+
+        return;
+    }
+
+    // Calculate volume required
+    let volume = (-molsToMove) * R * furnace.Temperature / pressure;
+
+    furnace.On = true;
+    furnace.SettingInput = 0;
+    furnace.SettingOutput = volume;
+
+    return;
+}
+
+loop {
+    yield();
+
+    handleFurnace(FURNACE1, DIAL1, ANALYZER1);
+    handleFurnace(FURNACE2, DIAL2, ANALYZER2);
+    handleFurnace(FURNACE3, DIAL3, ANALYZER3);
+}
+```
+
+**Note:** This example does not handle edge cases such as insufficient gas in
+the input network or overfilling the furnace/pipe network.
+
+---
+
+## Common Patterns
+
+### Waiting for a Condition
+
+```rust
+fn waitForDeviceToTurnOff(device) {
+    while (device.On) {
+        yield();
+    }
+}
+```
+
+## See Also
+
+- [Getting Started](getting-started.md) — First steps with Slang
+- [Language Reference](language-reference.md) — Complete syntax guide
+- [Built-in Functions](builtins.md) — System calls and math functions

docs/getting-started.md

@@ -0,0 +1,99 @@
+# Getting Started
+
+<!--toc:start-->
+
+- [Getting Started](#getting-started)
+  - [Program Structure](#program-structure)
+  - [The `yield()` Function](#the-yield-function)
+  - [Your First Program](#your-first-program)
+    - [Explanation](#explanation)
+  - [Comments](#comments)
+  - [See Also](#see-also)
+  <!--toc:end-->
+
+This guide covers the basics of writing your first Slang program.
+
+## Program Structure
+
+A Slang program consists of top-level declarations and a main loop:
+
+```rust
+// Device declarations
+device self = "db";
+device sensor = "d0";
+
+// Constants
+const THRESHOLD = 100;
+
+// Variables
+let counter = 0;
+
+// Main program loop
+loop {
+    yield();
+    // Your logic here
+}
+```
+
+## The `yield()` Function
+
+IC10 programs run continuously. The `yield()` function pauses execution for one
+game tick, preventing the script from consuming excessive resources.
+
+**Important:** You should always include `yield()` in your main loop unless you
+know what you're doing.
+
+```rust
+loop {
+    yield(); // Recommended!
+    // ...
+}
+```
+
+## Your First Program
+
+Here's a simple program that turns on a light when a gas sensor detects low
+pressure:
+
+```rust
+device gasSensor = "d0";
+device light = "d1";
+
+const LOW_PRESSURE = 50;
+
+loop {
+    yield();
+    light.On = gasSensor.Pressure < LOW_PRESSURE;
+}
+```
+
+### Explanation
+
+1. `device gasSensor = "d0"` — Binds the device at port `d0` to the name
+   `gasSensor`
+2. `device light = "d1"` — Binds the device at port `d1` to the name `light`
+3. `const LOW_PRESSURE = 50` — Defines a compile-time constant
+4. `loop { ... }` — Creates an infinite loop
+5. `yield()` — Pauses for one tick
+6. `light.On = gasSensor.Pressure < LOW_PRESSURE` — Reads the pressure and sets
+   the light state
+
+## Comments
+
+Slang supports single-line comments and documentation comments:
+
+```rust
+// This is a regular comment
+
+/// This is a documentation comment
+/// It can span multiple lines
+fn myFunction() {
+    // ...
+}
+```
+
+## See Also
+
+- [Language Reference](language-reference.md) — Complete syntax guide
+- [Built-in Functions](builtins.md) — Available system calls
+- [Examples](examples.md) — Real-world programs and patterns

docs/language-reference.md

@@ -0,0 +1,339 @@
+# Language Reference
+
+<!--toc:start-->
+
+- [Language Reference](#language-reference)
+  - [Literals](#literals)
+    - [Numbers](#numbers)
+    - [Temperature Literals](#temperature-literals)
+    - [Booleans](#booleans)
+    - [Strings](#strings)
+  - [Variables](#variables)
+    - [`let` - Mutable Variables](#let-mutable-variables)
+    - [`const` - Constants](#const-constants)
+  - [Device Declarations](#device-declarations)
+    - [Device Property Access](#device-property-access)
+    - [Device Property Assignment](#device-property-assignment)
+  - [Operators](#operators)
+    - [Arithmetic Operators](#arithmetic-operators)
+    - [Comparison Operators](#comparison-operators)
+    - [Logical Operators](#logical-operators)
+    - [Ternary Operator](#ternary-operator)
+    - [Operator Precedence](#operator-precedence)
+  - [Control Flow](#control-flow)
+    - [`if` / `else`](#if-and-else)
+    - [`loop`](#loop)
+    - [`while`](#while)
+    - [`break`](#break)
+    - [`continue`](#continue)
+  - [Functions](#functions)
+    - [Declaration](#declaration)
+    - [Invocation](#invocation)
+    - [Return Values](#return-values)
+  - [Parentheses for Grouping](#parentheses-for-grouping)
+  - [See Also](#see-also)
+  <!--toc:end-->
+
+Complete syntax reference for the Slang programming language.
+
+## Literals
+
+### Numbers
+
+Numbers can be integers or decimals. Underscores are allowed as visual
+separators:
+
+```rust
+const integer = 42;                 // Integer
+const decimal = 3.14;               // Decimal
+const million = 1_000_000;          // Integer with separators
+const decimalSeparators = 5_000.50; // Decimal with separators
+```
+
+### Temperature Literals
+
+Append a unit suffix to specify temperature. Values are automatically converted
+to Kelvin at compile time:
+
+| Suffix | Unit       | Example |
+| ------ | ---------- | ------- |
+| `c`    | Celsius    | `20c`   |
+| `f`    | Fahrenheit | `68f`   |
+| `k`    | Kelvin     | `293k`  |
+
+```rust
+const ROOM_TEMP = 20c;       // Converts to 293.15 Kelvin
+const FREEZING  = 32f;       // Converts to 273.15 Kelvin
+const ABSOLUTE1 = 0k;        // Already in Kelvin
+const ABSOLUTE2 = 0;         // Assumed to be in Kelvin
+```
+
+### Booleans
+
+Booleans compile to integer values `1` and `0` in IC10.
+
+```rust
+device ac = "d0";
+
+ac.Mode = false;
+ac.On = true;
+```
+
+### Strings
+
+Strings use double or single quotes. They are primarily used for prefab and
+name hashes.
+
+```rust
+const AC_HASH = hash("StructureAirConditioner");
+const AC_NAME_HASH = hash("Greenhouse Air Conditioner");
+```
+
+## Variables
+
+### `let` Mutable Variables
+
+Declares a variable that can be reassigned:
+
+```rust
+let counter = 0;
+// ...
+counter = counter + 1;
+```
+
+### `const` Constants
+
+Declares a compile-time constant. Constants are inlined and do not consume
+registers:
+
+```rust
+const MAX_PRESSURE = 10_000;
+const DOOR_HASH = hash("StructureCompositeDoor");
+```
+
+Constants support the `hash()` function for compile-time hash computation.
+
+## Device Declarations
+
+The `device` keyword binds a device port or reference ID to a named variable:
+
+```rust
+device self = "db";   // IC housing, or device the IC is plugged into (eg. an AC)
+device sensor = "d0"; // Device at port d0
+device valve = "d1";  // Device at port d1
+device ac1 = "$3FC";  // Device with reference ID $3FC (hexadecimal 1020)
+device ac2 = "1020";  // Device with reference ID 1020 (decimal)
+```
+
+**Note:** Reference IDs can be found in-game using the Configuration cartridge.
+
+### Device Property Access
+
+Read device properties using dot notation:
+
+```rust
+let temp = sensor.Temperature;
+let pressure = sensor.Pressure;
+let isOn = valve.On;
+```
+
+### Device Property Assignment
+
+Write to device properties using dot notation:
+
+```rust
+valve.On = true;
+valve.Setting = 100;
+```
+
+## Operators
+
+### Arithmetic Operators
+
+| Operator | Description    | Example  |
+| -------- | -------------- | -------- |
+| `+`      | Addition       | `a + b`  |
+| `-`      | Subtraction    | `a - b`  |
+| `*`      | Multiplication | `a * b`  |
+| `/`      | Division       | `a / b`  |
+| `%`      | Modulo         | `a % b`  |
+| `**`     | Exponentiation | `a ** b` |
+| `-`      | Negation       | `-a`     |
+
+### Comparison Operators
+
+| Operator | Description           | Example  |
+| -------- | --------------------- | -------- |
+| `==`     | Equal                 | `a == b` |
+| `!=`     | Not equal             | `a != b` |
+| `<`      | Less than             | `a < b`  |
+| `>`      | Greater than          | `a > b`  |
+| `<=`     | Less than or equal    | `a <= b` |
+| `>=`     | Greater than or equal | `a >= b` |
+
+### Logical Operators
+
+| Operator | Description | Example    |
+| -------- | ----------- | ---------- |
+| `&&`     | Logical AND | `a && b`   |
+| `\|\|`   | Logical OR  | `a \|\| b` |
+| `!`      | Logical NOT | `!a`       |
+
+### Ternary Operator
+
+Conditional expressions using `?` and `:`:
+
+```rust
+let result = condition ? valueIfTrue : valueIfFalse;
+```
+
+### Operator Precedence
+
+Operators are evaluated in the following order, from highest to lowest
+precedence:
+
+| Precedence | Operator(s)       | Description                      |
+| ---------- | ----------------- | -------------------------------- |
+| 1          | `()` `.`          | Grouping, Property access        |
+| 2          | `!` `-`           | Logical NOT, Negation            |
+| 3          | `**`              | Exponentiation                   |
+| 4          | `*` `/` `%`       | Multiplication, Division, Modulo |
+| 5          | `+` `-`           | Addition, Subtraction            |
+| 6          | `<` `<=` `>` `>=` | Comparison                       |
+| 7          | `==` `!=`         | Equality                         |
+| 8          | `&&`              | Logical AND                      |
+| 9          | `\|\|`            | Logical OR                       |
+| 10         | `?:`              | Ternary conditional              |
+| 11         | `=`               | Assignment                       |
+
+Use parentheses to override precedence:
+
+```rust
+let result = (20 + 10) * 5;
+```
+
+## Control Flow
+
+### if and else
+
+Conditional branching:
+
+```rust
+if (tank.Temperature > 30c) {
+    ac.On = true;
+} else {
+    ac.On = false;
+}
+```
+
+### `loop`
+
+Infinite loop that runs until `break`:
+
+```rust
+loop {
+    yield();
+    // Loop body
+    if (condition) {
+        break;  // Exit the loop
+    }
+}
+```
+
+### `while`
+
+Conditional loop that runs while the condition is true:
+
+```rust
+while (counter < 100) {
+    counter = counter + 1;
+    yield();
+}
+```
+
+### `break`
+
+Exits the current loop:
+
+```rust
+loop {
+    yield();
+    // ...
+    if (done) {
+        break;
+    }
+}
+```
+
+### `continue`
+
+Skips to the next iteration of the current loop:
+
+```rust
+loop {
+    yield();
+    if (shouldSkip) {
+        continue;
+    }
+    // This code is skipped when shouldSkip is true
+    // ...
+}
+```
+
+## Functions
+
+**Warning:** Functions are currently experimental and may produce suboptimal code.
+
+### Declaration
+
+```rust
+fn functionName(arg1, arg2) {
+    // Function body
+    return arg1 + arg2;
+}
+```
+
+### Invocation
+
+```rust
+let result = functionName(10, 20);
+```
+
+### Return Values
+
+Use `return` to exit a function and optionally return a value:
+
+```rust
+fn calculate(x) {
+    if (x < 0) {
+        return 0;  // Early return
+    }
+
+    return x * 2;
+}
+
+fn doWork() {
+    // No return value
+    return;
+}
+```
+
+## Parentheses for Grouping
+
+Use parentheses to control operator precedence:
+
+```rust
+let result = (a + b) * c;
+
+let complex = (
+    temp > 0c &&
+    stress < 50 &&
+    (pressure < 10_000 || temp > 20c)
+);
+```
+
+## See Also
+
+- [Getting Started](getting-started.md) — First steps with Slang
+- [Built-in Functions](builtins.md) — System calls and math functions
+- [Examples](examples.md) — Real-world code samples

rust_compiler/Cargo.lock

@@ -172,9 +172,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 
 [[package]]
 name = "bytecheck"
@@ -930,7 +930,7 @@ checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
 name = "slang"
-version = "0.3.0"
+version = "0.4.7"
 dependencies = [
  "anyhow",
  "clap",
@@ -1063,18 +1063,18 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.3"
+version = "0.7.4+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+checksum = "fe3cea6b2aa3b910092f6abd4053ea464fab5f9c170ba5e9a6aead16ec4af2b6"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.23.7"
+version = "0.23.10+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
 dependencies = [
  "indexmap",
  "toml_datetime",
@@ -1084,9 +1084,9 @@ dependencies = [
 
 [[package]]
 name = "toml_parser"
-version = "1.0.4"
+version = "1.0.5+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+checksum = "4c03bee5ce3696f31250db0bbaff18bc43301ce0e8db2ed1f07cbb2acf89984c"
 dependencies = [
  "winnow",
 ]

rust_compiler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "slang"
-version = "0.3.0"
+version = "0.4.7"
 edition = "2021"
 
 [workspace]

rust_compiler/libs/compiler/src/test/binary_expression.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use anyhow::Result;
 use indoc::indoc;
 use pretty_assertions::assert_eq;
@@ -52,11 +51,9 @@ fn nested_binary_expressions() -> Result<()> {
             add r1 r10 r9
             mul r2 r1 r8
             move r15 r2
-            j L1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            j __internal_L1
+            __internal_L1:
+            pop ra
             j ra
             main:
             push 10
@@ -175,3 +172,52 @@ fn test_ternary_expression_assignment() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_negative_literals() -> Result<()> {
+    let compiled = compile!(
+    debug
+    r#"
+        let item = -10c - 20c;
+    "#
+    );
+
+    assert_eq!(
+        compiled,
+        indoc! {
+            "
+            j main
+            main:
+            move r8 243.15
+            "
+        }
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_mismatched_temperature_literals() -> Result<()> {
+    let compiled = compile!(
+    debug
+    r#"
+        let item = -10c - 100k;
+        let item2 = item + 500c;
+    "#
+    );
+
+    assert_eq!(
+        compiled,
+        indoc! {
+            "
+            j main
+            main:
+            move r8 163.15
+            add r1 r8 773.15
+            move r9 r1
+            "
+        }
+    );
+
+    Ok(())
+}

rust_compiler/libs/compiler/src/test/branching.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use indoc::indoc;
 use pretty_assertions::assert_eq;
 
@@ -22,9 +21,9 @@ fn test_if_statement() -> anyhow::Result<()> {
             main:
             move r8 10
             sgt r1 r8 5
-            beqz r1 L1
+            beqz r1 __internal_L1
             move r8 20
-            L1:
+            __internal_L1:
             "
         }
     );
@@ -54,12 +53,12 @@ fn test_if_else_statement() -> anyhow::Result<()> {
             main:
             move r8 0
             sgt r1 10 5
-            beqz r1 L2
+            beqz r1 __internal_L2
             move r8 1
-            j L1
-            L2:
+            j __internal_L1
+            __internal_L2:
             move r8 2
-            L1:
+            __internal_L1:
             "
         }
     );
@@ -91,18 +90,18 @@ fn test_if_else_if_statement() -> anyhow::Result<()> {
             main:
             move r8 0
             seq r1 r8 1
-            beqz r1 L2
+            beqz r1 __internal_L2
             move r8 10
-            j L1
-            L2:
+            j __internal_L1
+            __internal_L2:
             seq r2 r8 2
-            beqz r2 L4
+            beqz r2 __internal_L4
             move r8 20
-            j L3
-            L4:
+            j __internal_L3
+            __internal_L4:
             move r8 30
-            L3:
-            L1:
+            __internal_L3:
+            __internal_L1:
             "
         }
     );
@@ -145,10 +144,10 @@ fn test_spilled_variable_update_in_branch() -> anyhow::Result<()> {
             move r14 7
             push 8
             seq r1 r8 1
-            beqz r1 L1
+            beqz r1 __internal_L1
             sub r0 sp 1
             put db r0 99
-            L1:
+            __internal_L1:
             sub sp sp 1
             "
         }

rust_compiler/libs/compiler/src/test/declaration_function_invocation.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use indoc::indoc;
 use pretty_assertions::assert_eq;
 
@@ -17,10 +16,8 @@ fn no_arguments() -> anyhow::Result<()> {
         j main
         doSomething:
         push ra
-        L1:
-        sub r0 sp 1
-        get ra db r0
-        sub sp sp 1
+        __internal_L1:
+        pop ra
         j ra
         main:
         jal doSomething
@@ -59,26 +56,22 @@ fn let_var_args() -> anyhow::Result<()> {
             push ra
             mul r1 r8 2
             move r15 r1
-            j L1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            j __internal_L1
+            __internal_L1:
+            pop ra
             j ra
             main:
-            L2:
+            __internal_L2:
             move r8 123
             push r8
             push r8
             jal mul2
-            sub r0 sp 1
-            get r8 db r0
-            sub sp sp 1
+            pop r8
             move r9 r15
             pow r1 r9 2
             move r9 r1
-            j L2
-            L3:
+            j __internal_L2
+            __internal_L3:
             "
         }
     );
@@ -127,11 +120,9 @@ fn inline_literal_args() -> anyhow::Result<()> {
             pop r9
             push ra
             move r15 5
-            j L1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            j __internal_L1
+            __internal_L1:
+            pop ra
             j ra
             main:
             move r8 123
@@ -139,9 +130,7 @@ fn inline_literal_args() -> anyhow::Result<()> {
             push 12
             push 34
             jal doSomething
-            sub r0 sp 1
-            get r8 db r0
-            sub sp sp 1
+            pop r8
             move r9 r15
             "
         }
@@ -170,10 +159,8 @@ fn mixed_args() -> anyhow::Result<()> {
             pop r8
             pop r9
             push ra
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            __internal_L1:
+            pop ra
             j ra
             main:
             move r8 123
@@ -181,9 +168,7 @@ fn mixed_args() -> anyhow::Result<()> {
             push r8
             push 456
             jal doSomething
-            sub r0 sp 1
-            get r8 db r0
-            sub sp sp 1
+            pop r8
             move r9 r15
             "
         }
@@ -214,11 +199,9 @@ fn with_return_statement() -> anyhow::Result<()> {
             pop r8
             push ra
             move r15 456
-            j L1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            j __internal_L1
+            __internal_L1:
+            pop ra
             j ra
             main:
             push 123
@@ -251,10 +234,8 @@ fn with_negative_return_literal() -> anyhow::Result<()> {
             doSomething:
             push ra
             move r15 -1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            __internal_L1:
+            pop ra
             j ra
             main:
             jal doSomething

rust_compiler/libs/compiler/src/test/declaration_literal.rs

@@ -133,11 +133,9 @@ fn test_boolean_return() -> anyhow::Result<()> {
             getTrue:
             push ra
             move r15 1
-            j L1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            j __internal_L1
+            __internal_L1:
+            pop ra
             j ra
             main:
             jal getTrue
@@ -170,3 +168,28 @@ fn test_const_hash_expr() -> anyhow::Result<()> {
     );
     Ok(())
 }
+
+#[test]
+fn test_declaration_is_const() -> anyhow::Result<()> {
+    let compiled = compile! {
+        debug
+        r#"
+            const MAX = 100;
+
+            let max = MAX;
+        "#
+    };
+
+    assert_eq!(
+        compiled,
+        indoc! {
+            "
+            j main
+            main:
+            move r8 100
+            "
+        }
+    );
+
+    Ok(())
+}

rust_compiler/libs/compiler/src/test/function_declaration.rs

@@ -5,7 +5,12 @@ use pretty_assertions::assert_eq;
 fn test_function_declaration_with_spillover_params() -> anyhow::Result<()> {
     let compiled = compile!(debug r#"
         // we need more than 4 params to 'spill' into a stack var
-        fn doSomething(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {};
+        fn doSomething(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9;
+        };
+
+        let item1 = 1;
+        let returned = doSomething(item1, 2, 3, 4, 5, 6, 7, 8, 9);
     "#);
 
     assert_eq!(
@@ -21,11 +26,39 @@ fn test_function_declaration_with_spillover_params() -> anyhow::Result<()> {
             pop r13
             pop r14
             push ra
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 3
+            sub r0 sp 3
+            get r1 db r0
+            sub r0 sp 2
+            get r2 db r0
+            add r3 r1 r2
+            add r4 r3 r14
+            add r5 r4 r13
+            add r6 r5 r12
+            add r7 r6 r11
+            add r1 r7 r10
+            add r2 r1 r9
+            add r3 r2 r8
+            move r15 r3
+            j __internal_L1
+            __internal_L1:
+            pop ra
+            sub sp sp 2
             j ra
+            main:
+            move r8 1
+            push r8
+            push r8
+            push 2
+            push 3
+            push 4
+            push 5
+            push 6
+            push 7
+            push 8
+            push 9
+            jal doSomething
+            pop r8
+            move r9 r15
         "}
     );
 
@@ -54,15 +87,13 @@ fn test_early_return() -> anyhow::Result<()> {
             doSomething:
             push ra
             seq r1 1 1
-            beqz r1 L2
-            j L1
-            L2:
+            beqz r1 __internal_L2
+            j __internal_L1
+            __internal_L2:
             move r8 3
-            j L1
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            j __internal_L1
+            __internal_L1:
+            pop ra
             j ra
             main:
             jal doSomething
@@ -90,10 +121,8 @@ fn test_function_declaration_with_register_params() -> anyhow::Result<()> {
             pop r8
             pop r9
             push ra
-            L1:
-            sub r0 sp 1
-            get ra db r0
-            sub sp sp 1
+            __internal_L1:
+            pop ra
             j ra
         "}
     );

rust_compiler/libs/compiler/src/test/logic_expression.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use indoc::indoc;
 use pretty_assertions::assert_eq;
 

rust_compiler/libs/compiler/src/test/loops.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use indoc::indoc;
 use pretty_assertions::assert_eq;
 
@@ -14,7 +13,7 @@ fn test_infinite_loop() -> anyhow::Result<()> {
         "
     };
 
-    // Labels: L1 (start), L2 (end)
+    // __internal_Labels: L1 (start), L2 (end)
     assert_eq!(
         compiled,
         indoc! {
@@ -22,11 +21,11 @@ fn test_infinite_loop() -> anyhow::Result<()> {
             j main
             main:
             move r8 0
-            L1:
+            __internal_L1:
             add r1 r8 1
             move r8 r1
-            j L1
-            L2:
+            j __internal_L1
+            __internal_L2:
             "
         }
     );
@@ -49,7 +48,7 @@ fn test_loop_break() -> anyhow::Result<()> {
         "
     };
 
-    // Labels: L1 (start), L2 (end), L3 (if end - implicit else label)
+    // __internal_Labels: L1 (start), L2 (end), L3 (if end - implicit else label)
     assert_eq!(
         compiled,
         indoc! {
@@ -57,15 +56,15 @@ fn test_loop_break() -> anyhow::Result<()> {
             j main
             main:
             move r8 0
-            L1:
+            __internal_L1:
             add r1 r8 1
             move r8 r1
             sgt r2 r8 10
-            beqz r2 L3
-            j L2
-            L3:
-            j L1
-            L2:
+            beqz r2 __internal_L3
+            j __internal_L2
+            __internal_L3:
+            j __internal_L1
+            __internal_L2:
             "
         }
     );
@@ -85,7 +84,7 @@ fn test_while_loop() -> anyhow::Result<()> {
         "
     };
 
-    // Labels: L1 (start), L2 (end)
+    // __internal_Labels: L1 (start), L2 (end)
     assert_eq!(
         compiled,
         indoc! {
@@ -93,13 +92,13 @@ fn test_while_loop() -> anyhow::Result<()> {
             j main
             main:
             move r8 0
-            L1:
+            __internal_L1:
             slt r1 r8 10
-            beqz r1 L2
+            beqz r1 __internal_L2
             add r2 r8 1
             move r8 r2
-            j L1
-            L2:
+            j __internal_L1
+            __internal_L2:
             "
         }
     );
@@ -123,7 +122,7 @@ fn test_loop_continue() -> anyhow::Result<()> {
         "#
     };
 
-    // Labels: L1 (start), L2 (end), L3 (if end)
+    // __internal_Labels: L1 (start), L2 (end), L3 (if end)
     assert_eq!(
         compiled,
         indoc! {
@@ -131,16 +130,16 @@ fn test_loop_continue() -> anyhow::Result<()> {
             j main
             main:
             move r8 0
-            L1:
+            __internal_L1:
             add r1 r8 1
             move r8 r1
             slt r2 r8 5
-            beqz r2 L3
-            j L1
-            L3:
-            j L2
-            j L1
-            L2:
+            beqz r2 __internal_L3
+            j __internal_L1
+            __internal_L3:
+            j __internal_L2
+            j __internal_L1
+            __internal_L2:
             "
         }
     );

rust_compiler/libs/compiler/src/test/math_syscall.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use anyhow::Result;
 use indoc::indoc;
 use pretty_assertions::assert_eq;

rust_compiler/libs/compiler/src/test/syscall.rs

@@ -1,4 +1,3 @@
-use crate::compile;
 use indoc::indoc;
 use pretty_assertions::assert_eq;
 
@@ -208,3 +207,29 @@ fn test_set_slot() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_load_reagent() -> anyhow::Result<()> {
+    let compiled = compile! {
+        debug
+        r#"
+        device thingy = "d0";
+
+        let something = lr(thingy, "Contents", hash("Iron"));
+        "#
+    };
+
+    assert_eq!(
+        compiled,
+        indoc! {
+            "
+            j main
+            main:
+            lr r15 d0 Contents -666742878
+            move r8 r15
+            "
+        }
+    );
+
+    Ok(())
+}

rust_compiler/libs/compiler/src/v1.rs

@@ -15,7 +15,7 @@ use parser::{
 use rust_decimal::Decimal;
 use std::{borrow::Cow, collections::HashMap};
 use thiserror::Error;
-use tokenizer::token::Number;
+use tokenizer::token::{Number, Unit};
 
 fn extract_literal<'a>(
     literal: Literal<'a>,
@@ -264,7 +264,7 @@ impl<'a> Compiler<'a> {
 
     fn next_label_name(&mut self) -> Cow<'a, str> {
         self.label_counter += 1;
-        Cow::from(format!("L{}", self.label_counter))
+        Cow::from(format!("__internal_L{}", self.label_counter))
     }
 
     fn expression(
@@ -714,7 +714,12 @@ impl<'a> Compiler<'a> {
 
                         Operand::Register(VariableScope::TEMP_STACK_REGISTER)
                     }
-                    VariableLocation::Constant(_) | VariableLocation::Device(_) => unreachable!(),
+                    VariableLocation::Constant(Literal::Number(num)) => Operand::Number(num.into()),
+                    VariableLocation::Constant(Literal::Boolean(b)) => {
+                        Operand::Number(Number::from(b).into())
+                    }
+                    VariableLocation::Device(_)
+                    | VariableLocation::Constant(Literal::String(_)) => unreachable!(),
                 };
                 self.emit_variable_assignment(&var_loc, src)?;
                 (var_loc, None)
@@ -811,7 +816,7 @@ impl<'a> Compiler<'a> {
                         ..
                     })),
                 ..
-            }) => Literal::Number(Number::Integer(crc_hash_signed(&str_to_hash))),
+            }) => Literal::Number(Number::Integer(crc_hash_signed(&str_to_hash), Unit::None)),
             LiteralOr::Or(Spanned { span, .. }) => {
                 return Err(Error::Unknown(
                     "hash only supports string literals in this context.".into(),
@@ -1115,43 +1120,26 @@ impl<'a> Compiler<'a> {
             Some(name.span),
         )?;
 
-        for register in active_registers {
-            let VariableLocation::Stack(stack_offset) = stack
-                .get_location_of(&Cow::from(format!("temp_{register}")), None)
-                .map_err(Error::Scope)?
-            else {
-                // This shouldn't happen if we just added it
-                return Err(Error::Unknown(
-                    format!("Failed to recover temp_{register}"),
-                    Some(name.span),
-                ));
-            };
+        // cleanup spilled temporary variables
+        let total_stack_usage = stack.stack_offset();
+        let saved_regs_count = active_registers.len() as u16;
+
+        if total_stack_usage > saved_regs_count {
+            let spill_amount = total_stack_usage - saved_regs_count;
             self.write_instruction(
                 Instruction::Sub(
-                    Operand::Register(VariableScope::TEMP_STACK_REGISTER),
                     Operand::StackPointer,
-                    Operand::Number(stack_offset.into()),
-                ),
-                Some(name.span),
-            )?;
-
-            self.write_instruction(
-                Instruction::Get(
-                    Operand::Register(register),
-                    Operand::Device(Cow::from("db")),
-                    Operand::Register(VariableScope::TEMP_STACK_REGISTER),
+                    Operand::StackPointer,
+                    Operand::Number(spill_amount.into()),
                 ),
                 Some(name.span),
             )?;
         }
 
-        if stack.stack_offset() > 0 {
+        // restore the registers in reverse order from the stack, now using `pop`
+        for register in active_registers.iter().rev() {
             self.write_instruction(
-                Instruction::Sub(
-                    Operand::StackPointer,
-                    Operand::StackPointer,
-                    Operand::Number(Decimal::from(stack.stack_offset())),
-                ),
+                Instruction::Pop(Operand::Register(*register)),
                 Some(name.span),
             )?;
         }
@@ -2022,6 +2010,7 @@ impl<'a> Compiler<'a> {
 
                 let loc = VariableLocation::Constant(Literal::Number(Number::Integer(
                     crc_hash_signed(&str_lit),
+                    Unit::None,
                 )));
 
                 Ok(Some(CompileLocation {
@@ -2249,10 +2238,7 @@ impl<'a> Compiler<'a> {
             System::LoadSlot(dev_name, slot_index, logic_type) => {
                 let (dev_hash, hash_cleanup) =
                     self.compile_literal_or_variable(dev_name.node, scope)?;
-                let (slot_index, slot_cleanup) = self.compile_literal_or_variable(
-                    LiteralOrVariable::Literal(slot_index.node),
-                    scope,
-                )?;
+                let (slot_index, slot_cleanup) = self.compile_operand(*slot_index, scope)?;
                 let (logic_type, logic_cleanup) = self.compile_literal_or_variable(
                     LiteralOrVariable::Literal(logic_type.node),
                     scope,
@@ -2277,10 +2263,7 @@ impl<'a> Compiler<'a> {
             System::SetSlot(dev_name, slot_index, logic_type, var) => {
                 let (dev_name, name_cleanup) =
                     self.compile_literal_or_variable(dev_name.node, scope)?;
-                let (slot_index, index_cleanup) = self.compile_literal_or_variable(
-                    LiteralOrVariable::Literal(slot_index.node),
-                    scope,
-                )?;
+                let (slot_index, index_cleanup) = self.compile_operand(*slot_index, scope)?;
                 let (logic_type, type_cleanup) = self.compile_literal_or_variable(
                     LiteralOrVariable::Literal(logic_type.node),
                     scope,
@@ -2295,6 +2278,48 @@ impl<'a> Compiler<'a> {
 
                 Ok(None)
             }
+            System::LoadReagent(device, reagent_mode, reagent_hash) => {
+                let Spanned {
+                    node: LiteralOrVariable::Variable(device_spanned),
+                    ..
+                } = device
+                else {
+                    return Err(Error::AgrumentMismatch(
+                        "Arg1 expected to be a variable".into(),
+                        span,
+                    ));
+                };
+
+                let (device, device_cleanup) = self.compile_literal_or_variable(
+                    LiteralOrVariable::Variable(device_spanned),
+                    scope,
+                )?;
+
+                let (reagent_mode, reagent_cleanup) = self.compile_literal_or_variable(
+                    LiteralOrVariable::Literal(reagent_mode.node),
+                    scope,
+                )?;
+
+                let (reagent_hash, reagent_hash_cleanup) =
+                    self.compile_operand(*reagent_hash, scope)?;
+
+                self.write_instruction(
+                    Instruction::LoadReagent(
+                        Operand::Register(VariableScope::RETURN_REGISTER),
+                        device,
+                        reagent_mode,
+                        reagent_hash,
+                    ),
+                    Some(span),
+                )?;
+
+                cleanup!(reagent_cleanup, reagent_hash_cleanup, device_cleanup);
+
+                Ok(Some(CompileLocation {
+                    location: VariableLocation::Persistant(VariableScope::RETURN_REGISTER),
+                    temp_name: None,
+                }))
+            }
         }
     }
 
@@ -2692,6 +2717,21 @@ impl<'a> Compiler<'a> {
 
         self.write_instruction(Instruction::LabelDef(return_label.clone()), Some(span))?;
 
+        if ra_stack_offset == 1 {
+            self.write_instruction(Instruction::Pop(Operand::ReturnAddress), Some(span))?;
+
+            let remaining_cleanup = block_scope.stack_offset() - 1;
+            if remaining_cleanup > 0 {
+                self.write_instruction(
+                    Instruction::Sub(
+                        Operand::StackPointer,
+                        Operand::StackPointer,
+                        Operand::Number(remaining_cleanup.into()),
+                    ),
+                    Some(span),
+                )?;
+            }
+        } else {
             self.write_instruction(
                 Instruction::Sub(
                     Operand::Register(VariableScope::TEMP_STACK_REGISTER),
@@ -2720,6 +2760,7 @@ impl<'a> Compiler<'a> {
                     Some(span),
                 )?;
             }
+        }
 
         self.write_instruction(Instruction::Jump(Operand::ReturnAddress), Some(span))?;
         Ok(())

rust_compiler/libs/helpers/src/syscall.rs

@@ -10,6 +10,7 @@ macro_rules! with_syscalls {
             "loadBatched",
             "loadBatchedNamed",
             "loadSlot",
+            "loadReagent",
             "set",
             "setBatched",
             "setBatchedNamed",
@@ -35,6 +36,7 @@ macro_rules! with_syscalls {
             "lb",
             "lbn",
             "ls",
+            "lr",
             "s",
             "sb",
             "sbn",

rust_compiler/libs/il/src/lib.rs

@@ -191,6 +191,9 @@ pub enum Instruction<'a> {
     /// `sbn deviceHash nameHash type value` - Set Batch Named
     StoreBatchNamed(Operand<'a>, Operand<'a>, Operand<'a>, Operand<'a>),
 
+    /// `lr register device reagentMode int`
+    LoadReagent(Operand<'a>, Operand<'a>, Operand<'a>, Operand<'a>),
+
     /// `j label` - Unconditional Jump
     Jump(Operand<'a>),
     /// `jal label` - Jump and Link (Function Call)
@@ -311,6 +314,9 @@ impl<'a> fmt::Display for Instruction<'a> {
             Instruction::StoreBatchNamed(d_hash, n_hash, typ, val) => {
                 write!(f, "sbn {} {} {} {}", d_hash, n_hash, typ, val)
             }
+            Instruction::LoadReagent(reg, device, reagent_mode, reagent_hash) => {
+                write!(f, "lr {} {} {} {}", reg, device, reagent_mode, reagent_hash)
+            }
             Instruction::Jump(lbl) => write!(f, "j {}", lbl),
             Instruction::JumpAndLink(lbl) => write!(f, "jal {}", lbl),
             Instruction::JumpRelative(off) => write!(f, "jr {}", off),

rust_compiler/libs/optimizer/src/leaf_function.rs

@@ -14,6 +14,10 @@ pub fn find_leaf_functions(instructions: &[InstructionNode]) -> HashSet<String>
     for node in instructions {
         match &node.instruction {
             Instruction::LabelDef(label) => {
+                if label.starts_with("__internal_L") {
+                    continue;
+                }
+
                 // If we were tracking a function, and it remained a leaf until now, save it.
                 if let Some(name) = current_label.take()
                     && is_current_leaf

rust_compiler/libs/optimizer/src/lib.rs

@@ -99,7 +99,7 @@ fn optimize_leaf_functions<'a>(
     // First scan: Identify instructions to remove and capture RA offsets
     for (i, node) in input.iter().enumerate() {
         match &node.instruction {
-            Instruction::LabelDef(label) => {
+            Instruction::LabelDef(label) if !label.starts_with("__internal_L") => {
                 current_function = Some(label.to_string());
                 function_start_indices.insert(label.to_string(), i);
             }
@@ -174,7 +174,9 @@ fn optimize_leaf_functions<'a>(
             continue; // SKIP (Remove)
         }
 
-        if let Instruction::LabelDef(l) = &node.instruction {
+        if let Instruction::LabelDef(l) = &node.instruction
+            && !l.starts_with("__internal_L")
+        {
             processing_function = Some(l.to_string());
         }
 
@@ -563,6 +565,7 @@ fn get_destination_reg(instr: &Instruction) -> Option<u8> {
         | Instruction::Sqrt(Operand::Register(r), _)
         | Instruction::Tan(Operand::Register(r), _)
         | Instruction::Trunc(Operand::Register(r), _)
+        | Instruction::LoadReagent(Operand::Register(r), _, _, _)
         | Instruction::Pop(Operand::Register(r)) => Some(*r),
         _ => None,
     }
@@ -593,6 +596,9 @@ fn set_destination_reg<'a>(instr: &Instruction<'a>, new_reg: u8) -> Option<Instr
             c.clone(),
             d.clone(),
         )),
+        Instruction::LoadReagent(_, b, c, d) => {
+            Some(Instruction::LoadReagent(r, b.clone(), c.clone(), d.clone()))
+        }
         Instruction::SetEq(_, a, b) => Some(Instruction::SetEq(r, a.clone(), b.clone())),
         Instruction::SetNe(_, a, b) => Some(Instruction::SetNe(r, a.clone(), b.clone())),
         Instruction::SetGt(_, a, b) => Some(Instruction::SetGt(r, a.clone(), b.clone())),
@@ -655,6 +661,14 @@ fn reg_is_read(instr: &Instruction, reg: u8) -> bool {
 
         Instruction::BranchEqZero(a, _) | Instruction::BranchNeZero(a, _) => check(a),
 
+        Instruction::LoadReagent(_, device, _, item_hash) => check(device) || check(item_hash),
+
+        Instruction::LoadSlot(_, dev, slot, _) => check(dev) || check(slot),
+        Instruction::LoadBatch(_, dev, _, mode) => check(dev) || check(mode),
+        Instruction::LoadBatchNamed(_, d_hash, n_hash, _, mode) => {
+            check(d_hash) || check(n_hash) || check(mode)
+        }
+
         Instruction::SetEq(_, a, b)
         | Instruction::SetNe(_, a, b)
         | Instruction::SetGt(_, a, b)

rust_compiler/libs/parser/src/lib.rs

@@ -1834,20 +1834,8 @@ impl<'a> Parser<'a> {
                 let mut args = args!(3);
                 let next = args.next();
                 let dev_name = literal_or_variable!(next);
-                let next = args.next();
-                let slot_index = get_arg!(Literal, literal_or_variable!(next));
-                if !matches!(
-                    slot_index,
-                    Spanned {
-                        node: Literal::Number(_),
-                        ..
-                    },
-                ) {
-                    return Err(Error::InvalidSyntax(
-                        slot_index.span,
-                        "Expected a number".to_string(),
-                    ));
-                }
+                let slot_index = args.next().ok_or(Error::UnexpectedEOF)?;
+
                 let next = args.next();
                 let slot_logic = get_arg!(Literal, literal_or_variable!(next));
                 if !matches!(
@@ -1864,27 +1852,17 @@ impl<'a> Parser<'a> {
                 }
 
                 Ok(SysCall::System(System::LoadSlot(
-                    dev_name, slot_index, slot_logic,
+                    dev_name,
+                    boxed!(slot_index),
+                    slot_logic,
                 )))
             }
             "setSlot" | "ss" => {
                 let mut args = args!(4);
                 let next = args.next();
                 let dev_name = literal_or_variable!(next);
-                let next = args.next();
-                let slot_index = get_arg!(Literal, literal_or_variable!(next));
-                if !matches!(
-                    slot_index,
-                    Spanned {
-                        node: Literal::Number(_),
-                        ..
-                    }
-                ) {
-                    return Err(Error::InvalidSyntax(
-                        slot_index.span,
-                        "Expected a number".into(),
-                    ));
-                }
+                let slot_index = args.next().ok_or(Error::UnexpectedEOF)?;
+
                 let next = args.next();
                 let slot_logic = get_arg!(Literal, literal_or_variable!(next));
                 if !matches!(
@@ -1904,9 +1882,23 @@ impl<'a> Parser<'a> {
 
                 Ok(SysCall::System(System::SetSlot(
                     dev_name,
-                    slot_index,
+                    boxed!(slot_index),
                     slot_logic,
-                    Box::new(expr),
+                    boxed!(expr),
+                )))
+            }
+            "loadReagent" | "lr" => {
+                let mut args = args!(3);
+                let next = args.next();
+                let device = literal_or_variable!(next);
+                let next = args.next();
+                let reagent_mode = get_arg!(Literal, literal_or_variable!(next));
+                let reagent_hash = args.next().ok_or(Error::UnexpectedEOF)?;
+
+                Ok(SysCall::System(System::LoadReagent(
+                    device,
+                    reagent_mode,
+                    Box::new(reagent_hash),
                 )))
             }
 

rust_compiler/libs/parser/src/sys_call.rs

@@ -223,7 +223,7 @@ documented! {
         /// `let isOccupied = ls(deviceHash, 2, "Occupied");`
         LoadSlot(
             Spanned<LiteralOrVariable<'a>>,
-            Spanned<Literal<'a>>,
+            Box<Spanned<Expression<'a>>>,
             Spanned<Literal<'a>>
         ),
         /// Stores a value of LogicType on a device by the index value
@@ -234,7 +234,19 @@ documented! {
         /// `ss(deviceHash, 0, "Open", true);`
         SetSlot(
             Spanned<LiteralOrVariable<'a>>,
+            Box<Spanned<Expression<'a>>>,
             Spanned<Literal<'a>>,
+            Box<Spanned<Expression<'a>>>
+        ),
+        /// Loads reagent of device's ReagentMode where a hash of the reagent type to check for
+        ///
+        /// ## IC10
+        /// `lr r? device(d?|r?|id) reagentMode int`
+        /// ## Slang
+        /// `let result = loadReagent(deviceHash, "ReagentMode", reagentHash);`
+        /// `let result = lr(deviceHash, "ReagentMode", reagentHash);`
+        LoadReagent(
+            Spanned<LiteralOrVariable<'a>>,
             Spanned<Literal<'a>>,
             Box<Spanned<Expression<'a>>>
         )
@@ -261,6 +273,7 @@ impl<'a> std::fmt::Display for System<'a> {
             }
             System::LoadSlot(a, b, c) => write!(f, "loadSlot({}, {}, {})", a, b, c),
             System::SetSlot(a, b, c, d) => write!(f, "setSlot({}, {}, {}, {})", a, b, c, d),
+            System::LoadReagent(a, b, c) => write!(f, "loadReagent({}, {}, {})", a, b, c),
         }
     }
 }

rust_compiler/libs/parser/src/test/blocks.rs

@@ -1,6 +1,6 @@
-use tokenizer::Tokenizer;
-
 use crate::Parser;
+use pretty_assertions::assert_eq;
+use tokenizer::Tokenizer;
 
 #[test]
 fn test_block() -> anyhow::Result<()> {

rust_compiler/libs/parser/src/test/mod.rs

@@ -54,10 +54,7 @@ fn test_const_declaration() -> Result<()> {
     let tokenizer = Tokenizer::from(input);
     let mut parser = Parser::new(tokenizer);
 
-    assert_eq!(
-        "(const item = 293.15)",
-        parser.parse()?.unwrap().to_string()
-    );
+    assert_eq!("(const item = 20c)", parser.parse()?.unwrap().to_string());
 
     assert_eq!(
         "(const decimal = 200.15)",

rust_compiler/libs/tokenizer/src/token.rs

@@ -102,48 +102,6 @@ impl<'a> Token<'a> {
     }
 }
 
-#[derive(Debug, PartialEq, Hash, Eq, Clone)]
-pub enum Temperature {
-    Celsius(Number),
-    Fahrenheit(Number),
-    Kelvin(Number),
-}
-
-impl std::fmt::Display for Temperature {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Temperature::Celsius(n) => write!(f, "{}°C", n),
-            Temperature::Fahrenheit(n) => write!(f, "{}°F", n),
-            Temperature::Kelvin(n) => write!(f, "{}°K", n),
-        }
-    }
-}
-
-impl Temperature {
-    pub fn to_kelvin(self) -> Number {
-        match self {
-            Temperature::Celsius(n) => {
-                let n = match n {
-                    Number::Integer(i) => Decimal::new(i as i64, 0),
-                    Number::Decimal(d) => d,
-                };
-                Number::Decimal(n + Decimal::new(27315, 2))
-            }
-            Temperature::Fahrenheit(n) => {
-                let n = match n {
-                    Number::Integer(i) => Decimal::new(i as i64, 0),
-                    Number::Decimal(d) => d,
-                };
-
-                let a = n - Decimal::new(32, 0);
-                let b = Decimal::new(5, 0) / Decimal::new(9, 0);
-                Number::Decimal(a * b + Decimal::new(27315, 2))
-            }
-            Temperature::Kelvin(n) => n,
-        }
-    }
-}
-
 macro_rules! symbol {
     ($var:ident) => {
         |_| Symbol::$var
@@ -157,7 +115,7 @@ macro_rules! keyword {
 }
 
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Logos)]
-#[logos(skip r"[ \t\f]+")]
+#[logos(skip r"[ \r\t\f]+")]
 #[logos(extras = Extras)]
 #[logos(error(LexError, LexError::from_lexer))]
 pub enum TokenType<'a> {
@@ -280,30 +238,27 @@ fn parse_number<'a>(lexer: &mut Lexer<'a, TokenType<'a>>) -> Result<Number, LexE
     span.end -= lexer.extras.line_start_index;
     span.start -= lexer.extras.line_start_index;
 
-    let num = if clean_str.contains('.') {
-        Number::Decimal(
+    let unit = match suffix {
+        Some('c') => Unit::Celsius,
+        Some('f') => Unit::Fahrenheit,
+        Some('k') => Unit::Kelvin,
+        _ => Unit::None,
+    };
+
+    if clean_str.contains('.') {
+        Ok(Number::Decimal(
             clean_str
                 .parse::<Decimal>()
                 .map_err(|_| LexError::NumberParse(line, span, slice.to_string()))?,
-        )
+            unit,
+        ))
     } else {
-        Number::Integer(
+        Ok(Number::Integer(
             clean_str
                 .parse::<i128>()
                 .map_err(|_| LexError::NumberParse(line, span, slice.to_string()))?,
-        )
-    };
-
-    if let Some(suffix) = suffix {
-        Ok(match suffix {
-            'c' => Temperature::Celsius(num),
-            'f' => Temperature::Fahrenheit(num),
-            'k' => Temperature::Kelvin(num),
-            _ => unreachable!(),
-        }
-        .to_kelvin())
-    } else {
-        Ok(num)
+            unit,
+        ))
     }
 }
 
@@ -395,25 +350,55 @@ impl<'a> std::fmt::Display for TokenType<'a> {
     }
 }
 
+#[derive(Debug, PartialEq, Hash, Eq, Clone, Copy)]
+pub enum Unit {
+    None,
+    Celsius,
+    Fahrenheit,
+    Kelvin,
+}
+
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Copy)]
 pub enum Number {
     /// Represents an integer number
-    Integer(i128),
+    Integer(i128, Unit),
     /// Represents a decimal type number with a precision of 64 bits
-    Decimal(Decimal),
+    Decimal(Decimal, Unit),
+}
+
+impl Number {
+    pub fn unit(&self) -> Unit {
+        match self {
+            Number::Integer(_, u) => *u,
+            Number::Decimal(_, u) => *u,
+        }
+    }
+
+    pub fn has_unit(&self) -> bool {
+        self.unit() != Unit::None
+    }
 }
 
 impl From<bool> for Number {
     fn from(value: bool) -> Self {
-        Self::Integer(if value { 1 } else { 0 })
+        Self::Integer(if value { 1 } else { 0 }, Unit::None)
     }
 }
 
 impl From<Number> for Decimal {
     fn from(value: Number) -> Self {
-        match value {
-            Number::Decimal(d) => d,
-            Number::Integer(i) => Decimal::from(i),
+        let (val, unit) = match value {
+            Number::Decimal(d, u) => (d, u),
+            Number::Integer(i, u) => (Decimal::from(i), u),
+        };
+
+        match unit {
+            Unit::None | Unit::Kelvin => val,
+            Unit::Celsius => val + Decimal::new(27315, 2),
+            Unit::Fahrenheit => {
+                (val - Decimal::new(32, 0)) * Decimal::new(5, 0) / Decimal::new(9, 0)
+                    + Decimal::new(27315, 2)
+            }
         }
     }
 }
@@ -423,22 +408,48 @@ impl std::ops::Neg for Number {
 
     fn neg(self) -> Self::Output {
         match self {
-            Self::Integer(i) => Self::Integer(-i),
-            Self::Decimal(d) => Self::Decimal(-d),
+            Self::Integer(i, u) => Self::Integer(-i, u),
+            Self::Decimal(d, u) => Self::Decimal(-d, u),
         }
     }
 }
 
+fn determine_target_unit(lhs_unit: Unit, rhs_unit: Unit) -> Option<Unit> {
+    if lhs_unit == rhs_unit {
+        return Some(lhs_unit);
+    }
+    if lhs_unit != Unit::None && rhs_unit == Unit::None {
+        return Some(lhs_unit);
+    }
+    if lhs_unit == Unit::None && rhs_unit != Unit::None {
+        return Some(rhs_unit);
+    }
+    // Mismatched units (C + F) -> Fallback to Kelvin/None
+    None
+}
+
 impl std::ops::Add for Number {
     type Output = Number;
 
     fn add(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (Self::Integer(l), Self::Integer(r)) => Number::Integer(l + r),
-            (Self::Decimal(l), Self::Decimal(r)) => Number::Decimal(l + r),
-            (Self::Integer(l), Self::Decimal(r)) => Number::Decimal(Decimal::from(l) + r),
-            (Self::Decimal(l), Self::Integer(r)) => Number::Decimal(l + Decimal::from(r)),
+        // If we can determine a common target unit (e.g. C + C = C, or C + Scalar = C),
+        // we preserve that unit. Otherwise, we convert to Kelvin (Decimal) and return Unit::None.
+        if let Some(target_unit) = determine_target_unit(self.unit(), rhs.unit()) {
+            return match (self, rhs) {
+                (Self::Integer(l, _), Self::Integer(r, _)) => Number::Integer(l + r, target_unit),
+                (Self::Decimal(l, _), Self::Decimal(r, _)) => Number::Decimal(l + r, target_unit),
+                (Self::Integer(l, _), Self::Decimal(r, _)) => {
+                    Number::Decimal(Decimal::from(l) + r, target_unit)
                 }
+                (Self::Decimal(l, _), Self::Integer(r, _)) => {
+                    Number::Decimal(l + Decimal::from(r), target_unit)
+                }
+            };
+        }
+
+        let l: Decimal = self.into();
+        let r: Decimal = rhs.into();
+        Number::Decimal(l + r, Unit::None)
     }
 }
 
@@ -446,12 +457,22 @@ impl std::ops::Sub for Number {
     type Output = Number;
 
     fn sub(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (Self::Integer(l), Self::Integer(r)) => Self::Integer(l - r),
-            (Self::Decimal(l), Self::Integer(r)) => Self::Decimal(l - Decimal::from(r)),
-            (Self::Integer(l), Self::Decimal(r)) => Self::Decimal(Decimal::from(l) - r),
-            (Self::Decimal(l), Self::Decimal(r)) => Self::Decimal(l - r),
+        if let Some(target_unit) = determine_target_unit(self.unit(), rhs.unit()) {
+            return match (self, rhs) {
+                (Self::Integer(l, _), Self::Integer(r, _)) => Number::Integer(l - r, target_unit),
+                (Self::Decimal(l, _), Self::Decimal(r, _)) => Number::Decimal(l - r, target_unit),
+                (Self::Integer(l, _), Self::Decimal(r, _)) => {
+                    Number::Decimal(Decimal::from(l) - r, target_unit)
                 }
+                (Self::Decimal(l, _), Self::Integer(r, _)) => {
+                    Number::Decimal(l - Decimal::from(r), target_unit)
+                }
+            };
+        }
+
+        let l: Decimal = self.into();
+        let r: Decimal = rhs.into();
+        Number::Decimal(l - r, Unit::None)
     }
 }
 
@@ -459,12 +480,26 @@ impl std::ops::Mul for Number {
     type Output = Number;
 
     fn mul(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (Number::Integer(l), Number::Integer(r)) => Number::Integer(l * r),
-            (Number::Integer(l), Number::Decimal(r)) => Number::Decimal(Decimal::from(l) * r),
-            (Number::Decimal(l), Number::Integer(r)) => Number::Decimal(l * Decimal::from(r)),
-            (Number::Decimal(l), Number::Decimal(r)) => Number::Decimal(l * r),
+        if let Some(target_unit) = determine_target_unit(self.unit(), rhs.unit()) {
+            return match (self, rhs) {
+                (Number::Integer(l, _), Number::Integer(r, _)) => {
+                    Number::Integer(l * r, target_unit)
                 }
+                (Number::Integer(l, _), Number::Decimal(r, _)) => {
+                    Number::Decimal(Decimal::from(l) * r, target_unit)
+                }
+                (Number::Decimal(l, _), Number::Integer(r, _)) => {
+                    Number::Decimal(l * Decimal::from(r), target_unit)
+                }
+                (Number::Decimal(l, _), Number::Decimal(r, _)) => {
+                    Number::Decimal(l * r, target_unit)
+                }
+            };
+        }
+
+        let l: Decimal = self.into();
+        let r: Decimal = rhs.into();
+        Number::Decimal(l * r, Unit::None)
     }
 }
 
@@ -472,7 +507,22 @@ impl std::ops::Div for Number {
     type Output = Number;
 
     fn div(self, rhs: Self) -> Self::Output {
-        Number::Decimal(Decimal::from(self) / Decimal::from(rhs))
+        if let Some(target_unit) = determine_target_unit(self.unit(), rhs.unit()) {
+            // Division always promotes to Decimal
+            let l_val = match self {
+                Self::Integer(i, _) => Decimal::from(i),
+                Self::Decimal(d, _) => d,
+            };
+            let r_val = match rhs {
+                Self::Integer(i, _) => Decimal::from(i),
+                Self::Decimal(d, _) => d,
+            };
+            return Number::Decimal(l_val / r_val, target_unit);
+        }
+
+        let l: Decimal = self.into();
+        let r: Decimal = rhs.into();
+        Number::Decimal(l / r, Unit::None)
     }
 }
 
@@ -480,15 +530,36 @@ impl std::ops::Rem for Number {
     type Output = Number;
 
     fn rem(self, rhs: Self) -> Self::Output {
-        Number::Decimal(Decimal::from(self) % Decimal::from(rhs))
+        if let Some(target_unit) = determine_target_unit(self.unit(), rhs.unit()) {
+            let l_val = match self {
+                Self::Integer(i, _) => Decimal::from(i),
+                Self::Decimal(d, _) => d,
+            };
+            let r_val = match rhs {
+                Self::Integer(i, _) => Decimal::from(i),
+                Self::Decimal(d, _) => d,
+            };
+            return Number::Decimal(l_val % r_val, target_unit);
+        }
+
+        let l: Decimal = self.into();
+        let r: Decimal = rhs.into();
+        Number::Decimal(l % r, Unit::None)
     }
 }
 
 impl std::fmt::Display for Number {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Number::Integer(i) => write!(f, "{}", i),
-            Number::Decimal(d) => write!(f, "{}", d),
+        let (val, unit) = match self {
+            Number::Integer(i, u) => (i.to_string(), u),
+            Number::Decimal(d, u) => (d.to_string(), u),
+        };
+
+        match unit {
+            Unit::None => write!(f, "{}", val),
+            Unit::Celsius => write!(f, "{}c", val),
+            Unit::Fahrenheit => write!(f, "{}f", val),
+            Unit::Kelvin => write!(f, "{}k", val),
         }
     }
 }
@@ -771,3 +842,21 @@ documented! {
         While,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::TokenType;
+    use logos::Logos;
+
+    #[test]
+    fn test_windows_crlf_endings() -> anyhow::Result<()> {
+        let src = "let i = 0;\r\n";
+
+        let lexer = TokenType::lexer(src);
+
+        let tokens = lexer.collect::<Vec<_>>();
+
+        assert!(!tokens.iter().any(|res| res.is_err()));
+        Ok(())
+    }
+}

rust_compiler/src/main.rs

@@ -53,6 +53,9 @@ struct Args {
     /// The output file for the compiled program. If not set, output will go to stdout.
     #[arg(short, long)]
     output_file: Option<PathBuf>,
+    /// Should Slang attempt to optimize the output?
+    #[arg(short = 'z', long)]
+    optimize: bool,
 }
 
 fn run_logic<'a>() -> Result<(), Error<'a>> {
@@ -107,7 +110,11 @@ fn run_logic<'a>() -> Result<(), Error<'a>> {
         }
     }
 
+    if args.optimize {
         optimizer::optimize(instructions).write(&mut writer)?;
+    } else {
+        instructions.write(&mut writer)?;
+    }
 
     writer.flush()?;
 

spilling.slang

@@ -1,43 +0,0 @@
-device self = "db";
-device gasSensor  = "d0";
-device atmosAnal  = "d1";
-device atmosValve = "d2";
-device atmosTank  = "d3";
-device atmosInlet = "d4";
-
-atmosInlet.Lock = true;
-atmosInlet.Mode = 1;
-atmosValve.On = false;
-atmosValve.Lock = true;
-
-let isPumping = false;
-let tempPressure = 0;
-
-loop {
-  yield();
-  let temp = gasSensor.Temperature;
-  let pres = atmosAnal.Pressure;
-  let liqV = atmosAnal.VolumeOfLiquid;
-  let tempVol = atmosAnal.Volume;
-
-  let stress = 5_000 * liqV / tempVol;
-
-  tempPressure = isPumping ? 1_000 : 10_000;
-
-  let shouldTurnOnInlet = (
-    temp > 0c &&
-    pres < tempPressure &&
-    stress < 50
-  );
-
-  isPumping = (
-    !shouldTurnOnInlet &&
-    atmosTank.Pressure < 35_000 &&
-    atmosAnal.RatioPollutant == 0 &&
-    atmosAnal.RatioLiquidPollutant == 0 &&
-    atmosAnal.Pressure > 1_000
-  );
-
-  atmosValve.On = isPumping;
-  atmosInlet.On = shouldTurnOnInlet;
-}

test.slang

@@ -1,72 +0,0 @@
-/// Laree script V1
-
-device self = "db";
-device larre = "d0";
-device exportChute = "d1";
-
-const TOTAL_SLOTS = 19;
-const EXPORT_CHUTE = 1;
-const START_STATION = 2;
-
-let currentIndex = 0;
-
-/// Waits for the larre to be idle before continuing
-fn waitForIdle() {
-  yield();
-  while (!larre.Idle) {
-    yield();
-  }
-}
-
-/// Instructs the Larre to go to the chute and deposit
-/// what is currently in its arm
-fn deposit() {
-  larre.Setting = EXPORT_CHUTE;
-  waitForIdle();
-  larre.Activate = true;
-  waitForIdle();
-  exportChute.Open = false;
-}
-
-/// This function is responsible for checking the plant under
-/// the larre at this index, and harvesting if applicable
-fn checkAndHarvest(currentIndex) {
-  if (currentIndex <= EXPORT_CHUTE || ls(larre, 255, "Seeding") < 1) {
-    return;
-  }
-
-  // harvest from this device
-  while (ls(larre, 255, "Mature")) {
-    yield();
-    larre.Activate = true;
-  }
-  let hasRemainingPlant = ls(larre, 255, "Occupied");
-
-  // move to the export chute
-  larre.Setting = EXPORT_CHUTE;
-  waitForIdle();
-  deposit();
-  if (hasRemainingPlant) {
-    deposit();
-  }
-
-  larre.Setting = currentIndex;
-  waitForIdle();
-
-  if (ls(larre, 0, "Occupied")) {
-    larre.Activate = true;
-  }
-  waitForIdle();
-}
-
-loop {
-  yield();
-  if (!larre.Idle) {
-    continue;
-  }
-  let newIndex = currentIndex + 1 > TOTAL_SLOTS ? START_STATION : currentIndex + 1;
-
-  checkAndHarvest(currentIndex);
-  larre.Setting = newIndex;
-  currentIndex = newIndex;
-}