Use panic wrapper for warning handler

Author: Quahu

src/Laylua/Library/Lua.Warnings.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using Laylua.Moon;
@@ -32,8 +31,7 @@ public sealed unsafe partial class Lua
 
     private MemoryStream? _warningBuffer;
 
-    [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvCdecl) })]
-    private static void WarningHandler(void* ud, byte* msg, int tocont)
+    private static readonly LuaWarnFunction _warningHandler = static (ud, msg, tocont) =>
     {
         var lua = FromExtraSpace((lua_State*) ud);
         var msgSpan = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(msg);
@@ -119,7 +117,7 @@ static void ClearWarningBuffer(MemoryStream warningBuffer)
             warningBuffer.Position = 0;
             warningBuffer.SetLength(0);
         }
-    }
+    };
 
     /// <inheritdoc cref="EmitWarning(ReadOnlySpan{char})"/>
     public void EmitWarning(string? message)

src/Laylua/Library/Lua.cs

@@ -94,7 +94,7 @@ private Lua(
         MainThread = LuaThread.CreateMainThread(this);
         Globals = LuaTable.CreateGlobalsTable(this);
 
-        lua_setwarnf(state.L, &WarningHandler, State.L);
+        lua_setwarnf(state.L, LayluaNative.CreateLuaWarnFunctionWrapper(_warningHandler), State.L);
     }
 
     private Lua(

src/Laylua/Moon/Native/Extern/LuaNative.Delegates.cs

@@ -30,7 +30,7 @@ namespace Laylua.Moon;
 /// <param name="ud"> The userdata. </param>
 /// <param name="msg"> The message. </param>
 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-public unsafe delegate void LuaWarnFunction(void* ud, [MarshalAs(UnmanagedType.LPStr)] string msg, int tocont);
+public unsafe delegate void LuaWarnFunction(void* ud, byte* msg, int tocont);
 
 /// <summary>
 ///     Represents a Lua allocation function.

src/Laylua/Moon/Native/Extern/LuaNative.cs

@@ -585,13 +585,22 @@ public static int lua_yield(lua_State* L, int nresults)
     public static extern void lua_setwarnf(lua_State* L, LuaWarnFunction f, void* ud);
 
     [DllImport(DllName, CallingConvention = Cdecl)]
-    public static extern void lua_setwarnf(lua_State* L, delegate* unmanaged[Cdecl]<void*, byte*, int, void> f, void* ud);
+    public static extern void lua_setwarnf(lua_State* L, IntPtr f, void* ud);
 
     [DllImport(DllName, CallingConvention = Cdecl)]
-    public static extern void lua_warning(lua_State* L, [MarshalAs(UnmanagedType.LPUTF8Str)] string msg, bool tocont);
+    public static extern void lua_setwarnf(lua_State* L, delegate* unmanaged[Cdecl]<void*, byte*, int, void> f, void* ud);
 
-    [DllImport(DllName, CallingConvention = Cdecl)]
-    private static extern void lua_warning(lua_State* L, byte* msg, bool tocont);
+    [UnmanagedFunctionPointer(Cdecl)]
+    private delegate void _lua_warningDelegate(lua_State* L, byte* msg, bool tocont);
+
+    private static _lua_warningDelegate _lua_warning = null!;
+
+    [ErrorExport]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void lua_warning(lua_State* L, byte* msg, bool tocont)
+    {
+        _lua_warning(L, msg, tocont);
+    }
 
     public static void lua_warning(lua_State* L, ReadOnlySpan<char> msg, bool tocont)
     {

src/Laylua/Moon/Native/Laylua/LayluaNative.FunctionWrappers.cs

@@ -205,6 +205,55 @@ public static IntPtr CreateLuaWriterFunctionWrapper(LuaWriterFunction function)
         return asmPtr;
     }
 
+    public static IntPtr CreateLuaWarnFunctionWrapper(LuaWarnFunction function)
+    {
+        var asmSpan = AllocFunctionWrapperAsm(out var asmPtr);
+
+        var functionWrapper = FunctionWrappers.GetValue(function, static function => (LuaWarnFunction) ((ud, msg, tocont) =>
+        {
+            try
+            {
+#if TRACE_PANIC
+                Console.WriteLine("LuaWarnFunction: calling delegate...");
+#endif
+                Unsafe.As<LuaWarnFunction>(function)(ud, msg, tocont);
+            }
+            catch (Exception ex)
+            {
+#if TRACE_PANIC
+                Console.WriteLine("LuaWarnFunction: caught exception...");
+#endif
+                var L = (lua_State*) ud;
+                var laylua = LayluaState.FromExtraSpace(L);
+                if (laylua.Panic != null)
+                {
+#if TRACE_PANIC
+                    Console.WriteLine($"LuaWarnFunction: setting panic exception: {ex}");
+#endif
+                    laylua.Panic.Exception = ExceptionDispatchInfo.Capture(ex);
+                }
+                else
+                {
+#if TRACE_PANIC
+                    Console.WriteLine($"LuaWarnFunction: panic is null, throwing exception: {ex}");
+#endif
+                    luaL_error(L, ex.Message);
+                }
+            }
+#if TRACE_PANIC
+            Console.WriteLine("LuaWarnFunction: returning...");
+#endif
+        }));
+
+        WriteFunctionWrapperPointers(asmSpan,
+#if TRACE_PANIC
+            asmPtr,
+#endif
+            function, functionWrapper);
+
+        return asmPtr;
+    }
+
     public static IntPtr CreateLuaHookFunctionWrapper(LuaHookFunction function)
     {
         var asmSpan = AllocFunctionWrapperAsm(out var asmPtr);
@@ -277,13 +326,18 @@ private static void WriteFunctionWrapperPointers(Span<byte> asmSpan,
         var functionWrapperPtr = Marshal.GetFunctionPointerForDelegate(functionWrapper);
 
         // MemoryMarshal.Write(asmSpan.Slice(21), ref functionPtr);
-        MemoryMarshal.Write(asmSpan.Slice(40 - 13), ref functionWrapperPtr);
-        MemoryMarshal.Write(asmSpan.Slice(71 - 13), ref getPotentialPanicPtr);
+        WriteFunctionWrapperPointers(asmSpan, functionWrapperPtr);
 
         // Console.WriteLine("Stack State at 0x{0:X}", (IntPtr) stackState);
 
 #if TRACE_PANIC
         Console.WriteLine("ManagedPanic for {0} asmPtr: 0x{1:X}\nGetPotentialPanicPtr: 0x{2:X}\nCallLuaCFunction: 0x{3:X} (for 0x{4:X})", callerName, asmPtr, getPotentialPanicPtr, functionWrapperPtr, functionPtr);
 #endif
     }
+
+    private static void WriteFunctionWrapperPointers(Span<byte> asmSpan, IntPtr functionWrapperPtr)
+    {
+        MemoryMarshal.Write(asmSpan.Slice(40 - 13), ref functionWrapperPtr);
+        MemoryMarshal.Write(asmSpan.Slice(71 - 13), ref getPotentialPanicPtr);
+    }
 }