Add DL_IMPORT(returntype) for all officially exported functions.

Include/Python.h

@@ -41,6 +41,9 @@ PERFORMANCE OF THIS SOFTWARE.
 #ifndef DL_IMPORT	/* declarations for DLL import/export */
 #define DL_IMPORT(RTYPE) RTYPE
 #endif
+#ifndef DL_EXPORT	/* declarations for DLL import/export */
+#define DL_EXPORT(RTYPE) RTYPE
+#endif
 
 #ifdef SYMANTEC__CFM68K__
 #define UsingSharedLibs

Include/bufferobject.h

@@ -46,13 +46,13 @@ extern DL_IMPORT(PyTypeObject) PyBuffer_Type;
 
 #define Py_END_OF_BUFFER	(-1)
 
-extern PyObject *PyBuffer_FromObject Py_PROTO((PyObject *base, int offset, int size));
-extern PyObject *PyBuffer_FromReadWriteObject Py_PROTO((PyObject *base, int offset, int size));
+extern DL_IMPORT(PyObject *) PyBuffer_FromObject Py_PROTO((PyObject *base, int offset, int size));
+extern DL_IMPORT(PyObject *) PyBuffer_FromReadWriteObject Py_PROTO((PyObject *base, int offset, int size));
 
-extern PyObject *PyBuffer_FromMemory Py_PROTO((void *ptr, int size));
-extern PyObject *PyBuffer_FromReadWriteMemory Py_PROTO((void *ptr, int size));
+extern DL_IMPORT(PyObject *) PyBuffer_FromMemory Py_PROTO((void *ptr, int size));
+extern DL_IMPORT(PyObject *) PyBuffer_FromReadWriteMemory Py_PROTO((void *ptr, int size));
 
-extern PyObject *PyBuffer_New Py_PROTO((int size));
+extern DL_IMPORT(PyObject *) PyBuffer_New Py_PROTO((int size));
 
 #ifdef __cplusplus
 }

Include/cStringIO.h

@@ -106,7 +106,7 @@ static struct PycStringIO_CAPI {
 #define PycStringIO_OutputCheck(O) \
   ((O)->ob_type==PycStringIO->OutputType)
 
-static void *
+static DL_IMPORT(void *)
 xxxPyCObject_Import(module_name, name)
   char *module_name;
   char *name;

Include/ceval.h

@@ -37,7 +37,7 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Interface to random parts in ceval.c */
 
-PyObject *PyEval_CallObjectWithKeywords
+DL_IMPORT(PyObject *) PyEval_CallObjectWithKeywords
 	Py_PROTO((PyObject *, PyObject *, PyObject *));
 
 /* Inline this */
@@ -45,26 +45,26 @@ PyObject *PyEval_CallObjectWithKeywords
         PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
 
 #ifdef HAVE_STDARG_PROTOTYPES
-PyObject *PyEval_CallFunction Py_PROTO((PyObject *obj, char *format, ...));
-PyObject *PyEval_CallMethod Py_PROTO((PyObject *obj,
+DL_IMPORT(PyObject *) PyEval_CallFunction Py_PROTO((PyObject *obj, char *format, ...));
+DL_IMPORT(PyObject *) PyEval_CallMethod Py_PROTO((PyObject *obj,
 				      char *methodname, char *format, ...));
 #else
 /* Better to have no prototypes at all for varargs functions in this case */
-PyObject *PyEval_CallFunction();
-PyObject *PyEval_CallMethod();
+DL_IMPORT(PyObject *) PyEval_CallFunction();
+DL_IMPORT(PyObject *) PyEval_CallMethod();
 #endif
 
-PyObject *PyEval_GetBuiltins Py_PROTO((void));
-PyObject *PyEval_GetGlobals Py_PROTO((void));
-PyObject *PyEval_GetLocals Py_PROTO((void));
-PyObject *PyEval_GetOwner Py_PROTO((void));
-PyObject *PyEval_GetFrame Py_PROTO((void));
-int PyEval_GetRestricted Py_PROTO((void));
+DL_IMPORT(PyObject *) PyEval_GetBuiltins Py_PROTO((void));
+DL_IMPORT(PyObject *) PyEval_GetGlobals Py_PROTO((void));
+DL_IMPORT(PyObject *) PyEval_GetLocals Py_PROTO((void));
+DL_IMPORT(PyObject *) PyEval_GetOwner Py_PROTO((void));
+DL_IMPORT(PyObject *) PyEval_GetFrame Py_PROTO((void));
+DL_IMPORT(int) PyEval_GetRestricted Py_PROTO((void));
 
-int Py_FlushLine Py_PROTO((void));
+DL_IMPORT(int) Py_FlushLine Py_PROTO((void));
 
-int Py_AddPendingCall Py_PROTO((int (*func) Py_PROTO((ANY *)), ANY *arg));
-int Py_MakePendingCalls Py_PROTO((void));
+DL_IMPORT(int) Py_AddPendingCall Py_PROTO((int (*func) Py_PROTO((ANY *)), ANY *arg));
+DL_IMPORT(int) Py_MakePendingCalls Py_PROTO((void));
 
 
 /* Interface for threads.
@@ -112,16 +112,16 @@ int Py_MakePendingCalls Py_PROTO((void));
    mechanism!
 */
 
-extern PyThreadState *PyEval_SaveThread Py_PROTO((void));
-extern void PyEval_RestoreThread Py_PROTO((PyThreadState *));
+extern DL_IMPORT(PyThreadState *) PyEval_SaveThread Py_PROTO((void));
+extern DL_IMPORT(void) PyEval_RestoreThread Py_PROTO((PyThreadState *));
 
 #ifdef WITH_THREAD
 
-extern void PyEval_InitThreads Py_PROTO((void));
-extern void PyEval_AcquireLock Py_PROTO((void));
-extern void PyEval_ReleaseLock Py_PROTO((void));
-extern void PyEval_AcquireThread Py_PROTO((PyThreadState *tstate));
-extern void PyEval_ReleaseThread Py_PROTO((PyThreadState *tstate));
+extern DL_IMPORT(void) PyEval_InitThreads Py_PROTO((void));
+extern DL_IMPORT(void) PyEval_AcquireLock Py_PROTO((void));
+extern DL_IMPORT(void) PyEval_ReleaseLock Py_PROTO((void));
+extern DL_IMPORT(void) PyEval_AcquireThread Py_PROTO((PyThreadState *tstate));
+extern DL_IMPORT(void) PyEval_ReleaseThread Py_PROTO((PyThreadState *tstate));
 
 #define Py_BEGIN_ALLOW_THREADS { \
 			PyThreadState *_save; \

Include/classobject.h

@@ -69,13 +69,13 @@ extern DL_IMPORT(PyTypeObject) PyClass_Type, PyInstance_Type, PyMethod_Type;
 #define PyInstance_Check(op) ((op)->ob_type == &PyInstance_Type)
 #define PyMethod_Check(op) ((op)->ob_type == &PyMethod_Type)
 
-extern PyObject *PyClass_New Py_PROTO((PyObject *, PyObject *, PyObject *));
-extern PyObject *PyInstance_New Py_PROTO((PyObject *, PyObject *, PyObject *));
-extern PyObject *PyMethod_New Py_PROTO((PyObject *, PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyClass_New Py_PROTO((PyObject *, PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyInstance_New Py_PROTO((PyObject *, PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyMethod_New Py_PROTO((PyObject *, PyObject *, PyObject *));
 
-extern PyObject *PyMethod_Function Py_PROTO((PyObject *));
-extern PyObject *PyMethod_Self Py_PROTO((PyObject *));
-extern PyObject *PyMethod_Class Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyMethod_Function Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyMethod_Self Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyMethod_Class Py_PROTO((PyObject *));
 
 /* Macros for direct access to these values. Type checks are *not*
    done, so use with care. */
@@ -86,9 +86,9 @@ extern PyObject *PyMethod_Class Py_PROTO((PyObject *));
 #define PyMethod_GET_CLASS(meth) \
 	(((PyMethodObject *)meth) -> im_class)
 
-extern int PyClass_IsSubclass Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(int) PyClass_IsSubclass Py_PROTO((PyObject *, PyObject *));
 
-extern PyObject *PyInstance_DoBinOp
+extern DL_IMPORT(PyObject *) PyInstance_DoBinOp
 	Py_PROTO((PyObject *, PyObject *,
 		  char *, char *,
 		  PyObject * (*) Py_PROTO((PyObject *, PyObject *)) ));

Include/cobject.h

@@ -54,7 +54,7 @@ extern DL_IMPORT(PyTypeObject) PyCObject_Type;
    destroyed.
 
 */
-extern PyObject *
+extern DL_IMPORT(PyObject *)
 PyCObject_FromVoidPtr Py_PROTO((void *cobj, void (*destruct)(void*)));
 
 
@@ -63,20 +63,20 @@ PyCObject_FromVoidPtr Py_PROTO((void *cobj, void (*destruct)(void*)));
    then it will be called with the first and second arguments if and when 
    the PyCObject is destroyed.
 */
-extern PyObject *
+extern DL_IMPORT(PyObject *)
 PyCObject_FromVoidPtrAndDesc Py_PROTO((void *cobj, void *desc,
                                        void (*destruct)(void*,void*)));
 
 /* Retrieve a pointer to a C object from a PyCObject. */
-extern void *
+extern DL_IMPORT(void *)
 PyCObject_AsVoidPtr Py_PROTO((PyObject *));
 
 /* Retrieve a pointer to a description object from a PyCObject. */
-extern void *
+extern DL_IMPORT(void *)
 PyCObject_GetDesc Py_PROTO((PyObject *));
 
 /* Import a pointer to a C object from a module using a PyCObject. */
-extern void *
+extern DL_IMPORT(void *)
 PyCObject_Import Py_PROTO((char *module_name, char *cobject_name));
 
 #ifdef __cplusplus

Include/compile.h

@@ -69,11 +69,11 @@ extern DL_IMPORT(PyTypeObject) PyCode_Type;
 
 /* Public interface */
 struct _node; /* Declare the existence of this type */
-PyCodeObject *PyNode_Compile Py_PROTO((struct _node *, char *));
-PyCodeObject *PyCode_New Py_PROTO((
+DL_IMPORT(PyCodeObject *) PyNode_Compile Py_PROTO((struct _node *, char *));
+DL_IMPORT(PyCodeObject *) PyCode_New Py_PROTO((
 	int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,
 	PyObject *, PyObject *, int, PyObject *)); /* same as struct above */
-int PyCode_Addr2Line Py_PROTO((PyCodeObject *, int));
+DL_IMPORT(int) PyCode_Addr2Line Py_PROTO((PyCodeObject *, int));
 
 /* for internal use only */
 #define _PyCode_GETCODEPTR(co, pp) \

Include/complexobject.h

@@ -20,12 +20,12 @@ typedef struct {
 #define c_quot _Py_c_quot
 #define c_pow _Py_c_pow
 
-extern Py_complex c_sum Py_PROTO((Py_complex, Py_complex));
-extern Py_complex c_diff Py_PROTO((Py_complex, Py_complex));
-extern Py_complex c_neg Py_PROTO((Py_complex));
-extern Py_complex c_prod Py_PROTO((Py_complex, Py_complex));
-extern Py_complex c_quot Py_PROTO((Py_complex, Py_complex));
-extern Py_complex c_pow Py_PROTO((Py_complex, Py_complex));
+extern DL_IMPORT(Py_complex) c_sum Py_PROTO((Py_complex, Py_complex));
+extern DL_IMPORT(Py_complex) c_diff Py_PROTO((Py_complex, Py_complex));
+extern DL_IMPORT(Py_complex) c_neg Py_PROTO((Py_complex));
+extern DL_IMPORT(Py_complex) c_prod Py_PROTO((Py_complex, Py_complex));
+extern DL_IMPORT(Py_complex) c_quot Py_PROTO((Py_complex, Py_complex));
+extern DL_IMPORT(Py_complex) c_pow Py_PROTO((Py_complex, Py_complex));
 
 
 /* Complex object interface */
@@ -44,12 +44,12 @@ extern DL_IMPORT(PyTypeObject) PyComplex_Type;
 
 #define PyComplex_Check(op) ((op)->ob_type == &PyComplex_Type)
 
-extern PyObject *PyComplex_FromCComplex Py_PROTO((Py_complex));
-extern PyObject *PyComplex_FromDoubles Py_PROTO((double real, double imag));
+extern DL_IMPORT(PyObject *) PyComplex_FromCComplex Py_PROTO((Py_complex));
+extern DL_IMPORT(PyObject *) PyComplex_FromDoubles Py_PROTO((double real, double imag));
 
-extern double PyComplex_RealAsDouble Py_PROTO((PyObject *op));
-extern double PyComplex_ImagAsDouble Py_PROTO((PyObject *op));
-extern Py_complex PyComplex_AsCComplex Py_PROTO((PyObject *op));
+extern DL_IMPORT(double) PyComplex_RealAsDouble Py_PROTO((PyObject *op));
+extern DL_IMPORT(double) PyComplex_ImagAsDouble Py_PROTO((PyObject *op));
+extern DL_IMPORT(Py_complex) PyComplex_AsCComplex Py_PROTO((PyObject *op));
 
 #ifdef __cplusplus
 }

Include/dictobject.h

@@ -41,21 +41,21 @@ extern DL_IMPORT(PyTypeObject) PyDict_Type;
 
 #define PyDict_Check(op) ((op)->ob_type == &PyDict_Type)
 
-extern PyObject *PyDict_New Py_PROTO((void));
-extern PyObject *PyDict_GetItem Py_PROTO((PyObject *mp, PyObject *key));
-extern int PyDict_SetItem Py_PROTO((PyObject *mp, PyObject *key, PyObject *item));
-extern int PyDict_DelItem Py_PROTO((PyObject *mp, PyObject *key));
-extern void PyDict_Clear Py_PROTO((PyObject *mp));
-extern int PyDict_Next
+extern DL_IMPORT(PyObject *) PyDict_New Py_PROTO((void));
+extern DL_IMPORT(PyObject *) PyDict_GetItem Py_PROTO((PyObject *mp, PyObject *key));
+extern DL_IMPORT(int) PyDict_SetItem Py_PROTO((PyObject *mp, PyObject *key, PyObject *item));
+extern DL_IMPORT(int) PyDict_DelItem Py_PROTO((PyObject *mp, PyObject *key));
+extern DL_IMPORT(void) PyDict_Clear Py_PROTO((PyObject *mp));
+extern DL_IMPORT(int) PyDict_Next
 	Py_PROTO((PyObject *mp, int *pos, PyObject **key, PyObject **value));
-extern PyObject *PyDict_Keys Py_PROTO((PyObject *mp));
-extern PyObject *PyDict_Values Py_PROTO((PyObject *mp));
-extern PyObject *PyDict_Items Py_PROTO((PyObject *mp));
-extern int PyDict_Size Py_PROTO((PyObject *mp));
-
-extern PyObject *PyDict_GetItemString Py_PROTO((PyObject *dp, char *key));
-extern int PyDict_SetItemString Py_PROTO((PyObject *dp, char *key, PyObject *item));
-extern int PyDict_DelItemString Py_PROTO((PyObject *dp, char *key));
+extern DL_IMPORT(PyObject *) PyDict_Keys Py_PROTO((PyObject *mp));
+extern DL_IMPORT(PyObject *) PyDict_Values Py_PROTO((PyObject *mp));
+extern DL_IMPORT(PyObject *) PyDict_Items Py_PROTO((PyObject *mp));
+extern DL_IMPORT(int) PyDict_Size Py_PROTO((PyObject *mp));
+
+extern DL_IMPORT(PyObject *) PyDict_GetItemString Py_PROTO((PyObject *dp, char *key));
+extern DL_IMPORT(int) PyDict_SetItemString Py_PROTO((PyObject *dp, char *key, PyObject *item));
+extern DL_IMPORT(int) PyDict_DelItemString Py_PROTO((PyObject *dp, char *key));
 
 #ifdef __cplusplus
 }

Include/eval.h

@@ -37,7 +37,7 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Interface to execute compiled code */
 
-PyObject *PyEval_EvalCode Py_PROTO((PyCodeObject *, PyObject *, PyObject *));
+DL_IMPORT(PyObject *) PyEval_EvalCode Py_PROTO((PyCodeObject *, PyObject *, PyObject *));
 
 #ifdef __cplusplus
 }

Include/fileobject.h

@@ -41,16 +41,16 @@ extern DL_IMPORT(PyTypeObject) PyFile_Type;
 
 #define PyFile_Check(op) ((op)->ob_type == &PyFile_Type)
 
-extern PyObject *PyFile_FromString Py_PROTO((char *, char *));
-extern void PyFile_SetBufSize Py_PROTO((PyObject *, int));
-extern PyObject *PyFile_FromFile
+extern DL_IMPORT(PyObject *) PyFile_FromString Py_PROTO((char *, char *));
+extern DL_IMPORT(void) PyFile_SetBufSize Py_PROTO((PyObject *, int));
+extern DL_IMPORT(PyObject *) PyFile_FromFile
 	Py_PROTO((FILE *, char *, char *, int (*)Py_FPROTO((FILE *))));
-extern FILE *PyFile_AsFile Py_PROTO((PyObject *));
-extern PyObject *PyFile_Name Py_PROTO((PyObject *));
-extern PyObject *PyFile_GetLine Py_PROTO((PyObject *, int));
-extern int PyFile_WriteObject Py_PROTO((PyObject *, PyObject *, int));
-extern int PyFile_SoftSpace Py_PROTO((PyObject *, int));
-extern int PyFile_WriteString Py_PROTO((char *, PyObject *));
+extern DL_IMPORT(FILE *) PyFile_AsFile Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyFile_Name Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyFile_GetLine Py_PROTO((PyObject *, int));
+extern DL_IMPORT(int) PyFile_WriteObject Py_PROTO((PyObject *, PyObject *, int));
+extern DL_IMPORT(int) PyFile_SoftSpace Py_PROTO((PyObject *, int));
+extern DL_IMPORT(int) PyFile_WriteString Py_PROTO((char *, PyObject *));
 
 #ifdef __cplusplus
 }

Include/floatobject.h

@@ -50,8 +50,8 @@ extern DL_IMPORT(PyTypeObject) PyFloat_Type;
 
 #define PyFloat_Check(op) ((op)->ob_type == &PyFloat_Type)
 
-extern PyObject *PyFloat_FromDouble Py_PROTO((double));
-extern double PyFloat_AsDouble Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyFloat_FromDouble Py_PROTO((double));
+extern DL_IMPORT(double) PyFloat_AsDouble Py_PROTO((PyObject *));
 
 /* Macro, trading safety for speed */
 #define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)

Include/frameobject.h

@@ -72,7 +72,7 @@ extern DL_IMPORT(PyTypeObject) PyFrame_Type;
 
 #define PyFrame_Check(op) ((op)->ob_type == &PyFrame_Type)
 
-PyFrameObject * PyFrame_New
+DL_IMPORT(PyFrameObject *) PyFrame_New
 	Py_PROTO((PyThreadState *, PyCodeObject *,
 		  PyObject *, PyObject *));
 
@@ -101,17 +101,17 @@ PyFrameObject * PyFrame_New
 
 /* Block management functions */
 
-void PyFrame_BlockSetup Py_PROTO((PyFrameObject *, int, int, int));
-PyTryBlock *PyFrame_BlockPop Py_PROTO((PyFrameObject *));
+DL_IMPORT(void) PyFrame_BlockSetup Py_PROTO((PyFrameObject *, int, int, int));
+DL_IMPORT(PyTryBlock *) PyFrame_BlockPop Py_PROTO((PyFrameObject *));
 
 /* Extend the value stack */
 
-PyObject **PyFrame_ExtendStack Py_PROTO((PyFrameObject *, int, int));
+DL_IMPORT(PyObject **) PyFrame_ExtendStack Py_PROTO((PyFrameObject *, int, int));
 
 /* Conversions between "fast locals" and locals in dictionary */
 
-void PyFrame_LocalsToFast Py_PROTO((PyFrameObject *, int));
-void PyFrame_FastToLocals Py_PROTO((PyFrameObject *));
+DL_IMPORT(void) PyFrame_LocalsToFast Py_PROTO((PyFrameObject *, int));
+DL_IMPORT(void) PyFrame_FastToLocals Py_PROTO((PyFrameObject *));
 
 #ifdef __cplusplus
 }

Include/funcobject.h

@@ -50,11 +50,11 @@ extern DL_IMPORT(PyTypeObject) PyFunction_Type;
 
 #define PyFunction_Check(op) ((op)->ob_type == &PyFunction_Type)
 
-extern PyObject *PyFunction_New Py_PROTO((PyObject *, PyObject *));
-extern PyObject *PyFunction_GetCode Py_PROTO((PyObject *));
-extern PyObject *PyFunction_GetGlobals Py_PROTO((PyObject *));
-extern PyObject *PyFunction_GetDefaults Py_PROTO((PyObject *));
-extern int PyFunction_SetDefaults Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyFunction_New Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyFunction_GetCode Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyFunction_GetGlobals Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyFunction_GetDefaults Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyFunction_SetDefaults Py_PROTO((PyObject *, PyObject *));
 
 /* Macros for direct access to these values. Type checks are *not*
    done, so use with care. */

Include/import.h

@@ -37,26 +37,26 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Module definition and import interface */
 
-long PyImport_GetMagicNumber Py_PROTO((void));
-PyObject *PyImport_ExecCodeModule Py_PROTO((char *name, PyObject *co));
-PyObject *PyImport_ExecCodeModuleEx Py_PROTO((
+DL_IMPORT(long) PyImport_GetMagicNumber Py_PROTO((void));
+DL_IMPORT(PyObject *) PyImport_ExecCodeModule Py_PROTO((char *name, PyObject *co));
+DL_IMPORT(PyObject *) PyImport_ExecCodeModuleEx Py_PROTO((
 	char *name, PyObject *co, char *pathname));
-PyObject *PyImport_GetModuleDict Py_PROTO((void));
-PyObject *PyImport_AddModule Py_PROTO((char *name));
-PyObject *PyImport_ImportModule Py_PROTO((char *name));
-PyObject *PyImport_ImportModuleEx Py_PROTO((
+DL_IMPORT(PyObject *) PyImport_GetModuleDict Py_PROTO((void));
+DL_IMPORT(PyObject *) PyImport_AddModule Py_PROTO((char *name));
+DL_IMPORT(PyObject *) PyImport_ImportModule Py_PROTO((char *name));
+DL_IMPORT(PyObject *) PyImport_ImportModuleEx Py_PROTO((
 	char *name, PyObject *globals, PyObject *locals, PyObject *fromlist));
-PyObject *PyImport_Import Py_PROTO((PyObject *name));
-PyObject *PyImport_ReloadModule Py_PROTO((PyObject *m));
-void PyImport_Cleanup Py_PROTO((void));
-int PyImport_ImportFrozenModule Py_PROTO((char *));
+DL_IMPORT(PyObject *) PyImport_Import Py_PROTO((PyObject *name));
+DL_IMPORT(PyObject *) PyImport_ReloadModule Py_PROTO((PyObject *m));
+DL_IMPORT(void) PyImport_Cleanup Py_PROTO((void));
+DL_IMPORT(int) PyImport_ImportFrozenModule Py_PROTO((char *));
 
-extern PyObject *_PyImport_FindExtension Py_PROTO((char *, char *));
-extern PyObject *_PyImport_FixupExtension Py_PROTO((char *, char *));
+extern DL_IMPORT(PyObject *)_PyImport_FindExtension Py_PROTO((char *, char *));
+extern DL_IMPORT(PyObject *)_PyImport_FixupExtension Py_PROTO((char *, char *));
 
 #ifdef __BEOS__
 #include <kernel/image.h>
-extern image_id PyImport_BeImageID( char *name );
+extern DL_IMPORT(image_id) PyImport_BeImageID( char *name );
 #endif
 
 struct _inittab {
@@ -66,8 +66,8 @@ struct _inittab {
 
 extern DL_IMPORT(struct _inittab *) PyImport_Inittab;
 
-extern int PyImport_AppendInittab Py_PROTO((char *name, void (*initfunc)()));
-extern int PyImport_ExtendInittab Py_PROTO((struct _inittab *newtab));
+extern DL_IMPORT(int) PyImport_AppendInittab Py_PROTO((char *name, void (*initfunc)()));
+extern DL_IMPORT(int) PyImport_ExtendInittab Py_PROTO((struct _inittab *newtab));
 
 struct _frozen {
 	char *name;

Include/intobject.h

@@ -61,9 +61,9 @@ extern DL_IMPORT(PyTypeObject) PyInt_Type;
 
 #define PyInt_Check(op) ((op)->ob_type == &PyInt_Type)
 
-extern PyObject *PyInt_FromLong Py_PROTO((long));
-extern long PyInt_AsLong Py_PROTO((PyObject *));
-extern long PyInt_GetMax Py_PROTO((void));
+extern DL_IMPORT(PyObject *) PyInt_FromLong Py_PROTO((long));
+extern DL_IMPORT(long) PyInt_AsLong Py_PROTO((PyObject *));
+extern DL_IMPORT(long) PyInt_GetMax Py_PROTO((void));
 
 
 /*

Include/intrcheck.h

@@ -35,9 +35,9 @@ PERFORMANCE OF THIS SOFTWARE.
 
 ******************************************************************/
 
-extern int PyOS_InterruptOccurred Py_PROTO((void));
-extern void PyOS_InitInterrupts Py_PROTO((void));
-void PyOS_AfterFork Py_PROTO((void));
+extern DL_IMPORT(int) PyOS_InterruptOccurred Py_PROTO((void));
+extern DL_IMPORT(void) PyOS_InitInterrupts Py_PROTO((void));
+DL_IMPORT(void) PyOS_AfterFork Py_PROTO((void));
 
 #ifdef __cplusplus
 }

Include/listobject.h

@@ -60,17 +60,17 @@ extern DL_IMPORT(PyTypeObject) PyList_Type;
 
 #define PyList_Check(op) ((op)->ob_type == &PyList_Type)
 
-extern PyObject *PyList_New Py_PROTO((int size));
-extern int PyList_Size Py_PROTO((PyObject *));
-extern PyObject *PyList_GetItem Py_PROTO((PyObject *, int));
-extern int PyList_SetItem Py_PROTO((PyObject *, int, PyObject *));
-extern int PyList_Insert Py_PROTO((PyObject *, int, PyObject *));
-extern int PyList_Append Py_PROTO((PyObject *, PyObject *));
-extern PyObject *PyList_GetSlice Py_PROTO((PyObject *, int, int));
-extern int PyList_SetSlice Py_PROTO((PyObject *, int, int, PyObject *));
-extern int PyList_Sort Py_PROTO((PyObject *));
-extern int PyList_Reverse Py_PROTO((PyObject *));
-extern PyObject *PyList_AsTuple Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyList_New Py_PROTO((int size));
+extern DL_IMPORT(int) PyList_Size Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyList_GetItem Py_PROTO((PyObject *, int));
+extern DL_IMPORT(int) PyList_SetItem Py_PROTO((PyObject *, int, PyObject *));
+extern DL_IMPORT(int) PyList_Insert Py_PROTO((PyObject *, int, PyObject *));
+extern DL_IMPORT(int) PyList_Append Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyList_GetSlice Py_PROTO((PyObject *, int, int));
+extern DL_IMPORT(int) PyList_SetSlice Py_PROTO((PyObject *, int, int, PyObject *));
+extern DL_IMPORT(int) PyList_Sort Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyList_Reverse Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyList_AsTuple Py_PROTO((PyObject *));
 
 /* Macro, trading safety for speed */
 #define PyList_GET_ITEM(op, i) (((PyListObject *)(op))->ob_item[i])

Include/longintrepr.h

@@ -73,7 +73,7 @@ struct _longobject {
 	digit ob_digit[1];
 };
 
-PyLongObject *_PyLong_New Py_PROTO((int));
+DL_IMPORT(PyLongObject *) _PyLong_New Py_PROTO((int));
 
 #ifdef __cplusplus
 }

Include/longobject.h

@@ -43,26 +43,26 @@ extern DL_IMPORT(PyTypeObject) PyLong_Type;
 
 #define PyLong_Check(op) ((op)->ob_type == &PyLong_Type)
 
-extern PyObject *PyLong_FromLong Py_PROTO((long));
-extern PyObject *PyLong_FromUnsignedLong Py_PROTO((unsigned long));
-extern PyObject *PyLong_FromDouble Py_PROTO((double));
-extern long PyLong_AsLong Py_PROTO((PyObject *));
-extern unsigned long PyLong_AsUnsignedLong Py_PROTO((PyObject *));
-extern double PyLong_AsDouble Py_PROTO((PyObject *));
-extern PyObject *PyLong_FromVoidPtr Py_PROTO((void *));
-extern void *PyLong_AsVoidPtr Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyLong_FromLong Py_PROTO((long));
+extern DL_IMPORT(PyObject *) PyLong_FromUnsignedLong Py_PROTO((unsigned long));
+extern DL_IMPORT(PyObject *) PyLong_FromDouble Py_PROTO((double));
+extern DL_IMPORT(long) PyLong_AsLong Py_PROTO((PyObject *));
+extern DL_IMPORT(unsigned long) PyLong_AsUnsignedLong Py_PROTO((PyObject *));
+extern DL_IMPORT(double) PyLong_AsDouble Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyLong_FromVoidPtr Py_PROTO((void *));
+extern DL_IMPORT(void *) PyLong_AsVoidPtr Py_PROTO((PyObject *));
 
 #ifdef HAVE_LONG_LONG
 #ifndef LONG_LONG
 #define LONG_LONG long long
 #endif
-extern PyObject *PyLong_FromLongLong Py_PROTO((LONG_LONG));
-extern PyObject *PyLong_FromUnsignedLongLong Py_PROTO((unsigned LONG_LONG));
-extern LONG_LONG PyLong_AsLongLong Py_PROTO((PyObject *));
-extern unsigned LONG_LONG PyLong_AsUnsignedLongLong Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyLong_FromLongLong Py_PROTO((LONG_LONG));
+extern DL_IMPORT(PyObject *) PyLong_FromUnsignedLongLong Py_PROTO((unsigned LONG_LONG));
+extern DL_IMPORT(LONG_LONG) PyLong_AsLongLong Py_PROTO((PyObject *));
+extern DL_IMPORT(unsigned LONG_LONG) PyLong_AsUnsignedLongLong Py_PROTO((PyObject *));
 #endif /* HAVE_LONG_LONG */
 
-PyObject *PyLong_FromString Py_PROTO((char *, char **, int));
+DL_IMPORT(PyObject *) PyLong_FromString Py_PROTO((char *, char **, int));
 
 #ifdef __cplusplus
 }

Include/marshal.h

@@ -37,15 +37,15 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Interface for marshal.c */
 
-void PyMarshal_WriteLongToFile Py_PROTO((long, FILE *));
-void PyMarshal_WriteShortToFile Py_PROTO((int, FILE *));
-void PyMarshal_WriteObjectToFile Py_PROTO((PyObject *, FILE *));
-PyObject *PyMarshal_WriteObjectToString Py_PROTO((PyObject *));
-
-long PyMarshal_ReadLongFromFile Py_PROTO((FILE *));
-int PyMarshal_ReadShortFromFile Py_PROTO((FILE *));
-PyObject *PyMarshal_ReadObjectFromFile Py_PROTO((FILE *));
-PyObject *PyMarshal_ReadObjectFromString Py_PROTO((char *, int));
+DL_IMPORT(void) PyMarshal_WriteLongToFile Py_PROTO((long, FILE *));
+DL_IMPORT(void) PyMarshal_WriteShortToFile Py_PROTO((int, FILE *));
+DL_IMPORT(void) PyMarshal_WriteObjectToFile Py_PROTO((PyObject *, FILE *));
+DL_IMPORT(PyObject *) PyMarshal_WriteObjectToString Py_PROTO((PyObject *));
+
+DL_IMPORT(long) PyMarshal_ReadLongFromFile Py_PROTO((FILE *));
+DL_IMPORT(int) PyMarshal_ReadShortFromFile Py_PROTO((FILE *));
+DL_IMPORT(PyObject *) PyMarshal_ReadObjectFromFile Py_PROTO((FILE *));
+DL_IMPORT(PyObject *) PyMarshal_ReadObjectFromString Py_PROTO((char *, int));
 
 #ifdef __cplusplus
 }

Include/methodobject.h

@@ -45,9 +45,9 @@ typedef PyObject *(*PyCFunction) Py_FPROTO((PyObject *, PyObject *));
 typedef PyObject *(*PyCFunctionWithKeywords)
 	Py_FPROTO((PyObject *, PyObject *, PyObject *));
 
-extern PyCFunction PyCFunction_GetFunction Py_PROTO((PyObject *));
-extern PyObject *PyCFunction_GetSelf Py_PROTO((PyObject *));
-extern int PyCFunction_GetFlags Py_PROTO((PyObject *));
+extern DL_IMPORT(PyCFunction) PyCFunction_GetFunction Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyCFunction_GetSelf Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyCFunction_GetFlags Py_PROTO((PyObject *));
 
 /* Macros for direct access to these values. Type checks are *not*
    done, so use with care. */
@@ -66,10 +66,10 @@ struct PyMethodDef {
 };
 typedef struct PyMethodDef PyMethodDef;
 
-extern PyObject *Py_FindMethod
+extern DL_IMPORT(PyObject *) Py_FindMethod
 	Py_PROTO((PyMethodDef[], PyObject *, char *));
 
-extern PyObject *PyCFunction_New
+extern DL_IMPORT(PyObject *) PyCFunction_New
 	Py_PROTO((PyMethodDef *, PyObject *));
 
 /* Flag passed to newmethodobject */
@@ -81,7 +81,7 @@ typedef struct PyMethodChain {
 	struct PyMethodChain *link;	/* NULL or base type */
 } PyMethodChain;
 
-extern PyObject *Py_FindMethodInChain
+extern DL_IMPORT(PyObject *) Py_FindMethodInChain
 	Py_PROTO((PyMethodChain *, PyObject *, char *));
 
 typedef struct {

Include/modsupport.h

@@ -41,25 +41,25 @@ PERFORMANCE OF THIS SOFTWARE.
 
 #include <stdarg.h>
 
-extern int PyArg_Parse Py_PROTO((PyObject *, char *, ...));
-extern int PyArg_ParseTuple Py_PROTO((PyObject *, char *, ...));
-extern int PyArg_ParseTupleAndKeywords Py_PROTO((PyObject *, PyObject *,
+extern DL_IMPORT(int) PyArg_Parse Py_PROTO((PyObject *, char *, ...));
+extern DL_IMPORT(int) PyArg_ParseTuple Py_PROTO((PyObject *, char *, ...));
+extern DL_IMPORT(int) PyArg_ParseTupleAndKeywords Py_PROTO((PyObject *, PyObject *,
 						 char *, char **, ...));
-extern PyObject *Py_BuildValue Py_PROTO((char *, ...));
+extern DL_IMPORT(PyObject *) Py_BuildValue Py_PROTO((char *, ...));
 
 #else
 
 #include <varargs.h>
 
 /* Better to have no prototypes at all for varargs functions in this case */
-extern int PyArg_Parse();
-extern int PyArg_ParseTuple();
-extern PyObject *Py_BuildValue();
+extern DL_IMPORT(int) PyArg_Parse();
+extern DL_IMPORT(int) PyArg_ParseTuple();
+extern DL_IMPORT(PyObject *) Py_BuildValue();
 
 #endif
 
-extern int PyArg_VaParse Py_PROTO((PyObject *, char *, va_list));
-extern PyObject *Py_VaBuildValue Py_PROTO((char *, va_list));
+extern DL_IMPORT(int) PyArg_VaParse Py_PROTO((PyObject *, char *, va_list));
+extern DL_IMPORT(PyObject *) Py_VaBuildValue Py_PROTO((char *, va_list));
 
 #define PYTHON_API_VERSION 1008
 #define PYTHON_API_STRING "1008"
@@ -107,7 +107,7 @@ extern PyObject *Py_VaBuildValue Py_PROTO((char *, va_list));
 #define Py_InitModule4 Py_InitModule4TraceRefs
 #endif
 
-extern PyObject *Py_InitModule4 Py_PROTO((char *, PyMethodDef *,
+extern DL_IMPORT(PyObject *) Py_InitModule4 Py_PROTO((char *, PyMethodDef *,
 					  char *, PyObject *, int));
 #define Py_InitModule(name, methods) \
 	Py_InitModule4(name, methods, (char *)NULL, (PyObject *)NULL, \
@@ -117,7 +117,7 @@ extern PyObject *Py_InitModule4 Py_PROTO((char *, PyMethodDef *,
 	Py_InitModule4(name, methods, doc, (PyObject *)NULL, \
 		       PYTHON_API_VERSION)
 
-extern char *_Py_PackageContext;
+extern DL_IMPORT(char *) _Py_PackageContext;
 
 #ifdef __cplusplus
 }

Include/moduleobject.h

@@ -41,10 +41,10 @@ extern DL_IMPORT(PyTypeObject) PyModule_Type;
 
 #define PyModule_Check(op) ((op)->ob_type == &PyModule_Type)
 
-extern PyObject *PyModule_New Py_PROTO((char *));
-extern PyObject *PyModule_GetDict Py_PROTO((PyObject *));
-extern char *PyModule_GetName Py_PROTO((PyObject *));
-extern void _PyModule_Clear Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyModule_New Py_PROTO((char *));
+extern DL_IMPORT(PyObject *) PyModule_GetDict Py_PROTO((PyObject *));
+extern DL_IMPORT(char *) PyModule_GetName Py_PROTO((PyObject *));
+extern DL_IMPORT(void) _PyModule_Clear Py_PROTO((PyObject *));
 
 #ifdef __cplusplus
 }

Include/mymalloc.h

@@ -106,14 +106,14 @@ extern void free Py_PROTO((ANY *)); /* XXX sometimes int on Unix old systems */
    The Python interpreter continues to use PyMem_NEW etc. */
 
 /* These wrappers around malloc call PyErr_NoMemory() on failure */
-extern ANY *Py_Malloc Py_PROTO((size_t));
-extern ANY *Py_Realloc Py_PROTO((ANY *, size_t));
-extern void Py_Free Py_PROTO((ANY *));
+extern DL_IMPORT(ANY *) Py_Malloc Py_PROTO((size_t));
+extern DL_IMPORT(ANY *) Py_Realloc Py_PROTO((ANY *, size_t));
+extern DL_IMPORT(void) Py_Free Py_PROTO((ANY *));
 
 /* These wrappers around malloc *don't* call anything on failure */
-extern ANY *PyMem_Malloc Py_PROTO((size_t));
-extern ANY *PyMem_Realloc Py_PROTO((ANY *, size_t));
-extern void PyMem_Free Py_PROTO((ANY *));
+extern DL_IMPORT(ANY *) PyMem_Malloc Py_PROTO((size_t));
+extern DL_IMPORT(ANY *) PyMem_Realloc Py_PROTO((ANY *, size_t));
+extern DL_IMPORT(void) PyMem_Free Py_PROTO((ANY *));
 
 #ifdef __cplusplus
 }

Include/node.h

@@ -45,9 +45,9 @@ typedef struct _node {
 	struct _node	*n_child;
 } node;
 
-extern node *PyNode_New Py_PROTO((int type));
-extern node *PyNode_AddChild Py_PROTO((node *n, int type, char *str, int lineno));
-extern void PyNode_Free Py_PROTO((node *n));
+extern DL_IMPORT(node *) PyNode_New Py_PROTO((int type));
+extern DL_IMPORT(node *) PyNode_AddChild Py_PROTO((node *n, int type, char *str, int lineno));
+extern DL_IMPORT(void) PyNode_Free Py_PROTO((node *n));
 
 /* Node access functions */
 #define NCH(n)		((n)->n_nchildren)
@@ -67,7 +67,7 @@ extern void PyNode_Free Py_PROTO((node *n));
 	} }
 #endif
 
-extern void PyNode_ListTree Py_PROTO((node *));
+extern DL_IMPORT(void) PyNode_ListTree Py_PROTO((node *));
 
 #ifdef __cplusplus
 }

Include/object.h

@@ -267,26 +267,26 @@ extern DL_IMPORT(PyTypeObject) PyType_Type; /* The type of type objects */
 #define PyType_Check(op) ((op)->ob_type == &PyType_Type)
 
 /* Generic operations on objects */
-extern int PyObject_Print Py_PROTO((PyObject *, FILE *, int));
-extern PyObject * PyObject_Repr Py_PROTO((PyObject *));
-extern PyObject * PyObject_Str Py_PROTO((PyObject *));
-extern int PyObject_Compare Py_PROTO((PyObject *, PyObject *));
-extern PyObject *PyObject_GetAttrString Py_PROTO((PyObject *, char *));
-extern int PyObject_SetAttrString Py_PROTO((PyObject *, char *, PyObject *));
-extern int PyObject_HasAttrString Py_PROTO((PyObject *, char *));
-extern PyObject *PyObject_GetAttr Py_PROTO((PyObject *, PyObject *));
-extern int PyObject_SetAttr Py_PROTO((PyObject *, PyObject *, PyObject *));
-extern int PyObject_HasAttr Py_PROTO((PyObject *, PyObject *));
-extern long PyObject_Hash Py_PROTO((PyObject *));
-extern int PyObject_IsTrue Py_PROTO((PyObject *));
-extern int PyObject_Not Py_PROTO((PyObject *));
-extern int PyCallable_Check Py_PROTO((PyObject *));
-extern int PyNumber_Coerce Py_PROTO((PyObject **, PyObject **));
-extern int PyNumber_CoerceEx Py_PROTO((PyObject **, PyObject **));
+extern DL_IMPORT(int) PyObject_Print Py_PROTO((PyObject *, FILE *, int));
+extern DL_IMPORT(PyObject *) PyObject_Repr Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyObject_Str Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyObject_Compare Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyObject_GetAttrString Py_PROTO((PyObject *, char *));
+extern DL_IMPORT(int) PyObject_SetAttrString Py_PROTO((PyObject *, char *, PyObject *));
+extern DL_IMPORT(int) PyObject_HasAttrString Py_PROTO((PyObject *, char *));
+extern DL_IMPORT(PyObject *) PyObject_GetAttr Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(int) PyObject_SetAttr Py_PROTO((PyObject *, PyObject *, PyObject *));
+extern DL_IMPORT(int) PyObject_HasAttr Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(long) PyObject_Hash Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyObject_IsTrue Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyObject_Not Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyCallable_Check Py_PROTO((PyObject *));
+extern DL_IMPORT(int) PyNumber_Coerce Py_PROTO((PyObject **, PyObject **));
+extern DL_IMPORT(int) PyNumber_CoerceEx Py_PROTO((PyObject **, PyObject **));
 
 /* Helpers for printing recursive container types */
-extern int Py_ReprEnter Py_PROTO((PyObject *));
-extern void Py_ReprLeave Py_PROTO((PyObject *));
+extern DL_IMPORT(int) Py_ReprEnter Py_PROTO((PyObject *));
+extern DL_IMPORT(void) Py_ReprLeave Py_PROTO((PyObject *));
 
 /* Flag bits for printing: */
 #define Py_PRINT_RAW	1	/* No string quotes etc. */
@@ -358,10 +358,10 @@ environment the global variable trick is not safe.)
 #endif
 
 #ifdef Py_TRACE_REFS
-extern void _Py_Dealloc Py_PROTO((PyObject *));
-extern void _Py_NewReference Py_PROTO((PyObject *));
-extern void _Py_ForgetReference Py_PROTO((PyObject *));
-extern void _Py_PrintReferences Py_PROTO((FILE *));
+extern DL_IMPORT(void) _Py_Dealloc Py_PROTO((PyObject *));
+extern DL_IMPORT(void) _Py_NewReference Py_PROTO((PyObject *));
+extern DL_IMPORT(void) _Py_ForgetReference Py_PROTO((PyObject *));
+extern DL_IMPORT(void) _Py_PrintReferences Py_PROTO((FILE *));
 #endif
 
 #ifndef Py_TRACE_REFS
@@ -375,12 +375,12 @@ extern void _Py_PrintReferences Py_PROTO((FILE *));
 #endif /* !Py_TRACE_REFS */
 
 #ifdef COUNT_ALLOCS
-extern void inc_count Py_PROTO((PyTypeObject *));
+extern DL_IMPORT(void) inc_count Py_PROTO((PyTypeObject *));
 #endif
 
 #ifdef Py_REF_DEBUG
 
-extern long _Py_RefTotal;
+extern DL_IMPORT(long) _Py_RefTotal;
 
 #ifndef Py_TRACE_REFS
 #ifdef COUNT_ALLOCS

Include/objimpl.h

@@ -55,8 +55,8 @@ n * tp_itemsize.  This fills in the ob_size field as well.
 */
 
 #ifndef MS_COREDLL
-extern PyObject *_PyObject_New Py_PROTO((PyTypeObject *));
-extern PyVarObject *_PyObject_NewVar Py_PROTO((PyTypeObject *, int));
+extern DL_IMPORT(PyObject *) _PyObject_New Py_PROTO((PyTypeObject *));
+extern DL_IMPORT(PyVarObject *) _PyObject_NewVar Py_PROTO((PyTypeObject *, int));
 
 #define PyObject_NEW(type, typeobj) ((type *) _PyObject_New(typeobj))
 #define PyObject_NEW_VAR(type, typeobj, n) ((type *) _PyObject_NewVar(typeobj, n))
@@ -66,8 +66,8 @@ extern PyVarObject *_PyObject_NewVar Py_PROTO((PyTypeObject *, int));
    extension module's malloc is used, rather than the core DLL malloc, as there is
    no guarantee they will use the same heap
 */
-extern PyObject *_PyObject_New Py_PROTO((PyTypeObject *, PyObject *));
-extern PyVarObject *_PyObject_NewVar Py_PROTO((PyTypeObject *, int, PyVarObject *));
+extern DL_IMPORT(PyObject *) _PyObject_New Py_PROTO((PyTypeObject *, PyObject *));
+extern DL_IMPORT(PyVarObject *) _PyObject_NewVar Py_PROTO((PyTypeObject *, int, PyVarObject *));
 
 #define PyObject_NEW(type, typeobj) ((type *) _PyObject_New(typeobj,(PyObject *)malloc((typeobj)->tp_basicsize)))
 #define PyObject_NEW_VAR(type, typeobj, n) ((type *) _PyObject_NewVar(typeobj, n, (PyVarObject *)malloc((typeobj)->tp_basicsize + n * (typeobj)->tp_itemsize)))

Include/parsetok.h

@@ -45,8 +45,8 @@ typedef struct {
 	char *text;
 } perrdetail;
 
-extern node *PyParser_ParseString Py_PROTO((char *, grammar *, int, perrdetail *));
-extern node *PyParser_ParseFile Py_PROTO((FILE *, char *, grammar *, int,
+extern DL_IMPORT(node *) PyParser_ParseString Py_PROTO((char *, grammar *, int, perrdetail *));
+extern DL_IMPORT(node *) PyParser_ParseFile Py_PROTO((FILE *, char *, grammar *, int,
 			    char *, char *, perrdetail *));
 
 #ifdef __cplusplus

Include/pgenheaders.h

@@ -62,12 +62,12 @@ PERFORMANCE OF THIS SOFTWARE.
 #include "pydebug.h"
 
 #ifdef HAVE_STDARG_PROTOTYPES
-void PySys_WriteStdout(const char *format, ...);
-void PySys_WriteStderr(const char *format, ...);
+DL_IMPORT(void) PySys_WriteStdout(const char *format, ...);
+DL_IMPORT(void) PySys_WriteStderr(const char *format, ...);
 #else
 /* Better to have no prototypes at all for varargs functions in this case */
-void PySys_WriteStdout();
-void PySys_WriteStderr();
+DL_IMPORT(void) PySys_WriteStdout();
+DL_IMPORT(void) PySys_WriteStderr();
 #endif
 
 #define addarc _Py_addarc

Include/pydebug.h

@@ -44,7 +44,7 @@ extern DL_IMPORT(int) Py_UseClassExceptionsFlag;
 extern DL_IMPORT(int) Py_FrozenFlag;
 extern DL_IMPORT(int) Py_TabcheckFlag;
 
-void Py_FatalError	Py_PROTO((char *));
+DL_IMPORT(void) Py_FatalError	Py_PROTO((char *));
 
 #ifdef __cplusplus
 }

Include/pyerrors.h

@@ -37,18 +37,18 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Error handling definitions */
 
-void PyErr_SetNone Py_PROTO((PyObject *));
-void PyErr_SetObject Py_PROTO((PyObject *, PyObject *));
-void PyErr_SetString Py_PROTO((PyObject *, const char *));
-PyObject *PyErr_Occurred Py_PROTO((void));
-void PyErr_Clear Py_PROTO((void));
-void PyErr_Fetch Py_PROTO((PyObject **, PyObject **, PyObject **));
-void PyErr_Restore Py_PROTO((PyObject *, PyObject *, PyObject *));
+DL_IMPORT(void) PyErr_SetNone Py_PROTO((PyObject *));
+DL_IMPORT(void) PyErr_SetObject Py_PROTO((PyObject *, PyObject *));
+DL_IMPORT(void) PyErr_SetString Py_PROTO((PyObject *, const char *));
+DL_IMPORT(PyObject *) PyErr_Occurred Py_PROTO((void));
+DL_IMPORT(void) PyErr_Clear Py_PROTO((void));
+DL_IMPORT(void) PyErr_Fetch Py_PROTO((PyObject **, PyObject **, PyObject **));
+DL_IMPORT(void) PyErr_Restore Py_PROTO((PyObject *, PyObject *, PyObject *));
 
 /* Error testing and normalization */
-int PyErr_GivenExceptionMatches Py_PROTO((PyObject *, PyObject *));
-int PyErr_ExceptionMatches Py_PROTO((PyObject *));
-void PyErr_NormalizeException Py_PROTO((PyObject**, PyObject**, PyObject**));
+DL_IMPORT(int) PyErr_GivenExceptionMatches Py_PROTO((PyObject *, PyObject *));
+DL_IMPORT(int) PyErr_ExceptionMatches Py_PROTO((PyObject *));
+DL_IMPORT(void) PyErr_NormalizeException Py_PROTO((PyObject**, PyObject**, PyObject**));
 
 
 /* Predefined exceptions */
@@ -86,21 +86,21 @@ extern DL_IMPORT(PyObject *) PyExc_MemoryErrorInst;
 
 /* Convenience functions */
 
-extern int PyErr_BadArgument Py_PROTO((void));
-extern PyObject *PyErr_NoMemory Py_PROTO((void));
-extern PyObject *PyErr_SetFromErrno Py_PROTO((PyObject *));
-extern PyObject *PyErr_SetFromErrnoWithFilename Py_PROTO((PyObject *, char *));
-extern PyObject *PyErr_Format Py_PROTO((PyObject *, const char *, ...));
+extern DL_IMPORT(int) PyErr_BadArgument Py_PROTO((void));
+extern DL_IMPORT(PyObject *) PyErr_NoMemory Py_PROTO((void));
+extern DL_IMPORT(PyObject *) PyErr_SetFromErrno Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyErr_SetFromErrnoWithFilename Py_PROTO((PyObject *, char *));
+extern DL_IMPORT(PyObject *) PyErr_Format Py_PROTO((PyObject *, const char *, ...));
 
-extern void PyErr_BadInternalCall Py_PROTO((void));
+extern DL_IMPORT(void) PyErr_BadInternalCall Py_PROTO((void));
 
 /* Function to create a new exception */
-PyObject *PyErr_NewException Py_PROTO((char *name, PyObject *base,
+DL_IMPORT(PyObject *) PyErr_NewException Py_PROTO((char *name, PyObject *base,
 				       PyObject *dict));
 
 /* In sigcheck.c or signalmodule.c */
-extern int PyErr_CheckSignals Py_PROTO((void));
-extern void PyErr_SetInterrupt Py_PROTO((void));
+extern DL_IMPORT(int) PyErr_CheckSignals Py_PROTO((void));
+extern DL_IMPORT(void) PyErr_SetInterrupt Py_PROTO((void));
 	
 
 #ifdef __cplusplus

Include/pystate.h

@@ -89,17 +89,17 @@ typedef struct _ts {
 } PyThreadState;
 
 
-PyInterpreterState *PyInterpreterState_New Py_PROTO((void));
-void PyInterpreterState_Clear Py_PROTO((PyInterpreterState *));
-void PyInterpreterState_Delete Py_PROTO((PyInterpreterState *));
+DL_IMPORT(PyInterpreterState *) PyInterpreterState_New Py_PROTO((void));
+DL_IMPORT(void) PyInterpreterState_Clear Py_PROTO((PyInterpreterState *));
+DL_IMPORT(void) PyInterpreterState_Delete Py_PROTO((PyInterpreterState *));
 
-PyThreadState *PyThreadState_New Py_PROTO((PyInterpreterState *));
-void PyThreadState_Clear Py_PROTO((PyThreadState *));
-void PyThreadState_Delete Py_PROTO((PyThreadState *));
+DL_IMPORT(PyThreadState *) PyThreadState_New Py_PROTO((PyInterpreterState *));
+DL_IMPORT(void) PyThreadState_Clear Py_PROTO((PyThreadState *));
+DL_IMPORT(void) PyThreadState_Delete Py_PROTO((PyThreadState *));
 
-PyThreadState *PyThreadState_Get Py_PROTO((void));
-PyThreadState *PyThreadState_Swap Py_PROTO((PyThreadState *));
-PyObject *PyThreadState_GetDict Py_PROTO((void));
+DL_IMPORT(PyThreadState *) PyThreadState_Get Py_PROTO((void));
+DL_IMPORT(PyThreadState *) PyThreadState_Swap Py_PROTO((PyThreadState *));
+DL_IMPORT(PyObject *) PyThreadState_GetDict Py_PROTO((void));
 
 #ifdef __cplusplus
 }

Include/pythonrun.h

@@ -37,77 +37,77 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* Interfaces to parse and execute pieces of python code */
 
-void Py_SetProgramName Py_PROTO((char *));
-char *Py_GetProgramName Py_PROTO((void));
+DL_IMPORT(void) Py_SetProgramName Py_PROTO((char *));
+DL_IMPORT(char *) Py_GetProgramName Py_PROTO((void));
 
-void Py_SetPythonHome Py_PROTO((char *));
-char *Py_GetPythonHome Py_PROTO((void));
+DL_IMPORT(void) Py_SetPythonHome Py_PROTO((char *));
+DL_IMPORT(char *) Py_GetPythonHome Py_PROTO((void));
 
-void Py_Initialize Py_PROTO((void));
-void Py_Finalize Py_PROTO((void));
-int Py_IsInitialized Py_PROTO((void));
-PyThreadState *Py_NewInterpreter Py_PROTO((void));
-void Py_EndInterpreter Py_PROTO((PyThreadState *));
+DL_IMPORT(void) Py_Initialize Py_PROTO((void));
+DL_IMPORT(void) Py_Finalize Py_PROTO((void));
+DL_IMPORT(int) Py_IsInitialized Py_PROTO((void));
+DL_IMPORT(PyThreadState *) Py_NewInterpreter Py_PROTO((void));
+DL_IMPORT(void) Py_EndInterpreter Py_PROTO((PyThreadState *));
 
-int PyRun_AnyFile Py_PROTO((FILE *, char *));
+DL_IMPORT(int) PyRun_AnyFile Py_PROTO((FILE *, char *));
 
-int PyRun_SimpleString Py_PROTO((char *));
-int PyRun_SimpleFile Py_PROTO((FILE *, char *));
-int PyRun_InteractiveOne Py_PROTO((FILE *, char *));
-int PyRun_InteractiveLoop Py_PROTO((FILE *, char *));
+DL_IMPORT(int) PyRun_SimpleString Py_PROTO((char *));
+DL_IMPORT(int) PyRun_SimpleFile Py_PROTO((FILE *, char *));
+DL_IMPORT(int) PyRun_InteractiveOne Py_PROTO((FILE *, char *));
+DL_IMPORT(int) PyRun_InteractiveLoop Py_PROTO((FILE *, char *));
 
-struct _node *PyParser_SimpleParseString Py_PROTO((char *, int));
-struct _node *PyParser_SimpleParseFile Py_PROTO((FILE *, char *, int));
+DL_IMPORT(struct _node *) PyParser_SimpleParseString Py_PROTO((char *, int));
+DL_IMPORT(struct _node *) PyParser_SimpleParseFile Py_PROTO((FILE *, char *, int));
 
-PyObject *PyRun_String Py_PROTO((char *, int, PyObject *, PyObject *));
-PyObject *PyRun_File Py_PROTO((FILE *, char *, int, PyObject *, PyObject *));
+DL_IMPORT(PyObject *) PyRun_String Py_PROTO((char *, int, PyObject *, PyObject *));
+DL_IMPORT(PyObject *) PyRun_File Py_PROTO((FILE *, char *, int, PyObject *, PyObject *));
 
-PyObject *Py_CompileString Py_PROTO((char *, char *, int));
+DL_IMPORT(PyObject *) Py_CompileString Py_PROTO((char *, char *, int));
 
-void PyErr_Print Py_PROTO((void));
-void PyErr_PrintEx Py_PROTO((int));
+DL_IMPORT(void) PyErr_Print Py_PROTO((void));
+DL_IMPORT(void) PyErr_PrintEx Py_PROTO((int));
 
-int Py_AtExit Py_PROTO((void (*func) Py_PROTO((void))));
+DL_IMPORT(int) Py_AtExit Py_PROTO((void (*func) Py_PROTO((void))));
 
-void Py_Exit Py_PROTO((int));
+DL_IMPORT(void) Py_Exit Py_PROTO((int));
 
-int Py_FdIsInteractive Py_PROTO((FILE *, char *));
+DL_IMPORT(int) Py_FdIsInteractive Py_PROTO((FILE *, char *));
 
 /* In getpath.c */
-char *Py_GetProgramFullPath Py_PROTO((void));
-char *Py_GetPrefix Py_PROTO((void));
-char *Py_GetExecPrefix Py_PROTO((void));
-char *Py_GetPath Py_PROTO((void));
+DL_IMPORT(char *) Py_GetProgramFullPath Py_PROTO((void));
+DL_IMPORT(char *) Py_GetPrefix Py_PROTO((void));
+DL_IMPORT(char *) Py_GetExecPrefix Py_PROTO((void));
+DL_IMPORT(char *) Py_GetPath Py_PROTO((void));
 
 /* In their own files */
-const char *Py_GetVersion Py_PROTO((void));
-const char *Py_GetPlatform Py_PROTO((void));
-const char *Py_GetCopyright Py_PROTO((void));
-const char *Py_GetCompiler Py_PROTO((void));
-const char *Py_GetBuildInfo Py_PROTO((void));
+DL_IMPORT(const char *) Py_GetVersion Py_PROTO((void));
+DL_IMPORT(const char *) Py_GetPlatform Py_PROTO((void));
+DL_IMPORT(const char *) Py_GetCopyright Py_PROTO((void));
+DL_IMPORT(const char *) Py_GetCompiler Py_PROTO((void));
+DL_IMPORT(const char *) Py_GetBuildInfo Py_PROTO((void));
 
 /* Internal -- various one-time initializations */
 
-PyObject *_PyBuiltin_Init_1 Py_PROTO((void));
-void _PyBuiltin_Init_2 Py_PROTO((PyObject *));
-PyObject *_PySys_Init Py_PROTO((void));
-void _PyImport_Init Py_PROTO((void));
+DL_IMPORT(PyObject *) _PyBuiltin_Init_1 Py_PROTO((void));
+DL_IMPORT(void) _PyBuiltin_Init_2 Py_PROTO((PyObject *));
+DL_IMPORT(PyObject *) _PySys_Init Py_PROTO((void));
+DL_IMPORT(void) _PyImport_Init Py_PROTO((void));
 
 /* Various internal finalizers */
-void _PyImport_Fini Py_PROTO((void));
-void _PyBuiltin_Fini_1 Py_PROTO((void));
-void _PyBuiltin_Fini_2 Py_PROTO((void));
-void PyMethod_Fini Py_PROTO((void));
-void PyFrame_Fini Py_PROTO((void));
-void PyCFunction_Fini Py_PROTO((void));
-void PyTuple_Fini Py_PROTO((void));
-void PyString_Fini Py_PROTO((void));
-void PyInt_Fini Py_PROTO((void));
-void PyFloat_Fini Py_PROTO((void));
-void PyOS_FiniInterrupts Py_PROTO((void));
+DL_IMPORT(void) _PyImport_Fini Py_PROTO((void));
+DL_IMPORT(void) _PyBuiltin_Fini_1 Py_PROTO((void));
+DL_IMPORT(void) _PyBuiltin_Fini_2 Py_PROTO((void));
+DL_IMPORT(void) PyMethod_Fini Py_PROTO((void));
+DL_IMPORT(void) PyFrame_Fini Py_PROTO((void));
+DL_IMPORT(void) PyCFunction_Fini Py_PROTO((void));
+DL_IMPORT(void) PyTuple_Fini Py_PROTO((void));
+DL_IMPORT(void) PyString_Fini Py_PROTO((void));
+DL_IMPORT(void) PyInt_Fini Py_PROTO((void));
+DL_IMPORT(void) PyFloat_Fini Py_PROTO((void));
+DL_IMPORT(void) PyOS_FiniInterrupts Py_PROTO((void));
 
 /* Stuff with no proper home (yet) */
-char *PyOS_Readline Py_PROTO((char *));
+DL_IMPORT(char *) PyOS_Readline Py_PROTO((char *));
 extern DL_IMPORT(int) (*PyOS_InputHook) Py_PROTO((void));
 extern DL_IMPORT(char) *(*PyOS_ReadlineFunctionPointer) Py_PROTO((char *));
 

Include/pythread.h

@@ -48,40 +48,40 @@ extern "C" {
 #define set_key_value PyThread_set_key_value
 
 
-void init_thread Py_PROTO((void));
-int start_new_thread Py_PROTO((void (*)(void *), void *));
+DL_IMPORT(void) init_thread Py_PROTO((void));
+DL_IMPORT(int) start_new_thread Py_PROTO((void (*)(void *), void *));
 #ifndef __BEOS__
-void exit_thread Py_PROTO((void));
-void _exit_thread Py_PROTO((void));
+DL_IMPORT(void) exit_thread Py_PROTO((void));
+DL_IMPORT(void) _exit_thread Py_PROTO((void));
 #else
-void PyThread_exit_thread Py_PROTO((void));
-void PyThread__exit_thread Py_PROTO((void));
+DL_IMPORT(void) PyThread_exit_thread Py_PROTO((void));
+DL_IMPORT(void) PyThread__exit_thread Py_PROTO((void));
 #endif
-long get_thread_ident Py_PROTO((void));
+DL_IMPORT(long) get_thread_ident Py_PROTO((void));
 
-type_lock allocate_lock Py_PROTO((void));
-void free_lock Py_PROTO((type_lock));
-int acquire_lock Py_PROTO((type_lock, int));
+DL_IMPORT(type_lock) allocate_lock Py_PROTO((void));
+DL_IMPORT(void) free_lock Py_PROTO((type_lock));
+DL_IMPORT(int) acquire_lock Py_PROTO((type_lock, int));
 #define WAIT_LOCK	1
 #define NOWAIT_LOCK	0
-void release_lock Py_PROTO((type_lock));
+DL_IMPORT(void) release_lock Py_PROTO((type_lock));
 
-type_sema allocate_sema Py_PROTO((int));
-void free_sema Py_PROTO((type_sema));
-int down_sema Py_PROTO((type_sema, int));
+DL_IMPORT(type_sema) allocate_sema Py_PROTO((int));
+DL_IMPORT(void) free_sema Py_PROTO((type_sema));
+DL_IMPORT(int) down_sema Py_PROTO((type_sema, int));
 #define WAIT_SEMA	1
 #define NOWAIT_SEMA	0
-void up_sema Py_PROTO((type_sema));
+DL_IMPORT(void) up_sema Py_PROTO((type_sema));
 
 #ifndef NO_EXIT_PROG
-void exit_prog Py_PROTO((int));
-void _exit_prog Py_PROTO((int));
+DL_IMPORT(void) exit_prog Py_PROTO((int));
+DL_IMPORT(void) _exit_prog Py_PROTO((int));
 #endif
 
-int create_key Py_PROTO((void));
-void delete_key Py_PROTO((int));
-int set_key_value Py_PROTO((int, void *));
-void * get_key_value Py_PROTO((int));
+DL_IMPORT(int) create_key Py_PROTO((void));
+DL_IMPORT(void) delete_key Py_PROTO((int));
+DL_IMPORT(int) set_key_value Py_PROTO((int, void *));
+DL_IMPORT(void *) get_key_value Py_PROTO((int));
 
 #ifdef __cplusplus
 }

Include/rangeobject.h

@@ -43,4 +43,4 @@ extern DL_IMPORT(PyTypeObject) PyRange_Type;
 
 #define PyRange_Check(op) ((op)->ob_type == &PyRange_Type)
 
-extern PyObject *PyRange_New Py_PROTO((long, long, long, int));
+extern DL_IMPORT(PyObject *) PyRange_New Py_PROTO((long, long, long, int));

Include/sliceobject.h

@@ -28,9 +28,9 @@ extern DL_IMPORT(PyTypeObject) PySlice_Type;
 
 #define PySlice_Check(op) ((op)->ob_type == &PySlice_Type)
 
-PyObject *PySlice_New Py_PROTO((
+DL_IMPORT(PyObject *) PySlice_New Py_PROTO((
 	PyObject* start, PyObject* stop, PyObject* step));
-int PySlice_GetIndices Py_PROTO((
+DL_IMPORT(int) PySlice_GetIndices Py_PROTO((
 	PySliceObject *r, int length, int *start, int *stop, int *step));
 
 #ifdef __cplusplus

Include/stringobject.h

@@ -81,18 +81,18 @@ extern DL_IMPORT(PyTypeObject) PyString_Type;
 
 #define PyString_Check(op) ((op)->ob_type == &PyString_Type)
 
-extern PyObject *PyString_FromStringAndSize Py_PROTO((const char *, int));
-extern PyObject *PyString_FromString Py_PROTO((const char *));
-extern int PyString_Size Py_PROTO((PyObject *));
-extern char *PyString_AsString Py_PROTO((PyObject *));
-extern void PyString_Concat Py_PROTO((PyObject **, PyObject *));
-extern void PyString_ConcatAndDel Py_PROTO((PyObject **, PyObject *));
-extern int _PyString_Resize Py_PROTO((PyObject **, int));
-extern PyObject *PyString_Format Py_PROTO((PyObject *, PyObject *));
+extern DL_IMPORT(PyObject *) PyString_FromStringAndSize Py_PROTO((const char *, int));
+extern DL_IMPORT(PyObject *) PyString_FromString Py_PROTO((const char *));
+extern DL_IMPORT(int) PyString_Size Py_PROTO((PyObject *));
+extern DL_IMPORT(char *) PyString_AsString Py_PROTO((PyObject *));
+extern DL_IMPORT(void) PyString_Concat Py_PROTO((PyObject **, PyObject *));
+extern DL_IMPORT(void) PyString_ConcatAndDel Py_PROTO((PyObject **, PyObject *));
+extern DL_IMPORT(int) _PyString_Resize Py_PROTO((PyObject **, int));
+extern DL_IMPORT(PyObject *) PyString_Format Py_PROTO((PyObject *, PyObject *));
 
 #ifdef INTERN_STRINGS
-extern void PyString_InternInPlace Py_PROTO((PyObject **));
-extern PyObject *PyString_InternFromString Py_PROTO((const char *));
+extern DL_IMPORT(void) PyString_InternInPlace Py_PROTO((PyObject **));
+extern DL_IMPORT(PyObject *) PyString_InternFromString Py_PROTO((const char *));
 #else
 #define PyString_InternInPlace(p)
 #define PyString_InternFromString(cp) PyString_FromString(cp)

Include/structmember.h

@@ -92,8 +92,8 @@ struct memberlist {
 #define READONLY	1
 #define RO		READONLY		/* Shorthand */
 
-PyObject *PyMember_Get Py_PROTO((char *, struct memberlist *, char *));
-int PyMember_Set Py_PROTO((char *, struct memberlist *, char *, PyObject *));
+DL_IMPORT(PyObject *) PyMember_Get Py_PROTO((char *, struct memberlist *, char *));
+DL_IMPORT(int) PyMember_Set Py_PROTO((char *, struct memberlist *, char *, PyObject *));
 
 #ifdef __cplusplus
 }

Include/sysmodule.h

@@ -37,19 +37,19 @@ PERFORMANCE OF THIS SOFTWARE.
 
 /* System module interface */
 
-PyObject *PySys_GetObject Py_PROTO((char *));
-int PySys_SetObject Py_PROTO((char *, PyObject *));
-FILE *PySys_GetFile Py_PROTO((char *, FILE *));
-void PySys_SetArgv Py_PROTO((int, char **));
-void PySys_SetPath Py_PROTO((char *));
+DL_IMPORT(PyObject *) PySys_GetObject Py_PROTO((char *));
+DL_IMPORT(int) PySys_SetObject Py_PROTO((char *, PyObject *));
+DL_IMPORT(FILE *) PySys_GetFile Py_PROTO((char *, FILE *));
+DL_IMPORT(void) PySys_SetArgv Py_PROTO((int, char **));
+DL_IMPORT(void) PySys_SetPath Py_PROTO((char *));
 
 #ifdef HAVE_STDARG_PROTOTYPES
-void PySys_WriteStdout(const char *format, ...);
-void PySys_WriteStderr(const char *format, ...);
+DL_IMPORT(void) PySys_WriteStdout(const char *format, ...);
+DL_IMPORT(void) PySys_WriteStderr(const char *format, ...);
 #else
 /* Better to have no prototypes at all for varargs functions in this case */
-void PySys_WriteStdout();
-void PySys_WriteStderr();
+DL_IMPORT(void) PySys_WriteStdout();
+DL_IMPORT(void) PySys_WriteStderr();
 #endif
 
 extern DL_IMPORT(PyObject *) _PySys_TraceFunc, *_PySys_ProfileFunc;

Include/token.h

@@ -88,9 +88,9 @@ PERFORMANCE OF THIS SOFTWARE.
 #define ISEOF(x)		((x) == ENDMARKER)
 
 
-extern char *_PyParser_TokenNames[]; /* Token names */
-extern int PyToken_OneChar Py_PROTO((int));
-extern int PyToken_TwoChars Py_PROTO((int, int));
+extern DL_IMPORT(char *) _PyParser_TokenNames[]; /* Token names */
+extern DL_IMPORT(int) PyToken_OneChar Py_PROTO((int));
+extern DL_IMPORT(int) PyToken_TwoChars Py_PROTO((int, int));
 
 #ifdef __cplusplus
 }

Include/traceback.h

@@ -39,13 +39,13 @@ PERFORMANCE OF THIS SOFTWARE.
 
 struct _frame;
 
-int PyTraceBack_Here Py_PROTO((struct _frame *));
-PyObject *PyTraceBack_Fetch Py_PROTO((void));
-int PyTraceBack_Store Py_PROTO((PyObject *));
-int PyTraceBack_Print Py_PROTO((PyObject *, PyObject *));
+DL_IMPORT(int) PyTraceBack_Here Py_PROTO((struct _frame *));
+DL_IMPORT(PyObject *) PyTraceBack_Fetch Py_PROTO((void));
+DL_IMPORT(int) PyTraceBack_Store Py_PROTO((PyObject *));
+DL_IMPORT(int) PyTraceBack_Print Py_PROTO((PyObject *, PyObject *));
 
 /* Reveale traceback type so we can typecheck traceback objects */
-extern PyTypeObject PyTraceBack_Type;
+extern DL_IMPORT(PyTypeObject) PyTraceBack_Type;
 #define PyTraceBack_Check(v) ((v)->ob_type == &PyTraceBack_Type)
 
 #ifdef __cplusplus

Include/tupleobject.h

@@ -60,12 +60,12 @@ extern DL_IMPORT(PyTypeObject) PyTuple_Type;
 
 #define PyTuple_Check(op) ((op)->ob_type == &PyTuple_Type)
 
-extern PyObject *PyTuple_New Py_PROTO((int size));
-extern int PyTuple_Size Py_PROTO((PyObject *));
-extern PyObject *PyTuple_GetItem Py_PROTO((PyObject *, int));
-extern int PyTuple_SetItem Py_PROTO((PyObject *, int, PyObject *));
-extern PyObject *PyTuple_GetSlice Py_PROTO((PyObject *, int, int));
-extern int _PyTuple_Resize Py_PROTO((PyObject **, int, int));
+extern DL_IMPORT(PyObject *) PyTuple_New Py_PROTO((int size));
+extern DL_IMPORT(int) PyTuple_Size Py_PROTO((PyObject *));
+extern DL_IMPORT(PyObject *) PyTuple_GetItem Py_PROTO((PyObject *, int));
+extern DL_IMPORT(int) PyTuple_SetItem Py_PROTO((PyObject *, int, PyObject *));
+extern DL_IMPORT(PyObject *) PyTuple_GetSlice Py_PROTO((PyObject *, int, int));
+extern DL_IMPORT(int) _PyTuple_Resize Py_PROTO((PyObject **, int, int));
 
 /* Macro, trading safety for speed */
 #define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i])