operators such as ``super(C, self)[name]``.
-.. function:: trunc(x)
-
- Return the :class:`Real` value *x* truncated to an :class:`Integral` (usually
- a long integer). Delegates to ``x.__trunc__()``.
-
-
.. function:: tuple([iterable])
Return a tuple whose items are the same and in the same order as *iterable*'s
Return the fractional and integer parts of *x*. Both results carry the sign of
*x*, and both are floats.
+
+.. function:: trunc(x)
+
+ Return the :class:`Real` value *x* truncated to an :class:`Integral` (usually
+ a long integer). Delegates to ``x.__trunc__()``.
+
+ .. versionadded:: 2.6
+
Note that :func:`frexp` and :func:`modf` have a different call/return pattern
than their C equivalents: they take a single argument and return a pair of
values, rather than returning their second return value through an 'output
/* Smallest negative value of type Py_ssize_t. */
#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
+#if SIZEOF_PID_T > SIZEOF_LONG
+# error "Python doesn't support sizeof(pid_t) > sizeof(long)"
+#endif
+
/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
* format to convert an argument with the width of a size_t or Py_ssize_t.
* C99 introduced "z" for this purpose, but not all platforms support that;
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 *);
+extern pid_t forkpty(int *, char *, struct termios *, struct winsize *);
#endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */
#endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */
"""
- __slots__ = ('numerator', 'denominator')
+ __slots__ = ('_numerator', '_denominator')
# We're immutable, so use __new__ not __init__
def __new__(cls, numerator=0, denominator=1):
raise ZeroDivisionError('Rational(%s, 0)' % numerator)
g = gcd(numerator, denominator)
- self.numerator = int(numerator // g)
- self.denominator = int(denominator // g)
+ self._numerator = int(numerator // g)
+ self._denominator = int(denominator // g)
return self
@classmethod
result = new
return result
+ @property
+ def numerator(a):
+ return a._numerator
+
+ @property
+ def denominator(a):
+ return a._denominator
+
def __repr__(self):
"""repr(self)"""
return ('Rational(%r,%r)' % (self.numerator, self.denominator))
Rational, that means that we define __add__ and __radd__ as:
def __add__(self, other):
+ # Both types have numerators/denominator attributes,
+ # so do the operation directly
if isinstance(other, (int, Rational)):
- # Do the real operation.
return Rational(self.numerator * other.denominator +
other.numerator * self.denominator,
self.denominator * other.denominator)
- # float and complex don't follow this protocol, and
- # Rational knows about them, so special case them.
+ # float and complex don't have those operations, but we
+ # know about those types, so special case them.
elif isinstance(other, float):
return float(self) + other
elif isinstance(other, complex):
return complex(self) + other
- else:
- # Let the other type take over.
- return NotImplemented
+ # Let the other type take over.
+ return NotImplemented
def __radd__(self, other):
# radd handles more types than add because there's
return float(other) + float(self)
elif isinstance(other, Complex):
return complex(other) + complex(self)
- else:
- return NotImplemented
+ return NotImplemented
There are 5 different cases for a mixed-type addition on
"""Unit tests for numbers.py."""
+import math
+import operator
import unittest
-from test import test_support
-from numbers import Number
-from numbers import Exact, Inexact
from numbers import Complex, Real, Rational, Integral
-import operator
+from numbers import Exact, Inexact
+from numbers import Number
+from test import test_support
class TestNumbers(unittest.TestCase):
def test_int(self):
self.failUnless(issubclass(complex, Inexact))
c1, c2 = complex(3, 2), complex(4,1)
- self.assertRaises(TypeError, trunc, c1)
+ # XXX: This is not ideal, but see the comment in math_trunc().
+ self.assertRaises(TypeError, math.trunc, c1)
self.assertRaises(TypeError, operator.mod, c1, c2)
self.assertRaises(TypeError, divmod, c1, c2)
self.assertRaises(TypeError, operator.floordiv, c1, c2)
raise ValueError
self.assertRaises(ValueError, sum, BadSeq())
- def test_trunc(self):
-
- self.assertEqual(trunc(1), 1)
- self.assertEqual(trunc(-1), -1)
- self.assertEqual(type(trunc(1)), int)
- self.assertEqual(type(trunc(1.5)), int)
- self.assertEqual(trunc(1.5), 1)
- self.assertEqual(trunc(-1.5), -1)
- self.assertEqual(trunc(1.999999), 1)
- self.assertEqual(trunc(-1.999999), -1)
- self.assertEqual(trunc(-0.999999), -0)
- self.assertEqual(trunc(-100.999), -100)
-
- class TestTrunc:
- def __trunc__(self):
- return 23
-
- class TestNoTrunc:
- pass
-
- self.assertEqual(trunc(TestTrunc()), 23)
-
- self.assertRaises(TypeError, trunc)
- self.assertRaises(TypeError, trunc, 1, 2)
- self.assertRaises(TypeError, trunc, TestNoTrunc())
-
- t = TestNoTrunc()
- t.__trunc__ = lambda *args: args
- self.assertRaises(TypeError, trunc, t)
- self.assertRaises(TypeError, trunc, t, 0)
-
def test_tuple(self):
self.assertEqual(tuple(()), ())
t0_3 = (0, 1, 2, 3)
except (OSError, IOError):
pass
+ if float.__getformat__("double").startswith("IEEE"):
+ def test_plus_minus_0j(self):
+ # test that -0j and 0j literals are not identified
+ z1, z2 = 0j, -0j
+ self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.))
+ self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
+
def test_main():
test_support.run_unittest(ComplexTest)
"""
from __future__ import with_statement
-import unittest
import glob
+import math
import os, sys
import pickle, copy
+import unittest
from decimal import *
from test.test_support import (TestSkipped, run_unittest, run_doctest,
is_resource_enabled)
# should work the same as to_integral in the ROUND_DOWN mode
d = Decimal(s)
r = d.to_integral(ROUND_DOWN)
- self.assertEqual(Decimal(trunc(d)), r)
+ self.assertEqual(Decimal(math.trunc(d)), r)
class ContextAPItests(unittest.TestCase):
self.ftest('tanh(0)', math.tanh(0), 0)
self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
+ def test_trunc(self):
+ self.assertEqual(math.trunc(1), 1)
+ self.assertEqual(math.trunc(-1), -1)
+ self.assertEqual(type(math.trunc(1)), int)
+ self.assertEqual(type(math.trunc(1.5)), int)
+ self.assertEqual(math.trunc(1.5), 1)
+ self.assertEqual(math.trunc(-1.5), -1)
+ self.assertEqual(math.trunc(1.999999), 1)
+ self.assertEqual(math.trunc(-1.999999), -1)
+ self.assertEqual(math.trunc(-0.999999), -0)
+ self.assertEqual(math.trunc(-100.999), -100)
+
+ class TestTrunc(object):
+ def __trunc__(self):
+ return 23
+
+ class TestNoTrunc(object):
+ pass
+
+ self.assertEqual(math.trunc(TestTrunc()), 23)
+
+ self.assertRaises(TypeError, math.trunc)
+ self.assertRaises(TypeError, math.trunc, 1, 2)
+ self.assertRaises(TypeError, math.trunc, TestNoTrunc())
+
+ # XXX Doesn't work because the method is looked up on
+ # the type only.
+ #t = TestNoTrunc()
+ #t.__trunc__ = lambda *args: args
+ #self.assertEquals((), math.trunc(t))
+ #self.assertRaises(TypeError, math.trunc, t, 0)
+
def testCopysign(self):
self.assertEqual(math.copysign(1, 42), 1.0)
self.assertEqual(math.copysign(0., 42), 0.0)
r.__init__(2, 15)
self.assertEquals((7, 3), _components(r))
+ self.assertRaises(AttributeError, setattr, r, 'numerator', 12)
+ self.assertRaises(AttributeError, setattr, r, 'denominator', 6)
+ self.assertEquals((7, 3), _components(r))
+
+ # But if you _really_ need to:
+ r._numerator = 4
+ r._denominator = 2
+ self.assertEquals((4, 2), _components(r))
+ # Which breaks some important operations:
+ self.assertNotEquals(R(4, 2), r)
+
def testFromFloat(self):
self.assertRaisesMessage(
TypeError, "Rational.from_float() only takes floats, not 3 (int)",
self.assertEqual(R.from_float(0.0).approximate(10000), R(0))
def testConversions(self):
- self.assertTypedEquals(-1, trunc(R(-11, 10)))
+ self.assertTypedEquals(-1, math.trunc(R(-11, 10)))
self.assertTypedEquals(-2, math.floor(R(-11, 10)))
self.assertTypedEquals(-1, math.ceil(R(-11, 10)))
self.assertTypedEquals(-1, math.ceil(R(-10, 10)))
# Because 10**23 can't be represented exactly as a float:
self.assertFalse(R(10**23) == float(10**23))
# The first test demonstrates why these are important.
- self.assertFalse(1e23 < float(R(trunc(1e23) + 1)))
- self.assertTrue(1e23 < R(trunc(1e23) + 1))
- self.assertFalse(1e23 <= R(trunc(1e23) - 1))
- self.assertTrue(1e23 > R(trunc(1e23) - 1))
- self.assertFalse(1e23 >= R(trunc(1e23) + 1))
+ self.assertFalse(1e23 < float(R(math.trunc(1e23) + 1)))
+ self.assertTrue(1e23 < R(math.trunc(1e23) + 1))
+ self.assertFalse(1e23 <= R(math.trunc(1e23) - 1))
+ self.assertTrue(1e23 > R(math.trunc(1e23) - 1))
+ self.assertFalse(1e23 >= R(math.trunc(1e23) + 1))
def testBigComplexComparisons(self):
self.assertFalse(R(10**23) == complex(10**23))
FUNC1(tanh, tanh,
"tanh(x)\n\nReturn the hyperbolic tangent of x.")
+static PyObject *
+math_trunc(PyObject *self, PyObject *number)
+{
+ static PyObject *trunc_str = NULL;
+ PyObject *trunc;
+
+ if (Py_TYPE(number)->tp_dict == NULL) {
+ if (PyType_Ready(Py_TYPE(number)) < 0)
+ return NULL;
+ }
+
+ if (trunc_str == NULL) {
+ trunc_str = PyUnicode_InternFromString("__trunc__");
+ if (trunc_str == NULL)
+ return NULL;
+ }
+
+ trunc = _PyType_Lookup(Py_TYPE(number), trunc_str);
+ if (trunc == NULL) {
+ PyErr_Format(PyExc_TypeError,
+ "type %.100s doesn't define __trunc__ method",
+ Py_TYPE(number)->tp_name);
+ return NULL;
+ }
+ return PyObject_CallFunctionObjArgs(trunc, number, NULL);
+}
+
+PyDoc_STRVAR(math_trunc_doc,
+"trunc(x:Real) -> Integral\n"
+"\n"
+"Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic"
+"method.");
+
static PyObject *
math_frexp(PyObject *self, PyObject *arg)
{
{"sqrt", math_sqrt, METH_O, math_sqrt_doc},
{"tan", math_tan, METH_O, math_tan_doc},
{"tanh", math_tanh, METH_O, math_tanh_doc},
+ {"trunc", math_trunc, METH_O, math_trunc_doc},
{NULL, NULL} /* sentinel */
};
static PyObject *
posix_fork1(PyObject *self, PyObject *noargs)
{
- int pid = fork1();
+ pid_t pid = fork1();
if (pid == -1)
return posix_error();
PyOS_AfterFork();
- return PyLong_FromLong((long)pid);
+ return PyLong_FromLong(pid);
}
#endif
static PyObject *
posix_fork(PyObject *self, PyObject *noargs)
{
- int pid = fork();
+ pid_t pid = fork();
if (pid == -1)
return posix_error();
if (pid == 0)
PyOS_AfterFork();
- return PyLong_FromLong((long)pid);
+ return PyLong_FromLong(pid);
}
#endif
static PyObject *
posix_forkpty(PyObject *self, PyObject *noargs)
{
- int master_fd = -1, pid;
+ int master_fd = -1;
+ pid_t pid;
pid = forkpty(&master_fd, NULL, NULL, NULL);
if (pid == -1)
return posix_error();
if (pid == 0)
PyOS_AfterFork();
- return Py_BuildValue("(ii)", pid, master_fd);
+ return Py_BuildValue("(li)", pid, master_fd);
}
#endif
Without arguments, equivalent to locals().\n\
With an argument, equivalent to object.__dict__.");
-static PyObject *
-builtin_trunc(PyObject *self, PyObject *number)
-{
- static PyObject *trunc_str = NULL;
- PyObject *trunc;
-
- if (Py_TYPE(number)->tp_dict == NULL) {
- if (PyType_Ready(Py_TYPE(number)) < 0)
- return NULL;
- }
-
- if (trunc_str == NULL) {
- trunc_str = PyUnicode_InternFromString("__trunc__");
- if (trunc_str == NULL)
- return NULL;
- }
-
- trunc = _PyType_Lookup(Py_TYPE(number), trunc_str);
- if (trunc == NULL) {
- PyErr_Format(PyExc_TypeError,
- "type %.100s doesn't define __trunc__ method",
- Py_TYPE(number)->tp_name);
- return NULL;
- }
- return PyObject_CallFunction(trunc, "O", number);
-}
-
-PyDoc_STRVAR(trunc_doc,
-"trunc(Real) -> Integral\n\
-\n\
-returns the integral closest to x between 0 and x.");
-
-
-
static PyObject*
builtin_sum(PyObject *self, PyObject *args)
{
{"sorted", (PyCFunction)builtin_sorted, METH_VARARGS | METH_KEYWORDS, sorted_doc},
{"sum", builtin_sum, METH_VARARGS, sum_doc},
{"vars", builtin_vars, METH_VARARGS, vars_doc},
- {"trunc", builtin_trunc, METH_O, trunc_doc},
{"zip", builtin_zip, METH_VARARGS, zip_doc},
{NULL, NULL},
};
{
PyObject *t, *v;
Py_ssize_t arg;
+ unsigned char *p, *q;
+ Py_complex z;
+ double d;
+ int real_part_zero, imag_part_zero;
/* necessary to make sure types aren't coerced (e.g., int and long) */
/* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */
if (PyFloat_Check(o)) {
- double d = PyFloat_AS_DOUBLE(o);
- unsigned char* p = (unsigned char*) &d;
- /* all we need is to make the tuple different in either the 0.0
- * or -0.0 case from all others, just to avoid the "coercion".
- */
- if (*p==0 && p[sizeof(double)-1]==0)
- t = PyTuple_Pack(3, o, o->ob_type, Py_None);
- else
- t = PyTuple_Pack(2, o, o->ob_type);
- } else {
- t = PyTuple_Pack(2, o, o->ob_type);
+ d = PyFloat_AS_DOUBLE(o);
+ p = (unsigned char*) &d;
+ /* all we need is to make the tuple different in either the 0.0
+ * or -0.0 case from all others, just to avoid the "coercion".
+ */
+ if (*p==0 && p[sizeof(double)-1]==0)
+ t = PyTuple_Pack(3, o, o->ob_type, Py_None);
+ else
+ t = PyTuple_Pack(2, o, o->ob_type);
+ }
+ else if (PyComplex_Check(o)) {
+ /* complex case is even messier: we need to make complex(x,
+ 0.) different from complex(x, -0.) and complex(0., y)
+ different from complex(-0., y), for any x and y. In
+ particular, all four complex zeros should be
+ distinguished.*/
+ z = PyComplex_AsCComplex(o);
+ p = (unsigned char*) &(z.real);
+ q = (unsigned char*) &(z.imag);
+ /* all that matters here is that on IEEE platforms
+ real_part_zero will be true if z.real == 0., and false if
+ z.real == -0. In fact, real_part_zero will also be true
+ for some other rarely occurring nonzero floats, but this
+ doesn't matter. Similar comments apply to
+ imag_part_zero. */
+ real_part_zero = *p==0 && p[sizeof(double)-1]==0;
+ imag_part_zero = *q==0 && q[sizeof(double)-1]==0;
+ if (real_part_zero && imag_part_zero) {
+ t = PyTuple_Pack(4, o, o->ob_type, Py_True, Py_True);
+ }
+ else if (real_part_zero && !imag_part_zero) {
+ t = PyTuple_Pack(4, o, o->ob_type, Py_True, Py_False);
+ }
+ else if (!real_part_zero && imag_part_zero) {
+ t = PyTuple_Pack(4, o, o->ob_type, Py_False, Py_True);
+ }
+ else {
+ t = PyTuple_Pack(2, o, o->ob_type);
+ }
+ }
+ else {
+ t = PyTuple_Pack(2, o, o->ob_type);
}
if (t == NULL)
- return -1;
+ return -1;
v = PyDict_GetItem(dict, t);
if (!v) {
v = NULL;
break;
}
+ Py_DECREF(v2);
}
retval = v;
break;
#! /bin/sh
-# From configure.in Revision: 60144 .
+# From configure.in Revision: 60476 .
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.61 for python 3.0.
#
_ACEOF
+{ echo "$as_me:$LINENO: checking for pid_t" >&5
+echo $ECHO_N "checking for pid_t... $ECHO_C" >&6; }
+if test "${ac_cv_type_pid_t+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+typedef pid_t ac__type_new_;
+int
+main ()
+{
+if ((ac__type_new_ *) 0)
+ return 0;
+if (sizeof (ac__type_new_))
+ return 0;
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_compile") 2>conftest.er1
+ ac_status=$?
+ grep -v '^ *+' conftest.er1 >conftest.err
+ rm -f conftest.er1
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && {
+ test -z "$ac_c_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest.$ac_objext; then
+ ac_cv_type_pid_t=yes
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_cv_type_pid_t=no
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_type_pid_t" >&5
+echo "${ECHO_T}$ac_cv_type_pid_t" >&6; }
+
+# The cast to long int works around a bug in the HP C Compiler
+# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+# This bug is HP SR number 8606223364.
+{ echo "$as_me:$LINENO: checking size of pid_t" >&5
+echo $ECHO_N "checking size of pid_t... $ECHO_C" >&6; }
+if test "${ac_cv_sizeof_pid_t+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test "$cross_compiling" = yes; then
+ # Depending upon the size, compute the lo and hi bounds.
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+ typedef pid_t ac__type_sizeof_;
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)];
+test_array [0] = 0
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_compile") 2>conftest.er1
+ ac_status=$?
+ grep -v '^ *+' conftest.er1 >conftest.err
+ rm -f conftest.er1
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && {
+ test -z "$ac_c_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest.$ac_objext; then
+ ac_lo=0 ac_mid=0
+ while :; do
+ cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+ typedef pid_t ac__type_sizeof_;
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+test_array [0] = 0
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_compile") 2>conftest.er1
+ ac_status=$?
+ grep -v '^ *+' conftest.er1 >conftest.err
+ rm -f conftest.er1
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && {
+ test -z "$ac_c_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest.$ac_objext; then
+ ac_hi=$ac_mid; break
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_lo=`expr $ac_mid + 1`
+ if test $ac_lo -le $ac_mid; then
+ ac_lo= ac_hi=
+ break
+ fi
+ ac_mid=`expr 2 '*' $ac_mid + 1`
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ done
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+ typedef pid_t ac__type_sizeof_;
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)];
+test_array [0] = 0
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_compile") 2>conftest.er1
+ ac_status=$?
+ grep -v '^ *+' conftest.er1 >conftest.err
+ rm -f conftest.er1
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && {
+ test -z "$ac_c_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest.$ac_objext; then
+ ac_hi=-1 ac_mid=-1
+ while :; do
+ cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+ typedef pid_t ac__type_sizeof_;
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)];
+test_array [0] = 0
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_compile") 2>conftest.er1
+ ac_status=$?
+ grep -v '^ *+' conftest.er1 >conftest.err
+ rm -f conftest.er1
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && {
+ test -z "$ac_c_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest.$ac_objext; then
+ ac_lo=$ac_mid; break
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_hi=`expr '(' $ac_mid ')' - 1`
+ if test $ac_mid -le $ac_hi; then
+ ac_lo= ac_hi=
+ break
+ fi
+ ac_mid=`expr 2 '*' $ac_mid`
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ done
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_lo= ac_hi=
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+# Binary search between lo and hi bounds.
+while test "x$ac_lo" != "x$ac_hi"; do
+ ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
+ cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+ typedef pid_t ac__type_sizeof_;
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)];
+test_array [0] = 0
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_compile") 2>conftest.er1
+ ac_status=$?
+ grep -v '^ *+' conftest.er1 >conftest.err
+ rm -f conftest.er1
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && {
+ test -z "$ac_c_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest.$ac_objext; then
+ ac_hi=$ac_mid
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_lo=`expr '(' $ac_mid ')' + 1`
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+done
+case $ac_lo in
+?*) ac_cv_sizeof_pid_t=$ac_lo;;
+'') if test "$ac_cv_type_pid_t" = yes; then
+ { { echo "$as_me:$LINENO: error: cannot compute sizeof (pid_t)
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute sizeof (pid_t)
+See \`config.log' for more details." >&2;}
+ { (exit 77); exit 77; }; }
+ else
+ ac_cv_sizeof_pid_t=0
+ fi ;;
+esac
+else
+ cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_includes_default
+ typedef pid_t ac__type_sizeof_;
+static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); }
+static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); }
+#include <stdio.h>
+#include <stdlib.h>
+int
+main ()
+{
+
+ FILE *f = fopen ("conftest.val", "w");
+ if (! f)
+ return 1;
+ if (((long int) (sizeof (ac__type_sizeof_))) < 0)
+ {
+ long int i = longval ();
+ if (i != ((long int) (sizeof (ac__type_sizeof_))))
+ return 1;
+ fprintf (f, "%ld\n", i);
+ }
+ else
+ {
+ unsigned long int i = ulongval ();
+ if (i != ((long int) (sizeof (ac__type_sizeof_))))
+ return 1;
+ fprintf (f, "%lu\n", i);
+ }
+ return ferror (f) || fclose (f) != 0;
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest$ac_exeext
+if { (ac_try="$ac_link"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_link") 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+ { (case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+ (eval "$ac_try") 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ ac_cv_sizeof_pid_t=`cat conftest.val`
+else
+ echo "$as_me: program exited with status $ac_status" >&5
+echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+( exit $ac_status )
+if test "$ac_cv_type_pid_t" = yes; then
+ { { echo "$as_me:$LINENO: error: cannot compute sizeof (pid_t)
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute sizeof (pid_t)
+See \`config.log' for more details." >&2;}
+ { (exit 77); exit 77; }; }
+ else
+ ac_cv_sizeof_pid_t=0
+ fi
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f conftest.val
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_sizeof_pid_t" >&5
+echo "${ECHO_T}$ac_cv_sizeof_pid_t" >&6; }
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define SIZEOF_PID_T $ac_cv_sizeof_pid_t
+_ACEOF
+
+
{ echo "$as_me:$LINENO: checking for long long support" >&5
echo $ECHO_N "checking for long long support... $ECHO_C" >&6; }
AC_TYPE_SIGNAL
AC_TYPE_SIZE_T
AC_TYPE_UID_T
-AC_CHECK_TYPE(ssize_t,
+AC_CHECK_TYPE(ssize_t,
AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
# Sizes of various common basic types
AC_CHECK_SIZEOF(double, 8)
AC_CHECK_SIZEOF(fpos_t, 4)
AC_CHECK_SIZEOF(size_t, 4)
+AC_CHECK_SIZEOF(pid_t, 4)
AC_MSG_CHECKING(for long long support)
have_long_long=no
/* The number of bytes in an off_t. */
#undef SIZEOF_OFF_T
+/* The size of `pid_t', as computed by sizeof. */
+#undef SIZEOF_PID_T
+
/* The number of bytes in a pthread_t. */
#undef SIZEOF_PTHREAD_T
projects / python / commitdiff