def test_args_parsing_into_scope(self):
space = DummySpace()
args = Arguments(space, [])
calls = []
def _match_signature(w_firstarg,
scope_w,
signature,
defaults_w=[],
blindargs=0):
calls.append((w_firstarg, scope_w, signature.argnames,
signature.has_vararg(), signature.has_kwarg(),
defaults_w, blindargs))
args._match_signature = _match_signature
scope_w = [None, None]
args.parse_into_scope(None, scope_w, "foo",
Signature(["a", "b"], None, None))
assert len(calls) == 1
assert calls[0] == (None, scope_w, ["a", "b"], False, False, [], 0)
assert calls[0][1] is scope_w
calls = []
scope_w = [None, None, None, None]
args.parse_into_scope(None,
scope_w,
"foo",
Signature(["a", "b"], "args", "kw"),
defaults_w=['x', 'y'])
assert len(calls) == 1
assert calls[0] == (None, scope_w, ["a", "b"], True, True, ["x",
"y"], 0)
calls = []
scope_w = [None, None, None, None]
args.parse_into_scope("obj",
scope_w,
"foo",
Signature(["a", "b"], "args", "kw"),
defaults_w=['x', 'y'])
assert len(calls) == 1
assert calls[0] == ("obj", scope_w, ["a", "b"], True, True, ["x",
"y"], 0)
class FakeArgErr(ArgErr):
def getmsg(self, fname):
return "msg " + fname
def _match_signature(*args):
raise FakeArgErr()
args._match_signature = _match_signature
excinfo = py.test.raises(OperationError, args.parse_into_scope, "obj",
[None, None], "foo",
Signature(["a", "b"], None, None))
assert excinfo.value.w_type is TypeError
assert excinfo.value._w_value == "msg foo"
def test_blindargs(self):
space = DummySpace()
kwds = [("a", 3), ('b', 4)]
for i in range(4):
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
w_kwds = dict(kwds[i:])
if i == 3:
w_kwds = None
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None,
l,
Signature(["a", "b"], None, "**"),
blindargs=2)
assert l == [1, 2, {'a': 3, 'b': 4}]
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None]
py.test.raises(ArgErrUnknownKwds,
args._match_signature,
None,
l,
Signature(["a", "b"]),
blindargs=2)
def test_match0(self):
space = DummySpace()
args = Arguments(space, [])
l = []
args._match_signature(None, l, Signature([]))
assert len(l) == 0
l = [None, None]
args = Arguments(space, [])
py.test.raises(ArgErr, args._match_signature, None, l, Signature(["a"]))
args = Arguments(space, [])
py.test.raises(ArgErr, args._match_signature, None, l, Signature(["a"], "*"))
args = Arguments(space, [])
l = [None]
args._match_signature(None, l, Signature(["a"]), defaults_w=[1])
assert l == [1]
args = Arguments(space, [])
l = [None]
args._match_signature(None, l, Signature([], "*"))
assert l == [()]
args = Arguments(space, [])
l = [None]
args._match_signature(None, l, Signature([], None, "**"))
assert l == [{}]
args = Arguments(space, [])
l = [None, None]
py.test.raises(ArgErr, args._match_signature, 41, l, Signature([]))
args = Arguments(space, [])
l = [None]
args._match_signature(1, l, Signature(["a"]))
assert l == [1]
args = Arguments(space, [])
l = [None]
args._match_signature(1, l, Signature([], "*"))
assert l == [(1,)]
def test_unmatch_signature(self):
space = DummySpace()
args = make_arguments_for_translation(space, [1,2,3])
sig = Signature(['a', 'b', 'c'], None, None)
data = args.match_signature(sig, [])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1])
sig = Signature(['a', 'b', 'c'], None, None)
data = args.match_signature(sig, [2, 3])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1,2,3,4,5])
sig = Signature(['a', 'b', 'c'], 'r', None)
data = args.match_signature(sig, [])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1], {'c': 3, 'b': 2})
sig = Signature(['a', 'b', 'c'], None, None)
data = args.match_signature(sig, [])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1], {'c': 5})
sig = Signature(['a', 'b', 'c'], None, None)
data = args.match_signature(sig, [2, 3])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1], {'c': 5, 'd': 7})
sig = Signature(['a', 'b', 'c'], None, 'kw')
data = args.match_signature(sig, [2, 3])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1,2,3,4,5], {'e': 5, 'd': 7})
sig = Signature(['a', 'b', 'c'], 'r', 'kw')
data = args.match_signature(sig, [2, 3])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [], {},
w_stararg=[1],
w_starstararg={'c': 5, 'd': 7})
sig = Signature(['a', 'b', 'c'], None, 'kw')
data = args.match_signature(sig, [2, 3])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
args = make_arguments_for_translation(space, [1,2], {'g': 9},
w_stararg=[3,4,5],
w_starstararg={'e': 5, 'd': 7})
sig = Signature(['a', 'b', 'c'], 'r', 'kw')
data = args.match_signature(sig, [2, 3])
new_args = args.unmatch_signature(sig, data)
assert args.unpack() == new_args.unpack()
def builder(translator, func):
# build a hacked graph that doesn't take a *arg any more, but
# individual extra arguments
graph = translator.buildflowgraph(func)
argnames, vararg, kwarg = graph.signature
assert vararg, "graph should have a *arg at this point"
assert not kwarg, "where does this **arg come from??"
argscopy = [Variable(v) for v in graph.getargs()]
starargs = [
Variable('stararg%d' % i) for i in range(nb_extra_args)
]
newstartblock = Block(argscopy[:-1] + starargs)
newtup = SpaceOperation('newtuple', starargs, argscopy[-1])
newstartblock.operations.append(newtup)
newstartblock.closeblock(Link(argscopy, graph.startblock))
graph.startblock.isstartblock = False
graph.startblock = newstartblock
newstartblock.isstartblock = True
argnames = argnames + ['.star%d' % i for i in range(nb_extra_args)]
graph.signature = Signature(argnames)
# note that we can mostly ignore defaults: if nb_extra_args > 0,
# then defaults aren't applied. if nb_extra_args == 0, then this
# just removes the *arg and the defaults keep their meaning.
if nb_extra_args > 0:
graph.defaults = None # shouldn't be used in this case
checkgraph(graph)
return graph
def acquire(self, space, __args__):
(w_user, w_password, w_cclass, w_purity) = __args__.parse_obj(
None,
"acquire",
Signature(["user", "password", "cclass", "purity"]),
defaults_w=[None, None, None, space.w_False])
if self.homogeneous and (w_user or w_password):
raise OperationError(
get(space).w_ProgrammingError,
space.wrap("pool is homogeneous. "
"Proxy authentication is not possible."))
self.checkConnected(space)
if __args__.keywords:
keywords = __args__.keywords + ["pool"]
else:
keywords = ["pool"]
if __args__.keywords_w:
keywords_w = __args__.keywords_w + [space.wrap(self)]
else:
keywords_w = [space.wrap(self)]
newargs = Arguments(space, __args__.arguments_w, keywords, keywords_w)
return space.call_args(self.w_connectionType, newargs)
def __init__(self,
bookkeeper,
pyobj=None,
name=None,
signature=None,
defaults=None,
specializer=None):
super(FunctionDesc, self).__init__(bookkeeper, pyobj)
if name is None:
name = pyobj.func_name
if signature is None:
if hasattr(pyobj, '_generator_next_method_of_'):
from pypy.interpreter.argument import Signature
signature = Signature(['entry']) # haaaaaack
defaults = ()
else:
signature = cpython_code_signature(pyobj.func_code)
if defaults is None:
defaults = pyobj.func_defaults
self.name = name
self.signature = signature
self.defaults = defaults or ()
# 'specializer' is a function with the following signature:
# specializer(funcdesc, args_s) => graph
# or => s_result (overridden/memo cases)
self.specializer = specializer
self._cache = {} # convenience for the specializer
def test_argument_unicode(self):
space = DummySpace()
w_starstar = space.wrap({u'abc': 5})
args = Arguments(space, [], w_starstararg=w_starstar)
l = [None]
args._match_signature(None, l, Signature(['abc']))
assert len(l) == 1
assert l[0] == space.wrap(5)
def test_match_kwds(self):
space = DummySpace()
for i in range(3):
kwds = [("c", 3)]
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
w_kwds = dict(kwds[i:])
if i == 2:
w_kwds = None
assert len(keywords) == len(keywords_w)
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c"]), defaults_w=[4])
assert l == [1, 2, 3]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "b1", "c"]), defaults_w=[4, 5])
assert l == [1, 2, 4, 3]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c", "d"]), defaults_w=[4, 5])
assert l == [1, 2, 3, 5]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr, args._match_signature, None, l,
Signature(["c", "b", "a", "d"]), defaults_w=[4, 5])
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr, args._match_signature, None, l,
Signature(["a", "b", "c1", "d"]), defaults_w=[4, 5])
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b"], None, "**"))
assert l == [1, 2, {'c': 3}]
def test_match_kwds2(self):
space = DummySpace()
kwds = [("c", 3), ('d', 4)]
for i in range(4):
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
w_kwds = dict(kwds[i:])
if i == 3:
w_kwds = None
args = Arguments(space, [1, 2], keywords, keywords_w, w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c"], None, "**"))
assert l == [1, 2, 3, {'d': 4}]
def cpython_code_signature(code):
"([list-of-arg-names], vararg-name-or-None, kwarg-name-or-None)."
argcount = code.co_argcount
assert argcount >= 0 # annotator hint
argnames = list(code.co_varnames[:argcount])
if code.co_flags & CO_VARARGS:
varargname = code.co_varnames[argcount]
argcount += 1
else:
varargname = None
if code.co_flags & CO_VARKEYWORDS:
kwargname = code.co_varnames[argcount]
argcount += 1
else:
kwargname = None
return Signature(argnames, varargname, kwargname)
def test_tweak_generator_body_graph(self):
def f(n, x, y, z=3):
z *= 10
yield n + 1
z -= 10
#
space = FlowObjSpace()
graph = space.build_flow(f, tweak_for_generator=False)
class Entry:
varnames = ['g_n', 'g_x', 'g_y', 'g_z']
tweak_generator_body_graph(Entry, graph)
if option.view:
graph.show()
# XXX how to test directly that the graph is correct? :-(
assert len(graph.startblock.inputargs) == 1
assert graph.signature == Signature(['entry'])
assert graph.defaults == ()
def test_match4(self):
space = DummySpace()
values = [4, 5, 6, 7]
for havefirstarg in [0, 1]:
for i in range(len(values) - havefirstarg):
arglist = values[havefirstarg:i + havefirstarg]
starargs = tuple(values[i + havefirstarg:])
if havefirstarg:
firstarg = values[0]
else:
firstarg = None
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None]
args._match_signature(firstarg, l,
Signature(["a", "b", "c", "d"]))
assert l == [4, 5, 6, 7]
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None, None, None]
py.test.raises(ArgErr, args._match_signature, firstarg, l,
Signature(["a"]))
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None, None, None]
py.test.raises(ArgErr, args._match_signature, firstarg, l,
Signature(["a", "b", "c", "d", "e"]))
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None, None, None]
py.test.raises(ArgErr, args._match_signature, firstarg, l,
Signature(["a", "b", "c", "d", "e"], "*"))
l = [None, None, None, None, None]
args = Arguments(space, arglist, w_stararg=starargs)
args._match_signature(firstarg,
l,
Signature(["a", "b", "c", "d", "e"]),
defaults_w=[1])
assert l == [4, 5, 6, 7, 1]
for j in range(len(values)):
l = [None] * (j + 1)
args = Arguments(space, arglist, w_stararg=starargs)
args._match_signature(
firstarg, l,
Signature(["a", "b", "c", "d", "e"][:j], "*"))
assert l == values[:j] + [tuple(values[j:])]
l = [None, None, None, None, None]
args = Arguments(space, arglist, w_stararg=starargs)
args._match_signature(
firstarg, l, Signature(["a", "b", "c", "d"], None, "**"))
assert l == [4, 5, 6, 7, {}]
def test_eq(self):
sig1 = Signature(["a", "b", "c"], "d", "c")
sig2 = Signature(["a", "b", "c"], "d", "c")
assert sig1 == sig2
def test_helpers(self):
sig = Signature(["a", "b", "c"], None, None)
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 3
assert sig.getallvarnames() == ["a", "b", "c"]
sig = Signature(["a", "b", "c"], "c", None)
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], None, "c")
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], "d", "c")
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 5
assert sig.getallvarnames() == ["a", "b", "c", "d", "c"]
'''%'\n '.join(bodySrc)).compile()
def report():
if not DictInfo._dict_infos:
return
os.write(2, "Starting multidict report.\n")
fd = os.open('dictinfo.txt', os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0644)
for info in DictInfo._dict_infos:
os.write(fd, '------------------\n')
_report_one(fd, info)
os.close(fd)
os.write(2, "Reporting done.\n")
init_signature = Signature(['seq_or_map'], None, 'kwargs')
init_defaults = [None]
def init__DictMulti(space, w_dict, __args__):
w_src, w_kwds = __args__.parse_obj(
None, 'dict',
init_signature, # signature
init_defaults) # default argument
if w_src is None:
pass
elif space.findattr(w_src, space.wrap("keys")) is None:
list_of_w_pairs = space.listview(w_src)
for w_pair in list_of_w_pairs:
pair = space.fixedview(w_pair)
if len(pair)!=2:
raise OperationError(space.w_ValueError,
def test_find_argname(self):
sig = Signature(["a", "b", "c"], None, None)
assert sig.find_argname("a") == 0
assert sig.find_argname("b") == 1
assert sig.find_argname("c") == 2
assert sig.find_argname("d") == -1
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%s)" % (w_self.__class__.__name__, w_self.wrappeditems)
def unwrap(w_list, space):
items = [space.unwrap(w_item) for w_item in w_list.wrappeditems
] # XXX generic mixed types unwrap
return list(items)
def append(w_list, w_item):
w_list.wrappeditems.append(w_item)
registerimplementation(W_ListObject)
init_signature = Signature(['sequence'], None, None)
init_defaults = [None]
def init__List(space, w_list, __args__):
# this is on the silly side
w_iterable, = __args__.parse_obj(None, 'list', init_signature,
init_defaults)
#
# this is the old version of the loop at the end of this function:
#
# w_list.wrappeditems = space.unpackiterable(w_iterable)
#
# This is commented out to avoid assigning a new RPython list to
# 'wrappeditems', which defeats the W_FastSeqIterObject optimization.
#
def test_find_argname(self):
sig = Signature(["a", "b", "c"], None, None)
assert sig.find_argname("a") == 0
assert sig.find_argname("b") == 1
assert sig.find_argname("c") == 2
assert sig.find_argname("d") == -1
def test_tuply(self):
sig = Signature(["a", "b", "c"], "d", "e")
x, y, z = sig
assert x == ["a", "b", "c"]
assert y == "d"
assert z == "e"
class W_BytearrayObject(W_Object):
from pypy.objspace.std.bytearraytype import bytearray_typedef as typedef
def __init__(w_self, data):
w_self.data = data
def __repr__(w_self):
""" representation for debugging purposes """
return "%s(%s)" % (w_self.__class__.__name__, ''.join(w_self.data))
registerimplementation(W_BytearrayObject)
init_signature = Signature(['source', 'encoding', 'errors'], None, None)
init_defaults = [None, None, None]
def init__Bytearray(space, w_bytearray, __args__):
# this is on the silly side
w_source, w_encoding, w_errors = __args__.parse_obj(
None, 'bytearray', init_signature, init_defaults)
if w_source is None:
w_source = space.wrap('')
if w_encoding is None:
w_encoding = space.w_None
if w_errors is None:
w_errors = space.w_None
def test_starstarargs_special(self):
class kwargs(object):
def __init__(self, k, v):
self.k = k
self.v = v
class MyDummySpace(DummySpace):
def view_as_kwargs(self, kw):
if isinstance(kw, kwargs):
return kw.k, kw.v
return None, None
space = MyDummySpace()
for i in range(3):
kwds = [("c", 3)]
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
rest = dict(kwds[i:])
w_kwds = kwargs(rest.keys(), rest.values())
if i == 2:
w_kwds = None
assert len(keywords) == len(keywords_w)
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None,
l,
Signature(["a", "b", "c"]),
defaults_w=[4])
assert l == [1, 2, 3]
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None,
l,
Signature(["a", "b", "b1", "c"]),
defaults_w=[4, 5])
assert l == [1, 2, 4, 3]
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None,
l,
Signature(["a", "b", "c", "d"]),
defaults_w=[4, 5])
assert l == [1, 2, 3, 5]
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr,
args._match_signature,
None,
l,
Signature(["c", "b", "a", "d"]),
defaults_w=[4, 5])
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr,
args._match_signature,
None,
l,
Signature(["a", "b", "c1", "d"]),
defaults_w=[4, 5])
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b"], None, "**"))
assert l == [1, 2, {'c': 3}]
excinfo = py.test.raises(OperationError,
Arguments,
space, [], ["a"], [1],
w_starstararg=kwargs(["a"], [2]))
assert excinfo.value.w_type is TypeError
def signature(self):
return Signature(self.argnames, self.varargname, self.kwargname)
iter__Frozenset = iter__Set
def cmp__Set_settypedef(space, w_left, w_other):
# hack hack until we get the expected result
raise OperationError(space.w_TypeError,
space.wrap('cannot compare sets using cmp()'))
cmp__Set_frozensettypedef = cmp__Set_settypedef
cmp__Frozenset_settypedef = cmp__Set_settypedef
cmp__Frozenset_frozensettypedef = cmp__Set_settypedef
init_signature = Signature(['some_iterable'], None, None)
init_defaults = [None]
def init__Set(space, w_set, __args__):
w_iterable, = __args__.parse_obj(None, 'set', init_signature,
init_defaults)
_initialize_set(space, w_set, w_iterable)
app = gateway.applevel("""
def setrepr(currently_in_repr, s):
'The app-level part of repr().'
set_id = id(s)
if set_id in currently_in_repr:
return '%s(...)' % (s.__class__.__name__,)
def normalize_calltable_row_signature(annotator, shape, row):
graphs = row.values()
assert graphs, "no graph??"
sig0 = graphs[0].signature
defaults0 = graphs[0].defaults
for graph in graphs[1:]:
if graph.signature != sig0:
break
if graph.defaults != defaults0:
break
else:
return False # nothing to do, all signatures already match
shape_cnt, shape_keys, shape_star, shape_stst = shape
assert not shape_star, "XXX not implemented"
assert not shape_stst, "XXX not implemented"
# for the first 'shape_cnt' arguments we need to generalize to
# a common type
call_nbargs = shape_cnt + len(shape_keys)
did_something = False
NODEFAULT = object()
for graph in graphs:
argnames, varargname, kwargname = graph.signature
assert not varargname, "XXX not implemented"
assert not kwargname, "XXX not implemented" # ?
inputargs_s = [annotator.binding(v) for v in graph.getargs()]
argorder = range(shape_cnt)
for key in shape_keys:
i = list(argnames).index(key)
assert i not in argorder
argorder.append(i)
need_reordering = (argorder != range(call_nbargs))
if need_reordering or len(graph.getargs()) != call_nbargs:
oldblock = graph.startblock
inlist = []
defaults = graph.defaults or ()
num_nondefaults = len(inputargs_s) - len(defaults)
defaults = [NODEFAULT] * num_nondefaults + list(defaults)
newdefaults = []
for j in argorder:
v = Variable(graph.getargs()[j])
annotator.setbinding(v, inputargs_s[j])
inlist.append(v)
newdefaults.append(defaults[j])
newblock = Block(inlist)
# prepare the output args of newblock:
# 1. collect the positional arguments
outlist = inlist[:shape_cnt]
# 2. add defaults and keywords
for j in range(shape_cnt, len(inputargs_s)):
try:
i = argorder.index(j)
v = inlist[i]
except ValueError:
default = defaults[j]
if default is NODEFAULT:
raise TyperError(
"call pattern has %d positional arguments, "
"but %r takes at least %d arguments" % (
shape_cnt, graph.name, num_nondefaults))
v = Constant(default)
outlist.append(v)
newblock.closeblock(Link(outlist, oldblock))
graph.startblock = newblock
for i in range(len(newdefaults)-1,-1,-1):
if newdefaults[i] is NODEFAULT:
newdefaults = newdefaults[i:]
break
graph.defaults = tuple(newdefaults)
graph.signature = Signature([argnames[j] for j in argorder],
None, None)
# finished
checkgraph(graph)
annotator.annotated[newblock] = annotator.annotated[oldblock]
did_something = True
return did_something
def test_helpers(self):
sig = Signature(["a", "b", "c"], None, None)
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 3
assert sig.getallvarnames() == ["a", "b", "c"]
sig = Signature(["a", "b", "c"], "c", None)
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], None, "c")
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], "d", "c")
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 5
assert sig.getallvarnames() == ["a", "b", "c", "d", "c"]
def tweak_generator_body_graph(Entry, graph):
# First, always run simplify_graph in order to reduce the number of
# variables passed around
simplify_graph(graph)
#
assert graph.startblock.operations[0].opname == 'generator_mark'
graph.startblock.operations.pop(0)
#
insert_empty_startblock(None, graph)
_insert_reads(graph.startblock, Entry.varnames)
Entry.block = graph.startblock
#
mappings = [Entry]
#
stopblock = Block([])
v0 = Variable()
v1 = Variable()
stopblock.operations = [
SpaceOperation('simple_call', [Constant(StopIteration)], v0),
SpaceOperation('type', [v0], v1),
]
stopblock.closeblock(Link([v1, v0], graph.exceptblock))
#
for block in list(graph.iterblocks()):
for exit in block.exits:
if exit.target is graph.returnblock:
exit.args = []
exit.target = stopblock
assert block is not stopblock
for index in range(len(block.operations) - 1, -1, -1):
op = block.operations[index]
if op.opname == 'yield':
[v_yielded_value] = op.args
del block.operations[index]
newlink = split_block(None, block, index)
newblock = newlink.target
#
class Resume(AbstractPosition):
_immutable_ = True
block = newblock
Resume.__name__ = 'Resume%d' % len(mappings)
mappings.append(Resume)
varnames = get_variable_names(newlink.args)
#
_insert_reads(newblock, varnames)
#
v_resume = Variable('resume')
block.operations.append(
SpaceOperation('simple_call', [Constant(Resume)],
v_resume))
for i, name in enumerate(varnames):
block.operations.append(
SpaceOperation(
'setattr',
[v_resume,
Constant(name), newlink.args[i]], Variable()))
v_pair = Variable('pair')
block.operations.append(
SpaceOperation('newtuple', [v_resume, v_yielded_value],
v_pair))
newlink.args = [v_pair]
newlink.target = graph.returnblock
#
regular_entry_block = Block([Variable('entry')])
block = regular_entry_block
for Resume in mappings:
v_check = Variable()
block.operations.append(
SpaceOperation(
'simple_call',
[Constant(isinstance), block.inputargs[0],
Constant(Resume)], v_check))
block.exitswitch = v_check
link1 = Link([block.inputargs[0]], Resume.block)
link1.exitcase = True
nextblock = Block([Variable('entry')])
link2 = Link([block.inputargs[0]], nextblock)
link2.exitcase = False
block.closeblock(link1, link2)
block = nextblock
block.closeblock(
Link([
Constant(AssertionError),
Constant(AssertionError("bad generator class"))
], graph.exceptblock))
graph.startblock = regular_entry_block
graph.signature = Signature(['entry'])
graph.defaults = ()
checkgraph(graph)
eliminate_empty_blocks(graph)
