Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-30 21:21:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

Add DL_IMPORT(returntype) for all officially exported functions.

Browse source
This commit is contained in:
Guido van Rossum 1998-12-04 18:48:25 +00:00
parent b241b67b89
commit 43466ec7b0
44 changed files with 401 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Include/Python.h
View file

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

102
Include/abstract.h
View file

@ -254,7 +254,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
#define PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A),NULL) #define PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A),NULL)
int PyObject_Cmp Py_PROTO((PyObject *o1, PyObject *o2, int *result)); DL_IMPORT(int) PyObject_Cmp Py_PROTO((PyObject *o1, PyObject *o2, int *result));
/* /*
Compare the values of o1 and o2 using a routine provided by Compare the values of o1 and o2 using a routine provided by
@ -302,7 +302,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
int PyCallable_Check Py_PROTO((PyObject *o)); DL_IMPORT(int) PyCallable_Check Py_PROTO((PyObject *o));
/* /*
Determine if the object, o, is callable. Return 1 if the Determine if the object, o, is callable. Return 1 if the
@ -314,7 +314,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
PyObject *PyObject_CallObject Py_PROTO((PyObject *callable_object, DL_IMPORT(PyObject *) PyObject_CallObject Py_PROTO((PyObject *callable_object,
PyObject *args)); PyObject *args));
/* /*
@ -327,7 +327,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyObject_CallFunction Py_PROTO((PyObject *callable_object, DL_IMPORT(PyObject *) PyObject_CallFunction Py_PROTO((PyObject *callable_object,
char *format, ...)); char *format, ...));
/* /*
@ -341,7 +341,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyObject_CallMethod Py_PROTO((PyObject *o, char *m, DL_IMPORT(PyObject *) PyObject_CallMethod Py_PROTO((PyObject *o, char *m,
char *format, ...)); char *format, ...));
/* /*
@ -394,7 +394,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyObject_Type Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyObject_Type Py_PROTO((PyObject *o));
/* /*
On success, returns a type object corresponding to the object On success, returns a type object corresponding to the object
@ -402,7 +402,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
equivalent to the Python expression: type(o). equivalent to the Python expression: type(o).
*/ */
int PyObject_Length Py_PROTO((PyObject *o)); DL_IMPORT(int) PyObject_Length Py_PROTO((PyObject *o));
/* /*
Return the length of object o. If the object, o, provides Return the length of object o. If the object, o, provides
@ -412,7 +412,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyObject_GetItem Py_PROTO((PyObject *o, PyObject *key)); DL_IMPORT(PyObject *) PyObject_GetItem Py_PROTO((PyObject *o, PyObject *key));
/* /*
Return element of o corresponding to the object, key, or NULL Return element of o corresponding to the object, key, or NULL
@ -421,7 +421,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
int PyObject_SetItem Py_PROTO((PyObject *o, PyObject *key, PyObject *v)); DL_IMPORT(int) PyObject_SetItem Py_PROTO((PyObject *o, PyObject *key, PyObject *v));
/* /*
Map the object, key, to the value, v. Returns Map the object, key, to the value, v. Returns
@ -429,7 +429,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
statement: o[key]=v. statement: o[key]=v.
*/ */
int PyObject_DelItem Py_PROTO((PyObject *o, PyObject *key)); DL_IMPORT(int) PyObject_DelItem Py_PROTO((PyObject *o, PyObject *key));
/* /*
Delete the mapping for key from *o. Returns -1 on failure. Delete the mapping for key from *o. Returns -1 on failure.
@ -439,7 +439,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
/* Number Protocol:*/ /* Number Protocol:*/
int PyNumber_Check Py_PROTO((PyObject *o)); DL_IMPORT(int) PyNumber_Check Py_PROTO((PyObject *o));
/* /*
Returns 1 if the object, o, provides numeric protocols, and Returns 1 if the object, o, provides numeric protocols, and
@ -449,7 +449,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Add Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Add Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of adding o1 and o2, or null on failure. Returns the result of adding o1 and o2, or null on failure.
@ -458,7 +458,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Subtract Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Subtract Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of subtracting o2 from o1, or null on Returns the result of subtracting o2 from o1, or null on
@ -467,7 +467,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Multiply Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Multiply Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of multiplying o1 and o2, or null on Returns the result of multiplying o1 and o2, or null on
@ -477,7 +477,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Divide Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Divide Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of dividing o1 by o2, or null on failure. Returns the result of dividing o1 by o2, or null on failure.
@ -486,7 +486,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Remainder Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Remainder Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the remainder of dividing o1 by o2, or null on Returns the remainder of dividing o1 by o2, or null on
@ -496,7 +496,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Divmod Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Divmod Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
See the built-in function divmod. Returns NULL on failure. See the built-in function divmod. Returns NULL on failure.
@ -506,7 +506,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Power Py_PROTO((PyObject *o1, PyObject *o2, PyObject *o3)); DL_IMPORT(PyObject *) PyNumber_Power Py_PROTO((PyObject *o1, PyObject *o2, PyObject *o3));
/* /*
See the built-in function pow. Returns NULL on failure. See the built-in function pow. Returns NULL on failure.
@ -515,7 +515,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Negative Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Negative Py_PROTO((PyObject *o));
/* /*
Returns the negation of o on success, or null on failure. Returns the negation of o on success, or null on failure.
@ -523,7 +523,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Positive Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Positive Py_PROTO((PyObject *o));
/* /*
Returns the (what?) of o on success, or NULL on failure. Returns the (what?) of o on success, or NULL on failure.
@ -531,7 +531,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Absolute Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Absolute Py_PROTO((PyObject *o));
/* /*
Returns the absolute value of o, or null on failure. This is Returns the absolute value of o, or null on failure. This is
@ -539,7 +539,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Invert Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Invert Py_PROTO((PyObject *o));
/* /*
Returns the bitwise negation of o on success, or NULL on Returns the bitwise negation of o on success, or NULL on
@ -549,7 +549,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Lshift Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Lshift Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of left shifting o1 by o2 on success, or Returns the result of left shifting o1 by o2 on success, or
@ -559,7 +559,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Rshift Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Rshift Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of right shifting o1 by o2 on success, or Returns the result of right shifting o1 by o2 on success, or
@ -568,7 +568,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_And Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_And Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of bitwise and of o1 and o2 on success, or Returns the result of bitwise and of o1 and o2 on success, or
@ -578,7 +578,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Xor Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Xor Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the bitwise exclusive or of o1 by o2 on success, or Returns the bitwise exclusive or of o1 by o2 on success, or
@ -588,7 +588,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Or Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PyNumber_Or Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Returns the result of bitwise or or o1 and o2 on success, or Returns the result of bitwise or or o1 and o2 on success, or
@ -616,7 +616,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Int Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Int Py_PROTO((PyObject *o));
/* /*
Returns the o converted to an integer object on success, or Returns the o converted to an integer object on success, or
@ -625,7 +625,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Long Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Long Py_PROTO((PyObject *o));
/* /*
Returns the o converted to a long integer object on success, Returns the o converted to a long integer object on success,
@ -634,7 +634,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PyNumber_Float Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PyNumber_Float Py_PROTO((PyObject *o));
/* /*
Returns the o converted to a float object on success, or NULL Returns the o converted to a float object on success, or NULL
@ -645,7 +645,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
/* Sequence protocol:*/ /* Sequence protocol:*/
int PySequence_Check Py_PROTO((PyObject *o)); DL_IMPORT(int) PySequence_Check Py_PROTO((PyObject *o));
/* /*
Return 1 if the object provides sequence protocol, and zero Return 1 if the object provides sequence protocol, and zero
@ -655,14 +655,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
int PySequence_Length Py_PROTO((PyObject *o)); DL_IMPORT(int) PySequence_Length Py_PROTO((PyObject *o));
/* /*
Return the length of sequence object o, or -1 on failure. Return the length of sequence object o, or -1 on failure.
*/ */
PyObject *PySequence_Concat Py_PROTO((PyObject *o1, PyObject *o2)); DL_IMPORT(PyObject *) PySequence_Concat Py_PROTO((PyObject *o1, PyObject *o2));
/* /*
Return the concatination of o1 and o2 on success, and NULL on Return the concatination of o1 and o2 on success, and NULL on
@ -671,7 +671,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PySequence_Repeat Py_PROTO((PyObject *o, int count)); DL_IMPORT(PyObject *) PySequence_Repeat Py_PROTO((PyObject *o, int count));
/* /*
Return the result of repeating sequence object o count times, Return the result of repeating sequence object o count times,
@ -680,7 +680,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PySequence_GetItem Py_PROTO((PyObject *o, int i)); DL_IMPORT(PyObject *) PySequence_GetItem Py_PROTO((PyObject *o, int i));
/* /*
Return the ith element of o, or NULL on failure. This is the Return the ith element of o, or NULL on failure. This is the
@ -688,7 +688,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
PyObject *PySequence_GetSlice Py_PROTO((PyObject *o, int i1, int i2)); DL_IMPORT(PyObject *) PySequence_GetSlice Py_PROTO((PyObject *o, int i1, int i2));
/* /*
Return the slice of sequence object o between i1 and i2, or Return the slice of sequence object o between i1 and i2, or
@ -697,7 +697,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
int PySequence_SetItem Py_PROTO((PyObject *o, int i, PyObject *v)); DL_IMPORT(int) PySequence_SetItem Py_PROTO((PyObject *o, int i, PyObject *v));
/* /*
Assign object v to the ith element of o. Returns Assign object v to the ith element of o. Returns
@ -706,7 +706,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
int PySequence_DelItem Py_PROTO((PyObject *o, int i)); DL_IMPORT(int) PySequence_DelItem Py_PROTO((PyObject *o, int i));
/* /*
Delete the ith element of object v. Returns Delete the ith element of object v. Returns
@ -714,7 +714,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
statement: del o[i]. statement: del o[i].
*/ */
int PySequence_SetSlice Py_PROTO((PyObject *o, int i1, int i2, PyObject *v)); DL_IMPORT(int) PySequence_SetSlice Py_PROTO((PyObject *o, int i1, int i2, PyObject *v));
/* /*
Assign the sequence object, v, to the slice in sequence Assign the sequence object, v, to the slice in sequence
@ -722,7 +722,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
equivalent of the Python statement: o[i1:i2]=v. equivalent of the Python statement: o[i1:i2]=v.
*/ */
int PySequence_DelSlice Py_PROTO((PyObject *o, int i1, int i2)); DL_IMPORT(int) PySequence_DelSlice Py_PROTO((PyObject *o, int i1, int i2));
/* /*
Delete the slice in sequence object, o, from i1 to i2. Delete the slice in sequence object, o, from i1 to i2.
@ -730,21 +730,21 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
statement: del o[i1:i2]. statement: del o[i1:i2].
*/ */
PyObject *PySequence_Tuple Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PySequence_Tuple Py_PROTO((PyObject *o));
/* /*
Returns the sequence, o, as a tuple on success, and NULL on failure. Returns the sequence, o, as a tuple on success, and NULL on failure.
This is equivalent to the Python expression: tuple(o) This is equivalent to the Python expression: tuple(o)
*/ */
PyObject *PySequence_List Py_PROTO((PyObject *o)); DL_IMPORT(PyObject *) PySequence_List Py_PROTO((PyObject *o));
/* /*
Returns the sequence, o, as a list on success, and NULL on failure. Returns the sequence, o, as a list on success, and NULL on failure.
This is equivalent to the Python expression: list(o) This is equivalent to the Python expression: list(o)
*/ */
int PySequence_Count Py_PROTO((PyObject *o, PyObject *value)); DL_IMPORT(int) PySequence_Count Py_PROTO((PyObject *o, PyObject *value));
/* /*
Return the number of occurrences on value on o, that is, Return the number of occurrences on value on o, that is,
@ -753,7 +753,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
expression: o.count(value). expression: o.count(value).
*/ */
int PySequence_Contains Py_PROTO((PyObject *o, PyObject *value)); DL_IMPORT(int) PySequence_Contains Py_PROTO((PyObject *o, PyObject *value));
#define PySequence_In PySequence_Contains #define PySequence_In PySequence_Contains
/* /*
@ -762,7 +762,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
is equivalent to the Python expression: value in o. is equivalent to the Python expression: value in o.
*/ */
int PySequence_Index Py_PROTO((PyObject *o, PyObject *value)); DL_IMPORT(int) PySequence_Index Py_PROTO((PyObject *o, PyObject *value));
/* /*
Return the first index for which o[i]=value. On error, Return the first index for which o[i]=value. On error,
@ -772,7 +772,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
/* Mapping protocol:*/ /* Mapping protocol:*/
int PyMapping_Check Py_PROTO((PyObject *o)); DL_IMPORT(int) PyMapping_Check Py_PROTO((PyObject *o));
/* /*
Return 1 if the object provides mapping protocol, and zero Return 1 if the object provides mapping protocol, and zero
@ -781,7 +781,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
This function always succeeds. This function always succeeds.
*/ */
int PyMapping_Length Py_PROTO((PyObject *o)); DL_IMPORT(int) PyMapping_Length Py_PROTO((PyObject *o));
/* /*
Returns the number of keys in object o on success, and -1 on Returns the number of keys in object o on success, and -1 on
@ -809,7 +809,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
#define PyMapping_DelItem(O,K) PyDict_DelItem((O),(K)) #define PyMapping_DelItem(O,K) PyDict_DelItem((O),(K))
int PyMapping_HasKeyString Py_PROTO((PyObject *o, char *key)); DL_IMPORT(int) PyMapping_HasKeyString Py_PROTO((PyObject *o, char *key));
/* /*
On success, return 1 if the mapping object has the key, key, On success, return 1 if the mapping object has the key, key,
@ -819,7 +819,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
This function always succeeds. This function always succeeds.
*/ */
int PyMapping_HasKey Py_PROTO((PyObject *o, PyObject *key)); DL_IMPORT(int) PyMapping_HasKey Py_PROTO((PyObject *o, PyObject *key));
/* /*
Return 1 if the mapping object has the key, key, Return 1 if the mapping object has the key, key,
@ -862,7 +862,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
*/ */
#define PyMapping_Items(O) PyObject_CallMethod(O,"items",NULL) #define PyMapping_Items(O) PyObject_CallMethod(O,"items",NULL)
PyObject *PyMapping_GetItemString Py_PROTO((PyObject *o, char *key)); DL_IMPORT(PyObject *) PyMapping_GetItemString Py_PROTO((PyObject *o, char *key));
/* /*
Return element of o corresponding to the object, key, or NULL Return element of o corresponding to the object, key, or NULL
@ -870,7 +870,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
o[key]. o[key].
*/ */
int PyMapping_SetItemString Py_PROTO((PyObject *o, char *key, DL_IMPORT(int) PyMapping_SetItemString Py_PROTO((PyObject *o, char *key,
PyObject *value)); PyObject *value));
/* /*

10
Include/bufferobject.h
View file

@ -46,13 +46,13 @@ extern DL_IMPORT(PyTypeObject) PyBuffer_Type;
#define Py_END_OF_BUFFER (-1) #define Py_END_OF_BUFFER (-1)
extern PyObject *PyBuffer_FromObject Py_PROTO((PyObject *base, int offset, int size)); extern DL_IMPORT(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_FromReadWriteObject Py_PROTO((PyObject *base, int offset, int size));
extern PyObject *PyBuffer_FromMemory Py_PROTO((void *ptr, int size)); extern DL_IMPORT(PyObject *) PyBuffer_FromMemory Py_PROTO((void *ptr, int size));
extern PyObject *PyBuffer_FromReadWriteMemory 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 #ifdef __cplusplus
} }

2
Include/cStringIO.h
View file

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

42
Include/ceval.h
View file

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

16
Include/classobject.h
View file

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

10
Include/cobject.h
View file

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

6
Include/compile.h
View file

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

22
Include/complexobject.h
View file

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

26
Include/dictobject.h
View file

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

2
Include/eval.h
View file

@ -37,7 +37,7 @@ PERFORMANCE OF THIS SOFTWARE.
/* Interface to execute compiled code */ /* 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 #ifdef __cplusplus
} }

18
Include/fileobject.h
View file

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

4
Include/floatobject.h
View file

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

12
Include/frameobject.h
View file

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

10
Include/funcobject.h
View file

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

32
Include/import.h
View file

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

6
Include/intobject.h
View file

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

6
Include/intrcheck.h
View file

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

22
Include/listobject.h
View file

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

2
Include/longintrepr.h
View file

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

26
Include/longobject.h
View file

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

16
Include/marshal.h
View file

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

12
Include/methodobject.h
View file

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

22
Include/modsupport.h
View file

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

8
Include/moduleobject.h
View file

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

12
Include/mymalloc.h
View file

@ -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. */ The Python interpreter continues to use PyMem_NEW etc. */
/* These wrappers around malloc call PyErr_NoMemory() on failure */ /* These wrappers around malloc call PyErr_NoMemory() on failure */
extern ANY *Py_Malloc Py_PROTO((size_t)); extern DL_IMPORT(ANY *) Py_Malloc Py_PROTO((size_t));
extern ANY *Py_Realloc Py_PROTO((ANY *, size_t)); extern DL_IMPORT(ANY *) Py_Realloc Py_PROTO((ANY *, size_t));
extern void Py_Free Py_PROTO((ANY *)); extern DL_IMPORT(void) Py_Free Py_PROTO((ANY *));
/* These wrappers around malloc *don't* call anything on failure */ /* These wrappers around malloc *don't* call anything on failure */
extern ANY *PyMem_Malloc Py_PROTO((size_t)); extern DL_IMPORT(ANY *) PyMem_Malloc Py_PROTO((size_t));
extern ANY *PyMem_Realloc Py_PROTO((ANY *, size_t)); extern DL_IMPORT(ANY *) PyMem_Realloc Py_PROTO((ANY *, size_t));
extern void PyMem_Free Py_PROTO((ANY *)); extern DL_IMPORT(void) PyMem_Free Py_PROTO((ANY *));
#ifdef __cplusplus #ifdef __cplusplus
} }

8
Include/node.h
View file

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

48
Include/object.h
View file

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

8
Include/objimpl.h
View file

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

4
Include/parsetok.h
View file

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

8
Include/pgenheaders.h
View file

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

2
Include/pydebug.h
View file

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

38
Include/pyerrors.h
View file

@ -37,18 +37,18 @@ PERFORMANCE OF THIS SOFTWARE.
/* Error handling definitions */ /* Error handling definitions */
void PyErr_SetNone Py_PROTO((PyObject *)); DL_IMPORT(void) PyErr_SetNone Py_PROTO((PyObject *));
void PyErr_SetObject Py_PROTO((PyObject *, PyObject *)); DL_IMPORT(void) PyErr_SetObject Py_PROTO((PyObject *, PyObject *));
void PyErr_SetString Py_PROTO((PyObject *, const char *)); DL_IMPORT(void) PyErr_SetString Py_PROTO((PyObject *, const char *));
PyObject *PyErr_Occurred Py_PROTO((void)); DL_IMPORT(PyObject *) PyErr_Occurred Py_PROTO((void));
void PyErr_Clear Py_PROTO((void)); DL_IMPORT(void) PyErr_Clear Py_PROTO((void));
void PyErr_Fetch Py_PROTO((PyObject **, PyObject **, PyObject **)); DL_IMPORT(void) PyErr_Fetch Py_PROTO((PyObject **, PyObject **, PyObject **));
void PyErr_Restore Py_PROTO((PyObject *, PyObject *, PyObject *)); DL_IMPORT(void) PyErr_Restore Py_PROTO((PyObject *, PyObject *, PyObject *));
/* Error testing and normalization */ /* Error testing and normalization */
int PyErr_GivenExceptionMatches Py_PROTO((PyObject *, PyObject *)); DL_IMPORT(int) PyErr_GivenExceptionMatches Py_PROTO((PyObject *, PyObject *));
int PyErr_ExceptionMatches Py_PROTO((PyObject *)); DL_IMPORT(int) PyErr_ExceptionMatches Py_PROTO((PyObject *));
void PyErr_NormalizeException Py_PROTO((PyObject**, PyObject**, PyObject**)); DL_IMPORT(void) PyErr_NormalizeException Py_PROTO((PyObject**, PyObject**, PyObject**));
/* Predefined exceptions */ /* Predefined exceptions */
@ -86,21 +86,21 @@ extern DL_IMPORT(PyObject *) PyExc_MemoryErrorInst;
/* Convenience functions */ /* Convenience functions */
extern int PyErr_BadArgument Py_PROTO((void)); extern DL_IMPORT(int) PyErr_BadArgument Py_PROTO((void));
extern PyObject *PyErr_NoMemory Py_PROTO((void)); extern DL_IMPORT(PyObject *) PyErr_NoMemory Py_PROTO((void));
extern PyObject *PyErr_SetFromErrno Py_PROTO((PyObject *)); extern DL_IMPORT(PyObject *) PyErr_SetFromErrno Py_PROTO((PyObject *));
extern PyObject *PyErr_SetFromErrnoWithFilename Py_PROTO((PyObject *, char *)); extern DL_IMPORT(PyObject *) PyErr_SetFromErrnoWithFilename Py_PROTO((PyObject *, char *));
extern PyObject *PyErr_Format Py_PROTO((PyObject *, const 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 */ /* 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)); PyObject *dict));
/* In sigcheck.c or signalmodule.c */ /* In sigcheck.c or signalmodule.c */
extern int PyErr_CheckSignals Py_PROTO((void)); extern DL_IMPORT(int) PyErr_CheckSignals Py_PROTO((void));
extern void PyErr_SetInterrupt Py_PROTO((void)); extern DL_IMPORT(void) PyErr_SetInterrupt Py_PROTO((void));
#ifdef __cplusplus #ifdef __cplusplus

18
Include/pystate.h
View file

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

98
Include/pythonrun.h
View file

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

42
Include/pythread.h
View file

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

2
Include/rangeobject.h
View file

@ -43,4 +43,4 @@ extern DL_IMPORT(PyTypeObject) PyRange_Type;
#define PyRange_Check(op) ((op)->ob_type == &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));

4
Include/sliceobject.h
View file

@ -28,9 +28,9 @@ extern DL_IMPORT(PyTypeObject) PySlice_Type;
#define PySlice_Check(op) ((op)->ob_type == &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)); 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)); PySliceObject *r, int length, int *start, int *stop, int *step));
#ifdef __cplusplus #ifdef __cplusplus

20
Include/stringobject.h
View file

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

4
Include/structmember.h
View file

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

18
Include/sysmodule.h
View file

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

6
Include/token.h
View file

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

10
Include/traceback.h
View file

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

12
Include/tupleobject.h
View file

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