vb Integer to c++ to ML32 to c++ to vb UInteger - c++

Question

I'm experimenting with changing a vb 2015 Integer into a vb 2015 UInteger via a direct bit-by-bit transfer in ML32. From vb2015, I call a vc++ 2015 function in a dll which uses the inline assembler to effect the change.
By doing this, I can take a negative Integer such as -633593090 = &HDA3C22FE = 11011010001111000010001011111110b
And change it to a UInteger = 11011010001111000010001011111110b = &HDA3C22FE = 3661374206
As opposed to something like the seemingly simple "uTest1 = CUInt(iTest1)" which throws a System.OverflowException for iTest1 negative.
I have code which works properly, but I'm interested in the possibility of a small improvement.
In vb 2015, I declare the access to the vc++ 2015 dll like this:
' vb Integer --> c++ signed long --> c++ unsigned long --> vb UInteger -- Works!
' by direct copy of bits through x86 ML32
' 4 bytes = 32 bits
<DllImport("StringTest.dll", EntryPoint:="bitConvert", SetLastError:=True, CharSet:=CharSet.Ansi, ExactSpelling:=True, CallingConvention:=CallingConvention.Cdecl)>
Private Shared Function bitConvertTester(ByRef varSInt As Integer, ByRef varUInt As UInteger) As Integer
' Must be "Shared"
' Must be "ByRef"
' Do not try varSInt As "Signed Integer" or varUInt As "Unsigned Integer" --> Syntax Error
' Leave the body of the function empty
End Function
And I use this vb 2015 code to actually call the vc++ 2015 function in the dll:
' Third Method - Partial - Works!
Dim pCTest As Color
Dim iTest As Integer
Dim uTest As UInteger
Dim returnCode As Integer
pCTest = Color.FromArgb(&HDA, &H3C, &H22, &HFE)
iTest = pCTest.ToArgb
System.Diagnostics.Debug.Write(iTest.ToString + vbCrLf)
System.Diagnostics.Debug.Write(Hex(iTest) + vbCrLf)
' vb Integer --> c++ signed long --> c++ unsigned long --> vb UInteger
' by direct copy of bits through x86 ML32
' 4 bytes = 32 bits
' Note: Function prototype is "ByRef", but this MUST
' NOT go in this test call (causes a syntax error).
returnCode = bitConvertTester(iTest, uTest)
System.Diagnostics.Debug.Write(uTest.ToString + vbCrLf)
System.Diagnostics.Debug.Write(Hex(uTest) + vbCrLf)
And here is the vc++ 2015 dll function itself:
#define EXPORT_VB extern "C" __declspec(dllexport)
// vb Integer --> c++ signed long --> c++ unsigned long --> vb UInteger -- Works!
// by direct copy of bits through x86 ML32
// 4 bytes = 32 bits
EXPORT_VB long __cdecl bitConvert(signed long *varSInt, unsigned long *varUInt)
{
// Intermediate variables are required for ML32 access.
signed long varSInt1;
unsigned long varUInt1;
varSInt1 = *varSInt;
__asm
{
mov EAX, varSInt1
mov varUInt1, EAX
}
*varUInt = varUInt1;
return 1; // Success Code
}
I call the vc++ 2015 dll function from vb 2015 with the variables ByRef so that the dll function can use pointers to change the vb 2015 variables as needed via *varSInt and *varUInt.
My question is: In the vc++ __asm block, is there any way for the ML32 code to access *varSInt and *varUInt directly, without going through the varSInt1 and varUInt1 intermediate variables?
BTW, the vb 2015 code uses:
Imports System
Imports System.IO
Imports System.Text
Imports System.Runtime.InteropServices
And the vc++ 2015 code uses:
#include "stdafx.h"
#include <stdexcept>
#include <string.h>
(One thing I find frustrating with Microsoft documentation is the failure to include a list of the "Imports" or "#include" statements required for use of the feature the documentation is describing).

Answer 1

I realise that you said you are just doing this as an exercise, but there is a relatively easy way to get the result you want in VB (or C# for that matter).
Function ToUInt(value As Integer) As UInteger
Return CUInt(If(value < 0, UInteger.MaxValue + value + 1, value))
End Function