Beispiel #1
0
W_CData.typedef = TypeDef(
    '_cffi_backend.CData',
    __module__ = '_cffi_backend',
    __name__ = '<cdata>',
    __repr__ = interp2app(W_CData.repr),
    __bool__ = interp2app(W_CData.bool),
    __int__ = interp2app(W_CData.int),
    __long__ = interp2app(W_CData.long),
    __float__ = interp2app(W_CData.float),
    __len__ = interp2app(W_CData.len),
    __lt__ = interp2app(W_CData.lt),
    __le__ = interp2app(W_CData.le),
    __eq__ = interp2app(W_CData.eq),
    __ne__ = interp2app(W_CData.ne),
    __gt__ = interp2app(W_CData.gt),
    __ge__ = interp2app(W_CData.ge),
    __hash__ = interp2app(W_CData.hash),
    __getitem__ = interp2app(W_CData.getitem),
    __setitem__ = interp2app(W_CData.setitem),
    __add__ = interp2app(W_CData.add),
    __radd__ = interp2app(W_CData.add),
    __sub__ = interp2app(W_CData.sub),
    __getattr__ = interp2app(W_CData.getattr),
    __setattr__ = interp2app(W_CData.setattr),
    __call__ = interp2app(W_CData.call),
    __iter__ = interp2app(W_CData.iter),
    __weakref__ = make_weakref_descr(W_CData),
    )
W_CData.typedef.acceptable_as_base_class = False
Beispiel #2
0
def descr_typecode(space, self):
    return space.wrap(self.typecode)


class W_ArrayBase(W_Object):
    @staticmethod
    def register(typeorder):
        typeorder[W_ArrayBase] = []

W_ArrayBase.typedef = StdTypeDef(
    'array',
    __new__ = interp2app(w_array),
    __module__   = 'array',
    itemsize = GetSetProperty(descr_itemsize),
    typecode = GetSetProperty(descr_typecode),
    __weakref__ = make_weakref_descr(W_ArrayBase),
)
W_ArrayBase.typedef.registermethods(globals())


class TypeCode(object):
    def __init__(self, itemtype, unwrap, canoverflow=False, signed=False):
        self.itemtype = itemtype
        self.bytes = rffi.sizeof(itemtype)
        #self.arraytype = lltype.GcArray(itemtype)
        self.arraytype = lltype.Array(itemtype, hints={'nolength': True})
        self.unwrap = unwrap
        self.signed = signed
        self.canoverflow = canoverflow
        self.w_class = None
Beispiel #3
0
    # so that we don't need to do it here.  Creating new SRE_Pattern
    # objects all the time would be bad for the JIT, which relies on the
    # identity of the CompiledPattern() object.
    srepat.code = rsre_core.CompiledPattern(code, flags)
    srepat.num_groups = groups
    srepat.w_groupindex = w_groupindex
    srepat.w_indexgroup = w_indexgroup
    return w_srepat


W_SRE_Pattern.typedef = TypeDef(
    'SRE_Pattern',
    __new__=interp2app(SRE_Pattern__new__),
    __copy__=interp2app(W_SRE_Pattern.cannot_copy_w),
    __deepcopy__=interp2app(W_SRE_Pattern.cannot_copy_w),
    __weakref__=make_weakref_descr(W_SRE_Pattern),
    findall=interp2app(W_SRE_Pattern.findall_w),
    finditer=interp2app(W_SRE_Pattern.finditer_w),
    match=interp2app(W_SRE_Pattern.match_w),
    scanner=interp2app(W_SRE_Pattern.finditer_w),  # reuse finditer()
    search=interp2app(W_SRE_Pattern.search_w),
    split=interp2app(W_SRE_Pattern.split_w),
    sub=interp2app(W_SRE_Pattern.sub_w),
    subn=interp2app(W_SRE_Pattern.subn_w),
    flags=interp_attrproperty('flags', W_SRE_Pattern, wrapfn="newint"),
    groupindex=interp_attrproperty_w('w_groupindex', W_SRE_Pattern),
    groups=interp_attrproperty('num_groups', W_SRE_Pattern, wrapfn="newint"),
    pattern=interp_attrproperty_w('w_pattern', W_SRE_Pattern),
)
W_SRE_Pattern.typedef.acceptable_as_base_class = False
Beispiel #4
0
                    "don't know the size pointed to by '%s'", ctype.name)
    ptr = w_cdata.unsafe_escaping_ptr()    # w_cdata kept alive by MiniBuffer()
    return MiniBuffer(LLBuffer(ptr, size), w_cdata)

MiniBuffer.typedef = TypeDef(
    "_cffi_backend.buffer", None, None, "read-write",
    __new__ = interp2app(MiniBuffer___new__),
    __len__ = interp2app(MiniBuffer.descr_len),
    __getitem__ = interp2app(MiniBuffer.descr_getitem),
    __setitem__ = interp2app(MiniBuffer.descr_setitem),
    __eq__ = interp2app(MiniBuffer.descr_eq),
    __ne__ = interp2app(MiniBuffer.descr_ne),
    __lt__ = interp2app(MiniBuffer.descr_lt),
    __le__ = interp2app(MiniBuffer.descr_le),
    __gt__ = interp2app(MiniBuffer.descr_gt),
    __ge__ = interp2app(MiniBuffer.descr_ge),
    __weakref__ = make_weakref_descr(MiniBuffer),
    __doc__ = """ffi.buffer(cdata[, byte_size]):
Return a read-write buffer object that references the raw C data
pointed to by the given 'cdata'.  The 'cdata' must be a pointer or an
array.  Can be passed to functions expecting a buffer, or directly
manipulated with:

    buf[:]          get a copy of it in a regular string, or
    buf[idx]        as a single character
    buf[:] = ...
    buf[idx] = ...  change the content
""",
    )
MiniBuffer.typedef.acceptable_as_base_class = False
Beispiel #5
0
    "read-write",
    variable_sized=True,
    __doc__="""\
Create a new memoryview object which references the given object.
""",
    __new__=interp2app(W_MemoryView.descr_new_memoryview),
    __eq__=interp2app(W_MemoryView.descr_eq),
    __getitem__=interp2app(W_MemoryView.descr_getitem),
    __len__=interp2app(W_MemoryView.descr_len),
    __ne__=interp2app(W_MemoryView.descr_ne),
    __setitem__=interp2app(W_MemoryView.descr_setitem),
    __repr__=interp2app(W_MemoryView.descr_repr),
    __hash__=interp2app(W_MemoryView.descr_hash),
    __enter__=interp2app(W_MemoryView.descr_enter),
    __exit__=interp2app(W_MemoryView.descr_exit),
    __weakref__=make_weakref_descr(W_MemoryView),
    cast=interp2app(W_MemoryView.descr_cast),
    hex=interp2app(W_MemoryView.descr_hex),
    tobytes=interp2app(W_MemoryView.descr_tobytes),
    tolist=interp2app(W_MemoryView.descr_tolist),
    release=interp2app(W_MemoryView.descr_release),
    format=GetSetProperty(W_MemoryView.w_get_format),
    itemsize=GetSetProperty(W_MemoryView.w_get_itemsize),
    ndim=GetSetProperty(W_MemoryView.w_get_ndim),
    nbytes=GetSetProperty(W_MemoryView.w_get_nbytes),
    readonly=GetSetProperty(W_MemoryView.w_is_readonly),
    shape=GetSetProperty(W_MemoryView.w_get_shape),
    strides=GetSetProperty(W_MemoryView.w_get_strides),
    suboffsets=GetSetProperty(W_MemoryView.w_get_suboffsets),
    obj=GetSetProperty(W_MemoryView.w_get_obj),
    _pypy_raw_address=interp2app(W_MemoryView.descr_pypy_raw_address),
Beispiel #6
0
                                          W_Root, W_Root]),
    __delslice__ = interp2app(W_InstanceObject.descr_delslice,
                             unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
    __call__ = interp2app(W_InstanceObject.descr_call,
                          unwrap_spec=['self', ObjSpace, Arguments]),
    __nonzero__ = interp2app(W_InstanceObject.descr_nonzero,
                             unwrap_spec=['self', ObjSpace]),
    __cmp__ = interp2app(W_InstanceObject.descr_cmp,
                         unwrap_spec=['self', ObjSpace, W_Root]),
    __hash__ = interp2app(W_InstanceObject.descr_hash,
                          unwrap_spec=['self', ObjSpace]),
    __index__ = interp2app(W_InstanceObject.descr_index,
                           unwrap_spec=['self', ObjSpace]),
    __contains__ = interp2app(W_InstanceObject.descr_contains,
                         unwrap_spec=['self', ObjSpace, W_Root]),
    __pow__ = interp2app(W_InstanceObject.descr_pow,
                         unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
    __rpow__ = interp2app(W_InstanceObject.descr_rpow,
                         unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
    next = interp2app(W_InstanceObject.descr_next,
                      unwrap_spec=['self', ObjSpace]),
    __weakref__ = make_weakref_descr(W_InstanceObject),
    __del__ = interp2app(W_InstanceObject.descr_del,
                         unwrap_spec=['self', ObjSpace]),
    **rawdict
)

class W_InstanceObjectWithDel(W_InstanceObject):
    def __del__(self):
        self._enqueue_for_destruction(self.space)
Beispiel #7
0
    elif __args__.arguments_w or __args__.keywords:
        raise OperationError(space.w_TypeError,
                             space.wrap("this constructor takes no arguments"))
    return w_inst


W_ClassObject.typedef = TypeDef(
    "classobj",
    __new__=interp2app(descr_classobj_new),
    __repr__=interp2app(W_ClassObject.descr_repr),
    __str__=interp2app(W_ClassObject.descr_str),
    __call__=interp2app(class_descr_call),
    __getattribute__=interp2app(W_ClassObject.descr_getattribute),
    __setattr__=interp2app(W_ClassObject.descr_setattr),
    __delattr__=interp2app(W_ClassObject.descr_delattr),
    __weakref__=make_weakref_descr(W_ClassObject),
)
W_ClassObject.typedef.acceptable_as_base_class = False


def make_unary_instance_method(name):
    def unaryop(self, space):
        w_meth = self.getattr(space, name, True)
        return space.call_function(w_meth)

    unaryop.func_name = name
    return unaryop


def make_binary_returning_notimplemented_instance_method(name):
    def binaryop(self, space, w_other):
Beispiel #8
0
    def fget_item(self, space):     return self._fget('i')
    def fget_length(self, space):   return self._fget('l')
    def fget_fields(self, space):   return self._fget('f')
    def fget_args(self, space):     return self._fget('a')
    def fget_result(self, space):   return self._fget('r')
    def fget_ellipsis(self, space): return self._fget('E')
    def fget_abi(self, space):      return self._fget('A')
    def fget_elements(self, space): return self._fget('e')
    def fget_relements(self, space):return self._fget('R')


W_CType.typedef = TypeDef(
    'CTypeDescr',
    __module__ = '_cffi_backend',
    __repr__ = interp2app(W_CType.repr),
    __weakref__ = make_weakref_descr(W_CType),
    kind = GetSetProperty(W_CType.fget_kind, doc="kind"),
    cname = GetSetProperty(W_CType.fget_cname, doc="C name"),
    item = GetSetProperty(W_CType.fget_item, doc="pointer to, or array of"),
    length = GetSetProperty(W_CType.fget_length, doc="array length or None"),
    fields = GetSetProperty(W_CType.fget_fields, doc="struct or union fields"),
    args = GetSetProperty(W_CType.fget_args, doc="function argument types"),
    result = GetSetProperty(W_CType.fget_result, doc="function result type"),
    ellipsis = GetSetProperty(W_CType.fget_ellipsis, doc="function has '...'"),
    abi = GetSetProperty(W_CType.fget_abi, doc="function ABI"),
    elements = GetSetProperty(W_CType.fget_elements, doc="enum elements"),
    relements = GetSetProperty(W_CType.fget_relements,
                               doc="enum elements, reversed"),
    __dir__ = interp2app(W_CType.dir),
    )
W_CType.typedef.acceptable_as_base_class = False
Beispiel #9
0
        from pypy.objspace.std.typeobject import _precheck_for_new
        w_subtype = _precheck_for_new(space, w_subtype)
        if __args__.arguments_w or __args__.keywords:
            w_parent_init, _ = space.lookup_in_type_where(w_subtype, '__init__')
            if w_parent_init is space.w_object:
                raise oefmt(space.w_TypeError,
                            "Initialization arguments are not supported")
        local = space.allocate_instance(Local, w_subtype)
        Local.__init__(local, space, __args__)
        return local

Local.typedef = TypeDef("_thread._local",
                        __doc__ = "Thread-local data",
                        __new__ = interp2app(Local.descr_local__new__.im_func),
                        __dict__ = GetSetProperty(descr_get_dict, cls=Local),
                        __weakref__ = make_weakref_descr(Local),
                        )

def thread_is_stopping(ec):
    sentinel_lock = ec._sentinel_lock
    if sentinel_lock is not None:
        if sentinel_lock.lock.is_acquired():
            sentinel_lock.descr_lock_release(ec.space)
    tlobjs = ec._thread_local_objs
    if tlobjs is None:
        return
    ec._thread_local_objs = None
    for wref in tlobjs.items():
        local = wref()
        if local is not None:
            del local.dicts[ec]
Beispiel #10
0
    flush=interp2app(W_IOBase.flush_w),
    seek=interp2app(W_IOBase.seek_w),
    tell=interp2app(W_IOBase.tell_w),
    truncate=interp2app(W_IOBase.truncate_w),
    fileno=interp2app(W_IOBase.fileno_w),
    isatty=interp2app(W_IOBase.isatty_w),
    readable=interp2app(W_IOBase.readable_w),
    writable=interp2app(W_IOBase.writable_w),
    seekable=interp2app(W_IOBase.seekable_w),
    _checkReadable=interp2app(check_readable_w),
    _checkWritable=interp2app(check_writable_w),
    _checkSeekable=interp2app(check_seekable_w),
    _checkClosed=interp2app(W_IOBase.check_closed_w),
    closed=GetSetProperty(W_IOBase.closed_get_w),
    __dict__=GetSetProperty(descr_get_dict, descr_set_dict, cls=W_IOBase),
    __weakref__=make_weakref_descr(W_IOBase),
    readline=interp2app(W_IOBase.readline_w),
    readlines=interp2app(W_IOBase.readlines_w),
    writelines=interp2app(W_IOBase.writelines_w),
)


class W_RawIOBase(W_IOBase):
    # ________________________________________________________________
    # Abstract read methods, based on readinto()

    def read_w(self, space, w_size=None):
        size = convert_size(space, w_size)
        if size < 0:
            return space.call_method(self, "readall")
Beispiel #11
0
    def descr_iter_unpack(self, space, w_buffer):
        return W_UnpackIter(space, self, w_buffer)

W_Struct.typedef = TypeDef("Struct",
    __new__=interp2app(W_Struct.descr__new__.im_func),
    __init__=interp2app(W_Struct.descr__init__),
    format=interp_attrproperty("format", cls=W_Struct, wrapfn="newbytes"),
    size=interp_attrproperty("size", cls=W_Struct, wrapfn="newint"),

    pack=interp2app(W_Struct.descr_pack),
    unpack=interp2app(W_Struct.descr_unpack),
    pack_into=interp2app(W_Struct.descr_pack_into),
    unpack_from=interp2app(W_Struct.descr_unpack_from),
    iter_unpack=interp2app(W_Struct.descr_iter_unpack),
    __weakref__=make_weakref_descr(W_Struct),
)

W_UnpackIter.typedef = TypeDef("unpack_iterator",
    __iter__=interp2app(W_UnpackIter.descr_iter),
    __next__=interp2app(W_UnpackIter.descr_next),
    __length_hint__=interp2app(W_UnpackIter.descr_length_hint)
)

def iter_unpack(space, w_format, w_buffer):
    w_struct = W_Struct()
    w_struct.descr__init__(space, w_format)
    return W_UnpackIter(space, w_struct, w_buffer)

def clearcache(space):
    """No-op on PyPy"""
Beispiel #12
0
    __repr__=interp2app(GeneratorIterator.descr__repr__),
    __reduce__=interp2app(GeneratorIterator.descr__reduce__),
    __setstate__=interp2app(GeneratorIterator.descr__setstate__),
    next=interp2app(GeneratorIterator.descr_next, descrmismatch='next'),
    send=interp2app(GeneratorIterator.descr_send, descrmismatch='send'),
    throw=interp2app(GeneratorIterator.descr_throw, descrmismatch='throw'),
    close=interp2app(GeneratorIterator.descr_close, descrmismatch='close'),
    __iter__=interp2app(GeneratorIterator.descr__iter__,
                        descrmismatch='__iter__'),
    gi_running=interp_attrproperty('running',
                                   cls=GeneratorIterator,
                                   wrapfn="newbool"),
    gi_frame=GetSetProperty(GeneratorIterator.descr_gi_frame),
    gi_code=GetSetProperty(GeneratorIterator.descr_gi_code),
    __name__=GetSetProperty(GeneratorIterator.descr__name__),
    __weakref__=make_weakref_descr(GeneratorIterator),
)
assert not GeneratorIterator.typedef.acceptable_as_base_class  # no __new__


def get_printable_location_genentry(bytecode):
    return '%s <generator>' % (bytecode.get_repr(), )


generatorentry_driver = jit.JitDriver(
    greens=['pycode'],
    reds=['gen', 'w_arg', 'operr'],
    get_printable_location=get_printable_location_genentry,
    name='generatorentry')

from pypy.tool.stdlib_opcode import HAVE_ARGUMENT, opmap
Beispiel #13
0
        self.keepalive = keepalive

    def descr_setitem(self, space, w_index, w_obj):
        try:
            W_Buffer.descr_setitem(self, space, w_index, w_obj)
        except OperationError as e:
            if e.match(space, space.w_TypeError):
                e.w_type = space.w_ValueError
            raise

MiniBuffer.typedef = TypeDef(
    "_cffi_backend.buffer",
    __len__ = interp2app(MiniBuffer.descr_len),
    __getitem__ = interp2app(MiniBuffer.descr_getitem),
    __setitem__ = interp2app(MiniBuffer.descr_setitem),
    __weakref__ = make_weakref_descr(MiniBuffer),
    __str__ = interp2app(MiniBuffer.descr_str),
    )
MiniBuffer.typedef.acceptable_as_base_class = False


@unwrap_spec(w_cdata=cdataobj.W_CData, size=int)
def buffer(space, w_cdata, size=-1):
    ctype = w_cdata.ctype
    if isinstance(ctype, ctypeptr.W_CTypePointer):
        if size < 0:
            structobj = w_cdata.get_structobj()
            if (structobj is not None and
                isinstance(structobj.ctype, ctypestruct.W_CTypeStructOrUnion)):
                size = structobj._sizeof()
            if size < 0:
Beispiel #14
0
Build an ordered collection accessible from endpoints only.""",
    __new__ = interp2app(descr__new__),
    __init__ = interp2app(W_Deque.init),
    append     = interp2app(W_Deque.append),
    appendleft = interp2app(W_Deque.appendleft),
    clear      = interp2app(W_Deque.clear),
    count      = interp2app(W_Deque.count),
    extend     = interp2app(W_Deque.extend),
    extendleft = interp2app(W_Deque.extendleft),
    pop        = interp2app(W_Deque.pop),
    popleft    = interp2app(W_Deque.popleft),
    remove     = interp2app(W_Deque.remove),
    reverse    = interp2app(W_Deque.reverse),
    rotate     = interp2app(W_Deque.rotate),
    __weakref__ = make_weakref_descr(W_Deque),
    __iter__ = interp2app(W_Deque.iter),
    __reversed__ = interp2app(W_Deque.reviter),
    __len__ = interp2app(W_Deque.length),
    __repr__ = interp2app(W_Deque.repr),
    __lt__ = interp2app(W_Deque.lt),
    __le__ = interp2app(W_Deque.le),
    __eq__ = interp2app(W_Deque.eq),
    __ne__ = interp2app(W_Deque.ne),
    __gt__ = interp2app(W_Deque.gt),
    __ge__ = interp2app(W_Deque.ge),
    __hash__ = None,
    __iadd__ = interp2app(W_Deque.iadd),
    __getitem__ = interp2app(W_Deque.getitem),
    __setitem__ = interp2app(W_Deque.setitem),
    __delitem__ = interp2app(W_Deque.delitem),
Beispiel #15
0
    rfind = interp2app(W_MMap.rfind),
    seek = interp2app(W_MMap.seek),
    tell = interp2app(W_MMap.tell),
    size = interp2app(W_MMap.descr_size),
    write = interp2app(W_MMap.write),
    write_byte = interp2app(W_MMap.write_byte),
    flush = interp2app(W_MMap.flush),
    move = interp2app(W_MMap.move),
    resize = interp2app(W_MMap.resize),

    __len__ = interp2app(W_MMap.__len__),
    __getitem__ = interp2app(W_MMap.descr_getitem),
    __setitem__ = interp2app(W_MMap.descr_setitem),
    __enter__ = interp2app(W_MMap.descr_enter),
    __exit__ = interp2app(W_MMap.descr_exit),
    __weakref__ = make_weakref_descr(W_MMap),

    closed = GetSetProperty(W_MMap.closed_get),
)

constants = rmmap.constants
PAGESIZE = rmmap.PAGESIZE
ALLOCATIONGRANULARITY = rmmap.ALLOCATIONGRANULARITY
ACCESS_READ  = rmmap.ACCESS_READ
ACCESS_WRITE = rmmap.ACCESS_WRITE
ACCESS_COPY  = rmmap.ACCESS_COPY


@objectmodel.dont_inline
def mmap_error(space, e):
    if isinstance(e, RValueError):
Beispiel #16
0
Build an ordered collection accessible from endpoints only.""",
    __module__='_collections',
    __new__=interp2app(descr__new__),
    __init__=interp2app(W_Deque.init),
    append=interp2app(W_Deque.append),
    appendleft=interp2app(W_Deque.appendleft),
    clear=interp2app(W_Deque.clear),
    count=interp2app(W_Deque.count),
    extend=interp2app(W_Deque.extend),
    extendleft=interp2app(W_Deque.extendleft),
    pop=interp2app(W_Deque.pop),
    popleft=interp2app(W_Deque.popleft),
    remove=interp2app(W_Deque.remove),
    reverse=interp2app(W_Deque.reverse),
    rotate=interp2app(W_Deque.rotate),
    __weakref__=make_weakref_descr(W_Deque),
    __iter__=interp2app(W_Deque.iter),
    __reversed__=interp2app(W_Deque.reviter),
    __len__=interp2app(W_Deque.length),
    __repr__=interp2app(W_Deque.repr),
    __lt__=interp2app(W_Deque.lt),
    __le__=interp2app(W_Deque.le),
    __eq__=interp2app(W_Deque.eq),
    __ne__=interp2app(W_Deque.ne),
    __gt__=interp2app(W_Deque.gt),
    __ge__=interp2app(W_Deque.ge),
    __hash__=None,
    __iadd__=interp2app(W_Deque.iadd),
    __getitem__=interp2app(W_Deque.getitem),
    __setitem__=interp2app(W_Deque.setitem),
    __delitem__=interp2app(W_Deque.delitem),
Beispiel #17
0
def W_TeeIterable___new__(space, w_subtype, w_iterable):
    # Obscure and undocumented function.  PyPy only supports w_iterable
    # being a W_TeeIterable, because the case where it is a general
    # iterable is useless and confusing as far as I can tell (as the
    # semantics are then slightly different; see the XXX in lib-python's
    # test_itertools).
    myiter = space.interp_w(W_TeeIterable, w_iterable)
    return space.wrap(W_TeeIterable(space, myiter.w_iterator,
                                           myiter.chained_list))

W_TeeIterable.typedef = TypeDef(
        'itertools._tee',
        __new__ = interp2app(W_TeeIterable___new__),
        __iter__ = interp2app(W_TeeIterable.iter_w),
        __next__ = interp2app(W_TeeIterable.next_w),
        __weakref__ = make_weakref_descr(W_TeeIterable),
        )
W_TeeIterable.typedef.acceptable_as_base_class = False


class W_GroupBy(W_Root):
    def __init__(self, space, w_iterable, w_fun):
        self.space = space
        self.w_iterable = self.space.iter(w_iterable)
        if space.is_none(w_fun):
            self.w_fun = None
        else:
            self.w_fun = w_fun
        self.index = 0
        self.lookahead = False
        self.exhausted = False
Beispiel #18
0
 __getslice__=interp2app(W_ArrayBase.descr_getslice),
 __setitem__=interp2app(W_ArrayBase.descr_setitem),
 __setslice__=interp2app(W_ArrayBase.descr_setslice),
 __delitem__=interp2app(W_ArrayBase.descr_delitem),
 __delslice__=interp2app(W_ArrayBase.descr_delslice),
 __iter__=interp2app(W_ArrayBase.descr_iter),
 __add__=interpindirect2app(W_ArrayBase.descr_add),
 __iadd__=interpindirect2app(W_ArrayBase.descr_inplace_add),
 __mul__=interpindirect2app(W_ArrayBase.descr_mul),
 __imul__=interpindirect2app(W_ArrayBase.descr_inplace_mul),
 __radd__=interp2app(W_ArrayBase.descr_radd),
 __rmul__=interp2app(W_ArrayBase.descr_rmul),
 __repr__=interp2app(W_ArrayBase.descr_repr),
 itemsize=GetSetProperty(descr_itemsize),
 typecode=GetSetProperty(descr_typecode),
 __weakref__=make_weakref_descr(W_ArrayBase),
 append=interpindirect2app(W_ArrayBase.descr_append),
 extend=interp2app(W_ArrayBase.descr_extend),
 count=interpindirect2app(W_ArrayBase.descr_count),
 index=interpindirect2app(W_ArrayBase.descr_index),
 reverse=interpindirect2app(W_ArrayBase.descr_reverse),
 remove=interpindirect2app(W_ArrayBase.descr_remove),
 pop=interpindirect2app(W_ArrayBase.descr_pop),
 insert=interpindirect2app(W_ArrayBase.descr_insert),
 tolist=interp2app(W_ArrayBase.descr_tolist),
 fromlist=interp2app(W_ArrayBase.descr_fromlist),
 tostring=interp2app(W_ArrayBase.descr_tostring),
 fromstring=interp2app(W_ArrayBase.descr_fromstring),
 tofile=interp2app(W_ArrayBase.descr_tofile),
 fromfile=interp2app(W_ArrayBase.descr_fromfile),
 fromunicode=interp2app(W_ArrayBase.descr_fromunicode),
Beispiel #19
0
    srepat.space = space
    srepat.w_pattern = w_pattern      # the original uncompiled pattern
    srepat.flags = flags
    srepat.code = code
    srepat.num_groups = groups
    srepat.w_groupindex = w_groupindex
    srepat.w_indexgroup = w_indexgroup
    return w_srepat


W_SRE_Pattern.typedef = TypeDef(
    'SRE_Pattern',
    __new__      = interp2app(SRE_Pattern__new__),
    __copy__     = interp2app(W_SRE_Pattern.cannot_copy_w),
    __deepcopy__ = interp2app(W_SRE_Pattern.cannot_copy_w),
    __weakref__  = make_weakref_descr(W_SRE_Pattern),
    findall      = interp2app(W_SRE_Pattern.findall_w),
    finditer     = interp2app(W_SRE_Pattern.finditer_w),
    match        = interp2app(W_SRE_Pattern.match_w),
    scanner      = interp2app(W_SRE_Pattern.finditer_w),    # reuse finditer()
    search       = interp2app(W_SRE_Pattern.search_w),
    split        = interp2app(W_SRE_Pattern.split_w),
    sub          = interp2app(W_SRE_Pattern.sub_w),
    subn         = interp2app(W_SRE_Pattern.subn_w),
    flags        = interp_attrproperty('flags', W_SRE_Pattern),
    groupindex   = interp_attrproperty_w('w_groupindex', W_SRE_Pattern),
    groups       = interp_attrproperty('num_groups', W_SRE_Pattern),
    pattern      = interp_attrproperty_w('w_pattern', W_SRE_Pattern),
)

# ____________________________________________________________
Beispiel #20
0
Methods of socket objects (keyword arguments not allowed):

accept() -- accept a connection, returning new socket and client address
bind(addr) -- bind the socket to a local address
close() -- close the socket
connect(addr) -- connect the socket to a remote address
connect_ex(addr) -- connect, return an error code instead of an exception
dup() -- return a new socket object identical to the current one [*]
fileno() -- return underlying file descriptor
getpeername() -- return remote address [*]
getsockname() -- return local address
getsockopt(level, optname[, buflen]) -- get socket options
gettimeout() -- return timeout or None
listen(n) -- start listening for incoming connections
makefile([mode, [bufsize]]) -- return a file object for the socket [*]
recv(buflen[, flags]) -- receive data
recvfrom(buflen[, flags]) -- receive data and sender's address
sendall(data[, flags]) -- send all data
send(data[, flags]) -- send data, may not send all of it
sendto(data[, flags], addr) -- send data to a given address
setblocking(0 | 1) -- set or clear the blocking I/O flag
setsockopt(level, optname, value) -- set socket options
settimeout(None | float) -- set or clear the timeout
shutdown(how) -- shut down traffic in one or both directions

 [*] not available on all platforms!""",
    __new__ = descr_socket_new,
    __weakref__ = make_weakref_descr(W_RSocket),
    ** socketmethods
    )
Beispiel #21
0
        return self._fget('E')

    def fget_abi(self, space):
        return self._fget('A')

    def fget_elements(self, space):
        return self._fget('e')

    def fget_relements(self, space):
        return self._fget('R')


W_CType.typedef = TypeDef(
    '_cffi_backend.CTypeDescr',
    __repr__=interp2app(W_CType.repr),
    __weakref__=make_weakref_descr(W_CType),
    kind=GetSetProperty(W_CType.fget_kind, doc="kind"),
    cname=GetSetProperty(W_CType.fget_cname, doc="C name"),
    item=GetSetProperty(W_CType.fget_item, doc="pointer to, or array of"),
    length=GetSetProperty(W_CType.fget_length, doc="array length or None"),
    fields=GetSetProperty(W_CType.fget_fields, doc="struct or union fields"),
    args=GetSetProperty(W_CType.fget_args, doc="function argument types"),
    result=GetSetProperty(W_CType.fget_result, doc="function result type"),
    ellipsis=GetSetProperty(W_CType.fget_ellipsis, doc="function has '...'"),
    abi=GetSetProperty(W_CType.fget_abi, doc="function ABI"),
    elements=GetSetProperty(W_CType.fget_elements, doc="enum elements"),
    relements=GetSetProperty(W_CType.fget_relements,
                             doc="enum elements, reversed"),
    __dir__=interp2app(W_CType.dir),
)
W_CType.typedef.acceptable_as_base_class = False
Beispiel #22
0
    "thread.lock",
    __doc__="""\
A lock object is a synchronization primitive.  To create a lock,
call the thread.allocate_lock() function.  Methods are:

acquire() -- lock the lock, possibly blocking until it can be obtained
release() -- unlock of the lock
locked() -- test whether the lock is currently locked

A lock is not owned by the thread that locked it; another thread may
unlock it.  A thread attempting to lock a lock that it has already locked
will block until another thread unlocks it.  Deadlocks may ensue.""",
    acquire=descr_acquire,
    _py3k_acquire=descr_py3k_acquire,
    release=descr_release,
    locked=descr_locked,
    __enter__=descr__enter__,
    __exit__=descr__exit__,
    __weakref__=make_weakref_descr(Lock),
    # Obsolete synonyms
    acquire_lock=descr_acquire,
    release_lock=descr_release,
    locked_lock=descr_locked,
)


def allocate_lock(space):
    """Create a new lock object.  (allocate() is an obsolete synonym.)
See LockType.__doc__ for information about locks."""
    return Lock(space)
Beispiel #23
0
bind(addr) -- bind the socket to a local address
close() -- close the socket
connect(addr) -- connect the socket to a remote address
connect_ex(addr) -- connect, return an error code instead of an exception
dup() -- return a new socket object identical to the current one [*]
fileno() -- return underlying file descriptor
getpeername() -- return remote address [*]
getsockname() -- return local address
getsockopt(level, optname[, buflen]) -- get socket options
gettimeout() -- return timeout or None
listen(n) -- start listening for incoming connections
makefile([mode, [bufsize]]) -- return a file object for the socket [*]
recv(buflen[, flags]) -- receive data
recvfrom(buflen[, flags]) -- receive data and sender's address
sendall(data[, flags]) -- send all data
send(data[, flags]) -- send data, may not send all of it
sendto(data[, flags], addr) -- send data to a given address
setblocking(0 | 1) -- set or clear the blocking I/O flag
setsockopt(level, optname, value) -- set socket options
settimeout(None | float) -- set or clear the timeout
shutdown(how) -- shut down traffic in one or both directions

 [*] not available on all platforms!""",
                           __new__=descr_socket_new,
                           __weakref__=make_weakref_descr(W_Socket),
                           __repr__=interp2app(W_Socket.descr_repr),
                           type=GetSetProperty(W_Socket.get_type_w),
                           proto=GetSetProperty(W_Socket.get_proto_w),
                           family=GetSetProperty(W_Socket.get_family_w),
                           **socketmethods)
Beispiel #24
0
                              doc = "file mode ('r', 'U', 'w', 'a', "
                                    "possibly with 'b' or '+' added)"),
    encoding = interp_attrproperty('encoding', cls=W_File),
    errors = interp_attrproperty('errors', cls=W_File),
    closed   = GetSetProperty(descr_file_closed, cls=W_File,
                              doc="True if the file is closed"),
    newlines = GetSetProperty(descr_file_newlines, cls=W_File,
                              doc="end-of-line convention used in this file"),
    softspace= GetSetProperty(descr_file_softspace,
                              descr_file_setsoftspace,
                              cls=W_File,
                              doc="Support for 'print'."),
    __repr__ = interp2app(W_File.file__repr__),
    writelines = interp2app(W_File.file_writelines),
    __exit__ = interp2app(W_File.file__exit__),
    __weakref__ = make_weakref_descr(W_File),
    **dict([(name, interp2app(getattr(W_File, 'file_' + name)))
                for name in W_File._exposed_method_names])
    )

# ____________________________________________________________

def wrap_list_of_str(space, lst):
    return space.newlist_bytes(lst)

class FileState:
    def __init__(self, space):
        self.openstreams = {}

def getopenstreams(space):
    return space.fromcache(FileState).openstreams
Beispiel #25
0
        w_result = space.call_args(w_init, __args__)
        if not space.is_w(w_result, space.w_None):
            raise oefmt(space.w_TypeError, "__init__() should return None")
    elif __args__.arguments_w or __args__.keywords:
        raise oefmt(space.w_TypeError, "this constructor takes no arguments")
    return w_inst

W_ClassObject.typedef = TypeDef("classobj",
    __new__ = interp2app(descr_classobj_new),
    __repr__ = interp2app(W_ClassObject.descr_repr),
    __str__ = interp2app(W_ClassObject.descr_str),
    __call__ = interp2app(class_descr_call),
    __getattribute__ = interp2app(W_ClassObject.descr_getattribute),
    __setattr__ = interp2app(W_ClassObject.descr_setattr),
    __delattr__ = interp2app(W_ClassObject.descr_delattr),
    __weakref__ = make_weakref_descr(W_ClassObject),
)
W_ClassObject.typedef.acceptable_as_base_class = False


def make_unary_instance_method(name):
    def unaryop(self, space):
        w_meth = self.getattr(space, name, True)
        return space.call_function(w_meth)
    unaryop.func_name = name
    return unaryop

def make_binary_returning_notimplemented_instance_method(name):
    def binaryop(self, space, w_other):
        try:
            w_meth = self.getattr(space, name, False)
Beispiel #26
0
    seek = interp2app(W_IOBase.seek_w),
    tell = interp2app(W_IOBase.tell_w),
    truncate = interp2app(W_IOBase.truncate_w),
    fileno = interp2app(W_IOBase.fileno_w),
    isatty = interp2app(W_IOBase.isatty_w),
    readable = interp2app(W_IOBase.readable_w),
    writable = interp2app(W_IOBase.writable_w),
    seekable = interp2app(W_IOBase.seekable_w),

    _checkReadable = interp2app(check_readable_w),
    _checkWritable = interp2app(check_writable_w),
    _checkSeekable = interp2app(check_seekable_w),
    _checkClosed = interp2app(W_IOBase.check_closed_w),
    closed = GetSetProperty(W_IOBase.closed_get_w),
    __dict__ = GetSetProperty(descr_get_dict, descr_set_dict, cls=W_IOBase),
    __weakref__ = make_weakref_descr(W_IOBase),

    readline = interp2app(W_IOBase.readline_w),
    readlines = interp2app(W_IOBase.readlines_w),
    writelines = interp2app(W_IOBase.writelines_w),
)

class W_RawIOBase(W_IOBase):
    # ________________________________________________________________
    # Abstract read methods, based on readinto()

    def read_w(self, space, w_size=None):
        size = convert_size(space, w_size)
        if size < 0:
            return space.call_method(self, "readall")
Beispiel #27
0
    errors=interp_attrproperty('errors', cls=W_File, wrapfn="newtext_or_none"),
    closed=GetSetProperty(descr_file_closed,
                          cls=W_File,
                          doc="True if the file is closed"),
    newlines=GetSetProperty(descr_file_newlines,
                            cls=W_File,
                            doc="end-of-line convention used in this file"),
    softspace=GetSetProperty(descr_file_softspace,
                             descr_file_setsoftspace,
                             cls=W_File,
                             doc="Support for 'print'."),
    __repr__=interp2app(W_File.file__repr__),
    write=interp2app(W_File.file_write),
    writelines=interp2app(W_File.file_writelines),
    __exit__=interp2app(W_File.file__exit__),
    __weakref__=make_weakref_descr(W_File),
    **dict([(name, interp2app(getattr(W_File, 'file_' + name)))
            for name in W_File._exposed_method_names]))

# ____________________________________________________________


def wrap_list_of_str(space, lst):
    return space.newlist_bytes(lst)


class FileState:
    def __init__(self, space):
        self.openstreams = {}

Beispiel #28
0
        unwrap_spec=['self', ObjSpace, W_Root, W_Root, W_Root]),
    __delslice__=interp2app(W_InstanceObject.descr_delslice,
                            unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
    __call__=interp2app(W_InstanceObject.descr_call,
                        unwrap_spec=['self', ObjSpace, Arguments]),
    __nonzero__=interp2app(W_InstanceObject.descr_nonzero,
                           unwrap_spec=['self', ObjSpace]),
    __cmp__=interp2app(W_InstanceObject.descr_cmp,
                       unwrap_spec=['self', ObjSpace, W_Root]),
    __hash__=interp2app(W_InstanceObject.descr_hash,
                        unwrap_spec=['self', ObjSpace]),
    __index__=interp2app(W_InstanceObject.descr_index,
                         unwrap_spec=['self', ObjSpace]),
    __contains__=interp2app(W_InstanceObject.descr_contains,
                            unwrap_spec=['self', ObjSpace, W_Root]),
    __pow__=interp2app(W_InstanceObject.descr_pow,
                       unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
    __rpow__=interp2app(W_InstanceObject.descr_rpow,
                        unwrap_spec=['self', ObjSpace, W_Root, W_Root]),
    next=interp2app(W_InstanceObject.descr_next,
                    unwrap_spec=['self', ObjSpace]),
    __weakref__=make_weakref_descr(W_InstanceObject),
    __del__=interp2app(W_InstanceObject.descr_del,
                       unwrap_spec=['self', ObjSpace]),
    **rawdict)


class W_InstanceObjectWithDel(W_InstanceObject):
    def __del__(self):
        self._enqueue_for_destruction(self.space)
Beispiel #29
0
    # Obscure and undocumented function.  PyPy only supports w_iterable
    # being a W_TeeIterable, because the case where it is a general
    # iterable is useless and confusing as far as I can tell (as the
    # semantics are then slightly different; see the XXX in lib-python's
    # test_itertools).
    myiter = space.interp_w(W_TeeIterable, w_iterable)
    return W_TeeIterable(space, myiter.w_iterator, myiter.chained_list)


W_TeeIterable.typedef = TypeDef(
    'itertools._tee',
    __new__=interp2app(W_TeeIterable___new__),
    __iter__=interp2app(W_TeeIterable.iter_w),
    next=interp2app(W_TeeIterable.next_w),
    __copy__=interp2app(W_TeeIterable.copy_w),
    __weakref__=make_weakref_descr(W_TeeIterable),
)
W_TeeIterable.typedef.acceptable_as_base_class = False


class W_GroupBy(W_Root):
    def __init__(self, space, w_iterable, w_fun):
        self.space = space
        self.w_iterator = self.space.iter(w_iterable)
        if w_fun is None:
            w_fun = space.w_None
        self.w_keyfunc = w_fun
        self.w_tgtkey = None
        self.w_currkey = None
        self.w_currvalue = None
Beispiel #30
0
W_CData.typedef = TypeDef(
    '_cffi_backend.CData',
    __module__='_cffi_backend',
    __name__='<cdata>',
    __repr__=interp2app(W_CData.repr),
    __bool__=interp2app(W_CData.bool),
    __int__=interp2app(W_CData.int),
    __long__=interp2app(W_CData.long),
    __float__=interp2app(W_CData.float),
    __len__=interp2app(W_CData.len),
    __lt__=interp2app(W_CData.lt),
    __le__=interp2app(W_CData.le),
    __eq__=interp2app(W_CData.eq),
    __ne__=interp2app(W_CData.ne),
    __gt__=interp2app(W_CData.gt),
    __ge__=interp2app(W_CData.ge),
    __hash__=interp2app(W_CData.hash),
    __getitem__=interp2app(W_CData.getitem),
    __setitem__=interp2app(W_CData.setitem),
    __add__=interp2app(W_CData.add),
    __radd__=interp2app(W_CData.add),
    __sub__=interp2app(W_CData.sub),
    __getattr__=interp2app(W_CData.getattr),
    __setattr__=interp2app(W_CData.setattr),
    __call__=interp2app(W_CData.call),
    __iter__=interp2app(W_CData.iter),
    __weakref__=make_weakref_descr(W_CData),
)
W_CData.typedef.acceptable_as_base_class = False
Beispiel #31
0
        self.rlock_owner = owner
        self.rlock_count = count

    def release_save_w(self, space):
        """For internal use by `threading.Condition`."""
        count, self.rlock_count = self.rlock_count, 0
        owner, self.rlock_owner = self.rlock_owner, 0
        self.lock.release()
        return space.newtuple([space.wrap(count), space.wrap(owner)])

    def descr__enter__(self, space):
        self.acquire_w(space)
        return self

    def descr__exit__(self, space, __args__):
        self.release_w(space)


W_RLock.typedef = TypeDef(
    "_thread.RLock",
    __new__=interp2app(W_RLock.descr__new__.im_func),
    acquire=interp2app(W_RLock.acquire_w),
    release=interp2app(W_RLock.release_w),
    _is_owned=interp2app(W_RLock.is_owned_w),
    _acquire_restore=interp2app(W_RLock.acquire_restore_w),
    _release_save=interp2app(W_RLock.release_save_w),
    __enter__=interp2app(W_RLock.descr__enter__),
    __exit__=interp2app(W_RLock.descr__exit__),
    __weakref__=make_weakref_descr(W_RLock),
)