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