1. Гибкая структура определения функций. Синтаксис достаточно прост и расширяем.
2. Возможность задания своих policy на ошибки загрузки функции.
3. Минимальный оверхед — создается _единая_ на все модули таблица указателей на функции, при первом вызове используется прокси с поиском функции, в дальнейшем — прямой вызов. Единая таблица загруженных модулей.
4. Привычный синтаксис вызова — нет никаких FunResolver<Type>()(params), все внешне выглядит обычным вызовом функции из неймспейса (да так оно на самом деле и есть).

// function table definition && declaration

USE_MODULE_BEGIN(kernel, *"*/ 'kern','el32','.dll' /*"*)
    DECLARE_FUN_P1_THROW(GetModuleHandle, *"*/ 'GetM','odul','eHan','dleA' /*"*, HMODULE, LPCSTR)
    DECLARE_FUN_P1(GetModuleHandleW, *"*/ 'GetM','odul','eHan','dleW' /*"*, HMODULE, LPCWSTR)
USE_MODULE_END

......
//  example

HMODULE hm = kernel::GetModuleHandle("ntdll.dll");
HMODULE hm2 = kernel::GetModuleHandleW(L"user32.dll");

Добавлены стратегии загрузки\выгрузки модулей. Соотв, добавлены 2 макроса: DL_USE_MODULE_NON_LOAD_BEGIN и DL_USE_MODULE_LOAD_POLICY_BEGIN. Первый использует GetModuleHandle для загрузки модуля, второй вызывает соотв. функции переданой ему стратегии.
Багфиксы в макросах.

Багфиксы
Что то еще?

#define DL_NO_STDCALL // не инастанцировать поддержку winapi соглашений о вызовах
#define DL_USE_CDECL  // инстанцировать поддержку __cdecl (по умолчанию отключено)

DL_DECLARE_FUN_PROXY_CC(call_conv) // инстанцировать поддержку конвенций call_conv.

DL_DECLARE_FUN_CC(cc, name_id, r, p)
DL_DECLARE_FUN_THROW_CC(cc, name_id, r, p)
DL_DECLARE_FUN_ERR_CC(cc, name_id, r, p, e)
DL_DECLARE_FUN_ERR_POLICY_CC(cc, name_id, r, p, pl)

#define DL_USE_CDECL
#include "delayimphlp.h"

DL_USE_MODULE_BEGIN(mydll, "mydll.dll")
    DL_DECLARE_FUN_CC(__cdecl, MyFun, int, (int))
DL_USE_MODULE_END()

#include "delayimphlp.h"

DL_DECLARE_FUN_PROXY_CC(__fastcall)

DL_USE_MODULE_BEGIN(mydll, "mydll.dll")
    DL_DECLARE_FUN_CC(__fastcall, MyFun, int, (int))
DL_USE_MODULE_END()

    DL_DECLARE_FUN_CC(ret, call_conv, fun_name, params)
        DL_DECLARE_FUN(ret, fun_name, params)

DL_MODULE_BEGIN(...)

DL_MODULE_END()

Добавлена поддержка MT. Отключается определением макроса DL_NO_MT.
Немного изменен интерфейс модуля
Добавлен макрос, позволяющий задавать custom policy для функций
Автоматическая поддержка юникода на основе макросов хедера от статически линкуемой библиотеки
Мелкие багфиксы

Багфиксы
Уменьшение размера прокси в MT варианте
Что то еще?

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#ifndef DL_NO_MT
    #define DL_MT _MT
#endif

#pragma warning (disable: 4786)

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define DL_STRINGIZE_(x) #x
#define DL_STRINGIZE(x) DL_STRINGIZE_(x)

#define MAX_DL_REPEAT 16
#define DL_COMMA() ,
#define DL_EMPTY() 

// DL_REPEAT_N
#define DL_REPEAT_IMPL_N_0(x, d) 
#define DL_REPEAT_IMPL_N_1(x, d)    DL_CAT(x,1)
#define DL_REPEAT_IMPL_N_2(x, d)    DL_REPEAT_IMPL_N_1(x, d)d()  DL_CAT(x,2)
#define DL_REPEAT_IMPL_N_3(x, d)    DL_REPEAT_IMPL_N_2(x, d)d()  DL_CAT(x,3)
#define DL_REPEAT_IMPL_N_4(x, d)    DL_REPEAT_IMPL_N_3(x, d)d()  DL_CAT(x,4)
#define DL_REPEAT_IMPL_N_5(x, d)    DL_REPEAT_IMPL_N_4(x, d)d()  DL_CAT(x,5)
#define DL_REPEAT_IMPL_N_6(x, d)    DL_REPEAT_IMPL_N_5(x, d)d()  DL_CAT(x,6)
#define DL_REPEAT_IMPL_N_7(x, d)    DL_REPEAT_IMPL_N_6(x, d)d()  DL_CAT(x,7)
#define DL_REPEAT_IMPL_N_8(x, d)    DL_REPEAT_IMPL_N_7(x, d)d()  DL_CAT(x,8)
#define DL_REPEAT_IMPL_N_9(x, d)    DL_REPEAT_IMPL_N_8(x, d)d()  DL_CAT(x,9)
#define DL_REPEAT_IMPL_N_10(x, d)    DL_REPEAT_IMPL_N_9(x, d)d()  DL_CAT(x,10)
#define DL_REPEAT_IMPL_N_11(x, d)    DL_REPEAT_IMPL_N_10(x, d)d()  DL_CAT(x,11)
#define DL_REPEAT_IMPL_N_12(x, d)    DL_REPEAT_IMPL_N_11(x, d)d()  DL_CAT(x,12)
#define DL_REPEAT_IMPL_N_13(x, d)    DL_REPEAT_IMPL_N_12(x, d)d()  DL_CAT(x,13)
#define DL_REPEAT_IMPL_N_14(x, d)    DL_REPEAT_IMPL_N_13(x, d)d()  DL_CAT(x,14)
#define DL_REPEAT_IMPL_N_15(x, d)    DL_REPEAT_IMPL_N_14(x, d)d()  DL_CAT(x,15)
#define DL_REPEAT_IMPL_N_16(x, d)    DL_REPEAT_IMPL_N_15(x, d)d()  DL_CAT(x,16)

#define DL_REPEAT_IMPL_N(n, x, d) DL_CAT(DL_REPEAT_IMPL_N_,n)(x, d)

#define DL_REPEAT_N(n,x) DL_REPEAT_IMPL_N(n, x, DL_COMMA)

// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_IMPL_N0(n, m, d1, d2)
#define DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2)    DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2)d1() DL_CAT(n,2)d2() DL_CAT(m,2)
#define DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2)d1() DL_CAT(n,3)d2() DL_CAT(m,3)
#define DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2)d1() DL_CAT(n,4)d2() DL_CAT(m,4)
#define DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2)d1() DL_CAT(n,5)d2() DL_CAT(m,5)
#define DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2)d1() DL_CAT(n,6)d2() DL_CAT(m,6)
#define DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2)d1() DL_CAT(n,7)d2() DL_CAT(m,7)
#define DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2)d1() DL_CAT(n,8)d2() DL_CAT(m,8)
#define DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2)d1() DL_CAT(n,9)d2() DL_CAT(m,9)
#define DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2)d1() DL_CAT(n,10)d2() DL_CAT(m,10)
#define DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2)d1() DL_CAT(n,11)d2() DL_CAT(m,11)
#define DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2)d1() DL_CAT(n,12)d2() DL_CAT(m,12)
#define DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2)d1() DL_CAT(n,13)d2() DL_CAT(m,13)
#define DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2)d1() DL_CAT(n,14)d2() DL_CAT(m,14)
#define DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2)    DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2)d1() DL_CAT(n,15)d2() DL_CAT(m,15)
#define DL_REPEAT_PARAM_IMPL_N16(n,m, d1, d2)    DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2)d1() DL_CAT(n,16)d2() DL_CAT(m,16)

#define DL_REPEAT_PARAM_IMPL_N(c, n, m, d1, d2)    DL_CAT(DL_REPEAT_PARAM_IMPL_N,c)(n, m, d1, d2)

#define DL_REPEAT_PARAM_N(c, n, m)    DL_REPEAT_PARAM_IMPL_N(c, n, m, DL_COMMA, DL_EMPTY)

// DL_SEQ_SIZE

#define DL_SEQ_SIZE(seq)    DL_SEQ_SIZE_IMPL(seq)
#define DL_SEQ_SIZE_IMPL(seq)    DL_CAT(DL_N_, DL_SEQ_SIZE_0 seq)

#define DL_SEQ_SIZE_0(_)    DL_SEQ_SIZE_1
#define DL_SEQ_SIZE_1(_)    DL_SEQ_SIZE_2
#define DL_SEQ_SIZE_2(_)    DL_SEQ_SIZE_3
#define DL_SEQ_SIZE_3(_)    DL_SEQ_SIZE_4
#define DL_SEQ_SIZE_4(_)    DL_SEQ_SIZE_5
#define DL_SEQ_SIZE_5(_)    DL_SEQ_SIZE_6
#define DL_SEQ_SIZE_6(_)    DL_SEQ_SIZE_7
#define DL_SEQ_SIZE_7(_)    DL_SEQ_SIZE_8
#define DL_SEQ_SIZE_8(_)    DL_SEQ_SIZE_9
#define DL_SEQ_SIZE_9(_)    DL_SEQ_SIZE_10
#define DL_SEQ_SIZE_10(_)    DL_SEQ_SIZE_11
#define DL_SEQ_SIZE_11(_)    DL_SEQ_SIZE_12
#define DL_SEQ_SIZE_12(_)    DL_SEQ_SIZE_13
#define DL_SEQ_SIZE_13(_)    DL_SEQ_SIZE_14
#define DL_SEQ_SIZE_14(_)    DL_SEQ_SIZE_15
#define DL_SEQ_SIZE_15(_)    DL_SEQ_SIZE_16

#define DL_N_DL_SEQ_SIZE_0    0
#define DL_N_DL_SEQ_SIZE_1    1
#define DL_N_DL_SEQ_SIZE_2    2
#define DL_N_DL_SEQ_SIZE_3    3
#define DL_N_DL_SEQ_SIZE_4    4
#define DL_N_DL_SEQ_SIZE_5    5
#define DL_N_DL_SEQ_SIZE_6    6
#define DL_N_DL_SEQ_SIZE_7    7
#define DL_N_DL_SEQ_SIZE_8    8
#define DL_N_DL_SEQ_SIZE_9    9
#define DL_N_DL_SEQ_SIZE_10    10
#define DL_N_DL_SEQ_SIZE_11    11
#define DL_N_DL_SEQ_SIZE_12    12
#define DL_N_DL_SEQ_SIZE_13    13
#define DL_N_DL_SEQ_SIZE_14    14
#define DL_N_DL_SEQ_SIZE_15    15
#define DL_N_DL_SEQ_SIZE_16    16

// DL_SEQ_ENUM

#define DL_SEQ_ENUM(seq)    DL_SEQ_ENUM_IMPL(seq)
#define DL_SEQ_ENUM_IMPL(seq)    DL_CAT(DL_SEQ_ENUM_, DL_SEQ_SIZE(seq)) seq

#define    DL_SEQ_ENUM_1(x)    x
#define    DL_SEQ_ENUM_2(x)    x, DL_SEQ_ENUM_1
#define    DL_SEQ_ENUM_3(x)    x, DL_SEQ_ENUM_2
#define    DL_SEQ_ENUM_4(x)    x, DL_SEQ_ENUM_3
#define    DL_SEQ_ENUM_5(x)    x, DL_SEQ_ENUM_4
#define    DL_SEQ_ENUM_6(x)    x, DL_SEQ_ENUM_5
#define    DL_SEQ_ENUM_7(x)    x, DL_SEQ_ENUM_6
#define    DL_SEQ_ENUM_8(x)    x, DL_SEQ_ENUM_7
#define    DL_SEQ_ENUM_9(x)    x, DL_SEQ_ENUM_8
#define    DL_SEQ_ENUM_10(x)    x, DL_SEQ_ENUM_9
#define    DL_SEQ_ENUM_11(x)    x, DL_SEQ_ENUM_10
#define    DL_SEQ_ENUM_12(x)    x, DL_SEQ_ENUM_11
#define    DL_SEQ_ENUM_13(x)    x, DL_SEQ_ENUM_12
#define    DL_SEQ_ENUM_14(x)    x, DL_SEQ_ENUM_13
#define    DL_SEQ_ENUM_15(x)    x, DL_SEQ_ENUM_14
#define    DL_SEQ_ENUM_16(x)    x, DL_SEQ_ENUM_15


#define NAME_ID(id)    DL_CAT(CNameId, id)

#define DECLARE_NAME_ID_IMPL(id, name, ret, text)\
struct NAME_ID(id)\
{\
    enum {length = sizeof(name)};\
    static ret GetStr(){return text(name);}\
};


#define DECLARE_NAME_ID_A(id, name)    DECLARE_NAME_ID_IMPL(id, name, LPCSTR, DL_EMPTY())
#define DECLARE_NAME_ID(id, name)    DECLARE_NAME_ID_IMPL(id, name, LPCTSTR,_T)


#ifdef DL_MT
//  MT only
struct CLWMutex
{
    CLWMutex(volatile LONG &pFlag):m_pFlag(pFlag)
    {
    }
    void Lock()
    {
        while(::InterlockedExchange(&m_pFlag, TRUE))
            Sleep(1);
    }
    void Unlock()
    {
        ::InterlockedExchange(&m_pFlag, FALSE);
    }
    volatile LONG &m_pFlag;
};

template<class T>
struct CAutoLock
{
    CAutoLock(T& obj):m_objLock(obj)
    {
        m_objLock.Lock();
    }
    ~CAutoLock()
    {
        m_objLock.Unlock();
    }
    T &m_objLock;
};

#endif //DL_MT


template <class Name>
class CModule
{
public:
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
#ifdef DL_MT
        static volatile LONG lMutex = FALSE;
        CLWMutex theMutex(lMutex);
        CAutoLock<CLWMutex> autoLock(theMutex);
#endif //DL_MT
        static type Module;
        return Module;
    }
    HMODULE GetModuleHandle() const
    {
        return m_hModule;
    }
    BOOL IsLoaded() const
    {
        return m_hModule != NULL;
    }
//  Caution - use with care. Not thread-safe
    BOOL UnloadModule()
    {
        HMODULE hModule = m_hModule;
        m_hModule = NULL;
        return FreeLibrary(hModule);
    }
    ~CModule()
    {
        if (m_hModule)
            UnloadModule();
    }
private:
    CModule()
    {
        m_hModule = ::LoadLibrary(name_type::GetStr());
    }
    HMODULE m_hModule;
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static typename proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::template Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
#ifdef DL_MT
        static volatile LONG lMutex = FALSE;
        CLWMutex theMutex(lMutex);
        CAutoLock<CLWMutex> autoLock(theMutex);
    //  test for first entry
        if (GetProxy() != proxy_type::template Proxy<type>::ProxyFun)
            return TRUE;
#endif // DL_MT
        const module_type &theModule = module_type::GetModule();
        if (theModule.IsLoaded())
        {
            FARPROC pFunction = ::GetProcAddress(theModule.GetModuleHandle(), name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};



struct CDynFunException
{
    CDynFunException(): m_sMessage(NULL)
    {
    };
    ~CDynFunException()
    {
        free(m_sMessage);
    };
    CDynFunException(LPCTSTR sMessage):m_sMessage(NULL)
    {
        SetMessage(sMessage);
    }
    CDynFunException(const CDynFunException &other):m_sMessage(NULL)
    {
        SetMessage(other.m_sMessage);
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.m_sMessage);
        return *this;
    }
    void SetMessage(LPCTSTR sMessage)
    {
        free(m_sMessage);
        m_sMessage = (LPTSTR)malloc((_tcslen(sMessage) + 1) * sizeof(TCHAR));
        if (m_sMessage)
            _tcscpy(m_sMessage, sMessage);
    }
    LPCTSTR GetMessage() const
    {
        return m_sMessage;
    }
private:
    LPTSTR m_sMessage;
};

template <class R> 
struct FunProxyThrowRetTypeTrait
{
    template <class F>
    struct FunctionTraitImpl
    {
        static R MakeReturn()
        {
            F::MakeReturnImpl();
            return R();
        }
    };
};

template <> 
struct FunProxyThrowRetTypeTrait<void>
{
    template <class F>
    struct FunctionTraitImpl
    {
        static void MakeReturn()
        {
            F::MakeReturnImpl();
        }
    };
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct FunctionTrait:public FunProxyThrowRetTypeTrait<typename DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >
    {
        static void MakeReturnImpl()
        {
            TCHAR szMessage[DynFunction::name_type::length + 64];
            _stprintf(szMessage, _T("Can'n resolve procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(szMessage);
        }
    };
};


//  we need not implement void return type value policy, 
//  coz void function can only throw on error

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct FunctionTrait
    {
        static typename DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};


#define FUN_PROXY(n) DL_CAT(FunProxy,n)
#define FUN_PROXY_IMPL(n) DL_CAT(FUN_PROXY(n),Impl)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R>\
struct FUN_PROXY_IMPL(param_count)\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <>\
struct FUN_PROXY_IMPL(param_count) <void>\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static void WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            else\
                Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> >\
struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy:public FUN_PROXY_IMPL(param_count)<R>::template RetProxy<DynFunction, DL_REPEAT_N(param_count, P), Policy>\
    {\
    };\
};

DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's


#define DL_USE_MODULE_BEGIN(nmspace, name) \
namespace nmspace \
{\
    DECLARE_NAME_ID(DL_CAT(_MODULE_, nmspace), name)\
    typedef CModule<NAME_ID(DL_CAT(_MODULE_, nmspace))> module_type;

#define DL_USE_MODULE_END \
};


#define DL_DECLARE_FUN(NameId, R, P) \
DECLARE_NAME_ID_A(NameId, DL_STRINGIZE(NameId))\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)> >::GetProxy();

#define DL_DECLARE_FUN_ERR(Name, NameId, R, P, E)\
DECLARE_NAME_ID_A(NameId, DL_STRINGIZE(NameId))\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DL_DECLARE_FUN_THROW(NameId, R, P)\
DECLARE_NAME_ID_A(NameId, DL_STRINGIZE(NameId))\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyThrowPolicy<> > >::GetProxy();

#define DL_DECLARE_FUN_POLICY(NameId, R, P, PL) \
DECLARE_NAME_ID_A(NameId, DL_STRINGIZE(NameId))\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)>, PL>::GetProxy();

#endif

AS>Нет, не то. Проинициализируйте буфер статически. Иначе в чем смысл, затраты кода будут больше неиспользуемой части буфера. Я привел вариант, но он ужасен, но там все в компиле-тайм. Другого я придумать не смог .

template<DWORD count>
struct CNameIdBuf;
template<>
struct CNameIdBuf<1>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct Buf
    {
        static const DWORD* Get()
        {
            static const DWORD a[1]={n0};
            return a;
        }
    };
};
template<>
struct CNameIdBuf<2>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct Buf
    {
        static const DWORD* Get()
        {
            static const DWORD a[2]={n0, n1};
            return a;
        }
    };
};
.......
template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    CNameId()
    {
        std::cout<<count<<"\n";
    }
    enum
    {
        count   =!n0?0
                :!n1?1
                :!n2?2
                :!n3?3
                :!n4?4
                :!n5?5
                :!n6?6
                :!n7?7
                :8
    };
    static void MakeStr(LPTSTR szBuffer)
    {
        static const DWORD* a=CNameIdBuf<count>::Buf<n0,n1,n2,n3,n4,n5,n6,n7>::Get();
    }
};
int main()
{
//    CNameId<>::MakeStr(0);
    CNameId<1>::MakeStr(0);
    CNameId<1,2>::MakeStr(0);
    //CNameId<1,4,5,6,7>::MakeStr(0);
    //CNameId<1,2,3,4,5,6,7,8>::MakeStr(0);
    return 0;
}

#define MAKE_BUF_SPEC(z, count, max_count)                                  \
template<>                                                                  \
struct CNameIdBuf<count>                                                    \
{                                                                           \
    template<BOOST_PP_ENUM_PARAMS(max_count, DWORD n)>                      \
    struct Buf                                                              \
    {                                                                       \
        static const DWORD* Get()                                           \
        {                                                                   \
            static const DWORD a[count]={BOOST_PP_ENUM_PARAMS(count, n)};   \
            return a;                                                       \
        }                                                                   \
    };                                                                      \
};                                                                          \
//end macro
BOOST_PP_REPEAT_FROM_TO(1, 9, MAKE_BUF_SPEC, 8)

template <DL_REPEAT_DEF_N(MAX_DL_REPEAT, DWORD n, = 0)>
struct CNameId
{
    enum
    {
        DL_REPEAT_PARAM_N(MAX_DL_REPEAT, m_n, =n),
        count   = DL_REPEAT_MACRO_IMPL_N(MAX_DL_REPEAT, NN_REP_COUNT_M, n, DL_EMPTY) MAX_DL_REPEAT,
        length  = count * sizeof(DWORD)
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::template CNameIdHolderImpl<DL_REPEAT_N(MAX_DL_REPEAT, n)>::GetStr();
    }
};


#define DL_USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId<DL_SEQ_ENUM_CHAR(NameId)> > module_type;

#define DL_USE_MODULE_END \
};


#define DL_DECLARE_FUN(NameId, R, P) \
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)> >::GetProxy();

#define DL_DECLARE_FUN_ERR(Name, NameId, R, P, E)\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DL_DECLARE_FUN_THROW(NameId, R, P)\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyThrowPolicy<> > >::GetProxy();



DL_USE_MODULE_BEGIN(kernel, (kern)(el32)(.dll))
    DL_DECLARE_FUN((GetP)(rocA)(ddre)(ss), FARPROC, (HMODULE)(LPCTSTR))
    DL_DECLARE_FUN((GetM)(odul)(eHan)(dleA), HMODULE, (LPCTSTR))
    DL_DECLARE_FUN_THROW((Init)(iali)(zeCr)(itic)(alSe)(ctio)(n), void, (LPCRITICAL_SECTION))
DL_USE_MODULE_END

#define DL_USE_MODULE_BEGIN(nmspace, Name) \
namespace nmspace \
{\
    struct CModuleNameId_##nmspace\
    {\
        static LPCSTR GetStr(){return Name;}\
    };\
    typedef CModule< CModuleNameId_##nmspace > module_type;

#define DL_USE_MODULE_END \
};


#define DL_DECLARE_FUN(Name, R, P) \
    struct CFunctionNameId_##Name\
    {\
        static LPCSTR GetStr(){return #Name;}\
    };\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CFunctionNameId_##Name, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)> >::GetProxy();

#define DL_DECLARE_FUN_ERR(Name, NameId, R, P, E)\
    struct CFunctionNameId_##Name\
    {\
        static LPCSTR GetStr(){return #Name;}\
    };\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CFunctionNameId_##Name, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DL_DECLARE_FUN_THROW(NameId, R, P)\
    struct CFunctionNameId_##Name\
    {\
        static LPCSTR GetStr(){return #Name;}\
    };\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CFunctionNameId_##Name, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyThrowPolicy<> > >::GetProxy();



DL_USE_MODULE_BEGIN(kernel, "kernel32.dll")
    DL_DECLARE_FUN(GetProcAddress, FARPROC, (HMODULE)(LPCTSTR))
    DL_DECLARE_FUN(GetModuleHandleA, HMODULE, (LPCTSTR))
    DL_DECLARE_FUN_THROW(InitializeCriticalSection, void, (LPCRITICAL_SECTION))
DL_USE_MODULE_END

AS>#define FLATTEN_STR(buff, name, idx) \
AS>        (buff)[4*(idx)] = (TCHAR)((name##idx & 0xFF000000) >> 24);\
AS>        (buff)[4*(idx) + 1] = (TCHAR)((name##idx & 0xFF0000) >> 16);\
AS>        (buff)[4*(idx) + 2] = (TCHAR)((name##idx & 0xFF00) >> 8);\
AS>        (buff)[4*(idx) + 3] = (TCHAR)(name##idx & 0xFF);

AS>void FlattenStr(LPSTR szBuffer, DWORD n0, DWORD n1, DWORD n2, DWORD n3, DWORD n4, DWORD n5, DWORD n6, DWORD n7)
AS>{
AS>        FLATTEN_STR(szBuffer, n, 0);
AS>        FLATTEN_STR(szBuffer, n, 1);
AS>        FLATTEN_STR(szBuffer, n, 2);
AS>        FLATTEN_STR(szBuffer, n, 3);
AS>        FLATTEN_STR(szBuffer, n, 4);
AS>        FLATTEN_STR(szBuffer, n, 5);
AS>        FLATTEN_STR(szBuffer, n, 6);
AS>        FLATTEN_STR(szBuffer, n, 7);
AS>        szBuffer[64] = _T('\0');
AS>}


AS>template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
AS>struct CNameId
AS>{
AS>    enum {name_size = 65, m_n0 = n0, m_n1 = n1, m_n2 = n2, m_n3 = n3, m_n4 = n4, m_n5 = n5, m_n6 = n6, m_n7 = n7};
AS>    static void MakeStr(LPTSTR szBuffer)
AS>    {
AS>        FlattenStr(szBuffer, n0,n1,n2,n3,n4,n5,n6,n7);
AS>    }
AS>};

void FlattenStr(LPSTR szBuffer, const DWORD* pN, DWORD n)
{
    for(DWORD i=0;i<n;i++)
    {
        szBuffer[i*4+0]=HIBYTE(HIWORD(pN[i]));
        szBuffer[i*4+1]=LOBYTE(HIWORD(pN[i]));
        szBuffer[i*4+2]=HIBYTE(LOWORD(pN[i]));
        szBuffer[i*4+3]=LOBYTE(LOWORD(pN[i]));
    }
    szBuffer[i*4] = 0;
}

template<DWORD n0 = 0,
        DWORD n1 = 0,
        DWORD n2 = 0,
        DWORD n3 = 0,
        DWORD n4 = 0,
        DWORD n5 = 0,
        DWORD n6 = 0,
        DWORD n7 = 0>
struct CNameId
{
    enum
    {
        name_size = 65,
        m_n0 = n0,
        m_n1 = n1,
        m_n2 = n2,
        m_n3 = n3,
        m_n4 = n4,
        m_n5 = n5,
        m_n6 = n6,
        m_n7 = n7
    };

    static void MakeStr(LPTSTR szBuffer)
    {
        static const DWORD a[]={n0,n1,n2,n3,n4,n5,n6,n7};
        FlattenStr(szBuffer, a, 7);
    }
};

static proxy_type::fun_type &GetProxy()

static typename proxy_type::fun_type &GetProxy()

struct FunctionTrait:public FunProxyThrowRetTypeTrait<DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >

struct FunctionTrait:public FunProxyThrowRetTypeTrait<typename DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >

static DynFunction::proxy_type::ret_type MakeReturn()

static typename DynFunction::proxy_type::ret_type MakeReturn()

static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\

static void WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\

#ifdef DL_MT
//  MT only
struct CLWMutex
{
    CLWMutex(volatile LONG &pFlag):m_pFlag(pFlag)
    {
    }
    void Lock()
    {
        while(::InterlockedExchange(&m_pFlag, TRUE))
            ::Sleep(1);
    }
    void Unlock()
    {
        ::InterlockedExchange(&m_pFlag, FALSE);
    }
    volatile LONG &m_pFlag;

private:
    // private section with blocked explicit/implicit assignments
    CLWMutex( const CLWMutex& ) throw();
    CLWMutex operator=( const CLWMutex& ) throw();
};

template<class T>
struct CAutoLock
{
    CAutoLock(T& obj):m_objLock(obj)
    {
        m_objLock.Lock();
    }
    ~CAutoLock()
    {
        m_objLock.Unlock();
    }
    T &m_objLock;


private:
    // private section with blocked explicit/implicit assignments
    CAutoLock( const CAutoLock& ) throw();
    CAutoLock operator=( const CAutoLock& ) throw();
};

#endif //DL_MT

AS>#define DECLARE_FUN_P1(Name, NameId, R, P1)\
AS>R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1> >::GetProxy().m_pfnProxy;
AS>

#define SEQ (B)(O)(O)(S)(T)

BOOST_PP_SEQ_ENUM(SEQ) // expands to B, O, O, S, T

#define SEQ (a)(b)(c)

BOOST_PP_SEQ_SIZE(SEQ) // expands to 3

USE_MODULE_BEGIN(kernel, ('kern')('el32')('.dll'))
    DECLARE_FUN_P1_THROW(GetModuleHandle, ('GetM')('odul')('eHan')('dleA'), HMODULE, LPCSTR)
    DECLARE_FUN_P1(GetModuleHandleW, ('GetM')('odul')('eHan')('dleW'), HMODULE, LPCWSTR)
USE_MODULE_END

template <DWORD count, DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    enum {name_size = count*4+1, m_n0 = n0, m_n1 = n1, m_n2 = n2, m_n3 = n3, m_n4 = n4, m_n5 = n5, m_n6 = n6, m_n7 = n7};
    static void MakeStr(LPTSTR szBuffer)
    {
        FlattenStr(szBuffer, n0,n1,n2,n3,n4,n5,n6,n7);
    }
};
#define MAKE_NAME_ID(id)CNameId< BOOST_PP_SEQ_SIZE(id),  BOOST_PP_SEQ_ENUM(id)>

#define DECLARE_FUN_P1(Name, NameId, R, P1)\
R (WINAPI *&Name)(P1) = CDynFunction<module_type, MAKE_NAME_ID(NameId), FunProxy<R, P1> >::GetProxy().m_pfnProxy;

#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
R (WINAPI *&Name)(P1) = CDynFunction<module_type, MAKE_NAME_ID(NameId), FunProxy<R, P1, FunProxyValuePolicy<R, E> > >::GetProxy().m_pfnProxy;
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
R (WINAPI *&Name)(P1) = CDynFunction<module_type, MAKE_NAME_ID(NameId), FunProxy<R, P1, FunProxyThrowPolicy<> > >::GetProxy().m_pfnProxy;

// CAT
#define CAT_(x,y) x##y
#define CAT(x,y) CAT_(x,y)

// REPEAT_N
#define REPEAT_N_0(x) CAT(x,0)
#define REPEAT_N_1(x) REPEAT_N_0(x), CAT(x,1)
#define REPEAT_N_2(x) REPEAT_N_1(x), CAT(x,2)
#define REPEAT_N_3(x) REPEAT_N_2(x), CAT(x,3)
//...
#define REPEAT_N(n,x) CAT(REPEAT_N_,n)(x)

// REPEAT_EX_N
#define REPEAT_EX_N_0(x,y) CAT(CAT(x,0),y)
#define REPEAT_EX_N_1(x,y) REPEAT_EX_N_0(x,y), CAT(CAT(x,1),y)
#define REPEAT_EX_N_2(x,y) REPEAT_EX_N_1(x,y), CAT(CAT(x,2),y)
#define REPEAT_EX_N_3(x,y) REPEAT_EX_N_2(x,y), CAT(CAT(x,3),y)
//...
#define REPEAT_EX_N(n,x,y) CAT(REPEAT_EX_N_,n)(x,y)

// REPEAT_EX2_N
#define REPEAT_EX2_N_0(x,y) CAT(CAT(x,0),CAT(y,0))
#define REPEAT_EX2_N_1(x,y) REPEAT_EX2_N_0(x,y), CAT(CAT(x,1),CAT(y,1))
#define REPEAT_EX2_N_2(x,y) REPEAT_EX2_N_1(x,y), CAT(CAT(x,2),CAT(y,2))
#define REPEAT_EX2_N_3(x,y) REPEAT_EX2_N_2(x,y), CAT(CAT(x,3),CAT(y,3))
//...
#define REPEAT_EX2_N(n,x,y) CAT(REPEAT_EX2_N_,n)(x,y)

// DECLARE_CNAMEID
#define CNAME_ID_(n) \
{ \
    enum \
    { \
        REPEAT_EX2_N(n,m_c,t_c) \
    }; \
    static const TCHAR* GetStr() \
    { \
        static const TCHAR str[]= \
        { \
            REPEAT_N(n,t_c) \
            ,0 \
        }; \
        return str; \
    } \
};

#define SPEC_CNAMEID(n) \
template<REPEAT_N(n,TCHAR t_c)> \
struct CNameID<REPEAT_N(n,t_c)> \
CNAME_ID_(n)

#define DECLARE_CNAMEID(n) \
template<REPEAT_EX_N(n,TCHAR t_c,=0)> \
struct CNameID \
CNAME_ID_(n)

// определяем сам класс
DECLARE_CNAMEID(2)
// специализации
SPEC_CNAMEID(0)
SPEC_CNAMEID(1)

// тестим
void main()
{
 const TCHAR* str = CNameID<'a','b','c'>::GetStr();
}

AS>DL_USE_MODULE_BEGIN(kernel, (kern)(el32)(.dll))
AS>    DL_DECLARE_FUN((GetP)(rocA)(ddre)(ss), FARPROC, (HMODULE)(LPCTSTR))
AS>    DL_DECLARE_FUN((GetM)(odul)(eHan)(dleA), HMODULE, (LPCTSTR))
AS>    DL_DECLARE_FUN_THROW((Init)(iali)(zeCr)(itic)(alSe)(ctio)(n), void, (LPCRITICAL_SECTION))
AS>DL_USE_MODULE_END
AS>

(HAND)(LE) (file)=(Crea)(teFi)(le)(
    (szPa)(th),
    (GENE)(RIC_)(WRIT)(E),
    (0),(0),
    (CREA)(TE_A)(LWAY)(S),
    (FILE)(_ATT)(RIBU)(TE_N)(ORMA)(L),
    (0));

Изменены порождающие макросы (спасибо WolfHound). Теперь синтаксис стал гораздо более очевидным и нативным:


DL_USE_MODULE_BEGIN(kernel, "kernel32.dll")
    DL_DECLARE_FUN(GetProcAddress, FARPROC, (HMODULE)(LPCTSTR))
    DL_DECLARE_FUN(GetModuleHandleA, HMODULE, (LPCTSTR))
    DL_DECLARE_FUN_THROW(InitializeCriticalSection, void, (LPCRITICAL_SECTION))
DL_USE_MODULE_END


Убраны ненужные теперь макросы DL_SEQ_ELEM и многие другие — макромагии стало меньше, совместимость с препроцессорами выше.

Поддержка MT.
Поддержка соглашений о вызовах кроме __stdcall.
Поддержка функций с переменным числом параметров.
Что то еще?

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#pragma warning (disable: 4786)

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define MAX_DL_REPEAT 16
#define DL_COMMA() ,
#define DL_EMPTY() 

// DL_REPEAT_N
#define DL_REPEAT_IMPL_N_0(x, d) 
#define DL_REPEAT_IMPL_N_1(x, d) DL_CAT(x,1)
#define DL_REPEAT_IMPL_N_2(x, d) DL_REPEAT_IMPL_N_1(x, d)d()  DL_CAT(x,2)
#define DL_REPEAT_IMPL_N_3(x, d) DL_REPEAT_IMPL_N_2(x, d)d()  DL_CAT(x,3)
#define DL_REPEAT_IMPL_N_4(x, d) DL_REPEAT_IMPL_N_3(x, d)d()  DL_CAT(x,4)
#define DL_REPEAT_IMPL_N_5(x, d) DL_REPEAT_IMPL_N_4(x, d)d()  DL_CAT(x,5)
#define DL_REPEAT_IMPL_N_6(x, d) DL_REPEAT_IMPL_N_5(x, d)d()  DL_CAT(x,6)
#define DL_REPEAT_IMPL_N_7(x, d) DL_REPEAT_IMPL_N_6(x, d)d()  DL_CAT(x,7)
#define DL_REPEAT_IMPL_N_8(x, d) DL_REPEAT_IMPL_N_7(x, d)d()  DL_CAT(x,8)
#define DL_REPEAT_IMPL_N_9(x, d) DL_REPEAT_IMPL_N_8(x, d)d()  DL_CAT(x,9)
#define DL_REPEAT_IMPL_N_10(x, d) DL_REPEAT_IMPL_N_9(x, d)d()  DL_CAT(x,10)
#define DL_REPEAT_IMPL_N_11(x, d) DL_REPEAT_IMPL_N_10(x, d)d()  DL_CAT(x,11)
#define DL_REPEAT_IMPL_N_12(x, d) DL_REPEAT_IMPL_N_11(x, d)d()  DL_CAT(x,12)
#define DL_REPEAT_IMPL_N_13(x, d) DL_REPEAT_IMPL_N_12(x, d)d()  DL_CAT(x,13)
#define DL_REPEAT_IMPL_N_14(x, d) DL_REPEAT_IMPL_N_13(x, d)d()  DL_CAT(x,14)
#define DL_REPEAT_IMPL_N_15(x, d) DL_REPEAT_IMPL_N_14(x, d)d()  DL_CAT(x,15)
#define DL_REPEAT_IMPL_N_16(x, d) DL_REPEAT_IMPL_N_15(x, d)d()  DL_CAT(x,16)

#define DL_REPEAT_IMPL_N(n, x, d) DL_CAT(DL_REPEAT_IMPL_N_,n)(x, d)

#define DL_REPEAT_N(n,x) DL_REPEAT_IMPL_N(n, x, DL_COMMA)

// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_IMPL_N0(n, m, d1, d2)
#define DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2) DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2)d1() DL_CAT(n,2)d2() DL_CAT(m,2)
#define DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2)d1() DL_CAT(n,3)d2() DL_CAT(m,3)
#define DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2)d1() DL_CAT(n,4)d2() DL_CAT(m,4)
#define DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2)d1() DL_CAT(n,5)d2() DL_CAT(m,5)
#define DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2)d1() DL_CAT(n,6)d2() DL_CAT(m,6)
#define DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2)d1() DL_CAT(n,7)d2() DL_CAT(m,7)
#define DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2)d1() DL_CAT(n,8)d2() DL_CAT(m,8)
#define DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2)d1() DL_CAT(n,9)d2() DL_CAT(m,9)
#define DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2)d1() DL_CAT(n,10)d2() DL_CAT(m,10)
#define DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2)d1() DL_CAT(n,11)d2() DL_CAT(m,11)
#define DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2)d1() DL_CAT(n,12)d2() DL_CAT(m,12)
#define DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2)d1() DL_CAT(n,13)d2() DL_CAT(m,13)
#define DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2)d1() DL_CAT(n,14)d2() DL_CAT(m,14)
#define DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2)d1() DL_CAT(n,15)d2() DL_CAT(m,15)
#define DL_REPEAT_PARAM_IMPL_N16(n,m, d1, d2) DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2)d1() DL_CAT(n,16)d2() DL_CAT(m,16)

#define DL_REPEAT_PARAM_IMPL_N(c, n, m, d1, d2) DL_CAT(DL_REPEAT_PARAM_IMPL_N,c)(n, m, d1, d2)

#define DL_REPEAT_PARAM_N(c, n, m) DL_REPEAT_PARAM_IMPL_N(c, n, m, DL_COMMA, DL_EMPTY)

// DL_SEQ_SIZE

#define DL_SEQ_SIZE(seq) DL_SEQ_SIZE_IMPL(seq)
#define DL_SEQ_SIZE_IMPL(seq) DL_CAT(DL_N_, DL_SEQ_SIZE_0 seq)

#define DL_SEQ_SIZE_0(_) DL_SEQ_SIZE_1
#define DL_SEQ_SIZE_1(_) DL_SEQ_SIZE_2
#define DL_SEQ_SIZE_2(_) DL_SEQ_SIZE_3
#define DL_SEQ_SIZE_3(_) DL_SEQ_SIZE_4
#define DL_SEQ_SIZE_4(_) DL_SEQ_SIZE_5
#define DL_SEQ_SIZE_5(_) DL_SEQ_SIZE_6
#define DL_SEQ_SIZE_6(_) DL_SEQ_SIZE_7
#define DL_SEQ_SIZE_7(_) DL_SEQ_SIZE_8
#define DL_SEQ_SIZE_8(_) DL_SEQ_SIZE_9
#define DL_SEQ_SIZE_9(_) DL_SEQ_SIZE_10
#define DL_SEQ_SIZE_10(_) DL_SEQ_SIZE_11
#define DL_SEQ_SIZE_11(_) DL_SEQ_SIZE_12
#define DL_SEQ_SIZE_12(_) DL_SEQ_SIZE_13
#define DL_SEQ_SIZE_13(_) DL_SEQ_SIZE_14
#define DL_SEQ_SIZE_14(_) DL_SEQ_SIZE_15
#define DL_SEQ_SIZE_15(_) DL_SEQ_SIZE_16

#define DL_N_DL_SEQ_SIZE_0 0
#define DL_N_DL_SEQ_SIZE_1 1
#define DL_N_DL_SEQ_SIZE_2 2
#define DL_N_DL_SEQ_SIZE_3 3
#define DL_N_DL_SEQ_SIZE_4 4
#define DL_N_DL_SEQ_SIZE_5 5
#define DL_N_DL_SEQ_SIZE_6 6
#define DL_N_DL_SEQ_SIZE_7 7
#define DL_N_DL_SEQ_SIZE_8 8
#define DL_N_DL_SEQ_SIZE_9 9
#define DL_N_DL_SEQ_SIZE_10 10
#define DL_N_DL_SEQ_SIZE_11 11
#define DL_N_DL_SEQ_SIZE_12 12
#define DL_N_DL_SEQ_SIZE_13 13
#define DL_N_DL_SEQ_SIZE_14 14
#define DL_N_DL_SEQ_SIZE_15 15
#define DL_N_DL_SEQ_SIZE_16 16

// DL_SEQ_ENUM

#define DL_SEQ_ENUM(seq) DL_SEQ_ENUM_IMPL(seq)
#define DL_SEQ_ENUM_IMPL(seq) DL_CAT(DL_SEQ_ENUM_, DL_SEQ_SIZE(seq)) seq

#define    DL_SEQ_ENUM_1(x) x
#define    DL_SEQ_ENUM_2(x) x, DL_SEQ_ENUM_1
#define    DL_SEQ_ENUM_3(x) x, DL_SEQ_ENUM_2
#define    DL_SEQ_ENUM_4(x) x, DL_SEQ_ENUM_3
#define    DL_SEQ_ENUM_5(x) x, DL_SEQ_ENUM_4
#define    DL_SEQ_ENUM_6(x) x, DL_SEQ_ENUM_5
#define    DL_SEQ_ENUM_7(x) x, DL_SEQ_ENUM_6
#define    DL_SEQ_ENUM_8(x) x, DL_SEQ_ENUM_7
#define    DL_SEQ_ENUM_9(x) x, DL_SEQ_ENUM_8
#define    DL_SEQ_ENUM_10(x) x, DL_SEQ_ENUM_9
#define    DL_SEQ_ENUM_11(x) x, DL_SEQ_ENUM_10
#define    DL_SEQ_ENUM_12(x) x, DL_SEQ_ENUM_11
#define    DL_SEQ_ENUM_13(x) x, DL_SEQ_ENUM_12
#define    DL_SEQ_ENUM_14(x) x, DL_SEQ_ENUM_13
#define    DL_SEQ_ENUM_15(x) x, DL_SEQ_ENUM_14
#define    DL_SEQ_ENUM_16(x) x, DL_SEQ_ENUM_15


#define NAME_ID(id) DL_CAT(CNameId, id)

#define DECLARE_NAME_ID(id, name)\
struct NAME_ID(id)\
{\
    enum {length = sizeof(name)};\
    static LPCSTR GetStr(){return name;}\
};


template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::template Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};



struct CDynFunException
{
    CDynFunException(): m_sMessage(NULL)
    {
    };
    ~CDynFunException()
    {
        free(m_sMessage);
    };
    CDynFunException(LPCTSTR sMessage):m_sMessage(NULL)
    {
        SetMessage(sMessage);
    }
    CDynFunException(const CDynFunException &other):m_sMessage(NULL)
    {
        SetMessage(other.m_sMessage);
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.m_sMessage);
        return *this;
    }
    void SetMessage(LPCTSTR sMessage)
    {
        free(m_sMessage);
        m_sMessage = (LPTSTR)malloc((_tcslen(sMessage) + 1) * sizeof(TCHAR));
        if (m_sMessage)
            _tcscpy(m_sMessage, sMessage);
    }
    LPCTSTR GetMessage() const
    {
        return m_sMessage;
    }
private:
    LPTSTR m_sMessage;
};

template <class R> struct FunProxyThrowRetTypeTrait
{
    template <class F>
    struct FunctionTraitImpl
    {
        static R MakeReturn()
        {
            F::MakeReturnImpl();
            return R();
        }
    };
};

template <> struct FunProxyThrowRetTypeTrait<void>
{
    template <class F>
    struct FunctionTraitImpl
    {
        static void MakeReturn()
        {
            F::MakeReturnImpl();
        }
    };
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct FunctionTrait:public FunProxyThrowRetTypeTrait<DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >
    {
        static void MakeReturnImpl()
        {
            TCHAR szMessage[DynFunction::name_type::length + 64];
            _stprintf(szMessage, _T("Can'n resolve procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(szMessage);
        }
    };
};


//  we need not implement void return type value policy, 
//  coz void function can only throw on error

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct FunctionTrait
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};


#define FUN_PROXY(n) DL_CAT(FunProxy,n)
#define FUN_PROXY_IMPL(n) DL_CAT(FUN_PROXY(n),Impl)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R> struct FUN_PROXY_IMPL(param_count)\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <> struct FUN_PROXY_IMPL(param_count) <void>\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            else\
                Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> > struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy:public FUN_PROXY_IMPL(param_count)<R>::template RetProxy<DynFunction, DL_REPEAT_N(param_count, P), Policy>\
    {\
    };\
};

DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's


#define DL_USE_MODULE_BEGIN(nmspace, name) \
namespace nmspace \
{\
    DECLARE_NAME_ID(nmspace, name)\
    typedef CModule<NAME_ID(nmspace)> module_type;

#define DL_USE_MODULE_END \
};

#define DL_DECLARE_FUN(NameId, R, P) \
DECLARE_NAME_ID(NameId, #NameId)\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)> >::GetProxy();

#define DL_DECLARE_FUN_ERR(Name, NameId, R, P, E)\
DECLARE_NAME_ID(NameId, #NameId)\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DL_DECLARE_FUN_THROW(NameId, R, P)\
DECLARE_NAME_ID(NameId, #NameId)\
static R (WINAPI *&NameId)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, NAME_ID(NameId), FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyThrowPolicy<> > >::GetProxy();

            _stprintf(szMessage, _T("Can'n resolve procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());

#define DECLARE_NAME_ID(id, name)\
struct NAME_ID(id)\
{\
    enum {length = sizeof(name)};\
    static LPCSTR GetStr(){return name;}\
};

#define DECLARE_NAME_ID(id, name)\
struct NAME_ID(id)\
{\
    enum {length = sizeof(name)};\
    static LPCTSTR GetStr(){return _T(name);}\
};

#define DL_USE_MODULE_BEGIN(nmspace, name) \
namespace nmspace \
{\
    DECLARE_NAME_ID(nmspace, name)\
    typedef CModule<NAME_ID(nmspace)> module_type;

#define DL_USE_MODULE_BEGIN(nmspace, name) \
namespace nmspace \
{\
    DECLARE_NAME_ID(_MODULE_##nmspace, name)\
    typedef CModule<NAME_ID(_MODULE_##nmspace)> module_type;

"Так они шептались целую неделю
и заодно делали большой железный сундук. Над ним трудились и
папа Карло, и Ферручино, и Буратино, который понемногу научился
мастерить. Артемон приносил различные железные предметы и ловко
смахивал хвостом металлические стружки. Мальвина шлифовала
готовые детали маленьким напильничком. Пьеро постукивал,
побрякивал, подтачивал, закручивал гаечки"

#define FLATTEN_STR(buff, name, idx) \
        (buff)[4*(idx)] = (TCHAR)((name##idx & 0xFF000000) >> 24);\
        (buff)[4*(idx) + 1] = (TCHAR)((name##idx & 0xFF0000) >> 16);\
        (buff)[4*(idx) + 2] = (TCHAR)((name##idx & 0xFF00) >> 8);\
        (buff)[4*(idx) + 3] = (TCHAR)(name##idx & 0xFF);

void FlattenStr(LPSTR szBuffer, DWORD n0, DWORD n1, DWORD n2, DWORD n3, DWORD n4, DWORD n5, DWORD n6, DWORD n7)
{
        FLATTEN_STR(szBuffer, n, 0);
        FLATTEN_STR(szBuffer, n, 1);
        FLATTEN_STR(szBuffer, n, 2);
        FLATTEN_STR(szBuffer, n, 3);
        FLATTEN_STR(szBuffer, n, 4);
        FLATTEN_STR(szBuffer, n, 5);
        FLATTEN_STR(szBuffer, n, 6);
        FLATTEN_STR(szBuffer, n, 7);
        szBuffer[64] = _T('\0');
}


template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    enum {name_size = 65, m_n0 = n0, m_n1 = n1, m_n2 = n2, m_n3 = n3, m_n4 = n4, m_n5 = n5, m_n6 = n6, m_n7 = n7};
    static void MakeStr(LPTSTR szBuffer)
    {
        FlattenStr(szBuffer, n0,n1,n2,n3,n4,n5,n6,n7);
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        TCHAR szFileName[name_type::name_size];
        name_type::MakeStr(szFileName);
        m_hModule = LoadLibrary(szFileName);
    }
};

template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    proxy_type::fun_type m_pfnProxy;
    
    static type &GetProxy()
    {
        static type proxy;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            TCHAR szFunName[name_type::name_size];
            name_type::MakeStr(szFunName);
            FARPROC pFunction = GetProcAddress(hModule, szFunName);
            if (pFunction)
            {
                GetProxy().m_pfnProxy = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
private:
    CDynFunction():m_pfnProxy(&proxy_type::Proxy<type>::ProxyFun)
    {
    }
};

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};

struct CDynFunException
{
    CDynFunException();
    CDynFunException(LPCTSTR sMessage):m_sMessage(sMessage)
    {
    }
    CDynFunException(const CDynFunException &other):m_sMessage(other.m_sMessage)
    {
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        m_sMessage = other.m_sMessage;
        return *this;
    }
    CString m_sMessage;
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            TCHAR szFunName[DynFunction::name_type::name_size];
            DynFunction::name_type::MakeStr(szFunName);
            CString sMessage;
            sMessage.Format(_T("Can'n load procedure <%s>: %d"), szFunName, GetLastError());
            throw E(sMessage);
            return 0;
        }
    };
};

template <typename R, typename P1, class Policy = FunProxyValuePolicy<R> > struct FunProxy
{
    typedef R (WINAPI *fun_type)(P1);
    typedef R ret_type;
    
    template <class DynFunction> struct Proxy
    {
        static R WINAPI ProxyFun(P1 param)
        {
            if (DynFunction::InitFunction())
                return DynFunction::GetProxy().m_pfnProxy(param);
            return Policy::Dummy<DynFunction>::MakeReturn();
        }
    };
};





#define USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId< /NameId/ > > module_type;\

#define USE_MODULE_END \
};\


#define DECLARE_FUN_P1(Name, NameId, R, P1)\
R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1> >::GetProxy().m_pfnProxy;

#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1, FunProxyValuePolicy<R, E> > >::GetProxy().m_pfnProxy;
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1, FunProxyThrowPolicy<> > >::GetProxy().m_pfnProxy;

template <DWORD n0 = 0, ... DWORD n7 = 0>
struct CNameId

template <__int64 n0 = 0, ... __int64 n7 = 0>
struct CNameId

static void MakeStr(LPTSTR szBuffer)
{
       static const DWORD a[]={n0,n1,n2,n3,n4,n5,n6,n7};
       static bool bInit;
       static TCHAR buf[name_size];
       if(bInit)
       {
            FlattenStr(buf,a ,7);
            bInit=true;
       }
       lstrcpy(szBuffer,buf);
}

static LPCTSTR MakeStr()
{
       static const DWORD a[]={n0,n1,n2,n3,n4,n5,n6,n7};
       static bool bInit;
       static TCHAR buf[name_size];
       if(bInit)
       {
            FlattenStr(buf,a ,7);
            bInit=true;
       }
       return buf;
}

// Макрос можно улучшить если будет необходимость
#define FLATTEN_STR(n,x) \
    ((n##x & 0xFF000000) >> 24), \
    ((n##x & 0x00FF0000) >> 16), \
    ((n##x & 0x0000FF00) >>  8), \
    ((n##x & 0x000000FF)),

template<DWORD n0 = 0,
        DWORD n1 = 0,
        DWORD n2 = 0,
        DWORD n3 = 0,
        DWORD n4 = 0,
        DWORD n5 = 0,
        DWORD n6 = 0,
        DWORD n7 = 0>
struct CNameId
{
    enum
    {
        name_size = (1<<7)-1,
        m_n0 = n0,
        m_n1 = n1,
        m_n2 = n2,
        m_n3 = n3,
        m_n4 = n4,
        m_n5 = n5,
        m_n6 = n6,
        m_n7 = n7
    };
    
    // нет вызова лишней функции
    static LPСTSTR MakeStr()
    {
        static const TCHAR buf[name_size]=
        {
            FLATTEN_STR(n,0)
            FLATTEN_STR(n,1)
            FLATTEN_STR(n,2)
            FLATTEN_STR(n,3)
            FLATTEN_STR(n,4)
            FLATTEN_STR(n,5)
            FLATTEN_STR(n,6)
            FLATTEN_STR(n,7)
        };
        return buf;
    }
};

__>Если их не будет это плохо

#define FLATTEN_STR(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))


#define    DECLARE_STR_DWORD(Name, Idx) \
static const TCHAR Name[] = {FLATTEN_STR(Idx##0), FLATTEN_STR(Idx##1), FLATTEN_STR(Idx##2), FLATTEN_STR(Idx##3), FLATTEN_STR(Idx##4), FLATTEN_STR(Idx##5), FLATTEN_STR(Idx##6), FLATTEN_STR(Idx##7)};

template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    enum
    {
        name_size = 65,
        m_n0 = n0,
        m_n1 = n1,
        m_n2 = n2,
        m_n3 = n3,
        m_n4 = n4,
        m_n5 = n5,
        m_n6 = n6,
        m_n7 = n7
    };
    static LPCTSTR GetStr()
    {
        DECLARE_STR_DWORD(szBuffer, n);
        return szBuffer;
    }
};

#define FLATTEN_STR(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))


#define    DECLARE_STR_DWORD(Name, Idx) \
static const TCHAR Name[] = {FLATTEN_STR(Idx##0), FLATTEN_STR(Idx##1), FLATTEN_STR(Idx##2), FLATTEN_STR(Idx##3), FLATTEN_STR(Idx##4), FLATTEN_STR(Idx##5), FLATTEN_STR(Idx##6), FLATTEN_STR(Idx##7)};


template <DWORD n0>
struct CNameIdHolder0
{
    template <DWORD n1>
    struct CNameIdHolder1
    {
        template <DWORD n2>
        struct CNameIdHolder2
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        FLATTEN_STR(n5),
                                                                        FLATTEN_STR(n6),
                                                                        FLATTEN_STR(n7),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                            template <>
                            struct CNameIdHolder7<0>
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        FLATTEN_STR(n5),
                                                                        FLATTEN_STR(n6),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                        template <>
                        struct CNameIdHolder6<0>
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        FLATTEN_STR(n5),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                    template <>
                    struct CNameIdHolder5<0>
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
                template <>
                struct CNameIdHolder4<0>
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
            template <>
            struct CNameIdHolder3<0>
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
        template <>
        struct CNameIdHolder2<0>
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
    };
    template <>
    struct CNameIdHolder1<0>
    {
        template <DWORD n2>
        struct CNameIdHolder2
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
    };
};

struct CNameIdHolder0<0>
{
    template <DWORD n1>
    struct CNameIdHolder1
    {
        template <DWORD n2>
        struct CNameIdHolder2
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
    };
};

template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    enum
    {
        m_n0 = n0,
        m_n1 = n1,
        m_n2 = n2,
        m_n3 = n3,
        m_n4 = n4,
        m_n5 = n5,
        m_n6 = n6,
        m_n7 = n7
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder0<n0>::CNameIdHolder1<n1>::CNameIdHolder2<n2>::CNameIdHolder3<n3>::CNameIdHolder4<n4>::CNameIdHolder5<n5>::CNameIdHolder6<n6>::CNameIdHolder7<n7>::GetStr();
    }
};

template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    CNameId()
    {
        std::cout<<count<<"\n";
    }
    enum
    {
        count   =!n0?0
                :!n1?1
                :!n2?2
                :!n3?3
                :!n4?4
                :!n5?5
                :!n6?6
                :!n7?7
                :8
    };
};
int main()
{
    CNameId<> id1;
    CNameId<1> id2;
    CNameId<1,2> id3;
    CNameId<1,4,5,6,7> id4;
    CNameId<1,2,3,4,5,6,7,8> id5;
    return 0;
}

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#define FLATTEN_STR(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))


#define    DECLARE_STR_DWORD(Name, Idx) \
static const TCHAR Name[] = {FLATTEN_STR(Idx##0), FLATTEN_STR(Idx##1), FLATTEN_STR(Idx##2), FLATTEN_STR(Idx##3), FLATTEN_STR(Idx##4), FLATTEN_STR(Idx##5), FLATTEN_STR(Idx##6), FLATTEN_STR(Idx##7)};

template <int count>
struct CNameIdHolder
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                FLATTEN_STR(n3),
                                                FLATTEN_STR(n4),
                                                FLATTEN_STR(n5),
                                                FLATTEN_STR(n6),
                                                FLATTEN_STR(n7),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};


template <>
struct CNameIdHolder<7>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                FLATTEN_STR(n3),
                                                FLATTEN_STR(n4),
                                                FLATTEN_STR(n5),
                                                FLATTEN_STR(n6),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};


template <>
struct CNameIdHolder<6>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                FLATTEN_STR(n3),
                                                FLATTEN_STR(n4),
                                                FLATTEN_STR(n5),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

template <>
struct CNameIdHolder<5>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                FLATTEN_STR(n3),
                                                FLATTEN_STR(n4),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

template <>
struct CNameIdHolder<4>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                FLATTEN_STR(n3),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

template <>
struct CNameIdHolder<3>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

template <>
struct CNameIdHolder<2>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

template <>
struct CNameIdHolder<1>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

template <>
struct CNameIdHolder<0>
{
    template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            return NULL;
        }
    };
};


template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    enum
    {
        m_n0 = n0,
        m_n1 = n1,
        m_n2 = n2,
        m_n3 = n3,
        m_n4 = n4,
        m_n5 = n5,
        m_n6 = n6,
        m_n7 = n7,
        count   = (!n0) ? 0: (!n1) ? 1: (!n2) ?2: (!n3) ? 3: (!n4) ? 4: (!n5) ? 5: (!n6) ? 6: 7
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::CNameIdHolderImpl<n0,n1,n2,n3,n4,n5,n6,n7>::GetStr();
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};

struct CDynFunException
{
    CDynFunException();
    CDynFunException(LPCTSTR sMessage):m_sMessage(sMessage)
    {
    }
    CDynFunException(const CDynFunException &other):m_sMessage(other.m_sMessage)
    {
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        m_sMessage = other.m_sMessage;
        return *this;
    }
    CString m_sMessage;
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            CString sMessage;
            sMessage.Format(_T("Can'n load procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(sMessage);
            return 0;
        }
    };
};

template <typename R, typename P1, class Policy = FunProxyValuePolicy<R> > struct FunProxy
{
    typedef R (WINAPI *fun_type)(P1);
    typedef R ret_type;
    
    template <class DynFunction> struct Proxy
    {
        static R WINAPI ProxyFun(P1 param)
        {
            if (DynFunction::InitFunction())
                return DynFunction::GetProxy()(param);
            return Policy::Dummy<DynFunction>::MakeReturn();
        }
    };
};



#define USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId< /NameId/ > > module_type;\

#define USE_MODULE_END \
};\


#define DECLARE_FUN_P1(Name, NameId, R, P1)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1> >::GetProxy();

#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1, FunProxyValuePolicy<R, E> > >::GetProxy();
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FunProxy<R, P1, FunProxyThrowPolicy<> > >::GetProxy();

AS>Определения макросов и прокси для числа параметров > 1 не приведены из принципа

<skip>
AS>

 static const TCHAR szBuffer[] = {
                                                FLATTEN_STR(n0),
                                                FLATTEN_STR(n1),
                                                FLATTEN_STR(n2),
                                                FLATTEN_STR(n3),
                                                FLATTEN_STR(n4),
                                                FLATTEN_STR(n5),
                                                FLATTEN_STR(n6),
                                                _T('\0')
                                            };

template<DWORD n,DWORD nx,DWORD np>
struct flatten_str
{ enum { value = nx<n?np:0 }; };

static const TCHAR szBuffer[] =
{
 flatten_str<7,0,n0>::value,
 flatten_str<7,1,n1>::value,
 ...
 flatten_str<7,7,0>::value
};

template<DWORD n,DWORD nx,DWORD np>
struct flatten_str
{ enum { value = nx<n?np:0 }; };

template <int count>
struct CNameIdHolder
{
    template <DWORD n0 = 0,
              DWORD n1 = 0,
              DWORD n2 = 0,
              DWORD n3 = 0,
              DWORD n4 = 0,
              DWORD n5 = 0,
              DWORD n6 = 0,
              DWORD n7 = 0>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] =
            {
                (TCHAR)flatten_str<count,0,n0>::value,
                (TCHAR)flatten_str<count,1,n1>::value,
                (TCHAR)flatten_str<count,2,n2>::value,
                (TCHAR)flatten_str<count,3,n3>::value,
                (TCHAR)flatten_str<count,4,n4>::value,
                (TCHAR)flatten_str<count,5,n5>::value,
                (TCHAR)flatten_str<count,6,n6>::value,
                (TCHAR)flatten_str<count,7,n7>::value,
                (TCHAR)flatten_str<count,8,0 >::value,
            };
            return szBuffer;
        }
    };
};

    static const TCHAR szBuffer[] =
    {
                (TCHAR)HIBYTE(HIWORD(flatten_str<count,0,n0>::value)),
                (TCHAR)LOBYTE(HIWORD(flatten_str<count,0,n0>::value)),
                (TCHAR)HIBYTE(LOWORD(flatten_str<count,0,n0>::value)),
                (TCHAR)LOBYTE(LOWORD(flatten_str<count,0,n0>::value)),
                //...
    };
    return szBuffer;

AS>Параметров и так 8, а CNameIdHolder и не должен быть расширяем — расширяем CNameId, именно его и надо менять, если надо более длинное имя. Специализация вполне красивая, хотя и не маленькая (впрочем, можно и без нее, но так экономится размер бинарника), и макрос тут тоже лучше, чем набор отдельных классов — "не плодите сущности без необходимости", их уже и так много

template<
        TCHAR c0=0,
        TCHAR c1=0,
        TCHAR c2=0,
        TCHAR c3=0,
                //...
    >
class CNameIdHolderImpl
{
};

__>Зато в моем варианте не требуется переписывать для каждой специализации код.

TCHAR sz[] = _T("test");

template <LPCTSTR s>
struct C
{
};

С<sz> c;

__>template<
__>        TCHAR c0=0,
__>        TCHAR c1=0,
__>        TCHAR c2=0,
__>        TCHAR c3=0,
__>                //...
    >>
__>class CNameIdHolderImpl
__>{
__>};
__>

__>>Зато в моем варианте не требуется переписывать для каждой специализации код.

AS>Ваш вариант вообще работать не будет, он определяет массив из 8-ми TCHAR Забудьте про эту мысль, она плохая, уверяю вас, вы РОВНЫМ счетом ничего не съэкономите, а наоборот.

AS>TCHAR sz[] = _T("test");

AS>template <LPCTSTR s>
AS>struct C
AS>{
AS>};

AS>С<sz> c;
AS>

template<const TCHAR s>
struct x{};

#define DEF_STR(strname,str) \
 const TCHAR strname##__unique_name[] = str; \
 x<strname##__unique_name> some_type##str_name;

__>>template<
__>>        TCHAR c0=0,
__>>        TCHAR c1=0,
__>>        TCHAR c2=0,
__>>        TCHAR c3=0,
__>>                //...
    >>>
__>>class CNameIdHolderImpl
__>>{
__>>};
__>>

AS>Проблем и так нет, это вы их придумали А запись имени получится в 2.5 раза длиннее и еще непонятнее.

template<typename TTraits>
class x;

struct traits_kernel32_lib
{ static LPCTSTR get_name() { return "kernel32.lib" } };

x<traits_kernel32_lib> lib_kernel;

#define USE_MODULE_BEGIN(nmspace, id, NameId) \
namespace nmspace \
{\
    struct nmspace##_traits##id##__unique_name
    { static LPCTSTR get_name() { return NameId; } };
    typedef CModule< CNameId< nmspace##_traits##id##__unique_name > > module_type;\

typedef CModule<
  CNameId<'k','e','r','n','e','l','3','2','.','d','l','l'>
 >kernel_module_type;

template<TCHAR c0=0,
         TCHAR c1=0,
         TCHAR c2=0,
         TCHAR c3=0,
         //...
        >
struct CNameId
{
  enum
  {
        m_c0 = c0,
        m_c1 = c1,
        m_c2 = c2,
        //...
        count   = (!c0) ? 0: 
                  (!c1) ? 1: 
                  (!c2) ? 2:
                  //...
   };
   static LPCTSTR GetStr()
   {
       static TCHAR strName[] =
       {
         c0,
         c1,
         c2,
         //...
         0
       };
       return strName;  
  }
};

AS>Мне — почти никак, он на VC6 компилится не будет, как я понял — там у вас частичная специализация?

CModule<'some','tex','t'>

template<TCHAR c0,TCHAR c1, ... >
struct CNameID
{...};

template<typename T,TCHAR str[]>
class str_to_char
{
 typedef T<str[0],str[1],...> type;  // как правильно не знаю :xz: 
};

// CAT
#define CAT_(x,y) x##y
#define CAT(x,y) CAT_(x,y)

// REPEAT_N
#define REPEAT_N_0(x) CAT(x,0)
#define REPEAT_N_1(x) REPEAT_N_0(x), CAT(x,1)
#define REPEAT_N_2(x) REPEAT_N_1(x), CAT(x,2)
#define REPEAT_N_3(x) REPEAT_N_2(x), CAT(x,3)
#define REPEAT_N_4(x) REPEAT_N_3(x), CAT(x,4)
#define REPEAT_N_5(x) REPEAT_N_4(x), CAT(x,5)
#define REPEAT_N_6(x) REPEAT_N_5(x), CAT(x,6)
#define REPEAT_N_7(x) REPEAT_N_6(x), CAT(x,7)
#define REPEAT_N_8(x) REPEAT_N_7(x), CAT(x,8)
//...
#define REPEAT_N(n,x) CAT(REPEAT_N_,n)(x)

// REPEAT2_N
#define REPEAT2_N_0(x,y) CAT(CAT(x,0),y)
#define REPEAT2_N_1(x,y) REPEAT2_N_0(x,y), CAT(CAT(x,1),y)
#define REPEAT2_N_2(x,y) REPEAT2_N_1(x,y), CAT(CAT(x,2),y)
#define REPEAT2_N_3(x,y) REPEAT2_N_2(x,y), CAT(CAT(x,3),y)
#define REPEAT2_N_4(x,y) REPEAT2_N_3(x,y), CAT(CAT(x,4),y)
#define REPEAT2_N_5(x,y) REPEAT2_N_4(x,y), CAT(CAT(x,5),y)
#define REPEAT2_N_6(x,y) REPEAT2_N_5(x,y), CAT(CAT(x,6),y)
#define REPEAT2_N_7(x,y) REPEAT2_N_6(x,y), CAT(CAT(x,7),y)
#define REPEAT2_N_8(x,y) REPEAT2_N_7(x,y), CAT(CAT(x,8),y)
//...
#define REPEAT2_N(n,x,y) CAT(REPEAT2_N_,n)(x,y)

// REPEAT2_EX_N
#define REPEAT2_EX_N_0(x,y) CAT(CAT(x,0),CAT(y,0))
#define REPEAT2_EX_N_1(x,y) REPEAT2_EX_N_0(x,y), CAT(CAT(x,1),CAT(y,1))
#define REPEAT2_EX_N_2(x,y) REPEAT2_EX_N_1(x,y), CAT(CAT(x,2),CAT(y,2))
#define REPEAT2_EX_N_3(x,y) REPEAT2_EX_N_2(x,y), CAT(CAT(x,3),CAT(y,3))
#define REPEAT2_EX_N_4(x,y) REPEAT2_EX_N_3(x,y), CAT(CAT(x,4),CAT(y,4))
#define REPEAT2_EX_N_5(x,y) REPEAT2_EX_N_4(x,y), CAT(CAT(x,5),CAT(y,5))
#define REPEAT2_EX_N_6(x,y) REPEAT2_EX_N_5(x,y), CAT(CAT(x,6),CAT(y,6))
#define REPEAT2_EX_N_7(x,y) REPEAT2_EX_N_6(x,y), CAT(CAT(x,7),CAT(y,7))
#define REPEAT2_EX_N_8(x,y) REPEAT2_EX_N_7(x,y), CAT(CAT(x,8),CAT(y,8))
//...
#define REPEAT2_EX_N(n,x,y) CAT(REPEAT2_EX_N_,n)(x,y)

// REPEAT3_NC_N
#define REPEAT3_NC_N_0(x,y,z) CAT(CAT(CAT(x,0),CAT(y,0)),z)
#define REPEAT3_NC_N_1(x,y,z) REPEAT3_NC_N_0(x,y,z) CAT(CAT(CAT(x,1),CAT(y,1)),z)
#define REPEAT3_NC_N_2(x,y,z) REPEAT3_NC_N_1(x,y,z) CAT(CAT(CAT(x,2),CAT(y,2)),z)
#define REPEAT3_NC_N_3(x,y,z) REPEAT3_NC_N_2(x,y,z) CAT(CAT(CAT(x,3),CAT(y,3)),z)
#define REPEAT3_NC_N_4(x,y,z) REPEAT3_NC_N_3(x,y,z) CAT(CAT(CAT(x,4),CAT(y,4)),z)
#define REPEAT3_NC_N_5(x,y,z) REPEAT3_NC_N_4(x,y,z) CAT(CAT(CAT(x,5),CAT(y,5)),z)
#define REPEAT3_NC_N_6(x,y,z) REPEAT3_NC_N_5(x,y,z) CAT(CAT(CAT(x,6),CAT(y,6)),z)
#define REPEAT3_NC_N_7(x,y,z) REPEAT3_NC_N_6(x,y,z) CAT(CAT(CAT(x,7),CAT(y,7)),z)
#define REPEAT3_NC_N_8(x,y,z) REPEAT3_NC_N_7(x,y,z) CAT(CAT(CAT(x,8),CAT(y,8)),z)
//...
#define REPEAT3_NC_N(n,x,y,z) CAT(REPEAT3_NC_N_,n)(x,y,z)

// CNameID
#define DECLARE_CNAMEID_IMPL(n) \
    template<unsigned N> \
    struct CNameIDImpl \
    CNAMEID_IMPL_(n,n)

#define SPEC_CNAMEID_IMPL(N,n) \
    template<> \
    struct CNameIDImpl<n> \
    CNAMEID_IMPL_(N,n)

#define CNAMEID_IMPL_(N,n) \
    { \
        template<REPEAT2_EX_N(N,TCHAR t_c,=0)> \
        struct Impl \
        { \
            static const TCHAR* GetStr() \
            { \
                static const TCHAR str[]= \
                { \
                    REPEAT_N(n,t_c), \
                    0 \
                }; \
                return str; \
            } \
        }; \
    };

#define DECLARE_CNAMEID(n) \
    template<REPEAT2_N(n,TCHAR t_c,=0)> \
    struct CNameID \
    { \
        enum \
        { \
            REPEAT2_EX_N(n,m_c,t_c), \
            count = REPEAT3_NC_N(n,!t_c,?,:) n+1 \
        }; \
        static const TCHAR* GetStr() \
        { return CNameIDImpl<count>::Impl<REPEAT_N(n,t_c)>::GetStr(); } \
    };

DECLARE_CNAMEID_IMPL(7)
SPEC_CNAMEID_IMPL(7,0)
SPEC_CNAMEID_IMPL(7,1)
SPEC_CNAMEID_IMPL(7,2)
SPEC_CNAMEID_IMPL(7,3)
SPEC_CNAMEID_IMPL(7,4)
SPEC_CNAMEID_IMPL(7,5)
SPEC_CNAMEID_IMPL(7,6)

DECLARE_CNAMEID(7)

void main()
{
    int n0 = CNameID<>::count;
    const TCHAR* s0 = CNameID<>::GetStr();
    int n1 = CNameID<'a'>::count;
    const TCHAR* s1 = CNameID<'a'>::GetStr();
    int n2 = CNameID<'a','b'>::count;
    const TCHAR* s2 = CNameID<'a','b'>::GetStr();
    int n3 = CNameID<'a','b','c'>::count;
    const TCHAR* s3 = CNameID<'a','b','c'>::GetStr();
    int n4 = CNameID<'a','b','c','d'>::count;
    const TCHAR* s4 = CNameID<'a','b','c','d'>::GetStr();
    int n5 = CNameID<'a','b','c','d','e'>::count;
    const TCHAR* s5 = CNameID<'a','b','c','d','e'>::GetStr();
}

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define MAX_DL_REPEAT 16

#define DL_REPEAT_EMPTY_PARAM()

// DL_REPEAT_N
#define DL_REPEAT_N_0(x) 
#define DL_REPEAT_N_1(x) DL_CAT(x,1)
#define DL_REPEAT_N_2(x) DL_REPEAT_N_1(x), DL_CAT(x,2)
#define DL_REPEAT_N_3(x) DL_REPEAT_N_2(x), DL_CAT(x,3)
#define DL_REPEAT_N_4(x) DL_REPEAT_N_3(x), DL_CAT(x,4)
#define DL_REPEAT_N_5(x) DL_REPEAT_N_4(x), DL_CAT(x,5)
#define DL_REPEAT_N_6(x) DL_REPEAT_N_5(x), DL_CAT(x,6)
#define DL_REPEAT_N_7(x) DL_REPEAT_N_6(x), DL_CAT(x,7)
#define DL_REPEAT_N_8(x) DL_REPEAT_N_7(x), DL_CAT(x,8)
#define DL_REPEAT_N_9(x) DL_REPEAT_N_8(x), DL_CAT(x,9)
#define DL_REPEAT_N_10(x) DL_REPEAT_N_9(x), DL_CAT(x,10)
#define DL_REPEAT_N_11(x) DL_REPEAT_N_10(x), DL_CAT(x,11)
#define DL_REPEAT_N_12(x) DL_REPEAT_N_11(x), DL_CAT(x,12)
#define DL_REPEAT_N_13(x) DL_REPEAT_N_12(x), DL_CAT(x,13)
#define DL_REPEAT_N_14(x) DL_REPEAT_N_13(x), DL_CAT(x,14)
#define DL_REPEAT_N_15(x) DL_REPEAT_N_14(x), DL_CAT(x,15)
#define DL_REPEAT_N_16(x) DL_REPEAT_N_15(x), DL_CAT(x,16)

#define DL_REPEAT_N(n, x) DL_CAT(DL_REPEAT_N_,n)(x)



// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_N0(n, m)
#define DL_REPEAT_PARAM_N1(n, m) DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_N2(n, m) DL_REPEAT_PARAM_N1(n, m), DL_CAT(n,2) DL_CAT(m,2)
#define DL_REPEAT_PARAM_N3(n, m) DL_REPEAT_PARAM_N2(n, m), DL_CAT(n,3) DL_CAT(m,3)
#define DL_REPEAT_PARAM_N4(n, m) DL_REPEAT_PARAM_N3(n, m), DL_CAT(n,4) DL_CAT(m,4)
#define DL_REPEAT_PARAM_N5(n, m) DL_REPEAT_PARAM_N4(n, m), DL_CAT(n,5) DL_CAT(m,5)
#define DL_REPEAT_PARAM_N6(n, m) DL_REPEAT_PARAM_N5(n, m), DL_CAT(n,6) DL_CAT(m,6)
#define DL_REPEAT_PARAM_N7(n, m) DL_REPEAT_PARAM_N6(n, m), DL_CAT(n,7) DL_CAT(m,7)
#define DL_REPEAT_PARAM_N8(n, m) DL_REPEAT_PARAM_N7(n, m), DL_CAT(n,8) DL_CAT(m,8)
#define DL_REPEAT_PARAM_N9(n, m) DL_REPEAT_PARAM_N8(n, m), DL_CAT(n,9) DL_CAT(m,9)
#define DL_REPEAT_PARAM_N10(n, m) DL_REPEAT_PARAM_N9(n, m), DL_CAT(n,10) DL_CAT(m,10)
#define DL_REPEAT_PARAM_N11(n, m) DL_REPEAT_PARAM_N10(n, m), DL_CAT(n,11) DL_CAT(m,11)
#define DL_REPEAT_PARAM_N12(n, m) DL_REPEAT_PARAM_N11(n, m), DL_CAT(n,12) DL_CAT(m,12)
#define DL_REPEAT_PARAM_N13(n, m) DL_REPEAT_PARAM_N12(n, m), DL_CAT(n,13) DL_CAT(m,13)
#define DL_REPEAT_PARAM_N14(n, m) DL_REPEAT_PARAM_N13(n, m), DL_CAT(n,14) DL_CAT(m,14)
#define DL_REPEAT_PARAM_N15(n, m) DL_REPEAT_PARAM_N14(n, m), DL_CAT(n,15) DL_CAT(m,15)
#define DL_REPEAT_PARAM_N16(n,m) DL_REPEAT_PARAM_N15(n, m), DL_CAT(n,16) DL_CAT(m,16)

#define DL_REPEAT_PARAM_N(c, n, m) DL_CAT(DL_REPEAT_PARAM_N,c)(n, m)

// DL_REPEAT_DEF_N
#define DL_REPEAT_DEF_N0(n, d)
#define DL_REPEAT_DEF_N1(n, d) DL_CAT(DL_CAT(n,1), d)
#define DL_REPEAT_DEF_N2(n, d) DL_REPEAT_DEF_N1(n, d), DL_CAT(DL_CAT(n,2), d)
#define DL_REPEAT_DEF_N3(n, d) DL_REPEAT_DEF_N2(n, d), DL_CAT(DL_CAT(n,3), d)
#define DL_REPEAT_DEF_N4(n, d) DL_REPEAT_DEF_N3(n, d), DL_CAT(DL_CAT(n,4), d)
#define DL_REPEAT_DEF_N5(n, d) DL_REPEAT_DEF_N4(n, d), DL_CAT(DL_CAT(n,5), d)
#define DL_REPEAT_DEF_N6(n, d) DL_REPEAT_DEF_N5(n, d), DL_CAT(DL_CAT(n,6), d)
#define DL_REPEAT_DEF_N7(n, d) DL_REPEAT_DEF_N6(n, d), DL_CAT(DL_CAT(n,7), d)
#define DL_REPEAT_DEF_N8(n, d) DL_REPEAT_DEF_N7(n, d), DL_CAT(DL_CAT(n,8), d)
#define DL_REPEAT_DEF_N9(n, d) DL_REPEAT_DEF_N8(n, d), DL_CAT(DL_CAT(n,9), d)
#define DL_REPEAT_DEF_N10(n, d) DL_REPEAT_DEF_N9(n, d), DL_CAT(DL_CAT(n,10), d)
#define DL_REPEAT_DEF_N11(n, d) DL_REPEAT_DEF_N10(n, d), DL_CAT(DL_CAT(n,11), d)
#define DL_REPEAT_DEF_N12(n, d) DL_REPEAT_DEF_N11(n, d), DL_CAT(DL_CAT(n,12), d)
#define DL_REPEAT_DEF_N13(n, d) DL_REPEAT_DEF_N12(n, d), DL_CAT(DL_CAT(n,13), d)
#define DL_REPEAT_DEF_N14(n, d) DL_REPEAT_DEF_N13(n, d), DL_CAT(DL_CAT(n,14), d)
#define DL_REPEAT_DEF_N15(n, d) DL_REPEAT_DEF_N14(n, d), DL_CAT(DL_CAT(n,15), d)
#define DL_REPEAT_DEF_N16(n,d) DL_REPEAT_DEF_N15(n, d), DL_CAT(DL_CAT(n,16), d)

#define DL_REPEAT_DEF_N(c, n, d) DL_CAT(DL_REPEAT_DEF_N,c)(n, d)


// DL_REPEAT_MACRO_N

#define DL_REPEAT_MACRO_N0(m, p)
#define DL_REPEAT_MACRO_N1(m, p) m(DL_CAT(p,1))
#define DL_REPEAT_MACRO_N2(m, p) DL_REPEAT_MACRO_N1(m, p), m(DL_CAT(p,2))
#define DL_REPEAT_MACRO_N3(m, p) DL_REPEAT_MACRO_N2(m, p), m(DL_CAT(p,3))
#define DL_REPEAT_MACRO_N4(m, p) DL_REPEAT_MACRO_N3(m, p), m(DL_CAT(p,4))
#define DL_REPEAT_MACRO_N5(m, p) DL_REPEAT_MACRO_N4(m, p), m(DL_CAT(p,5))
#define DL_REPEAT_MACRO_N6(m, p) DL_REPEAT_MACRO_N5(m, p), m(DL_CAT(p,6))
#define DL_REPEAT_MACRO_N7(m, p) DL_REPEAT_MACRO_N6(m, p), m(DL_CAT(p,7))
#define DL_REPEAT_MACRO_N8(m, p) DL_REPEAT_MACRO_N7(m, p), m(DL_CAT(p,8))
#define DL_REPEAT_MACRO_N9(m, p) DL_REPEAT_MACRO_N8(m, p), m(DL_CAT(p,9))
#define DL_REPEAT_MACRO_N10(m, p) DL_REPEAT_MACRO_N9(m, p), m(DL_CAT(p,10))
#define DL_REPEAT_MACRO_N11(m, p) DL_REPEAT_MACRO_N10(m, p), m(DL_CAT(p,11))
#define DL_REPEAT_MACRO_N12(m, p) DL_REPEAT_MACRO_N11(m, p), m(DL_CAT(p,12))
#define DL_REPEAT_MACRO_N13(m, p) DL_REPEAT_MACRO_N12(m, p), m(DL_CAT(p,13))
#define DL_REPEAT_MACRO_N14(m, p) DL_REPEAT_MACRO_N13(m, p), m(DL_CAT(p,14))
#define DL_REPEAT_MACRO_N15(m, p) DL_REPEAT_MACRO_N14(m, p), m(DL_CAT(p,15))
#define DL_REPEAT_MACRO_N16(m, p) DL_REPEAT_MACRO_N15(m, p), m(DL_CAT(p,16))

#define DL_REPEAT_MACRO_N(c, m, p) DL_CAT(DL_REPEAT_MACRO_N,c)(m,p)

#define FLATTEN_STR(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))


#define    DECLARE_STR_DWORD(Name, Idx) \
static const TCHAR Name[] = {FLATTEN_STR(Idx##0), FLATTEN_STR(Idx##1), FLATTEN_STR(Idx##2), FLATTEN_STR(Idx##3), FLATTEN_STR(Idx##4), FLATTEN_STR(Idx##5), FLATTEN_STR(Idx##6), FLATTEN_STR(Idx##7)};


template <int count>
struct CNameIdHolder
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                DL_REPEAT_MACRO_N(MAX_DL_REPEAT, FLATTEN_STR, n),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

#define NAME_ID_HOLDER_SPEC(num)\
template <>\
struct CNameIdHolder<num>\
{\
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>\
    struct CNameIdHolderImpl\
    {\
        static LPCTSTR GetStr()\
        {\
            static const TCHAR szBuffer[] = {\
                                                DL_REPEAT_MACRO_N(num, FLATTEN_STR, n),\
                                                _T('\0')\
                                            };\
            return szBuffer;\
        }\
    };\
};

NAME_ID_HOLDER_SPEC(15)
NAME_ID_HOLDER_SPEC(14)
NAME_ID_HOLDER_SPEC(13)
NAME_ID_HOLDER_SPEC(12)
NAME_ID_HOLDER_SPEC(11)
NAME_ID_HOLDER_SPEC(10)
NAME_ID_HOLDER_SPEC(9)
NAME_ID_HOLDER_SPEC(8)
NAME_ID_HOLDER_SPEC(7)
NAME_ID_HOLDER_SPEC(6)
NAME_ID_HOLDER_SPEC(5)
NAME_ID_HOLDER_SPEC(4)
NAME_ID_HOLDER_SPEC(3)
NAME_ID_HOLDER_SPEC(2)
NAME_ID_HOLDER_SPEC(1)

template <>
struct CNameIdHolder<0>
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            return NULL;
        }
    };
};


template <DL_REPEAT_DEF_N(MAX_DL_REPEAT, DWORD n, = 0)>
struct CNameId
{
    enum
    {
        DL_REPEAT_PARAM_N(MAX_DL_REPEAT, m_n, =n),
        count   = (!n1) ? 0: (!n2) ? 1: (!n3) ?2: (!n4) ? 3: (!n5) ? 4: (!n6) ? 5: (!n7) ? 6: (!n8) ? 7: 
                  (!n9) ? 8: (!n10) ? 9: (!n11) ?10: (!n12) ? 11: (!n13) ? 12: (!n14) ? 13: (!n15) ? 14: (!n16) ? 15: 16
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::CNameIdHolderImpl<DL_REPEAT_N(MAX_DL_REPEAT, n)>::GetStr();
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};

struct CDynFunException
{
    CDynFunException();
    CDynFunException(LPCTSTR sMessage):m_sMessage(sMessage)
    {
    }
    CDynFunException(const CDynFunException &other):m_sMessage(other.m_sMessage)
    {
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        m_sMessage = other.m_sMessage;
        return *this;
    }
    CString m_sMessage;
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            CString sMessage;
            sMessage.Format(_T("Can'n load procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(sMessage);
            return 0;
        }
    };
};



#define FUN_PROXY(n) DL_CAT(FunProxy,n)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> > struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::Dummy<DynFunction>::MakeReturn();\
        }\
    };\
};


DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's

#define USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId< /NameId/ > > module_type;

#define USE_MODULE_END \
};



#define DECLARE_FUN_P1(Name, NameId, R, P1) \
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1> >::GetProxy();


#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1, FunProxyValuePolicy<R, E> > >::GetProxy();
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1, FunProxyThrowPolicy<> > >::GetProxy();

#endif

#define CAT_0(x) CAT(x,0)
//...
#define CAT_n(x) CAT(x,n)

#define REPEAT_N(nfrom,nto,x) CAT(CAT_,nfrom)(x) /* как-нибудь перебор */ CAT(CAT_(nto))(x)

struct CDynFunException
{
    CDynFunException() : m_sMessage(0) {}
    CDynFunException(LPCTSTR sMessage) : m_sMessage(0)
    { SetMessage(sMessage); }
    CDynFunException(const CDynFunException &other) : m_sMessage(0)
    { SetMessage(other.sMessage); }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.sMessage);
        return *this;
    }
    ~CDynFunExecption()
    { delete[] m_sMessage; }

    const TCHAR* GetMessage() { return m_sMessage; }
private:
    void SetMessage(LPCTSTR sMessage)
    {
       delete[] m_sMessage;
       m_sMessage = new TCHAR[lstrlen(other.m_sMessage)+1];
       lstrcpy(m_sMessage,other.m_sMessage);
    }
    TCHAR* m_sMessage;
};

AS>Нет, это в tchar.h, и проблем не будет

<skip>
__>>

AS>new может сам вызывать эксепшен — начинаем тихо форматировать диск Конечно, лучше использовать malloc\free.

struct CDynFunException
{
    CDynFunException() : m_sMessage(0) {}
    CDynFunException(LPCTSTR sMessage) : m_sMessage(0)
    { SetMessage(sMessage); }
    CDynFunException(const CDynFunException& other) : m_sMessage(0)
    { SetMessage(other.sMessage); }
    CDynFunException &operator=(const CDynFunException &other)
    {
        SetMessage(other.sMessage);
        return *this;
    }
    ~CDynFunExecption()
    { free(m_sMessage); }

    const TCHAR* GetMessage() { return m_sMessage; }
private:
    void SetMessage(LPCTSTR sMessage)
    {
       free(m_sMessage);
       m_sMessage = malloc(lstrlen(other.m_sMessage)+1);
       lstrcpy(m_sMessage,other.m_sMessage);
    }
    TCHAR* m_sMessage;
};

Пофикшен баг с FLATTEN_STR
Изменены размножающие макросы — теперь удобнее и больше возможностей
С учетом возвращаемого типа void переработаны политика исключений и прокси вызова
В соответствии с пожеланиями телезрителей CString отправлен в dev\null, его в проекте больше нет
Немного причесан код для большего соответствия ANSI, где это возможно

Компилеро-независимый способ задания строк, сейчас работает только на линейке VC
Автоматический генератор макросов DECLARE_FUN_XXX
Что то еще?

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define MAX_DL_REPEAT 16
#define DL_COMMA() ,
#define DL_EMPTY() 

// DL_REPEAT_N
#define DL_REPEAT_IMPL_N_0(x, d) 
#define DL_REPEAT_IMPL_N_1(x, d) DL_CAT(x,1)
#define DL_REPEAT_IMPL_N_2(x, d) DL_REPEAT_IMPL_N_1(x, d)d()  DL_CAT(x,2)
#define DL_REPEAT_IMPL_N_3(x, d) DL_REPEAT_IMPL_N_2(x, d)d()  DL_CAT(x,3)
#define DL_REPEAT_IMPL_N_4(x, d) DL_REPEAT_IMPL_N_3(x, d)d()  DL_CAT(x,4)
#define DL_REPEAT_IMPL_N_5(x, d) DL_REPEAT_IMPL_N_4(x, d)d()  DL_CAT(x,5)
#define DL_REPEAT_IMPL_N_6(x, d) DL_REPEAT_IMPL_N_5(x, d)d()  DL_CAT(x,6)
#define DL_REPEAT_IMPL_N_7(x, d) DL_REPEAT_IMPL_N_6(x, d)d()  DL_CAT(x,7)
#define DL_REPEAT_IMPL_N_8(x, d) DL_REPEAT_IMPL_N_7(x, d)d()  DL_CAT(x,8)
#define DL_REPEAT_IMPL_N_9(x, d) DL_REPEAT_IMPL_N_8(x, d)d()  DL_CAT(x,9)
#define DL_REPEAT_IMPL_N_10(x, d) DL_REPEAT_IMPL_N_9(x, d)d()  DL_CAT(x,10)
#define DL_REPEAT_IMPL_N_11(x, d) DL_REPEAT_IMPL_N_10(x, d)d()  DL_CAT(x,11)
#define DL_REPEAT_IMPL_N_12(x, d) DL_REPEAT_IMPL_N_11(x, d)d()  DL_CAT(x,12)
#define DL_REPEAT_IMPL_N_13(x, d) DL_REPEAT_IMPL_N_12(x, d)d()  DL_CAT(x,13)
#define DL_REPEAT_IMPL_N_14(x, d) DL_REPEAT_IMPL_N_13(x, d)d()  DL_CAT(x,14)
#define DL_REPEAT_IMPL_N_15(x, d) DL_REPEAT_IMPL_N_14(x, d)d()  DL_CAT(x,15)
#define DL_REPEAT_IMPL_N_16(x, d) DL_REPEAT_IMPL_N_15(x, d)d()  DL_CAT(x,16)

#define DL_REPEAT_IMPL_N(n, x, d) DL_CAT(DL_REPEAT_IMPL_N_,n)(x, d)

#define DL_REPEAT_N(n,x) DL_REPEAT_IMPL_N(n, x, DL_COMMA)

// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_IMPL_N0(n, m, d1, d2)
#define DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2) DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2)d1() DL_CAT(n,2)d2() DL_CAT(m,2)
#define DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2)d1() DL_CAT(n,3)d2() DL_CAT(m,3)
#define DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2)d1() DL_CAT(n,4)d2() DL_CAT(m,4)
#define DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2)d1() DL_CAT(n,5)d2() DL_CAT(m,5)
#define DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2)d1() DL_CAT(n,6)d2() DL_CAT(m,6)
#define DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2)d1() DL_CAT(n,7)d2() DL_CAT(m,7)
#define DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2)d1() DL_CAT(n,8)d2() DL_CAT(m,8)
#define DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2)d1() DL_CAT(n,9)d2() DL_CAT(m,9)
#define DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2)d1() DL_CAT(n,10)d2() DL_CAT(m,10)
#define DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2)d1() DL_CAT(n,11)d2() DL_CAT(m,11)
#define DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2)d1() DL_CAT(n,12)d2() DL_CAT(m,12)
#define DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2)d1() DL_CAT(n,13)d2() DL_CAT(m,13)
#define DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2)d1() DL_CAT(n,14)d2() DL_CAT(m,14)
#define DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2)d1() DL_CAT(n,15)d2() DL_CAT(m,15)
#define DL_REPEAT_PARAM_IMPL_N16(n,m, d1, d2) DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2)d1() DL_CAT(n,16)d2() DL_CAT(m,16)

#define DL_REPEAT_PARAM_IMPL_N(c, n, m, d1, d2) DL_CAT(DL_REPEAT_PARAM_IMPL_N,c)(n, m, d1, d2)

#define DL_REPEAT_PARAM_N(c, n, m) DL_REPEAT_PARAM_IMPL_N(c, n, m, DL_COMMA, DL_EMPTY)

// DL_REPEAT_DEF_IMPL_N
#define DL_REPEAT_DEF_IMPL_N0(n, def, d)
#define DL_REPEAT_DEF_IMPL_N1(n, def, d) DL_CAT(DL_CAT(n,1), def)
#define DL_REPEAT_DEF_IMPL_N2(n, def, d) DL_REPEAT_DEF_IMPL_N1(n, def, d)d() DL_CAT(DL_CAT(n,2), def)
#define DL_REPEAT_DEF_IMPL_N3(n, def, d) DL_REPEAT_DEF_IMPL_N2(n, def, d)d() DL_CAT(DL_CAT(n,3), def)
#define DL_REPEAT_DEF_IMPL_N4(n, def, d) DL_REPEAT_DEF_IMPL_N3(n, def, d)d() DL_CAT(DL_CAT(n,4), def)
#define DL_REPEAT_DEF_IMPL_N5(n, def, d) DL_REPEAT_DEF_IMPL_N4(n, def, d)d() DL_CAT(DL_CAT(n,5), def)
#define DL_REPEAT_DEF_IMPL_N6(n, def, d) DL_REPEAT_DEF_IMPL_N5(n, def, d)d() DL_CAT(DL_CAT(n,6), def)
#define DL_REPEAT_DEF_IMPL_N7(n, def, d) DL_REPEAT_DEF_IMPL_N6(n, def, d)d() DL_CAT(DL_CAT(n,7), def)
#define DL_REPEAT_DEF_IMPL_N8(n, def, d) DL_REPEAT_DEF_IMPL_N7(n, def, d)d() DL_CAT(DL_CAT(n,8), def)
#define DL_REPEAT_DEF_IMPL_N9(n, def, d) DL_REPEAT_DEF_IMPL_N8(n, def, d)d() DL_CAT(DL_CAT(n,9), def)
#define DL_REPEAT_DEF_IMPL_N10(n, def, d) DL_REPEAT_DEF_IMPL_N9(n, def, d)d() DL_CAT(DL_CAT(n,10), def)
#define DL_REPEAT_DEF_IMPL_N11(n, def, d) DL_REPEAT_DEF_IMPL_N10(n, def, d)d() DL_CAT(DL_CAT(n,11), def)
#define DL_REPEAT_DEF_IMPL_N12(n, def, d) DL_REPEAT_DEF_IMPL_N11(n, def, d)d() DL_CAT(DL_CAT(n,12), def)
#define DL_REPEAT_DEF_IMPL_N13(n, def, d) DL_REPEAT_DEF_IMPL_N12(n, def, d)d() DL_CAT(DL_CAT(n,13), def)
#define DL_REPEAT_DEF_IMPL_N14(n, def, d) DL_REPEAT_DEF_IMPL_N13(n, def, d)d() DL_CAT(DL_CAT(n,14), def)
#define DL_REPEAT_DEF_IMPL_N15(n, def, d) DL_REPEAT_DEF_IMPL_N14(n, def, d)d() DL_CAT(DL_CAT(n,15), def)
#define DL_REPEAT_DEF_IMPL_N16(n, def, d) DL_REPEAT_DEF_IMPL_N15(n, def, d)d() DL_CAT(DL_CAT(n,16), def)

#define DL_REPEAT_DEF_IMPL_N(c, n, def, d) DL_CAT(DL_REPEAT_DEF_IMPL_N,c)(n, def, d)

#define DL_REPEAT_DEF_N(c, n, def) DL_REPEAT_DEF_IMPL_N(c, n, def, DL_COMMA)

// DL_REPEAT_MACRO_N

#define DL_REPEAT_MACRO_IMPL_N0(m, p, d)
#define DL_REPEAT_MACRO_IMPL_N1(m, p, d) m(p,1)
#define DL_REPEAT_MACRO_IMPL_N2(m, p, d) DL_REPEAT_MACRO_IMPL_N1(m, p, d)d() m(p,2)
#define DL_REPEAT_MACRO_IMPL_N3(m, p, d) DL_REPEAT_MACRO_IMPL_N2(m, p, d)d() m(p,3)
#define DL_REPEAT_MACRO_IMPL_N4(m, p, d) DL_REPEAT_MACRO_IMPL_N3(m, p, d)d() m(p,4)
#define DL_REPEAT_MACRO_IMPL_N5(m, p, d) DL_REPEAT_MACRO_IMPL_N4(m, p, d)d() m(p,5)
#define DL_REPEAT_MACRO_IMPL_N6(m, p, d) DL_REPEAT_MACRO_IMPL_N5(m, p, d)d() m(p,6)
#define DL_REPEAT_MACRO_IMPL_N7(m, p, d) DL_REPEAT_MACRO_IMPL_N6(m, p, d)d() m(p,7)
#define DL_REPEAT_MACRO_IMPL_N8(m, p, d) DL_REPEAT_MACRO_IMPL_N7(m, p, d)d() m(p,8)
#define DL_REPEAT_MACRO_IMPL_N9(m, p, d) DL_REPEAT_MACRO_IMPL_N8(m, p, d)d() m(p,9)
#define DL_REPEAT_MACRO_IMPL_N10(m, p, d) DL_REPEAT_MACRO_IMPL_N9(m, p, d)d() m(p,10)
#define DL_REPEAT_MACRO_IMPL_N11(m, p, d) DL_REPEAT_MACRO_IMPL_N10(m, p, d)d() m(p,11)
#define DL_REPEAT_MACRO_IMPL_N12(m, p, d) DL_REPEAT_MACRO_IMPL_N11(m, p, d)d() m(p,12)
#define DL_REPEAT_MACRO_IMPL_N13(m, p, d) DL_REPEAT_MACRO_IMPL_N12(m, p, d)d() m(p,13)
#define DL_REPEAT_MACRO_IMPL_N14(m, p, d) DL_REPEAT_MACRO_IMPL_N13(m, p, d)d() m(p,14)
#define DL_REPEAT_MACRO_IMPL_N15(m, p, d) DL_REPEAT_MACRO_IMPL_N14(m, p, d)d() m(p,15)
#define DL_REPEAT_MACRO_IMPL_N16(m, p, d) DL_REPEAT_MACRO_IMPL_N15(m, p, d)d() m(p,16)

#define DL_REPEAT_MACRO_IMPL_N(c, m, p, d) DL_CAT(DL_REPEAT_MACRO_IMPL_N,c)(m,p, d)
#define DL_REPEAT_MACRO_N(c, m, p) DL_REPEAT_MACRO_IMPL_N(c, m, p, DL_COMMA)

#define FLATTEN_STR3(val) (((val) > 0xFFFFFF) ? (val) : 0)
#define FLATTEN_STR2(val) (((val) > 0xFFFFFF) ? (val) : FLATTEN_STR3(val << 8))
#define FLATTEN_STR1(val) (((val) > 0xFFFFFF) ? (val) : FLATTEN_STR2(val << 8))
#define FLATTEN_STR0(val) (((val) > 0xFFFFFF) ? (val) : FLATTEN_STR1(val << 8))

#define FLATTEN_STR_(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))

#define FLATTEN_STR(val, num) FLATTEN_STR_(FLATTEN_STR0(DL_CAT(val, num)))

#pragma warning (disable: 4786)

template <int count>
struct CNameIdHolder
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                DL_REPEAT_MACRO_N(MAX_DL_REPEAT, FLATTEN_STR, n),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

#define NAME_ID_HOLDER_SPEC(num)\
template <>\
struct CNameIdHolder<num>\
{\
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>\
    struct CNameIdHolderImpl\
    {\
        static LPCTSTR GetStr()\
        {\
            static const TCHAR szBuffer[] = {\
                                                DL_REPEAT_MACRO_N(num, FLATTEN_STR, n),\
                                                _T('\0')\
                                            };\
            return szBuffer;\
        }\
    };\
};

NAME_ID_HOLDER_SPEC(15)
NAME_ID_HOLDER_SPEC(14)
NAME_ID_HOLDER_SPEC(13)
NAME_ID_HOLDER_SPEC(12)
NAME_ID_HOLDER_SPEC(11)
NAME_ID_HOLDER_SPEC(10)
NAME_ID_HOLDER_SPEC(9)
NAME_ID_HOLDER_SPEC(8)
NAME_ID_HOLDER_SPEC(7)
NAME_ID_HOLDER_SPEC(6)
NAME_ID_HOLDER_SPEC(5)
NAME_ID_HOLDER_SPEC(4)
NAME_ID_HOLDER_SPEC(3)
NAME_ID_HOLDER_SPEC(2)
NAME_ID_HOLDER_SPEC(1)

template <>
struct CNameIdHolder<0>
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            return NULL;
        }
    };
};

#define NN_REP_COUNT_M(p, n) (!DL_CAT(p,n)) ? (n-1):

template <DL_REPEAT_DEF_N(MAX_DL_REPEAT, DWORD n, = 0)>
struct CNameId
{
    enum
    {
        DL_REPEAT_PARAM_N(MAX_DL_REPEAT, m_n, =n),
        count   = DL_REPEAT_MACRO_IMPL_N(MAX_DL_REPEAT, NN_REP_COUNT_M, n, DL_EMPTY) MAX_DL_REPEAT,
        length  = count * sizeof(DWORD)
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::template CNameIdHolderImpl<DL_REPEAT_N(MAX_DL_REPEAT, n)>::GetStr();
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::template Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};



struct CDynFunException
{
    CDynFunException(): m_sMessage(NULL)
    {
    };
    ~CDynFunException()
    {
        free(m_sMessage);
    };
    CDynFunException(LPCTSTR sMessage):m_sMessage(NULL)
    {
        SetMessage(sMessage);
    }
    CDynFunException(const CDynFunException &other):m_sMessage(NULL)
    {
        SetMessage(other.m_sMessage);
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.m_sMessage);
        return *this;
    }
    void SetMessage(LPCTSTR sMessage)
    {
        free(m_sMessage);
        m_sMessage = (LPTSTR)malloc((_tcslen(sMessage) + 1) * sizeof(TCHAR));
        if (m_sMessage)
            _tcscpy(m_sMessage, sMessage);
    }
    LPTSTR m_sMessage;
};

template <class R> struct FunProxyThrowRetTypeTrait
{
    template <class F>
    struct FunctionTraitImpl
    {
        static R MakeReturn()
        {
            F::MakeReturnImpl();
            return R();
        }
    };
};

template <> struct FunProxyThrowRetTypeTrait<void>
{
    template <class F>
    struct FunctionTraitImpl
    {
        static void MakeReturn()
        {
            F::MakeReturnImpl();
        }
    };
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct FunctionTrait:public FunProxyThrowRetTypeTrait<DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >
    {
        static void MakeReturnImpl()
        {
            TCHAR szMessage[DynFunction::name_type::length + 64];
            _stprintf(szMessage, _T("Can'n resolve procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(szMessage);
        }
    };
};


//  we need not implement void return type value policy, 
//  coz void function can only throw on error

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct FunctionTrait
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};


#define FUN_PROXY(n) DL_CAT(FunProxy,n)
#define FUN_PROXY_IMPL(n) DL_CAT(FUN_PROXY(n),Impl)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R> struct FUN_PROXY_IMPL(param_count)\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <> struct FUN_PROXY_IMPL(param_count) <void>\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            else\
                Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> > struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy:public FUN_PROXY_IMPL(param_count)<R>::template RetProxy<DynFunction, DL_REPEAT_N(param_count, P), Policy>\
    {\
    };\
};

DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's

#define USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId< /NameId/ > > module_type;

#define USE_MODULE_END \
};



#define DECLARE_FUN_P1(Name, NameId, R, P1) \
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1> >::GetProxy();


#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1, FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1, FunProxyThrowPolicy<> > >::GetProxy();

#endif

#define DECLARE_FUN1_P1(Name, NameId0, R, P1) \
 static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<NameId0>, FUN_PROXY(1)<R, P1> >::GetProxy();

#define DECLARE_FUN2_P1(Name, NameId0, NameId1, R, P1) \
 static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<NameId0,NameId1>, FUN_PROXY(1)<R, P1> >::GetProxy();

//...

#define DECLARE_FUN1_P1(Name, NameId0, R, P1) \
 static R (WINAPI *&Name)(REPEAT_N(1,P)) = CDynFunction<module_type, CNameId<REPEAT_N(0,NameId)>, FUN_PROXY(1)<R, REPEAT_N(1,P)> >::GetProxy();

#define DECLARE_FUN2_P1(Name, NameId0, NameId1, R, P1) \
 static R (WINAPI *&Name)(REPEAT_N(1,P)) = CDynFunction<module_type, CNameId<REPEAT_N(1,NameId)>, FUN_PROXY(1)<R, REPEAT_N(1,P)> >::GetProxy();
//...

USE_MODULE_BEGIN(kernel, (kern)(el32)(.dll))
    DECLARE_FUN_P1(GetModuleHandle, (GetM)(odul)(eHan)(dleA), HMODULE, LPCTSTR)
    DECLARE_FUN_P1(GetModuleHandleW, (GetM)(odul)(eHan)(dleW), HMODULE, LPCWSTR)
    DECLARE_FUN_P1_THROW(InitializeCriticalSection, (Init)(iali)(zeCr)(itic)(alSe)(ctio)(n),VOID, LPCRITICAL_SECTION)
USE_MODULE_END

USE_MODULE_BEGIN(kernel, (kern)(el32)(.dll))
    DECLARE_FUN_P1((GetM)(odul)(eHan)(dleA), HMODULE, LPCTSTR)
    DECLARE_FUN_P1((GetM)(odul)(eHan)(dleW), HMODULE, LPCWSTR)
    DECLARE_FUN_P1_THROW(InitializeCriticalSection, (Init)(iali)(zeCr)(itic)(alSe)(ctio)(n),VOID, LPCRITICAL_SECTION)
USE_MODULE_END

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define MAX_DL_REPEAT 16
#define DL_COMMA() ,
#define DL_EMPTY() 

// DL_REPEAT_N
#define DL_REPEAT_IMPL_N_0(x, d) 
#define DL_REPEAT_IMPL_N_1(x, d) DL_CAT(x,1)
#define DL_REPEAT_IMPL_N_2(x, d) DL_REPEAT_IMPL_N_1(x, d)d()  DL_CAT(x,2)
#define DL_REPEAT_IMPL_N_3(x, d) DL_REPEAT_IMPL_N_2(x, d)d()  DL_CAT(x,3)
#define DL_REPEAT_IMPL_N_4(x, d) DL_REPEAT_IMPL_N_3(x, d)d()  DL_CAT(x,4)
#define DL_REPEAT_IMPL_N_5(x, d) DL_REPEAT_IMPL_N_4(x, d)d()  DL_CAT(x,5)
#define DL_REPEAT_IMPL_N_6(x, d) DL_REPEAT_IMPL_N_5(x, d)d()  DL_CAT(x,6)
#define DL_REPEAT_IMPL_N_7(x, d) DL_REPEAT_IMPL_N_6(x, d)d()  DL_CAT(x,7)
#define DL_REPEAT_IMPL_N_8(x, d) DL_REPEAT_IMPL_N_7(x, d)d()  DL_CAT(x,8)
#define DL_REPEAT_IMPL_N_9(x, d) DL_REPEAT_IMPL_N_8(x, d)d()  DL_CAT(x,9)
#define DL_REPEAT_IMPL_N_10(x, d) DL_REPEAT_IMPL_N_9(x, d)d()  DL_CAT(x,10)
#define DL_REPEAT_IMPL_N_11(x, d) DL_REPEAT_IMPL_N_10(x, d)d()  DL_CAT(x,11)
#define DL_REPEAT_IMPL_N_12(x, d) DL_REPEAT_IMPL_N_11(x, d)d()  DL_CAT(x,12)
#define DL_REPEAT_IMPL_N_13(x, d) DL_REPEAT_IMPL_N_12(x, d)d()  DL_CAT(x,13)
#define DL_REPEAT_IMPL_N_14(x, d) DL_REPEAT_IMPL_N_13(x, d)d()  DL_CAT(x,14)
#define DL_REPEAT_IMPL_N_15(x, d) DL_REPEAT_IMPL_N_14(x, d)d()  DL_CAT(x,15)
#define DL_REPEAT_IMPL_N_16(x, d) DL_REPEAT_IMPL_N_15(x, d)d()  DL_CAT(x,16)

#define DL_REPEAT_IMPL_N(n, x, d) DL_CAT(DL_REPEAT_IMPL_N_,n)(x, d)

#define DL_REPEAT_N(n,x) DL_REPEAT_IMPL_N(n, x, DL_COMMA)

// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_IMPL_N0(n, m, d1, d2)
#define DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2) DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2)d1() DL_CAT(n,2)d2() DL_CAT(m,2)
#define DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2)d1() DL_CAT(n,3)d2() DL_CAT(m,3)
#define DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2)d1() DL_CAT(n,4)d2() DL_CAT(m,4)
#define DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2)d1() DL_CAT(n,5)d2() DL_CAT(m,5)
#define DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2)d1() DL_CAT(n,6)d2() DL_CAT(m,6)
#define DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2)d1() DL_CAT(n,7)d2() DL_CAT(m,7)
#define DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2)d1() DL_CAT(n,8)d2() DL_CAT(m,8)
#define DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2)d1() DL_CAT(n,9)d2() DL_CAT(m,9)
#define DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2)d1() DL_CAT(n,10)d2() DL_CAT(m,10)
#define DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2)d1() DL_CAT(n,11)d2() DL_CAT(m,11)
#define DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2)d1() DL_CAT(n,12)d2() DL_CAT(m,12)
#define DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2)d1() DL_CAT(n,13)d2() DL_CAT(m,13)
#define DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2)d1() DL_CAT(n,14)d2() DL_CAT(m,14)
#define DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2)d1() DL_CAT(n,15)d2() DL_CAT(m,15)
#define DL_REPEAT_PARAM_IMPL_N16(n,m, d1, d2) DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2)d1() DL_CAT(n,16)d2() DL_CAT(m,16)

#define DL_REPEAT_PARAM_IMPL_N(c, n, m, d1, d2) DL_CAT(DL_REPEAT_PARAM_IMPL_N,c)(n, m, d1, d2)

#define DL_REPEAT_PARAM_N(c, n, m) DL_REPEAT_PARAM_IMPL_N(c, n, m, DL_COMMA, DL_EMPTY)

// DL_REPEAT_DEF_IMPL_N
#define DL_REPEAT_DEF_IMPL_N0(n, def, d)
#define DL_REPEAT_DEF_IMPL_N1(n, def, d) DL_CAT(DL_CAT(n,1), def)
#define DL_REPEAT_DEF_IMPL_N2(n, def, d) DL_REPEAT_DEF_IMPL_N1(n, def, d)d() DL_CAT(DL_CAT(n,2), def)
#define DL_REPEAT_DEF_IMPL_N3(n, def, d) DL_REPEAT_DEF_IMPL_N2(n, def, d)d() DL_CAT(DL_CAT(n,3), def)
#define DL_REPEAT_DEF_IMPL_N4(n, def, d) DL_REPEAT_DEF_IMPL_N3(n, def, d)d() DL_CAT(DL_CAT(n,4), def)
#define DL_REPEAT_DEF_IMPL_N5(n, def, d) DL_REPEAT_DEF_IMPL_N4(n, def, d)d() DL_CAT(DL_CAT(n,5), def)
#define DL_REPEAT_DEF_IMPL_N6(n, def, d) DL_REPEAT_DEF_IMPL_N5(n, def, d)d() DL_CAT(DL_CAT(n,6), def)
#define DL_REPEAT_DEF_IMPL_N7(n, def, d) DL_REPEAT_DEF_IMPL_N6(n, def, d)d() DL_CAT(DL_CAT(n,7), def)
#define DL_REPEAT_DEF_IMPL_N8(n, def, d) DL_REPEAT_DEF_IMPL_N7(n, def, d)d() DL_CAT(DL_CAT(n,8), def)
#define DL_REPEAT_DEF_IMPL_N9(n, def, d) DL_REPEAT_DEF_IMPL_N8(n, def, d)d() DL_CAT(DL_CAT(n,9), def)
#define DL_REPEAT_DEF_IMPL_N10(n, def, d) DL_REPEAT_DEF_IMPL_N9(n, def, d)d() DL_CAT(DL_CAT(n,10), def)
#define DL_REPEAT_DEF_IMPL_N11(n, def, d) DL_REPEAT_DEF_IMPL_N10(n, def, d)d() DL_CAT(DL_CAT(n,11), def)
#define DL_REPEAT_DEF_IMPL_N12(n, def, d) DL_REPEAT_DEF_IMPL_N11(n, def, d)d() DL_CAT(DL_CAT(n,12), def)
#define DL_REPEAT_DEF_IMPL_N13(n, def, d) DL_REPEAT_DEF_IMPL_N12(n, def, d)d() DL_CAT(DL_CAT(n,13), def)
#define DL_REPEAT_DEF_IMPL_N14(n, def, d) DL_REPEAT_DEF_IMPL_N13(n, def, d)d() DL_CAT(DL_CAT(n,14), def)
#define DL_REPEAT_DEF_IMPL_N15(n, def, d) DL_REPEAT_DEF_IMPL_N14(n, def, d)d() DL_CAT(DL_CAT(n,15), def)
#define DL_REPEAT_DEF_IMPL_N16(n, def, d) DL_REPEAT_DEF_IMPL_N15(n, def, d)d() DL_CAT(DL_CAT(n,16), def)

#define DL_REPEAT_DEF_IMPL_N(c, n, def, d) DL_CAT(DL_REPEAT_DEF_IMPL_N,c)(n, def, d)

#define DL_REPEAT_DEF_N(c, n, def) DL_REPEAT_DEF_IMPL_N(c, n, def, DL_COMMA)

// DL_REPEAT_MACRO_N

#define DL_REPEAT_MACRO_IMPL_N0(m, p, d)
#define DL_REPEAT_MACRO_IMPL_N1(m, p, d) m(p,1)
#define DL_REPEAT_MACRO_IMPL_N2(m, p, d) DL_REPEAT_MACRO_IMPL_N1(m, p, d)d() m(p,2)
#define DL_REPEAT_MACRO_IMPL_N3(m, p, d) DL_REPEAT_MACRO_IMPL_N2(m, p, d)d() m(p,3)
#define DL_REPEAT_MACRO_IMPL_N4(m, p, d) DL_REPEAT_MACRO_IMPL_N3(m, p, d)d() m(p,4)
#define DL_REPEAT_MACRO_IMPL_N5(m, p, d) DL_REPEAT_MACRO_IMPL_N4(m, p, d)d() m(p,5)
#define DL_REPEAT_MACRO_IMPL_N6(m, p, d) DL_REPEAT_MACRO_IMPL_N5(m, p, d)d() m(p,6)
#define DL_REPEAT_MACRO_IMPL_N7(m, p, d) DL_REPEAT_MACRO_IMPL_N6(m, p, d)d() m(p,7)
#define DL_REPEAT_MACRO_IMPL_N8(m, p, d) DL_REPEAT_MACRO_IMPL_N7(m, p, d)d() m(p,8)
#define DL_REPEAT_MACRO_IMPL_N9(m, p, d) DL_REPEAT_MACRO_IMPL_N8(m, p, d)d() m(p,9)
#define DL_REPEAT_MACRO_IMPL_N10(m, p, d) DL_REPEAT_MACRO_IMPL_N9(m, p, d)d() m(p,10)
#define DL_REPEAT_MACRO_IMPL_N11(m, p, d) DL_REPEAT_MACRO_IMPL_N10(m, p, d)d() m(p,11)
#define DL_REPEAT_MACRO_IMPL_N12(m, p, d) DL_REPEAT_MACRO_IMPL_N11(m, p, d)d() m(p,12)
#define DL_REPEAT_MACRO_IMPL_N13(m, p, d) DL_REPEAT_MACRO_IMPL_N12(m, p, d)d() m(p,13)
#define DL_REPEAT_MACRO_IMPL_N14(m, p, d) DL_REPEAT_MACRO_IMPL_N13(m, p, d)d() m(p,14)
#define DL_REPEAT_MACRO_IMPL_N15(m, p, d) DL_REPEAT_MACRO_IMPL_N14(m, p, d)d() m(p,15)
#define DL_REPEAT_MACRO_IMPL_N16(m, p, d) DL_REPEAT_MACRO_IMPL_N15(m, p, d)d() m(p,16)

#define DL_REPEAT_MACRO_IMPL_N(c, m, p, d) DL_CAT(DL_REPEAT_MACRO_IMPL_N,c)(m,p, d)
#define DL_REPEAT_MACRO_N(c, m, p) DL_REPEAT_MACRO_IMPL_N(c, m, p, DL_COMMA)

#define DL_SEQ_SIZE(seq) DL_SEQ_SIZE_IMPL(seq)
#define DL_SEQ_SIZE_IMPL(seq) DL_CAT(DL_N_, DL_SEQ_SIZE_0 seq)

#define DL_SEQ_SIZE_0(_) DL_SEQ_SIZE_1
#define DL_SEQ_SIZE_1(_) DL_SEQ_SIZE_2
#define DL_SEQ_SIZE_2(_) DL_SEQ_SIZE_3
#define DL_SEQ_SIZE_3(_) DL_SEQ_SIZE_4
#define DL_SEQ_SIZE_4(_) DL_SEQ_SIZE_5
#define DL_SEQ_SIZE_5(_) DL_SEQ_SIZE_6
#define DL_SEQ_SIZE_6(_) DL_SEQ_SIZE_7
#define DL_SEQ_SIZE_7(_) DL_SEQ_SIZE_8
#define DL_SEQ_SIZE_8(_) DL_SEQ_SIZE_9
#define DL_SEQ_SIZE_9(_) DL_SEQ_SIZE_10
#define DL_SEQ_SIZE_10(_) DL_SEQ_SIZE_11
#define DL_SEQ_SIZE_11(_) DL_SEQ_SIZE_12
#define DL_SEQ_SIZE_12(_) DL_SEQ_SIZE_13
#define DL_SEQ_SIZE_13(_) DL_SEQ_SIZE_14
#define DL_SEQ_SIZE_14(_) DL_SEQ_SIZE_15
#define DL_SEQ_SIZE_15(_) DL_SEQ_SIZE_16

#define DL_N_DL_SEQ_SIZE_0 0
#define DL_N_DL_SEQ_SIZE_1 1
#define DL_N_DL_SEQ_SIZE_2 2
#define DL_N_DL_SEQ_SIZE_3 3
#define DL_N_DL_SEQ_SIZE_4 4
#define DL_N_DL_SEQ_SIZE_5 5
#define DL_N_DL_SEQ_SIZE_6 6
#define DL_N_DL_SEQ_SIZE_7 7
#define DL_N_DL_SEQ_SIZE_8 8
#define DL_N_DL_SEQ_SIZE_9 9
#define DL_N_DL_SEQ_SIZE_10 10
#define DL_N_DL_SEQ_SIZE_11 11
#define DL_N_DL_SEQ_SIZE_12 12
#define DL_N_DL_SEQ_SIZE_13 13
#define DL_N_DL_SEQ_SIZE_14 14
#define DL_N_DL_SEQ_SIZE_15 15
#define DL_N_DL_SEQ_SIZE_16 16


#define DL_SEQ_ENUM(seq) DL_SEQ_ENUM_IMPL(seq)
#define DL_SEQ_ENUM_IMPL(seq) DL_CAT(DL_SEQ_ENUM_, DL_SEQ_SIZE(seq)) seq

#define DL_MAKE_CHAR_(x) #@x
#define DL_MAKE_CHAR(x) DL_MAKE_CHAR_(x)

#define    DL_SEQ_ENUM_1(x) DL_MAKE_CHAR(x)
#define    DL_SEQ_ENUM_2(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_1
#define    DL_SEQ_ENUM_3(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_2
#define    DL_SEQ_ENUM_4(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_3
#define    DL_SEQ_ENUM_5(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_4
#define    DL_SEQ_ENUM_6(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_5
#define    DL_SEQ_ENUM_7(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_6
#define    DL_SEQ_ENUM_8(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_7
#define    DL_SEQ_ENUM_9(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_8
#define    DL_SEQ_ENUM_10(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_9
#define    DL_SEQ_ENUM_11(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_10
#define    DL_SEQ_ENUM_12(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_11
#define    DL_SEQ_ENUM_13(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_12
#define    DL_SEQ_ENUM_14(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_13
#define    DL_SEQ_ENUM_15(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_14
#define    DL_SEQ_ENUM_16(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_15


#define FLATTEN_STR3(val) (((val) > 0xFFFFFF) ? (val) : 0)
#define FLATTEN_STR2(val) (((val) > 0xFFFFFF) ? (val) : FLATTEN_STR3(val << 8))
#define FLATTEN_STR1(val) (((val) > 0xFFFFFF) ? (val) : FLATTEN_STR2(val << 8))
#define FLATTEN_STR0(val) (((val) > 0xFFFFFF) ? (val) : FLATTEN_STR1(val << 8))

#define FLATTEN_STR_(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))

#define FLATTEN_STR(val, num) FLATTEN_STR_(FLATTEN_STR0(DL_CAT(val, num)))

#pragma warning (disable: 4786)

template <int count>
struct CNameIdHolder
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                DL_REPEAT_MACRO_N(MAX_DL_REPEAT, FLATTEN_STR, n),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

#define NAME_ID_HOLDER_SPEC(num)\
template <>\
struct CNameIdHolder<num>\
{\
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>\
    struct CNameIdHolderImpl\
    {\
        static LPCTSTR GetStr()\
        {\
            static const TCHAR szBuffer[] = {\
                                                DL_REPEAT_MACRO_N(num, FLATTEN_STR, n),\
                                                _T('\0')\
                                            };\
            return szBuffer;\
        }\
    };\
};

NAME_ID_HOLDER_SPEC(15)
NAME_ID_HOLDER_SPEC(14)
NAME_ID_HOLDER_SPEC(13)
NAME_ID_HOLDER_SPEC(12)
NAME_ID_HOLDER_SPEC(11)
NAME_ID_HOLDER_SPEC(10)
NAME_ID_HOLDER_SPEC(9)
NAME_ID_HOLDER_SPEC(8)
NAME_ID_HOLDER_SPEC(7)
NAME_ID_HOLDER_SPEC(6)
NAME_ID_HOLDER_SPEC(5)
NAME_ID_HOLDER_SPEC(4)
NAME_ID_HOLDER_SPEC(3)
NAME_ID_HOLDER_SPEC(2)
NAME_ID_HOLDER_SPEC(1)

template <>
struct CNameIdHolder<0>
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            return NULL;
        }
    };
};

#define NN_REP_COUNT_M(p, n) (!DL_CAT(p,n)) ? (n-1):

template <DL_REPEAT_DEF_N(MAX_DL_REPEAT, DWORD n, = 0)>
struct CNameId
{
    enum
    {
        DL_REPEAT_PARAM_N(MAX_DL_REPEAT, m_n, =n),
        count   = DL_REPEAT_MACRO_IMPL_N(MAX_DL_REPEAT, NN_REP_COUNT_M, n, DL_EMPTY) MAX_DL_REPEAT,
        length  = count * sizeof(DWORD)
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::template CNameIdHolderImpl<DL_REPEAT_N(MAX_DL_REPEAT, n)>::GetStr();
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::template Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};



struct CDynFunException
{
    CDynFunException(): m_sMessage(NULL)
    {
    };
    ~CDynFunException()
    {
        free(m_sMessage);
    };
    CDynFunException(LPCTSTR sMessage):m_sMessage(NULL)
    {
        SetMessage(sMessage);
    }
    CDynFunException(const CDynFunException &other):m_sMessage(NULL)
    {
        SetMessage(other.m_sMessage);
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.m_sMessage);
        return *this;
    }
    void SetMessage(LPCTSTR sMessage)
    {
        free(m_sMessage);
        m_sMessage = (LPTSTR)malloc((_tcslen(sMessage) + 1) * sizeof(TCHAR));
        if (m_sMessage)
            _tcscpy(m_sMessage, sMessage);
    }
    LPCTSTR GetMessage() const
    {
        return m_sMessage;
    }
private:
    LPTSTR m_sMessage;
};

template <class R> struct FunProxyThrowRetTypeTrait
{
    template <class F>
    struct FunctionTraitImpl
    {
        static R MakeReturn()
        {
            F::MakeReturnImpl();
            return R();
        }
    };
};

template <> struct FunProxyThrowRetTypeTrait<void>
{
    template <class F>
    struct FunctionTraitImpl
    {
        static void MakeReturn()
        {
            F::MakeReturnImpl();
        }
    };
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct FunctionTrait:public FunProxyThrowRetTypeTrait<DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >
    {
        static void MakeReturnImpl()
        {
            TCHAR szMessage[DynFunction::name_type::length + 64];
            _stprintf(szMessage, _T("Can'n resolve procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(szMessage);
        }
    };
};


//  we need not implement void return type value policy, 
//  coz void function can only throw on error

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct FunctionTrait
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};


#define FUN_PROXY(n) DL_CAT(FunProxy,n)
#define FUN_PROXY_IMPL(n) DL_CAT(FUN_PROXY(n),Impl)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R> struct FUN_PROXY_IMPL(param_count)\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <> struct FUN_PROXY_IMPL(param_count) <void>\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            else\
                Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> > struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy:public FUN_PROXY_IMPL(param_count)<R>::template RetProxy<DynFunction, DL_REPEAT_N(param_count, P), Policy>\
    {\
    };\
};

DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's

#define USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId<DL_SEQ_ENUM(NameId)> > module_type;

#define USE_MODULE_END \
};



#define DECLARE_FUN_P1(Name, NameId, R, P1) \
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM(NameId)>, FUN_PROXY(1)<R, P1> >::GetProxy();


#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM(NameId)>, FUN_PROXY(1)<R, P1, FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM(NameId)>, FUN_PROXY(1)<R, P1, FunProxyThrowPolicy<> > >::GetProxy();

#endif

// DWORD
USE_MODULE_BEGIN(kernel, (kern)(el3)(3.dl)(l)) -> kernel3
// TCHAR
USE_MODULE_BEGIN(kernel, (k)(e)(r)(n)(e)(l)(3)(2)(.)(d)(l)(l) ) -> kernel32.dll

#define DECLARE_FUN(Name, NameId, R, P1, COMMA1, P2, COMMA2, P3, COMMA3, ...) \
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM(NameId)>, FUN_PROXY(1)<R, P1 COMMA1 P2 COMMA2 ...> >::GetProxy(); // повторение здесь можно через макрос оформить.

// до
DECLARE_FUN_P1(GetModuleHandle, (GetM)(odul)(eHan)(dleA), HMODULE, LPCTSTR)

// после
DECLARE_FUN(GetModuleHandle, (GetM)(odul)(eHan)(dleA), HMODULE, LPCTSTR, EMPTY, EMPTY ... )
// EMPTY.. можно тоже через макрос оформить - REPEAT_N((сколько надо),EMPTY)

DECLARE_FUN(GetModuleHandle, (GetM)(odul)(eHan)(dleA), HMODULE, LPCTSTR)
// будет много предупреждений, однако код сработает нормально

__>>Все же стоит заменить DWORD, на TCHAR, так нельзя будет ошибиться в написани, вдобавок читать приятней

#define DECLARE_FUN(name1,name2,name3....) \
 CAT(name1,CAT(name2,CAT(name3... ))) // ну или через макрос как-то

__>#define DECLARE_FUN(Name, NameId, R, P1, COMMA1, P2, COMMA2, P3, COMMA3, ...) \
__>static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM(NameId)>, FUN_PROXY(1)<R, P1 COMMA1 P2 COMMA2 ...> >::GetProxy(); // повторение здесь можно через макрос оформить.
__>

#define DECLARE_FUN(Name, NameId, R, P) \
static R (WINAPI *&Name)(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)> >::GetProxy();

USE_MODULE_BEGIN(kernel, (kern)(el32)(.dll))
    DECLARE_FUN(GetProcAddress, (GetP)(rocA)(ddre)(ss), FARPROC, (HMODULE)(LPCTSTR))
USE_MODULE_END

Изменены порождающие макросы. Теперь для задания функци с любым (DL_MAX_REPEAT) числом параметров используется один тип макросов — DL_DECLARE_FUN_XXX
Изменены названия порождающих макросов
Изменено количество параметров в макросах DL_DECLARE_FUN_XXX — теперь параметр Name убран за ненадобностью

Поддержка MT.
Поддержка соглашений о вызовах кроме __stdcall.
Поддержка функций с переменным числом параметров.
Что то еще?

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define MAX_DL_REPEAT 16
#define DL_COMMA() ,
#define DL_EMPTY() 

// DL_REPEAT_N
#define DL_REPEAT_IMPL_N_0(x, d) 
#define DL_REPEAT_IMPL_N_1(x, d) DL_CAT(x,1)
#define DL_REPEAT_IMPL_N_2(x, d) DL_REPEAT_IMPL_N_1(x, d)d()  DL_CAT(x,2)
#define DL_REPEAT_IMPL_N_3(x, d) DL_REPEAT_IMPL_N_2(x, d)d()  DL_CAT(x,3)
#define DL_REPEAT_IMPL_N_4(x, d) DL_REPEAT_IMPL_N_3(x, d)d()  DL_CAT(x,4)
#define DL_REPEAT_IMPL_N_5(x, d) DL_REPEAT_IMPL_N_4(x, d)d()  DL_CAT(x,5)
#define DL_REPEAT_IMPL_N_6(x, d) DL_REPEAT_IMPL_N_5(x, d)d()  DL_CAT(x,6)
#define DL_REPEAT_IMPL_N_7(x, d) DL_REPEAT_IMPL_N_6(x, d)d()  DL_CAT(x,7)
#define DL_REPEAT_IMPL_N_8(x, d) DL_REPEAT_IMPL_N_7(x, d)d()  DL_CAT(x,8)
#define DL_REPEAT_IMPL_N_9(x, d) DL_REPEAT_IMPL_N_8(x, d)d()  DL_CAT(x,9)
#define DL_REPEAT_IMPL_N_10(x, d) DL_REPEAT_IMPL_N_9(x, d)d()  DL_CAT(x,10)
#define DL_REPEAT_IMPL_N_11(x, d) DL_REPEAT_IMPL_N_10(x, d)d()  DL_CAT(x,11)
#define DL_REPEAT_IMPL_N_12(x, d) DL_REPEAT_IMPL_N_11(x, d)d()  DL_CAT(x,12)
#define DL_REPEAT_IMPL_N_13(x, d) DL_REPEAT_IMPL_N_12(x, d)d()  DL_CAT(x,13)
#define DL_REPEAT_IMPL_N_14(x, d) DL_REPEAT_IMPL_N_13(x, d)d()  DL_CAT(x,14)
#define DL_REPEAT_IMPL_N_15(x, d) DL_REPEAT_IMPL_N_14(x, d)d()  DL_CAT(x,15)
#define DL_REPEAT_IMPL_N_16(x, d) DL_REPEAT_IMPL_N_15(x, d)d()  DL_CAT(x,16)

#define DL_REPEAT_IMPL_N(n, x, d) DL_CAT(DL_REPEAT_IMPL_N_,n)(x, d)

#define DL_REPEAT_N(n,x) DL_REPEAT_IMPL_N(n, x, DL_COMMA)

// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_IMPL_N0(n, m, d1, d2)
#define DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2) DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N1(n, m, d1, d2)d1() DL_CAT(n,2)d2() DL_CAT(m,2)
#define DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N2(n, m, d1, d2)d1() DL_CAT(n,3)d2() DL_CAT(m,3)
#define DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N3(n, m, d1, d2)d1() DL_CAT(n,4)d2() DL_CAT(m,4)
#define DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N4(n, m, d1, d2)d1() DL_CAT(n,5)d2() DL_CAT(m,5)
#define DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N5(n, m, d1, d2)d1() DL_CAT(n,6)d2() DL_CAT(m,6)
#define DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N6(n, m, d1, d2)d1() DL_CAT(n,7)d2() DL_CAT(m,7)
#define DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N7(n, m, d1, d2)d1() DL_CAT(n,8)d2() DL_CAT(m,8)
#define DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N8(n, m, d1, d2)d1() DL_CAT(n,9)d2() DL_CAT(m,9)
#define DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N9(n, m, d1, d2)d1() DL_CAT(n,10)d2() DL_CAT(m,10)
#define DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N10(n, m, d1, d2)d1() DL_CAT(n,11)d2() DL_CAT(m,11)
#define DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N11(n, m, d1, d2)d1() DL_CAT(n,12)d2() DL_CAT(m,12)
#define DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N12(n, m, d1, d2)d1() DL_CAT(n,13)d2() DL_CAT(m,13)
#define DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N13(n, m, d1, d2)d1() DL_CAT(n,14)d2() DL_CAT(m,14)
#define DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2) DL_REPEAT_PARAM_IMPL_N14(n, m, d1, d2)d1() DL_CAT(n,15)d2() DL_CAT(m,15)
#define DL_REPEAT_PARAM_IMPL_N16(n,m, d1, d2) DL_REPEAT_PARAM_IMPL_N15(n, m, d1, d2)d1() DL_CAT(n,16)d2() DL_CAT(m,16)

#define DL_REPEAT_PARAM_IMPL_N(c, n, m, d1, d2) DL_CAT(DL_REPEAT_PARAM_IMPL_N,c)(n, m, d1, d2)

#define DL_REPEAT_PARAM_N(c, n, m) DL_REPEAT_PARAM_IMPL_N(c, n, m, DL_COMMA, DL_EMPTY)

// DL_REPEAT_DEF_IMPL_N
#define DL_REPEAT_DEF_IMPL_N0(n, def, d)
#define DL_REPEAT_DEF_IMPL_N1(n, def, d) DL_CAT(DL_CAT(n,1), def)
#define DL_REPEAT_DEF_IMPL_N2(n, def, d) DL_REPEAT_DEF_IMPL_N1(n, def, d)d() DL_CAT(DL_CAT(n,2), def)
#define DL_REPEAT_DEF_IMPL_N3(n, def, d) DL_REPEAT_DEF_IMPL_N2(n, def, d)d() DL_CAT(DL_CAT(n,3), def)
#define DL_REPEAT_DEF_IMPL_N4(n, def, d) DL_REPEAT_DEF_IMPL_N3(n, def, d)d() DL_CAT(DL_CAT(n,4), def)
#define DL_REPEAT_DEF_IMPL_N5(n, def, d) DL_REPEAT_DEF_IMPL_N4(n, def, d)d() DL_CAT(DL_CAT(n,5), def)
#define DL_REPEAT_DEF_IMPL_N6(n, def, d) DL_REPEAT_DEF_IMPL_N5(n, def, d)d() DL_CAT(DL_CAT(n,6), def)
#define DL_REPEAT_DEF_IMPL_N7(n, def, d) DL_REPEAT_DEF_IMPL_N6(n, def, d)d() DL_CAT(DL_CAT(n,7), def)
#define DL_REPEAT_DEF_IMPL_N8(n, def, d) DL_REPEAT_DEF_IMPL_N7(n, def, d)d() DL_CAT(DL_CAT(n,8), def)
#define DL_REPEAT_DEF_IMPL_N9(n, def, d) DL_REPEAT_DEF_IMPL_N8(n, def, d)d() DL_CAT(DL_CAT(n,9), def)
#define DL_REPEAT_DEF_IMPL_N10(n, def, d) DL_REPEAT_DEF_IMPL_N9(n, def, d)d() DL_CAT(DL_CAT(n,10), def)
#define DL_REPEAT_DEF_IMPL_N11(n, def, d) DL_REPEAT_DEF_IMPL_N10(n, def, d)d() DL_CAT(DL_CAT(n,11), def)
#define DL_REPEAT_DEF_IMPL_N12(n, def, d) DL_REPEAT_DEF_IMPL_N11(n, def, d)d() DL_CAT(DL_CAT(n,12), def)
#define DL_REPEAT_DEF_IMPL_N13(n, def, d) DL_REPEAT_DEF_IMPL_N12(n, def, d)d() DL_CAT(DL_CAT(n,13), def)
#define DL_REPEAT_DEF_IMPL_N14(n, def, d) DL_REPEAT_DEF_IMPL_N13(n, def, d)d() DL_CAT(DL_CAT(n,14), def)
#define DL_REPEAT_DEF_IMPL_N15(n, def, d) DL_REPEAT_DEF_IMPL_N14(n, def, d)d() DL_CAT(DL_CAT(n,15), def)
#define DL_REPEAT_DEF_IMPL_N16(n, def, d) DL_REPEAT_DEF_IMPL_N15(n, def, d)d() DL_CAT(DL_CAT(n,16), def)

#define DL_REPEAT_DEF_IMPL_N(c, n, def, d) DL_CAT(DL_REPEAT_DEF_IMPL_N,c)(n, def, d)

#define DL_REPEAT_DEF_N(c, n, def) DL_REPEAT_DEF_IMPL_N(c, n, def, DL_COMMA)

// DL_REPEAT_MACRO_N

#define DL_REPEAT_MACRO_IMPL_N0(m, p, d)
#define DL_REPEAT_MACRO_IMPL_N1(m, p, d) m(p,1)
#define DL_REPEAT_MACRO_IMPL_N2(m, p, d) DL_REPEAT_MACRO_IMPL_N1(m, p, d)d() m(p,2)
#define DL_REPEAT_MACRO_IMPL_N3(m, p, d) DL_REPEAT_MACRO_IMPL_N2(m, p, d)d() m(p,3)
#define DL_REPEAT_MACRO_IMPL_N4(m, p, d) DL_REPEAT_MACRO_IMPL_N3(m, p, d)d() m(p,4)
#define DL_REPEAT_MACRO_IMPL_N5(m, p, d) DL_REPEAT_MACRO_IMPL_N4(m, p, d)d() m(p,5)
#define DL_REPEAT_MACRO_IMPL_N6(m, p, d) DL_REPEAT_MACRO_IMPL_N5(m, p, d)d() m(p,6)
#define DL_REPEAT_MACRO_IMPL_N7(m, p, d) DL_REPEAT_MACRO_IMPL_N6(m, p, d)d() m(p,7)
#define DL_REPEAT_MACRO_IMPL_N8(m, p, d) DL_REPEAT_MACRO_IMPL_N7(m, p, d)d() m(p,8)
#define DL_REPEAT_MACRO_IMPL_N9(m, p, d) DL_REPEAT_MACRO_IMPL_N8(m, p, d)d() m(p,9)
#define DL_REPEAT_MACRO_IMPL_N10(m, p, d) DL_REPEAT_MACRO_IMPL_N9(m, p, d)d() m(p,10)
#define DL_REPEAT_MACRO_IMPL_N11(m, p, d) DL_REPEAT_MACRO_IMPL_N10(m, p, d)d() m(p,11)
#define DL_REPEAT_MACRO_IMPL_N12(m, p, d) DL_REPEAT_MACRO_IMPL_N11(m, p, d)d() m(p,12)
#define DL_REPEAT_MACRO_IMPL_N13(m, p, d) DL_REPEAT_MACRO_IMPL_N12(m, p, d)d() m(p,13)
#define DL_REPEAT_MACRO_IMPL_N14(m, p, d) DL_REPEAT_MACRO_IMPL_N13(m, p, d)d() m(p,14)
#define DL_REPEAT_MACRO_IMPL_N15(m, p, d) DL_REPEAT_MACRO_IMPL_N14(m, p, d)d() m(p,15)
#define DL_REPEAT_MACRO_IMPL_N16(m, p, d) DL_REPEAT_MACRO_IMPL_N15(m, p, d)d() m(p,16)

#define DL_REPEAT_MACRO_IMPL_N(c, m, p, d) DL_CAT(DL_REPEAT_MACRO_IMPL_N,c)(m,p, d)
#define DL_REPEAT_MACRO_N(c, m, p) DL_REPEAT_MACRO_IMPL_N(c, m, p, DL_COMMA)

// DL_SEQ_SIZE

#define DL_SEQ_SIZE(seq) DL_SEQ_SIZE_IMPL(seq)
#define DL_SEQ_SIZE_IMPL(seq) DL_CAT(DL_N_, DL_SEQ_SIZE_0 seq)

#define DL_SEQ_SIZE_0(_) DL_SEQ_SIZE_1
#define DL_SEQ_SIZE_1(_) DL_SEQ_SIZE_2
#define DL_SEQ_SIZE_2(_) DL_SEQ_SIZE_3
#define DL_SEQ_SIZE_3(_) DL_SEQ_SIZE_4
#define DL_SEQ_SIZE_4(_) DL_SEQ_SIZE_5
#define DL_SEQ_SIZE_5(_) DL_SEQ_SIZE_6
#define DL_SEQ_SIZE_6(_) DL_SEQ_SIZE_7
#define DL_SEQ_SIZE_7(_) DL_SEQ_SIZE_8
#define DL_SEQ_SIZE_8(_) DL_SEQ_SIZE_9
#define DL_SEQ_SIZE_9(_) DL_SEQ_SIZE_10
#define DL_SEQ_SIZE_10(_) DL_SEQ_SIZE_11
#define DL_SEQ_SIZE_11(_) DL_SEQ_SIZE_12
#define DL_SEQ_SIZE_12(_) DL_SEQ_SIZE_13
#define DL_SEQ_SIZE_13(_) DL_SEQ_SIZE_14
#define DL_SEQ_SIZE_14(_) DL_SEQ_SIZE_15
#define DL_SEQ_SIZE_15(_) DL_SEQ_SIZE_16

#define DL_N_DL_SEQ_SIZE_0 0
#define DL_N_DL_SEQ_SIZE_1 1
#define DL_N_DL_SEQ_SIZE_2 2
#define DL_N_DL_SEQ_SIZE_3 3
#define DL_N_DL_SEQ_SIZE_4 4
#define DL_N_DL_SEQ_SIZE_5 5
#define DL_N_DL_SEQ_SIZE_6 6
#define DL_N_DL_SEQ_SIZE_7 7
#define DL_N_DL_SEQ_SIZE_8 8
#define DL_N_DL_SEQ_SIZE_9 9
#define DL_N_DL_SEQ_SIZE_10 10
#define DL_N_DL_SEQ_SIZE_11 11
#define DL_N_DL_SEQ_SIZE_12 12
#define DL_N_DL_SEQ_SIZE_13 13
#define DL_N_DL_SEQ_SIZE_14 14
#define DL_N_DL_SEQ_SIZE_15 15
#define DL_N_DL_SEQ_SIZE_16 16

// DL_SEQ_ENUM

#define DL_SEQ_ENUM(seq) DL_SEQ_ENUM_IMPL(seq)
#define DL_SEQ_ENUM_IMPL(seq) DL_CAT(DL_SEQ_ENUM_, DL_SEQ_SIZE(seq)) seq

#define    DL_SEQ_ENUM_1(x) x
#define    DL_SEQ_ENUM_2(x) x, DL_SEQ_ENUM_1
#define    DL_SEQ_ENUM_3(x) x, DL_SEQ_ENUM_2
#define    DL_SEQ_ENUM_4(x) x, DL_SEQ_ENUM_3
#define    DL_SEQ_ENUM_5(x) x, DL_SEQ_ENUM_4
#define    DL_SEQ_ENUM_6(x) x, DL_SEQ_ENUM_5
#define    DL_SEQ_ENUM_7(x) x, DL_SEQ_ENUM_6
#define    DL_SEQ_ENUM_8(x) x, DL_SEQ_ENUM_7
#define    DL_SEQ_ENUM_9(x) x, DL_SEQ_ENUM_8
#define    DL_SEQ_ENUM_10(x) x, DL_SEQ_ENUM_9
#define    DL_SEQ_ENUM_11(x) x, DL_SEQ_ENUM_10
#define    DL_SEQ_ENUM_12(x) x, DL_SEQ_ENUM_11
#define    DL_SEQ_ENUM_13(x) x, DL_SEQ_ENUM_12
#define    DL_SEQ_ENUM_14(x) x, DL_SEQ_ENUM_13
#define    DL_SEQ_ENUM_15(x) x, DL_SEQ_ENUM_14
#define    DL_SEQ_ENUM_16(x) x, DL_SEQ_ENUM_15

// DL_SEQ_ENUM_CHAR

#define DL_SEQ_ENUM_CHAR(seq) DL_SEQ_ENUM_CHAR_IMPL(seq)
#define DL_SEQ_ENUM_CHAR_IMPL(seq) DL_CAT(DL_SEQ_ENUM_CHAR_, DL_SEQ_SIZE(seq)) seq

#define DL_MAKE_CHAR_(x) #@x
#define DL_MAKE_CHAR(x) DL_MAKE_CHAR_(x)

#define    DL_SEQ_ENUM_CHAR_1(x) DL_MAKE_CHAR(x)
#define    DL_SEQ_ENUM_CHAR_2(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_1
#define    DL_SEQ_ENUM_CHAR_3(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_2
#define    DL_SEQ_ENUM_CHAR_4(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_3
#define    DL_SEQ_ENUM_CHAR_5(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_4
#define    DL_SEQ_ENUM_CHAR_6(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_5
#define    DL_SEQ_ENUM_CHAR_7(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_6
#define    DL_SEQ_ENUM_CHAR_8(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_7
#define    DL_SEQ_ENUM_CHAR_9(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_8
#define    DL_SEQ_ENUM_CHAR_10(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_9
#define    DL_SEQ_ENUM_CHAR_11(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_10
#define    DL_SEQ_ENUM_CHAR_12(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_11
#define    DL_SEQ_ENUM_CHAR_13(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_12
#define    DL_SEQ_ENUM_CHAR_14(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_13
#define    DL_SEQ_ENUM_CHAR_15(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_14
#define    DL_SEQ_ENUM_CHAR_16(x) DL_MAKE_CHAR(x), DL_SEQ_ENUM_CHAR_15

// DL_SEQ_ELEM

#define DL_SEQ_ELEM(i, seq) DL_SEQ_ELEM_IMPL(i, seq)
#define DL_SEQ_ELEM_IMPL(i, seq) DL_SEQ_ELEM_IMPL2((DL_CAT(DL_SEQ_ELEM_, i) seq))
#define DL_SEQ_ELEM_IMPL2(par) DL_SEQ_ELEM_IMPL3(DL_SEQ_ELEM_IMPL1 par)
#define DL_SEQ_ELEM_IMPL3(par) par
#define DL_SEQ_ELEM_IMPL1(x, _) x

#define    DL_SEQ_ELEM_0(x) x, DL_ELEM_NIL
#define    DL_SEQ_ELEM_1(_)  DL_SEQ_ELEM_0
#define    DL_SEQ_ELEM_2(_)  DL_SEQ_ELEM_1
#define    DL_SEQ_ELEM_3(_)  DL_SEQ_ELEM_2
#define    DL_SEQ_ELEM_4(_)  DL_SEQ_ELEM_3
#define    DL_SEQ_ELEM_5(_)  DL_SEQ_ELEM_4
#define    DL_SEQ_ELEM_6(_)  DL_SEQ_ELEM_5
#define    DL_SEQ_ELEM_7(_)  DL_SEQ_ELEM_6
#define    DL_SEQ_ELEM_8(_)  DL_SEQ_ELEM_7
#define    DL_SEQ_ELEM_9(_)  DL_SEQ_ELEM_8
#define    DL_SEQ_ELEM_10(_)  DL_SEQ_ELEM_9
#define    DL_SEQ_ELEM_11(_)  DL_SEQ_ELEM_10
#define    DL_SEQ_ELEM_12(_)  DL_SEQ_ELEM_11
#define    DL_SEQ_ELEM_13(_)  DL_SEQ_ELEM_12
#define    DL_SEQ_ELEM_14(_)  DL_SEQ_ELEM_13
#define    DL_SEQ_ELEM_15(_)  DL_SEQ_ELEM_14
#define    DL_SEQ_ELEM_16(_)  DL_SEQ_ELEM_15

#define DL_SEQ_HEAD(seq) DL_SEQ_HEAD_IMPL(seq)
#define DL_SEQ_HEAD_IMPL(seq) DL_SEQ_ELEM(0, seq)

#define DL_SEQ_TAIL(seq) DL_SEQ_TAIL_IMPL(DL_SEQ_TAIL_IMPL1 seq)
#define DL_SEQ_TAIL_IMPL(seq) seq
#define DL_SEQ_TAIL_IMPL1(x)

// DL_SEQ_FOLD_LEFT

#define DL_SEQ_FOLD_LEFT(macro, state, seq) DL_SEQ_FOLD_LEFT_IMPL(macro, state, seq) 
#define DL_SEQ_FOLD_LEFT_IMPL(macro, state, seq) DL_CAT(DL_SEQ_FOLD_LEFT_, DL_SEQ_SIZE(seq))(macro, state, seq)

#define DL_SEQ_FOLD_LEFT_0(macro, state, seq) DL_EMPTY()
#define DL_SEQ_FOLD_LEFT_1(macro, state, seq) macro(state, DL_SEQ_ELEM(0, seq))
#define DL_SEQ_FOLD_LEFT_2(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,1)(macro, state, seq), DL_SEQ_ELEM(1, seq))
#define DL_SEQ_FOLD_LEFT_3(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,2)(macro, state, seq), DL_SEQ_ELEM(2, seq))
#define DL_SEQ_FOLD_LEFT_4(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,3)(macro, state, seq), DL_SEQ_ELEM(3, seq))
#define DL_SEQ_FOLD_LEFT_5(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,4)(macro, state, seq), DL_SEQ_ELEM(4, seq))
#define DL_SEQ_FOLD_LEFT_6(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,5)(macro, state, seq), DL_SEQ_ELEM(5, seq))
#define DL_SEQ_FOLD_LEFT_7(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,6)(macro, state, seq), DL_SEQ_ELEM(6, seq))
#define DL_SEQ_FOLD_LEFT_8(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,7)(macro, state, seq), DL_SEQ_ELEM(7, seq))
#define DL_SEQ_FOLD_LEFT_9(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,8)(macro, state, seq), DL_SEQ_ELEM(8, seq))
#define DL_SEQ_FOLD_LEFT_10(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,9)(macro, state, seq), DL_SEQ_ELEM(9, seq))
#define DL_SEQ_FOLD_LEFT_11(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,10)(macro, state, seq), DL_SEQ_ELEM(10, seq))
#define DL_SEQ_FOLD_LEFT_12(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,11)(macro, state, seq), DL_SEQ_ELEM(11, seq))
#define DL_SEQ_FOLD_LEFT_13(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,12)(macro, state, seq), DL_SEQ_ELEM(12, seq))
#define DL_SEQ_FOLD_LEFT_14(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,13)(macro, state, seq), DL_SEQ_ELEM(13, seq))
#define DL_SEQ_FOLD_LEFT_15(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,14)(macro, state, seq), DL_SEQ_ELEM(14, seq))
#define DL_SEQ_FOLD_LEFT_16(macro, state, seq) macro(DL_CAT(DL_SEQ_FOLD_LEFT_,15)(macro, state, seq), DL_SEQ_ELEM(15, seq))

// DL_SEQ_CAT

#define DL_SEQ_CAT(seq) DL_SEQ_CAT_IMPL(seq)
#define DL_SEQ_CAT_IMPL(seq) DL_SEQ_FOLD_LEFT(DL_CAT, DL_SEQ_HEAD(seq), DL_SEQ_TAIL(seq))

// DL_FLATTEN_STR

#define DL_FLATTEN_STR3(val) (((val) > 0xFFFFFF) ? (val) : 0)
#define DL_FLATTEN_STR2(val) (((val) > 0xFFFFFF) ? (val) : DL_FLATTEN_STR3(val << 8))
#define DL_FLATTEN_STR1(val) (((val) > 0xFFFFFF) ? (val) : DL_FLATTEN_STR2(val << 8))
#define DL_FLATTEN_STR0(val) (((val) > 0xFFFFFF) ? (val) : DL_FLATTEN_STR1(val << 8))

#define DL_FLATTEN_STR_(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))

#define DL_FLATTEN_STR(val, num) DL_FLATTEN_STR_(DL_FLATTEN_STR0(DL_CAT(val, num)))

#pragma warning (disable: 4786)

template <int count>
struct CNameIdHolder
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                DL_REPEAT_MACRO_N(MAX_DL_REPEAT, DL_FLATTEN_STR, n),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

#define NAME_ID_HOLDER_SPEC(num)\
template <>\
struct CNameIdHolder<num>\
{\
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>\
    struct CNameIdHolderImpl\
    {\
        static LPCTSTR GetStr()\
        {\
            static const TCHAR szBuffer[] = {\
                                                DL_REPEAT_MACRO_N(num, DL_FLATTEN_STR, n),\
                                                _T('\0')\
                                            };\
            return szBuffer;\
        }\
    };\
};

NAME_ID_HOLDER_SPEC(15)
NAME_ID_HOLDER_SPEC(14)
NAME_ID_HOLDER_SPEC(13)
NAME_ID_HOLDER_SPEC(12)
NAME_ID_HOLDER_SPEC(11)
NAME_ID_HOLDER_SPEC(10)
NAME_ID_HOLDER_SPEC(9)
NAME_ID_HOLDER_SPEC(8)
NAME_ID_HOLDER_SPEC(7)
NAME_ID_HOLDER_SPEC(6)
NAME_ID_HOLDER_SPEC(5)
NAME_ID_HOLDER_SPEC(4)
NAME_ID_HOLDER_SPEC(3)
NAME_ID_HOLDER_SPEC(2)
NAME_ID_HOLDER_SPEC(1)

template <>
struct CNameIdHolder<0>
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            return NULL;
        }
    };
};

#define NN_REP_COUNT_M(p, n) (!DL_CAT(p,n)) ? (n-1):

template <DL_REPEAT_DEF_N(MAX_DL_REPEAT, DWORD n, = 0)>
struct CNameId
{
    enum
    {
        DL_REPEAT_PARAM_N(MAX_DL_REPEAT, m_n, =n),
        count   = DL_REPEAT_MACRO_IMPL_N(MAX_DL_REPEAT, NN_REP_COUNT_M, n, DL_EMPTY) MAX_DL_REPEAT,
        length  = count * sizeof(DWORD)
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::template CNameIdHolderImpl<DL_REPEAT_N(MAX_DL_REPEAT, n)>::GetStr();
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::template Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};



struct CDynFunException
{
    CDynFunException(): m_sMessage(NULL)
    {
    };
    ~CDynFunException()
    {
        free(m_sMessage);
    };
    CDynFunException(LPCTSTR sMessage):m_sMessage(NULL)
    {
        SetMessage(sMessage);
    }
    CDynFunException(const CDynFunException &other):m_sMessage(NULL)
    {
        SetMessage(other.m_sMessage);
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.m_sMessage);
        return *this;
    }
    void SetMessage(LPCTSTR sMessage)
    {
        free(m_sMessage);
        m_sMessage = (LPTSTR)malloc((_tcslen(sMessage) + 1) * sizeof(TCHAR));
        if (m_sMessage)
            _tcscpy(m_sMessage, sMessage);
    }
    LPCTSTR GetMessage() const
    {
        return m_sMessage;
    }
private:
    LPTSTR m_sMessage;
};

template <class R> struct FunProxyThrowRetTypeTrait
{
    template <class F>
    struct FunctionTraitImpl
    {
        static R MakeReturn()
        {
            F::MakeReturnImpl();
            return R();
        }
    };
};

template <> struct FunProxyThrowRetTypeTrait<void>
{
    template <class F>
    struct FunctionTraitImpl
    {
        static void MakeReturn()
        {
            F::MakeReturnImpl();
        }
    };
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct FunctionTrait:public FunProxyThrowRetTypeTrait<DynFunction::proxy_type::ret_type>::template FunctionTraitImpl<FunctionTrait<DynFunction> >
    {
        static void MakeReturnImpl()
        {
            TCHAR szMessage[DynFunction::name_type::length + 64];
            _stprintf(szMessage, _T("Can'n resolve procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(szMessage);
        }
    };
};


//  we need not implement void return type value policy, 
//  coz void function can only throw on error

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct FunctionTrait
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};


#define FUN_PROXY(n) DL_CAT(FunProxy,n)
#define FUN_PROXY_IMPL(n) DL_CAT(FUN_PROXY(n),Impl)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R> struct FUN_PROXY_IMPL(param_count)\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <> struct FUN_PROXY_IMPL(param_count) <void>\
{\
    template <class DynFunction, DL_REPEAT_N(param_count, typename P), class Policy> struct RetProxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            else\
                Policy::template FunctionTrait<DynFunction>::MakeReturn();\
        }\
    };\
};\
\
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> > struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy:public FUN_PROXY_IMPL(param_count)<R>::template RetProxy<DynFunction, DL_REPEAT_N(param_count, P), Policy>\
    {\
    };\
};

DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's

#define DL_USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId<DL_SEQ_ENUM_CHAR(NameId)> > module_type;

#define DL_USE_MODULE_END \
};



#define DL_DECLARE_FUN(NameId, R, P) \
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P)> >::GetProxy();

#define DL_DECLARE_FUN_ERR(Name, NameId, R, P, E)\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyValuePolicy<R,E> > >::GetProxy();
 
#define DL_DECLARE_FUN_THROW(NameId, R, P)\
static R (WINAPI *&DL_SEQ_CAT(NameId))(DL_SEQ_ENUM(P)) = CDynFunction<module_type, CNameId<DL_SEQ_ENUM_CHAR(NameId)>, FUN_PROXY(DL_SEQ_SIZE(P))<R, DL_SEQ_ENUM(P), FunProxyThrowPolicy<> > >::GetProxy();

#endif

DL_USE_MODULE_BEGIN(kernel, (kern)(el32)(.dll))
    DL_DECLARE_FUN((GetP)(rocA)(ddre)(ss), FARPROC, (HMODULE)(LPCTSTR))
    DL_DECLARE_FUN((GetM)(odul)(eHan)(dleA), HMODULE, (LPCTSTR))
    DL_DECLARE_FUN_THROW((Init)(iali)(zeCr)(itic)(alSe)(ctio)(n), void, (LPCRITICAL_SECTION))
DL_USE_MODULE_END

#define DECLARE_NAME_ID(id, name)\
struct NAME_ID(id)\
{\
    enum {length = sizeof(name)};\
    static LPCSTR GetStr(){return name;}\
    static LPCTSTR GetTStr(){return _T(name);}\
};

FARPROC GetProcAddress(
  HMODULE hModule,    // handle to DLL module
  LPCSTR lpProcName   // function name
);

HMODULE LoadLibrary(
  LPCTSTR lpFileName   // file name of module
);