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