1#ifndef Py_PYPORT_H
2#define Py_PYPORT_H
3
4#include "pyconfig.h" /* include for defines */
5
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
11
12#ifdef HAVE_STDINT_H
13#include <stdint.h>
14#endif
15
16/**************************************************************************
17Symbols and macros to supply platform-independent interfaces to basic
18C language & library operations whose spellings vary across platforms.
19
20Please try to make documentation here as clear as possible: by definition,
21the stuff here is trying to illuminate C's darkest corners.
22
23Config #defines referenced here:
24
25SIGNED_RIGHT_SHIFT_ZERO_FILLS
26Meaning: To be defined iff i>>j does not extend the sign bit when i is a
27 signed integral type and i < 0.
28Used in: Py_ARITHMETIC_RIGHT_SHIFT
29
30Py_DEBUG
31Meaning: Extra checks compiled in for debug mode.
32Used in: Py_SAFE_DOWNCAST
33
34HAVE_UINTPTR_T
35Meaning: The C9X type uintptr_t is supported by the compiler
36Used in: Py_uintptr_t
37
38HAVE_LONG_LONG
39Meaning: The compiler supports the C type "long long"
40Used in: PY_LONG_LONG
41
42**************************************************************************/
43
44/* typedefs for some C9X-defined synonyms for integral types.
45 *
46 * The names in Python are exactly the same as the C9X names, except with a
47 * Py_ prefix. Until C9X is universally implemented, this is the only way
48 * to ensure that Python gets reliable names that don't conflict with names
49 * in non-Python code that are playing their own tricks to define the C9X
50 * names.
51 *
52 * NOTE: don't go nuts here! Python has no use for *most* of the C9X
53 * integral synonyms. Only define the ones we actually need.
54 */
55
56#ifdef HAVE_LONG_LONG
57#ifndef PY_LONG_LONG
58#define PY_LONG_LONG long long
59#if defined(LLONG_MAX)
60/* If LLONG_MAX is defined in limits.h, use that. */
61#define PY_LLONG_MIN LLONG_MIN
62#define PY_LLONG_MAX LLONG_MAX
63#define PY_ULLONG_MAX ULLONG_MAX
64#elif defined(__LONG_LONG_MAX__)
65/* Otherwise, if GCC has a builtin define, use that. (Definition of
66 * PY_LLONG_MIN assumes two's complement with no trap representation.) */
67#define PY_LLONG_MAX __LONG_LONG_MAX__
68#define PY_LLONG_MIN (-PY_LLONG_MAX - 1)
69#define PY_ULLONG_MAX (PY_LLONG_MAX * Py_ULL(2) + 1)
70#elif defined(SIZEOF_LONG_LONG)
71/* Otherwise compute from SIZEOF_LONG_LONG, assuming two's complement, no
72 padding bits, and no trap representation. Note: PY_ULLONG_MAX was
73 previously #defined as (~0ULL) here; but that'll give the wrong value in a
74 preprocessor expression on systems where long long != intmax_t. */
75#define PY_LLONG_MAX \
76 (1 + 2 * ((Py_LL(1) << (CHAR_BIT * SIZEOF_LONG_LONG - 2)) - 1))
77#define PY_LLONG_MIN (-PY_LLONG_MAX - 1)
78#define PY_ULLONG_MAX (PY_LLONG_MAX * Py_ULL(2) + 1)
79#endif /* LLONG_MAX */
80#endif
81#endif /* HAVE_LONG_LONG */
82
83/* a build with 30-bit digits for Python integers needs an exact-width
84 * 32-bit unsigned integer type to store those digits. (We could just use
85 * type 'unsigned long', but that would be wasteful on a system where longs
86 * are 64-bits.) On Unix systems, the autoconf macro AC_TYPE_UINT32_T defines
87 * uint32_t to be such a type unless stdint.h or inttypes.h defines uint32_t.
88 * However, it doesn't set HAVE_UINT32_T, so we do that here.
89 */
90#ifdef uint32_t
91#define HAVE_UINT32_T 1
92#endif
93
94#ifdef HAVE_UINT32_T
95#ifndef PY_UINT32_T
96#define PY_UINT32_T uint32_t
97#endif
98#endif
99
100/* Macros for a 64-bit unsigned integer type; used for type 'twodigits' in the
101 * integer implementation, when 30-bit digits are enabled.
102 */
103#ifdef uint64_t
104#define HAVE_UINT64_T 1
105#endif
106
107#ifdef HAVE_UINT64_T
108#ifndef PY_UINT64_T
109#define PY_UINT64_T uint64_t
110#endif
111#endif
112
113/* Signed variants of the above */
114#ifdef int32_t
115#define HAVE_INT32_T 1
116#endif
117
118#ifdef HAVE_INT32_T
119#ifndef PY_INT32_T
120#define PY_INT32_T int32_t
121#endif
122#endif
123
124#ifdef int64_t
125#define HAVE_INT64_T 1
126#endif
127
128#ifdef HAVE_INT64_T
129#ifndef PY_INT64_T
130#define PY_INT64_T int64_t
131#endif
132#endif
133
134/* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all
135 the necessary integer types are available, and we're on a 64-bit platform
136 (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */
137
138#ifndef PYLONG_BITS_IN_DIGIT
139#if (defined HAVE_UINT64_T && defined HAVE_INT64_T && \
140 defined HAVE_UINT32_T && defined HAVE_INT32_T && SIZEOF_VOID_P >= 8)
141#define PYLONG_BITS_IN_DIGIT 30
142#else
143#define PYLONG_BITS_IN_DIGIT 15
144#endif
145#endif
146
147/* uintptr_t is the C9X name for an unsigned integral type such that a
148 * legitimate void* can be cast to uintptr_t and then back to void* again
149 * without loss of information. Similarly for intptr_t, wrt a signed
150 * integral type.
151 */
152#ifdef HAVE_UINTPTR_T
153typedef uintptr_t Py_uintptr_t;
154typedef intptr_t Py_intptr_t;
155
156#elif SIZEOF_VOID_P <= SIZEOF_INT
157typedef unsigned int Py_uintptr_t;
158typedef int Py_intptr_t;
159
160#elif SIZEOF_VOID_P <= SIZEOF_LONG
161typedef unsigned long Py_uintptr_t;
162typedef long Py_intptr_t;
163
164#elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
165typedef unsigned PY_LONG_LONG Py_uintptr_t;
166typedef PY_LONG_LONG Py_intptr_t;
167
168#else
169# error "Python needs a typedef for Py_uintptr_t in pyport.h."
170#endif /* HAVE_UINTPTR_T */
171
172/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==
173 * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an
174 * unsigned integral type). See PEP 353 for details.
175 */
176#ifdef HAVE_SSIZE_T
177typedef ssize_t Py_ssize_t;
178#elif SIZEOF_VOID_P == SIZEOF_SIZE_T
179typedef Py_intptr_t Py_ssize_t;
180#else
181# error "Python needs a typedef for Py_ssize_t in pyport.h."
182#endif
183
184/* Py_hash_t is the same size as a pointer. */
185#define SIZEOF_PY_HASH_T SIZEOF_SIZE_T
186typedef Py_ssize_t Py_hash_t;
187/* Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. */
188#define SIZEOF_PY_UHASH_T SIZEOF_SIZE_T
189typedef size_t Py_uhash_t;
190
191/* Only used for compatibility with code that may not be PY_SSIZE_T_CLEAN. */
192#ifdef PY_SSIZE_T_CLEAN
193typedef Py_ssize_t Py_ssize_clean_t;
194#else
195typedef int Py_ssize_clean_t;
196#endif
197
198/* Largest possible value of size_t.
199 SIZE_MAX is part of C99, so it might be defined on some
200 platforms. If it is not defined, (size_t)-1 is a portable
201 definition for C89, due to the way signed->unsigned
202 conversion is defined. */
203#ifdef SIZE_MAX
204#define PY_SIZE_MAX SIZE_MAX
205#else
206#define PY_SIZE_MAX ((size_t)-1)
207#endif
208
209/* Largest positive value of type Py_ssize_t. */
210#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
211/* Smallest negative value of type Py_ssize_t. */
212#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
213
214/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
215 * format to convert an argument with the width of a size_t or Py_ssize_t.
216 * C99 introduced "z" for this purpose, but not all platforms support that;
217 * e.g., MS compilers use "I" instead.
218 *
219 * These "high level" Python format functions interpret "z" correctly on
220 * all platforms (Python interprets the format string itself, and does whatever
221 * the platform C requires to convert a size_t/Py_ssize_t argument):
222 *
223 * PyBytes_FromFormat
224 * PyErr_Format
225 * PyBytes_FromFormatV
226 * PyUnicode_FromFormatV
227 *
228 * Lower-level uses require that you interpolate the correct format modifier
229 * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
230 * example,
231 *
232 * Py_ssize_t index;
233 * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);
234 *
235 * That will expand to %ld, or %Id, or to something else correct for a
236 * Py_ssize_t on the platform.
237 */
238#ifndef PY_FORMAT_SIZE_T
239# if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__)
240# define PY_FORMAT_SIZE_T ""
241# elif SIZEOF_SIZE_T == SIZEOF_LONG
242# define PY_FORMAT_SIZE_T "l"
243# elif defined(MS_WINDOWS)
244# define PY_FORMAT_SIZE_T "I"
245# else
246# error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T"
247# endif
248#endif
249
250/* PY_FORMAT_LONG_LONG is analogous to PY_FORMAT_SIZE_T above, but for
251 * the long long type instead of the size_t type. It's only available
252 * when HAVE_LONG_LONG is defined. The "high level" Python format
253 * functions listed above will interpret "lld" or "llu" correctly on
254 * all platforms.
255 */
256#ifdef HAVE_LONG_LONG
257# ifndef PY_FORMAT_LONG_LONG
258# ifdef MS_WINDOWS
259# define PY_FORMAT_LONG_LONG "I64"
260# else
261# error "This platform's pyconfig.h needs to define PY_FORMAT_LONG_LONG"
262# endif
263# endif
264#endif
265
266/* Py_LOCAL can be used instead of static to get the fastest possible calling
267 * convention for functions that are local to a given module.
268 *
269 * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
270 * for platforms that support that.
271 *
272 * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
273 * "aggressive" inlining/optimization is enabled for the entire module. This
274 * may lead to code bloat, and may slow things down for those reasons. It may
275 * also lead to errors, if the code relies on pointer aliasing. Use with
276 * care.
277 *
278 * NOTE: You can only use this for functions that are entirely local to a
279 * module; functions that are exported via method tables, callbacks, etc,
280 * should keep using static.
281 */
282
283#if defined(_MSC_VER)
284#if defined(PY_LOCAL_AGGRESSIVE)
285/* enable more aggressive optimization for visual studio */
286#pragma optimize("agtw", on)
287#endif
288/* ignore warnings if the compiler decides not to inline a function */
289#pragma warning(disable: 4710)
290/* fastest possible local call under MSVC */
291#define Py_LOCAL(type) static type __fastcall
292#define Py_LOCAL_INLINE(type) static __inline type __fastcall
293#elif defined(USE_INLINE)
294#define Py_LOCAL(type) static type
295#define Py_LOCAL_INLINE(type) static inline type
296#else
297#define Py_LOCAL(type) static type
298#define Py_LOCAL_INLINE(type) static type
299#endif
300
301/* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks
302 * are often very short. While most platforms have highly optimized code for
303 * large transfers, the setup costs for memcpy are often quite high. MEMCPY
304 * solves this by doing short copies "in line".
305 */
306
307#if defined(_MSC_VER)
308#define Py_MEMCPY(target, source, length) do { \
309 size_t i_, n_ = (length); \
310 char *t_ = (void*) (target); \
311 const char *s_ = (void*) (source); \
312 if (n_ >= 16) \
313 memcpy(t_, s_, n_); \
314 else \
315 for (i_ = 0; i_ < n_; i_++) \
316 t_[i_] = s_[i_]; \
317 } while (0)
318#else
319#define Py_MEMCPY memcpy
320#endif
321
322#include <stdlib.h>
323
324#ifdef HAVE_IEEEFP_H
325#include <ieeefp.h> /* needed for 'finite' declaration on some platforms */
326#endif
327
328#include <math.h> /* Moved here from the math section, before extern "C" */
329
330/********************************************
331 * WRAPPER FOR <time.h> and/or <sys/time.h> *
332 ********************************************/
333
334#ifdef TIME_WITH_SYS_TIME
335#include <sys/time.h>
336#include <time.h>
337#else /* !TIME_WITH_SYS_TIME */
338#ifdef HAVE_SYS_TIME_H
339#include <sys/time.h>
340#else /* !HAVE_SYS_TIME_H */
341#include <time.h>
342#endif /* !HAVE_SYS_TIME_H */
343#endif /* !TIME_WITH_SYS_TIME */
344
345
346/******************************
347 * WRAPPER FOR <sys/select.h> *
348 ******************************/
349
350/* NB caller must include <sys/types.h> */
351
352#ifdef HAVE_SYS_SELECT_H
353#include <sys/select.h>
354#endif /* !HAVE_SYS_SELECT_H */
355
356/*******************************
357 * stat() and fstat() fiddling *
358 *******************************/
359
360#ifdef HAVE_SYS_STAT_H
361#include <sys/stat.h>
362#elif defined(HAVE_STAT_H)
363#include <stat.h>
364#endif
365
366#ifndef S_IFMT
367/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
368#define S_IFMT 0170000
369#endif
370
371#ifndef S_IFLNK
372/* Windows doesn't define S_IFLNK but posixmodule.c maps
373 * IO_REPARSE_TAG_SYMLINK to S_IFLNK */
374# define S_IFLNK 0120000
375#endif
376
377#ifndef S_ISREG
378#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
379#endif
380
381#ifndef S_ISDIR
382#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
383#endif
384
385#ifndef S_ISCHR
386#define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR)
387#endif
388
389#ifdef __cplusplus
390/* Move this down here since some C++ #include's don't like to be included
391 inside an extern "C" */
392extern "C" {
393#endif
394
395
396/* Py_ARITHMETIC_RIGHT_SHIFT
397 * C doesn't define whether a right-shift of a signed integer sign-extends
398 * or zero-fills. Here a macro to force sign extension:
399 * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
400 * Return I >> J, forcing sign extension. Arithmetically, return the
401 * floor of I/2**J.
402 * Requirements:
403 * I should have signed integer type. In the terminology of C99, this can
404 * be either one of the five standard signed integer types (signed char,
405 * short, int, long, long long) or an extended signed integer type.
406 * J is an integer >= 0 and strictly less than the number of bits in the
407 * type of I (because C doesn't define what happens for J outside that
408 * range either).
409 * TYPE used to specify the type of I, but is now ignored. It's been left
410 * in for backwards compatibility with versions <= 2.6 or 3.0.
411 * Caution:
412 * I may be evaluated more than once.
413 */
414#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
415#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
416 ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
417#else
418#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
419#endif
420
421/* Py_FORCE_EXPANSION(X)
422 * "Simply" returns its argument. However, macro expansions within the
423 * argument are evaluated. This unfortunate trickery is needed to get
424 * token-pasting to work as desired in some cases.
425 */
426#define Py_FORCE_EXPANSION(X) X
427
428/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
429 * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this
430 * assert-fails if any information is lost.
431 * Caution:
432 * VALUE may be evaluated more than once.
433 */
434#ifdef Py_DEBUG
435#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
436 (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
437#else
438#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
439#endif
440
441/* Py_SET_ERRNO_ON_MATH_ERROR(x)
442 * If a libm function did not set errno, but it looks like the result
443 * overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno
444 * to 0 before calling a libm function, and invoke this macro after,
445 * passing the function result.
446 * Caution:
447 * This isn't reliable. See Py_OVERFLOWED comments.
448 * X is evaluated more than once.
449 */
450#if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64))
451#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
452#else
453#define _Py_SET_EDOM_FOR_NAN(X) ;
454#endif
455#define Py_SET_ERRNO_ON_MATH_ERROR(X) \
456 do { \
457 if (errno == 0) { \
458 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
459 errno = ERANGE; \
460 else _Py_SET_EDOM_FOR_NAN(X) \
461 } \
462 } while(0)
463
464/* Py_SET_ERANGE_ON_OVERFLOW(x)
465 * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
466 */
467#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
468
469/* Py_ADJUST_ERANGE1(x)
470 * Py_ADJUST_ERANGE2(x, y)
471 * Set errno to 0 before calling a libm function, and invoke one of these
472 * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
473 * for functions returning complex results). This makes two kinds of
474 * adjustments to errno: (A) If it looks like the platform libm set
475 * errno=ERANGE due to underflow, clear errno. (B) If it looks like the
476 * platform libm overflowed but didn't set errno, force errno to ERANGE. In
477 * effect, we're trying to force a useful implementation of C89 errno
478 * behavior.
479 * Caution:
480 * This isn't reliable. See Py_OVERFLOWED comments.
481 * X and Y may be evaluated more than once.
482 */
483#define Py_ADJUST_ERANGE1(X) \
484 do { \
485 if (errno == 0) { \
486 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
487 errno = ERANGE; \
488 } \
489 else if (errno == ERANGE && (X) == 0.0) \
490 errno = 0; \
491 } while(0)
492
493#define Py_ADJUST_ERANGE2(X, Y) \
494 do { \
495 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL || \
496 (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) { \
497 if (errno == 0) \
498 errno = ERANGE; \
499 } \
500 else if (errno == ERANGE) \
501 errno = 0; \
502 } while(0)
503
504/* The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are
505 * required to support the short float repr introduced in Python 3.1) require
506 * that the floating-point unit that's being used for arithmetic operations
507 * on C doubles is set to use 53-bit precision. It also requires that the
508 * FPU rounding mode is round-half-to-even, but that's less often an issue.
509 *
510 * If your FPU isn't already set to 53-bit precision/round-half-to-even, and
511 * you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should
512 *
513 * #define HAVE_PY_SET_53BIT_PRECISION 1
514 *
515 * and also give appropriate definitions for the following three macros:
516 *
517 * _PY_SET_53BIT_PRECISION_START : store original FPU settings, and
518 * set FPU to 53-bit precision/round-half-to-even
519 * _PY_SET_53BIT_PRECISION_END : restore original FPU settings
520 * _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to
521 * use the two macros above.
522 *
523 * The macros are designed to be used within a single C function: see
524 * Python/pystrtod.c for an example of their use.
525 */
526
527/* get and set x87 control word for gcc/x86 */
528#ifdef HAVE_GCC_ASM_FOR_X87
529#define HAVE_PY_SET_53BIT_PRECISION 1
530/* _Py_get/set_387controlword functions are defined in Python/pymath.c */
531#define _Py_SET_53BIT_PRECISION_HEADER \
532 unsigned short old_387controlword, new_387controlword
533#define _Py_SET_53BIT_PRECISION_START \
534 do { \
535 old_387controlword = _Py_get_387controlword(); \
536 new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \
537 if (new_387controlword != old_387controlword) \
538 _Py_set_387controlword(new_387controlword); \
539 } while (0)
540#define _Py_SET_53BIT_PRECISION_END \
541 if (new_387controlword != old_387controlword) \
542 _Py_set_387controlword(old_387controlword)
543#endif
544
545/* get and set x87 control word for VisualStudio/x86 */
546#if defined(_MSC_VER) && !defined(_WIN64) /* x87 not supported in 64-bit */
547#define HAVE_PY_SET_53BIT_PRECISION 1
548#define _Py_SET_53BIT_PRECISION_HEADER \
549 unsigned int old_387controlword, new_387controlword, out_387controlword
550/* We use the __control87_2 function to set only the x87 control word.
551 The SSE control word is unaffected. */
552#define _Py_SET_53BIT_PRECISION_START \
553 do { \
554 __control87_2(0, 0, &old_387controlword, NULL); \
555 new_387controlword = \
556 (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \
557 if (new_387controlword != old_387controlword) \
558 __control87_2(new_387controlword, _MCW_PC | _MCW_RC, \
559 &out_387controlword, NULL); \
560 } while (0)
561#define _Py_SET_53BIT_PRECISION_END \
562 do { \
563 if (new_387controlword != old_387controlword) \
564 __control87_2(old_387controlword, _MCW_PC | _MCW_RC, \
565 &out_387controlword, NULL); \
566 } while (0)
567#endif
568
569#ifdef HAVE_GCC_ASM_FOR_MC68881
570#define HAVE_PY_SET_53BIT_PRECISION 1
571#define _Py_SET_53BIT_PRECISION_HEADER \
572 unsigned int old_fpcr, new_fpcr
573#define _Py_SET_53BIT_PRECISION_START \
574 do { \
575 __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr)); \
576 /* Set double precision / round to nearest. */ \
577 new_fpcr = (old_fpcr & ~0xf0) | 0x80; \
578 if (new_fpcr != old_fpcr) \
579 __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr)); \
580 } while (0)
581#define _Py_SET_53BIT_PRECISION_END \
582 do { \
583 if (new_fpcr != old_fpcr) \
584 __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr)); \
585 } while (0)
586#endif
587
588/* default definitions are empty */
589#ifndef HAVE_PY_SET_53BIT_PRECISION
590#define _Py_SET_53BIT_PRECISION_HEADER
591#define _Py_SET_53BIT_PRECISION_START
592#define _Py_SET_53BIT_PRECISION_END
593#endif
594
595/* If we can't guarantee 53-bit precision, don't use the code
596 in Python/dtoa.c, but fall back to standard code. This
597 means that repr of a float will be long (17 sig digits).
598
599 Realistically, there are two things that could go wrong:
600
601 (1) doubles aren't IEEE 754 doubles, or
602 (2) we're on x86 with the rounding precision set to 64-bits
603 (extended precision), and we don't know how to change
604 the rounding precision.
605 */
606
607#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \
608 !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \
609 !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754)
610#define PY_NO_SHORT_FLOAT_REPR
611#endif
612
613/* double rounding is symptomatic of use of extended precision on x86. If
614 we're seeing double rounding, and we don't have any mechanism available for
615 changing the FPU rounding precision, then don't use Python/dtoa.c. */
616#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION)
617#define PY_NO_SHORT_FLOAT_REPR
618#endif
619
620
621/* Py_DEPRECATED(version)
622 * Declare a variable, type, or function deprecated.
623 * Usage:
624 * extern int old_var Py_DEPRECATED(2.3);
625 * typedef int T1 Py_DEPRECATED(2.4);
626 * extern int x() Py_DEPRECATED(2.5);
627 */
628#if defined(__GNUC__) && ((__GNUC__ >= 4) || \
629 (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
630#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
631#else
632#define Py_DEPRECATED(VERSION_UNUSED)
633#endif
634
635/**************************************************************************
636Prototypes that are missing from the standard include files on some systems
637(and possibly only some versions of such systems.)
638
639Please be conservative with adding new ones, document them and enclose them
640in platform-specific #ifdefs.
641**************************************************************************/
642
643#ifdef SOLARIS
644/* Unchecked */
645extern int gethostname(char *, int);
646#endif
647
648#ifdef HAVE__GETPTY
649#include <sys/types.h> /* we need to import mode_t */
650extern char * _getpty(int *, int, mode_t, int);
651#endif
652
653/* On QNX 6, struct termio must be declared by including sys/termio.h
654 if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must
655 be included before termios.h or it will generate an error. */
656#if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux)
657#include <sys/termio.h>
658#endif
659
660#if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY)
661#if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H)
662/* BSDI does not supply a prototype for the 'openpty' and 'forkpty'
663 functions, even though they are included in libutil. */
664#include <termios.h>
665extern int openpty(int *, int *, char *, struct termios *, struct winsize *);
666extern pid_t forkpty(int *, char *, struct termios *, struct winsize *);
667#endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */
668#endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */
669
670
671/* On 4.4BSD-descendants, ctype functions serves the whole range of
672 * wchar_t character set rather than single byte code points only.
673 * This characteristic can break some operations of string object
674 * including str.upper() and str.split() on UTF-8 locales. This
675 * workaround was provided by Tim Robbins of FreeBSD project.
676 */
677
678#ifdef __FreeBSD__
679#include <osreldate.h>
680#if __FreeBSD_version > 500039
681# define _PY_PORT_CTYPE_UTF8_ISSUE
682#endif
683#endif
684
685
686#if defined(__APPLE__)
687# define _PY_PORT_CTYPE_UTF8_ISSUE
688#endif
689
690#ifdef _PY_PORT_CTYPE_UTF8_ISSUE
691#include <ctype.h>
692#include <wctype.h>
693#undef isalnum
694#define isalnum(c) iswalnum(btowc(c))
695#undef isalpha
696#define isalpha(c) iswalpha(btowc(c))
697#undef islower
698#define islower(c) iswlower(btowc(c))
699#undef isspace
700#define isspace(c) iswspace(btowc(c))
701#undef isupper
702#define isupper(c) iswupper(btowc(c))
703#undef tolower
704#define tolower(c) towlower(btowc(c))
705#undef toupper
706#define toupper(c) towupper(btowc(c))
707#endif
708
709
710/* Declarations for symbol visibility.
711
712 PyAPI_FUNC(type): Declares a public Python API function and return type
713 PyAPI_DATA(type): Declares public Python data and its type
714 PyMODINIT_FUNC: A Python module init function. If these functions are
715 inside the Python core, they are private to the core.
716 If in an extension module, it may be declared with
717 external linkage depending on the platform.
718
719 As a number of platforms support/require "__declspec(dllimport/dllexport)",
720 we support a HAVE_DECLSPEC_DLL macro to save duplication.
721*/
722
723/*
724 All windows ports, except cygwin, are handled in PC/pyconfig.h.
725
726 Cygwin is the only other autoconf platform requiring special
727 linkage handling and it uses __declspec().
728*/
729#if defined(__CYGWIN__)
730# define HAVE_DECLSPEC_DLL
731#endif
732
733/* only get special linkage if built as shared or platform is Cygwin */
734#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
735# if defined(HAVE_DECLSPEC_DLL)
736# ifdef Py_BUILD_CORE
737# define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
738# define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
739 /* module init functions inside the core need no external linkage */
740 /* except for Cygwin to handle embedding */
741# if defined(__CYGWIN__)
742# define PyMODINIT_FUNC __declspec(dllexport) PyObject*
743# else /* __CYGWIN__ */
744# define PyMODINIT_FUNC PyObject*
745# endif /* __CYGWIN__ */
746# else /* Py_BUILD_CORE */
747 /* Building an extension module, or an embedded situation */
748 /* public Python functions and data are imported */
749 /* Under Cygwin, auto-import functions to prevent compilation */
750 /* failures similar to those described at the bottom of 4.1: */
751 /* http://docs.python.org/extending/windows.html#a-cookbook-approach */
752# if !defined(__CYGWIN__)
753# define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
754# endif /* !__CYGWIN__ */
755# define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
756 /* module init functions outside the core must be exported */
757# if defined(__cplusplus)
758# define PyMODINIT_FUNC extern "C" __declspec(dllexport) PyObject*
759# else /* __cplusplus */
760# define PyMODINIT_FUNC __declspec(dllexport) PyObject*
761# endif /* __cplusplus */
762# endif /* Py_BUILD_CORE */
763# endif /* HAVE_DECLSPEC */
764#endif /* Py_ENABLE_SHARED */
765
766/* If no external linkage macros defined by now, create defaults */
767#ifndef PyAPI_FUNC
768# define PyAPI_FUNC(RTYPE) RTYPE
769#endif
770#ifndef PyAPI_DATA
771# define PyAPI_DATA(RTYPE) extern RTYPE
772#endif
773#ifndef PyMODINIT_FUNC
774# if defined(__cplusplus)
775# define PyMODINIT_FUNC extern "C" PyObject*
776# else /* __cplusplus */
777# define PyMODINIT_FUNC PyObject*
778# endif /* __cplusplus */
779#endif
780
781/* limits.h constants that may be missing */
782
783#ifndef INT_MAX
784#define INT_MAX 2147483647
785#endif
786
787#ifndef LONG_MAX
788#if SIZEOF_LONG == 4
789#define LONG_MAX 0X7FFFFFFFL
790#elif SIZEOF_LONG == 8
791#define LONG_MAX 0X7FFFFFFFFFFFFFFFL
792#else
793#error "could not set LONG_MAX in pyport.h"
794#endif
795#endif
796
797#ifndef LONG_MIN
798#define LONG_MIN (-LONG_MAX-1)
799#endif
800
801#ifndef LONG_BIT
802#define LONG_BIT (8 * SIZEOF_LONG)
803#endif
804
805#if LONG_BIT != 8 * SIZEOF_LONG
806/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
807 * 32-bit platforms using gcc. We try to catch that here at compile-time
808 * rather than waiting for integer multiplication to trigger bogus
809 * overflows.
810 */
811#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
812#endif
813
814#ifdef __cplusplus
815}
816#endif
817
818/*
819 * Hide GCC attributes from compilers that don't support them.
820 */
821#if (!defined(__GNUC__) || __GNUC__ < 2 || \
822 (__GNUC__ == 2 && __GNUC_MINOR__ < 7) )
823#define Py_GCC_ATTRIBUTE(x)
824#else
825#define Py_GCC_ATTRIBUTE(x) __attribute__(x)
826#endif
827
828/*
829 * Specify alignment on compilers that support it.
830 */
831#if defined(__GNUC__) && __GNUC__ >= 3
832#define Py_ALIGNED(x) __attribute__((aligned(x)))
833#else
834#define Py_ALIGNED(x)
835#endif
836
837/* Eliminate end-of-loop code not reached warnings from SunPro C
838 * when using do{...}while(0) macros
839 */
840#ifdef __SUNPRO_C
841#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
842#endif
843
844/*
845 * Older Microsoft compilers don't support the C99 long long literal suffixes,
846 * so these will be defined in PC/pyconfig.h for those compilers.
847 */
848#ifndef Py_LL
849#define Py_LL(x) x##LL
850#endif
851
852#ifndef Py_ULL
853#define Py_ULL(x) Py_LL(x##U)
854#endif
855
856#ifdef VA_LIST_IS_ARRAY
857#define Py_VA_COPY(x, y) Py_MEMCPY((x), (y), sizeof(va_list))
858#else
859#ifdef __va_copy
860#define Py_VA_COPY __va_copy
861#else
862#define Py_VA_COPY(x, y) (x) = (y)
863#endif
864#endif
865
866/*
867 * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is
868 * detected by configure and defined in pyconfig.h. The code in pyconfig.h
869 * also takes care of Apple's universal builds.
870 */
871
872#ifdef WORDS_BIGENDIAN
873#define PY_BIG_ENDIAN 1
874#define PY_LITTLE_ENDIAN 0
875#else
876#define PY_BIG_ENDIAN 0
877#define PY_LITTLE_ENDIAN 1
878#endif
879
880#ifdef Py_BUILD_CORE
881/*
882 * Macros to protect CRT calls against instant termination when passed an
883 * invalid parameter (issue23524).
884 */
885#if defined _MSC_VER && _MSC_VER >= 1900
886
887extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler;
888#define _Py_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \
889 _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler);
890#define _Py_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); }
891
892#else
893
894#define _Py_BEGIN_SUPPRESS_IPH
895#define _Py_END_SUPPRESS_IPH
896
897#endif /* _MSC_VER >= 1900 */
898#endif /* Py_BUILD_CORE */
899
900#endif /* Py_PYPORT_H */
901