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