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