Update

- Changed BP_GetFunctionPointer to use intelligent stackframe reading instead of memory scanning (faster & safer).

Blitz/BlitzPointer.decls

@@ -1,399 +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/>.
-
-.lib "BlitzPointer.dll"
-
-; BlitzPointer
-BP_GetReturnAddress%()
-BP_GetFunctionPointer%()
-BP_GetVariablePointer%()
-
-; Memory Modification
-PeekMemoryByte%(lpMemoryPointer%)
-PeekMemoryShort%(lpMemoryPointer%)
-PeekMemoryInt%(lpMemoryPointer%)
-PeekMemoryFloat#(lpMemoryPointer%)
-PeekMemory(lpMemoryPointer%, iLength%, lpBank*)
-PokeMemoryByte(lpMemoryPointer%, value%)
-PokeMemoryShort(lpMemoryPointer%, value%)
-PokeMemoryInt(lpMemoryPointer%, value%)
-PokeMemoryFloat(lpMemoryPointer%, value#)
-PokeMemory(lpMemoryPointer%, iLength%, lpBank*)
-
-; Function Calling
-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"

BlitzPointer.cpp

@@ -1,5 +1,5 @@
 //	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (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
@@ -15,82 +15,170 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // Idea take from Code by Noodoby<http://www.blitzforum.de/forum/viewtopic.php?t=31651>
-// New Code by Xaymar<http://project-kube.de>
+// New Code by Xaymar<http://xaymar.com>
 
+#pragma once
 #include "BlitzPointer.h"
 
 DLL_METHOD intptr_t DLL_CALL BP_GetReturnAddress() {
-	intptr_t StackPointer, ReturnAddress;
+#pragma comment(linker, "/EXPORT:BP_GetReturnAddress=_BP_GetReturnAddress@0")
+	intptr_t BasePointer, ReturnAddress;
 
 	__asm { //ASM. Do touch if suicidal.
-		mov StackPointer, esp;		// Store current Stack Pointer
-		mov esp, ebp;				// On X86, EBP[0] is our own function and EBP[1] is the return address.
-		add esp, 4;					// Which means that we can just take it from there into our own variable.
-		pop ReturnAddress;			// Just like this.
-		mov esp, [StackPointer];		// And then reset the Stack Pointer.
+		mov BasePointer, ebp;		// Store current BasePointer
 	}
 
+	// Blitz uses X86 Call-Near (E8) instructions to call its own functions.
+	// We can simply deduce the Return Address like this because of that.
+	//-- Parent_EBP = *EBP
+	//-- Parent_RP = Parent_EBP + 16
+	ReturnAddress = *(intptr_t*)((*(intptr_t*)BasePointer) + 16);
+
 	return ReturnAddress;
 }
-#pragma comment(linker, "/EXPORT:BP_GetReturnAddress=_BP_GetReturnAddress@0")
 
-DLL_METHOD intptr_t DLL_CALL BP_GetFunctionPointer()
-{
-	intptr_t StackPointer, ReturnAddress;
+DLL_METHOD intptr_t DLL_CALL BP_GetFunctionPointer() {
+#pragma comment(linker, "/EXPORT:BP_GetFunctionPointer=_BP_GetFunctionPointer@0")
+	intptr_t BasePointer, ReturnAddress, FunctionPointer;
 
 	__asm { //ASM. Do touch if suicidal.
-		mov StackPointer, esp;		// Store current Stack Pointer
-		mov esp, ebp;				// On X86, EBP[0] is our own function and EBP[1] is the return address.
-		add esp, 4;					// Which means that we can just take it from there into our own variable.
-		pop ReturnAddress;			// Just like this.
-		mov esp, [StackPointer];	// And then reset the Stack Pointer.
+		mov BasePointer, ebp;		// Store current BasePointer
 	}
 
-	// Let's look backwards in memory for the function signature (0x53 0x56 0x57 0x55 0x89 0xE5) for at most one megabyte.
-	uint8_t* startPtr = (uint8_t*)ReturnAddress;
-	uint8_t* endPtr = (uint8_t*)(ReturnAddress - 1048576);
-	for (uint8_t* curPtr = startPtr; curPtr != endPtr; curPtr--) {
-		if (*(curPtr) == 0x53)												// push ebx
-			if (*(curPtr + 1) == 0x56)										// push esi
-				if (*(curPtr + 2) == 0x57)									// push edi
-					if (*(curPtr + 3) == 0x55)								// push ebp
-						if (*(curPtr + 4) == 0x89 && *(curPtr + 5) == 0xE5)	// mov ebp,esp
-							return (intptr_t)curPtr;
+	// Blitz uses X86 Call-Near (E8) instructions to call its own functions.
+	// We can simply deduce the Return Address like this because of that.
+	//-- Parent_EBP = *EBP
+	//-- Parent_RP = Parent_EBP + 16
+	ReturnAddress = *(intptr_t*)((*(intptr_t*)BasePointer) + 16);
+
+	// And since it's a Call-Near, the call is offset to the return address.
+	FunctionPointer = ReturnAddress + *(intptr_t*)(ReturnAddress - 4);
+
+	return FunctionPointer;
+}
+
+DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointer(int32_t pVariable) {
+#pragma comment(linker, "/EXPORT:BP_GetVariablePointer=_BP_GetVariablePointer@4")
+	intptr_t BasePointer;
+
+	__asm { //ASM. Do touch if suicidal.
+		mov BasePointer, ebp;		// Store current BasePointer
 	}
 
-	return 0;
+	// The Variable pointer that is used is at -9 bytes offset to the return address of this function.
+	return *(intptr_t*)(*(intptr_t*)(BasePointer + 4) - 9);
 }
-#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;
+DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointerType(int32_t pVariable) {
+#pragma comment(linker, "/EXPORT:BP_GetVariablePointerType=_BP_GetVariablePointerType@4")
+	intptr_t BasePointer;
+
+	__asm { //ASM. Do touch if suicidal.
+		mov BasePointer, ebp;		// Store current BasePointer
+	}
+
+	// The Variable pointer that is used is at -11 bytes offset to the return address of this function.
+	return *(intptr_t*)(*(intptr_t*)(BasePointer + 4) - 11);
 }
-#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")
+	int32_t returnValue, StackPointer;
+	
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer();
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}
 
 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")
+	int32_t returnValue, StackPointer;
+
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer(p1);
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}
 
 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")
+	int32_t returnValue, StackPointer;
+
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer(p1, p2);
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}
 
 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")
+	int32_t returnValue, StackPointer;
+
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer(p1, p2, p3);
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}
 
 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")
+	int32_t returnValue, StackPointer;
+
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer(p1, p2, p3, p4);
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}
+
+DLL_METHOD int32_t DLL_CALL BP_CallFunction5(BP_BlitzFunction5_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3, int32_t p4, int32_t p5) {
+#pragma comment(linker, "/EXPORT:BP_CallFunction5=_BP_CallFunction5@24")
+	int32_t returnValue, StackPointer;
+
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer(p1, p2, p3, p4, p5);
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}

BlitzPointer.h

@@ -1,5 +1,5 @@
 //	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (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
@@ -24,11 +24,15 @@ 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);
+typedef int32_t(__stdcall *BP_BlitzFunction5_t)(int32_t, int32_t, int32_t, int32_t, int32_t);
 
 // 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();
+/*DLL_METHOD intptr_t DLL_CALL BP_GetLastCalledFunctionPointer( );
+DLL_METHOD intptr_t DLL_CALL BP_GetNextCalledFunctionPointer();*/
+DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointer(int32_t pVariable);
+DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointerType(int32_t pVariable);
 
 // Native Blitz Function Calls
 DLL_METHOD int32_t DLL_CALL BP_CallFunction0(BP_BlitzFunction0_t lpFunctionPointer);
@@ -36,3 +40,4 @@ DLL_METHOD int32_t DLL_CALL BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPoint
 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);
+DLL_METHOD int32_t DLL_CALL BP_CallFunction5(BP_BlitzFunction5_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3, int32_t p4, int32_t p5);

BlitzPointer.vcxproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -13,18 +13,19 @@
   <PropertyGroup Label="Globals">
     <ProjectGuid>{AC8F52F4-9FE6-4CEF-B549-8180757020C8}</ProjectGuid>
     <RootNamespace>BlitzPointer</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>false</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -39,37 +40,32 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir);$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir);$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <SDLCheck>
-      </SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir);$(ProjectDir)</AdditionalIncludeDirectories>
-      <MultiProcessorCompilation>false</MultiProcessorCompilation>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <BufferSecurityCheck>false</BufferSecurityCheck>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
       <CompileAsManaged>false</CompileAsManaged>
       <CompileAsWinRT>false</CompileAsWinRT>
       <StructMemberAlignment>4Bytes</StructMemberAlignment>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <CreateHotpatchableImage>true</CreateHotpatchableImage>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
@@ -78,24 +74,41 @@
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
       <OmitFramePointers>false</OmitFramePointers>
       <CallingConvention>Cdecl</CallingConvention>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <StringPooling>true</StringPooling>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
+      <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <Version>1.0</Version>
+      <GenerateDebugInformation>Debug</GenerateDebugInformation>
       <LinkStatus>
       </LinkStatus>
+      <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
+      <EnableCOMDATFolding>false</EnableCOMDATFolding>
+      <FixedBaseAddress>false</FixedBaseAddress>
+      <LargeAddressAware>false</LargeAddressAware>
+      <OptimizeReferences>false</OptimizeReferences>
+      <LinkTimeCodeGeneration>
+      </LinkTimeCodeGeneration>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+      <FullProgramDatabaseFile>true</FullProgramDatabaseFile>
     </Link>
+    <ProjectReference />
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Full</Optimization>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>
-      </SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir);$(ProjectDir)</AdditionalIncludeDirectories>
-      <MultiProcessorCompilation>false</MultiProcessorCompilation>
+      <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <BufferSecurityCheck>false</BufferSecurityCheck>
@@ -104,26 +117,39 @@
       <StructMemberAlignment>4Bytes</StructMemberAlignment>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
       <MinimalRebuild>false</MinimalRebuild>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
       <OmitFramePointers>false</OmitFramePointers>
       <CallingConvention>Cdecl</CallingConvention>
+      <StringPooling>true</StringPooling>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
+      <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <EnableCOMDATFolding>
-      </EnableCOMDATFolding>
-      <OptimizeReferences>
-      </OptimizeReferences>
-      <Version>1.0</Version>
+      <GenerateDebugInformation>No</GenerateDebugInformation>
+      <EnableCOMDATFolding>false</EnableCOMDATFolding>
+      <OptimizeReferences>false</OptimizeReferences>
       <LinkStatus>
       </LinkStatus>
+      <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
+      <FixedBaseAddress>false</FixedBaseAddress>
+      <LargeAddressAware>false</LargeAddressAware>
+      <LinkTimeCodeGeneration>
+      </LinkTimeCodeGeneration>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+      <FullProgramDatabaseFile>false</FullProgramDatabaseFile>
     </Link>
+    <ProjectReference />
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="BlitzPointer.cpp" />
@@ -133,71 +159,13 @@
   <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">
-      <Link>LICENSE</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="LICENSE.lesser">
-      <Link>LICENSE.lesser</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="Blitz\BlitzPointer.decls">
-      <Link>BlitzPointer.decls</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\BlitzPointer.ipf">
-      <Link>Examples\BlitzPointer.ipf</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example_Shared.bb">
-      <Link>Examples\Example_Shared.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example01.bb">
-      <Link>Examples\Example01.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example02.bb">
-      <Link>Examples\Example02.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example03.bb">
-      <Link>Examples\Example03.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example04.bb">
-      <Link>Examples\Example04.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example05.bb">
-      <Link>Examples\Example05.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example06.bb">
-      <Link>Examples\Example06.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
-    <None Include="Blitz\Example07.bb">
-      <Link>Examples\Example07.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
-    </None>
   </ItemGroup>
+  <Target Name="CopyResources" AfterTargets="Build">
+    <ItemGroup>
+      <Resources Include="$(ProjectDir)\Resources\**\*.*" />
+    </ItemGroup>
+    <Copy SourceFiles="@(Resources)" DestinationFiles="@(Resources->'$(TargetDir)%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="True" UseHardlinksIfPossible="True" />
+  </Target>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

BlitzPointer.vcxproj.filters

@@ -5,13 +5,9 @@
       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
     </Filter>
-    <Filter Include="Blitz Files">
-      <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 Include="Header Files">
+      <UniqueIdentifier>{527b3491-2ee2-474d-863f-2d21b7abb958}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
     </Filter>
   </ItemGroup>
   <ItemGroup>
@@ -26,48 +22,11 @@
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="dllmain.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
     <ClInclude Include="BlitzPointer.h">
-      <Filter>Source Files</Filter>
+      <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BlitzPointer.h">
-      <Filter>Include Files</Filter>
+    <ClInclude Include="dllmain.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
-  <ItemGroup>
-    <None Include="Blitz\Example05.bb">
-      <Filter>Blitz Files</Filter>
-    </None>
-    <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>
-    <None Include="Blitz\Example06.bb">
-      <Filter>Blitz Files</Filter>
-    </None>
-    <None Include="Blitz\Example07.bb">
-      <Filter>Blitz Files</Filter>
-    </None>
-    <None Include="LICENSE" />
-    <None Include="LICENSE.lesser" />
-  </ItemGroup>
 </Project>

MemoryHelpers.cpp

@@ -1,5 +1,5 @@
 //	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example01.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example02.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example03.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example04.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example05.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example06.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

Resources/Examples/Example07.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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
@@ -15,7 +15,7 @@
 ;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
 
 ; ---------------------------------------------------------------------------- ;
-; Example 6 - Callbacks
+; Example 7 - Callbacks
 ; ---------------------------------------------------------------------------- ;
 ; License: Creative Commons Attribution 2.0
 ; Author: Michael Fabian Dirks<michael.dirks@realitybends.de>

Resources/Examples/Example08.bb

@@ -0,0 +1,84 @@
+;	BlitzPointer - Adding Pointers to Blitz.
+;	Copyright (C) 2015 Xaymar (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/>.
+
+; ---------------------------------------------------------------------------- ;
+; Example 8 - Variable-pointers
+; ---------------------------------------------------------------------------- ;
+; Variable-pointers are really neat. Not only can you have a single variable for
+;  a lot of things in many locations (even across thread) but you can pass them
+;  to DLLs too! This opens up Blitz to a whole new way of working with DLLs.
+
+; Three functions were added for this, each for the respective type
+; - BP_GetVariablePointerInt(Int%) 
+; - BP_GetVariablePointerFloat(Float#)
+; - BP_GetVariablePointerType(Type.)
+; (Strings are not supported sorry.)
+
+; Integers and Floats are really simple, just declare them and grab the pointer.
+Global MyInteger% = 66
+Global MyFloat# = 66.6
+Global Pointer% = 0
+
+; Grab the Integer Pointer and modify the value.
+Pointer = BP_GetVariablePointerInt(MyInteger)
+Print "MyInteger: " + PeekMemoryInt(Pointer)
+PokeMemoryInt(Pointer, 33)
+Print "MyInteger: " + PeekMemoryInt(Pointer)
+
+; Grab the Float Pointer and modify the value.
+Pointer = BP_GetVariablePointerFloat(MyFloat)
+Print "MyFloat: " + PeekMemoryFloat(Pointer)
+PokeMemoryFloat(Pointer, 33.3)
+Print "MyFloat: " + PeekMemoryFloat(Pointer)
+
+; Types are a tiny bit harder but open up so many possibilities once you get
+;  used to them. Start by defining a Type, we'll use a simple one for this.
+Type MyType
+	Field Check%
+End Type
+
+; Now create some elements that we can use when modifying the pointer
+Global MyElement.MyType = New MyType
+Global MyElement1.MyType = New MyType
+Global MyElement2.MyType = New MyType
+Global MyElement3.MyType = New MyType
+MyElement\Check = -1
+MyElement1\Check = $F
+MyElement2\Check = $FF
+MyElement3\Check = $FFF
+
+; Store the Pointer and original element.
+Pointer = BP_GetVariablePointerType(MyElement)
+Local TempPointer% = PeekMemoryInt(Pointer)
+
+; Modifying is as simple as storing a new value to the address the pointer is
+;  pointing at. The Int() thing is explained in Example 5.
+Print "MyElement\Check: " + MyElement\Check
+PokeMemoryInt(Pointer, Int(MyElement1))
+Print "MyElement\Check: " + MyElement\Check
+PokeMemoryInt(Pointer, Int(MyElement2))
+Print "MyElement\Check: " + MyElement\Check
+PokeMemoryInt(Pointer, Int(MyElement3))
+Print "MyElement\Check: " + MyElement\Check
+
+; Always return things to their original condition. Just in case.
+PokeMemoryInt(Pointer, TempPointer)
+Print "MyElement\Check: " + MyElement\Check
+
+WaitKey()
+
+; You can do some magic with this, such as iterating through types yourself by
+;  changing the pointer to the next element or previous element. See Example 6.

Resources/Examples/Example_Shared.bb

@@ -1,5 +1,5 @@
 ;	BlitzPointer - Adding Pointers to Blitz.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (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

dllmain.cpp

@@ -1,5 +1,5 @@
 //	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (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

dllmain.h

@@ -1,5 +1,5 @@
 //	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (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
@@ -23,9 +23,5 @@
 #include <windows.h>
 
 // Macros
-#ifndef IMPORT
-#define DLL_METHOD extern "C" //__declspec(dllexport)
-#else
-#define DLL_METHOD extern "c" __declspec(dllimport)
-#endif
+#define DLL_METHOD extern "C"
 #define DLL_CALL __stdcall