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