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