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
