def PyBuffer_FillInfo(space, view, obj, buf, length, readonly, flags):
"""
Fills in a buffer-info structure correctly for an exporter that can only
share a contiguous chunk of memory of "unsigned bytes" of the given
length. Returns 0 on success and -1 (with raising an error) on error.
This is not a complete re-implementation of the CPython API; it only
provides a subset of CPython's behavior.
"""
if flags & PyBUF_WRITABLE and readonly:
raise OperationError(space.w_ValueError,
space.wrap("Object is not writable"))
view.c_buf = buf
view.c_len = length
view.c_obj = obj
Py_IncRef(space, obj)
view.c_itemsize = 1
rffi.setintfield(view, 'c_readonly', readonly)
rffi.setintfield(view, 'c_ndim', 0)
view.c_format = lltype.nullptr(rffi.CCHARP.TO)
view.c_shape = lltype.nullptr(Py_ssize_tP.TO)
view.c_strides = lltype.nullptr(Py_ssize_tP.TO)
view.c_suboffsets = lltype.nullptr(Py_ssize_tP.TO)
view.c_internal = lltype.nullptr(rffi.VOIDP.TO)
return 0
def PyBuffer_FillInfo(space, view, obj, buf, length, readonly, flags):
"""
Fills in a buffer-info structure correctly for an exporter that can only
share a contiguous chunk of memory of "unsigned bytes" of the given
length. Returns 0 on success and -1 (with raising an error) on error.
"""
if flags & PyBUF_WRITABLE and readonly:
raise oefmt(space.w_ValueError, "Object is not writable")
view.c_buf = buf
view.c_len = length
view.c_obj = obj
if obj:
Py_IncRef(space, obj)
view.c_itemsize = 1
rffi.setintfield(view, 'c_readonly', readonly)
rffi.setintfield(view, 'c_ndim', 1)
view.c_format = lltype.nullptr(rffi.CCHARP.TO)
if (flags & PyBUF_FORMAT) == PyBUF_FORMAT:
view.c_format = rffi.str2charp("B")
view.c_shape = lltype.nullptr(Py_ssize_tP.TO)
if (flags & PyBUF_ND) == PyBUF_ND:
view.c_shape = rffi.cast(Py_ssize_tP, view.c__shape)
view.c_shape[0] = view.c_len
view.c_strides = lltype.nullptr(Py_ssize_tP.TO)
if (flags & PyBUF_STRIDES) == PyBUF_STRIDES:
view.c_strides = rffi.cast(Py_ssize_tP, view.c__strides)
view.c_strides[0] = view.c_itemsize
view.c_suboffsets = lltype.nullptr(Py_ssize_tP.TO)
view.c_internal = lltype.nullptr(rffi.VOIDP.TO)
return 0
def PyBuffer_FillInfo(space, view, obj, buf, length, readonly, flags):
"""
Fills in a buffer-info structure correctly for an exporter that can only
share a contiguous chunk of memory of "unsigned bytes" of the given
length. Returns 0 on success and -1 (with raising an error) on error.
This is not a complete re-implementation of the CPython API; it only
provides a subset of CPython's behavior.
"""
view.c_buf = buf
view.c_len = length
view.c_obj = obj
Py_IncRef(space, obj)
return 0
def PyDict_Next(space, w_dict, ppos, pkey, pvalue):
"""Iterate over all key-value pairs in the dictionary p. The
Py_ssize_t referred to by ppos must be initialized to 0
prior to the first call to this function to start the iteration; the
function returns true for each pair in the dictionary, and false once all
pairs have been reported. The parameters pkey and pvalue should either
point to PyObject* variables that will be filled in with each key
and value, respectively, or may be NULL. Any references returned through
them are borrowed. ppos should not be altered during iteration. Its
value represents offsets within the internal dictionary structure, and
since the structure is sparse, the offsets are not consecutive.
For example:
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(self->dict, &pos, &key, &value)) {
/* do something interesting with the values... */
...
}
The dictionary p should not be mutated during iteration. It is safe
(since Python 2.1) to modify the values but not the keys as you iterate
over the dictionary, the keys must not change.
For example:
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(self->dict, &pos, &key, &value)) {
int i = PyInt_AS_LONG(value) + 1;
PyObject *o = PyInt_FromLong(i);
if (o == NULL)
return -1;
if (PyDict_SetItem(self->dict, key, o) < 0) {
Py_DECREF(o);
return -1;
}
Py_DECREF(o);
}"""
if w_dict is None:
return 0
if not space.isinstance_w(w_dict, space.w_dict):
return 0
pos = ppos[0]
py_obj = as_pyobj(space, w_dict)
py_dict = rffi.cast(PyDictObject, py_obj)
if pos == 0:
# Store the current keys in the PyDictObject.
from pypy.objspace.std.listobject import W_ListObject
decref(space, py_dict.c__tmpkeys)
w_keys = space.call_method(space.w_dict, "keys", w_dict)
# w_keys must use the object strategy in order to keep the keys alive
if not isinstance(w_keys, W_ListObject):
return 0 # XXX should not call keys() above
w_keys.switch_to_object_strategy()
py_dict.c__tmpkeys = create_ref(space, w_keys)
Py_IncRef(space, py_dict.c__tmpkeys)
else:
if not py_dict.c__tmpkeys:
# pos should have been 0, cannot fail so return 0
return 0;
w_keys = from_ref(space, py_dict.c__tmpkeys)
ppos[0] += 1
if pos >= space.len_w(w_keys):
decref(space, py_dict.c__tmpkeys)
py_dict.c__tmpkeys = lltype.nullptr(PyObject.TO)
return 0
w_key = space.listview(w_keys)[pos] # fast iff w_keys uses object strat
w_value = space.getitem(w_dict, w_key)
if pkey:
pkey[0] = as_pyobj(space, w_key)
if pvalue:
pvalue[0] = as_pyobj(space, w_value)
return 1
def PyObject_SelfIter(space, ref):
"""Undocumented function, this is wat CPython does."""
Py_IncRef(space, ref)
return ref