def setup_method(self, method): def c(x, y, *args): pass code = PyCode._from_code(self.space, c.func_code) class ConcreteFastscopeFrame(Frame): def __init__(self, space, code, numlocals): self.code = code Frame.__init__(self, space) self.numlocals = numlocals self._fastlocals_w = [None] * self.numlocals def getcode(self): return self.code def setfastscope(self, scope_w): self._fastlocals_w = scope_w def getfastscope(self): return self._fastlocals_w def getfastscopelength(self): return self.numlocals self.f = ConcreteFastscopeFrame(self.space, code, numlocals=5)
def test_flatcall(self): space = self.space def f(a): return a code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict()) assert fn.code.fast_natural_arity == 1 | PyCode.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_res = space.call_function(fn, w_3) assert w_res is w_3 w_res = space.appexec([fn, w_3], """(f, x): return f(x) """) assert w_res is w_3
def setup_method(self, method): def c(x, y, *args): pass code = PyCode._from_code(self.space, c.func_code) class ConcreteFastscopeFrame(Frame): def __init__(self, space, code, numlocals): self.code = code Frame.__init__(self, space) self.numlocals = numlocals self.fastlocals_w = [None] * self.numlocals def getcode(self): return self.code def setfastscope(self, scope_w): self.fastlocals_w = scope_w def getfastscope(self): return self.fastlocals_w def getfastscopelength(self): return self.numlocals self.f = ConcreteFastscopeFrame(self.space, code, numlocals=5)
def test_flatcall_default_arg(self): space = self.space def f(a, b): return a+b code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict(), defs_w=[space.newint(1)]) assert fn.code.fast_natural_arity == 2|eval.Code.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_4 = space.newint(4) # ignore this for now #w_res = space.call_function(fn, w_3) # assert space.eq_w(w_res, w_4) w_res = space.appexec([fn, w_3], """(f, x): return f(x) """) assert space.eq_w(w_res, w_4)
def test_flatcall_method(self): space = self.space def f(self, a): return a code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict()) assert fn.code.fast_natural_arity == 2|PyCode.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_res = space.appexec([fn, w_3], """(f, x): class A(object): m = f y = A().m(x) b = A().m z = b(x) return y is x and z is x """) assert space.is_true(w_res)
def test_flatcall_default_arg_method(self): space = self.space def f(self, a, b): return a+b code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict(), defs_w=[space.newint(1)]) assert fn.code.fast_natural_arity == 3|eval.Code.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_res = space.appexec([fn, w_3], """(f, x): class A(object): m = f y = A().m(x) b = A().m z = b(x) return y+10*z """) assert space.eq_w(w_res, space.wrap(44))
def test_flatcall_method(self): space = self.space def f(self, a): return a code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict()) assert fn.code.fast_natural_arity == 2 | PyCode.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_res = space.appexec([fn, w_3], """(f, x): class A(object): m = f y = A().m(x) b = A().m z = b(x) return y is x and z is x """) assert space.is_true(w_res)
def test_flatcall_default_arg(self): space = self.space def f(a, b): return a + b code = PyCode._from_code(self.space, f.__code__) fn = Function(self.space, code, self.space.newdict(), defs_w=[space.newint(1)]) assert fn.code.fast_natural_arity == 2 | eval.Code.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_4 = space.newint(4) # ignore this for now #w_res = space.call_function(fn, w_3) # assert space.eq_w(w_res, w_4) w_res = space.appexec([fn, w_3], """(f, x): return f(x) """) assert space.eq_w(w_res, w_4)
def test_flatcall_default_arg_method(self): space = self.space def f(self, a, b): return a + b code = PyCode._from_code(self.space, f.__code__) fn = Function(self.space, code, self.space.newdict(), defs_w=[space.newint(1)]) assert fn.code.fast_natural_arity == 3 | eval.Code.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_res = space.appexec([fn, w_3], """(f, x): class A(object): m = f y = A().m(x) b = A().m z = b(x) return y+10*z """) assert space.eq_w(w_res, space.wrap(44))
def test_call_function(self): space = self.space d = {} for i in range(10): args = "(" + ''.join(["a%d," % a for a in range(i)]) + ")" exec """ def f%s: return %s """ % (args, args) in d f = d['f'] res = f(*range(i)) code = PyCode._from_code(self.space, f.__code__) fn = Function(self.space, code, self.space.newdict()) assert fn.code.fast_natural_arity == i | PyCode.FLATPYCALL if i < 5: def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb args_w = map(space.wrap, range(i)) w_res = space.call_function(fn, *args_w) check = space.is_true(space.eq(w_res, space.wrap(res))) assert check
def test_method_get(self): space = self.space # Create some function for this test only def m(self): return self func = Function(space, PyCode._from_code(self.space, m.__code__), space.newdict()) # Some shorthands obj1 = space.wrap(23) obj2 = space.wrap(42) args = Arguments(space, []) # Check method returned from func.__get__() w_meth1 = descr_function_get(space, func, obj1, space.type(obj1)) meth1 = space.unwrap(w_meth1) assert isinstance(meth1, Method) assert meth1.call_args(args) == obj1 # Check method returned from method.__get__() # --- meth1 is already bound so meth1.__get__(*) is meth1. w_meth2 = meth1.descr_method_get(obj2, space.type(obj2)) meth2 = space.unwrap(w_meth2) assert isinstance(meth2, Method) assert meth2.call_args(args) == obj1 # Check method returned from unbound_method.__get__() w_meth3 = descr_function_get(space, func, space.w_None, space.type(obj2)) meth3 = space.unwrap(w_meth3) assert meth3 is func
def test_flatcall(self): space = self.space def f(a): return a code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict()) assert fn.code.fast_natural_arity == 1|PyCode.FLATPYCALL def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb w_3 = space.newint(3) w_res = space.call_function(fn, w_3) assert w_res is w_3 w_res = space.appexec([fn, w_3], """(f, x): return f(x) """) assert w_res is w_3
def test_call_function(self): space = self.space d = {} for i in range(10): args = "(" + ''.join(["a%d," % a for a in range(i)]) + ")" exec """ def f%s: return %s """ % (args, args) in d f = d['f'] res = f(*range(i)) code = PyCode._from_code(self.space, f.func_code) fn = Function(self.space, code, self.space.newdict()) assert fn.code.fast_natural_arity == i|PyCode.FLATPYCALL if i < 5: def bomb(*args): assert False, "shortcutting should have avoided this" code.funcrun = bomb code.funcrun_obj = bomb args_w = map(space.wrap, range(i)) w_res = space.call_function(fn, *args_w) check = space.is_true(space.eq(w_res, space.wrap(res))) assert check
def test_method_get(self): space = self.space # Create some function for this test only def m(self): return self func = Function(space, PyCode._from_code(self.space, m.func_code), space.newdict()) # Some shorthands obj1 = space.wrap(23) obj2 = space.wrap(42) args = Arguments(space, []) # Check method returned from func.__get__() w_meth1 = descr_function_get(space, func, obj1, space.type(obj1)) meth1 = space.unwrap(w_meth1) assert isinstance(meth1, Method) assert meth1.call_args(args) == obj1 # Check method returned from method.__get__() # --- meth1 is already bound so meth1.__get__(*) is meth1. w_meth2 = meth1.descr_method_get(obj2, space.type(obj2)) meth2 = space.unwrap(w_meth2) assert isinstance(meth2, Method) assert meth2.call_args(args) == obj1 # Check method returned from unbound_method.__get__() w_meth3 = descr_function_get(space, func, None, space.type(obj2)) meth3 = space.unwrap(w_meth3) w_meth4 = meth3.descr_method_get(obj2, space.w_None) meth4 = space.unwrap(w_meth4) assert isinstance(meth4, Method) assert meth4.call_args(args) == obj2 # Check method returned from unbound_method.__get__() # --- with an incompatible class w_meth5 = meth3.descr_method_get(space.wrap('hello'), space.w_str) assert space.is_w(w_meth5, w_meth3)
def test_AppFrame(space): import sys co = PyCode._from_code(space, somefunc.func_code) pyframe = space.FrameClass(space, co, space.newdict(), None) runner = AppFrame(space, pyframe) interpret("f = lambda x: x+1", runner, should_fail=False) msg = interpret("assert isinstance(f(2), float)", runner) assert msg.startswith("assert isinstance(3, float)\n" " + where 3 = ")
def test_AppFrame(space): import sys co = PyCode._from_code(space, somefunc.func_code) pyframe = PyFrame(space, co, space.newdict(), None) runner = AppFrame(space, pyframe) exprinfo.run("f = lambda x: x+1", runner) msg = exprinfo.interpret("assert isinstance(f(2), float)", runner) assert msg.startswith("assert isinstance(3, float)\n" " + where 3 = ")
def check(self, w_dict, evalexpr, expected): # for now, we compile evalexpr with CPython's compiler but run # it with our own interpreter to extract the data from w_dict co_expr = compile(evalexpr, "<evalexpr>", "eval") space = self.space pyco_expr = PyCode._from_code(space, co_expr) w_res = pyco_expr.exec_code(space, w_dict, w_dict) res = space.str_w(space.repr(w_res)) assert res == repr(expected)
def check(self, w_dict, evalexpr, expected): # for now, we compile evalexpr with CPython's compiler but run # it with our own interpreter to extract the data from w_dict co_expr = compile(evalexpr, '<evalexpr>', 'eval') space = self.space pyco_expr = PyCode._from_code(space, co_expr) w_res = pyco_expr.exec_code(space, w_dict, w_dict) res = space.str_w(space.repr(w_res)) assert res == repr(expected)
def eval(self, expression, w_globals, w_locals): "NOT_RPYTHON: For internal debugging." import types from pypy.interpreter.pycode import PyCode if isinstance(expression, str): expression = compile(expression, '?', 'eval') if isinstance(expression, types.CodeType): expression = PyCode._from_code(self, expression) if not isinstance(expression, PyCode): raise TypeError, 'space.eval(): expected a string, code or PyCode object' return expression.exec_code(self, w_globals, w_locals)
def _testfile(space, magic, mtime, co=None): cpathname = str(udir.join('test.pyc')) f = file(cpathname, "wb") f.write(_getlong(magic)) f.write(_getlong(mtime)) if co: # marshal the code object with the PyPy marshal impl pyco = PyCode._from_code(space, co) w_marshal = space.getbuiltinmodule('marshal') w_marshaled_code = space.call_method(w_marshal, 'dumps', pyco) marshaled_code = space.bytes_w(w_marshaled_code) f.write(marshaled_code) f.close() return cpathname
def check(self, w_dict, evalexpr, expected): # for now, we compile evalexpr with CPython's compiler but run # it with our own interpreter to extract the data from w_dict co_expr = compile(evalexpr, '<evalexpr>', 'eval') space = self.space pyco_expr = PyCode._from_code(space, co_expr) w_res = pyco_expr.exec_host_bytecode(w_dict, w_dict) res = space.str_w(space.repr(w_res)) if not isinstance(expected, float): assert res == repr(expected) else: # Float representation can vary a bit between interpreter # versions, compare the numbers instead. assert eval(res) == expected
def exec_(self, statement, w_globals, w_locals, hidden_applevel=False): "NOT_RPYTHON: For internal debugging." import types from pypy.interpreter.pycode import PyCode if isinstance(statement, str): statement = compile(statement, '?', 'exec') if isinstance(statement, types.CodeType): statement = PyCode._from_code(self, statement, hidden_applevel=hidden_applevel) if not isinstance(statement, PyCode): raise TypeError, 'space.exec_(): expected a string, code or PyCode object' w_key = self.wrap('__builtins__') if not self.is_true(self.contains(w_globals, w_key)): self.setitem(w_globals, w_key, self.wrap(self.builtin)) return statement.exec_code(self, w_globals, w_locals)
def test_method_get(self): space = self.space # Create some function for this test only def m(self): return self func = Function(space, PyCode._from_code(self.space, m.func_code), space.newdict()) # Some shorthands obj1 = space.wrap(23) obj2 = space.wrap(42) args = Arguments(space, []) # Check method returned from func.__get__() w_meth1 = descr_function_get(space, func, obj1, space.type(obj1)) meth1 = space.unwrap(w_meth1) assert isinstance(meth1, Method) assert meth1.call_args(args) == obj1 # Check method returned from method.__get__() # --- meth1 is already bound so meth1.__get__(*) is meth1. w_meth2 = meth1.descr_method_get(obj2, space.type(obj2)) meth2 = space.unwrap(w_meth2) assert isinstance(meth2, Method) assert meth2.call_args(args) == obj1 # Check method returned from unbound_method.__get__() w_meth3 = descr_function_get(space, func, space.w_None, space.type(obj2)) meth3 = space.unwrap(w_meth3) w_meth4 = meth3.descr_method_get(obj2, space.w_None) meth4 = space.unwrap(w_meth4) assert isinstance(meth4, Method) assert meth4.call_args(args) == obj2 # Check method returned from unbound_method.__get__() # --- with an incompatible class w_meth5 = meth3.descr_method_get(space.wrap('hello'), space.w_text) assert space.is_w(w_meth5, w_meth3) # Same thing, with an old-style class w_oldclass = space.call_function(space.builtin.get('__metaclass__'), space.wrap('OldClass'), space.newtuple([]), space.newdict()) w_meth6 = meth3.descr_method_get(space.wrap('hello'), w_oldclass) assert space.is_w(w_meth6, w_meth3) # Reverse order of old/new styles w_meth7 = descr_function_get(space, func, space.w_None, w_oldclass) meth7 = space.unwrap(w_meth7) w_meth8 = meth7.descr_method_get(space.wrap('hello'), space.w_text) assert space.is_w(w_meth8, w_meth7)
def getframe(self, func): space = self.space try: func = func.im_func except AttributeError: pass code = func.func_code code = PyCode._from_code(self.space, code) w_globals = Constant({}) # space.newdict() frame = self.space.createframe(code, w_globals) formalargcount = code.getformalargcount() dummy = Constant(None) # dummy.dummy = True arg_list = [Variable() for i in range(formalargcount)] + [dummy] * (frame.nlocals - formalargcount) frame.setfastscope(arg_list) return frame
def build_flow(self, func, constargs={}): """ """ if func.func_doc and func.func_doc.lstrip().startswith('NOT_RPYTHON'): raise Exception, "%r is tagged as NOT_RPYTHON" % (func, ) code = func.func_code if code.co_flags & 32: # generator raise TypeError("%r is a generator" % (func, )) code = PyCode._from_code(self, code) if func.func_closure is None: closure = None else: closure = [ extract_cell_content(c, name, func) for c, name in zip( func.func_closure, func.func_code.co_freevars) ] # CallableFactory.pycall may add class_ to functions that are methods name = func.func_name class_ = getattr(func, 'class_', None) if class_ is not None: name = '%s.%s' % (class_.__name__, name) for c in "<>&!": name = name.replace(c, '_') ec = flowcontext.FlowExecutionContext(self, code, func.func_globals, constargs, closure, name) graph = ec.graph graph.func = func # attach a signature and defaults to the graph # so that it becomes even more interchangeable with the function # itself graph.signature = cpython_code_signature(code) graph.defaults = func.func_defaults or () self.setup_executioncontext(ec) from pypy.tool.error import FlowingError, format_global_error try: ec.build_flow() except FlowingError, a: # attach additional source info to AnnotatorError _, _, tb = sys.exc_info() e = FlowingError( format_global_error(ec.graph, ec.crnt_offset, str(a))) raise FlowingError, e, tb
def check(self, w_dict, evalexpr, expected): # for now, we compile evalexpr with CPython's compiler but run # it with our own interpreter to extract the data from w_dict co_expr = compile(evalexpr, '<evalexpr>', 'eval') space = self.space pyco_expr = PyCode._from_code(space, co_expr) w_res = pyco_expr.exec_host_bytecode(w_dict, w_dict) res = space.str_w(space.repr(w_res)) expected_repr = self.get_py3_repr(expected) if isinstance(expected, float): # Float representation can vary a bit between interpreter # versions, compare the numbers instead. assert eval(res) == expected elif isinstance(expected, long): assert expected_repr.endswith('L') assert res == expected_repr[:-1] # in py3 we don't have the L suffix else: assert res == expected_repr
def getframe(self, func): space = self.space try: func = func.im_func except AttributeError: pass code = func.func_code code = PyCode._from_code(self.space, code) w_globals = Constant({}) # space.newdict() frame = self.space.createframe(code, w_globals) formalargcount = code.getformalargcount() dummy = Constant(None) #dummy.dummy = True arg_list = ([Variable() for i in range(formalargcount)] + [dummy] * (len(frame.fastlocals_w) - formalargcount)) frame.setfastscope(arg_list) return frame
def build_flow(self, func, constargs={}, tweak_for_generator=True): """ """ if func.func_doc and func.func_doc.lstrip().startswith('NOT_RPYTHON'): raise Exception, "%r is tagged as NOT_RPYTHON" % (func, ) code = func.func_code is_generator = bool(code.co_flags & CO_GENERATOR) code = PyCode._from_code(self, code) if func.func_closure is None: cl = None else: cl = [extract_cell_content(c) for c in func.func_closure] # CallableFactory.pycall may add class_ to functions that are methods name = func.func_name class_ = getattr(func, 'class_', None) if class_ is not None: name = '%s.%s' % (class_.__name__, name) for c in "<>&!": name = name.replace(c, '_') class outerfunc: # hack closure = cl ec = flowcontext.FlowExecutionContext(self, code, func.func_globals, constargs, outerfunc, name, is_generator) graph = ec.graph graph.func = func # attach a signature and defaults to the graph # so that it becomes even more interchangeable with the function # itself graph.signature = cpython_code_signature(code) graph.defaults = func.func_defaults or () self.setup_executioncontext(ec) try: ec.build_flow() except error.FlowingError, a: # attach additional source info to AnnotatorError _, _, tb = sys.exc_info() formated = error.format_global_error(ec.graph, ec.crnt_offset, str(a)) e = error.FlowingError(formated) raise error.FlowingError, e, tb
def check(self, w_dict, evalexpr, expected): # for now, we compile evalexpr with CPython's compiler but run # it with our own interpreter to extract the data from w_dict co_expr = compile(evalexpr, '<evalexpr>', 'eval') space = self.space pyco_expr = PyCode._from_code(space, co_expr) w_res = pyco_expr.exec_host_bytecode(w_dict, w_dict) res = space.str_w(space.repr(w_res)) expected_repr = self.get_py3_repr(expected) if isinstance(expected, float): # Float representation can vary a bit between interpreter # versions, compare the numbers instead. assert eval(res) == expected elif isinstance(expected, long): assert expected_repr.endswith('L') assert res == expected_repr[: -1] # in py3 we don't have the L suffix else: assert res == expected_repr
def test_method_get(self): space = self.space # Create some function for this test only def m(self): return self func = Function(space, PyCode._from_code(self.space, m.func_code), space.newdict()) # Some shorthands obj1 = space.wrap(23) obj2 = space.wrap(42) args = Arguments(space, []) # Check method returned from func.__get__() w_meth1 = descr_function_get(space, func, obj1, space.type(obj1)) meth1 = space.unwrap(w_meth1) assert isinstance(meth1, Method) assert meth1.call_args(args) == obj1 # Check method returned from method.__get__() # --- meth1 is already bound so meth1.__get__(*) is meth1. w_meth2 = meth1.descr_method_get(obj2, space.type(obj2)) meth2 = space.unwrap(w_meth2) assert isinstance(meth2, Method) assert meth2.call_args(args) == obj1 # Check method returned from unbound_method.__get__() w_meth3 = descr_function_get(space, func, space.w_None, space.type(obj2)) meth3 = space.unwrap(w_meth3) w_meth4 = meth3.descr_method_get(obj2, space.w_None) meth4 = space.unwrap(w_meth4) assert isinstance(meth4, Method) assert meth4.call_args(args) == obj2 # Check method returned from unbound_method.__get__() # --- with an incompatible class w_meth5 = meth3.descr_method_get(space.wrap('hello'), space.w_str) assert space.is_w(w_meth5, w_meth3) # Same thing, with an old-style class w_oldclass = space.call_function( space.builtin.get('__metaclass__'), space.wrap('OldClass'), space.newtuple([]), space.newdict()) w_meth6 = meth3.descr_method_get(space.wrap('hello'), w_oldclass) assert space.is_w(w_meth6, w_meth3) # Reverse order of old/new styles w_meth7 = descr_function_get(space, func, space.w_None, w_oldclass) meth7 = space.unwrap(w_meth7) w_meth8 = meth7.descr_method_get(space.wrap('hello'), space.w_str) assert space.is_w(w_meth8, w_meth7)
def build_flow(self, func, constargs={}): """ """ if func.func_doc and func.func_doc.lstrip().startswith('NOT_RPYTHON'): raise Exception, "%r is tagged as NOT_RPYTHON" % (func,) code = func.func_code if code.co_flags & 32: # generator raise TypeError("%r is a generator" % (func,)) code = PyCode._from_code(self, code) if func.func_closure is None: closure = None else: closure = [extract_cell_content(c, name, func) for c, name in zip(func.func_closure, func.func_code.co_freevars)] # CallableFactory.pycall may add class_ to functions that are methods name = func.func_name class_ = getattr(func, 'class_', None) if class_ is not None: name = '%s.%s' % (class_.__name__, name) for c in "<>&!": name = name.replace(c, '_') ec = flowcontext.FlowExecutionContext(self, code, func.func_globals, constargs, closure, name) graph = ec.graph graph.func = func # attach a signature and defaults to the graph # so that it becomes even more interchangeable with the function # itself graph.signature = cpython_code_signature(code) graph.defaults = func.func_defaults or () self.setup_executioncontext(ec) from pypy.tool.error import FlowingError, format_global_error try: ec.build_flow() except FlowingError, a: # attach additional source info to AnnotatorError _, _, tb = sys.exc_info() e = FlowingError(format_global_error(ec.graph, ec.crnt_offset, str(a))) raise FlowingError, e, tb
def build_flow(self, func, constargs={}, tweak_for_generator=True): """ """ if func.func_doc and func.func_doc.lstrip().startswith('NOT_RPYTHON'): raise Exception, "%r is tagged as NOT_RPYTHON" % (func,) code = func.func_code is_generator = bool(code.co_flags & CO_GENERATOR) code = PyCode._from_code(self, code) if func.func_closure is None: cl = None else: cl = [extract_cell_content(c) for c in func.func_closure] # CallableFactory.pycall may add class_ to functions that are methods name = func.func_name class_ = getattr(func, 'class_', None) if class_ is not None: name = '%s.%s' % (class_.__name__, name) for c in "<>&!": name = name.replace(c, '_') class outerfunc: # hack closure = cl ec = flowcontext.FlowExecutionContext(self, code, func.func_globals, constargs, outerfunc, name, is_generator) graph = ec.graph graph.func = func # attach a signature and defaults to the graph # so that it becomes even more interchangeable with the function # itself graph.signature = cpython_code_signature(code) graph.defaults = func.func_defaults or () self.setup_executioncontext(ec) try: ec.build_flow() except error.FlowingError, a: # attach additional source info to AnnotatorError _, _, tb = sys.exc_info() formated = error.format_global_error(ec.graph, ec.crnt_offset, str(a)) e = error.FlowingError(formated) raise error.FlowingError, e, tb
# TODO use a custom UnicodeError raise OperationError( space.w_UnicodeDecodeError, space.newtuple([ space.wrap(e.encoding), space.wrap(e.object), space.wrap(e.start), space.wrap(e.end), space.wrap(e.reason) ])) except ValueError, e: raise OperationError(space.w_ValueError, space.wrap(str(e))) except TypeError, e: raise OperationError(space.w_TypeError, space.wrap(str(e))) from pypy.interpreter.pycode import PyCode return PyCode._from_code(space, c) compile._annspecialcase_ = "override:cpy_compile" def _warn_explicit(self, message, category, filename, lineno, module=None, registry=None): if hasattr(category, '__bases__') and \ issubclass(category, SyntaxWarning): assert isinstance(message, str) space = self.space w_mod = space.sys.getmodule('warnings')
def setup_method(self, method): def c(self, bar): return bar code = PyCode._from_code(self.space, c.func_code) self.fn = Function(self.space, code, self.space.newdict())
space.wrap(e.lineno), space.wrap(e.offset), space.wrap(e.text)])]) raise OperationError(space.w_SyntaxError, w_synerr) except UnicodeDecodeError, e: # TODO use a custom UnicodeError raise OperationError(space.w_UnicodeDecodeError, space.newtuple([ space.wrap(e.encoding), space.wrap(e.object), space.wrap(e.start), space.wrap(e.end), space.wrap(e.reason)])) except ValueError, e: raise OperationError(space.w_ValueError, space.wrap(str(e))) except TypeError, e: raise OperationError(space.w_TypeError, space.wrap(str(e))) from pypy.interpreter.pycode import PyCode return PyCode._from_code(space, c) compile._annspecialcase_ = "override:cpy_compile" def _warn_explicit(self, message, category, filename, lineno, module=None, registry=None): if hasattr(category, '__bases__') and \ issubclass(category, SyntaxWarning): assert isinstance(message, str) space = self.space w_mod = space.sys.getmodule('warnings') if w_mod is not None: w_dict = w_mod.getdict() w_reg = space.call_method(w_dict, 'setdefault', space.wrap("__warningregistry__"), space.newdict()) try: