def SETUP_WITH(self, target): # A simpler version than the 'real' 2.7 one: # directly call manager.__enter__(), don't use special lookup functions # which don't make sense on the RPython type system. w_manager = self.peekvalue() w_exit = op.getattr(w_manager, const("__exit__")).eval(self) self.settopvalue(w_exit) w_enter = op.getattr(w_manager, const('__enter__')).eval(self) w_result = op.simple_call(w_enter).eval(self) block = WithBlock(self, target) self.blockstack.append(block) self.pushvalue(w_result)
def LIST_APPEND(self, oparg): w_value = self.popvalue() if sys.version_info < (2, 7): w_list = self.popvalue() else: w_list = self.peekvalue(oparg - 1) w_append_meth = op.getattr(w_list, const('append')).eval(self) op.simple_call(w_append_meth, w_value).eval(self)
def import_from(self, w_module, w_name): assert isinstance(w_module, Constant) assert isinstance(w_name, Constant) try: return op.getattr(w_module, w_name).eval(self) except FlowingError: exc = ImportError("cannot import name '%s'" % w_name.value) raise Raise(const(exc))
def _insert_reads(block, varnames): assert len(varnames) == len(block.inputargs) v_entry1 = Variable('entry') for i, name in enumerate(varnames): hlop = op.getattr(v_entry1, const(name)) hlop.result = block.inputargs[i] block.operations.insert(i, hlop) block.inputargs = [v_entry1]
def setattr_SomeInstance(annotator, v_obj, v_attr, v_value): s_attr = annotator.annotation(v_attr) if not s_attr.is_constant() or not isinstance(s_attr.const, str): return attr = s_attr.const setters = _find_property_meth(annotator.annotation(v_obj), attr, 'fset') if setters: if all(setters): get_setter = op.getattr(v_obj, const(attr + '__setter__')) return [get_setter, op.simple_call(get_setter.result, v_value)] elif not any(setters): raise AnnotatorError("Attribute %r is unwritable" % attr)
def getslice_SomeInstance(annotator, v_obj, v_start, v_stop): get_getslice = op.getattr(v_obj, const('__getslice__')) return [get_getslice, op.simple_call(get_getslice.result, v_start, v_stop)]
def next_SomeInstance(annotator, v_arg): get_next = op.getattr(v_arg, const('next')) return [get_next, op.simple_call(get_next.result)]
def iter_SomeInstance(annotator, v_arg): get_iter = op.getattr(v_arg, const('__iter__')) return [get_iter, op.simple_call(get_iter.result)]
def len_SomeInstance(annotator, v_arg): get_len = op.getattr(v_arg, const('__len__')) return [get_len, op.simple_call(get_len.result)]
def setitem_SomeInstance(annotator, v_ins, v_idx, v_value): get_setitem = op.getattr(v_ins, const('__setitem__')) return [get_setitem, op.simple_call(get_setitem.result, v_idx, v_value)]
def contains_SomeInstance(annotator, v_ins, v_idx): get_contains = op.getattr(v_ins, const('__contains__')) return [get_contains, op.simple_call(get_contains.result, v_idx)]
def setslice_SomeInstance(annotator, v_obj, v_start, v_stop, v_iterable): get_setslice = op.getattr(v_obj, const('__setslice__')) return [get_setslice, op.simple_call(get_setslice.result, v_start, v_stop, v_iterable)]
def setslice_SomeInstance(annotator, v_obj, v_start, v_stop, v_iterable): get_setslice = op.getattr(v_obj, const('__setslice__')) return [ get_setslice, op.simple_call(get_setslice.result, v_start, v_stop, v_iterable) ]
def LOAD_ATTR(self, nameindex): "obj.attributename" w_obj = self.popvalue() w_attributename = self.getname_w(nameindex) w_value = op.getattr(w_obj, w_attributename).eval(self) self.pushvalue(w_value)
def sc_getattr(ctx, w_obj, w_index, w_default=None): if w_default is not None: return ctx.appcall(getattr, w_obj, w_index, w_default) else: from rpython.flowspace.operation import op return op.getattr(w_obj, w_index).eval(ctx)