pyport.h 19.4 KB
Newer Older
1
#ifndef Py_PYPORT_H
2
#define Py_PYPORT_H
3

4
#include "pyconfig.h" /* include for defines */
5

6 7
/**************************************************************************
Symbols and macros to supply platform-independent interfaces to basic
8
C language & library operations whose spellings vary across platforms.
9 10 11 12 13 14 15 16 17 18

Please try to make documentation here as clear as possible:  by definition,
the stuff here is trying to illuminate C's darkest corners.

Config #defines referenced here:

SIGNED_RIGHT_SHIFT_ZERO_FILLS
Meaning:  To be defined iff i>>j does not extend the sign bit when i is a
          signed integral type and i < 0.
Used in:  Py_ARITHMETIC_RIGHT_SHIFT
19

20 21 22
Py_DEBUG
Meaning:  Extra checks compiled in for debug mode.
Used in:  Py_SAFE_DOWNCAST
23 24 25 26 27 28 29

HAVE_UINTPTR_T
Meaning:  The C9X type uintptr_t is supported by the compiler
Used in:  Py_uintptr_t

HAVE_LONG_LONG
Meaning:  The compiler supports the C type "long long"
30
Used in:  PY_LONG_LONG
31

32 33 34
**************************************************************************/


35 36 37 38 39 40
/* For backward compatibility only. Obsolete, do not use. */
#ifdef HAVE_PROTOTYPES
#define Py_PROTO(x) x
#else
#define Py_PROTO(x) ()
#endif
41 42 43
#ifndef Py_FPROTO
#define Py_FPROTO(x) Py_PROTO(x)
#endif
44

45 46 47 48 49 50 51 52 53 54 55 56 57
/* typedefs for some C9X-defined synonyms for integral types.
 *
 * The names in Python are exactly the same as the C9X names, except with a
 * Py_ prefix.  Until C9X is universally implemented, this is the only way
 * to ensure that Python gets reliable names that don't conflict with names
 * in non-Python code that are playing their own tricks to define the C9X
 * names.
 *
 * NOTE: don't go nuts here!  Python has no use for *most* of the C9X
 * integral synonyms.  Only define the ones we actually need.
 */

#ifdef HAVE_LONG_LONG
58 59
#ifndef PY_LONG_LONG
#define PY_LONG_LONG long long
60 61 62 63 64
#endif
#endif /* HAVE_LONG_LONG */

/* uintptr_t is the C9X name for an unsigned integral type such that a
 * legitimate void* can be cast to uintptr_t and then back to void* again
65 66
 * without loss of information.  Similarly for intptr_t, wrt a signed
 * integral type.
67 68
 */
#ifdef HAVE_UINTPTR_T
69 70 71
typedef uintptr_t	Py_uintptr_t;
typedef intptr_t	Py_intptr_t;

72
#elif SIZEOF_VOID_P <= SIZEOF_INT
73 74 75
typedef unsigned int	Py_uintptr_t;
typedef int		Py_intptr_t;

76
#elif SIZEOF_VOID_P <= SIZEOF_LONG
77 78 79
typedef unsigned long	Py_uintptr_t;
typedef long		Py_intptr_t;

80
#elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
81 82
typedef unsigned PY_LONG_LONG	Py_uintptr_t;
typedef PY_LONG_LONG		Py_intptr_t;
83

84 85 86 87
#else
#   error "Python needs a typedef for Py_uintptr_t in pyport.h."
#endif /* HAVE_UINTPTR_T */

88 89
#include <stdlib.h>

90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
#include <math.h> /* Moved here from the math section, before extern "C" */

/********************************************
 * WRAPPER FOR <time.h> and/or <sys/time.h> *
 ********************************************/

#ifdef TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <time.h>
#else /* !TIME_WITH_SYS_TIME */
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#else /* !HAVE_SYS_TIME_H */
#include <time.h>
#endif /* !HAVE_SYS_TIME_H */
#endif /* !TIME_WITH_SYS_TIME */


/******************************
 * WRAPPER FOR <sys/select.h> *
 ******************************/

/* NB caller must include <sys/types.h> */

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif /* !HAVE_SYS_SELECT_H */

120 121 122 123 124 125 126 127 128 129
/*******************************
 * stat() and fstat() fiddling *
 *******************************/

/* We expect that stat and fstat exist on most systems.
 *  It's confirmed on Unix, Mac and Windows.
 *  If you don't have them, add
 *      #define DONT_HAVE_STAT
 * and/or
 *      #define DONT_HAVE_FSTAT
130
 * to your pyconfig.h. Python code beyond this should check HAVE_STAT and
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
 * HAVE_FSTAT instead.
 * Also
 *      #define DONT_HAVE_SYS_STAT_H
 * if <sys/stat.h> doesn't exist on your platform, and
 *      #define HAVE_STAT_H
 * if <stat.h> does (don't look at me -- ths mess is inherited).
 */
#ifndef DONT_HAVE_STAT
#define HAVE_STAT
#endif

#ifndef DONT_HAVE_FSTAT
#define HAVE_FSTAT
#endif

146 147
#ifdef RISCOS
#include <sys/types.h>
148
#include "unixstuff.h"
149 150
#endif

151
#ifndef DONT_HAVE_SYS_STAT_H
152 153 154
#if defined(PYOS_OS2) && defined(PYCC_GCC)
#include <sys/types.h>
#endif
155 156 157 158 159
#include <sys/stat.h>
#elif defined(HAVE_STAT_H)
#include <stat.h>
#endif

160 161 162 163 164 165 166 167 168 169 170 171 172
#if defined(PYCC_VACPP)
/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
#define S_IFMT (S_IFDIR|S_IFCHR|S_IFREG)
#endif

#ifndef S_ISREG
#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
#endif

#ifndef S_ISDIR
#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
#endif

173

174
#ifdef __cplusplus
175 176
/* Move this down here since some C++ #include's don't like to be included
   inside an extern "C" */
177 178 179
extern "C" {
#endif

180

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
/* Py_ARITHMETIC_RIGHT_SHIFT
 * C doesn't define whether a right-shift of a signed integer sign-extends
 * or zero-fills.  Here a macro to force sign extension:
 * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
 *    Return I >> J, forcing sign extension.
 * Requirements:
 *    I is of basic signed type TYPE (char, short, int, long, or long long).
 *    TYPE is one of char, short, int, long, or long long, although long long
 *    must not be used except on platforms that support it.
 *    J is an integer >= 0 and strictly less than the number of bits in TYPE
 *    (because C doesn't define what happens for J outside that range either).
 * Caution:
 *    I may be evaluated more than once.
 */
#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
	((I) < 0 ? ~((~(unsigned TYPE)(I)) >> (J)) : (I) >> (J))
#else
#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
#endif

202
/* Py_FORCE_EXPANSION(X)
203 204 205 206 207 208
 * "Simply" returns its argument.  However, macro expansions within the
 * argument are evaluated.  This unfortunate trickery is needed to get
 * token-pasting to work as desired in some cases.
 */
#define Py_FORCE_EXPANSION(X) X

209 210 211 212 213 214 215 216 217 218 219 220 221
/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
 * Cast VALUE to type NARROW from type WIDE.  In Py_DEBUG mode, this
 * assert-fails if any information is lost.
 * Caution:
 *    VALUE may be evaluated more than once.
 */
#ifdef Py_DEBUG
#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
	(assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
#else
#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
#endif

222 223 224 225 226 227 228 229 230 231 232 233
/* Py_IS_NAN(X)
 * Return 1 if float or double arg is a NaN, else 0.
 * Caution:
 *     X is evaluated more than once.
 *     This may not work on all platforms.  Each platform has *some*
 *     way to spell this, though -- override in pyconfig.h if you have
 *     a platform where it doesn't work.
 */
#ifndef Py_IS_NAN
#define Py_IS_NAN(X) ((X) != (X))
#endif

234 235 236 237 238 239
/* Py_IS_INFINITY(X)
 * Return 1 if float or double arg is an infinity, else 0.
 * Caution:
 *    X is evaluated more than once.
 *    This implementation may set the underflow flag if |X| is very small;
 *    it really can't be implemented correctly (& easily) before C99.
240
 *    Override in pyconfig.h if you have a better spelling on your platform.
241
 */
242
#ifndef Py_IS_INFINITY
243
#define Py_IS_INFINITY(X) ((X) && (X)*0.5 == (X))
244
#endif
245

246 247 248 249 250 251
/* HUGE_VAL is supposed to expand to a positive double infinity.  Python
 * uses Py_HUGE_VAL instead because some platforms are broken in this
 * respect.  We used to embed code in pyport.h to try to worm around that,
 * but different platforms are broken in conflicting ways.  If you're on
 * a platform where HUGE_VAL is defined incorrectly, fiddle your Python
 * config to #define Py_HUGE_VAL to something that works on your platform.
252
 */
253
#ifndef Py_HUGE_VAL
254 255 256
#define Py_HUGE_VAL HUGE_VAL
#endif

257 258 259 260 261 262
/* Py_OVERFLOWED(X)
 * Return 1 iff a libm function overflowed.  Set errno to 0 before calling
 * a libm function, and invoke this macro after, passing the function
 * result.
 * Caution:
 *    This isn't reliable.  C99 no longer requires libm to set errno under
Tim Peters's avatar
Tim Peters committed
263 264 265 266 267
 *	  any exceptional condition, but does require +- HUGE_VAL return
 *	  values on overflow.  A 754 box *probably* maps HUGE_VAL to a
 *	  double infinity, and we're cool if that's so, unless the input
 *	  was an infinity and an infinity is the expected result.  A C89
 *	  system sets errno to ERANGE, so we check for that too.  We're
268 269 270 271
 *	  out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or
 *	  if the returned result is a NaN, or if a C89 box returns HUGE_VAL
 *	  in non-overflow cases.
 *    X is evaluated more than once.
272
 * Some platforms have better way to spell this, so expect some #ifdef'ery.
273 274
 *
 * OpenBSD uses 'isinf()' because a compiler bug on that platform causes
275
 * the longer macro version to be mis-compiled. This isn't optimal, and
276 277 278 279
 * should be removed once a newer compiler is available on that platform.
 * The system that had the failure was running OpenBSD 3.2 on Intel, with
 * gcc 2.95.3.
 *
280
 * According to Tim's checkin, the FreeBSD systems use isinf() to work
281
 * around a FPE bug on that platform.
282
 */
283
#if defined(__FreeBSD__) || defined(__OpenBSD__)
284 285
#define Py_OVERFLOWED(X) isinf(X)
#else
286 287 288
#define Py_OVERFLOWED(X) ((X) != 0.0 && (errno == ERANGE ||    \
					 (X) == Py_HUGE_VAL || \
					 (X) == -Py_HUGE_VAL))
289
#endif
290

291
/* Py_SET_ERRNO_ON_MATH_ERROR(x)
292
 * If a libm function did not set errno, but it looks like the result
293 294 295
 * overflowed or not-a-number, set errno to ERANGE or EDOM.  Set errno
 * to 0 before calling a libm function, and invoke this macro after,
 * passing the function result.
296 297 298 299
 * Caution:
 *    This isn't reliable.  See Py_OVERFLOWED comments.
 *    X is evaluated more than once.
 */
300 301 302 303 304 305
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
#else
#define _Py_SET_EDOM_FOR_NAN(X) ;
#endif
#define Py_SET_ERRNO_ON_MATH_ERROR(X) \
306
	do { \
307 308 309 310 311
		if (errno == 0) { \
			if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
				errno = ERANGE; \
			else _Py_SET_EDOM_FOR_NAN(X) \
		} \
312
	} while(0)
313

314 315 316 317 318
/* Py_SET_ERANGE_ON_OVERFLOW(x)
 * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
 */
#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)

319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
/* Py_ADJUST_ERANGE1(x)
 * Py_ADJUST_ERANGE2(x, y)
 * Set errno to 0 before calling a libm function, and invoke one of these
 * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
 * for functions returning complex results).  This makes two kinds of
 * adjustments to errno:  (A) If it looks like the platform libm set
 * errno=ERANGE due to underflow, clear errno. (B) If it looks like the
 * platform libm overflowed but didn't set errno, force errno to ERANGE.  In
 * effect, we're trying to force a useful implementation of C89 errno
 * behavior.
 * Caution:
 *    This isn't reliable.  See Py_OVERFLOWED comments.
 *    X and Y may be evaluated more than once.
 */
#define Py_ADJUST_ERANGE1(X)						\
	do {								\
		if (errno == 0) {					\
			if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)	\
				errno = ERANGE;				\
		}							\
		else if (errno == ERANGE && (X) == 0.0)			\
			errno = 0;					\
	} while(0)

#define Py_ADJUST_ERANGE2(X, Y)						\
	do {								\
		if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||	\
		    (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {	\
				if (errno == 0)				\
					errno = ERANGE;			\
		}							\
		else if (errno == ERANGE)				\
			errno = 0;					\
	} while(0)

354
/* Py_DEPRECATED(version)
Neal Norwitz's avatar
Neal Norwitz committed
355
 * Declare a variable, type, or function deprecated.
356 357 358 359 360 361 362 363
 * Usage:
 *    extern int old_var Py_DEPRECATED(2.3);
 *    typedef int T1 Py_DEPRECATED(2.4);
 *    extern int x() Py_DEPRECATED(2.5);
 */
#if defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)
#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
#else
364
#define Py_DEPRECATED(VERSION_UNUSED)
365 366
#endif

367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
/**************************************************************************
Prototypes that are missing from the standard include files on some systems
(and possibly only some versions of such systems.)

Please be conservative with adding new ones, document them and enclose them
in platform-specific #ifdefs.
**************************************************************************/

#ifdef SOLARIS
/* Unchecked */
extern int gethostname(char *, int);
#endif

#ifdef __BEOS__
/* Unchecked */
/* It's in the libs, but not the headers... - [cjh] */
383
int shutdown( int, int );
384 385 386
#endif

#ifdef HAVE__GETPTY
387
#include <sys/types.h>		/* we need to import mode_t */
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
extern char * _getpty(int *, int, mode_t, int);
#endif

#if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY)
#if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H)
/* BSDI does not supply a prototype for the 'openpty' and 'forkpty'
   functions, even though they are included in libutil. */
#include <termios.h>
extern int openpty(int *, int *, char *, struct termios *, struct winsize *);
extern int forkpty(int *, char *, struct termios *, struct winsize *);
#endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */
#endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */


/* These are pulled from various places. It isn't obvious on what platforms
   they are necessary, nor what the exact prototype should look like (which
   is likely to vary between platforms!) If you find you need one of these
   declarations, please move them to a platform-specific block and include
   proper prototypes. */
#if 0

/* From Modules/resource.c */
extern int getrusage();
extern int getpagesize();

/* From Python/sysmodule.c and Modules/posixmodule.c */
extern int fclose(FILE *);

/* From Modules/posixmodule.c */
extern int fdatasync(int);
#endif /* 0 */

420 421 422 423 424 425 426

/************************
 * WRAPPER FOR <math.h> *
 ************************/

#ifndef HAVE_HYPOT
extern double hypot(double, double);
427
#endif
428

429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461

/*******************************************************************
On 4.4BSD-descendants, ctype functions serves the whole range of
wchar_t character set rather than single byte code points only.
This characteristic can break some operations of string object
including str.upper() and str.split() on UTF-8 locales.  This
workaround was provided by Tim Robbins of FreeBSD project.  He said
the incompatibility will be fixed in FreeBSD 6.
********************************************************************/

#ifdef __FreeBSD__
#include <osreldate.h>
#if __FreeBSD_version > 500039
#include <ctype.h>
#include <wctype.h>
#undef isalnum
#define isalnum(c) iswalnum(btowc(c))
#undef isalpha
#define isalpha(c) iswalpha(btowc(c))
#undef islower
#define islower(c) iswlower(btowc(c))
#undef isspace
#define isspace(c) iswspace(btowc(c))
#undef isupper
#define isupper(c) iswupper(btowc(c))
#undef tolower
#define tolower(c) towlower(btowc(c))
#undef toupper
#define toupper(c) towupper(btowc(c))
#endif
#endif


462 463 464
/* Declarations for symbol visibility.

  PyAPI_FUNC(type): Declares a public Python API function and return type
465
  PyAPI_DATA(type): Declares public Python data and its type
466
  PyMODINIT_FUNC:   A Python module init function.  If these functions are
467 468
                    inside the Python core, they are private to the core.
                    If in an extension module, it may be declared with
469 470 471 472 473 474
                    external linkage depending on the platform.

  As a number of platforms support/require "__declspec(dllimport/dllexport)",
  we support a HAVE_DECLSPEC_DLL macro to save duplication.
*/

475
/*
476 477 478 479
  All windows ports, except cygwin, are handled in PC/pyconfig.h.

  BeOS and cygwin are the only other autoconf platform requiring special
  linkage handling and both of these use __declspec().
480 481 482 483 484
*/
#if defined(__CYGWIN__) || defined(__BEOS__)
#	define HAVE_DECLSPEC_DLL
#endif

485 486
/* only get special linkage if built as shared or platform is Cygwin */
#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
487 488 489
#	if defined(HAVE_DECLSPEC_DLL)
#		ifdef Py_BUILD_CORE
#			define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
490
#			define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
491
			/* module init functions inside the core need no external linkage */
492 493 494 495 496 497
			/* except for Cygwin to handle embedding (FIXME: BeOS too?) */
#			if defined(__CYGWIN__)
#				define PyMODINIT_FUNC __declspec(dllexport) void
#			else /* __CYGWIN__ */
#				define PyMODINIT_FUNC void
#			endif /* __CYGWIN__ */
498 499 500
#		else /* Py_BUILD_CORE */
			/* Building an extension module, or an embedded situation */
			/* public Python functions and data are imported */
501 502 503 504 505
			/* Under Cygwin, auto-import functions to prevent compilation */
			/* failures similar to http://python.org/doc/FAQ.html#3.24 */
#			if !defined(__CYGWIN__)
#				define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
#			endif /* !__CYGWIN__ */
506
#			define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
			/* module init functions outside the core must be exported */
#			if defined(__cplusplus)
#				define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
#			else /* __cplusplus */
#				define PyMODINIT_FUNC __declspec(dllexport) void
#			endif /* __cplusplus */
#		endif /* Py_BUILD_CORE */
#	endif /* HAVE_DECLSPEC */
#endif /* Py_ENABLE_SHARED */

/* If no external linkage macros defined by now, create defaults */
#ifndef PyAPI_FUNC
#	define PyAPI_FUNC(RTYPE) RTYPE
#endif
#ifndef PyAPI_DATA
522
#	define PyAPI_DATA(RTYPE) extern RTYPE
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
#endif
#ifndef PyMODINIT_FUNC
#	if defined(__cplusplus)
#		define PyMODINIT_FUNC extern "C" void
#	else /* __cplusplus */
#		define PyMODINIT_FUNC void
#	endif /* __cplusplus */
#endif

/* Deprecated DL_IMPORT and DL_EXPORT macros */
#if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)
#	if defined(Py_BUILD_CORE)
#		define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
#		define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
#	else
#		define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
#		define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
#	endif
#endif
#ifndef DL_EXPORT
#	define DL_EXPORT(RTYPE) RTYPE
#endif
#ifndef DL_IMPORT
#	define DL_IMPORT(RTYPE) RTYPE
#endif
/* End of deprecated DL_* macros */
549 550 551 552

/* If the fd manipulation macros aren't defined,
   here is a set that should do the job */

553
#if 0 /* disabled and probably obsolete */
554

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
#ifndef	FD_SETSIZE
#define	FD_SETSIZE	256
#endif

#ifndef FD_SET

typedef long fd_mask;

#define NFDBITS	(sizeof(fd_mask) * NBBY)	/* bits per mask */
#ifndef howmany
#define	howmany(x, y)	(((x)+((y)-1))/(y))
#endif /* howmany */

typedef	struct fd_set {
	fd_mask	fds_bits[howmany(FD_SETSIZE, NFDBITS)];
} fd_set;

#define	FD_SET(n, p)	((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
#define	FD_CLR(n, p)	((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
#define	FD_ISSET(n, p)	((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
#define FD_ZERO(p)	memset((char *)(p), '\0', sizeof(*(p)))

#endif /* FD_SET */
578 579 580

#endif /* fd manipulation macros */

581

582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
/* limits.h constants that may be missing */

#ifndef INT_MAX
#define INT_MAX 2147483647
#endif

#ifndef LONG_MAX
#if SIZEOF_LONG == 4
#define LONG_MAX 0X7FFFFFFFL
#elif SIZEOF_LONG == 8
#define LONG_MAX 0X7FFFFFFFFFFFFFFFL
#else
#error "could not set LONG_MAX in pyport.h"
#endif
#endif

#ifndef LONG_MIN
#define LONG_MIN (-LONG_MAX-1)
#endif

602 603 604 605 606 607 608 609 610 611
#ifndef LONG_BIT
#define LONG_BIT (8 * SIZEOF_LONG)
#endif

#if LONG_BIT != 8 * SIZEOF_LONG
/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
 * 32-bit platforms using gcc.  We try to catch that here at compile-time
 * rather than waiting for integer multiplication to trigger bogus
 * overflows.
 */
612
#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
613 614
#endif

615 616 617 618
#ifdef __cplusplus
}
#endif

619 620 621
/*
 * Hide GCC attributes from compilers that don't support them.
 */
622
#if (!defined(__GNUC__) || __GNUC__ < 2 || \
623
     (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \
624
    !defined(RISCOS)
625 626 627
#define Py_GCC_ATTRIBUTE(x)
#else
#define Py_GCC_ATTRIBUTE(x) __attribute__(x)
628 629
#endif

630 631 632 633 634 635 636
/* Eliminate end-of-loop code not reached warnings from SunPro C
 * when using do{...}while(0) macros
 */
#ifdef __SUNPRO_C
#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
#endif

637
#endif /* Py_PYPORT_H */