Python Windows中的延迟加载

我正试图了解一些直接从PyCXX改编的代码。它是一个多平台C++ Python包装器。 编辑：原始代码

它似乎迎合了某些仅存在于Windows中的特殊现象：

#ifdef PY_WIN32_DELAYLOAD_PYTHON_DLL
:
#else
:
#endif

我将在下面给出完整的文件列表，它相当长

这个PY_WIN32_DELAYLOAD_PYTHON_DLL令牌在CPython中不存在，它也没有在PyCXX中定义。因此，我只能想象PyCXX打算将其作为可选的编译器标志提供

我想知道的是：它的目的是什么？它解决了什么问题？这一机制为什么会存在

也许熟悉Windows编程的人可以从代码中找到答案

我想知道它正在解决的问题是否仍然存在于现代Windows中，因为代码已经超过15年了

关键问题是：我可以把它取下来，还是换成更干净的

我很想把它删掉；但它在现代Windows环境中是否仍有一些有用的用途

代码：

---

在Win32上，延迟加载是一种机制，允许文件引用另一个PE文件，而该文件在文件启动时并不在加载程序所期望的位置，或者如果它根本不在那里，则可以正常地回滚。在我看来，这似乎是为了迎合一个嵌入python本身的Windows程序，但不想让包含python的DLL位于PATH中

---

一些Google进一步指出，这与避免python和python加载的模块之间的循环有关。

在Win32上，延迟加载是一种机制，允许文件引用另一个PE文件，而加载程序在启动文件时不在加载程序所期望的位置，或者优雅地退后，如果它根本不在那里。在我看来，这似乎是为了迎合一个嵌入python本身的Windows程序，但不想让包含python的DLL位于PATH中

---

一些谷歌搜索进一步指出，这与避免python和由python加载的模块之间的循环有关。

宏可以用预处理器参数定义，这就是为什么在任何地方都看不到它们。与Microsoft编译器一起使用的是/D参数

/D与源代码文件开头的define指令具有相同的效果，不同的是/D在命令行中去掉引号，define保留它们

使用gcc时，请使用-D检查此参考链接：

延迟加载是一种仅在使用库时加载库的机制，而不是在应用程序启动前由操作系统加载库。它可以节省宝贵的内存和加载时间，因为根据代码流，dll可能根本不会加载

如果定义了宏，则此代码试图自行实现延迟加载，否则按正常方式执行。Microsoft linker可以自动为您完成工作，即您不需要编写任何程序。请记住，这不是平台的功能，而是链接器功能

检查此参考：

如果需要，您可以删除该代码并指示Microsoft linker为您添加代码

您可以使用/DELAYLOAD参数来完成，如本文所述：

---

如果没有找到dll，请确保捕获正确的异常和钩子。

宏可以用预处理器参数定义，这就是为什么在任何地方都看不到它们的原因。与Microsoft编译器一起使用的是/D参数

/D与源代码文件开头的define指令具有相同的效果，不同的是/D在命令行中去掉引号，define保留它们

使用gcc时，请使用-D检查此参考链接：

延迟加载是一种仅在使用库时加载库的机制，而不是在应用程序启动前由操作系统加载库。它可以节省宝贵的内存和加载时间，因为根据代码流，dll可能根本不会加载

如果定义了宏，则此代码试图自行实现延迟加载，否则按正常方式执行。Microsoft linker可以自动为您完成工作，即您不需要编写任何程序。请记住，这不是平台的功能，而是链接器功能

检查此参考：

如果需要，您可以删除该代码并指示Microsoft linker为您添加代码

您可以使用/DELAYLOAD参数来完成，如本文所述：

---

如果没有找到dll，请确保捕获正确的异常和钩子。

因此，此代码尝试手动执行，这是可以自动执行的操作。它为什么存在？15年前是否存在没有/DELAYLOAD链接器标志的情况？也许这就是原因，或者某个人无法访问具有该功能的链接器。我不记得它具体是什么时候实现的，但可能要迟于15年前。因此，这段代码试图手动完成它，这是可以通过aut完成的

---

浪漫的。它为什么存在？15年前是否存在没有/DELAYLOAD链接器标志的情况？也许这就是原因，或者某个人无法访问具有该功能的链接器。我不记得它是什么时候实现的，但可能要比15年前晚，因为Windows loader的工作原理与Linux ld非常不同。根据@Waldo的回答，在现代WIndows中，您可能可以删除所有这些内容并使用/delayload。为什么不试试呢？因为Windows加载程序的工作原理与Linux ld.so非常不同。根据@Waldo的回答，在现代WIndows中，您可能可以删除所有这些内容并使用/delayload。你为什么不试试呢？

#include "Base.hxx" //"IndirectPythonInterface.hxx"

namespace Py
{

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

#ifdef PY_WIN32_DELAYLOAD_PYTHON_DLL

#   ifndef MS_WINDOWS
#       error "Can only delay load under Win32"
#   endif
#   include <windows.h> // !!! Is it possible we ever want Windows.h but no delay load? If so, this is wrong...

static HMODULE python_dll;

#   define DECLARE_ERROR( THE_ERROR ) \
        static PyObject* ptr__Exc_##THE_ERROR = nullptr;
ALL_ERRORS( DECLARE_ERROR )


static PyObject* ptr__PyNone        = nullptr;
static PyObject* ptr__PyFalse       = nullptr;
static PyObject* ptr__PyTrue        = nullptr;

#   define DECLARE_TYPE( T ) \
        static PyTypeObject* ptr__##T##_Type = nullptr;
ALL_TYPES( DECLARE_TYPE )


static int* ptr_Py_DebugFlag        = nullptr;
static int* ptr_Py_InteractiveFlag  = nullptr;
static int* ptr_Py_OptimizeFlag     = nullptr;
static int* ptr_Py_NoSiteFlag       = nullptr;
static int* ptr_Py_VerboseFlag      = nullptr;

static char** ptr__Py_PackageContext = nullptr;

#   ifdef Py_REF_DEBUG
int* ptr_Py_RefTotal; // !!! Why not static?
#   endif


//--------------------------------------------------------------------------------
class GetAddressException
{
public:
    GetAddressException( const char* _name )
        : name( _name )
    { }
    virtual ~GetAddressException() { }
    const char* name;
};


//--------------------------------------------------------------------------------

#   define GET_PTR( FUNC, RETURN_TYPE ) \
        static FUNC( const char *name ) \
            { \
                FARPROC addr = GetProcAddress( python_dll, name ); \
                if( addr == nullptr ) \
                    throw GetAddressException( name ); \
                \
                return RETURN_TYPE addr; \
            }

GET_PTR( PyObject *             GetPyObjectPointer_As_PyObjectPointer       , *(PyObject **)        )
GET_PTR( PyObject *                    GetPyObject_As_PyObjectPointer       ,  (PyObject *)         )
GET_PTR( PyTypeObject *     GetPyTypeObjectPointer_As_PyTypeObjectPointer   , *(PyTypeObject**)     )
GET_PTR( PyTypeObject *            GetPyTypeObject_As_PyTypeObjectPointer   ,  (PyTypeObject*)      )
GET_PTR( int *                              GetInt_as_IntPointer            ,  (int*)               )
GET_PTR( char **                    GetCharPointer_as_CharPointerPointer    ,  (char**)             )


#   ifdef _DEBUG
static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d_D.DLL";
#   else
static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d.DLL";
#   endif

//--------------------------------------------------------------------------------
bool InitialisePythonIndirectInterface()
{
    char python_dll_name[sizeof(python_dll_name_format)];

    _snprintf( python_dll_name, sizeof(python_dll_name_format) / sizeof(char) - 1, python_dll_name_format, PY_MAJOR_VERSION, PY_MINOR_VERSION );

    python_dll = LoadLibraryA( python_dll_name );
    if( python_dll == nullptr )
        return false;

    try
    {
#   ifdef Py_REF_DEBUG
        ptr_Py_RefTotal             = GetInt_as_IntPointer( "_Py_RefTotal" );
#   endif
        ptr_Py_DebugFlag            = GetInt_as_IntPointer( "Py_DebugFlag" );
        ptr_Py_InteractiveFlag      = GetInt_as_IntPointer( "Py_InteractiveFlag" );
        ptr_Py_OptimizeFlag         = GetInt_as_IntPointer( "Py_OptimizeFlag" );
        ptr_Py_NoSiteFlag           = GetInt_as_IntPointer( "Py_NoSiteFlag" );
        ptr_Py_VerboseFlag          = GetInt_as_IntPointer( "Py_VerboseFlag" );
        ptr__Py_PackageContext      = GetCharPointer_as_CharPointerPointer( "_Py_PackageContext" );

#   define ASSIGN_PTR( E ) \
        ptr__Exc_##E    = GetPyObjectPointer_As_PyObjectPointer( "PyExc_" #E );
        ALL_ERRORS( ASSIGN_PTR )

        ptr__PyNone                 = GetPyObject_As_PyObjectPointer( "_Py_NoneStruct" );
        ptr__PyFalse                = GetPyObject_As_PyObjectPointer( "_Py_ZeroStruct" );
        ptr__PyTrue                 = GetPyObject_As_PyObjectPointer( "_Py_TrueStruct" );

#   define MAKE_PTR( TYPENAME ) \
        ptr__##TYPENAME##_Type      = GetPyTypeObject_As_PyTypeObjectPointer( "Py" #TYPENAME "_Type" );
        ALL_TYPES( MAKE_PTR )
    }
    catch( GetAddressException &e )
    {
        OutputDebugStringA( python_dll_name );
        OutputDebugStringA( " does not contain symbol " );
        OutputDebugStringA( e.name );
        OutputDebugStringA( "\n" );

        return false;
    }

    return true;
}


//#if 0
//#define Py_INCREF(op) (                         \
//    _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
//    ((PyObject*)(op))->ob_refcnt++)
//
//#define Py_DECREF(op)                           \
//    if (_Py_DEC_REFTOTAL  _Py_REF_DEBUG_COMMA   \
//        --((PyObject*)(op))->ob_refcnt != 0)    \
//        _Py_CHECK_REFCNT(op)                    \
//    else                                        \
//        _Py_Dealloc((PyObject *)(op))
//#endif

void _XINCREF( PyObject* op )
{
    // This function must match the contents of Py_XINCREF(op)
    if( op == nullptr )
        return;

#   ifdef Py_REF_DEBUG
    (*ptr_Py_RefTotal)++;
#   endif
    (op)->ob_refcnt++;

}

void _XDECREF( PyObject* op )
{
    // This function must match the contents of Py_XDECREF(op);
    if( op == nullptr )
        return;

#   ifdef Py_REF_DEBUG
    (*ptr_Py_RefTotal)--;
#   endif

    if (--(op)->ob_refcnt == 0)
        _Py_Dealloc((PyObject *)(op));
}


#else // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


//
//    Needed to keep the abstactions for delayload interface
//
// !!! π Py_XDECREF has been deprecated in favour of Py_CLEAR

void _XINCREF( PyObject* op )
{
    Py_XINCREF( op );
}

void _XDECREF( PyObject* op )
{
    Py_XDECREF( op );
}

#endif // PY_WIN32_DELAYLOAD_PYTHON_DLL

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


//
//    Wrap Python-types, type checks, errors, flags, etc as function calls
//

#ifdef PY_WIN32_DELAYLOAD_PYTHON_DLL
#   define IF_DELAYLOAD_ELSE( A, B ) A
#else
#   define IF_DELAYLOAD_ELSE( A, B ) B
#endif


#define _Foo_Check( TYPENAME ) \
    bool _##TYPENAME##_Check( PyObject *pyob )  \
    { \
        return pyob->ob_type == _##TYPENAME##_Type(); \
    }
ALL_TYPES( _Foo_Check )

#define _Foo_Type( TYPENAME ) \
    PyTypeObject* _##TYPENAME##_Type() \
    { \
        return IF_DELAYLOAD_ELSE( ptr__##TYPENAME##_Type, & Py##TYPENAME##_Type ); \
    }
ALL_TYPES( _Foo_Type )



#define _Exc_Foo( E ) \
    PyObject* _Exc_##E() \
    { \
        return IF_DELAYLOAD_ELSE( ptr__Exc_##E, ::PyExc_##E ); \
    }
ALL_ERRORS( _Exc_Foo )


int& _Py_DebugFlag()                    { return IF_DELAYLOAD_ELSE( *ptr_Py_DebugFlag       , Py_DebugFlag ); }
int& _Py_InteractiveFlag()              { return IF_DELAYLOAD_ELSE( *ptr_Py_InteractiveFlag , Py_InteractiveFlag ); }
int& _Py_OptimizeFlag()                 { return IF_DELAYLOAD_ELSE( *ptr_Py_OptimizeFlag    , Py_OptimizeFlag ); }
int& _Py_NoSiteFlag()                   { return IF_DELAYLOAD_ELSE( *ptr_Py_NoSiteFlag      , Py_NoSiteFlag ); }
int& _Py_VerboseFlag()                  { return IF_DELAYLOAD_ELSE( *ptr_Py_VerboseFlag     , Py_VerboseFlag ); }

char* __Py_PackageContext()             { return IF_DELAYLOAD_ELSE( *ptr__Py_PackageContext , _Py_PackageContext ); }


PyObject* _None()                       { return IF_DELAYLOAD_ELSE( ptr__PyNone             , &::_Py_NoneStruct ); }
PyObject* _False()                      { return IF_DELAYLOAD_ELSE( ptr__PyFalse            , Py_False ); }
PyObject* _True()                       { return IF_DELAYLOAD_ELSE( ptr__PyTrue             , Py_True ); }

} // namespace Py