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