From 880e754254ebbfe18e5f97135d71d4cd15165185 Mon Sep 17 00:00:00 2001 From: Michael Dirks Date: Sat, 20 Jun 2015 15:08:27 +0200 Subject: [PATCH] 1.3 Update: - Blitz functions are callable using __stdcall, use it instead of using tailored asm. - DLLs that rely on this DLL no longer have to load the DLL to call Blitz functions, just include BlitzPointer.h and use the typedefs BP_BlitzFunction#_t. - Removed Hybrid support until Hybrid is open-source. --- Blitz/BlitzPointer.decls | 736 +++++++++++++++++------------------ Blitz/Example01.bb | 4 +- Blitz/Example02.bb | 4 +- Blitz/Example03.bb | 18 +- Blitz/Example04.bb | 20 +- Blitz/Example05.bb | 6 +- Blitz/Example06.bb | 2 +- Blitz/Example07.bb | 6 +- BlitzHybrid.cpp | 150 ------- BlitzNative.cpp | 91 ----- BlitzPointer.cpp | 41 +- BlitzPointer.h | 31 +- BlitzPointer.vcxproj | 13 +- BlitzPointer.vcxproj.filters | 15 +- MemoryHelpers.cpp | 20 +- dllmain.h | 11 +- 16 files changed, 484 insertions(+), 684 deletions(-) delete mode 100644 BlitzHybrid.cpp delete mode 100644 BlitzNative.cpp diff --git a/Blitz/BlitzPointer.decls b/Blitz/BlitzPointer.decls index e2d70e0..1e49857 100644 --- a/Blitz/BlitzPointer.decls +++ b/Blitz/BlitzPointer.decls @@ -16,6 +16,11 @@ .lib "BlitzPointer.dll" +; BlitzPointer +BP_GetReturnAddress%() +BP_GetFunctionPointer%() +BP_GetVariablePointer%() + ; Memory Modification PeekMemoryByte%(lpMemoryPointer%) PeekMemoryShort%(lpMemoryPointer%) @@ -28,372 +33,367 @@ PokeMemoryInt(lpMemoryPointer%, value%) PokeMemoryFloat(lpMemoryPointer%, value#) PokeMemory(lpMemoryPointer%, iLength%, lpBank*) -; BlitzPointer -BlitzPointer_GetReturnAddress%() -BlitzPointer_GetFunctionPointer%() - ; Function Calling -BlitzPointer_CallFunctionV(lpFunctionPointer%) : "BlitzPointer_CallFunction0" -BlitzPointer_CallFunctionVI(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionVII(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVIII(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIIII(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIIF(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIIP(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIF(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIIFI(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIFF(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIFP(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIP(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIIPI(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIPF(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIIPP(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIF(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVIFI(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIFII(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFIF(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFIP(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFF(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIFFI(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFFF(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFFP(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFP(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIFPI(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFPF(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIFPP(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIP(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVIPI(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIPII(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPIF(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPIP(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPF(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIPFI(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPFF(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPFP(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPP(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVIPPI(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPPF(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVIPPP(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVF(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionVFI(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVFII(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFIII(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIIF(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIIP(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIF(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFIFI(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIFF(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIFP(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIP(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFIPI(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIPF(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFIPP(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFF(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVFFI(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFFII(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFIF(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFIP(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFF(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFFFI(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFFF(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFFP(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFP(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFFPI(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFPF(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFFPP(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFP(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVFPI(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFPII(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPIF(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPIP(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPF(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFPFI(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPFF(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPFP(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPP(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVFPPI(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPPF(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVFPPP(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVP(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionVPI(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVPII(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPIII(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIIF(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIIP(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIF(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPIFI(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIFF(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIFP(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIP(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPIPI(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIPF(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPIPP(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPF(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVPFI(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPFII(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFIF(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFIP(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFF(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPFFI(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFFF(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFFP(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFP(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPFPI(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFPF(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPFPP(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPP(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionVPPI(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPPII(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPIF(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPIP(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPF(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPPFI(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPFF(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPFP(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPP(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionVPPPI(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPPF(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionVPPPP(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionI%(lpFunctionPointer%) : "BlitzPointer_CallFunction0" -BlitzPointer_CallFunctionII%(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionIII%(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIIII%(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIIII%(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIIF%(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIIP%(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIF%(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIIFI%(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIFF%(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIFP%(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIP%(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIIPI%(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIPF%(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIIPP%(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIF%(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIIFI%(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIFII%(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFIF%(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFIP%(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFF%(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIFFI%(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFFF%(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFFP%(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFP%(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIFPI%(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFPF%(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIFPP%(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIP%(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIIPI%(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIPII%(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPIF%(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPIP%(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPF%(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIPFI%(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPFF%(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPFP%(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPP%(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIIPPI%(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPPF%(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIIPPP%(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIF%(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionIFI%(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIFII%(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFIII%(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIIF%(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIIP%(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIF%(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFIFI%(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIFF%(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIFP%(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIP%(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFIPI%(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIPF%(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFIPP%(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFF%(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIFFI%(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFFII%(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFIF%(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFIP%(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFF%(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFFFI%(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFFF%(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFFP%(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFP%(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFFPI%(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFPF%(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFFPP%(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFP%(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIFPI%(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFPII%(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPIF%(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPIP%(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPF%(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFPFI%(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPFF%(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPFP%(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPP%(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIFPPI%(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPPF%(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIFPPP%(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIP%(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionIPI%(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIPII%(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPIII%(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIIF%(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIIP%(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIF%(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPIFI%(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIFF%(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIFP%(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIP%(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPIPI%(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIPF%(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPIPP%(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPF%(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIPFI%(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPFII%(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFIF%(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFIP%(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFF%(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPFFI%(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFFF%(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFFP%(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFP%(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPFPI%(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFPF%(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPFPP%(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPP%(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionIPPI%(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPPII%(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPIF%(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPIP%(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPF%(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPPFI%(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPFF%(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPFP%(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPP%(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionIPPPI%(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPPF%(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionIPPPP%(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionF#(lpFunctionPointer%) : "BlitzPointer_CallFunction0" -BlitzPointer_CallFunctionFI#(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionFII#(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFIII#(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIIII#(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIIF#(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIIP#(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIF#(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIIFI#(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIFF#(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIFP#(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIP#(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIIPI#(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIPF#(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIIPP#(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIF#(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFIFI#(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIFII#(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFIF#(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFIP#(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFF#(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIFFI#(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFFF#(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFFP#(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFP#(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIFPI#(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFPF#(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIFPP#(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIP#(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFIPI#(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIPII#(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPIF#(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPIP#(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPF#(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIPFI#(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPFF#(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPFP#(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPP#(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFIPPI#(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPPF#(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFIPPP#(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFF#(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionFFI#(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFFII#(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFIII#(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIIF#(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIIP#(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIF#(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFIFI#(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIFF#(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIFP#(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIP#(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFIPI#(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIPF#(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFIPP#(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFF#(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFFFI#(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFFII#(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFIF#(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFIP#(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFF#(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFFFI#(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFFF#(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFFP#(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFP#(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFFPI#(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFPF#(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFFPP#(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFP#(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFFPI#(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFPII#(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPIF#(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPIP#(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPF#(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFPFI#(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPFF#(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPFP#(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPP#(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFFPPI#(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPPF#(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFFPPP#(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFP#(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunction1" -BlitzPointer_CallFunctionFPI#(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFPII#(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPIII#(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIIF#(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIIP#(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIF#(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPIFI#(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIFF#(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIFP#(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIP#(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPIPI#(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIPF#(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPIPP#(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPF#(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFPFI#(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPFII#(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFIF#(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFIP#(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFF#(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPFFI#(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFFF#(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFFP#(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFP#(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPFPI#(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFPF#(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPFPP#(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPP#(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunction2" -BlitzPointer_CallFunctionFPPI#(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPPII#(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPIF#(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPIP#(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPF#(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPPFI#(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPFF#(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPFP#(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPP#(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunction3" -BlitzPointer_CallFunctionFPPPI#(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPPF#(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionFPPPP#(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunction4" -BlitzPointer_CallFunctionS$(lpFunctionPointer%) : "BlitzPointer_CallFunctionT0" +BP_CallFunctionV(lpFunctionPointer%) : "BP_CallFunction0" +BP_CallFunctionVI(lpFunctionPointer%, P1%) : "BP_CallFunction1" +BP_CallFunctionVII(lpFunctionPointer%, p1%, p2%) : "BP_CallFunction2" +BP_CallFunctionVIII(lpFunctionPointer%, p1%, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionVIIII(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVIIIF(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVIIIP(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVIIF(lpFunctionPointer%, p1%, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionVIIFI(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVIIFF(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVIIFP(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVIIP(lpFunctionPointer%, p1%, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionVIIPI(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVIIPF(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVIIPP(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVIF(lpFunctionPointer%, p1%, p2#) : "BP_CallFunction2" +BP_CallFunctionVIFI(lpFunctionPointer%, p1%, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionVIFII(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVIFIF(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVIFIP(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVIFF(lpFunctionPointer%, p1%, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionVIFFI(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVIFFF(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVIFFP(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVIFP(lpFunctionPointer%, p1%, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionVIFPI(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVIFPF(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVIFPP(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVIP(lpFunctionPointer%, p1%, p2*) : "BP_CallFunction2" +BP_CallFunctionVIPI(lpFunctionPointer%, p1%, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionVIPII(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVIPIF(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVIPIP(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVIPF(lpFunctionPointer%, p1%, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionVIPFI(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVIPFF(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVIPFP(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVIPP(lpFunctionPointer%, p1%, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionVIPPI(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVIPPF(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVIPPP(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVF(lpFunctionPointer%, P1#) : "BP_CallFunction1" +BP_CallFunctionVFI(lpFunctionPointer%, p1#, p2%) : "BP_CallFunction2" +BP_CallFunctionVFII(lpFunctionPointer%, p1#, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionVFIII(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVFIIF(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVFIIP(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVFIF(lpFunctionPointer%, p1#, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionVFIFI(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVFIFF(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVFIFP(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVFIP(lpFunctionPointer%, p1#, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionVFIPI(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVFIPF(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVFIPP(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVFF(lpFunctionPointer%, p1#, p2#) : "BP_CallFunction2" +BP_CallFunctionVFFI(lpFunctionPointer%, p1#, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionVFFII(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVFFIF(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVFFIP(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVFFF(lpFunctionPointer%, p1#, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionVFFFI(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVFFFF(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVFFFP(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVFFP(lpFunctionPointer%, p1#, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionVFFPI(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVFFPF(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVFFPP(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVFP(lpFunctionPointer%, p1#, p2*) : "BP_CallFunction2" +BP_CallFunctionVFPI(lpFunctionPointer%, p1#, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionVFPII(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVFPIF(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVFPIP(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVFPF(lpFunctionPointer%, p1#, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionVFPFI(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVFPFF(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVFPFP(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVFPP(lpFunctionPointer%, p1#, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionVFPPI(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVFPPF(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVFPPP(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVP(lpFunctionPointer%, P1*) : "BP_CallFunction1" +BP_CallFunctionVPI(lpFunctionPointer%, p1*, p2%) : "BP_CallFunction2" +BP_CallFunctionVPII(lpFunctionPointer%, p1*, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionVPIII(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVPIIF(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVPIIP(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVPIF(lpFunctionPointer%, p1*, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionVPIFI(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVPIFF(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVPIFP(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVPIP(lpFunctionPointer%, p1*, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionVPIPI(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVPIPF(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVPIPP(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVPF(lpFunctionPointer%, p1*, p2#) : "BP_CallFunction2" +BP_CallFunctionVPFI(lpFunctionPointer%, p1*, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionVPFII(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVPFIF(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVPFIP(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVPFF(lpFunctionPointer%, p1*, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionVPFFI(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVPFFF(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVPFFP(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVPFP(lpFunctionPointer%, p1*, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionVPFPI(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVPFPF(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVPFPP(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionVPP(lpFunctionPointer%, p1*, p2*) : "BP_CallFunction2" +BP_CallFunctionVPPI(lpFunctionPointer%, p1*, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionVPPII(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionVPPIF(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionVPPIP(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionVPPF(lpFunctionPointer%, p1*, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionVPPFI(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionVPPFF(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionVPPFP(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionVPPP(lpFunctionPointer%, p1*, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionVPPPI(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionVPPPF(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionVPPPP(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionI%(lpFunctionPointer%) : "BP_CallFunction0" +BP_CallFunctionII%(lpFunctionPointer%, P1%) : "BP_CallFunction1" +BP_CallFunctionIII%(lpFunctionPointer%, p1%, p2%) : "BP_CallFunction2" +BP_CallFunctionIIII%(lpFunctionPointer%, p1%, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionIIIII%(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIIIIF%(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIIIIP%(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIIIF%(lpFunctionPointer%, p1%, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionIIIFI%(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIIIFF%(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIIIFP%(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIIIP%(lpFunctionPointer%, p1%, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionIIIPI%(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIIIPF%(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIIIPP%(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIIF%(lpFunctionPointer%, p1%, p2#) : "BP_CallFunction2" +BP_CallFunctionIIFI%(lpFunctionPointer%, p1%, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionIIFII%(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIIFIF%(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIIFIP%(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIIFF%(lpFunctionPointer%, p1%, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionIIFFI%(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIIFFF%(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIIFFP%(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIIFP%(lpFunctionPointer%, p1%, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionIIFPI%(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIIFPF%(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIIFPP%(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIIP%(lpFunctionPointer%, p1%, p2*) : "BP_CallFunction2" +BP_CallFunctionIIPI%(lpFunctionPointer%, p1%, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionIIPII%(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIIPIF%(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIIPIP%(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIIPF%(lpFunctionPointer%, p1%, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionIIPFI%(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIIPFF%(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIIPFP%(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIIPP%(lpFunctionPointer%, p1%, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionIIPPI%(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIIPPF%(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIIPPP%(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIF%(lpFunctionPointer%, P1#) : "BP_CallFunction1" +BP_CallFunctionIFI%(lpFunctionPointer%, p1#, p2%) : "BP_CallFunction2" +BP_CallFunctionIFII%(lpFunctionPointer%, p1#, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionIFIII%(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIFIIF%(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIFIIP%(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIFIF%(lpFunctionPointer%, p1#, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionIFIFI%(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIFIFF%(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIFIFP%(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIFIP%(lpFunctionPointer%, p1#, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionIFIPI%(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIFIPF%(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIFIPP%(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIFF%(lpFunctionPointer%, p1#, p2#) : "BP_CallFunction2" +BP_CallFunctionIFFI%(lpFunctionPointer%, p1#, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionIFFII%(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIFFIF%(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIFFIP%(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIFFF%(lpFunctionPointer%, p1#, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionIFFFI%(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIFFFF%(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIFFFP%(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIFFP%(lpFunctionPointer%, p1#, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionIFFPI%(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIFFPF%(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIFFPP%(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIFP%(lpFunctionPointer%, p1#, p2*) : "BP_CallFunction2" +BP_CallFunctionIFPI%(lpFunctionPointer%, p1#, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionIFPII%(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIFPIF%(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIFPIP%(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIFPF%(lpFunctionPointer%, p1#, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionIFPFI%(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIFPFF%(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIFPFP%(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIFPP%(lpFunctionPointer%, p1#, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionIFPPI%(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIFPPF%(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIFPPP%(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIP%(lpFunctionPointer%, P1*) : "BP_CallFunction1" +BP_CallFunctionIPI%(lpFunctionPointer%, p1*, p2%) : "BP_CallFunction2" +BP_CallFunctionIPII%(lpFunctionPointer%, p1*, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionIPIII%(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIPIIF%(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIPIIP%(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIPIF%(lpFunctionPointer%, p1*, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionIPIFI%(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIPIFF%(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIPIFP%(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIPIP%(lpFunctionPointer%, p1*, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionIPIPI%(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIPIPF%(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIPIPP%(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIPF%(lpFunctionPointer%, p1*, p2#) : "BP_CallFunction2" +BP_CallFunctionIPFI%(lpFunctionPointer%, p1*, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionIPFII%(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIPFIF%(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIPFIP%(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIPFF%(lpFunctionPointer%, p1*, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionIPFFI%(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIPFFF%(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIPFFP%(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIPFP%(lpFunctionPointer%, p1*, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionIPFPI%(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIPFPF%(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIPFPP%(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionIPP%(lpFunctionPointer%, p1*, p2*) : "BP_CallFunction2" +BP_CallFunctionIPPI%(lpFunctionPointer%, p1*, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionIPPII%(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionIPPIF%(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionIPPIP%(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionIPPF%(lpFunctionPointer%, p1*, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionIPPFI%(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionIPPFF%(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionIPPFP%(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionIPPP%(lpFunctionPointer%, p1*, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionIPPPI%(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionIPPPF%(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionIPPPP%(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionF#(lpFunctionPointer%) : "BP_CallFunction0" +BP_CallFunctionFI#(lpFunctionPointer%, P1%) : "BP_CallFunction1" +BP_CallFunctionFII#(lpFunctionPointer%, p1%, p2%) : "BP_CallFunction2" +BP_CallFunctionFIII#(lpFunctionPointer%, p1%, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionFIIII#(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFIIIF#(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFIIIP#(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFIIF#(lpFunctionPointer%, p1%, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionFIIFI#(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFIIFF#(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFIIFP#(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFIIP#(lpFunctionPointer%, p1%, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionFIIPI#(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFIIPF#(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFIIPP#(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFIF#(lpFunctionPointer%, p1%, p2#) : "BP_CallFunction2" +BP_CallFunctionFIFI#(lpFunctionPointer%, p1%, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionFIFII#(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFIFIF#(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFIFIP#(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFIFF#(lpFunctionPointer%, p1%, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionFIFFI#(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFIFFF#(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFIFFP#(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFIFP#(lpFunctionPointer%, p1%, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionFIFPI#(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFIFPF#(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFIFPP#(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFIP#(lpFunctionPointer%, p1%, p2*) : "BP_CallFunction2" +BP_CallFunctionFIPI#(lpFunctionPointer%, p1%, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionFIPII#(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFIPIF#(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFIPIP#(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFIPF#(lpFunctionPointer%, p1%, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionFIPFI#(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFIPFF#(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFIPFP#(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFIPP#(lpFunctionPointer%, p1%, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionFIPPI#(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFIPPF#(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFIPPP#(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFF#(lpFunctionPointer%, P1#) : "BP_CallFunction1" +BP_CallFunctionFFI#(lpFunctionPointer%, p1#, p2%) : "BP_CallFunction2" +BP_CallFunctionFFII#(lpFunctionPointer%, p1#, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionFFIII#(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFFIIF#(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFFIIP#(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFFIF#(lpFunctionPointer%, p1#, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionFFIFI#(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFFIFF#(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFFIFP#(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFFIP#(lpFunctionPointer%, p1#, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionFFIPI#(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFFIPF#(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFFIPP#(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFFF#(lpFunctionPointer%, p1#, p2#) : "BP_CallFunction2" +BP_CallFunctionFFFI#(lpFunctionPointer%, p1#, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionFFFII#(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFFFIF#(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFFFIP#(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFFFF#(lpFunctionPointer%, p1#, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionFFFFI#(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFFFFF#(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFFFFP#(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFFFP#(lpFunctionPointer%, p1#, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionFFFPI#(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFFFPF#(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFFFPP#(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFFP#(lpFunctionPointer%, p1#, p2*) : "BP_CallFunction2" +BP_CallFunctionFFPI#(lpFunctionPointer%, p1#, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionFFPII#(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFFPIF#(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFFPIP#(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFFPF#(lpFunctionPointer%, p1#, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionFFPFI#(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFFPFF#(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFFPFP#(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFFPP#(lpFunctionPointer%, p1#, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionFFPPI#(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFFPPF#(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFFPPP#(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFP#(lpFunctionPointer%, P1*) : "BP_CallFunction1" +BP_CallFunctionFPI#(lpFunctionPointer%, p1*, p2%) : "BP_CallFunction2" +BP_CallFunctionFPII#(lpFunctionPointer%, p1*, p2%, p3%) : "BP_CallFunction3" +BP_CallFunctionFPIII#(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFPIIF#(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFPIIP#(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFPIF#(lpFunctionPointer%, p1*, p2%, p3#) : "BP_CallFunction3" +BP_CallFunctionFPIFI#(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFPIFF#(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFPIFP#(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFPIP#(lpFunctionPointer%, p1*, p2%, p3*) : "BP_CallFunction3" +BP_CallFunctionFPIPI#(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFPIPF#(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFPIPP#(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFPF#(lpFunctionPointer%, p1*, p2#) : "BP_CallFunction2" +BP_CallFunctionFPFI#(lpFunctionPointer%, p1*, p2#, p3%) : "BP_CallFunction3" +BP_CallFunctionFPFII#(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFPFIF#(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFPFIP#(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFPFF#(lpFunctionPointer%, p1*, p2#, p3#) : "BP_CallFunction3" +BP_CallFunctionFPFFI#(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFPFFF#(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFPFFP#(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFPFP#(lpFunctionPointer%, p1*, p2#, p3*) : "BP_CallFunction3" +BP_CallFunctionFPFPI#(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFPFPF#(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFPFPP#(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BP_CallFunction4" +BP_CallFunctionFPP#(lpFunctionPointer%, p1*, p2*) : "BP_CallFunction2" +BP_CallFunctionFPPI#(lpFunctionPointer%, p1*, p2*, p3%) : "BP_CallFunction3" +BP_CallFunctionFPPII#(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BP_CallFunction4" +BP_CallFunctionFPPIF#(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BP_CallFunction4" +BP_CallFunctionFPPIP#(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BP_CallFunction4" +BP_CallFunctionFPPF#(lpFunctionPointer%, p1*, p2*, p3#) : "BP_CallFunction3" +BP_CallFunctionFPPFI#(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BP_CallFunction4" +BP_CallFunctionFPPFF#(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BP_CallFunction4" +BP_CallFunctionFPPFP#(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BP_CallFunction4" +BP_CallFunctionFPPP#(lpFunctionPointer%, p1*, p2*, p3*) : "BP_CallFunction3" +BP_CallFunctionFPPPI#(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BP_CallFunction4" +BP_CallFunctionFPPPF#(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BP_CallFunction4" +BP_CallFunctionFPPPP#(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BP_CallFunction4" diff --git a/Blitz/Example01.bb b/Blitz/Example01.bb index e6220a2..630660f 100644 --- a/Blitz/Example01.bb +++ b/Blitz/Example01.bb @@ -38,14 +38,14 @@ Global fpOurFunction = 0 ; Our function can be anything we want, however we must be able to call it once ; without effect before we can actually retrieve the function pointer. Why? -; Simple! The BlitzPointer_GetFunctionPointer traces the return address for the +; Simple! The BP_GetFunctionPointer traces the return address for the ; Blitz function signature - and thus can't work outside a function. Function OurFunction() ; Let's begin by checking if we already have the pointer. Not required, but ; we do it anyway to save some scanning time on every call. If fpOurFunction = 0 Then ; Now let us call the above mentioned function to retrieve the pointer. - fpOurFunction = BlitzPointer_GetFunctionPointer() + fpOurFunction = BP_GetFunctionPointer() ; Weether you use a Return or an Else is up to you. Return is technically ; faster in Blitz, as using Else causes a complex ASM construction. Return diff --git a/Blitz/Example02.bb b/Blitz/Example02.bb index 98bfd54..8478909 100644 --- a/Blitz/Example02.bb +++ b/Blitz/Example02.bb @@ -29,7 +29,7 @@ ExampleInit() Global fpOurFunction = 0 Function OurFunction() If fpOurFunction = 0 Then - fpOurFunction = BlitzPointer_GetFunctionPointer() + fpOurFunction = BP_GetFunctionPointer() Return EndIf @@ -44,7 +44,7 @@ While Not KeyHit(1) ; BlitzPointer offers many ways of calling our function pointer. Each one ; describes different return types, parameter count and parameter types. ; Let's use the one that doesn't return a value for now. - BlitzPointer_CallFunctionV fpOurFunction + BP_CallFunctionV fpOurFunction ; Now if we run the program, instead of a fixed native call, we're calling a ; function pointer instead. Pretty useful in my opinion, especially for UI, ; networking, fake classes, etc. diff --git a/Blitz/Example03.bb b/Blitz/Example03.bb index 3412334..e2edacb 100644 --- a/Blitz/Example03.bb +++ b/Blitz/Example03.bb @@ -29,9 +29,9 @@ ; ---------------------------------------------------------------------------- ; ; Type Id Description Calling Function ; ---------------------------------------------------------------------------- ; -; void V Nothing BlitzPointer_CallFunctionV -; int I 32-bit Integer BlitzPointer_CallFunctionI -; float F Floating Point BlitzPointer_CallFunctionF +; void V Nothing BP_CallFunctionV +; int I 32-bit Integer BP_CallFunctionI +; float F Floating Point BP_CallFunctionF ; Now that we know what we can and can't do (without memory leaks at least), ; let's try out the return types ourselves. @@ -43,7 +43,7 @@ ExampleInit() Global fpVoidFunction = 0 Function VoidFunction() If fpVoidFunction = 0 Then - fpVoidFunction = BlitzPointer_GetFunctionPointer() + fpVoidFunction = BP_GetFunctionPointer() Return EndIf Text 0, 0, "Void Return Type" @@ -54,7 +54,7 @@ VoidFunction() Global fpIntFunction = 0 Function IntFunction%() If fpIntFunction = 0 Then - fpIntFunction = BlitzPointer_GetFunctionPointer() + fpIntFunction = BP_GetFunctionPointer() Return EndIf Text 0, 15, "Int Return Type" @@ -66,7 +66,7 @@ IntFunction() Global fpFloatFunction = 0 Function FloatFunction#() If fpFloatFunction = 0 Then - fpFloatFunction = BlitzPointer_GetFunctionPointer() + fpFloatFunction = BP_GetFunctionPointer() Return EndIf Text 0, 30, "Float Return Type" @@ -78,9 +78,9 @@ While Not KeyHit(1) ExampleUpdate() ; Calling the function and using the return value is really easy to do now: - BlitzPointer_CallFunctionV(fpVoidFunction) ; void returns nothing. - Text 200, 15, BlitzPointer_CallFunctionI(fpIntFunction) - Text 200, 30, BlitzPointer_CallFunctionF(fpFloatFunction) + BP_CallFunctionV(fpVoidFunction) ; void returns nothing. + Text 200, 15, BP_CallFunctionI(fpIntFunction) + Text 200, 30, BP_CallFunctionF(fpFloatFunction) ExampleLoop() Wend diff --git a/Blitz/Example04.bb b/Blitz/Example04.bb index 07f7e83..5dbfef1 100644 --- a/Blitz/Example04.bb +++ b/Blitz/Example04.bb @@ -31,9 +31,9 @@ ; ---------------------------------------------------------------------------- ; ; Type Id Description Calling Function ; ---------------------------------------------------------------------------- ; -; int I 32-bit Integer BlitzPointer_CallFunction*I -; float F Floating Point BlitzPointer_CallFunction*F -; pointer P Memory Pointer BlitzPointer_CallFunction*P +; int I 32-bit Integer BP_CallFunction*I +; float F Floating Point BP_CallFunction*F +; pointer P Memory Pointer BP_CallFunction*P ; Watch out: ; Calling a function that has parameters without giving enough parameters will @@ -47,7 +47,7 @@ ExampleInit() Global fpCurInGameSecond = 0 Function CurInGameSecond%(p1%=0) If fpCurInGameSecond = 0 Then - fpCurInGameSecond = BlitzPointer_GetFunctionPointer() + fpCurInGameSecond = BP_GetFunctionPointer() Return EndIf Text 5, 15, "IIFunction" @@ -61,7 +61,7 @@ CurInGameSecond() Global fpCurInGameSecondEx = 0 Function CurInGameSecondEx#(p1%=0, p2#=0) If fpCurInGameSecondEx = 0 Then - fpCurInGameSecondEx = BlitzPointer_GetFunctionPointer() + fpCurInGameSecondEx = BP_GetFunctionPointer() Return EndIf @@ -78,7 +78,7 @@ CurInGameSecondEx() Global fpConvertIntFloat Function ConvertIntFloat#(p1#=0) If fpConvertIntFloat = 0 Then - fpConvertIntFloat = BlitzPointer_GetFunctionPointer() + fpConvertIntFloat = BP_GetFunctionPointer() Print Hex(fpConvertIntFloat) WaitKey() Return @@ -101,18 +101,18 @@ While Not KeyHit(1) Text 480, 0, "Parameter 4" Text 600, 0, "Result" - Text 605, 15, BlitzPointer_CallFunctionII(fpCurInGameSecond, Frame) - Text 605, 30, BlitzPointer_CallFunctionFIF(fpCurInGameSecondEx, Frame, 0.016666666) + Text 605, 15, BP_CallFunctionII(fpCurInGameSecond, Frame) + Text 605, 30, BP_CallFunctionFIF(fpCurInGameSecondEx, Frame, 0.016666666) Local TempFlt# = Frame / 60.0 - Local TempInt% = BlitzPointer_CallFunctionIF(fpConvertIntFloat, TempFlt) + Local TempInt% = BP_CallFunctionIF(fpConvertIntFloat, TempFlt) Text 5, 60, "Float -> Int" Text 125, 60, TempFlt Text 605, 60, Hex(TempInt) Text 5, 75, "Int -> Float" Text 125, 75, Hex(TempInt) - Text 605, 75, BlitzPointer_CallFunctionFI(fpConvertIntFloat, TempInt) + Text 605, 75, BP_CallFunctionFI(fpConvertIntFloat, TempInt) ExampleLoop() diff --git a/Blitz/Example05.bb b/Blitz/Example05.bb index 4ae5d72..b8cf68b 100644 --- a/Blitz/Example05.bb +++ b/Blitz/Example05.bb @@ -41,7 +41,7 @@ End Type Global fpMyTypeFunc = 0 Function MyTypeFunc(This.MyType) If fpMyTypeFunc = 0 Then - fpMyTypeFunc = BlitzPointer_GetFunctionPointer() + fpMyTypeFunc = BP_GetFunctionPointer() Return EndIf If This = Null Then Return @@ -64,8 +64,8 @@ While Not KeyHit(1) ; Now in order to pass a Type Object to a function, we have to get a pointer ; from it. Thankfully, Blitz has this already built in: Int(). - If KeyDown(2) Then BlitzPointer_CallFunctionVI fpMyTypeFunc, Int(MT1) - If KeyDown(3) Then BlitzPointer_CallFunctionVI fpMyTypeFunc, Int(MT2) + If KeyDown(2) Then BP_CallFunctionVI fpMyTypeFunc, Int(MT1) + If KeyDown(3) Then BP_CallFunctionVI fpMyTypeFunc, Int(MT2) ExampleLoop() Wend diff --git a/Blitz/Example06.bb b/Blitz/Example06.bb index 616fa3f..bdf8067 100644 --- a/Blitz/Example06.bb +++ b/Blitz/Example06.bb @@ -82,7 +82,7 @@ End Type Global fpMyPointerFunction% = 0 Function MyPointerFunction(Pointer%) If fpMyPointerFunction = 0 Then - fpMyPointerFunction = BlitzPointer_GetFunctionPointer() + fpMyPointerFunction = BP_GetFunctionPointer() Return EndIf diff --git a/Blitz/Example07.bb b/Blitz/Example07.bb index f839e10..fda4700 100644 --- a/Blitz/Example07.bb +++ b/Blitz/Example07.bb @@ -54,7 +54,7 @@ Function TGenericUpdate() Local This.TGeneric For This = Each TGeneric If This\Pointer <> 0 Then - If BlitzPointer_CallFunctionII(CallbackIndex(This\Index), This\Pointer) Then + If BP_CallFunctionII(CallbackIndex(This\Index), This\Pointer) Then Delete This EndIf EndIf @@ -98,7 +98,7 @@ End Function Function TCubeCallback%(This.TCube) If CallbackIndex(CALLBACK_INDEX_TCUBE) = 0 Then - CallbackIndex(CALLBACK_INDEX_TCUBE) = BlitzPointer_GetFunctionPointer() + CallbackIndex(CALLBACK_INDEX_TCUBE) = BP_GetFunctionPointer() Return EndIf ; Safeguard against stupidity (it affect everyone). @@ -156,7 +156,7 @@ End Function Function TSphereUpdate%(This.TSphere) If CallbackIndex(CALLBACK_INDEX_TSPHERE) = 0 Then - CallbackIndex(CALLBACK_INDEX_TSPHERE) = BlitzPointer_GetFunctionPointer() + CallbackIndex(CALLBACK_INDEX_TSPHERE) = BP_GetFunctionPointer() Return EndIf ; Safeguard against stupidity (it affect everyone). diff --git a/BlitzHybrid.cpp b/BlitzHybrid.cpp deleted file mode 100644 index 06765e6..0000000 --- a/BlitzHybrid.cpp +++ /dev/null @@ -1,150 +0,0 @@ -// BlitzPointer - Adding Pointers to Blitz. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#include "BlitzPointer.h" - -// Hybrid specific defines. -#define CALLFUNCTION_DECL_BEGIN_64(NAME) DLL_EXPORT int64_t BlitzPointer_CallFunction##NAME(intptr_t lpFunctionPointer -#define CALLFUNCTION_IMPL_PARAMETER_64(INDEX, NAME) __asm MOV RAX, [NAME] __asm mov [esp + INDEX * 4], RAX -#define CALLFUNCTION_IMPL_CALL_64() __asm CALL QWORD ptr[lpFunctionPointer] -#define CALLFUNCTION_IMPL_RESULT_64() int64_t result; __asm MOV [result], RAX - -/* -// No Parameters -CALLFUNCTION_DECL_BEGIN_64(Q0) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_CALL_64() - CALLFUNCTION_IMPL_RESULT_64() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -// One Parameter -CALLFUNCTION_DECL_BEGIN_64(Q1D) - CALLFUNCTION_DECL_PARAMETER(int32_t, p1) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_PREPARE(1) - CALLFUNCTION_IMPL_PARAMETER(0, p1) - CALLFUNCTION_IMPL_CALL_64() - CALLFUNCTION_IMPL_RESULT_64() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN_64(Q1Q) - CALLFUNCTION_DECL_PARAMETER(int64_t, p1) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_PREPARE(1) - CALLFUNCTION_IMPL_PARAMETER_64(0, p1) - CALLFUNCTION_IMPL_CALL_64() - CALLFUNCTION_IMPL_RESULT_64() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -// Two Parameters -CALLFUNCTION_DECL_BEGIN(D2DQ) -CALLFUNCTION_DECL_PARAMETER(int32_t, p1) -CALLFUNCTION_DECL_PARAMETER(int64_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER_64(1, p2) -CALLFUNCTION_IMPL_PARAMETER(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN(D2QD) -CALLFUNCTION_DECL_PARAMETER(int64_t, p1) -CALLFUNCTION_DECL_PARAMETER(int32_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER(1, p2) -CALLFUNCTION_IMPL_PARAMETER_64(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN(D2QQ) -CALLFUNCTION_DECL_PARAMETER(int64_t, p1) -CALLFUNCTION_DECL_PARAMETER(int64_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER_64(1, p2) -CALLFUNCTION_IMPL_PARAMETER_64(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN_64(Q2DD) -CALLFUNCTION_DECL_PARAMETER(int32_t, p1) -CALLFUNCTION_DECL_PARAMETER(int64_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER_64(1, p2) -CALLFUNCTION_IMPL_PARAMETER(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT_64() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN_64(Q2DQ) -CALLFUNCTION_DECL_PARAMETER(int32_t, p1) -CALLFUNCTION_DECL_PARAMETER(int64_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER_64(1, p2) -CALLFUNCTION_IMPL_PARAMETER(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT_64() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN_64(Q2QD) -CALLFUNCTION_DECL_PARAMETER(int64_t, p1) -CALLFUNCTION_DECL_PARAMETER(int32_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER(1, p2) -CALLFUNCTION_IMPL_PARAMETER_64(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT_64() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -CALLFUNCTION_DECL_BEGIN_64(Q2QQ) -CALLFUNCTION_DECL_PARAMETER(int64_t, p1) -CALLFUNCTION_DECL_PARAMETER(int64_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() -CALLFUNCTION_IMPL_SAFEGUARD() -CALLFUNCTION_IMPL_PREPARE(2) -CALLFUNCTION_IMPL_PARAMETER_64(1, p2) -CALLFUNCTION_IMPL_PARAMETER_64(0, p1) -CALLFUNCTION_IMPL_CALL() -CALLFUNCTION_IMPL_RESULT_64() -CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() - -*/ \ No newline at end of file diff --git a/BlitzNative.cpp b/BlitzNative.cpp deleted file mode 100644 index 0591240..0000000 --- a/BlitzNative.cpp +++ /dev/null @@ -1,91 +0,0 @@ -// BlitzPointer - Adding Pointers to Blitz. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#include "BlitzPointer.h" - -// No Parameters -CALLFUNCTION_DECL_BEGIN(0) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_CALL() - CALLFUNCTION_IMPL_RESULT() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() -#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction0=_BlitzPointer_CallFunction0@4") - -// One Parameter -CALLFUNCTION_DECL_BEGIN(1) - CALLFUNCTION_DECL_PARAMETER(int32_t, p1) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_PREPARE(1) - CALLFUNCTION_IMPL_PARAMETER(0, p1) - CALLFUNCTION_IMPL_CALL() - CALLFUNCTION_IMPL_RESULT() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() -#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction1=_BlitzPointer_CallFunction1@8") - -// Two Parameters -CALLFUNCTION_DECL_BEGIN(2) - CALLFUNCTION_DECL_PARAMETER(int32_t, p1) - CALLFUNCTION_DECL_PARAMETER(int32_t, p2) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_PREPARE(2) - CALLFUNCTION_IMPL_PARAMETER(1, p2) - CALLFUNCTION_IMPL_PARAMETER(0, p1) - CALLFUNCTION_IMPL_CALL() - CALLFUNCTION_IMPL_RESULT() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() -#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction2=_BlitzPointer_CallFunction2@12") - -// Three Parameters -CALLFUNCTION_DECL_BEGIN(3) - CALLFUNCTION_DECL_PARAMETER(int32_t, p1) - CALLFUNCTION_DECL_PARAMETER(int32_t, p2) - CALLFUNCTION_DECL_PARAMETER(int32_t, p3) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_PREPARE(3) - CALLFUNCTION_IMPL_PARAMETER(2, p3) - CALLFUNCTION_IMPL_PARAMETER(1, p2) - CALLFUNCTION_IMPL_PARAMETER(0, p1) - CALLFUNCTION_IMPL_CALL() - CALLFUNCTION_IMPL_RESULT() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() -#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction3=_BlitzPointer_CallFunction3@16") - -// Four Parameters -CALLFUNCTION_DECL_BEGIN(4) - CALLFUNCTION_DECL_PARAMETER(int32_t, p1) - CALLFUNCTION_DECL_PARAMETER(int32_t, p2) - CALLFUNCTION_DECL_PARAMETER(int32_t, p3) - CALLFUNCTION_DECL_PARAMETER(int32_t, p4) -CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN() - CALLFUNCTION_IMPL_SAFEGUARD() - CALLFUNCTION_IMPL_PREPARE(4) - CALLFUNCTION_IMPL_PARAMETER(3, p4) - CALLFUNCTION_IMPL_PARAMETER(2, p3) - CALLFUNCTION_IMPL_PARAMETER(1, p2) - CALLFUNCTION_IMPL_PARAMETER(0, p1) - CALLFUNCTION_IMPL_CALL() - CALLFUNCTION_IMPL_RESULT() - CALLFUNCTION_IMPL_RETURN() -CALLFUNCTION_IMPL_END() -#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction4=_BlitzPointer_CallFunction4@20") diff --git a/BlitzPointer.cpp b/BlitzPointer.cpp index 4fc8de3..43c4544 100644 --- a/BlitzPointer.cpp +++ b/BlitzPointer.cpp @@ -19,7 +19,7 @@ #include "BlitzPointer.h" -DLL_EXPORT intptr_t BlitzPointer_GetReturnAddress() { +DLL_METHOD intptr_t DLL_CALL BP_GetReturnAddress() { intptr_t StackPointer, ReturnAddress; __asm { //ASM. Do touch if suicidal. @@ -32,9 +32,9 @@ DLL_EXPORT intptr_t BlitzPointer_GetReturnAddress() { return ReturnAddress; } -#pragma comment(linker, "/EXPORT:BlitzPointer_GetReturnAddress=_BlitzPointer_GetReturnAddress@0") +#pragma comment(linker, "/EXPORT:BP_GetReturnAddress=_BP_GetReturnAddress@0") -DLL_EXPORT intptr_t BlitzPointer_GetFunctionPointer() +DLL_METHOD intptr_t DLL_CALL BP_GetFunctionPointer() { intptr_t StackPointer, ReturnAddress; @@ -60,4 +60,37 @@ DLL_EXPORT intptr_t BlitzPointer_GetFunctionPointer() return 0; } -#pragma comment(linker, "/EXPORT:BlitzPointer_GetFunctionPointer=_BlitzPointer_GetFunctionPointer@0") +#pragma comment(linker, "/EXPORT:BP_GetFunctionPointer=_BP_GetFunctionPointer@0") + +DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointer() { + // ToDo: Figure out how to get the pointer of a variable reliably. Must do so without Goto. + // - Idea: Have user assign variable to the ptr first? Easier to find. + // - Strings are difficult - exclude these? + return 0; +} +#pragma comment(linker, "/EXPORT:BP_GetVariablePointer=_BP_GetVariablePointer@0") + +DLL_METHOD int32_t DLL_CALL BP_CallFunction0(BP_BlitzFunction0_t lpFunctionPointer) { + return lpFunctionPointer(); +} +#pragma comment(linker, "/EXPORT:BP_CallFunction0=_BP_CallFunction0@4") + +DLL_METHOD int32_t DLL_CALL BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPointer, int32_t p1) { + return lpFunctionPointer(p1); +} +#pragma comment(linker, "/EXPORT:BP_CallFunction1=_BP_CallFunction1@8") + +DLL_METHOD int32_t DLL_CALL BP_CallFunction2(BP_BlitzFunction2_t lpFunctionPointer, int32_t p1, int32_t p2) { + return lpFunctionPointer(p1, p2); +} +#pragma comment(linker, "/EXPORT:BP_CallFunction2=_BP_CallFunction2@12") + +DLL_METHOD int32_t DLL_CALL BP_CallFunction3(BP_BlitzFunction3_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3) { + return lpFunctionPointer(p1, p2, p3); +} +#pragma comment(linker, "/EXPORT:BP_CallFunction3=_BP_CallFunction3@16") + +DLL_METHOD int32_t DLL_CALL BP_CallFunction4(BP_BlitzFunction4_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3, int32_t p4) { + return lpFunctionPointer(p1, p2, p3, p4); +} +#pragma comment(linker, "/EXPORT:BP_CallFunction4=_BP_CallFunction4@20") diff --git a/BlitzPointer.h b/BlitzPointer.h index ec8c003..39ab146 100644 --- a/BlitzPointer.h +++ b/BlitzPointer.h @@ -18,18 +18,21 @@ #include "dllmain.h" #include -DLL_EXPORT intptr_t BlitzPointer_GetReturnAddress(); -DLL_EXPORT intptr_t BlitzPointer_GetFunctionPointer(); +// Types of Blitz Functions. +typedef int32_t(__stdcall *BP_BlitzFunction0_t)(); +typedef int32_t(__stdcall *BP_BlitzFunction1_t)(int32_t); +typedef int32_t(__stdcall *BP_BlitzFunction2_t)(int32_t, int32_t); +typedef int32_t(__stdcall *BP_BlitzFunction3_t)(int32_t, int32_t, int32_t); +typedef int32_t(__stdcall *BP_BlitzFunction4_t)(int32_t, int32_t, int32_t, int32_t); -// Defines for easier function generation. -#define CALLFUNCTION_DECL_BEGIN(NAME) DLL_EXPORT int32_t BlitzPointer_CallFunction##NAME(intptr_t lpFunctionPointer -#define CALLFUNCTION_DECL_PARAMETER(TYPE, NAME) , TYPE NAME -#define CALLFUNCTION_DECL_END() ) -#define CALLFUNCTION_IMPL_BEGIN() { -#define CALLFUNCTION_IMPL_SAFEGUARD() if (!lpFunctionPointer) return NULL; -#define CALLFUNCTION_IMPL_PREPARE(COUNT) __asm SUB ESP, COUNT * 4 -#define CALLFUNCTION_IMPL_PARAMETER(INDEX, NAME) __asm MOV EAX, [NAME] __asm MOV [ESP + INDEX * 4], EAX -#define CALLFUNCTION_IMPL_CALL() __asm CALL DWORD ptr[lpFunctionPointer] -#define CALLFUNCTION_IMPL_RESULT() int32_t result; __asm MOV [result], EAX -#define CALLFUNCTION_IMPL_RETURN() return result; -#define CALLFUNCTION_IMPL_END() } +// Basic Functionality (Pointer retrieval) +DLL_METHOD intptr_t DLL_CALL BP_GetReturnAddress(); +DLL_METHOD intptr_t DLL_CALL BP_GetFunctionPointer(); +DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointer(); + +// Native Blitz Function Calls +DLL_METHOD int32_t DLL_CALL BP_CallFunction0(BP_BlitzFunction0_t lpFunctionPointer); +DLL_METHOD int32_t DLL_CALL BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPointer, int32_t p1); +DLL_METHOD int32_t DLL_CALL BP_CallFunction2(BP_BlitzFunction2_t lpFunctionPointer, int32_t p1, int32_t p2); +DLL_METHOD int32_t DLL_CALL BP_CallFunction3(BP_BlitzFunction3_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3); +DLL_METHOD int32_t DLL_CALL BP_CallFunction4(BP_BlitzFunction4_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3, int32_t p4); diff --git a/BlitzPointer.vcxproj b/BlitzPointer.vcxproj index 9c429c4..cf7e1e9 100644 --- a/BlitzPointer.vcxproj +++ b/BlitzPointer.vcxproj @@ -77,7 +77,7 @@ false Disabled false - StdCall + Cdecl true @@ -112,7 +112,7 @@ false AnySuitable false - StdCall + Cdecl false @@ -126,11 +126,6 @@ - - false - false - - @@ -138,6 +133,10 @@ + + true + true + diff --git a/BlitzPointer.vcxproj.filters b/BlitzPointer.vcxproj.filters index 7c9d04e..f4cde68 100644 --- a/BlitzPointer.vcxproj.filters +++ b/BlitzPointer.vcxproj.filters @@ -9,6 +9,10 @@ {53eae672-7e3f-4de4-af1f-79e46e407a39} false + + {2651cf83-130d-4638-b631-b6321e4865d3} + false + @@ -17,12 +21,6 @@ Source Files - - Source Files - - - Source Files - Source Files @@ -34,6 +32,9 @@ Source Files + + Include Files + @@ -66,5 +67,7 @@ Blitz Files + + \ No newline at end of file diff --git a/MemoryHelpers.cpp b/MemoryHelpers.cpp index d7f6ca5..d2ea2f5 100644 --- a/MemoryHelpers.cpp +++ b/MemoryHelpers.cpp @@ -16,7 +16,7 @@ #include "dllmain.h" -DLL_EXPORT uint32_t PeekMemory(uint32_t* address, uint32_t length, intptr_t bank) { +DLL_METHOD uint32_t DLL_CALL PeekMemory(uint32_t* address, uint32_t length, intptr_t bank) { uint32_t bankAddress, bankSize; bankAddress = *(uint32_t*)(bank + 4); bankSize = *(uint32_t*)(bank + 8); @@ -32,7 +32,7 @@ DLL_EXPORT uint32_t PeekMemory(uint32_t* address, uint32_t length, intptr_t bank } #pragma comment(linker, "/EXPORT:PeekMemory=_PeekMemory@12") -DLL_EXPORT uint32_t PokeMemory(uint32_t address, uint32_t length, intptr_t bank) { +DLL_METHOD uint32_t DLL_CALL PokeMemory(uint32_t address, uint32_t length, intptr_t bank) { uint32_t bankAddress, bankSize; bankAddress = *(uint32_t*)(bank + 4); bankSize = *(uint32_t*)(bank + 8); @@ -48,42 +48,42 @@ DLL_EXPORT uint32_t PokeMemory(uint32_t address, uint32_t length, intptr_t bank) } #pragma comment(linker, "/EXPORT:PokeMemory=_PokeMemory@12") -DLL_EXPORT int8_t PeekMemoryByte(uint32_t* address) { +DLL_METHOD int8_t DLL_CALL PeekMemoryByte(uint32_t* address) { return *(int8_t*)address; } #pragma comment(linker, "/EXPORT:PeekMemoryByte=_PeekMemoryByte@4") -DLL_EXPORT void PokeMemoryByte(uint32_t* address, int8_t value) { +DLL_METHOD void DLL_CALL PokeMemoryByte(uint32_t* address, int8_t value) { *(int8_t*)address = value; } #pragma comment(linker, "/EXPORT:PokeMemoryByte=_PokeMemoryByte@8") -DLL_EXPORT int16_t PeekMemoryShort(uint32_t* address) { +DLL_METHOD int16_t DLL_CALL PeekMemoryShort(uint32_t* address) { return *(int16_t*)address; } #pragma comment(linker, "/EXPORT:PeekMemoryShort=_PeekMemoryShort@4") -DLL_EXPORT void PokeMemoryShort(uint32_t* address, int16_t value) { +DLL_METHOD void DLL_CALL PokeMemoryShort(uint32_t* address, int16_t value) { *(int16_t*)address = value; } #pragma comment(linker, "/EXPORT:PokeMemoryShort=_PokeMemoryShort@8") -DLL_EXPORT int32_t PeekMemoryInt(uint32_t* address) { +DLL_METHOD int32_t DLL_CALL PeekMemoryInt(uint32_t* address) { return *(int32_t*)address; } #pragma comment(linker, "/EXPORT:PeekMemoryInt=_PeekMemoryInt@4") -DLL_EXPORT void PokeMemoryInt(uint32_t* address, int32_t value) { +DLL_METHOD void DLL_CALL PokeMemoryInt(uint32_t* address, int32_t value) { *(int32_t*)address = value; } #pragma comment(linker, "/EXPORT:PokeMemoryInt=_PokeMemoryInt@8") -DLL_EXPORT float_t PeekMemoryFloat(uint32_t* address) { +DLL_METHOD float_t DLL_CALL PeekMemoryFloat(uint32_t* address) { return *(float_t*)address; } #pragma comment(linker, "/EXPORT:PeekMemoryFloat=_PeekMemoryFloat@4") -DLL_EXPORT void PokeMemoryFloat(uint32_t* address, float_t value) { +DLL_METHOD void DLL_CALL PokeMemoryFloat(uint32_t* address, float_t value) { *(float_t*)address = value; } #pragma comment(linker, "/EXPORT:PokeMemoryFloat=_PokeMemoryFloat@8") diff --git a/dllmain.h b/dllmain.h index 0873944..a521e27 100644 --- a/dllmain.h +++ b/dllmain.h @@ -14,9 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -// STL Exceptions -#include -#include +#pragma once // Memory Management #include @@ -25,4 +23,9 @@ #include // Macros -#define DLL_EXPORT extern "C" //__declspec(dllexport) \ No newline at end of file +#ifndef IMPORT +#define DLL_METHOD extern "C" //__declspec(dllexport) +#else +#define DLL_METHOD extern "c" __declspec(dllimport) +#endif +#define DLL_CALL __stdcall \ No newline at end of file