def attach_defaults(self, default_insts, kwdefault_insts):
if default_insts:
tmp = PyTupleLL(None, self.v)
tmp.declare_tmp(name=self.hlnode.owner.name + "_defaults")
tmp.pack(*default_insts)
self.c_obj.set_attr_string('__defaults__', tmp)
tmp.decref()
if kwdefault_insts:
tmp = PyDictLL(None, self.v)
tmp.declare_tmp(name=self.hlnode.owner.name + "_kwdefaults")
tmp.new()
for name, inst in kwdefault_insts:
if inst is None:
self.v.none.incref()
tmp.set_item_string(name, self.v.none)
else:
tmp.set_item_string(name, inst)
inst.decref()
self.c_obj.set_attr_string('__kwdefaults__', tmp)
tmp.decref()
def stub_load_args(self, args, defaults, vararg, kwonlyargs, kw_defaults, kwarg):
self.stub_arg_insts = []
# get args ref
args_tuple = self.stub_args_tuple
kwargs_dict = self.stub_kwargs_dict
# get copy of kwargs -- clear items out of it as we load them, or skip entirely
if kwarg:
if_have_kwargs = self.v.ctx.add(c.If(c.ID(kwargs_dict.name), c.Compound(), c.Compound()))
with self.v.new_context(if_have_kwargs.iftrue):
kwargs_inst = kwargs_dict.copy()
with self.v.new_context(if_have_kwargs.iffalse):
kwargs_dict.new()
kwargs_inst = kwargs_dict
else:
kwargs_inst = None
# load positional and normal keyword args
if args:
c_args_size = CIntegerLL(None, self.v)
c_args_size.declare_tmp(name='_args_size')
args_tuple.get_size_unchecked(c_args_size)
arg_insts = [None] * len(args)
for i, arg in enumerate(args):
# Note: different scope than the actual args are declared in.. need to stub them out here
#TODO: make this type pull from the arg.arg.hl.get_type() through lookup... maybe create dup_ll_type or something
arg_insts[i] = PyObjectLL(arg.arg.hl, self.v)
arg_insts[i].declare()
# query if in positional args
self.v.ctx.add(c.Comment("Grab arg {}".format(str(arg.arg))))
query_inst = self.v.ctx.add(c.If(c.BinaryOp('>', c.ID(c_args_size.name), c.Constant('integer', i)), c.Compound(), c.Compound()))
## get the positional arg on the true side
with self.v.new_context(query_inst.iftrue):
args_tuple.get_unchecked(i, arg_insts[i])
## get the keyword arg on the false side
with self.v.new_context(query_inst.iffalse):
have_kwarg = self.v.ctx.add(c.If(c.ID('kwargs'), c.Compound(), None))
### if we took kwargs, then get it directly
with self.v.new_context(have_kwarg.iftrue):
kwargs_dict.get_item_string_nofail(str(arg.arg), arg_insts[i])
### if no kwargs passed or the item was not in the kwargs, load the default from defaults
query_default_inst = self.v.ctx.add(c.If(c.UnaryOp('!', c.ID(arg_insts[i].name)), c.Compound(), c.Compound()))
with self.v.new_context(query_default_inst.iftrue):
kwstartoffset = len(args) - len(defaults)
if i >= kwstartoffset:
# try loading from defaults
default_offset = i - kwstartoffset
tmp = PyTupleLL(None, self.v)
tmp.declare_tmp()
self.c_obj.get_attr_string('__defaults__', tmp)
#self.v.ctx.add(c.Assignment('=', c.ID(tmp.name),
# c.FuncCall(c.ID('PyObject_GetAttrString'), c.ExprList(c.ID(self.c_obj.name), c.Constant('string', '__defaults__')))))
#
tmp.get_unchecked(default_offset, arg_insts[i])
#self.v.ctx.add(c.Assignment('=', c.ID(arg_insts[i].name),
# c.FuncCall(c.ID('PyTuple_GetItem'), c.ExprList(c.ID(tmp.name), c.Constant('integer', default_offset)))))
arg_insts[i].incref()
tmp.decref()
#self.v.ctx.add(c.FuncCall(c.ID('Py_INCREF'), c.ID(arg_insts[i].name)))
else:
# emit an error for an unpassed arg
with self.v.new_context(query_default_inst.iftrue):
self.fail('PyExc_TypeError', 'Missing arg {}'.format(str(arg)))
### if we did get the item out of the kwargs, delete it from the inst copy so it's not duped in the args we pass
with self.v.new_context(query_default_inst.iffalse):
if kwargs_inst:
kwargs_inst.del_item_string(str(arg.arg))
self.stub_arg_insts.extend(arg_insts)
# add unused args to varargs and pass if in taken args or error if not
if vararg:
self.v.ctx.add(c.Comment('load varargs'))
vararg_inst = args_tuple.get_slice(len(args), args_tuple.get_length())
self.stub_arg_insts.append(vararg_inst)
else:
len_inst = args_tuple.get_length()
ifstmt = self.v.ctx.add(c.If(c.BinaryOp('>', c.ID(len_inst.name), c.Constant('integer', len(args))), c.Compound(), None))
with self.v.new_context(ifstmt.iftrue):
self.fail_formatted('PyExc_TypeError', "{}() takes exactly {} positional arguments (%d given)".format(self.hlnode.owner.name, len(args)), len_inst)
# load all keyword only args
if kwonlyargs:
kwarg_insts = [None] * len(kwonlyargs)
for i, arg in enumerate(kwonlyargs):
kwarg_insts[i] = PyObjectLL(arg.arg.hl, self.v)
kwarg_insts[i].declare()
# ensure we have kwargs at all
have_kwarg = self.v.ctx.add(c.If(c.ID('kwargs'), c.Compound(), c.Compound()))
## in have_kwarg.iftrue, load all kwargs from the kwargs dict
with self.v.new_context(have_kwarg.iftrue):
for i, arg in enumerate(kwonlyargs):
#FIXME: we can make this significantly more efficient with a bit of work
kwargs_dict.get_item_string_nofail(str(arg.arg), kwarg_insts[i])
need_default = self.v.ctx.add(c.If(c.UnaryOp('!', c.ID(kwarg_insts[i].name)), c.Compound(), None))
### not found in kwdict, means we need to load from default
with self.v.new_context(need_default.iftrue):
kwdefaults0 = PyDictLL(None, self.v)
kwdefaults0.declare_tmp(name='_kwdefaults')
self.c_obj.get_attr_string('__kwdefaults__', kwdefaults0)
kwdefaults0.get_item_string(str(arg.arg), kwarg_insts[i])
kwdefaults0.decref()
### found in kwdict, means we need to delete from kwdict to avoid passing duplicate arg in kwargs
if kwargs_inst:
need_default.iffalse = c.Compound()
with self.v.new_context(need_default.iffalse):
kwargs_inst.del_item_string(str(arg.arg))
## if have_kwarg.iffalse, need to load from the kwdefaults dict
#TODO: this is identical to the failure case from above
with self.v.new_context(have_kwarg.iffalse):
kwdefaults1 = PyDictLL(None, self.v)
kwdefaults1.declare_tmp(name='_kwdefaults')
self.c_obj.get_attr_string('__kwdefaults__', kwdefaults1)
for i, arg in enumerate(kwonlyargs):
#have_kwarg.iffalse.add(c.Assignment('=', c.ID(kwdefaults1.name),
# c.FuncCall(c.ID('PyObject_GetAttrString'), c.ExprList(c.ID(self.c_obj.name), c.Constant('string', '__kwdefaults__')))))
kwdefaults1.get_item_string(str(arg.arg), kwarg_insts[i])
#have_kwarg.iffalse.add(c.Assignment('=', c.ID(kwarg_insts[i].name),
# c.FuncCall(c.ID('PyDict_GetItemString'), c.ExprList(c.ID(kwdefaults1.name), c.Constant('string', str(arg.arg))))))
#self.fail_if_null(kwarg_insts[i].name)
kwdefaults1.decref()
self.stub_arg_insts.extend(kwarg_insts)
# pass remainder of kwargs dict in as the kwarg slot
if kwarg:
self.stub_arg_insts.append(kwargs_inst)
'''
def sequence_as_tuple(self, out_inst=None):
if not out_inst:
out_inst = PyTupleLL(None, self.v)
out_inst.declare_tmp()
self.v.ctx.add(c.Assignment('=', c.ID(out_inst.name), c.FuncCall(c.ID('PySequence_Tuple'), c.ExprList(c.ID(self.name)))))
return out_inst