Add: BitFlags

src/Lua/Internal/BitFlags.cs

@@ -0,0 +1,38 @@
+namespace Lua.Internal;
+
+internal struct BitFlags2
+{
+    public byte Value;
+
+    public bool Flag0
+    {
+        get => (Value & 1) == 1;
+        set
+        {
+            if (value)
+            {
+                Value |= 1;
+            }
+            else
+            {
+                Value = (byte)(Value & ~1);
+            }
+        }
+    }
+    
+    public bool Flag1
+    {
+        get => (Value & 2) == 2;
+        set
+        {
+            if (value)
+            {
+                Value |= 2;
+            }
+            else
+            {
+                Value = (byte)(Value & ~2);
+            }
+        }
+    }
+}

src/Lua/LuaThread.cs

@@ -19,39 +19,20 @@ public abstract class LuaThread
 
     internal bool IsLineHookEnabled
     {
-        get => (LineAndCountHookMask & 1) != 0;
-        set
-        {
-            if (value)
-            {
-                LineAndCountHookMask |= 1;
-            }
-            else
-            {
-                LineAndCountHookMask &= 0b1111_1110;
-            }
-        }
+        get => LineAndCountHookMask.Flag0;
+        set => LineAndCountHookMask.Flag0 = value;
     }
 
     internal bool IsCountHookEnabled
     {
-        get => (LineAndCountHookMask & 2) != 0;
-        set
-        {
-            if (value)
-            {
-                LineAndCountHookMask |= 2;
-            }
-            else
-            {
-                LineAndCountHookMask &= 0b1111_1101;
-            }
-        }
+        get => LineAndCountHookMask.Flag1;
+        set => LineAndCountHookMask.Flag1 = value;
     }
-    internal bool IsCallHookEnabled;
-    internal byte LineAndCountHookMask;
-    internal bool IsReturnHookEnabled;
-    internal bool CallOrReturnHookEnabled => IsCallHookEnabled || IsReturnHookEnabled;
+   
+    internal BitFlags2 LineAndCountHookMask;
+     internal bool IsCallHookEnabled { get => CallOrReturnHookMask.Flag0; set => CallOrReturnHookMask.Flag0 = value; }
+    internal bool IsReturnHookEnabled { get => CallOrReturnHookMask.Flag1; set => CallOrReturnHookMask.Flag1 = value; }
+    internal BitFlags2 CallOrReturnHookMask;
     internal bool IsInHook;
     internal int HookCount;
     internal int BaseHookCount;

src/Lua/Runtime/LuaVirtualMachine.cs

@@ -285,7 +285,7 @@ public static partial class LuaVirtualMachine
             var stack = context.Stack;
             stack.EnsureCapacity(frameBase + context.Chunk.MaxStackPosition);
             ref var constHead = ref MemoryMarshalEx.UnsafeElementAt(context.Chunk.Constants, 0);
-            ref byte lineAndCountHookMask = ref context.Thread.LineAndCountHookMask;
+            ref var lineAndCountHookMask = ref context.Thread.LineAndCountHookMask;
             goto Loop;
         LineHook:
 
@@ -308,7 +308,7 @@ public static partial class LuaVirtualMachine
             {
                 var instructionRef = Unsafe.Add(ref instructionsHead, ++context.Pc);
                 context.Instruction = instructionRef;
-                if (lineAndCountHookMask != 0 && (context.Pc != context.LastHookPc))
+                if (lineAndCountHookMask.Value!=0 && (context.Pc != context.LastHookPc))
                 {
                     goto LineHook;
                 }
@@ -1052,7 +1052,7 @@ public static partial class LuaVirtualMachine
         var newFrame = func.CreateNewFrame(ref context, newBase, variableArgumentCount);
 
         thread.PushCallStackFrame(newFrame);
-        if (thread.CallOrReturnHookEnabled && !context.Thread.IsInHook)
+        if (thread.CallOrReturnHookMask.Value!=0 && !context.Thread.IsInHook)
         {
             context.PostOperation = PostOperationType.Call;
             ExecuteCallHook(ref context, argumentCount);
@@ -1187,7 +1187,7 @@ public static partial class LuaVirtualMachine
         newFrame.CallerInstructionIndex = lastPc;
         thread.PushCallStackFrame(newFrame);
 
-        if (thread.CallOrReturnHookEnabled && !context.Thread.IsInHook)
+        if (thread.CallOrReturnHookMask.Value!=0 && !context.Thread.IsInHook)
         {
             context.PostOperation = PostOperationType.TailCall;
             ExecuteCallHook(ref context, argumentCount, true);