Put object type conversion into separate file.

1 files changed, 0 insertions, 336 deletions

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)
 {