xaymar/BlitzExtensions
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Update BlitzPointer and add example files.

Browse Source
This commit is contained in:
Michael Fabian Dirks
2015-05-11 23:10:15 +02:00
parent c909aeb102
commit d69e0aba0b
16 changed files with 1183 additions and 1409 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BlitzExtensions.v12.suo
BIN
View File
Binary file not shown.
BlitzPointer/Blitz/BlitzPointer.decls
+488
View File
@@ -0,0 +1,488 @@
.lib "BlitzPointer.dll"
; BlitzPointer
BlitzPointer_GetReturnAddress%()
BlitzPointer_GetFunctionPointer%()
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_CallFunctionS0"
BlitzPointer_CallFunctionSI$(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunctionS1"
BlitzPointer_CallFunctionSII$(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSIII$(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIIII$(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIIF$(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIIP$(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIF$(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIIFI$(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIFF$(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIFP$(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIP$(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIIPI$(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIPF$(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIIPP$(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIF$(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSIFI$(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIFII$(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFIF$(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFIP$(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFF$(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIFFI$(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFFF$(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFFP$(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFP$(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIFPI$(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFPF$(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIFPP$(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIP$(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSIPI$(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIPII$(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPIF$(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPIP$(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPF$(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIPFI$(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPFF$(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPFP$(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPP$(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSIPPI$(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPPF$(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSIPPP$(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSF$(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunctionS1"
BlitzPointer_CallFunctionSFI$(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSFII$(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFIII$(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIIF$(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIIP$(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIF$(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFIFI$(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIFF$(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIFP$(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIP$(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFIPI$(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIPF$(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFIPP$(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFF$(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSFFI$(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFFII$(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFIF$(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFIP$(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFF$(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFFFI$(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFFF$(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFFP$(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFP$(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFFPI$(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFPF$(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFFPP$(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFP$(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSFPI$(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFPII$(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPIF$(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPIP$(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPF$(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFPFI$(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPFF$(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPFP$(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPP$(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSFPPI$(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPPF$(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSFPPP$(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSP$(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunctionS1"
BlitzPointer_CallFunctionSPI$(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSPII$(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPIII$(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIIF$(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIIP$(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIF$(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPIFI$(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIFF$(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIFP$(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIP$(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPIPI$(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIPF$(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPIPP$(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPF$(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSPFI$(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPFII$(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFIF$(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFIP$(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFF$(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPFFI$(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFFF$(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFFP$(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFP$(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPFPI$(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFPF$(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPFPP$(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPP$(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunctionS2"
BlitzPointer_CallFunctionSPPI$(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPPII$(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPIF$(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPIP$(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPF$(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPPFI$(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPFF$(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPFP$(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPP$(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunctionS3"
BlitzPointer_CallFunctionSPPPI$(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPPF$(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunctionS4"
BlitzPointer_CallFunctionSPPPP$(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunctionS4"
BlitzPointer/Blitz/BlitzPointer.ipf
+19
View File
@@ -0,0 +1,19 @@
[IDEal Project file]
<Settings>
Version="1"
Expanded="True"
Icon=""
MainFile="Example05.bb"
Compiler="Blitz3D"
CommandLine=""
</Settings>
<Folders>
</Folders>
<Files>
AbsPath="\Example01.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
AbsPath="\Example02.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
AbsPath="\Example03.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
AbsPath="\Example04.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
AbsPath="\Example05.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
AbsPath="\Example_Shared.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
</Files>
BlitzPointer/Blitz/Example01.bb
+56
View File
@@ -0,0 +1,56 @@
; ---------------------------------------------------------------------------- ;
; Example 1 - Retrieving Function Pointers
; ---------------------------------------------------------------------------- ;
; License: Creative Commons Attribution 2.0
; Author: Michael Fabian Dirks<michael.dirks@realitybends.de>
; If you don't know what a pointer is, I recommend googling it.
; Blitz doesn't offer native ways of getting function pointers, nor would they
; work with anything but tailored ASM calls. So what can they be useful for?
; Here are some examples on what you can do:
; * Footprint-only Callbacks (no longer need to override functions)
; * Creating APIs that support multiple versions.
Include "Example_Shared.bb"
ExampleInit()
; We begin by initalizing a variable to hold our pointer. Globals work best for
; this task as we don't have to use a function parameter.
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
; 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()
; 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
EndIf
; For proof reasons, we show the pointer on the screen.
Text 0, 0, "Function Pointer"
Text 0,15, " 0x" + Replace(RSet(Hex(fpOurFunction),8)," ","0")
End Function
; Now we call our function once. Since there is no function pointer assigned
; it will return almost immediately.
OurFunction()
While Not KeyHit(1)
ExampleUpdate()
OurFunction()
ExampleLoop()
Wend
End
;~IDEal Editor Parameters:
;~C#Blitz3D
BlitzPointer/Blitz/Example02.bb
+43
View File
@@ -0,0 +1,43 @@
; ---------------------------------------------------------------------------- ;
; Example 2 - Calling Functions
; ---------------------------------------------------------------------------- ;
; License: Creative Commons Attribution 2.0
; Author: Michael Fabian Dirks<michael.dirks@realitybends.de>
; Prerequisite: Example 1
; Since we now know how to retrieve a function pointer, how about we call it?
Include "Example_Shared.bb"
ExampleInit()
Global fpOurFunction = 0
Function OurFunction()
If fpOurFunction = 0 Then
fpOurFunction = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 0, 0, "Function Pointer"
Text 0,15, " 0x" + Replace(RSet(Hex(fpOurFunction),8)," ","0")
End Function
OurFunction()
While Not KeyHit(1)
ExampleUpdate()
; BlitzPointer offers many (one-thousand-three-hundred-sixty-four) 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 (V for void) for now.
BlitzPointer_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.
; We'll talk about the other ways of calling a function in Example 3.
ExampleLoop()
Wend
End
;~IDEal Editor Parameters:
;~C#Blitz3D
BlitzPointer/Blitz/Example03.bb
+89
View File
@@ -0,0 +1,89 @@
; ---------------------------------------------------------------------------- ;
; Example 3 - Calling Functions (Intermediate)
; ---------------------------------------------------------------------------- ;
; License: Creative Commons Attribution 2.0
; Author: Michael Fabian Dirks<michael.dirks@realitybends.de>
; Prerequisite: Example 2
; As said before, BlitzPointer offers one-thousand-three-hundred-sixty-four ways
; of calling our function pointer. Each one describes return type, parameter
; count and parameter types. So, what magic can we do with those?
; There are four return types in Blitz that we can use:
; ---------------------------------------------------------------------------- ;
; Type Id Description Calling Function
; ---------------------------------------------------------------------------- ;
; void V Nothing BlitzPointer_CallFunctionV
; int I 32-bit Integer BlitzPointer_CallFunctionI
; float F Floating Point BlitzPointer_CallFunctionF
; string S String BlitzPointer_CallFunctionS
;
; When returning strings we have to make sure that it is not 0-length, as Blitz
; doesn't know how to handle these and crashes with a Memory Access Violation.
Include "Example_Shared.bb"
ExampleInit()
; 'void' function
Global fpVoidFunction = 0
Function VoidFunction()
If fpVoidFunction = 0 Then
fpVoidFunction = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 0, 0, "Void Return Type"
End Function
VoidFunction()
Global fpIntFunction = 0
Function IntFunction%()
If fpIntFunction = 0 Then
fpIntFunction = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 0, 15, "Int Return Type"
Return MilliSecs()
End Function
IntFunction()
Global fpFloatFunction = 0
Function FloatFunction#()
If fpFloatFunction = 0 Then
fpFloatFunction = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 0, 30, "Float Return Type"
Return MilliSecs() / 1000.0
End Function
FloatFunction()
Global fpStringFunction = 0
Function StringFunction$()
If fpStringFunction = 0 Then
fpStringFunction = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 0, 45, "String Return Type"
Local T$ = ""
Local MS = MilliSecs()
T = (((MS / 1000) / 60) / 60) + ":" + RSet((((MS / 1000) / 60) Mod 60), 2) + ":" + RSet(((MS / 1000) Mod 60), 2) + "." + RSet(MS Mod 1000, 3)
Return T
End Function
StringFunction()
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)
Text 200, 45, BlitzPointer_CallFunctionS(fpStringFunction)
ExampleLoop()
Wend
End
;~IDEal Editor Parameters:
;~C#Blitz3D
BlitzPointer/Blitz/Example04.bb
+139
View File
@@ -0,0 +1,139 @@
; ---------------------------------------------------------------------------- ;
; Example 4 - Calling Functions (Advanced)
; ---------------------------------------------------------------------------- ;
; License: Creative Commons Attribution 2.0
; Author: Michael Fabian Dirks<michael.dirks@realitybends.de>
; Prerequisite: Example 3
; We now know how to use return values correctly and thus have knowledge about
; the first 4 of 1364 functions to call a pointer.
; Now you know about 4 different ways of calling a Function, what about the
; other 1360 that are left? Those are combinations of return types, parameter
; count and parameter types.
; BlitzPointer supports functions with up to four parameters, given that all
; parameters have a supported type.
; There are three parameter types in Blitz that we can use:
; ---------------------------------------------------------------------------- ;
; Type Id Description Calling Function
; ---------------------------------------------------------------------------- ;
; int I 32-bit Integer BlitzPointer_CallFunction*I
; float F Floating Point BlitzPointer_CallFunction*F
; type I Type Object BlitzPointer_CallFunction*I
; pointer P Memory Pointer BlitzPointer_CallFunction*P
;
; We can't pass strings as parameters, but we can pass types as parameters,
; which allows us to pass strings in a type.
Include "Example_Shared.bb"
ExampleInit()
; Example Function: Divide p1 by 60 and return the result.
Global fpCurInGameSecond = 0
Function CurInGameSecond%(p1%=0)
If fpCurInGameSecond = 0 Then
fpCurInGameSecond = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 5, 15, "IIFunction"
Text 125, 15, p1
Return (p1 Shr 2) / 15 ; Division by 60
End Function
CurInGameSecond()
; Example Function: Multiply p1 by p2 and return the result.
Global fpCurInGameSecondEx = 0
Function CurInGameSecondEx#(p1%=0, p2#=0)
If fpCurInGameSecondEx = 0 Then
fpCurInGameSecondEx = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 5, 30, "FIFFunction"
Text 125, 30, p1
Text 245, 30, p2
Return p1 * p2
End Function
CurInGameSecondEx()
; Example Function: Work around the fact that Strings can't be passed.
Type MyType
Field Name$
Field Desc$
End Type
Local MT.MyType = New MyType
MT\Name = "Hello"
MT\Desc = "World"
Global fpDisplayMyType = 0
Function DisplayMyType(p1.MyType)
If fpDisplayMyType = 0 Then
fpDisplayMyType = BlitzPointer_GetFunctionPointer()
Return
EndIf
Text 5, 45, "VTFunction"
Text 125, 45, Hex(Int(p1))
If p1 <> Null Then
Text 245, 45, p1\Name
Text 365, 45, p1\Desc
EndIf
End Function
DisplayMyType(Null)
; Example Function: Convert between Float and Int easily
; For this to work we must take and return a float.
Global fpConvertIntFloat
Function ConvertIntFloat#(p1#=0)
If fpConvertIntFloat = 0 Then
fpConvertIntFloat = BlitzPointer_GetFunctionPointer()
Return
EndIf
Return p1
End Function
ConvertIntFloat()
; Pointer-parameters are a bit trickier and require memory access, see UserLibs.txt.
Local Frame% = 0
While Not KeyHit(1)
ExampleUpdate()
Text 0, 0, "Functions"
Text 120, 0, "Parameter 1"
Text 240, 0, "Parameter 2"
Text 360, 0, "Parameter 3"
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)
; In order to pass a Type-object to a function, we need to get a pointer for it.
; Thankfully, Blitz can do this natively by calling Int() on it.
BlitzPointer_CallFunctionVI fpDisplayMyType, Int(MT)
Local TempFlt# = Frame / 60.0
Local TempInt% = BlitzPointer_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)
ExampleLoop()
; Allow us to pause execution
While KeyDown(57)
WaitTimer(Example_Timer)
Wend
Frame=Frame+1
Wend
End
;~IDEal Editor Parameters:
;~C#Blitz3D
BlitzPointer/Blitz/Example05.bb
+158
View File
@@ -0,0 +1,158 @@
; ---------------------------------------------------------------------------- ;
; Example 4 - Callbacks
; ---------------------------------------------------------------------------- ;
; License: Creative Commons Attribution 2.0
; Author: Michael Fabian Dirks<michael.dirks@realitybends.de>
; Prerequisite: Example 4
; Now that we have learned how to use functions, let's go for something really
; advanced - Callbacks! We can use these to practically fake a OOP language.
Include "Example_Shared.bb"
ExampleInit()
; Let's create a Type to hold our generic object that only contains callback and
; a pointer to the type object. This allows us to have a generic interface that
; takes BObject and whatever type-object the user wants and returns weether or
; not the BObject should be destroyed.
Type BObject
Field DataCallback
Field DataValue%
End Type
; Our Update loop looks like this, there's not much to do - after all we have
; the callbacks to do the dirty work for us.
Function BObjectUpdate()
Local Obj.BObject
For Obj.BObject = Each BObject
; Check if the Callback and Value is set.
If Obj\DataCallback <> 0 And Obj\DataValue <> 0 Then
; Our Callback tells us when we need to dispose of an object.
If BlitzPointer_CallFunctionIII(Obj\DataCallback, Int(Obj), Obj\DataValue)
Delete Obj
EndIf
Else
Delete Obj
EndIf
Next
End Function
; We'll have two different sub-objects:
; * BCube - Cubes with movement
; * BSphere - Randomly colored spheres
; BCube - Spawned when we press '1'
Type BCube
Field Entity
Field PosX#, PosY#, PosZ#
Field Time
End Type
; Our Callback for BCube - relatively simple.
Global fpBCubeCallback = 0
Function BCubeCallback%(Obj.BObject, Cube.BCube)
If fpBCubeCallback = 0 Then
fpBCubeCallback = BlitzPointer_GetFunctionPointer()
Return
EndIf
Local Prc# = 1.0 - ((MilliSecs() - Cube\Time) / 5000.0)
PositionEntity Cube\Entity, Cube\PosX, Cos(Cube\PosX + Prc * 360) * Sin(Cos(Cube\PosZ) * 180 + Prc * 360) * 50, Cube\PosZ
EntityAlpha Cube\Entity, Prc
If Prc < 0.0 Then
FreeEntity Cube\Entity
Delete Cube
Return True
EndIf
Return False
End Function
BCubeCallback(Null, Null)
Function BCubeCreate.BObject(X#, Y#, Z#)
Local Obj.BObject = New BObject
Obj\DataCallback = fpBCubeCallback
Local Cube.BCube = New BCube
Cube\Entity = CreateCube()
Cube\PosX = X
Cube\PosY = Y
Cube\PosZ = Z
Cube\Time = MilliSecs()
Obj\DataValue = Int(Cube)
Return Obj
End Function
; Our BSphere implementation, spawned when pressing 2
Type BSphere
Field Entity
Field StartColor[2]
Field EndColor[2]
Field Time
End Type
Global fpBSphereCallback = 0
Function BSphereCallback%(Obj.BObject, Sphere.BSphere)
If fpBSphereCallback = 0 Then
fpBSphereCallback = BlitzPointer_GetFunctionPointer()
Return
EndIf
Local Prc# = (MilliSecs() - Sphere\Time) / 5000.0
EntityColor Sphere\Entity, Sphere\StartColor[0] * (1.0 - Prc) + Sphere\EndColor[0] * Prc, Sphere\StartColor[1] * (1.0 - Prc) + Sphere\EndColor[1] * Prc, Sphere\StartColor[2] * (1.0 - Prc) + Sphere\EndColor[2] * Prc
EntityAlpha Sphere\Entity, 1.0 - Prc
If Prc >= 1.0 Then
FreeEntity Sphere\Entity
Delete Sphere
Return True
EndIf
Return False
End Function
BSphereCallback(Null, Null)
Function BSphereCreate.BObject(X#, Y#, Z#)
Local Obj.BObject = New BObject
Obj\DataCallback = fpBSphereCallback
Local Sphere.BSphere = New BSphere
Sphere\Entity = CreateSphere(2)
PositionEntity Sphere\Entity, X, Y, Z
Sphere\StartColor[0] = Rand(0, 255)
Sphere\StartColor[1] = Rand(0, 255)
Sphere\StartColor[2] = Rand(0, 255)
Sphere\EndColor[0] = Rand(0, 255)
Sphere\EndColor[1] = Rand(0, 255)
Sphere\EndColor[2] = Rand(0, 255)
Sphere\Time = MilliSecs()
Obj\DataValue = Int(Sphere)
Return Obj
End Function
SeedRnd MilliSecs()
While Not KeyHit(1)
;'1' spawns a few instances of BCube
If KeyHit(2) Then
For X = -100 To 100 Step 10
For Z = -100 To 100 Step 10
BCubeCreate(X, 0, Z)
Next
Next
EndIf
;'2' spawns a few instances of BSphere
If KeyHit(3) Then
Local O# = Rnd(-360, 360)
For R# = -180 To 180 Step 2.25
BSphereCreate(Cos(R+O)*100, Sin(R * 90) * 10 + 10, Sin(R+O)*100)
Next
EndIf
; We only need one function here, all other updates are done using callbacks.
BObjectUpdate()
ExampleUpdate()
ExampleLoop()
Wend
;~IDEal Editor Parameters:
;~C#Blitz3D
BlitzPointer/Blitz/Example_Shared.bb
+67
View File
@@ -0,0 +1,67 @@
Global Example_Timer
; Camera
Global Example_Camera_YawPivot
Global Example_Camera_PitchPivot
Global Example_Camera
; Scene
Global Example_SceneRoot
Global Example_SceneLight
Global Example_Floor
Global Example_Block
Function ExampleInit()
Example_Timer = CreateTimer(60)
Graphics3D 1024, 768, 32, 2
SetBuffer BackBuffer()
Example_Camera_YawPivot = CreatePivot()
Example_Camera_PitchPivot = CreatePivot(Example_Camera_YawPivot)
Example_Camera = CreateCamera(Example_Camera_PitchPivot)
MoveEntity Example_Camera, 0, 0, -20
TurnEntity Example_Camera_PitchPivot, 30, 0, 0
Example_SceneRoot = CreatePivot()
AmbientLight 51, 51, 51
Example_SceneLight = CreateLight(1, Example_SceneRoot)
RotateEntity Example_SceneLight, 70, 30, 0
Example_Floor = CreateCube(Example_SceneRoot)
EntityColor Example_Floor, 153, 255, 153
EntityShininess Example_Floor, 1.0
ScaleEntity Example_Floor, 100, 0.001, 100
;Example_Block = CreateCube(Example_SceneRoot)
;MoveEntity Example_Block, 0, 1, 0
End Function
Function ExampleUpdate()
Local MX#, MY#
MX = (MouseX() - 512) / 512.0
MY = (MouseY() - 384) / 384.0
If MouseHit(1) Then
MoveMouse 512, 384
ElseIf MouseDown(1) Then
TurnEntity Example_Camera_YawPivot, 0, -MX, 0
TurnEntity Example_Camera_PitchPivot, MY, 0, 0
;MoveMouse 512, 384
EndIf
If MouseHit(2) Then
MoveMouse 512, 384
ElseIf MouseDown(2) Then
MoveEntity Example_Camera, 0, 0, MY
;MoveMouse 512, 384
EndIf
RenderWorld
End Function
Function ExampleLoop()
Flip 0:Cls:WaitTimer(Example_Timer)
End Function
;~IDEal Editor Parameters:
;~C#Blitz3D
BlitzPointer/BlitzPointer.bb
View File
BlitzPointer/BlitzPointer.cpp
+48 -19
View File
@@ -43,46 +43,66 @@ DLL_EXPORT uint32_t BlitzPointer_GetFunctionPointer() {
return 0;
}
uint32_t __declspec(naked) BlitzPointer_CallFunction() {
__declspec(naked) uint32_t __BlitzPointer_CallFunction() {
__asm {
jmp eax
}
}
DLL_EXPORT uint32_t BlitzPointer_CallFunction0(uint32_t fpFunctionPointer) {
uint32_t returnvalue;
if (!fpFunctionPointer)
return 0;
__asm {
call dword ptr[fpFunctionPointer];
mov[returnvalue], eax;
}
return returnvalue;
uint32_t rv;
__asm {
mov[rv], eax;
}
return rv;
}
DLL_EXPORT uint32_t BlitzPointer_CallFunction1(uint32_t fpFunctionPointer, uint32_t p1) {
uint32_t returnvalue;
if (!fpFunctionPointer)
return 0;
__asm {
sub esp, 0x4;
mov eax, [p1];
mov[esp], eax;
call dword ptr[fpFunctionPointer];
mov[returnvalue], eax;
}
return returnvalue;
}
DLL_EXPORT uint32_t BlitzPointer_CallFunction2(uint32_t fpFunctionPointer, uint32_t p1, uint32_t p2) {
uint32_t returnvalue;
uint32_t rv;
__asm {
sub esp, 0x8
mov[rv], eax;
}
return rv;
}
DLL_EXPORT uint32_t BlitzPointer_CallFunction2(uint32_t fpFunctionPointer, uint32_t p1, uint32_t p2) {
if (!fpFunctionPointer)
return 0;
__asm {
sub esp, 0x8;
mov eax, [p2];
mov[esp + 4], eax;
mov eax, [p1];
mov[esp], eax;
call dword ptr[fpFunctionPointer];
mov[returnvalue], eax;
}
return returnvalue;
uint32_t rv;
__asm {
mov[rv], eax;
}
return rv;
}
DLL_EXPORT uint32_t BlitzPointer_CallFunction3(uint32_t fpFunctionPointer, uint32_t p1, uint32_t p2, uint32_t p3) {
uint32_t returnvalue;
if (!fpFunctionPointer)
return 0;
__asm {
sub esp, 0xC;
mov eax, [p3];
@@ -92,12 +112,18 @@ DLL_EXPORT uint32_t BlitzPointer_CallFunction3(uint32_t fpFunctionPointer, uint3
mov eax, [p1];
mov[esp], eax;
call dword ptr[fpFunctionPointer];
mov[returnvalue], eax;
}
return returnvalue;
uint32_t rv;
__asm {
mov[rv], eax;
}
return rv;
}
DLL_EXPORT uint32_t BlitzPointer_CallFunction4(uint32_t fpFunctionPointer, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4) {
uint32_t returnvalue;
if (!fpFunctionPointer)
return 0;
__asm {
sub esp, 0x10;
mov eax, [p4];
@@ -109,9 +135,12 @@ DLL_EXPORT uint32_t BlitzPointer_CallFunction4(uint32_t fpFunctionPointer, uint3
mov eax, [p1];
mov[esp], eax;
call dword ptr[fpFunctionPointer];
mov[returnvalue], eax;
}
return returnvalue;
uint32_t rv;
__asm {
mov[rv], eax;
}
return rv;
}
DLL_EXPORT uint32_t BlitzPointer_CallFunctionS0(uint32_t fpFunctionPointer) {
BlitzPointer/BlitzPointer.decls
-1368
View File
File diff suppressed because it is too large Load Diff
BlitzPointer/BlitzPointer.vcxproj
+35 -9
View File
@@ -57,7 +57,7 @@
<SDLCheck>
</SDLCheck>
<AdditionalIncludeDirectories>$(SolutionDir);$(ProjectDir)</AdditionalIncludeDirectories>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<BasicRuntimeChecks>Default</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
@@ -90,7 +90,7 @@
<SDLCheck>
</SDLCheck>
<AdditionalIncludeDirectories>$(SolutionDir);$(ProjectDir)</AdditionalIncludeDirectories>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
@@ -105,12 +105,14 @@
<ForcedIncludeFiles>
</ForcedIncludeFiles>
<BasicRuntimeChecks>Default</BasicRuntimeChecks>
<MinimalRebuild>true</MinimalRebuild>
<MinimalRebuild>false</MinimalRebuild>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>
</EnableCOMDATFolding>
<OptimizeReferences>
</OptimizeReferences>
<Version>1.0</Version>
<LinkStatus>
</LinkStatus>
@@ -125,12 +127,36 @@
<ClInclude Include="dllmain.h" />
</ItemGroup>
<ItemGroup>
<None Include="BlitzPointer.bb">
<Link>BlitzPointer.bb</Link>
<None Include="Blitz\BlitzPointer.decls">
<Link>BlitzPointer.decls</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="BlitzPointer.decls">
<Link>BlitzPointer.decls</Link>
<None Include="Blitz\BlitzPointer.ipf">
<Link>Examples\BlitzPointer.ipf</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="Blitz\Example_Shared.bb">
<Link>Examples\Example_Shared.bb</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="Blitz\Example01.bb">
<Link>Examples\Example01.bb</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="Blitz\Example02.bb">
<Link>Examples\Example02.bb</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="Blitz\Example03.bb">
<Link>Examples\Example03.bb</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="Blitz\Example04.bb">
<Link>Examples\Example04.bb</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Include="Blitz\Example05.bb">
<Link>Examples\Example05.bb</Link>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
BlitzPointer/BlitzPointer.vcxproj.filters
+21 -2
View File
@@ -7,6 +7,7 @@
</Filter>
<Filter Include="Blitz Files">
<UniqueIdentifier>{53eae672-7e3f-4de4-af1f-79e46e407a39}</UniqueIdentifier>
<ParseFiles>false</ParseFiles>
</Filter>
</ItemGroup>
<ItemGroup>
@@ -26,10 +27,28 @@
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="BlitzPointer.decls">
<None Include="Blitz\Example05.bb">
<Filter>Blitz Files</Filter>
</None>
<None Include="BlitzPointer.bb">
<None Include="Blitz\BlitzPointer.decls">
<Filter>Blitz Files</Filter>
</None>
<None Include="Blitz\BlitzPointer.ipf">
<Filter>Blitz Files</Filter>
</None>
<None Include="Blitz\Example_Shared.bb">
<Filter>Blitz Files</Filter>
</None>
<None Include="Blitz\Example01.bb">
<Filter>Blitz Files</Filter>
</None>
<None Include="Blitz\Example02.bb">
<Filter>Blitz Files</Filter>
</None>
<None Include="Blitz\Example03.bb">
<Filter>Blitz Files</Filter>
</None>
<None Include="Blitz\Example04.bb">
<Filter>Blitz Files</Filter>
</None>
</ItemGroup>
BlitzSteam/BlitzSteam.vcxproj
+7 -5
View File
@@ -69,7 +69,7 @@
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<CompileAsManaged>false</CompileAsManaged>
<CompileAsWinRT>false</CompileAsWinRT>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<FunctionLevelLinking>true</FunctionLevelLinking>
<CreateHotpatchableImage>true</CreateHotpatchableImage>
<RuntimeTypeInfo>
@@ -109,7 +109,7 @@
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<CompileAsManaged>false</CompileAsManaged>
<CompileAsWinRT>false</CompileAsWinRT>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<CreateHotpatchableImage>true</CreateHotpatchableImage>
<RuntimeTypeInfo>
</RuntimeTypeInfo>
@@ -117,12 +117,14 @@
<ForcedIncludeFiles>
</ForcedIncludeFiles>
<BasicRuntimeChecks>Default</BasicRuntimeChecks>
<MinimalRebuild>true</MinimalRebuild>
<MinimalRebuild>false</MinimalRebuild>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>
</EnableCOMDATFolding>
<OptimizeReferences>
</OptimizeReferences>
<Version>1.0</Version>
<AdditionalLibraryDirectories>D:\Projects\Cpp\#Libraries\Steamworks SDK\redistributable_bin</AdditionalLibraryDirectories>
<AdditionalDependencies>steam_api.lib;%(AdditionalDependencies)</AdditionalDependencies>
BlitzUtility/BlitzUtility.vcxproj
+12 -5
View File
@@ -19,12 +19,14 @@
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<WholeProgramOptimization>false</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
@@ -66,9 +68,10 @@
<CreateHotpatchableImage>true</CreateHotpatchableImage>
<FunctionLevelLinking>true</FunctionLevelLinking>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<CompileAsManaged>false</CompileAsManaged>
<MinimalRebuild>false</MinimalRebuild>
<CompileAsWinRT>false</CompileAsWinRT>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@@ -100,15 +103,19 @@
<RuntimeTypeInfo>
</RuntimeTypeInfo>
<CreateHotpatchableImage>true</CreateHotpatchableImage>
<MinimalRebuild>true</MinimalRebuild>
<MinimalRebuild>false</MinimalRebuild>
<FunctionLevelLinking>true</FunctionLevelLinking>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<CompileAsManaged>false</CompileAsManaged>
<CompileAsWinRT>false</CompileAsWinRT>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>
</EnableCOMDATFolding>
<OptimizeReferences>
</OptimizeReferences>
<Version>1.0</Version>
<LinkStatus>
</LinkStatus>