From 7736b5becd273cb271c55fcce9155677a381c4f6 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Tue, 15 Jan 2008 21:44:53 +0000 Subject: Merged revisions 59952-59984 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r59952 | thomas.heller | 2008-01-14 02:35:28 -0800 (Mon, 14 Jan 2008) | 1 line Issue 1821: configure libffi for amd64 on FreeeBSD. ........ r59953 | andrew.kuchling | 2008-01-14 06:48:43 -0800 (Mon, 14 Jan 2008) | 1 line Update description of float_info ........ r59959 | raymond.hettinger | 2008-01-14 14:58:05 -0800 (Mon, 14 Jan 2008) | 1 line Fix 1698398: Zipfile.printdir() crashed because the format string expected a tuple object of length six instead of a time.struct_time object. ........ r59961 | andrew.kuchling | 2008-01-14 17:29:16 -0800 (Mon, 14 Jan 2008) | 1 line Typo fixes ........ r59962 | andrew.kuchling | 2008-01-14 17:29:44 -0800 (Mon, 14 Jan 2008) | 1 line Markup fix ........ r59963 | andrew.kuchling | 2008-01-14 17:47:32 -0800 (Mon, 14 Jan 2008) | 1 line Add many items ........ r59964 | andrew.kuchling | 2008-01-14 17:55:32 -0800 (Mon, 14 Jan 2008) | 1 line Repair unfinished sentence ........ r59967 | raymond.hettinger | 2008-01-14 19:02:37 -0800 (Mon, 14 Jan 2008) | 5 lines Issue 1820: structseq objects did not work with the % formatting operator or isinstance(t, tuple). Orignal patch (without tests) by Leif Walsh. ........ r59968 | raymond.hettinger | 2008-01-14 19:07:42 -0800 (Mon, 14 Jan 2008) | 1 line Tighten the definition of a named tuple. ........ r59969 | skip.montanaro | 2008-01-14 19:40:20 -0800 (Mon, 14 Jan 2008) | 3 lines Better (?) text describing the lack of guarantees provided by qsize(), empty() and full(). ........ r59970 | raymond.hettinger | 2008-01-14 21:39:59 -0800 (Mon, 14 Jan 2008) | 1 line Temporarily revert 59967 until GC can be added. ........ r59971 | raymond.hettinger | 2008-01-14 21:46:43 -0800 (Mon, 14 Jan 2008) | 1 line Small grammar nit ........ r59972 | georg.brandl | 2008-01-14 22:55:56 -0800 (Mon, 14 Jan 2008) | 2 lines Typo. ........ r59973 | georg.brandl | 2008-01-14 22:58:15 -0800 (Mon, 14 Jan 2008) | 2 lines Remove duplicate entry. ........ r59974 | jeffrey.yasskin | 2008-01-14 23:46:24 -0800 (Mon, 14 Jan 2008) | 12 lines Add rational.Rational as an implementation of numbers.Rational with infinite precision. This has been discussed at http://bugs.python.org/issue1682. It's useful primarily for teaching, but it also demonstrates how to implement a member of the numeric tower, including fallbacks for mixed-mode arithmetic. I expect to write a couple more patches in this area: * Rational.from_decimal() * Rational.trim/approximate() (maybe with different names) * Maybe remove the parentheses from Rational.__str__() * Maybe rename one of the Rational classes * Maybe make Rational('3/2') work. ........ r59978 | andrew.kuchling | 2008-01-15 06:38:05 -0800 (Tue, 15 Jan 2008) | 8 lines Restore description of sys.dont_write_bytecode. The duplication is intentional -- this paragraph is in a section describing additions to the sys module, and there's a later section that mentions the switch. I think most people scan the what's-new and don't read it in detail, so a bit of duplication is OK. ........ r59984 | guido.van.rossum | 2008-01-15 09:59:29 -0800 (Tue, 15 Jan 2008) | 3 lines Issue #1786 (by myself): pdb should use its own stdin/stdout around an exec call and when creating a recursive instance. ........ --- Demo/classes/Rat.py | 306 --------------------------- Doc/glossary.rst | 2 +- Doc/library/numeric.rst | 1 + Doc/library/queue.rst | 5 +- Doc/library/rational.rst | 65 ++++++ Doc/library/sys.rst | 2 +- Doc/library/test.rst | 2 +- Doc/whatsnew/2.6.rst | 151 ++++++++++++- Lib/numbers.py | 25 ++- Lib/pdb.py | 10 +- Lib/rational.py | 410 ++++++++++++++++++++++++++++++++++++ Lib/test/test_rational.py | 283 +++++++++++++++++++++++++ Lib/test/test_sys.py | 2 +- Lib/zipfile.py | 4 +- Modules/_ctypes/libffi/configure | 159 +++++--------- Modules/_ctypes/libffi/configure.ac | 2 +- Python/sysmodule.c | 4 +- 17 files changed, 997 insertions(+), 436 deletions(-) delete mode 100755 Demo/classes/Rat.py create mode 100644 Doc/library/rational.rst create mode 100755 Lib/rational.py create mode 100644 Lib/test/test_rational.py diff --git a/Demo/classes/Rat.py b/Demo/classes/Rat.py deleted file mode 100755 index 6a350e8..0000000 --- a/Demo/classes/Rat.py +++ /dev/null @@ -1,306 +0,0 @@ -'''\ -This module implements rational numbers. - -The entry point of this module is the function - rat(numerator, denominator) -If either numerator or denominator is of an integral or rational type, -the result is a rational number, else, the result is the simplest of -the types float and complex which can hold numerator/denominator. -If denominator is omitted, it defaults to 1. -Rational numbers can be used in calculations with any other numeric -type. The result of the calculation will be rational if possible. - -There is also a test function with calling sequence - test() -The documentation string of the test function contains the expected -output. -''' - -# Contributed by Sjoerd Mullender - -from types import * - -def gcd(a, b): - '''Calculate the Greatest Common Divisor.''' - while b: - a, b = b, a%b - return a - -def rat(num, den = 1): - # must check complex before float - if isinstance(num, complex) or isinstance(den, complex): - # numerator or denominator is complex: return a complex - return complex(num) / complex(den) - if isinstance(num, float) or isinstance(den, float): - # numerator or denominator is float: return a float - return float(num) / float(den) - # otherwise return a rational - return Rat(num, den) - -class Rat: - '''This class implements rational numbers.''' - - def __init__(self, num, den = 1): - if den == 0: - raise ZeroDivisionError('rat(x, 0)') - - # normalize - - # must check complex before float - if (isinstance(num, complex) or - isinstance(den, complex)): - # numerator or denominator is complex: - # normalized form has denominator == 1+0j - self.__num = complex(num) / complex(den) - self.__den = complex(1) - return - if isinstance(num, float) or isinstance(den, float): - # numerator or denominator is float: - # normalized form has denominator == 1.0 - self.__num = float(num) / float(den) - self.__den = 1.0 - return - if (isinstance(num, self.__class__) or - isinstance(den, self.__class__)): - # numerator or denominator is rational - new = num / den - if not isinstance(new, self.__class__): - self.__num = new - if isinstance(new, complex): - self.__den = complex(1) - else: - self.__den = 1.0 - else: - self.__num = new.__num - self.__den = new.__den - else: - # make sure numerator and denominator don't - # have common factors - # this also makes sure that denominator > 0 - g = gcd(num, den) - self.__num = num / g - self.__den = den / g - # try making numerator and denominator of IntType if they fit - try: - numi = int(self.__num) - deni = int(self.__den) - except (OverflowError, TypeError): - pass - else: - if self.__num == numi and self.__den == deni: - self.__num = numi - self.__den = deni - - def __repr__(self): - return 'Rat(%s,%s)' % (self.__num, self.__den) - - def __str__(self): - if self.__den == 1: - return str(self.__num) - else: - return '(%s/%s)' % (str(self.__num), str(self.__den)) - - # a + b - def __add__(a, b): - try: - return rat(a.__num * b.__den + b.__num * a.__den, - a.__den * b.__den) - except OverflowError: - return rat(int(a.__num) * int(b.__den) + - int(b.__num) * int(a.__den), - int(a.__den) * int(b.__den)) - - def __radd__(b, a): - return Rat(a) + b - - # a - b - def __sub__(a, b): - try: - return rat(a.__num * b.__den - b.__num * a.__den, - a.__den * b.__den) - except OverflowError: - return rat(int(a.__num) * int(b.__den) - - int(b.__num) * int(a.__den), - int(a.__den) * int(b.__den)) - - def __rsub__(b, a): - return Rat(a) - b - - # a * b - def __mul__(a, b): - try: - return rat(a.__num * b.__num, a.__den * b.__den) - except OverflowError: - return rat(int(a.__num) * int(b.__num), - int(a.__den) * int(b.__den)) - - def __rmul__(b, a): - return Rat(a) * b - - # a / b - def __div__(a, b): - try: - return rat(a.__num * b.__den, a.__den * b.__num) - except OverflowError: - return rat(int(a.__num) * int(b.__den), - int(a.__den) * int(b.__num)) - - def __rdiv__(b, a): - return Rat(a) / b - - # a % b - def __mod__(a, b): - div = a / b - try: - div = int(div) - except OverflowError: - div = int(div) - return a - b * div - - def __rmod__(b, a): - return Rat(a) % b - - # a ** b - def __pow__(a, b): - if b.__den != 1: - if isinstance(a.__num, complex): - a = complex(a) - else: - a = float(a) - if isinstance(b.__num, complex): - b = complex(b) - else: - b = float(b) - return a ** b - try: - return rat(a.__num ** b.__num, a.__den ** b.__num) - except OverflowError: - return rat(int(a.__num) ** b.__num, - int(a.__den) ** b.__num) - - def __rpow__(b, a): - return Rat(a) ** b - - # -a - def __neg__(a): - try: - return rat(-a.__num, a.__den) - except OverflowError: - # a.__num == sys.maxint - return rat(-int(a.__num), a.__den) - - # abs(a) - def __abs__(a): - return rat(abs(a.__num), a.__den) - - # int(a) - def __int__(a): - return int(a.__num / a.__den) - - # long(a) - def __long__(a): - return int(a.__num) / int(a.__den) - - # float(a) - def __float__(a): - return float(a.__num) / float(a.__den) - - # complex(a) - def __complex__(a): - return complex(a.__num) / complex(a.__den) - - # cmp(a,b) - def __cmp__(a, b): - diff = Rat(a - b) - if diff.__num < 0: - return -1 - elif diff.__num > 0: - return 1 - else: - return 0 - - def __rcmp__(b, a): - return cmp(Rat(a), b) - - # a != 0 - def __bool__(a): - return a.__num != 0 - -def test(): - '''\ - Test function for rat module. - - The expected output is (module some differences in floating - precission): - -1 - -1 - 0 0L 0.1 (0.1+0j) - [Rat(1,2), Rat(-3,10), Rat(1,25), Rat(1,4)] - [Rat(-3,10), Rat(1,25), Rat(1,4), Rat(1,2)] - 0 - (11/10) - (11/10) - 1.1 - OK - 2 1.5 (3/2) (1.5+1.5j) (15707963/5000000) - 2 2 2.0 (2+0j) - - 4 0 4 1 4 0 - 3.5 0.5 3.0 1.33333333333 2.82842712475 1 - (7/2) (1/2) 3 (4/3) 2.82842712475 1 - (3.5+1.5j) (0.5-1.5j) (3+3j) (0.666666666667-0.666666666667j) (1.43248815986+2.43884761145j) 1 - 1.5 1 1.5 (1.5+0j) - - 3.5 -0.5 3.0 0.75 2.25 -1 - 3.0 0.0 2.25 1.0 1.83711730709 0 - 3.0 0.0 2.25 1.0 1.83711730709 1 - (3+1.5j) -1.5j (2.25+2.25j) (0.5-0.5j) (1.50768393746+1.04970907623j) -1 - (3/2) 1 1.5 (1.5+0j) - - (7/2) (-1/2) 3 (3/4) (9/4) -1 - 3.0 0.0 2.25 1.0 1.83711730709 -1 - 3 0 (9/4) 1 1.83711730709 0 - (3+1.5j) -1.5j (2.25+2.25j) (0.5-0.5j) (1.50768393746+1.04970907623j) -1 - (1.5+1.5j) (1.5+1.5j) - - (3.5+1.5j) (-0.5+1.5j) (3+3j) (0.75+0.75j) 4.5j -1 - (3+1.5j) 1.5j (2.25+2.25j) (1+1j) (1.18235814075+2.85446505899j) 1 - (3+1.5j) 1.5j (2.25+2.25j) (1+1j) (1.18235814075+2.85446505899j) 1 - (3+3j) 0j 4.5j (1+0j) (-0.638110484918+0.705394566962j) 0 - ''' - print(rat(-1, 1)) - print(rat(1, -1)) - a = rat(1, 10) - print(int(a), int(a), float(a), complex(a)) - b = rat(2, 5) - l = [a+b, a-b, a*b, a/b] - print(l) - l.sort() - print(l) - print(rat(0, 1)) - print(a+1) - print(a+1) - print(a+1.0) - try: - print(rat(1, 0)) - raise SystemError('should have been ZeroDivisionError') - except ZeroDivisionError: - print('OK') - print(rat(2), rat(1.5), rat(3, 2), rat(1.5+1.5j), rat(31415926,10000000)) - list = [2, 1.5, rat(3,2), 1.5+1.5j] - for i in list: - print(i, end=' ') - if not isinstance(i, complex): - print(int(i), float(i), end=' ') - print(complex(i)) - print() - for j in list: - print(i + j, i - j, i * j, i / j, i ** j, end=' ') - if not (isinstance(i, complex) or - isinstance(j, complex)): - print(cmp(i, j)) - print() - - -if __name__ == '__main__': - test() diff --git a/Doc/glossary.rst b/Doc/glossary.rst index 5c11ae0..13c254c 100644 --- a/Doc/glossary.rst +++ b/Doc/glossary.rst @@ -329,7 +329,7 @@ Glossary also :term:`immutable`. named tuple - Any tuple-like class whose indexable fields are also accessible with + Any tuple subclass whose indexable fields are also accessible with named attributes (for example, :func:`time.localtime` returns a tuple-like object where the *year* is accessible either with an index such as ``t[0]`` or with a named attribute like ``t.tm_year``). diff --git a/Doc/library/numeric.rst b/Doc/library/numeric.rst index d2b4d8b..4c65a43 100644 --- a/Doc/library/numeric.rst +++ b/Doc/library/numeric.rst @@ -21,6 +21,7 @@ The following modules are documented in this chapter: math.rst cmath.rst decimal.rst + rational.rst random.rst itertools.rst functools.rst diff --git a/Doc/library/queue.rst b/Doc/library/queue.rst index c5dbc20..331680d 100644 --- a/Doc/library/queue.rst +++ b/Doc/library/queue.rst @@ -49,8 +49,9 @@ See the source code for details. The public methods are: .. method:: Queue.qsize() - Return the approximate size of the queue. Because of multithreading semantics, - this number is not reliable. + Return the approximate size of the queue. Note, qsize() > 0 doesn't + guarantee that a subsequent get() will not block, nor will qsize() < maxsize + guarantee that put() will not block. .. method:: Queue.put(item[, block[, timeout]]) diff --git a/Doc/library/rational.rst b/Doc/library/rational.rst new file mode 100644 index 0000000..dd18305 --- /dev/null +++ b/Doc/library/rational.rst @@ -0,0 +1,65 @@ + +:mod:`rational` --- Rational numbers +==================================== + +.. module:: rational + :synopsis: Rational numbers. +.. moduleauthor:: Jeffrey Yasskin +.. sectionauthor:: Jeffrey Yasskin +.. versionadded:: 2.6 + + +The :mod:`rational` module defines an immutable, infinite-precision +Rational number class. + + +.. class:: Rational(numerator=0, denominator=1) + Rational(other_rational) + + The first version requires that *numerator* and *denominator* are + instances of :class:`numbers.Integral` and returns a new + ``Rational`` representing ``numerator/denominator``. If + *denominator* is :const:`0`, raises a :exc:`ZeroDivisionError`. The + second version requires that *other_rational* is an instance of + :class:`numbers.Rational` and returns an instance of + :class:`Rational` with the same value. + + Implements all of the methods and operations from + :class:`numbers.Rational` and is hashable. + + +.. method:: Rational.from_float(flt) + + This classmethod constructs a :class:`Rational` representing the + exact value of *flt*, which must be a :class:`float`. Beware that + ``Rational.from_float(0.3)`` is not the same value as ``Rational(3, + 10)`` + + +.. method:: Rational.__floor__() + + Returns the greatest :class:`int` ``<= self``. Will be accessible + through :func:`math.floor` in Py3k. + + +.. method:: Rational.__ceil__() + + Returns the least :class:`int` ``>= self``. Will be accessible + through :func:`math.ceil` in Py3k. + + +.. method:: Rational.__round__() + Rational.__round__(ndigits) + + The first version returns the nearest :class:`int` to ``self``, + rounding half to even. The second version rounds ``self`` to the + nearest multiple of ``Rational(1, 10**ndigits)`` (logically, if + ``ndigits`` is negative), again rounding half toward even. Will be + accessible through :func:`round` in Py3k. + + +.. seealso:: + + Module :mod:`numbers` + The abstract base classes making up the numeric tower. + diff --git a/Doc/library/sys.rst b/Doc/library/sys.rst index 4ab3529..6d1a09b 100644 --- a/Doc/library/sys.rst +++ b/Doc/library/sys.rst @@ -210,7 +210,7 @@ always available. +------------------------------+------------------------------------------+ | :const:`no_site` | -S | +------------------------------+------------------------------------------+ - | :const:`ingnore_environment` | -E | + | :const:`ignore_environment` | -E | +------------------------------+------------------------------------------+ | :const:`tabcheck` | -t or -tt | +------------------------------+------------------------------------------+ diff --git a/Doc/library/test.rst b/Doc/library/test.rst index a0f7841..6c35d50 100644 --- a/Doc/library/test.rst +++ b/Doc/library/test.rst @@ -300,7 +300,7 @@ The :mod:`test.test_support` module defines the following functions: This is a context manager than runs the :keyword:`with` statement body using a :class:`StringIO.StringIO` object as sys.stdout. That object can be - retrieved using the ``as`` clause of the with statement. + retrieved using the ``as`` clause of the :keyword:`with` statement. Example use:: diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst index 4d90d35..0539a44 100644 --- a/Doc/whatsnew/2.6.rst +++ b/Doc/whatsnew/2.6.rst @@ -426,6 +426,29 @@ can now be used in scripts running from inside a package. .. ====================================================================== +.. :: + + .. _pep-0370: + + PEP 370: XXX + ===================================================== + + When you run Python, the module search page ``sys.modules`` usually + includes a directory whose path ends in ``"site-packages"``. This + directory is intended to hold locally-installed packages available to + all users on a machine or using a particular site installation. + + Python 2.6 introduces a convention for user-specific site directories. + + .. seealso:: + + :pep:`370` - XXX + + PEP written by XXX; implemented by Christian Heimes. + + +.. ====================================================================== + .. _pep-3110: PEP 3110: Exception-Handling Changes @@ -650,6 +673,18 @@ Here are all of the changes that Python 2.6 makes to the core Python language. Optimizations ------------- +* Type objects now have a cache of methods that can reduce + the amount of work required to find the correct method implementation + for a particular class; once cached, the interpreter doesn't need to + traverse base classes to figure out the right method to call. + The cache is cleared if a base class or the class itself is modified, + so the cache should remain correct even in the face of Python's dynamic + nature. + (Original optimization implemented by Armin Rigo, updated for + Python 2.6 by Kevin Jacobs.) + + .. % Patch 1700288 + * All of the functions in the :mod:`struct` module have been rewritten in C, thanks to work at the Need For Speed sprint. (Contributed by Raymond Hettinger.) @@ -700,6 +735,11 @@ complete list of changes, or look through the CVS logs for all the details. >>> v2 variable(id=1, name='amplitude', type='int', size=4) + Where the new :class:`namedtuple` type proved suitable, the standard + library has been modified to return them. For example, + the :meth:`Decimal.as_tuple` method now returns a named tuple with + :attr:`sign`, :attr:`digits`, and :attr:`exponent` fields. + (Contributed by Raymond Hettinger.) * Another change to the :mod:`collections` module is that the @@ -758,7 +798,17 @@ complete list of changes, or look through the CVS logs for all the details. >>> Decimal(1000).log10() Decimal("3") - (Implemented by Facundo Batista and Mark Dickinson.) + The :meth:`as_tuple` method of :class:`Decimal` objects now returns a + named tuple with :attr:`sign`, :attr:`digits`, and :attr:`exponent` fields. + + (Implemented by Facundo Batista and Mark Dickinson. Named tuple + support added by Raymond Hettinger.) + +* The :mod:`difflib` module's :class:`SequenceMatcher` class + now returns named tuples representing matches. + In addition to behaving like tuples, the returned values + also have :attr:`a`, :attr:`b`, and :attr:`size` attributes. + (Contributed by Raymond Hettinger.) * An optional ``timeout`` parameter was added to the :class:`ftplib.FTP` class constructor as well as the :meth:`connect` @@ -795,6 +845,12 @@ complete list of changes, or look through the CVS logs for all the details. class constructors, specifying a timeout measured in seconds. (Added by Facundo Batista.) +* Most of the :mod:`inspect` module's functions, such as + :func:`getmoduleinfo` and :func:`getargs`, now return named tuples. + In addition to behaving like tuples, the elements of the return value + can also be accessed as attributes. + (Contributed by Raymond Hettinger.) + * A new function in the :mod:`itertools` module: ``izip_longest(iter1, iter2, ...[, fillvalue])`` makes tuples from each of the elements; if some of the iterables are shorter than others, the missing values are set to *fillvalue*. @@ -891,6 +947,13 @@ complete list of changes, or look through the CVS logs for all the details. .. Issue 1727780 +* Long regular expression searches carried out by the :mod:`re` + module will now check for signals being delivered, so especially + long searches can now be interrupted. + (Contributed by Josh Hoyt and Ralf Schmitt.) + + .. % Patch 846388 + * The :mod:`rgbimg` module has been removed. * The :mod:`sets` module has been deprecated; it's better to @@ -934,17 +997,42 @@ complete list of changes, or look through the CVS logs for all the details. .. Patch #957003 +* The :mod:`socket` module now supports TIPC (http://tipc.sf.net), + a high-performance non-IP-based protocol designed for use in clustered + environments. TIPC addresses are 4- or 5-tuples. + (Contributed by Alberto Bertogli.) + + .. Patch #1646 + * A new variable in the :mod:`sys` module, - :attr:`float_info`, is a dictionary + :attr:`float_info`, is an object containing information about the platform's floating-point support - derived from the :file:`float.h` file. Key/value pairs - in this dictionary include - ``"mant_dig"`` (number of digits in the mantissa), ``"epsilon"`` + derived from the :file:`float.h` file. Attributes of this object + include + :attr:`mant_dig` (number of digits in the mantissa), :attr:`epsilon` (smallest difference between 1.0 and the next largest value representable), and several others. (Contributed by Christian Heimes.) .. Patch 1534 + Another new variable, :attr:`dont_write_bytecode`, controls whether Python + writes any :file:`.pyc` or :file:`.pyo` files on importing a module. + If this variable is true, the compiled files are not written. The + variable is initially set on start-up by supplying the :option:`-B` + switch to the Python interpreter, or by setting the + :envvar:`PYTHONDONTWRITEBYTECODE` environment variable before + running the interpreter. Python code can subsequently + change the value of this variable to control whether bytecode files + are written or not. + (Contributed by Neal Norwitz and Georg Brandl.) + + Information about the command-line arguments supplied to the Python + interpreter are available as attributes of a ``sys.flags`` named + tuple. For example, the :attr:`verbose` attribute is true if Python + was executed in verbose mode, :attr:`debug` is true in debugging mode, etc. + These attributes are all read-only. + (Contributed by Christian Heimes.) + * The :mod:`tarfile` module now supports POSIX.1-2001 (pax) and POSIX.1-1988 (ustar) format tarfiles, in addition to the GNU tar format that was already supported. The default format @@ -1061,6 +1149,22 @@ complete list of changes, or look through the CVS logs for all the details. information. (Contributed by Alan McIntyre as part of his project for Google's Summer of Code 2007.) +* The :mod:`zipfile` module's :class:`ZipFile` class now has + :meth:`extract` and :meth:`extractall` methods that will unpack + a single file or all the files in the archive to the current directory, or + to a specified directory:: + + z = zipfile.ZipFile('python-251.zip') + + # Unpack a single file, writing it relative to the /tmp directory. + z.extract('Python/sysmodule.c', '/tmp') + + # Unpack all the files in the archive. + z.extractall() + + (Contributed by Alan McIntyre.) + .. % Patch 467924 + .. ====================================================================== .. whole new modules get described in subsections here @@ -1143,7 +1247,12 @@ Port-Specific Changes: Windows value, as does the :func:`getwche` function. The :func:`putwch` function takes a Unicode character and writes it to the console. -Platform-specific changes go here. +* The :mod:`_winreg` module now has a function, + :func:`ExpandEnvironmentStrings`, + that expands environment variable references such as ``%NAME%`` + in an input string. The handle objects provided by this + module now support the context protocol, so they can be used + in :keyword:`with` statements. .. ====================================================================== @@ -1153,14 +1262,21 @@ Platform-specific changes go here. Other Changes and Fixes ======================= -As usual, there were a bunch of other improvements and bugfixes scattered -throughout the source tree. A search through the change logs finds there were -XXX patches applied and YYY bugs fixed between Python 2.5 and 2.6. Both figures -are likely to be underestimates. +As usual, there were a bunch of other improvements and bugfixes +scattered throughout the source tree. A search through the change +logs finds there were XXX patches applied and YYY bugs fixed between +Python 2.5 and 2.6. Both figures are likely to be underestimates. Some of the more notable changes are: -* Details will go here. +* It's now possible to prevent Python from writing any :file:`.pyc` + or :file:`.pyo` files by either supplying the :option:`-B` switch + or setting the :envvar:`PYTHONDONTWRITEBYTECODE` environment variable + to any non-empty string when running the Python interpreter. These + are also used to set the :data:`sys.dont_write_bytecode` attribute; + Python code can change this variable to control whether bytecode + files are subsequently written. + (Contributed by Neal Norwitz and Georg Brandl.) .. ====================================================================== @@ -1177,6 +1293,19 @@ code: before adding elements from the iterable. This change makes the behavior match that of ``list.__init__()``. +* The :class:`Decimal` constructor now accepts leading and trailing + whitespace when passed a string. Previously it would raise an + :exc:`InvalidOperation` exception. On the other hand, the + :meth:`create_decimal` method of :class:`Context` objects now + explicitly disallows extra whitespace, raising a + :exc:`ConversionSyntax` exception. + +* Due to an implementation accident, if you passed a file path to + the built-in :func:`__import__` function, it would actually import + the specified file. This was never intended to work, however, and + the implementation now explicitly checks for this case and raises + an :exc:`ImportError`. + * The :mod:`socket` module exception :exc:`socket.error` now inherits from :exc:`IOError`. Previously it wasn't a subclass of :exc:`StandardError` but now it is, through :exc:`IOError`. diff --git a/Lib/numbers.py b/Lib/numbers.py index b1c0697..7c73fa7 100644 --- a/Lib/numbers.py +++ b/Lib/numbers.py @@ -5,6 +5,7 @@ TODO: Fill out more detailed documentation on the operators.""" +from __future__ import division from abc import ABCMeta, abstractmethod, abstractproperty __all__ = ["Number", "Exact", "Inexact", @@ -61,7 +62,8 @@ class Complex(Number): def __complex__(self): """Return a builtin complex instance. Called for complex(self).""" - def __bool__(self): + # Will be __bool__ in 3.0. + def __nonzero__(self): """True if self != 0. Called for bool(self).""" return self != 0 @@ -96,6 +98,7 @@ class Complex(Number): """-self""" raise NotImplementedError + @abstractmethod def __pos__(self): """+self""" raise NotImplementedError @@ -120,12 +123,28 @@ class Complex(Number): @abstractmethod def __div__(self, other): - """self / other; should promote to float or complex when necessary.""" + """self / other without __future__ division + + May promote to float. + """ raise NotImplementedError @abstractmethod def __rdiv__(self, other): - """other / self""" + """other / self without __future__ division""" + raise NotImplementedError + + @abstractmethod + def __truediv__(self, other): + """self / other with __future__ division. + + Should promote to float when necessary. + """ + raise NotImplementedError + + @abstractmethod + def __rtruediv__(self, other): + """other / self with __future__ division""" raise NotImplementedError @abstractmethod diff --git a/Lib/pdb.py b/Lib/pdb.py index bd51c31..dfd745d 100755 --- a/Lib/pdb.py +++ b/Lib/pdb.py @@ -198,7 +198,13 @@ class Pdb(bdb.Bdb, cmd.Cmd): globals = self.curframe.f_globals try: code = compile(line + '\n', '', 'single') - exec(code, globals, locals) + try: + sys.stdin = self.stdin + sys.stdout = self.stdout + exec(code, globals, locals) + finally: + sys.stdout = save_stdout + sys.stdin = save_stdin except: t, v = sys.exc_info()[:2] if type(t) == type(''): @@ -656,7 +662,7 @@ class Pdb(bdb.Bdb, cmd.Cmd): sys.settrace(None) globals = self.curframe.f_globals locals = self.curframe.f_locals - p = Pdb() + p = Pdb(self.completekey, self.stdin, self.stdout) p.prompt = "(%s) " % self.prompt.strip() print("ENTERING RECURSIVE DEBUGGER", file=self.stdout) sys.call_tracing(p.run, (arg, globals, locals)) diff --git a/Lib/rational.py b/Lib/rational.py new file mode 100755 index 0000000..bece207 --- /dev/null +++ b/Lib/rational.py @@ -0,0 +1,410 @@ +# Originally contributed by Sjoerd Mullender. +# Significantly modified by Jeffrey Yasskin . + +"""Rational, infinite-precision, real numbers.""" + +from __future__ import division +import math +import numbers +import operator + +__all__ = ["Rational"] + +RationalAbc = numbers.Rational + + +def _gcd(a, b): + """Calculate the Greatest Common Divisor. + + Unless b==0, the result will have the same sign as b (so that when + b is divided by it, the result comes out positive). + """ + while b: + a, b = b, a%b + return a + + +def _binary_float_to_ratio(x): + """x -> (top, bot), a pair of ints s.t. x = top/bot. + + The conversion is done exactly, without rounding. + bot > 0 guaranteed. + Some form of binary fp is assumed. + Pass NaNs or infinities at your own risk. + + >>> _binary_float_to_ratio(10.0) + (10, 1) + >>> _binary_float_to_ratio(0.0) + (0, 1) + >>> _binary_float_to_ratio(-.25) + (-1, 4) + """ + + if x == 0: + return 0, 1 + f, e = math.frexp(x) + signbit = 1 + if f < 0: + f = -f + signbit = -1 + assert 0.5 <= f < 1.0 + # x = signbit * f * 2**e exactly + + # Suck up CHUNK bits at a time; 28 is enough so that we suck + # up all bits in 2 iterations for all known binary double- + # precision formats, and small enough to fit in an int. + CHUNK = 28 + top = 0 + # invariant: x = signbit * (top + f) * 2**e exactly + while f: + f = math.ldexp(f, CHUNK) + digit = trunc(f) + assert digit >> CHUNK == 0 + top = (top << CHUNK) | digit + f = f - digit + assert 0.0 <= f < 1.0 + e = e - CHUNK + assert top + + # Add in the sign bit. + top = signbit * top + + # now x = top * 2**e exactly; fold in 2**e + if e>0: + return (top * 2**e, 1) + else: + return (top, 2 ** -e) + + +class Rational(RationalAbc): + """This class implements rational numbers. + + Rational(8, 6) will produce a rational number equivalent to + 4/3. Both arguments must be Integral. The numerator defaults to 0 + and the denominator defaults to 1 so that Rational(3) == 3 and + Rational() == 0. + + """ + + __slots__ = ('_numerator', '_denominator') + + def __init__(self, numerator=0, denominator=1): + if (not isinstance(numerator, numbers.Integral) and + isinstance(numerator, RationalAbc) and + denominator == 1): + # Handle copies from other rationals. + other_rational = numerator + numerator = other_rational.numerator + denominator = other_rational.denominator + + if (not isinstance(numerator, numbers.Integral) or + not isinstance(denominator, numbers.Integral)): + raise TypeError("Rational(%(numerator)s, %(denominator)s):" + " Both arguments must be integral." % locals()) + + if denominator == 0: + raise ZeroDivisionError('Rational(%s, 0)' % numerator) + + g = _gcd(numerator, denominator) + self._numerator = int(numerator // g) + self._denominator = int(denominator // g) + + @classmethod + def from_float(cls, f): + """Converts a float to a rational number, exactly.""" + if not isinstance(f, float): + raise TypeError("%s.from_float() only takes floats, not %r (%s)" % + (cls.__name__, f, type(f).__name__)) + if math.isnan(f) or math.isinf(f): + raise TypeError("Cannot convert %r to %s." % (f, cls.__name__)) + return cls(*_binary_float_to_ratio(f)) + + @property + def numerator(a): + return a._numerator + + @property + def denominator(a): + return a._denominator + + def __repr__(self): + """repr(self)""" + return ('rational.Rational(%r,%r)' % + (self.numerator, self.denominator)) + + def __str__(self): + """str(self)""" + if self.denominator == 1: + return str(self.numerator) + else: + return '(%s/%s)' % (self.numerator, self.denominator) + + def _operator_fallbacks(monomorphic_operator, fallback_operator): + """Generates forward and reverse operators given a purely-rational + operator and a function from the operator module. + + Use this like: + __op__, __rop__ = _operator_fallbacks(just_rational_op, operator.op) + + """ + def forward(a, b): + if isinstance(b, RationalAbc): + # Includes ints. + return monomorphic_operator(a, b) + elif isinstance(b, float): + return fallback_operator(float(a), b) + elif isinstance(b, complex): + return fallback_operator(complex(a), b) + else: + return NotImplemented + forward.__name__ = '__' + fallback_operator.__name__ + '__' + forward.__doc__ = monomorphic_operator.__doc__ + + def reverse(b, a): + if isinstance(a, RationalAbc): + # Includes ints. + return monomorphic_operator(a, b) + elif isinstance(a, numbers.Real): + return fallback_operator(float(a), float(b)) + elif isinstance(a, numbers.Complex): + return fallback_operator(complex(a), complex(b)) + else: + return NotImplemented + reverse.__name__ = '__r' + fallback_operator.__name__ + '__' + reverse.__doc__ = monomorphic_operator.__doc__ + + return forward, reverse + + def _add(a, b): + """a + b""" + return Rational(a.numerator * b.denominator + + b.numerator * a.denominator, + a.denominator * b.denominator) + + __add__, __radd__ = _operator_fallbacks(_add, operator.add) + + def _sub(a, b): + """a - b""" + return Rational(a.numerator * b.denominator - + b.numerator * a.denominator, + a.denominator * b.denominator) + + __sub__, __rsub__ = _operator_fallbacks(_sub, operator.sub) + + def _mul(a, b): + """a * b""" + return Rational(a.numerator * b.numerator, a.denominator * b.denominator) + + __mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul) + + def _div(a, b): + """a / b""" + return Rational(a.numerator * b.denominator, + a.denominator * b.numerator) + + __truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv) + __div__, __rdiv__ = _operator_fallbacks(_div, operator.truediv) + + @classmethod + def _floordiv(cls, a, b): + div = a / b + if isinstance(div, RationalAbc): + # trunc(math.floor(div)) doesn't work if the rational is + # more precise than a float because the intermediate + # rounding may cross an integer boundary. + return div.numerator // div.denominator + else: + return math.floor(div) + + def __floordiv__(a, b): + """a // b""" + # Will be math.floor(a / b) in 3.0. + return a._floordiv(a, b) + + def __rfloordiv__(b, a): + """a // b""" + # Will be math.floor(a / b) in 3.0. + return b._floordiv(a, b) + + @classmethod + def _mod(cls, a, b): + div = a // b + return a - b * div + + def __mod__(a, b): + """a % b""" + return a._mod(a, b) + + def __rmod__(b, a): + """a % b""" + return b._mod(a, b) + + def __pow__(a, b): + """a ** b + + If b is not an integer, the result will be a float or complex + since roots are generally irrational. If b is an integer, the + result will be rational. + + """ + if isinstance(b, RationalAbc): + if b.denominator == 1: + power = b.numerator + if power >= 0: + return Rational(a.numerator ** power, + a.denominator ** power) + else: + return Rational(a.denominator ** -power, + a.numerator ** -power) + else: + # A fractional power will generally produce an + # irrational number. + return float(a) ** float(b) + else: + return float(a) ** b + + def __rpow__(b, a): + """a ** b""" + if b.denominator == 1 and b.numerator >= 0: + # If a is an int, keep it that way if possible. + return a ** b.numerator + + if isinstance(a, RationalAbc): + return Rational(a.numerator, a.denominator) ** b + + if b.denominator == 1: + return a ** b.numerator + + return a ** float(b) + + def __pos__(a): + """+a: Coerces a subclass instance to Rational""" + return Rational(a.numerator, a.denominator) + + def __neg__(a): + """-a""" + return Rational(-a.numerator, a.denominator) + + def __abs__(a): + """abs(a)""" + return Rational(abs(a.numerator), a.denominator) + + def __trunc__(a): + """trunc(a)""" + if a.numerator < 0: + return -(-a.numerator // a.denominator) + else: + return a.numerator // a.denominator + + def __floor__(a): + """Will be math.floor(a) in 3.0.""" + return a.numerator // a.denominator + + def __ceil__(a): + """Will be math.ceil(a) in 3.0.""" + # The negations cleverly convince floordiv to return the ceiling. + return -(-a.numerator // a.denominator) + + def __round__(self, ndigits=None): + """Will be round(self, ndigits) in 3.0. + + Rounds half toward even. + """ + if ndigits is None: + floor, remainder = divmod(self.numerator, self.denominator) + if remainder * 2 < self.denominator: + return floor + elif remainder * 2 > self.denominator: + return floor + 1 + # Deal with the half case: + elif floor % 2 == 0: + return floor + else: + return floor + 1 + shift = 10**abs(ndigits) + # See _operator_fallbacks.forward to check that the results of + # these operations will always be Rational and therefore have + # __round__(). + if ndigits > 0: + return Rational((self * shift).__round__(), shift) + else: + return Rational((self / shift).__round__() * shift) + + def __hash__(self): + """hash(self) + + Tricky because values that are exactly representable as a + float must have the same hash as that float. + + """ + if self.denominator == 1: + # Get integers right. + return hash(self.numerator) + # Expensive check, but definitely correct. + if self == float(self): + return hash(float(self)) + else: + # Use tuple's hash to avoid a high collision rate on + # simple fractions. + return hash((self.numerator, self.denominator)) + + def __eq__(a, b): + """a == b""" + if isinstance(b, RationalAbc): + return (a.numerator == b.numerator and + a.denominator == b.denominator) + if isinstance(b, numbers.Complex) and b.imag == 0: + b = b.real + if isinstance(b, float): + return a == a.from_float(b) + else: + # XXX: If b.__eq__ is implemented like this method, it may + # give the wrong answer after float(a) changes a's + # value. Better ways of doing this are welcome. + return float(a) == b + + def _subtractAndCompareToZero(a, b, op): + """Helper function for comparison operators. + + Subtracts b from a, exactly if possible, and compares the + result with 0 using op, in such a way that the comparison + won't recurse. If the difference raises a TypeError, returns + NotImplemented instead. + + """ + if isinstance(b, numbers.Complex) and b.imag == 0: + b = b.real + if isinstance(b, float): + b = a.from_float(b) + try: + # XXX: If b <: Real but not <: RationalAbc, this is likely + # to fall back to a float. If the actual values differ by + # less than MIN_FLOAT, this could falsely call them equal, + # which would make <= inconsistent with ==. Better ways of + # doing this are welcome. + diff = a - b + except TypeError: + return NotImplemented + if isinstance(diff, RationalAbc): + return op(diff.numerator, 0) + return op(diff, 0) + + def __lt__(a, b): + """a < b""" + return a._subtractAndCompareToZero(b, operator.lt) + + def __gt__(a, b): + """a > b""" + return a._subtractAndCompareToZero(b, operator.gt) + + def __le__(a, b): + """a <= b""" + return a._subtractAndCompareToZero(b, operator.le) + + def __ge__(a, b): + """a >= b""" + return a._subtractAndCompareToZero(b, operator.ge) + + def __bool__(a): + """a != 0""" + return a.numerator != 0 diff --git a/Lib/test/test_rational.py b/Lib/test/test_rational.py new file mode 100644 index 0000000..a8e1737 --- /dev/null +++ b/Lib/test/test_rational.py @@ -0,0 +1,283 @@ +"""Tests for Lib/rational.py.""" + +from decimal import Decimal +from test.test_support import run_unittest, verbose +import math +import operator +import rational +import unittest +R = rational.Rational + +def _components(r): + return (r.numerator, r.denominator) + +class RationalTest(unittest.TestCase): + + def assertTypedEquals(self, expected, actual): + """Asserts that both the types and values are the same.""" + self.assertEquals(type(expected), type(actual)) + self.assertEquals(expected, actual) + + def assertRaisesMessage(self, exc_type, message, + callable, *args, **kwargs): + """Asserts that callable(*args, **kwargs) raises exc_type(message).""" + try: + callable(*args, **kwargs) + except exc_type as e: + self.assertEquals(message, str(e)) + else: + self.fail("%s not raised" % exc_type.__name__) + + def testInit(self): + self.assertEquals((0, 1), _components(R())) + self.assertEquals((7, 1), _components(R(7))) + self.assertEquals((7, 3), _components(R(R(7, 3)))) + + self.assertEquals((-1, 1), _components(R(-1, 1))) + self.assertEquals((-1, 1), _components(R(1, -1))) + self.assertEquals((1, 1), _components(R(-2, -2))) + self.assertEquals((1, 2), _components(R(5, 10))) + self.assertEquals((7, 15), _components(R(7, 15))) + self.assertEquals((10**23, 1), _components(R(10**23))) + + self.assertRaisesMessage(ZeroDivisionError, "Rational(12, 0)", + R, 12, 0) + self.assertRaises(TypeError, R, 1.5) + self.assertRaises(TypeError, R, 1.5 + 3j) + + def testFromFloat(self): + self.assertRaisesMessage( + TypeError, "Rational.from_float() only takes floats, not 3 (int)", + R.from_float, 3) + + self.assertEquals((0, 1), _components(R.from_float(-0.0))) + self.assertEquals((10, 1), _components(R.from_float(10.0))) + self.assertEquals((-5, 2), _components(R.from_float(-2.5))) + self.assertEquals((99999999999999991611392, 1), + _components(R.from_float(1e23))) + self.assertEquals(float(10**23), float(R.from_float(1e23))) + self.assertEquals((3602879701896397, 1125899906842624), + _components(R.from_float(3.2))) + self.assertEquals(3.2, float(R.from_float(3.2))) + + inf = 1e1000 + nan = inf - inf + self.assertRaisesMessage( + TypeError, "Cannot convert inf to Rational.", + R.from_float, inf) + self.assertRaisesMessage( + TypeError, "Cannot convert -inf to Rational.", + R.from_float, -inf) + self.assertRaisesMessage( + TypeError, "Cannot convert nan to Rational.", + R.from_float, nan) + + def testConversions(self): + self.assertTypedEquals(-1, trunc(R(-11, 10))) + self.assertTypedEquals(-2, R(-11, 10).__floor__()) + self.assertTypedEquals(-1, R(-11, 10).__ceil__()) + self.assertTypedEquals(-1, R(-10, 10).__ceil__()) + + self.assertTypedEquals(0, R(-1, 10).__round__()) + self.assertTypedEquals(0, R(-5, 10).__round__()) + self.assertTypedEquals(-2, R(-15, 10).__round__()) + self.assertTypedEquals(-1, R(-7, 10).__round__()) + + self.assertEquals(False, bool(R(0, 1))) + self.assertEquals(True, bool(R(3, 2))) + self.assertTypedEquals(0.1, float(R(1, 10))) + + # Check that __float__ isn't implemented by converting the + # numerator and denominator to float before dividing. + self.assertRaises(OverflowError, float, int('2'*400+'7')) + self.assertAlmostEquals(2.0/3, + float(R(int('2'*400+'7'), int('3'*400+'1')))) + + self.assertTypedEquals(0.1+0j, complex(R(1,10))) + + def testRound(self): + self.assertTypedEquals(R(-200), R(-150).__round__(-2)) + self.assertTypedEquals(R(-200), R(-250).__round__(-2)) + self.assertTypedEquals(R(30), R(26).__round__(-1)) + self.assertTypedEquals(R(-2, 10), R(-15, 100).__round__(1)) + self.assertTypedEquals(R(-2, 10), R(-25, 100).__round__(1)) + + + def testArithmetic(self): + self.assertEquals(R(1, 2), R(1, 10) + R(2, 5)) + self.assertEquals(R(-3, 10), R(1, 10) - R(2, 5)) + self.assertEquals(R(1, 25), R(1, 10) * R(2, 5)) + self.assertEquals(R(1, 4), R(1, 10) / R(2, 5)) + self.assertTypedEquals(2, R(9, 10) // R(2, 5)) + self.assertTypedEquals(10**23, R(10**23, 1) // R(1)) + self.assertEquals(R(2, 3), R(-7, 3) % R(3, 2)) + self.assertEquals(R(8, 27), R(2, 3) ** R(3)) + self.assertEquals(R(27, 8), R(2, 3) ** R(-3)) + self.assertTypedEquals(2.0, R(4) ** R(1, 2)) + z = pow(R(-1), R(1, 2)) + self.assertAlmostEquals(z.real, 0) + self.assertEquals(z.imag, 1) + + def testMixedArithmetic(self): + self.assertTypedEquals(R(11, 10), R(1, 10) + 1) + self.assertTypedEquals(1.1, R(1, 10) + 1.0) + self.assertTypedEquals(1.1 + 0j, R(1, 10) + (1.0 + 0j)) + self.assertTypedEquals(R(11, 10), 1 + R(1, 10)) + self.assertTypedEquals(1.1, 1.0 + R(1, 10)) + self.assertTypedEquals(1.1 + 0j, (1.0 + 0j) + R(1, 10)) + + self.assertTypedEquals(R(-9, 10), R(1, 10) - 1) + self.assertTypedEquals(-0.9, R(1, 10) - 1.0) + self.assertTypedEquals(-0.9 + 0j, R(1, 10) - (1.0 + 0j)) + self.assertTypedEquals(R(9, 10), 1 - R(1, 10)) + self.assertTypedEquals(0.9, 1.0 - R(1, 10)) + self.assertTypedEquals(0.9 + 0j, (1.0 + 0j) - R(1, 10)) + + self.assertTypedEquals(R(1, 10), R(1, 10) * 1) + self.assertTypedEquals(0.1, R(1, 10) * 1.0) + self.assertTypedEquals(0.1 + 0j, R(1, 10) * (1.0 + 0j)) + self.assertTypedEquals(R(1, 10), 1 * R(1, 10)) + self.assertTypedEquals(0.1, 1.0 * R(1, 10)) + self.assertTypedEquals(0.1 + 0j, (1.0 + 0j) * R(1, 10)) + + self.assertTypedEquals(R(1, 10), R(1, 10) / 1) + self.assertTypedEquals(0.1, R(1, 10) / 1.0) + self.assertTypedEquals(0.1 + 0j, R(1, 10) / (1.0 + 0j)) + self.assertTypedEquals(R(10, 1), 1 / R(1, 10)) + self.assertTypedEquals(10.0, 1.0 / R(1, 10)) + self.assertTypedEquals(10.0 + 0j, (1.0 + 0j) / R(1, 10)) + + self.assertTypedEquals(0, R(1, 10) // 1) + # XXX Jeffrey: why does this fail? + ##self.assertTypedEquals(0.0, R(1, 10) // 1.0) + self.assertTypedEquals(10, 1 // R(1, 10)) + self.assertTypedEquals(10**23, 10**22 // R(1, 10)) + # XXX Jeffrey: why does this fail? + ##self.assertTypedEquals(10.0, 1.0 // R(1, 10)) + + self.assertTypedEquals(R(1, 10), R(1, 10) % 1) + self.assertTypedEquals(0.1, R(1, 10) % 1.0) + self.assertTypedEquals(R(0, 1), 1 % R(1, 10)) + self.assertTypedEquals(0.0, 1.0 % R(1, 10)) + + # No need for divmod since we don't override it. + + # ** has more interesting conversion rules. + self.assertTypedEquals(R(100, 1), R(1, 10) ** -2) + self.assertTypedEquals(R(100, 1), R(10, 1) ** 2) + self.assertTypedEquals(0.1, R(1, 10) ** 1.0) + self.assertTypedEquals(0.1 + 0j, R(1, 10) ** (1.0 + 0j)) + self.assertTypedEquals(4 , 2 ** R(2, 1)) + z = pow(-1, R(1, 2)) + self.assertAlmostEquals(0, z.real) + self.assertEquals(1, z.imag) + self.assertTypedEquals(R(1, 4) , 2 ** R(-2, 1)) + self.assertTypedEquals(2.0 , 4 ** R(1, 2)) + self.assertTypedEquals(0.25, 2.0 ** R(-2, 1)) + self.assertTypedEquals(1.0 + 0j, (1.0 + 0j) ** R(1, 10)) + + def testMixingWithDecimal(self): + """Decimal refuses mixed comparisons.""" + self.assertRaisesMessage( + TypeError, + "unsupported operand type(s) for +: 'Rational' and 'Decimal'", + operator.add, R(3,11), Decimal('3.1415926')) + self.assertNotEquals(R(5, 2), Decimal('2.5')) + + def testComparisons(self): + self.assertTrue(R(1, 2) < R(2, 3)) + self.assertFalse(R(1, 2) < R(1, 2)) + self.assertTrue(R(1, 2) <= R(2, 3)) + self.assertTrue(R(1, 2) <= R(1, 2)) + self.assertFalse(R(2, 3) <= R(1, 2)) + self.assertTrue(R(1, 2) == R(1, 2)) + self.assertFalse(R(1, 2) == R(1, 3)) + + def testMixedLess(self): + self.assertTrue(2 < R(5, 2)) + self.assertFalse(2 < R(4, 2)) + self.assertTrue(R(5, 2) < 3) + self.assertFalse(R(4, 2) < 2) + + self.assertTrue(R(1, 2) < 0.6) + self.assertFalse(R(1, 2) < 0.4) + self.assertTrue(0.4 < R(1, 2)) + self.assertFalse(0.5 < R(1, 2)) + + def testMixedLessEqual(self): + self.assertTrue(0.5 <= R(1, 2)) + self.assertFalse(0.6 <= R(1, 2)) + self.assertTrue(R(1, 2) <= 0.5) + self.assertFalse(R(1, 2) <= 0.4) + self.assertTrue(2 <= R(4, 2)) + self.assertFalse(2 <= R(3, 2)) + self.assertTrue(R(4, 2) <= 2) + self.assertFalse(R(5, 2) <= 2) + + def testBigFloatComparisons(self): + # 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)) + + def testBigComplexComparisons(self): + self.assertFalse(R(10**23) == complex(10**23)) + self.assertTrue(R(10**23) > complex(10**23)) + self.assertFalse(R(10**23) <= complex(10**23)) + + def testMixedEqual(self): + self.assertTrue(0.5 == R(1, 2)) + self.assertFalse(0.6 == R(1, 2)) + self.assertTrue(R(1, 2) == 0.5) + self.assertFalse(R(1, 2) == 0.4) + self.assertTrue(2 == R(4, 2)) + self.assertFalse(2 == R(3, 2)) + self.assertTrue(R(4, 2) == 2) + self.assertFalse(R(5, 2) == 2) + + def testStringification(self): + self.assertEquals("rational.Rational(7,3)", repr(R(7, 3))) + self.assertEquals("(7/3)", str(R(7, 3))) + self.assertEquals("7", str(R(7, 1))) + + def testHash(self): + self.assertEquals(hash(2.5), hash(R(5, 2))) + self.assertEquals(hash(10**50), hash(R(10**50))) + self.assertNotEquals(hash(float(10**23)), hash(R(10**23))) + + def testApproximatePi(self): + # Algorithm borrowed from + # http://docs.python.org/lib/decimal-recipes.html + three = R(3) + lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24 + while abs(s - lasts) > R(1, 10**9): + lasts = s + n, na = n+na, na+8 + d, da = d+da, da+32 + t = (t * n) / d + s += t + self.assertAlmostEquals(math.pi, s) + + def testApproximateCos1(self): + # Algorithm borrowed from + # http://docs.python.org/lib/decimal-recipes.html + x = R(1) + i, lasts, s, fact, num, sign = 0, 0, R(1), 1, 1, 1 + while abs(s - lasts) > R(1, 10**9): + lasts = s + i += 2 + fact *= i * (i-1) + num *= x * x + sign *= -1 + s += num / fact * sign + self.assertAlmostEquals(math.cos(1), s) + +def test_main(): + run_unittest(RationalTest) + +if __name__ == '__main__': + test_main() diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index 264544d..8979889 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -324,7 +324,7 @@ class SysModuleTest(unittest.TestCase): self.failUnless(sys.flags) attrs = ("debug", "division_warning", "inspect", "interactive", "optimize", "dont_write_bytecode", - "no_site", "ingnore_environment", "tabcheck", "verbose") + "no_site", "ignore_environment", "tabcheck", "verbose") for attr in attrs: self.assert_(hasattr(sys.flags, attr), attr) self.assertEqual(type(getattr(sys.flags, attr)), int, attr) diff --git a/Lib/zipfile.py b/Lib/zipfile.py index 2d308c3..9f98728 100644 --- a/Lib/zipfile.py +++ b/Lib/zipfile.py @@ -718,7 +718,7 @@ class ZipFile: print("%-46s %19s %12s" % ("File Name", "Modified ", "Size"), file=file) for zinfo in self.filelist: - date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time + date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6] print("%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size), file=file) @@ -975,7 +975,7 @@ class ZipFile: data = data.encode("utf-8") if not isinstance(zinfo_or_arcname, ZipInfo): zinfo = ZipInfo(filename=zinfo_or_arcname, - date_time=time.localtime(time.time())) + date_time=time.localtime(time.time())[:6]) zinfo.compress_type = self.compression else: zinfo = zinfo_or_arcname diff --git a/Modules/_ctypes/libffi/configure b/Modules/_ctypes/libffi/configure index bc7e474..935683b 100755 --- a/Modules/_ctypes/libffi/configure +++ b/Modules/_ctypes/libffi/configure @@ -934,7 +934,7 @@ esac else echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi - cd $ac_popdir + cd "$ac_popdir" done fi @@ -1973,8 +1973,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2032,8 +2031,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2149,8 +2147,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2204,8 +2201,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2250,8 +2246,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2295,8 +2290,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2623,8 +2617,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2794,8 +2787,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2862,8 +2854,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3047,8 +3038,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3111,8 +3101,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3290,8 +3279,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3408,8 +3396,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3529,7 +3516,7 @@ arm*-*-rtems*) TARGET=ARM; TARGETDIR=arm;; cris-*-*) TARGET=LIBFFI_CRIS; TARGETDIR=cris;; s390-*-linux-*) TARGET=S390; TARGETDIR=s390;; s390x-*-linux-*) TARGET=S390; TARGETDIR=s390;; -x86_64-*-linux* | x86_64-*-freebsd* | x86_64-*-kfreebsd*-gnu) TARGET=X86_64; TARGETDIR=x86;; +amd64-*-freebsd* | x86_64-*-linux* | x86_64-*-freebsd* | x86_64-*-kfreebsd*-gnu) TARGET=X86_64; TARGETDIR=x86;; sh-*-linux* | sh[34]*-*-linux*) TARGET=SH; TARGETDIR=sh;; sh-*-rtems*) TARGET=SH; TARGETDIR=sh;; sh64-*-linux* | sh5*-*-linux*) TARGET=SH64; TARGETDIR=sh64;; @@ -3582,8 +3569,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3784,8 +3770,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3848,8 +3833,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3930,8 +3914,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4072,8 +4055,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4209,8 +4191,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4272,8 +4253,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4313,8 +4293,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4370,8 +4349,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4411,8 +4389,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4476,8 +4453,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4508,10 +4484,8 @@ See \`config.log' for more details." >&2;} esac else if test "$cross_compiling" = yes; then - { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling -See \`config.log' for more details." >&5 -echo "$as_me: error: cannot run test program while cross compiling -See \`config.log' for more details." >&2;} + { { echo "$as_me:$LINENO: error: internal error: not reached in cross-compile" >&5 +echo "$as_me: error: internal error: not reached in cross-compile" >&2;} { (exit 1); exit 1; }; } else cat >conftest.$ac_ext <<_ACEOF @@ -4623,8 +4597,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4686,8 +4659,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4727,8 +4699,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4784,8 +4755,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4825,8 +4795,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4890,8 +4859,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4922,10 +4890,8 @@ See \`config.log' for more details." >&2;} esac else if test "$cross_compiling" = yes; then - { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling -See \`config.log' for more details." >&5 -echo "$as_me: error: cannot run test program while cross compiling -See \`config.log' for more details." >&2;} + { { echo "$as_me:$LINENO: error: internal error: not reached in cross-compile" >&5 +echo "$as_me: error: internal error: not reached in cross-compile" >&2;} { (exit 1); exit 1; }; } else cat >conftest.$ac_ext <<_ACEOF @@ -5047,8 +5013,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5109,8 +5074,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5172,8 +5136,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5213,8 +5176,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5270,8 +5232,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5311,8 +5272,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5376,8 +5336,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5408,10 +5367,8 @@ See \`config.log' for more details." >&2;} esac else if test "$cross_compiling" = yes; then - { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling -See \`config.log' for more details." >&5 -echo "$as_me: error: cannot run test program while cross compiling -See \`config.log' for more details." >&2;} + { { echo "$as_me:$LINENO: error: internal error: not reached in cross-compile" >&5 +echo "$as_me: error: internal error: not reached in cross-compile" >&2;} { (exit 1); exit 1; }; } else cat >conftest.$ac_ext <<_ACEOF @@ -5528,8 +5485,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5571,8 +5527,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5629,8 +5584,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5762,8 +5716,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5829,8 +5782,7 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" - || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6789,11 +6741,6 @@ esac - if test x"$ac_file" != x-; then - { echo "$as_me:$LINENO: creating $ac_file" >&5 -echo "$as_me: creating $ac_file" >&6;} - rm -f "$ac_file" - fi # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ @@ -6832,6 +6779,12 @@ echo "$as_me: error: cannot find input file: $f" >&2;} fi;; esac done` || { (exit 1); exit 1; } + + if test x"$ac_file" != x-; then + { echo "$as_me:$LINENO: creating $ac_file" >&5 +echo "$as_me: creating $ac_file" >&6;} + rm -f "$ac_file" + fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF sed "$ac_vpsub diff --git a/Modules/_ctypes/libffi/configure.ac b/Modules/_ctypes/libffi/configure.ac index 10b04dc..a790ba2 100644 --- a/Modules/_ctypes/libffi/configure.ac +++ b/Modules/_ctypes/libffi/configure.ac @@ -67,7 +67,7 @@ arm*-*-rtems*) TARGET=ARM; TARGETDIR=arm;; cris-*-*) TARGET=LIBFFI_CRIS; TARGETDIR=cris;; s390-*-linux-*) TARGET=S390; TARGETDIR=s390;; s390x-*-linux-*) TARGET=S390; TARGETDIR=s390;; -x86_64-*-linux* | x86_64-*-freebsd* | x86_64-*-kfreebsd*-gnu) TARGET=X86_64; TARGETDIR=x86;; +amd64-*-freebsd* | x86_64-*-linux* | x86_64-*-freebsd* | x86_64-*-kfreebsd*-gnu) TARGET=X86_64; TARGETDIR=x86;; sh-*-linux* | sh[[34]]*-*-linux*) TARGET=SH; TARGETDIR=sh;; sh-*-rtems*) TARGET=SH; TARGETDIR=sh;; sh64-*-linux* | sh5*-*-linux*) TARGET=SH64; TARGETDIR=sh64;; diff --git a/Python/sysmodule.c b/Python/sysmodule.c index d6c0427..ae06c30 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -1020,11 +1020,11 @@ static PyStructSequence_Field flags_fields[] = { {"dont_write_bytecode", "-B"}, /* {"no_user_site", "-s"}, */ {"no_site", "-S"}, - {"ingnore_environment", "-E"}, + {"ignore_environment", "-E"}, {"tabcheck", "-t or -tt"}, {"verbose", "-v"}, #ifdef RISCOS - {"ricos_wimp", "???"}, + {"riscos_wimp", "???"}, #endif /* {"unbuffered", "-u"}, */ /* {"skip_first", "-x"}, */ -- cgit v0.12