To do what?

This issue was linked from <https://mail.python.org/pipermail/python-dev/2012-September/121781.html>. I was looking for ways to pass read-only memory views into “ctypes” without copying memory, and came across that thread. Assuming this “buf” attribute points to the memory of the memory view, it could then be passed to “ctypes.c_void_p” or “_CData.from_address”.

ctypes could grow a way to access the Py_buffer API instead.

There are other kinds of libraries that might want to access the .buf attribute. For example, the llvmpy extension.  Exposing it would be useful.

Ha, llvmpy... Yes, it could be useful. It's dangerous too, especially since the buffer isn't necessarily contiguous.

Well, a lot of things in this big bad world are dangerous.  Don't see how this is any more dangerous than all of the peril that tools like ctypes and llvmpy already provide.

Le 31/07/2014 11:24, David Beazley a écrit :
>
> Well, a lot of things in this big bad world are dangerous. Don't see
how this is any more dangerous than all of the peril that tools like
ctypes and llvmpy already provide.

The point of the buffer API is to make memory access *less* dangerous 
than with the perilous tools, though.

Otherwise we might as well decide that Python crashes because C crashes :-)

(as for llvmpy, I think its implementation deserves to die)

One of the other goals of memoryviews is to make memory access less hacky.  To that end, it would be nice to have the .buf attribute available given that all of the other attributes are already there.  I don't see why people should need to do some even more hacky hack thing on top of hacks just to expose the pointer (which they'll figure out how to do anyway if they actually need to use it for something).

Sometimes I've used memoryview slices to model pointers in C code.

memoryview could have limited number methods for pointer arithmetic on the
buf pointer. Arithmetic would return new slices, so in fact everything would
be safe with respect to bounds checking and life-cycle management.


Not completely safe of course once you pass the pointer to ctypes, but
the following is less likely to happen:

m = memoryview(b"123")
ptr = m.buf
del m
my_ctypes_func(ptr)


This is safer, since the view itself is the pointer:

m = memoryview(b"123")
my_ctypes_func(m)


Of course you could still subvert the second idiom by using ptr = int(m).