Temporary define to avoid build failure
[python.git] / Include / pyport.h
blobda83196e7f3e485445b8790d351fa6d43e729b86
1 #ifndef Py_PYPORT_H
2 #define Py_PYPORT_H
4 #include "pyconfig.h" /* include for defines */
6 /* Some versions of HP-UX & Solaris need inttypes.h for int32_t,
7 INT32_MAX, etc. */
8 #ifdef HAVE_INTTYPES_H
9 #include <inttypes.h>
10 #endif
12 #ifdef HAVE_STDINT_H
13 #include <stdint.h>
14 #endif
16 /**************************************************************************
17 Symbols and macros to supply platform-independent interfaces to basic
18 C language & library operations whose spellings vary across platforms.
20 Please try to make documentation here as clear as possible: by definition,
21 the stuff here is trying to illuminate C's darkest corners.
23 Config #defines referenced here:
25 SIGNED_RIGHT_SHIFT_ZERO_FILLS
26 Meaning: To be defined iff i>>j does not extend the sign bit when i is a
27 signed integral type and i < 0.
28 Used in: Py_ARITHMETIC_RIGHT_SHIFT
30 Py_DEBUG
31 Meaning: Extra checks compiled in for debug mode.
32 Used in: Py_SAFE_DOWNCAST
34 HAVE_UINTPTR_T
35 Meaning: The C9X type uintptr_t is supported by the compiler
36 Used in: Py_uintptr_t
38 HAVE_LONG_LONG
39 Meaning: The compiler supports the C type "long long"
40 Used in: PY_LONG_LONG
42 **************************************************************************/
45 /* For backward compatibility only. Obsolete, do not use. */
46 #ifdef HAVE_PROTOTYPES
47 #define Py_PROTO(x) x
48 #else
49 #define Py_PROTO(x) ()
50 #endif
51 #ifndef Py_FPROTO
52 #define Py_FPROTO(x) Py_PROTO(x)
53 #endif
55 /* typedefs for some C9X-defined synonyms for integral types.
57 * The names in Python are exactly the same as the C9X names, except with a
58 * Py_ prefix. Until C9X is universally implemented, this is the only way
59 * to ensure that Python gets reliable names that don't conflict with names
60 * in non-Python code that are playing their own tricks to define the C9X
61 * names.
63 * NOTE: don't go nuts here! Python has no use for *most* of the C9X
64 * integral synonyms. Only define the ones we actually need.
67 #ifdef HAVE_LONG_LONG
68 #ifndef PY_LONG_LONG
69 #define PY_LONG_LONG long long
70 #if defined(LLONG_MAX)
71 /* If LLONG_MAX is defined in limits.h, use that. */
72 #define PY_LLONG_MIN LLONG_MIN
73 #define PY_LLONG_MAX LLONG_MAX
74 #define PY_ULLONG_MAX ULLONG_MAX
75 #elif defined(__LONG_LONG_MAX__)
76 /* Otherwise, if GCC has a builtin define, use that. */
77 #define PY_LLONG_MAX __LONG_LONG_MAX__
78 #define PY_LLONG_MIN (-PY_LLONG_MAX-1)
79 #define PY_ULLONG_MAX (__LONG_LONG_MAX__*2ULL + 1ULL)
80 #else
81 /* Otherwise, rely on two's complement. */
82 #define PY_ULLONG_MAX (~0ULL)
83 #define PY_LLONG_MAX ((long long)(PY_ULLONG_MAX>>1))
84 #define PY_LLONG_MIN (-PY_LLONG_MAX-1)
85 #endif /* LLONG_MAX */
86 #endif
87 #endif /* HAVE_LONG_LONG */
89 /* a build with 30-bit digits for Python long integers needs an exact-width
90 * 32-bit unsigned integer type to store those digits. (We could just use
91 * type 'unsigned long', but that would be wasteful on a system where longs
92 * are 64-bits.) On Unix systems, the autoconf macro AC_TYPE_UINT32_T defines
93 * uint32_t to be such a type unless stdint.h or inttypes.h defines uint32_t.
94 * However, it doesn't set HAVE_UINT32_T, so we do that here.
96 #if (defined UINT32_MAX || defined uint32_t)
97 #ifndef PY_UINT32_T
98 #define HAVE_UINT32_T 1
99 #define PY_UINT32_T uint32_t
100 #endif
101 #endif
103 /* Macros for a 64-bit unsigned integer type; used for type 'twodigits' in the
104 * long integer implementation, when 30-bit digits are enabled.
106 #if (defined UINT64_MAX || defined uint64_t)
107 #ifndef PY_UINT64_T
108 #define HAVE_UINT64_T 1
109 #define PY_UINT64_T uint64_t
110 #endif
111 #endif
113 /* Signed variants of the above */
114 #if (defined INT32_MAX || defined int32_t)
115 #ifndef PY_INT32_T
116 #define HAVE_INT32_T 1
117 #define PY_INT32_T int32_t
118 #endif
119 #endif
120 #if (defined INT64_MAX || defined int64_t)
121 #ifndef PY_INT64_T
122 #define HAVE_INT64_T 1
123 #define PY_INT64_T int64_t
124 #endif
125 #endif
127 /* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all
128 the necessary integer types are available, and we're on a 64-bit platform
129 (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */
131 #ifndef PYLONG_BITS_IN_DIGIT
132 #if (defined HAVE_UINT64_T && defined HAVE_INT64_T && \
133 defined HAVE_UINT32_T && defined HAVE_INT32_T && SIZEOF_VOID_P >= 8)
134 #define PYLONG_BITS_IN_DIGIT 30
135 #else
136 #define PYLONG_BITS_IN_DIGIT 15
137 #endif
138 #endif
140 /* uintptr_t is the C9X name for an unsigned integral type such that a
141 * legitimate void* can be cast to uintptr_t and then back to void* again
142 * without loss of information. Similarly for intptr_t, wrt a signed
143 * integral type.
145 #ifdef HAVE_UINTPTR_T
146 typedef uintptr_t Py_uintptr_t;
147 typedef intptr_t Py_intptr_t;
149 #elif SIZEOF_VOID_P <= SIZEOF_INT
150 typedef unsigned int Py_uintptr_t;
151 typedef int Py_intptr_t;
153 #elif SIZEOF_VOID_P <= SIZEOF_LONG
154 typedef unsigned long Py_uintptr_t;
155 typedef long Py_intptr_t;
157 #elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
158 typedef unsigned PY_LONG_LONG Py_uintptr_t;
159 typedef PY_LONG_LONG Py_intptr_t;
161 #else
162 # error "Python needs a typedef for Py_uintptr_t in pyport.h."
163 #endif /* HAVE_UINTPTR_T */
165 /* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==
166 * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an
167 * unsigned integral type). See PEP 353 for details.
169 #ifdef HAVE_SSIZE_T
170 typedef ssize_t Py_ssize_t;
171 #elif SIZEOF_VOID_P == SIZEOF_SIZE_T
172 typedef Py_intptr_t Py_ssize_t;
173 #else
174 # error "Python needs a typedef for Py_ssize_t in pyport.h."
175 #endif
177 /* Largest possible value of size_t.
178 SIZE_MAX is part of C99, so it might be defined on some
179 platforms. If it is not defined, (size_t)-1 is a portable
180 definition for C89, due to the way signed->unsigned
181 conversion is defined. */
182 #ifdef SIZE_MAX
183 #define PY_SIZE_MAX SIZE_MAX
184 #else
185 #define PY_SIZE_MAX ((size_t)-1)
186 #endif
188 /* Largest positive value of type Py_ssize_t. */
189 #define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
190 /* Smallest negative value of type Py_ssize_t. */
191 #define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
193 #if SIZEOF_PID_T > SIZEOF_LONG
194 # error "Python doesn't support sizeof(pid_t) > sizeof(long)"
195 #endif
197 /* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
198 * format to convert an argument with the width of a size_t or Py_ssize_t.
199 * C99 introduced "z" for this purpose, but not all platforms support that;
200 * e.g., MS compilers use "I" instead.
202 * These "high level" Python format functions interpret "z" correctly on
203 * all platforms (Python interprets the format string itself, and does whatever
204 * the platform C requires to convert a size_t/Py_ssize_t argument):
206 * PyString_FromFormat
207 * PyErr_Format
208 * PyString_FromFormatV
210 * Lower-level uses require that you interpolate the correct format modifier
211 * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
212 * example,
214 * Py_ssize_t index;
215 * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);
217 * That will expand to %ld, or %Id, or to something else correct for a
218 * Py_ssize_t on the platform.
220 #ifndef PY_FORMAT_SIZE_T
221 # if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__)
222 # define PY_FORMAT_SIZE_T ""
223 # elif SIZEOF_SIZE_T == SIZEOF_LONG
224 # define PY_FORMAT_SIZE_T "l"
225 # elif defined(MS_WINDOWS)
226 # define PY_FORMAT_SIZE_T "I"
227 # else
228 # error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T"
229 # endif
230 #endif
232 /* Py_LOCAL can be used instead of static to get the fastest possible calling
233 * convention for functions that are local to a given module.
235 * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
236 * for platforms that support that.
238 * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
239 * "aggressive" inlining/optimizaion is enabled for the entire module. This
240 * may lead to code bloat, and may slow things down for those reasons. It may
241 * also lead to errors, if the code relies on pointer aliasing. Use with
242 * care.
244 * NOTE: You can only use this for functions that are entirely local to a
245 * module; functions that are exported via method tables, callbacks, etc,
246 * should keep using static.
249 #undef USE_INLINE /* XXX - set via configure? */
251 #if defined(_MSC_VER)
252 #if defined(PY_LOCAL_AGGRESSIVE)
253 /* enable more aggressive optimization for visual studio */
254 #pragma optimize("agtw", on)
255 #endif
256 /* ignore warnings if the compiler decides not to inline a function */
257 #pragma warning(disable: 4710)
258 /* fastest possible local call under MSVC */
259 #define Py_LOCAL(type) static type __fastcall
260 #define Py_LOCAL_INLINE(type) static __inline type __fastcall
261 #elif defined(USE_INLINE)
262 #define Py_LOCAL(type) static type
263 #define Py_LOCAL_INLINE(type) static inline type
264 #else
265 #define Py_LOCAL(type) static type
266 #define Py_LOCAL_INLINE(type) static type
267 #endif
269 /* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks
270 * are often very short. While most platforms have highly optimized code for
271 * large transfers, the setup costs for memcpy are often quite high. MEMCPY
272 * solves this by doing short copies "in line".
275 #if defined(_MSC_VER)
276 #define Py_MEMCPY(target, source, length) do { \
277 size_t i_, n_ = (length); \
278 char *t_ = (void*) (target); \
279 const char *s_ = (void*) (source); \
280 if (n_ >= 16) \
281 memcpy(t_, s_, n_); \
282 else \
283 for (i_ = 0; i_ < n_; i_++) \
284 t_[i_] = s_[i_]; \
285 } while (0)
286 #else
287 #define Py_MEMCPY memcpy
288 #endif
290 #include <stdlib.h>
292 #include <math.h> /* Moved here from the math section, before extern "C" */
294 /********************************************
295 * WRAPPER FOR <time.h> and/or <sys/time.h> *
296 ********************************************/
298 #ifdef TIME_WITH_SYS_TIME
299 #include <sys/time.h>
300 #include <time.h>
301 #else /* !TIME_WITH_SYS_TIME */
302 #ifdef HAVE_SYS_TIME_H
303 #include <sys/time.h>
304 #else /* !HAVE_SYS_TIME_H */
305 #include <time.h>
306 #endif /* !HAVE_SYS_TIME_H */
307 #endif /* !TIME_WITH_SYS_TIME */
310 /******************************
311 * WRAPPER FOR <sys/select.h> *
312 ******************************/
314 /* NB caller must include <sys/types.h> */
316 #ifdef HAVE_SYS_SELECT_H
318 #include <sys/select.h>
320 #endif /* !HAVE_SYS_SELECT_H */
322 /*******************************
323 * stat() and fstat() fiddling *
324 *******************************/
326 /* We expect that stat and fstat exist on most systems.
327 * It's confirmed on Unix, Mac and Windows.
328 * If you don't have them, add
329 * #define DONT_HAVE_STAT
330 * and/or
331 * #define DONT_HAVE_FSTAT
332 * to your pyconfig.h. Python code beyond this should check HAVE_STAT and
333 * HAVE_FSTAT instead.
334 * Also
335 * #define HAVE_SYS_STAT_H
336 * if <sys/stat.h> exists on your platform, and
337 * #define HAVE_STAT_H
338 * if <stat.h> does.
340 #ifndef DONT_HAVE_STAT
341 #define HAVE_STAT
342 #endif
344 #ifndef DONT_HAVE_FSTAT
345 #define HAVE_FSTAT
346 #endif
348 #ifdef RISCOS
349 #include <sys/types.h>
350 #include "unixstuff.h"
351 #endif
353 #ifdef HAVE_SYS_STAT_H
354 #if defined(PYOS_OS2) && defined(PYCC_GCC)
355 #include <sys/types.h>
356 #endif
357 #include <sys/stat.h>
358 #elif defined(HAVE_STAT_H)
359 #include <stat.h>
360 #endif
362 #if defined(PYCC_VACPP)
363 /* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
364 #define S_IFMT (S_IFDIR|S_IFCHR|S_IFREG)
365 #endif
367 #ifndef S_ISREG
368 #define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
369 #endif
371 #ifndef S_ISDIR
372 #define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
373 #endif
376 #ifdef __cplusplus
377 /* Move this down here since some C++ #include's don't like to be included
378 inside an extern "C" */
379 extern "C" {
380 #endif
383 /* Py_ARITHMETIC_RIGHT_SHIFT
384 * C doesn't define whether a right-shift of a signed integer sign-extends
385 * or zero-fills. Here a macro to force sign extension:
386 * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
387 * Return I >> J, forcing sign extension. Arithmetically, return the
388 * floor of I/2**J.
389 * Requirements:
390 * I should have signed integer type. In the terminology of C99, this can
391 * be either one of the five standard signed integer types (signed char,
392 * short, int, long, long long) or an extended signed integer type.
393 * J is an integer >= 0 and strictly less than the number of bits in the
394 * type of I (because C doesn't define what happens for J outside that
395 * range either).
396 * TYPE used to specify the type of I, but is now ignored. It's been left
397 * in for backwards compatibility with versions <= 2.6 or 3.0.
398 * Caution:
399 * I may be evaluated more than once.
401 #ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
402 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
403 ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
404 #else
405 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
406 #endif
408 /* Py_FORCE_EXPANSION(X)
409 * "Simply" returns its argument. However, macro expansions within the
410 * argument are evaluated. This unfortunate trickery is needed to get
411 * token-pasting to work as desired in some cases.
413 #define Py_FORCE_EXPANSION(X) X
415 /* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
416 * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this
417 * assert-fails if any information is lost.
418 * Caution:
419 * VALUE may be evaluated more than once.
421 #ifdef Py_DEBUG
422 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
423 (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
424 #else
425 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
426 #endif
428 /* Py_SET_ERRNO_ON_MATH_ERROR(x)
429 * If a libm function did not set errno, but it looks like the result
430 * overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno
431 * to 0 before calling a libm function, and invoke this macro after,
432 * passing the function result.
433 * Caution:
434 * This isn't reliable. See Py_OVERFLOWED comments.
435 * X is evaluated more than once.
437 #if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64))
438 #define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
439 #else
440 #define _Py_SET_EDOM_FOR_NAN(X) ;
441 #endif
442 #define Py_SET_ERRNO_ON_MATH_ERROR(X) \
443 do { \
444 if (errno == 0) { \
445 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
446 errno = ERANGE; \
447 else _Py_SET_EDOM_FOR_NAN(X) \
449 } while(0)
451 /* Py_SET_ERANGE_ON_OVERFLOW(x)
452 * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
454 #define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
456 /* Py_ADJUST_ERANGE1(x)
457 * Py_ADJUST_ERANGE2(x, y)
458 * Set errno to 0 before calling a libm function, and invoke one of these
459 * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
460 * for functions returning complex results). This makes two kinds of
461 * adjustments to errno: (A) If it looks like the platform libm set
462 * errno=ERANGE due to underflow, clear errno. (B) If it looks like the
463 * platform libm overflowed but didn't set errno, force errno to ERANGE. In
464 * effect, we're trying to force a useful implementation of C89 errno
465 * behavior.
466 * Caution:
467 * This isn't reliable. See Py_OVERFLOWED comments.
468 * X and Y may be evaluated more than once.
470 #define Py_ADJUST_ERANGE1(X) \
471 do { \
472 if (errno == 0) { \
473 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
474 errno = ERANGE; \
476 else if (errno == ERANGE && (X) == 0.0) \
477 errno = 0; \
478 } while(0)
480 #define Py_ADJUST_ERANGE2(X, Y) \
481 do { \
482 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL || \
483 (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) { \
484 if (errno == 0) \
485 errno = ERANGE; \
487 else if (errno == ERANGE) \
488 errno = 0; \
489 } while(0)
491 /* Py_DEPRECATED(version)
492 * Declare a variable, type, or function deprecated.
493 * Usage:
494 * extern int old_var Py_DEPRECATED(2.3);
495 * typedef int T1 Py_DEPRECATED(2.4);
496 * extern int x() Py_DEPRECATED(2.5);
498 #if defined(__GNUC__) && ((__GNUC__ >= 4) || \
499 (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
500 #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
501 #else
502 #define Py_DEPRECATED(VERSION_UNUSED)
503 #endif
505 /**************************************************************************
506 Prototypes that are missing from the standard include files on some systems
507 (and possibly only some versions of such systems.)
509 Please be conservative with adding new ones, document them and enclose them
510 in platform-specific #ifdefs.
511 **************************************************************************/
513 #ifdef SOLARIS
514 /* Unchecked */
515 extern int gethostname(char *, int);
516 #endif
518 #ifdef __BEOS__
519 /* Unchecked */
520 /* It's in the libs, but not the headers... - [cjh] */
521 int shutdown( int, int );
522 #endif
524 #ifdef HAVE__GETPTY
525 #include <sys/types.h> /* we need to import mode_t */
526 extern char * _getpty(int *, int, mode_t, int);
527 #endif
529 /* On QNX 6, struct termio must be declared by including sys/termio.h
530 if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must
531 be included before termios.h or it will generate an error. */
532 #ifdef HAVE_SYS_TERMIO_H
533 #include <sys/termio.h>
534 #endif
536 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY)
537 #if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H)
538 /* BSDI does not supply a prototype for the 'openpty' and 'forkpty'
539 functions, even though they are included in libutil. */
540 #include <termios.h>
541 extern int openpty(int *, int *, char *, struct termios *, struct winsize *);
542 extern pid_t forkpty(int *, char *, struct termios *, struct winsize *);
543 #endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */
544 #endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */
547 /* These are pulled from various places. It isn't obvious on what platforms
548 they are necessary, nor what the exact prototype should look like (which
549 is likely to vary between platforms!) If you find you need one of these
550 declarations, please move them to a platform-specific block and include
551 proper prototypes. */
552 #if 0
554 /* From Modules/resource.c */
555 extern int getrusage();
556 extern int getpagesize();
558 /* From Python/sysmodule.c and Modules/posixmodule.c */
559 extern int fclose(FILE *);
561 /* From Modules/posixmodule.c */
562 extern int fdatasync(int);
563 #endif /* 0 */
566 /* On 4.4BSD-descendants, ctype functions serves the whole range of
567 * wchar_t character set rather than single byte code points only.
568 * This characteristic can break some operations of string object
569 * including str.upper() and str.split() on UTF-8 locales. This
570 * workaround was provided by Tim Robbins of FreeBSD project.
573 #ifdef __FreeBSD__
574 #include <osreldate.h>
575 #if __FreeBSD_version > 500039
576 #include <ctype.h>
577 #include <wctype.h>
578 #undef isalnum
579 #define isalnum(c) iswalnum(btowc(c))
580 #undef isalpha
581 #define isalpha(c) iswalpha(btowc(c))
582 #undef islower
583 #define islower(c) iswlower(btowc(c))
584 #undef isspace
585 #define isspace(c) iswspace(btowc(c))
586 #undef isupper
587 #define isupper(c) iswupper(btowc(c))
588 #undef tolower
589 #define tolower(c) towlower(btowc(c))
590 #undef toupper
591 #define toupper(c) towupper(btowc(c))
592 #endif
593 #endif
596 /* Declarations for symbol visibility.
598 PyAPI_FUNC(type): Declares a public Python API function and return type
599 PyAPI_DATA(type): Declares public Python data and its type
600 PyMODINIT_FUNC: A Python module init function. If these functions are
601 inside the Python core, they are private to the core.
602 If in an extension module, it may be declared with
603 external linkage depending on the platform.
605 As a number of platforms support/require "__declspec(dllimport/dllexport)",
606 we support a HAVE_DECLSPEC_DLL macro to save duplication.
610 All windows ports, except cygwin, are handled in PC/pyconfig.h.
612 BeOS and cygwin are the only other autoconf platform requiring special
613 linkage handling and both of these use __declspec().
615 #if defined(__CYGWIN__) || defined(__BEOS__)
616 # define HAVE_DECLSPEC_DLL
617 #endif
619 /* only get special linkage if built as shared or platform is Cygwin */
620 #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
621 # if defined(HAVE_DECLSPEC_DLL)
622 # ifdef Py_BUILD_CORE
623 # define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
624 # define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
625 /* module init functions inside the core need no external linkage */
626 /* except for Cygwin to handle embedding (FIXME: BeOS too?) */
627 # if defined(__CYGWIN__)
628 # define PyMODINIT_FUNC __declspec(dllexport) void
629 # else /* __CYGWIN__ */
630 # define PyMODINIT_FUNC void
631 # endif /* __CYGWIN__ */
632 # else /* Py_BUILD_CORE */
633 /* Building an extension module, or an embedded situation */
634 /* public Python functions and data are imported */
635 /* Under Cygwin, auto-import functions to prevent compilation */
636 /* failures similar to http://python.org/doc/FAQ.html#3.24 */
637 # if !defined(__CYGWIN__)
638 # define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
639 # endif /* !__CYGWIN__ */
640 # define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
641 /* module init functions outside the core must be exported */
642 # if defined(__cplusplus)
643 # define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
644 # else /* __cplusplus */
645 # define PyMODINIT_FUNC __declspec(dllexport) void
646 # endif /* __cplusplus */
647 # endif /* Py_BUILD_CORE */
648 # endif /* HAVE_DECLSPEC */
649 #endif /* Py_ENABLE_SHARED */
651 /* If no external linkage macros defined by now, create defaults */
652 #ifndef PyAPI_FUNC
653 # define PyAPI_FUNC(RTYPE) RTYPE
654 #endif
655 #ifndef PyAPI_DATA
656 # define PyAPI_DATA(RTYPE) extern RTYPE
657 #endif
658 #ifndef PyMODINIT_FUNC
659 # if defined(__cplusplus)
660 # define PyMODINIT_FUNC extern "C" void
661 # else /* __cplusplus */
662 # define PyMODINIT_FUNC void
663 # endif /* __cplusplus */
664 #endif
666 /* Deprecated DL_IMPORT and DL_EXPORT macros */
667 #if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)
668 # if defined(Py_BUILD_CORE)
669 # define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
670 # define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
671 # else
672 # define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
673 # define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
674 # endif
675 #endif
676 #ifndef DL_EXPORT
677 # define DL_EXPORT(RTYPE) RTYPE
678 #endif
679 #ifndef DL_IMPORT
680 # define DL_IMPORT(RTYPE) RTYPE
681 #endif
682 /* End of deprecated DL_* macros */
684 /* If the fd manipulation macros aren't defined,
685 here is a set that should do the job */
687 #if 0 /* disabled and probably obsolete */
689 #ifndef FD_SETSIZE
690 #define FD_SETSIZE 256
691 #endif
693 #ifndef FD_SET
695 typedef long fd_mask;
697 #define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */
698 #ifndef howmany
699 #define howmany(x, y) (((x)+((y)-1))/(y))
700 #endif /* howmany */
702 typedef struct fd_set {
703 fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
704 } fd_set;
706 #define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
707 #define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
708 #define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
709 #define FD_ZERO(p) memset((char *)(p), '\0', sizeof(*(p)))
711 #endif /* FD_SET */
713 #endif /* fd manipulation macros */
716 /* limits.h constants that may be missing */
718 #ifndef INT_MAX
719 #define INT_MAX 2147483647
720 #endif
722 #ifndef LONG_MAX
723 #if SIZEOF_LONG == 4
724 #define LONG_MAX 0X7FFFFFFFL
725 #elif SIZEOF_LONG == 8
726 #define LONG_MAX 0X7FFFFFFFFFFFFFFFL
727 #else
728 #error "could not set LONG_MAX in pyport.h"
729 #endif
730 #endif
732 #ifndef LONG_MIN
733 #define LONG_MIN (-LONG_MAX-1)
734 #endif
736 #ifndef LONG_BIT
737 #define LONG_BIT (8 * SIZEOF_LONG)
738 #endif
740 #if LONG_BIT != 8 * SIZEOF_LONG
741 /* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
742 * 32-bit platforms using gcc. We try to catch that here at compile-time
743 * rather than waiting for integer multiplication to trigger bogus
744 * overflows.
746 #error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
747 #endif
749 #ifdef __cplusplus
751 #endif
754 * Hide GCC attributes from compilers that don't support them.
756 #if (!defined(__GNUC__) || __GNUC__ < 2 || \
757 (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \
758 !defined(RISCOS)
759 #define Py_GCC_ATTRIBUTE(x)
760 #else
761 #define Py_GCC_ATTRIBUTE(x) __attribute__(x)
762 #endif
765 * Add PyArg_ParseTuple format where available.
767 #ifdef HAVE_ATTRIBUTE_FORMAT_PARSETUPLE
768 #define Py_FORMAT_PARSETUPLE(func,p1,p2) __attribute__((format(func,p1,p2)))
769 #else
770 #define Py_FORMAT_PARSETUPLE(func,p1,p2)
771 #endif
774 * Specify alignment on compilers that support it.
776 #if defined(__GNUC__) && __GNUC__ >= 3
777 #define Py_ALIGNED(x) __attribute__((aligned(x)))
778 #else
779 #define Py_ALIGNED(x)
780 #endif
782 /* Eliminate end-of-loop code not reached warnings from SunPro C
783 * when using do{...}while(0) macros
785 #ifdef __SUNPRO_C
786 #pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
787 #endif
790 * Older Microsoft compilers don't support the C99 long long literal suffixes,
791 * so these will be defined in PC/pyconfig.h for those compilers.
793 #ifndef Py_LL
794 #define Py_LL(x) x##LL
795 #endif
797 #ifndef Py_ULL
798 #define Py_ULL(x) Py_LL(x##U)
799 #endif
801 #endif /* Py_PYPORT_H */