GetuCalcMethod

Applies to:Fast Math Parser
Class:uCalc.Callback
Returns the uCalc instance the current expression part belongs to
Syntax
GetuCalc()
Remarks
A callback is designed to work with all instances of uCalc. However, at times you may need to know which particular instance of uCalc the expression part being passed belongs to.
Example 1: Dealing with various data types in a callback 

Sub MyFunctionCB(ByVal ExprPartPtr As IntPtr)
   Dim ExprPart As New uCalc.Callback(ExprPartPtr)
   Dim ucc = ExprPart.GetuCalc()

   Console.WriteLine(ExprPart.ArgInt32(1)) ' Returns 1230
   Console.WriteLine(ExprPart.ArgInt64(2)) ' Returns 2

   Console.WriteLine(ucc.GetItemOf("Int8").GetDataType().ToString(ExprPart.ArgAddr(3))) ' Returns -1
   Console.WriteLine(ucc.GetItemOf("Int").GetDataType().ToString(ExprPart.ArgPtr(4))) ' Returns 123
End Sub

Sub MyFunctionCallback()
   uc.DefineVariable("x As Int = 123")
   uc.DefineVariable("xPtr As Int Ptr = AddressOf(x)")
   uc.DefineFunction("MyFunc(a As Int32, b As Int64, c As Byte, d As Int Ptr)", uc.PinAddr(AddressOf MyFunctionCB))
   uc.Eval("MyFunc(x*10, 1+1, 255, xPtr)")
End Sub

          

static void MyFunctionCB(IntPtr ExprPartPtr) {
   var ExprPart = New uCalc.Callback(ExprPartPtr);
   var ucc = ExprPart.GetuCalc();
   
   Console.WriteLine(ExprPart.ArgInt32(1)); // Returns 1230;
   Console.WriteLine(ExprPart.ArgInt64(2)); // Returns 2;
   
   Console.WriteLine(ucc.GetItemOf("Int8").GetDataType().ToString(ExprPart.ArgAddr(3))); // Returns -1;
   Console.WriteLine(ucc.GetItemOf("Int").GetDataType().ToString(ExprPart.ArgPtr(4))); // Returns 123;
}

static void MyFunctionCallback() {
   uc.DefineVariable("x As Int = 123");
   uc.DefineVariable("xPtr As Int Ptr = AddressOf(x)");
   uc.DefineFunction("MyFunc(a As Int32, b As Int64, c As Byte, d As Int Ptr)", uc.PinAddr(MyFunctionCB));
   uc.Eval("MyFunc(x*10, 1+1, 255, xPtr)");
}

          

procedure MyFunctionCB(ExprPartPtr: System.Pointer);
begin
   
//var ExprPart: uCalc.CreateCallback(ExprPartPtr);
//var ucc = ExprPart.GetuCalc();

   WriteLn(ExprPart.ArgInt32(1)); // Returns 1230;
   WriteLn(ExprPart.ArgInt64(2)); // Returns 2;

   WriteLn(ucc.GetItemOf('Int8').GetDataType().ToString(ExprPart.ArgAddr(3))); // Returns -1;
   WriteLn(ucc.GetItemOf('Int').GetDataType().ToString(ExprPart.ArgPtr(4))); // Returns 123;
End;

procedure MyFunctionCallback();
begin
   
   uc.DefineVariable('x As Int = 123');
   uc.DefineVariable('xPtr As Int Ptr = AddressOf(x)');
   uc.DefineFunction('MyFunc(a As Int32, b As Int64, c As Byte, d As Int Ptr)', MyFunctionCB);
   uc.Eval('MyFunc(x*10, 1+1, 255, xPtr)');
End;

          

void _stdcall MyFunctionCB(uCalcPtr ExprPartPtr) {
   auto ExprPart = uCalc::Callback(ExprPartPtr);
   auto ucc = ExprPart.GetuCalc();
   
   cout << ExprPart.ArgInt32(1) << endl; // Returns 1230;
   cout << ExprPart.ArgInt64(2) << endl; // Returns 2;
   
   cout << ucc.GetItemOf("Int8").GetDataType().ToString(ExprPart.ArgAddr(3)) << endl; // Returns -1;
   cout << ucc.GetItemOf("Int").GetDataType().ToString(ExprPart.ArgPtr(4)) << endl; // Returns 123;
}

void MyFunctionCallback() {
   uc.DefineVariable("x As Int = 123");
   uc.DefineVariable("xPtr As Int Ptr = AddressOf(x)");
   uc.DefineFunction("MyFunc(a As Int32, b As Int64, c As Byte, d As Int Ptr)", MyFunctionCB);
   uc.Eval("MyFunc(x*10, 1+1, 255, xPtr)");
}

          

static void MyFunctionCB(uCalcPtr ExprPartPtr) {
   auto ExprPart = uCalc::Callback(ExprPartPtr);
   auto ucc = ExprPart.GetuCalc();
   
   Console::WriteLine(ExprPart.ArgInt32(1)); // Returns 1230;
   Console::WriteLine(ExprPart.ArgInt64(2)); // Returns 2;
   
   Console::WriteLine(ucc.GetItemOf("Int8").GetDataType().ToString(ExprPart.ArgAddr(3))); // Returns -1;
   Console::WriteLine(ucc.GetItemOf("Int").GetDataType().ToString(ExprPart.ArgPtr(4))); // Returns 123;
}

static void MyFunctionCallback() {
   uc.DefineVariable("x As Int = 123");
   uc.DefineVariable("xPtr As Int Ptr = AddressOf(x)");
   uc.DefineFunction("MyFunc(a As Int32, b As Int64, c As Byte, d As Int Ptr)", ucPinAddr(MyFunctionCB));
   uc.Eval("MyFunc(x*10, 1+1, 255, xPtr)");
}
Example 2: Raising a floating point exception 

Sub FPEnvRaiseTestCB(ByVal ExprPartPtr As IntPtr)
   Dim ExprPart As New uCalc.Callback(ExprPartPtr)
   ExprPart.GetuCalc().FPEnvRaiseException(FPEnvExceptionEnum.Invalid)
End Sub

Sub FPEnvRaiseTest()
   uc.DefineFunction("FPEnvRaiseTest()", uc.PinAddr(AddressOf FPEnvRaiseTestCB))
   ' Note: If the exception is masked then EvalStr returns an error message
   '       otherwise the exception must be cought with a Try block.
   Console.WriteLine(uc.EvalStr("FPEnvRaiseTest()")) ' Returns "Invalid operation"
End Sub

          

static void FPEnvRaiseTestCB(IntPtr ExprPartPtr) {
   var ExprPart = New uCalc.Callback(ExprPartPtr);
   ExprPart.GetuCalc().FPEnvRaiseException(FPEnvExceptionEnum.Invalid);
}

static void FPEnvRaiseTest() {
   uc.DefineFunction("FPEnvRaiseTest()", uc.PinAddr(FPEnvRaiseTestCB));
   // Note: If the exception is masked then EvalStr returns an error message
   //       otherwise the exception must be cought with a Try block.
   Console.WriteLine(uc.EvalStr("FPEnvRaiseTest()")); // Returns "Invalid operation";
}

          

procedure FPEnvRaiseTestCB(ExprPartPtr: System.Pointer);
begin
   
//var ExprPart: uCalc.CreateCallback(ExprPartPtr);
   ExprPart.GetuCalc().FPEnvRaiseException(FPEnvExceptionEnum.Invalid);
End;

procedure FPEnvRaiseTest();
begin
   
   uc.DefineFunction('FPEnvRaiseTest()', FPEnvRaiseTestCB);
   // Note: If the exception is masked then EvalStr returns an error message
   //       otherwise the exception must be cought with a Try block.
   WriteLn(uc.EvalStr('FPEnvRaiseTest()')); // Returns 'Invalid operation';
End;

          

void _stdcall FPEnvRaiseTestCB(uCalcPtr ExprPartPtr) {
   auto ExprPart = uCalc::Callback(ExprPartPtr);
   ExprPart.GetuCalc().FPEnvRaiseException(FPEnvExceptionEnum::Invalid);
}

void FPEnvRaiseTest() {
   uc.DefineFunction("FPEnvRaiseTest()", FPEnvRaiseTestCB);
   // Note: If the exception is masked then EvalStr returns an error message
   //       otherwise the exception must be cought with a Try block.
   cout << uc.EvalStr("FPEnvRaiseTest()") << endl; // Returns "Invalid operation";
}

          

static void FPEnvRaiseTestCB(uCalcPtr ExprPartPtr) {
   auto ExprPart = uCalc::Callback(ExprPartPtr);
   ExprPart.GetuCalc().FPEnvRaiseException(FPEnvExceptionEnum::Invalid);
}

static void FPEnvRaiseTest() {
   uc.DefineFunction("FPEnvRaiseTest()", ucPinAddr(FPEnvRaiseTestCB));
   // Note: If the exception is masked then EvalStr returns an error message
   //       otherwise the exception must be cought with a Try block.
   Console::WriteLine(uc.EvalStr("FPEnvRaiseTest()")); // Returns "Invalid operation";
}
DLL import code
<DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.Cdecl, EntryPoint:="GetuCalc_Overload_Callback")> _

Private Function GetuCalc_Overload_Callback__(ByVal ExprPartHandle As IntPtr) As IntPtr
End Function
            
[DllImport(uCalcDLL, CharSet=CharSet.Ansi, CallingConvention=CallingConvention.Cdecl, EntryPoint="GetuCalc_Overload_Callback")]

protected static extern IntPtr GetuCalc_Overload_Callback_(IntPtr ExprPartHandle);
            
{DLLImport}function GetuCalc_Overload_Callback__(ExprPartHandle: System.Pointer): System.Pointer; cdecl; external uCalcDLL name 'GetuCalc_Overload_Callback';

            
typedef uCalcPtr (* __GetuCalc_Overload_Callback)(void *ExprPartHandle); 

            
[DllImport(uCalcLib, CharSet=CharSet::Ansi, CallingConvention=CallingConvention::Cdecl, EntryPoint = "GetuCalc_Overload_Callback")]

static uCalcPtr GetuCalc_Overload_Callback_(void *  ExprPartHandle);
Prev | Next