ENH: core: Got the tests running after the ArrayObject field access deprecation

9 files changed, 61 insertions, 55 deletions

diff --git a/numpy/core/include/numpy/ndarrayobject.h b/numpy/core/include/numpy/ndarrayobject.h
index dcb3d89f7..cfc88d743 100644
--- a/numpy/core/include/numpy/ndarrayobject.h
+++ b/numpy/core/include/numpy/ndarrayobject.h
@@ -165,11 +165,9 @@ PyArray_XDECREF_ERR(PyArrayObject *obj)
 {
     if (obj) {
         if (PyArray_FLAGS(obj) & NPY_ARRAY_UPDATEIFCOPY) {
-            PyObject *base = PyArray_BASE(obj);
-            ((PyArrayObject_fieldaccess *)base)->flags |=
-                                                    NPY_ARRAY_WRITEABLE;
-            ((PyArrayObject_fieldaccess *)obj)->flags &=
-                                                    ~NPY_ARRAY_UPDATEIFCOPY;
+            PyArrayObject *base = (PyArrayObject *)PyArray_BASE(obj);
+            PyArray_ENABLEFLAGS(base, NPY_ARRAY_WRITEABLE);
+            PyArray_CLEARFLAGS(obj, NPY_ARRAY_UPDATEIFCOPY);
         }
         Py_DECREF(obj);
     }
diff --git a/numpy/core/include/numpy/ndarraytypes.h b/numpy/core/include/numpy/ndarraytypes.h
index ab9347752..c4de89687 100644
--- a/numpy/core/include/numpy/ndarraytypes.h
+++ b/numpy/core/include/numpy/ndarraytypes.h
@@ -1341,7 +1341,7 @@ PyArray_CHKFLAGS(PyArrayObject *arr, int flags)
 static NPY_INLINE void
 PyArray_ENABLEFLAGS(PyArrayObject *arr, int flags)
 {
-    ((PyArrayObject_fieldaccess *)arr)->flags |= ~flags;
+    ((PyArrayObject_fieldaccess *)arr)->flags |= flags;
 }
 
 /*
diff --git a/numpy/core/src/multiarray/arrayobject.c b/numpy/core/src/multiarray/arrayobject.c
index 9af5c361b..21325bbb1 100644
--- a/numpy/core/src/multiarray/arrayobject.c
+++ b/numpy/core/src/multiarray/arrayobject.c
@@ -275,6 +275,7 @@ static void
 array_dealloc(PyArrayObject *self)
 {
     PyArrayObject_fieldaccess *fa = (PyArrayObject_fieldaccess *)self;
+
     _array_dealloc_buffer_info(self);
 
     if (fa->weakreflist != NULL) {
@@ -319,7 +320,7 @@ array_dealloc(PyArrayObject *self)
              * self already...
              */
         }
-        PyDataMem_FREE(fa->data);
+        //PyDataMem_FREE(fa->data);
     }
 
     PyDimMem_FREE(fa->dimensions);
diff --git a/numpy/core/src/multiarray/ctors.c b/numpy/core/src/multiarray/ctors.c
index b32a8553e..41db49832 100644
--- a/numpy/core/src/multiarray/ctors.c
+++ b/numpy/core/src/multiarray/ctors.c
@@ -2573,7 +2573,7 @@ PyArray_EnsureAnyArray(PyObject *op)
 
 /* TODO: Put the order parameter in PyArray_CopyAnyInto and remove this */
 NPY_NO_EXPORT int
-PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src,
+PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src,
                                 NPY_ORDER order)
 {
     PyArray_StridedTransferFn *stransfer = NULL;
@@ -2613,9 +2613,9 @@ PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src,
     dst_size = PyArray_SIZE(dst);
     src_size = PyArray_SIZE(src);
     if (dst_size != src_size) {
-        PyErr_SetString(PyExc_ValueError,
-                "arrays must have the same number of elements"
-                " for copy");
+        PyErr_Format(PyExc_ValueError,
+                "cannot copy from array of size %d into an array "
+                "of size %d", (int)src_size, (int)dst_size);
         return -1;
     }
 
@@ -2766,7 +2766,7 @@ PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src,
 NPY_NO_EXPORT int
 PyArray_CopyAnyInto(PyArrayObject *dst, PyArrayObject *src)
 {
-    return PyArray_CopyAnyIntoOrdered(dst, src, NPY_CORDER);
+    return PyArray_CopyAsFlat(dst, src, NPY_CORDER);
 }
 
 /*NUMPY_API
diff --git a/numpy/core/src/multiarray/ctors.h b/numpy/core/src/multiarray/ctors.h
index 13f5d0da6..ed7b72980 100644
--- a/numpy/core/src/multiarray/ctors.h
+++ b/numpy/core/src/multiarray/ctors.h
@@ -47,7 +47,7 @@ PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags);
 
 /* TODO: Put the order parameter in PyArray_CopyAnyInto and remove this */
 NPY_NO_EXPORT int
-PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src,
+PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src,
                                 NPY_ORDER order);
 
 /* FIXME: remove those from here */
diff --git a/numpy/core/src/multiarray/iterators.c b/numpy/core/src/multiarray/iterators.c
index 057c84a3a..6acbca4b7 100644
--- a/numpy/core/src/multiarray/iterators.c
+++ b/numpy/core/src/multiarray/iterators.c
@@ -22,7 +22,8 @@
 #define SingleIndex -3
 
 NPY_NO_EXPORT npy_intp
-parse_subindex(PyObject *op, npy_intp *step_size, npy_intp *n_steps, npy_intp max)
+parse_subindex(PyObject *op, npy_intp *step_size,
+                    npy_intp *n_steps, npy_intp max)
 {
     npy_intp index;
 
diff --git a/numpy/core/src/multiarray/mapping.c b/numpy/core/src/multiarray/mapping.c
index 21ad62dcb..30d9f4416 100644
--- a/numpy/core/src/multiarray/mapping.c
+++ b/numpy/core/src/multiarray/mapping.c
@@ -397,12 +397,13 @@ add_new_axes_0d(PyArrayObject *arr,  int newaxis_count)
         dimensions[i]  = 1;
     }
     Py_INCREF(PyArray_DESCR(arr));
-    if ((other = (PyArrayObject *)
-         PyArray_NewFromDescr(Py_TYPE(arr), PyArray_DESCR(arr),
-                              newaxis_count, dimensions,
-                              NULL, PyArray_DATA(arr),
-                              PyArray_FLAGS(arr),
-                              (PyObject *)arr)) == NULL) {
+    other = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(arr),
+                                PyArray_DESCR(arr),
+                                newaxis_count, dimensions,
+                                NULL, PyArray_DATA(arr),
+                                PyArray_FLAGS(arr),
+                                (PyObject *)arr);
+    if (other == NULL) {
         return NULL;
     }
     Py_INCREF(arr);
@@ -513,30 +514,35 @@ fancy_indexing_check(PyObject *args)
 NPY_NO_EXPORT PyObject *
 array_subscript_simple(PyArrayObject *self, PyObject *op)
 {
-    intp dimensions[MAX_DIMS], strides[MAX_DIMS];
-    intp offset;
+    npy_intp dimensions[MAX_DIMS], strides[MAX_DIMS];
+    npy_intp offset;
     int nd;
     PyArrayObject *other;
-    intp value;
+    npy_intp value;
 
     value = PyArray_PyIntAsIntp(op);
-    if (!PyErr_Occurred()) {
+    if (value == -1 && PyErr_Occurred()) {
+        PyErr_Clear();
+    }
+    else {
         return array_big_item(self, value);
     }
-    PyErr_Clear();
 
     /* Standard (view-based) Indexing */
-    if ((nd = parse_index(self, op, dimensions, strides, &offset)) == -1) {
+    nd = parse_index(self, op, dimensions, strides, &offset);
+    if (nd == -1) {
         return NULL;
     }
+
     /* This will only work if new array will be a view */
     Py_INCREF(PyArray_DESCR(self));
-    if ((other = (PyArrayObject *)
-         PyArray_NewFromDescr(Py_TYPE(self), PyArray_DESCR(self),
-                              nd, dimensions,
-                              strides, PyArray_DATA(self)+offset,
-                              PyArray_FLAGS(self),
-                              (PyObject *)self)) == NULL) {
+    other = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self),
+                                PyArray_DESCR(self),
+                                nd, dimensions,
+                                strides, PyArray_DATA(self)+offset,
+                                PyArray_FLAGS(self),
+                                (PyObject *)self);
+    if (other == NULL) {
         return NULL;
     }
     Py_INCREF(self);
@@ -545,6 +551,7 @@ array_subscript_simple(PyArrayObject *self, PyObject *op)
         return NULL;
     }
     PyArray_UpdateFlags(other, NPY_ARRAY_UPDATE_ALL);
+
     return (PyObject *)other;
 }
 
diff --git a/numpy/core/src/multiarray/sequence.c b/numpy/core/src/multiarray/sequence.c
index da59b1b72..7448435a1 100644
--- a/numpy/core/src/multiarray/sequence.c
+++ b/numpy/core/src/multiarray/sequence.c
@@ -30,50 +30,49 @@ array_any_nonzero(PyArrayObject *mp);
 
 
 static PyObject *
-array_slice(PyArrayObject *self, Py_ssize_t ilow,
-            Py_ssize_t ihigh)
+array_slice(PyArrayObject *self, Py_ssize_t ilow, Py_ssize_t ihigh)
 {
     PyArrayObject *ret;
-    Py_ssize_t l;
+    PyArray_Descr *dtype;
+    Py_ssize_t dim0;
     char *data;
+    npy_intp shape[NPY_MAXDIMS];
 
     if (PyArray_NDIM(self) == 0) {
         PyErr_SetString(PyExc_ValueError, "cannot slice a 0-d array");
         return NULL;
     }
 
-    l=PyArray_DIMS(self)[0];
+    dim0 = PyArray_DIM(self, 0);
     if (ilow < 0) {
         ilow = 0;
     }
-    else if (ilow > l) {
-        ilow = l;
+    else if (ilow > dim0) {
+        ilow = dim0;
     }
     if (ihigh < ilow) {
         ihigh = ilow;
     }
-    else if (ihigh > l) {
-        ihigh = l;
+    else if (ihigh > dim0) {
+        ihigh = dim0;
     }
 
-    if (ihigh != ilow) {
-        data = index2ptr(self, ilow);
-        if (data == NULL) {
-            return NULL;
-        }
-    }
-    else {
-        data = PyArray_DATA(self);
+    data = PyArray_DATA(self);
+    if (ilow < ihigh) {
+        data += ilow * PyArray_STRIDE(self, 0);
     }
 
-    PyArray_DIMS(self)[0] = ihigh-ilow;
-    Py_INCREF(PyArray_DESCR(self));
-    ret = (PyArrayObject *)                                           \
-        PyArray_NewFromDescr(Py_TYPE(self), PyArray_DESCR(self),
-                             PyArray_NDIM(self), PyArray_DIMS(self),
+    /* Same shape except dimension 0 */
+    shape[0] = ihigh - ilow;
+    memcpy(shape+1, PyArray_DIMS(self) + 1,
+                        (PyArray_NDIM(self)-1)*sizeof(npy_intp));
+
+    dtype = PyArray_DESCR(self);
+    Py_INCREF(dtype);
+    ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), dtype,
+                             PyArray_NDIM(self), shape,
                              PyArray_STRIDES(self), data,
                              PyArray_FLAGS(self), (PyObject *)self);
-    PyArray_DIMS(self)[0] = l;
     if (ret == NULL) {
         return NULL;
     }
diff --git a/numpy/core/src/multiarray/shape.c b/numpy/core/src/multiarray/shape.c
index 43ad0a967..506c9ba06 100644
--- a/numpy/core/src/multiarray/shape.c
+++ b/numpy/core/src/multiarray/shape.c
@@ -933,7 +933,7 @@ PyArray_Flatten(PyArrayObject *a, NPY_ORDER order)
     if (ret == NULL) {
         return NULL;
     }
-    if (PyArray_CopyAnyIntoOrdered(ret, a, order) < 0) {
+    if (PyArray_CopyAsFlat(ret, a, order) < 0) {
         Py_DECREF(ret);
         return NULL;
     }