diff --git a/README.md b/README.md
index fd3035e2..32b1297b 100644
--- a/README.md
+++ b/README.md
@@ -537,6 +537,8 @@ print(v1 - v2) -- <-1, -1, -1>
> [!NOTE]
> `__index` and `__newindex` cannot be set as they are used internally by the code generated by `[LuaObject]`.
+Generated default metatables are immutable and shared by all instances of the same C# type, across Lua states. You can still assign writable C# members from Lua. To customize an individual object's metatable, replace `ILuaUserData.Metatable` in C# or use `debug.setmetatable` in Lua; replacement tables remain mutable. Ordinary Lua tables and metatables remain mutable.
+
## Module Loading
In Lua, you can load modules using the `require` function. In regular Lua, modules are managed by searchers within the `package.searchers` function list. In addition to this, Lua-CSharp provides `ILuaModuleLoader` as a module loading mechanism.
diff --git a/sandbox/Benchmark/Benchmark.csproj b/sandbox/Benchmark/Benchmark.csproj
index 8ace8446..dd064769 100644
--- a/sandbox/Benchmark/Benchmark.csproj
+++ b/sandbox/Benchmark/Benchmark.csproj
@@ -15,6 +15,12 @@
+
+
diff --git a/sandbox/Benchmark/CoroutineTransferBenchmark.cs b/sandbox/Benchmark/CoroutineTransferBenchmark.cs
new file mode 100644
index 00000000..f0bc2acb
--- /dev/null
+++ b/sandbox/Benchmark/CoroutineTransferBenchmark.cs
@@ -0,0 +1,61 @@
+using BenchmarkDotNet.Attributes;
+using Lua;
+using Lua.Runtime;
+using Lua.Standard;
+
+[Config(typeof(ComparisonConfig))]
+public class CoroutineTransferBenchmark
+{
+ [Params("resume", "wrap")]
+ public string Operation { get; set; } = "resume";
+
+ [Params(1, 64, 4096)]
+ public int ResultCount { get; set; }
+
+ [Params(false, true)]
+ public bool Cancellable { get; set; }
+
+ LuaState state = default!;
+ LuaClosure closure = default!;
+ CancellationTokenSource cancellation = default!;
+
+ [GlobalSetup]
+ public void Setup()
+ {
+ state = LuaState.Create();
+ state.OpenStandardLibraries();
+ cancellation = new();
+ state.Environment["packet"] = new LuaFunction(
+ (context, _) =>
+ {
+ context.GetReturnBuffer(ResultCount).Fill(42);
+ return new(ResultCount);
+ }
+ );
+ closure = state.Load(
+ Operation == "wrap"
+ ? "local run=coroutine.wrap(function() for i=1,64 do coroutine.yield(packet()) end end); for i=1,64 do run() end; run(); return 42"
+ : "local co=coroutine.create(function() for i=1,64 do coroutine.yield(packet()) end end); for i=1,64 do coroutine.resume(co) end; coroutine.resume(co); return 42",
+ "coroutine-transfer"
+ );
+ if (Run() != 42)
+ throw new InvalidOperationException("Unexpected coroutine transfer result");
+ }
+
+ [Benchmark(OperationsPerInvoke = 64)]
+ public int Run()
+ {
+ state
+ .RunAsync(closure, 0, Cancellable ? cancellation.Token : default)
+ .GetAwaiter()
+ .GetResult();
+ return state.Stack.Pop().Read();
+ }
+
+ [GlobalCleanup]
+ public void Cleanup()
+ {
+ cancellation.Dispose();
+ state.Dispose();
+ }
+}
diff --git a/sandbox/Benchmark/GeneratedUserDataBenchmark.cs b/sandbox/Benchmark/GeneratedUserDataBenchmark.cs
new file mode 100644
index 00000000..27fccf23
--- /dev/null
+++ b/sandbox/Benchmark/GeneratedUserDataBenchmark.cs
@@ -0,0 +1,71 @@
+using BenchmarkDotNet.Attributes;
+using Lua;
+using Lua.Runtime;
+
+[Config(typeof(ComparisonConfig))]
+public class GeneratedUserDataBenchmark
+{
+ [Params("field", "method", "comparison", "write")]
+ public string Case { get; set; } = "field";
+
+ [Params(false, true)]
+ public bool OverrideMetatable { get; set; }
+
+ LuaState state = default!;
+ LuaClosure closure = default!;
+
+ [GlobalSetup]
+ public void Setup()
+ {
+ state = LuaState.Create();
+ var first = new GeneratedBenchmarkObject { Value = 7 };
+ var second = new GeneratedBenchmarkObject { Value = 8 };
+ if (OverrideMetatable)
+ {
+ ILuaUserData left = first;
+ ILuaUserData right = second;
+ left.Metatable = left.Metatable;
+ right.Metatable = right.Metatable;
+ }
+ state.Environment["first"] = first;
+ state.Environment["second"] = second;
+ var (source, expected) = Case switch
+ {
+ "field" => ("local v=first;local n=0;for i=1,1000 do n=n+v.Value end;return n", 7000),
+ "method" => ("local v=first;local n=0;for i=1,1000 do n=n+v:Add(1) end;return n", 8000),
+ "comparison" => (
+ "local a,b=first,second;local n=0;for i=1,1000 do if a ("local v=first;for i=1,1000 do v.Value=i end;return v.Value", 1000),
+ _ => throw new ArgumentOutOfRangeException(nameof(Case)),
+ };
+ closure = state.Load(source, Case);
+ if (Run() != expected)
+ throw new InvalidOperationException($"Unexpected result for {Case}");
+ }
+
+ [Benchmark(OperationsPerInvoke = 1000)]
+ public int Run()
+ {
+ state.RunAsync(closure).GetAwaiter().GetResult();
+ return state.Stack.Pop().Read();
+ }
+
+ [GlobalCleanup]
+ public void Cleanup() => state.Dispose();
+}
+
+[LuaObject]
+public partial class GeneratedBenchmarkObject
+{
+ [LuaMember]
+ public int Value { get; set; }
+
+ [LuaMember]
+ public int Add(int value) => Value + value;
+
+ [LuaMetamethod(LuaObjectMetamethod.Lt)]
+ public static bool Less(GeneratedBenchmarkObject left, GeneratedBenchmarkObject right) =>
+ left.Value < right.Value;
+}
diff --git a/sandbox/Benchmark/Program.cs b/sandbox/Benchmark/Program.cs
index 5999c35f..bcfce358 100644
--- a/sandbox/Benchmark/Program.cs
+++ b/sandbox/Benchmark/Program.cs
@@ -29,6 +29,8 @@
typeof(InterpreterComparison),
typeof(CompilationComparison),
typeof(StartupComparison),
+ typeof(GeneratedUserDataBenchmark),
+ typeof(CoroutineTransferBenchmark),
])
.Run(args);
diff --git a/sandbox/Benchmark/README.md b/sandbox/Benchmark/README.md
index d45b9fab..9f441ce1 100644
--- a/sandbox/Benchmark/README.md
+++ b/sandbox/Benchmark/README.md
@@ -25,6 +25,8 @@ measure Unicode encoding or arbitrary binary strings.
| `InterpreterComparison` | Execute a retained compiled chunk and read one numeric result | Numeric loops, Lua calls/varargs, table access/sort, metamethods, math, strings, patterns, coroutines, host callbacks, n-body |
| `CompilationComparison` | Compile source in an existing state; no execution | Small loop, n-body, control flow, identifiers, plain strings, escaped strings |
| `StartupComparison` | Create a state, open libraries, dispose where supported | One lifecycle per engine |
+| `GeneratedUserDataBenchmark` | Execute 1,000 generated C# member accesses or comparisons; report time per operation | Property reads/writes, method calls, comparisons, with default and explicitly replaced metatables |
+| `CoroutineTransferBenchmark` | Transfer 64 yielded packets; report time per transfer | `resume` and `wrap`, 1–4,096 results per packet, with and without cancellation |
Only the engine being measured is initialized for a benchmark. Execution
excludes source compilation and state setup. Scripts rebuild their mutable
@@ -52,6 +54,8 @@ equivalent deterministic disposal API.
dotnet bin/Release/net10.0/Benchmark.dll --filter '*InterpreterComparison*host-calls*'
dotnet bin/Release/net10.0/Benchmark.dll --filter '*CompilationComparison*'
dotnet bin/Release/net10.0/Benchmark.dll --filter '*StartupComparison*'
+dotnet bin/Release/net10.0/Benchmark.dll --filter '*GeneratedUserDataBenchmark*'
+dotnet bin/Release/net10.0/Benchmark.dll --filter '*CoroutineTransferBenchmark*'
dotnet bin/Release/net10.0/Benchmark.dll --legacy --filter '*GSubBenchmark*'
```
diff --git a/src/Lua.SourceGenerator/LuaObjectGenerator.Emit.cs b/src/Lua.SourceGenerator/LuaObjectGenerator.Emit.cs
index 567b89b3..fc3fc078 100644
--- a/src/Lua.SourceGenerator/LuaObjectGenerator.Emit.cs
+++ b/src/Lua.SourceGenerator/LuaObjectGenerator.Emit.cs
@@ -236,10 +236,7 @@ TempCollections tempCollections
metamethodSet.Add(LuaObjectMetamethod.NewIndex);
- if (!TryEmitMetatable(builder, metamethodSet, context))
- {
- return false;
- }
+ EmitMetatable(builder, metamethodSet);
// implicit operator
builder.AppendLine(
@@ -1342,62 +1339,74 @@ static void EmitMethodFunctionBody(
}
}
- static bool TryEmitMetatable(
- CodeBuilder builder,
- IEnumerable metamethods,
- in SourceProductionContext context
- )
+ static void EmitMetatable(CodeBuilder builder, IEnumerable metamethods)
{
builder.AppendLine("global::Lua.LuaTable? global::Lua.ILuaUserData.Metatable");
using (builder.BeginBlockScope())
- {
- builder.AppendLine("get => Metatable;");
- builder.AppendLine("set => Metatable = value;");
- }
- builder.AppendLine("static global::Lua.LuaTable? Metatable");
- using (builder.BeginBlockScope())
{
builder.AppendLine("get");
using (builder.BeginBlockScope())
{
builder.AppendLine(
- "var metatable = global::System.Threading.Volatile.Read(ref __metatable);"
- );
- builder.AppendLine("if (metatable != null) return metatable;");
- builder.AppendLine();
- builder.AppendLine("metatable = new();");
- foreach (var metamethod in metamethods)
- {
- var metaMethodName = metamethod.ToString();
- var lowerName = metaMethodName.ToLower();
- builder.AppendLine(
- $"metatable[global::Lua.Runtime.Metamethods.{metaMethodName}] = __metamethod_{lowerName};"
- );
- }
-
- builder.AppendLine(
- "// Publish only a complete table. Concurrent readers share the winning instance,"
+ "var overrides = global::System.Threading.Volatile.Read(ref __metatableOverrides);"
);
builder.AppendLine(
- "// including a custom metatable installed while initialization was in progress."
+ "return overrides != null && overrides.TryGetValue(this, out var entry) ? entry.Value : __metatable;"
);
+ }
+ builder.AppendLine("set");
+ using (builder.BeginBlockScope())
+ {
builder.AppendLine(
- "return global::System.Threading.Interlocked.CompareExchange(ref __metatable, metatable, null) ?? metatable;"
+ "__GetMetatableOverrides().GetValue(this, _ => new __MetatableOverride(value)).Value = value;"
);
}
+ }
- builder.AppendLine("set");
- using (builder.BeginBlockScope())
+ builder.AppendLine("static global::Lua.LuaTable __CreateMetatable()");
+ using (builder.BeginBlockScope())
+ {
+ builder.AppendLine("var metatable = new global::Lua.LuaTable();");
+ foreach (var metamethod in metamethods)
{
+ var metaMethodName = metamethod.ToString();
+ var lowerName = metaMethodName.ToLower();
builder.AppendLine(
- "global::System.Threading.Volatile.Write(ref __metatable, value);"
+ $"metatable[global::Lua.Runtime.Metamethods.{metaMethodName}] = __metamethod_{lowerName};"
);
}
+ builder.AppendLine("metatable.Freeze();");
+ builder.AppendLine("return metatable;");
}
- builder.AppendLine("static global::Lua.LuaTable? __metatable;");
+ builder.AppendLine("sealed class __MetatableOverride");
+ using (builder.BeginBlockScope())
+ {
+ builder.AppendLine("public volatile global::Lua.LuaTable? Value;");
+ builder.AppendLine(
+ "public __MetatableOverride(global::Lua.LuaTable? value) => Value = value;"
+ );
+ }
+ builder.AppendLine(
+ "static global::System.Runtime.CompilerServices.ConditionalWeakTable? __metatableOverrides;"
+ );
+ builder.AppendLine(
+ "static global::System.Runtime.CompilerServices.ConditionalWeakTable __GetMetatableOverrides()"
+ );
+ using (builder.BeginBlockScope())
+ {
+ builder.AppendLine(
+ "var overrides = global::System.Threading.Volatile.Read(ref __metatableOverrides);"
+ );
+ builder.AppendLine("if (overrides != null) return overrides;");
+ builder.AppendLine("overrides = new();");
+ builder.AppendLine(
+ "return global::System.Threading.Interlocked.CompareExchange(ref __metatableOverrides, overrides, null) ?? overrides;"
+ );
+ }
+ builder.AppendLine(
+ "static readonly global::Lua.LuaTable __metatable = __CreateMetatable();"
+ );
builder.AppendLine();
-
- return true;
}
}
diff --git a/src/Lua/CodeAnalysis/Compilation/BytecodeVerifier.cs b/src/Lua/CodeAnalysis/Compilation/BytecodeVerifier.cs
new file mode 100644
index 00000000..f0a96368
--- /dev/null
+++ b/src/Lua/CodeAnalysis/Compilation/BytecodeVerifier.cs
@@ -0,0 +1,255 @@
+using System.Diagnostics.CodeAnalysis;
+using Lua.Runtime;
+
+namespace Lua.CodeAnalysis.Compilation;
+
+// Loaded chunks cannot share the compiler's operand/bounds guarantees. Verify
+// once at the input boundary so the VM can keep its unchecked register accesses.
+readonly ref struct BytecodeVerifier(Prototype prototype, ReadOnlySpan name)
+{
+ readonly ReadOnlySpan chunkName = name;
+
+ public void Verify()
+ {
+ if (prototype.ParameterCount > prototype.MaxStackSize || prototype.Code.IsEmpty)
+ Invalid("function header");
+
+ var code = prototype.Code;
+ for (var pc = 0; pc < code.Length; pc++)
+ {
+ var instruction = code[pc];
+ var a = instruction.A;
+ var b = instruction.B;
+ var c = instruction.C;
+ switch (instruction.OpCode)
+ {
+ case OpCode.Move:
+ case OpCode.Unm:
+ case OpCode.Not:
+ case OpCode.Len:
+ Register(a);
+ Register(b);
+ break;
+ case OpCode.LoadK:
+ Register(a);
+ Constant(instruction.Bx);
+ break;
+ case OpCode.LoadKX:
+ Register(a);
+ Constant(ExtraArgument(pc));
+ Target(pc + 2);
+ continue;
+ case OpCode.LoadBool:
+ Register(a);
+ Target(pc + (c == 0 ? 1 : 2));
+ continue;
+ case OpCode.LoadNil:
+ Registers(a, b + 1);
+ break;
+ case OpCode.GetUpVal:
+ case OpCode.SetUpVal:
+ Register(a);
+ UpValue(b);
+ break;
+ case OpCode.GetTabUp:
+ Register(a);
+ UpValue(b);
+ RegisterOrConstant(c);
+ break;
+ case OpCode.GetTable:
+ Register(a);
+ Register(b);
+ RegisterOrConstant(c);
+ break;
+ case OpCode.SetTabUp:
+ UpValue(a);
+ RegisterOrConstant(b);
+ RegisterOrConstant(c);
+ break;
+ case OpCode.SetTable:
+ Register(a);
+ RegisterOrConstant(b);
+ RegisterOrConstant(c);
+ break;
+ case OpCode.NewTable:
+ Register(a);
+ break;
+ case OpCode.Self:
+ Registers(a, 2);
+ Register(b);
+ RegisterOrConstant(c);
+ break;
+ case OpCode.Add:
+ case OpCode.Sub:
+ case OpCode.Mul:
+ case OpCode.Div:
+ case OpCode.Mod:
+ case OpCode.Pow:
+ Register(a);
+ RegisterOrConstant(b);
+ RegisterOrConstant(c);
+ break;
+ case OpCode.Concat:
+ Register(a);
+ if (b >= c)
+ Invalid("concatenation range");
+ Registers(b, c - b + 1);
+ break;
+ case OpCode.Jmp:
+ if (a != 0)
+ Register(a - 1);
+ Target(pc + 1 + instruction.SBx);
+ continue;
+ case OpCode.Eq:
+ case OpCode.Lt:
+ case OpCode.Le:
+ Flag(a);
+ RegisterOrConstant(b);
+ RegisterOrConstant(c);
+ Target(pc + 2);
+ break;
+ case OpCode.Test:
+ Register(a);
+ Flag(c);
+ Target(pc + 2);
+ break;
+ case OpCode.TestSet:
+ Register(a);
+ Register(b);
+ Flag(c);
+ Target(pc + 2);
+ break;
+ case OpCode.Call:
+ case OpCode.TailCall:
+ Register(a);
+ if (b != 0)
+ Registers(a, b);
+ if (instruction.OpCode == OpCode.TailCall)
+ continue;
+ if (c != 0)
+ Registers(a, c - 1);
+ break;
+ case OpCode.Return:
+ Registers(a, b == 0 ? 0 : b - 1);
+ continue;
+ case OpCode.ForLoop:
+ case OpCode.ForPrep:
+ Registers(a, 4);
+ Target(pc + 1 + instruction.SBx);
+ if (instruction.OpCode == OpCode.ForPrep)
+ continue;
+ break;
+ case OpCode.TForCall:
+ Registers(a, 3 + c);
+ break;
+ case OpCode.TForLoop:
+ Registers(a, 2);
+ Target(pc + 1 + instruction.SBx);
+ break;
+ case OpCode.SetList:
+ Registers(a, b + 1);
+ var block = c == 0 ? ExtraArgument(pc) : c;
+ if (block == 0 || block > (int.MaxValue - LuaStack.MaxCapacity) / 50 + 1)
+ Invalid("table constructor block");
+ if (c == 0)
+ {
+ Target(pc + 2);
+ continue;
+ }
+ break;
+ case OpCode.Closure:
+ Register(a);
+ if ((uint)instruction.Bx >= (uint)prototype.ChildPrototypes.Length)
+ Invalid("child prototype index");
+ break;
+ case OpCode.VarArg:
+ if (!prototype.HasVariableArguments)
+ Invalid("vararg instruction in fixed-argument function");
+ Registers(a, b == 0 ? 0 : b - 1);
+ break;
+ case OpCode.ExtraArg:
+ if (
+ pc == 0
+ || !(
+ code[pc - 1].OpCode == OpCode.LoadKX
+ || (code[pc - 1].OpCode == OpCode.SetList && code[pc - 1].C == 0)
+ )
+ )
+ Invalid("unexpected extra argument");
+ continue;
+ default:
+ Invalid("opcode");
+ break;
+ }
+
+ Target(pc + 1);
+ }
+
+ foreach (var child in prototype.ChildPrototypes)
+ {
+ foreach (var upValue in child.UpValues)
+ {
+ if (upValue.IsLocal)
+ Register(upValue.Index);
+ else
+ UpValue(upValue.Index);
+ }
+ }
+ }
+
+ void Register(int index) => Registers(index, 1);
+
+ void Registers(int start, int count)
+ {
+ if (
+ (uint)start > (uint)prototype.MaxStackSize
+ || (uint)count > (uint)(prototype.MaxStackSize - start)
+ )
+ Invalid("register range");
+ }
+
+ void Constant(int index)
+ {
+ if ((uint)index >= (uint)prototype.Constants.Length)
+ Invalid("constant index");
+ }
+
+ void UpValue(int index)
+ {
+ if ((uint)index >= (uint)prototype.UpValues.Length)
+ Invalid("upvalue index");
+ }
+
+ void RegisterOrConstant(int operand)
+ {
+ if (Instruction.IsConstant(operand))
+ Constant(Instruction.ConstantIndex(operand));
+ else
+ Register(operand);
+ }
+
+ void Target(int pc)
+ {
+ if ((uint)pc >= (uint)prototype.Code.Length || prototype.Code[pc].OpCode == OpCode.ExtraArg)
+ Invalid("instruction target");
+ }
+
+ int ExtraArgument(int pc)
+ {
+ if (pc + 1 >= prototype.Code.Length || prototype.Code[pc + 1].OpCode != OpCode.ExtraArg)
+ Invalid("missing extra argument");
+ return prototype.Code[pc + 1].Ax;
+ }
+
+ void Flag(int value)
+ {
+ if (value > 1)
+ Invalid("boolean operand");
+ }
+
+ [DoesNotReturn]
+ void Invalid(string reason) =>
+ throw new LuaUndumpException(
+ $"{chunkName.ToString()}: invalid {reason} in precompiled chunk"
+ );
+}
diff --git a/src/Lua/CodeAnalysis/Compilation/Dump.cs b/src/Lua/CodeAnalysis/Compilation/Dump.cs
index ed90dd2d..4811b82b 100644
--- a/src/Lua/CodeAnalysis/Compilation/Dump.cs
+++ b/src/Lua/CodeAnalysis/Compilation/Dump.cs
@@ -1,6 +1,5 @@
using System.Buffers;
using System.Buffers.Binary;
-using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
@@ -77,6 +76,7 @@ public void Validate(ReadOnlySpan name)
|| PointerSize is not (4 or 8)
|| InstructionSize != 4
|| NumberSize != 8
+ || Endianness > 1
)
{
goto ErrIncompatible;
@@ -303,6 +303,7 @@ StringInternPool internPool
int pointerSize;
readonly ReadOnlySpan name = name;
+ [DoesNotReturn]
void Throw(string why)
{
throw new LuaUndumpException($"{name.ToString()}: {why} precompiled chunk");
@@ -341,16 +342,10 @@ byte ReadByte()
bool ReadBool()
{
- if (0 < Unread.Length)
- {
- var b = Unread[0];
- Unread = Unread[1..];
- return b != 0;
- }
-
- ThrowTooShort();
-
- return false;
+ var value = ReadByte();
+ if (value > 1)
+ Throw("invalid boolean in");
+ return value != 0;
}
int ReadInt()
@@ -367,6 +362,16 @@ int ReadInt()
return i;
}
+ // Check serialized lengths against the available input before allocating.
+ // Dividing avoids overflow when a corrupt count is close to int.MaxValue.
+ int ReadCount(int minimumElementSize)
+ {
+ var count = ReadInt();
+ if ((uint)count > (uint)(Unread.Length / minimumElementSize))
+ Throw("invalid length in");
+ return count;
+ }
+
long ReadLong()
{
long i = 0;
@@ -397,41 +402,42 @@ public Prototype Undump()
h.Validate(name);
otherEndian = BitConverter.IsLittleEndian ^ (h.Endianness == 1);
pointerSize = h.PointerSize;
- return UndumpFunction();
+ return UndumpFunction(0);
}
- Prototype UndumpFunction()
+ Prototype UndumpFunction(int depth)
{
+ if (depth >= Constants.MaxCallCount || !RuntimeHelpers.TryEnsureSufficientExecutionStack())
+ Throw("excessive nesting in");
var lineDefined = ReadInt(); // 4
var lastLineDefined = ReadInt(); // 4
var parameterCount = ReadByte(); // 1
var maxStackSize = ReadByte(); // 1
- var isVarArg = ReadByte() == 1; // 1
- var codeLength = ReadInt();
+ var isVarArg = ReadBool(); // 1
+ var codeLength = ReadCount(sizeof(int));
var code = new Instruction[codeLength];
ReadInToIntSpan(MemoryMarshal.Cast(code));
var constants = ReadConstants();
- var prototypes = ReadPrototypes();
+ var prototypes = ReadPrototypes(depth);
var upValues = ReadUpValues();
// Debug
var source = ReadString();
- var lineInfoLength = ReadInt();
+ var lineInfoLength = ReadCount(sizeof(int));
+ if (lineInfoLength != 0 && lineInfoLength != codeLength)
+ Throw("invalid line info in");
var lineInfo = new int[lineInfoLength];
ReadInToIntSpan(lineInfo.AsSpan());
var localVariables = ReadLocalVariables();
var upValueCount = ReadInt();
- Debug.Assert(
- upValueCount == upValues.Length,
- $"upvalue count mismatch: {upValueCount} != {upValues.Length}"
- );
- foreach (ref var desc in upValues.AsSpan())
+ if (upValueCount != 0 && upValueCount != upValues.Length)
+ Throw("invalid upvalue name count in");
+ for (var i = 0; i < upValueCount; i++)
{
- var name = ReadString();
- desc.Name = name;
+ upValues[i].Name = ReadString();
}
- return new(
+ var prototype = new Prototype(
source,
lineDefined,
lastLineDefined,
@@ -445,44 +451,49 @@ Prototype UndumpFunction()
localVariables,
upValues
);
+ new BytecodeVerifier(prototype, name).Verify();
+ return prototype;
}
void ReadInToIntSpan(Span toWrite)
{
- for (var i = 0; i < toWrite.Length; i++)
+ Read(MemoryMarshal.AsBytes(toWrite));
+ if (otherEndian)
{
- toWrite[i] = ReadInt();
+ foreach (ref var value in toWrite)
+ value = BinaryPrimitives.ReverseEndianness(value);
}
}
string ReadString()
{
- var len = pointerSize == 4 ? ReadInt() : (int)ReadLong();
- if (len == 0)
+ var serializedLength = pointerSize == 4 ? ReadInt() : ReadLong();
+ if (serializedLength == 0)
{
return "";
}
- len--;
- var arrayPooled = ArrayPool.Shared.Rent(len);
+ if (serializedLength < 0 || serializedLength > Unread.Length)
+ Throw("invalid string length in");
+ var len = (int)serializedLength;
+ if (Unread[len - 1] != 0)
+ Throw("unterminated string in");
+ var bytes = Unread[..(len - 1)];
+ Unread = Unread[len..];
char[]? charArrayPooled = null;
try
{
- var span = arrayPooled.AsSpan(0, len);
- Read(span);
-
- var l = ReadByte();
- Debug.Assert(l == 0);
+ // UTF-8 produces no more UTF-16 code units than input bytes. Decode
+ // directly from the chunk instead of copying to a second pooled array.
var chars =
len <= 128
- ? stackalloc char[len * 2]
- : (charArrayPooled = ArrayPool.Shared.Rent(len * 2));
- var count = Encoding.UTF8.GetChars(span, chars);
+ ? stackalloc char[len]
+ : (charArrayPooled = ArrayPool.Shared.Rent(len));
+ var count = Encoding.UTF8.GetChars(bytes, chars);
return internPool.Intern(chars[..count]);
}
finally
{
- ArrayPool.Shared.Return(arrayPooled);
if (charArrayPooled != null)
{
ArrayPool.Shared.Return(charArrayPooled);
@@ -492,7 +503,7 @@ string ReadString()
LuaValue[] ReadConstants()
{
- var count = ReadInt();
+ var count = ReadCount(1);
var constants = new LuaValue[count];
for (var i = 0; i < count; i++)
{
@@ -502,7 +513,7 @@ LuaValue[] ReadConstants()
case LuaValueType.Nil:
break;
case LuaValueType.Boolean:
- constants[i] = ReadByte() == 1;
+ constants[i] = ReadBool();
break;
case LuaValueType.Number:
constants[i] = ReadDouble();
@@ -510,19 +521,24 @@ LuaValue[] ReadConstants()
case LuaValueType.String:
constants[i] = ReadString();
break;
+ default:
+ Throw("invalid constant type in");
+ break;
}
}
return constants;
}
- Prototype[] ReadPrototypes()
+ Prototype[] ReadPrototypes(int depth)
{
- var count = ReadInt();
+ // Two line numbers, three flags, seven section counts, and the source length.
+ const int fixedFunctionSize = 2 * sizeof(int) + 3 + 7 * sizeof(int);
+ var count = ReadCount(fixedFunctionSize + pointerSize);
var prototypes = count != 0 ? new Prototype[count] : [];
for (var i = 0; i < count; i++)
{
- prototypes[i] = UndumpFunction();
+ prototypes[i] = UndumpFunction(depth + 1);
}
return prototypes;
@@ -530,7 +546,7 @@ Prototype[] ReadPrototypes()
LocalVariable[] ReadLocalVariables()
{
- var count = ReadInt();
+ var count = ReadCount(pointerSize + 2 * sizeof(int));
var localVariables = new LocalVariable[count];
for (var i = 0; i < count; i++)
{
@@ -550,14 +566,20 @@ LocalVariable[] ReadLocalVariables()
UpValueDesc[] ReadUpValues()
{
- var count = ReadInt();
- Debug.Assert(count < 100, $" too many upvalues :{count}");
+ var count = ReadCount(2);
+ if (count > Constants.MaxUpValue)
+ Throw("too many upvalues in");
var upValues = new UpValueDesc[count];
for (var i = 0; i < count; i++)
{
var isLocal = ReadBool();
var index = ReadByte();
- upValues[i] = new() { IsLocal = isLocal, Index = index };
+ upValues[i] = new()
+ {
+ IsLocal = isLocal,
+ Index = index,
+ Name = "",
+ };
}
return upValues;
diff --git a/src/Lua/CodeAnalysis/Compilation/PrototypeBuilder.cs b/src/Lua/CodeAnalysis/Compilation/PrototypeBuilder.cs
index 5ea73fcc..b3421253 100644
--- a/src/Lua/CodeAnalysis/Compilation/PrototypeBuilder.cs
+++ b/src/Lua/CodeAnalysis/Compilation/PrototypeBuilder.cs
@@ -65,6 +65,7 @@ internal static PrototypeBuilder Get(string source)
internal void Release()
{
+ Source = string.Empty;
ConstantsList.Clear();
CodeList.Clear();
PrototypeList.Clear();
diff --git a/src/Lua/Exceptions.cs b/src/Lua/Exceptions.cs
index 82555a12..c3214ecd 100644
--- a/src/Lua/Exceptions.cs
+++ b/src/Lua/Exceptions.cs
@@ -182,27 +182,25 @@ public class LuaRuntimeException : Exception, ILuaTracebackBuildable
public LuaRuntimeException(LuaState? state, Exception innerException)
: base(innerException.Message, innerException)
{
- if (state != null)
+ if (state is { IsRunning: true })
{
state.CurrentException?.BuildOrGet();
state.ExceptionTrace.Clear();
state.CurrentException = this;
+ State = state;
}
-
- State = state;
}
public LuaRuntimeException(LuaState? state, LuaValue errorObject, int level = 1)
{
- if (state != null)
+ if (state is { IsRunning: true })
{
state.CurrentException?.BuildOrGet();
state.ExceptionTrace.Clear();
state.CurrentException = this;
+ State = state;
}
- State = state;
-
ErrorObject = errorObject;
this.level = level;
}
@@ -328,7 +326,7 @@ internal static void AttemptInvalidOperationOnUpValues(LuaState state, string op
var proto = closure.Proto;
var upValue = proto.UpValues[reg];
- var luaValue = closure.UpValues[upValue.Index].GetValue();
+ var luaValue = closure.UpValues[reg].GetValue();
var name = upValue.Name;
throw new LuaRuntimeException(
@@ -341,25 +339,28 @@ internal static (string NameWhat, string Name) GetCurrentFunctionName(LuaState s
{
var current = state.GetCurrentFrame();
var pc = current.CallerInstructionIndex;
- LuaFunction callerFunction;
+ Prototype? callerPrototype;
if (current.IsTailCall)
{
pc = state.LastPc;
- callerFunction = state.LastCallerFunction!;
+ callerPrototype = state.LastCallerPrototype;
}
else
{
- var caller = state.GetCallStackFrames()[^2];
- callerFunction = caller.Function;
+ var frames = state.GetCallStackFrames();
+ if (frames.Length < 2)
+ return ("function", current.Function.Name);
+ var caller = frames[^2];
+ callerPrototype = (caller.Function as LuaClosure)?.Proto;
}
- if (callerFunction is not LuaClosure callerClosure)
+ if (callerPrototype is null)
{
return ("function", current.Function.Name);
}
return (
- LuaDebug.GetFuncName(callerClosure.Proto, pc, out var name) ?? "",
+ LuaDebug.GetFuncName(callerPrototype, pc, out var name) ?? "",
name ?? current.Function.Name
);
}
@@ -487,7 +488,12 @@ static string CreateMessage(Traceback traceback, LuaValue errorObject, int level
internal void Forget()
{
- State?.ExceptionTrace.Clear();
+ var state = State ?? luaTraceback?.State;
+ if (state != null && ReferenceEquals(state.CurrentException, this))
+ {
+ state.CurrentException = null;
+ state.ExceptionTrace.Clear();
+ }
State = null;
}
@@ -629,10 +635,13 @@ internal LuaCanceledException(
cancellationToken
)
{
- state.CurrentException?.BuildOrGet();
- state.ExceptionTrace.Clear();
- state.CurrentException = this;
- State = state;
+ if (state.IsRunning)
+ {
+ state.CurrentException?.BuildOrGet();
+ state.ExceptionTrace.Clear();
+ state.CurrentException = this;
+ State = state;
+ }
}
[MethodImpl(MethodImplOptions.NoInlining)]
diff --git a/src/Lua/IO/LuaStream.cs b/src/Lua/IO/LuaStream.cs
index 7bdbfabc..71452bd3 100644
--- a/src/Lua/IO/LuaStream.cs
+++ b/src/Lua/IO/LuaStream.cs
@@ -1,4 +1,5 @@
using System.Buffers;
+using System.Runtime.CompilerServices;
using System.Text;
using Lua.Internal;
@@ -39,6 +40,11 @@ public ValueTask ReadAllAsync(CancellationToken cancellationToken)
public ValueTask ReadBytesAsync(IBufferWriter writer, CancellationToken cancellationToken)
{
mode.ThrowIfNotReadable();
+ if (reader != null)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ reader.CopyBufferedBytes(writer);
+ }
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
@@ -53,10 +59,13 @@ public ValueTask ReadBytesAsync(IBufferWriter writer, CancellationToken ca
}
}
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
public ValueTask ReadByteAsync(CancellationToken cancellationToken)
{
mode.ThrowIfNotReadable();
- return new(innerStream.ReadByte());
+ if (reader == null)
+ return new(innerStream.ReadByte());
+ return new(reader.ReadByte(innerStream));
}
public ValueTask ReadAsync(int count, CancellationToken cancellationToken)
@@ -76,16 +85,7 @@ public ValueTask ReadByteAsync(CancellationToken cancellationToken)
mode.ThrowIfNotReadable();
reader ??= new(stringMode);
- // Use the Utf8Reader's ReadNumber method which handles positioning correctly
- var numberStr = reader.ReadNumber(innerStream);
- if (numberStr == null)
- {
- return new((double?)null);
- }
-
- // Parse using the shared utility
- var result = NumberReaderHelper.ParseNumber(numberStr.AsSpan());
- return new(result);
+ return new(reader.ReadNumber(innerStream));
}
public ValueTask WriteAsync(ReadOnlyMemory buffer, CancellationToken cancellationToken)
@@ -190,8 +190,9 @@ public long Seek(SeekOrigin origin, long offset)
offset -= reader.Remain;
}
+ var position = innerStream.Seek(offset, origin);
reader?.Clear();
- return innerStream.Seek(offset, origin);
+ return position;
}
public void Dispose()
@@ -209,12 +210,17 @@ public void Dispose()
{
innerStream.Flush();
}
-
- innerStream.Dispose();
}
finally
{
- reader?.Dispose();
+ try
+ {
+ innerStream.Dispose();
+ }
+ finally
+ {
+ reader?.Dispose();
+ }
}
}
}
diff --git a/src/Lua/Internal/CoroutineCore.cs b/src/Lua/Internal/CoroutineCore.cs
index e1c84cc7..52722715 100644
--- a/src/Lua/Internal/CoroutineCore.cs
+++ b/src/Lua/Internal/CoroutineCore.cs
@@ -1,4 +1,5 @@
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
using System.Threading.Tasks.Sources;
using Lua.Internal.CompilerServices;
using Lua.Runtime;
@@ -14,67 +15,83 @@ readonly struct YieldContext(LuaStack stack, int argCount)
public ReadOnlySpan Results => stack.AsSpan()[^argCount..];
}
- readonly struct ResumeContext(LuaStack? stack, int argCount)
+ readonly struct ResumeContext(LuaStack stack, int argCount)
{
- public ReadOnlySpan Results => stack!.AsSpan()[^argCount..];
+ readonly int resultBase = stack.Count - argCount;
+ public ReadOnlySpan Results => stack.GetBuffer().Slice(resultBase, argCount);
public bool IsDead => stack == null;
+
+ public void ClearResults() => stack.PopUntil(resultBase);
}
+ const int Suspended = 0;
+ const int Preparing = 1;
+ const int Running = 2;
+ const int Copying = 3;
+ const int Cancelling = 4;
+ const int Completed = 5;
+ const int Closed = 6;
+ const int CancelPending = 8;
+
+ // Preparing and Copying give the resumer exclusive access to the stack range.
+ // Cancellation waits until that ownership is released before waking the yield.
+ int handoff;
internal byte status = (byte)LuaThreadStatus.Suspended;
bool isFirstCall = true;
ValueTask functionTask;
-
+ LuaStack? yieldStack;
+ int yieldReturnBase;
+ CancellationTokenSource? executionSource;
+ CancellationToken executionToken;
+ CancellationScope? cancellation;
ManualResetValueTaskSourceCore resume;
ManualResetValueTaskSourceCore yield;
Traceback? traceback;
- public bool IsProtectedMode { get; private set; } = isProtectedMode;
- public LuaFunction Function { get; private set; } = function;
- public LuaState Thread { get; private set; } = state;
+ public bool IsProtectedMode { get; } = isProtectedMode;
+ public LuaFunction? Function { get; private set; } = function;
+ public LuaState Thread { get; } = state;
public Traceback? Traceback => traceback;
- YieldContext IValueTaskSource.GetResult(short token)
- {
- return yield.GetResult(token);
- }
+ internal CancellationToken GetCancellationOrigin(CancellationToken token) =>
+ cancellation == null ? token : cancellation.GetOrigin(token);
- ValueTaskSourceStatus IValueTaskSource.GetStatus(short token)
- {
- return yield.GetStatus(token);
- }
+ YieldContext IValueTaskSource.GetResult(short token) => yield.GetResult(token);
+
+ ValueTaskSourceStatus IValueTaskSource.GetStatus(short token) =>
+ yield.GetStatus(token);
+ // Coroutine continuations must not require a SynchronizationContext (Unity WebGL).
void IValueTaskSource.OnCompleted(
Action continuation,
object? state,
short token,
ValueTaskSourceOnCompletedFlags flags
- )
- {
- // Avoid SynchronizationContext capture (deadlocks Unity WebGL sync-over-async).
- flags &= ~ValueTaskSourceOnCompletedFlags.UseSchedulingContext;
- yield.OnCompleted(continuation, state, token, flags);
- }
+ ) =>
+ yield.OnCompleted(
+ continuation,
+ state,
+ token,
+ flags & ~ValueTaskSourceOnCompletedFlags.UseSchedulingContext
+ );
- ResumeContext IValueTaskSource.GetResult(short token)
- {
- return resume.GetResult(token);
- }
+ ResumeContext IValueTaskSource.GetResult(short token) => resume.GetResult(token);
- ValueTaskSourceStatus IValueTaskSource.GetStatus(short token)
- {
- return resume.GetStatus(token);
- }
+ ValueTaskSourceStatus IValueTaskSource.GetStatus(short token) =>
+ resume.GetStatus(token);
void IValueTaskSource.OnCompleted(
Action continuation,
object? state,
short token,
ValueTaskSourceOnCompletedFlags flags
- )
- {
- flags &= ~ValueTaskSourceOnCompletedFlags.UseSchedulingContext;
- resume.OnCompleted(continuation, state, token, flags);
- }
+ ) =>
+ resume.OnCompleted(
+ continuation,
+ state,
+ token,
+ flags & ~ValueTaskSourceOnCompletedFlags.UseSchedulingContext
+ );
[AsyncMethodBuilder(typeof(LightAsyncValueTaskMethodBuilder<>))]
internal async ValueTask ResumeAsyncCore(
@@ -82,143 +99,156 @@ internal async ValueTask ResumeAsyncCore(
int argCount,
int returnBase,
LuaState? baseThread,
- CancellationToken cancellationToken = default
+ CancellationToken cancellationToken = default,
+ bool includeStatus = true
)
{
if (baseThread != null)
{
baseThread.UnsafeSetStatus(LuaThreadStatus.Normal);
-
baseThread.GlobalState.ThreadStack.Push(Thread);
}
-
try
{
- switch ((LuaThreadStatus)Volatile.Read(ref status))
+ var phase = Interlocked.CompareExchange(ref handoff, Preparing, Suspended);
+ if (phase != Suspended)
+ return ResumeError(
+ stack,
+ returnBase,
+ baseThread,
+ phase is Completed or Closed or Cancelling
+ ? "cannot resume dead coroutine"
+ : "cannot resume non-suspended coroutine",
+ includeStatus
+ );
+ try
{
- case LuaThreadStatus.Suspended:
- Volatile.Write(ref status, (byte)LuaThreadStatus.Running);
-
- if (!isFirstCall)
- {
- yield.SetResult(new(stack, argCount));
- }
-
- break;
- case LuaThreadStatus.Normal:
- case LuaThreadStatus.Running:
- if (IsProtectedMode)
- {
- stack.PopUntil(returnBase);
- stack.Push(false);
- stack.Push("cannot resume non-suspended coroutine");
- return 2;
- }
- else
- {
- throw new LuaRuntimeException(
- baseThread,
- "cannot resume non-suspended coroutine"
- );
- }
- case LuaThreadStatus.Dead:
- if (IsProtectedMode)
- {
- stack.PopUntil(returnBase);
- stack.Push(false);
- stack.Push("cannot resume dead coroutine");
- return 2;
- }
- else
- {
- throw new LuaRuntimeException(baseThread, "cannot resume dead coroutine");
- }
+ if (isFirstCall)
+ Thread.Stack.EnsureCapacity(Thread.Stack.Count + argCount);
+ else
+ yieldStack!.EnsureCapacity(yieldReturnBase + argCount);
+ if (executionSource == null)
+ {
+ // A callback can retain its execution token across multiple resumes.
+ executionSource = new();
+ executionToken = executionSource.Token;
+ }
+ SetResumeToken(cancellationToken);
+ if (isFirstCall)
+ Thread.Stack.PushRange(stack.AsSpan()[^argCount..]);
}
-
- ValueTask resumeTask = new(this, resume.Version);
-
- CancellationTokenRegistration registration = default;
- if (cancellationToken.CanBeCanceled)
+ catch (Exception error)
{
- registration = cancellationToken.UnsafeRegister(
- static x =>
- {
- var coroutine = (CoroutineCore)x!;
- coroutine.yield.SetException(new OperationCanceledException());
- },
- this
- );
+ ReleaseTransfer(Preparing);
+ if (error is LuaStackOverflowException)
+ return ResumeError(
+ stack,
+ returnBase,
+ baseThread,
+ "too many arguments to resume",
+ includeStatus
+ );
+ throw;
}
+ var resumeTask = new ValueTask(this, resume.Version);
+ Volatile.Write(ref status, (byte)LuaThreadStatus.Running);
+ var cancelled =
+ Interlocked.CompareExchange(ref handoff, Running, Preparing)
+ == (Preparing | CancelPending);
+ if (cancelled)
+ Interlocked.Exchange(ref handoff, Running | CancelPending);
try
{
+ Exception? cancellationFailure = null;
if (isFirstCall)
{
- Thread.Stack.PushRange(stack.AsSpan()[^argCount..]);
- // functionTask = Function.InvokeAsync(new() { Access = this.CurrentAccess, ArgumentCount = Stack.Count, ReturnFrameBase = 0 }, cancellationToken);
- functionTask = Thread.RunAsync(Function, Thread.Stack.Count, cancellationToken);
- Volatile.Write(ref isFirstCall, false);
- if (!functionTask.IsCompleted)
+ if (cancelled)
+ executionSource!.Cancel();
+ isFirstCall = false;
+ functionTask = Thread.RunAsync(Function!, Thread.Stack.Count, executionToken);
+ if (functionTask.IsCompleted)
+ OnFunctionCompleted();
+ else
+ functionTask.GetAwaiter().UnsafeOnCompleted(OnFunctionCompleted);
+ }
+ else if (cancelled)
+ {
+ var error = new OperationCanceledException(
+ GetCancellationOrigin(executionToken)
+ );
+ try
+ {
+ executionSource!.Cancel();
+ }
+ catch (Exception failure)
{
- // UnsafeOnCompleted: OnCompleted would capture SyncContext and deadlock on WebGL.
- functionTask
- .GetAwaiter()
- .UnsafeOnCompleted(() => resume.SetResult(default));
+ cancellationFailure = failure;
}
+ yield.SetException(error);
}
+ else
+ yield.SetResult(new(stack, argCount));
- ResumeContext result0;
- if (functionTask.IsCompleted || (result0 = await resumeTask).IsDead)
+ ResumeContext result;
+ try
{
- _ = functionTask.Result;
- Volatile.Write(ref status, (byte)LuaThreadStatus.Dead);
- stack.PopUntil(returnBase);
- stack.Push(true);
- stack.PushRange(Thread.Stack.AsSpan());
- Thread.Dispose();
- return stack.Count - returnBase;
+ result = await resumeTask;
}
- else
+ catch (Exception error)
{
- Volatile.Write(ref status, (byte)LuaThreadStatus.Suspended);
- var results = result0.Results;
+ if (cancellationFailure != null)
+ ExceptionDispatchInfo.Capture(cancellationFailure).Throw();
+ if (!IsProtectedMode || error is OperationCanceledException)
+ throw;
stack.PopUntil(returnBase);
- stack.Push(true);
- stack.PushRange(results);
- return results.Length + 1;
+ var value = error is LuaRuntimeException { InnerException: null } luaError
+ ? luaError.ErrorObject
+ : new LuaValue(error.Message);
+ if (includeStatus)
+ stack.PushRange(false, value);
+ else
+ stack.Push(value);
+ return includeStatus ? 2 : 1;
}
- }
- catch (Exception ex) when (ex is not OperationCanceledException)
- {
- if (IsProtectedMode)
+ try
{
- if (ex is ILuaTracebackBuildable tracebackBuildable)
+ var results = result.IsDead ? Thread.Stack.AsSpan() : result.Results;
+ stack.PopUntil(returnBase);
+ if (includeStatus)
+ stack.PushRange(true, results);
+ else
{
- traceback = tracebackBuildable.BuildOrGet();
+ // Lua 5.2 reserves one spare slot for wrapped results too.
+ stack.EnsureCapacity(returnBase + results.Length + 1);
+ results.CopyTo(stack.GetBuffer()[returnBase..]);
+ stack.NotifyTop(returnBase + results.Length);
}
-
- Volatile.Write(ref status, (byte)LuaThreadStatus.Dead);
- Thread.Dispose();
- stack.PopUntil(returnBase);
- stack.Push(false);
- // Wrapped C# exceptions carry a message rather than a Lua error object.
- // Keep error(nil) intact when the exception originated in Lua.
- stack.Push(
- ex is LuaRuntimeException { InnerException: null } luaEx
- ? luaEx.ErrorObject
- : ex.Message
+ return results.Length + (includeStatus ? 1 : 0);
+ }
+ catch (LuaStackOverflowException)
+ {
+ return ResumeError(
+ stack,
+ returnBase,
+ baseThread,
+ "too many results to resume",
+ includeStatus
);
- return 2;
}
- else
+ finally
{
- throw;
+ if (!result.IsDead)
+ result.ClearResults();
}
}
finally
{
- registration.Dispose();
resume.Reset();
+ if (Volatile.Read(ref handoff) == Completed)
+ FinishExecution();
+ else
+ ReleaseTransfer(Copying);
}
}
finally
@@ -231,6 +261,179 @@ internal async ValueTask ResumeAsyncCore(
}
}
+ int ResumeError(
+ LuaStack stack,
+ int returnBase,
+ LuaState? baseThread,
+ string message,
+ bool includeStatus
+ )
+ {
+ if (!IsProtectedMode)
+ throw new LuaRuntimeException(baseThread, message);
+ stack.PopUntil(returnBase);
+ if (includeStatus)
+ stack.PushRange(false, new LuaValue(message));
+ else
+ stack.Push(message);
+ return includeStatus ? 2 : 1;
+ }
+
+ void OnFunctionCompleted()
+ {
+ Exception? error = null;
+ try
+ {
+ _ = functionTask.GetAwaiter().GetResult();
+ }
+ catch (Exception exception)
+ {
+ error =
+ exception is OperationCanceledException cancelled
+ && exception is not LuaCanceledException
+ ? new LuaCanceledException(
+ Thread,
+ GetCancellationOrigin(cancelled.CancellationToken),
+ exception
+ )
+ : exception;
+ if (error is ILuaTracebackBuildable buildable)
+ traceback = buildable.BuildOrGet();
+ }
+ functionTask = default;
+ var phase = Interlocked.Exchange(ref handoff, Completed);
+ if (phase == Cancelling)
+ FinishExecution();
+ else if ((phase & ~CancelPending) == Running)
+ {
+ if (error != null)
+ resume.SetException(error);
+ else
+ resume.SetResult(default);
+ }
+ }
+
+ void ReleaseTransfer(int phase)
+ {
+ Volatile.Write(ref status, (byte)LuaThreadStatus.Suspended);
+ if (Interlocked.CompareExchange(ref handoff, Suspended, phase) == (phase | CancelPending))
+ {
+ CompleteCancellation(phase | CancelPending);
+ }
+ }
+
+ void RequestCancellation()
+ {
+ while (true)
+ {
+ var phase = Volatile.Read(ref handoff);
+ var next = phase switch
+ {
+ Preparing or Running or Copying => phase | CancelPending,
+ Suspended => Copying | CancelPending,
+ _ => phase,
+ };
+ if (next == phase)
+ return;
+ if (Interlocked.CompareExchange(ref handoff, next, phase) != phase)
+ continue;
+ if (phase == Suspended)
+ CompleteCancellation(next);
+ else if (phase == Running)
+ executionSource!.Cancel();
+ return;
+ }
+ }
+
+ void CompleteCancellation(int phase)
+ {
+ var error = new OperationCanceledException(GetCancellationOrigin(executionToken));
+ try
+ {
+ executionSource!.Cancel();
+ }
+ finally
+ {
+ yield.SetException(error);
+ if (Interlocked.CompareExchange(ref handoff, Cancelling, phase) == Completed)
+ FinishExecution();
+ }
+ }
+
+ CancellationScope EnsureCancellation() => cancellation ??= new(this);
+
+ void SetResumeToken(CancellationToken token)
+ {
+ if (token.CanBeCanceled && token != executionToken)
+ EnsureCancellation();
+ cancellation?.SetResumeToken(token, isFirstCall);
+ }
+
+ void FinishExecution()
+ {
+ Thread.Dispose();
+ Function = null;
+ cancellation?.Dispose();
+ cancellation = null;
+ executionSource?.Dispose();
+ executionSource = null;
+ executionToken = default;
+ Volatile.Write(ref handoff, Closed);
+ Volatile.Write(ref status, (byte)LuaThreadStatus.Dead);
+ }
+
+ sealed class CancellationScope(CoroutineCore owner) : IDisposable
+ {
+ CancellationToken lifetimeToken;
+ CancellationToken resumeToken;
+ internal CancellationToken YieldToken;
+ CancellationTokenRegistration lifetimeRegistration;
+ CancellationTokenRegistration resumeRegistration;
+
+ internal CancellationToken GetOrigin(CancellationToken token) =>
+ token != owner.executionToken && token.IsCancellationRequested ? token
+ : lifetimeToken.IsCancellationRequested ? lifetimeToken
+ : resumeToken.IsCancellationRequested ? resumeToken
+ : YieldToken.IsCancellationRequested ? YieldToken
+ : token;
+
+ internal void SetResumeToken(CancellationToken token, bool first)
+ {
+ if (token == resumeToken)
+ return;
+ resumeRegistration.Dispose();
+ resumeRegistration = default;
+ resumeToken = token;
+ if (first)
+ {
+ lifetimeToken = token;
+ lifetimeRegistration = Register(token);
+ }
+ else if (token != lifetimeToken && token != owner.executionToken)
+ resumeRegistration = Register(token);
+ }
+
+ CancellationTokenRegistration Register(CancellationToken token) =>
+ token.UnsafeRegister(
+ static value => ((CoroutineCore)value!).RequestCancellation(),
+ owner
+ );
+
+ internal CancellationTokenRegistration RegisterYieldToken(CancellationToken token)
+ {
+ YieldToken = token;
+ return token == lifetimeToken ? default : Register(token);
+ }
+
+ public void Dispose()
+ {
+ lifetimeRegistration.Dispose();
+ resumeRegistration.Dispose();
+ lifetimeRegistration = resumeRegistration = default;
+ lifetimeToken = resumeToken = YieldToken = default;
+ }
+ }
+
[AsyncMethodBuilder(typeof(LightAsyncValueTaskMethodBuilder<>))]
internal async ValueTask YieldAsyncCore(
LuaStack stack,
@@ -241,52 +444,54 @@ internal async ValueTask YieldAsyncCore(
)
{
if (Volatile.Read(ref status) != (byte)LuaThreadStatus.Running)
- {
throw new LuaRuntimeException(baseThread, "cannot yield from a non-running coroutine");
- }
-
if (baseThread != null)
{
- if (baseThread.GetCallStackFrames()[^2].Function is not LuaClosure)
- {
+ var frames = baseThread.GetCallStackFrames();
+ if (frames.Length > 1 && frames[^2].Function is not LuaClosure)
throw new LuaRuntimeException(
baseThread,
"attempt to yield across a C#-call boundary"
);
- }
}
-
- resume.SetResult(new(stack, argCount));
-
+ cancellationToken.ThrowIfCancellationRequested();
+ Thread.ThrowIfCancellationRequested(executionToken);
CancellationTokenRegistration registration = default;
- if (cancellationToken.CanBeCanceled)
- {
- registration = cancellationToken.UnsafeRegister(
- static x =>
- {
- var coroutine = (CoroutineCore)x!;
- coroutine.yield.SetException(new OperationCanceledException());
- },
- this
- );
- }
-
- RETRY:
+ var published = false;
+ if (Interlocked.CompareExchange(ref handoff, Copying, Running) != Running)
+ throw new LuaCanceledException(Thread, GetCancellationOrigin(executionToken));
try
{
+ Thread.SuspendUpValues();
+ yieldStack = stack;
+ yieldReturnBase = returnBase;
+ if (cancellationToken.CanBeCanceled && cancellationToken != executionToken)
+ registration = EnsureCancellation().RegisterYieldToken(cancellationToken);
+ published = true;
+ resume.SetResult(new(stack, argCount));
var result = await new ValueTask(this, yield.Version);
+ Thread.ThrowIfCancellationRequested(executionToken);
+ Thread.ResumeUpValues();
stack.PopUntil(returnBase);
stack.PushRange(result.Results);
return result.Results.Length;
}
- catch (Exception ex) when (ex is not OperationCanceledException)
+ catch
{
- yield.Reset();
- goto RETRY;
+ if (!published)
+ {
+ Thread.ResumeUpValues();
+ if (Interlocked.Exchange(ref handoff, Running) == (Copying | CancelPending))
+ RequestCancellation();
+ }
+ throw;
}
finally
{
registration.Dispose();
+ yieldStack = null;
+ if (cancellation != null)
+ cancellation.YieldToken = default;
yield.Reset();
}
}
diff --git a/src/Lua/Internal/LuaDebug.cs b/src/Lua/Internal/LuaDebug.cs
index 63552f33..19dadd5b 100644
--- a/src/Lua/Internal/LuaDebug.cs
+++ b/src/Lua/Internal/LuaDebug.cs
@@ -233,7 +233,13 @@ ReadOnlySpan what
case 'l':
{
CurrentLine =
- pc >= 0 && closure is not null ? closure.Proto.LineInfo[pc] : -1;
+ frame.HasValue && closure is not null
+ ? (
+ (uint)pc < (uint)closure.Proto.LineInfo.Length
+ ? closure.Proto.LineInfo[pc]
+ : 0
+ )
+ : -1;
break;
}
case 'u':
diff --git a/src/Lua/Internal/LuaGlobalState.cs b/src/Lua/Internal/LuaGlobalState.cs
index 34b1f799..c3983ebc 100644
--- a/src/Lua/Internal/LuaGlobalState.cs
+++ b/src/Lua/Internal/LuaGlobalState.cs
@@ -2,7 +2,6 @@
using System.Runtime.CompilerServices;
using Lua.Internal;
using Lua.Platforms;
-using Lua.Runtime;
using Lua.Standard;
namespace Lua;
@@ -14,7 +13,6 @@ sealed class LuaGlobalState
FastStackCore stateStack;
readonly LuaTable environment;
readonly LuaTable registry = new();
- readonly UpValue envUpValue;
FastStackCore debugBufferPool;
@@ -24,7 +22,6 @@ sealed class LuaGlobalState
// Coroutines share this policy so Lua code cannot reset the limit by creating a new thread.
internal int MaxCallDepth = 100_000;
- internal UpValue EnvUpValue => envUpValue;
internal ref FastStackCore ThreadStack => ref stateStack;
internal ref FastStackCore DebugBufferPool => ref debugBufferPool;
@@ -42,6 +39,9 @@ sealed class LuaGlobalState
LuaTable? booleanMetatable;
LuaTable? functionMetatable;
LuaTable? stateMetatable;
+ LuaTable? fileHandleMetatable;
+
+ internal LuaTable FileHandleMetatable => fileHandleMetatable ??= FileHandle.CreateMetatable();
public static LuaGlobalState Create(LuaPlatform? platform = null)
{
@@ -53,7 +53,6 @@ public static LuaGlobalState Create(LuaPlatform? platform = null)
{
mainState = new(this);
environment = new();
- envUpValue = UpValue.Closed(environment);
registry[ModuleLibrary.LoadedKeyForRegistry] = new LuaTable(0, 8);
registry[ModuleLibrary.PreloadKeyForRegistry] = new LuaTable(0, 8);
Platform = platform;
diff --git a/src/Lua/Internal/LuaValueDictionary.cs b/src/Lua/Internal/LuaValueDictionary.cs
index e57449e8..7c6db950 100644
--- a/src/Lua/Internal/LuaValueDictionary.cs
+++ b/src/Lua/Internal/LuaValueDictionary.cs
@@ -22,6 +22,9 @@ sealed class LuaValueDictionary
int _nilCount;
+ [ThreadStatic]
+ static FastStackCore> deletedKeyPool;
+
public LuaValueDictionary(int capacity)
{
if (capacity < 0)
@@ -69,6 +72,17 @@ public void Clear()
_count = 0;
_freeList = -1;
_freeCount = 0;
+ if (_nilCount != 0)
+ {
+ for (var i = 0; i < count; i++)
+ {
+ if (
+ _entries[i].keyType == LuaValueType.Nil
+ && _entries[i].keyObject is WeakReference