Include/pyport.h

   1 #ifndef Py_PYPORT_H
   2 #define Py_PYPORT_H
   3
   4 #include "pyconfig.h" /* include for defines */
   5
   6 #ifdef HAVE_STDINT_H
   7 #include <stdint.h>
   8 #endif
   9
  10 /**************************************************************************
  11 Symbols and macros to supply platform-independent interfaces to basic
  12 C language & library operations whose spellings vary across platforms.
  13
  14 Please try to make documentation here as clear as possible:  by definition,
  15 the stuff here is trying to illuminate C's darkest corners.
  16
  17 Config #defines referenced here:
  18
  19 SIGNED_RIGHT_SHIFT_ZERO_FILLS
  20 Meaning:  To be defined iff i>>j does not extend the sign bit when i is a
  21           signed integral type and i < 0.
  22 Used in:  Py_ARITHMETIC_RIGHT_SHIFT
  23
  24 Py_DEBUG
  25 Meaning:  Extra checks compiled in for debug mode.
  26 Used in:  Py_SAFE_DOWNCAST
  27
  28 HAVE_UINTPTR_T
  29 Meaning:  The C9X type uintptr_t is supported by the compiler
  30 Used in:  Py_uintptr_t
  31
  32 HAVE_LONG_LONG
  33 Meaning:  The compiler supports the C type "long long"
  34 Used in:  PY_LONG_LONG
  35
  36 **************************************************************************/
  37
  38
  39 /* For backward compatibility only. Obsolete, do not use. */
  40 #ifdef HAVE_PROTOTYPES
  41 #define Py_PROTO(x) x
  42 #else
  43 #define Py_PROTO(x) ()
  44 #endif
  45 #ifndef Py_FPROTO
  46 #define Py_FPROTO(x) Py_PROTO(x)
  47 #endif
  48
  49 /* typedefs for some C9X-defined synonyms for integral types.
  50  *
  51  * The names in Python are exactly the same as the C9X names, except with a
  52  * Py_ prefix.  Until C9X is universally implemented, this is the only way
  53  * to ensure that Python gets reliable names that don't conflict with names
  54  * in non-Python code that are playing their own tricks to define the C9X
  55  * names.
  56  *
  57  * NOTE: don't go nuts here!  Python has no use for *most* of the C9X
  58  * integral synonyms.  Only define the ones we actually need.
  59  */
  60
  61 #ifdef HAVE_LONG_LONG
  62 #ifndef PY_LONG_LONG
  63 #define PY_LONG_LONG long long
  64 #if defined(LLONG_MAX)
  65 /* If LLONG_MAX is defined in limits.h, use that. */
  66 #define PY_LLONG_MIN LLONG_MIN
  67 #define PY_LLONG_MAX LLONG_MAX
  68 #define PY_ULLONG_MAX ULLONG_MAX
  69 #elif defined(__LONG_LONG_MAX__)
  70 /* Otherwise, if GCC has a builtin define, use that. */
  71 #define PY_LLONG_MAX __LONG_LONG_MAX__
  72 #define PY_LLONG_MIN (-PY_LLONG_MAX-1)
  73 #define PY_ULLONG_MAX (__LONG_LONG_MAX__*2ULL + 1ULL)
  74 #else
  75 /* Otherwise, rely on two's complement. */
  76 #define PY_ULLONG_MAX (~0ULL)
  77 #define PY_LLONG_MAX  ((long long)(PY_ULLONG_MAX>>1))
  78 #define PY_LLONG_MIN (-PY_LLONG_MAX-1)
  79 #endif /* LLONG_MAX */
  80 #endif
  81 #endif /* HAVE_LONG_LONG */
  82
  83 /* uintptr_t is the C9X name for an unsigned integral type such that a
  84  * legitimate void* can be cast to uintptr_t and then back to void* again
  85  * without loss of information.  Similarly for intptr_t, wrt a signed
  86  * integral type.
  87  */
  88 #ifdef HAVE_UINTPTR_T
  89 typedef uintptr_t       Py_uintptr_t;
  90 typedef intptr_t        Py_intptr_t;
  91
  92 #elif SIZEOF_VOID_P <= SIZEOF_INT
  93 typedef unsigned int    Py_uintptr_t;
  94 typedef int             Py_intptr_t;
  95
  96 #elif SIZEOF_VOID_P <= SIZEOF_LONG
  97 typedef unsigned long   Py_uintptr_t;
  98 typedef long            Py_intptr_t;
  99
 100 #elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
 101 typedef unsigned PY_LONG_LONG   Py_uintptr_t;
 102 typedef PY_LONG_LONG            Py_intptr_t;
 103
 104 #else
 105 #   error "Python needs a typedef for Py_uintptr_t in pyport.h."
 106 #endif /* HAVE_UINTPTR_T */
 107
 108 /* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==
 109  * sizeof(size_t).  C99 doesn't define such a thing directly (size_t is an
 110  * unsigned integral type).  See PEP 353 for details.
 111  */
 112 #ifdef HAVE_SSIZE_T
 113 typedef ssize_t         Py_ssize_t;
 114 #elif SIZEOF_VOID_P == SIZEOF_SIZE_T
 115 typedef Py_intptr_t     Py_ssize_t;
 116 #else
 117 #   error "Python needs a typedef for Py_ssize_t in pyport.h."
 118 #endif
 119
 120 /* Largest positive value of type Py_ssize_t. */
 121 #define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
 122 /* Smallest negative value of type Py_ssize_t. */
 123 #define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
 124
 125 #if SIZEOF_PID_T > SIZEOF_LONG
 126 #   error "Python doesn't support sizeof(pid_t) > sizeof(long)"
 127 #endif
 128
 129 /* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
 130  * format to convert an argument with the width of a size_t or Py_ssize_t.
 131  * C99 introduced "z" for this purpose, but not all platforms support that;
 132  * e.g., MS compilers use "I" instead.
 133  *
 134  * These "high level" Python format functions interpret "z" correctly on
 135  * all platforms (Python interprets the format string itself, and does whatever
 136  * the platform C requires to convert a size_t/Py_ssize_t argument):
 137  *
 138  *     PyString_FromFormat
 139  *     PyErr_Format
 140  *     PyString_FromFormatV
 141  *
 142  * Lower-level uses require that you interpolate the correct format modifier
 143  * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
 144  * example,
 145  *
 146  *     Py_ssize_t index;
 147  *     fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);
 148  *
 149  * That will expand to %ld, or %Id, or to something else correct for a
 150  * Py_ssize_t on the platform.
 151  */
 152 #ifndef PY_FORMAT_SIZE_T
 153 #   if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__)
 154 #       define PY_FORMAT_SIZE_T ""
 155 #   elif SIZEOF_SIZE_T == SIZEOF_LONG
 156 #       define PY_FORMAT_SIZE_T "l"
 157 #   elif defined(MS_WINDOWS)
 158 #       define PY_FORMAT_SIZE_T "I"
 159 #   else
 160 #       error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T"
 161 #   endif
 162 #endif
 163
 164 /* Py_LOCAL can be used instead of static to get the fastest possible calling
 165  * convention for functions that are local to a given module.
 166  *
 167  * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
 168  * for platforms that support that.
 169  *
 170  * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
 171  * "aggressive" inlining/optimizaion is enabled for the entire module.  This
 172  * may lead to code bloat, and may slow things down for those reasons.  It may
 173  * also lead to errors, if the code relies on pointer aliasing.  Use with
 174  * care.
 175  *
 176  * NOTE: You can only use this for functions that are entirely local to a
 177  * module; functions that are exported via method tables, callbacks, etc,
 178  * should keep using static.
 179  */
 180
 181 #undef USE_INLINE /* XXX - set via configure? */
 182
 183 #if defined(_MSC_VER)
 184 #if defined(PY_LOCAL_AGGRESSIVE)
 185 /* enable more aggressive optimization for visual studio */
 186 #pragma optimize("agtw", on)
 187 #endif
 188 /* ignore warnings if the compiler decides not to inline a function */
 189 #pragma warning(disable: 4710)
 190 /* fastest possible local call under MSVC */
 191 #define Py_LOCAL(type) static type __fastcall
 192 #define Py_LOCAL_INLINE(type) static __inline type __fastcall
 193 #elif defined(USE_INLINE)
 194 #define Py_LOCAL(type) static type
 195 #define Py_LOCAL_INLINE(type) static inline type
 196 #else
 197 #define Py_LOCAL(type) static type
 198 #define Py_LOCAL_INLINE(type) static type
 199 #endif
 200
 201 /* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks
 202  * are often very short.  While most platforms have highly optimized code for
 203  * large transfers, the setup costs for memcpy are often quite high.  MEMCPY
 204  * solves this by doing short copies "in line".
 205  */
 206
 207 #if defined(_MSC_VER)
 208 #define Py_MEMCPY(target, source, length) do {                          \
 209                 size_t i_, n_ = (length);                               \
 210                 char *t_ = (void*) (target);                            \
 211                 const char *s_ = (void*) (source);                      \
 212                 if (n_ >= 16)                                           \
 213                         memcpy(t_, s_, n_);                             \
 214                 else                                                    \
 215                         for (i_ = 0; i_ < n_; i_++)                     \
 216                                 t_[i_] = s_[i_];                        \
 217         } while (0)
 218 #else
 219 #define Py_MEMCPY memcpy
 220 #endif
 221
 222 #include <stdlib.h>
 223
 224 #include <math.h> /* Moved here from the math section, before extern "C" */
 225
 226 /********************************************
 227  * WRAPPER FOR <time.h> and/or <sys/time.h> *
 228  ********************************************/
 229
 230 #ifdef TIME_WITH_SYS_TIME
 231 #include <sys/time.h>
 232 #include <time.h>
 233 #else /* !TIME_WITH_SYS_TIME */
 234 #ifdef HAVE_SYS_TIME_H
 235 #include <sys/time.h>
 236 #else /* !HAVE_SYS_TIME_H */
 237 #include <time.h>
 238 #endif /* !HAVE_SYS_TIME_H */
 239 #endif /* !TIME_WITH_SYS_TIME */
 240
 241
 242 /******************************
 243  * WRAPPER FOR <sys/select.h> *
 244  ******************************/
 245
 246 /* NB caller must include <sys/types.h> */
 247
 248 #ifdef HAVE_SYS_SELECT_H
 249
 250 #include <sys/select.h>
 251
 252 #endif /* !HAVE_SYS_SELECT_H */
 253
 254 /*******************************
 255  * stat() and fstat() fiddling *
 256  *******************************/
 257
 258 /* We expect that stat and fstat exist on most systems.
 259  *  It's confirmed on Unix, Mac and Windows.
 260  *  If you don't have them, add
 261  *      #define DONT_HAVE_STAT
 262  * and/or
 263  *      #define DONT_HAVE_FSTAT
 264  * to your pyconfig.h. Python code beyond this should check HAVE_STAT and
 265  * HAVE_FSTAT instead.
 266  * Also
 267  *      #define HAVE_SYS_STAT_H
 268  * if <sys/stat.h> exists on your platform, and
 269  *      #define HAVE_STAT_H
 270  * if <stat.h> does.
 271  */
 272 #ifndef DONT_HAVE_STAT
 273 #define HAVE_STAT
 274 #endif
 275
 276 #ifndef DONT_HAVE_FSTAT
 277 #define HAVE_FSTAT
 278 #endif
 279
 280 #ifdef RISCOS
 281 #include <sys/types.h>
 282 #include "unixstuff.h"
 283 #endif
 284
 285 #ifdef HAVE_SYS_STAT_H
 286 #if defined(PYOS_OS2) && defined(PYCC_GCC)
 287 #include <sys/types.h>
 288 #endif
 289 #include <sys/stat.h>
 290 #elif defined(HAVE_STAT_H)
 291 #include <stat.h>
 292 #endif
 293
 294 #if defined(PYCC_VACPP)
 295 /* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
 296 #define S_IFMT (S_IFDIR|S_IFCHR|S_IFREG)
 297 #endif
 298
 299 #ifndef S_ISREG
 300 #define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
 301 #endif
 302
 303 #ifndef S_ISDIR
 304 #define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
 305 #endif
 306
 307
 308 #ifdef __cplusplus
 309 /* Move this down here since some C++ #include's don't like to be included
 310    inside an extern "C" */
 311 extern "C" {
 312 #endif
 313
 314
 315 /* Py_ARITHMETIC_RIGHT_SHIFT
 316  * C doesn't define whether a right-shift of a signed integer sign-extends
 317  * or zero-fills.  Here a macro to force sign extension:
 318  * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
 319  *    Return I >> J, forcing sign extension.
 320  * Requirements:
 321  *    I is of basic signed type TYPE (char, short, int, long, or long long).
 322  *    TYPE is one of char, short, int, long, or long long, although long long
 323  *    must not be used except on platforms that support it.
 324  *    J is an integer >= 0 and strictly less than the number of bits in TYPE
 325  *    (because C doesn't define what happens for J outside that range either).
 326  * Caution:
 327  *    I may be evaluated more than once.
 328  */
 329 #ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
 330 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
 331         ((I) < 0 ? ~((~(unsigned TYPE)(I)) >> (J)) : (I) >> (J))
 332 #else
 333 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
 334 #endif
 335
 336 /* Py_FORCE_EXPANSION(X)
 337  * "Simply" returns its argument.  However, macro expansions within the
 338  * argument are evaluated.  This unfortunate trickery is needed to get
 339  * token-pasting to work as desired in some cases.
 340  */
 341 #define Py_FORCE_EXPANSION(X) X
 342
 343 /* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
 344  * Cast VALUE to type NARROW from type WIDE.  In Py_DEBUG mode, this
 345  * assert-fails if any information is lost.
 346  * Caution:
 347  *    VALUE may be evaluated more than once.
 348  */
 349 #ifdef Py_DEBUG
 350 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
 351         (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
 352 #else
 353 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
 354 #endif
 355
 356 /* High precision defintion of pi and e (Euler)
 357  * The values are taken from libc6's math.h.
 358  */
 359 #ifndef Py_MATH_PIl
 360 #define Py_MATH_PIl 3.1415926535897932384626433832795029L
 361 #endif
 362 #ifndef Py_MATH_PI
 363 #define Py_MATH_PI 3.14159265358979323846
 364 #endif
 365
 366 #ifndef Py_MATH_El
 367 #define Py_MATH_El 2.7182818284590452353602874713526625L
 368 #endif
 369
 370 #ifndef Py_MATH_E
 371 #define Py_MATH_E 2.7182818284590452354
 372 #endif
 373
 374 /* Py_IS_NAN(X)
 375  * Return 1 if float or double arg is a NaN, else 0.
 376  * Caution:
 377  *     X is evaluated more than once.
 378  *     This may not work on all platforms.  Each platform has *some*
 379  *     way to spell this, though -- override in pyconfig.h if you have
 380  *     a platform where it doesn't work.
 381  */
 382 #ifndef Py_IS_NAN
 383 #ifdef HAVE_ISNAN
 384 #define Py_IS_NAN(X) isnan(X)
 385 #else
 386 #define Py_IS_NAN(X) ((X) != (X))
 387 #endif
 388 #endif
 389
 390 /* Py_IS_INFINITY(X)
 391  * Return 1 if float or double arg is an infinity, else 0.
 392  * Caution:
 393  *    X is evaluated more than once.
 394  *    This implementation may set the underflow flag if |X| is very small;
 395  *    it really can't be implemented correctly (& easily) before C99.
 396  *    Override in pyconfig.h if you have a better spelling on your platform.
 397  */
 398 #ifndef Py_IS_INFINITY
 399 #ifdef HAVE_ISINF
 400 #define Py_IS_INFINITY(X) isinf(X)
 401 #else
 402 #define Py_IS_INFINITY(X) ((X) && (X)*0.5 == (X))
 403 #endif
 404 #endif
 405
 406 /* Py_IS_FINITE(X)
 407  * Return 1 if float or double arg is neither infinite nor NAN, else 0.
 408  * Some compilers (e.g. VisualStudio) have intrisics for this, so a special
 409  * macro for this particular test is useful
 410  */
 411 #ifndef Py_IS_FINITE
 412 #ifdef HAVE_FINITE
 413 #define Py_IS_FINITE(X) finite(X)
 414 #else
 415 #define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
 416 #endif
 417 #endif
 418
 419 /* HUGE_VAL is supposed to expand to a positive double infinity.  Python
 420  * uses Py_HUGE_VAL instead because some platforms are broken in this
 421  * respect.  We used to embed code in pyport.h to try to worm around that,
 422  * but different platforms are broken in conflicting ways.  If you're on
 423  * a platform where HUGE_VAL is defined incorrectly, fiddle your Python
 424  * config to #define Py_HUGE_VAL to something that works on your platform.
 425  */
 426 #ifndef Py_HUGE_VAL
 427 #define Py_HUGE_VAL HUGE_VAL
 428 #endif
 429
 430 /* Py_NAN
 431  * A value that evaluates to a NaN. On IEEE 754 platforms INF*0 or
 432  * INF/INF works. Define Py_NO_NAN in pyconfig.h if your platform
 433  * doesn't support NaNs.
 434  */
 435 #if !defined(Py_NAN) && !defined(Py_NO_NAN)
 436 #define Py_NAN (Py_HUGE_VAL * 0.)
 437 #endif
 438
 439 /* Py_OVERFLOWED(X)
 440  * Return 1 iff a libm function overflowed.  Set errno to 0 before calling
 441  * a libm function, and invoke this macro after, passing the function
 442  * result.
 443  * Caution:
 444  *    This isn't reliable.  C99 no longer requires libm to set errno under
 445  *        any exceptional condition, but does require +- HUGE_VAL return
 446  *        values on overflow.  A 754 box *probably* maps HUGE_VAL to a
 447  *        double infinity, and we're cool if that's so, unless the input
 448  *        was an infinity and an infinity is the expected result.  A C89
 449  *        system sets errno to ERANGE, so we check for that too.  We're
 450  *        out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or
 451  *        if the returned result is a NaN, or if a C89 box returns HUGE_VAL
 452  *        in non-overflow cases.
 453  *    X is evaluated more than once.
 454  * Some platforms have better way to spell this, so expect some #ifdef'ery.
 455  *
 456  * OpenBSD uses 'isinf()' because a compiler bug on that platform causes
 457  * the longer macro version to be mis-compiled. This isn't optimal, and
 458  * should be removed once a newer compiler is available on that platform.
 459  * The system that had the failure was running OpenBSD 3.2 on Intel, with
 460  * gcc 2.95.3.
 461  *
 462  * According to Tim's checkin, the FreeBSD systems use isinf() to work
 463  * around a FPE bug on that platform.
 464  */
 465 #if defined(__FreeBSD__) || defined(__OpenBSD__)
 466 #define Py_OVERFLOWED(X) isinf(X)
 467 #else
 468 #define Py_OVERFLOWED(X) ((X) != 0.0 && (errno == ERANGE ||    \
 469                                          (X) == Py_HUGE_VAL || \
 470                                          (X) == -Py_HUGE_VAL))
 471 #endif
 472
 473 /* Py_SET_ERRNO_ON_MATH_ERROR(x)
 474  * If a libm function did not set errno, but it looks like the result
 475  * overflowed or not-a-number, set errno to ERANGE or EDOM.  Set errno
 476  * to 0 before calling a libm function, and invoke this macro after,
 477  * passing the function result.
 478  * Caution:
 479  *    This isn't reliable.  See Py_OVERFLOWED comments.
 480  *    X is evaluated more than once.
 481  */
 482 #if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64))
 483 #define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
 484 #else
 485 #define _Py_SET_EDOM_FOR_NAN(X) ;
 486 #endif
 487 #define Py_SET_ERRNO_ON_MATH_ERROR(X) \
 488         do { \
 489                 if (errno == 0) { \
 490                         if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
 491                                 errno = ERANGE; \
 492                         else _Py_SET_EDOM_FOR_NAN(X) \
 493                 } \
 494         } while(0)
 495
 496 /* Py_SET_ERANGE_ON_OVERFLOW(x)
 497  * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
 498  */
 499 #define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
 500
 501 /* Py_ADJUST_ERANGE1(x)
 502  * Py_ADJUST_ERANGE2(x, y)
 503  * Set errno to 0 before calling a libm function, and invoke one of these
 504  * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
 505  * for functions returning complex results).  This makes two kinds of
 506  * adjustments to errno:  (A) If it looks like the platform libm set
 507  * errno=ERANGE due to underflow, clear errno. (B) If it looks like the
 508  * platform libm overflowed but didn't set errno, force errno to ERANGE.  In
 509  * effect, we're trying to force a useful implementation of C89 errno
 510  * behavior.
 511  * Caution:
 512  *    This isn't reliable.  See Py_OVERFLOWED comments.
 513  *    X and Y may be evaluated more than once.
 514  */
 515 #define Py_ADJUST_ERANGE1(X)                                            \
 516         do {                                                            \
 517                 if (errno == 0) {                                       \
 518                         if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)  \
 519                                 errno = ERANGE;                         \
 520                 }                                                       \
 521                 else if (errno == ERANGE && (X) == 0.0)                 \
 522                         errno = 0;                                      \
 523         } while(0)
 524
 525 #define Py_ADJUST_ERANGE2(X, Y)                                         \
 526         do {                                                            \
 527                 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||        \
 528                     (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {        \
 529                                 if (errno == 0)                         \
 530                                         errno = ERANGE;                 \
 531                 }                                                       \
 532                 else if (errno == ERANGE)                               \
 533                         errno = 0;                                      \
 534         } while(0)
 535
 536 /* Py_DEPRECATED(version)
 537  * Declare a variable, type, or function deprecated.
 538  * Usage:
 539  *    extern int old_var Py_DEPRECATED(2.3);
 540  *    typedef int T1 Py_DEPRECATED(2.4);
 541  *    extern int x() Py_DEPRECATED(2.5);
 542  */
 543 #if defined(__GNUC__) && ((__GNUC__ >= 4) || \
 544                           (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
 545 #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
 546 #else
 547 #define Py_DEPRECATED(VERSION_UNUSED)
 548 #endif
 549
 550 /**************************************************************************
 551 Prototypes that are missing from the standard include files on some systems
 552 (and possibly only some versions of such systems.)
 553
 554 Please be conservative with adding new ones, document them and enclose them
 555 in platform-specific #ifdefs.
 556 **************************************************************************/
 557
 558 #ifdef SOLARIS
 559 /* Unchecked */
 560 extern int gethostname(char *, int);
 561 #endif
 562
 563 #ifdef __BEOS__
 564 /* Unchecked */
 565 /* It's in the libs, but not the headers... - [cjh] */
 566 int shutdown( int, int );
 567 #endif
 568
 569 #ifdef HAVE__GETPTY
 570 #include <sys/types.h>          /* we need to import mode_t */
 571 extern char * _getpty(int *, int, mode_t, int);
 572 #endif
 573
 574 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY)
 575 #if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H)
 576 /* BSDI does not supply a prototype for the 'openpty' and 'forkpty'
 577    functions, even though they are included in libutil. */
 578 #include <termios.h>
 579 extern int openpty(int *, int *, char *, struct termios *, struct winsize *);
 580 extern pid_t forkpty(int *, char *, struct termios *, struct winsize *);
 581 #endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */
 582 #endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */
 583
 584
 585 /* These are pulled from various places. It isn't obvious on what platforms
 586    they are necessary, nor what the exact prototype should look like (which
 587    is likely to vary between platforms!) If you find you need one of these
 588    declarations, please move them to a platform-specific block and include
 589    proper prototypes. */
 590 #if 0
 591
 592 /* From Modules/resource.c */
 593 extern int getrusage();
 594 extern int getpagesize();
 595
 596 /* From Python/sysmodule.c and Modules/posixmodule.c */
 597 extern int fclose(FILE *);
 598
 599 /* From Modules/posixmodule.c */
 600 extern int fdatasync(int);
 601 #endif /* 0 */
 602
 603
 604 /************************
 605  * WRAPPER FOR <math.h> *
 606  ************************/
 607
 608 #ifndef HAVE_HYPOT
 609 extern double hypot(double, double);
 610 #endif
 611
 612
 613 /* On 4.4BSD-descendants, ctype functions serves the whole range of
 614  * wchar_t character set rather than single byte code points only.
 615  * This characteristic can break some operations of string object
 616  * including str.upper() and str.split() on UTF-8 locales.  This
 617  * workaround was provided by Tim Robbins of FreeBSD project.
 618  */
 619
 620 #ifdef __FreeBSD__
 621 #include <osreldate.h>
 622 #if __FreeBSD_version > 500039
 623 #include <ctype.h>
 624 #include <wctype.h>
 625 #undef isalnum
 626 #define isalnum(c) iswalnum(btowc(c))
 627 #undef isalpha
 628 #define isalpha(c) iswalpha(btowc(c))
 629 #undef islower
 630 #define islower(c) iswlower(btowc(c))
 631 #undef isspace
 632 #define isspace(c) iswspace(btowc(c))
 633 #undef isupper
 634 #define isupper(c) iswupper(btowc(c))
 635 #undef tolower
 636 #define tolower(c) towlower(btowc(c))
 637 #undef toupper
 638 #define toupper(c) towupper(btowc(c))
 639 #endif
 640 #endif
 641
 642
 643 /* Declarations for symbol visibility.
 644
 645   PyAPI_FUNC(type): Declares a public Python API function and return type
 646   PyAPI_DATA(type): Declares public Python data and its type
 647   PyMODINIT_FUNC:   A Python module init function.  If these functions are
 648                     inside the Python core, they are private to the core.
 649                     If in an extension module, it may be declared with
 650                     external linkage depending on the platform.
 651
 652   As a number of platforms support/require "__declspec(dllimport/dllexport)",
 653   we support a HAVE_DECLSPEC_DLL macro to save duplication.
 654 */
 655
 656 /*
 657   All windows ports, except cygwin, are handled in PC/pyconfig.h.
 658
 659   BeOS and cygwin are the only other autoconf platform requiring special
 660   linkage handling and both of these use __declspec().
 661 */
 662 #if defined(__CYGWIN__) || defined(__BEOS__)
 663 #       define HAVE_DECLSPEC_DLL
 664 #endif
 665
 666 /* only get special linkage if built as shared or platform is Cygwin */
 667 #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
 668 #       if defined(HAVE_DECLSPEC_DLL)
 669 #               ifdef Py_BUILD_CORE
 670 #                       define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
 671 #                       define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
 672                         /* module init functions inside the core need no external linkage */
 673                         /* except for Cygwin to handle embedding (FIXME: BeOS too?) */
 674 #                       if defined(__CYGWIN__)
 675 #                               define PyMODINIT_FUNC __declspec(dllexport) void
 676 #                       else /* __CYGWIN__ */
 677 #                               define PyMODINIT_FUNC void
 678 #                       endif /* __CYGWIN__ */
 679 #               else /* Py_BUILD_CORE */
 680                         /* Building an extension module, or an embedded situation */
 681                         /* public Python functions and data are imported */
 682                         /* Under Cygwin, auto-import functions to prevent compilation */
 683                         /* failures similar to http://python.org/doc/FAQ.html#3.24 */
 684 #                       if !defined(__CYGWIN__)
 685 #                               define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
 686 #                       endif /* !__CYGWIN__ */
 687 #                       define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
 688                         /* module init functions outside the core must be exported */
 689 #                       if defined(__cplusplus)
 690 #                               define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
 691 #                       else /* __cplusplus */
 692 #                               define PyMODINIT_FUNC __declspec(dllexport) void
 693 #                       endif /* __cplusplus */
 694 #               endif /* Py_BUILD_CORE */
 695 #       endif /* HAVE_DECLSPEC */
 696 #endif /* Py_ENABLE_SHARED */
 697
 698 /* If no external linkage macros defined by now, create defaults */
 699 #ifndef PyAPI_FUNC
 700 #       define PyAPI_FUNC(RTYPE) RTYPE
 701 #endif
 702 #ifndef PyAPI_DATA
 703 #       define PyAPI_DATA(RTYPE) extern RTYPE
 704 #endif
 705 #ifndef PyMODINIT_FUNC
 706 #       if defined(__cplusplus)
 707 #               define PyMODINIT_FUNC extern "C" void
 708 #       else /* __cplusplus */
 709 #               define PyMODINIT_FUNC void
 710 #       endif /* __cplusplus */
 711 #endif
 712
 713 /* Deprecated DL_IMPORT and DL_EXPORT macros */
 714 #if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)
 715 #       if defined(Py_BUILD_CORE)
 716 #               define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
 717 #               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
 718 #       else
 719 #               define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
 720 #               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
 721 #       endif
 722 #endif
 723 #ifndef DL_EXPORT
 724 #       define DL_EXPORT(RTYPE) RTYPE
 725 #endif
 726 #ifndef DL_IMPORT
 727 #       define DL_IMPORT(RTYPE) RTYPE
 728 #endif
 729 /* End of deprecated DL_* macros */
 730
 731 /* If the fd manipulation macros aren't defined,
 732    here is a set that should do the job */
 733
 734 #if 0 /* disabled and probably obsolete */
 735
 736 #ifndef FD_SETSIZE
 737 #define FD_SETSIZE      256
 738 #endif
 739
 740 #ifndef FD_SET
 741
 742 typedef long fd_mask;
 743
 744 #define NFDBITS (sizeof(fd_mask) * NBBY)        /* bits per mask */
 745 #ifndef howmany
 746 #define howmany(x, y)   (((x)+((y)-1))/(y))
 747 #endif /* howmany */
 748
 749 typedef struct fd_set {
 750         fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
 751 } fd_set;
 752
 753 #define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
 754 #define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
 755 #define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
 756 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
 757
 758 #endif /* FD_SET */
 759
 760 #endif /* fd manipulation macros */
 761
 762
 763 /* limits.h constants that may be missing */
 764
 765 #ifndef INT_MAX
 766 #define INT_MAX 2147483647
 767 #endif
 768
 769 #ifndef LONG_MAX
 770 #if SIZEOF_LONG == 4
 771 #define LONG_MAX 0X7FFFFFFFL
 772 #elif SIZEOF_LONG == 8
 773 #define LONG_MAX 0X7FFFFFFFFFFFFFFFL
 774 #else
 775 #error "could not set LONG_MAX in pyport.h"
 776 #endif
 777 #endif
 778
 779 #ifndef LONG_MIN
 780 #define LONG_MIN (-LONG_MAX-1)
 781 #endif
 782
 783 #ifndef LONG_BIT
 784 #define LONG_BIT (8 * SIZEOF_LONG)
 785 #endif
 786
 787 #if LONG_BIT != 8 * SIZEOF_LONG
 788 /* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
 789  * 32-bit platforms using gcc.  We try to catch that here at compile-time
 790  * rather than waiting for integer multiplication to trigger bogus
 791  * overflows.
 792  */
 793 #error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
 794 #endif
 795
 796 #ifdef __cplusplus
 797 }
 798 #endif
 799
 800 /*
 801  * Hide GCC attributes from compilers that don't support them.
 802  */
 803 #if (!defined(__GNUC__) || __GNUC__ < 2 || \
 804      (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \
 805     !defined(RISCOS)
 806 #define Py_GCC_ATTRIBUTE(x)
 807 #else
 808 #define Py_GCC_ATTRIBUTE(x) __attribute__(x)
 809 #endif
 810
 811 /*
 812  * Add PyArg_ParseTuple format where available.
 813  */
 814 #ifdef HAVE_ATTRIBUTE_FORMAT_PARSETUPLE
 815 #define Py_FORMAT_PARSETUPLE(func,p1,p2) __attribute__((format(func,p1,p2)))
 816 #else
 817 #define Py_FORMAT_PARSETUPLE(func,p1,p2)
 818 #endif
 819
 820 /* Eliminate end-of-loop code not reached warnings from SunPro C
 821  * when using do{...}while(0) macros
 822  */
 823 #ifdef __SUNPRO_C
 824 #pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
 825 #endif
 826
 827 /*
 828  * Older Microsoft compilers don't support the C99 long long literal suffixes,
 829  * so these will be defined in PC/pyconfig.h for those compilers.
 830  */
 831 #ifndef Py_LL
 832 #define Py_LL(x) x##LL
 833 #endif
 834
 835 #ifndef Py_ULL
 836 #define Py_ULL(x) Py_LL(x##U)
 837 #endif
 838
 839 #endif /* Py_PYPORT_H */