Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/python3.8/pyport.h @ 69:33d812a61356

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