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