Small refactor lambda

qubka · qubka · commit d20b92ad5dba · 2024-06-29T17:01:30.000+01:00
diff --git a/managed/Plugify/NativeInterop.cs b/managed/Plugify/NativeInterop.cs
@@ -700,139 +700,135 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf
     {
 	    ManagedType returnType =  new ManagedType(methodInfo.ReturnType, methodInfo.ReturnTypeCustomAttributes.GetCustomAttributes(typeof(MarshalAsAttribute), false));
 	    ManagedType[] parameterTypes = methodInfo.GetParameters().Select(p => new ManagedType(p.ParameterType, p.GetCustomAttributes(typeof(MarshalAsAttribute), false))).ToArray();
+	   
+	    bool hasRet = returnType.ValueType is >= ValueType.String and <= ValueType.ArrayString;
+	    bool hasRefs = parameterTypes.Any(t => t.IsByRef);
 	    
         return parameters =>
         {
 	        lock (vm)
 	        {
 		        vm.Reset();
 
-		        bool hasRet = true;
-		        bool hasRefs = false;
-
 		        // Store parameters
 
 		        List<(nint, ValueType)> handlers = [];
 
-		        ValueType type = returnType.ValueType;
-		        switch (type)
+		        ValueType retType = returnType.ValueType;
+		        switch (retType)
 		        {
 			        case ValueType.String:
 			        {
 				        nint ptr = NativeMethods.AllocateString();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayBool:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorBool();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayChar8:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorChar8();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayChar16:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorChar16();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayInt8:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorInt8();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayInt16:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorInt16();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayInt32:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorInt32();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayInt64:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorInt64();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayUInt8:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorUInt8();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayUInt16:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorUInt16();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayUInt32:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorUInt32();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayUInt64:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorUInt64();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayPointer:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorIntPtr();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayFloat:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorFloat();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayDouble:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorDouble();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
 			        case ValueType.ArrayString:
 			        {
 				        nint ptr = NativeMethods.AllocateVectorString();
-				        handlers.Add((ptr, type));
+				        handlers.Add((ptr, retType));
 				        vm.ArgPointer(ptr);
 				        break;
 			        }
-			        default:
-				        // Should not require storage
-				        hasRet = false;
-				        break;
 		        }
 
 		        List<GCHandle> pins = [];
@@ -847,7 +843,6 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf
 			        {
 				        switch (valueType)
 				        {
-					        case ValueType.Invalid:
 					        case ValueType.Void:
 						        break;
 					        case ValueType.Bool:
@@ -1039,14 +1034,11 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf
 					        default:
 						        throw new ArgumentOutOfRangeException();
 				        }
-
-				        hasRefs = true;
 			        }
 			        else
 			        {
 				        switch (valueType)
 				        {
-					        case ValueType.Invalid:
 					        case ValueType.Void:
 						        break;
 					        case ValueType.Bool:
@@ -1243,10 +1235,8 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf
 
 		        object? ret = null;
 
-		        switch (type)
+		        switch (retType)
 		        {
-			        case ValueType.Invalid:
-				        break;
 			        case ValueType.Void:
 				        vm.CallVoid(funcAddress);
 				        break;

Original file line number	Diff line number	Diff line change
`@@ -700,139 +700,135 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf`
`700`	`700`	`{`
`701`	`701`	`ManagedType returnType = new ManagedType(methodInfo.ReturnType, methodInfo.ReturnTypeCustomAttributes.GetCustomAttributes(typeof(MarshalAsAttribute), false));`
`702`	`702`	`ManagedType[] parameterTypes = methodInfo.GetParameters().Select(p => new ManagedType(p.ParameterType, p.GetCustomAttributes(typeof(MarshalAsAttribute), false))).ToArray();`
	`703`	`+`
	`704`	`+ bool hasRet = returnType.ValueType is >= ValueType.String and <= ValueType.ArrayString;`
	`705`	`+ bool hasRefs = parameterTypes.Any(t => t.IsByRef);`
`703`	`706`
`704`	`707`	`return parameters =>`
`705`	`708`	`{`
`706`	`709`	`lock (vm)`
`707`	`710`	`{`
`708`	`711`	`vm.Reset();`
`709`	`712`
`710`		`- bool hasRet = true;`
`711`		`- bool hasRefs = false;`
`712`		`-`
`713`	`713`	`// Store parameters`
`714`	`714`
`715`	`715`	`List<(nint, ValueType)> handlers = [];`
`716`	`716`
`717`		`- ValueType type = returnType.ValueType;`
`718`		`- switch (type)`
	`717`	`+ ValueType retType = returnType.ValueType;`
	`718`	`+ switch (retType)`
`719`	`719`	`{`
`720`	`720`	`case ValueType.String:`
`721`	`721`	`{`
`722`	`722`	`nint ptr = NativeMethods.AllocateString();`
`723`		`- handlers.Add((ptr, type));`
	`723`	`+ handlers.Add((ptr, retType));`
`724`	`724`	`vm.ArgPointer(ptr);`
`725`	`725`	`break;`
`726`	`726`	`}`
`727`	`727`	`case ValueType.ArrayBool:`
`728`	`728`	`{`
`729`	`729`	`nint ptr = NativeMethods.AllocateVectorBool();`
`730`		`- handlers.Add((ptr, type));`
	`730`	`+ handlers.Add((ptr, retType));`
`731`	`731`	`vm.ArgPointer(ptr);`
`732`	`732`	`break;`
`733`	`733`	`}`
`734`	`734`	`case ValueType.ArrayChar8:`
`735`	`735`	`{`
`736`	`736`	`nint ptr = NativeMethods.AllocateVectorChar8();`
`737`		`- handlers.Add((ptr, type));`
	`737`	`+ handlers.Add((ptr, retType));`
`738`	`738`	`vm.ArgPointer(ptr);`
`739`	`739`	`break;`
`740`	`740`	`}`
`741`	`741`	`case ValueType.ArrayChar16:`
`742`	`742`	`{`
`743`	`743`	`nint ptr = NativeMethods.AllocateVectorChar16();`
`744`		`- handlers.Add((ptr, type));`
	`744`	`+ handlers.Add((ptr, retType));`
`745`	`745`	`vm.ArgPointer(ptr);`
`746`	`746`	`break;`
`747`	`747`	`}`
`748`	`748`	`case ValueType.ArrayInt8:`
`749`	`749`	`{`
`750`	`750`	`nint ptr = NativeMethods.AllocateVectorInt8();`
`751`		`- handlers.Add((ptr, type));`
	`751`	`+ handlers.Add((ptr, retType));`
`752`	`752`	`vm.ArgPointer(ptr);`
`753`	`753`	`break;`
`754`	`754`	`}`
`755`	`755`	`case ValueType.ArrayInt16:`
`756`	`756`	`{`
`757`	`757`	`nint ptr = NativeMethods.AllocateVectorInt16();`
`758`		`- handlers.Add((ptr, type));`
	`758`	`+ handlers.Add((ptr, retType));`
`759`	`759`	`vm.ArgPointer(ptr);`
`760`	`760`	`break;`
`761`	`761`	`}`
`762`	`762`	`case ValueType.ArrayInt32:`
`763`	`763`	`{`
`764`	`764`	`nint ptr = NativeMethods.AllocateVectorInt32();`
`765`		`- handlers.Add((ptr, type));`
	`765`	`+ handlers.Add((ptr, retType));`
`766`	`766`	`vm.ArgPointer(ptr);`
`767`	`767`	`break;`
`768`	`768`	`}`
`769`	`769`	`case ValueType.ArrayInt64:`
`770`	`770`	`{`
`771`	`771`	`nint ptr = NativeMethods.AllocateVectorInt64();`
`772`		`- handlers.Add((ptr, type));`
	`772`	`+ handlers.Add((ptr, retType));`
`773`	`773`	`vm.ArgPointer(ptr);`
`774`	`774`	`break;`
`775`	`775`	`}`
`776`	`776`	`case ValueType.ArrayUInt8:`
`777`	`777`	`{`
`778`	`778`	`nint ptr = NativeMethods.AllocateVectorUInt8();`
`779`		`- handlers.Add((ptr, type));`
	`779`	`+ handlers.Add((ptr, retType));`
`780`	`780`	`vm.ArgPointer(ptr);`
`781`	`781`	`break;`
`782`	`782`	`}`
`783`	`783`	`case ValueType.ArrayUInt16:`
`784`	`784`	`{`
`785`	`785`	`nint ptr = NativeMethods.AllocateVectorUInt16();`
`786`		`- handlers.Add((ptr, type));`
	`786`	`+ handlers.Add((ptr, retType));`
`787`	`787`	`vm.ArgPointer(ptr);`
`788`	`788`	`break;`
`789`	`789`	`}`
`790`	`790`	`case ValueType.ArrayUInt32:`
`791`	`791`	`{`
`792`	`792`	`nint ptr = NativeMethods.AllocateVectorUInt32();`
`793`		`- handlers.Add((ptr, type));`
	`793`	`+ handlers.Add((ptr, retType));`
`794`	`794`	`vm.ArgPointer(ptr);`
`795`	`795`	`break;`
`796`	`796`	`}`
`797`	`797`	`case ValueType.ArrayUInt64:`
`798`	`798`	`{`
`799`	`799`	`nint ptr = NativeMethods.AllocateVectorUInt64();`
`800`		`- handlers.Add((ptr, type));`
	`800`	`+ handlers.Add((ptr, retType));`
`801`	`801`	`vm.ArgPointer(ptr);`
`802`	`802`	`break;`
`803`	`803`	`}`
`804`	`804`	`case ValueType.ArrayPointer:`
`805`	`805`	`{`
`806`	`806`	`nint ptr = NativeMethods.AllocateVectorIntPtr();`
`807`		`- handlers.Add((ptr, type));`
	`807`	`+ handlers.Add((ptr, retType));`
`808`	`808`	`vm.ArgPointer(ptr);`
`809`	`809`	`break;`
`810`	`810`	`}`
`811`	`811`	`case ValueType.ArrayFloat:`
`812`	`812`	`{`
`813`	`813`	`nint ptr = NativeMethods.AllocateVectorFloat();`
`814`		`- handlers.Add((ptr, type));`
	`814`	`+ handlers.Add((ptr, retType));`
`815`	`815`	`vm.ArgPointer(ptr);`
`816`	`816`	`break;`
`817`	`817`	`}`
`818`	`818`	`case ValueType.ArrayDouble:`
`819`	`819`	`{`
`820`	`820`	`nint ptr = NativeMethods.AllocateVectorDouble();`
`821`		`- handlers.Add((ptr, type));`
	`821`	`+ handlers.Add((ptr, retType));`
`822`	`822`	`vm.ArgPointer(ptr);`
`823`	`823`	`break;`
`824`	`824`	`}`
`825`	`825`	`case ValueType.ArrayString:`
`826`	`826`	`{`
`827`	`827`	`nint ptr = NativeMethods.AllocateVectorString();`
`828`		`- handlers.Add((ptr, type));`
	`828`	`+ handlers.Add((ptr, retType));`
`829`	`829`	`vm.ArgPointer(ptr);`
`830`	`830`	`break;`
`831`	`831`	`}`
`832`		`- default:`
`833`		`- // Should not require storage`
`834`		`- hasRet = false;`
`835`		`- break;`
`836`	`832`	`}`
`837`	`833`
`838`	`834`	`List<GCHandle> pins = [];`
`@@ -847,7 +843,6 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf`
`847`	`843`	`{`
`848`	`844`	`switch (valueType)`
`849`	`845`	`{`
`850`		`- case ValueType.Invalid:`
`851`	`846`	`case ValueType.Void:`
`852`	`847`	`break;`
`853`	`848`	`case ValueType.Bool:`
`@@ -1039,14 +1034,11 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf`
`1039`	`1034`	`default:`
`1040`	`1035`	`throw new ArgumentOutOfRangeException();`
`1041`	`1036`	`}`
`1042`		`-`
`1043`		`- hasRefs = true;`
`1044`	`1037`	`}`
`1045`	`1038`	`else`
`1046`	`1039`	`{`
`1047`	`1040`	`switch (valueType)`
`1048`	`1041`	`{`
`1049`		`- case ValueType.Invalid:`
`1050`	`1042`	`case ValueType.Void:`
`1051`	`1043`	`break;`
`1052`	`1044`	`case ValueType.Bool:`
`@@ -1243,10 +1235,8 @@ private static Func<object[], object> ExternalInvoke(nint funcAddress, MethodInf`
`1243`	`1235`
`1244`	`1236`	`object? ret = null;`
`1245`	`1237`
`1246`		`- switch (type)`
	`1238`	`+ switch (retType)`
`1247`	`1239`	`{`
`1248`		`- case ValueType.Invalid:`
`1249`		`- break;`
`1250`	`1240`	`case ValueType.Void:`
`1251`	`1241`	`vm.CallVoid(funcAddress);`
`1252`	`1242`	`break;`