allow MutableScripts to be directly executed

merges the shared logic into a base class to be inherited by Script and MutableScript; changed existing usages of Script to ExecutableScript.

This change allows you more flexibility in setting up your own Starscript compilation pipeline, and even the ability to precompile scripts and then just load their files (compile, save, stop the program, load the file, works as if it was just compiled) if you want; since all the Hypervisor expects is an RO span of Value constants and bytes for code, with a few helpers that exist on the base class.

Author: GreemDev

src/Lib/Internal/ExecutableScript.cs

@@ -0,0 +1,40 @@
+namespace Starscript.Internal;
+
+public abstract class ExecutableScript : IDisposable
+{
+    public bool IsDisposed { get; protected set; }
+    
+    public abstract ReadOnlySpan<byte> Code { get; }
+
+    public abstract ReadOnlySpan<Value> Constants { get; }
+    
+    public virtual byte GetByteAt(int idx) => Code[idx];
+
+    public int GetMaskedByteAt(int idx) => GetByteAt(idx) & 0xFF;
+
+    public StringSegment Execute(StarscriptHypervisor hypervisor)
+    {
+        if (IsDisposed)
+            throw new ObjectDisposedException(nameof(ExecutableScript), "Cannot execute a disposed Script.");
+
+        return hypervisor.Run(this);
+    }
+
+    public StringSegment Execute(StarscriptHypervisor hypervisor, ValueMap locals)
+    {
+        if (IsDisposed)
+            throw new ObjectDisposedException(nameof(ExecutableScript), "Cannot execute a disposed Script.");
+
+        return hypervisor.Run(this, locals);
+    }
+
+    public StringSegment Execute(StarscriptHypervisor hypervisor, IStarscriptObject obj)
+    {
+        if (IsDisposed)
+            throw new ObjectDisposedException(nameof(ExecutableScript), "Cannot execute a disposed Script.");
+
+        return hypervisor.Run(this, obj);
+    }
+
+    public abstract void Dispose();
+}

src/Lib/Internal/MutableScript.cs

@@ -1,15 +1,20 @@
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using Starscript.Internal;
 using Starscript.Util;
 
 namespace Starscript;
 
-public class MutableScript
+public class MutableScript : ExecutableScript
 {
-    public List<Value> Constants { get; } = [];
+    private readonly List<Value> _constants = [];
+
+    public override ReadOnlySpan<Value> Constants => CollectionsMarshal.AsSpan(_constants);
 
     public ResizableBuffer<byte> CodeBuffer { get; } = new();
 
+    public override ReadOnlySpan<byte> Code => CodeBuffer.RoSpan;
+
     public Script MoveToImmutable()
     {
         // Trim the excess (null) bytes before copying
@@ -20,7 +25,7 @@ public Script MoveToImmutable()
 
         // Clear the current script's memory, potentially useful for a reusable script instance system in the future(?)
         CodeBuffer.ResetAndClear();
-        Constants.Clear();
+        _constants.Clear();
 
 #if DEBUG
         Compiler.DebugLog($"Resulting immutable script size in bytes after move: {codeCopy.Length * Unsafe.SizeOf<byte>()}");
@@ -32,6 +37,8 @@ public Script MoveToImmutable()
         );
     }
 
+    #region Script writing
+
     /// <summary>
     ///     Write an <see cref="Instruction"/> to this <see cref="MutableScript"/>.
     /// </summary>
@@ -62,7 +69,7 @@ public void WriteConstant(Value constant)
     {
         var constIndex = -1;
 
-        foreach (var (idx, value) in Constants.Index())
+        foreach (var (idx, value) in _constants.Index())
         {
             if (value == constant)
             {
@@ -73,10 +80,10 @@ public void WriteConstant(Value constant)
 
         if (constIndex is -1)
         {
-            constIndex = Constants.Count;
-            Constants.Add(constant);
+            constIndex = _constants.Count;
+            _constants.Add(constant);
         }
-        
+
         CodeBuffer.Write((byte)constIndex);
     }
 
@@ -103,4 +110,24 @@ public void PatchJump(int offset)
         CodeBuffer.Span[offset] = (byte)((jump >> 8) & 0xFF);
         CodeBuffer.Span[offset + 1] = (byte)(jump & 0xFF);
     }
+
+    #endregion
+    
+    public override void Dispose()
+    {
+        if (IsDisposed)
+            throw new ObjectDisposedException(nameof(MutableScript), "Cannot dispose an already disposed Script.");
+        
+        _constants.Clear();
+        _constants.TrimExcess();
+        CodeBuffer.ResetAndClear();
+
+#if DEBUG
+        Compiler.DebugLog("Destroyed mutable script");
+#endif
+
+        IsDisposed = true;
+
+        GC.SuppressFinalize(this);
+    }
 }

src/Lib/Public/Entities/Script.cs

@@ -1,59 +1,33 @@
-namespace Starscript;
+using Starscript.Internal;
 
-public class Script : IDisposable
+namespace Starscript;
+
+public class Script : ExecutableScript
 {
-    private bool _disposed;
-    
     private byte[] _code;
     private Value[] _constants;
 
-    public ReadOnlySpan<byte> Code => _code;
+    public override ReadOnlySpan<byte> Code => _code;
 
-    public ReadOnlySpan<Value> Constants => _constants;
+    public override ReadOnlySpan<Value> Constants => _constants;
 
     public Script(byte[] codeBuffer, Value[] constants)
     {
         _code = codeBuffer;
         _constants = constants;
     }
 
-    public byte GetByteAt(int idx)
+    public override byte GetByteAt(int idx)
     {
-        if (_disposed)
+        if (IsDisposed)
             throw new ObjectDisposedException(nameof(Script), "Cannot access bytecode of a disposed Script.");
 
         return _code[idx];
     }
 
-    public int GetMaskedByteAt(int idx) => GetByteAt(idx) & 0xFF;
-
-    public StringSegment Execute(StarscriptHypervisor hypervisor)
-    {
-        if (_disposed)
-            throw new ObjectDisposedException(nameof(Script), "Cannot execute a disposed Script.");
-
-        return hypervisor.Run(this);
-    }
-
-    public StringSegment Execute(StarscriptHypervisor hypervisor, ValueMap locals)
-    {
-        if (_disposed)
-            throw new ObjectDisposedException(nameof(Script), "Cannot execute a disposed Script.");
-
-        return hypervisor.Run(this, locals);
-    }
-
-    public StringSegment Execute(StarscriptHypervisor hypervisor, IStarscriptObject obj)
-    {
-        if (_disposed)
-            throw new ObjectDisposedException(nameof(Script), "Cannot execute a disposed Script.");
-
-        return hypervisor.Run(this, obj);
-    }
-
-    public void Dispose()
+    public override void Dispose()
     {
-        if (_disposed)
+        if (IsDisposed)
             throw new ObjectDisposedException(nameof(Script), "Cannot dispose an already disposed Script.");
 
         Array.Resize(ref _code, 0);
@@ -63,7 +37,7 @@ public void Dispose()
         Compiler.DebugLog("Destroyed script");
 #endif
 
-        _disposed = true;
+        IsDisposed = true;
 
         GC.SuppressFinalize(this);
     }

src/Lib/Public/Hypervisor/Starscript.HV.cs

@@ -6,7 +6,7 @@ namespace Starscript;
 
 public partial class StarscriptHypervisor
 {
-    internal StringSegment RunImpl(Script script, StringBuilder sb)
+    internal StringSegment RunImpl(ExecutableScript script, StringBuilder sb)
     {
         _stack.Clear();
 

src/Lib/Public/Starscript.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Text;
+using Starscript.Internal;
 using Starscript.Util;
 
 namespace Starscript;
@@ -59,20 +60,20 @@ public StarscriptHypervisor ReplaceLocals(ValueMap locals)
     public StarscriptHypervisor ReplaceLocals(IStarscriptObject locals) 
         => ReplaceLocals(locals.ToStarscript());
 
-    public StringSegment Run(Script script) => RunImpl(script, new StringBuilder());
+    public StringSegment Run(ExecutableScript script) => RunImpl(script, new StringBuilder());
 
     /// <summary>
     ///     Calls <see cref="Run(Script)"/> after calling <see cref="ReplaceLocals(Starscript.ValueMap)"/>.
     /// </summary>
     /// <remarks>The internal locals map has been reset by the time this method returns, if persistent locals is disabled.</remarks>
-    public StringSegment Run(Script script, ValueMap locals) 
+    public StringSegment Run(ExecutableScript script, ValueMap locals) 
         => ReplaceLocals(locals).Run(script);
 
     /// <summary>
     ///     Calls <see cref="Run(Script)"/> after calling <see cref="ReplaceLocals(Starscript.IStarscriptObject)"/>.
     /// </summary>
     /// <remarks>The internal locals map has been reset by the time this method returns, if persistent locals is disabled.</remarks>
-    public StringSegment Run(Script script, IStarscriptObject locals) 
+    public StringSegment Run(ExecutableScript script, IStarscriptObject locals) 
         => ReplaceLocals(locals).Run(script);
 
 #if DEBUG