xaymar/BlitzPointer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 9 Wiki Activity

1.3 Update:

Browse Source 
- 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.
This commit is contained in:
Michael Dirks
2015-06-20 15:08:27 +02:00
parent a5640928fc
commit 880e754254
16 changed files with 484 additions and 684 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Blitz/BlitzPointer.decls
+368 -368
View File
@@ -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"
Blitz/Example01.bb
+2 -2
View File
@@ -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
Blitz/Example02.bb
+2 -2
View File
@@ -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.
Blitz/Example03.bb
+9 -9
View File
@@ -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
Blitz/Example04.bb
+10 -10
View File
@@ -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()
Blitz/Example05.bb
+3 -3
View File
@@ -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
Blitz/Example06.bb
+1 -1
View File
@@ -82,7 +82,7 @@ End Type
Global fpMyPointerFunction% = 0
Function MyPointerFunction(Pointer%)
If fpMyPointerFunction = 0 Then
fpMyPointerFunction = BlitzPointer_GetFunctionPointer()
fpMyPointerFunction = BP_GetFunctionPointer()
Return
EndIf
Blitz/Example07.bb
+3 -3
View File
@@ -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).
BlitzHybrid.cpp
-150
View File
@@ -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 <http://www.gnu.org/licenses/>.
#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()
*/
BlitzNative.cpp
-91
View File
@@ -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 <http://www.gnu.org/licenses/>.
#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")
BlitzPointer.cpp
+37 -4
View File
@@ -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")
BlitzPointer.h
+17 -14
View File
@@ -18,18 +18,21 @@
#include "dllmain.h"
#include <string>
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);
BlitzPointer.vcxproj
+6 -7
View File
@@ -77,7 +77,7 @@
<PreprocessKeepComments>false</PreprocessKeepComments>
<InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
<OmitFramePointers>false</OmitFramePointers>
<CallingConvention>StdCall</CallingConvention>
<CallingConvention>Cdecl</CallingConvention>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@@ -112,7 +112,7 @@
<MinimalRebuild>false</MinimalRebuild>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<OmitFramePointers>false</OmitFramePointers>
<CallingConvention>StdCall</CallingConvention>
<CallingConvention>Cdecl</CallingConvention>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
@@ -126,11 +126,6 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="BlitzHybrid.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="BlitzNative.cpp" />
<ClCompile Include="BlitzPointer.cpp" />
<ClCompile Include="dllmain.cpp" />
<ClCompile Include="MemoryHelpers.cpp" />
@@ -138,6 +133,10 @@
<ItemGroup>
<ClInclude Include="BlitzPointer.h" />
<ClInclude Include="dllmain.h" />
<ClInclude Include="Include\BlitzPointer.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="LICENSE">
BlitzPointer.vcxproj.filters
+9 -6
View File
@@ -9,6 +9,10 @@
<UniqueIdentifier>{53eae672-7e3f-4de4-af1f-79e46e407a39}</UniqueIdentifier>
<ParseFiles>false</ParseFiles>
</Filter>
<Filter Include="Include Files">
<UniqueIdentifier>{2651cf83-130d-4638-b631-b6321e4865d3}</UniqueIdentifier>
<ParseFiles>false</ParseFiles>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="dllmain.cpp">
@@ -17,12 +21,6 @@
<ClCompile Include="BlitzPointer.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="BlitzNative.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="BlitzHybrid.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MemoryHelpers.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@@ -34,6 +32,9 @@
<ClInclude Include="BlitzPointer.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="Include\BlitzPointer.h">
<Filter>Include Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="Blitz\Example05.bb">
@@ -66,5 +67,7 @@
<None Include="Blitz\Example07.bb">
<Filter>Blitz Files</Filter>
</None>
<None Include="LICENSE" />
<None Include="LICENSE.lesser" />
</ItemGroup>
</Project>
MemoryHelpers.cpp
+10 -10
View File
@@ -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")
dllmain.h
+7 -4
View File
@@ -14,9 +14,7 @@
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// STL Exceptions
#include <exception>
#include <stdexcept>
#pragma once
// Memory Management
#include <memory>
@@ -25,4 +23,9 @@
#include <windows.h>
// Macros
#define DLL_EXPORT extern "C" //__declspec(dllexport)
#ifndef IMPORT
#define DLL_METHOD extern "C" //__declspec(dllexport)
#else
#define DLL_METHOD extern "c" __declspec(dllimport)
#endif
#define DLL_CALL __stdcall