JezK
Edit File: fortranobject.c
#define FORTRANOBJECT_C #include "fortranobject.h" #ifdef __cplusplus extern "C" { #endif #include <stdarg.h> #include <stdlib.h> #include <string.h> /* This file implements: FortranObject, array_from_pyobj, copy_ND_array Author: Pearu Peterson <pearu@cens.ioc.ee> $Revision: 1.52 $ $Date: 2005/07/11 07:44:20 $ */ int F2PyDict_SetItemString(PyObject *dict, char *name, PyObject *obj) { if (obj == NULL) { fprintf(stderr, "Error loading %s\n", name); if (PyErr_Occurred()) { PyErr_Print(); PyErr_Clear(); } return -1; } return PyDict_SetItemString(dict, name, obj); } /* * Python-only fallback for thread-local callback pointers */ void * F2PySwapThreadLocalCallbackPtr(char *key, void *ptr) { PyObject *local_dict, *value; void *prev; local_dict = PyThreadState_GetDict(); if (local_dict == NULL) { Py_FatalError( "F2PySwapThreadLocalCallbackPtr: PyThreadState_GetDict " "failed"); } value = PyDict_GetItemString(local_dict, key); if (value != NULL) { prev = PyLong_AsVoidPtr(value); if (PyErr_Occurred()) { Py_FatalError( "F2PySwapThreadLocalCallbackPtr: PyLong_AsVoidPtr failed"); } } else { prev = NULL; } value = PyLong_FromVoidPtr((void *)ptr); if (value == NULL) { Py_FatalError( "F2PySwapThreadLocalCallbackPtr: PyLong_FromVoidPtr failed"); } if (PyDict_SetItemString(local_dict, key, value) != 0) { Py_FatalError( "F2PySwapThreadLocalCallbackPtr: PyDict_SetItemString failed"); } Py_DECREF(value); return prev; } void * F2PyGetThreadLocalCallbackPtr(char *key) { PyObject *local_dict, *value; void *prev; local_dict = PyThreadState_GetDict(); if (local_dict == NULL) { Py_FatalError( "F2PyGetThreadLocalCallbackPtr: PyThreadState_GetDict failed"); } value = PyDict_GetItemString(local_dict, key); if (value != NULL) { prev = PyLong_AsVoidPtr(value); if (PyErr_Occurred()) { Py_FatalError( "F2PyGetThreadLocalCallbackPtr: PyLong_AsVoidPtr failed"); } } else { prev = NULL; } return prev; } static PyArray_Descr * get_descr_from_type_and_elsize(const int type_num, const int elsize) { PyArray_Descr * descr = PyArray_DescrFromType(type_num); if (type_num == NPY_STRING) { // PyArray_DescrFromType returns descr with elsize = 0. PyArray_DESCR_REPLACE(descr); if (descr == NULL) { return NULL; } descr->elsize = elsize; } return descr; } /************************* FortranObject *******************************/ typedef PyObject *(*fortranfunc)(PyObject *, PyObject *, PyObject *, void *); PyObject * PyFortranObject_New(FortranDataDef *defs, f2py_void_func init) { int i; PyFortranObject *fp = NULL; PyObject *v = NULL; if (init != NULL) { /* Initialize F90 module objects */ (*(init))(); } fp = PyObject_New(PyFortranObject, &PyFortran_Type); if (fp == NULL) { return NULL; } if ((fp->dict = PyDict_New()) == NULL) { Py_DECREF(fp); return NULL; } fp->len = 0; while (defs[fp->len].name != NULL) { fp->len++; } if (fp->len == 0) { goto fail; } fp->defs = defs; for (i = 0; i < fp->len; i++) { if (fp->defs[i].rank == -1) { /* Is Fortran routine */ v = PyFortranObject_NewAsAttr(&(fp->defs[i])); if (v == NULL) { goto fail; } PyDict_SetItemString(fp->dict, fp->defs[i].name, v); Py_XDECREF(v); } else if ((fp->defs[i].data) != NULL) { /* Is Fortran variable or array (not allocatable) */ PyArray_Descr * descr = get_descr_from_type_and_elsize(fp->defs[i].type, fp->defs[i].elsize); if (descr == NULL) { goto fail; } v = PyArray_NewFromDescr(&PyArray_Type, descr, fp->defs[i].rank, fp->defs[i].dims.d, NULL, fp->defs[i].data, NPY_ARRAY_FARRAY, NULL); if (v == NULL) { Py_DECREF(descr); goto fail; } PyDict_SetItemString(fp->dict, fp->defs[i].name, v); Py_XDECREF(v); } } return (PyObject *)fp; fail: Py_XDECREF(fp); return NULL; } PyObject * PyFortranObject_NewAsAttr(FortranDataDef *defs) { /* used for calling F90 module routines */ PyFortranObject *fp = NULL; fp = PyObject_New(PyFortranObject, &PyFortran_Type); if (fp == NULL) return NULL; if ((fp->dict = PyDict_New()) == NULL) { PyObject_Del(fp); return NULL; } fp->len = 1; fp->defs = defs; if (defs->rank == -1) { PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("function %s", defs->name)); } else if (defs->rank == 0) { PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("scalar %s", defs->name)); } else { PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("array %s", defs->name)); } return (PyObject *)fp; } /* Fortran methods */ static void fortran_dealloc(PyFortranObject *fp) { Py_XDECREF(fp->dict); PyObject_Del(fp); } /* Returns number of bytes consumed from buf, or -1 on error. */ static Py_ssize_t format_def(char *buf, Py_ssize_t size, FortranDataDef def) { char *p = buf; int i; npy_intp n; n = PyOS_snprintf(p, size, "array(%" NPY_INTP_FMT, def.dims.d[0]); if (n < 0 || n >= size) { return -1; } p += n; size -= n; for (i = 1; i < def.rank; i++) { n = PyOS_snprintf(p, size, ",%" NPY_INTP_FMT, def.dims.d[i]); if (n < 0 || n >= size) { return -1; } p += n; size -= n; } if (size <= 0) { return -1; } *p++ = ')'; size--; if (def.data == NULL) { static const char notalloc[] = ", not allocated"; if ((size_t)size < sizeof(notalloc)) { return -1; } memcpy(p, notalloc, sizeof(notalloc)); p += sizeof(notalloc); size -= sizeof(notalloc); } return p - buf; } static PyObject * fortran_doc(FortranDataDef def) { char *buf, *p; PyObject *s = NULL; Py_ssize_t n, origsize, size = 100; if (def.doc != NULL) { size += strlen(def.doc); } origsize = size; buf = p = (char *)PyMem_Malloc(size); if (buf == NULL) { return PyErr_NoMemory(); } if (def.rank == -1) { if (def.doc) { n = strlen(def.doc); if (n > size) { goto fail; } memcpy(p, def.doc, n); p += n; size -= n; } else { n = PyOS_snprintf(p, size, "%s - no docs available", def.name); if (n < 0 || n >= size) { goto fail; } p += n; size -= n; } } else { PyArray_Descr *d = PyArray_DescrFromType(def.type); n = PyOS_snprintf(p, size, "%s : '%c'-", def.name, d->type); Py_DECREF(d); if (n < 0 || n >= size) { goto fail; } p += n; size -= n; if (def.data == NULL) { n = format_def(p, size, def); if (n < 0) { goto fail; } p += n; size -= n; } else if (def.rank > 0) { n = format_def(p, size, def); if (n < 0) { goto fail; } p += n; size -= n; } else { n = strlen("scalar"); if (size < n) { goto fail; } memcpy(p, "scalar", n); p += n; size -= n; } } if (size <= 1) { goto fail; } *p++ = '\n'; size--; /* p now points one beyond the last character of the string in buf */ s = PyUnicode_FromStringAndSize(buf, p - buf); PyMem_Free(buf); return s; fail: fprintf(stderr, "fortranobject.c: fortran_doc: len(p)=%zd>%zd=size:" " too long docstring required, increase size\n", p - buf, origsize); PyMem_Free(buf); return NULL; } static FortranDataDef *save_def; /* save pointer of an allocatable array */ static void set_data(char *d, npy_intp *f) { /* callback from Fortran */ if (*f) /* In fortran f=allocated(d) */ save_def->data = d; else save_def->data = NULL; /* printf("set_data: d=%p,f=%d\n",d,*f); */ } static PyObject * fortran_getattr(PyFortranObject *fp, char *name) { int i, j, k, flag; if (fp->dict != NULL) { PyObject *v = _PyDict_GetItemStringWithError(fp->dict, name); if (v == NULL && PyErr_Occurred()) { return NULL; } else if (v != NULL) { Py_INCREF(v); return v; } } for (i = 0, j = 1; i < fp->len && (j = strcmp(name, fp->defs[i].name)); i++) ; if (j == 0) if (fp->defs[i].rank != -1) { /* F90 allocatable array */ if (fp->defs[i].func == NULL) return NULL; for (k = 0; k < fp->defs[i].rank; ++k) fp->defs[i].dims.d[k] = -1; save_def = &fp->defs[i]; (*(fp->defs[i].func))(&fp->defs[i].rank, fp->defs[i].dims.d, set_data, &flag); if (flag == 2) k = fp->defs[i].rank + 1; else k = fp->defs[i].rank; if (fp->defs[i].data != NULL) { /* array is allocated */ PyObject *v = PyArray_New( &PyArray_Type, k, fp->defs[i].dims.d, fp->defs[i].type, NULL, fp->defs[i].data, 0, NPY_ARRAY_FARRAY, NULL); if (v == NULL) return NULL; /* Py_INCREF(v); */ return v; } else { /* array is not allocated */ Py_RETURN_NONE; } } if (strcmp(name, "__dict__") == 0) { Py_INCREF(fp->dict); return fp->dict; } if (strcmp(name, "__doc__") == 0) { PyObject *s = PyUnicode_FromString(""), *s2, *s3; for (i = 0; i < fp->len; i++) { s2 = fortran_doc(fp->defs[i]); s3 = PyUnicode_Concat(s, s2); Py_DECREF(s2); Py_DECREF(s); s = s3; } if (PyDict_SetItemString(fp->dict, name, s)) return NULL; return s; } if ((strcmp(name, "_cpointer") == 0) && (fp->len == 1)) { PyObject *cobj = F2PyCapsule_FromVoidPtr((void *)(fp->defs[0].data), NULL); if (PyDict_SetItemString(fp->dict, name, cobj)) return NULL; return cobj; } PyObject *str, *ret; str = PyUnicode_FromString(name); ret = PyObject_GenericGetAttr((PyObject *)fp, str); Py_DECREF(str); return ret; } static int fortran_setattr(PyFortranObject *fp, char *name, PyObject *v) { int i, j, flag; PyArrayObject *arr = NULL; for (i = 0, j = 1; i < fp->len && (j = strcmp(name, fp->defs[i].name)); i++) ; if (j == 0) { if (fp->defs[i].rank == -1) { PyErr_SetString(PyExc_AttributeError, "over-writing fortran routine"); return -1; } if (fp->defs[i].func != NULL) { /* is allocatable array */ npy_intp dims[F2PY_MAX_DIMS]; int k; save_def = &fp->defs[i]; if (v != Py_None) { /* set new value (reallocate if needed -- see f2py generated code for more details ) */ for (k = 0; k < fp->defs[i].rank; k++) dims[k] = -1; if ((arr = array_from_pyobj(fp->defs[i].type, dims, fp->defs[i].rank, F2PY_INTENT_IN, v)) == NULL) return -1; (*(fp->defs[i].func))(&fp->defs[i].rank, PyArray_DIMS(arr), set_data, &flag); } else { /* deallocate */ for (k = 0; k < fp->defs[i].rank; k++) dims[k] = 0; (*(fp->defs[i].func))(&fp->defs[i].rank, dims, set_data, &flag); for (k = 0; k < fp->defs[i].rank; k++) dims[k] = -1; } memcpy(fp->defs[i].dims.d, dims, fp->defs[i].rank * sizeof(npy_intp)); } else { /* not allocatable array */ if ((arr = array_from_pyobj(fp->defs[i].type, fp->defs[i].dims.d, fp->defs[i].rank, F2PY_INTENT_IN, v)) == NULL) return -1; } if (fp->defs[i].data != NULL) { /* copy Python object to Fortran array */ npy_intp s = PyArray_MultiplyList(fp->defs[i].dims.d, PyArray_NDIM(arr)); if (s == -1) s = PyArray_MultiplyList(PyArray_DIMS(arr), PyArray_NDIM(arr)); if (s < 0 || (memcpy(fp->defs[i].data, PyArray_DATA(arr), s * PyArray_ITEMSIZE(arr))) == NULL) { if ((PyObject *)arr != v) { Py_DECREF(arr); } return -1; } if ((PyObject *)arr != v) { Py_DECREF(arr); } } else return (fp->defs[i].func == NULL ? -1 : 0); return 0; /* successful */ } if (fp->dict == NULL) { fp->dict = PyDict_New(); if (fp->dict == NULL) return -1; } if (v == NULL) { int rv = PyDict_DelItemString(fp->dict, name); if (rv < 0) PyErr_SetString(PyExc_AttributeError, "delete non-existing fortran attribute"); return rv; } else return PyDict_SetItemString(fp->dict, name, v); } static PyObject * fortran_call(PyFortranObject *fp, PyObject *arg, PyObject *kw) { int i = 0; /* printf("fortran call name=%s,func=%p,data=%p,%p\n",fp->defs[i].name, fp->defs[i].func,fp->defs[i].data,&fp->defs[i].data); */ if (fp->defs[i].rank == -1) { /* is Fortran routine */ if (fp->defs[i].func == NULL) { PyErr_Format(PyExc_RuntimeError, "no function to call"); return NULL; } else if (fp->defs[i].data == NULL) /* dummy routine */ return (*((fortranfunc)(fp->defs[i].func)))((PyObject *)fp, arg, kw, NULL); else return (*((fortranfunc)(fp->defs[i].func)))( (PyObject *)fp, arg, kw, (void *)fp->defs[i].data); } PyErr_Format(PyExc_TypeError, "this fortran object is not callable"); return NULL; } static PyObject * fortran_repr(PyFortranObject *fp) { PyObject *name = NULL, *repr = NULL; name = PyObject_GetAttrString((PyObject *)fp, "__name__"); PyErr_Clear(); if (name != NULL && PyUnicode_Check(name)) { repr = PyUnicode_FromFormat("<fortran %U>", name); } else { repr = PyUnicode_FromString("<fortran object>"); } Py_XDECREF(name); return repr; } PyTypeObject PyFortran_Type = { PyVarObject_HEAD_INIT(NULL, 0).tp_name = "fortran", .tp_basicsize = sizeof(PyFortranObject), .tp_dealloc = (destructor)fortran_dealloc, .tp_getattr = (getattrfunc)fortran_getattr, .tp_setattr = (setattrfunc)fortran_setattr, .tp_repr = (reprfunc)fortran_repr, .tp_call = (ternaryfunc)fortran_call, }; /************************* f2py_report_atexit *******************************/ #ifdef F2PY_REPORT_ATEXIT static int passed_time = 0; static int passed_counter = 0; static int passed_call_time = 0; static struct timeb start_time; static struct timeb stop_time; static struct timeb start_call_time; static struct timeb stop_call_time; static int cb_passed_time = 0; static int cb_passed_counter = 0; static int cb_passed_call_time = 0; static struct timeb cb_start_time; static struct timeb cb_stop_time; static struct timeb cb_start_call_time; static struct timeb cb_stop_call_time; extern void f2py_start_clock(void) { ftime(&start_time); } extern void f2py_start_call_clock(void) { f2py_stop_clock(); ftime(&start_call_time); } extern void f2py_stop_clock(void) { ftime(&stop_time); passed_time += 1000 * (stop_time.time - start_time.time); passed_time += stop_time.millitm - start_time.millitm; } extern void f2py_stop_call_clock(void) { ftime(&stop_call_time); passed_call_time += 1000 * (stop_call_time.time - start_call_time.time); passed_call_time += stop_call_time.millitm - start_call_time.millitm; passed_counter += 1; f2py_start_clock(); } extern void f2py_cb_start_clock(void) { ftime(&cb_start_time); } extern void f2py_cb_start_call_clock(void) { f2py_cb_stop_clock(); ftime(&cb_start_call_time); } extern void f2py_cb_stop_clock(void) { ftime(&cb_stop_time); cb_passed_time += 1000 * (cb_stop_time.time - cb_start_time.time); cb_passed_time += cb_stop_time.millitm - cb_start_time.millitm; } extern void f2py_cb_stop_call_clock(void) { ftime(&cb_stop_call_time); cb_passed_call_time += 1000 * (cb_stop_call_time.time - cb_start_call_time.time); cb_passed_call_time += cb_stop_call_time.millitm - cb_start_call_time.millitm; cb_passed_counter += 1; f2py_cb_start_clock(); } static int f2py_report_on_exit_been_here = 0; extern void f2py_report_on_exit(int exit_flag, void *name) { if (f2py_report_on_exit_been_here) { fprintf(stderr, " %s\n", (char *)name); return; } f2py_report_on_exit_been_here = 1; fprintf(stderr, " /-----------------------\\\n"); fprintf(stderr, " < F2PY performance report >\n"); fprintf(stderr, " \\-----------------------/\n"); fprintf(stderr, "Overall time spent in ...\n"); fprintf(stderr, "(a) wrapped (Fortran/C) functions : %8d msec\n", passed_call_time); fprintf(stderr, "(b) f2py interface, %6d calls : %8d msec\n", passed_counter, passed_time); fprintf(stderr, "(c) call-back (Python) functions : %8d msec\n", cb_passed_call_time); fprintf(stderr, "(d) f2py call-back interface, %6d calls : %8d msec\n", cb_passed_counter, cb_passed_time); fprintf(stderr, "(e) wrapped (Fortran/C) functions (actual) : %8d msec\n\n", passed_call_time - cb_passed_call_time - cb_passed_time); fprintf(stderr, "Use -DF2PY_REPORT_ATEXIT_DISABLE to disable this message.\n"); fprintf(stderr, "Exit status: %d\n", exit_flag); fprintf(stderr, "Modules : %s\n", (char *)name); } #endif /********************** report on array copy ****************************/ #ifdef F2PY_REPORT_ON_ARRAY_COPY static void f2py_report_on_array_copy(PyArrayObject *arr) { const npy_intp arr_size = PyArray_Size((PyObject *)arr); if (arr_size > F2PY_REPORT_ON_ARRAY_COPY) { fprintf(stderr, "copied an array: size=%ld, elsize=%" NPY_INTP_FMT "\n", arr_size, (npy_intp)PyArray_ITEMSIZE(arr)); } } static void f2py_report_on_array_copy_fromany(void) { fprintf(stderr, "created an array from object\n"); } #define F2PY_REPORT_ON_ARRAY_COPY_FROMARR \ f2py_report_on_array_copy((PyArrayObject *)arr) #define F2PY_REPORT_ON_ARRAY_COPY_FROMANY f2py_report_on_array_copy_fromany() #else #define F2PY_REPORT_ON_ARRAY_COPY_FROMARR #define F2PY_REPORT_ON_ARRAY_COPY_FROMANY #endif /************************* array_from_obj *******************************/ /* * File: array_from_pyobj.c * * Description: * ------------ * Provides array_from_pyobj function that returns a contiguous array * object with the given dimensions and required storage order, either * in row-major (C) or column-major (Fortran) order. The function * array_from_pyobj is very flexible about its Python object argument * that can be any number, list, tuple, or array. * * array_from_pyobj is used in f2py generated Python extension * modules. * * Author: Pearu Peterson <pearu@cens.ioc.ee> * Created: 13-16 January 2002 * $Id: fortranobject.c,v 1.52 2005/07/11 07:44:20 pearu Exp $ */ static int check_and_fix_dimensions(const PyArrayObject* arr, const int rank, npy_intp *dims, const char *errmess); static int find_first_negative_dimension(const int rank, const npy_intp *dims) { for (int i = 0; i < rank; ++i) { if (dims[i] < 0) { return i; } } return -1; } #ifdef DEBUG_COPY_ND_ARRAY void dump_dims(int rank, npy_intp const *dims) { int i; printf("["); for (i = 0; i < rank; ++i) { printf("%3" NPY_INTP_FMT, dims[i]); } printf("]\n"); } void dump_attrs(const PyArrayObject *obj) { const PyArrayObject_fields *arr = (const PyArrayObject_fields *)obj; int rank = PyArray_NDIM(arr); npy_intp size = PyArray_Size((PyObject *)arr); printf("\trank = %d, flags = %d, size = %" NPY_INTP_FMT "\n", rank, arr->flags, size); printf("\tstrides = "); dump_dims(rank, arr->strides); printf("\tdimensions = "); dump_dims(rank, arr->dimensions); } #endif #define SWAPTYPE(a, b, t) \ { \ t c; \ c = (a); \ (a) = (b); \ (b) = c; \ } static int swap_arrays(PyArrayObject *obj1, PyArrayObject *obj2) { PyArrayObject_fields *arr1 = (PyArrayObject_fields *)obj1, *arr2 = (PyArrayObject_fields *)obj2; SWAPTYPE(arr1->data, arr2->data, char *); SWAPTYPE(arr1->nd, arr2->nd, int); SWAPTYPE(arr1->dimensions, arr2->dimensions, npy_intp *); SWAPTYPE(arr1->strides, arr2->strides, npy_intp *); SWAPTYPE(arr1->base, arr2->base, PyObject *); SWAPTYPE(arr1->descr, arr2->descr, PyArray_Descr *); SWAPTYPE(arr1->flags, arr2->flags, int); /* SWAPTYPE(arr1->weakreflist,arr2->weakreflist,PyObject*); */ return 0; } #define ARRAY_ISCOMPATIBLE(arr,type_num) \ ((PyArray_ISINTEGER(arr) && PyTypeNum_ISINTEGER(type_num)) || \ (PyArray_ISFLOAT(arr) && PyTypeNum_ISFLOAT(type_num)) || \ (PyArray_ISCOMPLEX(arr) && PyTypeNum_ISCOMPLEX(type_num)) || \ (PyArray_ISBOOL(arr) && PyTypeNum_ISBOOL(type_num)) || \ (PyArray_ISSTRING(arr) && PyTypeNum_ISSTRING(type_num))) static int get_elsize(PyObject *obj) { /* get_elsize determines array itemsize from a Python object. Returns elsize if successful, -1 otherwise. Supported types of the input are: numpy.ndarray, bytes, str, tuple, list. */ if (PyArray_Check(obj)) { return PyArray_DESCR((PyArrayObject *)obj)->elsize; } else if (PyBytes_Check(obj)) { return PyBytes_GET_SIZE(obj); } else if (PyUnicode_Check(obj)) { return PyUnicode_GET_LENGTH(obj); } else if (PySequence_Check(obj)) { PyObject* fast = PySequence_Fast(obj, "f2py:fortranobject.c:get_elsize"); if (fast != NULL) { Py_ssize_t i, n = PySequence_Fast_GET_SIZE(fast); int sz, elsize = 0; for (i=0; i<n; i++) { sz = get_elsize(PySequence_Fast_GET_ITEM(fast, i) /* borrowed */); if (sz > elsize) { elsize = sz; } } Py_DECREF(fast); return elsize; } } return -1; } extern PyArrayObject * ndarray_from_pyobj(const int type_num, const int elsize_, npy_intp *dims, const int rank, const int intent, PyObject *obj, const char *errmess) { /* * Return an array with given element type and shape from a Python * object while taking into account the usage intent of the array. * * - element type is defined by type_num and elsize * - shape is defined by dims and rank * * ndarray_from_pyobj is used to convert Python object arguments * to numpy ndarrays with given type and shape that data is passed * to interfaced Fortran or C functions. * * errmess (if not NULL), contains a prefix of an error message * for an exception to be triggered within this function. * * Negative elsize value means that elsize is to be determined * from the Python object in runtime. * * Note on strings * --------------- * * String type (type_num == NPY_STRING) does not have fixed * element size and, by default, the type object sets it to * 0. Therefore, for string types, one has to use elsize * argument. For other types, elsize value is ignored. * * NumPy defines the type of a fixed-width string as * dtype('S<width>'). In addition, there is also dtype('c'), that * appears as dtype('S1') (these have the same type_num value), * but is actually different (.char attribute is either 'S' or * 'c', respecitely). * * In Fortran, character arrays and strings are different * concepts. The relation between Fortran types, NumPy dtypes, * and type_num-elsize pairs, is defined as follows: * * character*5 foo | dtype('S5') | elsize=5, shape=() * character(5) foo | dtype('S1') | elsize=1, shape=(5) * character*5 foo(n) | dtype('S5') | elsize=5, shape=(n,) * character(5) foo(n) | dtype('S1') | elsize=1, shape=(5, n) * character*(*) foo | dtype('S') | elsize=-1, shape=() * * Note about reference counting * ----------------------------- * * If the caller returns the array to Python, it must be done with * Py_BuildValue("N",arr). Otherwise, if obj!=arr then the caller * must call Py_DECREF(arr). * * Note on intent(cache,out,..) * ---------------------------- * Don't expect correct data when returning intent(cache) array. * */ char mess[F2PY_MESSAGE_BUFFER_SIZE]; PyArrayObject *arr = NULL; int elsize = (elsize_ < 0 ? get_elsize(obj) : elsize_); if (elsize < 0) { if (errmess != NULL) { strcpy(mess, errmess); } sprintf(mess + strlen(mess), " -- failed to determine element size from %s", Py_TYPE(obj)->tp_name); PyErr_SetString(PyExc_SystemError, mess); return NULL; } PyArray_Descr * descr = get_descr_from_type_and_elsize(type_num, elsize); // new reference if (descr == NULL) { return NULL; } elsize = descr->elsize; if ((intent & F2PY_INTENT_HIDE) || ((intent & F2PY_INTENT_CACHE) && (obj == Py_None)) || ((intent & F2PY_OPTIONAL) && (obj == Py_None)) ) { /* intent(cache), optional, intent(hide) */ int ineg = find_first_negative_dimension(rank, dims); if (ineg >= 0) { int i; strcpy(mess, "failed to create intent(cache|hide)|optional array" "-- must have defined dimensions but got ("); for(i = 0; i < rank; ++i) sprintf(mess + strlen(mess), "%" NPY_INTP_FMT ",", dims[i]); strcat(mess, ")"); PyErr_SetString(PyExc_ValueError, mess); Py_DECREF(descr); return NULL; } arr = (PyArrayObject *) \ PyArray_NewFromDescr(&PyArray_Type, descr, rank, dims, NULL, NULL, !(intent & F2PY_INTENT_C), NULL); if (arr == NULL) { Py_DECREF(descr); return NULL; } if (PyArray_ITEMSIZE(arr) != elsize) { strcpy(mess, "failed to create intent(cache|hide)|optional array"); sprintf(mess+strlen(mess)," -- expected elsize=%d got %" NPY_INTP_FMT, elsize, (npy_intp)PyArray_ITEMSIZE(arr)); PyErr_SetString(PyExc_ValueError,mess); Py_DECREF(arr); return NULL; } if (!(intent & F2PY_INTENT_CACHE)) { PyArray_FILLWBYTE(arr, 0); } return arr; } if (PyArray_Check(obj)) { arr = (PyArrayObject *)obj; if (intent & F2PY_INTENT_CACHE) { /* intent(cache) */ if (PyArray_ISONESEGMENT(arr) && PyArray_ITEMSIZE(arr) >= elsize) { if (check_and_fix_dimensions(arr, rank, dims, errmess)) { Py_DECREF(descr); return NULL; } if (intent & F2PY_INTENT_OUT) Py_INCREF(arr); Py_DECREF(descr); return arr; } strcpy(mess, "failed to initialize intent(cache) array"); if (!PyArray_ISONESEGMENT(arr)) strcat(mess, " -- input must be in one segment"); if (PyArray_ITEMSIZE(arr) < elsize) sprintf(mess + strlen(mess), " -- expected at least elsize=%d but got " "%" NPY_INTP_FMT, elsize, (npy_intp)PyArray_ITEMSIZE(arr)); PyErr_SetString(PyExc_ValueError, mess); Py_DECREF(descr); return NULL; } /* here we have always intent(in) or intent(inout) or intent(inplace) */ if (check_and_fix_dimensions(arr, rank, dims, errmess)) { Py_DECREF(descr); return NULL; } /* printf("intent alignment=%d\n", F2PY_GET_ALIGNMENT(intent)); printf("alignment check=%d\n", F2PY_CHECK_ALIGNMENT(arr, intent)); int i; for (i=1;i<=16;i++) printf("i=%d isaligned=%d\n", i, ARRAY_ISALIGNED(arr, i)); */ if ((! (intent & F2PY_INTENT_COPY)) && PyArray_ITEMSIZE(arr) == elsize && ARRAY_ISCOMPATIBLE(arr,type_num) && F2PY_CHECK_ALIGNMENT(arr, intent)) { if ((intent & F2PY_INTENT_INOUT || intent & F2PY_INTENT_INPLACE) ? ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY(arr) : PyArray_ISFARRAY(arr)) : ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY_RO(arr) : PyArray_ISFARRAY_RO(arr))) { if ((intent & F2PY_INTENT_OUT)) { Py_INCREF(arr); } /* Returning input array */ Py_DECREF(descr); return arr; } } if (intent & F2PY_INTENT_INOUT) { strcpy(mess, "failed to initialize intent(inout) array"); /* Must use PyArray_IS*ARRAY because intent(inout) requires * writable input */ if ((intent & F2PY_INTENT_C) && !PyArray_ISCARRAY(arr)) strcat(mess, " -- input not contiguous"); if (!(intent & F2PY_INTENT_C) && !PyArray_ISFARRAY(arr)) strcat(mess, " -- input not fortran contiguous"); if (PyArray_ITEMSIZE(arr) != elsize) sprintf(mess + strlen(mess), " -- expected elsize=%d but got %" NPY_INTP_FMT, elsize, (npy_intp)PyArray_ITEMSIZE(arr) ); if (!(ARRAY_ISCOMPATIBLE(arr, type_num))) { sprintf(mess + strlen(mess), " -- input '%c' not compatible to '%c'", PyArray_DESCR(arr)->type, descr->type); } if (!(F2PY_CHECK_ALIGNMENT(arr, intent))) sprintf(mess + strlen(mess), " -- input not %d-aligned", F2PY_GET_ALIGNMENT(intent)); PyErr_SetString(PyExc_ValueError, mess); Py_DECREF(descr); return NULL; } /* here we have always intent(in) or intent(inplace) */ { PyArrayObject * retarr = (PyArrayObject *) \ PyArray_NewFromDescr(&PyArray_Type, descr, PyArray_NDIM(arr), PyArray_DIMS(arr), NULL, NULL, !(intent & F2PY_INTENT_C), NULL); if (retarr==NULL) { Py_DECREF(descr); return NULL; } F2PY_REPORT_ON_ARRAY_COPY_FROMARR; if (PyArray_CopyInto(retarr, arr)) { Py_DECREF(retarr); return NULL; } if (intent & F2PY_INTENT_INPLACE) { if (swap_arrays(arr,retarr)) { Py_DECREF(retarr); return NULL; /* XXX: set exception */ } Py_XDECREF(retarr); if (intent & F2PY_INTENT_OUT) Py_INCREF(arr); } else { arr = retarr; } } return arr; } if ((intent & F2PY_INTENT_INOUT) || (intent & F2PY_INTENT_INPLACE) || (intent & F2PY_INTENT_CACHE)) { PyErr_Format(PyExc_TypeError, "failed to initialize intent(inout|inplace|cache) " "array, input '%s' object is not an array", Py_TYPE(obj)->tp_name); Py_DECREF(descr); return NULL; } { F2PY_REPORT_ON_ARRAY_COPY_FROMANY; arr = (PyArrayObject *)PyArray_FromAny( obj, descr, 0, 0, ((intent & F2PY_INTENT_C) ? NPY_ARRAY_CARRAY : NPY_ARRAY_FARRAY) | NPY_ARRAY_FORCECAST, NULL); // Warning: in the case of NPY_STRING, PyArray_FromAny may // reset descr->elsize, e.g. dtype('S0') becomes dtype('S1'). if (arr == NULL) { Py_DECREF(descr); return NULL; } if (type_num != NPY_STRING && PyArray_ITEMSIZE(arr) != elsize) { // This is internal sanity tests: elsize has been set to // descr->elsize in the beginning of this function. strcpy(mess, "failed to initialize intent(in) array"); sprintf(mess + strlen(mess), " -- expected elsize=%d got %" NPY_INTP_FMT, elsize, (npy_intp)PyArray_ITEMSIZE(arr)); PyErr_SetString(PyExc_ValueError, mess); Py_DECREF(arr); return NULL; } if (check_and_fix_dimensions(arr, rank, dims, errmess)) { Py_DECREF(arr); return NULL; } return arr; } } extern PyArrayObject * array_from_pyobj(const int type_num, npy_intp *dims, const int rank, const int intent, PyObject *obj) { /* Same as ndarray_from_pyobj but with elsize determined from type, if possible. Provided for backward compatibility. */ PyArray_Descr* descr = PyArray_DescrFromType(type_num); int elsize = descr->elsize; Py_DECREF(descr); return ndarray_from_pyobj(type_num, elsize, dims, rank, intent, obj, NULL); } /*****************************************/ /* Helper functions for array_from_pyobj */ /*****************************************/ static int check_and_fix_dimensions(const PyArrayObject* arr, const int rank, npy_intp *dims, const char *errmess) { /* * This function fills in blanks (that are -1's) in dims list using * the dimensions from arr. It also checks that non-blank dims will * match with the corresponding values in arr dimensions. * * Returns 0 if the function is successful. * * If an error condition is detected, an exception is set and 1 is * returned. */ char mess[F2PY_MESSAGE_BUFFER_SIZE]; const npy_intp arr_size = (PyArray_NDIM(arr)) ? PyArray_Size((PyObject *)arr) : 1; #ifdef DEBUG_COPY_ND_ARRAY dump_attrs(arr); printf("check_and_fix_dimensions:init: dims="); dump_dims(rank, dims); #endif if (rank > PyArray_NDIM(arr)) { /* [1,2] -> [[1],[2]]; 1 -> [[1]] */ npy_intp new_size = 1; int free_axe = -1; int i; npy_intp d; /* Fill dims where -1 or 0; check dimensions; calc new_size; */ for (i = 0; i < PyArray_NDIM(arr); ++i) { d = PyArray_DIM(arr, i); if (dims[i] >= 0) { if (d > 1 && dims[i] != d) { PyErr_Format( PyExc_ValueError, "%d-th dimension must be fixed to %" NPY_INTP_FMT " but got %" NPY_INTP_FMT "\n", i, dims[i], d); return 1; } if (!dims[i]) dims[i] = 1; } else { dims[i] = d ? d : 1; } new_size *= dims[i]; } for (i = PyArray_NDIM(arr); i < rank; ++i) if (dims[i] > 1) { PyErr_Format(PyExc_ValueError, "%d-th dimension must be %" NPY_INTP_FMT " but got 0 (not defined).\n", i, dims[i]); return 1; } else if (free_axe < 0) free_axe = i; else dims[i] = 1; if (free_axe >= 0) { dims[free_axe] = arr_size / new_size; new_size *= dims[free_axe]; } if (new_size != arr_size) { PyErr_Format(PyExc_ValueError, "unexpected array size: new_size=%" NPY_INTP_FMT ", got array with arr_size=%" NPY_INTP_FMT " (maybe too many free indices)\n", new_size, arr_size); return 1; } } else if (rank == PyArray_NDIM(arr)) { npy_intp new_size = 1; int i; npy_intp d; for (i = 0; i < rank; ++i) { d = PyArray_DIM(arr, i); if (dims[i] >= 0) { if (d > 1 && d != dims[i]) { if (errmess != NULL) { strcpy(mess, errmess); } sprintf(mess + strlen(mess), " -- %d-th dimension must be fixed to %" NPY_INTP_FMT " but got %" NPY_INTP_FMT, i, dims[i], d); PyErr_SetString(PyExc_ValueError, mess); return 1; } if (!dims[i]) dims[i] = 1; } else dims[i] = d; new_size *= dims[i]; } if (new_size != arr_size) { PyErr_Format(PyExc_ValueError, "unexpected array size: new_size=%" NPY_INTP_FMT ", got array with arr_size=%" NPY_INTP_FMT "\n", new_size, arr_size); return 1; } } else { /* [[1,2]] -> [[1],[2]] */ int i, j; npy_intp d; int effrank; npy_intp size; for (i = 0, effrank = 0; i < PyArray_NDIM(arr); ++i) if (PyArray_DIM(arr, i) > 1) ++effrank; if (dims[rank - 1] >= 0) if (effrank > rank) { PyErr_Format(PyExc_ValueError, "too many axes: %d (effrank=%d), " "expected rank=%d\n", PyArray_NDIM(arr), effrank, rank); return 1; } for (i = 0, j = 0; i < rank; ++i) { while (j < PyArray_NDIM(arr) && PyArray_DIM(arr, j) < 2) ++j; if (j >= PyArray_NDIM(arr)) d = 1; else d = PyArray_DIM(arr, j++); if (dims[i] >= 0) { if (d > 1 && d != dims[i]) { if (errmess != NULL) { strcpy(mess, errmess); } sprintf(mess + strlen(mess), " -- %d-th dimension must be fixed to %" NPY_INTP_FMT " but got %" NPY_INTP_FMT " (real index=%d)\n", i, dims[i], d, j-1); PyErr_SetString(PyExc_ValueError, mess); return 1; } if (!dims[i]) dims[i] = 1; } else dims[i] = d; } for (i = rank; i < PyArray_NDIM(arr); ++i) { /* [[1,2],[3,4]] -> [1,2,3,4] */ while (j < PyArray_NDIM(arr) && PyArray_DIM(arr, j) < 2) ++j; if (j >= PyArray_NDIM(arr)) d = 1; else d = PyArray_DIM(arr, j++); dims[rank - 1] *= d; } for (i = 0, size = 1; i < rank; ++i) size *= dims[i]; if (size != arr_size) { char msg[200]; int len; snprintf(msg, sizeof(msg), "unexpected array size: size=%" NPY_INTP_FMT ", arr_size=%" NPY_INTP_FMT ", rank=%d, effrank=%d, arr.nd=%d, dims=[", size, arr_size, rank, effrank, PyArray_NDIM(arr)); for (i = 0; i < rank; ++i) { len = strlen(msg); snprintf(msg + len, sizeof(msg) - len, " %" NPY_INTP_FMT, dims[i]); } len = strlen(msg); snprintf(msg + len, sizeof(msg) - len, " ], arr.dims=["); for (i = 0; i < PyArray_NDIM(arr); ++i) { len = strlen(msg); snprintf(msg + len, sizeof(msg) - len, " %" NPY_INTP_FMT, PyArray_DIM(arr, i)); } len = strlen(msg); snprintf(msg + len, sizeof(msg) - len, " ]\n"); PyErr_SetString(PyExc_ValueError, msg); return 1; } } #ifdef DEBUG_COPY_ND_ARRAY printf("check_and_fix_dimensions:end: dims="); dump_dims(rank, dims); #endif return 0; } /* End of file: array_from_pyobj.c */ /************************* copy_ND_array *******************************/ extern int copy_ND_array(const PyArrayObject *arr, PyArrayObject *out) { F2PY_REPORT_ON_ARRAY_COPY_FROMARR; return PyArray_CopyInto(out, (PyArrayObject *)arr); } /********************* Various utility functions ***********************/ extern int f2py_describe(PyObject *obj, char *buf) { /* Write the description of a Python object to buf. The caller must provide buffer with size sufficient to write the description. Return 1 on success. */ char localbuf[F2PY_MESSAGE_BUFFER_SIZE]; if (PyBytes_Check(obj)) { sprintf(localbuf, "%d-%s", (npy_int)PyBytes_GET_SIZE(obj), Py_TYPE(obj)->tp_name); } else if (PyUnicode_Check(obj)) { sprintf(localbuf, "%d-%s", (npy_int)PyUnicode_GET_LENGTH(obj), Py_TYPE(obj)->tp_name); } else if (PyArray_CheckScalar(obj)) { PyArrayObject* arr = (PyArrayObject*)obj; sprintf(localbuf, "%c%" NPY_INTP_FMT "-%s-scalar", PyArray_DESCR(arr)->kind, PyArray_ITEMSIZE(arr), Py_TYPE(obj)->tp_name); } else if (PyArray_Check(obj)) { int i; PyArrayObject* arr = (PyArrayObject*)obj; strcpy(localbuf, "("); for (i=0; i<PyArray_NDIM(arr); i++) { if (i) { strcat(localbuf, " "); } sprintf(localbuf + strlen(localbuf), "%" NPY_INTP_FMT ",", PyArray_DIM(arr, i)); } sprintf(localbuf + strlen(localbuf), ")-%c%" NPY_INTP_FMT "-%s", PyArray_DESCR(arr)->kind, PyArray_ITEMSIZE(arr), Py_TYPE(obj)->tp_name); } else if (PySequence_Check(obj)) { sprintf(localbuf, "%d-%s", (npy_int)PySequence_Length(obj), Py_TYPE(obj)->tp_name); } else { sprintf(localbuf, "%s instance", Py_TYPE(obj)->tp_name); } // TODO: detect the size of buf and make sure that size(buf) >= size(localbuf). strcpy(buf, localbuf); return 1; } extern npy_intp f2py_size_impl(PyArrayObject* var, ...) { npy_intp sz = 0; npy_intp dim; npy_intp rank; va_list argp; va_start(argp, var); dim = va_arg(argp, npy_int); if (dim==-1) { sz = PyArray_SIZE(var); } else { rank = PyArray_NDIM(var); if (dim>=1 && dim<=rank) sz = PyArray_DIM(var, dim-1); else fprintf(stderr, "f2py_size: 2nd argument value=%" NPY_INTP_FMT " fails to satisfy 1<=value<=%" NPY_INTP_FMT ". Result will be 0.\n", dim, rank); } va_end(argp); return sz; } /*********************************************/ /* Compatibility functions for Python >= 3.0 */ /*********************************************/ PyObject * F2PyCapsule_FromVoidPtr(void *ptr, void (*dtor)(PyObject *)) { PyObject *ret = PyCapsule_New(ptr, NULL, dtor); if (ret == NULL) { PyErr_Clear(); } return ret; } void * F2PyCapsule_AsVoidPtr(PyObject *obj) { void *ret = PyCapsule_GetPointer(obj, NULL); if (ret == NULL) { PyErr_Clear(); } return ret; } int F2PyCapsule_Check(PyObject *ptr) { return PyCapsule_CheckExact(ptr); } #ifdef __cplusplus } #endif /************************* EOF fortranobject.c *******************************/