Put object type conversion into separate file.

4 files changed, 353 insertions, 336 deletions

diff --git a/numpy/core/src/arrayconvert.c b/numpy/core/src/arrayconvert.c
new file mode 100644
index 000000000..17cb9aad0
--- /dev/null
+++ b/numpy/core/src/arrayconvert.c
@@ -0,0 +1,346 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "structmember.h"
+
+#define _MULTIARRAYMODULE
+#define NPY_NO_PREFIX
+#include "numpy/arrayobject.h"
+#include "numpy/arrayscalars.h"
+
+#include "arrayobject.h"
+
+#include "arrayconvert.h"
+
+/*NUMPY_API
+ * To List
+ */
+NPY_NO_EXPORT PyObject *
+PyArray_ToList(PyArrayObject *self)
+{
+    PyObject *lp;
+    PyArrayObject *v;
+    intp sz, i;
+
+    if (!PyArray_Check(self)) {
+        return (PyObject *)self;
+    }
+    if (self->nd == 0) {
+        return self->descr->f->getitem(self->data,self);
+    }
+
+    sz = self->dimensions[0];
+    lp = PyList_New(sz);
+    for (i = 0; i < sz; i++) {
+	v = (PyArrayObject *)array_big_item(self, i);
+	if (PyArray_Check(v) && (v->nd >= self->nd)) {
+	    PyErr_SetString(PyExc_RuntimeError,
+			    "array_item not returning smaller-"	\
+			    "dimensional array");
+	    Py_DECREF(v);
+	    Py_DECREF(lp);
+	    return NULL;
+	}
+        PyList_SetItem(lp, i, PyArray_ToList(v));
+        Py_DECREF(v);
+    }
+    return lp;
+}
+
+/* XXX: FIXME --- add ordering argument to
+   Allow Fortran ordering on write
+   This will need the addition of a Fortran-order iterator.
+ */
+
+/*NUMPY_API
+  To File
+*/
+NPY_NO_EXPORT int
+PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format)
+{
+    intp size;
+    intp n, n2;
+    size_t n3, n4;
+    PyArrayIterObject *it;
+    PyObject *obj, *strobj, *tupobj;
+
+    n3 = (sep ? strlen((const char *)sep) : 0);
+    if (n3 == 0) {
+        /* binary data */
+        if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) {
+            PyErr_SetString(PyExc_ValueError, "cannot write " \
+                    "object arrays to a file in "   \
+                    "binary mode");
+            return -1;
+        }
+
+        if (PyArray_ISCONTIGUOUS(self)) {
+            size = PyArray_SIZE(self);
+            NPY_BEGIN_ALLOW_THREADS;
+            n = fwrite((const void *)self->data,
+                    (size_t) self->descr->elsize,
+                    (size_t) size, fp);
+            NPY_END_ALLOW_THREADS;
+            if (n < size) {
+                PyErr_Format(PyExc_ValueError,
+                        "%ld requested and %ld written",
+                        (long) size, (long) n);
+                return -1;
+            }
+        }
+        else {
+            NPY_BEGIN_THREADS_DEF;
+
+            it = (PyArrayIterObject *) PyArray_IterNew((PyObject *)self);
+            NPY_BEGIN_THREADS;
+            while (it->index < it->size) {
+                if (fwrite((const void *)it->dataptr,
+                            (size_t) self->descr->elsize,
+                            1, fp) < 1) {
+                    NPY_END_THREADS;
+                    PyErr_Format(PyExc_IOError,
+                            "problem writing element"\
+                            " %"INTP_FMT" to file",
+                            it->index);
+                    Py_DECREF(it);
+                    return -1;
+                }
+                PyArray_ITER_NEXT(it);
+            }
+            NPY_END_THREADS;
+            Py_DECREF(it);
+        }
+    }
+    else {
+        /*
+         * text data
+         */
+
+        it = (PyArrayIterObject *)
+            PyArray_IterNew((PyObject *)self);
+        n4 = (format ? strlen((const char *)format) : 0);
+        while (it->index < it->size) {
+            obj = self->descr->f->getitem(it->dataptr, self);
+            if (obj == NULL) {
+                Py_DECREF(it);
+                return -1;
+            }
+            if (n4 == 0) {
+                /*
+                 * standard writing
+                 */
+                strobj = PyObject_Str(obj);
+                Py_DECREF(obj);
+                if (strobj == NULL) {
+                    Py_DECREF(it);
+                    return -1;
+                }
+            }
+            else {
+                /*
+                 * use format string
+                 */
+                tupobj = PyTuple_New(1);
+                if (tupobj == NULL) {
+                    Py_DECREF(it);
+                    return -1;
+                }
+                PyTuple_SET_ITEM(tupobj,0,obj);
+                obj = PyString_FromString((const char *)format);
+                if (obj == NULL) {
+                    Py_DECREF(tupobj);
+                    Py_DECREF(it);
+                    return -1;
+                }
+                strobj = PyString_Format(obj, tupobj);
+                Py_DECREF(obj);
+                Py_DECREF(tupobj);
+                if (strobj == NULL) {
+                    Py_DECREF(it);
+                    return -1;
+                }
+            }
+            NPY_BEGIN_ALLOW_THREADS;
+            n2 = PyString_GET_SIZE(strobj);
+            n = fwrite(PyString_AS_STRING(strobj), 1, n2, fp);
+            NPY_END_ALLOW_THREADS;
+            if (n < n2) {
+                PyErr_Format(PyExc_IOError,
+                        "problem writing element %"INTP_FMT\
+                        " to file", it->index);
+                Py_DECREF(strobj);
+                Py_DECREF(it);
+                return -1;
+            }
+            /* write separator for all but last one */
+            if (it->index != it->size-1) {
+                if (fwrite(sep, 1, n3, fp) < n3) {
+                    PyErr_Format(PyExc_IOError,
+                            "problem writing "\
+                            "separator to file");
+                    Py_DECREF(strobj);
+                    Py_DECREF(it);
+                    return -1;
+                }
+            }
+            Py_DECREF(strobj);
+            PyArray_ITER_NEXT(it);
+        }
+        Py_DECREF(it);
+    }
+    return 0;
+}
+
+/*NUMPY_API*/
+NPY_NO_EXPORT PyObject *
+PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
+{
+    intp numbytes;
+    intp index;
+    char *dptr;
+    int elsize;
+    PyObject *ret;
+    PyArrayIterObject *it;
+
+    if (order == NPY_ANYORDER)
+        order = PyArray_ISFORTRAN(self);
+
+    /*        if (PyArray_TYPE(self) == PyArray_OBJECT) {
+              PyErr_SetString(PyExc_ValueError, "a string for the data" \
+              "in an object array is not appropriate");
+              return NULL;
+              }
+    */
+
+    numbytes = PyArray_NBYTES(self);
+    if ((PyArray_ISCONTIGUOUS(self) && (order == NPY_CORDER))
+        || (PyArray_ISFORTRAN(self) && (order == NPY_FORTRANORDER))) {
+        ret = PyString_FromStringAndSize(self->data, (Py_ssize_t) numbytes);
+    }
+    else {
+        PyObject *new;
+        if (order == NPY_FORTRANORDER) {
+            /* iterators are always in C-order */
+            new = PyArray_Transpose(self, NULL);
+            if (new == NULL) {
+                return NULL;
+            }
+        }
+        else {
+            Py_INCREF(self);
+            new = (PyObject *)self;
+        }
+        it = (PyArrayIterObject *)PyArray_IterNew(new);
+        Py_DECREF(new);
+        if (it == NULL) {
+            return NULL;
+        }
+        ret = PyString_FromStringAndSize(NULL, (Py_ssize_t) numbytes);
+        if (ret == NULL) {
+            Py_DECREF(it);
+            return NULL;
+        }
+        dptr = PyString_AS_STRING(ret);
+        index = it->size;
+        elsize = self->descr->elsize;
+        while (index--) {
+            memcpy(dptr, it->dataptr, elsize);
+            dptr += elsize;
+            PyArray_ITER_NEXT(it);
+        }
+        Py_DECREF(it);
+    }
+    return ret;
+}
+
+/*NUMPY_API*/
+NPY_NO_EXPORT int
+PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)
+{
+    PyObject *newarr;
+    int itemsize, swap;
+    void *fromptr;
+    PyArray_Descr *descr;
+    intp size;
+    PyArray_CopySwapFunc *copyswap;
+
+    itemsize = arr->descr->elsize;
+    if (PyArray_ISOBJECT(arr)) {
+        fromptr = &obj;
+        swap = 0;
+        newarr = NULL;
+    }
+    else {
+        descr = PyArray_DESCR(arr);
+        Py_INCREF(descr);
+        newarr = PyArray_FromAny(obj, descr, 0,0, ALIGNED, NULL);
+        if (newarr == NULL) {
+            return -1;
+        }
+        fromptr = PyArray_DATA(newarr);
+        swap = (PyArray_ISNOTSWAPPED(arr) != PyArray_ISNOTSWAPPED(newarr));
+    }
+    size=PyArray_SIZE(arr);
+    copyswap = arr->descr->f->copyswap;
+    if (PyArray_ISONESEGMENT(arr)) {
+        char *toptr=PyArray_DATA(arr);
+        PyArray_FillWithScalarFunc* fillwithscalar =
+            arr->descr->f->fillwithscalar;
+        if (fillwithscalar && PyArray_ISALIGNED(arr)) {
+            copyswap(fromptr, NULL, swap, newarr);
+            fillwithscalar(toptr, size, fromptr, arr);
+        }
+        else {
+            while (size--) {
+                copyswap(toptr, fromptr, swap, arr);
+                toptr += itemsize;
+            }
+        }
+    }
+    else {
+        PyArrayIterObject *iter;
+
+        iter = (PyArrayIterObject *)\
+            PyArray_IterNew((PyObject *)arr);
+        if (iter == NULL) {
+            Py_XDECREF(newarr);
+            return -1;
+        }
+        while (size--) {
+            copyswap(iter->dataptr, fromptr, swap, arr);
+            PyArray_ITER_NEXT(iter);
+        }
+        Py_DECREF(iter);
+    }
+    Py_XDECREF(newarr);
+    return 0;
+}
+
+/*NUMPY_API
+  Copy an array.
+*/
+NPY_NO_EXPORT PyObject *
+PyArray_NewCopy(PyArrayObject *m1, NPY_ORDER fortran)
+{
+    PyArrayObject *ret;
+    if (fortran == PyArray_ANYORDER)
+        fortran = PyArray_ISFORTRAN(m1);
+
+    Py_INCREF(m1->descr);
+    ret = (PyArrayObject *)PyArray_NewFromDescr(m1->ob_type,
+                                                m1->descr,
+                                                m1->nd,
+                                                m1->dimensions,
+                                                NULL, NULL,
+                                                fortran,
+                                                (PyObject *)m1);
+    if (ret == NULL) {
+        return NULL;
+    }
+    if (PyArray_CopyInto(ret, m1) == -1) {
+        Py_DECREF(ret);
+        return NULL;
+    }
+
+    return (PyObject *)ret;
+}
+
diff --git a/numpy/core/src/arrayconvert.h b/numpy/core/src/arrayconvert.h
new file mode 100644
index 000000000..de24e27cf
--- /dev/null
+++ b/numpy/core/src/arrayconvert.h
@@ -0,0 +1,4 @@
+#ifndef _NPY_ARRAYOBJECT_CONVERT_H_
+#define _NPY_ARRAYOBJECT_CONVERT_H_
+
+#endif
diff --git a/numpy/core/src/arrayobject.c b/numpy/core/src/arrayobject.c
index 3aa0c81e4..2a9542b28 100644
--- a/numpy/core/src/arrayobject.c
+++ b/numpy/core/src/arrayobject.c
@@ -538,35 +538,6 @@ PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
 }
 
 
-/*NUMPY_API
-  Copy an array.
-*/
-NPY_NO_EXPORT PyObject *
-PyArray_NewCopy(PyArrayObject *m1, NPY_ORDER fortran)
-{
-    PyArrayObject *ret;
-    if (fortran == PyArray_ANYORDER)
-        fortran = PyArray_ISFORTRAN(m1);
-
-    Py_INCREF(m1->descr);
-    ret = (PyArrayObject *)PyArray_NewFromDescr(m1->ob_type,
-                                                m1->descr,
-                                                m1->nd,
-                                                m1->dimensions,
-                                                NULL, NULL,
-                                                fortran,
-                                                (PyObject *)m1);
-    if (ret == NULL) {
-        return NULL;
-    }
-    if (PyArray_CopyInto(ret, m1) == -1) {
-        Py_DECREF(ret);
-        return NULL;
-    }
-
-    return (PyObject *)ret;
-}
-
 /* Does nothing with descr (cannot be NULL) */
 /*NUMPY_API
   Get scalar-equivalent to a region of memory described by a descriptor.
@@ -1007,252 +978,8 @@ PyArray_RegisterCanCast(PyArray_Descr *descr, int totype,
     return 0;
 }
 
-
-/* XXX: FIXME --- add ordering argument to
-   Allow Fortran ordering on write
-   This will need the addition of a Fortran-order iterator.
- */
-
-/*NUMPY_API
-  To File
-*/
-NPY_NO_EXPORT int
-PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format)
-{
-    intp size;
-    intp n, n2;
-    size_t n3, n4;
-    PyArrayIterObject *it;
-    PyObject *obj, *strobj, *tupobj;
-
-    n3 = (sep ? strlen((const char *)sep) : 0);
-    if (n3 == 0) {
-        /* binary data */
-        if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) {
-            PyErr_SetString(PyExc_ValueError, "cannot write " \
-                    "object arrays to a file in "   \
-                    "binary mode");
-            return -1;
-        }
-
-        if (PyArray_ISCONTIGUOUS(self)) {
-            size = PyArray_SIZE(self);
-            NPY_BEGIN_ALLOW_THREADS;
-            n = fwrite((const void *)self->data,
-                    (size_t) self->descr->elsize,
-                    (size_t) size, fp);
-            NPY_END_ALLOW_THREADS;
-            if (n < size) {
-                PyErr_Format(PyExc_ValueError,
-                        "%ld requested and %ld written",
-                        (long) size, (long) n);
-                return -1;
-            }
-        }
-        else {
-            NPY_BEGIN_THREADS_DEF;
-
-            it = (PyArrayIterObject *) PyArray_IterNew((PyObject *)self);
-            NPY_BEGIN_THREADS;
-            while (it->index < it->size) {
-                if (fwrite((const void *)it->dataptr,
-                            (size_t) self->descr->elsize,
-                            1, fp) < 1) {
-                    NPY_END_THREADS;
-                    PyErr_Format(PyExc_IOError,
-                            "problem writing element"\
-                            " %"INTP_FMT" to file",
-                            it->index);
-                    Py_DECREF(it);
-                    return -1;
-                }
-                PyArray_ITER_NEXT(it);
-            }
-            NPY_END_THREADS;
-            Py_DECREF(it);
-        }
-    }
-    else {
-        /*
-         * text data
-         */
-
-        it = (PyArrayIterObject *)
-            PyArray_IterNew((PyObject *)self);
-        n4 = (format ? strlen((const char *)format) : 0);
-        while (it->index < it->size) {
-            obj = self->descr->f->getitem(it->dataptr, self);
-            if (obj == NULL) {
-                Py_DECREF(it);
-                return -1;
-            }
-            if (n4 == 0) {
-                /*
-                 * standard writing
-                 */
-                strobj = PyObject_Str(obj);
-                Py_DECREF(obj);
-                if (strobj == NULL) {
-                    Py_DECREF(it);
-                    return -1;
-                }
-            }
-            else {
-                /*
-                 * use format string
-                 */
-                tupobj = PyTuple_New(1);
-                if (tupobj == NULL) {
-                    Py_DECREF(it);
-                    return -1;
-                }
-                PyTuple_SET_ITEM(tupobj,0,obj);
-                obj = PyString_FromString((const char *)format);
-                if (obj == NULL) {
-                    Py_DECREF(tupobj);
-                    Py_DECREF(it);
-                    return -1;
-                }
-                strobj = PyString_Format(obj, tupobj);
-                Py_DECREF(obj);
-                Py_DECREF(tupobj);
-                if (strobj == NULL) {
-                    Py_DECREF(it);
-                    return -1;
-                }
-            }
-            NPY_BEGIN_ALLOW_THREADS;
-            n2 = PyString_GET_SIZE(strobj);
-            n = fwrite(PyString_AS_STRING(strobj), 1, n2, fp);
-            NPY_END_ALLOW_THREADS;
-            if (n < n2) {
-                PyErr_Format(PyExc_IOError,
-                        "problem writing element %"INTP_FMT\
-                        " to file", it->index);
-                Py_DECREF(strobj);
-                Py_DECREF(it);
-                return -1;
-            }
-            /* write separator for all but last one */
-            if (it->index != it->size-1) {
-                if (fwrite(sep, 1, n3, fp) < n3) {
-                    PyErr_Format(PyExc_IOError,
-                            "problem writing "\
-                            "separator to file");
-                    Py_DECREF(strobj);
-                    Py_DECREF(it);
-                    return -1;
-                }
-            }
-            Py_DECREF(strobj);
-            PyArray_ITER_NEXT(it);
-        }
-        Py_DECREF(it);
-    }
-    return 0;
-}
-
-/*NUMPY_API
- * To List
- */
-NPY_NO_EXPORT PyObject *
-PyArray_ToList(PyArrayObject *self)
-{
-    PyObject *lp;
-    PyArrayObject *v;
-    intp sz, i;
-
-    if (!PyArray_Check(self)) {
-        return (PyObject *)self;
-    }
-    if (self->nd == 0) {
-        return self->descr->f->getitem(self->data,self);
-    }
-
-    sz = self->dimensions[0];
-    lp = PyList_New(sz);
-    for (i = 0; i < sz; i++) {
-	v = (PyArrayObject *)array_big_item(self, i);
-	if (PyArray_Check(v) && (v->nd >= self->nd)) {
-	    PyErr_SetString(PyExc_RuntimeError,
-			    "array_item not returning smaller-"	\
-			    "dimensional array");
-	    Py_DECREF(v);
-	    Py_DECREF(lp);
-	    return NULL;
-	}
-        PyList_SetItem(lp, i, PyArray_ToList(v));
-        Py_DECREF(v);
-    }
-    return lp;
-}
-
-/*NUMPY_API*/
-NPY_NO_EXPORT PyObject *
-PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
-{
-    intp numbytes;
-    intp index;
-    char *dptr;
-    int elsize;
-    PyObject *ret;
-    PyArrayIterObject *it;
-
-    if (order == NPY_ANYORDER)
-        order = PyArray_ISFORTRAN(self);
-
-    /*        if (PyArray_TYPE(self) == PyArray_OBJECT) {
-              PyErr_SetString(PyExc_ValueError, "a string for the data" \
-              "in an object array is not appropriate");
-              return NULL;
-              }
-    */
-
-    numbytes = PyArray_NBYTES(self);
-    if ((PyArray_ISCONTIGUOUS(self) && (order == NPY_CORDER))
-        || (PyArray_ISFORTRAN(self) && (order == NPY_FORTRANORDER))) {
-        ret = PyString_FromStringAndSize(self->data, (Py_ssize_t) numbytes);
-    }
-    else {
-        PyObject *new;
-        if (order == NPY_FORTRANORDER) {
-            /* iterators are always in C-order */
-            new = PyArray_Transpose(self, NULL);
-            if (new == NULL) {
-                return NULL;
-            }
-        }
-        else {
-            Py_INCREF(self);
-            new = (PyObject *)self;
-        }
-        it = (PyArrayIterObject *)PyArray_IterNew(new);
-        Py_DECREF(new);
-        if (it == NULL) {
-            return NULL;
-        }
-        ret = PyString_FromStringAndSize(NULL, (Py_ssize_t) numbytes);
-        if (ret == NULL) {
-            Py_DECREF(it);
-            return NULL;
-        }
-        dptr = PyString_AS_STRING(ret);
-        index = it->size;
-        elsize = self->descr->elsize;
-        while (index--) {
-            memcpy(dptr, it->dataptr, elsize);
-            dptr += elsize;
-            PyArray_ITER_NEXT(it);
-        }
-        Py_DECREF(it);
-    }
-    return ret;
-}
-
-
 /*********************** end C-API functions **********************/
 
-
 /* array object functions */
 
 static void
@@ -2847,69 +2574,6 @@ PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj)
     }
 }
 
-/*NUMPY_API*/
-NPY_NO_EXPORT int
-PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)
-{
-    PyObject *newarr;
-    int itemsize, swap;
-    void *fromptr;
-    PyArray_Descr *descr;
-    intp size;
-    PyArray_CopySwapFunc *copyswap;
-
-    itemsize = arr->descr->elsize;
-    if (PyArray_ISOBJECT(arr)) {
-        fromptr = &obj;
-        swap = 0;
-        newarr = NULL;
-    }
-    else {
-        descr = PyArray_DESCR(arr);
-        Py_INCREF(descr);
-        newarr = PyArray_FromAny(obj, descr, 0,0, ALIGNED, NULL);
-        if (newarr == NULL) {
-            return -1;
-        }
-        fromptr = PyArray_DATA(newarr);
-        swap = (PyArray_ISNOTSWAPPED(arr) != PyArray_ISNOTSWAPPED(newarr));
-    }
-    size=PyArray_SIZE(arr);
-    copyswap = arr->descr->f->copyswap;
-    if (PyArray_ISONESEGMENT(arr)) {
-        char *toptr=PyArray_DATA(arr);
-        PyArray_FillWithScalarFunc* fillwithscalar =
-            arr->descr->f->fillwithscalar;
-        if (fillwithscalar && PyArray_ISALIGNED(arr)) {
-            copyswap(fromptr, NULL, swap, newarr);
-            fillwithscalar(toptr, size, fromptr, arr);
-        }
-        else {
-            while (size--) {
-                copyswap(toptr, fromptr, swap, arr);
-                toptr += itemsize;
-            }
-        }
-    }
-    else {
-        PyArrayIterObject *iter;
-
-        iter = (PyArrayIterObject *)\
-            PyArray_IterNew((PyObject *)arr);
-        if (iter == NULL) {
-            Py_XDECREF(newarr);
-            return -1;
-        }
-        while (size--) {
-            copyswap(iter->dataptr, fromptr, swap, arr);
-            PyArray_ITER_NEXT(iter);
-        }
-        Py_DECREF(iter);
-    }
-    Py_XDECREF(newarr);
-    return 0;
-}
-
 static PyObject *
 array_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 {
diff --git a/numpy/core/src/arrayobject.h b/numpy/core/src/arrayobject.h
index dadcf0cca..9156ea721 100644
--- a/numpy/core/src/arrayobject.h
+++ b/numpy/core/src/arrayobject.h
@@ -170,4 +170,7 @@ extern NPY_NO_EXPORT PyArray_Descr INT_Descr;
 /* Converting data types API */
 #include "arrayconvert_datatype.h"
 
+/* Object Conversion API */
+#include "arrayconvert.h"
+
 #endif