/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c

Bug Summary

File:	numpy/core/src/multiarray/descriptor.c
Warning:	line 527, column 14 Calling function 'PyDict_GetItemWithError' with a PyObject argument whose ownership has been released (with stolen reference)

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name getset.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/numpy/csa-scan,ctu-index-name=/tmp/pyrefcon/numpy/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/numpy/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +sse -target-feature +sse2 -target-feature +sse3 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/numpy -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -D NPY_INTERNAL_BUILD=1 -D HAVE_NPY_CONFIG_H=1 -D _FILE_OFFSET_BITS=64 -D _LARGEFILE_SOURCE=1 -D _LARGEFILE64_SOURCE=1 -I build/src.linux-x86_64-3.8/numpy/core/src/common -I build/src.linux-x86_64-3.8/numpy/core/src/umath -I numpy/core/include -I build/src.linux-x86_64-3.8/numpy/core/include/numpy -I build/src.linux-x86_64-3.8/numpy/distutils/include -I numpy/core/src/common -I numpy/core/src -I numpy/core -I numpy/core/src/npymath -I numpy/core/src/multiarray -I numpy/core/src/umath -I numpy/core/src/npysort -I numpy/core/src/_simd -I build/src.linux-x86_64-3.8/numpy/core/src/common -I build/src.linux-x86_64-3.8/numpy/core/src/npymath -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wall -Wformat -Werror=format-security -Wformat -Werror=format-security -Wdate-time -fdebug-compilation-dir=/tmp/pyrefcon/numpy -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/numpy/csa-scan/reports -x c numpy/core/src/multiarray/getset.c

numpy/core/src/multiarray/getset.c

→

1/* Array Descr Object */

3#define PY_SSIZE_T_CLEAN
4#include <Python.h>
5#include "structmember.h"

7#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E
8#define _MULTIARRAYMODULE
9#include "numpy/arrayobject.h"

11#include "npy_config.h"
12#include "npy_pycompat.h"
13#include "npy_import.h"

15#include "common.h"
16#include "conversion_utils.h"
17#include "ctors.h"
18#include "scalartypes.h"
19#include "descriptor.h"
20#include "getset.h"
21#include "arrayobject.h"
22#include "mem_overlap.h"
23#include "alloc.h"
24#include "npy_buffer.h"

26/*******************  array attribute get and set routines ******************/

28static PyObject *
29array_ndim_get(PyArrayObject *self)
30{
  return PyLong_FromLong(PyArray_NDIM(self));
32}

34static PyObject *
35array_flags_get(PyArrayObject *self)
36{
  return PyArray_NewFlagsObject((PyObject *)self);
38}

40static PyObject *
41array_shape_get(PyArrayObject *self)
42{
  return PyArray_IntTupleFromIntp(PyArray_NDIM(self), PyArray_DIMS(self));
44}


47static int
48array_shape_set(PyArrayObject *self, PyObject *val)
49{
  int nd;
  PyArrayObject *ret;

  if (val == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array shape");
      return -1;
  }
  /* Assumes C-order */
  ret = (PyArrayObject *)PyArray_Reshape(self, val);
  if (ret == NULL((void*)0)) {
      return -1;
  }
  if (PyArray_DATA(ret) != PyArray_DATA(self)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      PyErr_SetString(PyExc_AttributeError,
                      "Incompatible shape for in-place modification. Use "
                      "`.reshape()` to make a copy with the desired shape.");
      return -1;
  }

  nd = PyArray_NDIM(ret);
  if (nd > 0) {
      /* create new dimensions and strides */
      npy_intp *_dimensions = npy_alloc_cache_dim(2 * nd);
      if (_dimensions == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          PyErr_NoMemory();
          return -1;
      }
      /* Free old dimensions and strides */
      npy_free_cache_dim_array(self);
      ((PyArrayObject_fields *)self)->nd = nd;
      ((PyArrayObject_fields *)self)->dimensions = _dimensions; 
      ((PyArrayObject_fields *)self)->strides = _dimensions + nd;

      if (nd) {
          memcpy(PyArray_DIMS(self), PyArray_DIMS(ret), nd*sizeof(npy_intp));
          memcpy(PyArray_STRIDES(self), PyArray_STRIDES(ret), nd*sizeof(npy_intp));
      }
  }
  else {
      /* Free old dimensions and strides */
      npy_free_cache_dim_array(self);        
      ((PyArrayObject_fields *)self)->nd = 0;
      ((PyArrayObject_fields *)self)->dimensions = NULL((void*)0);
      ((PyArrayObject_fields *)self)->strides = NULL((void*)0);
  }

  Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
  PyArray_UpdateFlags(self, NPY_ARRAY_C_CONTIGUOUS0x0001 | NPY_ARRAY_F_CONTIGUOUS0x0002);
  return 0;
102}


105static PyObject *
106array_strides_get(PyArrayObject *self)
107{
  return PyArray_IntTupleFromIntp(PyArray_NDIM(self), PyArray_STRIDES(self));
109}

111static int
112array_strides_set(PyArrayObject *self, PyObject *obj)
113{
  PyArray_Dims newstrides = {NULL((void*)0), -1};
  PyArrayObject *new;
  npy_intp numbytes = 0;
  npy_intp offset = 0;
  npy_intp lower_offset = 0;
  npy_intp upper_offset = 0;
  Py_buffer view;

  if (obj == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array strides");
      return -1;
  }
  if (!PyArray_OptionalIntpConverter(obj, &newstrides) ||
      newstrides.len == -1) {
      PyErr_SetString(PyExc_TypeError, "invalid strides");
      return -1;
  }
  if (newstrides.len != PyArray_NDIM(self)) {
      PyErr_Format(PyExc_ValueError, "strides must be "       \
                   " same length as shape (%d)", PyArray_NDIM(self));
      goto fail;
  }
  new = self;
  while(PyArray_BASE(new) && PyArray_Check(PyArray_BASE(new))((((PyObject*)(PyArray_BASE(new)))->ob_type) == (&PyArray_Type
) || PyType_IsSubtype((((PyObject*)(PyArray_BASE(new)))->ob_type
), (&PyArray_Type)))) {
      new = (PyArrayObject *)(PyArray_BASE(new));
  }
  /*
   * Get the available memory through the buffer interface on
   * PyArray_BASE(new) or if that fails from the current new
   */
  if (PyArray_BASE(new) &&
          PyObject_GetBuffer(PyArray_BASE(new), &view, PyBUF_SIMPLE0) >= 0) {
      offset = PyArray_BYTES(self) - (char *)view.buf;
      numbytes = view.len + offset;
      PyBuffer_Release(&view);
  }
  else {
      PyErr_Clear();
      offset_bounds_from_strides(PyArray_ITEMSIZE(new), PyArray_NDIM(new),
                                 PyArray_DIMS(new), PyArray_STRIDES(new),
                                 &lower_offset, &upper_offset);

      offset = PyArray_BYTES(self) - (PyArray_BYTES(new) + lower_offset);
      numbytes = upper_offset - lower_offset;
  }

  /* numbytes == 0 is special here, but the 0-size array case always works */
  if (!PyArray_CheckStrides(PyArray_ITEMSIZE(self), PyArray_NDIM(self),
                            numbytes, offset,
                            PyArray_DIMS(self), newstrides.ptr)) {
      PyErr_SetString(PyExc_ValueError, "strides is not "\
                      "compatible with available memory");
      goto fail;
  }
  if (newstrides.len) {
      memcpy(PyArray_STRIDES(self), newstrides.ptr, sizeof(npy_intp)*newstrides.len);
  }
  PyArray_UpdateFlags(self, NPY_ARRAY_C_CONTIGUOUS0x0001 | NPY_ARRAY_F_CONTIGUOUS0x0002 |
                            NPY_ARRAY_ALIGNED0x0100);
  npy_free_cache_dim_obj(newstrides);
  return 0;

fail:
  npy_free_cache_dim_obj(newstrides);
  return -1;
180}



184static PyObject *
185array_priority_get(PyArrayObject *NPY_UNUSED(self)(__NPY_UNUSED_TAGGEDself) __attribute__ ((__unused__)))
186{
  return PyFloat_FromDouble(NPY_PRIORITY0.0);
188}

190static PyObject *
191array_typestr_get(PyArrayObject *self)
192{
  return arraydescr_protocol_typestr_get(PyArray_DESCR(self));
194}

196static PyObject *
197array_descr_get(PyArrayObject *self)
198{
  Py_INCREF(PyArray_DESCR(self))_Py_INCREF(((PyObject*)(PyArray_DESCR(self))));
  return (PyObject *)PyArray_DESCR(self);
201}

203static PyObject *
204array_protocol_descr_get(PyArrayObject *self)
205{
  PyObject *res;
  PyObject *dobj;

  res = arraydescr_protocol_descr_get(PyArray_DESCR(self));
  if (res) {
      return res;
  }
  PyErr_Clear();

  /* get default */
  dobj = PyTuple_New(2);
  if (dobj == NULL((void*)0)) {
      return NULL((void*)0);
  }
  PyTuple_SET_ITEM(dobj, 0, PyUnicode_FromString(""))PyTuple_SetItem(dobj, 0, PyUnicode_FromString(""));
  PyTuple_SET_ITEM(dobj, 1, array_typestr_get(self))PyTuple_SetItem(dobj, 1, array_typestr_get(self));
  res = PyList_New(1);
  if (res == NULL((void*)0)) {
      Py_DECREF(dobj)_Py_DECREF(((PyObject*)(dobj)));
      return NULL((void*)0);
  }
  PyList_SET_ITEM(res, 0, dobj)PyList_SetItem(res, 0, dobj);
  return res;
229}

231static PyObject *
232array_protocol_strides_get(PyArrayObject *self)
233{
  if (PyArray_ISCONTIGUOUS(self)PyArray_CHKFLAGS((self), 0x0001)) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  return PyArray_IntTupleFromIntp(PyArray_NDIM(self), PyArray_STRIDES(self));
238}



242static PyObject *
243array_dataptr_get(PyArrayObject *self)
244{
  return Py_BuildValue_Py_BuildValue_SizeT("NO",
                       PyLong_FromVoidPtr(PyArray_DATA(self)),
                       ((PyArray_FLAGS(self) & NPY_ARRAY_WRITEABLE0x0400) &&
                        !(PyArray_FLAGS(self) & NPY_ARRAY_WARN_ON_WRITE)) ?
                       Py_False((PyObject *) &_Py_FalseStruct) : Py_True((PyObject *) &_Py_TrueStruct));
250}

252static PyObject *
253array_ctypes_get(PyArrayObject *self)
254{
  PyObject *_numpy_internal;
  PyObject *ret;
  _numpy_internal = PyImport_ImportModule("numpy.core._internal");
  if (_numpy_internal == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_internal, "_ctypes", "ON", self,
                            PyLong_FromVoidPtr(PyArray_DATA(self)));
  Py_DECREF(_numpy_internal)_Py_DECREF(((PyObject*)(_numpy_internal)));
  return ret;
265}

267static PyObject *
268array_interface_get(PyArrayObject *self)
269{
  PyObject *dict;
  PyObject *obj;

  dict = PyDict_New();
  if (dict == NULL((void*)0)) {
      return NULL((void*)0);
  }

  int ret;

  /* dataptr */
  obj = array_dataptr_get(self);
  ret = PyDict_SetItemString(dict, "data", obj);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      Py_DECREF(dict)_Py_DECREF(((PyObject*)(dict)));
      return NULL((void*)0);
  }

  obj = array_protocol_strides_get(self);
  ret = PyDict_SetItemString(dict, "strides", obj);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      Py_DECREF(dict)_Py_DECREF(((PyObject*)(dict)));
      return NULL((void*)0);
  }

  obj = array_protocol_descr_get(self);
  ret = PyDict_SetItemString(dict, "descr", obj);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      Py_DECREF(dict)_Py_DECREF(((PyObject*)(dict)));
      return NULL((void*)0);
  }

  obj = arraydescr_protocol_typestr_get(PyArray_DESCR(self));
  ret = PyDict_SetItemString(dict, "typestr", obj);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      Py_DECREF(dict)_Py_DECREF(((PyObject*)(dict)));
      return NULL((void*)0);
  }

  obj = array_shape_get(self);
  ret = PyDict_SetItemString(dict, "shape", obj);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      Py_DECREF(dict)_Py_DECREF(((PyObject*)(dict)));
      return NULL((void*)0);
  }

  obj = PyLong_FromLong(3);
  ret = PyDict_SetItemString(dict, "version", obj);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      Py_DECREF(dict)_Py_DECREF(((PyObject*)(dict)));
      return NULL((void*)0);
  }

  return dict;
330}

332static PyObject *
333array_data_get(PyArrayObject *self)
334{
  return PyMemoryView_FromObject((PyObject *)self);
336}

338static int
339array_data_set(PyArrayObject *self, PyObject *op)
340{
  void *buf;
  Py_ssize_t buf_len;
  int writeable=1;
  Py_buffer view;

  /* 2016-19-02, 1.12 */
  int ret = DEPRECATE("Assigning the 'data' attribute is an "PyErr_WarnEx(PyExc_DeprecationWarning,"Assigning the 'data' attribute is an "
 "inherently unsafe operation and will " "be removed in the future."
,1)
                      "inherently unsafe operation and will "PyErr_WarnEx(PyExc_DeprecationWarning,"Assigning the 'data' attribute is an "
 "inherently unsafe operation and will " "be removed in the future."
,1)
                      "be removed in the future.")PyErr_WarnEx(PyExc_DeprecationWarning,"Assigning the 'data' attribute is an "
 "inherently unsafe operation and will " "be removed in the future."
,1);
  if (ret < 0) {
      return -1;
  }

  if (op == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array data");
      return -1;
  }
  if (PyObject_GetBuffer(op, &view, PyBUF_WRITABLE0x0001|PyBUF_SIMPLE0) < 0) {
      writeable = 0;
      PyErr_Clear();
      if (PyObject_GetBuffer(op, &view, PyBUF_SIMPLE0) < 0) {
          return -1;
      }
  }
  buf = view.buf;
  buf_len = view.len;
  /*
   * In Python 3 both of the deprecated functions PyObject_AsWriteBuffer and
   * PyObject_AsReadBuffer that this code replaces release the buffer. It is
   * up to the object that supplies the buffer to guarantee that the buffer
   * sticks around after the release.
   */
  PyBuffer_Release(&view);

  if (!PyArray_ISONESEGMENT(self)(PyArray_CHKFLAGS(self, 0x0001) || PyArray_CHKFLAGS(self, 0x0002
))) {
      PyErr_SetString(PyExc_AttributeError,
              "cannot set single-segment buffer for discontiguous array");
      return -1;
  }
  if (PyArray_NBYTES(self)(PyArray_ITEMSIZE(self) * PyArray_MultiplyList(PyArray_DIMS(self
), PyArray_NDIM(self))) > buf_len) {
      PyErr_SetString(PyExc_AttributeError, "not enough data for array");
      return -1;
  }
  if (PyArray_FLAGS(self) & NPY_ARRAY_OWNDATA0x0004) {
      PyArray_XDECREF(self);
      PyDataMem_FREE(PyArray_DATA(self));
  }
  if (PyArray_BASE(self)) {
      if ((PyArray_FLAGS(self) & NPY_ARRAY_WRITEBACKIFCOPY0x2000) ||
          (PyArray_FLAGS(self) & NPY_ARRAY_UPDATEIFCOPY0x1000)) {
          PyArray_ENABLEFLAGS((PyArrayObject *)PyArray_BASE(self),
                                              NPY_ARRAY_WRITEABLE0x0400);
          PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEBACKIFCOPY0x2000);
          PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY0x1000);
      }
      Py_DECREF(PyArray_BASE(self))_Py_DECREF(((PyObject*)(PyArray_BASE(self))));
      ((PyArrayObject_fields *)self)->base = NULL((void*)0);
  }
  Py_INCREF(op)_Py_INCREF(((PyObject*)(op)));
  if (PyArray_SetBaseObject(self, op) < 0) {
      return -1;
  }
  ((PyArrayObject_fields *)self)->data = buf;
  ((PyArrayObject_fields *)self)->flags = NPY_ARRAY_CARRAY(0x0001 | (0x0100 | 0x0400));
  if (!writeable) {
      PyArray_CLEARFLAGS(self, ~NPY_ARRAY_WRITEABLE0x0400);
  }
  return 0;
410}


413static PyObject *
414array_itemsize_get(PyArrayObject *self)
415{
  return PyLong_FromLong((long) PyArray_DESCR(self)->elsize);
417}

419static PyObject *
420array_size_get(PyArrayObject *self)
421{
  npy_intp size=PyArray_SIZE(self)PyArray_MultiplyList(PyArray_DIMS(self), PyArray_NDIM(self));
423#if NPY_SIZEOF_INTP8 <= NPY_SIZEOF_LONG8
  return PyLong_FromLong((long) size);
425#else
  if (size > NPY_MAX_LONG9223372036854775807L || size < NPY_MIN_LONG(-9223372036854775807L -1L)) {
      return PyLong_FromLongLong(size);
  }
  else {
      return PyLong_FromLong((long) size);
  }
432#endif
433}

435static PyObject *
436array_nbytes_get(PyArrayObject *self)
437{
  npy_intp nbytes = PyArray_NBYTES(self)(PyArray_ITEMSIZE(self) * PyArray_MultiplyList(PyArray_DIMS(self
), PyArray_NDIM(self)));
439#if NPY_SIZEOF_INTP8 <= NPY_SIZEOF_LONG8
  return PyLong_FromLong((long) nbytes);
441#else
  if (nbytes > NPY_MAX_LONG9223372036854775807L || nbytes < NPY_MIN_LONG(-9223372036854775807L -1L)) {
      return PyLong_FromLongLong(nbytes);
  }
  else {
      return PyLong_FromLong((long) nbytes);
  }
448#endif
449}


452/*
* If the type is changed.
* Also needing change: strides, itemsize
*
* Either itemsize is exactly the same or the array is single-segment
* (contiguous or fortran) with compatible dimensions The shape and strides
* will be adjusted in that case as well.
*/
460static int
461array_descr_set(PyArrayObject *self, PyObject *arg)
462{
  PyArray_Descr *newtype = NULL((void*)0);

  if (arg == NULL((void*)0)) {
1
Assuming 'arg' is not equal to NULL→
2
←
Taking false branch→
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array dtype");
      return -1;
  }

  if (!(PyArray_DescrConverter(arg, &newtype)) ||
3
←
Calling 'PyArray_DescrConverter'→
      newtype == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
              "invalid data-type for array");
      return -1;
  }

  /* check that we are not reinterpreting memory containing Objects. */
  if (_may_have_objects(PyArray_DESCR(self)) || _may_have_objects(newtype)) {
      static PyObject *checkfunc = NULL((void*)0);
      PyObject *safe;

      npy_cache_import("numpy.core._internal", "_view_is_safe", &checkfunc);
      if (checkfunc == NULL((void*)0)) {
          goto fail;
      }

      safe = PyObject_CallFunction_PyObject_CallFunction_SizeT(checkfunc, "OO",
                                   PyArray_DESCR(self), newtype);
      if (safe == NULL((void*)0)) {
          goto fail;
      }
      Py_DECREF(safe)_Py_DECREF(((PyObject*)(safe)));
  }

  /*
   * Viewing as an unsized void implies a void dtype matching the size of the
   * current dtype.
   */
  if (newtype->type_num == NPY_VOID &&
          PyDataType_ISUNSIZED(newtype)((newtype)->elsize == 0 && !(((PyArray_Descr *)(newtype
))->names != ((void*)0))) &&
          newtype->elsize != PyArray_DESCR(self)->elsize) {
      PyArray_DESCR_REPLACE(newtype)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(newtype);
 _Py_XDECREF(((PyObject*)(newtype))); newtype = _new_; } while
(0);
      if (newtype == NULL((void*)0)) {
          return -1;
      }
      newtype->elsize = PyArray_DESCR(self)->elsize;
  }

  /* Changing the size of the dtype results in a shape change */
  if (newtype->elsize != PyArray_DESCR(self)->elsize) {
      int axis;
      npy_intp newdim;

      /* forbidden cases */
      if (PyArray_NDIM(self) == 0) {
          PyErr_SetString(PyExc_ValueError,
                  "Changing the dtype of a 0d array is only supported "
                  "if the itemsize is unchanged");
          goto fail;
      }
      else if (PyDataType_HASSUBARRAY(newtype)((newtype)->subarray != ((void*)0))) {
          PyErr_SetString(PyExc_ValueError,
                  "Changing the dtype to a subarray type is only supported "
                  "if the total itemsize is unchanged");
          goto fail;
      }

      /* determine which axis to resize */
      if (PyArray_IS_C_CONTIGUOUS(self)PyArray_CHKFLAGS((self), 0x0001)) {
          axis = PyArray_NDIM(self) - 1;
      }
      else if (PyArray_IS_F_CONTIGUOUS(self)PyArray_CHKFLAGS((self), 0x0002)) {
          /* 2015-11-27 1.11.0, gh-6747 */
          if (DEPRECATE(PyErr_WarnEx(PyExc_DeprecationWarning,"Changing the shape of an F-contiguous array by "
 "descriptor assignment is deprecated. To maintain the " "Fortran contiguity of a multidimensional Fortran "
 "array, use 'a.T.view(...).T' instead",1)
                      "Changing the shape of an F-contiguous array by "PyErr_WarnEx(PyExc_DeprecationWarning,"Changing the shape of an F-contiguous array by "
 "descriptor assignment is deprecated. To maintain the " "Fortran contiguity of a multidimensional Fortran "
 "array, use 'a.T.view(...).T' instead",1)
                      "descriptor assignment is deprecated. To maintain the "PyErr_WarnEx(PyExc_DeprecationWarning,"Changing the shape of an F-contiguous array by "
 "descriptor assignment is deprecated. To maintain the " "Fortran contiguity of a multidimensional Fortran "
 "array, use 'a.T.view(...).T' instead",1)
                      "Fortran contiguity of a multidimensional Fortran "PyErr_WarnEx(PyExc_DeprecationWarning,"Changing the shape of an F-contiguous array by "
 "descriptor assignment is deprecated. To maintain the " "Fortran contiguity of a multidimensional Fortran "
 "array, use 'a.T.view(...).T' instead",1)
                      "array, use 'a.T.view(...).T' instead")PyErr_WarnEx(PyExc_DeprecationWarning,"Changing the shape of an F-contiguous array by "
 "descriptor assignment is deprecated. To maintain the " "Fortran contiguity of a multidimensional Fortran "
 "array, use 'a.T.view(...).T' instead",1) < 0) {
              goto fail;
          }
          axis = 0;
      }
      else {
          /* Don't mention the deprecated F-contiguous support */
          PyErr_SetString(PyExc_ValueError,
                  "To change to a dtype of a different size, the array must "
                  "be C-contiguous");
          goto fail;
      }

      if (newtype->elsize < PyArray_DESCR(self)->elsize) {
          /* if it is compatible, increase the size of the relevant axis */
          if (newtype->elsize == 0 ||
                  PyArray_DESCR(self)->elsize % newtype->elsize != 0) {
              PyErr_SetString(PyExc_ValueError,
                      "When changing to a smaller dtype, its size must be a "
                      "divisor of the size of original dtype");
              goto fail;
          }
          newdim = PyArray_DESCR(self)->elsize / newtype->elsize;
          PyArray_DIMS(self)[axis] *= newdim;
          PyArray_STRIDES(self)[axis] = newtype->elsize;
      }
      else if (newtype->elsize > PyArray_DESCR(self)->elsize) {
          /* if it is compatible, decrease the size of the relevant axis */
          newdim = PyArray_DIMS(self)[axis] * PyArray_DESCR(self)->elsize;
          if ((newdim % newtype->elsize) != 0) {
              PyErr_SetString(PyExc_ValueError,
                      "When changing to a larger dtype, its size must be a "
                      "divisor of the total size in bytes of the last axis "
                      "of the array.");
              goto fail;
          }
          PyArray_DIMS(self)[axis] = newdim / newtype->elsize;
          PyArray_STRIDES(self)[axis] = newtype->elsize;
      }
  }

  /* Viewing as a subarray increases the number of dimensions */
  if (PyDataType_HASSUBARRAY(newtype)((newtype)->subarray != ((void*)0))) {
      /*
       * create new array object from data and update
       * dimensions, strides and descr from it
       */
      PyArrayObject *temp;
      /*
       * We would decref newtype here.
       * temp will steal a reference to it
       */
      temp = (PyArrayObject *)
          PyArray_NewFromDescr(&PyArray_Type, newtype, PyArray_NDIM(self),
                               PyArray_DIMS(self), PyArray_STRIDES(self),
                               PyArray_DATA(self), PyArray_FLAGS(self), NULL((void*)0));
      if (temp == NULL((void*)0)) {
          return -1;
      }
      npy_free_cache_dim_array(self);
      ((PyArrayObject_fields *)self)->dimensions = PyArray_DIMS(temp);
      ((PyArrayObject_fields *)self)->nd = PyArray_NDIM(temp);
      ((PyArrayObject_fields *)self)->strides = PyArray_STRIDES(temp);
      newtype = PyArray_DESCR(temp);
      Py_INCREF(PyArray_DESCR(temp))_Py_INCREF(((PyObject*)(PyArray_DESCR(temp))));
      /* Fool deallocator not to delete these*/
      ((PyArrayObject_fields *)temp)->nd = 0;
      ((PyArrayObject_fields *)temp)->dimensions = NULL((void*)0);
      Py_DECREF(temp)_Py_DECREF(((PyObject*)(temp)));
  }

  Py_DECREF(PyArray_DESCR(self))_Py_DECREF(((PyObject*)(PyArray_DESCR(self))));
  ((PyArrayObject_fields *)self)->descr = newtype;
  PyArray_UpdateFlags(self, NPY_ARRAY_UPDATE_ALL(0x0001 | 0x0002 | 0x0100));
  return 0;

fail:
  Py_DECREF(newtype)_Py_DECREF(((PyObject*)(newtype)));
  return -1;
618}

620static PyObject *
621array_struct_get(PyArrayObject *self)
622{
  PyArrayInterface *inter;

  inter = (PyArrayInterface *)PyArray_mallocPyMem_RawMalloc(sizeof(PyArrayInterface));
  if (inter==NULL((void*)0)) {
      return PyErr_NoMemory();
  }
  inter->two = 2;
  inter->nd = PyArray_NDIM(self);
  inter->typekind = PyArray_DESCR(self)->kind;
  inter->itemsize = PyArray_DESCR(self)->elsize;
  inter->flags = PyArray_FLAGS(self);
  if (inter->flags & NPY_ARRAY_WARN_ON_WRITE) {
      /* Export a warn-on-write array as read-only */
      inter->flags = inter->flags & ~NPY_ARRAY_WARN_ON_WRITE;
      inter->flags = inter->flags & ~NPY_ARRAY_WRITEABLE0x0400;
  }
  /* reset unused flags */
  inter->flags &= ~(NPY_ARRAY_WRITEBACKIFCOPY0x2000 | NPY_ARRAY_UPDATEIFCOPY0x1000 |NPY_ARRAY_OWNDATA0x0004);
  if (PyArray_ISNOTSWAPPED(self)((PyArray_DESCR(self)->byteorder) != '>')) inter->flags |= NPY_ARRAY_NOTSWAPPED0x0200;
  /*
   * Copy shape and strides over since these can be reset
   *when the array is "reshaped".
   */
  if (PyArray_NDIM(self) > 0) {
      inter->shape = (npy_intp *)PyArray_mallocPyMem_RawMalloc(2*sizeof(npy_intp)*PyArray_NDIM(self));
      if (inter->shape == NULL((void*)0)) {
          PyArray_freePyMem_RawFree(inter);
          return PyErr_NoMemory();
      }
      inter->strides = inter->shape + PyArray_NDIM(self);
      if (PyArray_NDIM(self)) {
          memcpy(inter->shape, PyArray_DIMS(self), sizeof(npy_intp)*PyArray_NDIM(self));
          memcpy(inter->strides, PyArray_STRIDES(self), sizeof(npy_intp)*PyArray_NDIM(self));
      }
  }
  else {
      inter->shape = NULL((void*)0);
      inter->strides = NULL((void*)0);
  }
  inter->data = PyArray_DATA(self);
  if (PyDataType_HASFIELDS(PyArray_DESCR(self))(((PyArray_Descr *)(PyArray_DESCR(self)))->names != ((void
*)0))) {
      inter->descr = arraydescr_protocol_descr_get(PyArray_DESCR(self));
      if (inter->descr == NULL((void*)0)) {
          PyErr_Clear();
      }
      else {
          inter->flags &= NPY_ARR_HAS_DESCR0x0800;
      }
  }
  else {
      inter->descr = NULL((void*)0);
  }
  PyObject *ret = PyCapsule_New(inter, NULL((void*)0), gentype_struct_free);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
  if (PyCapsule_SetContext(ret, self) < 0) {
      return NULL((void*)0);
  }
  return ret;
684}

686static PyObject *
687array_base_get(PyArrayObject *self)
688{
  if (PyArray_BASE(self) == NULL((void*)0)) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  else {
      Py_INCREF(PyArray_BASE(self))_Py_INCREF(((PyObject*)(PyArray_BASE(self))));
      return PyArray_BASE(self);
  }
696}

698/*
* Create a view of a complex array with an equivalent data-type
* except it is real instead of complex.
*/
702static PyArrayObject *
703_get_part(PyArrayObject *self, int imag)
704{
  int float_type_num;
  PyArray_Descr *type;
  PyArrayObject *ret;
  int offset;

  switch (PyArray_DESCR(self)->type_num) {
      case NPY_CFLOAT:
          float_type_num = NPY_FLOAT;
          break;
      case NPY_CDOUBLE:
          float_type_num = NPY_DOUBLE;
          break;
      case NPY_CLONGDOUBLE:
          float_type_num = NPY_LONGDOUBLE;
          break;
      default:
          PyErr_Format(PyExc_ValueError,
                   "Cannot convert complex type number %d to float",
                   PyArray_DESCR(self)->type_num);
          return NULL((void*)0);

  }
  type = PyArray_DescrFromType(float_type_num);

  offset = (imag ? type->elsize : 0);

  if (!PyArray_ISNBO(PyArray_DESCR(self)->byteorder)((PyArray_DESCR(self)->byteorder) != '>')) {
      PyArray_Descr *new;
      new = PyArray_DescrNew(type);
      new->byteorder = PyArray_DESCR(self)->byteorder;
      Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
      type = new;
  }
  ret = (PyArrayObject *)PyArray_NewFromDescrAndBase(
          Py_TYPE(self)(((PyObject*)(self))->ob_type),
          type,
          PyArray_NDIM(self),
          PyArray_DIMS(self),
          PyArray_STRIDES(self),
          PyArray_BYTES(self) + offset,
          PyArray_FLAGS(self), (PyObject *)self, (PyObject *)self);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  return ret;
750}

752/* For Object arrays, we need to get and set the
 real part of each element.
*/

756static PyObject *
757array_real_get(PyArrayObject *self)
758{
  PyArrayObject *ret;

  if (PyArray_ISCOMPLEX(self)(((PyArray_TYPE(self)) >= NPY_CFLOAT) && ((PyArray_TYPE
(self)) <= NPY_CLONGDOUBLE))) {
      ret = _get_part(self, 0);
      return (PyObject *)ret;
  }
  else {
      Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
      return (PyObject *)self;
  }
769}


772static int
773array_real_set(PyArrayObject *self, PyObject *val)
774{
  PyArrayObject *ret;
  PyArrayObject *new;
  int retcode;

  if (val == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array real part");
      return -1;
  }
  if (PyArray_ISCOMPLEX(self)(((PyArray_TYPE(self)) >= NPY_CFLOAT) && ((PyArray_TYPE
(self)) <= NPY_CLONGDOUBLE))) {
      ret = _get_part(self, 0);
      if (ret == NULL((void*)0)) {
          return -1;
      }
  }
  else {
      Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
      ret = self;
  }
  new = (PyArrayObject *)PyArray_FROM_O(val)PyArray_FromAny(val, ((void*)0), 0, 0, 0, ((void*)0));
  if (new == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return -1;
  }
  retcode = PyArray_MoveInto(ret, new);
  Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
  Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
  return retcode;
803}

805/* For Object arrays we need to get
 and set the imaginary part of
 each element
808*/

810static PyObject *
811array_imag_get(PyArrayObject *self)
812{
  PyArrayObject *ret;

  if (PyArray_ISCOMPLEX(self)(((PyArray_TYPE(self)) >= NPY_CFLOAT) && ((PyArray_TYPE
(self)) <= NPY_CLONGDOUBLE))) {
      ret = _get_part(self, 1);
  }
  else {
      Py_INCREF(PyArray_DESCR(self))_Py_INCREF(((PyObject*)(PyArray_DESCR(self))));
      ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self)(((PyObject*)(self))->ob_type),
                                                  PyArray_DESCR(self),
                                                  PyArray_NDIM(self),
                                                  PyArray_DIMS(self),
                                                  NULL((void*)0), NULL((void*)0),
                                                  PyArray_ISFORTRAN(self)(PyArray_CHKFLAGS(self, 0x0002) && (!PyArray_CHKFLAGS
(self, 0x0001))),
                                                  (PyObject *)self);
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
      if (_zerofill(ret) < 0) {
          return NULL((void*)0);
      }
      PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEABLE0x0400);
  }
  return (PyObject *) ret;
836}

838static int
839array_imag_set(PyArrayObject *self, PyObject *val)
840{
  if (val == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array imaginary part");
      return -1;
  }
  if (PyArray_ISCOMPLEX(self)(((PyArray_TYPE(self)) >= NPY_CFLOAT) && ((PyArray_TYPE
(self)) <= NPY_CLONGDOUBLE))) {
      PyArrayObject *ret;
      PyArrayObject *new;
      int retcode;

      ret = _get_part(self, 1);
      if (ret == NULL((void*)0)) {
          return -1;
      }
      new = (PyArrayObject *)PyArray_FROM_O(val)PyArray_FromAny(val, ((void*)0), 0, 0, 0, ((void*)0));
      if (new == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return -1;
      }
      retcode = PyArray_MoveInto(ret, new);
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return retcode;
  }
  else {
      PyErr_SetString(PyExc_TypeError,
              "array does not have imaginary part to set");
      return -1;
  }
870}

872static PyObject *
873array_flat_get(PyArrayObject *self)
874{
  return PyArray_IterNew((PyObject *)self);
876}

878static int
879array_flat_set(PyArrayObject *self, PyObject *val)
880{
  PyArrayObject *arr = NULL((void*)0);
  int retval = -1;
  PyArrayIterObject *selfit = NULL((void*)0), *arrit = NULL((void*)0);
  PyArray_Descr *typecode;
  int swap;
  PyArray_CopySwapFunc *copyswap;

  if (val == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete array flat iterator");
      return -1;
  }
  if (PyArray_FailUnlessWriteable(self, "array") < 0) return -1;
  typecode = PyArray_DESCR(self);
  Py_INCREF(typecode)_Py_INCREF(((PyObject*)(typecode)));
  arr = (PyArrayObject *)PyArray_FromAny(val, typecode,
                0, 0, NPY_ARRAY_FORCECAST0x0010 | PyArray_FORTRAN_IF(self)((PyArray_CHKFLAGS(self, 0x0002) ? 0x0002 : 0)), NULL((void*)0));
  if (arr == NULL((void*)0)) {
      return -1;
  }
  arrit = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr);
  if (arrit == NULL((void*)0)) {
      goto exit;
  }
  selfit = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
  if (selfit == NULL((void*)0)) {
      goto exit;
  }
  if (arrit->size == 0) {
      retval = 0;
      goto exit;
  }
  swap = PyArray_ISNOTSWAPPED(self)((PyArray_DESCR(self)->byteorder) != '>') != PyArray_ISNOTSWAPPED(arr)((PyArray_DESCR(arr)->byteorder) != '>');
  copyswap = PyArray_DESCR(self)->f->copyswap;
  if (PyDataType_REFCHK(PyArray_DESCR(self))(((PyArray_DESCR(self))->flags & (0x01)) == (0x01))) {
      while (selfit->index < selfit->size) {
          PyArray_Item_XDECREF(selfit->dataptr, PyArray_DESCR(self));
          PyArray_Item_INCREF(arrit->dataptr, PyArray_DESCR(arr));
          memmove(selfit->dataptr, arrit->dataptr, sizeof(PyObject **));
          if (swap) {
              copyswap(selfit->dataptr, NULL((void*)0), swap, self);
          }
          PyArray_ITER_NEXT(selfit)do { ((PyArrayIterObject *)(selfit))->index++; if (((PyArrayIterObject
 *)(selfit))->nd_m1 == 0) { do { (((PyArrayIterObject *)(selfit
)))->dataptr += ((PyArrayIterObject *)(((PyArrayIterObject
 *)(selfit))))->strides[0]; (((PyArrayIterObject *)(selfit
)))->coordinates[0]++; } while (0); } else if (((PyArrayIterObject
 *)(selfit))->contiguous) ((PyArrayIterObject *)(selfit))->
dataptr += PyArray_DESCR(((PyArrayIterObject *)(selfit))->
ao)->elsize; else if (((PyArrayIterObject *)(selfit))->
nd_m1 == 1) { do { if ((((PyArrayIterObject *)(selfit)))->
coordinates[1] < (((PyArrayIterObject *)(selfit)))->dims_m1
[1]) { (((PyArrayIterObject *)(selfit)))->coordinates[1]++
; (((PyArrayIterObject *)(selfit)))->dataptr += (((PyArrayIterObject
 *)(selfit)))->strides[1]; } else { (((PyArrayIterObject *
)(selfit)))->coordinates[1] = 0; (((PyArrayIterObject *)(selfit
)))->coordinates[0]++; (((PyArrayIterObject *)(selfit)))->
dataptr += (((PyArrayIterObject *)(selfit)))->strides[0] -
 (((PyArrayIterObject *)(selfit)))->backstrides[1]; } } while
 (0); } else { int __npy_i; for (__npy_i=((PyArrayIterObject *
)(selfit))->nd_m1; __npy_i >= 0; __npy_i--) { if (((PyArrayIterObject
 *)(selfit))->coordinates[__npy_i] < ((PyArrayIterObject
 *)(selfit))->dims_m1[__npy_i]) { ((PyArrayIterObject *)(selfit
))->coordinates[__npy_i]++; ((PyArrayIterObject *)(selfit)
)->dataptr += ((PyArrayIterObject *)(selfit))->strides[
__npy_i]; break; } else { ((PyArrayIterObject *)(selfit))->
coordinates[__npy_i] = 0; ((PyArrayIterObject *)(selfit))->
dataptr -= ((PyArrayIterObject *)(selfit))->backstrides[__npy_i
]; } } } } while (0);
          PyArray_ITER_NEXT(arrit)do { ((PyArrayIterObject *)(arrit))->index++; if (((PyArrayIterObject
 *)(arrit))->nd_m1 == 0) { do { (((PyArrayIterObject *)(arrit
)))->dataptr += ((PyArrayIterObject *)(((PyArrayIterObject
 *)(arrit))))->strides[0]; (((PyArrayIterObject *)(arrit))
)->coordinates[0]++; } while (0); } else if (((PyArrayIterObject
 *)(arrit))->contiguous) ((PyArrayIterObject *)(arrit))->
dataptr += PyArray_DESCR(((PyArrayIterObject *)(arrit))->ao
)->elsize; else if (((PyArrayIterObject *)(arrit))->nd_m1
 == 1) { do { if ((((PyArrayIterObject *)(arrit)))->coordinates
[1] < (((PyArrayIterObject *)(arrit)))->dims_m1[1]) { (
((PyArrayIterObject *)(arrit)))->coordinates[1]++; (((PyArrayIterObject
 *)(arrit)))->dataptr += (((PyArrayIterObject *)(arrit)))->
strides[1]; } else { (((PyArrayIterObject *)(arrit)))->coordinates
[1] = 0; (((PyArrayIterObject *)(arrit)))->coordinates[0]++
; (((PyArrayIterObject *)(arrit)))->dataptr += (((PyArrayIterObject
 *)(arrit)))->strides[0] - (((PyArrayIterObject *)(arrit))
)->backstrides[1]; } } while (0); } else { int __npy_i; for
 (__npy_i=((PyArrayIterObject *)(arrit))->nd_m1; __npy_i >=
 0; __npy_i--) { if (((PyArrayIterObject *)(arrit))->coordinates
[__npy_i] < ((PyArrayIterObject *)(arrit))->dims_m1[__npy_i
]) { ((PyArrayIterObject *)(arrit))->coordinates[__npy_i]++
; ((PyArrayIterObject *)(arrit))->dataptr += ((PyArrayIterObject
 *)(arrit))->strides[__npy_i]; break; } else { ((PyArrayIterObject
 *)(arrit))->coordinates[__npy_i] = 0; ((PyArrayIterObject
 *)(arrit))->dataptr -= ((PyArrayIterObject *)(arrit))->
backstrides[__npy_i]; } } } } while (0);
          if (arrit->index == arrit->size) {
              PyArray_ITER_RESET(arrit)do { ((PyArrayIterObject *)(arrit))->index = 0; ((PyArrayIterObject
 *)(arrit))->dataptr = PyArray_BYTES(((PyArrayIterObject *
)(arrit))->ao); memset(((PyArrayIterObject *)(arrit))->
coordinates, 0, (((PyArrayIterObject *)(arrit))->nd_m1+1)*
sizeof(npy_intp)); } while (0);
          }
      }
      retval = 0;
      goto exit;
  }

  while(selfit->index < selfit->size) {
      copyswap(selfit->dataptr, arrit->dataptr, swap, self);
      PyArray_ITER_NEXT(selfit)do { ((PyArrayIterObject *)(selfit))->index++; if (((PyArrayIterObject
 *)(selfit))->nd_m1 == 0) { do { (((PyArrayIterObject *)(selfit
)))->dataptr += ((PyArrayIterObject *)(((PyArrayIterObject
 *)(selfit))))->strides[0]; (((PyArrayIterObject *)(selfit
)))->coordinates[0]++; } while (0); } else if (((PyArrayIterObject
 *)(selfit))->contiguous) ((PyArrayIterObject *)(selfit))->
dataptr += PyArray_DESCR(((PyArrayIterObject *)(selfit))->
ao)->elsize; else if (((PyArrayIterObject *)(selfit))->
nd_m1 == 1) { do { if ((((PyArrayIterObject *)(selfit)))->
coordinates[1] < (((PyArrayIterObject *)(selfit)))->dims_m1
[1]) { (((PyArrayIterObject *)(selfit)))->coordinates[1]++
; (((PyArrayIterObject *)(selfit)))->dataptr += (((PyArrayIterObject
 *)(selfit)))->strides[1]; } else { (((PyArrayIterObject *
)(selfit)))->coordinates[1] = 0; (((PyArrayIterObject *)(selfit
)))->coordinates[0]++; (((PyArrayIterObject *)(selfit)))->
dataptr += (((PyArrayIterObject *)(selfit)))->strides[0] -
 (((PyArrayIterObject *)(selfit)))->backstrides[1]; } } while
 (0); } else { int __npy_i; for (__npy_i=((PyArrayIterObject *
)(selfit))->nd_m1; __npy_i >= 0; __npy_i--) { if (((PyArrayIterObject
 *)(selfit))->coordinates[__npy_i] < ((PyArrayIterObject
 *)(selfit))->dims_m1[__npy_i]) { ((PyArrayIterObject *)(selfit
))->coordinates[__npy_i]++; ((PyArrayIterObject *)(selfit)
)->dataptr += ((PyArrayIterObject *)(selfit))->strides[
__npy_i]; break; } else { ((PyArrayIterObject *)(selfit))->
coordinates[__npy_i] = 0; ((PyArrayIterObject *)(selfit))->
dataptr -= ((PyArrayIterObject *)(selfit))->backstrides[__npy_i
]; } } } } while (0);
      PyArray_ITER_NEXT(arrit)do { ((PyArrayIterObject *)(arrit))->index++; if (((PyArrayIterObject
 *)(arrit))->nd_m1 == 0) { do { (((PyArrayIterObject *)(arrit
)))->dataptr += ((PyArrayIterObject *)(((PyArrayIterObject
 *)(arrit))))->strides[0]; (((PyArrayIterObject *)(arrit))
)->coordinates[0]++; } while (0); } else if (((PyArrayIterObject
 *)(arrit))->contiguous) ((PyArrayIterObject *)(arrit))->
dataptr += PyArray_DESCR(((PyArrayIterObject *)(arrit))->ao
)->elsize; else if (((PyArrayIterObject *)(arrit))->nd_m1
 == 1) { do { if ((((PyArrayIterObject *)(arrit)))->coordinates
[1] < (((PyArrayIterObject *)(arrit)))->dims_m1[1]) { (
((PyArrayIterObject *)(arrit)))->coordinates[1]++; (((PyArrayIterObject
 *)(arrit)))->dataptr += (((PyArrayIterObject *)(arrit)))->
strides[1]; } else { (((PyArrayIterObject *)(arrit)))->coordinates
[1] = 0; (((PyArrayIterObject *)(arrit)))->coordinates[0]++
; (((PyArrayIterObject *)(arrit)))->dataptr += (((PyArrayIterObject
 *)(arrit)))->strides[0] - (((PyArrayIterObject *)(arrit))
)->backstrides[1]; } } while (0); } else { int __npy_i; for
 (__npy_i=((PyArrayIterObject *)(arrit))->nd_m1; __npy_i >=
 0; __npy_i--) { if (((PyArrayIterObject *)(arrit))->coordinates
[__npy_i] < ((PyArrayIterObject *)(arrit))->dims_m1[__npy_i
]) { ((PyArrayIterObject *)(arrit))->coordinates[__npy_i]++
; ((PyArrayIterObject *)(arrit))->dataptr += ((PyArrayIterObject
 *)(arrit))->strides[__npy_i]; break; } else { ((PyArrayIterObject
 *)(arrit))->coordinates[__npy_i] = 0; ((PyArrayIterObject
 *)(arrit))->dataptr -= ((PyArrayIterObject *)(arrit))->
backstrides[__npy_i]; } } } } while (0);
      if (arrit->index == arrit->size) {
          PyArray_ITER_RESET(arrit)do { ((PyArrayIterObject *)(arrit))->index = 0; ((PyArrayIterObject
 *)(arrit))->dataptr = PyArray_BYTES(((PyArrayIterObject *
)(arrit))->ao); memset(((PyArrayIterObject *)(arrit))->
coordinates, 0, (((PyArrayIterObject *)(arrit))->nd_m1+1)*
sizeof(npy_intp)); } while (0);
      }
  }
  retval = 0;

exit:
  Py_XDECREF(selfit)_Py_XDECREF(((PyObject*)(selfit)));
  Py_XDECREF(arrit)_Py_XDECREF(((PyObject*)(arrit)));
  Py_XDECREF(arr)_Py_XDECREF(((PyObject*)(arr)));
  return retval;
948}

950static PyObject *
951array_transpose_get(PyArrayObject *self)
952{
  return PyArray_Transpose(self, NULL((void*)0));
954}

956/* If this is None, no function call is made
 --- default sub-class behavior
958*/
959static PyObject *
960array_finalize_get(PyArrayObject *NPY_UNUSED(self)(__NPY_UNUSED_TAGGEDself) __attribute__ ((__unused__)))
961{
  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
963}

965NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyGetSetDef array_getsetlist[] = {
  {"ndim",
      (getter)array_ndim_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"flags",
      (getter)array_flags_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"shape",
      (getter)array_shape_get,
      (setter)array_shape_set,
      NULL((void*)0), NULL((void*)0)},
  {"strides",
      (getter)array_strides_get,
      (setter)array_strides_set,
      NULL((void*)0), NULL((void*)0)},
  {"data",
      (getter)array_data_get,
      (setter)array_data_set,
      NULL((void*)0), NULL((void*)0)},
  {"itemsize",
      (getter)array_itemsize_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"size",
      (getter)array_size_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"nbytes",
      (getter)array_nbytes_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"base",
      (getter)array_base_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"dtype",
      (getter)array_descr_get,
      (setter)array_descr_set,
      NULL((void*)0), NULL((void*)0)},
  {"real",
      (getter)array_real_get,
      (setter)array_real_set,
      NULL((void*)0), NULL((void*)0)},
  {"imag",
      (getter)array_imag_get,
      (setter)array_imag_set,
      NULL((void*)0), NULL((void*)0)},
  {"flat",
      (getter)array_flat_get,
      (setter)array_flat_set,
      NULL((void*)0), NULL((void*)0)},
  {"ctypes",
      (getter)array_ctypes_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"T",
      (getter)array_transpose_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"__array_interface__",
      (getter)array_interface_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"__array_struct__",
      (getter)array_struct_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"__array_priority__",
      (getter)array_priority_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {"__array_finalize__",
      (getter)array_finalize_get,
      NULL((void*)0),
      NULL((void*)0), NULL((void*)0)},
  {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)},  /* Sentinel */
1043};

1045/****************** end of attribute get and set routines *******************/

←

/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c

→

1/* Array Descr Object */

3#define PY_SSIZE_T_CLEAN
4#include <Python.h>
5#include "structmember.h"

7#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E
8#define _MULTIARRAYMODULE
9#include "numpy/arrayobject.h"
10#include "numpy/arrayscalars.h"

12#include "npy_config.h"
13#include "npy_ctypes.h"
14#include "npy_pycompat.h"

16#include "_datetime.h"
17#include "common.h"
18#include "templ_common.h" /* for npy_mul_with_overflow_intp */
19#include "descriptor.h"
20#include "alloc.h"
21#include "assert.h"
22#include "npy_buffer.h"

24/*
* offset:    A starting offset.
* alignment: A power-of-two alignment.
*
* This macro returns the smallest value >= 'offset'
* that is divisible by 'alignment'. Because 'alignment'
* is a power of two and integers are twos-complement,
* it is possible to use some simple bit-fiddling to do this.
*/
33#define NPY_NEXT_ALIGNED_OFFSET(offset, alignment) \
              (((offset) + (alignment) - 1) & (-(alignment)))

36#ifndef PyDictProxy_Check
37#define PyDictProxy_Check(obj) (Py_TYPE(obj)(((PyObject*)(obj))->ob_type) == &PyDictProxy_Type)
38#endif

40static PyObject *typeDict = NULL((void*)0);   /* Must be explicitly loaded */

42static PyArray_Descr *
43_try_convert_from_inherit_tuple(PyArray_Descr *type, PyObject *newobj);

45static PyArray_Descr *
46_convert_from_any(PyObject *obj, int align);

48/*
* This function creates a dtype object when the object is a ctypes subclass.
*
* Returns `Py_NotImplemented` if the type is not a ctypes subclass.
*/
53static PyArray_Descr *
54_try_convert_from_ctypes_type(PyTypeObject *type)
55{
  PyObject *_numpy_dtype_ctypes;
  PyObject *res;

  if (!npy_ctypes_check(type)) {
      Py_INCREF(Py_NotImplemented)_Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct))));
      return (PyArray_Descr *)Py_NotImplemented(&_Py_NotImplementedStruct);
  }

  /* Call the python function of the same name. */
  _numpy_dtype_ctypes = PyImport_ImportModule("numpy.core._dtype_ctypes");
  if (_numpy_dtype_ctypes == NULL((void*)0)) {
      return NULL((void*)0);
  }
  res = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_dtype_ctypes, "dtype_from_ctypes_type", "O", (PyObject *)type);
  Py_DECREF(_numpy_dtype_ctypes)_Py_DECREF(((PyObject*)(_numpy_dtype_ctypes)));
  if (res == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /*
   * sanity check that dtype_from_ctypes_type returned the right type,
   * since getting it wrong would give segfaults.
   */
  if (!PyObject_TypeCheck(res, &PyArrayDescr_Type)((((PyObject*)(res))->ob_type) == (&(*(PyTypeObject *)
(&PyArrayDescr_TypeFull))) || PyType_IsSubtype((((PyObject
*)(res))->ob_type), (&(*(PyTypeObject *)(&PyArrayDescr_TypeFull
)))))) {
      Py_DECREF(res)_Py_DECREF(((PyObject*)(res)));
      PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 81);
      return NULL((void*)0);
  }

  return (PyArray_Descr *)res;
86}

88static PyArray_Descr *
89_convert_from_any(PyObject *obj, int align);

91/*
* This function creates a dtype object when the object has a "dtype" attribute,
* and it can be converted to a dtype object.
*
* Returns `Py_NotImplemented` if this is not possible.
* Currently the only failure mode for a NULL return is a RecursionError.
*/
98static PyArray_Descr *
99_try_convert_from_dtype_attr(PyObject *obj)
100{
  /* For arbitrary objects that have a "dtype" attribute */
  PyObject *dtypedescr = PyObject_GetAttrString(obj, "dtype");
  if (dtypedescr == NULL((void*)0)) {
      /*
       * This can be reached due to recursion limit being hit while fetching
       * the attribute (tested for py3.7). This removes the custom message.
       */
      goto fail;
  }

  if (PyArray_DescrCheck(dtypedescr)((((PyObject*)(dtypedescr))->ob_type) == (&(*(PyTypeObject
 *)(&PyArrayDescr_TypeFull))) || PyType_IsSubtype((((PyObject
*)(dtypedescr))->ob_type), (&(*(PyTypeObject *)(&PyArrayDescr_TypeFull
)))))) {
      /* The dtype attribute is already a valid descriptor */
      return (PyArray_Descr *)dtypedescr;
  }

  if (Py_EnterRecursiveCall(((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from its "
 "`.dtype` attribute."))
          " while trying to convert the given data type from its "((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from its "
 "`.dtype` attribute."))
          "`.dtype` attribute.")((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from its "
 "`.dtype` attribute.")) != 0) {
      Py_DECREF(dtypedescr)_Py_DECREF(((PyObject*)(dtypedescr)));
      return NULL((void*)0);
  }

  PyArray_Descr *newdescr = _convert_from_any(dtypedescr, 0);
  Py_DECREF(dtypedescr)_Py_DECREF(((PyObject*)(dtypedescr)));
  Py_LeaveRecursiveCall()do{ if((--(PyThreadState_Get()->recursion_depth) < (((_Py_CheckRecursionLimit
) > 200) ? ((_Py_CheckRecursionLimit) - 50) : (3 * ((_Py_CheckRecursionLimit
) >> 2))))) PyThreadState_Get()->overflowed = 0; } while
(0);
  if (newdescr == NULL((void*)0)) {
      goto fail;
  }

  /* Deprecated 2021-01-05, NumPy 1.21 */
  if (DEPRECATE("in the future the `.dtype` attribute of a given data"PyErr_WarnEx(PyExc_DeprecationWarning,"in the future the `.dtype` attribute of a given data"
 "type object must be a valid dtype instance. " "`data_type.dtype` may need to be coerced using "
 "`np.dtype(data_type.dtype)`. (Deprecated NumPy 1.20)",1)
                "type object must be a valid dtype instance. "PyErr_WarnEx(PyExc_DeprecationWarning,"in the future the `.dtype` attribute of a given data"
 "type object must be a valid dtype instance. " "`data_type.dtype` may need to be coerced using "
 "`np.dtype(data_type.dtype)`. (Deprecated NumPy 1.20)",1)
                "`data_type.dtype` may need to be coerced using "PyErr_WarnEx(PyExc_DeprecationWarning,"in the future the `.dtype` attribute of a given data"
 "type object must be a valid dtype instance. " "`data_type.dtype` may need to be coerced using "
 "`np.dtype(data_type.dtype)`. (Deprecated NumPy 1.20)",1)
                "`np.dtype(data_type.dtype)`. (Deprecated NumPy 1.20)")PyErr_WarnEx(PyExc_DeprecationWarning,"in the future the `.dtype` attribute of a given data"
 "type object must be a valid dtype instance. " "`data_type.dtype` may need to be coerced using "
 "`np.dtype(data_type.dtype)`. (Deprecated NumPy 1.20)",1) < 0) {
      Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
      return NULL((void*)0);
  }

  return newdescr;

fail:
  /* Ignore all but recursion errors, to give ctypes a full try. */
  if (!PyErr_ExceptionMatches(PyExc_RecursionError)) {
      PyErr_Clear();
      Py_INCREF(Py_NotImplemented)_Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct))));
      return (PyArray_Descr *)Py_NotImplemented(&_Py_NotImplementedStruct);
  }
  return NULL((void*)0);
149}

151/* Expose to another file with a prefixed name */
152NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
153_arraydescr_try_convert_from_dtype_attr(PyObject *obj)
154{
  return _try_convert_from_dtype_attr(obj);
156}

158/*
* Sets the global typeDict object, which is a dictionary mapping
* dtype names to numpy scalar types.
*/
162NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
163array_set_typeDict(PyObject *NPY_UNUSED(ignored)(__NPY_UNUSED_TAGGEDignored) __attribute__ ((__unused__)), PyObject *args)
164{
  PyObject *dict;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O:set_typeDict", &dict)) {
      return NULL((void*)0);
  }
  /* Decrement old reference (if any)*/
  Py_XDECREF(typeDict)_Py_XDECREF(((PyObject*)(typeDict)));
  typeDict = dict;
  /* Create an internal reference to it */
  Py_INCREF(dict)_Py_INCREF(((PyObject*)(dict)));
  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
176}

178#define _chk_byteorder(arg) (arg == '>' || arg == '<' ||        \
                           arg == '|' || arg == '=')

181static int
182_check_for_commastring(const char *type, Py_ssize_t len)
183{
  Py_ssize_t i;
  int sqbracket;

  /* Check for ints at start of string */
  if ((type[0] >= '0'
              && type[0] <= '9')
          || ((len > 1)
              && _chk_byteorder(type[0])
              && (type[1] >= '0'
              && type[1] <= '9'))) {
      return 1;
  }
  /* Check for empty tuple */
  if (((len > 1)
              && (type[0] == '('
              && type[1] == ')'))
          || ((len > 3)
              && _chk_byteorder(type[0])
              && (type[1] == '('
              && type[2] == ')'))) {
      return 1;
  }
  /*
   * Check for presence of commas outside square [] brackets. This
   * allows commas inside of [], for parameterized dtypes to use.
   */
  sqbracket = 0;
  for (i = 0; i < len; i++) {
      switch (type[i]) {
          case ',':
              if (sqbracket == 0) {
                  return 1;
              }
              break;
          case '[':
              ++sqbracket;
              break;
          case ']':
              --sqbracket;
              break;
      }
  }
  return 0;
227}

229#undef _chk_byteorder

231static int
232is_datetime_typestr(char const *type, Py_ssize_t len)
233{
  if (len < 2) {
      return 0;
  }
  if (type[1] == '8' && (type[0] == 'M' || type[0] == 'm')) {
      return 1;
  }
  if (len < 10) {
      return 0;
  }
  if (strncmp(type, "datetime64", 10) == 0) {
      return 1;
  }
  if (len < 11) {
      return 0;
  }
  if (strncmp(type, "timedelta64", 11) == 0) {
      return 1;
  }
  return 0;
253}

255static PyArray_Descr *
256_convert_from_tuple(PyObject *obj, int align)
257{
  if (PyTuple_GET_SIZE(obj)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(obj))))->
ob_size) != 2) {
      PyErr_Format(PyExc_TypeError, 
       "Tuple must have size 2, but has size %zd",
       PyTuple_GET_SIZE(obj)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(obj))))->
ob_size));
      return NULL((void*)0);
  }
  PyArray_Descr *type = _convert_from_any(PyTuple_GET_ITEM(obj, 0)((((void) (0)), (PyTupleObject *)(obj))->ob_item[0]), align);
  if (type == NULL((void*)0)) {
      return NULL((void*)0);
  }
  PyObject *val = PyTuple_GET_ITEM(obj,1)((((void) (0)), (PyTupleObject *)(obj))->ob_item[1]);
  /* try to interpret next item as a type */
  PyArray_Descr *res = _try_convert_from_inherit_tuple(type, val);
  if ((PyObject *)res != Py_NotImplemented(&_Py_NotImplementedStruct)) {
      Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
      return res;
  }
  Py_DECREF(res)_Py_DECREF(((PyObject*)(res)));
  /*
   * We get here if _try_convert_from_inherit_tuple failed without crashing
   */
  if (PyDataType_ISUNSIZED(type)((type)->elsize == 0 && !(((PyArray_Descr *)(type)
)->names != ((void*)0)))) {
      /* interpret next item as a typesize */
      int itemsize = PyArray_PyIntAsInt(PyTuple_GET_ITEM(obj,1)((((void) (0)), (PyTupleObject *)(obj))->ob_item[1]));

      if (error_converting(itemsize)(((itemsize) == -1) && PyErr_Occurred())) {
          PyErr_SetString(PyExc_ValueError,
                  "invalid itemsize in generic type tuple");
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
      PyArray_DESCR_REPLACE(type)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(type); _Py_XDECREF
(((PyObject*)(type))); type = _new_; } while(0);
      if (type == NULL((void*)0)) {
          return NULL((void*)0);
      }
      if (type->type_num == NPY_UNICODE) {
          type->elsize = itemsize << 2;
      }
      else {
          type->elsize = itemsize;
      }
      return type;
  }
  else if (type->metadata && (PyDict_Check(val)((((((PyObject*)(val))->ob_type))->tp_flags & ((1UL
 << 29))) != 0) || PyDictProxy_Check(val))) {
      /* Assume it's a metadata dictionary */
      if (PyDict_Merge(type->metadata, val, 0) == -1) {
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
      return type;
  }
  else {
      /*
       * interpret next item as shape (if it's a tuple)
       * and reset the type to NPY_VOID with
       * a new fields attribute.
       */
      PyArray_Dims shape = {NULL((void*)0), -1};
      if (!(PyArray_IntpConverter(val, &shape)) || (shape.len > NPY_MAXDIMS32)) {
          PyErr_SetString(PyExc_ValueError,
                  "invalid shape in fixed-type tuple.");
          goto fail;
      }
      /* if (type, ()) was given it is equivalent to type... */
      if (shape.len == 0 && PyTuple_Check(val)((((((PyObject*)(val))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
          npy_free_cache_dim_obj(shape);
          return type;
      }
      /* (type, 1) use to be equivalent to type, but is deprecated */
      if (shape.len == 1
              && shape.ptr[0] == 1
              && PyNumber_Check(val)) {
          /* 2019-05-20, 1.17 */
          if (DEPRECATE_FUTUREWARNING(PyErr_WarnEx(PyExc_FutureWarning,"Passing (type, 1) or '1type' as a synonym of type is "
 "deprecated; in a future version of numpy, it will be " "understood as (type, (1,)) / '(1,)type'."
,1)
                      "Passing (type, 1) or '1type' as a synonym of type is "PyErr_WarnEx(PyExc_FutureWarning,"Passing (type, 1) or '1type' as a synonym of type is "
 "deprecated; in a future version of numpy, it will be " "understood as (type, (1,)) / '(1,)type'."
,1)
                      "deprecated; in a future version of numpy, it will be "PyErr_WarnEx(PyExc_FutureWarning,"Passing (type, 1) or '1type' as a synonym of type is "
 "deprecated; in a future version of numpy, it will be " "understood as (type, (1,)) / '(1,)type'."
,1)
                      "understood as (type, (1,)) / '(1,)type'.")PyErr_WarnEx(PyExc_FutureWarning,"Passing (type, 1) or '1type' as a synonym of type is "
 "deprecated; in a future version of numpy, it will be " "understood as (type, (1,)) / '(1,)type'."
,1) < 0) {
              goto fail;
          }
          npy_free_cache_dim_obj(shape);
          return type;
      }

      /* validate and set shape */
      for (int i=0; i < shape.len; i++) {
          if (shape.ptr[i] < 0) {
              PyErr_SetString(PyExc_ValueError,
                              "invalid shape in fixed-type tuple: "
                              "dimension smaller then zero.");
              goto fail;
          }
          if (shape.ptr[i] > NPY_MAX_INT2147483647) {
              PyErr_SetString(PyExc_ValueError,
                              "invalid shape in fixed-type tuple: "
                              "dimension does not fit into a C int.");
              goto fail;
          }
      }
      npy_intp items = PyArray_OverflowMultiplyList(shape.ptr, shape.len);
      int overflowed;
      int nbytes;
      if (items < 0 || items > NPY_MAX_INT2147483647) {
          overflowed = 1;
      }
      else {
          overflowed = npy_mul_with_overflow_int(
              &nbytes, type->elsize, (int) items);
      }
      if (overflowed) {
          PyErr_SetString(PyExc_ValueError,
                          "invalid shape in fixed-type tuple: dtype size in "
                          "bytes must fit into a C int.");
          goto fail;
      }
      PyArray_Descr *newdescr = PyArray_DescrNewFromType(NPY_VOID);
      if (newdescr == NULL((void*)0)) {
          goto fail;
      }
      newdescr->elsize = nbytes;
      newdescr->subarray = PyArray_mallocPyMem_RawMalloc(sizeof(PyArray_ArrayDescr));
      if (newdescr->subarray == NULL((void*)0)) {
          Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
          PyErr_NoMemory();
          goto fail;
      }
      newdescr->flags = type->flags;
      newdescr->alignment = type->alignment;
      newdescr->subarray->base = type;
      type = NULL((void*)0);
      Py_XDECREF(newdescr->fields)_Py_XDECREF(((PyObject*)(newdescr->fields)));
      Py_XDECREF(newdescr->names)_Py_XDECREF(((PyObject*)(newdescr->names)));
      newdescr->fields = NULL((void*)0);
      newdescr->names = NULL((void*)0);

      /*
       * Create a new subarray->shape tuple (it can be an arbitrary
       * sequence of integer like objects, neither of which is safe.
       */
      newdescr->subarray->shape = PyTuple_New(shape.len);
      if (newdescr->subarray->shape == NULL((void*)0)) {
          Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
          goto fail;
      }
      for (int i=0; i < shape.len; i++) {
          PyTuple_SET_ITEM(newdescr->subarray->shape, i,PyTuple_SetItem(newdescr->subarray->shape, i, PyLong_FromLong
((long)shape.ptr[i]))
                           PyLong_FromLong((long)shape.ptr[i]))PyTuple_SetItem(newdescr->subarray->shape, i, PyLong_FromLong
((long)shape.ptr[i]));

          if (PyTuple_GET_ITEM(newdescr->subarray->shape, i)((((void) (0)), (PyTupleObject *)(newdescr->subarray->shape
))->ob_item[i]) == NULL((void*)0)) {
              Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
              goto fail;
          }
      }

      npy_free_cache_dim_obj(shape);
      return newdescr;

  fail:
      Py_XDECREF(type)_Py_XDECREF(((PyObject*)(type)));
      npy_free_cache_dim_obj(shape);
      return NULL((void*)0);
  }
419}

421/*
* obj is a list.  Each item is a tuple with
*
* (field-name, data-type (either a list or a string), and an optional
* shape parameter).
*
* field-name can be a string or a 2-tuple
* data-type can now be a list, string, or 2-tuple
*          (string, metadata dictionary)
*/
431static PyArray_Descr *
432_convert_from_array_descr(PyObject *obj, int align)
433{
  int n = PyList_GET_SIZE(obj)(((void) (0)), (((PyVarObject*)(obj))->ob_size));
  PyObject *nameslist = PyTuple_New(n);
  if (!nameslist) {
23
←
Assuming 'nameslist' is non-null→
24
←
Taking false branch→
      return NULL((void*)0);
  }

  /* Types with fields need the Python C API for field access */
  char dtypeflags = NPY_NEEDS_PYAPI0x10;
  int maxalign = 0;
  int totalsize = 0;
  PyObject *fields = PyDict_New();
  if (!fields) {
25
←
Assuming 'fields' is non-null→
26
←
Taking false branch→
      return NULL((void*)0);
  }
  for (int i = 0; i < n; i++) {
27
←
Assuming 'i' is < 'n'→
28
←
Loop condition is true.  Entering loop body→
      PyObject *item = PyList_GET_ITEM(obj, i)(((PyListObject *)(obj))->ob_item[i]);
      if (!PyTuple_Check(item)((((((PyObject*)(item))->ob_type))->tp_flags & ((1UL
 << 26))) != 0) || (PyTuple_GET_SIZE(item)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(item))))->
ob_size) < 2)) {
29
←
Assuming the condition is true→
30
←
Assuming field 'ob_size' is >= 2→
31
←
Taking false branch→
          PyErr_Format(PyExc_TypeError, 
	 "Field elements must be 2- or 3-tuples, got '%R'", 
	 item);
          goto fail;
      }
      PyObject *name = PyTuple_GET_ITEM(item, 0)((((void) (0)), (PyTupleObject *)(item))->ob_item[0]);
      PyObject *title;
      if (PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
32
←
Assuming the condition is false→
33
←
Taking false branch→
          title = NULL((void*)0);
      }
      else if (PyTuple_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
34
←
Assuming the condition is true→
35
←
Taking true branch→
          if (PyTuple_GET_SIZE(name)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(name))))->
ob_size) != 2) {
36
←
Assuming field 'ob_size' is equal to 2→
37
←
Taking false branch→
              PyErr_Format(PyExc_TypeError, 
		"If a tuple, the first element of a field tuple must have "
		"two elements, not %zd",
	       	PyTuple_GET_SIZE(name)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(name))))->
ob_size));
              goto fail;
          }
          title = PyTuple_GET_ITEM(name, 0)((((void) (0)), (PyTupleObject *)(name))->ob_item[0]);
          name = PyTuple_GET_ITEM(name, 1)((((void) (0)), (PyTupleObject *)(name))->ob_item[1]);
          if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
38
←
Assuming the condition is true→
39
←
Taking false branch→
              PyErr_SetString(PyExc_TypeError, "Field name must be a str");
              goto fail;
          }
      }
      else {
          PyErr_SetString(PyExc_TypeError, 
	            "First element of field tuple is "
	            "neither a tuple nor str");
          goto fail;
      }

      /* Insert name into nameslist */
      Py_INCREF(name)_Py_INCREF(((PyObject*)(name)));

      if (PyUnicode_GetLength(name) == 0) {
40
←
Assuming the condition is true→
41
←
Taking true branch→
          Py_DECREF(name)_Py_DECREF(((PyObject*)(name)));
          if (title == NULL((void*)0)) {
42
←
Assuming 'title' is equal to NULL→
43
←
Taking true branch→
              name = PyUnicode_FromFormat("f%d", i);
44
←
Calling 'PyUnicode_FromFormat'→
46
←
Returning from 'PyUnicode_FromFormat'→
              if (name == NULL((void*)0)) {
47
←
Assuming 'name' is not equal to NULL→
48
←
Taking false branch→
                  goto fail;
              }
          }
          /* On Py3, allow only non-empty Unicode strings as field names */
          else if (PyUnicode_Check(title)((((((PyObject*)(title))->ob_type))->tp_flags & ((1UL
 << 28))) != 0) && PyUnicode_GetLength(title) > 0) {
              name = title;
              Py_INCREF(name)_Py_INCREF(((PyObject*)(name)));
          }
          else {
              PyErr_SetString(PyExc_TypeError, "Field titles must be non-empty strings");
              goto fail;
          }
      }
      PyTuple_SET_ITEM(nameslist, i, name)PyTuple_SetItem(nameslist, i, name);
49
←
Calling 'PyTuple_SetItem'→
51
←
Returning from 'PyTuple_SetItem'→

      /* Process rest */
      PyArray_Descr *conv;
      if (PyTuple_GET_SIZE(item)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(item))))->
ob_size) == 2) {
52
←
Assuming field 'ob_size' is equal to 2→
53
←
Taking true branch→
          conv = _convert_from_any(PyTuple_GET_ITEM(item, 1)((((void) (0)), (PyTupleObject *)(item))->ob_item[1]), align);
          if (conv == NULL((void*)0)) {
54
←
Assuming 'conv' is not equal to NULL→
55
←
Taking false branch→
              goto fail;
          }
      }
      else if (PyTuple_GET_SIZE(item)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(item))))->
ob_size) == 3) {
          PyObject *newobj = PyTuple_GetSlice(item, 1, 3);
          conv = _convert_from_any(newobj, align);
          Py_DECREF(newobj)_Py_DECREF(((PyObject*)(newobj)));
          if (conv == NULL((void*)0)) {
              goto fail;
          }
      }
      else {
          PyErr_Format(PyExc_TypeError,
                  "Field elements must be tuples with at most 3 elements, got '%R'", item);
          goto fail;
      }
      if ((PyDict_GetItemWithError(fields, name) != NULL((void*)0))
56
←
Calling function 'PyDict_GetItemWithError' with a PyObject argument whose ownership has been released (with stolen reference)
           || (title
               && PyUnicode_Check(title)((((((PyObject*)(title))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)
               && (PyDict_GetItemWithError(fields, title) != NULL((void*)0)))) {
          PyErr_Format(PyExc_ValueError,
                  "field %R occurs more than once", name);
          Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
          goto fail;
      }
      else if (PyErr_Occurred()) {
          /* Dict lookup crashed */
          Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
          goto fail;
      }
      dtypeflags |= (conv->flags & NPY_FROM_FIELDS(0x08 | 0x02 | 0x01 | 0x10));
      if (align) {
          int _align = conv->alignment;
          if (_align > 1) {
              totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, _align);
          }
          maxalign = PyArray_MAX(maxalign, _align)(((maxalign)>(_align))?(maxalign):(_align));
      }
      PyObject *tup = PyTuple_New((title == NULL((void*)0) ? 2 : 3));
      if (tup == NULL((void*)0)) {
          goto fail;
      }
      PyTuple_SET_ITEM(tup, 0, (PyObject *)conv)PyTuple_SetItem(tup, 0, (PyObject *)conv);
      PyTuple_SET_ITEM(tup, 1, PyLong_FromLong((long) totalsize))PyTuple_SetItem(tup, 1, PyLong_FromLong((long) totalsize));

      /*
       * Title can be "meta-data".  Only insert it
       * into the fields dictionary if it is a string
       * and if it is not the same as the name.
       */
      if (title != NULL((void*)0)) {
          Py_INCREF(title)_Py_INCREF(((PyObject*)(title)));
          PyTuple_SET_ITEM(tup, 2, title)PyTuple_SetItem(tup, 2, title);
          if (PyDict_SetItem(fields, name, tup) < 0) {
              goto fail;
          }
          if (PyUnicode_Check(title)((((((PyObject*)(title))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
              PyObject *existing = PyDict_GetItemWithError(fields, title);
              if (existing == NULL((void*)0) && PyErr_Occurred()) {
                  goto fail;
              }
              if (existing != NULL((void*)0)) {
                  PyErr_SetString(PyExc_ValueError,
                          "title already used as a name or title.");
                  Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
                  goto fail;
              }
              if (PyDict_SetItem(fields, title, tup) < 0) {
                  goto fail;
              }
          }
      }
      else {
          if (PyDict_SetItem(fields, name, tup) < 0) {
              goto fail;
          }
      }

      totalsize += conv->elsize;
      Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
  }

  if (maxalign > 1) {
      totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, maxalign);
  }

  PyArray_Descr *new = PyArray_DescrNewFromType(NPY_VOID);
  if (new == NULL((void*)0)) {
      Py_XDECREF(fields)_Py_XDECREF(((PyObject*)(fields)));
      Py_XDECREF(nameslist)_Py_XDECREF(((PyObject*)(nameslist)));
      return NULL((void*)0);
  }
  new->fields = fields;
  new->names = nameslist;
  new->elsize = totalsize;
  new->flags = dtypeflags;

  /* Structured arrays get a sticky aligned bit */
  if (align) {
      new->flags |= NPY_ALIGNED_STRUCT0x80;
      new->alignment = maxalign;
  }
  return new;

fail:
  Py_DECREF(fields)_Py_DECREF(((PyObject*)(fields)));
  Py_DECREF(nameslist)_Py_DECREF(((PyObject*)(nameslist)));
  return NULL((void*)0);

620}

622/*
* a list specifying a data-type can just be
* a list of formats.  The names for the fields
* will default to f0, f1, f2, and so forth.
*/
627static PyArray_Descr *
628_convert_from_list(PyObject *obj, int align)
629{
  int n = PyList_GET_SIZE(obj)(((void) (0)), (((PyVarObject*)(obj))->ob_size));
  /*
   * Ignore any empty string at end which _internal._commastring
   * can produce
   */
  PyObject *last_item = PyList_GET_ITEM(obj, n-1)(((PyListObject *)(obj))->ob_item[n-1]);
  if (PyUnicode_Check(last_item)((((((PyObject*)(last_item))->ob_type))->tp_flags &
 ((1UL << 28))) != 0)) {
      Py_ssize_t s = PySequence_Size(last_item);
      if (s < 0) {
          return NULL((void*)0);
      }
      if (s == 0) {
          n = n - 1;
      }
  }
  if (n == 0) {
      PyErr_SetString(PyExc_ValueError, "Expected at least one field name");
      return NULL((void*)0);
  }
  PyObject *nameslist = PyTuple_New(n);
  if (!nameslist) {
      return NULL((void*)0);
  }
  PyObject *fields = PyDict_New();
  if (!fields) {
      Py_DECREF(nameslist)_Py_DECREF(((PyObject*)(nameslist)));
      return NULL((void*)0);
  }

  /* Types with fields need the Python C API for field access */
  char dtypeflags = NPY_NEEDS_PYAPI0x10;
  int maxalign = 0;
  int totalsize = 0;
  for (int i = 0; i < n; i++) {
      PyArray_Descr *conv = _convert_from_any(
              PyList_GET_ITEM(obj, i)(((PyListObject *)(obj))->ob_item[i]), align);
      if (conv == NULL((void*)0)) {
          goto fail;
      }
      dtypeflags |= (conv->flags & NPY_FROM_FIELDS(0x08 | 0x02 | 0x01 | 0x10));
      if (align) {
          int _align = conv->alignment;
          if (_align > 1) {
              totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, _align);
          }
          maxalign = PyArray_MAX(maxalign, _align)(((maxalign)>(_align))?(maxalign):(_align));
      }
      PyObject *size_obj = PyLong_FromLong((long) totalsize);
      if (!size_obj) {
          Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
          goto fail;
      }
      PyObject *tup = PyTuple_New(2);
      if (!tup) {
          Py_DECREF(size_obj)_Py_DECREF(((PyObject*)(size_obj)));
          Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
          goto fail;
      }
      PyTuple_SET_ITEM(tup, 0, (PyObject *)conv)PyTuple_SetItem(tup, 0, (PyObject *)conv);
      PyTuple_SET_ITEM(tup, 1, size_obj)PyTuple_SetItem(tup, 1, size_obj);
      PyObject *key = PyUnicode_FromFormat("f%d", i);
      if (!key) {
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          goto fail;
      }
      /* steals a reference to key */
      PyTuple_SET_ITEM(nameslist, i, key)PyTuple_SetItem(nameslist, i, key);
      int ret = PyDict_SetItem(fields, key, tup);
      Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
      if (ret < 0) {
          goto fail;
      }
      totalsize += conv->elsize;
  }
  PyArray_Descr *new = PyArray_DescrNewFromType(NPY_VOID);
  new->fields = fields;
  new->names = nameslist;
  new->flags = dtypeflags;
  if (maxalign > 1) {
      totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, maxalign);
  }
  /* Structured arrays get a sticky aligned bit */
  if (align) {
      new->flags |= NPY_ALIGNED_STRUCT0x80;
      new->alignment = maxalign;
  }
  new->elsize = totalsize;
  return new;

fail:
  Py_DECREF(nameslist)_Py_DECREF(((PyObject*)(nameslist)));
  Py_DECREF(fields)_Py_DECREF(((PyObject*)(fields)));
  return NULL((void*)0);
723}


726/*
* comma-separated string
* this is the format developed by the numarray records module and implemented
* by the format parser in that module this is an alternative implementation
* found in the _internal.py file patterned after that one -- the approach is
* to try to convert to a list (with tuples if any repeat information is
* present) and then call the _convert_from_list)
*
* TODO: Calling Python from C like this in critical-path code is not
*       a good idea. This should all be converted to C code.
*/
737static PyArray_Descr *
738_convert_from_commastring(PyObject *obj, int align)
739{
  PyObject *listobj;
  PyArray_Descr *res;
  PyObject *_numpy_internal;
  assert(PyUnicode_Check(obj))((void) (0));
  _numpy_internal = PyImport_ImportModule("numpy.core._internal");
  if (_numpy_internal == NULL((void*)0)) {
      return NULL((void*)0);
  }
  listobj = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_internal, "_commastring", "O", obj);
  Py_DECREF(_numpy_internal)_Py_DECREF(((PyObject*)(_numpy_internal)));
  if (listobj == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (!PyList_Check(listobj)((((((PyObject*)(listobj))->ob_type))->tp_flags & (
(1UL << 25))) != 0) || PyList_GET_SIZE(listobj)(((void) (0)), (((PyVarObject*)(listobj))->ob_size)) < 1) {
      PyErr_SetString(PyExc_RuntimeError,
              "_commastring is not returning a list with len >= 1");
      Py_DECREF(listobj)_Py_DECREF(((PyObject*)(listobj)));
      return NULL((void*)0);
  }
  if (PyList_GET_SIZE(listobj)(((void) (0)), (((PyVarObject*)(listobj))->ob_size)) == 1) {
      res = _convert_from_any(PyList_GET_ITEM(listobj, 0)(((PyListObject *)(listobj))->ob_item[0]), align);
  }
  else {
      res = _convert_from_list(listobj, align);
  }
  Py_DECREF(listobj)_Py_DECREF(((PyObject*)(listobj)));
  return res;
767}

769static int
770_is_tuple_of_integers(PyObject *obj)
771{
  int i;

  if (!PyTuple_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
      return 0;
  }
  for (i = 0; i < PyTuple_GET_SIZE(obj)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(obj))))->
ob_size); i++) {
      if (!PyArray_IsIntegerScalar(PyTuple_GET_ITEM(obj, i))(((((((PyObject*)(((((void) (0)), (PyTupleObject *)(obj))->
ob_item[i])))->ob_type))->tp_flags & ((1UL <<
 24))) != 0) || (((((PyObject*)((((((void) (0)), (PyTupleObject
 *)(obj))->ob_item[i]))))->ob_type) == (&PyIntegerArrType_Type
) || PyType_IsSubtype((((PyObject*)((((((void) (0)), (PyTupleObject
 *)(obj))->ob_item[i]))))->ob_type), (&PyIntegerArrType_Type
)))))) {
          return 0;
      }
  }
  return 1;
783}

785/*
* helper function for _try_convert_from_inherit_tuple to disallow dtypes of the form
* (old_dtype, new_dtype) where either of the dtypes contains python
* objects - these dtypes are not useful and can be a source of segfaults,
* when an attempt is made to interpret a python object as a different dtype
* or vice versa
* an exception is made for dtypes of the form ('O', [('name', 'O')]), which
* people have been using to add a field to an object array without fields
*/
794static int
795_validate_union_object_dtype(PyArray_Descr *new, PyArray_Descr *conv)
796{
  PyObject *name, *tup;
  PyArray_Descr *dtype;

  if (!PyDataType_REFCHK(new)(((new)->flags & (0x01)) == (0x01)) && !PyDataType_REFCHK(conv)(((conv)->flags & (0x01)) == (0x01))) {
      return 0;
  }
  if (PyDataType_HASFIELDS(new)(((PyArray_Descr *)(new))->names != ((void*)0)) || new->kind != 'O') {
      goto fail;
  }
  if (!PyDataType_HASFIELDS(conv)(((PyArray_Descr *)(conv))->names != ((void*)0)) || PyTuple_GET_SIZE(conv->names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(conv->names
))))->ob_size) != 1) {
      goto fail;
  }
  name = PyTuple_GET_ITEM(conv->names, 0)((((void) (0)), (PyTupleObject *)(conv->names))->ob_item
[0]);
  if (name == NULL((void*)0)) {
      return -1;
  }
  tup = PyDict_GetItemWithError(conv->fields, name);
  if (tup == NULL((void*)0)) {
      if (!PyErr_Occurred()) {
          /* fields was missing the name it claimed to contain */
          PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 817);
      }
      return -1;
  }
  dtype = (PyArray_Descr *)PyTuple_GET_ITEM(tup, 0)((((void) (0)), (PyTupleObject *)(tup))->ob_item[0]);
  if (dtype == NULL((void*)0)) {
      return -1;
  }
  if (dtype->kind != 'O') {
      goto fail;
  }
  return 0;

830fail:
  PyErr_SetString(PyExc_ValueError,
          "dtypes of the form (old_dtype, new_dtype) containing the object "
          "dtype are not supported");
  return -1;
835}

837/*
* A tuple type would be either (generic typeobject, typesize)
* or (fixed-length data-type, shape)
*
* or (inheriting data-type, new-data-type)
* The new data-type must have the same itemsize as the inheriting data-type
* unless the latter is 0
*
* Thus (int32, {'real':(int16,0),'imag',(int16,2)})
*
* is one way to specify a descriptor that will give
* a['real'] and a['imag'] to an int32 array.
*
* leave type reference alone
*
* Returns `Py_NotImplemented` if the second tuple item is not
* appropriate.
*/
855static PyArray_Descr *
856_try_convert_from_inherit_tuple(PyArray_Descr *type, PyObject *newobj)
857{
  if (PyArray_IsScalar(newobj, Integer)(((((PyObject*)(newobj))->ob_type) == (&PyIntegerArrType_Type
) || PyType_IsSubtype((((PyObject*)(newobj))->ob_type), (&
PyIntegerArrType_Type)))) || _is_tuple_of_integers(newobj)) {
      /* It's a subarray or flexible type instead */
      Py_INCREF(Py_NotImplemented)_Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct))));
      return (PyArray_Descr *)Py_NotImplemented(&_Py_NotImplementedStruct);
  }
  PyArray_Descr *conv = _convert_from_any(newobj, 0);
  if (conv == NULL((void*)0)) {
      /* Let someone else try to convert this */
      PyErr_Clear();
      Py_INCREF(Py_NotImplemented)_Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct))));
      return (PyArray_Descr *)Py_NotImplemented(&_Py_NotImplementedStruct);
  }
  PyArray_Descr *new = PyArray_DescrNew(type);
  if (new == NULL((void*)0)) {
      goto fail;
  }
  if (PyDataType_ISUNSIZED(new)((new)->elsize == 0 && !(((PyArray_Descr *)(new))->
names != ((void*)0)))) {
      new->elsize = conv->elsize;
  }
  else if (new->elsize != conv->elsize) {
      PyErr_SetString(PyExc_ValueError,
              "mismatch in size of old and new data-descriptor");
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      goto fail;
  }
  else if (_validate_union_object_dtype(new, conv) < 0) {
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      goto fail;
  }

  if (PyDataType_HASFIELDS(conv)(((PyArray_Descr *)(conv))->names != ((void*)0))) {
      Py_XDECREF(new->fields)_Py_XDECREF(((PyObject*)(new->fields)));
      new->fields = conv->fields;
      Py_XINCREF(new->fields)_Py_XINCREF(((PyObject*)(new->fields)));

      Py_XDECREF(new->names)_Py_XDECREF(((PyObject*)(new->names)));
      new->names = conv->names;
      Py_XINCREF(new->names)_Py_XINCREF(((PyObject*)(new->names)));
  }
  if (conv->metadata != NULL((void*)0)) {
      Py_XDECREF(new->metadata)_Py_XDECREF(((PyObject*)(new->metadata)));
      new->metadata = conv->metadata;
      Py_XINCREF(new->metadata)_Py_XINCREF(((PyObject*)(new->metadata)));
  }
  /*
   * Certain flags must be inherited from the fields.  This is needed
   * only for void dtypes (or subclasses of it such as a record dtype).
   * For other dtypes, the field part will only be used for direct field
   * access and thus flag inheritance should not be necessary.
   * (We only allow object fields if the dtype is object as well.)
   * This ensures copying over of the NPY_FROM_FIELDS "inherited" flags.
   */
  if (new->type_num == NPY_VOID) {
      new->flags = conv->flags;
  }
  Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
  return new;

fail:
  Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
  return NULL((void*)0);
919}

921/*
* Validates that any field of the structured array 'dtype' which has
* the NPY_ITEM_HASOBJECT flag set does not overlap with another field.
*
* This algorithm is worst case O(n^2). It could be done with a sort
* and sweep algorithm, but the structured dtype representation is
* rather ugly right now, so writing something better can wait until
* that representation is made sane.
*
* Returns 0 on success, -1 if an exception is raised.
*/
932static int
933_validate_object_field_overlap(PyArray_Descr *dtype)
934{
  PyObject *names, *fields, *key, *tup, *title;
  Py_ssize_t i, j, names_size;
  PyArray_Descr *fld_dtype, *fld2_dtype;
  int fld_offset, fld2_offset;

  /* Get some properties from the dtype */
  names = dtype->names;
  names_size = PyTuple_GET_SIZE(names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(names))))->
ob_size);
  fields = dtype->fields;

  for (i = 0; i < names_size; ++i) {
      key = PyTuple_GET_ITEM(names, i)((((void) (0)), (PyTupleObject *)(names))->ob_item[i]);
      if (key == NULL((void*)0)) {
          return -1;
      }
      tup = PyDict_GetItemWithError(fields, key);
      if (tup == NULL((void*)0)) {
          if (!PyErr_Occurred()) {
              /* fields was missing the name it claimed to contain */
              PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 954);
          }
          return -1;
      }
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(tup, "Oi|O", &fld_dtype, &fld_offset, &title)) {
          return -1;
      }

      /* If this field has objects, check for overlaps */
      if (PyDataType_REFCHK(fld_dtype)(((fld_dtype)->flags & (0x01)) == (0x01))) {
          for (j = 0; j < names_size; ++j) {
              if (i != j) {
                  key = PyTuple_GET_ITEM(names, j)((((void) (0)), (PyTupleObject *)(names))->ob_item[j]);
                  if (key == NULL((void*)0)) {
                      return -1;
                  }
                  tup = PyDict_GetItemWithError(fields, key);
                  if (tup == NULL((void*)0)) {
                      if (!PyErr_Occurred()) {
                          /* fields was missing the name it claimed to contain */
                          PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 974);
                      }
                      return -1;
                  }
                  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(tup, "Oi|O", &fld2_dtype,
                                              &fld2_offset, &title)) {
                      return -1;
                  }
                  /* Raise an exception if it overlaps */
                  if (fld_offset < fld2_offset + fld2_dtype->elsize &&
                              fld2_offset < fld_offset + fld_dtype->elsize) {
                      PyErr_SetString(PyExc_TypeError,
                              "Cannot create a NumPy dtype with overlapping "
                              "object fields");
                      return -1;
                  }
              }
          }
      }
  }

  /* It passed all the overlap tests */
  return 0;
997}

999/*
* a dictionary specifying a data-type
* must have at least two and up to four
* keys These must all be sequences of the same length.
*
* can also have an additional key called "metadata" which can be any dictionary
*
* "names" --- field names
* "formats" --- the data-type descriptors for the field.
*
* Optional:
*
* "offsets" --- integers indicating the offset into the
* record of the start of the field.
* if not given, then "consecutive offsets"
* will be assumed and placed in the dictionary.
*
* "titles" --- Allows the use of an additional key
* for the fields dictionary.(if these are strings
* or unicode objects) or
* this can also be meta-data to
* be passed around with the field description.
*
* Attribute-lookup-based field names merely has to query the fields
* dictionary of the data-descriptor.  Any result present can be used
* to return the correct field.
*
* So, the notion of what is a name and what is a title is really quite
* arbitrary.
*
* What does distinguish a title, however, is that if it is not None,
* it will be placed at the end of the tuple inserted into the
* fields dictionary.and can therefore be used to carry meta-data around.
*
* If the dictionary does not have "names" and "formats" entries,
* then it will be checked for conformity and used directly.
*/
1036static PyArray_Descr *
1037_convert_from_field_dict(PyObject *obj, int align)
1038{
  PyObject *_numpy_internal;
  PyArray_Descr *res;

  _numpy_internal = PyImport_ImportModule("numpy.core._internal");
  if (_numpy_internal == NULL((void*)0)) {
      return NULL((void*)0);
  }
  res = (PyArray_Descr *)PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_internal,
          "_usefields", "Oi", obj, align);
  Py_DECREF(_numpy_internal)_Py_DECREF(((PyObject*)(_numpy_internal)));
  return res;
1050}

1052/*
* Creates a struct dtype object from a Python dictionary.
*/
1055static PyArray_Descr *
1056_convert_from_dict(PyObject *obj, int align)
1057{
  PyObject *fields = PyDict_New();
  if (fields == NULL((void*)0)) {
      return (PyArray_Descr *)PyErr_NoMemory();
  }
  /*
   * Use PyMapping_GetItemString to support dictproxy objects as well.
   */
  PyObject *names = PyMapping_GetItemString(obj, "names");
  if (names == NULL((void*)0)) {
      Py_DECREF(fields)_Py_DECREF(((PyObject*)(fields)));
      /* XXX should check this is a KeyError */
      PyErr_Clear();
      return _convert_from_field_dict(obj, align);
  }
  PyObject *descrs = PyMapping_GetItemString(obj, "formats");
  if (descrs == NULL((void*)0)) {
      Py_DECREF(fields)_Py_DECREF(((PyObject*)(fields)));
      /* XXX should check this is a KeyError */
      PyErr_Clear();
      Py_DECREF(names)_Py_DECREF(((PyObject*)(names)));
      return _convert_from_field_dict(obj, align);
  }
  int n = PyObject_LengthPyObject_Size(names);
  PyObject *offsets = PyMapping_GetItemString(obj, "offsets");
  if (!offsets) {
      PyErr_Clear();
  }
  PyObject *titles = PyMapping_GetItemString(obj, "titles");
  if (!titles) {
      PyErr_Clear();
  }

  if ((n > PyObject_LengthPyObject_Size(descrs))
      || (offsets && (n > PyObject_LengthPyObject_Size(offsets)))
      || (titles && (n > PyObject_LengthPyObject_Size(titles)))) {
      PyErr_SetString(PyExc_ValueError,
              "'names', 'formats', 'offsets', and 'titles' dict "
              "entries must have the same length");
      goto fail;
  }

  /*
   * If a property 'aligned' is in the dict, it overrides the align flag
   * to be True if it not already true.
   */
  PyObject *tmp = PyMapping_GetItemString(obj, "aligned");
  if (tmp == NULL((void*)0)) {
      PyErr_Clear();
  } else {
      if (tmp == Py_True((PyObject *) &_Py_TrueStruct)) {
          align = 1;
      }
      else if (tmp != Py_False((PyObject *) &_Py_FalseStruct)) {
          Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
          PyErr_SetString(PyExc_ValueError,
                  "NumPy dtype descriptor includes 'aligned' entry, "
                  "but its value is neither True nor False");
          goto fail;
      }
      Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
  }

  /* Types with fields need the Python C API for field access */
  char dtypeflags = NPY_NEEDS_PYAPI0x10;
  int totalsize = 0;
  int maxalign = 0;
  int has_out_of_order_fields = 0;
  for (int i = 0; i < n; i++) {
      /* Build item to insert (descr, offset, [title])*/
      int len = 2;
      PyObject *title = NULL((void*)0);
      PyObject *ind = PyLong_FromLong(i);
      if (titles) {
          title=PyObject_GetItem(titles, ind);
          if (title && title != Py_None(&_Py_NoneStruct)) {
              len = 3;
          }
          else {
              Py_XDECREF(title)_Py_XDECREF(((PyObject*)(title)));
          }
          PyErr_Clear();
      }
      PyObject *tup = PyTuple_New(len);
      PyObject *descr = PyObject_GetItem(descrs, ind);
      if (!descr) {
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
          goto fail;
      }
      PyArray_Descr *newdescr = _convert_from_any(descr, align);
      Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
      if (newdescr == NULL((void*)0)) {
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
          goto fail;
      }
      PyTuple_SET_ITEM(tup, 0, (PyObject *)newdescr)PyTuple_SetItem(tup, 0, (PyObject *)newdescr);
      int _align = 1;
      if (align) {
          _align = newdescr->alignment;
          maxalign = PyArray_MAX(maxalign,_align)(((maxalign)>(_align))?(maxalign):(_align));
      }
      if (offsets) {
          PyObject *off = PyObject_GetItem(offsets, ind);
          if (!off) {
              Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
              Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
              goto fail;
          }
          long offset = PyArray_PyIntAsInt(off);
          if (error_converting(offset)(((offset) == -1) && PyErr_Occurred())) {
              Py_DECREF(off)_Py_DECREF(((PyObject*)(off)));
              Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
              Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
              goto fail;
          }
          Py_DECREF(off)_Py_DECREF(((PyObject*)(off)));
          if (offset < 0) {
              PyErr_Format(PyExc_ValueError, "offset %ld cannot be negative",
                           offset);
              Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
              Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
              goto fail;
          }

          PyTuple_SET_ITEM(tup, 1, PyLong_FromLong(offset))PyTuple_SetItem(tup, 1, PyLong_FromLong(offset));
          /* Flag whether the fields are specified out of order */
          if (offset < totalsize) {
              has_out_of_order_fields = 1;
          }
          /* If align=True, enforce field alignment */
          if (align && offset % newdescr->alignment != 0) {
              PyErr_Format(PyExc_ValueError,
                      "offset %ld for NumPy dtype with fields is "
                      "not divisible by the field alignment %d "
                      "with align=True",
                      offset, newdescr->alignment);
              Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
              Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
              goto fail;
          }
          else if (offset + newdescr->elsize > totalsize) {
              totalsize = offset + newdescr->elsize;
          }
      }
      else {
          if (align && _align > 1) {
              totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, _align);
          }
          PyTuple_SET_ITEM(tup, 1, PyLong_FromLong(totalsize))PyTuple_SetItem(tup, 1, PyLong_FromLong(totalsize));
          totalsize += newdescr->elsize;
      }
      if (len == 3) {
          PyTuple_SET_ITEM(tup, 2, title)PyTuple_SetItem(tup, 2, title);
      }
      PyObject *name = PyObject_GetItem(names, ind);
      Py_DECREF(ind)_Py_DECREF(((PyObject*)(ind)));
      if (!name) {
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          goto fail;
      }
      if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
          PyErr_SetString(PyExc_ValueError,
                  "field names must be strings");
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          goto fail;
      }

      /* Insert into dictionary */
      if (PyDict_GetItemWithError(fields, name) != NULL((void*)0)) {
          PyErr_SetString(PyExc_ValueError,
                  "name already used as a name or title");
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          goto fail;
      }
      else if (PyErr_Occurred()) {
          /* MemoryError during dict lookup */
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          goto fail;
      }
      int ret = PyDict_SetItem(fields, name, tup);
      Py_DECREF(name)_Py_DECREF(((PyObject*)(name)));
      if (ret < 0) {
          Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
          goto fail;
      }
      if (len == 3) {
          if (PyUnicode_Check(title)((((((PyObject*)(title))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
              if (PyDict_GetItemWithError(fields, title) != NULL((void*)0)) {
                  PyErr_SetString(PyExc_ValueError,
                          "title already used as a name or title.");
                  Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
                  goto fail;
              }
              else if (PyErr_Occurred()) {
                  /* MemoryError during dict lookup */
                  goto fail;
              }
              if (PyDict_SetItem(fields, title, tup) < 0) {
                  Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
                  goto fail;
              }
          }
      }
      Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
      dtypeflags |= (newdescr->flags & NPY_FROM_FIELDS(0x08 | 0x02 | 0x01 | 0x10));
  }

  PyArray_Descr *new = PyArray_DescrNewFromType(NPY_VOID);
  if (new == NULL((void*)0)) {
      goto fail;
  }
  if (maxalign > 1) {
      totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, maxalign);
  }
  if (align) {
      new->alignment = maxalign;
  }
  new->elsize = totalsize;
  if (!PyTuple_Check(names)((((((PyObject*)(names))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
      Py_SETREF(names, PySequence_Tuple(names))do { PyObject *_py_tmp = ((PyObject*)(names)); (names) = (PySequence_Tuple
(names)); _Py_DECREF(((PyObject*)(_py_tmp))); } while (0);
      if (names == NULL((void*)0)) {
          Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
          goto fail;
      }
  }
  new->names = names;
  new->fields = fields;
  new->flags = dtypeflags;
  /* new takes responsibility for DECREFing names, fields */
  names = NULL((void*)0);
  fields = NULL((void*)0);

  /*
   * If the fields weren't in order, and there was an OBJECT type,
   * need to verify that no OBJECT types overlap with something else.
   */
  if (has_out_of_order_fields && PyDataType_REFCHK(new)(((new)->flags & (0x01)) == (0x01))) {
      if (_validate_object_field_overlap(new) < 0) {
          Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
          goto fail;
      }
  }

  /* Structured arrays get a sticky aligned bit */
  if (align) {
      new->flags |= NPY_ALIGNED_STRUCT0x80;
  }

  /* Override the itemsize if provided */
  tmp = PyMapping_GetItemString(obj, "itemsize");
  if (tmp == NULL((void*)0)) {
      PyErr_Clear();
  } else {
      int itemsize = (int)PyArray_PyIntAsInt(tmp);
      Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
      if (error_converting(itemsize)(((itemsize) == -1) && PyErr_Occurred())) {
          Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
          goto fail;
      }
      /* Make sure the itemsize isn't made too small */
      if (itemsize < new->elsize) {
          PyErr_Format(PyExc_ValueError,
                  "NumPy dtype descriptor requires %d bytes, "
                  "cannot override to smaller itemsize of %d",
                  new->elsize, itemsize);
          Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
          goto fail;
      }
      /* If align is set, make sure the alignment divides into the size */
      if (align && itemsize % new->alignment != 0) {
          PyErr_Format(PyExc_ValueError,
                  "NumPy dtype descriptor requires alignment of %d bytes, "
                  "which is not divisible into the specified itemsize %d",
                  new->alignment, itemsize);
          Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
          goto fail;
      }
      /* Set the itemsize */
      new->elsize = itemsize;
  }

  /* Add the metadata if provided */
  PyObject *metadata = PyMapping_GetItemString(obj, "metadata");

  if (metadata == NULL((void*)0)) {
      PyErr_Clear();
  }
  else if (new->metadata == NULL((void*)0)) {
      new->metadata = metadata;
  }
  else {
      int ret = PyDict_Merge(new->metadata, metadata, 0);
      Py_DECREF(metadata)_Py_DECREF(((PyObject*)(metadata)));
      if (ret < 0) {
          Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
          goto fail;
      }
  }

  Py_XDECREF(fields)_Py_XDECREF(((PyObject*)(fields)));
  Py_XDECREF(names)_Py_XDECREF(((PyObject*)(names)));
  Py_XDECREF(descrs)_Py_XDECREF(((PyObject*)(descrs)));
  Py_XDECREF(offsets)_Py_XDECREF(((PyObject*)(offsets)));
  Py_XDECREF(titles)_Py_XDECREF(((PyObject*)(titles)));
  return new;

fail:
  Py_XDECREF(fields)_Py_XDECREF(((PyObject*)(fields)));
  Py_XDECREF(names)_Py_XDECREF(((PyObject*)(names)));
  Py_XDECREF(descrs)_Py_XDECREF(((PyObject*)(descrs)));
  Py_XDECREF(offsets)_Py_XDECREF(((PyObject*)(offsets)));
  Py_XDECREF(titles)_Py_XDECREF(((PyObject*)(titles)));
  return NULL((void*)0);
1372}


1375/*NUMPY_API*/
1376NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
1377PyArray_DescrNewFromType(int type_num)
1378{
  PyArray_Descr *old;
  PyArray_Descr *new;

  old = PyArray_DescrFromType(type_num);
  new = PyArray_DescrNew(old);
  Py_DECREF(old)_Py_DECREF(((PyObject*)(old)));
  return new;
1386}

1388/*NUMPY_API
* Get typenum from an object -- None goes to NULL
*/
1391NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
1392PyArray_DescrConverter2(PyObject *obj, PyArray_Descr **at)
1393{
  if (obj == Py_None(&_Py_NoneStruct)) {
      *at = NULL((void*)0);
      return NPY_SUCCEED1;
  }
  else {
      return PyArray_DescrConverter(obj, at);
  }
1401}

1403/**
* Get a dtype instance from a python type
*/
1406static PyArray_Descr *
1407_convert_from_type(PyObject *obj) {
  PyTypeObject *typ = (PyTypeObject*)obj;

  if (PyType_IsSubtype(typ, &PyGenericArrType_Type)) {
      return PyArray_DescrFromTypeObject(obj);
  }
  else if (typ == &PyLong_Type) {
      return PyArray_DescrFromType(NPY_LONG);
  }
  else if (typ == &PyFloat_Type) {
      return PyArray_DescrFromType(NPY_DOUBLE);
  }
  else if (typ == &PyComplex_Type) {
      return PyArray_DescrFromType(NPY_CDOUBLE);
  }
  else if (typ == &PyBool_Type) {
      return PyArray_DescrFromType(NPY_BOOL);
  }
  else if (typ == &PyBytes_Type) {
      /*
       * TODO: This should be deprecated, and have special handling for
       *       dtype=bytes/"S" in coercion: It should not rely on "S0".
       */
      return PyArray_DescrFromType(NPY_STRING);
  }
  else if (typ == &PyUnicode_Type) {
      /*
       * TODO: This should be deprecated, and have special handling for
       *       dtype=str/"U" in coercion: It should not rely on "U0".
       */
      return PyArray_DescrFromType(NPY_UNICODE);
  }
  else if (typ == &PyMemoryView_Type) {
      return PyArray_DescrFromType(NPY_VOID);
  }
  else if (typ == &PyBaseObject_Type) {
      return PyArray_DescrFromType(NPY_OBJECT);
  }
  else {
      PyArray_Descr *ret = _try_convert_from_dtype_attr(obj);
      if ((PyObject *)ret != Py_NotImplemented(&_Py_NotImplementedStruct)) {
          return ret;
      }
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));

      /*
       * Note: this comes after _try_convert_from_dtype_attr because the ctypes
       * type might override the dtype if numpy does not otherwise
       * support it.
       */
      ret = _try_convert_from_ctypes_type(typ);
      if ((PyObject *)ret != Py_NotImplemented(&_Py_NotImplementedStruct)) {
          return ret;
      }
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));

      /*
       * All other classes are treated as object. This can be convenient
       * to convey an intention of using it for a specific python type
       * and possibly allow converting to a new type-specific dtype in the future. It may make sense to
       * only allow this only within `dtype=...` keyword argument context
       * in the future.
       */
      return PyArray_DescrFromType(NPY_OBJECT);
  }
1472}


1475static PyArray_Descr *
1476_convert_from_str(PyObject *obj, int align);

1478static PyArray_Descr *
1479_convert_from_any(PyObject *obj, int align)
1480{
  /* default */
  if (obj == Py_None(&_Py_NoneStruct)) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
      return PyArray_DescrFromType(NPY_DEFAULT_TYPENPY_DOUBLE);
  }
  else if (PyArray_DescrCheck(obj)((((PyObject*)(obj))->ob_type) == (&(*(PyTypeObject *)
(&PyArrayDescr_TypeFull))) || PyType_IsSubtype((((PyObject
*)(obj))->ob_type), (&(*(PyTypeObject *)(&PyArrayDescr_TypeFull
)))))) {
7
←
Assuming the condition is false→
8
←
Assuming the condition is false→
9
←
Taking false branch→
      PyArray_Descr *ret = (PyArray_Descr *)obj;
      Py_INCREF(ret)_Py_INCREF(((PyObject*)(ret)));
      return ret;
  }
  else if (PyType_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 31))) != 0)) {
10
←
Assuming the condition is false→
11
←
Taking false branch→
      return _convert_from_type(obj);
  }
  /* or a typecode string */
  else if (PyBytes_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 27))) != 0)) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
      /* Allow bytes format strings: convert to unicode */
      PyObject *obj2 = PyUnicode_FromEncodedObject(obj, NULL((void*)0), NULL((void*)0));
      if (obj2 == NULL((void*)0)) {
          /* Convert the exception into a TypeError */
          if (PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
              PyErr_SetString(PyExc_TypeError,
                      "data type not understood");
          }
          return NULL((void*)0);
      }
      PyArray_Descr *ret = _convert_from_str(obj2, align);
      Py_DECREF(obj2)_Py_DECREF(((PyObject*)(obj2)));
      return ret;
  }
  else if (PyUnicode_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
14
←
Assuming the condition is false→
15
←
Taking false branch→
      return _convert_from_str(obj, align);
  }
  else if (PyTuple_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
16
←
Assuming the condition is false→
17
←
Taking false branch→
      /* or a tuple */
      if (Py_EnterRecursiveCall(((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a tuple object"))
              " while trying to convert the given data type from"((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a tuple object"))
              " a tuple object" )((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a tuple object")) != 0) {
          return NULL((void*)0);
      }
      PyArray_Descr *ret = _convert_from_tuple(obj, align);
      Py_LeaveRecursiveCall()do{ if((--(PyThreadState_Get()->recursion_depth) < (((_Py_CheckRecursionLimit
) > 200) ? ((_Py_CheckRecursionLimit) - 50) : (3 * ((_Py_CheckRecursionLimit
) >> 2))))) PyThreadState_Get()->overflowed = 0; } while
(0);
      return ret;
  }
  else if (PyList_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 25))) != 0)) {
18
←
Assuming the condition is true→
19
←
Taking true branch→
      /* or a list */
      if (Py_EnterRecursiveCall(((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a list object"))
20
←
Assuming the condition is false→
21
←
Taking false branch→
              " while trying to convert the given data type from"((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a list object"))
              " a list object" )((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a list object")) != 0) {
          return NULL((void*)0);
      }
      PyArray_Descr *ret = _convert_from_array_descr(obj, align);
22
←
Calling '_convert_from_array_descr'→
      Py_LeaveRecursiveCall()do{ if((--(PyThreadState_Get()->recursion_depth) < (((_Py_CheckRecursionLimit
) > 200) ? ((_Py_CheckRecursionLimit) - 50) : (3 * ((_Py_CheckRecursionLimit
) >> 2))))) PyThreadState_Get()->overflowed = 0; } while
(0);
      return ret;
  }
  else if (PyDict_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 29))) != 0) || PyDictProxy_Check(obj)) {
      /* or a dictionary */
      if (Py_EnterRecursiveCall(((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a dict object"))
              " while trying to convert the given data type from"((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a dict object"))
              " a dict object" )((++(PyThreadState_Get()->recursion_depth) > _Py_CheckRecursionLimit
) && _Py_CheckRecursiveCall(" while trying to convert the given data type from"
 " a dict object")) != 0) {
          return NULL((void*)0);
      }
      PyArray_Descr *ret = _convert_from_dict(obj, align);
      Py_LeaveRecursiveCall()do{ if((--(PyThreadState_Get()->recursion_depth) < (((_Py_CheckRecursionLimit
) > 200) ? ((_Py_CheckRecursionLimit) - 50) : (3 * ((_Py_CheckRecursionLimit
) >> 2))))) PyThreadState_Get()->overflowed = 0; } while
(0);
      return ret;
  }
  else if (PyArray_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyArray_Type)))) {
      PyErr_SetString(PyExc_TypeError, "Cannot construct a dtype from an array");
      return NULL((void*)0);
  }
  else {
      PyArray_Descr *ret = _try_convert_from_dtype_attr(obj);
      if ((PyObject *)ret != Py_NotImplemented(&_Py_NotImplementedStruct)) {
          return ret;
      }
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      /*
       * Note: this comes after _try_convert_from_dtype_attr because the ctypes
       * type might override the dtype if numpy does not otherwise
       * support it.
       */
      ret = _try_convert_from_ctypes_type(Py_TYPE(obj)(((PyObject*)(obj))->ob_type));
      if ((PyObject *)ret != Py_NotImplemented(&_Py_NotImplementedStruct)) {
          return ret;
      }
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      PyErr_Format(PyExc_TypeError, "Cannot interpret '%R' as a data type", obj);
      return NULL((void*)0);
  }
1568}


1571/*NUMPY_API
* Get typenum from an object -- None goes to NPY_DEFAULT_TYPE
* This function takes a Python object representing a type and converts it
* to a the correct PyArray_Descr * structure to describe the type.
*
* Many objects can be used to represent a data-type which in NumPy is
* quite a flexible concept.
*
* This is the central code that converts Python objects to
* Type-descriptor objects that are used throughout numpy.
*
* Returns a new reference in *at, but the returned should not be
* modified as it may be one of the canonical immutable objects or
* a reference to the input obj.
*/
1586NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
1587PyArray_DescrConverter(PyObject *obj, PyArray_Descr **at)
1588{
  *at = _convert_from_any(obj, 0);
4
←
Calling '_convert_from_any'→
  return (*at) ? NPY_SUCCEED1 : NPY_FAIL0;
1591}

1593/** Convert a bytestring specification into a dtype */
1594static PyArray_Descr *
1595_convert_from_str(PyObject *obj, int align)
1596{
  /* Check for a string typecode. */
  Py_ssize_t len = 0;
  char const *type = PyUnicode_AsUTF8AndSize(obj, &len);
  if (type == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* Empty string is invalid */
  if (len == 0) {
      goto fail;
  }

  /* check for commas present or first (or second) element a digit */
  if (_check_for_commastring(type, len)) {
      return _convert_from_commastring(obj, align);
  }

  /* Process the endian character. '|' is replaced by '='*/
  char endian = '=';
  switch (type[0]) {
      case '>':
      case '<':
      case '=':
          endian = type[0];
          ++type;
          --len;
          break;

      case '|':
          endian = '=';
          ++type;
          --len;
          break;
  }

  /* Just an endian character is invalid */
  if (len == 0) {
      goto fail;
  }

  /* Check for datetime format */
  if (is_datetime_typestr(type, len)) {
      PyArray_Descr *ret = parse_dtype_from_datetime_typestr(type, len);
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
      /* ret has byte order '=' at this point */
      if (!PyArray_ISNBO(endian)((endian) != '>')) {
          ret->byteorder = endian;
      }
      return ret;
  }

  int check_num = NPY_NOTYPE + 10;
  int elsize = 0;
  /* A typecode like 'd' */
  if (len == 1) {
      /* Python byte string characters are unsigned */
      check_num = (unsigned char) type[0];
  }
  /* A kind + size like 'f8' */
  else {
      char *typeend = NULL((void*)0);
      int kind;

      /* Parse the integer, make sure it's the rest of the string */
      elsize = (int)strtol(type + 1, &typeend, 10);
      if (typeend - type == len) {

          kind = type[0];
          switch (kind) {
              case NPY_STRINGLTR:
              case NPY_STRINGLTR2:
                  check_num = NPY_STRING;
                  break;

              /*
               * When specifying length of UNICODE
               * the number of characters is given to match
               * the STRING interface.  Each character can be
               * more than one byte and itemsize must be
               * the number of bytes.
               */
              case NPY_UNICODELTR:
                  check_num = NPY_UNICODE;
                  elsize <<= 2;
                  break;

              case NPY_VOIDLTR:
                  check_num = NPY_VOID;
                  break;

              default:
                  if (elsize == 0) {
                      check_num = NPY_NOTYPE+10;
                  }
                  /* Support for generic processing c8, i4, f8, etc...*/
                  else {
                      check_num = PyArray_TypestrConvert(elsize, kind);
                      if (check_num == NPY_NOTYPE) {
                          check_num += 10;
                      }
                      elsize = 0;
                  }
          }
      }
  }

  if (PyErr_Occurred()) {
      goto fail;
  }

  PyArray_Descr *ret;
  if ((check_num == NPY_NOTYPE + 10) ||
          (ret = PyArray_DescrFromType(check_num)) == NULL((void*)0)) {
      PyErr_Clear();
      /* Now check to see if the object is registered in typeDict */
      if (typeDict == NULL((void*)0)) {
          goto fail;
      }
      PyObject *item = PyDict_GetItemWithError(typeDict, obj);
      if (item == NULL((void*)0)) {
          if (PyErr_Occurred()) {
              return NULL((void*)0);
          }
          goto fail;
      }

      /* Check for a deprecated Numeric-style typecode */
      /* `Uint` has deliberately weird uppercasing */
      char *dep_tps[] = {"Bytes", "Datetime64", "Str", "Uint"};
      int ndep_tps = sizeof(dep_tps) / sizeof(dep_tps[0]);
      for (int i = 0; i < ndep_tps; ++i) {
          char *dep_tp = dep_tps[i];

          if (strncmp(type, dep_tp, strlen(dep_tp)) == 0) {
              /* Deprecated 2020-06-09, NumPy 1.20 */
              if (DEPRECATE("Numeric-style type codes are "PyErr_WarnEx(PyExc_DeprecationWarning,"Numeric-style type codes are "
 "deprecated and will result in " "an error in the future.",1
)
                            "deprecated and will result in "PyErr_WarnEx(PyExc_DeprecationWarning,"Numeric-style type codes are "
 "deprecated and will result in " "an error in the future.",1
)
                            "an error in the future.")PyErr_WarnEx(PyExc_DeprecationWarning,"Numeric-style type codes are "
 "deprecated and will result in " "an error in the future.",1
) < 0) {
                  goto fail;
              }
          }
      }
      /*
       * Probably only ever dispatches to `_convert_from_type`, but who
       * knows what users are injecting into `np.typeDict`.
       */
      return _convert_from_any(item, align);
  }

  if (PyDataType_ISUNSIZED(ret)((ret)->elsize == 0 && !(((PyArray_Descr *)(ret))->
names != ((void*)0))) && ret->elsize != elsize) {
      PyArray_DESCR_REPLACE(ret)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(ret); _Py_XDECREF
(((PyObject*)(ret))); ret = _new_; } while(0);
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
      ret->elsize = elsize;
  }
  if (endian != '=' && PyArray_ISNBO(endian)((endian) != '>')) {
      endian = '=';
  }
  if (endian != '=' && ret->byteorder != '|' && ret->byteorder != endian) {
      PyArray_DESCR_REPLACE(ret)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(ret); _Py_XDECREF
(((PyObject*)(ret))); ret = _new_; } while(0);
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
      ret->byteorder = endian;
  }
  return ret;

1767fail:
  PyErr_Format(PyExc_TypeError, "data type %R not understood", obj);
  return NULL((void*)0);
1770}

1772/** Array Descr Objects for dynamic types **/

1774/*
* There are some statically-defined PyArray_Descr objects corresponding
* to the basic built-in types.
* These can and should be DECREF'd and INCREF'd as appropriate, anyway.
* If a mistake is made in reference counting, deallocation on these
* builtins will be attempted leading to problems.
*
* This lets us deal with all PyArray_Descr objects using reference
* counting (regardless of whether they are statically or dynamically
* allocated).
*/

1786/*NUMPY_API
* base cannot be NULL
*/
1789NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
1790PyArray_DescrNew(PyArray_Descr *base)
1791{
  PyArray_Descr *newdescr = PyObject_New(PyArray_Descr, Py_TYPE(base))( (PyArray_Descr *) _PyObject_New((((PyObject*)(base))->ob_type
)) );

  if (newdescr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  /* Don't copy PyObject_HEAD part */
  memcpy((char *)newdescr + sizeof(PyObject),
         (char *)base + sizeof(PyObject),
         sizeof(PyArray_Descr) - sizeof(PyObject));

  /*
   * The c_metadata has a by-value ownership model, need to clone it
   * (basically a deep copy, but the auxdata clone function has some
   * flexibility still) so the new PyArray_Descr object owns
   * a copy of the data. Having both 'base' and 'newdescr' point to
   * the same auxdata pointer would cause a double-free of memory.
   */
  if (base->c_metadata != NULL((void*)0)) {
      newdescr->c_metadata = NPY_AUXDATA_CLONE(base->c_metadata)((base->c_metadata)->clone(base->c_metadata));
      if (newdescr->c_metadata == NULL((void*)0)) {
          PyErr_NoMemory();
          /* TODO: This seems wrong, as the old fields get decref'd? */
          Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
          return NULL((void*)0);
      }
  }

  if (newdescr->fields == Py_None(&_Py_NoneStruct)) {
      newdescr->fields = NULL((void*)0);
  }
  Py_XINCREF(newdescr->fields)_Py_XINCREF(((PyObject*)(newdescr->fields)));
  Py_XINCREF(newdescr->names)_Py_XINCREF(((PyObject*)(newdescr->names)));
  if (newdescr->subarray) {
      newdescr->subarray = PyArray_mallocPyMem_RawMalloc(sizeof(PyArray_ArrayDescr));
      if (newdescr->subarray == NULL((void*)0)) {
          Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
          return (PyArray_Descr *)PyErr_NoMemory();
      }
      memcpy(newdescr->subarray, base->subarray, sizeof(PyArray_ArrayDescr));
      Py_INCREF(newdescr->subarray->shape)_Py_INCREF(((PyObject*)(newdescr->subarray->shape)));
      Py_INCREF(newdescr->subarray->base)_Py_INCREF(((PyObject*)(newdescr->subarray->base)));
  }
  Py_XINCREF(newdescr->typeobj)_Py_XINCREF(((PyObject*)(newdescr->typeobj)));
  Py_XINCREF(newdescr->metadata)_Py_XINCREF(((PyObject*)(newdescr->metadata)));
  newdescr->hash = -1;

  return newdescr;
1839}

1841/*
* should never be called for builtin-types unless
* there is a reference-count problem
*/
1845static void
1846arraydescr_dealloc(PyArray_Descr *self)
1847{
  if (self->fields == Py_None(&_Py_NoneStruct)) {
      fprintf(stderr, "*** Reference count error detected: "__fprintf_chk (stderr, 2 - 1, "*** Reference count error detected: "
 "an attempt was made to deallocate the dtype %d (%c) ***\n",
 self->type_num, self->type)
              "an attempt was made to deallocate the dtype %d (%c) ***\n",__fprintf_chk (stderr, 2 - 1, "*** Reference count error detected: "
 "an attempt was made to deallocate the dtype %d (%c) ***\n",
 self->type_num, self->type)
              self->type_num, self->type)__fprintf_chk (stderr, 2 - 1, "*** Reference count error detected: "
 "an attempt was made to deallocate the dtype %d (%c) ***\n",
 self->type_num, self->type);
      assert(0)((void) (0));
      Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
      Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
      return;
  }
  Py_XDECREF(self->typeobj)_Py_XDECREF(((PyObject*)(self->typeobj)));
  Py_XDECREF(self->names)_Py_XDECREF(((PyObject*)(self->names)));
  Py_XDECREF(self->fields)_Py_XDECREF(((PyObject*)(self->fields)));
  if (self->subarray) {
      Py_XDECREF(self->subarray->shape)_Py_XDECREF(((PyObject*)(self->subarray->shape)));
      Py_DECREF(self->subarray->base)_Py_DECREF(((PyObject*)(self->subarray->base)));
      PyArray_freePyMem_RawFree(self->subarray);
  }
  Py_XDECREF(self->metadata)_Py_XDECREF(((PyObject*)(self->metadata)));
  NPY_AUXDATA_FREE(self->c_metadata)do { if ((self->c_metadata) != ((void*)0)) { (self->c_metadata
)->free(self->c_metadata); } } while(0);
  self->c_metadata = NULL((void*)0);
  Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject *)self);
1869}

1871/*
* we need to be careful about setting attributes because these
* objects are pointed to by arrays that depend on them for interpreting
* data.  Currently no attributes of data-type objects can be set
* directly except names.
*/
1877static PyMemberDef arraydescr_members[] = {
  {"type",
      T_OBJECT6, offsetof(PyArray_Descr, typeobj)__builtin_offsetof(PyArray_Descr, typeobj), READONLY1, NULL((void*)0)},
  {"kind",
      T_CHAR7, offsetof(PyArray_Descr, kind)__builtin_offsetof(PyArray_Descr, kind), READONLY1, NULL((void*)0)},
  {"char",
      T_CHAR7, offsetof(PyArray_Descr, type)__builtin_offsetof(PyArray_Descr, type), READONLY1, NULL((void*)0)},
  {"num",
      T_INT1, offsetof(PyArray_Descr, type_num)__builtin_offsetof(PyArray_Descr, type_num), READONLY1, NULL((void*)0)},
  {"byteorder",
      T_CHAR7, offsetof(PyArray_Descr, byteorder)__builtin_offsetof(PyArray_Descr, byteorder), READONLY1, NULL((void*)0)},
  {"itemsize",
      T_INT1, offsetof(PyArray_Descr, elsize)__builtin_offsetof(PyArray_Descr, elsize), READONLY1, NULL((void*)0)},
  {"alignment",
      T_INT1, offsetof(PyArray_Descr, alignment)__builtin_offsetof(PyArray_Descr, alignment), READONLY1, NULL((void*)0)},
  {"flags",
      T_BYTE8, offsetof(PyArray_Descr, flags)__builtin_offsetof(PyArray_Descr, flags), READONLY1, NULL((void*)0)},
  {NULL((void*)0), 0, 0, 0, NULL((void*)0)},
1895};

1897static PyObject *
1898arraydescr_subdescr_get(PyArray_Descr *self)
1899{
  if (!PyDataType_HASSUBARRAY(self)((self)->subarray != ((void*)0))) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  return Py_BuildValue_Py_BuildValue_SizeT("OO",
          (PyObject *)self->subarray->base, self->subarray->shape);
1905}

1907NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1908arraydescr_protocol_typestr_get(PyArray_Descr *self)
1909{
  char basic_ = self->kind;
  char endian = self->byteorder;
  int size = self->elsize;
  PyObject *ret;

  if (endian == '=') {
      endian = '<';
      if (!PyArray_IsNativeByteOrder(endian)((endian) != '>')) {
          endian = '>';
      }
  }
  if (self->type_num == NPY_UNICODE) {
      size >>= 2;
  }
  if (self->type_num == NPY_OBJECT) {
      ret = PyUnicode_FromFormat("%c%c", endian, basic_);
  }
  else {
      ret = PyUnicode_FromFormat("%c%c%d", endian, basic_, size);
  }
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }

  if (PyDataType_ISDATETIME(self)(((((PyArray_Descr*)(self))->type_num) >=NPY_DATETIME) &&
 ((((PyArray_Descr*)(self))->type_num) <=NPY_TIMEDELTA)
)) {
      PyArray_DatetimeMetaData *meta;
      meta = get_datetime_metadata_from_dtype(self);
      if (meta == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
      PyObject *umeta = metastr_to_unicode(meta, 0);
      if (umeta == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }

      Py_SETREF(ret, PyUnicode_Concat(ret, umeta))do { PyObject *_py_tmp = ((PyObject*)(ret)); (ret) = (PyUnicode_Concat
(ret, umeta)); _Py_DECREF(((PyObject*)(_py_tmp))); } while (0
);
      Py_DECREF(umeta)_Py_DECREF(((PyObject*)(umeta)));
  }
  return ret;
1951}

1953static PyObject *
1954arraydescr_name_get(PyArray_Descr *self)
1955{
  /* let python handle this */
  PyObject *_numpy_dtype;
  PyObject *res;
  _numpy_dtype = PyImport_ImportModule("numpy.core._dtype");
  if (_numpy_dtype == NULL((void*)0)) {
      return NULL((void*)0);
  }
  res = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_dtype, "_name_get", "O", self);
  Py_DECREF(_numpy_dtype)_Py_DECREF(((PyObject*)(_numpy_dtype)));
  return res;
1966}

1968static PyObject *
1969arraydescr_base_get(PyArray_Descr *self)
1970{
  if (!PyDataType_HASSUBARRAY(self)((self)->subarray != ((void*)0))) {
      Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
      return (PyObject *)self;
  }
  Py_INCREF(self->subarray->base)_Py_INCREF(((PyObject*)(self->subarray->base)));
  return (PyObject *)(self->subarray->base);
1977}

1979static PyObject *
1980arraydescr_shape_get(PyArray_Descr *self)
1981{
  if (!PyDataType_HASSUBARRAY(self)((self)->subarray != ((void*)0))) {
      return PyTuple_New(0);
  }
  assert(PyTuple_Check(self->subarray->shape))((void) (0));
  Py_INCREF(self->subarray->shape)_Py_INCREF(((PyObject*)(self->subarray->shape)));
  return self->subarray->shape;
1988}

1990static PyObject *
1991arraydescr_ndim_get(PyArray_Descr *self)
1992{
  Py_ssize_t ndim;

  if (!PyDataType_HASSUBARRAY(self)((self)->subarray != ((void*)0))) {
      return PyLong_FromLong(0);
  }

  /*
   * PyTuple_Size has built in check
   * for tuple argument
   */
  ndim = PyTuple_Size(self->subarray->shape);
  return PyLong_FromLong(ndim);
2005}


2008NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2009arraydescr_protocol_descr_get(PyArray_Descr *self)
2010{
  PyObject *dobj, *res;
  PyObject *_numpy_internal;

  if (!PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      /* get default */
      dobj = PyTuple_New(2);
      if (dobj == NULL((void*)0)) {
          return NULL((void*)0);
      }
      PyTuple_SET_ITEM(dobj, 0, PyUnicode_FromString(""))PyTuple_SetItem(dobj, 0, PyUnicode_FromString(""));
      PyTuple_SET_ITEM(dobj, 1, arraydescr_protocol_typestr_get(self))PyTuple_SetItem(dobj, 1, arraydescr_protocol_typestr_get(self
));
      res = PyList_New(1);
      if (res == NULL((void*)0)) {
          Py_DECREF(dobj)_Py_DECREF(((PyObject*)(dobj)));
          return NULL((void*)0);
      }
      PyList_SET_ITEM(res, 0, dobj)PyList_SetItem(res, 0, dobj);
      return res;
  }

  _numpy_internal = PyImport_ImportModule("numpy.core._internal");
  if (_numpy_internal == NULL((void*)0)) {
      return NULL((void*)0);
  }
  res = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_internal, "_array_descr", "O", self);
  Py_DECREF(_numpy_internal)_Py_DECREF(((PyObject*)(_numpy_internal)));
  return res;
2038}

2040/*
* returns 1 for a builtin type
* and 2 for a user-defined data-type descriptor
* return 0 if neither (i.e. it's a copy of one)
*/
2045static PyObject *
2046arraydescr_isbuiltin_get(PyArray_Descr *self)
2047{
  long val;
  val = 0;
  if (self->fields == Py_None(&_Py_NoneStruct)) {
      val = 1;
  }
  if (PyTypeNum_ISUSERDEF(self->type_num)(((self->type_num) >= NPY_USERDEF) && ((self->
type_num) < NPY_USERDEF+ NPY_NUMUSERTYPES))) {
      val = 2;
  }
  return PyLong_FromLong(val);
2057}

2059static int
2060_arraydescr_isnative(PyArray_Descr *self)
2061{
  if (!PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      return PyArray_ISNBO(self->byteorder)((self->byteorder) != '>');
  }
  else {
      PyObject *key, *value, *title = NULL((void*)0);
      PyArray_Descr *new;
      int offset;
      Py_ssize_t pos = 0;
      while (PyDict_Next(self->fields, &pos, &key, &value)) {
          if (NPY_TITLE_KEY(key, value)(NPY_TITLE_KEY_check((key), (value)))) {
              continue;
          }
          if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(value, "Oi|O", &new, &offset, &title)) {
              return -1;
          }
          if (!_arraydescr_isnative(new)) {
              return 0;
          }
      }
  }
  return 1;
2083}

2085/*
* return Py_True if this data-type descriptor
* has native byteorder if no fields are defined
*
* or if all sub-fields have native-byteorder if
* fields are defined
*/
2092static PyObject *
2093arraydescr_isnative_get(PyArray_Descr *self)
2094{
  PyObject *ret;
  int retval;
  retval = _arraydescr_isnative(self);
  if (retval == -1) {
      return NULL((void*)0);
  }
  ret = retval ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct);
  Py_INCREF(ret)_Py_INCREF(((PyObject*)(ret)));
  return ret;
2104}

2106static PyObject *
2107arraydescr_isalignedstruct_get(PyArray_Descr *self)
2108{
  PyObject *ret;
  ret = (self->flags&NPY_ALIGNED_STRUCT0x80) ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct);
  Py_INCREF(ret)_Py_INCREF(((PyObject*)(ret)));
  return ret;
2113}

2115static PyObject *
2116arraydescr_fields_get(PyArray_Descr *self)
2117{
  if (!PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  return PyDictProxy_New(self->fields);
2122}

2124static PyObject *
2125arraydescr_metadata_get(PyArray_Descr *self)
2126{
  if (self->metadata == NULL((void*)0)) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  return PyDictProxy_New(self->metadata);
2131}

2133static PyObject *
2134arraydescr_hasobject_get(PyArray_Descr *self)
2135{
  if (PyDataType_FLAGCHK(self, NPY_ITEM_HASOBJECT)(((self)->flags & (0x01)) == (0x01))) {
      Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct);
  }
  else {
      Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);
  }
2142}

2144static PyObject *
2145arraydescr_names_get(PyArray_Descr *self)
2146{
  if (!PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  Py_INCREF(self->names)_Py_INCREF(((PyObject*)(self->names)));
  return self->names;
2152}

2154static int
2155arraydescr_names_set(PyArray_Descr *self, PyObject *val)
2156{
  int N = 0;
  int i;
  PyObject *new_names;
  PyObject *new_fields;

  if (val == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete dtype names attribute");
      return -1;
  }
  if (!PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      PyErr_SetString(PyExc_ValueError,
              "there are no fields defined");
      return -1;
  }

  /*
   * FIXME
   *
   * This deprecation has been temporarily removed for the NumPy 1.7
   * release. It should be re-added after the 1.7 branch is done,
   * and a convenience API to replace the typical use-cases for
   * mutable names should be implemented.
   *
   * if (DEPRECATE("Setting NumPy dtype names is deprecated, the dtype "
   *                "will become immutable in a future version") < 0) {
   *     return -1;
   * }
   */

  N = PyTuple_GET_SIZE(self->names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(self->names
))))->ob_size);
  if (!PySequence_Check(val) || PyObject_Size((PyObject *)val) != N) {
      PyErr_Format(PyExc_ValueError,
              "must replace all names at once with a sequence of length %d",
              N);
      return -1;
  }
  /* Make sure all entries are strings */
  for (i = 0; i < N; i++) {
      PyObject *item;
      int valid = 1;
      item = PySequence_GetItem(val, i);
      valid = PyUnicode_Check(item)((((((PyObject*)(item))->ob_type))->tp_flags & ((1UL
 << 28))) != 0);
      Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
      if (!valid) {
          PyErr_Format(PyExc_ValueError,
                  "item #%d of names is of type %s and not string",
                  i, Py_TYPE(item)(((PyObject*)(item))->ob_type)->tp_name);
          return -1;
      }
  }
  /* Invalidate cached hash value */
  self->hash = -1;
  /* Update dictionary keys in fields */
  new_names = PySequence_Tuple(val);
  if (new_names == NULL((void*)0)) {
      return -1;
  }
  new_fields = PyDict_New();
  if (new_fields == NULL((void*)0)) {
      Py_DECREF(new_names)_Py_DECREF(((PyObject*)(new_names)));
      return -1;
  }
  for (i = 0; i < N; i++) {
      PyObject *key;
      PyObject *item;
      PyObject *new_key;
      int ret;
      key = PyTuple_GET_ITEM(self->names, i)((((void) (0)), (PyTupleObject *)(self->names))->ob_item
[i]);
      /* Borrowed references to item and new_key */
      item = PyDict_GetItemWithError(self->fields, key);
      if (item == NULL((void*)0)) {
          if (!PyErr_Occurred()) {
              /* fields was missing the name it claimed to contain */
              PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 2231);
          }
          Py_DECREF(new_names)_Py_DECREF(((PyObject*)(new_names)));
          Py_DECREF(new_fields)_Py_DECREF(((PyObject*)(new_fields)));
          return -1;
      }
      new_key = PyTuple_GET_ITEM(new_names, i)((((void) (0)), (PyTupleObject *)(new_names))->ob_item[i]);
      /* Check for duplicates */
      ret = PyDict_Contains(new_fields, new_key);
      if (ret < 0) {
          Py_DECREF(new_names)_Py_DECREF(((PyObject*)(new_names)));
          Py_DECREF(new_fields)_Py_DECREF(((PyObject*)(new_fields)));
          return -1;
      }
      else if (ret != 0) {
          PyErr_SetString(PyExc_ValueError, "Duplicate field names given.");
          Py_DECREF(new_names)_Py_DECREF(((PyObject*)(new_names)));
          Py_DECREF(new_fields)_Py_DECREF(((PyObject*)(new_fields)));
          return -1;
      }
      if (PyDict_SetItem(new_fields, new_key, item) < 0) {
          Py_DECREF(new_names)_Py_DECREF(((PyObject*)(new_names)));
          Py_DECREF(new_fields)_Py_DECREF(((PyObject*)(new_fields)));
          return -1;
      }
  }

  /* Replace names */
  Py_DECREF(self->names)_Py_DECREF(((PyObject*)(self->names)));
  self->names = new_names;

  /* Replace fields */
  Py_DECREF(self->fields)_Py_DECREF(((PyObject*)(self->fields)));
  self->fields = new_fields;

  return 0;
2267}

2269static PyGetSetDef arraydescr_getsets[] = {
  {"subdtype",
      (getter)arraydescr_subdescr_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"descr",
      (getter)arraydescr_protocol_descr_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"str",
      (getter)arraydescr_protocol_typestr_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"name",
      (getter)arraydescr_name_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"base",
      (getter)arraydescr_base_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"shape",
      (getter)arraydescr_shape_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"ndim",
      (getter)arraydescr_ndim_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"isbuiltin",
      (getter)arraydescr_isbuiltin_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"isnative",
      (getter)arraydescr_isnative_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"isalignedstruct",
      (getter)arraydescr_isalignedstruct_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"fields",
      (getter)arraydescr_fields_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"metadata",
      (getter)arraydescr_metadata_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"names",
      (getter)arraydescr_names_get,
      (setter)arraydescr_names_set,
      NULL((void*)0), NULL((void*)0)},
  {"hasobject",
      (getter)arraydescr_hasobject_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)},
2314};

2316static PyObject *
2317arraydescr_new(PyTypeObject *subtype,
              PyObject *args, PyObject *kwds)
2319{
  if (subtype != &PyArrayDescr_Type(*(PyTypeObject *)(&PyArrayDescr_TypeFull))) {
      /* The DTypeMeta class should prevent this from happening. */
      PyErr_Format(PyExc_SystemError,
              "'%S' must not inherit np.dtype.__new__().", subtype);
      return NULL((void*)0);
  }

  PyObject *odescr, *metadata=NULL((void*)0);
  PyArray_Descr *descr, *conv;
  npy_bool align = NPY_FALSE0;
  npy_bool copy = NPY_FALSE0;
  npy_bool copied = NPY_FALSE0;

  static char *kwlist[] = {"dtype", "align", "copy", "metadata", NULL((void*)0)};

  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, kwds, "O|O&O&O!:dtype", kwlist,
              &odescr,
              PyArray_BoolConverter, &align,
              PyArray_BoolConverter, &copy,
              &PyDict_Type, &metadata)) {
      return NULL((void*)0);
  }

  conv = _convert_from_any(odescr, align);
  if (conv == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* Get a new copy of it unless it's already a copy */
  if (copy && conv->fields == Py_None(&_Py_NoneStruct)) {
      descr = PyArray_DescrNew(conv);
      Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
      conv = descr;
      copied = NPY_TRUE1;
  }

  if ((metadata != NULL((void*)0))) {
      /*
       * We need to be sure to make a new copy of the data-type and any
       * underlying dictionary
       */
      if (!copied) {
          copied = NPY_TRUE1;
          descr = PyArray_DescrNew(conv);
          Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
          conv = descr;
      }
      if ((conv->metadata != NULL((void*)0))) {
          /*
           * Make a copy of the metadata before merging with the
           * input metadata so that this data-type descriptor has
           * it's own copy
           */
          /* Save a reference */
          odescr = conv->metadata;
          conv->metadata = PyDict_Copy(odescr);
          /* Decrement the old reference */
          Py_DECREF(odescr)_Py_DECREF(((PyObject*)(odescr)));

          /*
           * Update conv->metadata with anything new in metadata
           * keyword, but do not over-write anything already there
           */
          if (PyDict_Merge(conv->metadata, metadata, 0) != 0) {
              Py_DECREF(conv)_Py_DECREF(((PyObject*)(conv)));
              return NULL((void*)0);
          }
      }
      else {
          /* Make a copy of the input dictionary */
          conv->metadata = PyDict_Copy(metadata);
      }
  }

  return (PyObject *)conv;
2395}


2398/*
* Return a tuple of
* (cleaned metadata dictionary, tuple with (str, num))
*/
2402static PyObject *
2403_get_pickleabletype_from_datetime_metadata(PyArray_Descr *dtype)
2404{
  PyObject *ret, *dt_tuple;
  PyArray_DatetimeMetaData *meta;

  /* Create the 2-item tuple to return */
  ret = PyTuple_New(2);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* Store the metadata dictionary */
  if (dtype->metadata != NULL((void*)0)) {
      Py_INCREF(dtype->metadata)_Py_INCREF(((PyObject*)(dtype->metadata)));
      PyTuple_SET_ITEM(ret, 0, dtype->metadata)PyTuple_SetItem(ret, 0, dtype->metadata);
  } else {
      PyTuple_SET_ITEM(ret, 0, PyDict_New())PyTuple_SetItem(ret, 0, PyDict_New());
  }

  /* Convert the datetime metadata into a tuple */
  meta = get_datetime_metadata_from_dtype(dtype);
  if (meta == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return NULL((void*)0);
  }
  /* Use a 4-tuple that numpy 1.6 knows how to unpickle */
  dt_tuple = PyTuple_New(4);
  if (dt_tuple == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return NULL((void*)0);
  }
  PyTuple_SET_ITEM(dt_tuple, 0,PyTuple_SetItem(dt_tuple, 0, PyBytes_FromString(_datetime_strings
[meta->base]))
          PyBytes_FromString(_datetime_strings[meta->base]))PyTuple_SetItem(dt_tuple, 0, PyBytes_FromString(_datetime_strings
[meta->base]));
  PyTuple_SET_ITEM(dt_tuple, 1,PyTuple_SetItem(dt_tuple, 1, PyLong_FromLong(meta->num))
          PyLong_FromLong(meta->num))PyTuple_SetItem(dt_tuple, 1, PyLong_FromLong(meta->num));
  PyTuple_SET_ITEM(dt_tuple, 2,PyTuple_SetItem(dt_tuple, 2, PyLong_FromLong(1))
          PyLong_FromLong(1))PyTuple_SetItem(dt_tuple, 2, PyLong_FromLong(1));
  PyTuple_SET_ITEM(dt_tuple, 3,PyTuple_SetItem(dt_tuple, 3, PyLong_FromLong(1))
          PyLong_FromLong(1))PyTuple_SetItem(dt_tuple, 3, PyLong_FromLong(1));

  PyTuple_SET_ITEM(ret, 1, dt_tuple)PyTuple_SetItem(ret, 1, dt_tuple);

  return ret;
2446}

2448/*
* return a tuple of (callable object, args, state).
*
* TODO: This method needs to change so that unpickling doesn't
*       use __setstate__. This is required for the dtype
*       to be an immutable object.
*/
2455static PyObject *
2456arraydescr_reduce(PyArray_Descr *self, PyObject *NPY_UNUSED(args)(__NPY_UNUSED_TAGGEDargs) __attribute__ ((__unused__)))
2457{
  /*
   * version number of this pickle type. Increment if we need to
   * change the format. Be sure to handle the old versions in
   * arraydescr_setstate.
  */
  const int version = 4;
  PyObject *ret, *mod, *obj;
  PyObject *state;
  char endian;
  int elsize, alignment;

  ret = PyTuple_New(3);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  mod = PyImport_ImportModule("numpy.core._multiarray_umath");
  if (mod == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return NULL((void*)0);
  }
  obj = PyObject_GetAttrString(mod, "dtype");
  Py_DECREF(mod)_Py_DECREF(((PyObject*)(mod)));
  if (obj == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return NULL((void*)0);
  }
  PyTuple_SET_ITEM(ret, 0, obj)PyTuple_SetItem(ret, 0, obj);
  if (PyTypeNum_ISUSERDEF(self->type_num)(((self->type_num) >= NPY_USERDEF) && ((self->
type_num) < NPY_USERDEF+ NPY_NUMUSERTYPES))
          || ((self->type_num == NPY_VOID
                  && self->typeobj != &PyVoidArrType_Type))) {
      obj = (PyObject *)self->typeobj;
      Py_INCREF(obj)_Py_INCREF(((PyObject*)(obj)));
  }
  else {
      elsize = self->elsize;
      if (self->type_num == NPY_UNICODE) {
          elsize >>= 2;
      }
      obj = PyUnicode_FromFormat("%c%d",self->kind, elsize);
  }
  PyTuple_SET_ITEM(ret, 1, Py_BuildValue("(NOO)", obj, Py_False, Py_True))PyTuple_SetItem(ret, 1, _Py_BuildValue_SizeT("(NOO)", obj, ((
PyObject *) &_Py_FalseStruct), ((PyObject *) &_Py_TrueStruct
)));

  /*
   * Now return the state which is at least byteorder,
   * subarray, and fields
   */
  endian = self->byteorder;
  if (endian == '=') {
      endian = '<';
      if (!PyArray_IsNativeByteOrder(endian)((endian) != '>')) {
          endian = '>';
      }
  }
  if (PyDataType_ISDATETIME(self)(((((PyArray_Descr*)(self))->type_num) >=NPY_DATETIME) &&
 ((((PyArray_Descr*)(self))->type_num) <=NPY_TIMEDELTA)
)) {
      PyObject *newobj;
      state = PyTuple_New(9);
      PyTuple_SET_ITEM(state, 0, PyLong_FromLong(version))PyTuple_SetItem(state, 0, PyLong_FromLong(version));
      /*
       * newobj is a tuple of the Python metadata dictionary
       * and tuple of date_time info (str, num)
       */
      newobj = _get_pickleabletype_from_datetime_metadata(self);
      if (newobj == NULL((void*)0)) {
          Py_DECREF(state)_Py_DECREF(((PyObject*)(state)));
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
      PyTuple_SET_ITEM(state, 8, newobj)PyTuple_SetItem(state, 8, newobj);
  }
  else if (self->metadata) {
      state = PyTuple_New(9);
      PyTuple_SET_ITEM(state, 0, PyLong_FromLong(version))PyTuple_SetItem(state, 0, PyLong_FromLong(version));
      Py_INCREF(self->metadata)_Py_INCREF(((PyObject*)(self->metadata)));
      PyTuple_SET_ITEM(state, 8, self->metadata)PyTuple_SetItem(state, 8, self->metadata);
  }
  else { /* Use version 3 pickle format */
      state = PyTuple_New(8);
      PyTuple_SET_ITEM(state, 0, PyLong_FromLong(3))PyTuple_SetItem(state, 0, PyLong_FromLong(3));
  }

  PyTuple_SET_ITEM(state, 1, PyUnicode_FromFormat("%c", endian))PyTuple_SetItem(state, 1, PyUnicode_FromFormat("%c", endian));
  PyTuple_SET_ITEM(state, 2, arraydescr_subdescr_get(self))PyTuple_SetItem(state, 2, arraydescr_subdescr_get(self));
  if (PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      Py_INCREF(self->names)_Py_INCREF(((PyObject*)(self->names)));
      Py_INCREF(self->fields)_Py_INCREF(((PyObject*)(self->fields)));
      PyTuple_SET_ITEM(state, 3, self->names)PyTuple_SetItem(state, 3, self->names);
      PyTuple_SET_ITEM(state, 4, self->fields)PyTuple_SetItem(state, 4, self->fields);
  }
  else {
      PyTuple_SET_ITEM(state, 3, Py_None)PyTuple_SetItem(state, 3, (&_Py_NoneStruct));
      PyTuple_SET_ITEM(state, 4, Py_None)PyTuple_SetItem(state, 4, (&_Py_NoneStruct));
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  }

  /* for extended types it also includes elsize and alignment */
  if (PyTypeNum_ISEXTENDED(self->type_num)((((self->type_num) >=NPY_STRING) && ((self->
type_num) <=NPY_VOID)) || (((self->type_num) >= NPY_USERDEF
) && ((self->type_num) < NPY_USERDEF+ NPY_NUMUSERTYPES
)))) {
      elsize = self->elsize;
      alignment = self->alignment;
  }
  else {
      elsize = -1;
      alignment = -1;
  }
  PyTuple_SET_ITEM(state, 5, PyLong_FromLong(elsize))PyTuple_SetItem(state, 5, PyLong_FromLong(elsize));
  PyTuple_SET_ITEM(state, 6, PyLong_FromLong(alignment))PyTuple_SetItem(state, 6, PyLong_FromLong(alignment));
  PyTuple_SET_ITEM(state, 7, PyLong_FromLong(self->flags))PyTuple_SetItem(state, 7, PyLong_FromLong(self->flags));

  PyTuple_SET_ITEM(ret, 2, state)PyTuple_SetItem(ret, 2, state);
  return ret;
2568}

2570/*
* returns NPY_OBJECT_DTYPE_FLAGS if this data-type has an object portion used
* when setting the state because hasobject is not stored.
*/
2574static char
2575_descr_find_object(PyArray_Descr *self)
2576{
  if (self->flags
          || self->type_num == NPY_OBJECT
          || self->kind == 'O') {
      return NPY_OBJECT_DTYPE_FLAGS(0x02 | 0x20 | 0x04 | 0x01 | 0x08 | 0x10);
  }
  if (PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      PyObject *key, *value, *title = NULL((void*)0);
      PyArray_Descr *new;
      int offset;
      Py_ssize_t pos = 0;

      while (PyDict_Next(self->fields, &pos, &key, &value)) {
          if (NPY_TITLE_KEY(key, value)(NPY_TITLE_KEY_check((key), (value)))) {
              continue;
          }
          if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(value, "Oi|O", &new, &offset, &title)) {
              PyErr_Clear();
              return 0;
          }
          if (_descr_find_object(new)) {
              new->flags = NPY_OBJECT_DTYPE_FLAGS(0x02 | 0x20 | 0x04 | 0x01 | 0x08 | 0x10);
              return NPY_OBJECT_DTYPE_FLAGS(0x02 | 0x20 | 0x04 | 0x01 | 0x08 | 0x10);
          }
      }
  }
  return 0;
2603}

2605/*
* state is at least byteorder, subarray, and fields but could include elsize
* and alignment for EXTENDED arrays
*/
2609static PyObject *
2610arraydescr_setstate(PyArray_Descr *self, PyObject *args)
2611{
  int elsize = -1, alignment = -1;
  int version = 4;
  char endian;
  PyObject *endian_obj;
  PyObject *subarray, *fields, *names = NULL((void*)0), *metadata=NULL((void*)0);
  int incref_names = 1;
  int int_dtypeflags = 0;
  char dtypeflags;

  if (self->fields == Py_None(&_Py_NoneStruct)) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  if (PyTuple_GET_SIZE(args)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(args))))->
ob_size) != 1
          || !(PyTuple_Check(PyTuple_GET_ITEM(args, 0))((((((PyObject*)(((((void) (0)), (PyTupleObject *)(args))->
ob_item[0])))->ob_type))->tp_flags & ((1UL <<
 26))) != 0))) {
      PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 2626);
      return NULL((void*)0);
  }
  switch (PyTuple_GET_SIZE(PyTuple_GET_ITEM(args,0))(((PyVarObject*)((((void) (0)), (PyTupleObject *)(((((void) (
0)), (PyTupleObject *)(args))->ob_item[0])))))->ob_size
)) {
  case 9:
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(iOOOOiiiO):__setstate__",
                  &version, &endian_obj,
                  &subarray, &names, &fields, &elsize,
                  &alignment, &int_dtypeflags, &metadata)) {
          PyErr_Clear();
          return NULL((void*)0);
      }
      break;
  case 8:
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(iOOOOiii):__setstate__",
                  &version, &endian_obj,
                  &subarray, &names, &fields, &elsize,
                  &alignment, &int_dtypeflags)) {
          return NULL((void*)0);
      }
      break;
  case 7:
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(iOOOOii):__setstate__",
                  &version, &endian_obj,
                  &subarray, &names, &fields, &elsize,
                  &alignment)) {
          return NULL((void*)0);
      }
      break;
  case 6:
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(iOOOii):__setstate__",
                  &version,
                  &endian_obj, &subarray, &fields,
                  &elsize, &alignment)) {
          return NULL((void*)0);
      }
      break;
  case 5:
      version = 0;
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "(OOOii):__setstate__",
                  &endian_obj, &subarray, &fields, &elsize,
                  &alignment)) {
          return NULL((void*)0);
      }
      break;
  default:
      /* raise an error */
      if (PyTuple_GET_SIZE(PyTuple_GET_ITEM(args,0))(((PyVarObject*)((((void) (0)), (PyTupleObject *)(((((void) (
0)), (PyTupleObject *)(args))->ob_item[0])))))->ob_size
) > 5) {
          version = PyLong_AsLong(PyTuple_GET_ITEM(args, 0)((((void) (0)), (PyTupleObject *)(args))->ob_item[0]));
      }
      else {
          version = -1;
      }
  }

  /*
   * If we ever need another pickle format, increment the version
   * number. But we should still be able to handle the old versions.
   */
  if (version < 0 || version > 4) {
      PyErr_Format(PyExc_ValueError,
                   "can't handle version %d of numpy.dtype pickle",
                   version);
      return NULL((void*)0);
  }
  /* Invalidate cached hash value */
  self->hash = -1;

  if (version == 1 || version == 0) {
      if (fields != Py_None(&_Py_NoneStruct)) {
          PyObject *key, *list;
          key = PyLong_FromLong(-1);
          list = PyDict_GetItemWithError(fields, key);
          if (!list) {
              if (!PyErr_Occurred()) {
                  /* fields was missing the name it claimed to contain */
                  PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 2702);
              }
              return NULL((void*)0);
          }
          Py_INCREF(list)_Py_INCREF(((PyObject*)(list)));
          names = list;
          PyDict_DelItem(fields, key);
          incref_names = 0;
      }
      else {
          names = Py_None(&_Py_NoneStruct);
      }
  }

  /* Parse endian */
  if (PyUnicode_Check(endian_obj)((((((PyObject*)(endian_obj))->ob_type))->tp_flags &
 ((1UL << 28))) != 0) || PyBytes_Check(endian_obj)((((((PyObject*)(endian_obj))->ob_type))->tp_flags &
 ((1UL << 27))) != 0)) {
      PyObject *tmp = NULL((void*)0);
      char *str;
      Py_ssize_t len;

      if (PyUnicode_Check(endian_obj)((((((PyObject*)(endian_obj))->ob_type))->tp_flags &
 ((1UL << 28))) != 0)) {
          tmp = PyUnicode_AsASCIIString(endian_obj);
          if (tmp == NULL((void*)0)) {
              return NULL((void*)0);
          }
          endian_obj = tmp;
      }

      if (PyBytes_AsStringAndSize(endian_obj, &str, &len) < 0) {
          Py_XDECREF(tmp)_Py_XDECREF(((PyObject*)(tmp)));
          return NULL((void*)0);
      }
      if (len != 1) {
          PyErr_SetString(PyExc_ValueError,
                          "endian is not 1-char string in Numpy dtype unpickling");
          Py_XDECREF(tmp)_Py_XDECREF(((PyObject*)(tmp)));
          return NULL((void*)0);
      }
      endian = str[0];
      Py_XDECREF(tmp)_Py_XDECREF(((PyObject*)(tmp)));
  }
  else {
      PyErr_SetString(PyExc_ValueError,
                      "endian is not a string in Numpy dtype unpickling");
      return NULL((void*)0);
  }

  if ((fields == Py_None(&_Py_NoneStruct) && names != Py_None(&_Py_NoneStruct)) ||
      (names == Py_None(&_Py_NoneStruct) && fields != Py_None(&_Py_NoneStruct))) {
      PyErr_Format(PyExc_ValueError,
              "inconsistent fields and names in Numpy dtype unpickling");
      return NULL((void*)0);
  }

  if (names != Py_None(&_Py_NoneStruct) && !PyTuple_Check(names)((((((PyObject*)(names))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
      PyErr_Format(PyExc_ValueError,
              "non-tuple names in Numpy dtype unpickling");
      return NULL((void*)0);
  }

  if (fields != Py_None(&_Py_NoneStruct) && !PyDict_Check(fields)((((((PyObject*)(fields))->ob_type))->tp_flags & ((
1UL << 29))) != 0)) {
      PyErr_Format(PyExc_ValueError,
              "non-dict fields in Numpy dtype unpickling");
      return NULL((void*)0);
  }

  if (endian != '|' && PyArray_IsNativeByteOrder(endian)((endian) != '>')) {
      endian = '=';
  }
  self->byteorder = endian;
  if (self->subarray) {
      Py_XDECREF(self->subarray->base)_Py_XDECREF(((PyObject*)(self->subarray->base)));
      Py_XDECREF(self->subarray->shape)_Py_XDECREF(((PyObject*)(self->subarray->shape)));
      PyArray_freePyMem_RawFree(self->subarray);
  }
  self->subarray = NULL((void*)0);

  if (subarray != Py_None(&_Py_NoneStruct)) {
      PyObject *subarray_shape;

      /*
       * Ensure that subarray[0] is an ArrayDescr and
       * that subarray_shape obtained from subarray[1] is a tuple of integers.
       */
      if (!(PyTuple_Check(subarray)((((((PyObject*)(subarray))->ob_type))->tp_flags & (
(1UL << 26))) != 0) &&
            PyTuple_Size(subarray) == 2 &&
            PyArray_DescrCheck(PyTuple_GET_ITEM(subarray, 0))((((PyObject*)(((((void) (0)), (PyTupleObject *)(subarray))->
ob_item[0])))->ob_type) == (&(*(PyTypeObject *)(&PyArrayDescr_TypeFull
))) || PyType_IsSubtype((((PyObject*)(((((void) (0)), (PyTupleObject
 *)(subarray))->ob_item[0])))->ob_type), (&(*(PyTypeObject
 *)(&PyArrayDescr_TypeFull))))))) {
          PyErr_Format(PyExc_ValueError,
                       "incorrect subarray in __setstate__");
          return NULL((void*)0);
      }
      subarray_shape = PyTuple_GET_ITEM(subarray, 1)((((void) (0)), (PyTupleObject *)(subarray))->ob_item[1]);
      if (PyNumber_Check(subarray_shape)) {
          PyObject *tmp;
          tmp = PyNumber_Long(subarray_shape);
          if (tmp == NULL((void*)0)) {
              return NULL((void*)0);
          }
          subarray_shape = Py_BuildValue_Py_BuildValue_SizeT("(O)", tmp);
          Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
          if (subarray_shape == NULL((void*)0)) {
              return NULL((void*)0);
          }
      }
      else if (_is_tuple_of_integers(subarray_shape)) {
          Py_INCREF(subarray_shape)_Py_INCREF(((PyObject*)(subarray_shape)));
      }
      else {
          PyErr_Format(PyExc_ValueError,
                       "incorrect subarray shape in __setstate__");
          return NULL((void*)0);
      }

      self->subarray = PyArray_mallocPyMem_RawMalloc(sizeof(PyArray_ArrayDescr));
      if (!PyDataType_HASSUBARRAY(self)((self)->subarray != ((void*)0))) {
          return PyErr_NoMemory();
      }
      self->subarray->base = (PyArray_Descr *)PyTuple_GET_ITEM(subarray, 0)((((void) (0)), (PyTupleObject *)(subarray))->ob_item[0]);
      Py_INCREF(self->subarray->base)_Py_INCREF(((PyObject*)(self->subarray->base)));
      self->subarray->shape = subarray_shape;
  }

  if (fields != Py_None(&_Py_NoneStruct)) {
      /*
       * Ensure names are of appropriate string type
       */
      Py_ssize_t i;
      int names_ok = 1;
      PyObject *name;

      for (i = 0; i < PyTuple_GET_SIZE(names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(names))))->
ob_size); ++i) {
          name = PyTuple_GET_ITEM(names, i)((((void) (0)), (PyTupleObject *)(names))->ob_item[i]);
          if (!PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
              names_ok = 0;
              break;
          }
      }

      if (names_ok) {
          Py_XDECREF(self->fields)_Py_XDECREF(((PyObject*)(self->fields)));
          self->fields = fields;
          Py_INCREF(fields)_Py_INCREF(((PyObject*)(fields)));
          Py_XDECREF(self->names)_Py_XDECREF(((PyObject*)(self->names)));
          self->names = names;
          if (incref_names) {
              Py_INCREF(names)_Py_INCREF(((PyObject*)(names)));
          }
      }
      else {
          /*
           * To support pickle.load(f, encoding='bytes') for loading Py2
           * generated pickles on Py3, we need to be more lenient and convert
           * field names from byte strings to unicode.
           */
          PyObject *tmp, *new_name, *field;

          tmp = PyDict_New();
          if (tmp == NULL((void*)0)) {
              return NULL((void*)0);
          }
          Py_XDECREF(self->fields)_Py_XDECREF(((PyObject*)(self->fields)));
          self->fields = tmp;

          tmp = PyTuple_New(PyTuple_GET_SIZE(names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(names))))->
ob_size));
          if (tmp == NULL((void*)0)) {
              return NULL((void*)0);
          }
          Py_XDECREF(self->names)_Py_XDECREF(((PyObject*)(self->names)));
          self->names = tmp;

          for (i = 0; i < PyTuple_GET_SIZE(names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(names))))->
ob_size); ++i) {
              name = PyTuple_GET_ITEM(names, i)((((void) (0)), (PyTupleObject *)(names))->ob_item[i]);
              field = PyDict_GetItemWithError(fields, name);
              if (!field) {
                  if (!PyErr_Occurred()) {
                      /* fields was missing the name it claimed to contain */
                      PyErr_BadInternalCall()_PyErr_BadInternalCall("/tmp/pyrefcon/numpy/numpy/core/src/multiarray/descriptor.c"
, 2878);
                  }
                  return NULL((void*)0);
              }

              if (PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
                  new_name = name;
                  Py_INCREF(new_name)_Py_INCREF(((PyObject*)(new_name)));
              }
              else {
                  new_name = PyUnicode_FromEncodedObject(name, "ASCII", "strict");
                  if (new_name == NULL((void*)0)) {
                      return NULL((void*)0);
                  }
              }

              PyTuple_SET_ITEM(self->names, i, new_name)PyTuple_SetItem(self->names, i, new_name);
              if (PyDict_SetItem(self->fields, new_name, field) != 0) {
                  return NULL((void*)0);
              }
          }
      }
  }

  if (PyTypeNum_ISEXTENDED(self->type_num)((((self->type_num) >=NPY_STRING) && ((self->
type_num) <=NPY_VOID)) || (((self->type_num) >= NPY_USERDEF
) && ((self->type_num) < NPY_USERDEF+ NPY_NUMUSERTYPES
)))) {
      self->elsize = elsize;
      self->alignment = alignment;
  }

  /*
   * We use an integer converted to char for backward compatibility with
   * pickled arrays. Pickled arrays created with previous versions encoded
   * flags as an int even though it actually was a char in the PyArray_Descr
   * structure
   */
  dtypeflags = int_dtypeflags;
  if (dtypeflags != int_dtypeflags) {
      PyErr_Format(PyExc_ValueError,
                   "incorrect value for flags variable (overflow)");
      return NULL((void*)0);
  }
  else {
      self->flags = dtypeflags;
  }

  if (version < 3) {
      self->flags = _descr_find_object(self);
  }

  /*
   * We have a borrowed reference to metadata so no need
   * to alter reference count when throwing away Py_None.
   */
  if (metadata == Py_None(&_Py_NoneStruct)) {
      metadata = NULL((void*)0);
  }

  if (PyDataType_ISDATETIME(self)(((((PyArray_Descr*)(self))->type_num) >=NPY_DATETIME) &&
 ((((PyArray_Descr*)(self))->type_num) <=NPY_TIMEDELTA)
) && (metadata != NULL((void*)0))) {
      PyObject *old_metadata;
      PyArray_DatetimeMetaData temp_dt_data;

      if ((! PyTuple_Check(metadata)((((((PyObject*)(metadata))->ob_type))->tp_flags & (
(1UL << 26))) != 0)) || (PyTuple_Size(metadata) != 2)) {
          PyErr_Format(PyExc_ValueError,
                  "Invalid datetime dtype (metadata, c_metadata): %R",
                  metadata);
          return NULL((void*)0);
      }

      if (convert_datetime_metadata_tuple_to_datetime_metadata(
                                  PyTuple_GET_ITEM(metadata, 1)((((void) (0)), (PyTupleObject *)(metadata))->ob_item[1]),
                                  &temp_dt_data,
                                  NPY_TRUE1) < 0) {
          return NULL((void*)0);
      }

      old_metadata = self->metadata;
      self->metadata = PyTuple_GET_ITEM(metadata, 0)((((void) (0)), (PyTupleObject *)(metadata))->ob_item[0]);
      memcpy((char *) &((PyArray_DatetimeDTypeMetaData *)self->c_metadata)->meta,
             (char *) &temp_dt_data,
             sizeof(PyArray_DatetimeMetaData));
      Py_XINCREF(self->metadata)_Py_XINCREF(((PyObject*)(self->metadata)));
      Py_XDECREF(old_metadata)_Py_XDECREF(((PyObject*)(old_metadata)));
  }
  else {
      PyObject *old_metadata = self->metadata;
      self->metadata = metadata;
      Py_XINCREF(self->metadata)_Py_XINCREF(((PyObject*)(self->metadata)));
      Py_XDECREF(old_metadata)_Py_XDECREF(((PyObject*)(old_metadata)));
  }

  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
2969}

2971/*NUMPY_API
*
* Get type-descriptor from an object forcing alignment if possible
* None goes to DEFAULT type.
*
* any object with the .fields attribute and/or .itemsize attribute (if the
*.fields attribute does not give the total size -- i.e. a partial record
* naming).  If itemsize is given it must be >= size computed from fields
*
* The .fields attribute must return a convertible dictionary if present.
* Result inherits from NPY_VOID.
2982*/
2983NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2984PyArray_DescrAlignConverter(PyObject *obj, PyArray_Descr **at)
2985{
  *at = _convert_from_any(obj, 1);
  return (*at) ? NPY_SUCCEED1 : NPY_FAIL0;
2988}

2990/*NUMPY_API
*
* Get type-descriptor from an object forcing alignment if possible
* None goes to NULL.
*/
2995NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2996PyArray_DescrAlignConverter2(PyObject *obj, PyArray_Descr **at)
2997{
  if (obj == Py_None(&_Py_NoneStruct)) {
      *at = NULL((void*)0);
      return NPY_SUCCEED1;
  }
  else {
      return PyArray_DescrAlignConverter(obj, at);
  }
3005}



3009/*NUMPY_API
*
* returns a copy of the PyArray_Descr structure with the byteorder
* altered:
* no arguments:  The byteorder is swapped (in all subfields as well)
* single argument:  The byteorder is forced to the given state
* (in all subfields as well)
*
* Valid states:  ('big', '>') or ('little' or '<')
* ('native', or '=')
*
* If a descr structure with | is encountered it's own
* byte-order is not changed but any fields are:
*
*
* Deep bytorder change of a data-type descriptor
* *** Leaves reference count of self unchanged --- does not DECREF self ***
*/
3027NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
3028PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
3029{
  PyArray_Descr *new;
  char endian;

  new = PyArray_DescrNew(self);
  endian = new->byteorder;
  if (endian != NPY_IGNORE'|') {
      if (newendian == NPY_SWAP's') {
          /* swap byteorder */
          if (PyArray_ISNBO(endian)((endian) != '>')) {
              endian = NPY_OPPBYTE'>';
          }
          else {
              endian = NPY_NATBYTE'<';
          }
          new->byteorder = endian;
      }
      else if (newendian != NPY_IGNORE'|') {
          new->byteorder = newendian;
      }
  }
  if (PyDataType_HASFIELDS(new)(((PyArray_Descr *)(new))->names != ((void*)0))) {
      PyObject *newfields;
      PyObject *key, *value;
      PyObject *newvalue;
      PyObject *old;
      PyArray_Descr *newdescr;
      Py_ssize_t pos = 0;
      int len, i;

      newfields = PyDict_New();
      /* make new dictionary with replaced PyArray_Descr Objects */
      while (PyDict_Next(self->fields, &pos, &key, &value)) {
          if (NPY_TITLE_KEY(key, value)(NPY_TITLE_KEY_check((key), (value)))) {
              continue;
          }
          if (!PyUnicode_Check(key)((((((PyObject*)(key))->ob_type))->tp_flags & ((1UL
 << 28))) != 0) || !PyTuple_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
 << 26))) != 0) ||
              ((len=PyTuple_GET_SIZE(value)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(value))))->
ob_size)) < 2)) {
              continue;
          }
          old = PyTuple_GET_ITEM(value, 0)((((void) (0)), (PyTupleObject *)(value))->ob_item[0]);
          if (!PyArray_DescrCheck(old)((((PyObject*)(old))->ob_type) == (&(*(PyTypeObject *)
(&PyArrayDescr_TypeFull))) || PyType_IsSubtype((((PyObject
*)(old))->ob_type), (&(*(PyTypeObject *)(&PyArrayDescr_TypeFull
)))))) {
              continue;
          }
          newdescr = PyArray_DescrNewByteorder(
                  (PyArray_Descr *)old, newendian);
          if (newdescr == NULL((void*)0)) {
              Py_DECREF(newfields)_Py_DECREF(((PyObject*)(newfields))); Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
              return NULL((void*)0);
          }
          newvalue = PyTuple_New(len);
          PyTuple_SET_ITEM(newvalue, 0, (PyObject *)newdescr)PyTuple_SetItem(newvalue, 0, (PyObject *)newdescr);
          for (i = 1; i < len; i++) {
              old = PyTuple_GET_ITEM(value, i)((((void) (0)), (PyTupleObject *)(value))->ob_item[i]);
              Py_INCREF(old)_Py_INCREF(((PyObject*)(old)));
              PyTuple_SET_ITEM(newvalue, i, old)PyTuple_SetItem(newvalue, i, old);
          }
          int ret = PyDict_SetItem(newfields, key, newvalue);
          Py_DECREF(newvalue)_Py_DECREF(((PyObject*)(newvalue)));
          if (ret < 0) {
              Py_DECREF(newfields)_Py_DECREF(((PyObject*)(newfields)));
              Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
              return NULL((void*)0);
          }
      }
      Py_DECREF(new->fields)_Py_DECREF(((PyObject*)(new->fields)));
      new->fields = newfields;
  }
  if (PyDataType_HASSUBARRAY(new)((new)->subarray != ((void*)0))) {
      Py_DECREF(new->subarray->base)_Py_DECREF(((PyObject*)(new->subarray->base)));
      new->subarray->base = PyArray_DescrNewByteorder(
              self->subarray->base, newendian);
  }
  return new;
3103}


3106static PyObject *
3107arraydescr_newbyteorder(PyArray_Descr *self, PyObject *args)
3108{
  char endian=NPY_SWAP's';

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "|O&:newbyteorder", PyArray_ByteorderConverter,
              &endian)) {
      return NULL((void*)0);
  }
  return (PyObject *)PyArray_DescrNewByteorder(self, endian);
3116}

3118static PyMethodDef arraydescr_methods[] = {
  /* for pickling */
  {"__reduce__",
      (PyCFunction)arraydescr_reduce,
      METH_VARARGS0x0001, NULL((void*)0)},
  {"__setstate__",
      (PyCFunction)arraydescr_setstate,
      METH_VARARGS0x0001, NULL((void*)0)},
  {"newbyteorder",
      (PyCFunction)arraydescr_newbyteorder,
      METH_VARARGS0x0001, NULL((void*)0)},
  {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)}           /* sentinel */
3130};

3132/*
* Checks whether the structured data type in 'dtype'
* has a simple layout, where all the fields are in order,
* and follow each other with no alignment padding.
*
* When this returns true, the dtype can be reconstructed
* from a list of the field names and dtypes with no additional
* dtype parameters.
*
* Returns 1 if it has a simple layout, 0 otherwise.
*/
3143NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
3144is_dtype_struct_simple_unaligned_layout(PyArray_Descr *dtype)
3145{
  PyObject *names, *fields, *key, *tup, *title;
  Py_ssize_t i, names_size;
  PyArray_Descr *fld_dtype;
  int fld_offset;
  npy_intp total_offset;

  /* Get some properties from the dtype */
  names = dtype->names;
  names_size = PyTuple_GET_SIZE(names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(names))))->
ob_size);
  fields = dtype->fields;

  /* Start at offset zero */
  total_offset = 0;

  for (i = 0; i < names_size; ++i) {
      key = PyTuple_GET_ITEM(names, i)((((void) (0)), (PyTupleObject *)(names))->ob_item[i]);
      if (key == NULL((void*)0)) {
          return 0;
      }
      tup = PyDict_GetItem(fields, key);
      if (tup == NULL((void*)0)) {
          return 0;
      }
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(tup, "Oi|O", &fld_dtype, &fld_offset, &title)) {
          PyErr_Clear();
          return 0;
      }
      /* If this field doesn't follow the pattern, not a simple layout */
      if (total_offset != fld_offset) {
          return 0;
      }
      /* Get the next offset */
      total_offset += fld_dtype->elsize;
  }

  /*
   * If the itemsize doesn't match the final offset, it's
   * not a simple layout.
   */
  if (total_offset != dtype->elsize) {
      return 0;
  }

  /* It's a simple layout, since all the above tests passed */
  return 1;
3191}

3193/*
* The general dtype repr function.
*/
3196static PyObject *
3197arraydescr_repr(PyArray_Descr *dtype)
3198{
  PyObject *_numpy_dtype;
  PyObject *res;
  _numpy_dtype = PyImport_ImportModule("numpy.core._dtype");
  if (_numpy_dtype == NULL((void*)0)) {
      return NULL((void*)0);
  }
  res = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_dtype, "__repr__", "O", dtype);
  Py_DECREF(_numpy_dtype)_Py_DECREF(((PyObject*)(_numpy_dtype)));
  return res;
3208}
3209/*
* The general dtype str function.
*/
3212static PyObject *
3213arraydescr_str(PyArray_Descr *dtype)
3214{
  PyObject *_numpy_dtype;
  PyObject *res;
  _numpy_dtype = PyImport_ImportModule("numpy.core._dtype");
  if (_numpy_dtype == NULL((void*)0)) {
      return NULL((void*)0);
  }
  res = PyObject_CallMethod_PyObject_CallMethod_SizeT(_numpy_dtype, "__str__", "O", dtype);
  Py_DECREF(_numpy_dtype)_Py_DECREF(((PyObject*)(_numpy_dtype)));
  return res;
3224}

3226static PyObject *
3227arraydescr_richcompare(PyArray_Descr *self, PyObject *other, int cmp_op)
3228{
  PyArray_Descr *new = _convert_from_any(other, 0);
  if (new == NULL((void*)0)) {
      return NULL((void*)0);
  }

  npy_bool ret;
  switch (cmp_op) {
  case Py_LT0:
      ret = !PyArray_EquivTypes(self, new) && PyArray_CanCastTo(self, new);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return PyBool_FromLong(ret);
  case Py_LE1:
      ret = PyArray_CanCastTo(self, new);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return PyBool_FromLong(ret);
  case Py_EQ2:
      ret = PyArray_EquivTypes(self, new);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return PyBool_FromLong(ret);
  case Py_NE3:
      ret = !PyArray_EquivTypes(self, new);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return PyBool_FromLong(ret);
  case Py_GT4:
      ret = !PyArray_EquivTypes(self, new) && PyArray_CanCastTo(new, self);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return PyBool_FromLong(ret);
  case Py_GE5:
      ret = PyArray_CanCastTo(new, self);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return PyBool_FromLong(ret);
  default:
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      Py_RETURN_NOTIMPLEMENTEDreturn _Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct
)))), (&_Py_NotImplementedStruct);
  }
3264}

3266static int
3267descr_nonzero(PyObject *NPY_UNUSED(self)(__NPY_UNUSED_TAGGEDself) __attribute__ ((__unused__)))
3268{
  /* `bool(np.dtype(...)) == True` for all dtypes. Needed to override default
   * nonzero implementation, which checks if `len(object) > 0`. */
  return 1;
3272}

3274static PyNumberMethods descr_as_number = {
  .nb_bool = (inquiry)descr_nonzero,
3276};

3278/*************************************************************************
****************   Implement Mapping Protocol ***************************
*************************************************************************/

3282static Py_ssize_t
3283descr_length(PyObject *self0)
3284{
  PyArray_Descr *self = (PyArray_Descr *)self0;

  if (PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      return PyTuple_GET_SIZE(self->names)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(self->names
))))->ob_size);
  }
  else {
      return 0;
  }
3293}

3295static PyObject *
3296descr_repeat(PyObject *self, Py_ssize_t length)
3297{
  PyObject *tup;
  PyArray_Descr *new;
  if (length < 0) {
      return PyErr_Format(PyExc_ValueError,
              "Array length must be >= 0, not %"NPY_INTP_FMT"ld", (npy_intp)length);
  }
  tup = Py_BuildValue_Py_BuildValue_SizeT("O" NPY_SSIZE_T_PYFMT"n", self, length);
  if (tup == NULL((void*)0)) {
      return NULL((void*)0);
  }
  new = _convert_from_any(tup, 0);
  Py_DECREF(tup)_Py_DECREF(((PyObject*)(tup)));
  return (PyObject *)new;
3311}

3313static int
3314_check_has_fields(PyArray_Descr *self)
3315{
  if (!PyDataType_HASFIELDS(self)(((PyArray_Descr *)(self))->names != ((void*)0))) {
      PyErr_Format(PyExc_KeyError, "There are no fields in dtype %S.", self);
      return -1;
  }
  else {
      return 0;
  }
3323}

3325static PyObject *
3326_subscript_by_name(PyArray_Descr *self, PyObject *op)
3327{
  PyObject *obj = PyDict_GetItemWithError(self->fields, op);
  if (obj == NULL((void*)0)) {
      if (!PyErr_Occurred()) {
          PyErr_Format(PyExc_KeyError,
                  "Field named %R not found.", op);
      }
      return NULL((void*)0);
  }
  PyObject *descr = PyTuple_GET_ITEM(obj, 0)((((void) (0)), (PyTupleObject *)(obj))->ob_item[0]);
  Py_INCREF(descr)_Py_INCREF(((PyObject*)(descr)));
  return descr;
3339}

3341static PyObject *
3342_subscript_by_index(PyArray_Descr *self, Py_ssize_t i)
3343{
  PyObject *name = PySequence_GetItem(self->names, i);
  PyObject *ret;
  if (name == NULL((void*)0)) {
      PyErr_Format(PyExc_IndexError,
                   "Field index %zd out of range.", i);
      return NULL((void*)0);
  }
  ret = _subscript_by_name(self, name);
  Py_DECREF(name)_Py_DECREF(((PyObject*)(name)));
  return ret;
3354}

3356static npy_bool
3357_is_list_of_strings(PyObject *obj)
3358{
  int seqlen, i;
  if (!PyList_CheckExact(obj)((((PyObject*)(obj))->ob_type) == &PyList_Type)) {
      return NPY_FALSE0;
  }
  seqlen = PyList_GET_SIZE(obj)(((void) (0)), (((PyVarObject*)(obj))->ob_size));
  for (i = 0; i < seqlen; i++) {
      PyObject *item = PyList_GET_ITEM(obj, i)(((PyListObject *)(obj))->ob_item[i]);
      if (!PyUnicode_Check(item)((((((PyObject*)(item))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
          return NPY_FALSE0;
      }
  }

  return NPY_TRUE1;
3372}

3374NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
3375arraydescr_field_subset_view(PyArray_Descr *self, PyObject *ind)
3376{
  int seqlen, i;
  PyObject *fields = NULL((void*)0);
  PyObject *names = NULL((void*)0);
  PyArray_Descr *view_dtype;

  seqlen = PySequence_Size(ind);
  if (seqlen == -1) {
      return NULL((void*)0);
  }

  fields = PyDict_New();
  if (fields == NULL((void*)0)) {
      goto fail;
  }
  names = PyTuple_New(seqlen);
  if (names == NULL((void*)0)) {
      goto fail;
  }

  for (i = 0; i < seqlen; i++) {
      PyObject *name;
      PyObject *tup;

      name = PySequence_GetItem(ind, i);
      if (name == NULL((void*)0)) {
          goto fail;
      }

      /* Let the names tuple steal a reference now, so we don't need to
       * decref name if an error occurs further on.
       */
      PyTuple_SET_ITEM(names, i, name)PyTuple_SetItem(names, i, name);

      tup = PyDict_GetItemWithError(self->fields, name);
      if (tup == NULL((void*)0)) {
          if (!PyErr_Occurred()) {
              PyErr_SetObject(PyExc_KeyError, name);
          }
          goto fail;
      }

      /* disallow use of titles as index */
      if (PyTuple_Size(tup) == 3) {
          PyObject *title = PyTuple_GET_ITEM(tup, 2)((((void) (0)), (PyTupleObject *)(tup))->ob_item[2]);
          int titlecmp = PyObject_RichCompareBool(title, name, Py_EQ2);
          if (titlecmp < 0) {
              goto fail;
          }
          if (titlecmp == 1) {
              /* if title == name, we were given a title, not a field name */
              PyErr_SetString(PyExc_KeyError,
                          "cannot use field titles in multi-field index");
              goto fail;
          }
          if (PyDict_SetItem(fields, title, tup) < 0) {
              goto fail;
          }
      }
      /* disallow duplicate field indices */
      if (PyDict_Contains(fields, name)) {
          PyObject *msg = NULL((void*)0);
          PyObject *fmt = PyUnicode_FromString(
                                 "duplicate field of name {!r}");
          if (fmt != NULL((void*)0)) {
              msg = PyObject_CallMethod_PyObject_CallMethod_SizeT(fmt, "format", "O", name);
              Py_DECREF(fmt)_Py_DECREF(((PyObject*)(fmt)));
          }
          PyErr_SetObject(PyExc_ValueError, msg);
          Py_XDECREF(msg)_Py_XDECREF(((PyObject*)(msg)));
          goto fail;
      }
      if (PyDict_SetItem(fields, name, tup) < 0) {
          goto fail;
      }
  }

  view_dtype = PyArray_DescrNewFromType(NPY_VOID);
  if (view_dtype == NULL((void*)0)) {
      goto fail;
  }
  view_dtype->elsize = self->elsize;
  view_dtype->names = names;
  view_dtype->fields = fields;
  view_dtype->flags = self->flags;
  return view_dtype;

3463fail:
  Py_XDECREF(fields)_Py_XDECREF(((PyObject*)(fields)));
  Py_XDECREF(names)_Py_XDECREF(((PyObject*)(names)));
  return NULL((void*)0);
3467}

3469static PyObject *
3470descr_subscript(PyArray_Descr *self, PyObject *op)
3471{
  if (_check_has_fields(self) < 0) {
      return NULL((void*)0);
  }

  if (PyUnicode_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)) {
      return _subscript_by_name(self, op);
  }
  else if (_is_list_of_strings(op)) {
      return (PyObject *)arraydescr_field_subset_view(self, op);
  }
  else {
      Py_ssize_t i = PyArray_PyIntAsIntp(op);
      if (error_converting(i)(((i) == -1) && PyErr_Occurred())) {
          /* if converting to an int gives a type error, adjust the message */
          PyObject *err = PyErr_Occurred();
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
              PyErr_SetString(PyExc_TypeError,
                      "Field key must be an integer field offset, "
                      "single field name, or list of field names.");
          }
          return NULL((void*)0);
      }
      return _subscript_by_index(self, i);
  }
3496}

3498static PySequenceMethods descr_as_sequence = {
  (lenfunc) descr_length,                  /* sq_length */
  (binaryfunc) NULL((void*)0),                       /* sq_concat */
  (ssizeargfunc) descr_repeat,             /* sq_repeat */
  (ssizeargfunc) NULL((void*)0),                     /* sq_item */
  (ssizessizeargfunc) NULL((void*)0),                /* sq_slice */
  (ssizeobjargproc) NULL((void*)0),                  /* sq_ass_item */
  (ssizessizeobjargproc) NULL((void*)0),             /* sq_ass_slice */
  (objobjproc) NULL((void*)0),                       /* sq_contains */
  (binaryfunc) NULL((void*)0),                       /* sq_inplace_concat */
  (ssizeargfunc) NULL((void*)0),                     /* sq_inplace_repeat */
3509};

3511static PyMappingMethods descr_as_mapping = {
  descr_length,                                /* mp_length*/
  (binaryfunc)descr_subscript,                 /* mp_subscript*/
  (objobjargproc)NULL((void*)0),                         /* mp_ass_subscript*/
3515};

3517/****************** End of Mapping Protocol ******************************/


3520/*
* NOTE: Since this is a MetaClass, the name has Full appended here, the
*       correct name of the type is PyArrayDescr_Type.
*/
3524NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_DTypeMeta PyArrayDescr_TypeFull = {
  {{
      /* NULL represents `type`, this is set to DTypeMeta at import time */
      PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
      .tp_name = "numpy.dtype",
      .tp_basicsize = sizeof(PyArray_Descr),
      .tp_dealloc = (destructor)arraydescr_dealloc,
      .tp_repr = (reprfunc)arraydescr_repr,
      .tp_as_number = &descr_as_number,
      .tp_as_sequence = &descr_as_sequence,
      .tp_as_mapping = &descr_as_mapping,
      .tp_str = (reprfunc)arraydescr_str,
      .tp_flags = Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0) | Py_TPFLAGS_BASETYPE(1UL << 10),
      .tp_richcompare = (richcmpfunc)arraydescr_richcompare,
      .tp_methods = arraydescr_methods,
      .tp_members = arraydescr_members,
      .tp_getset = arraydescr_getsets,
      .tp_new = arraydescr_new,
  },},
  .type_num = -1,
  .kind = '\0',
  .abstract = 1,
  .parametric = 0,
  .singleton = 0,
  .scalar_type = NULL((void*)0),
3549};

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyUnicode_FromFormat.model

→

1#ifndef PyUnicode_FromFormat
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject* PyUnicode_FromFormat(const char *format, ...) {
6  return clang_analyzer_PyObject_New_Reference();
45
←
Setting reference count to 1→
7}
8#else
9#warning "API PyUnicode_FromFormat is defined as a macro."
10#endif

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyTuple_SetItem.model

1#ifndef PyTuple_SetItem
2struct _object;
3typedef struct _object PyObject;
4void clang_analyzer_PyObject_Steal_Reference(const void *);
5int clang_analyzer_noimpl_conjure_int();
6int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o) {
7  clang_analyzer_PyObject_Steal_Reference(o);
50
←
Setting reference count to 0→
8  return clang_analyzer_noimpl_conjure_int();
9}
10#else
11#warning "API PyTuple_SetItem is defined as a macro."
12#endif