[pypy-commit] pypy jit-usable_retrace_3: merge release-2.0-beta-1
hakanardo
noreply at buildbot.pypy.org
Fri Dec 28 12:46:39 CET 2012
Author: Hakan Ardo <hakan at debian.org>
Branch: jit-usable_retrace_3
Changeset: r59603:d41644a1e24b
Date: 2012-12-26 14:15 +0100
http://bitbucket.org/pypy/pypy/changeset/d41644a1e24b/
Log: merge release-2.0-beta-1
diff too long, truncating to 2000 out of 21388 lines
diff --git a/.hgtags b/.hgtags
--- a/.hgtags
+++ b/.hgtags
@@ -2,3 +2,4 @@
b48df0bf4e75b81d98f19ce89d4a7dc3e1dab5e5 benchmarked
d8ac7d23d3ec5f9a0fa1264972f74a010dbfd07f release-1.6
ff4af8f318821f7f5ca998613a60fca09aa137da release-1.7
+7e4f0faa3d515b313f035a9eead56655bdb5e768 release-2.0-beta1
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,9 +1,10 @@
-License for files in the pypy/ directory
-==================================================
+License
+=======
Except when otherwise stated (look for LICENSE files in directories or
information at the beginning of each file) all software and
-documentation in the 'pypy' directories is licensed as follows:
+documentation in the 'pypy', 'ctype_configure', 'dotviewer', 'demo',
+and 'lib_pypy' directories is licensed as follows:
The MIT License
diff --git a/lib-python/2.7/distutils/command/build_ext.py b/lib-python/2.7/distutils/command/build_ext.py
--- a/lib-python/2.7/distutils/command/build_ext.py
+++ b/lib-python/2.7/distutils/command/build_ext.py
@@ -699,6 +699,9 @@
shared extension. On most platforms, this is just 'ext.libraries';
on Windows and OS/2, we add the Python library (eg. python20.dll).
"""
+ # For PyPy, we must not add any such Python library, on any platform
+ if "__pypy__" in sys.builtin_module_names:
+ return ext.libraries
# The python library is always needed on Windows.
if sys.platform == "win32":
template = "python%d%d"
diff --git a/lib-python/conftest.py b/lib-python/conftest.py
--- a/lib-python/conftest.py
+++ b/lib-python/conftest.py
@@ -14,7 +14,7 @@
from pypy.interpreter.main import run_string, run_file
# the following adds command line options as a side effect!
-from pypy.conftest import gettestobjspace, option as pypy_option
+from pypy.conftest import option as pypy_option
from pypy.tool.pytest import appsupport
from pypy.tool.pytest.confpath import pypydir, testdir, testresultdir
diff --git a/lib_pypy/_sqlite3.py b/lib_pypy/_sqlite3.py
--- a/lib_pypy/_sqlite3.py
+++ b/lib_pypy/_sqlite3.py
@@ -784,6 +784,9 @@
self.statement.reset()
raise self.connection._get_exception(ret)
+ if self.statement.kind == DML:
+ self.statement.reset()
+
if self.statement.kind == DQL and ret == SQLITE_ROW:
self.statement._build_row_cast_map()
self.statement._readahead(self)
@@ -791,9 +794,6 @@
self.statement.item = None
self.statement.exhausted = True
- if self.statement.kind == DML:
- self.statement.reset()
-
self.rowcount = -1
if self.statement.kind == DML:
self.rowcount = sqlite.sqlite3_changes(self.connection.db)
diff --git a/lib_pypy/itertools.py b/lib_pypy/itertools.py
deleted file mode 100644
--- a/lib_pypy/itertools.py
+++ /dev/null
@@ -1,670 +0,0 @@
-# Note that PyPy contains also a built-in module 'itertools' which will
-# hide this one if compiled in.
-
-"""Functional tools for creating and using iterators.
-
-Infinite iterators:
-count([n]) --> n, n+1, n+2, ...
-cycle(p) --> p0, p1, ... plast, p0, p1, ...
-repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times
-
-Iterators terminating on the shortest input sequence:
-izip(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ...
-ifilter(pred, seq) --> elements of seq where pred(elem) is True
-ifilterfalse(pred, seq) --> elements of seq where pred(elem) is False
-islice(seq, [start,] stop [, step]) --> elements from
- seq[start:stop:step]
-imap(fun, p, q, ...) --> fun(p0, q0), fun(p1, q1), ...
-starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...
-tee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n
-chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ...
-takewhile(pred, seq) --> seq[0], seq[1], until pred fails
-dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails
-groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)
-"""
-
-__all__ = ['chain', 'count', 'cycle', 'dropwhile', 'groupby', 'ifilter',
- 'ifilterfalse', 'imap', 'islice', 'izip', 'repeat', 'starmap',
- 'takewhile', 'tee', 'compress', 'product']
-
-try: from __pypy__ import builtinify
-except ImportError: builtinify = lambda f: f
-
-
-class chain(object):
- """Make an iterator that returns elements from the first iterable
- until it is exhausted, then proceeds to the next iterable, until
- all of the iterables are exhausted. Used for treating consecutive
- sequences as a single sequence.
-
- Equivalent to :
-
- def chain(*iterables):
- for it in iterables:
- for element in it:
- yield element
- """
- def __init__(self, *iterables):
- self._iterables_iter = iter(map(iter, iterables))
- # little trick for the first chain.next() call
- self._cur_iterable_iter = iter([])
-
- def __iter__(self):
- return self
-
- def next(self):
- while True:
- try:
- return self._cur_iterable_iter.next()
- except StopIteration:
- self._cur_iterable_iter = self._iterables_iter.next()
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self._cur_iterable_iter))
-
-
-class compress(object):
- def __init__(self, data, selectors):
- self.data = iter(data)
- self.selectors = iter(selectors)
-
- def __iter__(self):
- return self
-
- def next(self):
- while True:
- next_item = self.data.next()
- next_selector = self.selectors.next()
- if bool(next_selector):
- return next_item
-
-
-class count(object):
- """Make an iterator that returns consecutive integers starting
- with n. If not specified n defaults to zero. Does not currently
- support python long integers. Often used as an argument to imap()
- to generate consecutive data points. Also, used with izip() to
- add sequence numbers.
-
- Equivalent to :
-
- def count(n=0):
- if not isinstance(n, int):
- raise TypeError("%s is not a regular integer" % n)
- while True:
- yield n
- n += 1
- """
- def __init__(self, n=0):
- if not isinstance(n, int):
- raise TypeError('%s is not a regular integer' % n)
- self.times = n-1
-
- def __iter__(self):
- return self
-
- def next(self):
- self.times += 1
- return self.times
-
- def __repr__(self):
- return 'count(%d)' % (self.times + 1)
-
-
-
-class cycle(object):
- """Make an iterator returning elements from the iterable and
- saving a copy of each. When the iterable is exhausted, return
- elements from the saved copy. Repeats indefinitely.
-
- Equivalent to :
-
- def cycle(iterable):
- saved = []
- for element in iterable:
- yield element
- saved.append(element)
- while saved:
- for element in saved:
- yield element
- """
- def __init__(self, iterable):
- self._cur_iter = iter(iterable)
- self._saved = []
- self._must_save = True
-
- def __iter__(self):
- return self
-
- def next(self):
- # XXX Could probably be improved
- try:
- next_elt = self._cur_iter.next()
- if self._must_save:
- self._saved.append(next_elt)
- except StopIteration:
- self._cur_iter = iter(self._saved)
- next_elt = self._cur_iter.next()
- self._must_save = False
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self._cur_iter))
- return next_elt
-
-
-class dropwhile(object):
- """Make an iterator that drops elements from the iterable as long
- as the predicate is true; afterwards, returns every
- element. Note, the iterator does not produce any output until the
- predicate is true, so it may have a lengthy start-up time.
-
- Equivalent to :
-
- def dropwhile(predicate, iterable):
- iterable = iter(iterable)
- for x in iterable:
- if not predicate(x):
- yield x
- break
- for x in iterable:
- yield x
- """
- def __init__(self, predicate, iterable):
- self._predicate = predicate
- self._iter = iter(iterable)
- self._dropped = False
-
- def __iter__(self):
- return self
-
- def next(self):
- try:
- value = self._iter.next()
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self._iter))
- if self._dropped:
- return value
- while self._predicate(value):
- value = self._iter.next()
- self._dropped = True
- return value
-
-class groupby(object):
- """Make an iterator that returns consecutive keys and groups from the
- iterable. The key is a function computing a key value for each
- element. If not specified or is None, key defaults to an identity
- function and returns the element unchanged. Generally, the
- iterable needs to already be sorted on the same key function.
-
- The returned group is itself an iterator that shares the
- underlying iterable with groupby(). Because the source is shared,
- when the groupby object is advanced, the previous group is no
- longer visible. So, if that data is needed later, it should be
- stored as a list:
-
- groups = []
- uniquekeys = []
- for k, g in groupby(data, keyfunc):
- groups.append(list(g)) # Store group iterator as a list
- uniquekeys.append(k)
- """
- def __init__(self, iterable, key=None):
- if key is None:
- key = lambda x: x
- self.keyfunc = key
- self.it = iter(iterable)
- self.tgtkey = self.currkey = self.currvalue = xrange(0)
-
- def __iter__(self):
- return self
-
- def next(self):
- while self.currkey == self.tgtkey:
- try:
- self.currvalue = self.it.next() # Exit on StopIteration
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self.it))
- self.currkey = self.keyfunc(self.currvalue)
- self.tgtkey = self.currkey
- return (self.currkey, self._grouper(self.tgtkey))
-
- def _grouper(self, tgtkey):
- while self.currkey == tgtkey:
- yield self.currvalue
- self.currvalue = self.it.next() # Exit on StopIteration
- self.currkey = self.keyfunc(self.currvalue)
-
-
-
-class _ifilter_base(object):
- """base class for ifilter and ifilterflase"""
- def __init__(self, predicate, iterable):
- # Make sure iterable *IS* iterable
- self._iter = iter(iterable)
- if predicate is None:
- self._predicate = bool
- else:
- self._predicate = predicate
-
- def __iter__(self):
- return self
-
-class ifilter(_ifilter_base):
- """Make an iterator that filters elements from iterable returning
- only those for which the predicate is True. If predicate is
- None, return the items that are true.
-
- Equivalent to :
-
- def ifilter:
- if predicate is None:
- predicate = bool
- for x in iterable:
- if predicate(x):
- yield x
- """
- def next(self):
- try:
- next_elt = self._iter.next()
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self._iter))
- while True:
- if self._predicate(next_elt):
- return next_elt
- next_elt = self._iter.next()
-
-class ifilterfalse(_ifilter_base):
- """Make an iterator that filters elements from iterable returning
- only those for which the predicate is False. If predicate is
- None, return the items that are false.
-
- Equivalent to :
-
- def ifilterfalse(predicate, iterable):
- if predicate is None:
- predicate = bool
- for x in iterable:
- if not predicate(x):
- yield x
- """
- def next(self):
- try:
- next_elt = self._iter.next()
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self._iter))
- while True:
- if not self._predicate(next_elt):
- return next_elt
- next_elt = self._iter.next()
-
-
-
-
-class imap(object):
- """Make an iterator that computes the function using arguments
- from each of the iterables. If function is set to None, then
- imap() returns the arguments as a tuple. Like map() but stops
- when the shortest iterable is exhausted instead of filling in
- None for shorter iterables. The reason for the difference is that
- infinite iterator arguments are typically an error for map()
- (because the output is fully evaluated) but represent a common
- and useful way of supplying arguments to imap().
-
- Equivalent to :
-
- def imap(function, *iterables):
- iterables = map(iter, iterables)
- while True:
- args = [i.next() for i in iterables]
- if function is None:
- yield tuple(args)
- else:
- yield function(*args)
-
- """
- def __init__(self, function, iterable, *other_iterables):
- self._func = function
- self._iters = map(iter, (iterable, ) + other_iterables)
-
- def __iter__(self):
- return self
-
- def next(self):
- try:
- args = [it.next() for it in self._iters]
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (it))
- if self._func is None:
- return tuple(args)
- else:
- return self._func(*args)
-
-
-
-class islice(object):
- """Make an iterator that returns selected elements from the
- iterable. If start is non-zero, then elements from the iterable
- are skipped until start is reached. Afterward, elements are
- returned consecutively unless step is set higher than one which
- results in items being skipped. If stop is None, then iteration
- continues until the iterator is exhausted, if at all; otherwise,
- it stops at the specified position. Unlike regular slicing,
- islice() does not support negative values for start, stop, or
- step. Can be used to extract related fields from data where the
- internal structure has been flattened (for example, a multi-line
- report may list a name field on every third line).
- """
- def __init__(self, iterable, *args):
- s = slice(*args)
- self.start, self.stop, self.step = s.start or 0, s.stop, s.step
- if not isinstance(self.start, (int, long)):
- raise ValueError("Start argument must be an integer")
- if self.stop is not None and not isinstance(self.stop, (int,long)):
- raise ValueError("Stop argument must be an integer or None")
- if self.step is None:
- self.step = 1
- if self.start<0 or (self.stop is not None and self.stop<0
- ) or self.step<=0:
- raise ValueError, "indices for islice() must be positive"
- self.it = iter(iterable)
- self.donext = None
- self.cnt = 0
-
- def __iter__(self):
- return self
-
- def next(self):
- if self.donext is None:
- try:
- self.donext = self.it.next
- except AttributeError:
- raise TypeError
- nextindex = self.start
- if self.stop is not None and nextindex >= self.stop:
- raise StopIteration
- while self.cnt <= nextindex:
- nextitem = self.donext()
- self.cnt += 1
- self.start += self.step
- return nextitem
-
-class izip(object):
- """Make an iterator that aggregates elements from each of the
- iterables. Like zip() except that it returns an iterator instead
- of a list. Used for lock-step iteration over several iterables at
- a time.
-
- Equivalent to :
-
- def izip(*iterables):
- iterables = map(iter, iterables)
- while iterables:
- result = [i.next() for i in iterables]
- yield tuple(result)
- """
- def __init__(self, *iterables):
- self._iterators = map(iter, iterables)
- self._result = [None] * len(self._iterators)
-
- def __iter__(self):
- return self
-
- def next(self):
- if not self._iterators:
- raise StopIteration()
- try:
- return tuple([i.next() for i in self._iterators])
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % (i))
-
-
-class product(object):
-
- def __init__(self, *args, **kw):
- if len(kw) > 1:
- raise TypeError("product() takes at most 1 argument (%d given)" %
- len(kw))
- self.repeat = kw.get('repeat', 1)
- self.gears = [x for x in args] * self.repeat
- self.num_gears = len(self.gears)
- # initialization of indicies to loop over
- self.indicies = [(0, len(self.gears[x]))
- for x in range(0, self.num_gears)]
- self.cont = True
-
- def roll_gears(self):
- # Starting from the end of the gear indicies work to the front
- # incrementing the gear until the limit is reached. When the limit
- # is reached carry operation to the next gear
- should_carry = True
- for n in range(0, self.num_gears):
- nth_gear = self.num_gears - n - 1
- if should_carry:
- count, lim = self.indicies[nth_gear]
- count += 1
- if count == lim and nth_gear == 0:
- self.cont = False
- if count == lim:
- should_carry = True
- count = 0
- else:
- should_carry = False
- self.indicies[nth_gear] = (count, lim)
- else:
- break
-
- def __iter__(self):
- return self
-
- def next(self):
- if not self.cont:
- raise StopIteration
- l = []
- for x in range(0, self.num_gears):
- index, limit = self.indicies[x]
- l.append(self.gears[x][index])
- self.roll_gears()
- return tuple(l)
-
-
-class repeat(object):
- """Make an iterator that returns object over and over again.
- Runs indefinitely unless the times argument is specified. Used
- as argument to imap() for invariant parameters to the called
- function. Also used with izip() to create an invariant part of a
- tuple record.
-
- Equivalent to :
-
- def repeat(object, times=None):
- if times is None:
- while True:
- yield object
- else:
- for i in xrange(times):
- yield object
- """
- def __init__(self, obj, times=None):
- self._obj = obj
- if times is not None:
- xrange(times) # Raise a TypeError
- if times < 0:
- times = 0
- self._times = times
-
- def __iter__(self):
- return self
-
- def next(self):
- # next() *need* to decrement self._times when consumed
- if self._times is not None:
- if self._times <= 0:
- raise StopIteration()
- self._times -= 1
- return self._obj
-
- def __repr__(self):
- if self._times is not None:
- return 'repeat(%r, %r)' % (self._obj, self._times)
- else:
- return 'repeat(%r)' % (self._obj,)
-
- def __len__(self):
- if self._times == -1 or self._times is None:
- raise TypeError("len() of uniszed object")
- return self._times
-
-
-class starmap(object):
- """Make an iterator that computes the function using arguments
- tuples obtained from the iterable. Used instead of imap() when
- argument parameters are already grouped in tuples from a single
- iterable (the data has been ``pre-zipped''). The difference
- between imap() and starmap() parallels the distinction between
- function(a,b) and function(*c).
-
- Equivalent to :
-
- def starmap(function, iterable):
- iterable = iter(iterable)
- while True:
- yield function(*iterable.next())
- """
- def __init__(self, function, iterable):
- self._func = function
- self._iter = iter(iterable)
-
- def __iter__(self):
- return self
-
- def next(self):
- # CPython raises a TypeError when the iterator doesn't return a tuple
- try:
- t = self._iter.next()
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % self._iter)
- if not isinstance(t, tuple):
- raise TypeError("iterator must return a tuple")
- return self._func(*t)
-
-
-
-class takewhile(object):
- """Make an iterator that returns elements from the iterable as
- long as the predicate is true.
-
- Equivalent to :
-
- def takewhile(predicate, iterable):
- for x in iterable:
- if predicate(x):
- yield x
- else:
- break
- """
- def __init__(self, predicate, iterable):
- self._predicate = predicate
- self._iter = iter(iterable)
-
- def __iter__(self):
- return self
-
- def next(self):
- try:
- value = self._iter.next()
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % \
- (self._iter))
- if not self._predicate(value):
- raise StopIteration()
- return value
-
-
-class TeeData(object):
- """Holds cached values for TeeObjects"""
- def __init__(self, iterator):
- self.data = []
- self._iter = iterator
-
- def __getitem__(self, i):
- # iterates until 'i' if not done yet
- while i>= len(self.data):
- try:
- self.data.append( self._iter.next() )
- except AttributeError:
- # CPython raises a TypeError when next() is not defined
- raise TypeError('%s has no next() method' % self._iter)
- return self.data[i]
-
-
-class TeeObject(object):
- """Iterables / Iterators as returned by the tee() function"""
- def __init__(self, iterable=None, tee_data=None):
- if tee_data:
- self.tee_data = tee_data
- self.pos = 0
- # <=> Copy constructor
- elif isinstance(iterable, TeeObject):
- self.tee_data = iterable.tee_data
- self.pos = iterable.pos
- else:
- self.tee_data = TeeData(iter(iterable))
- self.pos = 0
-
- def next(self):
- data = self.tee_data[self.pos]
- self.pos += 1
- return data
-
- def __iter__(self):
- return self
-
-
- at builtinify
-def tee(iterable, n=2):
- """Return n independent iterators from a single iterable.
- Note : once tee() has made a split, the original iterable
- should not be used anywhere else; otherwise, the iterable could get
- advanced without the tee objects being informed.
-
- Note : this member of the toolkit may require significant auxiliary
- storage (depending on how much temporary data needs to be stored).
- In general, if one iterator is going to use most or all of the
- data before the other iterator, it is faster to use list() instead
- of tee()
-
- Equivalent to :
-
- def tee(iterable, n=2):
- def gen(next, data={}, cnt=[0]):
- for i in count():
- if i == cnt[0]:
- item = data[i] = next()
- cnt[0] += 1
- else:
- item = data.pop(i)
- yield item
- it = iter(iterable)
- return tuple([gen(it.next) for i in range(n)])
- """
- if isinstance(iterable, TeeObject):
- # a,b = tee(range(10)) ; c,d = tee(a) ; self.assert_(a is c)
- return tuple([iterable] +
- [TeeObject(tee_data=iterable.tee_data) for i in xrange(n-1)])
- tee_data = TeeData(iter(iterable))
- return tuple([TeeObject(tee_data=tee_data) for i in xrange(n)])
diff --git a/lib_pypy/numpypy/core/numeric.py b/lib_pypy/numpypy/core/numeric.py
--- a/lib_pypy/numpypy/core/numeric.py
+++ b/lib_pypy/numpypy/core/numeric.py
@@ -1,5 +1,5 @@
-from _numpypy import array, ndarray, int_, float_, bool_ #, complex_# , longlong
+from _numpypy import array, ndarray, int_, float_, bool_, flexible #, complex_# , longlong
from _numpypy import concatenate
from .fromnumeric import any
import math
@@ -200,7 +200,7 @@
typename = "'%s'" % typename
lf = ''
- if 0: # or issubclass(arr.dtype.type, flexible):
+ if issubclass(arr.dtype.type, flexible):
if arr.dtype.names:
typename = "%s" % str(arr.dtype)
else:
diff --git a/lib_pypy/pypy_test/test_itertools.py b/lib_pypy/pypy_test/test_itertools.py
deleted file mode 100644
--- a/lib_pypy/pypy_test/test_itertools.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from py.test import raises
-from lib_pypy import itertools
-
-class TestItertools(object):
-
- def test_compress(self):
- it = itertools.compress(['a', 'b', 'c'], [0, 1, 0])
-
- assert list(it) == ['b']
-
- def test_compress_diff_len(self):
- it = itertools.compress(['a'], [])
- raises(StopIteration, it.next)
-
- def test_product(self):
- l = [1, 2]
- m = ['a', 'b']
-
- prodlist = itertools.product(l, m)
- assert list(prodlist) == [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
-
- def test_product_repeat(self):
- l = [1, 2]
- m = ['a', 'b']
-
- prodlist = itertools.product(l, m, repeat=2)
- ans = [(1, 'a', 1, 'a'), (1, 'a', 1, 'b'), (1, 'a', 2, 'a'),
- (1, 'a', 2, 'b'), (1, 'b', 1, 'a'), (1, 'b', 1, 'b'),
- (1, 'b', 2, 'a'), (1, 'b', 2, 'b'), (2, 'a', 1, 'a'),
- (2, 'a', 1, 'b'), (2, 'a', 2, 'a'), (2, 'a', 2, 'b'),
- (2, 'b', 1, 'a'), (2, 'b', 1, 'b'), (2, 'b', 2, 'a'),
- (2, 'b', 2, 'b')]
- assert list(prodlist) == ans
-
- def test_product_diff_sizes(self):
- l = [1, 2]
- m = ['a']
-
- prodlist = itertools.product(l, m)
- assert list(prodlist) == [(1, 'a'), (2, 'a')]
-
- l = [1]
- m = ['a', 'b']
- prodlist = itertools.product(l, m)
- assert list(prodlist) == [(1, 'a'), (1, 'b')]
-
- def test_product_toomany_args(self):
- l = [1, 2]
- m = ['a']
- raises(TypeError, itertools.product, l, m, repeat=1, foo=2)
diff --git a/lib_pypy/pyrepl/readline.py b/lib_pypy/pyrepl/readline.py
--- a/lib_pypy/pyrepl/readline.py
+++ b/lib_pypy/pyrepl/readline.py
@@ -233,7 +233,7 @@
try:
return unicode(line, ENCODING)
except UnicodeDecodeError: # bah, silently fall back...
- return unicode(line, 'utf-8')
+ return unicode(line, 'utf-8', 'replace')
def get_history_length(self):
return self.saved_history_length
diff --git a/lib_pypy/pyrepl/unix_console.py b/lib_pypy/pyrepl/unix_console.py
--- a/lib_pypy/pyrepl/unix_console.py
+++ b/lib_pypy/pyrepl/unix_console.py
@@ -496,7 +496,7 @@
if iscode:
self.__tputs(text)
else:
- os.write(self.output_fd, text.encode(self.encoding))
+ os.write(self.output_fd, text.encode(self.encoding, 'replace'))
del self.__buffer[:]
def __tputs(self, fmt, prog=delayprog):
diff --git a/pypy/annotation/annrpython.py b/pypy/annotation/annrpython.py
--- a/pypy/annotation/annrpython.py
+++ b/pypy/annotation/annrpython.py
@@ -548,7 +548,7 @@
if cell.is_constant():
newcell.const = cell.const
cell = newcell
- cell.knowntypedata = renamed_knowntypedata
+ cell.set_knowntypedata(renamed_knowntypedata)
cells.append(cell)
diff --git a/pypy/annotation/binaryop.py b/pypy/annotation/binaryop.py
--- a/pypy/annotation/binaryop.py
+++ b/pypy/annotation/binaryop.py
@@ -31,21 +31,21 @@
# XXX unify this with ObjSpace.MethodTable
BINARY_OPERATIONS = set(['add', 'sub', 'mul', 'div', 'mod',
- 'truediv', 'floordiv', 'divmod', 'pow',
+ 'truediv', 'floordiv', 'divmod',
'and_', 'or_', 'xor',
'lshift', 'rshift',
'getitem', 'setitem', 'delitem',
'getitem_idx', 'getitem_key', 'getitem_idx_key',
'inplace_add', 'inplace_sub', 'inplace_mul',
'inplace_truediv', 'inplace_floordiv', 'inplace_div',
- 'inplace_mod', 'inplace_pow',
+ 'inplace_mod',
'inplace_lshift', 'inplace_rshift',
'inplace_and', 'inplace_or', 'inplace_xor',
'lt', 'le', 'eq', 'ne', 'gt', 'ge', 'is_', 'cmp',
'coerce',
]
+[opname+'_ovf' for opname in
- """add sub mul floordiv div mod pow lshift
+ """add sub mul floordiv div mod lshift
""".split()
])
@@ -65,7 +65,6 @@
def inplace_floordiv((obj1, obj2)): return pair(obj1, obj2).floordiv()
def inplace_div((obj1, obj2)): return pair(obj1, obj2).div()
def inplace_mod((obj1, obj2)): return pair(obj1, obj2).mod()
- def inplace_pow((obj1, obj2)): return pair(obj1, obj2).pow(s_None)
def inplace_lshift((obj1, obj2)): return pair(obj1, obj2).lshift()
def inplace_rshift((obj1, obj2)): return pair(obj1, obj2).rshift()
def inplace_and((obj1, obj2)): return pair(obj1, obj2).and_()
@@ -145,7 +144,7 @@
# XXX HACK HACK HACK
bk = getbookkeeper()
if bk is not None: # for testing
- knowntypedata = r.knowntypedata = {}
+ knowntypedata = {}
fn, block, i = bk.position_key
annotator = bk.annotator
@@ -169,6 +168,7 @@
bind(obj2, obj1, 0)
bind(obj1, obj2, 1)
+ r.set_knowntypedata(knowntypedata)
return r
@@ -301,19 +301,6 @@
return SomeInteger(nonneg=int1.nonneg, knowntype=int1.knowntype)
rshift.can_only_throw = []
- def pow((int1, int2), obj3):
- knowntype = rarithmetic.compute_restype(int1.knowntype, int2.knowntype)
- return SomeInteger(nonneg = int1.nonneg,
- knowntype=knowntype)
- pow.can_only_throw = [ZeroDivisionError]
- pow_ovf = _clone(pow, [ZeroDivisionError, OverflowError])
-
- def inplace_pow((int1, int2)):
- knowntype = rarithmetic.compute_restype(int1.knowntype, int2.knowntype)
- return SomeInteger(nonneg = int1.nonneg,
- knowntype=knowntype)
- inplace_pow.can_only_throw = [ZeroDivisionError]
-
def _compare_helper((int1, int2), opname, operation):
r = SomeBool()
if int1.is_immutable_constant() and int2.is_immutable_constant():
@@ -351,8 +338,7 @@
case = opname in ('gt', 'ge', 'eq')
add_knowntypedata(knowntypedata, case, [op.args[0]],
SomeInteger(nonneg=True, knowntype=tointtype(int1)))
- if knowntypedata:
- r.knowntypedata = knowntypedata
+ r.set_knowntypedata(knowntypedata)
# a special case for 'x < 0' or 'x >= 0',
# where 0 is a flow graph Constant
# (in this case we are sure that it cannot become a r_uint later)
@@ -383,8 +369,7 @@
if hasattr(boo1, 'knowntypedata') and \
hasattr(boo2, 'knowntypedata'):
ktd = merge_knowntypedata(boo1.knowntypedata, boo2.knowntypedata)
- if ktd:
- s.knowntypedata = ktd
+ s.set_knowntypedata(ktd)
return s
def and_((boo1, boo2)):
@@ -500,9 +485,6 @@
div.can_only_throw = []
truediv = div
- def pow((flt1, flt2), obj3):
- raise NotImplementedError("float power not supported, use math.pow")
-
# repeat these in order to copy the 'can_only_throw' attribute
inplace_div = div
inplace_truediv = truediv
diff --git a/pypy/annotation/bookkeeper.py b/pypy/annotation/bookkeeper.py
--- a/pypy/annotation/bookkeeper.py
+++ b/pypy/annotation/bookkeeper.py
@@ -16,7 +16,7 @@
from pypy.annotation.dictdef import DictDef
from pypy.annotation import description
from pypy.annotation.signature import annotationoftype
-from pypy.interpreter.argument import ArgumentsForTranslation
+from pypy.objspace.flow.argument import ArgumentsForTranslation
from pypy.rlib.objectmodel import r_dict, Symbolic
from pypy.tool.algo.unionfind import UnionFind
from pypy.rpython.lltypesystem import lltype, llmemory
@@ -101,7 +101,7 @@
def consider_list_delitem(self, idx):
return self.indexrepr(idx)
-
+
def consider_str_join(self, s):
if s.is_constant():
return repr(s.const)
@@ -224,7 +224,7 @@
check_no_flags(s_value_or_def.listdef.listitem)
elif isinstance(s_value_or_def, SomeDict):
check_no_flags(s_value_or_def.dictdef.dictkey)
- check_no_flags(s_value_or_def.dictdef.dictvalue)
+ check_no_flags(s_value_or_def.dictdef.dictvalue)
elif isinstance(s_value_or_def, SomeTuple):
for s_item in s_value_or_def.items:
check_no_flags(s_item)
@@ -238,9 +238,9 @@
elif isinstance(s_value_or_def, ListItem):
if s_value_or_def in seen:
return
- seen.add(s_value_or_def)
+ seen.add(s_value_or_def)
check_no_flags(s_value_or_def.s_value)
-
+
for clsdef in self.classdefs:
check_no_flags(clsdef)
@@ -366,14 +366,14 @@
listdef = ListDef(self, s_ImpossibleValue)
for e in x:
listdef.generalize(self.immutablevalue(e, False))
- result = SomeList(listdef)
+ result = SomeList(listdef)
elif tp is dict or tp is r_dict:
if need_const:
key = Constant(x)
try:
return self.immutable_cache[key]
except KeyError:
- result = SomeDict(DictDef(self,
+ result = SomeDict(DictDef(self,
s_ImpossibleValue,
s_ImpossibleValue,
is_r_dict = tp is r_dict))
@@ -396,7 +396,7 @@
result.const_box = key
return result
else:
- dictdef = DictDef(self,
+ dictdef = DictDef(self,
s_ImpossibleValue,
s_ImpossibleValue,
is_r_dict = tp is r_dict)
@@ -545,7 +545,7 @@
return True
else:
return False
-
+
def getfrozen(self, pyobj):
return description.FrozenDesc(self, pyobj)
@@ -566,7 +566,7 @@
key = (x.__class__, x)
if key in self.seen_mutable:
return
- clsdef = self.getuniqueclassdef(x.__class__)
+ clsdef = self.getuniqueclassdef(x.__class__)
self.seen_mutable[key] = True
self.event('mutable', x)
source = InstanceSource(self, x)
@@ -586,7 +586,7 @@
except KeyError:
access_sets = map[attrname] = UnionFind(description.ClassAttrFamily)
return access_sets
-
+
def pbc_getattr(self, pbc, s_attr):
assert s_attr.is_constant()
attr = s_attr.const
@@ -598,7 +598,7 @@
first = descs[0]
if len(descs) == 1:
return first.s_read_attribute(attr)
-
+
change = first.mergeattrfamilies(descs[1:], attr)
attrfamily = first.getattrfamily(attr)
@@ -700,7 +700,7 @@
def ondegenerated(self, what, s_value, where=None, called_from_graph=None):
self.annotator.ondegenerated(what, s_value, where=where,
called_from_graph=called_from_graph)
-
+
def whereami(self):
return self.annotator.whereami(self.position_key)
diff --git a/pypy/annotation/builtin.py b/pypy/annotation/builtin.py
--- a/pypy/annotation/builtin.py
+++ b/pypy/annotation/builtin.py
@@ -188,10 +188,10 @@
variables = [op.args[1]]
for variable in variables:
assert bk.annotator.binding(variable) == s_obj
- r.knowntypedata = {}
-
+ knowntypedata = {}
if not hasattr(typ, '_freeze_') and isinstance(s_type, SomePBC):
- add_knowntypedata(r.knowntypedata, True, variables, bk.valueoftype(typ))
+ add_knowntypedata(knowntypedata, True, variables, bk.valueoftype(typ))
+ r.set_knowntypedata(knowntypedata)
return r
# note that this one either needs to be constant, or we will create SomeObject
@@ -323,10 +323,12 @@
def robjmodel_hlinvoke(s_repr, s_llcallable, *args_s):
from pypy.rpython import rmodel
- assert s_repr.is_constant() and isinstance(s_repr.const, rmodel.Repr),"hlinvoke expects a constant repr as first argument"
- r_func, nimplicitarg = s_repr.const.get_r_implfunc()
+ from pypy.rpython.error import TyperError
- nbargs = len(args_s) + nimplicitarg
+ assert s_repr.is_constant() and isinstance(s_repr.const, rmodel.Repr), "hlinvoke expects a constant repr as first argument"
+ r_func, nimplicitarg = s_repr.const.get_r_implfunc()
+
+ nbargs = len(args_s) + nimplicitarg
s_sigs = r_func.get_s_signatures((nbargs, (), False, False))
if len(s_sigs) != 1:
raise TyperError("cannot hlinvoke callable %r with not uniform"
@@ -337,6 +339,7 @@
return lltype_to_annotation(rresult.lowleveltype)
+
def robjmodel_keepalive_until_here(*args_s):
return immutablevalue(None)
@@ -404,7 +407,10 @@
BUILTIN_ANALYZERS[unicodedata.decimal] = unicodedata_decimal # xxx
# object - just ignore object.__init__
-BUILTIN_ANALYZERS[object.__init__] = object_init
+if hasattr(object.__init__, 'im_func'):
+ BUILTIN_ANALYZERS[object.__init__.im_func] = object_init
+else:
+ BUILTIN_ANALYZERS[object.__init__] = object_init
# import
BUILTIN_ANALYZERS[__import__] = import_func
diff --git a/pypy/annotation/description.py b/pypy/annotation/description.py
--- a/pypy/annotation/description.py
+++ b/pypy/annotation/description.py
@@ -1,8 +1,7 @@
import types, py
from pypy.objspace.flow.model import Constant, FunctionGraph
-from pypy.interpreter.pycode import cpython_code_signature
-from pypy.interpreter.argument import rawshape
-from pypy.interpreter.argument import ArgErr
+from pypy.objspace.flow.bytecode import cpython_code_signature
+from pypy.objspace.flow.argument import rawshape, ArgErr
from pypy.tool.sourcetools import valid_identifier
from pypy.tool.pairtype import extendabletype
@@ -181,7 +180,7 @@
name = pyobj.func_name
if signature is None:
if hasattr(pyobj, '_generator_next_method_of_'):
- from pypy.interpreter.argument import Signature
+ from pypy.objspace.flow.argument import Signature
signature = Signature(['entry']) # haaaaaack
defaults = ()
else:
@@ -260,7 +259,7 @@
try:
inputcells = args.match_signature(signature, defs_s)
except ArgErr, e:
- raise TypeError("signature mismatch: %s() %s" %
+ raise TypeError("signature mismatch: %s() %s" %
(self.name, e.getmsg()))
return inputcells
diff --git a/pypy/annotation/model.py b/pypy/annotation/model.py
--- a/pypy/annotation/model.py
+++ b/pypy/annotation/model.py
@@ -195,6 +195,10 @@
unsigned = False
def __init__(self):
pass
+ def set_knowntypedata(self, knowntypedata):
+ assert not hasattr(self, 'knowntypedata')
+ if knowntypedata:
+ self.knowntypedata = knowntypedata
class SomeStringOrUnicode(SomeObject):
immutable = True
@@ -380,6 +384,14 @@
desc, = descriptions
if desc.pyobj is not None:
self.const = desc.pyobj
+ elif len(descriptions) > 1:
+ from pypy.annotation.description import ClassDesc
+ if self.getKind() is ClassDesc:
+ # a PBC of several classes: enforce them all to be
+ # built, without support for specialization. See
+ # rpython/test/test_rpbc.test_pbc_of_classes_not_all_used
+ for desc in descriptions:
+ desc.getuniqueclassdef()
def any_description(self):
return iter(self.descriptions).next()
@@ -696,7 +708,7 @@
return r
def not_const(s_obj):
- if s_obj.is_constant():
+ if s_obj.is_constant() and not isinstance(s_obj, SomePBC):
new_s_obj = SomeObject.__new__(s_obj.__class__)
dic = new_s_obj.__dict__ = s_obj.__dict__.copy()
if 'const' in dic:
diff --git a/pypy/annotation/specialize.py b/pypy/annotation/specialize.py
--- a/pypy/annotation/specialize.py
+++ b/pypy/annotation/specialize.py
@@ -6,7 +6,7 @@
from pypy.objspace.flow.model import Block, Link, Variable, SpaceOperation
from pypy.objspace.flow.model import Constant, checkgraph
from pypy.annotation import model as annmodel
-from pypy.interpreter.argument import Signature
+from pypy.objspace.flow.argument import Signature
def flatten_star_args(funcdesc, args_s):
argnames, vararg, kwarg = funcdesc.signature
diff --git a/pypy/annotation/test/test_annrpython.py b/pypy/annotation/test/test_annrpython.py
--- a/pypy/annotation/test/test_annrpython.py
+++ b/pypy/annotation/test/test_annrpython.py
@@ -13,7 +13,7 @@
from pypy.rlib.rarithmetic import r_uint, base_int, r_longlong, r_ulonglong
from pypy.rlib.rarithmetic import r_singlefloat
from pypy.rlib import objectmodel
-from pypy.objspace.flow.objspace import FlowObjSpace
+from pypy.objspace.flow.objspace import FlowObjSpace, FlowingError
from pypy.translator.test import snippet
@@ -1431,15 +1431,6 @@
assert a.binding(et) == t
assert isinstance(a.binding(ev), annmodel.SomeInstance) and a.binding(ev).classdef == a.bookkeeper.getuniqueclassdef(Exception)
- def test_pow(self):
- def f(n):
- n **= 2
- return 2 ** n
- a = self.RPythonAnnotator()
- s = a.build_types(f, [int])
- # result should be an integer
- assert s.knowntype == int
-
def test_inplace_div(self):
def f(n):
n /= 2
@@ -3156,10 +3147,9 @@
x **= y
return x ** y
a = self.RPythonAnnotator()
- s = a.build_types(f, [int, int])
- assert isinstance(s, annmodel.SomeInteger)
- a = self.RPythonAnnotator()
- py.test.raises(NotImplementedError, a.build_types, f, [float, float])
+ py.test.raises(FlowingError, a.build_types, f, [int, int])
+ a = self.RPythonAnnotator()
+ py.test.raises(FlowingError, a.build_types, f, [float, float])
def test_intcmp_bug(self):
def g(x, y):
@@ -3815,6 +3805,20 @@
s = a.build_types(f, [annmodel.SomeInteger()])
assert isinstance(s, annmodel.SomeBool)
+ def test_object_init(self):
+ class A(object):
+ pass
+
+ class B(A):
+ def __init__(self):
+ A.__init__(self)
+
+ def f():
+ B()
+
+ a = self.RPythonAnnotator()
+ a.build_types(f, []) # assert did not explode
+
def g(n):
return [0,1,2,n]
diff --git a/pypy/annotation/unaryop.py b/pypy/annotation/unaryop.py
--- a/pypy/annotation/unaryop.py
+++ b/pypy/annotation/unaryop.py
@@ -76,7 +76,7 @@
s_obj.is_true_behavior(r)
bk = getbookkeeper()
- knowntypedata = r.knowntypedata = {}
+ knowntypedata = {}
fn, block, i = bk.position_key
op = block.operations[i]
assert op.opname == "is_true" or op.opname == "nonzero"
@@ -86,8 +86,8 @@
if s_obj.can_be_none():
s_nonnone_obj = s_obj.nonnoneify()
add_knowntypedata(knowntypedata, True, [arg], s_nonnone_obj)
+ r.set_knowntypedata(knowntypedata)
return r
-
def nonzero(obj):
return obj.is_true()
diff --git a/pypy/bin/py.py b/pypy/bin/py.py
--- a/pypy/bin/py.py
+++ b/pypy/bin/py.py
@@ -65,10 +65,17 @@
config, parser = option.get_standard_options()
interactiveconfig = Config(cmdline_optiondescr)
to_optparse(interactiveconfig, parser=parser)
+ def set_family_of_options(option, opt, value, parser):
+ from pypy.config.pypyoption import set_pypy_opt_level
+ set_pypy_opt_level(config, value)
parser.add_option(
'--cc', type=str, action="callback",
callback=set_compiler,
help="Compiler to use for compiling generated C")
+ parser.add_option(
+ '--opt', type=str, action="callback",
+ callback=set_family_of_options,
+ help="Set the family of options based on -opt=0,1,2,jit...")
args = option.process_options(parser, argv[1:])
if interactiveconfig.verbose:
error.RECORD_INTERPLEVEL_TRACEBACK = True
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -372,7 +372,7 @@
config.objspace.std.suggest(builtinshortcut=True)
config.objspace.std.suggest(optimized_list_getitem=True)
config.objspace.std.suggest(getattributeshortcut=True)
- config.objspace.std.suggest(newshortcut=True)
+ #config.objspace.std.suggest(newshortcut=True)
config.objspace.std.suggest(withspecialisedtuple=True)
config.objspace.std.suggest(withidentitydict=True)
#if not IS_64_BITS:
diff --git a/pypy/config/test/test_pypyoption.py b/pypy/config/test/test_pypyoption.py
--- a/pypy/config/test/test_pypyoption.py
+++ b/pypy/config/test/test_pypyoption.py
@@ -47,10 +47,10 @@
def test_set_pypy_opt_level():
conf = get_pypy_config()
set_pypy_opt_level(conf, '2')
- assert conf.objspace.std.newshortcut
+ assert conf.objspace.std.getattributeshortcut
conf = get_pypy_config()
set_pypy_opt_level(conf, '0')
- assert not conf.objspace.std.newshortcut
+ assert not conf.objspace.std.getattributeshortcut
def test_rweakref_required():
conf = get_pypy_config()
diff --git a/pypy/config/translationoption.py b/pypy/config/translationoption.py
--- a/pypy/config/translationoption.py
+++ b/pypy/config/translationoption.py
@@ -118,7 +118,7 @@
("translation.gcrootfinder", DEFL_ROOTFINDER_WITHJIT),
("translation.list_comprehension_operations", True)]),
ChoiceOption("jit_backend", "choose the backend for the JIT",
- ["auto", "x86", "x86-without-sse2", "llvm", 'arm'],
+ ["auto", "x86", "x86-without-sse2", 'arm'],
default="auto", cmdline="--jit-backend"),
ChoiceOption("jit_profiler", "integrate profiler support into the JIT",
["off", "oprofile"],
diff --git a/pypy/conftest.py b/pypy/conftest.py
--- a/pypy/conftest.py
+++ b/pypy/conftest.py
@@ -1,14 +1,5 @@
-import py, pytest, sys, os, textwrap, types
-from pypy.interpreter.gateway import app2interp_temp
-from pypy.interpreter.error import OperationError
-from pypy.interpreter.function import Method
-from pypy.tool.pytest import appsupport
-from pypy.tool.option import make_config, make_objspace
-from pypy.config.config import ConflictConfigError
-from inspect import isclass, getmro
-from pypy.tool.udir import udir
-from pypy.tool.autopath import pypydir
-from pypy.tool import leakfinder
+import py, pytest, sys, os, textwrap
+from inspect import isclass
# pytest settings
rsyncdirs = ['.', '../lib-python', '../lib_pypy', '../demo']
@@ -33,6 +24,12 @@
def pytest_report_header():
return "pytest-%s from %s" %(pytest.__version__, pytest.__file__)
+
+def pytest_addhooks(pluginmanager):
+ from pypy.tool.pytest.plugins import LeakFinder
+ pluginmanager.register(LeakFinder())
+
+
def pytest_configure(config):
global option
option = config.option
@@ -70,145 +67,10 @@
pass
def pytest_funcarg__space(request):
+ from pypy.tool.pytest.objspace import gettestobjspace
spaceconfig = getattr(request.cls, 'spaceconfig', {})
return gettestobjspace(**spaceconfig)
-_SPACECACHE={}
-def gettestobjspace(name=None, **kwds):
- """ helper for instantiating and caching space's for testing.
- """
- try:
- config = make_config(option, objspace=name, **kwds)
- except ConflictConfigError, e:
- # this exception is typically only raised if a module is not available.
- # in this case the test should be skipped
- py.test.skip(str(e))
- key = config.getkey()
- try:
- return _SPACECACHE[key]
- except KeyError:
- if getattr(option, 'runappdirect', None):
- if name not in (None, 'std'):
- myname = getattr(sys, 'pypy_objspaceclass', '')
- if not myname.lower().startswith(name):
- py.test.skip("cannot runappdirect test: "
- "%s objspace required" % (name,))
- return TinyObjSpace(**kwds)
- space = maketestobjspace(config)
- _SPACECACHE[key] = space
- return space
-
-def maketestobjspace(config=None):
- if config is None:
- config = make_config(option)
- space = make_objspace(config)
- space.startup() # Initialize all builtin modules
- space.setitem(space.builtin.w_dict, space.wrap('AssertionError'),
- appsupport.build_pytest_assertion(space))
- space.setitem(space.builtin.w_dict, space.wrap('raises'),
- space.wrap(appsupport.app_raises))
- space.setitem(space.builtin.w_dict, space.wrap('skip'),
- space.wrap(appsupport.app_skip))
- space.raises_w = appsupport.raises_w.__get__(space)
- space.eq_w = appsupport.eq_w.__get__(space)
- return space
-
-class TinyObjSpace(object):
- def __init__(self, **kwds):
- import sys
- info = getattr(sys, 'pypy_translation_info', None)
- for key, value in kwds.iteritems():
- if key == 'usemodules':
- if info is not None:
- for modname in value:
- ok = info.get('objspace.usemodules.%s' % modname,
- False)
- if not ok:
- py.test.skip("cannot runappdirect test: "
- "module %r required" % (modname,))
- else:
- if '__pypy__' in value:
- py.test.skip("no module __pypy__ on top of CPython")
- continue
- if info is None:
- py.test.skip("cannot runappdirect this test on top of CPython")
- has = info.get(key, None)
- if has != value:
- #print sys.pypy_translation_info
- py.test.skip("cannot runappdirect test: space needs %s = %s, "\
- "while pypy-c was built with %s" % (key, value, has))
-
- for name in ('int', 'long', 'str', 'unicode', 'None'):
- setattr(self, 'w_' + name, eval(name))
-
-
- def appexec(self, args, body):
- body = body.lstrip()
- assert body.startswith('(')
- src = py.code.Source("def anonymous" + body)
- d = {}
- exec src.compile() in d
- return d['anonymous'](*args)
-
- def wrap(self, obj):
- return obj
-
- def unpackiterable(self, itr):
- return list(itr)
-
- def is_true(self, obj):
- return bool(obj)
-
- def str_w(self, w_str):
- return w_str
-
- def newdict(self, module=None):
- return {}
-
- def newtuple(self, iterable):
- return tuple(iterable)
-
- def newlist(self, iterable):
- return list(iterable)
-
- def call_function(self, func, *args, **kwds):
- return func(*args, **kwds)
-
- def call_method(self, obj, name, *args, **kwds):
- return getattr(obj, name)(*args, **kwds)
-
- def getattr(self, obj, name):
- return getattr(obj, name)
-
- def setattr(self, obj, name, value):
- setattr(obj, name, value)
-
- def getbuiltinmodule(self, name):
- return __import__(name)
-
- def delslice(self, obj, *args):
- obj.__delslice__(*args)
-
- def is_w(self, obj1, obj2):
- return obj1 is obj2
-
-def translation_test_so_skip_if_appdirect():
- if option.runappdirect:
- py.test.skip("translation test, skipped for appdirect")
-
-
-class OpErrKeyboardInterrupt(KeyboardInterrupt):
- pass
-
-def check_keyboard_interrupt(e):
- # we cannot easily convert w_KeyboardInterrupt to KeyboardInterrupt
- # in general without a space -- here is an approximation
- try:
- if e.w_type.name == 'KeyboardInterrupt':
- tb = sys.exc_info()[2]
- raise OpErrKeyboardInterrupt, OpErrKeyboardInterrupt(), tb
- except AttributeError:
- pass
#
# Interfacing/Integrating with py.test's collection process
@@ -270,10 +132,12 @@
def makeitem(self, name, obj):
if isclass(obj) and self.classnamefilter(name):
if name.startswith('AppTest'):
+ from pypy.tool.pytest.apptest import AppClassCollector
return AppClassCollector(name, parent=self)
elif name.startswith('ExpectTest'):
if self.config.option.rundirect:
return py.test.collect.Class(name, parent=self)
+ from pypy.tool.pytest.expecttest import ExpectClassCollector
return ExpectClassCollector(name, parent=self)
# XXX todo
#elif name.startswith('AppExpectTest'):
@@ -281,16 +145,19 @@
# return AppClassCollector(name, parent=self)
# return AppExpectClassCollector(name, parent=self)
else:
+ from pypy.tool.pytest.inttest import IntClassCollector
return IntClassCollector(name, parent=self)
elif hasattr(obj, 'func_code') and self.funcnamefilter(name):
if name.startswith('app_test_'):
assert not obj.func_code.co_flags & 32, \
"generator app level functions? you must be joking"
+ from pypy.tool.pytest.apptest import AppTestFunction
return AppTestFunction(name, parent=self)
elif obj.func_code.co_flags & 32: # generator function
return pytest.Generator(name, parent=self)
else:
+ from pypy.tool.pytest.inttest import IntTestFunction
return IntTestFunction(name, parent=self)
def skip_on_missing_buildoption(**ropts):
@@ -311,150 +178,36 @@
class LazyObjSpaceGetter(object):
def __get__(self, obj, cls=None):
+ from pypy.tool.pytest.objspace import gettestobjspace
space = gettestobjspace()
if cls:
cls.space = space
return space
-class AppError(Exception):
-
- def __init__(self, excinfo):
- self.excinfo = excinfo
-
def pytest_runtest_setup(__multicall__, item):
if isinstance(item, py.test.collect.Function):
appclass = item.getparent(PyPyClassCollector)
if appclass is not None:
+ # Make cls.space and cls.runappdirect available in tests.
spaceconfig = getattr(appclass.obj, 'spaceconfig', None)
- if spaceconfig:
+ if spaceconfig is not None:
+ from pypy.tool.pytest.objspace import gettestobjspace
appclass.obj.space = gettestobjspace(**spaceconfig)
+ appclass.obj.runappdirect = option.runappdirect
__multicall__.execute()
- if isinstance(item, py.test.collect.Function):
- if not getattr(item.obj, 'dont_track_allocations', False):
- leakfinder.start_tracking_allocations()
-
-def pytest_runtest_call(__multicall__, item):
- __multicall__.execute()
- item._success = True
-
def pytest_runtest_teardown(__multicall__, item):
__multicall__.execute()
- if isinstance(item, py.test.collect.Function):
- if (not getattr(item.obj, 'dont_track_allocations', False)
- and leakfinder.TRACK_ALLOCATIONS):
- item._pypytest_leaks = leakfinder.stop_tracking_allocations(False)
- else: # stop_tracking_allocations() already called
- item._pypytest_leaks = None
-
- # check for leaks, but only if the test passed so far
- if getattr(item, '_success', False) and item._pypytest_leaks:
- raise leakfinder.MallocMismatch(item._pypytest_leaks)
-
if 'pygame' in sys.modules:
assert option.view, ("should not invoke Pygame "
"if conftest.option.view is False")
-_pygame_imported = False
-
-class IntTestFunction(py.test.collect.Function):
- def __init__(self, *args, **kwargs):
- super(IntTestFunction, self).__init__(*args, **kwargs)
- self.keywords['interplevel'] = True
-
- def runtest(self):
- try:
- super(IntTestFunction, self).runtest()
- except OperationError, e:
- check_keyboard_interrupt(e)
- raise
- except Exception, e:
- cls = e.__class__
- while cls is not Exception:
- if cls.__name__ == 'DistutilsPlatformError':
- from distutils.errors import DistutilsPlatformError
- if isinstance(e, DistutilsPlatformError):
- py.test.skip('%s: %s' % (e.__class__.__name__, e))
- cls = cls.__bases__[0]
- raise
-
-class AppTestFunction(py.test.collect.Function):
- def __init__(self, *args, **kwargs):
- super(AppTestFunction, self).__init__(*args, **kwargs)
- self.keywords['applevel'] = True
-
- def _prunetraceback(self, traceback):
- return traceback
-
- def execute_appex(self, space, target, *args):
- try:
- target(*args)
- except OperationError, e:
- tb = sys.exc_info()[2]
- if e.match(space, space.w_KeyboardInterrupt):
- raise OpErrKeyboardInterrupt, OpErrKeyboardInterrupt(), tb
- appexcinfo = appsupport.AppExceptionInfo(space, e)
- if appexcinfo.traceback:
- raise AppError, AppError(appexcinfo), tb
- raise
-
- def runtest(self):
- target = self.obj
- if self.config.option.runappdirect:
- return target()
- space = gettestobjspace()
- filename = self._getdynfilename(target)
- func = app2interp_temp(target, filename=filename)
- print "executing", func
- self.execute_appex(space, func, space)
-
- def repr_failure(self, excinfo):
- if excinfo.errisinstance(AppError):
- excinfo = excinfo.value.excinfo
- return super(AppTestFunction, self).repr_failure(excinfo)
-
- def _getdynfilename(self, func):
- code = getattr(func, 'im_func', func).func_code
- return "[%s:%s]" % (code.co_filename, code.co_firstlineno)
-
-class AppTestMethod(AppTestFunction):
- def setup(self):
- super(AppTestMethod, self).setup()
- instance = self.parent.obj
- w_instance = self.parent.w_instance
- space = instance.space
- for name in dir(instance):
- if name.startswith('w_'):
- if self.config.option.runappdirect:
- setattr(instance, name[2:], getattr(instance, name))
- else:
- obj = getattr(instance, name)
- if isinstance(obj, types.MethodType):
- source = py.std.inspect.getsource(obj).lstrip()
- w_func = space.appexec([], textwrap.dedent("""
- ():
- %s
- return %s
- """) % (source, name))
- w_obj = Method(space, w_func, w_instance, space.w_None)
- else:
- w_obj = obj
- space.setattr(w_instance, space.wrap(name[2:]), w_obj)
-
- def runtest(self):
- target = self.obj
- if self.config.option.runappdirect:
- return target()
- space = target.im_self.space
- filename = self._getdynfilename(target)
- func = app2interp_temp(target.im_func, filename=filename)
- w_instance = self.parent.w_instance
- self.execute_appex(space, func, space, w_instance)
class PyPyClassCollector(py.test.collect.Class):
+ # All pypy Test classes have a "space" member.
def setup(self):
cls = self.obj
if not hasattr(cls, 'spaceconfig'):
@@ -463,125 +216,6 @@
assert hasattr(cls, 'space') # set by pytest_runtest_setup
super(PyPyClassCollector, self).setup()
-class IntInstanceCollector(py.test.collect.Instance):
- Function = IntTestFunction
-
-class IntClassCollector(PyPyClassCollector):
- Instance = IntInstanceCollector
-
- def _haskeyword(self, keyword):
- return keyword == 'interplevel' or \
- super(IntClassCollector, self)._haskeyword(keyword)
-
- def _keywords(self):
- return super(IntClassCollector, self)._keywords() + ['interplevel']
-
-class AppClassInstance(py.test.collect.Instance):
- Function = AppTestMethod
-
- def setup(self):
- super(AppClassInstance, self).setup()
- instance = self.obj
- space = instance.space
- w_class = self.parent.w_class
- if self.config.option.runappdirect:
- self.w_instance = instance
- else:
- self.w_instance = space.call_function(w_class)
-
-class AppClassCollector(PyPyClassCollector):
- Instance = AppClassInstance
-
- def _haskeyword(self, keyword):
- return keyword == 'applevel' or \
- super(AppClassCollector, self)._haskeyword(keyword)
-
- def _keywords(self):
- return super(AppClassCollector, self)._keywords() + ['applevel']
-
- def setup(self):
- super(AppClassCollector, self).setup()
- cls = self.obj
- #
- # <hack>
- for name in dir(cls):
- if name.startswith('test_'):
- func = getattr(cls, name, None)
- code = getattr(func, 'func_code', None)
- if code and code.co_flags & 32:
- raise AssertionError("unsupported: %r is a generator "
- "app-level test method" % (name,))
- # </hack>
- #
- space = cls.space
- clsname = cls.__name__
- if self.config.option.runappdirect:
- w_class = cls
- else:
- w_class = space.call_function(space.w_type,
- space.wrap(clsname),
- space.newtuple([]),
- space.newdict())
- self.w_class = w_class
-
-class ExpectTestMethod(py.test.collect.Function):
- def safe_name(target):
- s = "_".join(target)
- s = s.replace("()", "paren")
- s = s.replace(".py", "")
- s = s.replace(".", "_")
- s = s.replace(os.sep, "_")
- return s
-
- safe_name = staticmethod(safe_name)
-
- def safe_filename(self):
- name = self.safe_name(self.listnames())
- num = 0
- while udir.join(name + '.py').check():
- num += 1
- name = self.safe_name(self.listnames()) + "_" + str(num)
- return name + '.py'
-
- def _spawn(self, *args, **kwds):
- import pexpect
- kwds.setdefault('timeout', 600)
- child = pexpect.spawn(*args, **kwds)
- child.logfile = sys.stdout
- return child
-
- def spawn(self, argv):
- return self._spawn(sys.executable, argv)
-
- def runtest(self):
- target = self.obj
- import pexpect
- source = py.code.Source(target)[1:].deindent()
- filename = self.safe_filename()
- source.lines = ['import sys',
- 'sys.path.insert(0, %s)' % repr(os.path.dirname(pypydir))
- ] + source.lines
- source.lines.append('print "%s ok!"' % filename)
- f = udir.join(filename)
- f.write(source)
- # run target in the guarded environment
- child = self.spawn([str(f)])
- import re
- child.expect(re.escape(filename + " ok!"))
-
-class ExpectClassInstance(py.test.collect.Instance):
- Function = ExpectTestMethod
-
-class ExpectClassCollector(py.test.collect.Class):
- Instance = ExpectClassInstance
-
- def setup(self):
- super(ExpectClassCollector, self).setup()
- try:
- import pexpect
- except ImportError:
- py.test.skip("pexpect not found")
-
def pytest_ignore_collect(path):
return path.check(link=1)
diff --git a/pypy/doc/cpython_differences.rst b/pypy/doc/cpython_differences.rst
--- a/pypy/doc/cpython_differences.rst
+++ b/pypy/doc/cpython_differences.rst
@@ -285,17 +285,14 @@
Miscellaneous
-------------
-* Hash randomization is not supported in PyPy. Passing ``-R`` to the
- command line, or setting the ``PYTHONHASHSEED`` environment variable
- will display a warning message.
+* Hash randomization (``-R``) is ignored in PyPy. As documented in
+ http://bugs.python.org/issue14621 , some of us believe it has no
+ purpose in CPython either.
-* ``sys.setrecursionlimit()`` is ignored (and not needed) on
- PyPy. On CPython it would set the maximum number of nested
- calls that can occur before a RuntimeError is raised; on PyPy
- overflowing the stack also causes RuntimeErrors, but the limit
- is checked at a lower level. (The limit is currently hard-coded
- at 768 KB, corresponding to roughly 1480 Python calls on
- Linux.)
+* ``sys.setrecursionlimit(n)`` sets the limit only approximately,
+ by setting the usable stack space to ``n * 768`` bytes. On Linux,
+ depending on the compiler settings, the default of 768KB is enough
+ for about 1400 calls.
* assignment to ``__class__`` is limited to the cases where it
works on CPython 2.5. On CPython 2.6 and 2.7 it works in a bit
diff --git a/pypy/doc/getting-started-dev.rst b/pypy/doc/getting-started-dev.rst
--- a/pypy/doc/getting-started-dev.rst
+++ b/pypy/doc/getting-started-dev.rst
@@ -100,7 +100,7 @@
To translate and run for the CLI you must have the SDK installed: Windows
users need the `.NET Framework SDK`_, while Linux and Mac users
can use Mono_. To translate and run for the JVM you must have a JDK
-installed (at least version 5) and ``java``/``javac`` on your path.
+installed (at least version 6) and ``java``/``javac`` on your path.
A slightly larger example
+++++++++++++++++++++++++
diff --git a/pypy/doc/sandbox.rst b/pypy/doc/sandbox.rst
--- a/pypy/doc/sandbox.rst
+++ b/pypy/doc/sandbox.rst
@@ -25,6 +25,13 @@
this case we also generate systematic run-time checks against buffer
overflows.
+.. warning::
+
+ The hard work from the PyPy side is done --- you get a fully secure
+ version. What is only experimental and unpolished is the library to
+ use this sandboxed PyPy from a regular Python interpreter (CPython, or
+ an unsandboxed PyPy). Contributions welcome.
+
Overview
--------
diff --git a/pypy/doc/whatsnew-2.0-beta1.rst b/pypy/doc/whatsnew-2.0-beta1.rst
new file mode 100644
--- /dev/null
+++ b/pypy/doc/whatsnew-2.0-beta1.rst
@@ -0,0 +1,65 @@
+======================
+What's new in PyPy xxx
+======================
+
+.. this is the revision of the last merge from default to release-1.9.x
+.. startrev: 8d567513d04d
+
+Fixed the performance of gc.get_referrers()
+
+.. branch: default
+.. branch: app_main-refactor
+.. branch: win-ordinal
+.. branch: reflex-support
+Provides cppyy module (disabled by default) for access to C++ through Reflex.
+See doc/cppyy.rst for full details and functionality.
+.. branch: nupypy-axis-arg-check
+Check that axis arg is valid in _numpypy
+.. branch:less-gettestobjspace
+.. branch: move-apptest-support
+
+.. branch: iterator-in-rpython
+.. branch: numpypy_count_nonzero
+.. branch: numpy-refactor
+Remove numpy lazy evaluation and simplify everything
+.. branch: numpy-reintroduce-jit-drivers
+.. branch: numpy-fancy-indexing
+Support for array[array-of-ints] in numpy
+.. branch: even-more-jit-hooks
+Implement better JIT hooks
+.. branch: virtual-arguments
+Improve handling of **kwds greatly, making them virtual sometimes.
+.. branch: improve-rbigint
+Introduce __int128 on systems where it's supported and improve the speed of
+rlib/rbigint.py greatly.
+.. branch: translation-cleanup
+Start to clean up a bit the flow object space.
+.. branch: ffi-backend
+Support CFFI. http://morepypy.blogspot.ch/2012/08/cffi-release-03.html
+.. branch: speedup-unpackiterable
+.. branch: stdlib-2.7.3
+The stdlib was updated to version 2.7.3
+
+.. branch: numpypy-complex2
+Complex dtype support for numpy
+.. branch: numpypy-problems
+Improve dtypes intp, uintp, void, string and record
+.. branch: numpypy.float16
+Add float16 numpy dtype
+.. branch: kill-someobject
+major cleanups including killing some object support
+.. branch: cpyext-PyThreadState_New
+implement threadstate-related functions in cpyext
+
+.. branch: unicode-strategies
+add dict/list/set strategies optimized for unicode items
+
+.. "uninteresting" branches that we should just ignore for the whatsnew:
+.. branch: slightly-shorter-c
+.. branch: better-enforceargs
+.. branch: rpython-unicode-formatting
+.. branch: jit-opaque-licm
+.. branch: rpython-utf8
+Support for utf-8 encoding in RPython
+.. branch: arm-backend-2
+Support ARM in the JIT.
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
deleted file mode 100644
--- a/pypy/doc/whatsnew-head.rst
+++ /dev/null
@@ -1,53 +0,0 @@
-======================
-What's new in PyPy xxx
-======================
-
-.. this is the revision of the last merge from default to release-1.9.x
-.. startrev: 8d567513d04d
-
-.. branch: default
-.. branch: app_main-refactor
-.. branch: win-ordinal
-.. branch: reflex-support
-Provides cppyy module (disabled by default) for access to C++ through Reflex.
-See doc/cppyy.rst for full details and functionality.
-.. branch: nupypy-axis-arg-check
-Check that axis arg is valid in _numpypy
-
-.. branch: iterator-in-rpython
More information about the pypy-commit
mailing list