Commits

Maciej Fijalkowski committed ed42a04

s/FlowSpaceFrame(pyframe.PyFrame)/FlowSpaceFrame(object)/

  • Participants
  • Parent commits dce1aed
  • Branches translation-cleanup

Comments (0)

Files changed (8)

File pypy/annotation/binaryop.py

 
 # XXX unify this with ObjSpace.MethodTable
 BINARY_OPERATIONS = set(['add', 'sub', 'mul', 'div', 'mod',
-                         'truediv', 'floordiv', 'divmod', 'pow',
+                         'truediv', 'floordiv', 'divmod',
                          'and_', 'or_', 'xor',
                          'lshift', 'rshift',
                          'getitem', 'setitem', 'delitem',
                          'getitem_idx', 'getitem_key', 'getitem_idx_key',
                          'inplace_add', 'inplace_sub', 'inplace_mul',
                          'inplace_truediv', 'inplace_floordiv', 'inplace_div',
-                         'inplace_mod', 'inplace_pow',
+                         'inplace_mod',
                          'inplace_lshift', 'inplace_rshift',
                          'inplace_and', 'inplace_or', 'inplace_xor',
                          'lt', 'le', 'eq', 'ne', 'gt', 'ge', 'is_', 'cmp',
                          'coerce',
                          ]
                         +[opname+'_ovf' for opname in
-                          """add sub mul floordiv div mod pow lshift
+                          """add sub mul floordiv div mod lshift
                            """.split()
                           ])
 
     def inplace_floordiv((obj1, obj2)): return pair(obj1, obj2).floordiv()
     def inplace_div((obj1, obj2)):      return pair(obj1, obj2).div()
     def inplace_mod((obj1, obj2)):      return pair(obj1, obj2).mod()
-    def inplace_pow((obj1, obj2)):      return pair(obj1, obj2).pow(s_None)
     def inplace_lshift((obj1, obj2)):   return pair(obj1, obj2).lshift()
     def inplace_rshift((obj1, obj2)):   return pair(obj1, obj2).rshift()
     def inplace_and((obj1, obj2)):      return pair(obj1, obj2).and_()
             return SomeInteger(nonneg=int1.nonneg, knowntype=int1.knowntype)
     rshift.can_only_throw = []
 
-    def pow((int1, int2), obj3):
-        knowntype = rarithmetic.compute_restype(int1.knowntype, int2.knowntype)
-        return SomeInteger(nonneg = int1.nonneg,
-                           knowntype=knowntype)
-    pow.can_only_throw = [ZeroDivisionError]
-    pow_ovf = _clone(pow, [ZeroDivisionError, OverflowError])
-
-    def inplace_pow((int1, int2)):
-        knowntype = rarithmetic.compute_restype(int1.knowntype, int2.knowntype)
-        return SomeInteger(nonneg = int1.nonneg,
-                           knowntype=knowntype)
-    inplace_pow.can_only_throw = [ZeroDivisionError]
-
     def _compare_helper((int1, int2), opname, operation):
         r = SomeBool()
         if int1.is_immutable_constant() and int2.is_immutable_constant():
     div.can_only_throw = []
     truediv = div
 
-    def pow((flt1, flt2), obj3):
-        raise NotImplementedError("float power not supported, use math.pow")
-
     # repeat these in order to copy the 'can_only_throw' attribute
     inplace_div = div
     inplace_truediv = truediv

File pypy/annotation/test/test_annrpython.py

 from pypy.rlib.rarithmetic import r_uint, base_int, r_longlong, r_ulonglong
 from pypy.rlib.rarithmetic import r_singlefloat
 from pypy.rlib import objectmodel
-from pypy.objspace.flow.objspace import FlowObjSpace
+from pypy.objspace.flow.objspace import FlowObjSpace, FlowingError
 
 from pypy.translator.test import snippet
 
         assert a.binding(et) == t
         assert isinstance(a.binding(ev), annmodel.SomeInstance) and a.binding(ev).classdef == a.bookkeeper.getuniqueclassdef(Exception)
 
-    def test_pow(self):
-        def f(n):
-            n **= 2
-            return 2 ** n
-        a = self.RPythonAnnotator()
-        s = a.build_types(f, [int])
-        # result should be an integer
-        assert s.knowntype == int
-
     def test_inplace_div(self):
         def f(n):
             n /= 2
             x **= y
             return x ** y
         a = self.RPythonAnnotator()
-        s = a.build_types(f, [int, int])
-        assert isinstance(s, annmodel.SomeInteger)
-        a = self.RPythonAnnotator()
-        py.test.raises(NotImplementedError, a.build_types, f, [float, float])
+        py.test.raises(FlowingError, a.build_types, f, [int, int])
+        a = self.RPythonAnnotator()
+        py.test.raises(FlowingError, a.build_types, f, [float, float])
 
     def test_intcmp_bug(self):
         def g(x, y):

File pypy/objspace/flow/argument.py

     def _combine_starargs_wrapped(self, w_stararg):
         # unpack the * arguments
         space = self.space
-        args_w = space.fixedview(w_stararg)
+        args_w = space.unpackiterable(w_stararg)
         self.arguments_w = self.arguments_w + args_w
 
     def _combine_starstarargs_wrapped(self, w_starstararg):
                 self.keywords_w = values_w
             else:
                 if set(keywords) & set(self.keywords):
-                    raise TypeError("got multiple values for keyword argument '%s'", key)
+                    raise TypeError("got multiple values for keyword arguments '%s'", set(keywords) & set(self.keywords))
                 self.keywords = self.keywords + keywords
                 self.keywords_w = self.keywords_w + values_w
             return

File pypy/objspace/flow/flowcontext.py

     BINARY_OP.func_name = OPCODE
     return BINARY_OP
 
+_unsupported_ops = [
+    ('BINARY_POWER', "a ** b"),
+    ('BUILD_CLASS', 'creating new classes'),
+    ('EXEC_STMT', 'exec statement'),
+    ('STOP_CODE', '???'),
+    ('STORE_NAME', 'modifying globals'),
+    ('INPLACE_POWER', 'a **= b'),
+    ('LOAD_LOCALS', 'locals()'),
+    ('IMPORT_STAR', 'import *'),
+    ('MISSING_OPCODE', '???'),
+    ('DELETE_GLOBAL', 'modifying globals'),
+    ('DELETE_NAME', 'modifying globals'),
+    ('DELETE_ATTR', 'deleting attributes'),
+]
+
+def unsupportedoperation(OPCODE, msg):
+    def UNSUPPORTED(self, *ignored):
+        raise FlowingError(self, "%s is not RPython" % (msg,))
+    UNSUPPORTED.func_name = OPCODE
+    return UNSUPPORTED
+
 compare_method = [
     "cmp_lt",   # "<"
     "cmp_le",   # "<="
     "cmp_exc_match",
     ]
 
-class FlowSpaceFrame(pyframe.PyFrame):
+class FlowSpaceFrame(object):
     opcode_method_names = host_bytecode_spec.method_names
 
     def __init__(self, space, graph, code):
             "peek past the bottom of the stack")
         return self.locals_stack_w[index]
 
+    def pushrevvalues(self, n, values_w): # n should be len(values_w)
+        assert len(values_w) == n
+        for i in range(n - 1, -1, -1):
+            self.pushvalue(values_w[i])
+
     def settopvalue(self, w_object, index_from_top=0):
         index = self.valuestackdepth + ~index_from_top
         assert index >= self.pycode.co_nlocals, (
     def LOAD_GLOBAL(self, nameindex, next_instr):
         w_result = self.space.find_global(self.w_globals, self.getname_u(nameindex))
         self.pushvalue(w_result)
+    LOAD_NAME = LOAD_GLOBAL
 
     def LOAD_ATTR(self, nameindex, next_instr):
         "obj.attributename"
     for OPCODE, op in _binary_ops:
         locals()[OPCODE] = binaryoperation(OPCODE, op)
 
+    for OPCODE, op in _unsupported_ops:
+        locals()[OPCODE] = unsupportedoperation(OPCODE, op)
+
     def BUILD_LIST_FROM_ARG(self, _, next_instr):
         # This opcode was added with pypy-1.8.  Here is a simpler
         # version, enough for annotation.
         fn = self.space.newfunction(w_codeobj, self.w_globals, defaults)
         self.pushvalue(fn)
 
+    def STORE_ATTR(self, nameindex, next_instr):
+        "obj.attributename = newvalue"
+        w_attributename = self.getname_w(nameindex)
+        w_obj = self.popvalue()
+        w_newvalue = self.popvalue()
+        self.space.setattr(w_obj, w_attributename, w_newvalue)
+
+    def UNPACK_SEQUENCE(self, itemcount, next_instr):
+        w_iterable = self.popvalue()
+        items = self.space.unpackiterable(w_iterable, itemcount)
+        self.pushrevvalues(itemcount, items)
+
+    def slice(self, w_start, w_end):
+        w_obj = self.popvalue()
+        w_result = self.space.getslice(w_obj, w_start, w_end)
+        self.pushvalue(w_result)
+
+    def SLICE_0(self, oparg, next_instr):
+        self.slice(self.space.w_None, self.space.w_None)
+
+    def SLICE_1(self, oparg, next_instr):
+        w_start = self.popvalue()
+        self.slice(w_start, self.space.w_None)
+
+    def SLICE_2(self, oparg, next_instr):
+        w_end = self.popvalue()
+        self.slice(self.space.w_None, w_end)
+
+    def SLICE_3(self, oparg, next_instr):
+        w_end = self.popvalue()
+        w_start = self.popvalue()
+        self.slice(w_start, w_end)
+
+    def storeslice(self, w_start, w_end):
+        w_obj = self.popvalue()
+        w_newvalue = self.popvalue()
+        self.space.setslice(w_obj, w_start, w_end, w_newvalue)
+
+    def STORE_SLICE_0(self, oparg, next_instr):
+        self.storeslice(self.space.w_None, self.space.w_None)
+
+    def STORE_SLICE_1(self, oparg, next_instr):
+        w_start = self.popvalue()
+        self.storeslice(w_start, self.space.w_None)
+
+    def STORE_SLICE_2(self, oparg, next_instr):
+        w_end = self.popvalue()
+        self.storeslice(self.space.w_None, w_end)
+
+    def STORE_SLICE_3(self, oparg, next_instr):
+        w_end = self.popvalue()
+        w_start = self.popvalue()
+        self.storeslice(w_start, w_end)
+
+    def deleteslice(self, w_start, w_end):
+        w_obj = self.popvalue()
+        self.space.delslice(w_obj, w_start, w_end)
+
+    def DELETE_SLICE_0(self, oparg, next_instr):
+        self.deleteslice(self.space.w_None, self.space.w_None)
+
+    def DELETE_SLICE_1(self, oparg, next_instr):
+        w_start = self.popvalue()
+        self.deleteslice(w_start, self.space.w_None)
+
+    def DELETE_SLICE_2(self, oparg, next_instr):
+        w_end = self.popvalue()
+        self.deleteslice(self.space.w_None, w_end)
+
+    def DELETE_SLICE_3(self, oparg, next_instr):
+        w_end = self.popvalue()
+        w_start = self.popvalue()
+        self.deleteslice(w_start, w_end)
+
+    def LIST_APPEND(self, oparg, next_instr):
+        w = self.popvalue()
+        v = self.peekvalue(oparg - 1)
+        self.space.call_method(v, 'append', w)
+
+    def DELETE_FAST(self, varindex, next_instr):
+        if self.locals_stack_w[varindex] is None:
+            varname = self.getlocalvarname(varindex)
+            message = "local variable '%s' referenced before assignment"
+            raise UnboundLocalError(message, varname)
+        self.locals_stack_w[varindex] = None
+
+    def STORE_MAP(self, oparg, next_instr):
+        w_key = self.popvalue()
+        w_value = self.popvalue()
+        w_dict = self.peekvalue()
+        self.space.setitem(w_dict, w_key, w_value)
+
+    def STORE_SUBSCR(self, oparg, next_instr):
+        "obj[subscr] = newvalue"
+        w_subscr = self.popvalue()
+        w_obj = self.popvalue()
+        w_newvalue = self.popvalue()
+        self.space.setitem(w_obj, w_subscr, w_newvalue)
+
+    def BUILD_SLICE(self, numargs, next_instr):
+        if numargs == 3:
+            w_step = self.popvalue()
+        elif numargs == 2:
+            w_step = self.space.w_None
+        else:
+            raise BytecodeCorruption
+        w_end = self.popvalue()
+        w_start = self.popvalue()
+        w_slice = self.space.newslice(w_start, w_end, w_step)
+        self.pushvalue(w_slice)
+
+    def DELETE_SUBSCR(self, oparg, next_instr):
+        "del obj[subscr]"
+        w_subscr = self.popvalue()
+        w_obj = self.popvalue()
+        self.space.delitem(w_obj, w_subscr)
+
+    def BUILD_TUPLE(self, itemcount, next_instr):
+        items = self.popvalues(itemcount)
+        w_tuple = self.space.newtuple(items)
+        self.pushvalue(w_tuple)
+
+    def BUILD_LIST(self, itemcount, next_instr):
+        items = self.popvalues(itemcount)
+        w_list = self.space.newlist(items)
+        self.pushvalue(w_list)
+
+    def BUILD_MAP(self, itemcount, next_instr):
+        w_dict = self.space.newdict()
+        self.pushvalue(w_dict)
+
+    def NOP(self, *args):
+        pass
+
     # XXX Unimplemented 2.7 opcodes ----------------
 
     # Set literals, set comprehensions

File pypy/objspace/flow/objspace.py

             w_real_class = self.wrap(rstackovf._StackOverflow)
             return self._exception_match(w_exc_type, w_real_class)
         # checking a tuple of classes
-        for w_klass in self.fixedview(w_check_class):
+        for w_klass in self.unpackiterable(w_check_class):
             if self.exception_match(w_exc_type, w_klass):
                 return True
         return False
             tweak_generator_graph(graph)
         return graph
 
-    def fixedview(self, w_tuple, expected_length=None):
-        return self.unpackiterable(w_tuple, expected_length)
-    listview = fixedview_unroll = fixedview
-
     def unpackiterable(self, w_iterable, expected_length=None):
         if not isinstance(w_iterable, Variable):
             l = list(self.unwrap(w_iterable))

File pypy/rpython/rfloat.py

 
     # 'floordiv' on floats not supported in RPython
 
-    # pow on floats not supported in RPython
-
     #comparisons: eq is_ ne lt le gt ge
 
     def rtype_eq(_, hop):

File pypy/rpython/rint.py

         return _rtype_template(hop, 'rshift')
     rtype_inplace_rshift = rtype_rshift
 
-    def rtype_pow(_, hop):
-        raise MissingRTypeOperation("'**' not supported in RPython")
-
-    rtype_pow_ovf = rtype_pow
-    rtype_inplace_pow = rtype_pow
-
-##    def rtype_pow(_, hop, suffix=''):
-##        if hop.has_implicit_exception(ZeroDivisionError):
-##            suffix += '_zer'
-##        s_int3 = hop.args_s[2]
-##        rresult = hop.rtyper.makerepr(hop.s_result)
-##        if s_int3.is_constant() and s_int3.const is None:
-##            vlist = hop.inputargs(rresult, rresult, Void)[:2]
-##        else:
-##            vlist = hop.inputargs(rresult, rresult, rresult)
-##        hop.exception_is_here()
-##        return hop.genop(rresult.opprefix + 'pow' + suffix, vlist, resulttype=rresult)
-
-##    def rtype_pow_ovf(_, hop):
-##        if hop.s_result.unsigned:
-##            raise TyperError("forbidden uint_pow_ovf")
-##        hop.has_implicit_exception(OverflowError) # record that we know about it
-##        return self.rtype_pow(_, hop, suffix='_ovf')
-
-##    def rtype_inplace_pow(_, hop):
-##        return _rtype_template(hop, 'pow', [ZeroDivisionError])
-
     #comparisons: eq is_ ne lt le gt ge
 
     def rtype_eq(_, hop): 

File pypy/translator/c/src/float.h

 #define OP_FLOAT_SUB(x,y,r)     r = x - y
 #define OP_FLOAT_MUL(x,y,r)     r = x * y
 #define OP_FLOAT_TRUEDIV(x,y,r) r = x / y
-#define OP_FLOAT_POW(x,y,r)     r = pow(x, y)
 
 /*** conversions ***/