[pypy-commit] pypy py3k: merge default
gutworth
noreply at buildbot.pypy.org
Thu Mar 15 04:44:55 CET 2012
Author: Benjamin Peterson <benjamin at python.org>
Branch: py3k
Changeset: r53666:a090e5bd9a16
Date: 2012-03-14 22:44 -0500
http://bitbucket.org/pypy/pypy/changeset/a090e5bd9a16/
Log: merge default
diff --git a/pypy/bin/rpython b/pypy/bin/rpython
new file mode 100755
--- /dev/null
+++ b/pypy/bin/rpython
@@ -0,0 +1,18 @@
+#!/usr/bin/env pypy
+
+"""RPython translation usage:
+
+rpython <translation options> target <targetoptions>
+
+run with --help for more information
+"""
+
+import sys
+from pypy.translator.goal.translate import main
+
+# no implicit targets
+if len(sys.argv) == 1:
+ print __doc__
+ sys.exit(1)
+
+main()
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -182,9 +182,6 @@
cmdline="--translationmodules",
suggests=[("objspace.allworkingmodules", False)]),
- BoolOption("geninterp", "specify whether geninterp should be used",
- default=False),
-
BoolOption("logbytecodes",
"keep track of bytecode usage",
default=False),
@@ -391,10 +388,6 @@
config.objspace.std.suggest(withsmalllong=True)
# xxx other options? ropes maybe?
- # completely disable geninterp in a level 0 translation
- if level == '0':
- config.objspace.suggest(geninterp=False)
-
# some optimizations have different effects depending on the typesystem
if type_system == 'ootype':
config.objspace.std.suggest(multimethods="doubledispatch")
diff --git a/pypy/config/translationoption.py b/pypy/config/translationoption.py
--- a/pypy/config/translationoption.py
+++ b/pypy/config/translationoption.py
@@ -182,11 +182,6 @@
# Flags of the TranslationContext:
BoolOption("simplifying", "Simplify flow graphs", default=True),
- BoolOption("builtins_can_raise_exceptions",
- "When true, assume any call to a 'simple' builtin such as "
- "'hex' can raise an arbitrary exception",
- default=False,
- cmdline=None),
BoolOption("list_comprehension_operations",
"When true, look for and special-case the sequence of "
"operations that results from a list comprehension and "
diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -913,18 +913,12 @@
self.filename = filename
self.source = str(py.code.Source(source).deindent())
self.modname = modname
- # look at the first three lines for a NOT_RPYTHON tag
- first = "\n".join(source.split("\n", 3)[:3])
- if "NOT_RPYTHON" in first:
- self.can_use_geninterp = False
- else:
- self.can_use_geninterp = True
# make source code available for tracebacks
lines = [x + "\n" for x in source.split("\n")]
py.std.linecache.cache[filename] = (1, None, lines, filename)
def __repr__(self):
- return "<ApplevelClass filename=%r can_use_geninterp=%r>" % (self.filename, self.can_use_geninterp)
+ return "<ApplevelClass filename=%r>" % (self.filename,)
def getwdict(self, space):
return space.fromcache(ApplevelCache).getorbuild(self)
@@ -985,10 +979,7 @@
def build(self, app):
"NOT_RPYTHON. Called indirectly by Applevel.getwdict()."
- if self.space.config.objspace.geninterp and app.can_use_geninterp:
- return PyPyCacheDir.build_applevelinterp_dict(app, self.space)
- else:
- return build_applevel_dict(app, self.space)
+ return build_applevel_dict(app, self.space)
# __________ pure applevel version __________
@@ -1002,157 +993,6 @@
filename=self.filename)
return w_glob
-# __________ geninterplevel version __________
-
-class PyPyCacheDir:
- "NOT_RPYTHON"
- # similar to applevel, but using translation to interp-level.
- # This version maintains a cache folder with single files.
-
- def build_applevelinterp_dict(cls, self, space):
- "NOT_RPYTHON"
- # N.B. 'self' is the ApplevelInterp; this is a class method,
- # just so that we have a convenient place to store the global state.
- if not cls._setup_done:
- cls._setup()
-
- from pypy.translator.geninterplevel import translate_as_module
- import marshal
- scramble = md5(cls.seed)
- scramble.update(marshal.dumps(self.source))
- key = scramble.hexdigest()
- initfunc = cls.known_code.get(key)
- if not initfunc:
- # try to get it from file
- name = key
- if self.filename:
- prename = os.path.splitext(os.path.basename(self.filename))[0]
- else:
- prename = 'zznoname'
- name = "%s_%s" % (prename, name)
- try:
- __import__("pypy._cache."+name)
- except ImportError, x:
- # print x
- pass
- else:
- initfunc = cls.known_code[key]
- if not initfunc:
- # build it and put it into a file
- initfunc, newsrc = translate_as_module(
- self.source, self.filename, self.modname)
- fname = cls.cache_path.join(name+".py").strpath
- f = file(get_tmp_file_name(fname), "w")
- print >> f, """\
-# self-destruct on double-click:
-if __name__ == "__main__":
- from pypy import _cache
- import os
- namestart = os.path.join(os.path.split(_cache.__file__)[0], '%s')
- for ending in ('.py', '.pyc', '.pyo'):
- try:
- os.unlink(namestart+ending)
- except os.error:
- pass""" % name
- print >> f
- print >> f, newsrc
- print >> f, "from pypy._cache import known_code"
- print >> f, "known_code[%r] = %s" % (key, initfunc.__name__)
- f.close()
- rename_tmp_to_eventual_file_name(fname)
- w_glob = initfunc(space)
- return w_glob
- build_applevelinterp_dict = classmethod(build_applevelinterp_dict)
-
- _setup_done = False
-
- def _setup(cls):
- """NOT_RPYTHON"""
- lp = py.path.local
- import pypy, os
- p = lp(pypy.__file__).new(basename='_cache').ensure(dir=1)
- cls.cache_path = p
- ini = p.join('__init__.py')
- try:
- if not ini.check():
- raise ImportError # don't import if only a .pyc file left!!!
- from pypy._cache import known_code, \
- GI_VERSION_RENDERED
- except ImportError:
- GI_VERSION_RENDERED = 0
- from pypy.translator.geninterplevel import GI_VERSION
- cls.seed = md5(str(GI_VERSION)).digest()
- if GI_VERSION != GI_VERSION_RENDERED or GI_VERSION is None:
- for pth in p.listdir():
- if pth.check(file=1):
- try:
- pth.remove()
- except: pass
- f = file(get_tmp_file_name(str(ini)), "w")
- f.write("""\
-# This folder acts as a cache for code snippets which have been
-# compiled by compile_as_module().
-# It will get a new entry for every piece of code that has
-# not been seen, yet.
-#
-# Caution! Only the code snippet is checked. If something
-# is imported, changes are not detected. Also, changes
-# to geninterplevel or gateway are also not checked.
-# Exception: There is a checked version number in geninterplevel.py
-#
-# If in doubt, remove this file from time to time.
-
-GI_VERSION_RENDERED = %r
-
-known_code = {}
-
-# self-destruct on double-click:
-def harakiri():
- import pypy._cache as _c
- import py
- lp = py.path.local
- for pth in lp(_c.__file__).dirpath().listdir():
- try:
- pth.remove()
- except: pass
-
-if __name__ == "__main__":
- harakiri()
-
-del harakiri
-""" % GI_VERSION)
- f.close()
- rename_tmp_to_eventual_file_name(str(ini))
- import pypy._cache
- cls.known_code = pypy._cache.known_code
- cls._setup_done = True
- _setup = classmethod(_setup)
-
-
-def gethostname(_cache=[]):
- if not _cache:
- try:
- import socket
- hostname = socket.gethostname()
- except:
- hostname = ''
- _cache.append(hostname)
- return _cache[0]
-
-def get_tmp_file_name(fname):
- return '%s~%s~%d' % (fname, gethostname(), os.getpid())
-
-def rename_tmp_to_eventual_file_name(fname):
- # generated files are first written to the host- and process-specific
- # file 'tmpname', and then atomically moved to their final 'fname'
- # to avoid problems if py.py is started several times in parallel
- tmpname = get_tmp_file_name(fname)
- try:
- os.rename(tmpname, fname)
- except (OSError, IOError):
- os.unlink(fname) # necessary on Windows
- os.rename(tmpname, fname)
-
# ____________________________________________________________
def appdef(source, applevel=ApplevelClass, filename=None):
@@ -1190,11 +1030,6 @@
return build_applevel_dict(self, space)
-class applevelinterp_temp(ApplevelClass):
- hidden_applevel = False
- def getwdict(self, space): # no cache
- return PyPyCacheDir.build_applevelinterp_dict(self, space)
-
# app2interp_temp is used for testing mainly
def app2interp_temp(func, applevel_temp=applevel_temp, filename=None):
""" NOT_RPYTHON """
diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -1437,11 +1437,9 @@
if lastchar.isspace() and lastchar != ' ':
return
file_softspace(stream, True)
- print_item_to._annspecialcase_ = "specialize:argtype(0)"
def print_item(x):
print_item_to(x, sys_stdout())
- print_item._annspecialcase_ = "flowspace:print_item"
def print_newline_to(stream):
stream.write("\n")
@@ -1449,7 +1447,6 @@
def print_newline():
print_newline_to(sys_stdout())
- print_newline._annspecialcase_ = "flowspace:print_newline"
def file_softspace(file, newflag):
try:
diff --git a/pypy/interpreter/test/test_appinterp.py b/pypy/interpreter/test/test_appinterp.py
--- a/pypy/interpreter/test/test_appinterp.py
+++ b/pypy/interpreter/test/test_appinterp.py
@@ -1,6 +1,6 @@
import py
-from pypy.interpreter.gateway import appdef, ApplevelClass, applevel_temp, applevelinterp_temp
+from pypy.interpreter.gateway import appdef, ApplevelClass, applevel_temp
from pypy.interpreter.error import OperationError
def test_execwith_novars(space):
@@ -82,9 +82,6 @@
w_res = g(space, space.wrap(10), space.wrap(1))
assert space.eq_w(w_res, space.wrap(-9))
-def test_applevelinterp_functions(space):
- test_applevel_functions(space, applevel_temp = applevelinterp_temp)
-
def test_applevel_class(space, applevel_temp = applevel_temp):
app = applevel_temp('''
class C(object):
@@ -99,9 +96,6 @@
w_clsattr = space.getattr(c, space.wrap('attr'))
assert space.eq_w(w_clsattr, space.wrap(17))
-def test_applevelinterp_class(space):
- test_applevel_class(space, applevel_temp = applevelinterp_temp)
-
def app_test_something_at_app_level():
x = 2
assert x/2 == 1
@@ -161,7 +155,7 @@
w_str = space1.getattr(w_mymod1, space1.wrap("hi"))
assert space1.str_w(w_str) == "hello"
- def test_geninterp_can_unfreeze(self):
+ def test_random_stuff_can_unfreeze(self):
# When a module contains an "import" statement in applevel code, the
# imported module is initialized, possibly after it has been already
# frozen.
diff --git a/pypy/interpreter/test/test_gateway.py b/pypy/interpreter/test/test_gateway.py
--- a/pypy/interpreter/test/test_gateway.py
+++ b/pypy/interpreter/test/test_gateway.py
@@ -102,14 +102,6 @@
g3 = gateway.app2interp_temp(noapp_g3, gateway.applevel_temp)
assert self.space.eq_w(g3(self.space, w('foo'), w('bar')), w('foobar'))
- def test_app2interp2(self):
- """same but using transformed code"""
- w = self.space.wrap
- def noapp_g3(a, b):
- return a+b
- g3 = gateway.app2interp_temp(noapp_g3, gateway.applevelinterp_temp)
- assert self.space.eq_w(g3(self.space, w('foo'), w('bar')), w('foobar'))
-
def test_app2interp_general_args(self):
w = self.space.wrap
def app_general(x, *args, **kwds):
diff --git a/pypy/jit/backend/llsupport/test/test_gc.py b/pypy/jit/backend/llsupport/test/test_gc.py
--- a/pypy/jit/backend/llsupport/test/test_gc.py
+++ b/pypy/jit/backend/llsupport/test/test_gc.py
@@ -11,6 +11,7 @@
from pypy.jit.tool.oparser import parse
from pypy.rpython.lltypesystem.rclass import OBJECT, OBJECT_VTABLE
from pypy.jit.metainterp.optimizeopt.util import equaloplists
+from pypy.rlib.rarithmetic import is_valid_int
def test_boehm():
gc_ll_descr = GcLLDescr_boehm(None, None, None)
@@ -103,7 +104,7 @@
gcrootmap.put(retaddr, shapeaddr)
assert gcrootmap._gcmap[0] == retaddr
assert gcrootmap._gcmap[1] == shapeaddr
- p = rffi.cast(rffi.LONGP, gcrootmap.gcmapstart())
+ p = rffi.cast(rffi.SIGNEDP, gcrootmap.gcmapstart())
assert p[0] == retaddr
assert (gcrootmap.gcmapend() ==
gcrootmap.gcmapstart() + rffi.sizeof(lltype.Signed) * 2)
@@ -419,9 +420,9 @@
assert newops[0].getarg(1) == v_value
assert newops[0].result is None
wbdescr = newops[0].getdescr()
- assert isinstance(wbdescr.jit_wb_if_flag, int)
- assert isinstance(wbdescr.jit_wb_if_flag_byteofs, int)
- assert isinstance(wbdescr.jit_wb_if_flag_singlebyte, int)
+ assert is_valid_int(wbdescr.jit_wb_if_flag)
+ assert is_valid_int(wbdescr.jit_wb_if_flag_byteofs)
+ assert is_valid_int(wbdescr.jit_wb_if_flag_singlebyte)
def test_get_rid_of_debug_merge_point(self):
operations = [
diff --git a/pypy/jit/backend/test/support.py b/pypy/jit/backend/test/support.py
--- a/pypy/jit/backend/test/support.py
+++ b/pypy/jit/backend/test/support.py
@@ -3,6 +3,7 @@
from pypy.rlib.debug import debug_print
from pypy.translator.translator import TranslationContext, graphof
from pypy.jit.metainterp.optimizeopt import ALL_OPTS_NAMES
+from pypy.rlib.rarithmetic import is_valid_int
class BaseCompiledMixin(object):
@@ -24,7 +25,7 @@
from pypy.annotation import model as annmodel
for arg in args:
- assert isinstance(arg, int)
+ assert is_valid_int(arg)
self.pre_translation_hook()
t = self._get_TranslationContext()
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -1185,14 +1185,14 @@
def bhimpl_getinteriorfield_gc_f(cpu, array, index, descr):
return cpu.bh_getinteriorfield_gc_f(array, index, descr)
- @arguments("cpu", "r", "i", "d", "i")
- def bhimpl_setinteriorfield_gc_i(cpu, array, index, descr, value):
+ @arguments("cpu", "r", "i", "i", "d")
+ def bhimpl_setinteriorfield_gc_i(cpu, array, index, value, descr):
cpu.bh_setinteriorfield_gc_i(array, index, descr, value)
- @arguments("cpu", "r", "i", "d", "r")
- def bhimpl_setinteriorfield_gc_r(cpu, array, index, descr, value):
+ @arguments("cpu", "r", "i", "r", "d")
+ def bhimpl_setinteriorfield_gc_r(cpu, array, index, value, descr):
cpu.bh_setinteriorfield_gc_r(array, index, descr, value)
- @arguments("cpu", "r", "i", "d", "f")
- def bhimpl_setinteriorfield_gc_f(cpu, array, index, descr, value):
+ @arguments("cpu", "r", "i", "f", "d")
+ def bhimpl_setinteriorfield_gc_f(cpu, array, index, value, descr):
cpu.bh_setinteriorfield_gc_f(array, index, descr, value)
@arguments("cpu", "r", "d", returns="i")
diff --git a/pypy/jit/metainterp/test/test_ajit.py b/pypy/jit/metainterp/test/test_ajit.py
--- a/pypy/jit/metainterp/test/test_ajit.py
+++ b/pypy/jit/metainterp/test/test_ajit.py
@@ -3784,6 +3784,15 @@
assert res == 11 * 12 * 13
self.check_operations_history(int_add=3, int_mul=2)
+ def test_setinteriorfield(self):
+ A = lltype.GcArray(lltype.Struct('S', ('x', lltype.Signed)))
+ a = lltype.malloc(A, 5, immortal=True)
+ def g(n):
+ a[n].x = n + 2
+ return a[n].x
+ res = self.interp_operations(g, [1])
+ assert res == 3
+
class TestLLtype(BaseLLtypeTests, LLJitMixin):
def test_tagged(self):
diff --git a/pypy/jit/metainterp/test/test_list.py b/pypy/jit/metainterp/test/test_list.py
--- a/pypy/jit/metainterp/test/test_list.py
+++ b/pypy/jit/metainterp/test/test_list.py
@@ -232,6 +232,7 @@
def test_newlist_hint(self):
def f(i):
l = newlist_hint(i)
+ l[0] = 55
return len(l)
r = self.interp_operations(f, [3])
diff --git a/pypy/module/__builtin__/app_inspect.py b/pypy/module/__builtin__/app_inspect.py
--- a/pypy/module/__builtin__/app_inspect.py
+++ b/pypy/module/__builtin__/app_inspect.py
@@ -8,8 +8,6 @@
from __pypy__ import lookup_special
def _caller_locals():
- # note: the reason why this is working is because the functions in here are
- # compiled by geninterp, so they don't have a frame
return sys._getframe(0).f_locals
def vars(*obj):
@@ -26,17 +24,6 @@
except AttributeError:
raise TypeError("vars() argument must have __dict__ attribute")
-# Replaced by the interp-level helper space.callable():
-##def callable(ob):
-## import __builtin__ # XXX this is insane but required for now for geninterp
-## for c in type(ob).__mro__:
-## if '__call__' in c.__dict__:
-## if isinstance(ob, __builtin__._instance): # old style instance!
-## return getattr(ob, '__call__', None) is not None
-## return True
-## else:
-## return False
-
def dir(*args):
"""dir([object]) -> list of strings
diff --git a/pypy/module/_multiprocessing/test/test_semaphore.py b/pypy/module/_multiprocessing/test/test_semaphore.py
--- a/pypy/module/_multiprocessing/test/test_semaphore.py
+++ b/pypy/module/_multiprocessing/test/test_semaphore.py
@@ -1,7 +1,6 @@
from pypy.conftest import gettestobjspace
from pypy.module._multiprocessing.interp_semaphore import (
RECURSIVE_MUTEX, SEMAPHORE)
-from pypy.rlib.rarithmetic import is_valid_int
class AppTestSemaphore:
@@ -22,7 +21,7 @@
sem = SemLock(kind, value, maxvalue)
assert sem.kind == kind
assert sem.maxvalue == maxvalue
- assert is_valid_int(sem.handle)
+ assert isinstance(sem.handle, (int, long))
assert sem._count() == 0
if sys.platform == 'darwin':
diff --git a/pypy/module/cpyext/api.py b/pypy/module/cpyext/api.py
--- a/pypy/module/cpyext/api.py
+++ b/pypy/module/cpyext/api.py
@@ -823,6 +823,8 @@
pypy_decls.append("#ifdef __cplusplus")
pypy_decls.append("extern \"C\" {")
pypy_decls.append("#endif\n")
+ pypy_decls.append('#define Signed long /* xxx temporary fix */\n')
+ pypy_decls.append('#define Unsigned unsigned long /* xxx temporary fix */\n')
for decl in FORWARD_DECLS:
pypy_decls.append("%s;" % (decl,))
@@ -854,6 +856,8 @@
typ = 'PyObject*'
pypy_decls.append('PyAPI_DATA(%s) %s;' % (typ, name))
+ pypy_decls.append('#undef Signed /* xxx temporary fix */\n')
+ pypy_decls.append('#undef Unsigned /* xxx temporary fix */\n')
pypy_decls.append("#ifdef __cplusplus")
pypy_decls.append("}")
pypy_decls.append("#endif")
diff --git a/pypy/module/cpyext/stringobject.py b/pypy/module/cpyext/stringobject.py
--- a/pypy/module/cpyext/stringobject.py
+++ b/pypy/module/cpyext/stringobject.py
@@ -130,6 +130,11 @@
@cpython_api([PyObject], rffi.CCHARP, error=0)
def PyString_AsString(space, ref):
+ if from_ref(space, rffi.cast(PyObject, ref.c_ob_type)) is space.w_str:
+ pass # typecheck returned "ok" without forcing 'ref' at all
+ elif not PyString_Check(space, ref): # otherwise, use the alternate way
+ raise OperationError(space.w_TypeError, space.wrap(
+ "PyString_AsString only support strings"))
ref_str = rffi.cast(PyStringObject, ref)
if not ref_str.c_buffer:
# copy string buffer
diff --git a/pypy/module/cpyext/test/test_longobject.py b/pypy/module/cpyext/test/test_longobject.py
--- a/pypy/module/cpyext/test/test_longobject.py
+++ b/pypy/module/cpyext/test/test_longobject.py
@@ -101,9 +101,9 @@
space.wrap((2, 7)))):
py.test.skip("unsupported before Python 2.7")
- assert api._PyLong_Sign(space.wrap(0L)) == 0
- assert api._PyLong_Sign(space.wrap(2L)) == 1
- assert api._PyLong_Sign(space.wrap(-2L)) == -1
+ assert api._PyLong_Sign(space.wraplong(0L)) == 0
+ assert api._PyLong_Sign(space.wraplong(2L)) == 1
+ assert api._PyLong_Sign(space.wraplong(-2L)) == -1
assert api._PyLong_NumBits(space.wrap(0)) == 0
assert api._PyLong_NumBits(space.wrap(1)) == 1
diff --git a/pypy/module/cpyext/test/test_number.py b/pypy/module/cpyext/test/test_number.py
--- a/pypy/module/cpyext/test/test_number.py
+++ b/pypy/module/cpyext/test/test_number.py
@@ -6,12 +6,12 @@
class TestIterator(BaseApiTest):
def test_check(self, space, api):
assert api.PyIndex_Check(space.wrap(12))
- assert api.PyIndex_Check(space.wrap(-12L))
+ assert api.PyIndex_Check(space.wraplong(-12L))
assert not api.PyIndex_Check(space.wrap(12.1))
assert not api.PyIndex_Check(space.wrap('12'))
assert api.PyNumber_Check(space.wrap(12))
- assert api.PyNumber_Check(space.wrap(-12L))
+ assert api.PyNumber_Check(space.wraplong(-12L))
assert api.PyNumber_Check(space.wrap(12.1))
assert not api.PyNumber_Check(space.wrap('12'))
assert not api.PyNumber_Check(space.wrap(1+3j))
@@ -21,7 +21,7 @@
assert api.PyLong_CheckExact(w_l)
def test_number_int(self, space, api):
- w_l = api.PyNumber_Int(space.wrap(123L))
+ w_l = api.PyNumber_Int(space.wraplong(123L))
assert api.PyInt_CheckExact(w_l)
w_l = api.PyNumber_Int(space.wrap(2 << 65))
assert api.PyLong_CheckExact(w_l)
@@ -29,7 +29,7 @@
assert api.PyInt_CheckExact(w_l)
def test_number_index(self, space, api):
- w_l = api.PyNumber_Index(space.wrap(123L))
+ w_l = api.PyNumber_Index(space.wraplong(123L))
assert api.PyLong_CheckExact(w_l)
w_l = api.PyNumber_Index(space.wrap(42.3))
assert w_l is None
diff --git a/pypy/module/pypyjit/policy.py b/pypy/module/pypyjit/policy.py
--- a/pypy/module/pypyjit/policy.py
+++ b/pypy/module/pypyjit/policy.py
@@ -138,8 +138,6 @@
if mod == 'pypy.rlib.rbigint' or mod == 'pypy.rlib.rlocale' or mod == 'pypy.rlib.rsocket':
return False
- if '_geninterp_' in func.func_globals: # skip all geninterped stuff
- return False
if mod.startswith('pypy.interpreter.astcompiler.'):
return False
if mod.startswith('pypy.interpreter.pyparser.'):
diff --git a/pypy/module/pypyjit/test/test_policy.py b/pypy/module/pypyjit/test/test_policy.py
--- a/pypy/module/pypyjit/test/test_policy.py
+++ b/pypy/module/pypyjit/test/test_policy.py
@@ -14,12 +14,6 @@
from pypy.rlib.rlocale import setlocale
assert not pypypolicy.look_inside_function(setlocale)
-def test_geninterp():
- d = {'_geninterp_': True}
- exec """def f():
- pass""" in d
- assert not pypypolicy.look_inside_function(d['f'])
-
def test_astcompiler():
from pypy.interpreter.astcompiler import ast
assert not pypypolicy.look_inside_function(ast.AST.walkabout)
diff --git a/pypy/module/rbench/__init__.py b/pypy/module/rbench/__init__.py
deleted file mode 100644
--- a/pypy/module/rbench/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# Package initialisation
-from pypy.interpreter.mixedmodule import MixedModule
-
-class Module(MixedModule):
- """geninterpreted benchmarks"""
-
- appleveldefs = {
- 'pystone': 'app_bench.pystone',
- 'richards': 'app_bench.richards',
- }
-
- interpleveldefs = {}
diff --git a/pypy/module/rbench/app_bench.py b/pypy/module/rbench/app_bench.py
deleted file mode 100644
--- a/pypy/module/rbench/app_bench.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from pypy.translator.test.rpystone import main as pystone
-from pypy.translator.goal.richards import main as richards
diff --git a/pypy/objspace/flow/objspace.py b/pypy/objspace/flow/objspace.py
--- a/pypy/objspace/flow/objspace.py
+++ b/pypy/objspace/flow/objspace.py
@@ -105,7 +105,7 @@
is_ = None # real version added by add_operations()
id = None # real version added by add_operations()
- def newdict(self):
+ def newdict(self, module="ignored"):
if self.concrete_mode:
return Constant({})
return self.do_operation('newdict')
@@ -223,10 +223,8 @@
except UnwrapException:
raise Exception, "non-constant except guard"
if check_class in (NotImplementedError, AssertionError):
- # if we are in geninterp, we cannot catch these exceptions
- if not self.config.translation.builtins_can_raise_exceptions:
- raise error.FlowingError("Catching %s is not valid in RPython" %
- check_class.__name__)
+ raise error.FlowingError("Catching %s is not valid in RPython" %
+ check_class.__name__)
if not isinstance(check_class, tuple):
# the simple case
return ObjSpace.exception_match(self, w_exc_type, w_check_class)
@@ -440,41 +438,33 @@
exceptions = [Exception] # *any* exception by default
if isinstance(w_callable, Constant):
c = w_callable.value
- if not self.config.translation.builtins_can_raise_exceptions:
- if (isinstance(c, (types.BuiltinFunctionType,
- types.BuiltinMethodType,
- types.ClassType,
- types.TypeType)) and
- c.__module__ in ['__builtin__', 'exceptions']):
- exceptions = operation.implicit_exceptions.get(c)
+ if (isinstance(c, (types.BuiltinFunctionType,
+ types.BuiltinMethodType,
+ types.ClassType,
+ types.TypeType)) and
+ c.__module__ in ['__builtin__', 'exceptions']):
+ exceptions = operation.implicit_exceptions.get(c)
self.handle_implicit_exceptions(exceptions)
return w_res
def handle_implicit_exceptions(self, exceptions):
if not exceptions:
return
- if not self.config.translation.builtins_can_raise_exceptions:
- # clean up 'exceptions' by removing the non-RPythonic exceptions
- # which might be listed for geninterp.
- exceptions = [exc for exc in exceptions
- if exc is not TypeError and
- exc is not AttributeError]
- if exceptions:
- # catch possible exceptions implicitly. If the OperationError
- # below is not caught in the same function, it will produce an
- # exception-raising return block in the flow graph. Note that
- # even if the interpreter re-raises the exception, it will not
- # be the same ImplicitOperationError instance internally.
- context = self.getexecutioncontext()
- outcome, w_exc_cls, w_exc_value = context.guessexception(*exceptions)
- if outcome is not None:
- # we assume that the caught exc_cls will be exactly the
- # one specified by 'outcome', and not a subclass of it,
- # unless 'outcome' is Exception.
- #if outcome is not Exception:
- #w_exc_cls = Constant(outcome) Now done by guessexception itself
- #pass
- raise operation.ImplicitOperationError(w_exc_cls, w_exc_value)
+ # catch possible exceptions implicitly. If the OperationError
+ # below is not caught in the same function, it will produce an
+ # exception-raising return block in the flow graph. Note that
+ # even if the interpreter re-raises the exception, it will not
+ # be the same ImplicitOperationError instance internally.
+ context = self.getexecutioncontext()
+ outcome, w_exc_cls, w_exc_value = context.guessexception(*exceptions)
+ if outcome is not None:
+ # we assume that the caught exc_cls will be exactly the
+ # one specified by 'outcome', and not a subclass of it,
+ # unless 'outcome' is Exception.
+ #if outcome is not Exception:
+ #w_exc_cls = Constant(outcome) Now done by guessexception itself
+ #pass
+ raise operation.ImplicitOperationError(w_exc_cls, w_exc_value)
def w_KeyboardInterrupt(self):
# the reason to do this is: if you interrupt the flowing of a function
diff --git a/pypy/objspace/flow/operation.py b/pypy/objspace/flow/operation.py
--- a/pypy/objspace/flow/operation.py
+++ b/pypy/objspace/flow/operation.py
@@ -262,8 +262,6 @@
OverflowError: 'ovf',
IndexError: 'idx',
KeyError: 'key',
- AttributeError: 'att',
- TypeError: 'typ',
ZeroDivisionError: 'zer',
ValueError: 'val',
}
@@ -298,11 +296,6 @@
lis.append(OverflowError)
implicit_exceptions[name+"_ovf"] = lis
-for _name in 'getattr', 'delattr':
- _add_exceptions(_name, AttributeError)
-del _name
-
-_add_exceptions('iter', TypeError)
_add_exceptions("""div mod divmod truediv floordiv pow
inplace_div inplace_mod inplace_divmod inplace_truediv
inplace_floordiv inplace_pow""", ZeroDivisionError)
diff --git a/pypy/objspace/flow/specialcase.py b/pypy/objspace/flow/specialcase.py
--- a/pypy/objspace/flow/specialcase.py
+++ b/pypy/objspace/flow/specialcase.py
@@ -49,35 +49,9 @@
else:
raise Exception, "should call %r with exactly %d arguments" % (
fn, Arity[opname])
- if space.config.translation.builtins_can_raise_exceptions:
- # in this mode, avoid constant folding and raise an implicit Exception
- w_result = space.do_operation(opname, *args_w)
- space.handle_implicit_exceptions([Exception])
- return w_result
- else:
- # in normal mode, completely replace the call with the underlying
- # operation and its limited implicit exceptions semantic
- return getattr(space, opname)(*args_w)
-
-
-# This is not a space cache.
-# It is just collecting the compiled functions from all the source snippets.
-
-class FunctionCache(Cache):
- """A cache mapping applevel instances to dicts with simple functions"""
-
- def _build(app):
- """NOT_RPYTHON.
- Called indirectly by ApplevelClass.interphook().appcaller()."""
- dic = {}
- if not app.can_use_geninterp:
- return None
- if app.filename is not None:
- dic['__file__'] = app.filename
- dic['__name__'] = app.modname
- exec py.code.Source(app.source).compile() in dic
- return dic
- _build = staticmethod(_build)
+ # completely replace the call with the underlying
+ # operation and its limited implicit exceptions semantic
+ return getattr(space, opname)(*args_w)
# _________________________________________________________________________
# a simplified version of the basic printing routines, for RPython programs
@@ -99,29 +73,21 @@
s = '\n'
import os
os.write(1, s)
-# _________________________________________________________________________
-
-compiled_funcs = FunctionCache()
def sc_applevel(space, app, name, args_w):
- dic = compiled_funcs.getorbuild(app)
- if not dic:
- return None # signal that this is not RPython
- func = dic[name]
- if getattr(func, '_annspecialcase_', '').startswith('flowspace:'):
- # a hack to replace specific app-level helpers with simplified
- # RPython versions
- name = func._annspecialcase_[len('flowspace:'):]
- if name == 'print_item': # more special cases...
- w_s = space.do_operation('str', *args_w)
- args_w = (w_s,)
- func = globals()['rpython_' + name]
+ # special case only for print_item and print_newline
+ if 'pyopcode' in app.filename and name == 'print_item':
+ w_s = space.do_operation('str', *args_w)
+ args_w = (w_s,)
+ elif 'pyopcode' in app.filename and name == 'print_newline':
+ pass
else:
- # otherwise, just call the app-level helper and hope that it
- # is RPython enough
- pass
+ raise Exception("not RPython: calling %r from %r" % (name, app))
+ func = globals()['rpython_' + name]
return space.do_operation('simple_call', Constant(func), *args_w)
+# _________________________________________________________________________
+
def sc_r_uint(space, r_uint, args):
args_w, kwds_w = args.unpack()
assert not kwds_w
diff --git a/pypy/objspace/flow/test/test_objspace.py b/pypy/objspace/flow/test/test_objspace.py
--- a/pypy/objspace/flow/test/test_objspace.py
+++ b/pypy/objspace/flow/test/test_objspace.py
@@ -968,61 +968,6 @@
g = self.codetest(f)
-class TestGenInterpStyle(Base):
- def setup_class(cls):
- cls.space = FlowObjSpace()
- cls.space.config.translation.builtins_can_raise_exceptions = True
-
- def reraiseAttributeError(v):
- try:
- x = getattr(v, "y")
- except AttributeError:
- raise
-
- def test_reraiseAttributeError(self):
- x = self.codetest(self.reraiseAttributeError)
- simplify_graph(x)
- self.show(x)
- excfound = []
- for link in x.iterlinks():
- if link.target is x.exceptblock:
- excfound.append(link.exitcase)
- assert len(excfound) == 2
- excfound.sort()
- expected = [Exception, AttributeError]
- expected.sort()
- assert excfound == expected
-
- def reraiseTypeError(dic):
- try:
- x = dic[5]
- except TypeError:
- raise
-
- def test_reraiseTypeError(self):
- x = self.codetest(self.reraiseTypeError)
- simplify_graph(x)
- self.show(x)
- excfound = []
- for link in x.iterlinks():
- if link.target is x.exceptblock:
- excfound.append(link.exitcase)
- assert len(excfound) == 2
- excfound.sort()
- expected = [Exception, TypeError]
- expected.sort()
- assert excfound == expected
-
- def test_can_catch_special_exceptions(self):
- def f():
- try:
- f()
- except NotImplementedError:
- pass
- graph = self.codetest(f)
- # assert did not crash
-
-
DATA = {'x': 5,
'y': 6}
diff --git a/pypy/objspace/std/intobject.py b/pypy/objspace/std/intobject.py
--- a/pypy/objspace/std/intobject.py
+++ b/pypy/objspace/std/intobject.py
@@ -6,7 +6,7 @@
from pypy.objspace.std.noneobject import W_NoneObject
from pypy.objspace.std.register_all import register_all
from pypy.rlib import jit
-from pypy.rlib.rarithmetic import ovfcheck, LONG_BIT, r_uint
+from pypy.rlib.rarithmetic import ovfcheck, LONG_BIT, r_uint, is_valid_int
from pypy.rlib.rbigint import rbigint
"""
@@ -42,6 +42,7 @@
from pypy.objspace.std.longtype import long_typedef as typedef
def __init__(w_self, intval):
+ assert is_valid_int(intval)
w_self.intval = intval
def __repr__(w_self):
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -9,7 +9,7 @@
from pypy.objspace.descroperation import DescrOperation, raiseattrerror
from pypy.rlib.objectmodel import instantiate, r_dict, specialize, is_annotation_constant
from pypy.rlib.debug import make_sure_not_resized
-from pypy.rlib.rarithmetic import base_int, widen, maxint
+from pypy.rlib.rarithmetic import base_int, widen, maxint, is_valid_int
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib import jit
@@ -168,10 +168,6 @@
return self.newbool(x)
else:
return self.newint(x)
- # this is an inlined 'is_valid_int' which cannot be used
- # due to the special annotation nature of 'wrap'.
- if isinstance(x, long) and (-maxint - 1 <= x <= maxint):
- return self.newint(x)
if isinstance(x, str):
return wrapunicode(self, x.decode('ascii'))
if isinstance(x, unicode):
@@ -202,6 +198,11 @@
"NOT_RPYTHON"
# _____ this code is here to support testing only _____
+ # we might get there in non-translated versions if 'x' is
+ # a long that fits the correct range.
+ if is_valid_int(x):
+ return self.newint(x)
+
# wrap() of a container works on CPython, but the code is
# not RPython. Don't use -- it is kept around mostly for tests.
# Use instead newdict(), newlist(), newtuple().
@@ -220,17 +221,7 @@
# The following cases are even stranger.
# Really really only for tests.
if type(x) is long:
- if self.config.objspace.std.withsmalllong:
- from pypy.rlib.rarithmetic import r_longlong
- try:
- rx = r_longlong(x)
- except OverflowError:
- pass
- else:
- from pypy.objspace.std.smalllongobject import \
- W_SmallLongObject
- return W_SmallLongObject(rx)
- return W_LongObject.fromlong(x)
+ return self.wraplong(x)
if isinstance(x, slice):
return W_SliceObject(self.wrap(x.start),
self.wrap(x.stop),
@@ -271,6 +262,20 @@
return w_result
return None
+ def wraplong(self, x):
+ "NOT_RPYTHON"
+ if self.config.objspace.std.withsmalllong:
+ from pypy.rlib.rarithmetic import r_longlong
+ try:
+ rx = r_longlong(x)
+ except OverflowError:
+ pass
+ else:
+ from pypy.objspace.std.smalllongobject import \
+ W_SmallLongObject
+ return W_SmallLongObject(rx)
+ return W_LongObject.fromlong(x)
+
def unwrap(self, w_obj):
"""NOT_RPYTHON"""
if isinstance(w_obj, Wrappable):
diff --git a/pypy/objspace/std/test/test_stringobject.py b/pypy/objspace/std/test/test_stringobject.py
--- a/pypy/objspace/std/test/test_stringobject.py
+++ b/pypy/objspace/std/test/test_stringobject.py
@@ -531,6 +531,8 @@
# Need default encoding utf-8, but sys.setdefaultencoding
# is removed after startup.
import sys
+ if not hasattr(sys, 'setdefaultencoding'):
+ skip("sys.setdefaultencoding() not available")
old_encoding = sys.getdefaultencoding()
# Duplicate unittest.test_support.CleanImport logic because it won't
# import.
diff --git a/pypy/rlib/rarithmetic.py b/pypy/rlib/rarithmetic.py
--- a/pypy/rlib/rarithmetic.py
+++ b/pypy/rlib/rarithmetic.py
@@ -92,7 +92,10 @@
We therefore can no longer use the int type as it is, but need
to use long everywhere.
"""
-
+
+# XXX returning int(n) should not be necessary and should be simply n.
+# XXX TODO: replace all int(n) by long(n) and fix everything that breaks.
+# XXX Then relax it and replace int(n) by n.
def intmask(n):
if isinstance(n, objectmodel.Symbolic):
return n # assume Symbolics don't overflow
@@ -137,8 +140,11 @@
maxint = int(LONG_TEST - 1)
def is_valid_int(r):
- return isinstance(r, (int, long)) and (
+ if objectmodel.we_are_translated():
+ return isinstance(r, int)
+ return type(r) in (int, long, bool) and (
-maxint - 1 <= r <= maxint)
+is_valid_int._annspecialcase_ = 'specialize:argtype(0)'
def ovfcheck(r):
"NOT_RPYTHON"
diff --git a/pypy/rlib/rzlib.py b/pypy/rlib/rzlib.py
--- a/pypy/rlib/rzlib.py
+++ b/pypy/rlib/rzlib.py
@@ -1,6 +1,7 @@
from __future__ import with_statement
import sys
+from pypy.rlib import rgc
from pypy.rlib.rstring import StringBuilder
from pypy.rpython.lltypesystem import rffi, lltype
from pypy.rpython.tool import rffi_platform
@@ -236,6 +237,7 @@
compress data.
"""
stream = lltype.malloc(z_stream, flavor='raw', zero=True)
+ rgc.add_memory_pressure(rffi.sizeof(z_stream))
err = _deflateInit2(stream, level, method, wbits, memLevel, strategy)
if err == Z_OK:
return stream
@@ -264,6 +266,7 @@
decompress data.
"""
stream = lltype.malloc(z_stream, flavor='raw', zero=True)
+ rgc.add_memory_pressure(rffi.sizeof(z_stream))
err = _inflateInit2(stream, wbits)
if err == Z_OK:
return stream
diff --git a/pypy/rlib/test/test_rarithmetic.py b/pypy/rlib/test/test_rarithmetic.py
--- a/pypy/rlib/test/test_rarithmetic.py
+++ b/pypy/rlib/test/test_rarithmetic.py
@@ -330,6 +330,15 @@
return a == b
py.test.raises(MissingRTypeOperation, "self.interpret(f, [42.0])")
+ def test_is_valid_int(self):
+ def f(x):
+ return (is_valid_int(x) * 4 +
+ is_valid_int(x > 0) * 2 +
+ is_valid_int(x + 0.5))
+ assert f(123) == 4 + 2
+ res = self.interpret(f, [123])
+ assert res == 4 + 2
+
class TestLLtype(BaseTestRarithmetic, LLRtypeMixin):
pass
diff --git a/pypy/rpython/llinterp.py b/pypy/rpython/llinterp.py
--- a/pypy/rpython/llinterp.py
+++ b/pypy/rpython/llinterp.py
@@ -1,6 +1,6 @@
from pypy.objspace.flow.model import FunctionGraph, Constant, Variable, c_last_exception
from pypy.rlib.rarithmetic import intmask, r_uint, ovfcheck, r_longlong
-from pypy.rlib.rarithmetic import r_ulonglong
+from pypy.rlib.rarithmetic import r_ulonglong, is_valid_int
from pypy.rpython.lltypesystem import lltype, llmemory, lloperation, llheap
from pypy.rpython.lltypesystem import rclass
from pypy.rpython.ootypesystem import ootype
@@ -1021,22 +1021,22 @@
# Overflow-detecting variants
def op_int_neg_ovf(self, x):
- assert type(x) is int
+ assert is_valid_int(x)
try:
return ovfcheck(-x)
except OverflowError:
self.make_llexception()
def op_int_abs_ovf(self, x):
- assert type(x) is int
+ assert is_valid_int(x)
try:
return ovfcheck(abs(x))
except OverflowError:
self.make_llexception()
def op_int_lshift_ovf(self, x, y):
- assert isinstance(x, int)
- assert isinstance(y, int)
+ assert is_valid_int(x)
+ assert is_valid_int(y)
try:
return ovfcheck(x << y)
except OverflowError:
@@ -1060,7 +1060,9 @@
return r
'''%locals()
elif operator == '%':
- code = '''r = %(checkfn)s(x %% y)
+ ## overflow check on % does not work with emulated int
+ code = '''%(checkfn)s(x // y)
+ r = x %% y
if x^y < 0 and x%%y != 0:
r -= y
return r
@@ -1077,15 +1079,15 @@
self.make_llexception()
""" % locals()).compile() in globals(), d
- _makefunc2('op_int_add_ovf', '+', '(int, llmemory.AddressOffset)')
- _makefunc2('op_int_mul_ovf', '*', '(int, llmemory.AddressOffset)', 'int')
- _makefunc2('op_int_sub_ovf', '-', 'int')
- _makefunc2('op_int_floordiv_ovf', '//', 'int') # XXX negative args
- _makefunc2('op_int_floordiv_zer', '//', 'int') # can get off-by-one
- _makefunc2('op_int_floordiv_ovf_zer', '//', 'int') # (see op_int_floordiv)
- _makefunc2('op_int_mod_ovf', '%', 'int')
- _makefunc2('op_int_mod_zer', '%', 'int')
- _makefunc2('op_int_mod_ovf_zer', '%', 'int')
+ _makefunc2('op_int_add_ovf', '+', '(int, long, llmemory.AddressOffset)')
+ _makefunc2('op_int_mul_ovf', '*', '(int, long, llmemory.AddressOffset)', '(int, long)')
+ _makefunc2('op_int_sub_ovf', '-', '(int, long)')
+ _makefunc2('op_int_floordiv_ovf', '//', '(int, long)') # XXX negative args
+ _makefunc2('op_int_floordiv_zer', '//', '(int, long)') # can get off-by-one
+ _makefunc2('op_int_floordiv_ovf_zer', '//', '(int, long)') # (see op_int_floordiv)
+ _makefunc2('op_int_mod_ovf', '%', '(int, long)')
+ _makefunc2('op_int_mod_zer', '%', '(int, long)')
+ _makefunc2('op_int_mod_ovf_zer', '%', '(int, long)')
_makefunc2('op_uint_floordiv_zer', '//', 'r_uint')
_makefunc2('op_uint_mod_zer', '%', 'r_uint')
@@ -1107,7 +1109,7 @@
x = x.default
# if type(x) is a subclass of Symbolic, bool(x) will usually raise
# a TypeError -- unless __nonzero__ has been explicitly overridden.
- assert isinstance(x, (int, Symbolic))
+ assert is_valid_int(x) or isinstance(x, Symbolic)
return bool(x)
# hack for jit.codegen.llgraph
@@ -1129,7 +1131,7 @@
def op_oonewarray(self, ARRAY, length):
assert isinstance(ARRAY, ootype.Array)
- assert isinstance(length, int)
+ assert is_valid_int(length)
return ootype.oonewarray(ARRAY, length)
def op_runtimenew(self, class_):
diff --git a/pypy/rpython/lltypesystem/llmemory.py b/pypy/rpython/lltypesystem/llmemory.py
--- a/pypy/rpython/lltypesystem/llmemory.py
+++ b/pypy/rpython/lltypesystem/llmemory.py
@@ -8,6 +8,8 @@
from pypy.rlib.objectmodel import Symbolic
from pypy.rpython.lltypesystem import lltype
from pypy.tool.uid import uid
+from pypy.rlib.rarithmetic import is_valid_int
+
class AddressOffset(Symbolic):
@@ -28,7 +30,7 @@
def __ge__(self, other):
if self is other:
return True
- elif (isinstance(other, (int, long)) and other == 0 and
+ elif (is_valid_int(other) and other == 0 and
self.known_nonneg()):
return True
else:
@@ -58,7 +60,7 @@
return "<ItemOffset %r %r>" % (self.TYPE, self.repeat)
def __mul__(self, other):
- if not isinstance(other, int):
+ if not is_valid_int(other):
return NotImplemented
return ItemOffset(self.TYPE, self.repeat * other)
diff --git a/pypy/rpython/memory/gc/test/test_direct.py b/pypy/rpython/memory/gc/test/test_direct.py
--- a/pypy/rpython/memory/gc/test/test_direct.py
+++ b/pypy/rpython/memory/gc/test/test_direct.py
@@ -9,7 +9,7 @@
import py
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.memory.gctypelayout import TypeLayoutBuilder
-from pypy.rlib.rarithmetic import LONG_BIT
+from pypy.rlib.rarithmetic import LONG_BIT, is_valid_int
WORD = LONG_BIT // 8
@@ -286,7 +286,7 @@
p = self.malloc(S)
hash = self.gc.identityhash(p)
print hash
- assert isinstance(hash, (int, long))
+ assert is_valid_int(hash)
assert hash == self.gc.identityhash(p)
self.stackroots.append(p)
for i in range(6):
@@ -299,7 +299,7 @@
self.gc.collect()
hash = self.gc.identityhash(self.stackroots[-1])
print hash
- assert isinstance(hash, (int, long))
+ assert is_valid_int(hash)
for i in range(6):
self.gc.collect()
assert hash == self.gc.identityhash(self.stackroots[-1])
@@ -311,7 +311,7 @@
self.gc.collect()
hash = self.gc.identityhash(self.stackroots[-1])
print hash
- assert isinstance(hash, (int, long))
+ assert is_valid_int(hash)
for i in range(2):
self.gc.collect()
assert hash == self.gc.identityhash(self.stackroots[-1])
@@ -319,7 +319,7 @@
# (4) p is a prebuilt object
hash = self.gc.identityhash(p_const)
print hash
- assert isinstance(hash, (int, long))
+ assert is_valid_int(hash)
assert hash == self.gc.identityhash(p_const)
# (5) p is actually moving (for the markcompact gc)
p0 = self.malloc(S)
diff --git a/pypy/rpython/test/test_llinterp.py b/pypy/rpython/test/test_llinterp.py
--- a/pypy/rpython/test/test_llinterp.py
+++ b/pypy/rpython/test/test_llinterp.py
@@ -353,13 +353,16 @@
try:
return ovfcheck((-sys.maxint - 1) % x)
except OverflowError:
- return 1
+ return 43
except ZeroDivisionError:
- return 0
+ return 42
res = interpret(f, [0])
- assert res == 0
+ assert res == 42
+ # the following test doesn't work any more before translation,
+ # but "too bad" is the best answer I suppose
res = interpret(f, [-1])
- assert res == 1
+ if 0:
+ assert res == 43
res = interpret(f, [30])
assert res == (-sys.maxint - 1) % 30
diff --git a/pypy/rpython/test/test_rbuiltin.py b/pypy/rpython/test/test_rbuiltin.py
--- a/pypy/rpython/test/test_rbuiltin.py
+++ b/pypy/rpython/test/test_rbuiltin.py
@@ -5,7 +5,7 @@
from pypy.rlib.debug import llinterpcall
from pypy.rpython.lltypesystem import lltype
from pypy.tool import udir
-from pypy.rlib.rarithmetic import intmask
+from pypy.rlib.rarithmetic import intmask, is_valid_int
from pypy.rlib.rarithmetic import r_int, r_uint, r_longlong, r_ulonglong
from pypy.annotation.builtin import *
from pypy.rpython.test.tool import BaseRtypingTest, LLRtypeMixin, OORtypeMixin
@@ -567,7 +567,7 @@
if r_longlong is not r_int:
assert isinstance(res, r_longlong)
else:
- assert isinstance(res, int)
+ assert is_valid_int(res)
#
def llfn(v):
return rffi.cast(rffi.ULONGLONG, v)
diff --git a/pypy/translator/c/src/debug_print.c b/pypy/translator/c/src/debug_print.c
--- a/pypy/translator/c/src/debug_print.c
+++ b/pypy/translator/c/src/debug_print.c
@@ -13,6 +13,7 @@
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
+#include "common_header.h"
#include "src/profiling.h"
#include "src/debug_print.h"
diff --git a/pypy/translator/c/test/test_database.py b/pypy/translator/c/test/test_database.py
--- a/pypy/translator/c/test/test_database.py
+++ b/pypy/translator/c/test/test_database.py
@@ -232,7 +232,7 @@
B = Signed
db = LowLevelDatabase()
assert db.gettype(A) == "int @"
- assert db.gettype(B) == "long @"
+ assert db.gettype(B) == "Signed @"
def test_recursive_struct():
diff --git a/pypy/translator/c/test/test_newgc.py b/pypy/translator/c/test/test_newgc.py
--- a/pypy/translator/c/test/test_newgc.py
+++ b/pypy/translator/c/test/test_newgc.py
@@ -675,8 +675,8 @@
gc.collect()
p_a1 = rffi.cast(rffi.VOIDPP, ll_args[0])[0]
p_a2 = rffi.cast(rffi.VOIDPP, ll_args[1])[0]
- a1 = rffi.cast(rffi.LONGP, p_a1)[0]
- a2 = rffi.cast(rffi.LONGP, p_a2)[0]
+ a1 = rffi.cast(rffi.SIGNEDP, p_a1)[0]
+ a2 = rffi.cast(rffi.SIGNEDP, p_a2)[0]
res = rffi.cast(rffi.INTP, ll_res)
if a1 > a2:
res[0] = rffi.cast(rffi.INT, 1)
@@ -692,7 +692,7 @@
ptr = CallbackFuncPtr([ffi_type_pointer, ffi_type_pointer],
ffi_type_sint, callback)
- TP = rffi.CArray(rffi.LONG)
+ TP = rffi.CArray(lltype.Signed)
to_sort = lltype.malloc(TP, 4, flavor='raw')
to_sort[0] = 4
to_sort[1] = 3
@@ -700,7 +700,7 @@
to_sort[3] = 2
qsort.push_arg(rffi.cast(rffi.VOIDP, to_sort))
qsort.push_arg(rffi.cast(rffi.SIZE_T, 4))
- qsort.push_arg(rffi.cast(rffi.SIZE_T, rffi.sizeof(rffi.LONG)))
+ qsort.push_arg(rffi.cast(rffi.SIZE_T, rffi.sizeof(lltype.Signed)))
qsort.push_arg(rffi.cast(rffi.VOIDP, ptr.ll_closure))
qsort.call(lltype.Void)
result = [to_sort[i] for i in range(4)] == [1,2,3,4]
@@ -1202,7 +1202,7 @@
def f():
from pypy.rpython.lltypesystem import lltype, rffi
alist = [A() for i in range(50000)]
- idarray = lltype.malloc(rffi.LONGP.TO, len(alist), flavor='raw')
+ idarray = lltype.malloc(rffi.SIGNEDP.TO, len(alist), flavor='raw')
# Compute the id of all elements of the list. The goal is
# to not allocate memory, so that if the GC needs memory to
# remember the ids, it will trigger some collections itself
diff --git a/pypy/translator/geninterplevel.py b/pypy/translator/geninterplevel.py
deleted file mode 100644
--- a/pypy/translator/geninterplevel.py
+++ /dev/null
@@ -1,1544 +0,0 @@
-"""
-Implementation of a translator from application Python to
-interpreter level RPython.
-
-The idea is that we can automatically transform application level
-implementations of methods into some equivalent representation at
-interpreter level. Then, the RPython to C translation might
-hopefully spit out some more efficient code than always interpreting
-these methods.
-
-Note that the application level functions are treated as rpythonic,
-in a sense that globals are constants, for instance. This definition
-is not exact and might change.
-
-The interface for this module is
-
- (initfunc, newsrc) = translate_as_module(
- sourcetext,
- filename=None,
- modname="app2interpexec",
- tmpname=None)
-
-If filename is given, it is used as a reference where
-this sourcetext can be literally found, to produce
-real line numbers. It cannot be just any name but
-must exist and contain the source code somewhere.
-
-modname is optional and will be put into the dictionary
-to be created.
-
-tmpname is optional. If given, a temporary file will
-be created for debugging purposes.
-
-The returned newsrc is the generated source text.
-It is used in gateway.py's caching mechanism.
-The initfunc result is a function named "init"+modname
-It must be called with a space instance and returns
-a wrapped dict which is suitable to use as a module dict,
-containing all trnaslatedobjects with their originalname.
-
-Integration of this module is finished.
-There are no longer hand-generated source
-pieces in pypy svn.
-"""
-
-import autopath, os, sys, types
-import inspect
-import cPickle as pickle, __builtin__
-from copy_reg import _HEAPTYPE
-from pypy.objspace.flow.model import Variable, Constant, SpaceOperation
-from pypy.objspace.flow.model import c_last_exception, checkgraph
-from pypy.interpreter.pycode import CO_VARARGS, CO_VARKEYWORDS
-from types import FunctionType, CodeType, ModuleType, MethodType
-from pypy.interpreter.error import OperationError
-from pypy.interpreter.argument import ArgumentsForTranslation, Arguments
-from pypy.translator.backendopt.ssa import SSI_to_SSA
-
-from pypy.translator.translator import TranslationContext
-from pypy.objspace.flow.objspace import FlowObjSpace
-
-from pypy.tool.sourcetools import render_docstr, NiceCompile
-
-from pypy.translator.gensupp import ordered_blocks, UniqueList, builtin_base, \
- uniquemodulename, C_IDENTIFIER, NameManager
-from pypy.tool.identity_dict import identity_dict
-
-import pypy # __path__
-import py.path
-from pypy.tool.ansi_print import ansi_log
-
-log = py.log.Producer("geninterp")
-py.log.setconsumer("geninterp", ansi_log)
-
-GI_VERSION = '1.2.9' # bump this for substantial changes
-# ____________________________________________________________
-
-try:
- set
-except NameError:
- class fake_set(object):
- pass
- class fake_frozenset(object):
- pass
- builtin_set = fake_set
- builtin_frozenset = fake_frozenset
- faked_set = True
-else:
- builtin_set = set
- builtin_frozenset = frozenset
- faked_set = False
-
-def eval_helper(self, typename, expr):
- name = self.uniquename("gtype_%s" % typename)
- unique = self.uniquenameofprebuilt("eval_helper", eval_helper)
- self.initcode.append1(
- 'def %s(expr):\n'
- ' dic = space.newdict()\n'
- ' if "types." in expr:\n'
- ' space.exec_("import types", dic, dic, hidden_applevel=True)\n'
- ' else:\n'
- ' space.exec_("", dic, dic, hidden_applevel=True)\n'
- ' return space.eval(expr, dic, dic, hidden_applevel=True)' % (unique, ))
- self.initcode.append1('%s = %s(%r)' % (name, unique, expr))
- return name
-
-def unpickle_helper(self, name, value):
- unique = self.uniquenameofprebuilt("unpickle_helper", unpickle_helper)
- self.initcode.append1(
- 'def %s(value):\n'
- ' dic = space.newdict()\n'
- ' space.exec_("import cPickle as pickle", dic, dic, hidden_applevel=True)\n'
- ' return space.eval("pickle.loads(%%r)" %% value, dic, dic, hidden_applevel=True)' % unique)
- self.initcode.append1('%s = %s(%r)' % (
- name, unique, pickle.dumps(value, 2)) )
-
-# hey, for longs we can do even easier:
-def long_helper(self, name, value):
- unique = self.uniquenameofprebuilt("long_helper", long_helper)
- self.initcode.append1(
- 'def %s(value):\n'
- ' dic = space.newdict()\n'
- ' space.exec_("", dic, dic, hidden_applevel=True) # init __builtins__\n'
- ' return space.eval(value, dic, dic, hidden_applevel=True)' % unique)
- self.initcode.append1('%s = %s(%r)' % (
- name, unique, repr(value) ) )
-
-def bltinmod_helper(self, mod):
- name = self.uniquename("mod_%s" % mod.__name__)
- unique = self.uniquenameofprebuilt("bltinmod_helper", bltinmod_helper)
- self.initcode.append1(
- 'def %s(name):\n'
- ' dic = space.newdict()\n'
- ' space.exec_("import %%s" %% name, dic, dic, hidden_applevel=True)\n'
- ' return space.eval("%%s" %% name, dic, dic, hidden_applevel=True)' % (unique, ))
- self.initcode.append1('%s = %s(%r)' % (name, unique, mod.__name__))
- return name
-
-class GenRpy:
- def __init__(self, translator, entrypoint=None, modname=None, moddict=None):
- self.translator = translator
- if entrypoint is None:
- entrypoint = translator.entrypoint
- self.entrypoint = entrypoint
- self.modname = self.trans_funcname(modname or
- uniquemodulename(entrypoint))
- self.moddict = moddict # the dict if we translate a module
-
- def late_OperationError():
- self.initcode.append1(
- 'from pypy.interpreter.error import OperationError as gOperationError')
- return 'gOperationError'
- def late_Arguments():
- self.initcode.append1('from pypy.interpreter import gateway')
- return 'gateway.Arguments'
-
- self.rpynames = {Constant(None).key: 'space.w_None',
- Constant(False).key: 'space.w_False',
- Constant(True).key: 'space.w_True',
- Constant(Ellipsis).key: 'space.w_Ellipsis',
- Constant(NotImplemented).key: 'space.w_NotImplemented',
- Constant(OperationError).key: late_OperationError,
- Constant(Arguments).key: late_Arguments,
- }
- self.initcode = UniqueList() # list of lines for the module's initxxx()
- self.latercode = UniqueList()
- # list of generators generating extra lines
- # for later in initxxx() -- for recursive
- # objects
- self.namespace = NameManager()
- self.namespace.make_reserved_names('__doc__ __args__ space goto')
- self.globaldecl = []
- self.globalobjects = []
- self.pendingfunctions = []
- self.currentfunc = None
- self.debugstack = () # linked list of nested nameof()
-
- # special constructors:
- self.has_listarg = {}
- for name in "newtuple newlist".split():
- self.has_listarg[name] = name
-
- # catching all builtins in advance, to avoid problems
- # with modified builtins
-
- class bltinstub:
- def __init__(self, name):
- self.__name__ = name
- def __repr__(self):
- return '<%s>' % self.__name__
-
- self.ibuiltin_ids = identity_dict()
- self.ibuiltin_ids.update([
- (value, bltinstub(key))
- for key, value in __builtin__.__dict__.items()
- if callable(value) and type(value) not in [types.ClassType, type] ] )
-
- self.space = FlowObjSpace() # for introspection
-
- self.use_fast_call = True
- self.specialize_goto = False
- self._labeltable = {} # unique label names, reused per func
-
- self._space_arities = None
-
- self._signature_cache = {}
- self._defaults_cache = {}
-
- def expr(self, v, localscope, wrapped = True):
- if isinstance(v, Variable):
- return localscope.localname(v.name, wrapped)
- elif isinstance(v, Constant):
- return self.nameof(v.value,
- debug=('Constant in the graph of', self.currentfunc))
- else:
- raise TypeError, "expr(%r)" % (v,)
-
- def arglist(self, args, localscope):
- res = [self.expr(arg, localscope) for arg in args]
- return ", ".join(res)
-
- def oper(self, op, localscope):
- if op.opname in ('issubtype', 'isinstance'):
- arg = op.args[1]
- if (not isinstance(arg, Constant)
- or not isinstance(arg.value, (type, types.ClassType))):
- func = issubclass if op.opname == 'issubtype' else isinstance
- op = SpaceOperation("simple_call",
- [Constant(func)]+op.args,
- op.result)
- if op.opname == "simple_call":
- v = op.args[0]
- space_shortcut = self.try_space_shortcut_for_builtin(v, len(op.args)-1,
- op.args[1:])
- if space_shortcut is not None:
- # space method call
- exv = space_shortcut
- fmt = "%(res)s = %(func)s(%(args)s)"
- else:
- # import sys|__builtin__|_codecs avoid going through __import__
- if isinstance(v, Constant) and v.value is __builtin__.__import__:
- name, glb, loc, frm_lst = op.args[1:]
- if (isinstance(name, Constant) and name.value in ('sys', '__builtin__', '_codecs') and
- isinstance(loc, Constant) and loc.value is None and
- isinstance(frm_lst, Constant) and frm_lst.value is None):
- return "%s = space.getbuiltinmodule(%r)" % (self.expr(op.result, localscope),
- name.value)
- exv = self.expr(v, localscope)
- # default for a spacecall:
- fmt = "%(res)s = space.call_function(%(func)s, %(args)s)"
- # see if we can optimize for a fast call.
- # we just do the very simple ones.
- if self.use_fast_call and (isinstance(v, Constant)
- and exv.startswith('gfunc_')):
- func = v.value
- if (not func.func_code.co_flags & CO_VARARGS) and (
- func.func_defaults is None):
- fmt = "%(res)s = fastf_%(func)s(space, %(args)s)"
- exv = exv[6:]
- return fmt % {"res" : self.expr(op.result, localscope),
- "func": exv,
- "args": self.arglist(op.args[1:], localscope) }
- if op.opname == "call_args":
- v = op.args[0]
- exv = self.expr(v, localscope)
- fmt = (
- "_args = %(Arg)s(space, [%(args_w)s], %(keywords)s, [%(keywords_w)s], %(w_stararg)s, %(w_starstararg)s)\n"
- "%(res)s = space.call_args(%(func)s, _args)")
- assert isinstance(op.args[1], Constant)
- shape = op.args[1].value
- # make a list out of the second shape elt.
- shape = shape[0], list(shape[1]), shape[2], shape[3]
- arglist = [self.expr(arg, localscope) for arg in op.args[2:]]
- args = ArgumentsForTranslation.fromshape(None, shape, arglist)
- return fmt % {"res": self.expr(op.result, localscope),
- "func": exv,
- "args_w": ", ".join(args.arguments_w),
- "keywords": args.keywords,
- "keywords_w": ", ".join(args.keywords_w),
- "w_stararg": args.w_stararg,
- "w_starstararg": args.w_starstararg,
- 'Arg': self.nameof(Arguments) }
- if op.opname == "hint":
- return "%s = %s" % (self.expr(op.result, localscope),
- self.expr(op.args[0], localscope))
- if op.opname in self.has_listarg:
- fmt = "%s = %s([%s])"
- else:
- fmt = "%s = %s(%s)"
- # special case is_true
- opname = op.opname
- if opname.startswith('getitem_'):
- opname = 'getitem'
- wrapped = opname != "is_true"
- oper = "space.%s" % opname
- return fmt % (self.expr(op.result, localscope, wrapped), oper,
- self.arglist(op.args, localscope))
-
- def large_assignment(self, left, right, margin=65):
- expr = "(%s) = (%s)" % (", ".join(left), ", ".join(right))
- pieces = expr.split(",")
- res = [pieces.pop(0)]
- for piece in pieces:
- if len(res[-1])+len(piece)+1 > margin:
- res[-1] += ","
- res.append(piece)
- else:
- res[-1] += (","+piece)
- return res
-
- def large_initialize(self, vars, margin=65):
- res = []
- nonestr = "None"
- margin -= len(nonestr)
- for var in vars:
- ass = var+"="
- if not res or len(res[-1]) >= margin:
- res.append(ass)
- else:
- res[-1] += ass
- res = [line + nonestr for line in res]
- return res
-
- def mklabel(self, blocknum):
- if self.specialize_goto:
- lbname = self._labeltable.get(blocknum)
- if not lbname:
- self.initcode.append1(
- 'from pypy.objspace.flow.framestate import SpecTag')
- lbname = self.uniquename("glabel_%d" % blocknum)
- self._labeltable[blocknum] = lbname
- self.initcode.append1('%s = SpecTag()' % lbname)
- return lbname
- else:
- return repr(blocknum)
-
- def gen_link(self, link, localscope, blocknum, block, linklocalvars=None):
- "Generate the code to jump across the given Link."
- linklocalvars = linklocalvars or {}
- left, right = [], []
- for a1, a2 in zip(link.args, link.target.inputargs):
- if a1 in linklocalvars:
- src = linklocalvars[a1]
- else:
- src = self.expr(a1, localscope)
- dest = self.expr(a2, localscope)
- if src != dest:
- left.append(dest)
- right.append(src)
- if left: # anything at all?
- txt = "%s = %s" % (", ".join(left), ", ".join(right))
- if len(txt) <= 65: # arbitrary
- yield txt
- else:
- for line in self.large_assignment(left, right):
- yield line
- goto = blocknum[link.target]
- yield 'goto = %s' % self.mklabel(goto)
- if goto <= blocknum[block]:
- yield 'continue'
-
- def register_early(self, obj, name):
- # this was needed for recursive lists.
- # note that self.latercode led to too late initialization.
- key = Constant(obj).key
- self.rpynames[key] = name
-
- def nameof(self, obj, debug=None, namehint=None):
- key = Constant(obj).key
- try:
- txt = self.rpynames[key]
- if type(txt) is not str:
- # this is a predefined constant, initialized on first use
- func = txt
- txt = func()
- self.rpynames[key] = txt
- return txt
-
- except KeyError:
- if debug:
- stackentry = debug, obj
- else:
- stackentry = obj
- self.debugstack = (self.debugstack, stackentry)
- obj_builtin_base = builtin_base(obj)
- if obj_builtin_base in (object, int, long) and type(obj) is not obj_builtin_base:
- # assume it's a user defined thingy
- name = self.nameof_instance(obj)
- else:
- # shortcutting references to __builtin__
- if obj in self.ibuiltin_ids:
- func = self.ibuiltin_ids[obj]
- #name = self.get_nameof_builtin_func(func)
- # the above is quicker in principle, but pulls more
- # stuff in, so it is slower right now.
- name = "(space.builtin.get(space.str_w(%s)))" % self.nameof(func.__name__)
- else:
- for cls in type(obj).__mro__:
- meth = getattr(self,
- 'nameof_' + cls.__name__.replace(' ', ''),
- None)
- if meth:
- break
- else:
- raise Exception, "nameof(%r)" % (obj,)
-
- code = meth.im_func.func_code
- if namehint and 'namehint' in code.co_varnames[:code.co_argcount]:
- name = meth(obj, namehint=namehint)
- else:
- name = meth(obj)
- self.debugstack, x = self.debugstack
- assert x is stackentry
- self.rpynames[key] = name
- return name
-
- def get_nameof_builtin_func(self, func):
- # this is a hack!
- # in some cases, like exceptions, we don't have space.builtin available,
- #so we crate a fall-back...
- name = self.uniquename('gbltin_' + func.__name__)
- self.initcode.append1('''\
-try:
- # see if we have space.builtin in this context
- space.builtin
-except AttributeError:
- print "didn\'t get", %(bltin)r
- def %(name)s(space, __args__):
- w_func = space.builtin.get(%(bltin)r)
- return space.call_args(w_func, __args__)
- %(name)s = space.wrap(gateway.interp2app(%(name)s, unwrap_spec=[gateway.ObjSpace, gateway.Arguments]))
-else:
- print "got it:", %(bltin)r
- %(name)s = space.builtin.get(%(bltin)r)'''
- % {'name': name, 'bltin': func.__name__} )
- return name
-
- def uniquename(self, basename):
- name = self.namespace.uniquename(basename)
- self.globalobjects.append(name)
- self.globaldecl.append('# global object %s' % (name,))
- return name
-
- def uniquenameofprebuilt(self, basename, obj):
- # identifying an object and giving it a name,
- # without the attempt to render it.
- key = Constant(obj).key
- try:
- txt = self.rpynames[key]
- except KeyError:
- self.rpynames[key] = txt = self.uniquename(basename)
- return txt
-
- def nameof_object(self, value):
- if type(value) is not object:
- # try to just wrap it?
- name = self.uniquename('g_%sinst_%r' % (type(value).__name__, value))
- self.initcode.append1('%s = space.wrap(%r)' % (name, value))
- return name
- name = self.uniquename('g_object')
- self.initcode.append('_tup = space.newtuple([])\n'
- '%s = space.call(space.w_object, _tup)'
- % name)
- return name
-
- def is_module_builtin(self, mod):
- if not hasattr(mod, "__file__") or mod.__file__ is None:
- return True
- if not (mod.__file__.endswith('.pyc') or
- mod.__file__.endswith('.py') or
- mod.__file__.endswith('.pyo')):
- return True
- if mod.__file__.endswith('*.py'): # on top of PyPy, a mixed module
- return True
- return False
-
- def nameof_module(self, value):
- if value is os or self.is_module_builtin(value):
- return bltinmod_helper(self, value)
-
- # we might have createda reference to a module
- # that is non-standard.
-
- # SKIPPING
- return "space.w_None"
-
- # check whether we can import
- try:
- import value
- need_extra_path = False
- except ImportError:
- need_extra_path = True
- name = self.uniquename('mod_%s' % value.__name__)
- if need_extra_path:
- assert False
- ## self.initcode.append1('import pypy')
- ## self.initcode.append1('import sys')
- ## self.initcode.append1('import os')
- ## self.initcode.append1('for pkgdir in pypy.__path__:\n'
- ## ' libdir = os.path.join(pkgdir, "lib")\n'
- ## ' if os.path.isdir(libdir):\n'
- ## ' break\n'
- ## 'else:\n'
- ## ' raise Exception, "cannot find pypy/lib directory"\n'
- ## 'sys.path.insert(0, libdir)\n')
- ## self.initcode.append1('try:\n'
- ## ' import %s as _tmp\n'
- ## 'finally:\n'
- ## ' if libdir in sys.path:\n'
- ## ' sys.path.remove(libdir)\n' % value.__name__)
- else:
- self.initcode.append1('import %s as _tmp' % value.__name__)
- self.initcode.append1('%s = space.wrap(_tmp)' % (name))
- return name
-
-
- def nameof_int(self, value):
- if value >= 0:
- name = 'gi_%d' % value
- else:
- # make sure that the type ident is completely described by
- # the prefixbefore the initial '_' for easy postprocessing
- name = 'gi_minus_%d' % abs(value)
- name = self.uniquename(name)
- self.initcode.append1('%s = space.wrap(%d)' % (name, value))
- return name
-
- def nameof_long(self, value):
- # assume we want them in hex most of the time
- if value < 256L:
- s = "%dL" % value
- else:
- s = "0x%08xL" % value
- if value >= 0:
- name = 'glong_%s' % s
- else:
- # mae sure that the type ident is completely described by
- # the prefix before the initial '_'
- name = 'glong_minus_%d' % abs(value)
- name = self.uniquename(name)
- # allow literally short longs only, meaning they
- # must fit into a machine word.
- if (sys.maxint*2+1)&value == value:
- self.initcode.append1('%s = space.wrap(%s) # XXX implement long!' % (name, s))
- else:
- long_helper(self, name, value)
- return name
-
- def nameof_float(self, value):
- name = 'gfloat_%s' % value
- name = (name.replace('-', 'minus')
- .replace('.', 'dot'))
- name = self.uniquename(name)
- # handle overflows
- if value != 0.0 and 2*value == value:
- self.initcode.append1('float_inf = 1e200\nfloat_inf *= float_inf')
- sign = '-+'[value >= 0]
- self.initcode.append('%s = space.wrap(%sfloat_inf)' % (name, sign))
- else:
- self.initcode.append('%s = space.wrap(%r)' % (name, value))
- return name
-
- def nameof_str(self, value):
- if [c for c in value if c<' ' or c>'~' or c=='"' or c=='\\']:
- # non-printable string
- namestr = repr(value)[1:-1]
- else:
- # printable string
- namestr = value
- if not namestr:
- namestr = "_emptystr_"
- name = self.uniquename('gs_' + namestr[:32])
- if len(value) < 30 and "\n" not in value:
- txt = '%s = space.new_interned_str(%r)' % (name, value)
- else:
- txt = render_docstr(value, '%s = space.new_interned_str(\n' % name, ')')
- txt = txt, # not splitted
- self.initcode.append(txt)
- return name
-
- def skipped_function(self, func):
- # debugging only! Generates a placeholder for missing functions
- # that raises an exception when called.
- name = self.uniquename('gskippedfunc_' + func.__name__)
- self.globaldecl.append('# global decl %s' % (name, ))
- self.initcode.append('# build func %s' % name)
- return name
-
- def skipped_class(self, cls):
- # debugging only! Generates a placeholder for missing classes
- # that raises an exception when called.
- name = self.uniquename('gskippedclass_' + cls.__name__)
- self.globaldecl.append('# global decl %s' % (name, ))
- self.initcode.append1('# build class %s' % name)
- return name
-
- def trans_funcname(self, s):
- return s.translate(C_IDENTIFIER)
-
- def nameof_function(self, func, namehint=''):
- if hasattr(func, 'geninterplevel_name'):
- return func.geninterplevel_name(self)
- if func.func_globals is None:
- # built-in functions on top of PyPy
- return self.nameof_builtin_function(func)
-
- printable_name = '(%s:%d) %s' % (
- self.trans_funcname(func.func_globals.get('__name__', '?')),
- func.func_code.co_firstlineno,
- func.__name__)
- if (func.func_doc and
- func.func_doc.lstrip().startswith('NOT_RPYTHON')):
- log.WARNING("skipped %s" % printable_name)
- return self.skipped_function(func)
- name = self.uniquename('gfunc_' + self.trans_funcname(
- namehint + func.__name__))
-
- positional, varargs, varkwds, defs = inspect.getargspec(func)
- if varargs is varkwds is defs is None:
- unwrap = ', '.join(['gateway.W_Root']*len(positional))
- interp_name = 'fastf_' + name[6:]
- else:
- unwrap = 'gateway.Arguments'
- interp_name = 'f_' + name[6:]
-
- self.initcode.append1('from pypy.interpreter import gateway')
- self.initcode.append1('%s = space.wrap(gateway.interp2app(%s, unwrap_spec=[gateway.ObjSpace, %s]))' %
- (name, interp_name, unwrap))
- self.pendingfunctions.append(func)
- return name
-
- def nameof_staticmethod(self, sm):
- # XXX XXX XXXX
- func = sm.__get__(42.5)
- name = self.uniquename('gsm_' + func.__name__)
- functionname = self.nameof(func)
- self.initcode.append1('%s = space.wrap(%s)' % (name, functionname))
- return name
-
- def nameof_instancemethod(self, meth):
- if (not hasattr(meth.im_func, 'func_globals') or
- meth.im_func.func_globals is None):
- # built-in methods (bound or not) on top of PyPy or possibly 2.4
- return self.nameof_builtin_method(meth)
- if meth.im_self is None:
- # no error checking here
- return self.nameof(meth.im_func, namehint="%s_" % meth.im_class.__name__)
- else:
- ob = self.nameof(meth.im_self)
- func = self.nameof(meth.im_func)
- typ = self.nameof(meth.im_class)
- name = self.uniquename('gmeth_' + meth.im_func.__name__)
- funcname = self.nameof(meth.im_func.__name__)
- self.initcode.append1(
- '%s = space.getattr(%s, %s)' % (name, ob, funcname))
- return name
-
- nameof_method = nameof_instancemethod # when run on top of PyPy
-
- def should_translate_attr(self, pbc, attr):
- ignore = getattr(pbc.__class__, 'NOT_RPYTHON_ATTRIBUTES', [])
- if attr in ignore:
- return False
- else:
- return "probably" # True
-
- def later(self, gen):
- self.latercode.append1((gen, self.debugstack))
-
- def nameof_instance(self, instance):
- klass = instance.__class__
- name = self.uniquename('ginst_' + klass.__name__)
- cls = self.nameof(klass)
- if hasattr(klass, '__base__'):
- base_class = builtin_base(instance)
- base = self.nameof(base_class)
- else:
- base_class = None
- base = cls
- def initinstance():
- content = instance.__dict__.items()
- content.sort()
- for key, value in content:
- if self.should_translate_attr(instance, key):
- try:
- yield 'space.setattr(%s, %s, %s)' % (
- name, self.nameof(key), self.nameof(value))
- except:
- log.ERROR("Problem while generating %s of %r" % (
- name, instance))
- raise
- self.initcode.append1("%s = space.call_method(%s, '__new__', %s)" % (
- name, cls, cls))
- self.later(initinstance())
- return name
-
- def space_arities(self):
- if self._space_arities is None:
- arities = self._space_arities = {}
- for name, sym, arity, specnames in self.space.MethodTable:
- arities[name] = arity
- del arities["isinstance"]
- return self._space_arities
-
- def try_space_shortcut_for_builtin(self, v, nargs, args):
- if isinstance(v, Constant) and v.value in self.ibuiltin_ids:
- name = self.ibuiltin_ids[v.value].__name__
- if (hasattr(self.space, name) and
- self.space_arities().get(name, -1) == nargs):
- return "space.%s" % name
- return None
-
- def nameof_builtin_function_or_method(self, func):
- if func.__self__ is None:
- return self.nameof_builtin_function(func)
- else:
- return self.nameof_builtin_method(func)
-
- def nameof_builtin_function(self, func):
- # builtin function
- if func in self.ibuiltin_ids:
- func = self.ibuiltin_ids[func]
- return "(space.builtin.get(space.str_w(%s)))" % self.nameof(func.__name__)
- # where does it come from? Python2.2 doesn't have func.__module__
- for modname, module in sys.modules.items():
- if not self.is_module_builtin(module):
- continue # skip non-builtin modules
- if func is getattr(module, func.__name__, None):
- break
- else:
- raise Exception, '%r not found in any built-in module' % (func,)
- #if modname == '__builtin__':
- # # be lazy
- # return "(space.builtin.get(space.str_w(%s)))" % self.nameof(func.__name__)
- if modname == 'sys':
- # be lazy
- return "(space.sys.get(space.str_w(%s)))" % self.nameof(func.__name__)
- else:
- name = self.uniquename('gbltin_' + func.__name__)
- self.initcode.append1('%s = space.getattr(%s, %s)' % (
- name, self.nameof(module), self.nameof(func.__name__)))
- return name
-
- def nameof_builtin_method(self, meth):
- try:
- im_self = meth.__self__
- except AttributeError:
- im_self = meth.im_self # on top of PyPy
- if im_self is None:
- # builtin unbound method (only on top of PyPy)
- name = self.nameof_wrapper_descriptor(meth)
- else:
- # builtin (bound) method
- name = self.uniquename('gbltinmethod_' + meth.__name__)
- self.initcode.append1('%s = space.getattr(%s, %s)' % (
- name, self.nameof(im_self), self.nameof(meth.__name__)))
- return name
-
- def nameof_classobj(self, cls):
- initcode = []
- printable_name = cls.__name__
- if cls.__doc__ and cls.__doc__.lstrip().startswith('NOT_RPYTHON'):
- #raise Exception, "%r should never be reached" % (cls,)
- log.WARNING("skipped class %s" % printable_name)
- return self.skipped_class(cls)
-
- metaclass = "space.w_type"
- name = self.uniquename('gcls_' + cls.__name__)
-
- if issubclass(cls, py.builtin.BaseException):
- # if cls.__module__ == 'exceptions':
- # don't rely on this, py.magic redefines AssertionError
- if getattr(__builtin__,cls.__name__,None) is cls:
- # exception are defined on the space
- return 'space.w_%s' % cls.__name__
-
- if not isinstance(cls, type):
- assert type(cls) is types.ClassType
- # do *not* change metaclass, but leave the
- # decision to what PyPy thinks is correct.
- # metaclass = 'space.w_classobj'
-
- basenames = [self.nameof(base) for base in cls.__bases__]
-
- def initclassobj():
- content = cls.__dict__.items()
- content.sort()
- for key, value in content:
- if key.startswith('__'):
- if key in ['__module__', '__doc__', '__dict__',
- '__weakref__', '__metaclass__', '__slots__',
- '__new__', '__del__']:
- continue
-
- # redirect value through class interface, in order to
- # get methods instead of functions.
- value = getattr(cls, key)
-
- if isinstance(value, staticmethod) and value.__get__(1) not in self.translator.flowgraphs and self.translator.frozen:
- log.WARNING("skipped staticmethod: %s" % value)
- continue
- if isinstance(value, MethodType) and value.im_self is cls:
- log.WARNING("skipped classmethod: %s" % value)
- continue
-
- yield 'space.setattr(%s, %s, %s)' % (
- name, self.nameof(key), self.nameof(value))
-
- baseargs = ", ".join(basenames)
- initcode.append('_dic = space.newdict()')
- for key, value in cls.__dict__.items():
- if key.startswith('__'):
- if key in ['__module__', '__metaclass__', '__slots__',
- '__new__', '__del__']:
- keyname = self.nameof(key)
- valname = self.nameof(value)
- initcode.append("space.setitem(_dic, %s, %s)" % (
- keyname, valname))
-
- if cls.__doc__ is not None:
- sdoc = self.nameof("__doc__")
- docobj = cls.__dict__["__doc__"]
- if type(docobj) in (str, unicode):
- docstr = render_docstr(cls, "_doc = space.wrap(", ")")
- initcode.append((docstr,)) # not splitted
- else:
- initcode.append("_doc = %s" % self.nameof(docobj) )
- initcode.append("space.setitem(_dic, %s, _doc)" % (sdoc,))
- cls_name = self.nameof(cls.__name__)
- for l in initcode:
- self.initcode.append(l)
- self.initcode.append1('_bases = space.newtuple([%(bases)s])\n'
- '_args = space.newtuple([%(name)s, _bases, _dic])\n'
- '%(klass)s = space.call(%(meta)s, _args)'
- % {"bases": baseargs,
- "klass": name,
- "name" : cls_name,
- "meta" : metaclass} )
-
- self.later(initclassobj())
- return name
-
- nameof_class = nameof_classobj # for Python 2.2
-
- typename_mapping = {
- object: 'space.w_object',
- int: 'space.w_int',
- long: 'space.w_int',
- bool: 'space.w_bool',
- list: 'space.w_list',
- tuple: 'space.w_tuple',
- dict: 'space.w_dict',
- str: 'space.w_str',
- float: 'space.w_float',
- slice: 'space.w_slice',
- types.InstanceType: (eval_helper, 'InstanceType', 'types.InstanceType'),
- type: 'space.w_type',
- complex: (eval_helper, 'complex', 'types.ComplexType'),
- unicode:'space.w_unicode',
- basestring: (eval_helper, 'basestring', 'basestring'),
- file: (eval_helper, 'file', 'file'),
- type(None): (eval_helper, 'NoneType', 'type(None)'),
- CodeType: (eval_helper, 'code', 'type((lambda:42).func_code)'),
- ModuleType: (eval_helper, 'ModuleType', 'types.ModuleType'),
- xrange: (eval_helper, 'xrange', 'xrange'),
-
- ##r_int: 'space.w_int',
- ##r_uint: 'space.w_int',
-
- type(len): (eval_helper, 'FunctionType', 'type(lambda:42)'),
- # type 'method_descriptor':
- # XXX small problem here:
- # XXX with space.eval, we get <W_TypeObject(method)>
- # XXX but with wrap, we get <W_TypeObject(instancemethod)>
- type(list.append): (eval_helper, "method_descriptor", "type(list.append)"),
- # type 'wrapper_descriptor':
- type(type(None).__repr__): (eval_helper, "wrapper_descriptor",
- "type(type(None).__repr__)"),
- # type 'getset_descriptor':
- # XXX here we get <W_TypeObject(FakeDescriptor)>,
- # while eval gives us <W_TypeObject(GetSetProperty)>
- type(type.__dict__['__dict__']): (eval_helper, "getset_descriptor",
- "type(type.__dict__[\'__dict__\'])"),
- # type 'member_descriptor':
- # XXX this does not work in eval!
- # type(type.__dict__['__basicsize__']): "cannot eval type(type.__dict__['__basicsize__'])",
- # XXX there seems to be no working support for member descriptors ???
- type(types.GeneratorType.gi_frame):
- (eval_helper, "member_descriptor", 'type(property.fdel)'),
- types.ClassType: 'space.w_type',
- types.MethodType: (eval_helper, "instancemethod",
- "type((lambda:42).__get__(42))"),
- type(Ellipsis): (eval_helper, 'EllipsisType', 'types.EllipsisType'),
- builtin_set: (eval_helper, "set", "set"),
- builtin_frozenset: (eval_helper, "frozenset", "frozenset"),
- buffer: (eval_helper, "buffer", "buffer"),
- }
-
- def nameof_type(self, cls):
- if cls in self.typename_mapping:
- ret = self.typename_mapping[cls]
- if type(ret) is tuple:
- ret = ret[0](self, ret[1], ret[2])
- return ret
- if issubclass(cls, py.builtin.BaseException): # Python 2.5 only
- # if cls.__module__ == 'exceptions':
- # don't rely on this, py.magic redefines AssertionError
- if getattr(__builtin__,cls.__name__,None) is cls:
- # exception are defined on the space
- return 'space.w_%s' % cls.__name__
- assert cls.__module__ != '__builtin__' or cls.__flags__&_HEAPTYPE, (
- "built-in class %r not found in typename_mapping "
- "while compiling %s" % (cls, self.currentfunc and
- self.currentfunc.__name__ or "*no function at all*"))
- return self.nameof_classobj(cls)
-
- def nameof_tuple(self, tup):
- name = self.uniquename('g%dtuple' % len(tup))
- args = [self.nameof(x) for x in tup]
- args = ', '.join(args)
- self.initcode.append1('%s = space.newtuple([%s])' % (name, args))
- return name
-
- def nameof_list(self, lis):
- name = self.uniquename('g%dlist' % len(lis))
- # note that self.latercode led to too late initialization.
- self.register_early(lis, name)
- # try to save at least one assignment.
- if lis and lis[0] is not lis:
- default = lis[0]
- else:
- default = None
- self.initcode.append('%s = space.newlist([%s])' % (name, self.nameof(default)))
- self.initcode.append('%s = space.mul(%s, %s)' % (name, name, self.nameof(len(lis))))
- for i in range(len(lis)):
- if lis[i] is not default:
- item = self.nameof(lis[i])
- self.initcode.append('space.setitem(%s, %s, %s);' % (
- name, self.nameof(i), item))
- return name
-
- def nameof_dict(self, dic):
- assert dic is not __builtins__
- name = self.uniquename('g%ddict' % len(dic))
- self.register_early(dic, name)
- self.initcode.append('%s = space.newdict()' % (name,))
- for k in dic:
- if k == '__builtins__':
- continue
- self.initcode.append('space.setitem(%s, %s, %s)'%(
- name, self.nameof(k), self.nameof(dic[k])))
- return name
-
- # strange prebuilt instances below, don't look too closely
- # XXX oh well.
- def nameof_member_descriptor(self, md):
- try:
- im_class = md.__objclass__
- except AttributeError:
- im_class = md.im_class # on top of PyPy
- name = self.uniquename('gdescriptor_%s_%s' % (
- im_class.__name__, md.__name__))
- cls = self.nameof(im_class)
- self.initcode.append1('%s = space.getattr(%s, %s)' %
- (name, cls, self.nameof(md.__name__)))
- return name
- nameof_getset_descriptor = nameof_member_descriptor
- nameof_method_descriptor = nameof_member_descriptor
- nameof_wrapper_descriptor = nameof_member_descriptor
-
- def nameof_property(self, prop):
- origin = prop.__doc__ # XXX quite a hack
- if not origin:
- raise ValueError("sorry, cannot build properties"
- " without a helper in __doc__")
- name = self.uniquename('gprop_' + origin)
- # property is lazy loaded app-level as well, trigger it*s creation
- self.initcode.append1('space.builtin.get("property") # pull it in')
- globname = self.nameof(self.moddict)
- self.initcode.append('space.setitem(%s, space.new_interned_str("__builtins__"), '
- 'space.builtin.w_dict)' % globname)
- self.initcode.append('%s = space.eval("property(%s)", %s, %s, hidden_applevel=True)' %(
- name, origin, globname, globname) )
- self.initcode.append('space.delitem(%s, space.new_interned_str("__builtins__"))'
- % globname)
- return name
-
- def nameof_file(self, fil):
- if fil is sys.stdin:
- return 'space.sys.get("stdin")'
- if fil is sys.stdout:
- return 'space.sys.get("stdout")'
- if fil is sys.stderr:
- return 'space.sys.get("stderr")'
- raise Exception, 'Cannot translate an already-open file: %r' % (fil,)
-
- def gen_source(self, fname, ftmpname=None, file=file):
- self.fname = fname
- self.ftmpname = ftmpname
-
- # generate unordered source file, first.
- # I prefer this over ordering everything in memory.
- fname = self.fname
- if self.ftmpname:
- fname = self.ftmpname
- f = file(fname, "w")
- # generate ordered source file
- try:
- self.f = f
- self.gen_source_temp()
- finally:
- f.close()
-
- def copyfile(source, target):
- f = file(source)
- data = f.read()
- f.close()
- f = file(target, "w")
- f.write(data)
- f.close()
-
- def order_sections(fname):
- sep = "\n##SECTION##\n"
- f = file(fname)
- txt = f.read()
- f.close()
- pieces = txt.split(sep)
- prelude = pieces.pop(0)
- postlude = pieces.pop()
- dic = {}
- while pieces:
- func = pieces.pop()
- head = pieces.pop()
- key = makekey(head, len(pieces))
- dic[key] = head + sep + func
- lis = dic.items()
- lis.sort()
- lis = [prelude] + [func for head, func in lis] + [postlude]
- txt = sep.join(lis)
- f = file(fname, "w")
- f.write(txt)
- f.close()
-
- def makekey(txt, uniqueno):
- dic = {}
- for line in txt.split("\n"):
- ign, name, value = line.split(None, 2)
- dic[name] = eval(value, {})
- key = (dic["filename"], dic["firstlineno"],
- dic["function"], uniqueno)
- return key
-
- order_sections(fname)
- if self.ftmpname:
- copyfile(self.ftmpname, self.fname)
-
- def gen_source_temp(self):
- f = self.f
-
- # header
- print >> f, self.RPY_HEADER
- print >> f
-
- info = {
- 'modname': self.modname,
- # the side-effects of this is kick-start the process
- 'entrypoint': None # self.nameof(self.entrypoint),
- }
- # header """def initmodule(space):"""
- print >> f, self.RPY_INIT_HEADER % info
-
- # doc
- if self.moddict and self.moddict.get("__doc__"):
- doc = self.moddict["__doc__"]
- print >> f, render_docstr(doc, " __doc__ = \\\n")
- print >> f
- # make sure it is not rendered again
- key = Constant(doc).key
- self.rpynames[key] = "w__doc__"
- self.initcode.append("w__doc__ = space.new_interned_str(__doc__)")
-
- # info.entrypoint must be done *after* __doc__ is handled,
- # because nameof(entrypoint) might touch __doc__ early.
- info["entrypoint"] = self.nameof(self.entrypoint)
-
- # function implementations
- while self.pendingfunctions or self.latercode:
- if self.pendingfunctions:
- func = self.pendingfunctions.pop()
- self.currentfunc = func
- self.gen_rpyfunction(func)
- # collect more of the latercode after each function
- while self.latercode:
- gen, self.debugstack = self.latercode.pop()
- #self.initcode.extend(gen) -- eats TypeError! bad CPython!
- for line in gen:
- self.initcode.append1(line)
- self.debugstack = ()
- self.gen_global_declarations()
-
- # set the final splitter
- print >> f, "##SECTION##"
- # footer, init code
- for codelines in self.initcode:
- # keep docstrings unindented
- indent = " "
- if type(codelines) is tuple:
- codelines = codelines[0].split("\n", 1)
- codelines[0] = indent + codelines[0]
- indent = ""
- else:
- codelines = codelines.split("\n")
- for codeline in codelines:
- print >> f, indent + codeline
-
- self.gen_trailer(info, " ")
- # do not close the file here!
-
- def gen_trailer(self, info, indent):
- if self.moddict:
- # we are generating a module, no __main__ etc.
- print >> self.f, indent + "return %s" % self.nameof(self.entrypoint)
- print >> self.f
- else:
- # we should have an entrypoint function
- info['entrypointname'] = self.trans_funcname(self.entrypoint.__name__)
- print >> self.f, self.RPY_INIT_FOOTER % info
-
- def gen_global_declarations(self):
- g = self.globaldecl
- if g:
- f = self.f
- print >> f, '# global declaration%s' % ('s'*(len(g)>1))
- for line in g:
- print >> f, line
- print >> f
- del g[:]
- g = self.globalobjects
- for name in g:
- pass # self.initcode.append1('# REGISTER_GLOBAL(%s)' % (name,))
- del g[:]
-
- def rel_filename(self, name):
- # try to find a name relative to pypy and unify.
- # if not possible, stick with the original.
- ref = py.path.local(pypy.__path__[0])
- rel = py.path.local(name).relto(ref)
- if rel:
- # make it os independent
- return rel.replace('\\', '/')
- return name # no success
-
- def getsignature(self, argnamelist, varargname, varkwname):
- key = (argnamelist, varargname, varkwname)
- try:
- return self._signature_cache[key]
- except KeyError:
- pass
- signame = self.uniquename('sig')
- self._signature_cache[key] = signame
- self.initcode.append("%s = gateway.Signature(%r, %r, %r)" % (
- signame, list(argnamelist), varargname, varkwname))
- return signame
-
- def getdefaults(self, names):
- key = tuple(names)
- try:
- return self._defaults_cache[key]
- except KeyError:
- pass
- defaultsname = self.uniquename('default')
- self._defaults_cache[key] = defaultsname
- self.initcode.append("%s = [%s]" % (defaultsname, ', '.join(names)))
- return defaultsname
-
- def gen_rpyfunction(self, func):
- try:
- graph = self.translator.buildflowgraph(func, True)
- except Exception, e:
- print 20*"*", e
- print func
- raise
- SSI_to_SSA(graph)
- checkgraph(graph)
-
- f = self.f
- print >> f, "##SECTION##" # simple to split, afterwards
- print >> f, ("## filename %r\n"
- "## function %r\n"
- "## firstlineno %d") % (
- self.rel_filename(func.func_code.co_filename),
- func.func_code.co_name,
- func.func_code.co_firstlineno)
- print >> f, "##SECTION##"
- localscope = self.namespace.localScope()
- body = list(self.rpyfunction_body(graph, localscope))
- name_of_defaults = [self.nameof(x, debug=('Default argument of', func))
- for x in (func.func_defaults or ())]
- self.gen_global_declarations()
-
- # print header
- docstr = render_docstr(func, " ")
- cname = self.nameof(func)
- assert cname.startswith('gfunc_')
- f_name = 'f_' + cname[6:]
-
- # collect all the arguments
- vararg = varkw = None
- varargname = varkwname = None
- all_args = graph.getargs()
- p = len(all_args)
- if func.func_code.co_flags & CO_VARKEYWORDS:
- p -= 1
- varkw = graph.getargs()[p]
- varkwname = func.func_code.co_varnames[p]
- if func.func_code.co_flags & CO_VARARGS:
- p -= 1
- vararg = graph.getargs()[p]
- varargname = func.func_code.co_varnames[p]
- positional_args = all_args[:p]
- argnamelist = func.func_code.co_varnames[:func.func_code.co_argcount]
-
- fast_args = [self.expr(a, localscope) for a in positional_args]
- if vararg is not None:
- vararg = self.expr(vararg, localscope)
- fast_args.append(vararg)
- if varkw is not None:
- varkw = self.expr(varkw, localscope)
- fast_args.append(varkw)
- fast_name = 'fast' + f_name
-
- fast_set = dict(zip(fast_args, fast_args))
-
- simple = (varargname is varkwname is None) and not name_of_defaults
-
- # create function declaration
- name = self.trans_funcname(func.__name__) # for <lambda>
- argstr = ", ".join(['space'] + fast_args)
- fast_function_header = (' def %s(%s):'
- % (name, argstr))
-
- def install_func(f_name, name):
- yield ''
- yield ' %s = %s' % (f_name, name)
- yield ' %s.__name__ = %r' % (f_name, f_name)
- #import __builtin__
- #dic = __builtin__.__dict__
- #if dic.get(name):
- # yield 'del %s # hiding a builtin!' % name
- #else:
- # self.initcode.append1('del m.%s' % (name,))
-
- def tupstr(seq):
- if len(seq) == 1:
- fmt = '%s,'
- else:
- fmt = '%s'
- return fmt % ', '.join(seq)
- def tupassstr(seq):
- if not seq:
- return ""
- else:
- return tupstr(seq) + " = "
-
- if not simple:
- print >> f, ' def %s(space, __args__):' % (name,)
- if docstr is not None:
- print >> f, docstr
- print >> f
-
- signame = self.getsignature(argnamelist, varargname, varkwname)
- defaultsname = self.getdefaults(name_of_defaults)
- print >> f, ' %s__args__.parse_obj(None, %r, %s, %s)' % (
- tupassstr(fast_args), func.__name__, signame, defaultsname)
- print >> f, ' return %s(%s)' % (fast_name,
- ', '.join(["space"]+fast_args))
-
- for line in install_func(f_name, name):
- print >> f, line
-
- print >> f
-
- print >> f, fast_function_header
- if docstr is not None:
- print >> f, docstr
-
- # print the body
- for line in body:
- print >> f, line
- for line in install_func("fast"+f_name, name):
- print >> f, line
- print >> f
-
- # print the PyMethodDef
- # skipped
-
-
- def rpyfunction_body(self, graph, localscope):
- start = graph.startblock
- allblocks = ordered_blocks(graph)
- nblocks = len(allblocks)
-
- blocknum = {}
- for block in allblocks:
- blocknum[block] = len(blocknum)+1
-
- yield " goto = %s # startblock" % self.mklabel(blocknum[start])
- yield " while True:"
-
- def render_block(block):
- catch_exception = block.exitswitch == c_last_exception
- regular_op = len(block.operations) - catch_exception
- # render all but maybe the last op
- for op in block.operations[:regular_op]:
- for line in self.oper(op, localscope).split("\n"):
- yield "%s" % line
- # render the last op if it is exception handled
- for op in block.operations[regular_op:]:
- yield "try:"
- for line in self.oper(op, localscope).split("\n"):
- yield " %s" % line
-
- if len(block.exits) == 0:
- if len(block.inputargs) == 2: # exc_cls, exc_value
- # exceptional return block
- exc_cls = self.expr(block.inputargs[0], localscope)
- exc_val = self.expr(block.inputargs[1], localscope)
- yield "raise %s(%s, %s)" % (self.nameof(OperationError),
- exc_cls, exc_val)
- else:
- # regular return block
- retval = self.expr(block.inputargs[0], localscope)
- yield "return %s" % retval
- return
- elif block.exitswitch is None:
- # single-exit block
- assert len(block.exits) == 1
- for op in self.gen_link(block.exits[0], localscope, blocknum, block):
- yield "%s" % op
- elif catch_exception:
- # block catching the exceptions raised by its last operation
- # we handle the non-exceptional case first
- link = block.exits[0]
- assert link.exitcase is None
- for op in self.gen_link(link, localscope, blocknum, block):
- yield " %s" % op
- # we must catch the exception raised by the last operation,
- # which goes to the last err%d_%d label written above.
- # Since we only have OperationError, we need to select:
- yield "except %s, e:" % (self.nameof(OperationError),)
- yield " e.normalize_exception(space)"
- q = "if"
- for link in block.exits[1:]:
- assert issubclass(link.exitcase, py.builtin.BaseException)
- # Exeption classes come unwrapped in link.exitcase
- yield " %s e.match(space, %s):" % (q,
- self.nameof(link.exitcase))
- q = "elif"
- for op in self.gen_link(link, localscope, blocknum, block, {
- link.last_exception: 'e.w_type',
- link.last_exc_value: 'e.get_w_value(space)'}):
- yield " %s" % op
- yield " else:raise # unhandled case, should not happen"
- else:
- # block ending in a switch on a value
- exits = list(block.exits)
- if len(exits) == 2 and (
- exits[0].exitcase is False and exits[1].exitcase is True):
- # order these guys like Python does
- exits.reverse()
- q = "if"
- for link in exits[:-1]:
- yield "%s %s == %s:" % (q, self.expr(block.exitswitch,
- localscope),
- link.exitcase)
- for op in self.gen_link(link, localscope, blocknum, block):
- yield " %s" % op
- q = "elif"
- link = exits[-1]
- yield "else:"
- for op in self.gen_link(exits[-1], localscope, blocknum, block):
- yield " %s" % op
-
- cmpop = ('==', 'is') [self.specialize_goto]
- for block in allblocks:
- blockno = blocknum[block]
- yield ""
- yield " if goto %s %s:" % (cmpop, self.mklabel(blockno))
- for line in render_block(block):
- yield " %s" % line
-
-# ____________________________________________________________
-
- RPY_HEADER = '''#!/bin/env python
-# -*- coding: LATIN-1 -*-'''
-
- RPY_SEP = "#*************************************************************"
-
- RPY_INIT_HEADER = RPY_SEP + '''
-__name__ = "_geninterp_"+%(modname)r
-_geninterp_ = True
-
-def init%(modname)s(space):
- """NOT_RPYTHON"""
-'''
-
- RPY_INIT_FOOTER = '''
-# entry point: %(entrypointname)s, %(entrypoint)s
-if __name__ == "__main__":
- from pypy.objspace.std import StdObjSpace
- from pypy.objspace.std.model import UnwrapError
- space = StdObjSpace()
- init%(modname)s(space)
- ret = space.call(%(entrypoint)s, space.newtuple([]))
- try:
- print space.unwrap(ret)
- except UnwrapError:
- print "cannot unwrap, here the wrapped result:"
- print ret
-'''
-
-# _____________________________________________________________________
-
-# implementation of the interface that is finally only
-# used: translate_as_module
-
-import py.code
-import cStringIO as StringIO
-
-class memfile(object):
- _storage = {}
- def __init__(self, name, mode="r"):
- if mode == "w":
- self._storage[name] = StringIO.StringIO()
- elif mode == "r":
- try:
- data = self._storage[name].getvalue()
- except IndexError:
- f = file(name)
- data = f.read()
- f.close()
- self._storage[name] = StringIO.StringIO(data)
- else:
- raise ValueError, "mode %s not supported" % mode
- self._file = self._storage[name]
- def __getattr__(self, name):
- return getattr(self._file, name)
- def close(self):
- pass
-
-def translate_as_module(sourcetext, filename=None, modname="app2interpexec",
- do_imports_immediately=False, tmpname=None):
- """ compile sourcetext as a module, translating to interp level.
- The result is the init function that creates the wrapped module dict,
- together with the generated source text.
- This init function needs a space as argument.
- tmpname can be passed for debugging purposes.
-
- Example:
-
- initfunc, newsrc = translate_as_module(text)
- from pypy.objspace.std import Space
- space = Space()
- dic = initfunc(space)
- # and now use the members of the dict
- """
- from pypy.tool.lib_pypy import LIB_PYPY
- # create something like a module
- if type(sourcetext) is str:
- code = py.code.Source(sourcetext).compile()
- else:
- # assume we got an already compiled source
- code = sourcetext
- dic = {'__name__': modname}
- if filename:
- dic['__file__'] = filename
-
- # XXX allow the app-level code to contain e.g. "import _formatting"
- libdir = str(LIB_PYPY)
- sys.path.insert(0, libdir)
- try:
- if faked_set:
- import __builtin__
- __builtin__.set = fake_set
- __builtin__.frozenset = fake_frozenset
- try:
- exec code in dic
- finally:
- if libdir in sys.path:
- sys.path.remove(libdir)
-
- entrypoint = dic
- t = TranslationContext(verbose=False, simplifying=True,
- builtins_can_raise_exceptions=True,
- list_comprehension_operations=False)
- t.no_annotator_but_do_imports_immediately = do_imports_immediately
- gen = GenRpy(t, entrypoint, modname, dic)
-
- finally:
- if faked_set:
- del __builtin__.set
- del __builtin__.frozenset
-
- if tmpname:
- _file = file
- else:
- _file = memfile
- tmpname = 'nada'
- out = _file(tmpname, 'w')
- gen.f = out
- try:
- if faked_set:
- import __builtin__
- __builtin__.set = fake_set
- __builtin__.frozenset = fake_frozenset
- gen.gen_source(tmpname, file=_file)
- finally:
- if faked_set:
- del __builtin__.set
- del __builtin__.frozenset
- out.close()
- f = _file(tmpname)
- newsrc = f.read()
- f.close()
- code = py.code.Source(newsrc).compile()
- dic = {}
- exec code in dic
- # now we just need to return the init function,
- # which then needs to be called with the space to return the dict.
- return dic['init%s' % modname], newsrc
-
-#___________________________________________________________________
-
-# some testing code
-
-testcode = """
-def f(a, b):
- return a + b
-
-def g():
- return f(f(1, 2), f(4, 8))
-"""
-
-if __name__ == '__main__':
- res = translate_as_module(testcode, tmpname='/tmp/look.py')
diff --git a/pypy/translator/gensupp.py b/pypy/translator/gensupp.py
--- a/pypy/translator/gensupp.py
+++ b/pypy/translator/gensupp.py
@@ -5,61 +5,6 @@
import sys
-from pypy.objspace.flow.model import Block
-
-# ordering the blocks of a graph by source position
-
-def ordered_blocks(graph):
- # collect all blocks
- allblocks = []
- for block in graph.iterblocks():
- # first we order by offset in the code string
- if block.operations:
- ofs = block.operations[0].offset
- else:
- ofs = sys.maxint
- # then we order by input variable name or value
- if block.inputargs:
- txt = str(block.inputargs[0])
- else:
- txt = "dummy"
- allblocks.append((ofs, txt, block))
- allblocks.sort()
- #for ofs, txt, block in allblocks:
- # print ofs, txt, block
- return [block for ofs, txt, block in allblocks]
-
-# a unique list, similar to a list.
-# append1 appends an object only if it is not there, already.
-
-class UniqueList(list):
- def __init__(self, *args, **kwds):
- list.__init__(self, *args, **kwds)
- self.dic = {}
-
- def append1(self, arg):
- try:
- self.dic[arg]
- except KeyError:
- self.dic[arg] = 1
- list.append(self, arg)
- except TypeError: # not hashable
- if arg not in self:
- list.append(self, arg)
-
-def builtin_base(obj):
- typ = type(obj)
- return builtin_type_base(typ)
-
-def builtin_type_base(typ):
- from copy_reg import _HEAPTYPE
- while typ.__flags__&_HEAPTYPE:
- typ = typ.__base__
- return typ
-
-def c_string(s):
- return '"%s"' % (s.replace('\\', '\\\\').replace('"', '\"'),)
-
def uniquemodulename(name, SEEN={}):
# never reuse the same module name within a Python session!
i = 0
diff --git a/pypy/translator/goal/targetpypystandalone.py b/pypy/translator/goal/targetpypystandalone.py
--- a/pypy/translator/goal/targetpypystandalone.py
+++ b/pypy/translator/goal/targetpypystandalone.py
@@ -242,7 +242,6 @@
filename = os.path.join(this_dir, 'app_main.py')
app = gateway.applevel(open(filename).read(), 'app_main.py', 'app_main')
app.hidden_applevel = False
- app.can_use_geninterp = False
w_dict = app.getwdict(space)
entry_point = create_entry_point(space, w_dict)
diff --git a/pypy/translator/oosupport/test_template/overflow.py b/pypy/translator/oosupport/test_template/overflow.py
--- a/pypy/translator/oosupport/test_template/overflow.py
+++ b/pypy/translator/oosupport/test_template/overflow.py
@@ -3,9 +3,12 @@
class BaseTestOverflow:
- def check(self, fn, args):
+ def check(self, fn, args, expected=None):
res1 = self.interpret(fn, args)
- res2 = fn(*args)
+ if expected is not None:
+ res2 = expected
+ else:
+ res2 = fn(*args)
assert res1 == res2
def test_add(self):
@@ -63,7 +66,9 @@
return ovfcheck(x % y)
except OverflowError:
return 42
- self.check(fn, [-sys.maxint-1, -1])
+ # force the expected result to be 42, because direct run of ovfcheck()
+ # cannot detect this particular overflow case
+ self.check(fn, [-sys.maxint-1, -1], expected=42)
def test_div(self):
def fn(x, y):
diff --git a/pypy/translator/test/snippet.py b/pypy/translator/test/snippet.py
--- a/pypy/translator/test/snippet.py
+++ b/pypy/translator/test/snippet.py
@@ -647,49 +647,6 @@
result += 1.0 / n
return result
-
-# specifically for geninterp testing
-
-def t_isinstance(x, y):
- return isinstance(x, (int, long)) and isinstance(y, int)
-
-def t_issubclass(x, y):
- return issubclass(type(x), (int, long)) and issubclass(type(y), int)
-
-def t_neg_long():
- return -132
-
-def t_attrerror(x):
- try:
- return x.foobar
- except AttributeError:
- return 567
-
-
-class Exc(Exception):
- def __init__(self, v):
- Exception.__init__(self, v)
-
-def exception_subclass_sanity(x):
- try:
- raise Exc(x)
- except Exception, e:
- return e.args[0]
-
-
-class HaveProp(object):
-
- def __init__(self, v):
- self.v = v
-
- def _hi(self):
- return self.v
- hi = property(_hi, doc="HaveProp._hi")
-
-
-def run_prop(v):
- return HaveProp(v).hi
-
# --------------------(Currently) Non runnable Functions ---------------------
def _somebug1(n=int):
diff --git a/pypy/translator/test/test_geninterp.py b/pypy/translator/test/test_geninterp.py
deleted file mode 100644
--- a/pypy/translator/test/test_geninterp.py
+++ /dev/null
@@ -1,302 +0,0 @@
-"""
-Description
-_____________________________
-
-This test is almost a copy of test_genc.py
-The setup code is slightly different:
-Instead of compiling single functions from
-snippets.py, almost all of snippets is translated,
-up to the point where they are untranslatable.
-snippets has been slightly re-ordered for that.
-
-The idea was to create a couple of tests without much
-extra work, in a sense derived from the test_genc.
-
-A problem with that is, that the tests actually should
-be run at application level. The test code checks real
-Python values,so we have to do tricks to unwrap things.
-This is limited:
-Some tests cannot work, since they mutate their arguments.
-Some tests operate with un-unwrappable things.
-Those are disabled for the moment by an 'needapp_' prefix.
-
-XXX think about a way to produce more tests from a common
-XXX basis. Should we write generators for such tests like this?
-"""
-import autopath
-import py
-from pypy.tool.udir import udir
-from pypy.objspace.flow.model import *
-from pypy.translator.geninterplevel import translate_as_module
-from pypy.translator.test import snippet
-from pypy.interpreter.error import OperationError
-from py.code import Source
-
-class TestGenRpyTestCase:
- objspacename = 'std'
-
- snippet_ad = """if 1:
- def import_func():
- import copyreg
- return copyreg._reconstructor.__code__.co_name
-
- def import_sys_func():
- import sys
- return sys.__name__
-"""
-
- def setup_class(cls):
- # simply compile snippets just once
- src = str(Source(snippet))
- # truncate non-compilable stuff for now:
- p = src.index('Non compilable Functions')
- src = src[:p] + '\n'
- # put our ad into snippet
- exec cls.snippet_ad in snippet.__dict__
- src += cls.snippet_ad
- # just in case of trouble, we produce a tempfile
- ini, newsrc = translate_as_module(src, tmpname = str(
- udir.join("_geninterp_test.py")))
- cls.w_glob = ini(cls.space)
-
- def build_interpfunc(self, func, *morefuncs):
- # we ignore morefuncs, since they live in snippets
- space = self.space
- func = space.getitem(self.w_glob, space.wrap(func.__name__))
- def wrapunwrap(*args):
- w_args = space.wrap(args)
- try:
- w_res = space.call(func, w_args)
- except OperationError, e:
- w_typ = e.w_type
- # XXX how to unwrap an exception?
- name = space.unwrap(space.getattr(w_typ, space.wrap('__name__')))
- exc = __builtins__[name]
- raise exc
- return space.unwrap(w_res)
- return wrapunwrap
-
- # small addition to see whether imports look fine
- def test_import(self):
- import copy_reg
- impfunc = self.build_interpfunc(snippet.import_func)
- assert impfunc() == '_reconstructor'
-
- def test_import_sys(self):
- impfunc = self.build_interpfunc(snippet.import_sys_func)
- assert impfunc() == 'sys'
-
- def test_simple_func(self):
- cfunc = self.build_interpfunc(snippet.simple_func)
- assert cfunc(1) == 2
-
- def test_while_func(self):
- while_func = self.build_interpfunc(snippet.while_func)
- assert while_func(10) == 55
-
- def test_nested_whiles(self):
- nested_whiles = self.build_interpfunc(snippet.nested_whiles)
- assert nested_whiles(111, 114) == (
- '...!...!...!...!...!')
-
- def test_poor_man_range(self):
- poor_man_range = self.build_interpfunc(snippet.poor_man_range)
- assert poor_man_range(10) == range(10)
-
- def poor_man_rev_range(self):
- poor_man_rev_range = self.build_interpfunc(snippet.poor_man_rev_range)
- assert poor_man_rev_range(10) == range(9,-1,-1)
-
- def test_simple_id(self):
- #we just want to see, if renaming of parameter works correctly
- #if the first branch is the end branch
- simple_id = self.build_interpfunc(snippet.simple_id)
- assert simple_id(9) == 9
-
- def test_branch_id(self):
- branch_id = self.build_interpfunc(snippet.branch_id)
- assert branch_id(1, 2, 3) == 2
- assert branch_id(0, 2, 3) == 3
-
- def test_int_id(self):
- int_id = self.build_interpfunc(snippet.int_id)
- assert int_id(3) == 3
-
- def dont_test_attrs(self):
- attrs = self.build_interpfunc(snippet.attrs)
- assert attrs() == 9
-
- def test_builtinusage(self):
- fun = self.build_interpfunc(snippet.builtinusage)
- assert fun() == 4
-
- def xpensive_test_sieve(self):
- sieve = self.build_interpfunc(snippet.sieve_of_eratosthenes)
- assert sieve() == 1028
-
- def test_slice(self):
- half = self.build_interpfunc(snippet.half_of_n)
- assert half(10) == 5
-
- def test_poly_branch(self):
- poly_branch = self.build_interpfunc(snippet.poly_branch)
- assert poly_branch(10) == [1,2,3]*2
- assert poly_branch(0) == ['a','b','c']*2
-
- def test_and(self):
- sand = self.build_interpfunc(snippet.s_and)
- assert sand(5, 6) == "yes"
- assert sand(5, 0) == "no"
- assert sand(0, 6) == "no"
- assert sand(0, 0) == "no"
-
- def test_yast(self):
- yast = self.build_interpfunc(snippet.yast)
- assert yast([1000,100,10,1]) == 1111
- assert yast(range(100)) == (99*100)/2
-
- def test_with_init(self):
- with_init = self.build_interpfunc(snippet.with_init)
- assert with_init(0) == 0
- assert with_init(-100) == -100
-
- def test_with_more_init(self):
- with_more_init = self.build_interpfunc(snippet.with_more_init)
- assert with_more_init(10, False) == -10
- assert with_more_init(20, True) == 20
-
- def needapp_test_global_instance(self):
- global_instance = self.build_interpfunc(snippet.global_instance)
- assert global_instance() == 42
-
- def needapp_test_global_newstyle_instance(self):
- global_newstyle_instance = self.build_interpfunc(snippet.global_newstyle_instance)
- assert global_newstyle_instance().a == 1
-
- def needapp_test_global_recursive_list(self):
- global_recursive_list = self.build_interpfunc(snippet.global_recursive_list)
- lst = global_recursive_list()
- assert len(lst) == 1
- assert lst[0] is lst
-
-## def test_global_badinit(self):
-## global_badinit = self.build_interpfunc(snippet.global_badinit)
-## self.assertEquals(global_badinit(), 1)
-
- def test_multiple_inheritance(self):
- multiple_inheritance = self.build_interpfunc(snippet.multiple_inheritance)
- assert multiple_inheritance() == 1+2+3+4
-
- def test_call_star_args0(self):
- call_star_args = self.build_interpfunc(snippet.call_star_args0)
- assert call_star_args(42) == 21
-
- def test_call_star_args1(self):
- call_star_args = self.build_interpfunc(snippet.call_star_args1)
- assert call_star_args(30) == 40
-
- def test_call_star_args1def(self):
- call_star_args = self.build_interpfunc(snippet.call_star_args1def)
- assert call_star_args(7) == 45
-
- def test_call_star_args(self):
- call_star_args = self.build_interpfunc(snippet.call_star_args)
- assert call_star_args(42) == 52
-
- def test_call_default_args(self):
- call_default_args = self.build_interpfunc(snippet.call_default_args)
- assert call_default_args(42) == 111+42+3
-
- def test_call_default_and_star_args(self):
- call_default_and_star_args = self.build_interpfunc(
- snippet.call_default_and_star_args)
- assert call_default_and_star_args(42) == (
- (111+42+3+0, -1000-2000-3000+2))
-
- def test_call_with_star(self):
- call_with_star = self.build_interpfunc(snippet.call_with_star)
- assert call_with_star(()) == -15L
- assert call_with_star((4,)) == -13L
- assert call_with_star((4,7)) == -9L
- assert call_with_star([]) == -15L
- assert call_with_star([4]) == -13L
- assert call_with_star([4,7]) == -9L
- raises(TypeError, call_with_star, (4,7,12))
- raises(TypeError, call_with_star, [4,7,12,63])
- raises(TypeError, call_with_star, 521)
-
- def test_call_with_keyword(self):
- call_with_keyword = self.build_interpfunc(snippet.call_with_keyword)
- assert call_with_keyword(100) == 82
-
- def test_call_very_complex(self):
- call_very_complex = self.build_interpfunc(snippet.call_very_complex,
- snippet.default_args)
- assert call_very_complex(5, (3,), {}) == -12
- assert call_very_complex(5, (), {'y': 3}) == -12
- raises(TypeError, call_very_complex, 5, (3,), {'y': 4})
-
- def test_finallys(self):
- finallys = self.build_interpfunc(snippet.finallys)
- assert finallys(['hello']) == 8
- assert finallys('X') == 8
- assert finallys([]) == 6
- assert finallys('XY') == 6
-
- def needapp_test_finally2(self):
- finally2 = self.build_interpfunc(snippet.finally2)
- lst = range(10)
- finally2(lst, 5)
- assert lst == [0,1,2,3,4, 6, 6,7,8, 'done']
- dic = {}
- raises(KeyError, finally2, dic, "won't find this key")
- assert dic == {-1: 'done'}
-
- def test_bare_raise(self):
- bare_raise = self.build_interpfunc(snippet.bare_raise)
- assert bare_raise(range(0, 100, 10), False) == 50
- assert bare_raise(range(0, 100, 10), True) == 50
- raises(IndexError, bare_raise, range(0, 30, 10), False)
- assert bare_raise(range(0, 30, 10), True) == None
-
- def needapp_test_get_set_del_slice(self):
- fn = self.build_interpfunc(snippet.get_set_del_slice)
- l = list('abcdefghij')
- result = fn(l)
- assert l == [3, 'c', 8, 11, 'h', 9]
- assert result == ([3, 'c'], [9], [11, 'h'])
-
- def test_do_try_raise_choose(self):
- fn = self.build_interpfunc(snippet.do_try_raise_choose)
- result = fn()
- assert result == [-1,0,1,2]
-
-
- def test_t_isinstance(self):
- fn = self.build_interpfunc(snippet.t_isinstance)
- result = fn(1, 2)
- assert result == True
-
- def test_t_issubclass(self):
- fn = self.build_interpfunc(snippet.t_issubclass)
- result = fn(1, 2)
- assert result == True
-
- def test_negative_long(self):
- fn = self.build_interpfunc(snippet.t_neg_long)
- result = fn()
- assert result == -132 and type(result) is int
-
- def test_attributeerror(self):
- fn = self.build_interpfunc(snippet.t_attrerror)
- result = fn(42)
- assert result == 567
-
- def test_Exception_subclass(self):
- fn = self.build_interpfunc(snippet.exception_subclass_sanity)
- result = fn(7)
- assert result == 7
-
- def test_property(self):
- fn = self.build_interpfunc(snippet.run_prop)
- assert fn(23) == 23
diff --git a/pypy/translator/test/test_rpystone.py b/pypy/translator/test/test_rpystone.py
deleted file mode 100644
--- a/pypy/translator/test/test_rpystone.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from pypy.translator.geninterplevel import translate_as_module, __file__ as __
-from pypy.objspace.std import Space
-import os
-fname = os.path.join(os.path.dirname(__), "test", "rpystone.py")
-src = file(fname).read()
-init, ign = translate_as_module(src)#, tmpname="/tmp/look.py")
-
-LOOPS = 25
-
-def test_rpystone():
- space = Space()
- modic = init(space)
- entry = space.getitem(modic, space.wrap("entrypoint"))
- # warm-up,to get everything translated
- space.call(entry, space.newtuple([space.wrap(-1)]))
- # now this is the real one
- space.call(entry, space.newtuple([space.wrap(LOOPS)]))
-
-if __name__ == "__main__":
- test_rpystone()
\ No newline at end of file
diff --git a/pypy/translator/translator.py b/pypy/translator/translator.py
--- a/pypy/translator/translator.py
+++ b/pypy/translator/translator.py
@@ -21,7 +21,6 @@
FLOWING_FLAGS = {
'verbose': False,
'simplifying': True,
- 'builtins_can_raise_exceptions': False,
'list_comprehension_operations': False, # True, - not super-tested
}
@@ -31,7 +30,6 @@
config = get_pypy_config(translating=True)
# ZZZ should go away in the end
for attr in ['verbose', 'simplifying',
- 'builtins_can_raise_exceptions',
'list_comprehension_operations']:
if attr in flowing_flags:
setattr(config.translation, attr, flowing_flags[attr])
More information about the pypy-commit
mailing list