Access Violation at address 00000000 read of address 00000000 - C++ Builder 10

#ifndef DllH
#define DllH
/////////////////////////////////////////////////////////////////////////////
// Wrapper classes encapsulating a DLL & calls of import function from DLL
/////////////////////////////////////////////////////////////////////////////
// Copyright 1999-2002 Vyacheslav Yermolayev
// http:\\bcdev.narod.ru
// e-mail: [email]yerm@mail.ru[/email]
/////////////////////////////////////////////////////////////////////////////
namespace Dll
{
//---------------------------------------------------------------------------
class TDll
{
    HINSTANCE m_DLLInstance;
 
public:
    TDll(const wchar_t* a_Name)
    {
#pragma option push -w-pia
        if (!(m_DLLInstance = LoadLibrary(a_Name)))
#pragma option pop
            throw(Exception(a_Name));
    }
    ~TDll()
    {
        if (m_DLLInstance)
            FreeLibrary(m_DLLInstance);
    }
    operator HINSTANCE() const
    {
        return m_DLLInstance;
    }
};
//---------------------------------------------------------------------------
class TDllProc
{
public:
    TDllProc(const TDll& a_Dll, const wchar_t* a_Name)
    {
        //#pragma option push -w-pia
        //   if(!(  m_Proc = GetProcAddress(HINSTANCE(a_Dll),a_Name)))
        //#pragma option pop
        //  throw(Exception(u"Ошибка получения адреса функции:" + AnsiString(a_Name)));
    }
 
protected:
    FARPROC m_Proc;
};
//---------------------------------------------------------------------------
// Function without parameters
//---------------------------------------------------------------------------
class TDllProcV0 : public TDllProc
{
public:
    TDllProcV0(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()()
    {
        typedef void (*TProc)();
        ((TProc)m_Proc)();
    }
};
 
template <class R>
class TDllProc0 : public TDllProc
{
public:
    TDllProc0(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()()
    {
        typedef R (*TProc)();
        return ((TProc)m_Proc)();
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 1 parameter
//---------------------------------------------------------------------------
template <class P1>
class TDllProcV1 : public TDllProc
{
public:
    TDllProcV1(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1)
    {
        typedef void(__stdcall * TProc)(P1);
        ((TProc)m_Proc)(p1);
    }
};
 
template <class R, class P1>
class TDllProc1 : public TDllProc
{
public:
    TDllProc1(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1)
    {
        typedef R(__stdcall * TProc)(P1);
        return ((TProc)m_Proc)(p1);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 2 parameters
//---------------------------------------------------------------------------
template <class P1, class P2>
class TDllProcV2 : public TDllProc
{
public:
    TDllProcV2(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2)
    {
        typedef void(__stdcall * TProc)(P1, P2);
        ((TProc)m_Proc)(p1, p2);
    }
};
 
template <class R, class P1, class P2>
class TDllProc2 : public TDllProc
{
public:
    TDllProc2(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2)
    {
        typedef R(__stdcall * TProc)(P1, P2);
        return ((TProc)m_Proc)(p1, p2);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 3 parameters
//---------------------------------------------------------------------------
template <class P1, class P2, class P3>
class TDllProcV3 : public TDllProc
{
public:
    TDllProcV3(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2, P3 p3)
    {
        typedef void(__stdcall * TProc)(P1, P2, P3);
        ((TProc)m_Proc)(p1, p2, p3);
    }
};
 
template <class R, class P1, class P2, class P3>
class TDllProc3 : public TDllProc
{
public:
    TDllProc3(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2, P3 p3)
    {
        typedef R(__stdcall * TProc)(P1, P2, P3);
        return ((TProc)m_Proc)(p1, p2, p3);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 4 parameters
//---------------------------------------------------------------------------
template <class P1, class P2, class P3, class P4>
class TDllProcV4 : public TDllProc
{
public:
    TDllProcV4(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2, P3 p3, P4 p4)
    {
        typedef void(__stdcall * TProc)(P1, P2, P3, P4);
        ((TProc)m_Proc)(p1, p2, p3, p4);
    }
};
 
template <class R, class P1, class P2, class P3, class P4>
class TDllProc4 : public TDllProc
{
public:
    TDllProc4(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2, P3 p3, P4 p4)
    {
        typedef R(__stdcall * TProc)(P1, P2, P3, P4);
        return ((TProc)m_Proc)(p1, p2, p3, p4);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//ФFunction with 5 parameters
//---------------------------------------------------------------------------
template <class P1, class P2, class P3, class P4, class P5>
class TDllProcV5 : public TDllProc
{
public:
    TDllProcV5(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    {
        typedef void (*TProc)(P1, P2, P3, P4, P5);
        ((TProc)m_Proc)(p1, p2, p3, p4, p5);
    }
};
 
template <class R, class P1, class P2, class P3, class P4, class P5>
class TDllProc5 : public TDllProc
{
public:
    TDllProc5(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    {
        typedef R (*TProc)(P1, P2, P3, P4, P5);
        return ((TProc)m_Proc)(p1, p2, p3, p4, p5);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 6 parameters
//---------------------------------------------------------------------------
template <class P1, class P2, class P3, class P4, class P5, class P6>
class TDllProcV6 : public TDllProc
{
public:
    TDllProcV6(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    {
        typedef void (*TProc)(P1, P2, P3, P4, P5, P6);
        ((TProc)m_Proc)(p1, p2, p3, p4, p5, p6);
    }
};
 
template <class R, class P1, class P2, class P3, class P4, class P5, class P6>
class TDllProc6 : public TDllProc
{
public:
    TDllProc6(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    {
        typedef R (*TProc)(P1, P2, P3, P4, P5, P6);
        return ((TProc)m_Proc)(p1, p2, p3, p4, p5, p6);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 7 parameters
//---------------------------------------------------------------------------
template <class P1, class P2, class P3, class P4, class P5, class P6, class P7>
class TDllProcV7 : public TDllProc
{
public:
    TDllProcV7(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
    {
        typedef void (*TProc)(P1, P2, P3, P4, P5, P6, P7);
        ((TProc)m_Proc)(p1, p2, p3, p4, p5, p6, p7);
    }
};
 
template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
class TDllProc7 : public TDllProc
{
public:
    TDllProc7(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
    {
        typedef R (*TProc)(P1, P2, P3, P4, P5, P6, P7);
        return ((TProc)m_Proc)(p1, p2, p3, p4, p5, p6, p7);
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Function with 8 parameters
//---------------------------------------------------------------------------
template <class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
class TDllProcV8 : public TDllProc
{
public:
    TDllProcV8(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
    {
        typedef void (*TProc)(P1, P2, P3, P4, P5, P6, P7, P8);
        ((TProc)m_Proc)(p1, p2, p3, p4, p5, p6, p7, p8);
    }
};
 
template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
class TDllProc8 : public TDllProc
{
public:
    TDllProc8(const TDll& a_Dll, const wchar_t* a_Name)
        : TDllProc(a_Dll, a_Name)
    {
    }
    R operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
    {
        typedef R (*TProc)(P1, P2, P3, P4, P5, P6, P7, P8);
        return ((TProc)m_Proc)(p1, p2, p3, p4, p5, p6, p7, p8);
    }
};
//--------------------------------------------