Mercurial > repos > yating-l > jbrowsearchivecreator

comparison test/include/python2.7/pyport.h @ 3:7d1a9a91b989 draft

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