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

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