Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60789,60793,60796,60799-60809,60812-60813,60815-60821,60823-60826,60828-60829,60831-60834,60836,60838-60839,60846-60849,60852-60854,60856-60859,60861-60870,60874-60878,60880-60892,60894-60898 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r60876 | georg.brandl | 2008-02-17 16:14:10 +0100 (Sun, 17 Feb 2008) | 2 lines

  Fix function name.
........
  r60877 | facundo.batista | 2008-02-17 17:21:13 +0100 (Sun, 17 Feb 2008) | 4 lines


  Now we handle different the backup copy, because of security
  issues regarding user/group and permissions. Fixes 1050828.
........
  r60878 | facundo.batista | 2008-02-17 19:59:29 +0100 (Sun, 17 Feb 2008) | 4 lines


  Issue 2112. mmap does not raises EnvironmentError no more, but
  a subclass of it. Thanks John Lenton.
........
  r60882 | amaury.forgeotdarc | 2008-02-17 21:56:31 +0100 (Sun, 17 Feb 2008) | 5 lines

  Compilation was broken on Windows since the introduction of Advanced String Formatting.

  Only PCBuild (vs9) was really tested.
  Changes for older compilers were done manually.
........
  r60883 | georg.brandl | 2008-02-17 22:18:55 +0100 (Sun, 17 Feb 2008) | 2 lines

  #2133: fix HTML color spec.
........
  r60884 | facundo.batista | 2008-02-18 04:43:43 +0100 (Mon, 18 Feb 2008) | 5 lines


  Issue #1916. Added isgenerator() and isgeneratorfunction() to
  inspect.py.  Thanks Javi Mansilla for patch review and
  corrections.
........
  r60885 | facundo.batista | 2008-02-18 13:48:43 +0100 (Mon, 18 Feb 2008) | 4 lines


  Issue 1224. Now we support again the double slash in the URL.
  Thanks Anthony Lenton.
........
  r60887 | eric.smith | 2008-02-18 15:25:02 +0100 (Mon, 18 Feb 2008) | 1 line

  Temporarily removed float tests.  See issue 1600.
........
  r60891 | kristjan.jonsson | 2008-02-18 18:40:47 +0100 (Mon, 18 Feb 2008) | 1 line

  Perform correct handling of stack overflow for windows: Catch the correct exception code and reset the overflow condition when handled.
........

Doc/c-api/tuple.rst

@@ -106,6 +106,6 @@ Tuple Objects
    ``*p`` is destroyed.  On failure, returns ``-1`` and sets ``*p`` to *NULL*, and
    raises :exc:`MemoryError` or :exc:`SystemError`.
 
-.. cfunction:: int PyMethod_ClearFreeList(void)
+.. cfunction:: int PyTuple_ClearFreeList(void)
 
    Clear the free list. Return the total number of freed items.

Doc/library/inspect.rst

@@ -26,7 +26,7 @@ Types and members
 -----------------
 
 The :func:`getmembers` function retrieves the members of an object such as a
-class or module. The eleven functions whose names begin with "is" are mainly
+class or module. The fifteen functions whose names begin with "is" are mainly
 provided as convenient choices for the second argument to :func:`getmembers`.
 They also help you determine when you can expect to find the following special
 attributes:
@@ -229,6 +229,16 @@ attributes:
    Return true if the object is a Python function or unnamed (:term:`lambda`) function.
 
 
+.. function:: isgeneratorfunction(object)
+
+   Return true if the object is a Python generator function.
+
+
+.. function:: isgenerator(object)
+
+   Return true if the object is a generator.
+
+
 .. function:: istraceback(object)
 
    Return true if the object is a traceback.

Lib/SimpleHTTPServer.py

@@ -143,7 +143,8 @@ class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
 
         """
         # abandon query parameters
-        path = urlparse.urlparse(path)[2]
+        path = path.split('?',1)[0]
+        path = path.split('#',1)[0]
         path = posixpath.normpath(urllib.unquote(path))
         words = path.split('/')
         words = filter(None, words)

Lib/inspect.py

@@ -7,8 +7,9 @@ It also provides some help for examining source code and class layout.
 
 Here are some of the useful functions provided by this module:
 
-    ismodule(), isclass(), ismethod(), isfunction(), istraceback(),
+    ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
-        isframe(), iscode(), isbuiltin(), isroutine() - check object types
+        isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
+        isroutine() - check object types
     getmembers() - get members of an object that satisfy a given condition
 
     getfile(), getsourcefile(), getsource() - find an object's source code
@@ -29,9 +30,20 @@ Here are some of the useful functions provided by this module:
 __author__ = 'Ka-Ping Yee <ping@lfw.org>'
 __date__ = '1 Jan 2001'
 
-import sys, os, types, re, dis, imp, tokenize, linecache
+import sys
+import os
+import types
+import string
+import re
+import dis
+import imp
+import tokenize
+import linecache
 from operator import attrgetter
 from collections import namedtuple
+# These constants are from Include/code.h.
+CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 0x1, 0x2, 0x4, 0x8
+CO_NESTED, CO_GENERATOR, CO_NOFREE = 0x10, 0x20, 0x40
 
 # ----------------------------------------------------------- type-checking
 def ismodule(object):
@@ -137,6 +149,33 @@ def isfunction(object):
         __kwdefaults__  dict of keyword only parameters with defaults"""
     return isinstance(object, types.FunctionType)
 
+def isgeneratorfunction(object):
+    """Return true if the object is a user-defined generator function.
+
+    Generator function objects provides same attributes as functions.
+
+    See isfunction.__doc__ for attributes listing."""
+    if (isfunction(object) or ismethod(object)) and \
+        object.__code__.co_flags & CO_GENERATOR:
+        return True
+
+def isgenerator(object):
+    """Return true if the object is a generator.
+
+    Generator objects provide these attributes:
+        __iter__        defined to support interation over container
+        close           raises a new GeneratorExit exception inside the
+                        generator to terminate the iteration
+        gi_code         code object
+        gi_frame        frame object or possibly None once the generator has
+                        been exhausted
+        gi_running      set to 1 when generator is executing, 0 otherwise
+        next            return the next item from the container
+        send            resumes the generator and "sends" a value that becomes
+                        the result of the current yield-expression
+        throw           used to raise an exception inside the generator"""
+    return isinstance(object, types.GeneratorType)
+
 def istraceback(object):
     """Return true if the object is a traceback.
 
@@ -198,6 +237,10 @@ def isroutine(object):
             or ismethod(object)
             or ismethoddescriptor(object))
 
+def isgenerator(object):
+    """Return true if the object is a generator object."""
+    return isinstance(object, types.GeneratorType)
+
 def getmembers(object, predicate=None):
     """Return all members of an object as (name, value) pairs sorted by name.
     Optionally, only return members that satisfy a given predicate."""
@@ -670,9 +713,6 @@ def getclasstree(classes, unique=0):
     return walktree(roots, children, None)
 
 # ------------------------------------------------ argument list extraction
-# These constants are from Python's compile.h.
-CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 1, 2, 4, 8
-
 Arguments = namedtuple('Arguments', 'args, varargs, varkw')
 
 def getargs(co):

Lib/pydoc.py

@@ -660,7 +660,7 @@ class HTMLDoc(Doc):
             contents = self.multicolumn(
                 modules, lambda t: self.modulelink(t[1]))
             result = result + self.bigsection(
-                'Modules', '#fffff', '#aa55cc', contents)
+                'Modules', '#ffffff', '#aa55cc', contents)
 
         if classes:
             classlist = [value for (key, value) in classes]

Lib/test/test_SimpleHTTPServer.py

@@ -0,0 +1,41 @@
+"""
+These tests only check url parsing for now.
+We don't want to require the 'network' resource.
+"""
+
+import os, unittest
+from SimpleHTTPServer import SimpleHTTPRequestHandler
+from test import test_support
+
+
+class SocketlessRequestHandler (SimpleHTTPRequestHandler):
+    def __init__(self):
+        pass
+
+class SimpleHTTPRequestHandlerTestCase(unittest.TestCase):
+    """ Test url parsing """
+    def setUp (self):
+        self.translated = os.getcwd()
+        self.translated = os.path.join(self.translated, 'filename')
+        self.handler = SocketlessRequestHandler ()
+
+    def test_queryArguments (self):
+        path = self.handler.translate_path ('/filename')
+        self.assertEquals (path, self.translated)
+        path = self.handler.translate_path ('/filename?foo=bar')
+        self.assertEquals (path, self.translated)
+        path = self.handler.translate_path ('/filename?a=b&spam=eggs#zot')
+        self.assertEquals (path, self.translated)
+
+    def test_startWithDoubleSlash (self):
+        path = self.handler.translate_path ('//filename')
+        self.assertEquals (path, self.translated)
+        path = self.handler.translate_path ('//filename?foo=bar')
+        self.assertEquals (path, self.translated)
+
+
+def test_main():
+    test_support.run_unittest(SimpleHTTPRequestHandlerTestCase)
+
+if __name__ == "__main__":
+    test_main()

Lib/test/test_inspect.py

@@ -13,10 +13,10 @@ from test import inspect_fodder2 as mod2
 
 # Functions tested in this suite:
 # ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
-# isbuiltin, isroutine, getmembers, getdoc, getfile, getmodule,
+# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers,
-# getsourcefile, getcomments, getsource, getclasstree, getargspec,
+# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource,
-# getargvalues, formatargspec, formatargvalues, currentframe, stack, trace
+# getclasstree, getargspec, getargvalues, formatargspec, formatargvalues,
-# isdatadescriptor
+# currentframe, stack, trace, isdatadescriptor
 
 modfile = mod.__file__
 if modfile.endswith(('c', 'o')):
@@ -41,23 +41,33 @@ git = mod.StupidGit()
 class IsTestBase(unittest.TestCase):
     predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
                       inspect.isframe, inspect.isfunction, inspect.ismethod,
-                      inspect.ismodule, inspect.istraceback])
+                      inspect.ismodule, inspect.istraceback,
+                      inspect.isgenerator, inspect.isgeneratorfunction])
 
     def istest(self, predicate, exp):
         obj = eval(exp)
         self.failUnless(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
 
         for other in self.predicates - set([predicate]):
+            if predicate == inspect.isgeneratorfunction and\
+               other == inspect.isfunction:
+                continue
             self.failIf(other(obj), 'not %s(%s)' % (other.__name__, exp))
 
+def generator_function_example(self):
+    for i in range(2):
+        yield i
+
 class TestPredicates(IsTestBase):
-    def test_thirteen(self):
+    def test_fifteen(self):
         count = len([x for x in dir(inspect) if x.startswith('is')])
-        # Doc/lib/libinspect.tex claims there are 13 such functions
+        # This test is here for remember you to update Doc/library/inspect.rst
-        expected = 13
+        # which claims there are 15 such functions
+        expected = 15
         err_msg = "There are %d (not %d) is* functions" % (count, expected)
         self.assertEqual(count, expected, err_msg)
 
+
     def test_excluding_predicates(self):
         self.istest(inspect.isbuiltin, 'sys.exit')
         self.istest(inspect.isbuiltin, '[].append')
@@ -70,6 +80,8 @@ class TestPredicates(IsTestBase):
         self.istest(inspect.ismodule, 'mod')
         self.istest(inspect.istraceback, 'tb')
         self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory')
+        self.istest(inspect.isgenerator, '(x for x in range(2))')
+        self.istest(inspect.isgeneratorfunction, 'generator_function_example')
         if hasattr(types, 'GetSetDescriptorType'):
             self.istest(inspect.isgetsetdescriptor,
                         'type(tb.tb_frame).f_locals')

Lib/test/test_mmap.py

@@ -435,6 +435,11 @@ class MmapTests(unittest.TestCase):
         self.assertRaises(TypeError, m.write, "foo")
 
 
+    def test_error(self):
+        self.assert_(issubclass(mmap.error, EnvironmentError))
+        self.assert_("mmap.error" in str(mmap.error))
+
+
 def test_main():
     run_unittest(MmapTests)
 

Lib/test/test_types.py

@@ -63,15 +63,15 @@ class TypesTests(unittest.TestCase):
 
         try: 5 / 0
         except ZeroDivisionError: pass
-        else: self.fail("5 / 0L didn't raise ZeroDivisionError")
+        else: self.fail("5 / 0 didn't raise ZeroDivisionError")
 
         try: 5 // 0
         except ZeroDivisionError: pass
-        else: self.fail("5 // 0L didn't raise ZeroDivisionError")
+        else: self.fail("5 // 0 didn't raise ZeroDivisionError")
 
         try: 5 % 0
         except ZeroDivisionError: pass
-        else: self.fail("5 % 0L didn't raise ZeroDivisionError")
+        else: self.fail("5 % 0 didn't raise ZeroDivisionError")
 
     def test_numeric_types(self):
         if 0 != 0 or 0 != 0.0 or 0 != 0.0: self.fail('mixed comparisons')
@@ -80,7 +80,7 @@ class TypesTests(unittest.TestCase):
             self.fail('int/long/float value not equal')
         # calling built-in types without argument must return 0
         if int() != 0: self.fail('int() does not return 0')
-        if int() != 0: self.fail('long() does not return 0L')
+        if int() != 0: self.fail('long() does not return 0')
         if float() != 0.0: self.fail('float() does not return 0.0')
         if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
         else: self.fail('int() does not round properly')
@@ -203,6 +203,251 @@ class TypesTests(unittest.TestCase):
         self.assertRaises(TypeError, type, 1, 2)
         self.assertRaises(TypeError, type, 1, 2, 3, 4)
 
+    def test_int__format__(self):
+        def test(i, format_spec, result):
+            # just make sure I'm not accidentally checking longs
+            assert type(i) == int
+            assert type(format_spec) == str
+            self.assertEqual(i.__format__(format_spec), result)
+
+        test(123456789, 'd', '123456789')
+        test(123456789, 'd', '123456789')
+
+        test(1, 'c', '\01')
+
+        # sign and aligning are interdependent
+        test(1, "-", '1')
+        test(-1, "-", '-1')
+        test(1, "-3", '  1')
+        test(-1, "-3", ' -1')
+        test(1, "+3", ' +1')
+        test(-1, "+3", ' -1')
+        test(1, " 3", '  1')
+        test(-1, " 3", ' -1')
+        test(1, " ", ' 1')
+        test(-1, " ", '-1')
+
+        # hex
+        test(3, "x", "3")
+        test(3, "X", "3")
+        test(1234, "x", "4d2")
+        test(-1234, "x", "-4d2")
+        test(1234, "8x", "     4d2")
+        test(-1234, "8x", "    -4d2")
+        test(1234, "x", "4d2")
+        test(-1234, "x", "-4d2")
+        test(-3, "x", "-3")
+        test(-3, "X", "-3")
+        test(int('be', 16), "x", "be")
+        test(int('be', 16), "X", "BE")
+        test(-int('be', 16), "x", "-be")
+        test(-int('be', 16), "X", "-BE")
+
+        # octal
+        test(3, "o", "3")
+        test(-3, "o", "-3")
+        test(65, "o", "101")
+        test(-65, "o", "-101")
+        test(1234, "o", "2322")
+        test(-1234, "o", "-2322")
+        test(1234, "-o", "2322")
+        test(-1234, "-o", "-2322")
+        test(1234, " o", " 2322")
+        test(-1234, " o", "-2322")
+        test(1234, "+o", "+2322")
+        test(-1234, "+o", "-2322")
+
+        # binary
+        test(3, "b", "11")
+        test(-3, "b", "-11")
+        test(1234, "b", "10011010010")
+        test(-1234, "b", "-10011010010")
+        test(1234, "-b", "10011010010")
+        test(-1234, "-b", "-10011010010")
+        test(1234, " b", " 10011010010")
+        test(-1234, " b", "-10011010010")
+        test(1234, "+b", "+10011010010")
+        test(-1234, "+b", "-10011010010")
+
+        # make sure these are errors
+
+        # precision disallowed
+        self.assertRaises(ValueError, 3 .__format__, "1.3")
+        # sign not allowed with 'c'
+        self.assertRaises(ValueError, 3 .__format__, "+c")
+        # format spec must be string
+        self.assertRaises(TypeError, 3 .__format__, None)
+        self.assertRaises(TypeError, 3 .__format__, 0)
+
+        # ensure that only int and float type specifiers work
+        for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
+                            [chr(x) for x in range(ord('A'), ord('Z')+1)]):
+            if not format_spec in 'bcdoxXeEfFgGn%':
+                self.assertRaises(ValueError, 0 .__format__, format_spec)
+                self.assertRaises(ValueError, 1 .__format__, format_spec)
+                self.assertRaises(ValueError, (-1) .__format__, format_spec)
+
+        # ensure that float type specifiers work; format converts
+        #  the int to a float
+        for format_spec in 'eEfFgGn%':
+            for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
+                self.assertEqual(value.__format__(format_spec),
+                                 float(value).__format__(format_spec))
+
+    def test_long__format__(self):
+        def test(i, format_spec, result):
+            # make sure we're not accidentally checking ints
+            assert type(i) == int
+            assert type(format_spec) == str
+            self.assertEqual(i.__format__(format_spec), result)
+
+        test(10**100, 'd', '1' + '0' * 100)
+        test(10**100+100, 'd', '1' + '0' * 97 + '100')
+
+        test(123456789, 'd', '123456789')
+        test(123456789, 'd', '123456789')
+
+        # sign and aligning are interdependent
+        test(1, "-", '1')
+        test(-1, "-", '-1')
+        test(1, "-3", '  1')
+        test(-1, "-3", ' -1')
+        test(1, "+3", ' +1')
+        test(-1, "+3", ' -1')
+        test(1, " 3", '  1')
+        test(-1, " 3", ' -1')
+        test(1, " ", ' 1')
+        test(-1, " ", '-1')
+
+        test(1, 'c', '\01')
+
+        # hex
+        test(3, "x", "3")
+        test(3, "X", "3")
+        test(1234, "x", "4d2")
+        test(-1234, "x", "-4d2")
+        test(1234, "8x", "     4d2")
+        test(-1234, "8x", "    -4d2")
+        test(1234, "x", "4d2")
+        test(-1234, "x", "-4d2")
+        test(-3, "x", "-3")
+        test(-3, "X", "-3")
+
+        # octal
+        test(3, "o", "3")
+        test(-3, "o", "-3")
+        test(65, "o", "101")
+        test(-65, "o", "-101")
+        test(1234, "o", "2322")
+        test(-1234, "o", "-2322")
+        test(1234, "-o", "2322")
+        test(-1234, "-o", "-2322")
+        test(1234, " o", " 2322")
+        test(-1234, " o", "-2322")
+        test(1234, "+o", "+2322")
+        test(-1234, "+o", "-2322")
+
+        # binary
+        test(3, "b", "11")
+        test(-3, "b", "-11")
+        test(1234, "b", "10011010010")
+        test(-1234, "b", "-10011010010")
+        test(1234, "-b", "10011010010")
+        test(-1234, "-b", "-10011010010")
+        test(1234, " b", " 10011010010")
+        test(-1234, " b", "-10011010010")
+        test(1234, "+b", "+10011010010")
+        test(-1234, "+b", "-10011010010")
+
+        # make sure these are errors
+
+        # precision disallowed
+        self.assertRaises(ValueError, 3 .__format__, "1.3")
+        # sign not allowed with 'c'
+        self.assertRaises(ValueError, 3 .__format__, "+c")
+        # format spec must be string
+        self.assertRaises(TypeError, 3 .__format__, None)
+        self.assertRaises(TypeError, 3 .__format__, 0)
+
+        # ensure that only int and float type specifiers work
+        for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
+                            [chr(x) for x in range(ord('A'), ord('Z')+1)]):
+            if not format_spec in 'bcdoxXeEfFgGn%':
+                self.assertRaises(ValueError, 0 .__format__, format_spec)
+                self.assertRaises(ValueError, 1 .__format__, format_spec)
+                self.assertRaises(ValueError, (-1) .__format__, format_spec)
+
+        # ensure that float type specifiers work; format converts
+        #  the long to a float
+        for format_spec in 'eEfFgGn%':
+            for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
+                self.assertEqual(value.__format__(format_spec),
+                                 float(value).__format__(format_spec))
+
+    def test_float__format__(self):
+        # these should be rewritten to use both format(x, spec) and
+        # x.__format__(spec)
+
+        def test(f, format_spec, result):
+            assert type(f) == float
+            assert type(format_spec) == str
+            self.assertEqual(f.__format__(format_spec), result)
+
+        test(0.0, 'f', '0.000000')
+
+        # the default is 'g', except for empty format spec
+        test(0.0, '', '0.0')
+        test(0.01, '', '0.01')
+        test(0.01, 'g', '0.01')
+
+        test( 1.0, ' g', ' 1')
+        test(-1.0, ' g', '-1')
+        test( 1.0, '+g', '+1')
+        test(-1.0, '+g', '-1')
+        test(1.1234e200, 'g', '1.1234e+200')
+        test(1.1234e200, 'G', '1.1234E+200')
+
+
+        test(1.0, 'f', '1.000000')
+
+        test(-1.0, 'f', '-1.000000')
+
+        test( 1.0, ' f', ' 1.000000')
+        test(-1.0, ' f', '-1.000000')
+        test( 1.0, '+f', '+1.000000')
+        test(-1.0, '+f', '-1.000000')
+        test(1.1234e200, 'f', '1.1234e+200')
+        test(1.1234e200, 'F', '1.1234e+200')
+
+        # temporarily removed.  see issue 1600
+ #       test( 1.0, 'e', '1.000000e+00')
+ #       test(-1.0, 'e', '-1.000000e+00')
+ #       test( 1.0, 'E', '1.000000E+00')
+ #       test(-1.0, 'E', '-1.000000E+00')
+ #       test(1.1234e20, 'e', '1.123400e+20')
+ #       test(1.1234e20, 'E', '1.123400E+20')
+
+        # % formatting
+        test(-1.0, '%', '-100.000000%')
+
+        # format spec must be string
+        self.assertRaises(TypeError, 3.0.__format__, None)
+        self.assertRaises(TypeError, 3.0.__format__, 0)
+
+        # other format specifiers shouldn't work on floats,
+        #  in particular int specifiers
+        for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
+                            [chr(x) for x in range(ord('A'), ord('Z')+1)]):
+            if not format_spec in 'eEfFgGn%':
+                self.assertRaises(ValueError, format, 0.0, format_spec)
+                self.assertRaises(ValueError, format, 1.0, format_spec)
+                self.assertRaises(ValueError, format, -1.0, format_spec)
+                self.assertRaises(ValueError, format, 1e100, format_spec)
+                self.assertRaises(ValueError, format, -1e100, format_spec)
+                self.assertRaises(ValueError, format, 1e-100, format_spec)
+                self.assertRaises(ValueError, format, -1e-100, format_spec)
+
+
 def test_main():
     run_unittest(TypesTests)
 

Modules/mmapmodule.c

@@ -1326,7 +1326,10 @@ initmmap(void)
 	dict = PyModule_GetDict(module);
 	if (!dict)
 		return;
-	mmap_module_error = PyExc_EnvironmentError;
+	mmap_module_error = PyErr_NewException("mmap.error",
+		PyExc_EnvironmentError , NULL);
+	if (mmap_module_error == NULL)
+		return;
 	PyDict_SetItemString(dict, "error", mmap_module_error);
 	PyDict_SetItemString(dict, "mmap", (PyObject*) &mmap_object_type);
 #ifdef PROT_EXEC

PC/VC6/pythoncore.dsp

@@ -125,6 +125,10 @@ SOURCE=..\..\Modules\_codecsmodule.c
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\Modules\_collectionsmodule.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\Modules\_csv.c
 # End Source File
 # Begin Source File
@@ -349,6 +353,14 @@ SOURCE=..\..\Objects\floatobject.c
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\Python\formatter_string.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Python\formatter_unicode.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\Objects\frameobject.c
 # End Source File
 # Begin Source File

PC/VS7.1/pythoncore.vcproj

@@ -514,6 +514,9 @@
 		<File
 			RelativePath="..\..\Objects\floatobject.c">
 		</File>
+		<File
+			RelativePath="..\..\Python\formatter_unicode.c">
+		</File>
 		<File
 			RelativePath="..\..\Objects\frameobject.c">
 		</File>

Python/pythonrun.c

@@ -1899,8 +1899,14 @@ PyOS_CheckStack(void)
 		   not enough space left on the stack */
 		alloca(PYOS_STACK_MARGIN * sizeof(void*));
 		return 0;
-	} __except (EXCEPTION_EXECUTE_HANDLER) {
+	} __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
-		/* just ignore all errors */
+		        EXCEPTION_EXECUTE_HANDLER : 
+		        EXCEPTION_CONTINUE_SEARCH) {
+		int errcode = _resetstkoflw();
+		if (errcode)
+		{
+			Py_FatalError("Could not reset the stack!");
+		}
 	}
 	return 1;
 }

Tools/scripts/reindent.py

@@ -4,10 +4,11 @@
 
 """reindent [-d][-r][-v] [ path ... ]
 
--d (--dryrun)  Dry run.  Analyze, but don't make any changes to, files.
+-d (--dryrun)   Dry run.   Analyze, but don't make any changes to, files.
--r (--recurse) Recurse.  Search for all .py files in subdirectories too.
+-r (--recurse)  Recurse.   Search for all .py files in subdirectories too.
--v (--verbose) Verbose.  Print informative msgs; else no output.
+-n (--nobackup) No backup. Does not make a ".bak" file before reindenting.
--h (--help)    Help.     Print this usage information and exit.
+-v (--verbose)  Verbose.   Print informative msgs; else no output.
+-h (--help)     Help.      Print this usage information and exit.
 
 Change Python (.py) files to use 4-space indents and no hard tab characters.
 Also trim excess spaces and tabs from ends of lines, and remove empty lines
@@ -31,17 +32,23 @@ resulting .py file won't change it again).
 The hard part of reindenting is figuring out what to do with comment
 lines.  So long as the input files get a clean bill of health from
 tabnanny.py, reindent should do a good job.
+
+The backup file is a copy of the one that is being reindented. The ".bak"
+file is generated with shutil.copy(), but some corner cases regarding
+user/group and permissions could leave the backup file more readable that
+you'd prefer. You can always use the --nobackup option to prevent this.
 """
 
 __version__ = "1"
 
 import tokenize
-import os
+import os, shutil
 import sys
 
-verbose = 0
+verbose    = 0
-recurse = 0
+recurse    = 0
-dryrun  = 0
+dryrun     = 0
+makebackup = True
 
 def usage(msg=None):
     if msg is not None:
@@ -57,10 +64,10 @@ def errprint(*args):
 
 def main():
     import getopt
-    global verbose, recurse, dryrun
+    global verbose, recurse, dryrun, makebackup
     try:
-        opts, args = getopt.getopt(sys.argv[1:], "drvh",
+        opts, args = getopt.getopt(sys.argv[1:], "drnvh",
-                                   ["dryrun", "recurse", "verbose", "help"])
+                        ["dryrun", "recurse", "nobackup", "verbose", "help"])
     except getopt.error as msg:
         usage(msg)
         return
@@ -69,6 +76,8 @@ def main():
             dryrun += 1
         elif o in ('-r', '--recurse'):
             recurse += 1
+        elif o in ('-n', '--nobackup'):
+            makebackup = False
         elif o in ('-v', '--verbose'):
             verbose += 1
         elif o in ('-h', '--help'):
@@ -112,11 +121,10 @@ def check(file):
                 print("But this is a dry run, so leaving it alone.")
         if not dryrun:
             bak = file + ".bak"
-            if os.path.exists(bak):
+            if makebackup:
-                os.remove(bak)
+                shutil.copyfile(file, bak)
-            os.rename(file, bak)
+                if verbose:
-            if verbose:
+                    print("backed up", file, "to", bak)
-                print("renamed", file, "to", bak)
             f = open(file, "w")
             r.write(f)
             f.close()