Cleanup

Author: mcpiroman

scripts/Memory.cs scripts/Detour.csscripts/Memory.cs renamed to scripts/Detour.cs

@@ -11,7 +11,7 @@
 namespace UnityNativeTool.Internal
 {
     /// <summary>A low level memory helper</summary>
-    internal static class Memory
+    internal static class Detour
     {
         static readonly HashSet<PlatformID> WindowsPlatformIDSet = new HashSet<PlatformID>
         {

scripts/DllManipulator.ReflectionCache.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -14,8 +15,8 @@ public partial class DllManipulator
         private static readonly Type[] MARSHAL_AS_ATTRIBUTE_CTOR_PARAMETERS = { typeof(UnmanagedType) };
 
 
-        private static readonly Lazy<FieldInfo> Field_NativeFunctions = new Lazy<FieldInfo>(
-            () => typeof(DllManipulator).GetField(nameof(_nativeFunctions), BindingFlags.NonPublic | BindingFlags.Static));
+        private static readonly Lazy<FieldInfo> Field_MockedNativeFunctions = new Lazy<FieldInfo>(
+            () => typeof(DllManipulator).GetField(nameof(_mockedNativeFunctions), BindingFlags.NonPublic | BindingFlags.Static));
 
         private static readonly Lazy<FieldInfo> Field_NativeFunctionDelegate = new Lazy<FieldInfo>(
             () => typeof(NativeFunction).GetField(nameof(NativeFunction.@delegate), BindingFlags.Public | BindingFlags.Instance));
@@ -29,6 +30,10 @@ public partial class DllManipulator
         private static readonly Lazy<MethodInfo> Method_WriteNativeCrashLog = new Lazy<MethodInfo>(
             () => typeof(DllManipulator).GetMethod(nameof(WriteNativeCrashLog), BindingFlags.NonPublic | BindingFlags.Static));
 
+
+        private static readonly Lazy<MethodInfo> Method_List_NativeFunction_get_Item = new Lazy<MethodInfo>(
+            () => typeof(List<NativeFunction>).GetMethod("get_Item", BindingFlags.Public | BindingFlags.Instance));
+
         /// <summary>
         /// <see cref="ReaderWriterLockSlim.EnterReadLock()"/>
         /// </summary>

scripts/DllManipulator.cs

@@ -28,12 +28,11 @@ public partial class DllManipulator
         private static readonly Dictionary<string, NativeDll> _dlls = new Dictionary<string, NativeDll>();
         private static readonly Dictionary<MethodInfo, DynamicMethod> _nativeFunctionMocks = new Dictionary<MethodInfo, DynamicMethod>();
         private static readonly Dictionary<NativeFunctionSignature, Type> _delegateTypesForNativeFunctionSignatures = new Dictionary<NativeFunctionSignature, Type>();
-        private static NativeFunction[] _nativeFunctions = null;
-        private static int _nativeFunctionsCount = 0;
+        private static List<NativeFunction> _mockedNativeFunctions = new List<NativeFunction>();
         private static int _createdDelegateTypes = 0;
         private static int _lastNativeCallIndex = 0; //Use with synchronization
 
-        public static void SetUnityContext(int unityMainThreadId, string assetsPath)
+        internal static void SetUnityContext(int unityMainThreadId, string assetsPath)
         {
             DllManipulator._unityMainThreadId = unityMainThreadId;
             DllManipulator._assetsPath = assetsPath;
@@ -79,19 +78,10 @@ public static void UnloadAll()
                         LowLevelPluginManager.OnBeforeDllUnload(dll);
 
                         bool success = SysUnloadDll(dll.handle);
-                        dll.handle = IntPtr.Zero;
-
-                        //Reset error states at unload
-                        dll.loadingError = false;
-                        dll.symbolError = false;
-
-                        foreach (var func in dll.functions)
-                        {
-                            func.@delegate = null;
-                        }
-
                         if (!success)
                             Debug.LogWarning($"Error while unloading DLL \"{dll.name}\" at path \"{dll.path}\"");
+
+                        dll.ResetAsUnloaded();
                     }
                 }
             }
@@ -101,14 +91,13 @@ public static void UnloadAll()
             }
         }
 
-        public static void ForgetAllDlls()
+        internal static void ForgetAllDlls()
         {
             _dlls.Clear();
-            _nativeFunctions = null;
-            _nativeFunctionsCount = 0;
+            _mockedNativeFunctions.Clear();
         }
 
-        public static void ClearCrashLogs()
+        internal static void ClearCrashLogs()
         {
             if (Options.enableCrashLogs)
             {
@@ -140,7 +129,7 @@ public static IList<NativeDllInfo> GetUsedDllsInfos()
             return dllInfos;
         }
 
-        public static IEnumerable<MethodInfo> FindNativeFunctionsToMock(Assembly assembly)
+        internal static IEnumerable<MethodInfo> FindNativeFunctionsToMock(Assembly assembly)
         {
             var allTypes = assembly.GetTypes();
             foreach (var type in allTypes)
@@ -162,19 +151,19 @@ public static IEnumerable<MethodInfo> FindNativeFunctionsToMock(Assembly assembl
             }
         }
 
-        public static string ApplyDirectoryPathMacros(string path)
+        private static string ApplyDirectoryPathMacros(string path)
         {
             return path
                 .Replace(DLL_PATH_PATTERN_ASSETS_MACRO, _assetsPath)
                 .Replace(DLL_PATH_PATTERN_PROJECT_MACRO, _assetsPath + "/../");
         }
 
-        public static void MockNativeFunction(MethodInfo function)
+        internal static void MockNativeFunction(MethodInfo function)
         {
             var methodMock = GetNativeFunctionMockMethod(function);
-            Memory.MarkForNoInlining(function);
+            Detour.MarkForNoInlining(function);
             PrepareDynamicMethod(methodMock);
-            Memory.DetourMethod(function, methodMock);
+            Detour.DetourMethod(function, methodMock);
         }
 
         /// <summary>
@@ -202,9 +191,8 @@ private static DynamicMethod GetNativeFunctionMockMethod(MethodInfo nativeMethod
 
                 var nativeFunction = new NativeFunction(nativeFunctionSymbol, dll);
                 dll.functions.Add(nativeFunction);
-                var nativeFunctionIndex = _nativeFunctionsCount;
-                AddNativeFunction(nativeFunction);
-                nativeFunction.index = nativeFunctionIndex;
+                var nativeFunctionIndex = _mockedNativeFunctions.Count;
+                _mockedNativeFunctions.Add(nativeFunction);
 
                 var parameters = nativeMethod.GetParameters();
                 var parameterTypes = parameters.Select(x => x.ParameterType).ToArray();
@@ -247,9 +235,9 @@ private static void GenerateNativeFunctionMockBody(ILGenerator il, ParameterInfo
                 il.BeginExceptionBlock(); //Start lock clause: lock, try {  ...  }, finally { release }
             }
 
-            il.Emit(OpCodes.Ldsfld, Field_NativeFunctions.Value); //Load NativeFunction object
+            il.Emit(OpCodes.Ldsfld, Field_MockedNativeFunctions.Value); //Load NativeFunction object
             il.EmitFastI4Load(nativeFunctionIndex);
-            il.Emit(OpCodes.Ldelem_Ref);
+            il.Emit(OpCodes.Call, Method_List_NativeFunction_get_Item.Value);
 
             if (Options.loadingMode == DllLoadingMode.Lazy) //If lazy mode, load the function. Otherwise we assume it's already loaded
             {
@@ -276,9 +264,9 @@ private static void GenerateNativeFunctionMockBody(ILGenerator il, ParameterInfo
                 }
                 il.Emit(OpCodes.Call, Method_WriteNativeCrashLog.Value);
 
-                il.Emit(OpCodes.Ldsfld, Field_NativeFunctions.Value); //Once again load native function, previous one was consumed by log method
+                il.Emit(OpCodes.Ldsfld, Field_MockedNativeFunctions.Value); //Once again load native function, previous one was consumed by log method
                 il.EmitFastI4Load(nativeFunctionIndex);
-                il.Emit(OpCodes.Ldelem_Ref);
+                il.Emit(OpCodes.Call, Method_List_NativeFunction_get_Item.Value);
             }
 
             il.Emit(OpCodes.Ldfld, Field_NativeFunctionDelegate.Value);
@@ -326,24 +314,6 @@ private static void PrepareDynamicMethod(DynamicMethod method)
             }
         }
 
-        /// <summary>
-        /// Adds <paramref name="nativeFunction"/> to <see cref="_nativeFunctions"/> list
-        /// </summary>
-        private static void AddNativeFunction(NativeFunction nativeFunction)
-        {
-            if (_nativeFunctions == null)
-                _nativeFunctions = new NativeFunction[4];
-
-            if (_nativeFunctionsCount == _nativeFunctions.Length)
-            {
-                var newArray = new NativeFunction[_nativeFunctions.Length * 2];
-                Array.Copy(_nativeFunctions, newArray, _nativeFunctions.Length);
-                _nativeFunctions = newArray;
-            }
-
-            _nativeFunctions[_nativeFunctionsCount++] = nativeFunction;
-        }
-
         private static Type CreateDelegateTypeForNativeFunctionSignature(NativeFunctionSignature functionSignature, string functionName)
         {
             if (_customDelegateTypesModule == null)

scripts/NativeDll.cs

@@ -17,6 +17,18 @@ public NativeDll(string name, string path)
             this.name = name;
             this.path = path;
         }
+
+        public void ResetAsUnloaded()
+        {
+            handle = IntPtr.Zero;
+            loadingError = false;
+            symbolError = false;
+
+            foreach (var func in functions)
+            {
+                func.@delegate = null;
+            }
+        }
     }
 
     public class NativeDllInfo

scripts/NativeFunction.cs

@@ -34,9 +34,8 @@ internal class NativeFunction
     {
         public readonly NativeFunctionIdentity identity;
         public NativeDll containingDll;
-        public Delegate @delegate = null;
         public Type delegateType = null;
-        public int index = -1;
+        public Delegate @delegate = null;
 
         public NativeFunction(string symbol, NativeDll containingDll)
         {