[Python-3000-checkins] r55167 - in python/branches/p3yk: Demo/tix/grid.py Doc/lib/libdbhash.tex Doc/lib/libfuncs.tex Doc/lib/libitertools.tex Doc/lib/librandom.tex Doc/lib/libstdtypes.tex Doc/lib/libtimeit.tex Doc/lib/libtypes.tex Doc/tut/tut.tex Lib/Cookie.py Lib/bsddb/test/test_thread.py Lib/calendar.py Lib/copy.py Lib/ctypes/test/test_arrays.py Lib/ctypes/test/test_slicing.py Lib/difflib.py Lib/distutils/command/install.py Lib/doctest.py Lib/genericpath.py Lib/gettext.py Lib/heapq.py Lib/hmac.py Lib/idlelib/CodeContext.py Lib/mhlib.py Lib/pickle.py Lib/plat-mac/EasyDialogs.py Lib/plat-mac/applesingle.py Lib/plat-riscos/riscospath.py Lib/popen2.py Lib/pydoc.py Lib/random.py Lib/sqlite3/test/regression.py Lib/sre_compile.py Lib/string.py Lib/stringprep.py Lib/subprocess.py Lib/tarfile.py Lib/tempfile.py Lib/test/fork_wait.py Lib/test/list_tests.py Lib/test/output/test_cProfile Lib/test/output/test_profile Lib/test/pickletester.py Lib/test/seq_tests.py Lib/test/sortperf.py Lib/test/string_tests.py Lib/test/test_array.py Lib/test/test_binascii.py Lib/test/test_bisect.py Lib/test/test_bsddb.py Lib/test/test_bufio.py Lib/test/test_builtin.py Lib/test/test_bz2.py Lib/test/test_calendar.py Lib/test/test_codeccallbacks.py Lib/test/test_codecs.py Lib/test/test_compile.py Lib/test/test_complex.py Lib/test/test_contains.py Lib/test/test_copy.py Lib/test/test_csv.py Lib/test/test_datetime.py Lib/test/test_decimal.py Lib/test/test_deque.py Lib/test/test_descr.py Lib/test/test_dis.py Lib/test/test_doctest.py Lib/test/test_dummy_thread.py Lib/test/test_enumerate.py Lib/test/test_functools.py Lib/test/test_gc.py Lib/test/test_generators.py Lib/test/test_genexps.py Lib/test/test_grp.py Lib/test/test_heapq.py Lib/test/test_index.py Lib/test/test_io.py Lib/test/test_isinstance.py Lib/test/test_iter.py Lib/test/test_iterlen.py Lib/test/test_itertools.py Lib/test/test_list.py Lib/test/test_listcomps.py Lib/test/test_logging.py Lib/test/test_long.py Lib/test/test_mailbox.py Lib/test/test_mhlib.py Lib/test/test_mimetools.py Lib/test/test_mmap.py Lib/test/test_multibytecodec.py Lib/test/test_multibytecodec_support.py Lib/test/test_mutants.py Lib/test/test_operator.py Lib/test/test_peepholer.py Lib/test/test_pep352.py Lib/test/test_pow.py Lib/test/test_pprint.py Lib/test/test_pwd.py Lib/test/test_queue.py Lib/test/test_random.py Lib/test/test_repr.py Lib/test/test_richcmp.py Lib/test/test_set.py Lib/test/test_setcomps.py Lib/test/test_slice.py Lib/test/test_sort.py Lib/test/test_struct.py Lib/test/test_structseq.py Lib/test/test_tempfile.py Lib/test/test_trace.py Lib/test/test_tuple.py Lib/test/test_ucn.py Lib/test/test_unicode.py Lib/test/test_unicodedata.py Lib/test/test_userdict.py Lib/test/test_userlist.py Lib/test/test_winsound.py Lib/test/test_xdrlib.py Lib/test/test_xrange.py Lib/test/test_zipfile.py Lib/test/test_zipfile64.py Lib/test/time_hashlib.py Lib/types.py Lib/urllib.py Misc/NEWS Objects/rangeobject.c Parser/spark.py Python/bltinmodule.c Tools/pybench/Arithmetic.py Tools/pybench/Calls.py Tools/pybench/Constructs.py Tools/pybench/Dict.py Tools/pybench/Exceptions.py Tools/pybench/Imports.py Tools/pybench/Instances.py Tools/pybench/Lists.py Tools/pybench/Lookups.py Tools/pybench/NewInstances.py Tools/pybench/Numbers.py Tools/pybench/Strings.py Tools/pybench/Tuples.py Tools/pybench/Unicode.py Tools/pybench/systimes.py Tools/scripts/reindent.py Tools/unicode/makeunicodedata.py Tools/unicode/mkstringprep.py

neal.norwitz python-3000-checkins at python.org
Mon May 7 10:03:40 CEST 2007


Author: neal.norwitz
Date: Mon May  7 10:03:22 2007
New Revision: 55167

Modified:
   python/branches/p3yk/Demo/tix/grid.py
   python/branches/p3yk/Doc/lib/libdbhash.tex
   python/branches/p3yk/Doc/lib/libfuncs.tex
   python/branches/p3yk/Doc/lib/libitertools.tex
   python/branches/p3yk/Doc/lib/librandom.tex
   python/branches/p3yk/Doc/lib/libstdtypes.tex
   python/branches/p3yk/Doc/lib/libtimeit.tex
   python/branches/p3yk/Doc/lib/libtypes.tex
   python/branches/p3yk/Doc/tut/tut.tex
   python/branches/p3yk/Lib/Cookie.py
   python/branches/p3yk/Lib/bsddb/test/test_thread.py
   python/branches/p3yk/Lib/calendar.py
   python/branches/p3yk/Lib/copy.py
   python/branches/p3yk/Lib/ctypes/test/test_arrays.py
   python/branches/p3yk/Lib/ctypes/test/test_slicing.py
   python/branches/p3yk/Lib/difflib.py
   python/branches/p3yk/Lib/distutils/command/install.py
   python/branches/p3yk/Lib/doctest.py
   python/branches/p3yk/Lib/genericpath.py
   python/branches/p3yk/Lib/gettext.py
   python/branches/p3yk/Lib/heapq.py
   python/branches/p3yk/Lib/hmac.py
   python/branches/p3yk/Lib/idlelib/CodeContext.py
   python/branches/p3yk/Lib/mhlib.py
   python/branches/p3yk/Lib/pickle.py
   python/branches/p3yk/Lib/plat-mac/EasyDialogs.py
   python/branches/p3yk/Lib/plat-mac/applesingle.py
   python/branches/p3yk/Lib/plat-riscos/riscospath.py
   python/branches/p3yk/Lib/popen2.py
   python/branches/p3yk/Lib/pydoc.py
   python/branches/p3yk/Lib/random.py
   python/branches/p3yk/Lib/sqlite3/test/regression.py
   python/branches/p3yk/Lib/sre_compile.py
   python/branches/p3yk/Lib/string.py
   python/branches/p3yk/Lib/stringprep.py
   python/branches/p3yk/Lib/subprocess.py
   python/branches/p3yk/Lib/tarfile.py
   python/branches/p3yk/Lib/tempfile.py
   python/branches/p3yk/Lib/test/fork_wait.py
   python/branches/p3yk/Lib/test/list_tests.py
   python/branches/p3yk/Lib/test/output/test_cProfile
   python/branches/p3yk/Lib/test/output/test_profile
   python/branches/p3yk/Lib/test/pickletester.py
   python/branches/p3yk/Lib/test/seq_tests.py
   python/branches/p3yk/Lib/test/sortperf.py
   python/branches/p3yk/Lib/test/string_tests.py
   python/branches/p3yk/Lib/test/test_array.py
   python/branches/p3yk/Lib/test/test_binascii.py
   python/branches/p3yk/Lib/test/test_bisect.py
   python/branches/p3yk/Lib/test/test_bsddb.py
   python/branches/p3yk/Lib/test/test_bufio.py
   python/branches/p3yk/Lib/test/test_builtin.py
   python/branches/p3yk/Lib/test/test_bz2.py
   python/branches/p3yk/Lib/test/test_calendar.py
   python/branches/p3yk/Lib/test/test_codeccallbacks.py
   python/branches/p3yk/Lib/test/test_codecs.py
   python/branches/p3yk/Lib/test/test_compile.py
   python/branches/p3yk/Lib/test/test_complex.py
   python/branches/p3yk/Lib/test/test_contains.py
   python/branches/p3yk/Lib/test/test_copy.py
   python/branches/p3yk/Lib/test/test_csv.py
   python/branches/p3yk/Lib/test/test_datetime.py
   python/branches/p3yk/Lib/test/test_decimal.py
   python/branches/p3yk/Lib/test/test_deque.py
   python/branches/p3yk/Lib/test/test_descr.py
   python/branches/p3yk/Lib/test/test_dis.py
   python/branches/p3yk/Lib/test/test_doctest.py
   python/branches/p3yk/Lib/test/test_dummy_thread.py
   python/branches/p3yk/Lib/test/test_enumerate.py
   python/branches/p3yk/Lib/test/test_functools.py
   python/branches/p3yk/Lib/test/test_gc.py
   python/branches/p3yk/Lib/test/test_generators.py
   python/branches/p3yk/Lib/test/test_genexps.py
   python/branches/p3yk/Lib/test/test_grp.py
   python/branches/p3yk/Lib/test/test_heapq.py
   python/branches/p3yk/Lib/test/test_index.py
   python/branches/p3yk/Lib/test/test_io.py
   python/branches/p3yk/Lib/test/test_isinstance.py
   python/branches/p3yk/Lib/test/test_iter.py
   python/branches/p3yk/Lib/test/test_iterlen.py
   python/branches/p3yk/Lib/test/test_itertools.py
   python/branches/p3yk/Lib/test/test_list.py
   python/branches/p3yk/Lib/test/test_listcomps.py
   python/branches/p3yk/Lib/test/test_logging.py
   python/branches/p3yk/Lib/test/test_long.py
   python/branches/p3yk/Lib/test/test_mailbox.py
   python/branches/p3yk/Lib/test/test_mhlib.py
   python/branches/p3yk/Lib/test/test_mimetools.py
   python/branches/p3yk/Lib/test/test_mmap.py
   python/branches/p3yk/Lib/test/test_multibytecodec.py
   python/branches/p3yk/Lib/test/test_multibytecodec_support.py
   python/branches/p3yk/Lib/test/test_mutants.py
   python/branches/p3yk/Lib/test/test_operator.py
   python/branches/p3yk/Lib/test/test_peepholer.py
   python/branches/p3yk/Lib/test/test_pep352.py
   python/branches/p3yk/Lib/test/test_pow.py
   python/branches/p3yk/Lib/test/test_pprint.py
   python/branches/p3yk/Lib/test/test_pwd.py
   python/branches/p3yk/Lib/test/test_queue.py
   python/branches/p3yk/Lib/test/test_random.py
   python/branches/p3yk/Lib/test/test_repr.py
   python/branches/p3yk/Lib/test/test_richcmp.py
   python/branches/p3yk/Lib/test/test_set.py
   python/branches/p3yk/Lib/test/test_setcomps.py
   python/branches/p3yk/Lib/test/test_slice.py
   python/branches/p3yk/Lib/test/test_sort.py
   python/branches/p3yk/Lib/test/test_struct.py
   python/branches/p3yk/Lib/test/test_structseq.py
   python/branches/p3yk/Lib/test/test_tempfile.py
   python/branches/p3yk/Lib/test/test_trace.py
   python/branches/p3yk/Lib/test/test_tuple.py
   python/branches/p3yk/Lib/test/test_ucn.py
   python/branches/p3yk/Lib/test/test_unicode.py
   python/branches/p3yk/Lib/test/test_unicodedata.py
   python/branches/p3yk/Lib/test/test_userdict.py
   python/branches/p3yk/Lib/test/test_userlist.py
   python/branches/p3yk/Lib/test/test_winsound.py
   python/branches/p3yk/Lib/test/test_xdrlib.py
   python/branches/p3yk/Lib/test/test_xrange.py
   python/branches/p3yk/Lib/test/test_zipfile.py
   python/branches/p3yk/Lib/test/test_zipfile64.py
   python/branches/p3yk/Lib/test/time_hashlib.py
   python/branches/p3yk/Lib/types.py
   python/branches/p3yk/Lib/urllib.py
   python/branches/p3yk/Misc/NEWS
   python/branches/p3yk/Objects/rangeobject.c
   python/branches/p3yk/Parser/spark.py
   python/branches/p3yk/Python/bltinmodule.c
   python/branches/p3yk/Tools/pybench/Arithmetic.py
   python/branches/p3yk/Tools/pybench/Calls.py
   python/branches/p3yk/Tools/pybench/Constructs.py
   python/branches/p3yk/Tools/pybench/Dict.py
   python/branches/p3yk/Tools/pybench/Exceptions.py
   python/branches/p3yk/Tools/pybench/Imports.py
   python/branches/p3yk/Tools/pybench/Instances.py
   python/branches/p3yk/Tools/pybench/Lists.py
   python/branches/p3yk/Tools/pybench/Lookups.py
   python/branches/p3yk/Tools/pybench/NewInstances.py
   python/branches/p3yk/Tools/pybench/Numbers.py
   python/branches/p3yk/Tools/pybench/Strings.py
   python/branches/p3yk/Tools/pybench/Tuples.py
   python/branches/p3yk/Tools/pybench/Unicode.py
   python/branches/p3yk/Tools/pybench/systimes.py
   python/branches/p3yk/Tools/scripts/reindent.py
   python/branches/p3yk/Tools/unicode/makeunicodedata.py
   python/branches/p3yk/Tools/unicode/mkstringprep.py
Log:
So long xrange.  range() now supports values that are outside
-sys.maxint to sys.maxint.  floats raise a TypeError.

This has been sitting for a long time.  It probably has some problems and
needs cleanup.  Objects/rangeobject.c now uses 4-space indents since
it is almost completely new.



Modified: python/branches/p3yk/Demo/tix/grid.py
==============================================================================
--- python/branches/p3yk/Demo/tix/grid.py	(original)
+++ python/branches/p3yk/Demo/tix/grid.py	Mon May  7 10:03:22 2007
@@ -18,8 +18,8 @@
 g = MyGrid(r, name="a_grid",
 selectunit="cell")
 g.pack(fill=tk.BOTH)
-for x in xrange(5):
-    for y in xrange(5):
+for x in range(5):
+    for y in range(5):
         g.set(x,y,text=str((x,y)))
 
 c = tk.Button(r, text="Close", command=r.destroy)

Modified: python/branches/p3yk/Doc/lib/libdbhash.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libdbhash.tex	(original)
+++ python/branches/p3yk/Doc/lib/libdbhash.tex	Mon May  7 10:03:22 2007
@@ -72,7 +72,7 @@
 
 \begin{verbatim}
 print db.first()
-for i in xrange(1, len(db)):
+for i in range(1, len(db)):
     print db.next()
 \end{verbatim}
 \end{methoddesc}

Modified: python/branches/p3yk/Doc/lib/libfuncs.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libfuncs.tex	(original)
+++ python/branches/p3yk/Doc/lib/libfuncs.tex	Mon May  7 10:03:22 2007
@@ -868,7 +868,7 @@
 \end{funcdesc}
 
 \begin{funcdesc}{range}{\optional{start,} stop\optional{, step}}
-  This is a versatile function to create lists containing arithmetic
+  This is a versatile function to create sequences containing arithmetic
   progressions.  It is most often used in \keyword{for} loops.  The
   arguments must be plain integers.  If the \var{step} argument is
   omitted, it defaults to \code{1}.  If the \var{start} argument is
@@ -882,19 +882,19 @@
   \exception{ValueError} is raised).  Example:
 
 \begin{verbatim}
->>> range(10)
+>>> list(range(10))
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
->>> range(1, 11)
+>>> list(range(1, 11))
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
->>> range(0, 30, 5)
+>>> list(range(0, 30, 5))
 [0, 5, 10, 15, 20, 25]
->>> range(0, 10, 3)
+>>> list(range(0, 10, 3))
 [0, 3, 6, 9]
->>> range(0, -10, -1)
+>>> list(range(0, -10, -1))
 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
->>> range(0)
+>>> list(range(0))
 []
->>> range(1, 0)
+>>> list(range(1, 0))
 []
 \end{verbatim}
 \end{funcdesc}
@@ -1230,24 +1230,6 @@
     other scopes (such as modules) can be.  This may change.}
 \end{funcdesc}
 
-\begin{funcdesc}{xrange}{\optional{start,} stop\optional{, step}}
-  This function is very similar to \function{range()}, but returns an
-  ``xrange object'' instead of a list.  This is an opaque sequence
-  type which yields the same values as the corresponding list, without
-  actually storing them all simultaneously.  The advantage of
-  \function{xrange()} over \function{range()} is minimal (since
-  \function{xrange()} still has to create the values when asked for
-  them) except when a very large range is used on a memory-starved
-  machine or when all of the range's elements are never used (such as
-  when the loop is usually terminated with \keyword{break}).
-
-  \note{\function{xrange()} is intended to be simple and fast.
-        Implementations may impose restrictions to achieve this.
-        The C implementation of Python restricts all arguments to
-        native C longs ("short" Python integers), and also requires
-        that the number of elements fit in a native C long.}
-\end{funcdesc}
-
 \begin{funcdesc}{zip}{\optional{iterable, \moreargs}}
   This function returns a list of tuples, where the \var{i}-th tuple contains
   the \var{i}-th element from each of the argument sequences or iterables.

Modified: python/branches/p3yk/Doc/lib/libitertools.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libitertools.tex	(original)
+++ python/branches/p3yk/Doc/lib/libitertools.tex	Mon May  7 10:03:22 2007
@@ -161,7 +161,7 @@
                 key = lambda x: x
             self.keyfunc = key
             self.it = iter(iterable)
-            self.tgtkey = self.currkey = self.currvalue = xrange(0)
+            self.tgtkey = self.currkey = self.currvalue = []
         def __iter__(self):
             return self
         def __next__(self):
@@ -252,7 +252,7 @@
   \begin{verbatim}
      def islice(iterable, *args):
          s = slice(*args)
-         it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
+         it = iter(range(s.start or 0, s.stop or sys.maxint, s.step or 1))
          nexti = next(it)
          for i, element in enumerate(iterable):
              if i == nexti:
@@ -342,7 +342,7 @@
              while True:
                  yield object
          else:
-             for i in xrange(times):
+             for i in range(times):
                  yield object
   \end{verbatim}
 \end{funcdesc}
@@ -425,7 +425,7 @@
 Check 1202 is for $823.14
 
 >>> import operator
->>> for cube in imap(operator.pow, xrange(1,5), repeat(3)):
+>>> for cube in imap(operator.pow, range(1,5), repeat(3)):
 ...    print cube
 ...
 1

Modified: python/branches/p3yk/Doc/lib/librandom.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/librandom.tex	(original)
+++ python/branches/p3yk/Doc/lib/librandom.tex	Mon May  7 10:03:22 2007
@@ -163,9 +163,9 @@
   population contains repeats, then each occurrence is a possible
   selection in the sample.
 
-  To choose a sample from a range of integers, use an \function{xrange()}
+  To choose a sample from a range of integers, use an \function{range()}
   object as an argument.  This is especially fast and space efficient for
-  sampling from a large population:  \code{sample(xrange(10000000), 60)}.
+  sampling from a large population:  \code{sample(range(10000000), 60)}.
 \end{funcdesc}
 
 

Modified: python/branches/p3yk/Doc/lib/libstdtypes.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libstdtypes.tex	(original)
+++ python/branches/p3yk/Doc/lib/libstdtypes.tex	Mon May  7 10:03:22 2007
@@ -403,11 +403,11 @@
 
 \section{Sequence Types ---
 	    \class{str}, \class{unicode}, \class{list},
-	    \class{tuple}, \class{buffer}, \class{xrange}
+	    \class{tuple}, \class{buffer}, \class{range}
 	    \label{typesseq}}
 
 There are six sequence types: strings, Unicode strings, lists,
-tuples, buffers, and xrange objects.
+tuples, buffers, and range objects.
 
 String literals are written in single or double quotes:
 \code{'xyzzy'}, \code{"frobozz"}.  See chapter 2 of the
@@ -433,11 +433,11 @@
 \obindex{buffer}
 
 Xrange objects are similar to buffers in that there is no specific
-syntax to create them, but they are created using the \function{xrange()}
-function.\bifuncindex{xrange}  They don't support slicing,
+syntax to create them, but they are created using the \function{range()}
+function.\bifuncindex{range}  They don't support slicing,
 concatenation or repetition, and using \code{in}, \code{not in},
 \function{min()} or \function{max()} on them is inefficient.
-\obindex{xrange}
+\obindex{range}
 
 Most sequence types support the following operations.  The \samp{in} and
 \samp{not in} operations have the same priorities as the comparison
@@ -1069,11 +1069,11 @@
 \refmodule{re}.\refstmodindex{re}
 
 
-\subsection{XRange Type \label{typesseq-xrange}}
+\subsection{XRange Type \label{typesseq-range}}
 
-The \class{xrange}\obindex{xrange} type is an immutable sequence which
-is commonly used for looping.  The advantage of the \class{xrange}
-type is that an \class{xrange} object will always take the same amount
+The \class{range}\obindex{range} type is an immutable sequence which
+is commonly used for looping.  The advantage of the \class{range}
+type is that an \class{range} object will always take the same amount
 of memory, no matter the size of the range it represents.  There are
 no consistent performance advantages.
 

Modified: python/branches/p3yk/Doc/lib/libtimeit.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libtimeit.tex	(original)
+++ python/branches/p3yk/Doc/lib/libtimeit.tex	Mon May  7 10:03:22 2007
@@ -98,7 +98,7 @@
 measured.  If so, GC can be re-enabled as the first statement in the
 \var{setup} string.  For example:
 \begin{verbatim}
-    timeit.Timer('for i in xrange(10): oct(i)', 'gc.enable()').timeit()
+    timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()
 \end{verbatim}
 \end{notice}
 \end{methoddesc}

Modified: python/branches/p3yk/Doc/lib/libtypes.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libtypes.tex	(original)
+++ python/branches/p3yk/Doc/lib/libtypes.tex	Mon May  7 10:03:22 2007
@@ -147,9 +147,9 @@
 The type of open file objects such as \code{sys.stdout}.
 \end{datadesc}
 
-\begin{datadesc}{XRangeType}
+\begin{datadesc}{RangeType}
 The type of range objects returned by
-\function{xrange()}\bifuncindex{xrange}.
+\function{range()}\bifuncindex{range}.
 \end{datadesc}
 
 \begin{datadesc}{SliceType}

Modified: python/branches/p3yk/Doc/tut/tut.tex
==============================================================================
--- python/branches/p3yk/Doc/tut/tut.tex	(original)
+++ python/branches/p3yk/Doc/tut/tut.tex	Mon May  7 10:03:22 2007
@@ -2260,7 +2260,7 @@
 function.
 
 \begin{verbatim}
->>> for i in reversed(xrange(1,10,2)):
+>>> for i in reversed(range(1,10,2)):
 ...     print i
 ...
 9
@@ -2700,12 +2700,12 @@
  'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
  'enumerate', 'eval', 'exec', 'execfile', 'exit', 'file', 'filter', 'float',
  'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
- 'id', 'int', 'isinstance', 'issubclass', 'iter',
+ 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
  'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min',
  'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
  'reload', 'repr', 'reversed', 'round', 'set',
  'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
- 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
+ 'tuple', 'type', 'unichr', 'unicode', 'vars', 'zip']
 \end{verbatim}
 
 
@@ -4762,7 +4762,7 @@
 >>> import random
 >>> random.choice(['apple', 'pear', 'banana'])
 'apple'
->>> random.sample(xrange(100), 10)   # sampling without replacement
+>>> random.sample(range(100), 10)   # sampling without replacement
 [30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
 >>> random.random()    # random float
 0.17970987693706186

Modified: python/branches/p3yk/Lib/Cookie.py
==============================================================================
--- python/branches/p3yk/Lib/Cookie.py	(original)
+++ python/branches/p3yk/Lib/Cookie.py	Mon May  7 10:03:22 2007
@@ -305,7 +305,7 @@
     '\375' : '\\375',  '\376' : '\\376',  '\377' : '\\377'
     }
 
-_idmap = ''.join(chr(x) for x in xrange(256))
+_idmap = ''.join(chr(x) for x in range(256))
 
 def _quote(str, LegalChars=_LegalChars, idmap=_idmap):
     #

Modified: python/branches/p3yk/Lib/bsddb/test/test_thread.py
==============================================================================
--- python/branches/p3yk/Lib/bsddb/test/test_thread.py	(original)
+++ python/branches/p3yk/Lib/bsddb/test/test_thread.py	Mon May  7 10:03:22 2007
@@ -229,7 +229,7 @@
             print("%s: creating records %d - %d" % (name, start, stop))
 
         # create a bunch of records
-        for x in xrange(start, stop):
+        for x in range(start, stop):
             key = '%04d' % x
             dbutils.DeadlockWrap(d.put, key, self.makeData(key),
                                  max_retries=12)
@@ -239,7 +239,7 @@
 
             # do a bit or reading too
             if random() <= 0.05:
-                for y in xrange(start, x):
+                for y in range(start, x):
                     key = '%04d' % x
                     data = dbutils.DeadlockWrap(d.get, key, max_retries=12)
                     self.assertEqual(data, self.makeData(key))
@@ -252,7 +252,7 @@
                 print("could not complete sync()...")
 
         # read them back, deleting a few
-        for x in xrange(start, stop):
+        for x in range(start, stop):
             key = '%04d' % x
             data = dbutils.DeadlockWrap(d.get, key, max_retries=12)
             if verbose and x % 100 == 0:

Modified: python/branches/p3yk/Lib/calendar.py
==============================================================================
--- python/branches/p3yk/Lib/calendar.py	(original)
+++ python/branches/p3yk/Lib/calendar.py	Mon May  7 10:03:22 2007
@@ -45,7 +45,7 @@
 
 class _localized_month:
 
-    _months = [datetime.date(2001, i+1, 1).strftime for i in xrange(12)]
+    _months = [datetime.date(2001, i+1, 1).strftime for i in range(12)]
     _months.insert(0, lambda x: "")
 
     def __init__(self, format):
@@ -65,7 +65,7 @@
 class _localized_day:
 
     # January 1, 2001, was a Monday.
-    _days = [datetime.date(2001, 1, i+1).strftime for i in xrange(7)]
+    _days = [datetime.date(2001, 1, i+1).strftime for i in range(7)]
 
     def __init__(self, format):
         self.format = format
@@ -144,7 +144,7 @@
         Return a iterator for one week of weekday numbers starting with the
         configured first one.
         """
-        for i in xrange(self.firstweekday, self.firstweekday + 7):
+        for i in range(self.firstweekday, self.firstweekday + 7):
             yield i%7
 
     def itermonthdates(self, year, month):
@@ -192,7 +192,7 @@
         Each row represents a week; week entries are datetime.date values.
         """
         dates = list(self.itermonthdates(year, month))
-        return [ dates[i:i+7] for i in xrange(0, len(dates), 7) ]
+        return [ dates[i:i+7] for i in range(0, len(dates), 7) ]
 
     def monthdays2calendar(self, year, month):
         """
@@ -202,7 +202,7 @@
         are zero.
         """
         days = list(self.itermonthdays2(year, month))
-        return [ days[i:i+7] for i in xrange(0, len(days), 7) ]
+        return [ days[i:i+7] for i in range(0, len(days), 7) ]
 
     def monthdayscalendar(self, year, month):
         """
@@ -210,7 +210,7 @@
         Each row represents a week; days outside this month are zero.
         """
         days = list(self.itermonthdays(year, month))
-        return [ days[i:i+7] for i in xrange(0, len(days), 7) ]
+        return [ days[i:i+7] for i in range(0, len(days), 7) ]
 
     def yeardatescalendar(self, year, width=3):
         """
@@ -221,9 +221,9 @@
         """
         months = [
             self.monthdatescalendar(year, i)
-            for i in xrange(January, January+12)
+            for i in range(January, January+12)
         ]
-        return [months[i:i+width] for i in xrange(0, len(months), width) ]
+        return [months[i:i+width] for i in range(0, len(months), width) ]
 
     def yeardays2calendar(self, year, width=3):
         """
@@ -234,9 +234,9 @@
         """
         months = [
             self.monthdays2calendar(year, i)
-            for i in xrange(January, January+12)
+            for i in range(January, January+12)
         ]
-        return [months[i:i+width] for i in xrange(0, len(months), width) ]
+        return [months[i:i+width] for i in range(0, len(months), width) ]
 
     def yeardayscalendar(self, year, width=3):
         """
@@ -246,9 +246,9 @@
         """
         months = [
             self.monthdayscalendar(year, i)
-            for i in xrange(January, January+12)
+            for i in range(January, January+12)
         ]
-        return [months[i:i+width] for i in xrange(0, len(months), width) ]
+        return [months[i:i+width] for i in range(0, len(months), width) ]
 
 
 class TextCalendar(Calendar):
@@ -341,7 +341,7 @@
         header = self.formatweekheader(w)
         for (i, row) in enumerate(self.yeardays2calendar(theyear, m)):
             # months in this row
-            months = xrange(m*i+1, min(m*(i+1)+1, 13))
+            months = range(m*i+1, min(m*(i+1)+1, 13))
             a('\n'*l)
             names = (self.formatmonthname(theyear, k, colwidth, False)
                      for k in months)
@@ -352,7 +352,7 @@
             a('\n'*l)
             # max number of weeks for this row
             height = max(len(cal) for cal in row)
-            for j in xrange(height):
+            for j in range(height):
                 weeks = []
                 for cal in row:
                     if j >= len(cal):
@@ -444,9 +444,9 @@
         a('<table border="0" cellpadding="0" cellspacing="0" class="year">')
         a('\n')
         a('<tr><th colspan="%d" class="year">%s</th></tr>' % (width, theyear))
-        for i in xrange(January, January+12, width):
+        for i in range(January, January+12, width):
             # months in this row
-            months = xrange(i, min(i+width, 13))
+            months = range(i, min(i+width, 13))
             a('<tr>')
             for m in months:
                 a('<td>')

Modified: python/branches/p3yk/Lib/copy.py
==============================================================================
--- python/branches/p3yk/Lib/copy.py	(original)
+++ python/branches/p3yk/Lib/copy.py	Mon May  7 10:03:22 2007
@@ -100,7 +100,7 @@
 def _copy_immutable(x):
     return x
 for t in (type(None), int, float, bool, str, tuple,
-          frozenset, type, xrange, types.ClassType,
+          frozenset, type, range, types.ClassType,
           types.BuiltinFunctionType,
           types.FunctionType):
     d[t] = _copy_immutable
@@ -194,7 +194,7 @@
 except AttributeError:
     pass
 d[type] = _deepcopy_atomic
-d[xrange] = _deepcopy_atomic
+d[range] = _deepcopy_atomic
 d[types.ClassType] = _deepcopy_atomic
 d[types.BuiltinFunctionType] = _deepcopy_atomic
 d[types.FunctionType] = _deepcopy_atomic

Modified: python/branches/p3yk/Lib/ctypes/test/test_arrays.py
==============================================================================
--- python/branches/p3yk/Lib/ctypes/test/test_arrays.py	(original)
+++ python/branches/p3yk/Lib/ctypes/test/test_arrays.py	Mon May  7 10:03:22 2007
@@ -11,7 +11,7 @@
         # create classes holding simple numeric types, and check
         # various properties.
 
-        init = range(15, 25)
+        init = list(range(15, 25))
 
         for fmt in formats:
             alen = len(init)
@@ -27,7 +27,7 @@
 
             # change the items
             from operator import setitem
-            new_values = range(42, 42+alen)
+            new_values = list(range(42, 42+alen))
             [setitem(ia, n, new_values[n]) for n in range(alen)]
             values = [ia[i] for i in range(len(init))]
             self.failUnlessEqual(values, new_values)

Modified: python/branches/p3yk/Lib/ctypes/test/test_slicing.py
==============================================================================
--- python/branches/p3yk/Lib/ctypes/test/test_slicing.py	(original)
+++ python/branches/p3yk/Lib/ctypes/test/test_slicing.py	Mon May  7 10:03:22 2007
@@ -5,8 +5,8 @@
 
 class SlicesTestCase(unittest.TestCase):
     def test_getslice_cint(self):
-        a = (c_int * 100)(*xrange(1100, 1200))
-        b = range(1100, 1200)
+        a = (c_int * 100)(*range(1100, 1200))
+        b = list(range(1100, 1200))
         self.failUnlessEqual(a[0:2], b[0:2])
         self.failUnlessEqual(len(a), len(b))
         self.failUnlessEqual(a[5:7], b[5:7])
@@ -14,14 +14,14 @@
         self.failUnlessEqual(a[:], b[:])
 
         a[0:5] = range(5, 10)
-        self.failUnlessEqual(a[0:5], range(5, 10))
+        self.failUnlessEqual(a[0:5], list(range(5, 10)))
 
     def test_setslice_cint(self):
-        a = (c_int * 100)(*xrange(1100, 1200))
-        b = range(1100, 1200)
+        a = (c_int * 100)(*range(1100, 1200))
+        b = list(range(1100, 1200))
 
-        a[32:47] = range(32, 47)
-        self.failUnlessEqual(a[32:47], range(32, 47))
+        a[32:47] = list(range(32, 47))
+        self.failUnlessEqual(a[32:47], list(range(32, 47)))
 
         from operator import setslice
 
@@ -50,7 +50,7 @@
 
         dll.my_strdup.restype = POINTER(c_byte)
         res = dll.my_strdup(s)
-        self.failUnlessEqual(res[:len(s)], range(ord("a"), ord("z")+1))
+        self.failUnlessEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
         dll.my_free(res)
 
     def test_char_ptr_with_free(self):
@@ -111,7 +111,8 @@
             else:
                 return
             res = dll.my_wcsdup(s)
-            self.failUnlessEqual(res[:len(s)-1], range(ord("a"), ord("z")+1))
+            self.failUnlessEqual(res[:len(s)-1],
+                                 list(range(ord("a"), ord("z")+1)))
             dll.my_free(res)
 
 ################################################################

Modified: python/branches/p3yk/Lib/difflib.py
==============================================================================
--- python/branches/p3yk/Lib/difflib.py	(original)
+++ python/branches/p3yk/Lib/difflib.py	Mon May  7 10:03:22 2007
@@ -407,7 +407,7 @@
         # junk-free match ending with a[i-1] and b[j]
         j2len = {}
         nothing = []
-        for i in xrange(alo, ahi):
+        for i in range(alo, ahi):
             # look at all instances of a[i] in b; note that because
             # b2j has no junk keys, the loop is skipped if a[i] is junk
             j2lenget = j2len.get
@@ -921,7 +921,7 @@
 
     def _dump(self, tag, x, lo, hi):
         """Generate comparison results for a same-tagged range."""
-        for i in xrange(lo, hi):
+        for i in range(lo, hi):
             yield '%s %s' % (tag, x[i])
 
     def _plain_replace(self, a, alo, ahi, b, blo, bhi):
@@ -967,10 +967,10 @@
         # search for the pair that matches best without being identical
         # (identical lines must be junk lines, & we don't want to synch up
         # on junk -- unless we have to)
-        for j in xrange(blo, bhi):
+        for j in range(blo, bhi):
             bj = b[j]
             cruncher.set_seq2(bj)
-            for i in xrange(alo, ahi):
+            for i in range(alo, ahi):
                 ai = a[i]
                 if ai == bj:
                     if eqi is None:

Modified: python/branches/p3yk/Lib/distutils/command/install.py
==============================================================================
--- python/branches/p3yk/Lib/distutils/command/install.py	(original)
+++ python/branches/p3yk/Lib/distutils/command/install.py	Mon May  7 10:03:22 2007
@@ -517,7 +517,7 @@
             outputs = self.get_outputs()
             if self.root:               # strip any package prefix
                 root_len = len(self.root)
-                for counter in xrange(len(outputs)):
+                for counter in range(len(outputs)):
                     outputs[counter] = outputs[counter][root_len:]
             self.execute(write_file,
                          (self.record, outputs),

Modified: python/branches/p3yk/Lib/doctest.py
==============================================================================
--- python/branches/p3yk/Lib/doctest.py	(original)
+++ python/branches/p3yk/Lib/doctest.py	Mon May  7 10:03:22 2007
@@ -2610,14 +2610,14 @@
             "ellipsis": r"""
                 If the ellipsis flag is used, then '...' can be used to
                 elide substrings in the desired output:
-                    >>> print(range(1000)) #doctest: +ELLIPSIS
+                    >>> print(list(range(1000))) #doctest: +ELLIPSIS
                     [0, 1, 2, ..., 999]
             """,
 
             "whitespace normalization": r"""
                 If the whitespace normalization flag is used, then
                 differences in whitespace are ignored.
-                    >>> print(range(30)) #doctest: +NORMALIZE_WHITESPACE
+                    >>> print(list(range(30))) #doctest: +NORMALIZE_WHITESPACE
                     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
                      15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
                      27, 28, 29]

Modified: python/branches/p3yk/Lib/genericpath.py
==============================================================================
--- python/branches/p3yk/Lib/genericpath.py	(original)
+++ python/branches/p3yk/Lib/genericpath.py	Mon May  7 10:03:22 2007
@@ -71,7 +71,7 @@
     s1 = min(m)
     s2 = max(m)
     n = min(len(s1), len(s2))
-    for i in xrange(n):
+    for i in range(n):
         if s1[i] != s2[i]:
             return s1[:i]
     return s1[:n]

Modified: python/branches/p3yk/Lib/gettext.py
==============================================================================
--- python/branches/p3yk/Lib/gettext.py	(original)
+++ python/branches/p3yk/Lib/gettext.py	Mon May  7 10:03:22 2007
@@ -281,7 +281,7 @@
             raise IOError(0, 'Bad magic number', filename)
         # Now put all messages from the .mo file buffer into the catalog
         # dictionary.
-        for i in xrange(0, msgcount):
+        for i in range(0, msgcount):
             mlen, moff = unpack(ii, buf[masteridx:masteridx+8])
             mend = moff + mlen
             tlen, toff = unpack(ii, buf[transidx:transidx+8])

Modified: python/branches/p3yk/Lib/heapq.py
==============================================================================
--- python/branches/p3yk/Lib/heapq.py	(original)
+++ python/branches/p3yk/Lib/heapq.py	Mon May  7 10:03:22 2007
@@ -173,7 +173,7 @@
     # or i < (n-1)/2.  If n is even = 2*j, this is (2*j-1)/2 = j-1/2 so
     # j-1 is the largest, which is n//2 - 1.  If n is odd = 2*j+1, this is
     # (2*j+1-1)/2 = j so j-1 is the largest, and that's again n//2-1.
-    for i in reversed(xrange(n//2)):
+    for i in reversed(range(n//2)):
         _siftup(x, i)
 
 def nlargest(n, iterable):

Modified: python/branches/p3yk/Lib/hmac.py
==============================================================================
--- python/branches/p3yk/Lib/hmac.py	(original)
+++ python/branches/p3yk/Lib/hmac.py	Mon May  7 10:03:22 2007
@@ -3,8 +3,8 @@
 Implements the HMAC algorithm as described by RFC 2104.
 """
 
-trans_5C = "".join ([chr (x ^ 0x5C) for x in xrange(256)])
-trans_36 = "".join ([chr (x ^ 0x36) for x in xrange(256)])
+trans_5C = "".join ([chr (x ^ 0x5C) for x in range(256)])
+trans_36 = "".join ([chr (x ^ 0x36) for x in range(256)])
 
 # The size of the digests returned by HMAC depends on the underlying
 # hashing module used.  Use digest_size from the instance of HMAC instead.

Modified: python/branches/p3yk/Lib/idlelib/CodeContext.py
==============================================================================
--- python/branches/p3yk/Lib/idlelib/CodeContext.py	(original)
+++ python/branches/p3yk/Lib/idlelib/CodeContext.py	Mon May  7 10:03:22 2007
@@ -117,7 +117,7 @@
         lastindent = INFINITY
         # For a line to be interesting, it must begin with a block opening
         # keyword, and have less indentation than lastindent.
-        for linenum in xrange(new_topvisible, stopline-1, -1):
+        for linenum in range(new_topvisible, stopline-1, -1):
             indent, text, opener = self.get_line_info(linenum)
             if indent < lastindent:
                 lastindent = indent

Modified: python/branches/p3yk/Lib/mhlib.py
==============================================================================
--- python/branches/p3yk/Lib/mhlib.py	(original)
+++ python/branches/p3yk/Lib/mhlib.py	Mon May  7 10:03:22 2007
@@ -828,7 +828,7 @@
     def tolist(self):
         l = []
         for lo, hi in self.pairs:
-            m = range(lo, hi+1)
+            m = list(range(lo, hi+1))
             l = l + m
         return l
 

Modified: python/branches/p3yk/Lib/pickle.py
==============================================================================
--- python/branches/p3yk/Lib/pickle.py	(original)
+++ python/branches/p3yk/Lib/pickle.py	Mon May  7 10:03:22 2007
@@ -635,7 +635,7 @@
                 write(APPEND)
             return
 
-        r = xrange(self._BATCHSIZE)
+        r = range(self._BATCHSIZE)
         while items is not None:
             tmp = []
             for i in r:
@@ -683,7 +683,7 @@
                 write(SETITEM)
             return
 
-        r = xrange(self._BATCHSIZE)
+        r = range(self._BATCHSIZE)
         while items is not None:
             tmp = []
             for i in r:

Modified: python/branches/p3yk/Lib/plat-mac/EasyDialogs.py
==============================================================================
--- python/branches/p3yk/Lib/plat-mac/EasyDialogs.py	(original)
+++ python/branches/p3yk/Lib/plat-mac/EasyDialogs.py	Mon May  7 10:03:22 2007
@@ -814,11 +814,11 @@
     try:
         if hasattr(MacOS, 'SchedParams'):
             appsw = MacOS.SchedParams(1, 0)
-        for i in xrange(20):
+        for i in range(20):
             bar.inc()
             time.sleep(0.05)
         bar.set(0,100)
-        for i in xrange(100):
+        for i in range(100):
             bar.set(i)
             time.sleep(0.05)
             if i % 10 == 0:

Modified: python/branches/p3yk/Lib/plat-mac/applesingle.py
==============================================================================
--- python/branches/p3yk/Lib/plat-mac/applesingle.py	(original)
+++ python/branches/p3yk/Lib/plat-mac/applesingle.py	Mon May  7 10:03:22 2007
@@ -60,7 +60,7 @@
             raise Error, "Unknown AppleSingle version number 0x%8.8x" % (version,)
         if nentry <= 0:
             raise Error, "AppleSingle file contains no forks"
-        headers = [fileobj.read(AS_ENTRY_LENGTH) for i in xrange(nentry)]
+        headers = [fileobj.read(AS_ENTRY_LENGTH) for i in range(nentry)]
         self.forks = []
         for hdr in headers:
             try:

Modified: python/branches/p3yk/Lib/plat-riscos/riscospath.py
==============================================================================
--- python/branches/p3yk/Lib/plat-riscos/riscospath.py	(original)
+++ python/branches/p3yk/Lib/plat-riscos/riscospath.py	Mon May  7 10:03:22 2007
@@ -174,7 +174,7 @@
     s1 = min(m)
     s2 = max(m)
     n = min(len(s1), len(s2))
-    for i in xrange(n):
+    for i in range(n):
         if s1[i] != s2[i]:
             return s1[:i]
     return s1[:n]

Modified: python/branches/p3yk/Lib/popen2.py
==============================================================================
--- python/branches/p3yk/Lib/popen2.py	(original)
+++ python/branches/p3yk/Lib/popen2.py	Mon May  7 10:03:22 2007
@@ -79,7 +79,7 @@
     def _run_child(self, cmd):
         if isinstance(cmd, basestring):
             cmd = ['/bin/sh', '-c', cmd]
-        for i in xrange(3, MAXFD):
+        for i in range(3, MAXFD):
             try:
                 os.close(i)
             except OSError:

Modified: python/branches/p3yk/Lib/pydoc.py
==============================================================================
--- python/branches/p3yk/Lib/pydoc.py	(original)
+++ python/branches/p3yk/Lib/pydoc.py	Mon May  7 10:03:22 2007
@@ -1582,7 +1582,7 @@
         'INTEGER': ('ref/integers', 'int range'),
         'FLOAT': ('ref/floating', 'float math'),
         'COMPLEX': ('ref/imaginary', 'complex cmath'),
-        'SEQUENCES': ('lib/typesseq', 'STRINGMETHODS FORMATTING xrange LISTS'),
+        'SEQUENCES': ('lib/typesseq', 'STRINGMETHODS FORMATTING range LISTS'),
         'MAPPINGS': 'DICTIONARIES',
         'FUNCTIONS': ('lib/typesfunctions', 'def TYPES'),
         'METHODS': ('lib/typesmethods', 'class def CLASSES TYPES'),

Modified: python/branches/p3yk/Lib/random.py
==============================================================================
--- python/branches/p3yk/Lib/random.py	(original)
+++ python/branches/p3yk/Lib/random.py	Mon May  7 10:03:22 2007
@@ -256,7 +256,7 @@
 
         if random is None:
             random = self.random
-        for i in reversed(xrange(1, len(x))):
+        for i in reversed(range(1, len(x))):
             # pick an element in x[:i+1] with which to exchange x[i]
             j = int(random() * (i+1))
             x[i], x[j] = x[j], x[i]
@@ -274,9 +274,9 @@
         population contains repeats, then each occurrence is a possible
         selection in the sample.
 
-        To choose a sample in a range of integers, use xrange as an argument.
+        To choose a sample in a range of integers, use range as an argument.
         This is especially fast and space efficient for sampling from a
-        large population:   sample(xrange(10000000), 60)
+        large population:   sample(range(10000000), 60)
         """
 
         # XXX Although the documentation says `population` is "a sequence",
@@ -311,7 +311,7 @@
             # An n-length list is smaller than a k-length set, or this is a
             # mapping type so the other algorithm wouldn't work.
             pool = list(population)
-            for i in xrange(k):         # invariant:  non-selected at [0,n-i)
+            for i in range(k):         # invariant:  non-selected at [0,n-i)
                 j = _int(random() * (n-i))
                 result[i] = pool[j]
                 pool[j] = pool[n-i-1]   # move non-selected item into vacancy
@@ -319,7 +319,7 @@
             try:
                 selected = set()
                 selected_add = selected.add
-                for i in xrange(k):
+                for i in range(k):
                     j = _int(random() * n)
                     while j in selected:
                         j = _int(random() * n)

Modified: python/branches/p3yk/Lib/sqlite3/test/regression.py
==============================================================================
--- python/branches/p3yk/Lib/sqlite3/test/regression.py	(original)
+++ python/branches/p3yk/Lib/sqlite3/test/regression.py	Mon May  7 10:03:22 2007
@@ -51,10 +51,10 @@
         # reset before a rollback, but only those that are still in the
         # statement cache. The others are not accessible from the connection object.
         con = sqlite.connect(":memory:", cached_statements=5)
-        cursors = [con.cursor() for x in xrange(5)]
+        cursors = [con.cursor() for x in range(5)]
         cursors[0].execute("create table test(x)")
         for i in range(10):
-            cursors[0].executemany("insert into test(x) values (?)", [(x,) for x in xrange(10)])
+            cursors[0].executemany("insert into test(x) values (?)", [(x,) for x in range(10)])
 
         for i in range(5):
             cursors[i].execute(" " * i + "select x from test")

Modified: python/branches/p3yk/Lib/sre_compile.py
==============================================================================
--- python/branches/p3yk/Lib/sre_compile.py	(original)
+++ python/branches/p3yk/Lib/sre_compile.py	Mon May  7 10:03:22 2007
@@ -318,7 +318,7 @@
             elif op is LITERAL:
                 charmap[fixup(av)] = 1
             elif op is RANGE:
-                for i in xrange(fixup(av[0]), fixup(av[1])+1):
+                for i in range(fixup(av[0]), fixup(av[1])+1):
                     charmap[i] = 1
             elif op is CATEGORY:
                 # XXX: could expand category
@@ -330,13 +330,13 @@
         if sys.maxunicode != 65535:
             # XXX: negation does not work with big charsets
             return charset
-        for i in xrange(65536):
+        for i in range(65536):
             charmap[i] = not charmap[i]
     comps = {}
     mapping = [0]*256
     block = 0
     data = []
-    for i in xrange(256):
+    for i in range(256):
         chunk = tuple(charmap[i*256:(i+1)*256])
         new = comps.setdefault(chunk, block)
         mapping[i] = new
@@ -461,7 +461,7 @@
         code.extend(prefix)
         # generate overlap table
         table = [-1] + ([0]*len(prefix))
-        for i in xrange(len(prefix)):
+        for i in range(len(prefix)):
             table[i+1] = table[i]+1
             while table[i+1] > 0 and prefix[i] != prefix[table[i+1]-1]:
                 table[i+1] = table[table[i+1]-1]+1

Modified: python/branches/p3yk/Lib/string.py
==============================================================================
--- python/branches/p3yk/Lib/string.py	(original)
+++ python/branches/p3yk/Lib/string.py	Mon May  7 10:03:22 2007
@@ -30,7 +30,7 @@
 
 # Case conversion helpers
 # Use str to convert Unicode literal in case of -U
-l = map(chr, xrange(256))
+l = map(chr, range(256))
 _idmap = str('').join(l)
 del l
 

Modified: python/branches/p3yk/Lib/stringprep.py
==============================================================================
--- python/branches/p3yk/Lib/stringprep.py	(original)
+++ python/branches/p3yk/Lib/stringprep.py	Mon May  7 10:03:22 2007
@@ -16,7 +16,7 @@
     return (c & 0xFFFF) not in (0xFFFE, 0xFFFF)
 
 
-b1_set = set([173, 847, 6150, 6155, 6156, 6157, 8203, 8204, 8205, 8288, 65279] + range(65024,65040))
+b1_set = set([173, 847, 6150, 6155, 6156, 6157, 8203, 8204, 8205, 8288, 65279] + list(range(65024,65040)))
 def in_table_b1(code):
     return ord(code) in b1_set
 
@@ -217,7 +217,7 @@
 def in_table_c21(code):
     return ord(code) < 128 and unicodedata.category(code) == "Cc"
 
-c22_specials = set([1757, 1807, 6158, 8204, 8205, 8232, 8233, 65279] + range(8288,8292) + range(8298,8304) + range(65529,65533) + range(119155,119163))
+c22_specials = set([1757, 1807, 6158, 8204, 8205, 8232, 8233, 65279] + list(range(8288,8292)) + list(range(8298,8304)) + list(range(65529,65533)) + list(range(119155,119163)))
 def in_table_c22(code):
     c = ord(code)
     if c < 128: return False
@@ -254,12 +254,12 @@
     return ord(code) in c7_set
 
 
-c8_set = set([832, 833, 8206, 8207] + range(8234,8239) + range(8298,8304))
+c8_set = set([832, 833, 8206, 8207] + list(range(8234,8239)) + list(range(8298,8304)))
 def in_table_c8(code):
     return ord(code) in c8_set
 
 
-c9_set = set([917505] + range(917536,917632))
+c9_set = set([917505] + list(range(917536,917632)))
 def in_table_c9(code):
     return ord(code) in c9_set
 

Modified: python/branches/p3yk/Lib/subprocess.py
==============================================================================
--- python/branches/p3yk/Lib/subprocess.py	(original)
+++ python/branches/p3yk/Lib/subprocess.py	Mon May  7 10:03:22 2007
@@ -969,7 +969,7 @@
 
 
         def _close_fds(self, but):
-            for i in xrange(3, MAXFD):
+            for i in range(3, MAXFD):
                 if i == but:
                     continue
                 try:

Modified: python/branches/p3yk/Lib/tarfile.py
==============================================================================
--- python/branches/p3yk/Lib/tarfile.py	(original)
+++ python/branches/p3yk/Lib/tarfile.py	Mon May  7 10:03:22 2007
@@ -188,7 +188,7 @@
             raise HeaderError("invalid header")
     else:
         n = 0
-        for i in xrange(len(s) - 1):
+        for i in range(len(s) - 1):
             n <<= 8
             n += ord(s[i + 1])
     return n
@@ -214,7 +214,7 @@
             n = struct.unpack("L", struct.pack("l", n))[0]
 
         s = ""
-        for i in xrange(digits - 1):
+        for i in range(digits - 1):
             s = chr(n & 0377) + s
             n >>= 8
         s = chr(0200) + s
@@ -245,7 +245,7 @@
 
     BUFSIZE = 16 * 1024
     blocks, remainder = divmod(length, BUFSIZE)
-    for b in xrange(blocks):
+    for b in range(blocks):
         buf = src.read(BUFSIZE)
         if len(buf) < BUFSIZE:
             raise IOError("end of file reached")
@@ -514,7 +514,7 @@
         """
         if pos - self.pos >= 0:
             blocks, remainder = divmod(pos - self.pos, self.bufsize)
-            for i in xrange(blocks):
+            for i in range(blocks):
                 self.read(self.bufsize)
             self.read(remainder)
         else:
@@ -1297,7 +1297,7 @@
         realpos = 0
         # There are 4 possible sparse structs in the
         # first header.
-        for i in xrange(4):
+        for i in range(4):
             try:
                 offset = nti(buf[pos:pos + 12])
                 numbytes = nti(buf[pos + 12:pos + 24])
@@ -1318,7 +1318,7 @@
         while isextended == 1:
             buf = tarfile.fileobj.read(BLOCKSIZE)
             pos = 0
-            for i in xrange(21):
+            for i in range(21):
                 try:
                     offset = nti(buf[pos:pos + 12])
                     numbytes = nti(buf[pos + 12:pos + 24])
@@ -2304,7 +2304,7 @@
         else:
             end = members.index(tarinfo)
 
-        for i in xrange(end - 1, -1, -1):
+        for i in range(end - 1, -1, -1):
             if name == members[i].name:
                 return members[i]
 

Modified: python/branches/p3yk/Lib/tempfile.py
==============================================================================
--- python/branches/p3yk/Lib/tempfile.py	(original)
+++ python/branches/p3yk/Lib/tempfile.py	Mon May  7 10:03:22 2007
@@ -196,7 +196,7 @@
         if dir != _os.curdir:
             dir = _os.path.normcase(_os.path.abspath(dir))
         # Try only a few names per directory.
-        for seq in xrange(100):
+        for seq in range(100):
             name = next(namer)
             filename = _os.path.join(dir, name)
             try:
@@ -235,7 +235,7 @@
 
     names = _get_candidate_names()
 
-    for seq in xrange(TMP_MAX):
+    for seq in range(TMP_MAX):
         name = next(names)
         file = _os.path.join(dir, pre + name + suf)
         try:
@@ -327,7 +327,7 @@
 
     names = _get_candidate_names()
 
-    for seq in xrange(TMP_MAX):
+    for seq in range(TMP_MAX):
         name = next(names)
         file = _os.path.join(dir, prefix + name + suffix)
         try:
@@ -362,7 +362,7 @@
         dir = gettempdir()
 
     names = _get_candidate_names()
-    for seq in xrange(TMP_MAX):
+    for seq in range(TMP_MAX):
         name = next(names)
         file = _os.path.join(dir, prefix + name + suffix)
         if not _exists(file):

Modified: python/branches/p3yk/Lib/test/fork_wait.py
==============================================================================
--- python/branches/p3yk/Lib/test/fork_wait.py	(original)
+++ python/branches/p3yk/Lib/test/fork_wait.py	Mon May  7 10:03:22 2007
@@ -52,7 +52,7 @@
         time.sleep(LONGSLEEP)
 
         a = sorted(self.alive.keys())
-        self.assertEquals(a, range(NUM_THREADS))
+        self.assertEquals(a, list(range(NUM_THREADS)))
 
         prefork_lives = self.alive.copy()
 

Modified: python/branches/p3yk/Lib/test/list_tests.py
==============================================================================
--- python/branches/p3yk/Lib/test/list_tests.py	(original)
+++ python/branches/p3yk/Lib/test/list_tests.py	Mon May  7 10:03:22 2007
@@ -47,9 +47,9 @@
         self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
 
     def test_print(self):
-        d = self.type2test(xrange(200))
+        d = self.type2test(range(200))
         d.append(d)
-        d.extend(xrange(200,400))
+        d.extend(range(200,400))
         d.append(d)
         d.append(400)
         try:
@@ -398,7 +398,7 @@
                 del self.victim[:]
                 return False
         a = self.type2test()
-        a[:] = [EvilCmp(a) for _ in xrange(100)]
+        a[:] = [EvilCmp(a) for _ in range(100)]
         # This used to seg fault before patch #1005778
         self.assertRaises(ValueError, a.index, None)
 

Modified: python/branches/p3yk/Lib/test/output/test_cProfile
==============================================================================
--- python/branches/p3yk/Lib/test/output/test_cProfile	(original)
+++ python/branches/p3yk/Lib/test/output/test_cProfile	Mon May  7 10:03:22 2007
@@ -1,5 +1,5 @@
 test_cProfile
-         127 function calls (107 primitive calls) in 1.000 CPU seconds
+         119 function calls (99 primitive calls) in 1.000 CPU seconds
 
    Ordered by: standard name
 
@@ -18,7 +18,6 @@
        12    0.000    0.000    0.012    0.001 {hasattr}
         4    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}
         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
-        8    0.000    0.000    0.000    0.000 {range}
         4    0.000    0.000    0.000    0.000 {sys.exc_info}
 
 
@@ -28,7 +27,6 @@
                                                       ncalls  tottime  cumtime
 <string>:1(<module>)                              ->       1    0.270    1.000  test_cProfile.py:30(testfunc)
 test_cProfile.py:103(subhelper)                   ->      16    0.016    0.016  test_cProfile.py:115(__getattr__)
-                                                           8    0.000    0.000  {range}
 test_cProfile.py:115(__getattr__)                 -> 
 test_cProfile.py:30(testfunc)                     ->       1    0.014    0.130  test_cProfile.py:40(factorial)
                                                            2    0.040    0.600  test_cProfile.py:60(helper)
@@ -49,7 +47,6 @@
 {hasattr}                                         ->      12    0.012    0.012  test_cProfile.py:115(__getattr__)
 {method 'append' of 'list' objects}               -> 
 {method 'disable' of '_lsprof.Profiler' objects}  -> 
-{range}                                           -> 
 {sys.exc_info}                                    -> 
 
 
@@ -76,7 +73,6 @@
                                                            8    0.000    0.008  test_cProfile.py:93(helper2)
 {method 'append' of 'list' objects}               <-       4    0.000    0.000  test_cProfile.py:78(helper1)
 {method 'disable' of '_lsprof.Profiler' objects}  <- 
-{range}                                           <-       8    0.000    0.000  test_cProfile.py:103(subhelper)
 {sys.exc_info}                                    <-       4    0.000    0.000  test_cProfile.py:78(helper1)
 
 

Modified: python/branches/p3yk/Lib/test/output/test_profile
==============================================================================
--- python/branches/p3yk/Lib/test/output/test_profile	(original)
+++ python/branches/p3yk/Lib/test/output/test_profile	Mon May  7 10:03:22 2007
@@ -1,5 +1,5 @@
 test_profile
-         128 function calls (108 primitive calls) in 1.000 CPU seconds
+         120 function calls (100 primitive calls) in 1.000 CPU seconds
 
    Ordered by: standard name
 
@@ -8,7 +8,6 @@
         4    0.000    0.000    0.000    0.000 :0(exc_info)
         1    0.000    0.000    1.000    1.000 :0(exec)
        12    0.000    0.000    0.012    0.001 :0(hasattr)
-        8    0.000    0.000    0.000    0.000 :0(range)
         1    0.000    0.000    0.000    0.000 :0(setprofile)
         1    0.000    0.000    1.000    1.000 <string>:1(<module>)
         0    0.000             0.000          profile:0(profiler)
@@ -31,14 +30,12 @@
 :0(exc_info)                          -> 
 :0(exec)                              -> <string>:1(<module>)(1)    1.000
 :0(hasattr)                           -> test_profile.py:115(__getattr__)(12)    0.028
-:0(range)                             -> 
 :0(setprofile)                        -> 
 <string>:1(<module>)                  -> test_profile.py:30(testfunc)(1)    1.000
 profile:0(profiler)                   -> profile:0(testfunc())(1)    1.000
 profile:0(testfunc())                 -> :0(exec)(1)    1.000
                                          :0(setprofile)(1)    0.000
-test_profile.py:103(subhelper)        -> :0(range)(8)    0.000
-                                         test_profile.py:115(__getattr__)(16)    0.028
+test_profile.py:103(subhelper)        -> test_profile.py:115(__getattr__)(16)    0.028
 test_profile.py:115(__getattr__)      -> 
 test_profile.py:30(testfunc)          -> test_profile.py:40(factorial)(1)    0.170
                                          test_profile.py:60(helper)(2)    0.600
@@ -65,7 +62,6 @@
 :0(exec)                              <- profile:0(testfunc())(1)    1.000
 :0(hasattr)                           <- test_profile.py:78(helper1)(4)    0.120
                                          test_profile.py:93(helper2)(8)    0.400
-:0(range)                             <- test_profile.py:103(subhelper)(8)    0.080
 :0(setprofile)                        <- profile:0(testfunc())(1)    1.000
 <string>:1(<module>)                  <- :0(exec)(1)    1.000
 profile:0(profiler)                   <- 

Modified: python/branches/p3yk/Lib/test/pickletester.py
==============================================================================
--- python/branches/p3yk/Lib/test/pickletester.py	(original)
+++ python/branches/p3yk/Lib/test/pickletester.py	Mon May  7 10:03:22 2007
@@ -745,7 +745,7 @@
 
     def test_list_chunking(self):
         n = 10  # too small to chunk
-        x = range(n)
+        x = list(range(n))
         for proto in protocols:
             s = self.dumps(x, proto)
             y = self.loads(s)
@@ -754,7 +754,7 @@
             self.assertEqual(num_appends, proto > 0)
 
         n = 2500  # expect at least two chunks when proto > 0
-        x = range(n)
+        x = list(range(n))
         for proto in protocols:
             s = self.dumps(x, proto)
             y = self.loads(s)
@@ -991,7 +991,7 @@
     def test_persistence(self):
         self.id_count = 0
         self.load_count = 0
-        L = range(10)
+        L = list(range(10))
         self.assertEqual(self.loads(self.dumps(L)), L)
         self.assertEqual(self.id_count, 5)
         self.assertEqual(self.load_count, 5)
@@ -999,7 +999,7 @@
     def test_bin_persistence(self):
         self.id_count = 0
         self.load_count = 0
-        L = range(10)
+        L = list(range(10))
         self.assertEqual(self.loads(self.dumps(L, 1)), L)
         self.assertEqual(self.id_count, 5)
         self.assertEqual(self.load_count, 5)

Modified: python/branches/p3yk/Lib/test/seq_tests.py
==============================================================================
--- python/branches/p3yk/Lib/test/seq_tests.py	(original)
+++ python/branches/p3yk/Lib/test/seq_tests.py	Mon May  7 10:03:22 2007
@@ -120,7 +120,7 @@
         self.assertEqual(len(vv), len(s))
 
         # Create from various iteratables
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (Sequence, IterFunc, IterGen,
                       itermulti, iterfunc):
                 self.assertEqual(self.type2test(g(s)), self.type2test(s))
@@ -136,10 +136,10 @@
 
     def test_getitem(self):
         u = self.type2test([0, 1, 2, 3, 4])
-        for i in xrange(len(u)):
+        for i in range(len(u)):
             self.assertEqual(u[i], i)
             self.assertEqual(u[int(i)], i)
-        for i in xrange(-len(u), -1):
+        for i in range(-len(u), -1):
             self.assertEqual(u[i], len(u)+i)
             self.assertEqual(u[int(i)], len(u)+i)
         self.assertRaises(IndexError, u.__getitem__, -len(u)-1)
@@ -299,9 +299,9 @@
         self.assertEqual(next(iter(T((1,2)))), 1)
 
     def test_repeat(self):
-        for m in xrange(4):
+        for m in range(4):
             s = tuple(range(m))
-            for n in xrange(-3, 5):
+            for n in range(-3, 5):
                 self.assertEqual(self.type2test(s*n), self.type2test(s)*n)
             self.assertEqual(self.type2test(s)*(-4), self.type2test([]))
             self.assertEqual(id(s), id(s*1))

Modified: python/branches/p3yk/Lib/test/sortperf.py
==============================================================================
--- python/branches/p3yk/Lib/test/sortperf.py	(original)
+++ python/branches/p3yk/Lib/test/sortperf.py	Mon May  7 10:03:22 2007
@@ -24,7 +24,7 @@
         fp = open(fn, "rb")
     except IOError:
         r = random.random
-        result = [r() for i in xrange(n)]
+        result = [r() for i in range(n)]
         try:
             try:
                 fp = open(fn, "wb")
@@ -108,7 +108,7 @@
         doit(L) # +sort
 
         # Replace 1% of the elements at random.
-        for dummy in xrange(n // 100):
+        for dummy in range(n // 100):
             L[random.randrange(n)] = random.random()
         doit(L) # %sort
 

Modified: python/branches/p3yk/Lib/test/string_tests.py
==============================================================================
--- python/branches/p3yk/Lib/test/string_tests.py	(original)
+++ python/branches/p3yk/Lib/test/string_tests.py	Mon May  7 10:03:22 2007
@@ -112,9 +112,9 @@
         digits = 7
         base = len(charset)
         teststrings = set()
-        for i in xrange(base ** digits):
+        for i in range(base ** digits):
             entry = []
-            for j in xrange(digits):
+            for j in range(digits):
                 i, m = divmod(i, base)
                 entry.append(charset[m])
             teststrings.add(''.join(entry))
@@ -151,9 +151,9 @@
         digits = 5
         base = len(charset)
         teststrings = set()
-        for i in xrange(base ** digits):
+        for i in range(base ** digits):
             entry = []
-            for j in xrange(digits):
+            for j in range(digits):
                 i, m = divmod(i, base)
                 entry.append(charset[m])
             teststrings.add(''.join(entry))
@@ -1021,10 +1021,10 @@
 
     def test_floatformatting(self):
         # float formatting
-        for prec in xrange(100):
+        for prec in range(100):
             format = '%%.%if' % prec
             value = 0.01
-            for x in xrange(60):
+            for x in range(60):
                 value = value * 3.141592655 / 3.0 * 10.0
                 # The formatfloat() code in stringobject.c and
                 # unicodeobject.c uses a 120 byte buffer and switches from
@@ -1091,7 +1091,7 @@
 
     def test_maketrans(self):
         self.assertEqual(
-           ''.join(map(chr, xrange(256))).replace('abc', 'xyz'),
+           ''.join(map(chr, range(256))).replace('abc', 'xyz'),
            string.maketrans('abc', 'xyz')
         )
         self.assertRaises(ValueError, string.maketrans, 'abc', 'xyzw')

Modified: python/branches/p3yk/Lib/test/test_array.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_array.py	(original)
+++ python/branches/p3yk/Lib/test/test_array.py	Mon May  7 10:03:22 2007
@@ -836,7 +836,7 @@
 
     def test_iterationcontains(self):
         a = array.array(self.typecode, range(10))
-        self.assertEqual(list(a), range(10))
+        self.assertEqual(list(a), list(range(10)))
         b = array.array(self.typecode, [20])
         self.assertEqual(a[-1] in a, True)
         self.assertEqual(b[0] not in a, True)
@@ -985,7 +985,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*tests)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_binascii.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_binascii.py	(original)
+++ python/branches/p3yk/Lib/test/test_binascii.py	Mon May  7 10:03:22 2007
@@ -9,7 +9,7 @@
     # Create binary test data
     data = "The quick brown fox jumps over the lazy dog.\r\n"
     # Be slow so we don't depend on other modules
-    data += "".join(map(chr, xrange(256)))
+    data += "".join(map(chr, range(256)))
     data += "\r\nHello world.\n"
 
     def test_exceptions(self):
@@ -58,7 +58,7 @@
 
         fillers = ""
         valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
-        for i in xrange(256):
+        for i in range(256):
             c = chr(i)
             if c not in valid:
                 fillers += c

Modified: python/branches/p3yk/Lib/test/test_bisect.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_bisect.py	(original)
+++ python/branches/p3yk/Lib/test/test_bisect.py	Mon May  7 10:03:22 2007
@@ -94,8 +94,8 @@
 
     def test_random(self, n=25):
         from random import randrange
-        for i in xrange(n):
-            data = [randrange(0, n, 2) for j in xrange(i)]
+        for i in range(n):
+            data = [randrange(0, n, 2) for j in range(i)]
             data.sort()
             elem = randrange(-1, n+1)
             ip = bisect_left(data, elem)
@@ -111,9 +111,9 @@
 
     def test_optionalSlicing(self):
         for func, data, elem, expected in self.precomputedCases:
-            for lo in xrange(4):
+            for lo in range(4):
                 lo = min(len(data), lo)
-                for hi in xrange(3,8):
+                for hi in range(3,8):
                     hi = min(len(data), hi)
                     ip = func(data, elem, lo, hi)
                     self.failUnless(lo <= ip <= hi)
@@ -147,7 +147,7 @@
     def test_vsBuiltinSort(self, n=500):
         from random import choice
         for insorted in (list(), UserList()):
-            for i in xrange(n):
+            for i in range(n):
                 digit = choice("0123456789")
                 if digit in "02468":
                     f = insort_left
@@ -248,7 +248,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_bsddb.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_bsddb.py	(original)
+++ python/branches/p3yk/Lib/test/test_bsddb.py	Mon May  7 10:03:22 2007
@@ -117,13 +117,13 @@
 
     def test_first_next_looping(self):
         items = [self.f.first()]
-        for i in xrange(1, len(self.f)):
+        for i in range(1, len(self.f)):
             items.append(self.f.next())
         self.assertSetEquals(items, self.d.items())
 
     def test_previous_last_looping(self):
         items = [self.f.last()]
-        for i in xrange(1, len(self.f)):
+        for i in range(1, len(self.f)):
             items.append(self.f.previous())
         self.assertSetEquals(items, self.d.items())
 

Modified: python/branches/p3yk/Lib/test/test_bufio.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_bufio.py	(original)
+++ python/branches/p3yk/Lib/test/test_bufio.py	Mon May  7 10:03:22 2007
@@ -5,8 +5,8 @@
 # the expected results.  For best testing, run this under a debug-build
 # Python too (to exercise asserts in the C code).
 
-lengths = range(1, 257) + [512, 1000, 1024, 2048, 4096, 8192, 10000,
-                           16384, 32768, 65536, 1000000]
+lengths = list(range(1, 257)) + [512, 1000, 1024, 2048, 4096, 8192, 10000,
+                                 16384, 32768, 65536, 1000000]
 
 class BufferSizeTest(unittest.TestCase):
     def try_one(self, s):

Modified: python/branches/p3yk/Lib/test/test_builtin.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_builtin.py	(original)
+++ python/branches/p3yk/Lib/test/test_builtin.py	Mon May  7 10:03:22 2007
@@ -993,7 +993,7 @@
             # thread for the details:
 
             #     http://sources.redhat.com/ml/newlib/2002/msg00369.html
-            self.assertRaises(MemoryError, list, xrange(sys.maxint // 2))
+            self.assertRaises(MemoryError, list, range(sys.maxint // 2))
 
         # This code used to segfault in Py2.4a3
         x = []
@@ -1457,38 +1457,39 @@
         self.assertRaises(TypeError, pow)
 
     def test_range(self):
-        self.assertEqual(range(3), [0, 1, 2])
-        self.assertEqual(range(1, 5), [1, 2, 3, 4])
-        self.assertEqual(range(0), [])
-        self.assertEqual(range(-3), [])
-        self.assertEqual(range(1, 10, 3), [1, 4, 7])
-        self.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
+        self.assertEqual(list(range(3)), [0, 1, 2])
+        self.assertEqual(list(range(1, 5)), [1, 2, 3, 4])
+        self.assertEqual(list(range(0)), [])
+        self.assertEqual(list(range(-3)), [])
+        self.assertEqual(list(range(1, 10, 3)), [1, 4, 7])
+        #self.assertEqual(list(range(5, -5, -3)), [5, 2, -1, -4])
 
+        """ XXX(nnorwitz):
         # Now test range() with longs
-        self.assertEqual(range(-2**100), [])
-        self.assertEqual(range(0, -2**100), [])
-        self.assertEqual(range(0, 2**100, -1), [])
-        self.assertEqual(range(0, 2**100, -1), [])
+        self.assertEqual(list(range(-2**100)), [])
+        self.assertEqual(list(range(0, -2**100)), [])
+        self.assertEqual(list(range(0, 2**100, -1)), [])
+        self.assertEqual(list(range(0, 2**100, -1)), [])
 
         a = int(10 * sys.maxint)
         b = int(100 * sys.maxint)
         c = int(50 * sys.maxint)
 
-        self.assertEqual(range(a, a+2), [a, a+1])
-        self.assertEqual(range(a+2, a, -1), [a+2, a+1])
-        self.assertEqual(range(a+4, a, -2), [a+4, a+2])
+        self.assertEqual(list(range(a, a+2)), [a, a+1])
+        self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1])
+        self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2])
 
-        seq = range(a, b, c)
+        seq = list(range(a, b, c))
         self.assert_(a in seq)
         self.assert_(b not in seq)
         self.assertEqual(len(seq), 2)
 
-        seq = range(b, a, -c)
+        seq = list(range(b, a, -c))
         self.assert_(b in seq)
         self.assert_(a not in seq)
         self.assertEqual(len(seq), 2)
 
-        seq = range(-a, -b, -c)
+        seq = list(range(-a, -b, -c))
         self.assert_(-a in seq)
         self.assert_(-b not in seq)
         self.assertEqual(len(seq), 2)
@@ -1505,6 +1506,7 @@
 
         # XXX This won't (but should!) raise RuntimeError if a is an int...
         self.assertRaises(RuntimeError, range, a, a + 1, badzero(1))
+        """
 
         # Reject floats when it would require PyLongs to represent.
         # (smaller floats still accepted, but deprecated)
@@ -1513,8 +1515,10 @@
         self.assertRaises(TypeError, range, 0, "spam")
         self.assertRaises(TypeError, range, 0, 42, "spam")
 
-        self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
-        self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
+        #NEAL self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
+        #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
+
+        self.assertRaises(OverflowError, len, range(0, sys.maxint**10))
 
     def test_input(self):
         self.write_testfile()
@@ -1633,8 +1637,8 @@
 
     def test_sum(self):
         self.assertEqual(sum([]), 0)
-        self.assertEqual(sum(range(2,8)), 27)
-        self.assertEqual(sum(iter(range(2,8))), 27)
+        self.assertEqual(sum(list(range(2,8))), 27)
+        self.assertEqual(sum(iter(list(range(2,8)))), 27)
         self.assertEqual(sum(Squares(10)), 285)
         self.assertEqual(sum(iter(Squares(10))), 285)
         self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
@@ -1731,7 +1735,7 @@
                 else:
                     return i
         self.assertEqual(
-            list(zip(SequenceWithoutALength(), xrange(2**30))),
+            list(zip(SequenceWithoutALength(), range(2**30))),
             list(enumerate(range(5)))
         )
 
@@ -1746,7 +1750,7 @@
 class TestSorted(unittest.TestCase):
 
     def test_basic(self):
-        data = range(100)
+        data = list(range(100))
         copy = data[:]
         random.shuffle(copy)
         self.assertEqual(data, sorted(copy))
@@ -1791,7 +1795,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_bz2.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_bz2.py	(original)
+++ python/branches/p3yk/Lib/test/test_bz2.py	Mon May  7 10:03:22 2007
@@ -230,7 +230,7 @@
     def testOpenDel(self):
         # "Test opening and deleting a file many times"
         self.createTempFile()
-        for i in xrange(10000):
+        for i in range(10000):
             o = BZ2File(self.filename)
             del o
 

Modified: python/branches/p3yk/Lib/test/test_calendar.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_calendar.py	(original)
+++ python/branches/p3yk/Lib/test/test_calendar.py	Mon May  7 10:03:22 2007
@@ -260,7 +260,7 @@
     def check_weeks(self, year, month, weeks):
         cal = calendar.monthcalendar(year, month)
         self.assertEqual(len(cal), len(weeks))
-        for i in xrange(len(weeks)):
+        for i in range(len(weeks)):
             self.assertEqual(weeks[i], sum(day != 0 for day in cal[i]))
 
 

Modified: python/branches/p3yk/Lib/test/test_codeccallbacks.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_codeccallbacks.py	(original)
+++ python/branches/p3yk/Lib/test/test_codeccallbacks.py	Mon May  7 10:03:22 2007
@@ -234,7 +234,7 @@
             if not isinstance(exc, UnicodeEncodeError) \
                and not isinstance(exc, UnicodeDecodeError):
                 raise TypeError("don't know how to handle %r" % exc)
-            l = [u"<%d>" % ord(exc.object[pos]) for pos in xrange(exc.start, exc.end)]
+            l = [u"<%d>" % ord(exc.object[pos]) for pos in range(exc.start, exc.end)]
             return (u"[%s]" % u"".join(l), exc.end)
 
         codecs.register_error("test.handler1", handler1)
@@ -242,7 +242,7 @@
         def handler2(exc):
             if not isinstance(exc, UnicodeDecodeError):
                 raise TypeError("don't know how to handle %r" % exc)
-            l = [u"<%d>" % ord(exc.object[pos]) for pos in xrange(exc.start, exc.end)]
+            l = [u"<%d>" % ord(exc.object[pos]) for pos in range(exc.start, exc.end)]
             return (u"[%s]" % u"".join(l), exc.end+1) # skip one character
 
         codecs.register_error("test.handler2", handler2)
@@ -308,13 +308,13 @@
         self.assertRaises(TypeError, exctype, *(args + ["too much"]))
         # check with one argument of the wrong type
         wrongargs = [ "spam", u"eggs", 42, 1.0, None ]
-        for i in xrange(len(args)):
+        for i in range(len(args)):
             for wrongarg in wrongargs:
                 if type(wrongarg) is type(args[i]):
                     continue
                 # build argument array
                 callargs = []
-                for j in xrange(len(args)):
+                for j in range(len(args)):
                     if i==j:
                         callargs.append(wrongarg)
                     else:

Modified: python/branches/p3yk/Lib/test/test_codecs.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_codecs.py	(original)
+++ python/branches/p3yk/Lib/test/test_codecs.py	Mon May  7 10:03:22 2007
@@ -25,7 +25,7 @@
 
 class MixInCheckStateHandling:
     def check_state_handling_decode(self, encoding, u, s):
-        for i in xrange(len(s)+1):
+        for i in range(len(s)+1):
             d = codecs.getincrementaldecoder(encoding)()
             part1 = d.decode(s[:i])
             state = d.getstate()
@@ -47,7 +47,7 @@
             self.assertEqual(u, part1+part2)
 
     def check_state_handling_encode(self, encoding, u, s):
-        for i in xrange(len(u)+1):
+        for i in range(len(u)+1):
             d = codecs.getincrementalencoder(encoding)()
             part1 = d.encode(u[:i])
             state = d.getstate()
@@ -135,17 +135,17 @@
 
         # Test lines where the first read might end with \r, so the
         # reader has to look ahead whether this is a lone \r or a \r\n
-        for size in xrange(80):
+        for size in range(80):
             for lineend in u"\n \r\n \r \u2028".split():
                 s = 10*(size*u"a" + lineend + u"xxx\n")
                 reader = getreader(s)
-                for i in xrange(10):
+                for i in range(10):
                     self.assertEqual(
                         reader.readline(keepends=True),
                         size*u"a" + lineend,
                     )
                 reader = getreader(s)
-                for i in xrange(10):
+                for i in range(10):
                     self.assertEqual(
                         reader.readline(keepends=False),
                         size*u"a",
@@ -1252,7 +1252,7 @@
             if encoding in broken_unicode_with_streams:
                 continue
             reader = codecs.getreader(encoding)(StringIO.StringIO(s.encode(encoding)))
-            for t in xrange(5):
+            for t in range(5):
                 # Test that calling seek resets the internal codec state and buffers
                 reader.seek(0, 0)
                 line = reader.readline()
@@ -1320,7 +1320,7 @@
             (u"ab", 3)
         )
 
-        allbytes = "".join(chr(i) for i in xrange(256))
+        allbytes = "".join(chr(i) for i in range(256))
         self.assertEquals(
             codecs.charmap_decode(allbytes, "ignore", u""),
             (u"", len(allbytes))

Modified: python/branches/p3yk/Lib/test/test_compile.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_compile.py	(original)
+++ python/branches/p3yk/Lib/test/test_compile.py	Mon May  7 10:03:22 2007
@@ -399,11 +399,11 @@
         # is the max. Ensure the result of too many annotations is a
         # SyntaxError.
         s = "def f((%s)): pass"
-        s %= ', '.join('a%d:%d' % (i,i) for i in xrange(65535))
+        s %= ', '.join('a%d:%d' % (i,i) for i in range(65535))
         self.assertRaises(SyntaxError, compile, s, '?', 'exec')
         # Test that the max # of annotations compiles.
         s = "def f((%s)): pass"
-        s %= ', '.join('a%d:%d' % (i,i) for i in xrange(65534))
+        s %= ', '.join('a%d:%d' % (i,i) for i in range(65534))
         compile(s, '?', 'exec')
 
     def test_mangling(self):

Modified: python/branches/p3yk/Lib/test/test_complex.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_complex.py	(original)
+++ python/branches/p3yk/Lib/test/test_complex.py	Mon May  7 10:03:22 2007
@@ -64,7 +64,7 @@
             self.assertClose(q, x)
 
     def test_truediv(self):
-        simple_real = [float(i) for i in xrange(-5, 6)]
+        simple_real = [float(i) for i in range(-5, 6)]
         simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
         for x in simple_complex:
             for y in simple_complex:
@@ -76,7 +76,7 @@
         self.check_div(complex(1e-200, 1e-200), 1+0j)
 
         # Just for fun.
-        for i in xrange(100):
+        for i in range(100):
             self.check_div(complex(random(), random()),
                            complex(random(), random()))
 
@@ -158,7 +158,7 @@
         self.assertRaises(ValueError, pow, a, b, 0)
 
     def test_boolcontext(self):
-        for i in xrange(100):
+        for i in range(100):
             self.assert_(complex(random() + 1e-6, random() + 1e-6))
         self.assert_(not complex(0.0, 0.0))
 
@@ -296,13 +296,13 @@
         self.assertRaises(TypeError, complex, complex2(1j))
 
     def test_hash(self):
-        for x in xrange(-30, 30):
+        for x in range(-30, 30):
             self.assertEqual(hash(x), hash(complex(x, 0)))
             x /= 3.0    # now check against floating point
             self.assertEqual(hash(x), hash(complex(x, 0.)))
 
     def test_abs(self):
-        nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]
+        nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)]
         for num in nums:
             self.assertAlmostEqual((num.real**2 + num.imag**2)  ** 0.5, abs(num))
 

Modified: python/branches/p3yk/Lib/test/test_contains.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_contains.py	(original)
+++ python/branches/p3yk/Lib/test/test_contains.py	Mon May  7 10:03:22 2007
@@ -86,7 +86,7 @@
     check(unicode('d') not in 'abc', "u'd' in 'abc'")
 
 # A collection of tests on builtin sequence types
-a = range(10)
+a = list(range(10))
 for i in a:
     check(i in a, "%r not in %r" % (i, a))
 check(16 not in a, "16 not in %r" % (a,))
@@ -105,7 +105,7 @@
     works when the list is modified during the check.
     """
 
-    aList = range(15)
+    aList = list(range(15))
 
     def __cmp__(self, other):
         if other == 12:

Modified: python/branches/p3yk/Lib/test/test_copy.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_copy.py	(original)
+++ python/branches/p3yk/Lib/test/test_copy.py	Mon May  7 10:03:22 2007
@@ -84,7 +84,7 @@
             pass
         tests = [None, 42, 2**100, 3.14, True, False, 1j,
                  "hello", u"hello\u1234", f.__code__,
-                 NewStyle, xrange(10), Classic, max]
+                 NewStyle, range(10), Classic, max]
         for x in tests:
             self.assert_(copy.copy(x) is x, repr(x))
 
@@ -257,7 +257,7 @@
             pass
         tests = [None, 42, 2**100, 3.14, True, False, 1j,
                  "hello", u"hello\u1234", f.__code__,
-                 NewStyle, xrange(10), Classic, max]
+                 NewStyle, range(10), Classic, max]
         for x in tests:
             self.assert_(copy.deepcopy(x) is x, repr(x))
 

Modified: python/branches/p3yk/Lib/test/test_csv.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_csv.py	(original)
+++ python/branches/p3yk/Lib/test/test_csv.py	Mon May  7 10:03:22 2007
@@ -909,7 +909,7 @@
         def test_create_read(self):
             delta = 0
             lastrc = sys.gettotalrefcount()
-            for i in xrange(20):
+            for i in range(20):
                 gc.collect()
                 self.assertEqual(gc.garbage, [])
                 rc = sys.gettotalrefcount()
@@ -925,7 +925,7 @@
             delta = 0
             lastrc = sys.gettotalrefcount()
             s = NUL()
-            for i in xrange(20):
+            for i in range(20):
                 gc.collect()
                 self.assertEqual(gc.garbage, [])
                 rc = sys.gettotalrefcount()
@@ -941,7 +941,7 @@
             delta = 0
             rows = ["a,b,c\r\n"]*5
             lastrc = sys.gettotalrefcount()
-            for i in xrange(20):
+            for i in range(20):
                 gc.collect()
                 self.assertEqual(gc.garbage, [])
                 rc = sys.gettotalrefcount()
@@ -958,7 +958,7 @@
             rows = [[1,2,3]]*5
             s = NUL()
             lastrc = sys.gettotalrefcount()
-            for i in xrange(20):
+            for i in range(20):
                 gc.collect()
                 self.assertEqual(gc.garbage, [])
                 rc = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_datetime.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_datetime.py	(original)
+++ python/branches/p3yk/Lib/test/test_datetime.py	Mon May  7 10:03:22 2007
@@ -569,7 +569,7 @@
 
         # Check first and last days of year spottily across the whole
         # range of years supported.
-        for year in xrange(MINYEAR, MAXYEAR+1, 7):
+        for year in range(MINYEAR, MAXYEAR+1, 7):
             # Verify (year, 1, 1) -> ordinal -> y, m, d is identity.
             d = self.theclass(year, 1, 1)
             n = d.toordinal()

Modified: python/branches/p3yk/Lib/test/test_decimal.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_decimal.py	(original)
+++ python/branches/p3yk/Lib/test/test_decimal.py	Mon May  7 10:03:22 2007
@@ -842,7 +842,7 @@
         self.assertNotEqual(da, object)
 
         # sortable
-        a = map(Decimal, xrange(100))
+        a = map(Decimal, range(100))
         b =  a[:]
         random.shuffle(a)
         a.sort()

Modified: python/branches/p3yk/Lib/test/test_deque.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_deque.py	(original)
+++ python/branches/p3yk/Lib/test/test_deque.py	Mon May  7 10:03:22 2007
@@ -29,23 +29,23 @@
 class TestBasic(unittest.TestCase):
 
     def test_basics(self):
-        d = deque(xrange(100))
-        d.__init__(xrange(100, 200))
-        for i in xrange(200, 400):
+        d = deque(range(100))
+        d.__init__(range(100, 200))
+        for i in range(200, 400):
             d.append(i)
-        for i in reversed(xrange(-200, 0)):
+        for i in reversed(range(-200, 0)):
             d.appendleft(i)
-        self.assertEqual(list(d), range(-200, 400))
+        self.assertEqual(list(d), list(range(-200, 400)))
         self.assertEqual(len(d), 600)
 
-        left = [d.popleft() for i in xrange(250)]
-        self.assertEqual(left, range(-200, 50))
-        self.assertEqual(list(d), range(50, 400))
+        left = [d.popleft() for i in range(250)]
+        self.assertEqual(left, list(range(-200, 50)))
+        self.assertEqual(list(d), list(range(50, 400)))
 
-        right = [d.pop() for i in xrange(250)]
+        right = [d.pop() for i in range(250)]
         right.reverse()
-        self.assertEqual(right, range(150, 400))
-        self.assertEqual(list(d), range(50, 150))
+        self.assertEqual(right, list(range(150, 400)))
+        self.assertEqual(list(d), list(range(50, 150)))
 
     def test_comparisons(self):
         d = deque('xabc'); d.popleft()
@@ -82,15 +82,15 @@
 
     def test_getitem(self):
         n = 200
-        d = deque(xrange(n))
-        l = range(n)
-        for i in xrange(n):
+        d = deque(range(n))
+        l = list(range(n))
+        for i in range(n):
             d.popleft()
             l.pop(0)
             if random.random() < 0.5:
                 d.append(i)
                 l.append(i)
-            for j in xrange(1-len(l), len(l)):
+            for j in range(1-len(l), len(l)):
                 assert d[j] == l[j]
 
         d = deque('superman')
@@ -102,22 +102,22 @@
 
     def test_setitem(self):
         n = 200
-        d = deque(xrange(n))
-        for i in xrange(n):
+        d = deque(range(n))
+        for i in range(n):
             d[i] = 10 * i
-        self.assertEqual(list(d), [10*i for i in xrange(n)])
+        self.assertEqual(list(d), [10*i for i in range(n)])
         l = list(d)
-        for i in xrange(1-n, 0, -1):
+        for i in range(1-n, 0, -1):
             d[i] = 7*i
             l[i] = 7*i
         self.assertEqual(list(d), l)
 
     def test_delitem(self):
         n = 500         # O(n**2) test, don't make this too big
-        d = deque(xrange(n))
+        d = deque(range(n))
         self.assertRaises(IndexError, d.__delitem__, -n-1)
         self.assertRaises(IndexError, d.__delitem__, n)
-        for i in xrange(n):
+        for i in range(n):
             self.assertEqual(len(d), n-i)
             j = random.randrange(-len(d), len(d))
             val = d[j]
@@ -140,11 +140,11 @@
         d.rotate()              # check default to 1
         self.assertEqual(tuple(d), s)
 
-        for i in xrange(n*3):
+        for i in range(n*3):
             d = deque(s)
             e = deque(d)
             d.rotate(i)         # check vs. rot(1) n times
-            for j in xrange(i):
+            for j in range(i):
                 e.rotate(1)
             self.assertEqual(tuple(d), tuple(e))
             d.rotate(-i)        # check that it works in reverse
@@ -152,11 +152,11 @@
             e.rotate(n-i)       # check that it wraps forward
             self.assertEqual(tuple(e), s)
 
-        for i in xrange(n*3):
+        for i in range(n*3):
             d = deque(s)
             e = deque(d)
             d.rotate(-i)
-            for j in xrange(i):
+            for j in range(i):
                 e.rotate(-1)    # check vs. rot(-1) n times
             self.assertEqual(tuple(d), tuple(e))
             d.rotate(i)         # check that it works in reverse
@@ -168,7 +168,7 @@
         e = deque(s)
         e.rotate(BIG+17)        # verify on long series of rotates
         dr = d.rotate
-        for i in xrange(BIG+17):
+        for i in range(BIG+17):
             dr()
         self.assertEqual(tuple(d), tuple(e))
 
@@ -201,7 +201,7 @@
         self.assertRaises(IndexError, d.popleft)
 
     def test_clear(self):
-        d = deque(xrange(100))
+        d = deque(range(100))
         self.assertEqual(len(d), 100)
         d.clear()
         self.assertEqual(len(d), 0)
@@ -234,14 +234,14 @@
             self.assertEqual(d, deque())
 
     def test_repr(self):
-        d = deque(xrange(200))
+        d = deque(range(200))
         e = eval(repr(d))
         self.assertEqual(list(d), list(e))
         d.append(d)
         self.assert_('...' in repr(d))
 
     def test_print(self):
-        d = deque(xrange(200))
+        d = deque(range(200))
         d.append(d)
         try:
             fo = open(test_support.TESTFN, "wb")
@@ -262,33 +262,34 @@
 
     def test_long_steadystate_queue_popleft(self):
         for size in (0, 1, 2, 100, 1000):
-            d = deque(xrange(size))
+            d = deque(range(size))
             append, pop = d.append, d.popleft
-            for i in xrange(size, BIG):
+            for i in range(size, BIG):
                 append(i)
                 x = pop()
                 if x != i - size:
                     self.assertEqual(x, i-size)
-            self.assertEqual(list(d), range(BIG-size, BIG))
+            self.assertEqual(list(d), list(range(BIG-size, BIG)))
 
     def test_long_steadystate_queue_popright(self):
         for size in (0, 1, 2, 100, 1000):
-            d = deque(reversed(xrange(size)))
+            d = deque(reversed(range(size)))
             append, pop = d.appendleft, d.pop
-            for i in xrange(size, BIG):
+            for i in range(size, BIG):
                 append(i)
                 x = pop()
                 if x != i - size:
                     self.assertEqual(x, i-size)
-            self.assertEqual(list(reversed(list(d))), range(BIG-size, BIG))
+            self.assertEqual(list(reversed(list(d))),
+                             list(range(BIG-size, BIG)))
 
     def test_big_queue_popleft(self):
         pass
         d = deque()
         append, pop = d.append, d.popleft
-        for i in xrange(BIG):
+        for i in range(BIG):
             append(i)
-        for i in xrange(BIG):
+        for i in range(BIG):
             x = pop()
             if x != i:
                 self.assertEqual(x, i)
@@ -296,9 +297,9 @@
     def test_big_queue_popright(self):
         d = deque()
         append, pop = d.appendleft, d.pop
-        for i in xrange(BIG):
+        for i in range(BIG):
             append(i)
-        for i in xrange(BIG):
+        for i in range(BIG):
             x = pop()
             if x != i:
                 self.assertEqual(x, i)
@@ -306,9 +307,9 @@
     def test_big_stack_right(self):
         d = deque()
         append, pop = d.append, d.pop
-        for i in xrange(BIG):
+        for i in range(BIG):
             append(i)
-        for i in reversed(xrange(BIG)):
+        for i in reversed(range(BIG)):
             x = pop()
             if x != i:
                 self.assertEqual(x, i)
@@ -317,22 +318,22 @@
     def test_big_stack_left(self):
         d = deque()
         append, pop = d.appendleft, d.popleft
-        for i in xrange(BIG):
+        for i in range(BIG):
             append(i)
-        for i in reversed(xrange(BIG)):
+        for i in reversed(range(BIG)):
             x = pop()
             if x != i:
                 self.assertEqual(x, i)
         self.assertEqual(len(d), 0)
 
     def test_roundtrip_iter_init(self):
-        d = deque(xrange(200))
+        d = deque(range(200))
         e = deque(d)
         self.assertNotEqual(id(d), id(e))
         self.assertEqual(list(d), list(e))
 
     def test_pickle(self):
-        d = deque(xrange(200))
+        d = deque(range(200))
         for i in (0, 1, 2):
             s = pickle.dumps(d, i)
             e = pickle.loads(s)
@@ -366,7 +367,7 @@
         self.assertEqual(list(d), list(e))
 
     def test_reversed(self):
-        for s in ('abcd', xrange(2000)):
+        for s in ('abcd', range(2000)):
             self.assertEqual(list(reversed(deque(s))), list(reversed(s)))
 
     def test_gc_doesnt_blowup(self):
@@ -374,14 +375,14 @@
         # This used to assert-fail in deque_traverse() under a debug
         # build, or run wild with a NULL pointer in a release build.
         d = deque()
-        for i in xrange(100):
+        for i in range(100):
             d.append(1)
             gc.collect()
 
 class TestVariousIteratorArgs(unittest.TestCase):
 
     def test_constructor(self):
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (seq_tests.Sequence, seq_tests.IterFunc,
                       seq_tests.IterGen, seq_tests.IterFuncStop,
                       seq_tests.itermulti, seq_tests.iterfunc):
@@ -412,23 +413,23 @@
 class TestSubclass(unittest.TestCase):
 
     def test_basics(self):
-        d = Deque(xrange(100))
-        d.__init__(xrange(100, 200))
-        for i in xrange(200, 400):
+        d = Deque(range(100))
+        d.__init__(range(100, 200))
+        for i in range(200, 400):
             d.append(i)
-        for i in reversed(xrange(-200, 0)):
+        for i in reversed(range(-200, 0)):
             d.appendleft(i)
-        self.assertEqual(list(d), range(-200, 400))
+        self.assertEqual(list(d), list(range(-200, 400)))
         self.assertEqual(len(d), 600)
 
-        left = [d.popleft() for i in xrange(250)]
-        self.assertEqual(left, range(-200, 50))
-        self.assertEqual(list(d), range(50, 400))
+        left = [d.popleft() for i in range(250)]
+        self.assertEqual(left, list(range(-200, 50)))
+        self.assertEqual(list(d), list(range(50, 400)))
 
-        right = [d.pop() for i in xrange(250)]
+        right = [d.pop() for i in range(250)]
         right.reverse()
-        self.assertEqual(right, range(150, 400))
-        self.assertEqual(list(d), range(50, 150))
+        self.assertEqual(right, list(range(150, 400)))
+        self.assertEqual(list(d), list(range(50, 150)))
 
         d.clear()
         self.assertEqual(len(d), 0)
@@ -618,7 +619,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_descr.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_descr.py	(original)
+++ python/branches/p3yk/Lib/test/test_descr.py	Mon May  7 10:03:22 2007
@@ -1181,7 +1181,7 @@
             return 0
     g = G()
     orig_objects = len(gc.get_objects())
-    for i in xrange(10):
+    for i in range(10):
         g==g
     new_objects = len(gc.get_objects())
     vereq(orig_objects, new_objects)
@@ -2363,24 +2363,24 @@
     class sublist(list):
         pass
     a = sublist(range(5))
-    vereq(a, range(5))
+    vereq(a, list(range(5)))
     a.append("hello")
-    vereq(a, range(5) + ["hello"])
+    vereq(a, list(range(5)) + ["hello"])
     a[5] = 5
-    vereq(a, range(6))
+    vereq(a, list(range(6)))
     a.extend(range(6, 20))
-    vereq(a, range(20))
+    vereq(a, list(range(20)))
     a[-5:] = []
-    vereq(a, range(15))
+    vereq(a, list(range(15)))
     del a[10:15]
     vereq(len(a), 10)
-    vereq(a, range(10))
-    vereq(list(a), range(10))
+    vereq(a, list(range(10)))
+    vereq(list(a), list(range(10)))
     vereq(a[0], 0)
     vereq(a[9], 9)
     vereq(a[-10], 0)
     vereq(a[-1], 9)
-    vereq(a[:5], range(5))
+    vereq(a[:5], list(range(5)))
 
     class CountedInput(file):
         """Counts lines read by self.readline().
@@ -2412,7 +2412,7 @@
         f.writelines(lines)
         f.close()
         f = CountedInput(TESTFN)
-        for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]):
+        for (i, expected) in zip(list(range(1, 5)) + [4], lines + 2 * [""]):
             got = f.readline()
             vereq(expected, got)
             vereq(f.lineno, i)
@@ -2439,7 +2439,7 @@
     vereq(str(object=500), '500')
     vereq(unicode(string='abc', errors='strict'), u'abc')
     vereq(tuple(sequence=range(3)), (0, 1, 2))
-    vereq(list(sequence=(0, 1, 2)), range(3))
+    vereq(list(sequence=(0, 1, 2)), list(range(3)))
     # note: as of Python 2.3, dict() no longer has an "items" keyword arg
 
     for constructor in (int, float, int, complex, str, unicode,
@@ -3502,7 +3502,7 @@
         def __init__(self, x):
             self.x = x
     o = None
-    for i in xrange(50000):
+    for i in range(50000):
         o = trash(o)
     del o
 
@@ -3959,7 +3959,7 @@
 def wrapper_segfault():
     # SF 927248: deeply nested wrappers could cause stack overflow
     f = lambda:None
-    for i in xrange(1000000):
+    for i in range(1000000):
         f = f.__call__
     f = None
 

Modified: python/branches/p3yk/Lib/test/test_dis.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_dis.py	(original)
+++ python/branches/p3yk/Lib/test/test_dis.py	Mon May  7 10:03:22 2007
@@ -144,12 +144,12 @@
             return namespace['foo']
 
         # Test all small ranges
-        for i in xrange(1, 300):
+        for i in range(1, 300):
             expected = _BIG_LINENO_FORMAT % (i + 2)
             self.do_disassembly_test(func(i), expected)
 
         # Test some larger ranges too
-        for i in xrange(300, 5000, 10):
+        for i in range(300, 5000, 10):
             expected = _BIG_LINENO_FORMAT % (i + 2)
             self.do_disassembly_test(func(i), expected)
 

Modified: python/branches/p3yk/Lib/test/test_doctest.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_doctest.py	(original)
+++ python/branches/p3yk/Lib/test/test_doctest.py	Mon May  7 10:03:22 2007
@@ -996,7 +996,7 @@
     (0, 1)
 
     An example from the docs:
-    >>> print(range(20)) #doctest: +NORMALIZE_WHITESPACE
+    >>> print(list(range(20))) #doctest: +NORMALIZE_WHITESPACE
     [0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
     10,  11, 12, 13, 14, 15, 16, 17, 18, 19]
 
@@ -1004,7 +1004,7 @@
 output to match any substring in the actual output:
 
     >>> def f(x):
-    ...     '>>> print(range(15))\n[0, 1, 2, ..., 14]\n'
+    ...     '>>> print(list(range(15)))\n[0, 1, 2, ..., 14]\n'
 
     >>> # Without the flag:
     >>> test = doctest.DocTestFinder().find(f)[0]
@@ -1013,7 +1013,7 @@
     **********************************************************************
     File ..., line 2, in f
     Failed example:
-        print(range(15))
+        print(list(range(15)))
     Expected:
         [0, 1, 2, ..., 14]
     Got:
@@ -1044,10 +1044,10 @@
 
     Examples from the docs:
 
-    >>> print(range(20)) # doctest:+ELLIPSIS
+    >>> print(list(range(20))) # doctest:+ELLIPSIS
     [0, 1, ..., 18, 19]
 
-    >>> print(range(20)) # doctest: +ELLIPSIS
+    >>> print(list(range(20))) # doctest: +ELLIPSIS
     ...                 # doctest: +NORMALIZE_WHITESPACE
     [0,    1, ...,   18,    19]
 
@@ -1302,10 +1302,10 @@
 example with a comment of the form ``# doctest: +OPTION``:
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))      # should fail: no ellipsis
+    ...     >>> print(list(range(10)))      # should fail: no ellipsis
     ...     [0, 1, ..., 9]
     ...
-    ...     >>> print(range(10))      # doctest: +ELLIPSIS
+    ...     >>> print(list(range(10)))      # doctest: +ELLIPSIS
     ...     [0, 1, ..., 9]
     ...     '''
     >>> test = doctest.DocTestFinder().find(f)[0]
@@ -1314,7 +1314,7 @@
     **********************************************************************
     File ..., line 2, in f
     Failed example:
-        print(range(10))      # should fail: no ellipsis
+        print(list(range(10)))      # should fail: no ellipsis
     Expected:
         [0, 1, ..., 9]
     Got:
@@ -1325,11 +1325,11 @@
 comment of the form ``# doctest: -OPTION``:
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))
+    ...     >>> print(list(range(10)))
     ...     [0, 1, ..., 9]
     ...
     ...     >>> # should fail: no ellipsis
-    ...     >>> print(range(10))      # doctest: -ELLIPSIS
+    ...     >>> print(list(range(10)))      # doctest: -ELLIPSIS
     ...     [0, 1, ..., 9]
     ...     '''
     >>> test = doctest.DocTestFinder().find(f)[0]
@@ -1339,7 +1339,7 @@
     **********************************************************************
     File ..., line 6, in f
     Failed example:
-        print(range(10))      # doctest: -ELLIPSIS
+        print(list(range(10)))      # doctest: -ELLIPSIS
     Expected:
         [0, 1, ..., 9]
     Got:
@@ -1350,13 +1350,13 @@
 do not change the options for surrounding examples:
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))      # Should fail: no ellipsis
+    ...     >>> print(list(range(10)))      # Should fail: no ellipsis
     ...     [0, 1, ..., 9]
     ...
-    ...     >>> print(range(10))      # doctest: +ELLIPSIS
+    ...     >>> print(list(range(10)))      # doctest: +ELLIPSIS
     ...     [0, 1, ..., 9]
     ...
-    ...     >>> print(range(10))      # Should fail: no ellipsis
+    ...     >>> print(list(range(10)))      # Should fail: no ellipsis
     ...     [0, 1, ..., 9]
     ...     '''
     >>> test = doctest.DocTestFinder().find(f)[0]
@@ -1365,7 +1365,7 @@
     **********************************************************************
     File ..., line 2, in f
     Failed example:
-        print(range(10))      # Should fail: no ellipsis
+        print(list(range(10)))      # Should fail: no ellipsis
     Expected:
         [0, 1, ..., 9]
     Got:
@@ -1373,7 +1373,7 @@
     **********************************************************************
     File ..., line 8, in f
     Failed example:
-        print(range(10))      # Should fail: no ellipsis
+        print(list(range(10)))      # Should fail: no ellipsis
     Expected:
         [0, 1, ..., 9]
     Got:
@@ -1384,9 +1384,9 @@
 may be separated by whitespace, commas, or both:
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))      # Should fail
+    ...     >>> print(list(range(10)))      # Should fail
     ...     [0, 1,  ...,   9]
-    ...     >>> print(range(10))      # Should succeed
+    ...     >>> print(list(range(10)))      # Should succeed
     ...     ... # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
     ...     [0, 1,  ...,   9]
     ...     '''
@@ -1396,7 +1396,7 @@
     **********************************************************************
     File ..., line 2, in f
     Failed example:
-        print(range(10))      # Should fail
+        print(list(range(10)))      # Should fail
     Expected:
         [0, 1,  ...,   9]
     Got:
@@ -1404,9 +1404,9 @@
     (1, 2)
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))      # Should fail
+    ...     >>> print(list(range(10)))      # Should fail
     ...     [0, 1,  ...,   9]
-    ...     >>> print(range(10))      # Should succeed
+    ...     >>> print(list(range(10)))      # Should succeed
     ...     ... # doctest: +ELLIPSIS,+NORMALIZE_WHITESPACE
     ...     [0, 1,  ...,   9]
     ...     '''
@@ -1416,7 +1416,7 @@
     **********************************************************************
     File ..., line 2, in f
     Failed example:
-        print(range(10))      # Should fail
+        print(list(range(10)))      # Should fail
     Expected:
         [0, 1,  ...,   9]
     Got:
@@ -1424,9 +1424,9 @@
     (1, 2)
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))      # Should fail
+    ...     >>> print(list(range(10)))      # Should fail
     ...     [0, 1,  ...,   9]
-    ...     >>> print(range(10))      # Should succeed
+    ...     >>> print(list(range(10)))      # Should succeed
     ...     ... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
     ...     [0, 1,  ...,   9]
     ...     '''
@@ -1436,7 +1436,7 @@
     **********************************************************************
     File ..., line 2, in f
     Failed example:
-        print(range(10))      # Should fail
+        print(list(range(10)))      # Should fail
     Expected:
         [0, 1,  ...,   9]
     Got:
@@ -1447,7 +1447,7 @@
 long as a continuation prompt is used:
 
     >>> def f(x): r'''
-    ...     >>> print(range(10))
+    ...     >>> print(list(range(10)))
     ...     ... # doctest: +ELLIPSIS
     ...     [0, 1, ..., 9]
     ...     '''

Modified: python/branches/p3yk/Lib/test/test_dummy_thread.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_dummy_thread.py	(original)
+++ python/branches/p3yk/Lib/test/test_dummy_thread.py	Mon May  7 10:03:22 2007
@@ -153,7 +153,7 @@
             print()
             print("*** Testing multiple thread creation "\
             "(will take approx. %s to %s sec.) ***" % (DELAY, thread_count))
-        for count in xrange(thread_count):
+        for count in range(thread_count):
             if DELAY:
                 local_delay = round(random.random(), 1)
             else:

Modified: python/branches/p3yk/Lib/test/test_enumerate.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_enumerate.py	(original)
+++ python/branches/p3yk/Lib/test/test_enumerate.py	Mon May  7 10:03:22 2007
@@ -134,18 +134,18 @@
                 raise StopIteration
             def __len__(self):
                 return 5
-        for data in 'abc', range(5), tuple(enumerate('abc')), A(), xrange(1,17,5):
+        for data in 'abc', range(5), tuple(enumerate('abc')), A(), range(1,17,5):
             self.assertEqual(list(data)[::-1], list(reversed(data)))
         self.assertRaises(TypeError, reversed, {})
 
-    def test_xrange_optimization(self):
-        x = xrange(1)
+    def test_range_optimization(self):
+        x = range(1)
         self.assertEqual(type(reversed(x)), type(iter(x)))
 
     def test_len(self):
         # This is an implementation detail, not an interface requirement
         from test.test_iterlen import len
-        for s in ('hello', tuple('hello'), list('hello'), xrange(5)):
+        for s in ('hello', tuple('hello'), list('hello'), range(5)):
             self.assertEqual(len(reversed(s)), len(s))
             r = reversed(s)
             list(r)
@@ -205,7 +205,7 @@
     import sys
     if verbose and hasattr(sys, "gettotalrefcount"):
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*testclasses)
             counts[i] = sys.gettotalrefcount()
         print(counts)

Modified: python/branches/p3yk/Lib/test/test_functools.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_functools.py	(original)
+++ python/branches/p3yk/Lib/test/test_functools.py	Mon May  7 10:03:22 2007
@@ -352,7 +352,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_gc.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_gc.py	(original)
+++ python/branches/p3yk/Lib/test/test_gc.py	Mon May  7 10:03:22 2007
@@ -399,7 +399,7 @@
 
         got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
         got.sort()
-        self.assertEqual(got, [0, 0] + range(5))
+        self.assertEqual(got, [0, 0] + list(range(5)))
 
         self.assertEqual(gc.get_referents(1, 'a', 4j), [])
 

Modified: python/branches/p3yk/Lib/test/test_generators.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_generators.py	(original)
+++ python/branches/p3yk/Lib/test/test_generators.py	Mon May  7 10:03:22 2007
@@ -343,7 +343,7 @@
 ...         for c in gcomb(rest, k):
 ...             yield c
 
->>> seq = range(1, 5)
+>>> seq = list(range(1, 5))
 >>> for k in range(len(seq) + 2):
 ...     print("%d-combs of %s:" % (k, seq))
 ...     for c in gcomb(seq, k):

Modified: python/branches/p3yk/Lib/test/test_genexps.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_genexps.py	(original)
+++ python/branches/p3yk/Lib/test/test_genexps.py	Mon May  7 10:03:22 2007
@@ -59,16 +59,16 @@
 Test running gen when defining function is out of scope
 
     >>> def f(n):
-    ...     return (i*i for i in xrange(n))
+    ...     return (i*i for i in range(n))
     >>> list(f(10))
     [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 
     >>> def f(n):
-    ...     return ((i,j) for i in xrange(3) for j in xrange(n))
+    ...     return ((i,j) for i in range(3) for j in range(n))
     >>> list(f(4))
     [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]
     >>> def f(n):
-    ...     return ((i,j) for i in xrange(3) for j in xrange(4) if j in xrange(n))
+    ...     return ((i,j) for i in range(3) for j in range(4) if j in range(n))
     >>> list(f(4))
     [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]
     >>> list(f(2))
@@ -77,21 +77,21 @@
 Verify that parenthesis are required in a statement
 
     >>> def f(n):
-    ...     return i*i for i in xrange(n)
+    ...     return i*i for i in range(n)
     Traceback (most recent call last):
        ...
     SyntaxError: invalid syntax
 
 Verify that parenthesis are required when used as a keyword argument value
 
-    >>> dict(a = i for i in xrange(10))
+    >>> dict(a = i for i in range(10))
     Traceback (most recent call last):
        ...
     SyntaxError: invalid syntax
 
 Verify that parenthesis are required when used as a keyword argument value
 
-    >>> dict(a = (i for i in xrange(10))) #doctest: +ELLIPSIS
+    >>> dict(a = (i for i in range(10))) #doctest: +ELLIPSIS
     {'a': <generator object at ...>}
 
 Verify early binding for the outermost for-expression
@@ -128,7 +128,7 @@
 
 Verify re-use of tuples (a side benefit of using genexps over listcomps)
 
-    >>> tupleids = map(id, ((i,i) for i in xrange(10)))
+    >>> tupleids = map(id, ((i,i) for i in range(10)))
     >>> int(max(tupleids) - min(tupleids))
     0
 
@@ -149,7 +149,7 @@
 
 Make a generator that acts like range()
 
-    >>> yrange = lambda n:  (i for i in xrange(n))
+    >>> yrange = lambda n:  (i for i in range(n))
     >>> list(yrange(10))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
@@ -181,14 +181,14 @@
 
 Verify that a gen exp cannot be resumed while it is actively running:
 
-    >>> g = (next(me) for i in xrange(10))
+    >>> g = (next(me) for i in range(10))
     >>> me = g
     >>> next(me)
     Traceback (most recent call last):
       File "<pyshell#30>", line 1, in -toplevel-
         next(me)
       File "<pyshell#28>", line 1, in <generator expression>
-        g = (next(me) for i in xrange(10))
+        g = (next(me) for i in range(10))
     ValueError: generator already executing
 
 Verify exception propagation
@@ -211,7 +211,7 @@
 
 Make sure that None is a valid return value
 
-    >>> list(None for i in xrange(10))
+    >>> list(None for i in range(10))
     [None, None, None, None, None, None, None, None, None, None]
 
 Check that generator attributes are present
@@ -270,7 +270,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_grp.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_grp.py	(original)
+++ python/branches/p3yk/Lib/test/test_grp.py	Mon May  7 10:03:22 2007
@@ -55,7 +55,7 @@
         fakename = allnames[namei]
         while fakename in bynames:
             chars = map(None, fakename)
-            for i in xrange(len(chars)):
+            for i in range(len(chars)):
                 if chars[i] == 'z':
                     chars[i] = 'A'
                     break

Modified: python/branches/p3yk/Lib/test/test_heapq.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_heapq.py	(original)
+++ python/branches/p3yk/Lib/test/test_heapq.py	Mon May  7 10:03:22 2007
@@ -90,7 +90,7 @@
 
     def test_heapsort(self):
         # Exercise everything with repeated heapsort checks
-        for trial in xrange(100):
+        for trial in range(100):
             size = random.randrange(50)
             data = [random.randrange(25) for i in range(size)]
             if trial & 1:     # Half of the time, use heapify
@@ -105,7 +105,7 @@
 
     def test_merge(self):
         inputs = []
-        for i in xrange(random.randrange(5)):
+        for i in range(random.randrange(5)):
             row = sorted(random.randrange(1000) for j in range(random.randrange(10)))
             inputs.append(row)
         self.assertEqual(sorted(chain(*inputs)), list(merge(*inputs)))
@@ -277,7 +277,7 @@
 
     def test_iterable_args(self):
         for f in  (nlargest, nsmallest):
-            for s in ("123", "", range(1000), (1, 1.2), xrange(2000,2200,5)):
+            for s in ("123", "", range(1000), (1, 1.2), range(2000,2200,5)):
                 for g in (G, I, Ig, L, R):
                     self.assertEqual(f(2, g(s)), f(2,s))
                 self.assertEqual(f(2, S(s)), [])
@@ -300,7 +300,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_index.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_index.py	(original)
+++ python/branches/p3yk/Lib/test/test_index.py	Mon May  7 10:03:22 2007
@@ -49,7 +49,7 @@
         self.assertEqual(self.n.__index__(), 5)
 
     def test_subclasses(self):
-        r = range(10)
+        r = list(range(10))
         self.assertEqual(r[TrapInt(5):TrapInt(10)], r[5:10])
         self.assertEqual(r[TrapLong(5):TrapLong(10)], r[5:10])
         self.assertEqual(slice(TrapInt()).indices(0), (0,0,1))
@@ -164,14 +164,6 @@
     seq = u"this is a test"
 
 
-class XRangeTestCase(unittest.TestCase):
-
-    def test_xrange(self):
-        n = newstyle()
-        n.ind = 5
-        self.assertEqual(xrange(1, 20)[n], 6)
-        self.assertEqual(xrange(1, 20).__getitem__(n), 6)
-
 class OverflowTestCase(unittest.TestCase):
 
     def setUp(self):
@@ -215,7 +207,6 @@
         TupleTestCase,
         StringTestCase,
         UnicodeTestCase,
-        XRangeTestCase,
         OverflowTestCase,
     )
 

Modified: python/branches/p3yk/Lib/test/test_io.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_io.py	(original)
+++ python/branches/p3yk/Lib/test/test_io.py	Mon May  7 10:03:22 2007
@@ -546,7 +546,7 @@
         wlines = []
         for size in (0, 1, 2, 3, 4, 5, 30, 31, 32, 33, 62, 63, 64, 65, 1000):
             chars = []
-            for i in xrange(size):
+            for i in range(size):
                 chars.append(sample[i % len(sample)])
             line = u"".join(chars) + "\n"
             wlines.append((f.tell(), line))

Modified: python/branches/p3yk/Lib/test/test_isinstance.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_isinstance.py	(original)
+++ python/branches/p3yk/Lib/test/test_isinstance.py	Mon May  7 10:03:22 2007
@@ -259,7 +259,7 @@
     # Make sure that calling isinstance with a deeply nested tuple for its
     # argument will raise RuntimeError eventually.
     tuple_arg = (compare_to,)
-    for cnt in xrange(sys.getrecursionlimit()+5):
+    for cnt in range(sys.getrecursionlimit()+5):
         tuple_arg = (tuple_arg,)
         fxn(arg, tuple_arg)
 

Modified: python/branches/p3yk/Lib/test/test_iter.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_iter.py	(original)
+++ python/branches/p3yk/Lib/test/test_iter.py	Mon May  7 10:03:22 2007
@@ -68,18 +68,18 @@
 
     # Test basic use of iter() function
     def test_iter_basic(self):
-        self.check_iterator(iter(range(10)), range(10))
+        self.check_iterator(iter(range(10)), list(range(10)))
 
     # Test that iter(iter(x)) is the same as iter(x)
     def test_iter_idempotency(self):
-        seq = range(10)
+        seq = list(range(10))
         it = iter(seq)
         it2 = iter(it)
         self.assert_(it is it2)
 
     # Test that for loops over iterators work
     def test_iter_for_loop(self):
-        self.check_for_loop(iter(range(10)), range(10))
+        self.check_for_loop(iter(range(10)), list(range(10)))
 
     # Test several independent iterators over the same list
     def test_iter_independence(self):
@@ -106,19 +106,19 @@
 
     # Test a class with __iter__ in a for loop
     def test_iter_class_for(self):
-        self.check_for_loop(IteratingSequenceClass(10), range(10))
+        self.check_for_loop(IteratingSequenceClass(10), list(range(10)))
 
     # Test a class with __iter__ with explicit iter()
     def test_iter_class_iter(self):
-        self.check_iterator(iter(IteratingSequenceClass(10)), range(10))
+        self.check_iterator(iter(IteratingSequenceClass(10)), list(range(10)))
 
     # Test for loop on a sequence class without __iter__
     def test_seq_class_for(self):
-        self.check_for_loop(SequenceClass(10), range(10))
+        self.check_for_loop(SequenceClass(10), list(range(10)))
 
     # Test iter() on a sequence class without __iter__
     def test_seq_class_iter(self):
-        self.check_iterator(iter(SequenceClass(10)), range(10))
+        self.check_iterator(iter(SequenceClass(10)), list(range(10)))
 
     # Test two-argument iter() with callable instance
     def test_iter_callable(self):
@@ -131,7 +131,7 @@
                 if i > 100:
                     raise IndexError # Emergency stop
                 return i
-        self.check_iterator(iter(C(), 10), range(10))
+        self.check_iterator(iter(C(), 10), list(range(10)))
 
     # Test two-argument iter() with function
     def test_iter_function(self):
@@ -139,7 +139,7 @@
             i = state[0]
             state[0] = i+1
             return i
-        self.check_iterator(iter(spam, 10), range(10))
+        self.check_iterator(iter(spam, 10), list(range(10)))
 
     # Test two-argument iter() with function that raises StopIteration
     def test_iter_function_stop(self):
@@ -149,7 +149,7 @@
                 raise StopIteration
             state[0] = i+1
             return i
-        self.check_iterator(iter(spam, 20), range(10))
+        self.check_iterator(iter(spam, 20), list(range(10)))
 
     # Test exception propagation through function iterator
     def test_exception_function(self):
@@ -164,7 +164,7 @@
             for x in iter(spam, 20):
                 res.append(x)
         except RuntimeError:
-            self.assertEqual(res, range(10))
+            self.assertEqual(res, list(range(10)))
         else:
             self.fail("should have raised RuntimeError")
 
@@ -180,7 +180,7 @@
             for x in MySequenceClass(20):
                 res.append(x)
         except RuntimeError:
-            self.assertEqual(res, range(10))
+            self.assertEqual(res, list(range(10)))
         else:
             self.fail("should have raised RuntimeError")
 
@@ -191,11 +191,11 @@
                 if i == 10:
                     raise StopIteration
                 return SequenceClass.__getitem__(self, i)
-        self.check_for_loop(MySequenceClass(20), range(10))
+        self.check_for_loop(MySequenceClass(20), list(range(10)))
 
     # Test a big range
     def test_iter_big_range(self):
-        self.check_for_loop(iter(range(10000)), range(10000))
+        self.check_for_loop(iter(range(10000)), list(range(10000)))
 
     # Test an empty list
     def test_iter_empty(self):
@@ -203,11 +203,11 @@
 
     # Test a tuple
     def test_iter_tuple(self):
-        self.check_for_loop(iter((0,1,2,3,4,5,6,7,8,9)), range(10))
+        self.check_for_loop(iter((0,1,2,3,4,5,6,7,8,9)), list(range(10)))
 
-    # Test an xrange
-    def test_iter_xrange(self):
-        self.check_for_loop(iter(xrange(10)), range(10))
+    # Test a range
+    def test_iter_range(self):
+        self.check_for_loop(iter(range(10)), list(range(10)))
 
     # Test a string
     def test_iter_string(self):
@@ -248,10 +248,9 @@
 
     # Test list()'s use of iterators.
     def test_builtin_list(self):
-        self.assertEqual(list(SequenceClass(5)), range(5))
+        self.assertEqual(list(SequenceClass(5)), list(range(5)))
         self.assertEqual(list(SequenceClass(0)), [])
         self.assertEqual(list(()), [])
-        self.assertEqual(list(range(10, -1, -1)), range(10, -1, -1))
 
         d = {"one": 1, "two": 2, "three": 3}
         self.assertEqual(list(d), list(d.keys()))
@@ -313,7 +312,7 @@
 
     # Test filter()'s use of iterators.
     def test_builtin_filter(self):
-        self.assertEqual(filter(None, SequenceClass(5)), range(1, 5))
+        self.assertEqual(filter(None, SequenceClass(5)), list(range(1, 5)))
         self.assertEqual(filter(None, SequenceClass(0)), [])
         self.assertEqual(filter(None, ()), ())
         self.assertEqual(filter(None, "abc"), "abc")
@@ -389,8 +388,8 @@
 
     # Test map()'s use of iterators.
     def test_builtin_map(self):
-        self.assertEqual(map(None, SequenceClass(5)), range(5))
-        self.assertEqual(map(lambda x: x+1, SequenceClass(5)), range(1, 6))
+        self.assertEqual(map(None, SequenceClass(5)), list(range(5)))
+        self.assertEqual(map(lambda x: x+1, SequenceClass(5)), list(range(1, 6)))
 
         d = {"one": 1, "two": 2, "three": 3}
         self.assertEqual(map(None, d), list(d.keys()))
@@ -413,7 +412,7 @@
             f.close()
         f = open(TESTFN, "r")
         try:
-            self.assertEqual(map(len, f), range(1, 21, 2))
+            self.assertEqual(map(len, f), list(range(1, 21, 2)))
         finally:
             f.close()
             try:
@@ -470,7 +469,7 @@
             except OSError:
                 pass
 
-        self.assertEqual(list(zip(xrange(5))), [(i,) for i in range(5)])
+        self.assertEqual(list(zip(range(5))), [(i,) for i in range(5)])
 
         # Classes that lie about their lengths.
         class NoGuessLen5:
@@ -799,16 +798,16 @@
 
     def test_sinkstate_list(self):
         # This used to fail
-        a = range(5)
+        a = list(range(5))
         b = iter(a)
-        self.assertEqual(list(b), range(5))
+        self.assertEqual(list(b), list(range(5)))
         a.extend(range(5, 10))
         self.assertEqual(list(b), [])
 
     def test_sinkstate_tuple(self):
         a = (0, 1, 2, 3, 4)
         b = iter(a)
-        self.assertEqual(list(b), range(5))
+        self.assertEqual(list(b), list(range(5)))
         self.assertEqual(list(b), [])
 
     def test_sinkstate_string(self):
@@ -821,7 +820,7 @@
         # This used to fail
         a = SequenceClass(5)
         b = iter(a)
-        self.assertEqual(list(b), range(5))
+        self.assertEqual(list(b), list(range(5)))
         a.n = 10
         self.assertEqual(list(b), [])
 
@@ -834,7 +833,7 @@
                 raise AssertionError, "shouldn't have gotten this far"
             return i
         b = iter(spam, 5)
-        self.assertEqual(list(b), range(5))
+        self.assertEqual(list(b), list(range(5)))
         self.assertEqual(list(b), [])
 
     def test_sinkstate_dict(self):
@@ -851,13 +850,13 @@
             for i in range(5):
                 yield i
         b = gen()
-        self.assertEqual(list(b), range(5))
+        self.assertEqual(list(b), list(range(5)))
         self.assertEqual(list(b), [])
 
     def test_sinkstate_range(self):
-        a = xrange(5)
+        a = range(5)
         b = iter(a)
-        self.assertEqual(list(b), range(5))
+        self.assertEqual(list(b), list(range(5)))
         self.assertEqual(list(b), [])
 
     def test_sinkstate_enumerate(self):

Modified: python/branches/p3yk/Lib/test/test_iterlen.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_iterlen.py	(original)
+++ python/branches/p3yk/Lib/test/test_iterlen.py	Mon May  7 10:03:22 2007
@@ -9,14 +9,14 @@
 
 A complication is that an iterable and iterator can be the same object. To
 maintain the invariant, an iterator needs to dynamically update its length.
-For instance, an iterable such as xrange(10) always reports its length as ten,
-but it=iter(xrange(10)) starts at ten, and then goes to nine after next(it).
+For instance, an iterable such as range(10) always reports its length as ten,
+but it=iter(range(10)) starts at ten, and then goes to nine after next(it).
 Having this capability means that map() can ignore the distinction between
 map(func, iterable) and map(func, iter(iterable)).
 
 When the iterable is immutable, the implementation can straight-forwardly
 report the original length minus the cumulative number of calls to next().
-This is the case for tuples, xrange objects, and itertools.repeat().
+This is the case for tuples, range objects, and itertools.repeat().
 
 Some containers become temporarily immutable during iteration.  This includes
 dicts, sets, and collections.deque.  Their implementation is equally simple
@@ -65,7 +65,7 @@
 
     def test_invariant(self):
         it = self.it
-        for i in reversed(xrange(1, n+1)):
+        for i in reversed(range(1, n+1)):
             self.assertEqual(len(it), i)
             next(it)
         self.assertEqual(len(it), 0)
@@ -100,59 +100,59 @@
 class TestXrange(TestInvariantWithoutMutations):
 
     def setUp(self):
-        self.it = iter(xrange(n))
+        self.it = iter(range(n))
 
 class TestXrangeCustomReversed(TestInvariantWithoutMutations):
 
     def setUp(self):
-        self.it = reversed(xrange(n))
+        self.it = reversed(range(n))
 
 class TestTuple(TestInvariantWithoutMutations):
 
     def setUp(self):
-        self.it = iter(tuple(xrange(n)))
+        self.it = iter(tuple(range(n)))
 
 ## ------- Types that should not be mutated during iteration -------
 
 class TestDeque(TestTemporarilyImmutable):
 
     def setUp(self):
-        d = deque(xrange(n))
+        d = deque(range(n))
         self.it = iter(d)
         self.mutate = d.pop
 
 class TestDequeReversed(TestTemporarilyImmutable):
 
     def setUp(self):
-        d = deque(xrange(n))
+        d = deque(range(n))
         self.it = reversed(d)
         self.mutate = d.pop
 
 class TestDictKeys(TestTemporarilyImmutable):
 
     def setUp(self):
-        d = dict.fromkeys(xrange(n))
+        d = dict.fromkeys(range(n))
         self.it = iter(d)
         self.mutate = d.popitem
 
 class TestDictItems(TestTemporarilyImmutable):
 
     def setUp(self):
-        d = dict.fromkeys(xrange(n))
+        d = dict.fromkeys(range(n))
         self.it = iter(d.items())
         self.mutate = d.popitem
 
 class TestDictValues(TestTemporarilyImmutable):
 
     def setUp(self):
-        d = dict.fromkeys(xrange(n))
+        d = dict.fromkeys(range(n))
         self.it = iter(d.values())
         self.mutate = d.popitem
 
 class TestSet(TestTemporarilyImmutable):
 
     def setUp(self):
-        d = set(xrange(n))
+        d = set(range(n))
         self.it = iter(d)
         self.mutate = d.pop
 
@@ -164,7 +164,7 @@
         self.it = iter(range(n))
 
     def test_mutation(self):
-        d = range(n)
+        d = list(range(n))
         it = iter(d)
         next(it)
         next(it)
@@ -174,7 +174,7 @@
         d[1:] = []
         self.assertEqual(len(it), 0)
         self.assertEqual(list(it), [])
-        d.extend(xrange(20))
+        d.extend(range(20))
         self.assertEqual(len(it), 0)
 
 class TestListReversed(TestInvariantWithoutMutations):
@@ -183,7 +183,7 @@
         self.it = reversed(range(n))
 
     def test_mutation(self):
-        d = range(n)
+        d = list(range(n))
         it = reversed(d)
         next(it)
         next(it)
@@ -193,7 +193,7 @@
         d[1:] = []
         self.assertEqual(len(it), 0)
         self.assertEqual(list(it), [])  # confirm invariant
-        d.extend(xrange(20))
+        d.extend(range(20))
         self.assertEqual(len(it), 0)
 
 class TestSeqIter(TestInvariantWithoutMutations):
@@ -212,7 +212,7 @@
         d[1:] = []
         self.assertEqual(len(it), 0)
         self.assertEqual(list(it), [])
-        d.extend(xrange(20))
+        d.extend(range(20))
         self.assertEqual(len(it), 0)
 
 class TestSeqIterReversed(TestInvariantWithoutMutations):
@@ -231,7 +231,7 @@
         d[1:] = []
         self.assertEqual(len(it), 0)
         self.assertEqual(list(it), [])  # confirm invariant
-        d.extend(xrange(20))
+        d.extend(range(20))
         self.assertEqual(len(it), 0)
 
 

Modified: python/branches/p3yk/Lib/test/test_itertools.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_itertools.py	(original)
+++ python/branches/p3yk/Lib/test/test_itertools.py	Mon May  7 10:03:22 2007
@@ -248,7 +248,7 @@
         self.assertEqual(len(dict.fromkeys(ids)), len(ids))
 
     def test_repeat(self):
-        self.assertEqual(lzip(xrange(3),repeat('a')),
+        self.assertEqual(lzip(range(3),repeat('a')),
                          [(0, 'a'), (1, 'a'), (2, 'a')])
         self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a'])
         self.assertEqual(take(3, repeat('a')), ['a', 'a', 'a'])
@@ -301,39 +301,41 @@
                 (10, 3),
                 (20,)
                 ]:
-            self.assertEqual(list(islice(xrange(100), *args)), range(*args))
+            self.assertEqual(list(islice(range(100), *args)),
+                             list(range(*args)))
 
         for args, tgtargs in [  # Stop when seqn is exhausted
                 ((10, 110, 3), ((10, 100, 3))),
                 ((10, 110), ((10, 100))),
                 ((110,), (100,))
                 ]:
-            self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs))
+            self.assertEqual(list(islice(range(100), *args)),
+                             list(range(*tgtargs)))
 
         # Test stop=None
-        self.assertEqual(list(islice(xrange(10), None)), range(10))
-        self.assertEqual(list(islice(xrange(10), None, None)), range(10))
-        self.assertEqual(list(islice(xrange(10), None, None, None)), range(10))
-        self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10))
-        self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2))
+        self.assertEqual(list(islice(range(10), None)), list(range(10)))
+        self.assertEqual(list(islice(range(10), None, None)), list(range(10)))
+        self.assertEqual(list(islice(range(10), None, None, None)), list(range(10)))
+        self.assertEqual(list(islice(range(10), 2, None)), list(range(2, 10)))
+        self.assertEqual(list(islice(range(10), 1, None, 2)), list(range(1, 10, 2)))
 
         # Test number of items consumed     SF #1171417
         it = iter(range(10))
-        self.assertEqual(list(islice(it, 3)), range(3))
-        self.assertEqual(list(it), range(3, 10))
+        self.assertEqual(list(islice(it, 3)), list(range(3)))
+        self.assertEqual(list(it), list(range(3, 10)))
 
         # Test invalid arguments
-        self.assertRaises(TypeError, islice, xrange(10))
-        self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4)
-        self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1)
-        self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1)
-        self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1)
-        self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0)
-        self.assertRaises(ValueError, islice, xrange(10), 'a')
-        self.assertRaises(ValueError, islice, xrange(10), 'a', 1)
-        self.assertRaises(ValueError, islice, xrange(10), 1, 'a')
-        self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1)
-        self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1)
+        self.assertRaises(TypeError, islice, range(10))
+        self.assertRaises(TypeError, islice, range(10), 1, 2, 3, 4)
+        self.assertRaises(ValueError, islice, range(10), -5, 10, 1)
+        self.assertRaises(ValueError, islice, range(10), 1, -5, -1)
+        self.assertRaises(ValueError, islice, range(10), 1, 10, -1)
+        self.assertRaises(ValueError, islice, range(10), 1, 10, 0)
+        self.assertRaises(ValueError, islice, range(10), 'a')
+        self.assertRaises(ValueError, islice, range(10), 'a', 1)
+        self.assertRaises(ValueError, islice, range(10), 1, 'a')
+        self.assertRaises(ValueError, islice, range(10), 'a', 1, 1)
+        self.assertRaises(ValueError, islice, range(10), 1, 'a', 1)
         self.assertEqual(len(list(islice(count(), 1, 10, sys.maxint))), 1)
 
     def test_takewhile(self):
@@ -364,7 +366,7 @@
     def test_tee(self):
         n = 200
         def irange(n):
-            for i in xrange(n):
+            for i in range(n):
                 yield i
 
         a, b = tee([])        # test empty iterator
@@ -375,22 +377,22 @@
         self.assertEqual(lzip(a,b), lzip(range(n), range(n)))
 
         a, b = tee(irange(n)) # test 0% interleaved
-        self.assertEqual(list(a), range(n))
-        self.assertEqual(list(b), range(n))
+        self.assertEqual(list(a), list(range(n)))
+        self.assertEqual(list(b), list(range(n)))
 
         a, b = tee(irange(n)) # test dealloc of leading iterator
-        for i in xrange(100):
+        for i in range(100):
             self.assertEqual(next(a), i)
         del a
-        self.assertEqual(list(b), range(n))
+        self.assertEqual(list(b), list(range(n)))
 
         a, b = tee(irange(n)) # test dealloc of trailing iterator
-        for i in xrange(100):
+        for i in range(100):
             self.assertEqual(next(a), i)
         del b
-        self.assertEqual(list(a), range(100, n))
+        self.assertEqual(list(a), list(range(100, n)))
 
-        for j in xrange(5):   # test randomly interleaved
+        for j in range(5):   # test randomly interleaved
             order = [0]*n + [1]*n
             random.shuffle(order)
             lists = ([], [])
@@ -398,8 +400,8 @@
             for i in order:
                 value = next(its[i])
                 lists[i].append(value)
-            self.assertEqual(lists[0], range(n))
-            self.assertEqual(lists[1], range(n))
+            self.assertEqual(lists[0], list(range(n)))
+            self.assertEqual(lists[1], list(range(n)))
 
         # test argument format checking
         self.assertRaises(TypeError, tee)
@@ -413,18 +415,18 @@
         self.assertEqual(list(c), list('def'))
 
         # test long-lagged and multi-way split
-        a, b, c = tee(xrange(2000), 3)
-        for i in xrange(100):
+        a, b, c = tee(range(2000), 3)
+        for i in range(100):
             self.assertEqual(next(a), i)
-        self.assertEqual(list(b), range(2000))
-        self.assertEqual([next(c), next(c)], range(2))
-        self.assertEqual(list(a), range(100,2000))
-        self.assertEqual(list(c), range(2,2000))
+        self.assertEqual(list(b), list(range(2000)))
+        self.assertEqual([next(c), next(c)], list(range(2)))
+        self.assertEqual(list(a), list(range(100,2000)))
+        self.assertEqual(list(c), list(range(2,2000)))
 
         # test values of n
         self.assertRaises(TypeError, tee, 'abc', 'invalid')
         self.assertRaises(ValueError, tee, [], -1)
-        for n in xrange(5):
+        for n in range(5):
             result = tee('abc', n)
             self.assertEqual(type(result), tuple)
             self.assertEqual(len(result), n)
@@ -444,7 +446,7 @@
         self.assert_(list(t1) == list(t2) == list(t3) == list('abc'))
 
         # test that tee objects are weak referencable
-        a, b = tee(xrange(10))
+        a, b = tee(range(10))
         p = proxy(a)
         self.assertEqual(getattr(p, '__class__'), type(b))
         del a
@@ -608,7 +610,7 @@
 class TestVariousIteratorArgs(unittest.TestCase):
 
     def test_chain(self):
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(chain(g(s))), list(g(s)))
                 self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s)))
@@ -617,7 +619,7 @@
             self.assertRaises(ZeroDivisionError, list, chain(E(s)))
 
     def test_cycle(self):
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 tgtlen = len(s) * 3
                 expected = list(g(s))*3
@@ -628,7 +630,7 @@
             self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
 
     def test_groupby(self):
-        for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
+        for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual([k for k, sb in groupby(g(s))], list(g(s)))
             self.assertRaises(TypeError, groupby, X(s))
@@ -636,7 +638,7 @@
             self.assertRaises(ZeroDivisionError, list, groupby(E(s)))
 
     def test_ifilter(self):
-        for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
+        for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s)))
             self.assertRaises(TypeError, ifilter, isEven, X(s))
@@ -644,7 +646,7 @@
             self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s)))
 
     def test_ifilterfalse(self):
-        for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
+        for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s)))
             self.assertRaises(TypeError, ifilterfalse, isEven, X(s))
@@ -652,7 +654,7 @@
             self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s)))
 
     def test_izip(self):
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(izip(g(s))), lzip(g(s)))
                 self.assertEqual(list(izip(g(s), g(s))), lzip(g(s), g(s)))
@@ -661,7 +663,7 @@
             self.assertRaises(ZeroDivisionError, list, izip(E(s)))
 
     def test_iziplongest(self):
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(izip_longest(g(s))), list(zip(g(s))))
                 self.assertEqual(list(izip_longest(g(s), g(s))), list(zip(g(s), g(s))))
@@ -670,7 +672,7 @@
             self.assertRaises(ZeroDivisionError, list, izip_longest(E(s)))
 
     def test_imap(self):
-        for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)):
+        for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s)))
                 self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s)))
@@ -679,7 +681,7 @@
             self.assertRaises(ZeroDivisionError, list, imap(onearg, E(s)))
 
     def test_islice(self):
-        for s in ("12345", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("12345", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2])
             self.assertRaises(TypeError, islice, X(s), 10)
@@ -687,7 +689,7 @@
             self.assertRaises(ZeroDivisionError, list, islice(E(s), 10))
 
     def test_starmap(self):
-        for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)):
+        for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
             for g in (G, I, Ig, S, L, R):
                 ss = lzip(s, s)
                 self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s)))
@@ -696,7 +698,7 @@
             self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
 
     def test_takewhile(self):
-        for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
+        for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 tgt = []
                 for elem in g(s):
@@ -708,7 +710,7 @@
             self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s)))
 
     def test_dropwhile(self):
-        for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
+        for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 tgt = []
                 for elem in g(s):
@@ -720,7 +722,7 @@
             self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s)))
 
     def test_tee(self):
-        for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+        for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
             for g in (G, I, Ig, S, L, R):
                 it1, it2 = tee(g(s))
                 self.assertEqual(list(it1), list(g(s)))
@@ -824,7 +826,7 @@
 Check 1202 is for $823.14
 
 >>> import operator
->>> for cube in imap(operator.pow, xrange(1,4), repeat(3)):
+>>> for cube in imap(operator.pow, range(1,4), repeat(3)):
 ...    print(cube)
 ...
 1
@@ -968,7 +970,7 @@
 >>> no([1, 2, 5, 9], lambda x: x%2==0)
 False
 
->>> quantify(xrange(99), lambda x: x%2==0)
+>>> quantify(range(99), lambda x: x%2==0)
 50
 
 >>> a = [[1, 2, 3], [4, 5, 6]]
@@ -1014,7 +1016,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_list.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_list.py	(original)
+++ python/branches/p3yk/Lib/test/test_list.py	Mon May  7 10:03:22 2007
@@ -26,7 +26,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(ListTest)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_listcomps.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_listcomps.py	(original)
+++ python/branches/p3yk/Lib/test/test_listcomps.py	Mon May  7 10:03:22 2007
@@ -43,20 +43,20 @@
 Make a nested list comprehension that acts like range()
 
     >>> def frange(n):
-    ...     return [i for i in xrange(n)]
+    ...     return [i for i in range(n)]
     >>> frange(10)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Same again, only as a lambda expression instead of a function definition
 
-    >>> lrange = lambda n:  [i for i in xrange(n)]
+    >>> lrange = lambda n:  [i for i in range(n)]
     >>> lrange(10)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Generators can call other generators:
 
     >>> def grange(n):
-    ...     for x in [i for i in xrange(n)]:
+    ...     for x in [i for i in range(n)]:
     ...         yield x
     >>> list(grange(5))
     [0, 1, 2, 3, 4]
@@ -64,7 +64,7 @@
 
 Make sure that None is a valid return value
 
-    >>> [None for i in xrange(10)]
+    >>> [None for i in range(10)]
     [None, None, None, None, None, None, None, None, None, None]
 
 ########### Tests for various scoping corner cases ############
@@ -138,7 +138,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()
@@ -191,20 +191,20 @@
 Make a nested list comprehension that acts like range()
 
     >>> def frange(n):
-    ...     return [i for i in xrange(n)]
+    ...     return [i for i in range(n)]
     >>> frange(10)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Same again, only as a lambda expression instead of a function definition
 
-    >>> lrange = lambda n:  [i for i in xrange(n)]
+    >>> lrange = lambda n:  [i for i in range(n)]
     >>> lrange(10)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Generators can call other generators:
 
     >>> def grange(n):
-    ...     for x in [i for i in xrange(n)]:
+    ...     for x in [i for i in range(n)]:
     ...         yield x
     >>> list(grange(5))
     [0, 1, 2, 3, 4]
@@ -212,7 +212,7 @@
 
 Make sure that None is a valid return value
 
-    >>> [None for i in xrange(10)]
+    >>> [None for i in range(10)]
     [None, None, None, None, None, None, None, None, None, None]
 
 ########### Tests for various scoping corner cases ############
@@ -286,7 +286,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()
@@ -339,20 +339,20 @@
 Make a nested list comprehension that acts like range()
 
     >>> def frange(n):
-    ...     return [i for i in xrange(n)]
+    ...     return [i for i in range(n)]
     >>> frange(10)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Same again, only as a lambda expression instead of a function definition
 
-    >>> lrange = lambda n:  [i for i in xrange(n)]
+    >>> lrange = lambda n:  [i for i in range(n)]
     >>> lrange(10)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Generators can call other generators:
 
     >>> def grange(n):
-    ...     for x in [i for i in xrange(n)]:
+    ...     for x in [i for i in range(n)]:
     ...         yield x
     >>> list(grange(5))
     [0, 1, 2, 3, 4]
@@ -360,7 +360,7 @@
 
 Make sure that None is a valid return value
 
-    >>> [None for i in xrange(10)]
+    >>> [None for i in range(10)]
     [None, None, None, None, None, None, None, None, None, None]
 
 ########### Tests for various scoping corner cases ############
@@ -434,7 +434,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_logging.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_logging.py	(original)
+++ python/branches/p3yk/Lib/test/test_logging.py	Mon May  7 10:03:22 2007
@@ -355,7 +355,7 @@
     logger.info("Info message")
     message("-- logging at WARNING, 3 messages should be seen --")
     logger.warn("Warn message")
-    for i in xrange(102):
+    for i in range(102):
         message(MSG % i)
         logger.info("Info index = %d", i)
     mh.close()

Modified: python/branches/p3yk/Lib/test/test_long.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_long.py	(original)
+++ python/branches/p3yk/Lib/test/test_long.py	Mon May  7 10:03:22 2007
@@ -71,7 +71,7 @@
 
     def getran2(ndigits):
         answer = 0
-        for i in xrange(ndigits):
+        for i in range(ndigits):
             answer = (answer << SHIFT) | random.randint(0, MASK)
         if random.random() < 0.5:
             answer = -answer
@@ -92,8 +92,8 @@
             self.assert_(y < r <= 0, Frm("bad mod from divmod on %r and %r", x, y))
 
     def test_division(self):
-        digits = range(1, MAXDIGITS+1) + range(KARATSUBA_CUTOFF,
-                                               KARATSUBA_CUTOFF + 14)
+        digits = list(range(1, MAXDIGITS+1)) + list(range(KARATSUBA_CUTOFF,
+                                                      KARATSUBA_CUTOFF + 14))
         digits.append(KARATSUBA_CUTOFF * 3)
         for lenx in digits:
             x = self.getran(lenx)
@@ -102,7 +102,8 @@
                 self.check_division(x, y)
 
     def test_karatsuba(self):
-        digits = range(1, 5) + range(KARATSUBA_CUTOFF, KARATSUBA_CUTOFF + 10)
+        digits = list(range(1, 5)) + list(range(KARATSUBA_CUTOFF,
+                                                KARATSUBA_CUTOFF + 10))
         digits.extend([KARATSUBA_CUTOFF * 10, KARATSUBA_CUTOFF * 100])
 
         bits = [digit * SHIFT for digit in digits]
@@ -140,7 +141,7 @@
         eq(x ^ ~x, -1, Frm("x ^ ~x != -1 for x=%r", x))
         eq(-x, 1 + ~x, Frm("not -x == 1 + ~x for x=%r", x))
         eq(-x, ~(x-1), Frm("not -x == ~(x-1) forx =%r", x))
-        for n in xrange(2*SHIFT):
+        for n in range(2*SHIFT):
             p2 = 2 ** n
             eq(x << n >> n, x,
                 Frm("x << n >> n != x for x=%r, n=%r", (x, n)))
@@ -184,7 +185,7 @@
     def test_bitop_identities(self):
         for x in special:
             self.check_bitop_identities_1(x)
-        digits = xrange(1, MAXDIGITS+1)
+        digits = range(1, MAXDIGITS+1)
         for lenx in digits:
             x = self.getran(lenx)
             self.check_bitop_identities_1(x)
@@ -229,8 +230,8 @@
     def test_format(self):
         for x in special:
             self.check_format_1(x)
-        for i in xrange(10):
-            for lenx in xrange(1, MAXDIGITS+1):
+        for i in range(10):
+            for lenx in range(1, MAXDIGITS+1):
                 x = self.getran(lenx)
                 self.check_format_1(x)
 
@@ -399,7 +400,7 @@
 
         LOG10E = math.log10(math.e)
 
-        for exp in range(10) + [100, 1000, 10000]:
+        for exp in list(range(10)) + [100, 1000, 10000]:
             value = 10 ** exp
             log10 = math.log10(value)
             self.assertAlmostEqual(log10, exp)

Modified: python/branches/p3yk/Lib/test/test_mailbox.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_mailbox.py	(original)
+++ python/branches/p3yk/Lib/test/test_mailbox.py	Mon May  7 10:03:22 2007
@@ -208,7 +208,7 @@
         for value in method():
             self.fail("Not empty")
         keys, values = [], []
-        for i in xrange(repetitions):
+        for i in range(repetitions):
             keys.append(self._box.add(self._template % i))
             values.append(self._template % i)
         if do_keys and not do_values:
@@ -254,11 +254,11 @@
     def test_len(self, repetitions=10):
         # Get message count
         keys = []
-        for i in xrange(repetitions):
+        for i in range(repetitions):
             self.assert_(len(self._box) == i)
             keys.append(self._box.add(self._template % i))
             self.assert_(len(self._box) == i + 1)
-        for i in xrange(repetitions):
+        for i in range(repetitions):
             self.assert_(len(self._box) == repetitions - i)
             self._box.remove(keys[i])
             self.assert_(len(self._box) == repetitions - i - 1)
@@ -293,7 +293,7 @@
     def test_clear(self, iterations=10):
         # Remove all messages using clear()
         keys = []
-        for i in xrange(iterations):
+        for i in range(iterations):
             self._box.add(self._template % i)
         for i, key in enumerate(keys):
             self.assert_(self._box.get_string(key) == self._template % i)
@@ -323,10 +323,10 @@
     def test_popitem(self, iterations=10):
         # Get and remove an arbitrary (key, message) using popitem()
         keys = []
-        for i in xrange(10):
+        for i in range(10):
             keys.append(self._box.add(self._template % i))
         seen = []
-        for i in xrange(10):
+        for i in range(10):
             key, msg = self._box.popitem()
             self.assert_(key in keys)
             self.assert_(key not in seen)
@@ -387,7 +387,7 @@
         self._test_flush_or_close(self._box.close)
 
     def _test_flush_or_close(self, method):
-        contents = [self._template % i for i in xrange(3)]
+        contents = [self._template % i for i in range(3)]
         self._box.add(contents[0])
         self._box.add(contents[1])
         self._box.add(contents[2])
@@ -599,7 +599,7 @@
         pattern = re.compile(r"(?P<time>\d+)\.M(?P<M>\d{1,6})P(?P<P>\d+)"
                              r"Q(?P<Q>\d+)\.(?P<host>[^:/]+)")
         previous_groups = None
-        for x in xrange(repetitions):
+        for x in range(repetitions):
             tmp_file = self._box._create_tmp()
             head, tail = os.path.split(tmp_file.name)
             self.assertEqual(head, os.path.abspath(os.path.join(self._path,
@@ -703,7 +703,7 @@
 
     def test_open_close_open(self):
         # Open and inspect previously-created mailbox
-        values = [self._template % i for i in xrange(3)]
+        values = [self._template % i for i in range(3)]
         for value in values:
             self._box.add(value)
         self._box.close()
@@ -718,7 +718,7 @@
     def test_add_and_close(self):
         # Verifying that closing a mailbox doesn't change added items
         self._box.add(_sample_message)
-        for i in xrange(3):
+        for i in range(3):
             self._box.add(self._template % i)
         self._box.add(_sample_message)
         self._box._file.flush()

Modified: python/branches/p3yk/Lib/test/test_mhlib.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_mhlib.py	(original)
+++ python/branches/p3yk/Lib/test/test_mhlib.py	Mon May  7 10:03:22 2007
@@ -121,7 +121,7 @@
                       'Date': '29 July 2001'}, "Hullo, Mrs. Premise!\n")
 
         # A folder with many messages
-        for i in range(5, 101)+range(101, 201, 2):
+        for i in list(range(5, 101))+list(range(101, 201, 2)):
             writeMessage('wide', i,
                          {'From': 'nowhere', 'Subject': 'message #%s' % i},
                          "This is message number %s\n" % i)
@@ -203,7 +203,7 @@
 
         f = mh.openfolder('wide')
         all = f.listmessages()
-        eq(all, range(5, 101)+range(101, 201, 2))
+        eq(all, list(range(5, 101))+list(range(101, 201, 2)))
         eq(f.getcurrent(), 55)
         f.setcurrent(99)
         eq(readFile(os.path.join(_mhpath, 'wide', '.mh_sequences')),
@@ -212,21 +212,21 @@
         def seqeq(seq, val):
             eq(f.parsesequence(seq), val)
 
-        seqeq('5-55', range(5, 56))
-        seqeq('90-108', range(90, 101)+range(101, 109, 2))
-        seqeq('90-108', range(90, 101)+range(101, 109, 2))
-
-        seqeq('10:10', range(10, 20))
-        seqeq('10:+10', range(10, 20))
-        seqeq('101:10', range(101, 121, 2))
+        seqeq('5-55', list(range(5, 56)))
+        seqeq('90-108', list(range(90, 101))+list(range(101, 109, 2)))
+        seqeq('90-108', list(range(90, 101))+list(range(101, 109, 2)))
+
+        seqeq('10:10', list(range(10, 20)))
+        seqeq('10:+10', list(range(10, 20)))
+        seqeq('101:10', list(range(101, 121, 2)))
 
         seqeq('cur', [99])
         seqeq('.', [99])
         seqeq('prev', [98])
         seqeq('next', [100])
         seqeq('cur:-3', [97, 98, 99])
-        seqeq('first-cur', range(5, 100))
-        seqeq('150-last', range(151, 201, 2))
+        seqeq('first-cur', list(range(5, 100)))
+        seqeq('150-last', list(range(151, 201, 2)))
         seqeq('prev-next', [98, 99, 100])
 
         lowprimes = [5, 7, 11, 13, 17, 19, 23, 29]

Modified: python/branches/p3yk/Lib/test/test_mimetools.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_mimetools.py	(original)
+++ python/branches/p3yk/Lib/test/test_mimetools.py	Mon May  7 10:03:22 2007
@@ -26,7 +26,7 @@
 
     def test_boundary(self):
         s = set([""])
-        for i in xrange(100):
+        for i in range(100):
             nb = mimetools.choose_boundary()
             self.assert_(nb not in s)
             s.add(nb)

Modified: python/branches/p3yk/Lib/test/test_mmap.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_mmap.py	(original)
+++ python/branches/p3yk/Lib/test/test_mmap.py	Mon May  7 10:03:22 2007
@@ -299,10 +299,10 @@
     def test_anonymous(self):
         # anonymous mmap.mmap(-1, PAGE)
         m = mmap.mmap(-1, PAGESIZE)
-        for x in xrange(PAGESIZE):
+        for x in range(PAGESIZE):
             self.assertEqual(m[x], '\0', "anonymously mmap'ed contents should be zero")
 
-        for x in xrange(PAGESIZE):
+        for x in range(PAGESIZE):
             m[x] = ch = chr(x & 255)
             self.assertEqual(m[x], ch)
 

Modified: python/branches/p3yk/Lib/test/test_multibytecodec.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_multibytecodec.py	(original)
+++ python/branches/p3yk/Lib/test/test_multibytecodec.py	Mon May  7 10:03:22 2007
@@ -214,7 +214,7 @@
         else:
             myunichr = lambda x: unichr(0xD7C0+(x>>10)) + unichr(0xDC00+(x&0x3FF))
 
-        for x in xrange(0x10000, 0x110000):
+        for x in range(0x10000, 0x110000):
             # Any ISO 2022 codec will cause the segfault
             myunichr(x).encode('iso_2022_jp', 'ignore')
 

Modified: python/branches/p3yk/Lib/test/test_multibytecodec_support.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_multibytecodec_support.py	(original)
+++ python/branches/p3yk/Lib/test/test_multibytecodec_support.py	Mon May  7 10:03:22 2007
@@ -145,7 +145,7 @@
 
     def test_incrementalencoder(self):
         UTF8Reader = codecs.getreader('utf-8')
-        for sizehint in [None] + range(1, 33) + \
+        for sizehint in [None] + list(range(1, 33)) + \
                         [64, 128, 256, 512, 1024]:
             istream = UTF8Reader(StringIO(self.tstring[1]))
             ostream = StringIO()
@@ -165,7 +165,7 @@
 
     def test_incrementaldecoder(self):
         UTF8Writer = codecs.getwriter('utf-8')
-        for sizehint in [None, -1] + range(1, 33) + \
+        for sizehint in [None, -1] + list(range(1, 33)) + \
                         [64, 128, 256, 512, 1024]:
             istream = StringIO(self.tstring[0])
             ostream = UTF8Writer(StringIO())
@@ -203,7 +203,7 @@
     def test_streamreader(self):
         UTF8Writer = codecs.getwriter('utf-8')
         for name in ["read", "readline", "readlines"]:
-            for sizehint in [None, -1] + range(1, 33) + \
+            for sizehint in [None, -1] + list(range(1, 33)) + \
                             [64, 128, 256, 512, 1024]:
                 istream = self.reader(StringIO(self.tstring[0]))
                 ostream = UTF8Writer(StringIO())
@@ -223,7 +223,7 @@
         readfuncs = ('read', 'readline', 'readlines')
         UTF8Reader = codecs.getreader('utf-8')
         for name in readfuncs:
-            for sizehint in [None] + range(1, 33) + \
+            for sizehint in [None] + list(range(1, 33)) + \
                             [64, 128, 256, 512, 1024]:
                 istream = UTF8Reader(StringIO(self.tstring[1]))
                 ostream = self.writer(StringIO())

Modified: python/branches/p3yk/Lib/test/test_mutants.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_mutants.py	(original)
+++ python/branches/p3yk/Lib/test/test_mutants.py	Mon May  7 10:03:22 2007
@@ -113,7 +113,7 @@
 
 def fill_dict(d, candidates, numentries):
     d.clear()
-    for i in xrange(numentries):
+    for i in range(numentries):
         d[Horrid(random.choice(candidates))] = \
             Horrid(random.choice(candidates))
     return list(d.keys())
@@ -152,7 +152,7 @@
 # leak).
 
 def test(n):
-    for i in xrange(n):
+    for i in range(n):
         test_one(random.randrange(1, 100))
 
 # See last comment block for clues about good values for n.

Modified: python/branches/p3yk/Lib/test/test_operator.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_operator.py	(original)
+++ python/branches/p3yk/Lib/test/test_operator.py	Mon May  7 10:03:22 2007
@@ -138,7 +138,7 @@
         self.assert_(a == [4, 2, 1])
 
     def test_delslice(self):
-        a = range(10)
+        a = list(range(10))
         self.failUnlessRaises(TypeError, operator.delslice, a)
         self.failUnlessRaises(TypeError, operator.delslice, a, None, None)
         self.failUnless(operator.delslice(a, 2, 8) is None)
@@ -163,7 +163,7 @@
         self.failUnless(operator.getitem(a, 2) == 2)
 
     def test_getslice(self):
-        a = range(10)
+        a = list(range(10))
         self.failUnlessRaises(TypeError, operator.getslice)
         self.failUnlessRaises(TypeError, operator.getslice, a, None, None)
         self.failUnless(operator.getslice(a, 4, 6) == [4, 5])
@@ -200,7 +200,7 @@
         self.failUnlessRaises(TypeError, operator.isSequenceType)
         self.failUnless(operator.isSequenceType(dir()))
         self.failUnless(operator.isSequenceType(()))
-        self.failUnless(operator.isSequenceType(xrange(10)))
+        self.failUnless(operator.isSequenceType(range(10)))
         self.failUnless(operator.isSequenceType('yeahbuddy'))
         self.failIf(operator.isSequenceType(3))
         class Dict(dict): pass
@@ -253,7 +253,7 @@
         self.assertRaises(TypeError, operator.pow, 1, 2, 3)
 
     def test_repeat(self):
-        a = range(3)
+        a = list(range(3))
         self.failUnlessRaises(TypeError, operator.repeat)
         self.failUnlessRaises(TypeError, operator.repeat, a, None)
         self.failUnless(operator.repeat(a, 2) == a+a)
@@ -291,7 +291,7 @@
         self.failIf(operator.contains(range(4), 5))
 
     def test_setitem(self):
-        a = range(3)
+        a = list(range(3))
         self.failUnlessRaises(TypeError, operator.setitem, a)
         self.failUnlessRaises(TypeError, operator.setitem, a, None, None)
         self.failUnless(operator.setitem(a, 0, 2) is None)
@@ -299,7 +299,7 @@
         self.assertRaises(IndexError, operator.setitem, a, 4, 2)
 
     def test_setslice(self):
-        a = range(4)
+        a = list(range(4))
         self.failUnlessRaises(TypeError, operator.setslice, a)
         self.failUnlessRaises(TypeError, operator.setslice, a, None, None, None)
         self.failUnless(operator.setslice(a, 1, 3, [2, 1]) is None)
@@ -459,7 +459,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_peepholer.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_peepholer.py	(original)
+++ python/branches/p3yk/Lib/test/test_peepholer.py	Mon May  7 10:03:22 2007
@@ -220,7 +220,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_pep352.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_pep352.py	(original)
+++ python/branches/p3yk/Lib/test/test_pep352.py	Mon May  7 10:03:22 2007
@@ -36,7 +36,8 @@
                 last_exc = getattr(__builtin__, superclass_name)
             except AttributeError:
                 self.fail("base class %s not a built-in" % superclass_name)
-            self.failUnless(superclass_name in exc_set)
+            self.failUnless(superclass_name in exc_set,
+                            '%s not found' % superclass_name)
             exc_set.discard(superclass_name)
             superclasses = []  # Loop will insert base exception
             last_depth = 0

Modified: python/branches/p3yk/Lib/test/test_pow.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_pow.py	(original)
+++ python/branches/p3yk/Lib/test/test_pow.py	Mon May  7 10:03:22 2007
@@ -14,12 +14,12 @@
                 self.assertEquals(pow(type(i), 3), i*i*i)
 
             pow2 = 1
-            for i in range(0,31):
+            for i in range(0, 31):
                 self.assertEquals(pow(2, i), pow2)
                 if i != 30 : pow2 = pow2*2
 
             for othertype in int, int:
-                for i in range(-10, 0) + range(1, 10):
+                for i in list(range(-10, 0)) + list(range(1, 10)):
                     ii = type(i)
                     for j in range(1, 11):
                         jj = -othertype(j)

Modified: python/branches/p3yk/Lib/test/test_pprint.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_pprint.py	(original)
+++ python/branches/p3yk/Lib/test/test_pprint.py	Mon May  7 10:03:22 2007
@@ -33,8 +33,8 @@
 class QueryTestCase(unittest.TestCase):
 
     def setUp(self):
-        self.a = range(100)
-        self.b = range(200)
+        self.a = list(range(100))
+        self.b = list(range(200))
         self.a[-12] = self.b
 
     def test_basic(self):

Modified: python/branches/p3yk/Lib/test/test_pwd.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_pwd.py	(original)
+++ python/branches/p3yk/Lib/test/test_pwd.py	Mon May  7 10:03:22 2007
@@ -60,7 +60,7 @@
         fakename = allnames[namei]
         while fakename in bynames:
             chars = map(None, fakename)
-            for i in xrange(len(chars)):
+            for i in range(len(chars)):
                 if chars[i] == 'z':
                     chars[i] = 'A'
                     break

Modified: python/branches/p3yk/Lib/test/test_queue.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_queue.py	(original)
+++ python/branches/p3yk/Lib/test/test_queue.py	Mon May  7 10:03:22 2007
@@ -243,7 +243,7 @@
     cum = 0
     for i in (0,1):
         threading.Thread(target=worker, args=(q,)).start()
-    for i in xrange(100):
+    for i in range(100):
         q.put(i)
     q.join()
     verify(cum==sum(range(100)), "q.join() did not block until all tasks were done")

Modified: python/branches/p3yk/Lib/test/test_random.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_random.py	(original)
+++ python/branches/p3yk/Lib/test/test_random.py	Mon May  7 10:03:22 2007
@@ -15,7 +15,7 @@
 
     def randomlist(self, n):
         """Helper function to make a list of random numbers"""
-        return [self.gen.random() for i in xrange(n)]
+        return [self.gen.random() for i in range(n)]
 
     def test_autoseed(self):
         self.gen.seed()
@@ -37,7 +37,7 @@
         for arg in [None, 0, 0, 1, 1, -1, -1, 10**20, -(10**20),
                     3.14, 1+2j, 'a', tuple('abc')]:
             self.gen.seed(arg)
-        for arg in [range(3), dict(one=1)]:
+        for arg in [list(range(3)), dict(one=1)]:
             self.assertRaises(TypeError, self.gen.seed, arg)
         self.assertRaises(TypeError, self.gen.seed, 1, 2)
         self.assertRaises(TypeError, type(self.gen), [])
@@ -61,8 +61,8 @@
         # For the entire allowable range of 0 <= k <= N, validate that
         # the sample is of the correct length and contains only unique items
         N = 100
-        population = xrange(N)
-        for k in xrange(N+1):
+        population = range(N)
+        for k in range(N+1):
             s = self.gen.sample(population, k)
             self.assertEqual(len(s), k)
             uniq = set(s)
@@ -80,10 +80,10 @@
             if n == 0:
                 return 1
             return n * factorial(n - 1)
-        for k in xrange(n):
+        for k in range(n):
             expected = factorial(n) // factorial(n-k)
             perms = {}
-            for i in xrange(trials):
+            for i in range(trials):
                 perms[tuple(self.gen.sample(pop, k))] = None
                 if len(perms) == expected:
                     break
@@ -94,7 +94,7 @@
         # SF bug #801342 -- population can be any iterable defining __len__()
         self.gen.sample(set(range(20)), 2)
         self.gen.sample(range(20), 2)
-        self.gen.sample(xrange(20), 2)
+        self.gen.sample(range(20), 2)
         self.gen.sample(str('abcdefghijklmnopqrst'), 2)
         self.gen.sample(tuple('abcdefghijklmnopqrst'), 2)
 
@@ -102,21 +102,23 @@
         self.gen.sample(dict.fromkeys('abcdefghijklmnopqrst'), 2)
 
         # SF bug #1460340 -- random.sample can raise KeyError
-        a = dict.fromkeys(range(10)+range(10,100,2)+range(100,110))
+        a = dict.fromkeys(list(range(10)) +
+                          list(range(10,100,2)) +
+                          list(range(100,110)))
         self.gen.sample(a, 3)
 
         # A followup to bug #1460340:  sampling from a dict could return
         # a subset of its keys or of its values, depending on the size of
         # the subset requested.
         N = 30
-        d = dict((i, complex(i, i)) for i in xrange(N))
-        for k in xrange(N+1):
+        d = dict((i, complex(i, i)) for i in range(N))
+        for k in range(N+1):
             samp = self.gen.sample(d, k)
             # Verify that we got ints back (keys); the values are complex.
             for x in samp:
                 self.assert_(type(x) is int)
         samp.sort()
-        self.assertEqual(samp, range(N))
+        self.assertEqual(samp, list(range(N)))
 
     def test_gauss(self):
         # Ensure that the seed() method initializes all the hidden state.  In
@@ -137,9 +139,9 @@
 
     def test_pickling(self):
         state = pickle.dumps(self.gen)
-        origseq = [self.gen.random() for i in xrange(10)]
+        origseq = [self.gen.random() for i in range(10)]
         newgen = pickle.loads(state)
-        restoredseq = [newgen.random() for i in xrange(10)]
+        restoredseq = [newgen.random() for i in range(10)]
         self.assertEqual(origseq, restoredseq)
 
 class WichmannHill_TestBasicOps(TestBasicOps):
@@ -156,7 +158,7 @@
         r1 = self.gen.random()
         # now do it the slow way
         self.gen.setstate(s)
-        for i in xrange(N):
+        for i in range(N):
             self.gen.random()
         r2 = self.gen.random()
         self.assertEqual(r1, r2)
@@ -215,7 +217,7 @@
         # This should pass whenever a C double has 53 bit precision.
         span = 2 ** 53
         cum = 0
-        for i in xrange(100):
+        for i in range(100):
             cum |= int(self.gen.random() * span)
         self.assertEqual(cum, span-1)
 
@@ -224,7 +226,7 @@
         # in stages so that all bit positions are active.
         span = 2 ** 500
         cum = 0
-        for i in xrange(100):
+        for i in range(100):
             r = self.gen.randrange(span)
             self.assert_(0 <= r < span)
             cum |= r
@@ -241,18 +243,18 @@
     def test_rangelimits(self):
         for start, stop in [(-2,0), (-(2**60)-2,-(2**60)), (2**60,2**60+2)]:
             self.assertEqual(set(range(start,stop)),
-                set([self.gen.randrange(start,stop) for i in xrange(100)]))
+                set([self.gen.randrange(start,stop) for i in range(100)]))
 
     def test_genrandbits(self):
         # Verify ranges
-        for k in xrange(1, 1000):
+        for k in range(1, 1000):
             self.assert_(0 <= self.gen.getrandbits(k) < 2**k)
 
         # Verify all bits active
         getbits = self.gen.getrandbits
         for span in [1, 2, 3, 4, 31, 32, 32, 52, 53, 54, 119, 127, 128, 129]:
             cum = 0
-            for i in xrange(100):
+            for i in range(100):
                 cum |= getbits(span)
             self.assertEqual(cum, 2**span-1)
 
@@ -267,7 +269,7 @@
         # check bitcount transition points:  2**i and 2**(i+1)-1
         # show that: k = int(1.001 + _log(n, 2))
         # is equal to or one greater than the number of bits in n
-        for i in xrange(1, 1000):
+        for i in range(1, 1000):
             n = 1 << i # check an exact power of two
             numbits = i+1
             k = int(1.00001 + _log(n, 2))
@@ -367,7 +369,7 @@
         # This should pass whenever a C double has 53 bit precision.
         span = 2 ** 53
         cum = 0
-        for i in xrange(100):
+        for i in range(100):
             cum |= int(self.gen.random() * span)
         self.assertEqual(cum, span-1)
 
@@ -376,7 +378,7 @@
         # in stages so that all bit positions are active.
         span = 2 ** 500
         cum = 0
-        for i in xrange(100):
+        for i in range(100):
             r = self.gen.randrange(span)
             self.assert_(0 <= r < span)
             cum |= r
@@ -393,7 +395,7 @@
     def test_rangelimits(self):
         for start, stop in [(-2,0), (-(2**60)-2,-(2**60)), (2**60,2**60+2)]:
             self.assertEqual(set(range(start,stop)),
-                set([self.gen.randrange(start,stop) for i in xrange(100)]))
+                set([self.gen.randrange(start,stop) for i in range(100)]))
 
     def test_genrandbits(self):
         # Verify cross-platform repeatability
@@ -401,14 +403,14 @@
         self.assertEqual(self.gen.getrandbits(100),
                          97904845777343510404718956115)
         # Verify ranges
-        for k in xrange(1, 1000):
+        for k in range(1, 1000):
             self.assert_(0 <= self.gen.getrandbits(k) < 2**k)
 
         # Verify all bits active
         getbits = self.gen.getrandbits
         for span in [1, 2, 3, 4, 31, 32, 32, 52, 53, 54, 119, 127, 128, 129]:
             cum = 0
-            for i in xrange(100):
+            for i in range(100):
                 cum |= getbits(span)
             self.assertEqual(cum, 2**span-1)
 
@@ -423,7 +425,7 @@
         # check bitcount transition points:  2**i and 2**(i+1)-1
         # show that: k = int(1.001 + _log(n, 2))
         # is equal to or one greater than the number of bits in n
-        for i in xrange(1, 1000):
+        for i in range(1, 1000):
             n = 1 << i # check an exact power of two
             numbits = i+1
             k = int(1.00001 + _log(n, 2))
@@ -455,7 +457,7 @@
 def gamma(z, cof=_gammacoeff, g=7):
     z -= 1.0
     sum = cof[0]
-    for i in xrange(1,len(cof)):
+    for i in range(1,len(cof)):
         sum += cof[i] / (z+i)
     z += 0.5
     return (z+g)**z / exp(z+g) * sqrt(2*pi) * sum
@@ -464,7 +466,7 @@
     def test_zeroinputs(self):
         # Verify that distributions can handle a series of zero inputs'
         g = random.Random()
-        x = [g.random() for i in xrange(50)] + [0.0]*5
+        x = [g.random() for i in range(50)] + [0.0]*5
         g.random = x[:].pop; g.uniform(1,10)
         g.random = x[:].pop; g.paretovariate(1.0)
         g.random = x[:].pop; g.expovariate(1.0)
@@ -483,7 +485,7 @@
         # Only works for distributions which do not consume variates in pairs
         g = random.Random()
         N = 5000
-        x = [i/float(N) for i in xrange(1,N)]
+        x = [i/float(N) for i in range(1,N)]
         for variate, args, mu, sigmasqrd in [
                 (g.uniform, (1.0,10.0), (10.0+1.0)/2, (10.0-1.0)**2/12),
                 (g.expovariate, (1.5,), 1/1.5, 1/1.5**2),
@@ -493,7 +495,7 @@
                                   gamma(1+2/3.0)-gamma(1+1/3.0)**2) ]:
             g.random = x[:].pop
             y = []
-            for i in xrange(len(x)):
+            for i in range(len(x)):
                 try:
                     y.append(variate(*args))
                 except IndexError:
@@ -544,7 +546,7 @@
     import sys
     if verbose and hasattr(sys, "gettotalrefcount"):
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*testclasses)
             counts[i] = sys.gettotalrefcount()
         print(counts)

Modified: python/branches/p3yk/Lib/test/test_repr.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_repr.py	(original)
+++ python/branches/p3yk/Lib/test/test_repr.py	Mon May  7 10:03:22 2007
@@ -135,11 +135,11 @@
         self.failUnless(repr(''.split).startswith(
             '<built-in method split of str object at 0x'))
 
-    def test_xrange(self):
+    def test_range(self):
         eq = self.assertEquals
-        eq(repr(xrange(1)), 'xrange(1)')
-        eq(repr(xrange(1, 2)), 'xrange(1, 2)')
-        eq(repr(xrange(1, 2, 3)), 'xrange(1, 4, 3)')
+        eq(repr(range(1)), 'range(1)')
+        eq(repr(range(1, 2)), 'range(1, 2)')
+        eq(repr(range(1, 4, 3)), 'range(1, 4, 3)')
 
     def test_nesting(self):
         eq = self.assertEquals

Modified: python/branches/p3yk/Lib/test/test_richcmp.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_richcmp.py	(original)
+++ python/branches/p3yk/Lib/test/test_richcmp.py	Mon May  7 10:03:22 2007
@@ -105,7 +105,7 @@
             realres = op(a, b)
             # can't use assertEqual(realres, expres) here
             self.assertEqual(len(realres), len(expres))
-            for i in xrange(len(realres)):
+            for i in range(len(realres)):
                 # results are bool, so we can use "is" here
                 self.assert_(realres[i] is expres[i])
 
@@ -119,7 +119,7 @@
         for opname in opmap:
             self.checkfail(ValueError, opname, a, b)
 
-        a = range(5)
+        a = list(range(5))
         b = 5 * [2]
         # try mixed arguments (but not (a, b) as that won't return a bool vector)
         args = [(a, Vector(b)), (Vector(a), b), (Vector(a), Vector(b))]
@@ -142,8 +142,8 @@
         # Check that comparisons involving Number objects
         # give the same results give as comparing the
         # corresponding ints
-        for a in xrange(3):
-            for b in xrange(3):
+        for a in range(3):
+            for b in range(3):
                 for typea in (int, Number):
                     for typeb in (int, Number):
                         if typea==typeb==int:

Modified: python/branches/p3yk/Lib/test/test_set.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_set.py	(original)
+++ python/branches/p3yk/Lib/test/test_set.py	Mon May  7 10:03:22 2007
@@ -227,7 +227,7 @@
         # Create a nest of cycles to exercise overall ref count check
         class A:
             pass
-        s = set(A() for i in xrange(1000))
+        s = set(A() for i in range(1000))
         for elem in s:
             elem.cycle = s
             elem.sub = elem
@@ -283,7 +283,7 @@
 
     def test_do_not_rehash_dict_keys(self):
         n = 10
-        d = dict.fromkeys(map(HashCountingInt, xrange(n)))
+        d = dict.fromkeys(map(HashCountingInt, range(n)))
         self.assertEqual(sum(elem.hash_count for elem in d), n)
         s = self.thetype(d)
         self.assertEqual(sum(elem.hash_count for elem in d), n)
@@ -377,7 +377,7 @@
         s.discard(self.thetype(self.word))
 
     def test_pop(self):
-        for i in xrange(len(self.s)):
+        for i in range(len(self.s)):
             elem = self.s.pop()
             self.assert_(elem not in self.s)
         self.assertRaises(KeyError, self.s.pop)
@@ -525,7 +525,7 @@
         f = frozenset()
         efs = [frozenset(), frozenset([]), frozenset(()), frozenset(''),
                frozenset(), frozenset([]), frozenset(()), frozenset(''),
-               frozenset(xrange(0)), frozenset(frozenset()),
+               frozenset(range(0)), frozenset(frozenset()),
                frozenset(f), f]
         # All of the empty frozensets should have just one id()
         self.assertEqual(len(set(map(id, efs))), 1)
@@ -541,9 +541,9 @@
 
         # make sure that all permutations give the same hash value
         n = 100
-        seq = [randrange(n) for i in xrange(n)]
+        seq = [randrange(n) for i in range(n)]
         results = set()
-        for i in xrange(200):
+        for i in range(200):
             shuffle(seq)
             results.add(hash(self.thetype(seq)))
         self.assertEqual(len(results), 1)
@@ -553,7 +553,7 @@
         self.assertEqual(id(self.s), id(dup))
 
     def test_frozen_as_dictkey(self):
-        seq = range(10) + list('abcdefg') + ['apple']
+        seq = list(range(10)) + list('abcdefg') + ['apple']
         key1 = self.thetype(seq)
         key2 = self.thetype(reversed(seq))
         self.assertEqual(key1, key2)
@@ -571,7 +571,7 @@
         hashvalues = set()
         addhashvalue = hashvalues.add
         elemmasks = [(i+1, 1<<i) for i in range(n)]
-        for i in xrange(2**n):
+        for i in range(2**n):
             addhashvalue(hash(frozenset([e for e, m in elemmasks if m&i])))
         self.assertEqual(len(hashvalues), 2**n)
 
@@ -601,7 +601,7 @@
         F = Frozenset()
         efs = [Frozenset(), Frozenset([]), Frozenset(()), Frozenset(''),
                Frozenset(), Frozenset([]), Frozenset(()), Frozenset(''),
-               Frozenset(xrange(0)), Frozenset(Frozenset()),
+               Frozenset(range(0)), Frozenset(Frozenset()),
                Frozenset(frozenset()), f, F, Frozenset(f), Frozenset(F)]
         # All empty frozenset subclass instances should have different ids
         self.assertEqual(len(set(map(id, efs))), len(efs))
@@ -775,7 +775,7 @@
         set([1,2,3])
         set((1,2,3))
         set({'one':1, 'two':2, 'three':3})
-        set(xrange(3))
+        set(range(3))
         set('abc')
         set(gooditer())
 
@@ -1268,7 +1268,7 @@
 class TestOnlySetsGenerator(TestOnlySetsInBinaryOps):
     def setUp(self):
         def gen():
-            for i in xrange(0, 10, 2):
+            for i in range(0, 10, 2):
                 yield i
         self.set   = set((1, 2, 3))
         self.other = gen()
@@ -1451,7 +1451,7 @@
 
     def test_constructor(self):
         for cons in (set, frozenset):
-            for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
+            for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
                 for g in (G, I, Ig, S, L, R):
                     self.assertEqual(sorted(cons(g(s)), key=repr), sorted(g(s), key=repr))
                 self.assertRaises(TypeError, cons , X(s))
@@ -1460,7 +1460,7 @@
 
     def test_inline_methods(self):
         s = set('november')
-        for data in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):
+        for data in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5), 'december'):
             for meth in (s.union, s.intersection, s.difference, s.symmetric_difference):
                 for g in (G, I, Ig, L, R):
                     expected = meth(data)
@@ -1471,7 +1471,7 @@
                 self.assertRaises(ZeroDivisionError, meth, E(s))
 
     def test_inplace_methods(self):
-        for data in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):
+        for data in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5), 'december'):
             for methname in ('update', 'intersection_update',
                              'difference_update', 'symmetric_difference_update'):
                 for g in (G, I, Ig, S, L, R):
@@ -1529,7 +1529,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_setcomps.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_setcomps.py	(original)
+++ python/branches/p3yk/Lib/test/test_setcomps.py	Mon May  7 10:03:22 2007
@@ -43,23 +43,23 @@
     SyntaxError: ...
 
 
-Make a nested set comprehension that acts like set(xrange())
+Make a nested set comprehension that acts like set(range())
 
     >>> def srange(n):
-    ...     return {i for i in xrange(n)}
+    ...     return {i for i in range(n)}
     >>> list(sorted(srange(10)))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Same again, only as a lambda expression instead of a function definition
 
-    >>> lrange = lambda n:  {i for i in xrange(n)}
+    >>> lrange = lambda n:  {i for i in range(n)}
     >>> list(sorted(lrange(10)))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Generators can call other generators:
 
     >>> def grange(n):
-    ...     for x in {i for i in xrange(n)}:
+    ...     for x in {i for i in range(n)}:
     ...         yield x
     >>> list(sorted(grange(5)))
     [0, 1, 2, 3, 4]
@@ -67,7 +67,7 @@
 
 Make sure that None is a valid return value
 
-    >>> {None for i in xrange(10)}
+    >>> {None for i in range(10)}
     {None}
 
 ########### Tests for various scoping corner cases ############
@@ -141,7 +141,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()
@@ -194,23 +194,23 @@
     SyntaxError: ...
 
 
-Make a nested set comprehension that acts like set(xrange())
+Make a nested set comprehension that acts like set(range())
 
     >>> def srange(n):
-    ...     return {i for i in xrange(n)}
+    ...     return {i for i in range(n)}
     >>> list(sorted(srange(10)))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Same again, only as a lambda expression instead of a function definition
 
-    >>> lrange = lambda n:  {i for i in xrange(n)}
+    >>> lrange = lambda n:  {i for i in range(n)}
     >>> list(sorted(lrange(10)))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Generators can call other generators:
 
     >>> def grange(n):
-    ...     for x in {i for i in xrange(n)}:
+    ...     for x in {i for i in range(n)}:
     ...         yield x
     >>> list(sorted(grange(5)))
     [0, 1, 2, 3, 4]
@@ -218,7 +218,7 @@
 
 Make sure that None is a valid return value
 
-    >>> {None for i in xrange(10)}
+    >>> {None for i in range(10)}
     {None}
 
 ########### Tests for various scoping corner cases ############
@@ -292,7 +292,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()
@@ -345,23 +345,23 @@
     SyntaxError: ...
 
 
-Make a nested set comprehension that acts like set(xrange())
+Make a nested set comprehension that acts like set(range())
 
     >>> def srange(n):
-    ...     return {i for i in xrange(n)}
+    ...     return {i for i in range(n)}
     >>> list(sorted(srange(10)))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Same again, only as a lambda expression instead of a function definition
 
-    >>> lrange = lambda n:  {i for i in xrange(n)}
+    >>> lrange = lambda n:  {i for i in range(n)}
     >>> list(sorted(lrange(10)))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 Generators can call other generators:
 
     >>> def grange(n):
-    ...     for x in {i for i in xrange(n)}:
+    ...     for x in {i for i in range(n)}:
     ...         yield x
     >>> list(sorted(grange(5)))
     [0, 1, 2, 3, 4]
@@ -369,7 +369,7 @@
 
 Make sure that None is a valid return value
 
-    >>> {None for i in xrange(10)}
+    >>> {None for i in range(10)}
     {None}
 
 ########### Tests for various scoping corner cases ############
@@ -443,7 +443,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_doctest(test_genexps, verbose)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_slice.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_slice.py	(original)
+++ python/branches/p3yk/Lib/test/test_slice.py	Mon May  7 10:03:22 2007
@@ -89,7 +89,7 @@
         )
         self.assertEqual(slice(-100, 100, 2).indices(10), (0, 10,  2))
 
-        self.assertEqual(range(10)[::sys.maxint - 1], [0])
+        self.assertEqual(list(range(10))[::sys.maxint - 1], [0])
 
         self.assertRaises(OverflowError, slice(None).indices, 1<<100)
 

Modified: python/branches/p3yk/Lib/test/test_sort.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_sort.py	(original)
+++ python/branches/p3yk/Lib/test/test_sort.py	Mon May  7 10:03:22 2007
@@ -75,7 +75,7 @@
                 return "Stable(%d, %d)" % (self.key, self.index)
 
         for n in sizes:
-            x = range(n)
+            x = list(range(n))
             if verbose:
                 print("Testing size", n)
 
@@ -115,7 +115,7 @@
                 Complains.maybe_complain = False
                 check("exception during sort left some permutation", x, s)
 
-            s = [Stable(random.randrange(10), i) for i in xrange(n)]
+            s = [Stable(random.randrange(10), i) for i in range(n)]
             augmented = [(e, e.index) for e in s]
             augmented.sort()    # forced stable because ties broken by index
             x = [e for e, i in augmented] # a stable sort of s
@@ -144,10 +144,10 @@
     def test_cmpNone(self):
         # Testing None as a comparison function.
 
-        L = range(50)
+        L = list(range(50))
         random.shuffle(L)
         L.sort(None)
-        self.assertEqual(L, range(50))
+        self.assertEqual(L, list(range(50)))
 
     def test_undetected_mutation(self):
         # Python 2.4a1 did not always detect mutation
@@ -182,7 +182,7 @@
         self.assertRaises(TypeError, data.sort, None, lambda x,y: 0)
 
     def test_stability(self):
-        data = [(random.randrange(100), i) for i in xrange(200)]
+        data = [(random.randrange(100), i) for i in range(200)]
         copy = data[:]
         data.sort(key=lambda (x,y): x)  # sort on the random first field
         copy.sort()                     # sort using both fields
@@ -204,13 +204,13 @@
 
     def test_key_with_exception(self):
         # Verify that the wrapper has been removed
-        data = range(-2,2)
+        data = list(range(-2, 2))
         dup = data[:]
         self.assertRaises(ZeroDivisionError, data.sort, None, lambda x: 1/x)
         self.assertEqual(data, dup)
 
     def test_key_with_mutation(self):
-        data = range(10)
+        data = list(range(10))
         def k(x):
             del data[:]
             data[:] = range(20)
@@ -218,7 +218,7 @@
         self.assertRaises(ValueError, data.sort, key=k)
 
     def test_key_with_mutating_del(self):
-        data = range(10)
+        data = list(range(10))
         class SortKiller(object):
             def __init__(self, x):
                 pass
@@ -230,7 +230,7 @@
         self.assertRaises(ValueError, data.sort, key=SortKiller)
 
     def test_key_with_mutating_del_and_exception(self):
-        data = range(10)
+        data = list(range(10))
         ## dup = data[:]
         class SortKiller(object):
             def __init__(self, x):
@@ -238,7 +238,7 @@
                     raise RuntimeError
             def __del__(self):
                 del data[:]
-                data[:] = range(20)
+                data[:] = list(range(20))
         self.assertRaises(RuntimeError, data.sort, key=SortKiller)
         ## major honking subtlety: we *can't* do:
         ##
@@ -250,14 +250,14 @@
         ## date (this cost some brain cells to figure out...).
 
     def test_reverse(self):
-        data = range(100)
+        data = list(range(100))
         random.shuffle(data)
         data.sort(reverse=True)
-        self.assertEqual(data, range(99,-1,-1))
+        self.assertEqual(data, list(range(99,-1,-1)))
         self.assertRaises(TypeError, data.sort, "wrong type")
 
     def test_reverse_stability(self):
-        data = [(random.randrange(100), i) for i in xrange(200)]
+        data = [(random.randrange(100), i) for i in range(200)]
         copy1 = data[:]
         copy2 = data[:]
         data.sort(cmp=lambda x,y: cmp(x[0],y[0]), reverse=True)
@@ -281,7 +281,7 @@
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
-        for i in xrange(len(counts)):
+        for i in range(len(counts)):
             test_support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()

Modified: python/branches/p3yk/Lib/test/test_struct.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_struct.py	(original)
+++ python/branches/p3yk/Lib/test/test_struct.py	Mon May  7 10:03:22 2007
@@ -558,18 +558,18 @@
         vereq(s.unpack_from(data), ('abcd',))
         vereq(s.unpack_from(data, 2), ('cd01',))
         vereq(s.unpack_from(data, 4), ('0123',))
-        for i in xrange(6):
+        for i in range(6):
             vereq(s.unpack_from(data, i), (data[i:i+4],))
-        for i in xrange(6, len(test_string) + 1):
+        for i in range(6, len(test_string) + 1):
             simple_err(s.unpack_from, data, i)
     for cls in (str, buffer):
         data = cls(test_string)
         vereq(struct.unpack_from(fmt, data), ('abcd',))
         vereq(struct.unpack_from(fmt, data, 2), ('cd01',))
         vereq(struct.unpack_from(fmt, data, 4), ('0123',))
-        for i in xrange(6):
+        for i in range(6):
             vereq(struct.unpack_from(fmt, data, i), (data[i:i+4],))
-        for i in xrange(6, len(test_string) + 1):
+        for i in range(6, len(test_string) + 1):
             simple_err(struct.unpack_from, fmt, data, i)
 
 def test_pack_into():

Modified: python/branches/p3yk/Lib/test/test_structseq.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_structseq.py	(original)
+++ python/branches/p3yk/Lib/test/test_structseq.py	Mon May  7 10:03:22 2007
@@ -13,17 +13,17 @@
 
         # Check that slicing works the same way; at one point, slicing t[i:j] with
         # 0 < i < j could produce NULLs in the result.
-        for i in xrange(-len(t), len(t)):
+        for i in range(-len(t), len(t)):
             self.assertEqual(t[i:], astuple[i:])
-            for j in xrange(-len(t), len(t)):
+            for j in range(-len(t), len(t)):
                 self.assertEqual(t[i:j], astuple[i:j])
 
-        for j in xrange(-len(t), len(t)):
+        for j in range(-len(t), len(t)):
             self.assertEqual(t[:j], astuple[:j])
 
         self.assertRaises(IndexError, t.__getitem__, -len(t)-1)
         self.assertRaises(IndexError, t.__getitem__, len(t))
-        for i in xrange(-len(t), len(t)-1):
+        for i in range(-len(t), len(t)-1):
             self.assertEqual(t[i], astuple[i])
 
     def test_repr(self):
@@ -33,13 +33,13 @@
     def test_concat(self):
         t1 = time.gmtime()
         t2 = t1 + tuple(t1)
-        for i in xrange(len(t1)):
+        for i in range(len(t1)):
             self.assertEqual(t2[i], t2[i+len(t1)])
 
     def test_repeat(self):
         t1 = time.gmtime()
         t2 = 3 * t1
-        for i in xrange(len(t1)):
+        for i in range(len(t1)):
             self.assertEqual(t2[i], t2[i+len(t1)])
             self.assertEqual(t2[i], t2[i+2*len(t1)])
 

Modified: python/branches/p3yk/Lib/test/test_tempfile.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_tempfile.py	(original)
+++ python/branches/p3yk/Lib/test/test_tempfile.py	Mon May  7 10:03:22 2007
@@ -111,7 +111,7 @@
 
         dict = {}
         r = self.r
-        for i in xrange(TEST_FILES):
+        for i in range(TEST_FILES):
             s = next(r)
             self.nameCheck(s, '', '', '')
             self.failIf(s in dict)
@@ -245,7 +245,7 @@
 
     def test_basic_many(self):
         # _mkstemp_inner can create many files (stochastic)
-        extant = range(TEST_FILES)
+        extant = list(range(TEST_FILES))
         for i in extant:
             extant[i] = self.do_create(pre="aa")
 
@@ -457,7 +457,7 @@
 
     def test_basic_many(self):
         # mkdtemp can create many directories (stochastic)
-        extant = range(TEST_FILES)
+        extant = list(range(TEST_FILES))
         try:
             for i in extant:
                 extant[i] = self.do_create(pre="aa")
@@ -541,7 +541,7 @@
 
     def test_many(self):
         # mktemp can choose many usable file names (stochastic)
-        extant = range(TEST_FILES)
+        extant = list(range(TEST_FILES))
         for i in extant:
             extant[i] = self.do_create(pre="aa")
 

Modified: python/branches/p3yk/Lib/test/test_trace.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_trace.py	(original)
+++ python/branches/p3yk/Lib/test/test_trace.py	Mon May  7 10:03:22 2007
@@ -285,7 +285,7 @@
         handled OK."""
         self.raiseOnEvent = event
         try:
-            for i in xrange(sys.getrecursionlimit() + 1):
+            for i in range(sys.getrecursionlimit() + 1):
                 sys.settrace(self.trace)
                 try:
                     self.f()

Modified: python/branches/p3yk/Lib/test/test_tuple.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_tuple.py	(original)
+++ python/branches/p3yk/Lib/test/test_tuple.py	Mon May  7 10:03:22 2007
@@ -39,7 +39,7 @@
         def f():
             for i in range(1000):
                 yield i
-        self.assertEqual(list(tuple(f())), range(1000))
+        self.assertEqual(list(tuple(f())), list(range(1000)))
 
     def test_hash(self):
         # See SF bug 942952:  Weakness in tuple hash
@@ -58,7 +58,7 @@
         #      is sorely suspect.
 
         N=50
-        base = range(N)
+        base = list(range(N))
         xp = [(i, j) for i in base for j in base]
         inps = base + [(i, j) for i in base for j in xp] + \
                      [(i, j) for i in xp for j in base] + xp + list(zip(base))

Modified: python/branches/p3yk/Lib/test/test_ucn.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_ucn.py	(original)
+++ python/branches/p3yk/Lib/test/test_ucn.py	Mon May  7 10:03:22 2007
@@ -61,7 +61,7 @@
     def test_ascii_letters(self):
         import unicodedata
 
-        for char in "".join(map(chr, xrange(ord("a"), ord("z")))):
+        for char in "".join(map(chr, range(ord("a"), ord("z")))):
             name = "LATIN SMALL LETTER %s" % char.upper()
             code = unicodedata.lookup(name)
             self.assertEqual(unicodedata.name(code), name)
@@ -95,7 +95,7 @@
     def test_bmp_characters(self):
         import unicodedata
         count = 0
-        for code in xrange(0x10000):
+        for code in range(0x10000):
             char = unichr(code)
             name = unicodedata.name(char, None)
             if name is not None:

Modified: python/branches/p3yk/Lib/test/test_unicode.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_unicode.py	(original)
+++ python/branches/p3yk/Lib/test/test_unicode.py	Mon May  7 10:03:22 2007
@@ -90,7 +90,7 @@
                 "\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef"
                 "\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd"
                 "\\xfe\\xff'")
-            testrepr = repr(u''.join(map(unichr, xrange(256))))
+            testrepr = repr(u''.join(map(unichr, range(256))))
             self.assertEqual(testrepr, latin1repr)
             # Test repr works on wide unicode escapes without overflow.
             self.assertEqual(repr(u"\U00010000" * 39 + u"\uffff" * 4096),
@@ -631,7 +631,7 @@
         self.assertEqual(u'hello'.encode('latin-1'), 'hello')
 
         # Roundtrip safety for BMP (just the first 1024 chars)
-        for c in xrange(1024):
+        for c in range(1024):
             u = unichr(c)
             for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le',
                              'utf-16-be', 'raw_unicode_escape',
@@ -639,13 +639,13 @@
                 self.assertEqual(unicode(u.encode(encoding),encoding), u)
 
         # Roundtrip safety for BMP (just the first 256 chars)
-        for c in xrange(256):
+        for c in range(256):
             u = unichr(c)
             for encoding in ('latin-1',):
                 self.assertEqual(unicode(u.encode(encoding),encoding), u)
 
         # Roundtrip safety for BMP (just the first 128 chars)
-        for c in xrange(128):
+        for c in range(128):
             u = unichr(c)
             for encoding in ('ascii',):
                 self.assertEqual(unicode(u.encode(encoding),encoding), u)
@@ -661,13 +661,14 @@
         # This excludes surrogates: in the full range, there would be
         # a surrogate pair (\udbff\udc00), which gets converted back
         # to a non-BMP character (\U0010fc00)
-        u = u''.join(map(unichr, range(0,0xd800)+range(0xe000,0x10000)))
+        u = u''.join(map(unichr, list(range(0,0xd800)) +
+                                 list(range(0xe000,0x10000))))
         for encoding in ('utf-8',):
             self.assertEqual(unicode(u.encode(encoding),encoding), u)
 
     def test_codecs_charmap(self):
         # 0-127
-        s = ''.join(map(chr, xrange(128)))
+        s = ''.join(map(chr, range(128)))
         for encoding in (
             'cp037', 'cp1026',
             'cp437', 'cp500', 'cp737', 'cp775', 'cp850',
@@ -695,7 +696,7 @@
             self.assertEqual(unicode(s, encoding).encode(encoding), s)
 
         # 128-255
-        s = ''.join(map(chr, xrange(128, 256)))
+        s = ''.join(map(chr, range(128, 256)))
         for encoding in (
             'cp037', 'cp1026',
             'cp437', 'cp500', 'cp737', 'cp775', 'cp850',

Modified: python/branches/p3yk/Lib/test/test_unicodedata.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_unicodedata.py	(original)
+++ python/branches/p3yk/Lib/test/test_unicodedata.py	Mon May  7 10:03:22 2007
@@ -193,7 +193,7 @@
         # i.e. if a character has a decimal value,
         # its numeric value should be the same.
         count = 0
-        for i in xrange(0x10000):
+        for i in range(0x10000):
             c = unichr(i)
             dec = self.db.decimal(c, -1)
             if dec != -1:
@@ -206,7 +206,7 @@
         # i.e. if a character has a digit value,
         # its numeric value should be the same.
         count = 0
-        for i in xrange(0x10000):
+        for i in range(0x10000):
             c = unichr(i)
             dec = self.db.digit(c, -1)
             if dec != -1:

Modified: python/branches/p3yk/Lib/test/test_userdict.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_userdict.py	(original)
+++ python/branches/p3yk/Lib/test/test_userdict.py	Mon May  7 10:03:22 2007
@@ -118,7 +118,7 @@
             self.assertEqual(u0.get(i), d0.get(i))
 
         # Test "in" iteration.
-        for i in xrange(20):
+        for i in range(20):
             u2[i] = str(i)
         ikeys = []
         for k in u2:

Modified: python/branches/p3yk/Lib/test/test_userlist.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_userlist.py	(original)
+++ python/branches/p3yk/Lib/test/test_userlist.py	Mon May  7 10:03:22 2007
@@ -14,7 +14,7 @@
         for i in range(-3, 6):
             self.assertEqual(u[:i], l[:i])
             self.assertEqual(u[i:], l[i:])
-            for j in xrange(-3, 6):
+            for j in range(-3, 6):
                 self.assertEqual(u[i:j], l[i:j])
 
     def test_add_specials(self):

Modified: python/branches/p3yk/Lib/test/test_winsound.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_winsound.py	(original)
+++ python/branches/p3yk/Lib/test/test_winsound.py	Mon May  7 10:03:22 2007
@@ -19,7 +19,7 @@
         winsound.Beep(32767, 75)
 
     def test_increasingfrequency(self):
-        for i in xrange(100, 2000, 100):
+        for i in range(100, 2000, 100):
             winsound.Beep(i, 75)
 
 class MessageBeepTest(unittest.TestCase):

Modified: python/branches/p3yk/Lib/test/test_xdrlib.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_xdrlib.py	(original)
+++ python/branches/p3yk/Lib/test/test_xdrlib.py	Mon May  7 10:03:22 2007
@@ -44,7 +44,7 @@
         self.assertAlmostEqual(up.unpack_float(), 1.9)
         self.assertAlmostEqual(up.unpack_double(), 1.9)
         self.assertEqual(up.unpack_string(), s)
-        self.assertEqual(up.unpack_list(up.unpack_uint), range(5))
+        self.assertEqual(up.unpack_list(up.unpack_uint), list(range(5)))
         self.assertEqual(up.unpack_array(up.unpack_string), a)
         up.done()
         self.assertRaises(EOFError, up.unpack_uint)

Modified: python/branches/p3yk/Lib/test/test_xrange.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_xrange.py	(original)
+++ python/branches/p3yk/Lib/test/test_xrange.py	Mon May  7 10:03:22 2007
@@ -9,56 +9,52 @@
 
 class XrangeTest(unittest.TestCase):
     def test_xrange(self):
-        self.assertEqual(list(xrange(3)), [0, 1, 2])
-        self.assertEqual(list(xrange(1, 5)), [1, 2, 3, 4])
-        self.assertEqual(list(xrange(0)), [])
-        self.assertEqual(list(xrange(-3)), [])
-        self.assertEqual(list(xrange(1, 10, 3)), [1, 4, 7])
-        self.assertEqual(list(xrange(5, -5, -3)), [5, 2, -1, -4])
+        self.assertEqual(list(range(3)), [0, 1, 2])
+        self.assertEqual(list(range(1, 5)), [1, 2, 3, 4])
+        self.assertEqual(list(range(0)), [])
+        self.assertEqual(list(range(-3)), [])
+        self.assertEqual(list(range(1, 10, 3)), [1, 4, 7])
+        self.assertEqual(list(range(5, -5, -3)), [5, 2, -1, -4])
 
         a = 10
         b = 100
         c = 50
 
-        self.assertEqual(list(xrange(a, a+2)), [a, a+1])
-        self.assertEqual(list(xrange(a+2, a, -1)), [a+2, a+1])
-        self.assertEqual(list(xrange(a+4, a, -2)), [a+4, a+2])
+        self.assertEqual(list(range(a, a+2)), [a, a+1])
+        self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1])
+        self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2])
 
-        seq = list(xrange(a, b, c))
+        seq = list(range(a, b, c))
         self.assert_(a in seq)
         self.assert_(b not in seq)
         self.assertEqual(len(seq), 2)
 
-        seq = list(xrange(b, a, -c))
+        seq = list(range(b, a, -c))
         self.assert_(b in seq)
         self.assert_(a not in seq)
         self.assertEqual(len(seq), 2)
 
-        seq = list(xrange(-a, -b, -c))
+        seq = list(range(-a, -b, -c))
         self.assert_(-a in seq)
         self.assert_(-b not in seq)
         self.assertEqual(len(seq), 2)
 
-        self.assertRaises(TypeError, xrange)
-        self.assertRaises(TypeError, xrange, 1, 2, 3, 4)
-        self.assertRaises(ValueError, xrange, 1, 2, 0)
+        self.assertRaises(TypeError, range)
+        self.assertRaises(TypeError, range, 1, 2, 3, 4)
+        self.assertRaises(ValueError, range, 1, 2, 0)
 
-        self.assertRaises(TypeError, xrange, 0.0, 2, 1)
-        self.assertRaises(TypeError, xrange, 1, 2.0, 1)
-        self.assertRaises(TypeError, xrange, 1, 2, 1.0)
-        self.assertRaises(TypeError, xrange, 1e100, 1e101, 1e101)
+        self.assertRaises(TypeError, range, 0.0, 2, 1)
+        self.assertRaises(TypeError, range, 1, 2.0, 1)
+        self.assertRaises(TypeError, range, 1, 2, 1.0)
+        self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
 
-        self.assertRaises(TypeError, xrange, 0, "spam")
-        self.assertRaises(TypeError, xrange, 0, 42, "spam")
+        self.assertRaises(TypeError, range, 0, "spam")
+        self.assertRaises(TypeError, range, 0, 42, "spam")
 
-        self.assertEqual(len(xrange(0, sys.maxint, sys.maxint-1)), 2)
+        self.assertEqual(len(range(0, sys.maxint, sys.maxint-1)), 2)
 
-        self.assertRaises(OverflowError, xrange, -sys.maxint, sys.maxint)
-        self.assertRaises(OverflowError, xrange, 0, 2*sys.maxint)
-
-        r = xrange(-sys.maxint, sys.maxint, 2)
+        r = range(-sys.maxint, sys.maxint, 2)
         self.assertEqual(len(r), sys.maxint)
-        self.assertRaises(OverflowError, xrange, -sys.maxint-1, sys.maxint, 2)
 
 def test_main():
     test.test_support.run_unittest(XrangeTest)

Modified: python/branches/p3yk/Lib/test/test_zipfile.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_zipfile.py	(original)
+++ python/branches/p3yk/Lib/test/test_zipfile.py	Mon May  7 10:03:22 2007
@@ -19,7 +19,7 @@
 class TestsWithSourceFile(unittest.TestCase):
     def setUp(self):
         self.line_gen = ("Zipfile test line %d. random float: %f" % (i, random())
-                          for i in xrange(FIXEDTEST_SIZE))
+                          for i in range(FIXEDTEST_SIZE))
         self.data = '\n'.join(self.line_gen) + '\n'
 
         # Make a source file with some lines
@@ -562,7 +562,7 @@
 class TestsWithRandomBinaryFiles(unittest.TestCase):
     def setUp(self):
         datacount = randint(16, 64)*1024 + randint(1, 1024)
-        self.data = ''.join((struct.pack('<f', random()*randint(-1000, 1000)) for i in xrange(datacount)))
+        self.data = ''.join((struct.pack('<f', random()*randint(-1000, 1000)) for i in range(datacount)))
 
         # Make a source file with some lines
         fp = open(TESTFN, "wb")
@@ -706,7 +706,7 @@
 
 class UniversalNewlineTests(unittest.TestCase):
     def setUp(self):
-        self.line_gen = ["Test of zipfile line %d." % i for i in xrange(FIXEDTEST_SIZE)]
+        self.line_gen = ["Test of zipfile line %d." % i for i in range(FIXEDTEST_SIZE)]
         self.seps = ('\r', '\r\n', '\n')
         self.arcdata, self.arcfiles = {}, {}
         for n, s in enumerate(self.seps):

Modified: python/branches/p3yk/Lib/test/test_zipfile64.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_zipfile64.py	(original)
+++ python/branches/p3yk/Lib/test/test_zipfile64.py	Mon May  7 10:03:22 2007
@@ -33,9 +33,7 @@
 class TestsWithSourceFile(unittest.TestCase):
     def setUp(self):
         # Create test data.
-        # xrange() is important here -- don't want to create immortal space
-        # for a million ints.
-        line_gen = ("Test of zipfile line %d." % i for i in xrange(1000000))
+        line_gen = ("Test of zipfile line %d." % i for i in range(1000000))
         self.data = '\n'.join(line_gen)
 
         # And write it to a file.

Modified: python/branches/p3yk/Lib/test/time_hashlib.py
==============================================================================
--- python/branches/p3yk/Lib/test/time_hashlib.py	(original)
+++ python/branches/p3yk/Lib/test/time_hashlib.py	Mon May  7 10:03:22 2007
@@ -14,7 +14,7 @@
 
     localCF = creatorFunc
     start = time.time()
-    for f in xrange(iterations):
+    for f in range(iterations):
         x = localCF(longStr).digest()
     end = time.time()
 
@@ -22,7 +22,7 @@
 
 def test_create():
     start = time.time()
-    for f in xrange(20000):
+    for f in range(20000):
         d = creatorFunc()
     end = time.time()
 
@@ -30,7 +30,7 @@
 
 def test_zero():
     start = time.time()
-    for f in xrange(20000):
+    for f in range(20000):
         x = creatorFunc().digest()
     end = time.time()
 

Modified: python/branches/p3yk/Lib/types.py
==============================================================================
--- python/branches/p3yk/Lib/types.py	(original)
+++ python/branches/p3yk/Lib/types.py	Mon May  7 10:03:22 2007
@@ -63,7 +63,6 @@
 
 ModuleType = type(sys)
 FileType = file
-XRangeType = xrange
 
 try:
     raise TypeError

Modified: python/branches/p3yk/Lib/urllib.py
==============================================================================
--- python/branches/p3yk/Lib/urllib.py	(original)
+++ python/branches/p3yk/Lib/urllib.py	Mon May  7 10:03:22 2007
@@ -1151,7 +1151,7 @@
 def unquote(s):
     """unquote('abc%20def') -> 'abc def'."""
     res = s.split('%')
-    for i in xrange(1, len(res)):
+    for i in range(1, len(res)):
         item = res[i]
         try:
             res[i] = _hextochr[item[:2]] + item[2:]

Modified: python/branches/p3yk/Misc/NEWS
==============================================================================
--- python/branches/p3yk/Misc/NEWS	(original)
+++ python/branches/p3yk/Misc/NEWS	Mon May  7 10:03:22 2007
@@ -16,11 +16,9 @@
 
 - Weed really old/weird stuff from the library.
 
-- Unify range() and xrange().
-
 - Use io.py instead of C stdio everywhere.
 
-- Make strings all Unicode.
+- Make strings all Unicode (see branches/py3k-struni).
 
 - Get rid of various compatibility-related flags (e.g. division flags).
 
@@ -28,6 +26,9 @@
 Core and Builtins
 -----------------
 
+- range() now returns an iterator rather than a list.  Floats are not allowed.
+  xrange() is no longer defined.
+
 - Merged from (2.6) trunk at r54987.
 
 - Patch #1660500: hide iteration variable in list comps, add set comps
@@ -171,7 +172,7 @@
 Library
 -------
 
-- Remove functions in string module that are also string methods.
+- Remove functions in string and strop modules that are also string methods.
 
 - Remove obsolete modules: xmllib, stringold.
 

Modified: python/branches/p3yk/Objects/rangeobject.c
==============================================================================
--- python/branches/p3yk/Objects/rangeobject.c	(original)
+++ python/branches/p3yk/Objects/rangeobject.c	Mon May  7 10:03:22 2007
@@ -2,139 +2,292 @@
 
 #include "Python.h"
 
+/* Support objects whose length is > PY_SSIZE_T_MAX.
+
+   This could be sped up for small PyLongs if they fit in an Py_ssize_t.
+   This only matters on Win64.  Though we could use PY_LONG_LONG which
+   would presumably help perf.
+*/
+
 typedef struct {
-	PyObject_HEAD
-	long	start;
-	long	step;
-	long	len;
+    PyObject_HEAD
+    PyObject *start;
+    PyObject *stop;
+    PyObject *step;
 } rangeobject;
 
-/* Return number of items in range/xrange (lo, hi, step).  step > 0
- * required.  Return a value < 0 if & only if the true value is too
- * large to fit in a signed long.
- */
-static long
-get_len_of_range(long lo, long hi, long step)
+/* Helper function for validating step.  Always returns a new reference or
+   NULL on error. 
+*/
+static PyObject *
+validate_step(PyObject *step)
 {
-	/* -------------------------------------------------------------
-	If lo >= hi, the range is empty.
-	Else if n values are in the range, the last one is
-	lo + (n-1)*step, which must be <= hi-1.  Rearranging,
-	n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
-	the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
-	the RHS is non-negative and so truncation is the same as the
-	floor.  Letting M be the largest positive long, the worst case
-	for the RHS numerator is hi=M, lo=-M-1, and then
-	hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
-	precision to compute the RHS exactly.
-	---------------------------------------------------------------*/
-	long n = 0;
-	if (lo < hi) {
-		unsigned long uhi = (unsigned long)hi;
-		unsigned long ulo = (unsigned long)lo;
-		unsigned long diff = uhi - ulo - 1;
-		n = (long)(diff / (unsigned long)step + 1);
-	}
-	return n;
+    /* No step specified, use a step of 1. */
+    if (!step)
+        return PyInt_FromLong(1);
+
+    step = PyNumber_Index(step);
+    if (step) {
+        Py_ssize_t istep = PyNumber_AsSsize_t(step, NULL);
+        if (istep == -1 && PyErr_Occurred()) {
+            /* Ignore OverflowError, we know the value isn't 0. */
+            PyErr_Clear();
+        }
+        else if (istep == 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "range() arg 3 must not be zero");
+            Py_CLEAR(step);
+        }
+    }
+
+    return step;
 }
 
+/* XXX(nnorwitz): should we error check if the user passes any empty ranges?
+   range(-10)
+   range(0, -5)
+   range(0, 5, -1)
+*/
 static PyObject *
 range_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
-	rangeobject *obj;
-	long ilow = 0, ihigh = 0, istep = 1;
-	long n;
-
-	if (!_PyArg_NoKeywords("xrange()", kw))
-		return NULL;
-
-	if (PyTuple_Size(args) <= 1) {
-		if (!PyArg_ParseTuple(args,
-				"l;xrange() requires 1-3 int arguments",
-				&ihigh))
-			return NULL;
-	}
-	else {
-		if (!PyArg_ParseTuple(args,
-				"ll|l;xrange() requires 1-3 int arguments",
-				&ilow, &ihigh, &istep))
-			return NULL;
-	}
-	if (istep == 0) {
-		PyErr_SetString(PyExc_ValueError, "xrange() arg 3 must not be zero");
-		return NULL;
-	}
-	if (istep > 0)
-		n = get_len_of_range(ilow, ihigh, istep);
-	else
-		n = get_len_of_range(ihigh, ilow, -istep);
-	if (n < 0) {
-		PyErr_SetString(PyExc_OverflowError,
-				"xrange() result has too many items");
-		return NULL;
-	}
-
-	obj = PyObject_New(rangeobject, &PyRange_Type);
-	if (obj == NULL)
-		return NULL;
-	obj->start = ilow;
-	obj->len   = n;
-	obj->step  = istep;
-	return (PyObject *) obj;
+    rangeobject *obj = NULL;
+    PyObject *start = NULL, *stop = NULL, *step = NULL;
+
+    if (!_PyArg_NoKeywords("range()", kw))
+        return NULL;
+
+    if (PyTuple_Size(args) <= 1) {
+        if (!PyArg_UnpackTuple(args, "range", 1, 1, &stop))
+            goto Fail;
+        stop = PyNumber_Index(stop);
+        if (!stop)
+            goto Fail;
+        start = PyInt_FromLong(0);
+        step = PyInt_FromLong(1);
+        if (!start || !step)
+            goto Fail;
+    }
+    else {
+        if (!PyArg_UnpackTuple(args, "range", 2, 3,
+                               &start, &stop, &step))
+            goto Fail;
+
+        /* Convert borrowed refs to owned refs */
+        start = PyNumber_Index(start);
+        stop = PyNumber_Index(stop);
+        step = validate_step(step);
+        if (!start || !stop || !step)
+            goto Fail;
+    }
+
+    obj = PyObject_New(rangeobject, &PyRange_Type);
+    if (obj == NULL)
+        goto Fail;
+    obj->start = start;
+    obj->stop = stop;
+    obj->step = step;
+    return (PyObject *) obj;
+
+Fail:
+    Py_XDECREF(start);
+    Py_XDECREF(stop);
+    Py_XDECREF(step);
+    return NULL;
 }
 
 PyDoc_STRVAR(range_doc,
-"xrange([start,] stop[, step]) -> xrange object\n\
+"range([start,] stop[, step]) -> range object\n\
 \n\
-Like range(), but instead of returning a list, returns an object that\n\
-generates the numbers in the range on demand.  For looping, this is \n\
-slightly faster than range() and more memory efficient.");
+Returns an iterator that generates the numbers in the range on demand.");
 
-static PyObject *
-range_item(rangeobject *r, Py_ssize_t i)
+static void
+range_dealloc(rangeobject *r)
+{
+    Py_DECREF(r->start);
+    Py_DECREF(r->stop);
+    Py_DECREF(r->step);
+}
+
+/* Return number of items in range (lo, hi, step), when arguments are
+ * PyInt or PyLong objects.  step > 0 required.  Return a value < 0 if
+ * & only if the true value is too large to fit in a signed long.
+ * Arguments MUST return 1 with either PyInt_Check() or
+ * PyLong_Check().  Return -1 when there is an error.
+ */
+static PyObject*
+range_length_obj(rangeobject *r)
 {
-	if (i < 0 || i >= r->len) {
-		PyErr_SetString(PyExc_IndexError,
-				"xrange object index out of range");
-		return NULL;
-	}
-	return PyInt_FromSsize_t(r->start + (i % r->len) * r->step);
+    /* -------------------------------------------------------------
+    Algorithm is equal to that of get_len_of_range(), but it operates
+    on PyObjects (which are assumed to be PyLong or PyInt objects).
+    ---------------------------------------------------------------*/
+    int cmp_result, cmp_call;
+    PyObject *lo, *hi;
+    PyObject *step = NULL;
+    PyObject *diff = NULL;
+    PyObject *one = NULL;
+    PyObject *tmp1 = NULL, *tmp2 = NULL, *result;
+                /* holds sub-expression evaluations */
+
+    PyObject *zero = PyLong_FromLong(0);
+    if (zero == NULL)
+        return NULL;
+    cmp_call = PyObject_Cmp(r->step, zero, &cmp_result);
+    Py_DECREF(zero);
+    if (cmp_call == -1)
+        return NULL;
+
+    assert(cmp_result != 0);
+    if (cmp_result > 0) {
+        lo = r->start;
+        hi = r->stop;
+        step = r->step;
+        Py_INCREF(step);
+    } else {
+        lo = r->stop;
+        hi = r->start;
+        step = PyNumber_Negative(r->step);
+        if (!step)
+            return NULL;
+    }
+
+    /* if (lo >= hi), return length of 0. */
+    if (PyObject_Compare(lo, hi) >= 0) {
+        Py_XDECREF(step);
+        return PyLong_FromLong(0);
+    }
+
+    if ((one = PyLong_FromLong(1L)) == NULL)
+        goto Fail;
+
+    if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
+        goto Fail;
+
+    if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
+        goto Fail;
+
+    if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
+        goto Fail;
+
+    if ((result = PyNumber_Add(tmp2, one)) == NULL)
+        goto Fail;
+
+    Py_DECREF(tmp2);
+    Py_DECREF(diff);
+    Py_DECREF(step);
+    Py_DECREF(tmp1);
+    Py_DECREF(one);
+    return result;
+
+  Fail:
+    Py_XDECREF(tmp2);
+    Py_XDECREF(diff);
+    Py_XDECREF(step);
+    Py_XDECREF(tmp1);
+    Py_XDECREF(one);
+    return NULL;
 }
 
 static Py_ssize_t
 range_length(rangeobject *r)
 {
-	return (Py_ssize_t)(r->len);
+    PyObject *len = range_length_obj(r);
+    Py_ssize_t result = -1;
+    if (len) {
+        result = PyLong_AsSsize_t(len);
+        Py_DECREF(len);
+    }
+    return result;
 }
 
+/* range(...)[x] is necessary for:  seq[:] = range(...) */
+
 static PyObject *
-range_repr(rangeobject *r)
+range_item(rangeobject *r, Py_ssize_t i)
 {
-	PyObject *rtn;
+    Py_ssize_t len = range_length(r);
+    PyObject *rem, *incr, *result;
 
-	if (r->start == 0 && r->step == 1)
-		rtn = PyString_FromFormat("xrange(%ld)",
-					  r->start + r->len * r->step);
-
-	else if (r->step == 1)
-		rtn = PyString_FromFormat("xrange(%ld, %ld)",
-					  r->start,
-					  r->start + r->len * r->step);
-
-	else
-		rtn = PyString_FromFormat("xrange(%ld, %ld, %ld)",
-					  r->start,
-					  r->start + r->len * r->step,
-					  r->step);
-	return rtn;
+    /* XXX(nnorwitz): should negative indices be supported? */
+    /* XXX(nnorwitz): should support range[x] where x > PY_SSIZE_T_MAX? */
+    if (i < 0 || i >= len) {
+        if (!PyErr_Occurred())
+            PyErr_SetString(PyExc_IndexError,
+                            "xrange object index out of range");
+            return NULL;
+        }
+
+    /* XXX(nnorwitz): optimize for short ints. */
+    rem = PyLong_FromSsize_t(i % len);
+    if (!rem)
+        return NULL;
+    incr = PyNumber_Multiply(rem, r->step);
+    Py_DECREF(rem);
+    if (!incr)
+        return NULL;
+    result = PyNumber_Add(r->start, incr);
+    Py_DECREF(incr);
+    return result;
+}
+
+static PyObject *
+range_repr(rangeobject *r)
+{
+    PyObject *start_str = NULL, *stop_str = NULL, *step_str = NULL;
+    PyObject *result = NULL;
+    Py_ssize_t istart, istep;
+
+    /* We always need the stop value. */
+    stop_str = PyObject_Str(r->stop);
+    if (!stop_str)
+        return NULL;
+
+    /* XXX(nnorwitz): should we use PyObject_Repr instead of str? */
+
+    /* Check for special case values for printing.  We don't always
+       need the start or step values.  We don't care about errors
+       (it means overflow), so clear the errors. */
+    istart = PyNumber_AsSsize_t(r->start, NULL);
+    if (istart != 0 || (istart == -1 && PyErr_Occurred())) {
+        PyErr_Clear();
+        start_str = PyObject_Str(r->start);
+    }
+
+    istep = PyNumber_AsSsize_t(r->step, NULL);
+    if (istep != 1 || (istep == -1 && PyErr_Occurred())) {
+        PyErr_Clear();
+        step_str = PyObject_Str(r->step);
+    }
+
+    if (istart == 0 && istep == 1)
+        result = PyString_FromFormat("range(%s)",
+                                     PyString_AS_STRING(stop_str));
+    else if (istep == 1) {
+        if (start_str)
+            result = PyString_FromFormat("range(%s, %s)",
+                                         PyString_AS_STRING(start_str),
+                                         PyString_AS_STRING(stop_str));
+    }
+    else if (start_str && step_str)
+        result = PyString_FromFormat("range(%s, %s, %s)",
+                                     PyString_AS_STRING(start_str),
+                                     PyString_AS_STRING(stop_str),
+                                     PyString_AS_STRING(step_str));
+    /* else result is NULL and an error should already be set. */
+
+    Py_XDECREF(start_str);
+    Py_XDECREF(stop_str);
+    Py_XDECREF(step_str);
+    return result;
 }
 
 static PySequenceMethods range_as_sequence = {
-	(lenfunc)range_length,	/* sq_length */
-	0,			/* sq_concat */
-	0,			/* sq_repeat */
-	(ssizeargfunc)range_item, /* sq_item */
-	0,			/* sq_slice */
+    (lenfunc)range_length,	/* sq_length */
+    0,			/* sq_concat */
+    0,			/* sq_repeat */
+    (ssizeargfunc)range_item, /* sq_item */
+    0,			/* sq_slice */
 };
 
 static PyObject * range_iter(PyObject *seq);
@@ -144,17 +297,18 @@
 "Returns a reverse iterator.");
 
 static PyMethodDef range_methods[] = {
-	{"__reversed__",	(PyCFunction)range_reverse, METH_NOARGS, reverse_doc},
- 	{NULL,		NULL}		/* sentinel */
+    {"__reversed__",	(PyCFunction)range_reverse, METH_NOARGS,
+	reverse_doc},
+    {NULL,		NULL}		/* sentinel */
 };
 
 PyTypeObject PyRange_Type = {
 	PyObject_HEAD_INIT(&PyType_Type)
 	0,			/* Number of items for varobject */
-	"xrange",		/* Name of this type */
+	"range",		/* Name of this type */
 	sizeof(rangeobject),	/* Basic object size */
 	0,			/* Item size for varobject */
-	(destructor)PyObject_Del, /* tp_dealloc */
+	(destructor)range_dealloc, /* tp_dealloc */
 	0,			/* tp_print */
 	0,			/* tp_getattr */
 	0,			/* tp_setattr */
@@ -192,6 +346,11 @@
 
 /*********************** Xrange Iterator **************************/
 
+/* There are 2 types of iterators, one for C longs, the other for
+   Python longs (ie, PyObjects).  This should make iteration fast
+   in the normal case, but possible for any numeric value.
+*/
+
 typedef struct {
 	PyObject_HEAD
 	long	index;
@@ -203,25 +362,42 @@
 static PyObject *
 rangeiter_next(rangeiterobject *r)
 {
-	if (r->index < r->len)
-		return PyInt_FromLong(r->start + (r->index++) * r->step);
-	return NULL;
+    if (r->index < r->len)
+        return PyInt_FromLong(r->start + (r->index++) * r->step);
+    return NULL;
 }
 
 static PyObject *
 rangeiter_len(rangeiterobject *r)
 {
-	return PyInt_FromLong(r->len - r->index);
+    return PyInt_FromLong(r->len - r->index);
+}
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *index;
+    PyObject *start;
+    PyObject *step;
+    PyObject *len;
+} longrangeiterobject;
+
+static PyObject *
+longrangeiter_len(longrangeiterobject *r, PyObject *no_args)
+{
+    return PyNumber_Subtract(r->len, r->index);
 }
+static PyObject *rangeiter_new(PyTypeObject *, PyObject *args, PyObject *kw);
 
-PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
+PyDoc_STRVAR(length_hint_doc,
+             "Private method returning an estimate of len(list(it)).");
 
 static PyMethodDef rangeiter_methods[] = {
-	{"__length_hint__", (PyCFunction)rangeiter_len, METH_NOARGS, length_hint_doc},
- 	{NULL,		NULL}		/* sentinel */
+    {"__length_hint__", (PyCFunction)rangeiter_len, METH_NOARGS,
+	length_hint_doc},
+    {NULL,		NULL}		/* sentinel */
 };
 
-static PyTypeObject Pyrangeiter_Type = {
+PyTypeObject Pyrangeiter_Type = {
 	PyObject_HEAD_INIT(&PyType_Type)
 	0,                                      /* ob_size */
 	"rangeiterator",                        /* tp_name */
@@ -252,50 +428,279 @@
 	PyObject_SelfIter,			/* tp_iter */
 	(iternextfunc)rangeiter_next,		/* tp_iternext */
 	rangeiter_methods,			/* tp_methods */
-	0,
+	0,					/* tp_members */
+	0,					/* tp_getset */
+	0,					/* tp_base */
+	0,					/* tp_dict */
+	0,					/* tp_descr_get */
+	0,					/* tp_descr_set */
+	0,					/* tp_dictoffset */
+	0,					/* tp_init */
+	0,					/* tp_alloc */
+	rangeiter_new,				/* tp_new */
 };
 
+/* Return number of items in range/xrange (lo, hi, step).  step > 0
+ * required.  Return a value < 0 if & only if the true value is too
+ * large to fit in a signed long.
+ */
+static long
+get_len_of_range(long lo, long hi, long step)
+{
+    /* -------------------------------------------------------------
+    If lo >= hi, the range is empty.
+    Else if n values are in the range, the last one is
+    lo + (n-1)*step, which must be <= hi-1.  Rearranging,
+    n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
+    the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
+    the RHS is non-negative and so truncation is the same as the
+    floor.  Letting M be the largest positive long, the worst case
+    for the RHS numerator is hi=M, lo=-M-1, and then
+    hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
+    precision to compute the RHS exactly.
+    ---------------------------------------------------------------*/
+    long n = 0;
+    if (lo < hi) {
+        unsigned long uhi = (unsigned long)hi;
+        unsigned long ulo = (unsigned long)lo;
+        unsigned long diff = uhi - ulo - 1;
+        n = (long)(diff / (unsigned long)step + 1);
+    }
+    return n;
+}
+
 static PyObject *
-range_iter(PyObject *seq)
+int_range_iter(long start, long stop, long step)
+{
+    rangeiterobject *it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
+    if (it == NULL)
+        return NULL;
+    it->start = start;
+    it->step = step;
+    if (step > 0)
+        it->len = get_len_of_range(start, stop, step);
+    else
+        it->len = get_len_of_range(stop, start, -step);
+    it->index = 0;
+    return (PyObject *)it;
+}
+
+static PyObject *
+rangeiter_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
-	rangeiterobject *it;
+    long start, stop, step;
+
+    if (!_PyArg_NoKeywords("rangeiter()", kw))
+        return NULL;
 
-	if (!PyRange_Check(seq)) {
-		PyErr_BadInternalCall();
-		return NULL;
-	}
-	it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
-	if (it == NULL)
-		return NULL;
-	it->index = 0;
-	it->start = ((rangeobject *)seq)->start;
-	it->step = ((rangeobject *)seq)->step;
-	it->len = ((rangeobject *)seq)->len;
-	return (PyObject *)it;
+    if (!PyArg_ParseTuple(args, "lll;rangeiter() requires 3 int arguments",
+                          &start, &stop, &step))
+        return NULL;
+
+    return int_range_iter(start, stop, step);
+}
+
+static PyMethodDef longrangeiter_methods[] = {
+    {"__length_hint__", (PyCFunction)longrangeiter_len, METH_NOARGS,
+	length_hint_doc},
+    {NULL,		NULL}		/* sentinel */
+};
+
+static void
+longrangeiter_dealloc(longrangeiterobject *r)
+{
+    Py_XDECREF(r->index);
+    Py_DECREF(r->start);
+    Py_DECREF(r->step);
+    Py_DECREF(r->len);
 }
 
 static PyObject *
-range_reverse(PyObject *seq)
+longrangeiter_next(longrangeiterobject *r)
 {
-	rangeiterobject *it;
-	long start, step, len;
+    PyObject *one, *product, *new_index, *result;
+    if (PyObject_RichCompareBool(r->index, r->len, Py_LT) != 1)
+        return NULL;
+
+    one = PyLong_FromLong(1);
+    if (!one)
+        return NULL;
+
+    product = PyNumber_Multiply(r->index, r->step);
+    if (!product) {
+        Py_DECREF(one);
+        return NULL;
+    }
+
+    new_index = PyNumber_Add(r->index, one);
+    Py_DECREF(one);
+    if (!new_index) {
+        Py_DECREF(product);
+        return NULL;
+    }
+
+    result = PyNumber_Add(r->start, product);
+    Py_DECREF(product);
+    if (result) {
+        Py_DECREF(r->index);
+        r->index = new_index;
+    }
 
-	if (!PyRange_Check(seq)) {
-		PyErr_BadInternalCall();
-		return NULL;
-	}
-	it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
-	if (it == NULL)
-		return NULL;
-
-	start = ((rangeobject *)seq)->start;
-	step = ((rangeobject *)seq)->step;
-	len = ((rangeobject *)seq)->len;
-
-	it->index = 0;
-	it->start = start + (len-1) * step;
-	it->step = -step;
-	it->len = len;
+    return result;
+}
 
-	return (PyObject *)it;
+static PyTypeObject Pylongrangeiter_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,                                      /* ob_size */
+	"rangeiterator",                        /* tp_name */
+	sizeof(longrangeiterobject),            /* tp_basicsize */
+	0,                                      /* tp_itemsize */
+	/* methods */
+	(destructor)longrangeiter_dealloc,	/* tp_dealloc */
+	0,                                      /* tp_print */
+	0,                                      /* tp_getattr */
+	0,                                      /* tp_setattr */
+	0,                                      /* tp_compare */
+	0,                                      /* tp_repr */
+	0,                                      /* tp_as_number */
+	0,					/* tp_as_sequence */
+	0,                                      /* tp_as_mapping */
+	0,                                      /* tp_hash */
+	0,                                      /* tp_call */
+	0,                                      /* tp_str */
+	PyObject_GenericGetAttr,                /* tp_getattro */
+	0,                                      /* tp_setattro */
+	0,                                      /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,			/* tp_flags */
+	0,                                      /* tp_doc */
+	0,					/* tp_traverse */
+	0,                                      /* tp_clear */
+	0,                                      /* tp_richcompare */
+	0,                                      /* tp_weaklistoffset */
+	PyObject_SelfIter,			/* tp_iter */
+	(iternextfunc)longrangeiter_next,	/* tp_iternext */
+	longrangeiter_methods,			/* tp_methods */
+	0,
+};
+
+static PyObject *
+range_iter(PyObject *seq)
+{
+    rangeobject *r = (rangeobject *)seq;
+    longrangeiterobject *it;
+    PyObject *tmp, *len;
+
+    assert(PyRange_Check(seq));
+    if (_PyLong_FitsInLong(r->start) &&
+        _PyLong_FitsInLong(r->stop) &&
+        _PyLong_FitsInLong(r->step))
+        return int_range_iter(PyLong_AsLong(r->start),
+                      PyLong_AsLong(r->stop),
+                      PyLong_AsLong(r->step));
+
+    it = PyObject_New(longrangeiterobject, &Pylongrangeiter_Type);
+    if (it == NULL)
+        return NULL;
+    it->start = r->start;
+    /* Calculate length: (r->stop - r->start) / r->step */
+    tmp = PyNumber_Subtract(r->stop, r->start);
+    if (!tmp)
+        goto create_failure;
+    len = PyNumber_FloorDivide(tmp, r->step);
+    Py_DECREF(tmp);
+    if (!len)
+        goto create_failure;
+    it->len = len;
+    it->step = r->step;
+    it->index = PyLong_FromLong(0);
+    if (!it->index)
+        goto create_failure;
+
+    Py_INCREF(it->start);
+    Py_INCREF(it->step);
+    Py_INCREF(it->len);
+    return (PyObject *)it;
+
+create_failure:
+    PyObject_Del(it);
+    return NULL;
+}
+
+static PyObject *
+range_reverse(PyObject *seq)
+{
+    rangeobject *range = (rangeobject*) seq;
+    longrangeiterobject *it;
+    PyObject *one, *sum, *diff, *len = NULL, *product;
+
+    /* XXX(nnorwitz): do the calc for the new start/stop first,
+        then if they fit, call the proper iter()?
+    */
+    assert(PyRange_Check(seq));
+    if (_PyLong_FitsInLong(range->start) &&
+        _PyLong_FitsInLong(range->stop) &&
+        _PyLong_FitsInLong(range->step)) {
+        long start = PyLong_AsLong(range->start);
+        long step = PyLong_AsLong(range->step);
+        long stop = PyLong_AsLong(range->stop);
+        /* XXX(nnorwitz): need to check for overflow and simplify. */
+        long len = get_len_of_range(start, stop, step);
+        long new_start = start + (len - 1) * step;
+        long new_stop = start;
+        if (step > 0)
+            new_stop -= 1;
+        else
+            new_stop += 1;
+        return int_range_iter(new_start, new_stop, -step);
+    }
+
+    it = PyObject_New(longrangeiterobject, &Pylongrangeiter_Type);
+    if (it == NULL)
+        return NULL;
+
+    /* start + (len - 1) * step */
+    len = range_length_obj(range);
+    if (!len)
+        goto create_failure;
+
+    one = PyLong_FromLong(1);
+    if (!one)
+        goto create_failure;
+
+    diff = PyNumber_Subtract(len, one);
+    Py_DECREF(one);
+    if (!diff)
+        goto create_failure;
+
+    product = PyNumber_Multiply(len, range->step);
+    if (!product)
+        goto create_failure;
+
+    sum = PyNumber_Add(range->start, product);
+    Py_DECREF(product);
+    it->start = sum;
+    if (!it->start)
+        goto create_failure;
+    it->step = PyNumber_Negative(range->step);
+    if (!it->step) {
+        Py_DECREF(it->start);
+        PyObject_Del(it);
+        return NULL;
+    }
+
+    /* Steal reference to len. */
+    it->len = len;
+
+    it->index = PyLong_FromLong(0);
+    if (!it->index) {
+        Py_DECREF(it);
+        return NULL;
+    }
+
+    return (PyObject *)it;
+
+create_failure:
+    Py_XDECREF(len);
+    PyObject_Del(it);
+    return NULL;
 }

Modified: python/branches/p3yk/Parser/spark.py
==============================================================================
--- python/branches/p3yk/Parser/spark.py	(original)
+++ python/branches/p3yk/Parser/spark.py	Mon May  7 10:03:22 2007
@@ -324,7 +324,7 @@
             self.states = { 0: self.makeState0() }
             self.makeState(0, self._BOF)
 
-        for i in xrange(len(tokens)):
+        for i in range(len(tokens)):
             sets.append([])
 
             if sets[i] == []:

Modified: python/branches/p3yk/Python/bltinmodule.c
==============================================================================
--- python/branches/p3yk/Python/bltinmodule.c	(original)
+++ python/branches/p3yk/Python/bltinmodule.c	Mon May  7 10:03:22 2007
@@ -1618,302 +1618,6 @@
 end:  string appended after the last value, default a newline.");
 
 
-/* Return number of items in range (lo, hi, step), when arguments are
- * PyInt or PyLong objects.  step > 0 required.  Return a value < 0 if
- * & only if the true value is too large to fit in a signed long.
- * Arguments MUST return 1 with either PyInt_Check() or
- * PyLong_Check().  Return -1 when there is an error.
- */
-static long
-get_len_of_range_longs(PyObject *lo, PyObject *hi, PyObject *step)
-{
-	/* -------------------------------------------------------------
-	Algorithm is equal to that of get_len_of_range(), but it operates
-	on PyObjects (which are assumed to be PyLong or PyInt objects).
-	---------------------------------------------------------------*/
-	long n;
-	PyObject *diff = NULL;
-	PyObject *one = NULL;
-	PyObject *tmp1 = NULL, *tmp2 = NULL, *tmp3 = NULL;
-		/* holds sub-expression evaluations */
-
-	/* If (lo >= hi), return length of 0 (or error). */
-	n = PyObject_RichCompareBool(lo, hi, Py_LT);
-	if (n <= 0)
-		return n;
-
-	if ((one = PyLong_FromLong(1L)) == NULL)
-		goto Fail;
-
-	if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
-		goto Fail;
-
-	if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
-		goto Fail;
-
-	if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
-		goto Fail;
-
-	if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
-		goto Fail;
-
-	n = PyLong_AsLong(tmp3);
-	if (PyErr_Occurred()) {  /* Check for Overflow */
-		PyErr_Clear();
-		goto Fail;
-	}
-
-	Py_DECREF(tmp3);
-	Py_DECREF(tmp2);
-	Py_DECREF(diff);
-	Py_DECREF(tmp1);
-	Py_DECREF(one);
-	return n;
-
-  Fail:
-	Py_XDECREF(tmp3);
-	Py_XDECREF(tmp2);
-	Py_XDECREF(diff);
-	Py_XDECREF(tmp1);
-	Py_XDECREF(one);
-	return -1;
-}
-
-/* An extension of builtin_range() that handles the case when PyLong
- * arguments are given. */
-static PyObject *
-handle_range_longs(PyObject *self, PyObject *args)
-{
-	PyObject *ilow;
-	PyObject *ihigh = NULL;
-	PyObject *istep = NULL;
-
-	PyObject *curnum = NULL;
-	PyObject *v = NULL;
-	long bign;
-	int i, n;
-	int step_pos;
-
-	PyObject *zero = PyLong_FromLong(0);
-
-	if (zero == NULL)
-		return NULL;
-
-	if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
-		Py_DECREF(zero);
-		return NULL;
-	}
-
-	/* Figure out which way we were called, supply defaults, and be
-	 * sure to incref everything so that the decrefs at the end
-	 * are correct.
-	 */
-	assert(ilow != NULL);
-	if (ihigh == NULL) {
-		/* only 1 arg -- it's the upper limit */
-		ihigh = ilow;
-		ilow = NULL;
-	}
-	assert(ihigh != NULL);
-	Py_INCREF(ihigh);
-
-	/* ihigh correct now; do ilow */
-	if (ilow == NULL)
-		ilow = zero;
-	Py_INCREF(ilow);
-
-	/* ilow and ihigh correct now; do istep */
-	if (istep == NULL) {
-		istep = PyLong_FromLong(1L);
-		if (istep == NULL)
-			goto Fail;
-	}
-	else {
-		Py_INCREF(istep);
-	}
-
-	if (!PyInt_Check(ilow) && !PyLong_Check(ilow)) {
-		PyErr_Format(PyExc_TypeError,
-			     "range() integer start argument expected, got %s.",
-			     ilow->ob_type->tp_name);
-		goto Fail;
-	}
-
-	if (!PyInt_Check(ihigh) && !PyLong_Check(ihigh)) {
-		PyErr_Format(PyExc_TypeError,
-			     "range() integer end argument expected, got %s.",
-			     ihigh->ob_type->tp_name);
-		goto Fail;
-	}
-
-	if (!PyInt_Check(istep) && !PyLong_Check(istep)) {
-		PyErr_Format(PyExc_TypeError,
-			     "range() integer step argument expected, got %s.",
-			     istep->ob_type->tp_name);
-		goto Fail;
-	}
-
-	step_pos = PyObject_RichCompareBool(istep, zero, Py_GT);
-	if (step_pos < 0)
-		goto Fail;
-	if (step_pos)
-		bign = get_len_of_range_longs(ilow, ihigh, istep);
-	else {
-		int step_zero = PyObject_RichCompareBool(istep, zero, Py_EQ);
-		PyObject *neg_istep;
-		if (step_zero < 0)
-			goto Fail;
-		if (step_zero) {
-			PyErr_SetString(PyExc_ValueError,
-				"range() step argument must not be zero");
-			goto Fail;
-		}
-		neg_istep = PyNumber_Negative(istep);
-		if (neg_istep == NULL)
-			goto Fail;
-		bign = get_len_of_range_longs(ihigh, ilow, neg_istep);
-		Py_DECREF(neg_istep);
-	}
-
-	n = (int)bign;
-	if (bign < 0 || (long)n != bign) {
-		PyErr_SetString(PyExc_OverflowError,
-				"range() result has too many items");
-		goto Fail;
-	}
-
-	v = PyList_New(n);
-	if (v == NULL)
-		goto Fail;
-
-	curnum = ilow;
-	Py_INCREF(curnum);
-
-	for (i = 0; i < n; i++) {
-		PyObject *w = PyNumber_Long(curnum);
-		PyObject *tmp_num;
-		if (w == NULL)
-			goto Fail;
-
-		PyList_SET_ITEM(v, i, w);
-
-		tmp_num = PyNumber_Add(curnum, istep);
-		if (tmp_num == NULL)
-			goto Fail;
-
-		Py_DECREF(curnum);
-		curnum = tmp_num;
-	}
-	Py_DECREF(ilow);
-	Py_DECREF(ihigh);
-	Py_DECREF(istep);
-	Py_DECREF(zero);
-	Py_DECREF(curnum);
-	return v;
-
-  Fail:
-	Py_DECREF(ilow);
-	Py_DECREF(ihigh);
-	Py_XDECREF(istep);
-	Py_DECREF(zero);
-	Py_XDECREF(curnum);
-	Py_XDECREF(v);
-	return NULL;
-}
-
-/* Return number of items in range/xrange (lo, hi, step).  step > 0
- * required.  Return a value < 0 if & only if the true value is too
- * large to fit in a signed long.
- */
-static long
-get_len_of_range(long lo, long hi, long step)
-{
-	/* -------------------------------------------------------------
-	If lo >= hi, the range is empty.
-	Else if n values are in the range, the last one is
-	lo + (n-1)*step, which must be <= hi-1.  Rearranging,
-	n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
-	the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
-	the RHS is non-negative and so truncation is the same as the
-	floor.  Letting M be the largest positive long, the worst case
-	for the RHS numerator is hi=M, lo=-M-1, and then
-	hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
-	precision to compute the RHS exactly.
-	---------------------------------------------------------------*/
-	long n = 0;
-	if (lo < hi) {
-		unsigned long uhi = (unsigned long)hi;
-		unsigned long ulo = (unsigned long)lo;
-		unsigned long diff = uhi - ulo - 1;
-		n = (long)(diff / (unsigned long)step + 1);
-	}
-	return n;
-}
-
-static PyObject *
-builtin_range(PyObject *self, PyObject *args)
-{
-	long ilow = 0, ihigh = 0, istep = 1;
-	long bign;
-	int i, n;
-
-	PyObject *v;
-
-	if (PyTuple_Size(args) <= 1) {
-		if (!PyArg_ParseTuple(args,
-				"l;range() requires 1-3 int arguments",
-				&ihigh)) {
-			PyErr_Clear();
-			return handle_range_longs(self, args);
-		}
-	}
-	else {
-		if (!PyArg_ParseTuple(args,
-				"ll|l;range() requires 1-3 int arguments",
-				&ilow, &ihigh, &istep)) {
-			PyErr_Clear();
-			return handle_range_longs(self, args);
-		}
-	}
-	if (istep == 0) {
-		PyErr_SetString(PyExc_ValueError,
-				"range() step argument must not be zero");
-		return NULL;
-	}
-	if (istep > 0)
-		bign = get_len_of_range(ilow, ihigh, istep);
-	else
-		bign = get_len_of_range(ihigh, ilow, -istep);
-	n = (int)bign;
-	if (bign < 0 || (long)n != bign) {
-		PyErr_SetString(PyExc_OverflowError,
-				"range() result has too many items");
-		return NULL;
-	}
-	v = PyList_New(n);
-	if (v == NULL)
-		return NULL;
-	for (i = 0; i < n; i++) {
-		PyObject *w = PyInt_FromLong(ilow);
-		if (w == NULL) {
-			Py_DECREF(v);
-			return NULL;
-		}
-		PyList_SET_ITEM(v, i, w);
-		ilow += istep;
-	}
-	return v;
-}
-
-PyDoc_STRVAR(range_doc,
-"range([start,] stop[, step]) -> list of integers\n\
-\n\
-Return a list containing an arithmetic progression of integers.\n\
-range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\n\
-When step is given, it specifies the increment (or decrement).\n\
-For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!\n\
-These are exactly the valid indices for a list of 4 elements.");
-
 static PyObject *
 builtin_input(PyObject *self, PyObject *args)
 {
@@ -2301,7 +2005,6 @@
  	{"ord",		builtin_ord,        METH_O, ord_doc},
  	{"pow",		builtin_pow,        METH_VARARGS, pow_doc},
  	{"print",	(PyCFunction)builtin_print,      METH_VARARGS | METH_KEYWORDS, print_doc},
- 	{"range",	builtin_range,      METH_VARARGS, range_doc},
  	{"reload",	builtin_reload,     METH_O, reload_doc},
  	{"repr",	builtin_repr,       METH_O, repr_doc},
  	{"round",	(PyCFunction)builtin_round,      METH_VARARGS | METH_KEYWORDS, round_doc},
@@ -2371,6 +2074,7 @@
 	SETBUILTIN("int",		&PyLong_Type);
 	SETBUILTIN("list",		&PyList_Type);
 	SETBUILTIN("object",		&PyBaseObject_Type);
+	SETBUILTIN("range",		&PyRange_Type);
 	SETBUILTIN("reversed",		&PyReversed_Type);
 	SETBUILTIN("set",		&PySet_Type);
 	SETBUILTIN("slice",		&PySlice_Type);
@@ -2379,7 +2083,6 @@
 	SETBUILTIN("super",		&PySuper_Type);
 	SETBUILTIN("tuple",		&PyTuple_Type);
 	SETBUILTIN("type",		&PyType_Type);
-	SETBUILTIN("xrange",		&PyRange_Type);
 #ifdef Py_USING_UNICODE
 	SETBUILTIN("unicode",		&PyUnicode_Type);
 #endif

Modified: python/branches/p3yk/Tools/pybench/Arithmetic.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Arithmetic.py	(original)
+++ python/branches/p3yk/Tools/pybench/Arithmetic.py	Mon May  7 10:03:22 2007
@@ -8,7 +8,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             a = 2
             b = 3
@@ -152,7 +152,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class SimpleFloatArithmetic(Test):
@@ -163,7 +163,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             a = 2.1
             b = 3.3332
@@ -307,7 +307,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class SimpleIntFloatArithmetic(Test):
@@ -318,7 +318,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             a = 2
             b = 3
@@ -462,7 +462,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -474,7 +474,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             a = 2220001L
             b = 100001L
@@ -618,7 +618,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class SimpleComplexArithmetic(Test):
@@ -629,7 +629,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             a = 2 + 3j
             b = 2.5 + 4.5j
@@ -773,5 +773,5 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Calls.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Calls.py	(original)
+++ python/branches/p3yk/Tools/pybench/Calls.py	Mon May  7 10:03:22 2007
@@ -24,7 +24,7 @@
             return d,e,f
 
         # do calls
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             f()
             f1(i)
@@ -104,7 +104,7 @@
             return d,e,f
 
         # do calls
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 ###
@@ -124,7 +124,7 @@
         f3 = range
 
         # do calls
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             f0()
             f0()
@@ -225,7 +225,7 @@
         f3 = range
 
         # do calls
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 ###
@@ -261,7 +261,7 @@
 
         o = c()
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             o.f()
             o.f()
@@ -367,7 +367,7 @@
 
         o = c
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 ###
@@ -388,7 +388,7 @@
                 return f(x-1)
             return 1
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             f(10)
             f(10)
             f(10)
@@ -405,7 +405,7 @@
                 return f(x-1)
             return 1
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 

Modified: python/branches/p3yk/Tools/pybench/Constructs.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Constructs.py	(original)
+++ python/branches/p3yk/Tools/pybench/Constructs.py	Mon May  7 10:03:22 2007
@@ -9,7 +9,7 @@
     def test(self):
 
         a,b,c = 1,2,3
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             if a == 1:
                 if b == 2:
@@ -464,7 +464,7 @@
     def calibrate(self):
 
         a,b,c = 1,2,3
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class NestedForLoops(Test):
@@ -478,7 +478,7 @@
         l1 = range(1000)
         l2 = range(10)
         l3 = range(5)
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             for i in l1:
                 for j in l2:
                     for k in l3:
@@ -489,7 +489,7 @@
         l1 = range(1000)
         l2 = range(10)
         l3 = range(5)
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class ForLoops(Test):
@@ -501,7 +501,7 @@
     def test(self):
 
         l1 = range(100)
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             for i in l1:
                 pass
             for i in l1:
@@ -560,5 +560,5 @@
     def calibrate(self):
 
         l1 = range(1000)
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Dict.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Dict.py	(original)
+++ python/branches/p3yk/Tools/pybench/Dict.py	Mon May  7 10:03:22 2007
@@ -8,7 +8,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             d1 = {}
             d2 = {}
@@ -72,7 +72,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class DictWithStringKeys(Test):
@@ -85,7 +85,7 @@
 
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             d['abc'] = 1
             d['def'] = 2
@@ -161,7 +161,7 @@
 
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class DictWithFloatKeys(Test):
@@ -174,7 +174,7 @@
 
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             d[1.234] = 1
             d[2.345] = 2
@@ -250,7 +250,7 @@
 
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class DictWithIntegerKeys(Test):
@@ -263,7 +263,7 @@
 
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             d[1] = 1
             d[2] = 2
@@ -339,7 +339,7 @@
 
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class SimpleDictManipulation(Test):
@@ -353,7 +353,7 @@
         d = {}
         has_key = lambda key: key in d
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             d[0] = 3
             d[1] = 4
@@ -500,5 +500,5 @@
         d = {}
         has_key = lambda key: key in d
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Exceptions.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Exceptions.py	(original)
+++ python/branches/p3yk/Tools/pybench/Exceptions.py	Mon May  7 10:03:22 2007
@@ -10,7 +10,7 @@
 
         error = ValueError
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             try:
                 raise error
             except:
@@ -48,7 +48,7 @@
 
         error = ValueError
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -60,7 +60,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             try:
                 pass
             except:
@@ -687,7 +687,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 ### Test to make Fredrik happy...

Modified: python/branches/p3yk/Tools/pybench/Imports.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Imports.py	(original)
+++ python/branches/p3yk/Tools/pybench/Imports.py	Mon May  7 10:03:22 2007
@@ -12,7 +12,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             import os
             import os
             import os
@@ -45,7 +45,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -57,7 +57,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             import package
             import package
             import package
@@ -90,7 +90,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class SecondSubmoduleImport(Test):
@@ -101,7 +101,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             import package.submodule
             import package.submodule
             import package.submodule
@@ -134,5 +134,5 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Instances.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Instances.py	(original)
+++ python/branches/p3yk/Tools/pybench/Instances.py	Mon May  7 10:03:22 2007
@@ -26,7 +26,7 @@
                 self.e = b
                 self.f = c
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             o = c()
             o1 = c()
             o2 = c()
@@ -62,5 +62,5 @@
                 self.e = b
                 self.f = c
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Lists.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Lists.py	(original)
+++ python/branches/p3yk/Tools/pybench/Lists.py	Mon May  7 10:03:22 2007
@@ -11,7 +11,7 @@
         l = []
         append = l.append
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             append(2)
             append(3)
@@ -127,7 +127,7 @@
         l = []
         append = l.append
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class ListSlicing(Test):
@@ -141,7 +141,7 @@
         n = range(100)
         r = range(25)
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             l = n[:]
 
@@ -160,7 +160,7 @@
         n = range(100)
         r = range(25)
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             for j in r:
                 pass
 
@@ -172,7 +172,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             l = []
 
@@ -291,5 +291,5 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Lookups.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Lookups.py	(original)
+++ python/branches/p3yk/Tools/pybench/Lookups.py	Mon May  7 10:03:22 2007
@@ -11,7 +11,7 @@
         class c:
             pass
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             c.__a = 2
             c.__b = 3
@@ -178,7 +178,7 @@
         class c:
             pass
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class NormalClassAttribute(Test):
@@ -192,7 +192,7 @@
         class c:
             pass
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             c.a = 2
             c.b = 3
@@ -364,7 +364,7 @@
         class c:
             pass
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class SpecialInstanceAttribute(Test):
@@ -379,7 +379,7 @@
             pass
         o = c()
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             o.__a__ = 2
             o.__b__ = 3
@@ -552,7 +552,7 @@
             pass
         o = c()
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class NormalInstanceAttribute(Test):
@@ -567,7 +567,7 @@
             pass
         o = c()
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             o.a = 2
             o.b = 3
@@ -740,7 +740,7 @@
             pass
         o = c()
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class BuiltinMethodLookup(Test):
@@ -754,7 +754,7 @@
         l = []
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             l.append
             l.append
@@ -941,5 +941,5 @@
         l = []
         d = {}
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/NewInstances.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/NewInstances.py	(original)
+++ python/branches/p3yk/Tools/pybench/NewInstances.py	Mon May  7 10:03:22 2007
@@ -35,7 +35,7 @@
                 self.e = b
                 self.f = c
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             o = c()
             o1 = c()
             o2 = c()
@@ -71,5 +71,5 @@
                 self.e = b
                 self.f = c
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Numbers.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Numbers.py	(original)
+++ python/branches/p3yk/Tools/pybench/Numbers.py	Mon May  7 10:03:22 2007
@@ -8,7 +8,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             2 < 3
             2 > 3
@@ -192,7 +192,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -204,7 +204,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             2.1 < 3.31
             2.1 > 3.31
@@ -388,7 +388,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -400,7 +400,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             2.1 < 4
             2.1 > 4
@@ -584,7 +584,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -596,7 +596,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             1234567890L < 3456789012345L
             1234567890L > 3456789012345L
@@ -780,5 +780,5 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Strings.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Strings.py	(original)
+++ python/branches/p3yk/Tools/pybench/Strings.py	Mon May  7 10:03:22 2007
@@ -14,7 +14,7 @@
         s = join(map(str,range(100)))
         t = join(map(str,range(1,101)))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             t + s
             t + s
             t + s
@@ -80,7 +80,7 @@
         s = join(map(str,range(100)))
         t = join(map(str,range(1,101)))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -96,7 +96,7 @@
         s = join(map(str,range(10)))
         t = join(map(str,range(10))) + "abc"
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             t < s
             t > s
             t == s
@@ -162,7 +162,7 @@
         s = join(map(str,range(10)))
         t = join(map(str,range(10))) + "abc"
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -178,7 +178,7 @@
         s = sys.intern(join(map(str,range(10))))
         t = s
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             t == s
             t == s
             t >= s
@@ -244,7 +244,7 @@
         s = sys.intern(join(map(str,range(10))))
         t = s
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -256,7 +256,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             s = 'om'
             s = s + 'xbx'
             s = s + 'xcx'
@@ -319,7 +319,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -333,7 +333,7 @@
 
         s = join(map(str,range(100)))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             s[50:]
             s[:25]
@@ -379,7 +379,7 @@
 
         s = join(map(str,range(100)))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 ### String methods
@@ -399,7 +399,7 @@
             u = join(map(chr,range(100)),'')
             v = join(map(chr,range(256)),'')
 
-            for i in xrange(self.rounds):
+            for i in range(self.rounds):
 
                 s.lower()
                 s.lower()
@@ -456,7 +456,7 @@
             u = join(map(chr,range(100)),'')
             v = join(map(chr,range(256)),'')
 
-            for i in xrange(self.rounds):
+            for i in range(self.rounds):
                 pass
 
     class StringPredicates(Test):
@@ -470,7 +470,7 @@
             data = ('abc', '123', '   ', '\xe4\xf6\xfc', '\xdf'*10)
             len_data = len(data)
 
-            for i in xrange(self.rounds):
+            for i in range(self.rounds):
                 s = data[i % len_data]
 
                 s.isalnum()
@@ -559,5 +559,5 @@
             data = ('abc', '123', '   ', '\xe4\xf6\xfc', '\xdf'*10)
             len_data = len(data)
 
-            for i in xrange(self.rounds):
+            for i in range(self.rounds):
                 s = data[i % len_data]

Modified: python/branches/p3yk/Tools/pybench/Tuples.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Tuples.py	(original)
+++ python/branches/p3yk/Tools/pybench/Tuples.py	Mon May  7 10:03:22 2007
@@ -11,7 +11,7 @@
         r = range(25)
         t = tuple(range(100))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             for j in r:
 
@@ -260,7 +260,7 @@
         r = range(25)
         t = tuple(range(100))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             for j in r:
                 pass
 
@@ -272,7 +272,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             t = (1,2,3,4,5,6)
 
@@ -356,5 +356,5 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass

Modified: python/branches/p3yk/Tools/pybench/Unicode.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/Unicode.py	(original)
+++ python/branches/p3yk/Tools/pybench/Unicode.py	Mon May  7 10:03:22 2007
@@ -18,7 +18,7 @@
         s = unicode(join(map(str,range(100))))
         t = unicode(join(map(str,range(1,101))))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             t + s
             t + s
             t + s
@@ -84,7 +84,7 @@
         s = unicode(join(map(str,range(100))))
         t = unicode(join(map(str,range(1,101))))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -100,7 +100,7 @@
         s = unicode(join(map(str,range(10))))
         t = unicode(join(map(str,range(10))) + "abc")
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             t < s
             t > s
             t == s
@@ -166,7 +166,7 @@
         s = unicode(join(map(str,range(10))))
         t = unicode(join(map(str,range(10))) + "abc")
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -178,7 +178,7 @@
 
     def test(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             s = u'om'
             s = s + u'xbx'
             s = s + u'xcx'
@@ -241,7 +241,7 @@
 
     def calibrate(self):
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 
@@ -255,7 +255,7 @@
 
         s = unicode(join(map(str,range(100))))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             s[50:]
             s[:25]
@@ -301,7 +301,7 @@
 
         s = unicode(join(map(str,range(100))))
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 ### String methods
@@ -319,7 +319,7 @@
         u = join(map(unichr,range(500)),'')
         v = join(map(unichr,range(1000)),'')
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
 
             s.lower()
             s.lower()
@@ -376,7 +376,7 @@
         u = join(map(unichr,range(500)),'')
         v = join(map(unichr,range(1000)),'')
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             pass
 
 class UnicodePredicates(Test):
@@ -390,7 +390,7 @@
         data = (u'abc', u'123', u'   ', u'\u1234\u2345\u3456', u'\uFFFF'*10)
         len_data = len(data)
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             s = data[i % len_data]
 
             s.isalnum()
@@ -448,7 +448,7 @@
         data = (u'abc', u'123', u'   ', u'\u1234\u2345\u3456', u'\uFFFF'*10)
         len_data = len(data)
 
-        for i in xrange(self.rounds):
+        for i in range(self.rounds):
             s = data[i % len_data]
 
 try:
@@ -475,7 +475,7 @@
             mirrored = unicodedata.mirrored
             combining = unicodedata.combining
 
-            for i in xrange(self.rounds):
+            for i in range(self.rounds):
 
                 c = data[i % len_data]
 
@@ -537,6 +537,6 @@
             mirrored = unicodedata.mirrored
             combining = unicodedata.combining
 
-            for i in xrange(self.rounds):
+            for i in range(self.rounds):
 
                 c = data[i % len_data]

Modified: python/branches/p3yk/Tools/pybench/systimes.py
==============================================================================
--- python/branches/p3yk/Tools/pybench/systimes.py	(original)
+++ python/branches/p3yk/Tools/pybench/systimes.py	Mon May  7 10:03:22 2007
@@ -181,7 +181,7 @@
 
 def some_workload():
     x = 0L
-    for i in xrange(10000000L):
+    for i in range(10000000L):
         x = x + 1L
 
 def test_workload():

Modified: python/branches/p3yk/Tools/scripts/reindent.py
==============================================================================
--- python/branches/p3yk/Tools/scripts/reindent.py	(original)
+++ python/branches/p3yk/Tools/scripts/reindent.py	Mon May  7 10:03:22 2007
@@ -193,7 +193,7 @@
                     want = have2want.get(have, -1)
                     if want < 0:
                         # Then it probably belongs to the next real stmt.
-                        for j in xrange(i+1, len(stats)-1):
+                        for j in range(i+1, len(stats)-1):
                             jline, jlevel = stats[j]
                             if jlevel >= 0:
                                 if have == getlspace(lines[jline]):
@@ -203,7 +203,7 @@
                                            # comment like this one,
                         # in which case we should shift it like its base
                         # line got shifted.
-                        for j in xrange(i-1, -1, -1):
+                        for j in range(i-1, -1, -1):
                             jline, jlevel = stats[j]
                             if jlevel >= 0:
                                 want = have + getlspace(after[jline-1]) - \

Modified: python/branches/p3yk/Tools/unicode/makeunicodedata.py
==============================================================================
--- python/branches/p3yk/Tools/unicode/makeunicodedata.py	(original)
+++ python/branches/p3yk/Tools/unicode/makeunicodedata.py	Mon May  7 10:03:22 2007
@@ -935,7 +935,7 @@
     if __debug__:
         # exhaustively verify that the decomposition is correct
         mask = ~((~0) << shift) # i.e., low-bit mask of shift bits
-        for i in xrange(len(t)):
+        for i in range(len(t)):
             assert t[i] == t2[(t1[i >> shift] << shift) + (i & mask)]
     return best
 

Modified: python/branches/p3yk/Tools/unicode/mkstringprep.py
==============================================================================
--- python/branches/p3yk/Tools/unicode/mkstringprep.py	(original)
+++ python/branches/p3yk/Tools/unicode/mkstringprep.py	Mon May  7 10:03:22 2007
@@ -37,7 +37,7 @@
         tuple.append((prev,prev+span+1))
     else:
         single.append(prev)
-    tuple = " + ".join(["range(%d,%d)" % t for t in tuple])
+    tuple = " + ".join(["list(range(%d,%d))" % t for t in tuple])
     if not single:
         return "set(%s)" % tuple
     if not tuple:


More information about the Python-3000-checkins mailing list