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/* 207#if SIZEOF_PID_T > SIZEOF_LONG 208# error "Python doesn't support sizeof(pid_t) > sizeof(long)" 209#endif 210*/ 211 212/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf 213 * format to convert an argument with the width of a size_t or Py_ssize_t. 214 * C99 introduced "z" for this purpose, but not all platforms support that; 215 * e.g., MS compilers use "I" instead. 216 * 217 * These "high level" Python format functions interpret "z" correctly on 218 * all platforms (Python interprets the format string itself, and does whatever 219 * the platform C requires to convert a size_t/Py_ssize_t argument): 220 * 221 * PyString_FromFormat 222 * PyErr_Format 223 * PyString_FromFormatV 224 * 225 * Lower-level uses require that you interpolate the correct format modifier 226 * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for 227 * example, 228 * 229 * Py_ssize_t index; 230 * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index); 231 * 232 * That will expand to %ld, or %Id, or to something else correct for a 233 * Py_ssize_t on the platform. 234 */ 235#ifndef PY_FORMAT_SIZE_T 236# if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__) 237# define PY_FORMAT_SIZE_T "" 238# elif SIZEOF_SIZE_T == SIZEOF_LONG 239# define PY_FORMAT_SIZE_T "l" 240# elif defined(MS_WINDOWS) 241# define PY_FORMAT_SIZE_T "I" 242# elif defined(__MINGW32__) && defined(__USE_MINGW_ANSI_STDIO) 243# define PY_FORMAT_SIZE_T "z" 244# else 245# error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T" 246# endif 247#endif 248 249/* PY_FORMAT_LONG_LONG is analogous to PY_FORMAT_SIZE_T above, but for 250 * the long long type instead of the size_t type. It's only available 251 * when HAVE_LONG_LONG is defined. The "high level" Python format 252 * functions listed above will interpret "lld" or "llu" correctly on 253 * all platforms. 254 */ 255#ifdef HAVE_LONG_LONG 256# ifndef PY_FORMAT_LONG_LONG 257# if defined(MS_WIN64) || defined(MS_WINDOWS) 258# define PY_FORMAT_LONG_LONG "I64" 259# else 260# error "This platform's pyconfig.h needs to define PY_FORMAT_LONG_LONG" 261# endif 262# endif 263#endif 264 265/* Py_LOCAL can be used instead of static to get the fastest possible calling 266 * convention for functions that are local to a given module. 267 * 268 * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining, 269 * for platforms that support that. 270 * 271 * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more 272 * "aggressive" inlining/optimizaion is enabled for the entire module. This 273 * may lead to code bloat, and may slow things down for those reasons. It may 274 * also lead to errors, if the code relies on pointer aliasing. Use with 275 * care. 276 * 277 * NOTE: You can only use this for functions that are entirely local to a 278 * module; functions that are exported via method tables, callbacks, etc, 279 * should keep using static. 280 */ 281 282#undef USE_INLINE /* XXX - set via configure? */ 283 284#if defined(_MSC_VER) 285#if defined(PY_LOCAL_AGGRESSIVE) 286/* enable more aggressive optimization for visual studio */ 287#pragma optimize("agtw", on) 288#endif 289/* ignore warnings if the compiler decides not to inline a function */ 290#pragma warning(disable: 4710) 291/* fastest possible local call under MSVC */ 292#define Py_LOCAL(type) static type __fastcall 293#define Py_LOCAL_INLINE(type) static __inline type __fastcall 294#elif defined(USE_INLINE) 295#define Py_LOCAL(type) static type 296#define Py_LOCAL_INLINE(type) static inline type 297#else 298#define Py_LOCAL(type) static type 299#define Py_LOCAL_INLINE(type) static type 300#endif 301 302/* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks 303 * are often very short. While most platforms have highly optimized code for 304 * large transfers, the setup costs for memcpy are often quite high. MEMCPY 305 * solves this by doing short copies "in line". 306 */ 307 308#if defined(_MSC_VER) 309#define Py_MEMCPY(target, source, length) do { \ 310 size_t i_, n_ = (length); \ 311 char *t_ = (void*) (target); \ 312 const char *s_ = (void*) (source); \ 313 if (n_ >= 16) \ 314 memcpy(t_, s_, n_); \ 315 else \ 316 for (i_ = 0; i_ < n_; i_++) \ 317 t_[i_] = s_[i_]; \ 318 } while (0) 319#else 320#define Py_MEMCPY memcpy 321#endif 322 323#include <stdlib.h> 324 325#ifdef HAVE_IEEEFP_H 326#include <ieeefp.h> /* needed for 'finite' declaration on some platforms */ 327#endif 328 329#include <math.h> /* Moved here from the math section, before extern "C" */ 330 331/******************************************** 332 * WRAPPER FOR <time.h> and/or <sys/time.h> * 333 ********************************************/ 334 335#ifdef TIME_WITH_SYS_TIME 336#include <sys/time.h> 337#include <time.h> 338#else /* !TIME_WITH_SYS_TIME */ 339#ifdef HAVE_SYS_TIME_H 340#include <sys/time.h> 341#else /* !HAVE_SYS_TIME_H */ 342#include <time.h> 343#endif /* !HAVE_SYS_TIME_H */ 344#endif /* !TIME_WITH_SYS_TIME */ 345 346 347/****************************** 348 * WRAPPER FOR <sys/select.h> * 349 ******************************/ 350 351/* NB caller must include <sys/types.h> */ 352 353#ifdef HAVE_SYS_SELECT_H 354 355#include <sys/select.h> 356 357#endif /* !HAVE_SYS_SELECT_H */ 358 359/******************************* 360 * stat() and fstat() fiddling * 361 *******************************/ 362 363/* We expect that stat and fstat exist on most systems. 364 * It's confirmed on Unix, Mac and Windows. 365 * If you don't have them, add 366 * #define DONT_HAVE_STAT 367 * and/or 368 * #define DONT_HAVE_FSTAT 369 * to your pyconfig.h. Python code beyond this should check HAVE_STAT and 370 * HAVE_FSTAT instead. 371 * Also 372 * #define HAVE_SYS_STAT_H 373 * if <sys/stat.h> exists on your platform, and 374 * #define HAVE_STAT_H 375 * if <stat.h> does. 376 */ 377#ifndef DONT_HAVE_STAT 378#define HAVE_STAT 379#endif 380 381#ifndef DONT_HAVE_FSTAT 382#define HAVE_FSTAT 383#endif 384 385#ifdef RISCOS 386#include <sys/types.h> 387#include "unixstuff.h" 388#endif 389 390#ifdef HAVE_SYS_STAT_H 391#if defined(PYOS_OS2) && defined(PYCC_GCC) 392#include <sys/types.h> 393#endif 394#include <sys/stat.h> 395#elif defined(HAVE_STAT_H) 396#include <stat.h> 397#endif 398 399#if defined(PYCC_VACPP) 400/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */ 401#define S_IFMT (S_IFDIR|S_IFCHR|S_IFREG) 402#endif 403 404#ifndef S_ISREG 405#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG) 406#endif 407 408#ifndef S_ISDIR 409#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR) 410#endif 411 412 413#ifdef __cplusplus 414/* Move this down here since some C++ #include's don't like to be included 415 inside an extern "C" */ 416extern "C" { 417#endif 418 419 420/* Py_ARITHMETIC_RIGHT_SHIFT 421 * C doesn't define whether a right-shift of a signed integer sign-extends 422 * or zero-fills. Here a macro to force sign extension: 423 * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) 424 * Return I >> J, forcing sign extension. Arithmetically, return the 425 * floor of I/2**J. 426 * Requirements: 427 * I should have signed integer type. In the terminology of C99, this can 428 * be either one of the five standard signed integer types (signed char, 429 * short, int, long, long long) or an extended signed integer type. 430 * J is an integer >= 0 and strictly less than the number of bits in the 431 * type of I (because C doesn't define what happens for J outside that 432 * range either). 433 * TYPE used to specify the type of I, but is now ignored. It's been left 434 * in for backwards compatibility with versions <= 2.6 or 3.0. 435 * Caution: 436 * I may be evaluated more than once. 437 */ 438#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS 439#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \ 440 ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J)) 441#else 442#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J)) 443#endif 444 445/* Py_FORCE_EXPANSION(X) 446 * "Simply" returns its argument. However, macro expansions within the 447 * argument are evaluated. This unfortunate trickery is needed to get 448 * token-pasting to work as desired in some cases. 449 */ 450#define Py_FORCE_EXPANSION(X) X 451 452/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) 453 * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this 454 * assert-fails if any information is lost. 455 * Caution: 456 * VALUE may be evaluated more than once. 457 */ 458#ifdef Py_DEBUG 459#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \ 460 (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE)) 461#else 462#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE) 463#endif 464 465/* Py_SET_ERRNO_ON_MATH_ERROR(x) 466 * If a libm function did not set errno, but it looks like the result 467 * overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno 468 * to 0 before calling a libm function, and invoke this macro after, 469 * passing the function result. 470 * Caution: 471 * This isn't reliable. See Py_OVERFLOWED comments. 472 * X is evaluated more than once. 473 */ 474#if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64)) 475#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM; 476#else 477#define _Py_SET_EDOM_FOR_NAN(X) ; 478#endif 479#define Py_SET_ERRNO_ON_MATH_ERROR(X) \ 480 do { \ 481 if (errno == 0) { \ 482 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \ 483 errno = ERANGE; \ 484 else _Py_SET_EDOM_FOR_NAN(X) \ 485 } \ 486 } while(0) 487 488/* Py_SET_ERANGE_ON_OVERFLOW(x) 489 * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility. 490 */ 491#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X) 492 493/* Py_ADJUST_ERANGE1(x) 494 * Py_ADJUST_ERANGE2(x, y) 495 * Set errno to 0 before calling a libm function, and invoke one of these 496 * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful 497 * for functions returning complex results). This makes two kinds of 498 * adjustments to errno: (A) If it looks like the platform libm set 499 * errno=ERANGE due to underflow, clear errno. (B) If it looks like the 500 * platform libm overflowed but didn't set errno, force errno to ERANGE. In 501 * effect, we're trying to force a useful implementation of C89 errno 502 * behavior. 503 * Caution: 504 * This isn't reliable. See Py_OVERFLOWED comments. 505 * X and Y may be evaluated more than once. 506 */ 507#define Py_ADJUST_ERANGE1(X) \ 508 do { \ 509 if (errno == 0) { \ 510 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \ 511 errno = ERANGE; \ 512 } \ 513 else if (errno == ERANGE && (X) == 0.0) \ 514 errno = 0; \ 515 } while(0) 516 517#define Py_ADJUST_ERANGE2(X, Y) \ 518 do { \ 519 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL || \ 520 (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) { \ 521 if (errno == 0) \ 522 errno = ERANGE; \ 523 } \ 524 else if (errno == ERANGE) \ 525 errno = 0; \ 526 } while(0) 527 528/* The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are 529 * required to support the short float repr introduced in Python 3.1) require 530 * that the floating-point unit that's being used for arithmetic operations 531 * on C doubles is set to use 53-bit precision. It also requires that the 532 * FPU rounding mode is round-half-to-even, but that's less often an issue. 533 * 534 * If your FPU isn't already set to 53-bit precision/round-half-to-even, and 535 * you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should 536 * 537 * #define HAVE_PY_SET_53BIT_PRECISION 1 538 * 539 * and also give appropriate definitions for the following three macros: 540 * 541 * _PY_SET_53BIT_PRECISION_START : store original FPU settings, and 542 * set FPU to 53-bit precision/round-half-to-even 543 * _PY_SET_53BIT_PRECISION_END : restore original FPU settings 544 * _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to 545 * use the two macros above. 546 * 547 * The macros are designed to be used within a single C function: see 548 * Python/pystrtod.c for an example of their use. 549 */ 550 551/* get and set x87 control word for gcc/x86 */ 552#ifdef HAVE_GCC_ASM_FOR_X87 553#define HAVE_PY_SET_53BIT_PRECISION 1 554/* _Py_get/set_387controlword functions are defined in Python/pymath.c */ 555#define _Py_SET_53BIT_PRECISION_HEADER \ 556 unsigned short old_387controlword, new_387controlword 557#define _Py_SET_53BIT_PRECISION_START \ 558 do { \ 559 old_387controlword = _Py_get_387controlword(); \ 560 new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \ 561 if (new_387controlword != old_387controlword) \ 562 _Py_set_387controlword(new_387controlword); \ 563 } while (0) 564#define _Py_SET_53BIT_PRECISION_END \ 565 if (new_387controlword != old_387controlword) \ 566 _Py_set_387controlword(old_387controlword) 567#endif 568 569/* get and set x87 control word for VisualStudio/x86 */ 570#if defined(_MSC_VER) && !defined(_WIN64) /* x87 not supported in 64-bit */ 571#define HAVE_PY_SET_53BIT_PRECISION 1 572#define _Py_SET_53BIT_PRECISION_HEADER \ 573 unsigned int old_387controlword, new_387controlword, out_387controlword 574/* We use the __control87_2 function to set only the x87 control word. 575 The SSE control word is unaffected. */ 576#define _Py_SET_53BIT_PRECISION_START \ 577 do { \ 578 __control87_2(0, 0, &old_387controlword, NULL); \ 579 new_387controlword = \ 580 (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \ 581 if (new_387controlword != old_387controlword) \ 582 __control87_2(new_387controlword, _MCW_PC | _MCW_RC, \ 583 &out_387controlword, NULL); \ 584 } while (0) 585#define _Py_SET_53BIT_PRECISION_END \ 586 do { \ 587 if (new_387controlword != old_387controlword) \ 588 __control87_2(old_387controlword, _MCW_PC | _MCW_RC, \ 589 &out_387controlword, NULL); \ 590 } while (0) 591#endif 592 593/* default definitions are empty */ 594#ifndef HAVE_PY_SET_53BIT_PRECISION 595#define _Py_SET_53BIT_PRECISION_HEADER 596#define _Py_SET_53BIT_PRECISION_START 597#define _Py_SET_53BIT_PRECISION_END 598#endif 599 600/* If we can't guarantee 53-bit precision, don't use the code 601 in Python/dtoa.c, but fall back to standard code. This 602 means that repr of a float will be long (17 sig digits). 603 604 Realistically, there are two things that could go wrong: 605 606 (1) doubles aren't IEEE 754 doubles, or 607 (2) we're on x86 with the rounding precision set to 64-bits 608 (extended precision), and we don't know how to change 609 the rounding precision. 610 */ 611 612#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \ 613 !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \ 614 !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754) 615#define PY_NO_SHORT_FLOAT_REPR 616#endif 617 618/* double rounding is symptomatic of use of extended precision on x86. If 619 we're seeing double rounding, and we don't have any mechanism available for 620 changing the FPU rounding precision, then don't use Python/dtoa.c. */ 621#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION) 622#define PY_NO_SHORT_FLOAT_REPR 623#endif 624 625/* Py_DEPRECATED(version) 626 * Declare a variable, type, or function deprecated. 627 * Usage: 628 * extern int old_var Py_DEPRECATED(2.3); 629 * typedef int T1 Py_DEPRECATED(2.4); 630 * extern int x() Py_DEPRECATED(2.5); 631 */ 632#if defined(__GNUC__) && ((__GNUC__ >= 4) || \ 633 (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) 634#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) 635#else 636#define Py_DEPRECATED(VERSION_UNUSED) 637#endif 638 639/************************************************************************** 640Prototypes that are missing from the standard include files on some systems 641(and possibly only some versions of such systems.) 642 643Please be conservative with adding new ones, document them and enclose them 644in platform-specific #ifdefs. 645**************************************************************************/ 646 647#ifdef SOLARIS 648/* Unchecked */ 649extern int gethostname(char *, int); 650#endif 651 652#ifdef __BEOS__ 653/* Unchecked */ 654/* It's in the libs, but not the headers... - [cjh] */ 655int shutdown( int, int ); 656#endif 657 658#ifdef HAVE__GETPTY 659#include <sys/types.h> /* we need to import mode_t */ 660extern char * _getpty(int *, int, mode_t, int); 661#endif 662 663/* On QNX 6, struct termio must be declared by including sys/termio.h 664 if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must 665 be included before termios.h or it will generate an error. */ 666#if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux) 667#include <sys/termio.h> 668#endif 669 670#if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) 671#if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) && !defined(HAVE_UTIL_H) 672/* BSDI does not supply a prototype for the 'openpty' and 'forkpty' 673 functions, even though they are included in libutil. */ 674#include <termios.h> 675extern int openpty(int *, int *, char *, struct termios *, struct winsize *); 676extern pid_t forkpty(int *, char *, struct termios *, struct winsize *); 677#endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */ 678#endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */ 679 680 681/* These are pulled from various places. It isn't obvious on what platforms 682 they are necessary, nor what the exact prototype should look like (which 683 is likely to vary between platforms!) If you find you need one of these 684 declarations, please move them to a platform-specific block and include 685 proper prototypes. */ 686#if 0 687 688/* From Modules/resource.c */ 689extern int getrusage(); 690extern int getpagesize(); 691 692/* From Python/sysmodule.c and Modules/posixmodule.c */ 693extern int fclose(FILE *); 694 695/* From Modules/posixmodule.c */ 696extern int fdatasync(int); 697#endif /* 0 */ 698 699 700#ifdef __MINGW32__ 701/* FIXME: some of next definitions specific to gcc(mingw build) can be 702 generalized on definitions of _WIN32 or WIN32 and to be common for 703 all windows build instead explicitly to define only for non-autotools 704 based builds (see PC/pyconfig.h for details). */ 705#if !defined(MS_WIN64) && defined(_WIN64) 706# define MS_WIN64 707#endif 708#if !defined(MS_WIN32) && defined(_WIN32) 709# define MS_WIN32 710#endif 711#if !defined(MS_WIN32) && defined(_WIN32) 712# define MS_WIN32 713#endif 714#if !defined(MS_WINDOWS) && defined(MS_WIN32) 715# define MS_WINDOWS 716#endif 717 718#ifndef PYTHONPATH 719# define PYTHONPATH ".\\DLLs;.\\lib;.\\lib\\plat-win;.\\lib\\lib-tk" 720#endif 721 722/* python 2.6+ requires Windows 2000 or greater. */ 723#define Py_WINVER 0x0500 724 725#if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_MODULE) 726/* FIXME if NTDDI_xxx is in use by mingw (see PC/pyconfig.h) */ 727#ifndef WINVER 728# define WINVER Py_WINVER 729#endif 730#ifndef _WIN32_WINNT 731# define _WIN32_WINNT Py_WINVER 732#endif 733#endif 734 735#ifdef PLATFORM 736/*NOTE: if compile getplatform.c PLATFORM is set to MACHDEP that is 737 "win" for mingw build (see respective comment in configure.in). */ 738# undef PLATFORM 739#endif 740/* always set to "win32" - see PC/pyconfig.h */ 741#define PLATFORM "win32" 742 743#if defined(MS_WIN64) 744# define SIZEOF_HKEY 8 745#elif defined(MS_WIN32) 746# define SIZEOF_HKEY 4 747#endif 748 749/*NOTE: mingw has isinf as macro defined in math.h. 750 Since PC/pyconfig.h define Py_IS_INFINITY(X) that cover HAVE_DECL_ISFINITE 751 here for Py_IS_INFINITY we define same as for MSVC build. 752 This makes HAVE_DECL_ISFINITE needless. 753 Also see commants in configure.in and pymath.h. */ 754#define Py_IS_INFINITY(X) (!_finite(X) && !_isnan(X)) 755 756#ifndef HAVE_LARGEFILE_SUPPORT 757/* 758 FIXME: on windows platforms: 759 - Python use PY_LONG_LONG(!) for Py_off_t (_fileio.c); 760 - HAVE_LARGEFILE_SUPPORT is defined in PC/pyconfig.h; 761 - PC/pyconfig.h define 4 for SIZEOF_OFF_T and 8 for SIZEOF_FPOS_T; 762 - If HAVE_LARGEFILE_SUPPORT isn't defined python will use off_t(!) 763 for Py_off_t (see fileobjects.c and bz2module.c). 764 Since for mingw configure detect 4 for size of "off_t" and 8 - for 765 "fpos_t" we has to define HAVE_LARGEFILE_SUPPORT too. 766 TODO: to test with AC_SYS_LARGEFILE and appropriate updates in 767 python code. 768*/ 769# define HAVE_LARGEFILE_SUPPORT 770#endif 771 772#if defined(Py_ENABLE_SHARED) 773# define MS_COREDLL 1 /* deprecated old symbol, but still in use for windows code */ 774#else 775# define MS_NO_COREDLL 1 776#endif 777 778#if Py_UNICODE_SIZE == 2 779/* For mingw is 2 but FIXME: What about to raise error in configure if 780 unicode size isn't two ? Did python windows code support ucs4 ? */ 781# define Py_WIN_WIDE_FILENAMES 782#endif 783 784/* NOTE: Don't define HAVE_STDDEF_H. 785 * It is defined by PC/pyconfig.h and used by Include/Python.h 786 * (with comment For size_t?) but isn't required for mingw */ 787#define Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE 788 789/* All other defines from PC/pyconfig.h are in autoconf generated 790 pyconfig.h */ 791#if 0 792/*FIXME: 793 MSDN: 794 "The getaddrinfo function was added to the ws2_32.dll on Windows XP 795 and later." 796 mingw: 797 getaddrinfo and getnameinfo is defined for WINVER >= 0x0501. 798 PC/pyconfig.h: 799 "Python 2.6+ requires Windows 2000 or greater" 800 So far so good but socketmodule.h define HAVE_GETADDRINFO and 801 HAVE_GETNAMEINFO under very specific condition : 802 # ifdef SIO_GET_MULTICAST_FILTER 803 # include <MSTcpIP.h> 804 So the question is "Separate SDKs" required for w2k in MSVC build ? 805 TODO: resolve later, may by configure :-/. For now python code will 806 use fake implementation and if user define appropriate value for 807 WINVER - the functionas from C runtime. 808 For details see socketmodule.c . 809 */ 810#ifndef HAVE_GETADDRINFO 811# define HAVE_GETADDRINFO 812#endif 813#ifndef HAVE_GETNAMEINFO 814# define HAVE_GETNAMEINFO 815#endif 816#endif 817 818/* Refer to <Modules/_math.h> . 819 For mingw host configure detect functions described as HAVE_XXX 820 in _math.h but as MSVC don't define them we will undefine HAVE_XXX 821 too to use _Py_* replacements same as MSVC build . 822 */ 823#undef HAVE_ACOSH 824#undef HAVE_ASINH 825#undef HAVE_ATANH 826#undef HAVE_EXPM1 827#undef HAVE_LOG1P 828 829#endif /*def __MINGW32__*/ 830 831/* On 4.4BSD-descendants, ctype functions serves the whole range of 832 * wchar_t character set rather than single byte code points only. 833 * This characteristic can break some operations of string object 834 * including str.upper() and str.split() on UTF-8 locales. This 835 * workaround was provided by Tim Robbins of FreeBSD project. 836 */ 837 838#ifdef __FreeBSD__ 839#include <osreldate.h> 840#if __FreeBSD_version > 500039 841# define _PY_PORT_CTYPE_UTF8_ISSUE 842#endif 843#endif 844 845 846#if defined(__APPLE__) 847# define _PY_PORT_CTYPE_UTF8_ISSUE 848#endif 849 850#ifdef _PY_PORT_CTYPE_UTF8_ISSUE 851#include <ctype.h> 852#include <wctype.h> 853#undef isalnum 854#define isalnum(c) iswalnum(btowc(c)) 855#undef isalpha 856#define isalpha(c) iswalpha(btowc(c)) 857#undef islower 858#define islower(c) iswlower(btowc(c)) 859#undef isspace 860#define isspace(c) iswspace(btowc(c)) 861#undef isupper 862#define isupper(c) iswupper(btowc(c)) 863#undef tolower 864#define tolower(c) towlower(btowc(c)) 865#undef toupper 866#define toupper(c) towupper(btowc(c)) 867#endif 868 869 870/* Declarations for symbol visibility. 871 872 PyAPI_FUNC(type): Declares a public Python API function and return type 873 PyAPI_DATA(type): Declares public Python data and its type 874 PyMODINIT_FUNC: A Python module init function. If these functions are 875 inside the Python core, they are private to the core. 876 If in an extension module, it may be declared with 877 external linkage depending on the platform. 878 879 As a number of platforms support/require "__declspec(dllimport/dllexport)", 880 we support a HAVE_DECLSPEC_DLL macro to save duplication. 881*/ 882 883/* 884 MSVC windows port is handled in PC/pyconfig.h. 885 886 BeOS, mingw32 and cygwin use autoconf and require special 887 linkage handling and all of these use __declspec(). 888*/ 889#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BEOS__) 890# define HAVE_DECLSPEC_DLL 891#endif 892 893/* only get special linkage if built as shared or platform is Cygwin */ 894#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__) 895# if defined(HAVE_DECLSPEC_DLL) 896# ifdef Py_BUILD_CORE 897# define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE 898# define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE 899 /* module init functions inside the core need no external linkage */ 900 /* except for Cygwin to handle embedding (FIXME: BeOS too?) */ 901# if defined(__CYGWIN__) 902# define PyMODINIT_FUNC __declspec(dllexport) void 903# else /* __CYGWIN__ */ 904# define PyMODINIT_FUNC void 905# endif /* __CYGWIN__ */ 906# else /* Py_BUILD_CORE */ 907 /* Building an extension module, or an embedded situation */ 908 /* public Python functions and data are imported */ 909 /* Under Cygwin, auto-import functions to prevent compilation */ 910 /* failures similar to those described at the bottom of 4.1: */ 911 /* http://docs.python.org/extending/windows.html#a-cookbook-approach */ 912# if !defined(__CYGWIN__) && !defined(__MINGW32__) 913# define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE 914# else 915# define PyAPI_FUNC(RTYPE) RTYPE 916# endif /* !__CYGWIN__ !__MINGW32__ */ 917 /* NOTE: The issue3945 "compile error in _fileio.c (cygwin)" 918 * was resolved with modification of code. 919 * This issue was resolved for gcc(mingw) with enabling auto 920 * import feature. Since _fileio.c problem now disappear there 921 * is no more reasons to avoid dllimport for gcc(mingw). 922 */ 923# define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE 924 /* module init functions outside the core must be exported */ 925# if defined(__cplusplus) 926# define PyMODINIT_FUNC extern "C" __declspec(dllexport) void 927# else /* __cplusplus */ 928# define PyMODINIT_FUNC __declspec(dllexport) void 929# endif /* __cplusplus */ 930# endif /* Py_BUILD_CORE */ 931# endif /* HAVE_DECLSPEC */ 932#endif /* Py_ENABLE_SHARED */ 933 934/* If no external linkage macros defined by now, create defaults */ 935#ifndef PyAPI_FUNC 936# define PyAPI_FUNC(RTYPE) RTYPE 937#endif 938#ifndef PyAPI_DATA 939# define PyAPI_DATA(RTYPE) extern RTYPE 940#endif 941#ifndef PyMODINIT_FUNC 942# if defined(__cplusplus) 943# define PyMODINIT_FUNC extern "C" void 944# else /* __cplusplus */ 945# define PyMODINIT_FUNC void 946# endif /* __cplusplus */ 947#endif 948 949/* Deprecated DL_IMPORT and DL_EXPORT macros */ 950#if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL) 951# if defined(Py_BUILD_CORE) 952# define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE 953# define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE 954# else 955# define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE 956# define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE 957# endif 958#endif 959#ifndef DL_EXPORT 960# define DL_EXPORT(RTYPE) RTYPE 961#endif 962#ifndef DL_IMPORT 963# define DL_IMPORT(RTYPE) RTYPE 964#endif 965/* End of deprecated DL_* macros */ 966 967/* If the fd manipulation macros aren't defined, 968 here is a set that should do the job */ 969 970#if 0 /* disabled and probably obsolete */ 971 972#ifndef FD_SETSIZE 973#define FD_SETSIZE 256 974#endif 975 976#ifndef FD_SET 977 978typedef long fd_mask; 979 980#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */ 981#ifndef howmany 982#define howmany(x, y) (((x)+((y)-1))/(y)) 983#endif /* howmany */ 984 985typedef struct fd_set { 986 fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)]; 987} fd_set; 988 989#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS))) 990#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS))) 991#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS))) 992#define FD_ZERO(p) memset((char *)(p), '\0', sizeof(*(p))) 993 994#endif /* FD_SET */ 995 996#endif /* fd manipulation macros */ 997 998 999/* limits.h constants that may be missing */ 1000 1001#ifndef INT_MAX 1002#define INT_MAX 2147483647 1003#endif 1004 1005#ifndef LONG_MAX 1006#if SIZEOF_LONG == 4 1007#define LONG_MAX 0X7FFFFFFFL 1008#elif SIZEOF_LONG == 8 1009#define LONG_MAX 0X7FFFFFFFFFFFFFFFL 1010#else 1011#error "could not set LONG_MAX in pyport.h" 1012#endif 1013#endif 1014 1015#ifndef LONG_MIN 1016#define LONG_MIN (-LONG_MAX-1) 1017#endif 1018 1019#ifndef LONG_BIT 1020#define LONG_BIT (8 * SIZEOF_LONG) 1021#endif 1022 1023#if LONG_BIT != 8 * SIZEOF_LONG 1024/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent 1025 * 32-bit platforms using gcc. We try to catch that here at compile-time 1026 * rather than waiting for integer multiplication to trigger bogus 1027 * overflows. 1028 */ 1029#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)." 1030#endif 1031 1032#ifdef __cplusplus 1033} 1034#endif 1035 1036/* 1037 * Hide GCC attributes from compilers that don't support them. 1038 */ 1039#if (!defined(__GNUC__) || __GNUC__ < 2 || \ 1040 (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \ 1041 !defined(RISCOS) 1042#define Py_GCC_ATTRIBUTE(x) 1043#else 1044#define Py_GCC_ATTRIBUTE(x) __attribute__(x) 1045#endif 1046 1047/* 1048 * Add PyArg_ParseTuple format where available. 1049 */ 1050#ifdef HAVE_ATTRIBUTE_FORMAT_PARSETUPLE 1051#define Py_FORMAT_PARSETUPLE(func,p1,p2) __attribute__((format(func,p1,p2))) 1052#else 1053#define Py_FORMAT_PARSETUPLE(func,p1,p2) 1054#endif 1055 1056/* 1057 * Specify alignment on compilers that support it. 1058 */ 1059#if defined(__GNUC__) && __GNUC__ >= 3 1060#define Py_ALIGNED(x) __attribute__((aligned(x))) 1061#else 1062#define Py_ALIGNED(x) 1063#endif 1064 1065/* Eliminate end-of-loop code not reached warnings from SunPro C 1066 * when using do{...}while(0) macros 1067 */ 1068#ifdef __SUNPRO_C 1069#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED) 1070#endif 1071 1072/* 1073 * Older Microsoft compilers don't support the C99 long long literal suffixes, 1074 * so these will be defined in PC/pyconfig.h for those compilers. 1075 */ 1076#ifndef Py_LL 1077#define Py_LL(x) x##LL 1078#endif 1079 1080#ifndef Py_ULL 1081#define Py_ULL(x) Py_LL(x##U) 1082#endif 1083 1084#endif /* Py_PYPORT_H */ 1085