Implement PyMemoryView_GetContiguous

Author: msimacek

graalpython/com.oracle.graal.python.cext/src/memoryobject.c

@@ -59,8 +59,7 @@ PyObject* PyMemoryView_FromObject(PyObject *v) {
 
 /* called back from the above upcall only if the object was native */
 PyObject* PyTruffle_MemoryViewFromObject(PyObject *v) {
-        // TODO resource management
-        Py_buffer buffer;
+    Py_buffer buffer;
     if (PyObject_CheckBuffer(v)) {
         PyObject *ret;
         if (PyObject_GetBuffer(v, &buffer, PyBUF_FULL_RO) < 0) {
@@ -92,30 +91,34 @@ PyObject* PyMemoryView_FromBuffer(Py_buffer *buffer) {
             releasefn = pb->bf_releasebuffer;
         }
     }
-        return polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_MemoryViewFromBuffer",
-                buffer,
-                native_to_java(buffer->obj),
-                releasefn,
-                buffer->len,
-                buffer->readonly,
-                buffer->itemsize,
-                polyglot_from_string(buffer->format ? buffer->format : "B", "ascii"),
-                buffer->ndim,
-                polyglot_from_i8_array(buffer->buf, buffer->len),
-                buffer->shape ? polyglot_from_size_array(buffer->shape, ndim) : NULL,
-                buffer->strides ? polyglot_from_size_array(buffer->strides, ndim) : NULL,
-                buffer->suboffsets ? polyglot_from_size_array(buffer->suboffsets, ndim) : NULL);
+    return polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_MemoryViewFromBuffer",
+            buffer,
+            native_to_java(buffer->obj),
+            releasefn,
+            buffer->len,
+            buffer->readonly,
+            buffer->itemsize,
+            polyglot_from_string(buffer->format ? buffer->format : "B", "ascii"),
+            buffer->ndim,
+            polyglot_from_i8_array(buffer->buf, buffer->len),
+            buffer->shape ? polyglot_from_size_array(buffer->shape, ndim) : NULL,
+            buffer->strides ? polyglot_from_size_array(buffer->strides, ndim) : NULL,
+            buffer->suboffsets ? polyglot_from_size_array(buffer->suboffsets, ndim) : NULL);
 }
 
-PyObject *PyMemoryView_FromMemory(char *mem, Py_ssize_t size, int flags)
-{
+PyObject *PyMemoryView_FromMemory(char *mem, Py_ssize_t size, int flags) {
     assert(mem != NULL);
     assert(flags == PyBUF_READ || flags == PyBUF_WRITE);
     int readonly = (flags == PyBUF_WRITE) ? 0 : 1;
     return polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_MemoryViewFromBuffer",
             NULL, NULL, NULL, size, readonly, 1, polyglot_from_string("B", "ascii"), 1, polyglot_from_i8_array((int8_t*)mem, size), NULL, NULL, NULL);
 }
 
+UPCALL_ID(PyMemoryView_GetContiguous)
+PyObject* PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char order) {
+    return UPCALL_CEXT_O(_jls_PyMemoryView_GetContiguous, native_to_java(obj), buffertype, (int)order);
+}
+
 /* Macros taken from CPython */
 /* Memoryview buffer properties */
 #define MV_C_CONTIGUOUS(flags) (flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C))

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_memoryview.py

@@ -224,6 +224,32 @@ def compile_module(self, name):
         cmpfunc=unhandled_error_compare_with_message,
     )
 
+    test_memoryview_getcontiguous = CPyExtFunction(
+        lambda args: args[1],
+        lambda: [
+            (bytearray(b'12345678'), b'12345678'),
+            (memoryview(b'12345678'), b'12345678'),
+            (memoryview(b'12345678')[::2], b'1357'),
+            (memoryview(b'12345678abcd').cast('i')[::2], b'1234abcd'),
+        ],
+        code='''
+            static PyObject* test_getcontiguous(PyObject* obj, PyObject* expected) {
+                PyObject *mv = PyMemoryView_GetContiguous(obj, PyBUF_READ, 'C');
+                if (!mv)
+                    return NULL;
+                Py_buffer *view = PyMemoryView_GET_BUFFER(mv);
+                PyObject *bytes = PyBytes_FromStringAndSize(view->buf, view->len);
+                Py_DECREF(mv);
+                return bytes;
+            }
+        ''',
+        resultspec='O',
+        argspec='OO',
+        arguments=["PyObject* order", "PyObject* expected"],
+        callfunction="test_getcontiguous",
+        cmpfunc=unhandled_error_compare_with_message,
+    )
+
     test_memoryview_slice = CPyExtFunction(
         lambda args: bytes((5, 6, 255, 128, 99))[args[0]][args[1]][args[2]],
         lambda: list(itertools.product(slices, slices, range(-2, 5))),

graalpython/lib-graalpython/python_cext.py

@@ -800,6 +800,36 @@ def PyUnicode_Replace(s, substr, replstr, count):
     return s.replace(substr, replstr, count)
 
 
+##################### MEMORY_VIEW
+def PyMemoryView_GetContiguous(obj, buffertype, order_int):
+    PyBUF_READ = 0x100
+    PyBUF_WRITE = 0x200
+    assert buffertype == PyBUF_READ or buffertype == PyBUF_WRITE
+    order = chr(order_int)
+    assert order == 'C' or order == 'F' or order == 'A'
+    mv = memoryview(obj)
+    release = True
+    try:
+        if buffertype == PyBUF_WRITE and mv.readonly:
+            raise BufferError("underlying buffer is not writable")
+        if mv.contiguous:
+            release = False
+            return mv
+        if buffertype == PyBUF_WRITE:
+            raise BufferError("writable contiguous buffer requested for a non-contiguous object.")
+        mv_bytes = memoryview(mv.tobytes(order))
+        if mv.format == 'B':
+            return mv_bytes
+        else:
+            try:
+                return mv_bytes.cast(mv.format)
+            finally:
+                mv_bytes.release()
+    finally:
+        if release:
+            mv.release()
+
+
 ##################### CAPSULE