diff options
Diffstat (limited to 'Include/pyport.h')
| -rw-r--r-- | Include/pyport.h | 317 |
1 files changed, 317 insertions, 0 deletions
diff --git a/Include/pyport.h b/Include/pyport.h index b9a699b..6026a2b 100644 --- a/Include/pyport.h +++ b/Include/pyport.h @@ -29,7 +29,15 @@ Used in: Py_SAFE_DOWNCAST **************************************************************************/ +#define ANY void /* For API compatibility only. Obsolete, do not use. */ + +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif + #ifdef __cplusplus +/* Move this down here since some C++ #include's don't like to be included + inside an extern "C" */ extern "C" { #endif @@ -136,6 +144,315 @@ extern int fsync(int fd); #endif /* 0 */ + +/************************ + * WRAPPER FOR <math.h> * + ************************/ + +/* On the 68K Mac, when using CFM (Code Fragment Manager), + <math.h> requires special treatment -- we need to surround it with + #pragma lib_export off / on... + This is because MathLib.o is a static library, and exporting its + symbols doesn't quite work... + XXX Not sure now... Seems to be something else going on as well... */ + +#ifndef HAVE_HYPOT +extern double hypot(double, double); +#ifdef MWERKS_BEFORE_PRO4 +#define hypot we_dont_want_faulty_hypot_decl +#endif +#endif + +#include <math.h> + +#ifndef HAVE_HYPOT +#ifdef __MWERKS__ +#undef hypot +#endif +#endif + +#if defined(USE_MSL) && defined(__MC68K__) +/* CodeWarrior MSL 2.1.1 has weird define overrides that don't work +** when you take the address of math functions. If I interpret the +** ANSI C standard correctly this is illegal, but I haven't been able +** to convince the MetroWerks folks of this... +*/ +#undef acos +#undef asin +#undef atan +#undef atan2 +#undef ceil +#undef cos +#undef cosh +#undef exp +#undef fabs +#undef floor +#undef fmod +#undef log +#undef log10 +#undef pow +#undef rint +#undef sin +#undef sinh +#undef sqrt +#undef tan +#undef tanh +#define acos acosd +#define asin asind +#define atan atand +#define atan2 atan2d +#define ceil ceild +#define cos cosd +#define cosh coshd +#define exp expd +#define fabs fabsd +#define floor floord +#define fmod fmodd +#define log logd +#define log10 log10d +#define pow powd +#define rint rintd +#define sin sind +#define sinh sinhd +#define sqrt sqrtd +#define tan tand +#define tanh tanhd +#endif + + +/*********************************** + * WRAPPER FOR malloc/realloc/free * + ***********************************/ + +#ifndef DL_IMPORT /* declarations for DLL import */ +#define DL_IMPORT(RTYPE) RTYPE +#endif + +#ifndef NULL +#define NULL ((void *)0) +#endif + +#ifdef MALLOC_ZERO_RETURNS_NULL +/* XXX Always allocate one extra byte, since some malloc's return NULL + XXX for malloc(0) or realloc(p, 0). */ +#define _PyMem_EXTRA 1 +#else +#define _PyMem_EXTRA 0 +#endif + +/* + * Core memory allocator + * ===================== + */ + +/* To make sure the interpreter is user-malloc friendly, all memory + APIs are implemented on top of this one. + + The PyCore_* macros can be defined to make the interpreter use a + custom allocator. Note that they are for internal use only. Both + the core and extension modules should use the PyMem_* API. + + See the comment block at the end of this file for two scenarios + showing how to use this to use a different allocator. */ + +#ifndef PyCore_MALLOC_FUNC +#undef PyCore_REALLOC_FUNC +#undef PyCore_FREE_FUNC +#define PyCore_MALLOC_FUNC malloc +#define PyCore_REALLOC_FUNC realloc +#define PyCore_FREE_FUNC free +#endif + +#ifndef PyCore_MALLOC_PROTO +#undef PyCore_REALLOC_PROTO +#undef PyCore_FREE_PROTO +#define PyCore_MALLOC_PROTO (size_t) +#define PyCore_REALLOC_PROTO (void *, size_t) +#define PyCore_FREE_PROTO (void *) +#endif + +#ifdef NEED_TO_DECLARE_MALLOC_AND_FRIEND +extern void *PyCore_MALLOC_FUNC PyCore_MALLOC_PROTO; +extern void *PyCore_REALLOC_FUNC PyCore_REALLOC_PROTO; +extern void PyCore_FREE_FUNC PyCore_FREE_PROTO; +#endif + +#ifndef PyCore_MALLOC +#undef PyCore_REALLOC +#undef PyCore_FREE +#define PyCore_MALLOC(n) PyCore_MALLOC_FUNC(n) +#define PyCore_REALLOC(p, n) PyCore_REALLOC_FUNC((p), (n)) +#define PyCore_FREE(p) PyCore_FREE_FUNC(p) +#endif + +/* BEWARE: + + Each interface exports both functions and macros. Extension modules + should normally use the functions for ensuring binary compatibility + of the user's code across Python versions. Subsequently, if the + Python runtime switches to its own malloc (different from standard + malloc), no recompilation is required for the extensions. + + The macro versions trade compatibility for speed. They can be used + whenever there is a performance problem, but their use implies + recompilation of the code for each new Python release. The Python + core uses the macros because it *is* compiled on every upgrade. + This might not be the case with 3rd party extensions in a custom + setup (for example, a customer does not always have access to the + source of 3rd party deliverables). You have been warned! */ + +/* + * Raw memory interface + * ==================== + */ + +/* Functions */ + +/* Function wrappers around PyCore_MALLOC and friends; useful if you + need to be sure that you are using the same memory allocator as + Python. Note that the wrappers make sure that allocating 0 bytes + returns a non-NULL pointer, even if the underlying malloc + doesn't. Returned pointers must be checked for NULL explicitly. + No action is performed on failure. */ +extern DL_IMPORT(void *) PyMem_Malloc(size_t); +extern DL_IMPORT(void *) PyMem_Realloc(void *, size_t); +extern DL_IMPORT(void) PyMem_Free(void *); + +/* Starting from Python 1.6, the wrappers Py_{Malloc,Realloc,Free} are + no longer supported. They used to call PyErr_NoMemory() on failure. */ + +/* Macros */ +#define PyMem_MALLOC(n) PyCore_MALLOC(n) +#define PyMem_REALLOC(p, n) PyCore_REALLOC((void *)(p), (n)) +#define PyMem_FREE(p) PyCore_FREE((void *)(p)) + +/* + * Type-oriented memory interface + * ============================== + */ + +/* Functions */ +#define PyMem_New(type, n) \ + ( (type *) PyMem_Malloc((n) * sizeof(type)) ) +#define PyMem_Resize(p, type, n) \ + ( (p) = (type *) PyMem_Realloc((n) * sizeof(type)) ) +#define PyMem_Del(p) PyMem_Free(p) + +/* Macros */ +#define PyMem_NEW(type, n) \ + ( (type *) PyMem_MALLOC(_PyMem_EXTRA + (n) * sizeof(type)) ) +#define PyMem_RESIZE(p, type, n) \ + if ((p) == NULL) \ + (p) = (type *)(PyMem_MALLOC( \ + _PyMem_EXTRA + (n) * sizeof(type))); \ + else \ + (p) = (type *)(PyMem_REALLOC((p), \ + _PyMem_EXTRA + (n) * sizeof(type))) +#define PyMem_DEL(p) PyMem_FREE(p) + +/* PyMem_XDEL is deprecated. To avoid the call when p is NULL, + it is recommended to write the test explicitly in the code. + Note that according to ANSI C, free(NULL) has no effect. */ + +/* SCENARIOS + + Here are two scenarios by Vladimir Marangozov (the author of the + memory allocation redesign). + + 1) Scenario A + + Suppose you want to use a debugging malloc library that collects info on + where the malloc calls originate from. Assume the interface is: + + d_malloc(size_t n, char* src_file, unsigned long src_line) c.s. + + In this case, you would define (for example in config.h) : + + #define PyCore_MALLOC_FUNC d_malloc + ... + #define PyCore_MALLOC_PROTO (size_t, char *, unsigned long) + ... + #define NEED_TO_DECLARE_MALLOC_AND_FRIEND + + #define PyCore_MALLOC(n) PyCore_MALLOC_FUNC((n), __FILE__, __LINE__) + ... + + 2) Scenario B + + Suppose you want to use malloc hooks (defined & initialized in a 3rd party + malloc library) instead of malloc functions. In this case, you would + define: + + #define PyCore_MALLOC_FUNC (*malloc_hook) + ... + #define NEED_TO_DECLARE_MALLOC_AND_FRIEND + + and ignore the previous definitions about PyCore_MALLOC_FUNC, etc. + + +*/ + +/******************************************** + * WRAPPER FOR <time.h> and/or <sys/time.h> * + ********************************************/ + +#ifdef TIME_WITH_SYS_TIME +#include <sys/time.h> +#include <time.h> +#else /* !TIME_WITH_SYS_TIME */ +#ifdef HAVE_SYS_TIME_H +#include <sys/time.h> +#else /* !HAVE_SYS_TIME_H */ +#include <time.h> +#endif /* !HAVE_SYS_TIME_H */ +#endif /* !TIME_WITH_SYS_TIME */ + + +/****************************** + * WRAPPER FOR <sys/select.h> * + ******************************/ + +/* NB caller must include <sys/types.h> */ + +#ifdef HAVE_SYS_SELECT_H + +#include <sys/select.h> + +#else /* !HAVE_SYS_SELECT_H */ + +#ifdef USE_GUSI1 +/* If we don't have sys/select the definition may be in unistd.h */ +#include <GUSI.h> +#endif + +#endif /* !HAVE_SYS_SELECT_H */ + +/* If the fd manipulation macros aren't defined, + here is a set that should do the job */ + +#ifndef FD_SETSIZE +#define FD_SETSIZE 256 +#endif + +#ifndef FD_SET + +typedef long fd_mask; + +#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */ +#ifndef howmany +#define howmany(x, y) (((x)+((y)-1))/(y)) +#endif /* howmany */ + +typedef struct fd_set { + fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)]; +} fd_set; + +#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS))) +#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS))) +#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS))) +#define FD_ZERO(p) memset((char *)(p), '\0', sizeof(*(p))) + +#endif /* FD_SET */ #ifdef __cplusplus } #endif |