Ejemplo n.º 1
0
 def delslice(self, w_obj, w_start, w_stop):
     w_descr = self.lookup(w_obj, '__delslice__')
     if w_descr is not None:
         w_start, w_stop = old_slice_range(self, w_obj, w_start, w_stop)
         self.get_and_call_function(w_descr, w_obj, w_start, w_stop)
     else:
         ObjSpace.delslice(self, w_obj, w_start, w_stop)
Ejemplo n.º 2
0
    def __init__(self, config=None):
        self._seen_extras = []
        ObjSpace.__init__(self, config=config)
        self.setup()

        # Be sure to annotate W_SliceObject constructor.
        # In Python2, this is triggered by W_InstanceObject.__getslice__.
        def build_slice():
            self.newslice(self.w_None, self.w_None, self.w_None)

        def attach_list_strategy():
            # this is needed for modules which interacts directly with
            # std.listobject.W_ListObject, e.g. after an isinstance check. For
            # example, _hpy_universal. We need to attach a couple of attributes
            # so that the annotator annotates them with the correct types
            from pypy.objspace.std.listobject import W_ListObject, ObjectListStrategy
            space = self
            w_obj = w_some_obj()
            if isinstance(w_obj, W_ListObject):
                w_obj.space = space
                w_obj.strategy = ObjectListStrategy(space)
                list_w = [w_some_obj(), w_some_obj()]
                w_obj.lstorage = w_obj.strategy.erase(list_w)

        self._seen_extras.append(build_slice)
        self._seen_extras.append(attach_list_strategy)
Ejemplo n.º 3
0
    def __init__(self, config=None):
        self._seen_extras = []
        ObjSpace.__init__(self, config=config)
        self.setup()

        # Be sure to annotate W_SliceObject constructor.
        # In Python2, this is triggered by W_InstanceObject.__getslice__.
        def build_slice():
            self.newslice(self.w_None, self.w_None, self.w_None)
        self._seen_extras.append(build_slice)
Ejemplo n.º 4
0
 def exception_match(self, w_exc_type, w_check_class):
     try:
         check_class = self.unwrap(w_check_class)
     except UnwrapException:
         raise Exception, "non-constant except guard"
     if not isinstance(check_class, tuple):
         # the simple case
         return ObjSpace.exception_match(self, w_exc_type, w_check_class)
     # checking a tuple of classes
     for w_klass in self.unpacktuple(w_check_class):
         if ObjSpace.exception_match(self, w_exc_type, w_klass):
             return True
     return False
Ejemplo n.º 5
0
 def exception_match(self, w_exc_type, w_check_class):
     try:
         check_class = self.unwrap(w_check_class)
     except UnwrapException:
         raise Exception, "non-constant except guard"
     if not isinstance(check_class, tuple):
         # the simple case
         return ObjSpace.exception_match(self, w_exc_type, w_check_class)
     # checking a tuple of classes
     for w_klass in self.viewiterable(w_check_class):
         if ObjSpace.exception_match(self, w_exc_type, w_klass):
             return True
     return False
Ejemplo n.º 6
0
 def createexecutioncontext(self):
     # add space specific fields to execution context
     # note that this method must not call space methods that might need an
     # execution context themselves (e.g. nearly all space methods)
     ec = ObjSpace.createexecutioncontext(self)
     ec._py_repr = None
     return ec
Ejemplo n.º 7
0
    def call_method(self, w_obj, methname, *arg_w):
        if self.config.objspace.opcodes.CALL_METHOD:
            from pypy.objspace.std.callmethod import call_method_opt

            return call_method_opt(self, w_obj, methname, *arg_w)
        else:
            return ObjSpace.call_method(self, w_obj, methname, *arg_w)
Ejemplo n.º 8
0
 def createexecutioncontext(self):
     # add space specific fields to execution context
     # note that this method must not call space methods that might need an
     # execution context themselves (e.g. nearly all space methods)
     ec = ObjSpace.createexecutioncontext(self)
     ec._py_repr = None
     return ec
Ejemplo n.º 9
0
 def listview(self, w_obj, expected_length=-1):
     t = self.listview_no_unpack(w_obj)
     if t is None:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return t
Ejemplo n.º 10
0
 def listview(self, w_obj, expected_length=-1):
     t = self.listview_no_unpack(w_obj)
     if t is None:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return t
Ejemplo n.º 11
0
def exception_issubclass_w(space, w_cls1, w_cls2):
    if isinstance(w_cls1, W_ClassObject):
        if isinstance(w_cls2, W_ClassObject):
            return w_cls1.is_subclass_of(w_cls2)
        return False
    if isinstance(w_cls2, W_ClassObject):
        return False
    return BaseObjSpace.exception_issubclass_w(space, w_cls1, w_cls2)
Ejemplo n.º 12
0
 def fixedview(self, w_obj, expected_length=-1, unroll=False):
     """ Fast paths
     """
     if isinstance(w_obj, W_TupleObject):
         t = w_obj.wrappeditems
     elif isinstance(w_obj, W_ListObject):
         t = w_obj.wrappeditems[:]
     else:
         if unroll:
             return make_sure_not_resized(ObjSpace.unpackiterable_unroll(
                 self, w_obj, expected_length)[:])
         else:
             return make_sure_not_resized(ObjSpace.unpackiterable(
                 self, w_obj, expected_length)[:])
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return make_sure_not_resized(t)
Ejemplo n.º 13
0
def exception_issubclass_w(space, w_cls1, w_cls2):
    if isinstance(w_cls1, W_ClassObject):
        if isinstance(w_cls2, W_ClassObject):
            return w_cls1.is_subclass_of(w_cls2)
        return False
    if isinstance(w_cls2, W_ClassObject):
        return False
    return BaseObjSpace.exception_issubclass_w(space, w_cls1, w_cls2)
Ejemplo n.º 14
0
 def fixedview(self, w_obj, expected_length=-1, unroll=False):
     """ Fast paths
     """
     if isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
         t = w_obj.tolist()
     elif type(w_obj) is W_ListObject:
         if unroll:
             t = w_obj.getitems_unroll()
         else:
             t = w_obj.getitems_fixedsize()
     else:
         if unroll:
             return make_sure_not_resized(ObjSpace.unpackiterable_unroll(self, w_obj, expected_length))
         else:
             return make_sure_not_resized(ObjSpace.unpackiterable(self, w_obj, expected_length)[:])
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return make_sure_not_resized(t)
Ejemplo n.º 15
0
    def finditem(self, w_obj, w_key):
        """ Perform a getitem on w_obj with w_key (any object). Returns found
        element or None on element not found.

        performance shortcut to avoid creating the OperationError(KeyError).
        """
        if isinstance(w_obj, W_DictMultiObject) and not w_obj.user_overridden_class:
            return w_obj.getitem(w_key)
        return ObjSpace.finditem(self, w_obj, w_key)
Ejemplo n.º 16
0
 def unpackiterable(self, w_obj, expected_length=-1):
     if isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
         t = w_obj.getitems_copy()
     elif type(w_obj) is W_ListObject:
         t = w_obj.getitems_copy()
     else:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return t
Ejemplo n.º 17
0
    def finditem_str(self, w_obj, key):
        """ Perform a getitem on w_obj with key (string). Returns found
        element or None on element not found.

        performance shortcut to avoid creating the OperationError(KeyError)
        and allocating W_BytesObject
        """
        if isinstance(w_obj, W_DictMultiObject) and not w_obj.user_overridden_class:
            return w_obj.getitem_str(key)
        return ObjSpace.finditem_str(self, w_obj, key)
Ejemplo n.º 18
0
 def unpackiterable(self, w_obj, expected_length=-1):
     if isinstance(w_obj, W_TupleObject):
         t = w_obj.wrappeditems[:]
     elif isinstance(w_obj, W_ListObject):
         t = w_obj.wrappeditems[:]
     else:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise UnpackValueError("Expected length %d, got %d" % (expected_length, len(t)))
     return t
Ejemplo n.º 19
0
def exception_issubclass_w(space, w_cls1, w_cls2):
    cls1 = space.interpclass_w(w_cls1)
    cls2 = space.interpclass_w(w_cls2)
    if isinstance(cls1, W_ClassObject):
        if isinstance(cls2, W_ClassObject):
            return cls1.is_subclass_of(cls2)
        return False
    if isinstance(cls2, W_ClassObject):
        return False
    return BaseObjSpace.exception_issubclass_w(space, w_cls1, w_cls2)
Ejemplo n.º 20
0
 def unpackiterable(self, w_obj, expected_length=-1):
     if isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
         t = w_obj.getitems_copy()
     elif type(w_obj) is W_ListObject:
         t = w_obj.getitems_copy()
     else:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return t
Ejemplo n.º 21
0
    def finditem(self, w_obj, w_key):
        """ Perform a getitem on w_obj with w_key (any object). Returns found
        element or None on element not found.

        performance shortcut to avoid creating the OperationError(KeyError).
        """
        if (isinstance(w_obj, W_DictMultiObject)
                and not w_obj.user_overridden_class):
            return w_obj.getitem(w_key)
        return ObjSpace.finditem(self, w_obj, w_key)
Ejemplo n.º 22
0
 def listview(self, w_obj, expected_length=-1):
     if isinstance(w_obj, W_ListObject):
         t = w_obj.wrappeditems
     elif isinstance(w_obj, W_TupleObject):
         t = w_obj.wrappeditems[:]
     else:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return t
Ejemplo n.º 23
0
 def exception_match(self, w_exc_type, w_check_class):
     try:
         check_class = self.unwrap(w_check_class)
     except UnwrapException:
         raise Exception, "non-constant except guard"
     if check_class in (NotImplementedError, AssertionError):
         raise error.FlowingError("Catching %s is not valid in RPython" % check_class.__name__)
     if not isinstance(check_class, tuple):
         # the simple case
         return ObjSpace.exception_match(self, w_exc_type, w_check_class)
     # special case for StackOverflow (see rlib/rstackovf.py)
     if check_class == rstackovf.StackOverflow:
         w_real_class = self.wrap(rstackovf._StackOverflow)
         return ObjSpace.exception_match(self, w_exc_type, w_real_class)
     # checking a tuple of classes
     for w_klass in self.fixedview(w_check_class):
         if self.exception_match(w_exc_type, w_klass):
             return True
     return False
Ejemplo n.º 24
0
def exception_issubclass_w(space, w_cls1, w_cls2):
    cls1 = space.interpclass_w(w_cls1)
    cls2 = space.interpclass_w(w_cls2)
    if isinstance(cls1, W_ClassObject):
        if isinstance(cls2, W_ClassObject):
            return cls1.is_subclass_of(cls2)
        return False
    if isinstance(cls2, W_ClassObject):
        return False
    return BaseObjSpace.exception_issubclass_w(space, w_cls1, w_cls2)
Ejemplo n.º 25
0
 def unpackiterable(self, w_obj, expected_length=-1):
     if isinstance(w_obj, W_TupleObject):
         t = w_obj.wrappeditems[:]
     elif isinstance(w_obj, W_ListObject):
         t = w_obj.wrappeditems[:]
     else:
         return ObjSpace.unpackiterable(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise UnpackValueError("Expected length %d, got %d" %
                                (expected_length, len(t)))
     return t
Ejemplo n.º 26
0
 def exception_match(self, w_exc_type, w_check_class):
     try:
         check_class = self.unwrap(w_check_class)
     except UnwrapException:
         raise Exception, "non-constant except guard"
     if check_class in (NotImplementedError, AssertionError):
         raise error.FlowingError("Catching %s is not valid in RPython" %
                                  check_class.__name__)
     if not isinstance(check_class, tuple):
         # the simple case
         return ObjSpace.exception_match(self, w_exc_type, w_check_class)
     # special case for StackOverflow (see rlib/rstackovf.py)
     if check_class == rstackovf.StackOverflow:
         w_real_class = self.wrap(rstackovf._StackOverflow)
         return ObjSpace.exception_match(self, w_exc_type, w_real_class)
     # checking a tuple of classes
     for w_klass in self.fixedview(w_check_class):
         if self.exception_match(w_exc_type, w_klass):
             return True
     return False
Ejemplo n.º 27
0
 def fixedview(self, w_obj, expected_length=-1, unroll=False):
     """ Fast paths
     """
     if isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
         t = w_obj.tolist()
     elif type(w_obj) is W_ListObject:
         if unroll:
             t = w_obj.getitems_unroll()
         else:
             t = w_obj.getitems_fixedsize()
     else:
         if unroll:
             return make_sure_not_resized(ObjSpace.unpackiterable_unroll(
                 self, w_obj, expected_length))
         else:
             return make_sure_not_resized(ObjSpace.unpackiterable(
                 self, w_obj, expected_length)[:])
     if expected_length != -1 and len(t) != expected_length:
         raise self._wrap_expected_length(expected_length, len(t))
     return make_sure_not_resized(t)
Ejemplo n.º 28
0
    def finditem_str(self, w_obj, key):
        """ Perform a getitem on w_obj with key (string). Returns found
        element or None on element not found.

        performance shortcut to avoid creating the OperationError(KeyError)
        and allocating W_BytesObject
        """
        if (isinstance(w_obj, W_DictMultiObject)
                and not w_obj.user_overridden_class):
            return w_obj.getitem_str(key)
        return ObjSpace.finditem_str(self, w_obj, key)
Ejemplo n.º 29
0
 def getindex_w(self, w_obj, w_exception, objdescr=None):
     # Performance shortcut for the common case of w_obj being an int.
     # If withsmallint is disabled, we check for W_IntObject.
     # If withsmallint is enabled, we only check for W_SmallIntObject - it's
     # probably not useful to have a shortcut for W_IntObject at all then.
     if self.config.objspace.std.withsmallint:
         if type(w_obj) is W_SmallIntObject:
             return w_obj.intval
     else:
         if type(w_obj) is W_IntObject:
             return w_obj.intval
     return ObjSpace.getindex_w(self, w_obj, w_exception, objdescr)
Ejemplo n.º 30
0
 def fixedview(self, w_obj, expected_length=-1):
     """ Fast paths
     """
     if isinstance(w_obj, W_TupleObject):
         t = w_obj.wrappeditems
     elif isinstance(w_obj, W_ListObject):
         t = w_obj.wrappeditems[:]
     else:
         return ObjSpace.fixedview(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise UnpackValueError("Expected length %d, got %d" % (expected_length, len(t)))
     return t
Ejemplo n.º 31
0
 def fixedview(self, w_obj, expected_length=-1):
     """ Fast paths
     """
     if isinstance(w_obj, W_TupleObject):
         t = w_obj.wrappeditems
     elif isinstance(w_obj, W_ListObject):
         t = w_obj.wrappeditems[:]
     else:
         return ObjSpace.fixedview(self, w_obj, expected_length)
     if expected_length != -1 and len(t) != expected_length:
         raise UnpackValueError("Expected length %d, got %d" %
                                (expected_length, len(t)))
     return t
Ejemplo n.º 32
0
 def createexecutioncontext(self):
     # add space specific fields to execution context
     ec = ObjSpace.createexecutioncontext(self)
     ec._py_repr = self.newdict()
     if self.config.objspace.std.withmethodcache:
         SIZE = 1 << self.config.objspace.std.methodcachesizeexp
         ec.method_cache_versions = [None] * SIZE
         ec.method_cache_names = [None] * SIZE
         ec.method_cache_lookup_where = [(None, None)] * SIZE
         if self.config.objspace.std.withmethodcachecounter:
             ec.method_cache_hits = {}
             ec.method_cache_misses = {}
     return ec
Ejemplo n.º 33
0
 def createexecutioncontext(self):
     # add space specific fields to execution context
     # note that this method must not call space methods that might need an
     # execution context themselves (e.g. nearly all space methods)
     ec = ObjSpace.createexecutioncontext(self)
     ec._py_repr = None
     if self.config.objspace.std.withmethodcache:
         SIZE = 1 << self.config.objspace.std.methodcachesizeexp
         ec.method_cache_versions = [None] * SIZE
         ec.method_cache_names = [None] * SIZE
         ec.method_cache_lookup_where = [(None, None)] * SIZE
         if self.config.objspace.std.withmethodcachecounter:
             ec.method_cache_hits = {}
             ec.method_cache_misses = {}
     return ec
Ejemplo n.º 34
0
 def unpackiterable(self, w_iterable, expected_length=None):
     if not isinstance(w_iterable, Variable):
         l = list(self.unwrap(w_iterable))
         if expected_length is not None and len(l) != expected_length:
             raise ValueError
         return [self.wrap(x) for x in l]
     if isinstance(w_iterable, Variable) and expected_length is None:
         raise UnwrapException, ("cannot unpack a Variable iterable" "without knowing its length")
     elif expected_length is not None:
         w_len = self.len(w_iterable)
         w_correct = self.eq(w_len, self.wrap(expected_length))
         if not self.is_true(w_correct):
             e = OperationError(self.w_ValueError, self.w_None)
             e.normalize_exception(self)
             raise e
         return [self.do_operation("getitem", w_iterable, self.wrap(i)) for i in range(expected_length)]
     return ObjSpace.unpackiterable(self, w_iterable, expected_length)
Ejemplo n.º 35
0
 def unpackiterable(self, w_iterable, expected_length=None):
     if not isinstance(w_iterable, Variable):
         l = list(self.unwrap(w_iterable))
         if expected_length is not None and len(l) != expected_length:
             raise ValueError
         return [self.wrap(x) for x in l]
     if isinstance(w_iterable, Variable) and expected_length is None:
         raise UnwrapException, ("cannot unpack a Variable iterable"
                                 "without knowing its length")
     elif expected_length is not None:
         w_len = self.len(w_iterable)
         w_correct = self.eq(w_len, self.wrap(expected_length))
         if not self.is_true(w_correct):
             e = OperationError(self.w_ValueError, self.w_None)
             e.normalize_exception(self)
             raise e
         return [self.do_operation('getitem', w_iterable, self.wrap(i)) 
                     for i in range(expected_length)]
     return ObjSpace.unpackiterable(self, w_iterable, expected_length)
Ejemplo n.º 36
0
def exception_issubclass_w(space, w_cls1, w_cls2):
    if (space.type(w_cls1) is space.w_type
            and space.type(w_cls2) is space.w_type):
        return BaseObjSpace.exception_issubclass_w(space, w_cls1, w_cls2)
    #
    if (not exception_is_valid_class_w(space, w_cls2)
            or not exception_is_valid_class_w(space, w_cls1)):
        return False
    #
    # The rest is the rare slow case.  Use the general logic of issubclass()
    # (issue #3149).  CPython 3.x doesn't do that (but there is a
    # many-years issue report: https://bugs.python.org/issue12029), and
    # there are probably tests, so we won't call abstract_issubclass_w()
    # either in PyPy3.
    try:
        return abstract_issubclass_w(space, w_cls1, w_cls2, True)
    except OperationError as e:
        if e. async (space):
            raise
        return False
Ejemplo n.º 37
0
    def unpackiterable(self, w_iterable, expected_length=None):
        if not isinstance(w_iterable, Variable):
            l = list(self.unwrap(w_iterable))
            if expected_length is not None and len(l) != expected_length:
                raise ValueError
            return [self.wrap(x) for x in l]
        if isinstance(w_iterable, Variable) and expected_length is None:
            raise UnwrapException, ("cannot unpack a Variable iterable"
                                    "without knowing its length")
##            # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK
##            print ("*** cannot unpack a Variable iterable "
##                   "without knowing its length,")
##            print "    assuming a list or tuple with up to 7 items"
##            items = []
##            w_len = self.len(w_iterable)
##            i = 0
##            while True:
##                w_i = self.wrap(i)
##                w_cond = self.eq(w_len, w_i)
##                if self.is_true(w_cond):
##                    break  # done
##                if i == 7:
##                    # too many values
##                    raise OperationError(self.w_AssertionError, self.w_None)
##                w_item = self.do_operation('getitem', w_iterable, w_i)
##                items.append(w_item)
##                i += 1
##            return items
##            # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK
        elif expected_length is not None:
            w_len = self.len(w_iterable)
            w_correct = self.eq(w_len, self.wrap(expected_length))
            if not self.is_true(w_correct):
                e = OperationError(self.w_ValueError, self.w_None)
                e.normalize_exception(self)
                raise e
            return [
                self.do_operation('getitem', w_iterable, self.wrap(i))
                for i in range(expected_length)
            ]
        return ObjSpace.unpackiterable(self, w_iterable, expected_length)
Ejemplo n.º 38
0
    def unpackiterable(self, w_iterable, expected_length=None):
        if not isinstance(w_iterable, Variable):
            l = list(self.unwrap(w_iterable))
            if expected_length is not None and len(l) != expected_length:
                raise ValueError
            return [self.wrap(x) for x in l]
        if isinstance(w_iterable, Variable) and expected_length is None:
            raise UnwrapException, ("cannot unpack a Variable iterable"
                                    "without knowing its length")
##            # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK
##            print ("*** cannot unpack a Variable iterable "
##                   "without knowing its length,")
##            print "    assuming a list or tuple with up to 7 items"
##            items = []
##            w_len = self.len(w_iterable)
##            i = 0
##            while True:
##                w_i = self.wrap(i)
##                w_cond = self.eq(w_len, w_i)
##                if self.is_true(w_cond):
##                    break  # done
##                if i == 7:
##                    # too many values
##                    raise OperationError(self.w_AssertionError, self.w_None)
##                w_item = self.do_operation('getitem', w_iterable, w_i)
##                items.append(w_item)
##                i += 1
##            return items
##            # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK
        elif expected_length is not None:
            w_len = self.len(w_iterable)
            w_correct = self.eq(w_len, self.wrap(expected_length))
            if not self.is_true(w_correct):
                e = OperationError(self.w_ValueError, self.w_None)
                e.normalize_exception(self)
                raise e
            return [self.do_operation('getitem', w_iterable, self.wrap(i)) 
                        for i in range(expected_length)]
        return ObjSpace.unpackiterable(self, w_iterable, expected_length)
Ejemplo n.º 39
0
 def getindex_w(self, w_obj, w_exception, objdescr=None, errmsg=None):
     if type(w_obj) is W_IntObject:
         return w_obj.intval
     return ObjSpace.getindex_w(self, w_obj, w_exception, objdescr, errmsg)
Ejemplo n.º 40
0
def exception_is_valid_obj_as_class_w(space, w_obj):
    obj = space.interpclass_w(w_obj)
    if isinstance(obj, W_ClassObject):
        return True
    return BaseObjSpace.exception_is_valid_obj_as_class_w(space, w_obj)
Ejemplo n.º 41
0
def exception_is_valid_class_w(space, w_cls):
    cls = space.interpclass_w(w_cls)
    if isinstance(cls, W_ClassObject):
        return True
    return BaseObjSpace.exception_is_valid_class_w(space, w_cls)
Ejemplo n.º 42
0
def exception_getclass(space, w_obj):
    obj = space.interpclass_w(w_obj)
    if isinstance(obj, W_InstanceObject):
        return obj.w_class
    return BaseObjSpace.exception_getclass(space, w_obj)
Ejemplo n.º 43
0
 def __init__(self, config=None):
     self._seen_extras = []
     ObjSpace.__init__(self, config=config)
     self.setup()
Ejemplo n.º 44
0
 def createexecutioncontext(self):
     ec = ObjSpace.createexecutioncontext(self)
     ec._py_repr = None
     return ec
Ejemplo n.º 45
0
 def __init__(self, config=None):
     self._seen_extras = []
     ObjSpace.__init__(self, config=config)
Ejemplo n.º 46
0
 def createframe(self, code, w_globals, outer_func=None):
     from pypy.objspace.std.fake import CPythonFakeCode, CPythonFakeFrame
     if not we_are_translated() and isinstance(code, CPythonFakeCode):
         return CPythonFakeFrame(self, code, w_globals)
     else:
         return ObjSpace.createframe(self, code, w_globals, outer_func)
Ejemplo n.º 47
0
def exception_is_valid_obj_as_class_w(space, w_obj):
    obj = space.interpclass_w(w_obj)
    if isinstance(obj, W_ClassObject):
        return True
    return BaseObjSpace.exception_is_valid_obj_as_class_w(space, w_obj)
Ejemplo n.º 48
0
 def newlist_utf8(self, list_u, is_ascii):
     if is_ascii:
         return W_ListObject.newlist_utf8(self, list_u)
     return ObjSpace.newlist_utf8(self, list_u, False)
Ejemplo n.º 49
0
def exception_is_valid_class_w(space, w_cls):
    cls = space.interpclass_w(w_cls)
    if isinstance(cls, W_ClassObject):
        return True
    return BaseObjSpace.exception_is_valid_class_w(space, w_cls)
Ejemplo n.º 50
0
 def call_method(self, w_obj, methname, *arg_w):
     if self.config.objspace.opcodes.CALL_METHOD:
         from pypy.objspace.std.callmethod import call_method_opt
         return call_method_opt(self, w_obj, methname, *arg_w)
     else:
         return ObjSpace.call_method(self, w_obj, methname, *arg_w)
Ejemplo n.º 51
0
 def createframe(self, code, w_globals, outer_func=None):
     from pypy.objspace.std.fake import CPythonFakeCode, CPythonFakeFrame
     if not we_are_translated() and isinstance(code, CPythonFakeCode):
         return CPythonFakeFrame(self, code, w_globals)
     else:
         return ObjSpace.createframe(self, code, w_globals, outer_func)
Ejemplo n.º 52
0
 def getindex_w(self, w_obj, w_exception, objdescr=None):
     if type(w_obj) is W_IntObject:
         return w_obj.intval
     return ObjSpace.getindex_w(self, w_obj, w_exception, objdescr)
Ejemplo n.º 53
0
def exception_getclass(space, w_obj):
    obj = space.interpclass_w(w_obj)
    if isinstance(obj, W_InstanceObject):
        return obj.w_class
    return BaseObjSpace.exception_getclass(space, w_obj)
Ejemplo n.º 54
0
 def createexecutioncontext(self):
     ec = ObjSpace.createexecutioncontext(self)
     ec._py_repr = None
     return ec
Ejemplo n.º 55
0
 def finditem(self, w_obj, w_key):
     # performance shortcut to avoid creating the OperationError(KeyError)
     if type(w_obj) is self.DictObjectCls:
         return w_obj.get(w_key, None)
     return ObjSpace.finditem(self, w_obj, w_key)