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

source code of include/python3.10/pyport.h