AppPkg/Applications/Python/Python-2.7.10/Include/pyport.h

   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 /**************************************************************************
  17 Symbols and macros to supply platform-independent interfaces to basic
  18 C language & library operations whose spellings vary across platforms.
  19
  20 Please try to make documentation here as clear as possible:  by definition,
  21 the stuff here is trying to illuminate C's darkest corners.
  22
  23 Config #defines referenced here:
  24
  25 SIGNED_RIGHT_SHIFT_ZERO_FILLS
  26 Meaning:  To be defined iff i>>j does not extend the sign bit when i is a
  27           signed integral type and i < 0.
  28 Used in:  Py_ARITHMETIC_RIGHT_SHIFT
  29
  30 Py_DEBUG
  31 Meaning:  Extra checks compiled in for debug mode.
  32 Used in:  Py_SAFE_DOWNCAST
  33
  34 HAVE_UINTPTR_T
  35 Meaning:  The C9X type uintptr_t is supported by the compiler
  36 Used in:  Py_uintptr_t
  37
  38 HAVE_LONG_LONG
  39 Meaning:  The compiler supports the C type "long long"
  40 Used 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
 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 #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" */
 412 extern "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 /**************************************************************************
 636 Prototypes that are missing from the standard include files on some systems
 637 (and possibly only some versions of such systems.)
 638
 639 Please be conservative with adding new ones, document them and enclose them
 640 in platform-specific #ifdefs.
 641 **************************************************************************/
 642
 643 #ifdef SOLARIS
 644 /* Unchecked */
 645 extern int gethostname(char *, int);
 646 #endif
 647
 648 #ifdef __BEOS__
 649 /* Unchecked */
 650 /* It's in the libs, but not the headers... - [cjh] */
 651 int shutdown( int, int );
 652 #endif
 653
 654 #ifdef HAVE__GETPTY
 655 #include <sys/types.h>          /* we need to import mode_t */
 656 extern 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>
 671 extern int openpty(int *, int *, char *, struct termios *, struct winsize *);
 672 extern 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 */
 685 extern int getrusage();
 686 extern int getpagesize();
 687
 688 /* From Python/sysmodule.c and Modules/posixmodule.c */
 689 extern int fclose(FILE *);
 690
 691 /* From Modules/posixmodule.c */
 692 extern 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 > 500039
 706 # define _PY_PORT_CTYPE_UTF8_ISSUE
 707 #endif
 708 #endif
 709
 710
 711 #if defined(__APPLE__)
 712 # define _PY_PORT_CTYPE_UTF8_ISSUE
 713 #endif
 714
 715 #ifdef _PY_PORT_CTYPE_UTF8_ISSUE
 716 #include <ctype.h>
 717 #include <wctype.h>
 718 #undef isalnum
 719 #define isalnum(c) iswalnum(btowc(c))
 720 #undef isalpha
 721 #define isalpha(c) iswalpha(btowc(c))
 722 #undef islower
 723 #define islower(c) iswlower(btowc(c))
 724 #undef isspace
 725 #define isspace(c) iswspace(btowc(c))
 726 #undef isupper
 727 #define isupper(c) iswupper(btowc(c))
 728 #undef tolower
 729 #define tolower(c) towlower(btowc(c))
 730 #undef toupper
 731 #define toupper(c) towupper(btowc(c))
 732 #endif
 733
 734
 735 /* Declarations for symbol visibility.
 736
 737   PyAPI_FUNC(type): Declares a public Python API function and return type
 738   PyAPI_DATA(type): Declares public Python data and its type
 739   PyMODINIT_FUNC:   A Python module init function.  If these functions are
 740                     inside the Python core, they are private to the core.
 741                     If in an extension module, it may be declared with
 742                     external linkage depending on the platform.
 743
 744   As a number of platforms support/require "__declspec(dllimport/dllexport)",
 745   we support a HAVE_DECLSPEC_DLL macro to save duplication.
 746 */
 747
 748 /*
 749   All windows ports, except cygwin, are handled in PC/pyconfig.h.
 750
 751   BeOS and cygwin are the only other autoconf platform requiring special
 752   linkage handling and both of these use __declspec().
 753 */
 754 #if defined(__CYGWIN__) || defined(__BEOS__)
 755 #       define HAVE_DECLSPEC_DLL
 756 #endif
 757
 758 /* only get special linkage if built as shared or platform is Cygwin */
 759 #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
 760 #       if defined(HAVE_DECLSPEC_DLL)
 761 #               ifdef Py_BUILD_CORE
 762 #                       define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
 763 #                       define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
 764         /* module init functions inside the core need no external linkage */
 765         /* except for Cygwin to handle embedding (FIXME: BeOS too?) */
 766 #                       if defined(__CYGWIN__)
 767 #                               define PyMODINIT_FUNC __declspec(dllexport) void
 768 #                       else /* __CYGWIN__ */
 769 #                               define PyMODINIT_FUNC void
 770 #                       endif /* __CYGWIN__ */
 771 #               else /* Py_BUILD_CORE */
 772         /* Building an extension module, or an embedded situation */
 773         /* public Python functions and data are imported */
 774         /* Under Cygwin, auto-import functions to prevent compilation */
 775         /* failures similar to those described at the bottom of 4.1: */
 776         /* http://docs.python.org/extending/windows.html#a-cookbook-approach */
 777 #                       if !defined(__CYGWIN__)
 778 #                               define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
 779 #                       endif /* !__CYGWIN__ */
 780 #                       define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
 781         /* module init functions outside the core must be exported */
 782 #                       if defined(__cplusplus)
 783 #                               define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
 784 #                       else /* __cplusplus */
 785 #                               define PyMODINIT_FUNC __declspec(dllexport) void
 786 #                       endif /* __cplusplus */
 787 #               endif /* Py_BUILD_CORE */
 788 #       endif /* HAVE_DECLSPEC */
 789 #endif /* Py_ENABLE_SHARED */
 790
 791 /* If no external linkage macros defined by now, create defaults */
 792 #ifndef PyAPI_FUNC
 793 #       define PyAPI_FUNC(RTYPE) RTYPE
 794 #endif
 795 #ifndef PyAPI_DATA
 796 #       define PyAPI_DATA(RTYPE) extern RTYPE
 797 #endif
 798 #ifndef PyMODINIT_FUNC
 799 #       if defined(__cplusplus)
 800 #               define PyMODINIT_FUNC extern "C" void
 801 #       else /* __cplusplus */
 802 #               define PyMODINIT_FUNC void
 803 #       endif /* __cplusplus */
 804 #endif
 805
 806 /* Deprecated DL_IMPORT and DL_EXPORT macros */
 807 #if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)
 808 #       if defined(Py_BUILD_CORE)
 809 #               define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
 810 #               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
 811 #       else
 812 #               define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
 813 #               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
 814 #       endif
 815 #endif
 816 #ifndef DL_EXPORT
 817 #       define DL_EXPORT(RTYPE) RTYPE
 818 #endif
 819 #ifndef DL_IMPORT
 820 #       define DL_IMPORT(RTYPE) RTYPE
 821 #endif
 822 /* End of deprecated DL_* macros */
 823
 824 /* If the fd manipulation macros aren't defined,
 825    here is a set that should do the job */
 826
 827 #if 0 /* disabled and probably obsolete */
 828
 829 #ifndef FD_SETSIZE
 830 #define FD_SETSIZE      256
 831 #endif
 832
 833 #ifndef FD_SET
 834
 835 typedef long fd_mask;
 836
 837 #define NFDBITS (sizeof(fd_mask) * NBBY)        /* bits per mask */
 838 #ifndef howmany
 839 #define howmany(x, y)   (((x)+((y)-1))/(y))
 840 #endif /* howmany */
 841
 842 typedef struct fd_set {
 843     fd_mask     fds_bits[howmany(FD_SETSIZE, NFDBITS)];
 844 } fd_set;
 845
 846 #define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
 847 #define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
 848 #define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
 849 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
 850
 851 #endif /* FD_SET */
 852
 853 #endif /* fd manipulation macros */
 854
 855
 856 /* limits.h constants that may be missing */
 857
 858 #ifndef INT_MAX
 859 #define INT_MAX 2147483647
 860 #endif
 861
 862 #ifndef LONG_MAX
 863 #if SIZEOF_LONG == 4
 864 #define LONG_MAX 0X7FFFFFFFL
 865 #elif SIZEOF_LONG == 8
 866 #define LONG_MAX 0X7FFFFFFFFFFFFFFFL
 867 #else
 868 #error "could not set LONG_MAX in pyport.h"
 869 #endif
 870 #endif
 871
 872 #ifndef LONG_MIN
 873 #define LONG_MIN (-LONG_MAX-1)
 874 #endif
 875
 876 #ifndef LONG_BIT
 877 #define LONG_BIT (8 * SIZEOF_LONG)
 878 #endif
 879
 880 #if LONG_BIT != 8 * SIZEOF_LONG
 881 /* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
 882  * 32-bit platforms using gcc.  We try to catch that here at compile-time
 883  * rather than waiting for integer multiplication to trigger bogus
 884  * overflows.
 885  */
 886 #error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
 887 #endif
 888
 889 #ifdef __cplusplus
 890 }
 891 #endif
 892
 893 /*
 894  * Hide GCC attributes from compilers that don't support them.
 895  */
 896 #if (!defined(__GNUC__) || __GNUC__ < 2 || \
 897      (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \
 898     !defined(RISCOS)
 899 #define Py_GCC_ATTRIBUTE(x)
 900 #else
 901 #define Py_GCC_ATTRIBUTE(x) __attribute__(x)
 902 #endif
 903
 904 /*
 905  * Add PyArg_ParseTuple format where available.
 906  */
 907 #ifdef HAVE_ATTRIBUTE_FORMAT_PARSETUPLE
 908 #define Py_FORMAT_PARSETUPLE(func,p1,p2) __attribute__((format(func,p1,p2)))
 909 #else
 910 #define Py_FORMAT_PARSETUPLE(func,p1,p2)
 911 #endif
 912
 913 /*
 914  * Specify alignment on compilers that support it.
 915  */
 916 #if defined(__GNUC__) && __GNUC__ >= 3
 917 #define Py_ALIGNED(x) __attribute__((aligned(x)))
 918 #else
 919 #define Py_ALIGNED(x)
 920 #endif
 921
 922 /* Eliminate end-of-loop code not reached warnings from SunPro C
 923  * when using do{...}while(0) macros
 924  */
 925 #ifdef __SUNPRO_C
 926 #pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
 927 #endif
 928
 929 /*
 930  * Older Microsoft compilers don't support the C99 long long literal suffixes,
 931  * so these will be defined in PC/pyconfig.h for those compilers.
 932  */
 933 #ifndef Py_LL
 934 #define Py_LL(x) x##LL
 935 #endif
 936
 937 #ifndef Py_ULL
 938 #define Py_ULL(x) Py_LL(x##U)
 939 #endif
 940
 941 #endif /* Py_PYPORT_H */