numpy/core/src/multiarray/nditer

Bug Summary

File:	numpy/core/src/multiarray/nditer_pywrap.c
Warning:	line 1596, column 27 PyObject ownership leak with reference count of 1

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 nditer_pywrap.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/nditer_pywrap.c

numpy/core/src/multiarray/nditer_pywrap.c

→

1/*
* This file implements the CPython wrapper of NpyIter
*
* Copyright (c) 2010 by Mark Wiebe (mwwiebe@gmail.com)
* The University of British Columbia
*
* See LICENSE.txt for the license.
*/
9#define PY_SSIZE_T_CLEAN
10#include "Python.h"
11#include "structmember.h"

13#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E
14#define _MULTIARRAYMODULE
15#include <numpy/arrayobject.h>
16#include "npy_config.h"
17#include "npy_pycompat.h"
18#include "alloc.h"
19#include "common.h"
20#include "conversion_utils.h"
21#include "ctors.h"

23/* Functions not part of the public NumPy C API */
24npy_bool npyiter_has_writeback(NpyIter *iter);


27typedef struct NewNpyArrayIterObject_tag NewNpyArrayIterObject;

29struct NewNpyArrayIterObject_tag {
  PyObject_HEADPyObject ob_base;
  /* The iterator */
  NpyIter *iter;
  /* Flag indicating iteration started/stopped */
  char started, finished;
  /* Child to update for nested iteration */
  NewNpyArrayIterObject *nested_child;
  /* Cached values from the iterator */
  NpyIter_IterNextFunc *iternext;
  NpyIter_GetMultiIndexFunc *get_multi_index;
  char **dataptrs;
  PyArray_Descr **dtypes;
  PyArrayObject **operands;
  npy_intp *innerstrides, *innerloopsizeptr;
  char readflags[NPY_MAXARGS32];
  char writeflags[NPY_MAXARGS32];
46};

48static int npyiter_cache_values(NewNpyArrayIterObject *self)
49{
  NpyIter *iter = self->iter;

  /* iternext and get_multi_index functions */
  self->iternext = NpyIter_GetIterNext(iter, NULL((void*)0));
  if (self->iternext == NULL((void*)0)) {
      return -1;
  }

  if (NpyIter_HasMultiIndex(iter) && !NpyIter_HasDelayedBufAlloc(iter)) {
      self->get_multi_index = NpyIter_GetGetMultiIndex(iter, NULL((void*)0));
  }
  else {
      self->get_multi_index = NULL((void*)0);
  }

  /* Internal data pointers */
  self->dataptrs = NpyIter_GetDataPtrArray(iter);
  self->dtypes = NpyIter_GetDescrArray(iter);
  self->operands = NpyIter_GetOperandArray(iter);

  if (NpyIter_HasExternalLoop(iter)) {
      self->innerstrides = NpyIter_GetInnerStrideArray(iter);
      self->innerloopsizeptr = NpyIter_GetInnerLoopSizePtr(iter);
  }
  else {
      self->innerstrides = NULL((void*)0);
      self->innerloopsizeptr = NULL((void*)0);
  }

  /* The read/write settings */
  NpyIter_GetReadFlags(iter, self->readflags);
  NpyIter_GetWriteFlags(iter, self->writeflags);
  return 0;
83}

85static PyObject *
86npyiter_new(PyTypeObject *subtype, PyObject *NPY_UNUSED(args)(__NPY_UNUSED_TAGGEDargs) __attribute__ ((__unused__)),
          PyObject *NPY_UNUSED(kwds)(__NPY_UNUSED_TAGGEDkwds) __attribute__ ((__unused__)))
88{
  NewNpyArrayIterObject *self;

  self = (NewNpyArrayIterObject *)subtype->tp_alloc(subtype, 0);
  if (self != NULL((void*)0)) {
      self->iter = NULL((void*)0);
      self->nested_child = NULL((void*)0);
  }

  return (PyObject *)self;
98}

100static int
101NpyIter_GlobalFlagsConverter(PyObject *flags_in, npy_uint32 *flags)
102{
  npy_uint32 tmpflags = 0;
  int iflags, nflags;

  PyObject *f;
  char *str = NULL((void*)0);
  Py_ssize_t length = 0;
  npy_uint32 flag;

  if (flags_in == NULL((void*)0) || flags_in == Py_None(&_Py_NoneStruct)) {
      return 1;
  }

  if (!PyTuple_Check(flags_in)((((((PyObject*)(flags_in))->ob_type))->tp_flags & (
(1UL << 26))) != 0) && !PyList_Check(flags_in)((((((PyObject*)(flags_in))->ob_type))->tp_flags & (
(1UL << 25))) != 0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator global flags must be a list or tuple of strings");
      return 0;
  }

  nflags = PySequence_Size(flags_in);

  for (iflags = 0; iflags < nflags; ++iflags) {
      f = PySequence_GetItem(flags_in, iflags);
      if (f == NULL((void*)0)) {
          return 0;
      }

      if (PyUnicode_Check(f)((((((PyObject*)(f))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)) {
          /* accept unicode input */
          PyObject *f_str;
          f_str = PyUnicode_AsASCIIString(f);
          if (f_str == NULL((void*)0)) {
              Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
              return 0;
          }
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          f = f_str;
      }

      if (PyBytes_AsStringAndSize(f, &str, &length) < 0) {
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          return 0;
      }
      /* Use switch statements to quickly isolate the right flag */
      flag = 0;
      switch (str[0]) {
          case 'b':
              if (strcmp(str, "buffered") == 0) {
                  flag = NPY_ITER_BUFFERED0x00000200;
              }
              break;
          case 'c':
              if (length >= 6) switch (str[5]) {
                  case 'e':
                      if (strcmp(str, "c_index") == 0) {
                          flag = NPY_ITER_C_INDEX0x00000001;
                      }
                      break;
                  case 'i':
                      if (strcmp(str, "copy_if_overlap") == 0) {
                          flag = NPY_ITER_COPY_IF_OVERLAP0x00002000;
                      }
                      break;
                  case 'n':
                      if (strcmp(str, "common_dtype") == 0) {
                          flag = NPY_ITER_COMMON_DTYPE0x00000010;
                      }
                      break;
              }
              break;
          case 'd':
              if (strcmp(str, "delay_bufalloc") == 0) {
                  flag = NPY_ITER_DELAY_BUFALLOC0x00000800;
              }
              break;
          case 'e':
              if (strcmp(str, "external_loop") == 0) {
                  flag = NPY_ITER_EXTERNAL_LOOP0x00000008;
              }
              break;
          case 'f':
              if (strcmp(str, "f_index") == 0) {
                  flag = NPY_ITER_F_INDEX0x00000002;
              }
              break;
          case 'g':
              /*
               * Documentation is grow_inner, but initial implementation
               * was growinner, so allowing for either.
               */
              if (strcmp(str, "grow_inner") == 0 ||
                          strcmp(str, "growinner") == 0) {
                  flag = NPY_ITER_GROWINNER0x00000400;
              }
              break;
          case 'm':
              if (strcmp(str, "multi_index") == 0) {
                  flag = NPY_ITER_MULTI_INDEX0x00000004;
              }
              break;
          case 'r':
              if (strcmp(str, "ranged") == 0) {
                  flag = NPY_ITER_RANGED0x00000100;
              }
              else if (strcmp(str, "refs_ok") == 0) {
                  flag = NPY_ITER_REFS_OK0x00000020;
              }
              else if (strcmp(str, "reduce_ok") == 0) {
                  flag = NPY_ITER_REDUCE_OK0x00000080;
              }
              break;
          case 'z':
              if (strcmp(str, "zerosize_ok") == 0) {
                  flag = NPY_ITER_ZEROSIZE_OK0x00000040;
              }
              break;
      }
      if (flag == 0) {
          PyErr_Format(PyExc_ValueError,
                  "Unexpected iterator global flag \"%s\"", str);
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          return 0;
      }
      else {
          tmpflags |= flag;
      }
      Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
  }

  *flags |= tmpflags;
  return 1;
233}

235static int
236NpyIter_OpFlagsConverter(PyObject *op_flags_in,
                       npy_uint32 *op_flags)
238{
  int iflags, nflags;
  npy_uint32 flag;

  if (!PyTuple_Check(op_flags_in)((((((PyObject*)(op_flags_in))->ob_type))->tp_flags &
 ((1UL << 26))) != 0) && !PyList_Check(op_flags_in)((((((PyObject*)(op_flags_in))->ob_type))->tp_flags &
 ((1UL << 25))) != 0)) {
      PyErr_SetString(PyExc_ValueError,
              "op_flags must be a tuple or array of per-op flag-tuples");
      return 0;
  }

  nflags = PySequence_Size(op_flags_in);

  *op_flags = 0;
  for (iflags = 0; iflags < nflags; ++iflags) {
      PyObject *f;
      char *str = NULL((void*)0);
      Py_ssize_t length = 0;

      f = PySequence_GetItem(op_flags_in, iflags);
      if (f == NULL((void*)0)) {
          return 0;
      }

      if (PyUnicode_Check(f)((((((PyObject*)(f))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)) {
          /* accept unicode input */
          PyObject *f_str;
          f_str = PyUnicode_AsASCIIString(f);
          if (f_str == NULL((void*)0)) {
              Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
              return 0;
          }
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          f = f_str;
      }

      if (PyBytes_AsStringAndSize(f, &str, &length) < 0) {
          PyErr_Clear();
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          PyErr_SetString(PyExc_ValueError,
                 "op_flags must be a tuple or array of per-op flag-tuples");
          return 0;
      }

      /* Use switch statements to quickly isolate the right flag */
      flag = 0;
      switch (str[0]) {
          case 'a':
              if (length > 2) switch(str[2]) {
                  case 'i':
                      if (strcmp(str, "aligned") == 0) {
                          flag = NPY_ITER_ALIGNED0x00100000;
                      }
                      break;
                  case 'l':
                      if (strcmp(str, "allocate") == 0) {
                          flag = NPY_ITER_ALLOCATE0x01000000;
                      }
                      break;
                  case 'r':
                      if (strcmp(str, "arraymask") == 0) {
                          flag = NPY_ITER_ARRAYMASK0x20000000;
                      }
                      break;
              }
              break;
          case 'c':
              if (strcmp(str, "copy") == 0) {
                  flag = NPY_ITER_COPY0x00400000;
              }
              if (strcmp(str, "contig") == 0) {
                  flag = NPY_ITER_CONTIG0x00200000;
              }
              break;
          case 'n':
              switch (str[1]) {
                  case 'b':
                      if (strcmp(str, "nbo") == 0) {
                          flag = NPY_ITER_NBO0x00080000;
                      }
                      break;
                  case 'o':
                      if (strcmp(str, "no_subtype") == 0) {
                          flag = NPY_ITER_NO_SUBTYPE0x02000000;
                      }
                      else if (strcmp(str, "no_broadcast") == 0) {
                          flag = NPY_ITER_NO_BROADCAST0x08000000;
                      }
                      break;
              }
              break;
          case 'o':
              if (strcmp(str, "overlap_assume_elementwise") == 0) {
                  flag = NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE0x40000000;
              }
              break;
          case 'r':
              if (length > 4) switch (str[4]) {
                  case 'o':
                      if (strcmp(str, "readonly") == 0) {
                          flag = NPY_ITER_READONLY0x00020000;
                      }
                      break;
                  case 'w':
                      if (strcmp(str, "readwrite") == 0) {
                          flag = NPY_ITER_READWRITE0x00010000;
                      }
                      break;
              }
              break;
          case 'u':
              switch (str[1]) {
                  case 'p':
                      if (strcmp(str, "updateifcopy") == 0) {
                          flag = NPY_ITER_UPDATEIFCOPY0x00800000;
                      }
                      break;
              }
              break;
          case 'v':
              if (strcmp(str, "virtual") == 0) {
                  flag = NPY_ITER_VIRTUAL0x04000000;
              }
              break;
          case 'w':
              if (length > 5) switch (str[5]) {
                  case 'o':
                      if (strcmp(str, "writeonly") == 0) {
                          flag = NPY_ITER_WRITEONLY0x00040000;
                      }
                      break;
                  case 'm':
                      if (strcmp(str, "writemasked") == 0) {
                          flag = NPY_ITER_WRITEMASKED0x10000000;
                      }
                      break;
              }
              break;
      }
      if (flag == 0) {
          PyErr_Format(PyExc_ValueError,
                  "Unexpected per-op iterator flag \"%s\"", str);
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          return 0;
      }
      else {
          *op_flags |= flag;
      }
      Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
  }

  return 1;
389}

391static int
392npyiter_convert_op_flags_array(PyObject *op_flags_in,
                       npy_uint32 *op_flags_array, npy_intp nop)
394{
  npy_intp iop;

  if (!PyTuple_Check(op_flags_in)((((((PyObject*)(op_flags_in))->ob_type))->tp_flags &
 ((1UL << 26))) != 0) && !PyList_Check(op_flags_in)((((((PyObject*)(op_flags_in))->ob_type))->tp_flags &
 ((1UL << 25))) != 0)) {
      PyErr_SetString(PyExc_ValueError,
              "op_flags must be a tuple or array of per-op flag-tuples");
      return 0;
  }

  if (PySequence_Size(op_flags_in) != nop) {
      goto try_single_flags;
  }

  for (iop = 0; iop < nop; ++iop) {
      PyObject *f = PySequence_GetItem(op_flags_in, iop);
      if (f == NULL((void*)0)) {
          return 0;
      }
      /* If the first item is a string, try as one set of flags */
      if (iop == 0 && (PyBytes_Check(f)((((((PyObject*)(f))->ob_type))->tp_flags & ((1UL <<
 27))) != 0) || PyUnicode_Check(f)((((((PyObject*)(f))->ob_type))->tp_flags & ((1UL <<
 28))) != 0))) {
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          goto try_single_flags;
      }
      if (NpyIter_OpFlagsConverter(f,
                      &op_flags_array[iop]) != 1) {
          Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
          return 0;
      }

      Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
  }

  return 1;

428try_single_flags:
  if (NpyIter_OpFlagsConverter(op_flags_in,
                      &op_flags_array[0]) != 1) {
      return 0;
  }

  for (iop = 1; iop < nop; ++iop) {
      op_flags_array[iop] = op_flags_array[0];
  }

  return 1;
439}

441static int
442npyiter_convert_dtypes(PyObject *op_dtypes_in,
                      PyArray_Descr **op_dtypes,
                      npy_intp nop)
445{
  npy_intp iop;

  /*
   * If the input isn't a tuple of dtypes, try converting it as-is
   * to a dtype, and replicating to all operands.
   */
  if ((!PyTuple_Check(op_dtypes_in)((((((PyObject*)(op_dtypes_in))->ob_type))->tp_flags &
 ((1UL << 26))) != 0) && !PyList_Check(op_dtypes_in)((((((PyObject*)(op_dtypes_in))->ob_type))->tp_flags &
 ((1UL << 25))) != 0)) ||
                                  PySequence_Size(op_dtypes_in) != nop) {
      goto try_single_dtype;
  }

  for (iop = 0; iop < nop; ++iop) {
      PyObject *dtype = PySequence_GetItem(op_dtypes_in, iop);
      if (dtype == NULL((void*)0)) {
          npy_intp i;
          for (i = 0; i < iop; ++i ) {
              Py_XDECREF(op_dtypes[i])_Py_XDECREF(((PyObject*)(op_dtypes[i])));
          }
          return 0;
      }

      /* Try converting the object to a descr */
      if (PyArray_DescrConverter2(dtype, &op_dtypes[iop]) != 1) {
          npy_intp i;
          for (i = 0; i < iop; ++i ) {
              Py_XDECREF(op_dtypes[i])_Py_XDECREF(((PyObject*)(op_dtypes[i])));
          }
          Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
          PyErr_Clear();
          goto try_single_dtype;
      }

      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
  }

  return 1;

483try_single_dtype:
  if (PyArray_DescrConverter2(op_dtypes_in, &op_dtypes[0]) == 1) {
      for (iop = 1; iop < nop; ++iop) {
          op_dtypes[iop] = op_dtypes[0];
          Py_XINCREF(op_dtypes[iop])_Py_XINCREF(((PyObject*)(op_dtypes[iop])));
      }
      return 1;
  }

  return 0;
493}

495static int
496npyiter_convert_op_axes(PyObject *op_axes_in, int nop,
                      int **op_axes, int *oa_ndim)
498{
  PyObject *a;
  int iop;

  if ((!PyTuple_Check(op_axes_in)((((((PyObject*)(op_axes_in))->ob_type))->tp_flags &
 ((1UL << 26))) != 0) && !PyList_Check(op_axes_in)((((((PyObject*)(op_axes_in))->ob_type))->tp_flags &
 ((1UL << 25))) != 0)) ||
                              PySequence_Size(op_axes_in) != nop) {
      PyErr_SetString(PyExc_ValueError,
              "op_axes must be a tuple/list matching the number of ops");
      return 0;
  }

  *oa_ndim = -1;

  /* Copy the tuples into op_axes */
  for (iop = 0; iop < nop; ++iop) {
      int idim;
      a = PySequence_GetItem(op_axes_in, iop);
      if (a == NULL((void*)0)) {
          return 0;
      }
      if (a == Py_None(&_Py_NoneStruct)) {
          op_axes[iop] = NULL((void*)0);
      } else {
          if (!PyTuple_Check(a)((((((PyObject*)(a))->ob_type))->tp_flags & ((1UL <<
 26))) != 0) && !PyList_Check(a)((((((PyObject*)(a))->ob_type))->tp_flags & ((1UL <<
 25))) != 0)) {
              PyErr_SetString(PyExc_ValueError,
                      "Each entry of op_axes must be None "
                      "or a tuple/list");
              Py_DECREF(a)_Py_DECREF(((PyObject*)(a)));
              return 0;
          }
          if (*oa_ndim == -1) {
              *oa_ndim = PySequence_Size(a);
              if (*oa_ndim > NPY_MAXDIMS32) {
                  PyErr_SetString(PyExc_ValueError,
                          "Too many dimensions in op_axes");
                  Py_DECREF(a)_Py_DECREF(((PyObject*)(a)));
                  return 0;
              }
          }
          if (PySequence_Size(a) != *oa_ndim) {
              PyErr_SetString(PyExc_ValueError,
                      "Each entry of op_axes must have the same size");
              Py_DECREF(a)_Py_DECREF(((PyObject*)(a)));
              return 0;
          }
          for (idim = 0; idim < *oa_ndim; ++idim) {
              PyObject *v = PySequence_GetItem(a, idim);
              if (v == NULL((void*)0)) {
                  Py_DECREF(a)_Py_DECREF(((PyObject*)(a)));
                  return 0;
              }
              /* numpy.newaxis is None */
              if (v == Py_None(&_Py_NoneStruct)) {
                  op_axes[iop][idim] = -1;
              }
              else {
                  op_axes[iop][idim] = PyArray_PyIntAsInt(v);
                  if (op_axes[iop][idim]==-1 &&
                                              PyErr_Occurred()) {
                      Py_DECREF(a)_Py_DECREF(((PyObject*)(a)));
                      Py_DECREF(v)_Py_DECREF(((PyObject*)(v)));
                      return 0;
                  }
              }
              Py_DECREF(v)_Py_DECREF(((PyObject*)(v)));
          }
      }
      Py_DECREF(a)_Py_DECREF(((PyObject*)(a)));
  }

  if (*oa_ndim == -1) {
      PyErr_SetString(PyExc_ValueError,
              "If op_axes is provided, at least one list of axes "
              "must be contained within it");
      return 0;
  }

  return 1;
576}

578/*
* Converts the operand array and op_flags array into the form
* NpyIter_AdvancedNew needs.  Sets nop, and on success, each
* op[i] owns a reference to an array object.
*/
583static int
584npyiter_convert_ops(PyObject *op_in, PyObject *op_flags_in,
                  PyArrayObject **op, npy_uint32 *op_flags,
                  int *nop_out)
587{
  int iop, nop;

  /* nop and op */
  if (PyTuple_Check(op_in)((((((PyObject*)(op_in))->ob_type))->tp_flags & ((1UL
 << 26))) != 0) || PyList_Check(op_in)((((((PyObject*)(op_in))->ob_type))->tp_flags & ((1UL
 << 25))) != 0)) {
      nop = PySequence_Size(op_in);
      if (nop == 0) {
          PyErr_SetString(PyExc_ValueError,
                  "Must provide at least one operand");
          return 0;
      }
      if (nop > NPY_MAXARGS32) {
          PyErr_SetString(PyExc_ValueError, "Too many operands");
          return 0;
      }

      for (iop = 0; iop < nop; ++iop) {
          PyObject *item = PySequence_GetItem(op_in, iop);
          if (item == NULL((void*)0)) {
              npy_intp i;
              for (i = 0; i < iop; ++i) {
                  Py_XDECREF(op[i])_Py_XDECREF(((PyObject*)(op[i])));
              }
              return 0;
          }
          else if (item == Py_None(&_Py_NoneStruct)) {
              Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
              item = NULL((void*)0);
          }
          /* This is converted to an array after op flags are retrieved */
          op[iop] = (PyArrayObject *)item;
      }
  }
  else {
      nop = 1;
      /* Is converted to an array after op flags are retrieved */
      Py_INCREF(op_in)_Py_INCREF(((PyObject*)(op_in)));
      op[0] = (PyArrayObject *)op_in;
  }

  *nop_out = nop;

  /* op_flags */
  if (op_flags_in == NULL((void*)0) || op_flags_in == Py_None(&_Py_NoneStruct)) {
      for (iop = 0; iop < nop; ++iop) {
          /*
           * By default, make NULL operands writeonly and flagged for
           * allocation, and everything else readonly.  To write
           * to a provided operand, you must specify the write flag manually.
           */
          if (op[iop] == NULL((void*)0)) {
              op_flags[iop] = NPY_ITER_WRITEONLY0x00040000 | NPY_ITER_ALLOCATE0x01000000;
          }
          else {
              op_flags[iop] = NPY_ITER_READONLY0x00020000;
          }
      }
  }
  else if (npyiter_convert_op_flags_array(op_flags_in,
                                    op_flags, nop) != 1) {
      for (iop = 0; iop < nop; ++iop) {
          Py_XDECREF(op[iop])_Py_XDECREF(((PyObject*)(op[iop])));
      }
      *nop_out = 0;
      return 0;
  }

  /* Now that we have the flags - convert all the ops to arrays */
  for (iop = 0; iop < nop; ++iop) {
      if (op[iop] != NULL((void*)0)) {
          PyArrayObject *ao;
          int fromanyflags = 0;

          if (op_flags[iop]&(NPY_ITER_READWRITE0x00010000|NPY_ITER_WRITEONLY0x00040000)) {
              fromanyflags |= NPY_ARRAY_WRITEBACKIFCOPY0x2000;
          }
          ao = (PyArrayObject *)PyArray_FROM_OF((PyObject *)op[iop],PyArray_CheckFromAny((PyObject *)op[iop], ((void*)0), 0, 0, fromanyflags
, ((void*)0))
                                                fromanyflags)PyArray_CheckFromAny((PyObject *)op[iop], ((void*)0), 0, 0, fromanyflags
, ((void*)0));
          if (ao == NULL((void*)0)) {
              if (PyErr_Occurred() &&
                          PyErr_ExceptionMatches(PyExc_TypeError)) {
                  PyErr_SetString(PyExc_TypeError,
                          "Iterator operand is flagged as writeable, "
                          "but is an object which cannot be written "
                          "back to via WRITEBACKIFCOPY");
              }
              for (iop = 0; iop < nop; ++iop) {
                  Py_DECREF(op[iop])_Py_DECREF(((PyObject*)(op[iop])));
              }
              *nop_out = 0;
              return 0;
          }
          Py_DECREF(op[iop])_Py_DECREF(((PyObject*)(op[iop])));
          op[iop] = ao;
      }
  }

  return 1;
685}

687static int
688npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds)
689{
  static char *kwlist[] = {"op", "flags", "op_flags", "op_dtypes",
                           "order", "casting", "op_axes", "itershape",
                           "buffersize",
                           NULL((void*)0)};

  PyObject *op_in = NULL((void*)0), *op_flags_in = NULL((void*)0),
              *op_dtypes_in = NULL((void*)0), *op_axes_in = NULL((void*)0);

  int iop, nop = 0;
  PyArrayObject *op[NPY_MAXARGS32];
  npy_uint32 flags = 0;
  NPY_ORDER order = NPY_KEEPORDER;
  NPY_CASTING casting = NPY_SAFE_CASTING;
  npy_uint32 op_flags[NPY_MAXARGS32];
  PyArray_Descr *op_request_dtypes[NPY_MAXARGS32];
  int oa_ndim = -1;
  int op_axes_arrays[NPY_MAXARGS32][NPY_MAXDIMS32];
  int *op_axes[NPY_MAXARGS32];
  PyArray_Dims itershape = {NULL((void*)0), -1};
  int buffersize = 0;

  if (self->iter != NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator was already initialized");
      return -1;
  }

  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, kwds, "O|O&OOO&O&OO&i:nditer", kwlist,
                  &op_in,
                  NpyIter_GlobalFlagsConverter, &flags,
                  &op_flags_in,
                  &op_dtypes_in,
                  PyArray_OrderConverter, &order,
                  PyArray_CastingConverter, &casting,
                  &op_axes_in,
                  PyArray_OptionalIntpConverter, &itershape,
                  &buffersize)) {
      npy_free_cache_dim_obj(itershape);
      return -1;
  }

  /* Set the dtypes and ops to all NULL to start */
  memset(op_request_dtypes, 0, sizeof(op_request_dtypes));

  /* op and op_flags */
  if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &nop)
                                                      != 1) {
      goto fail;
  }

  /* op_request_dtypes */
  if (op_dtypes_in != NULL((void*)0) && op_dtypes_in != Py_None(&_Py_NoneStruct) &&
          npyiter_convert_dtypes(op_dtypes_in,
                                 op_request_dtypes, nop) != 1) {
      goto fail;
  }

  /* op_axes */
  if (op_axes_in != NULL((void*)0) && op_axes_in != Py_None(&_Py_NoneStruct)) {
      /* Initialize to point to the op_axes arrays */
      for (iop = 0; iop < nop; ++iop) {
          op_axes[iop] = op_axes_arrays[iop];
      }

      if (npyiter_convert_op_axes(op_axes_in, nop,
                                  op_axes, &oa_ndim) != 1) {
          goto fail;
      }
  }

  if (itershape.len != -1) {
      if (oa_ndim == -1) {
          oa_ndim = itershape.len;
          memset(op_axes, 0, sizeof(op_axes[0]) * nop);
      }
      else if (oa_ndim != itershape.len) {
          PyErr_SetString(PyExc_ValueError,
                      "'op_axes' and 'itershape' must have the same number "
                      "of entries equal to the iterator ndim");
          goto fail;
      }
  }

  self->iter = NpyIter_AdvancedNew(nop, op, flags, order, casting, op_flags,
                                op_request_dtypes,
                                oa_ndim, oa_ndim >= 0 ? op_axes : NULL((void*)0),
                                itershape.ptr,
                                buffersize);

  if (self->iter == NULL((void*)0)) {
      goto fail;
  }

  /* Cache some values for the member functions to use */
  if (npyiter_cache_values(self) < 0) {
      goto fail;
  }

  if (NpyIter_GetIterSize(self->iter) == 0) {
      self->started = 1;
      self->finished = 1;
  }
  else {
      self->started = 0;
      self->finished = 0;
  }

  npy_free_cache_dim_obj(itershape);

  /* Release the references we got to the ops and dtypes */
  for (iop = 0; iop < nop; ++iop) {
      Py_XDECREF(op[iop])_Py_XDECREF(((PyObject*)(op[iop])));
      Py_XDECREF(op_request_dtypes[iop])_Py_XDECREF(((PyObject*)(op_request_dtypes[iop])));
  }

  return 0;

807fail:
  npy_free_cache_dim_obj(itershape);
  for (iop = 0; iop < nop; ++iop) {
      Py_XDECREF(op[iop])_Py_XDECREF(((PyObject*)(op[iop])));
      Py_XDECREF(op_request_dtypes[iop])_Py_XDECREF(((PyObject*)(op_request_dtypes[iop])));
  }
  return -1;
814}

816NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
817NpyIter_NestedIters(PyObject *NPY_UNUSED(self)(__NPY_UNUSED_TAGGEDself) __attribute__ ((__unused__)),
                  PyObject *args, PyObject *kwds)
819{
  static char *kwlist[] = {"op", "axes", "flags", "op_flags",
                           "op_dtypes", "order",
                           "casting", "buffersize",
                           NULL((void*)0)};

  PyObject *op_in = NULL((void*)0), *axes_in = NULL((void*)0),
          *op_flags_in = NULL((void*)0), *op_dtypes_in = NULL((void*)0);

  int iop, nop = 0, inest, nnest = 0;
  PyArrayObject *op[NPY_MAXARGS32];
  npy_uint32 flags = 0, flags_inner;
  NPY_ORDER order = NPY_KEEPORDER;
  NPY_CASTING casting = NPY_SAFE_CASTING;
  npy_uint32 op_flags[NPY_MAXARGS32], op_flags_inner[NPY_MAXARGS32];
  PyArray_Descr *op_request_dtypes[NPY_MAXARGS32],
                *op_request_dtypes_inner[NPY_MAXARGS32];
  int op_axes_data[NPY_MAXDIMS32];
  int *nested_op_axes[NPY_MAXDIMS32];
  int nested_naxes[NPY_MAXDIMS32], iaxes, naxes;
  int negones[NPY_MAXDIMS32];
  char used_axes[NPY_MAXDIMS32];
  int buffersize = 0;

  PyObject *ret = NULL((void*)0);

  if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, kwds, "OO|O&OOO&O&i", kwlist,
                  &op_in,
                  &axes_in,
                  NpyIter_GlobalFlagsConverter, &flags,
                  &op_flags_in,
                  &op_dtypes_in,
                  PyArray_OrderConverter, &order,
                  PyArray_CastingConverter, &casting,
                  &buffersize)) {
      return NULL((void*)0);
  }

  /* axes */
  if (!PyTuple_Check(axes_in)((((((PyObject*)(axes_in))->ob_type))->tp_flags & (
(1UL << 26))) != 0) && !PyList_Check(axes_in)((((((PyObject*)(axes_in))->ob_type))->tp_flags & (
(1UL << 25))) != 0)) {
      PyErr_SetString(PyExc_ValueError,
              "axes must be a tuple of axis arrays");
      return NULL((void*)0);
  }
  nnest = PySequence_Size(axes_in);
  if (nnest < 2) {
      PyErr_SetString(PyExc_ValueError,
              "axes must have at least 2 entries for nested iteration");
      return NULL((void*)0);
  }
  naxes = 0;
  memset(used_axes, 0, NPY_MAXDIMS32);
  for (inest = 0; inest < nnest; ++inest) {
      PyObject *item = PySequence_GetItem(axes_in, inest);
      npy_intp i;
      if (item == NULL((void*)0)) {
          return NULL((void*)0);
      }
      if (!PyTuple_Check(item)((((((PyObject*)(item))->ob_type))->tp_flags & ((1UL
 << 26))) != 0) && !PyList_Check(item)((((((PyObject*)(item))->ob_type))->tp_flags & ((1UL
 << 25))) != 0)) {
          PyErr_SetString(PyExc_ValueError,
                  "Each item in axes must be a an integer tuple");
          Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
          return NULL((void*)0);
      }
      nested_naxes[inest] = PySequence_Size(item);
      if (naxes + nested_naxes[inest] > NPY_MAXDIMS32) {
          PyErr_SetString(PyExc_ValueError,
                  "Too many axes given");
          Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
          return NULL((void*)0);
      }
      for (i = 0; i < nested_naxes[inest]; ++i) {
          PyObject *v = PySequence_GetItem(item, i);
          npy_intp axis;
          if (v == NULL((void*)0)) {
              Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
              return NULL((void*)0);
          }
          axis = PyLong_AsLong(v);
          Py_DECREF(v)_Py_DECREF(((PyObject*)(v)));
          if (axis < 0 || axis >= NPY_MAXDIMS32) {
              PyErr_SetString(PyExc_ValueError,
                      "An axis is out of bounds");
              Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
              return NULL((void*)0);
          }
          /*
           * This check is very important, without it out of bounds
           * data accesses are possible.
           */
          if (used_axes[axis] != 0) {
              PyErr_SetString(PyExc_ValueError,
                      "An axis is used more than once");
              Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
              return NULL((void*)0);
          }
          used_axes[axis] = 1;
          op_axes_data[naxes+i] = axis;
      }
      nested_op_axes[inest] = &op_axes_data[naxes];
      naxes += nested_naxes[inest];
      Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
  }

  /* op and op_flags */
  if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &nop)
                                                      != 1) {
      return NULL((void*)0);
  }

  /* Set the dtypes to all NULL to start as well */
  memset(op_request_dtypes, 0, sizeof(op_request_dtypes[0])*nop);
  memset(op_request_dtypes_inner, 0,
                      sizeof(op_request_dtypes_inner[0])*nop);

  /* op_request_dtypes */
  if (op_dtypes_in != NULL((void*)0) && op_dtypes_in != Py_None(&_Py_NoneStruct) &&
          npyiter_convert_dtypes(op_dtypes_in,
                                 op_request_dtypes, nop) != 1) {
      goto fail;
  }

  ret = PyTuple_New(nnest);
  if (ret == NULL((void*)0)) {
      goto fail;
  }

  /* For broadcasting allocated arrays */
  for (iaxes = 0; iaxes < naxes; ++iaxes) {
      negones[iaxes] = -1;
  }

  /*
   * Clear any unnecessary ALLOCATE flags, so we can use them
   * to indicate exactly the allocated outputs.  Also, separate
   * the inner loop flags.
   */
  for (iop = 0; iop < nop; ++iop) {
      if ((op_flags[iop]&NPY_ITER_ALLOCATE0x01000000) && op[iop] != NULL((void*)0)) {
          op_flags[iop] &= ~NPY_ITER_ALLOCATE0x01000000;
      }

      /*
       * Clear any flags allowing copies or output allocation for
       * the inner loop.
       */
      op_flags_inner[iop] = op_flags[iop] & ~(NPY_ITER_COPY0x00400000|
                           NPY_ITER_UPDATEIFCOPY0x00800000|
                           NPY_ITER_ALLOCATE0x01000000);
      /*
       * If buffering is enabled and copying is not,
       * clear the nbo_aligned flag and strip the data type
       * for the outer loops.
       */
      if ((flags&(NPY_ITER_BUFFERED0x00000200)) &&
              !(op_flags[iop]&(NPY_ITER_COPY0x00400000|
                                 NPY_ITER_UPDATEIFCOPY0x00800000|
                                 NPY_ITER_ALLOCATE0x01000000))) {
          op_flags[iop] &= ~(NPY_ITER_NBO0x00080000|NPY_ITER_ALIGNED0x00100000|NPY_ITER_CONTIG0x00200000);
          op_request_dtypes_inner[iop] = op_request_dtypes[iop];
          op_request_dtypes[iop] = NULL((void*)0);
      }
  }

  /* Only the inner loop gets the buffering and no inner flags */
  flags_inner = flags&~NPY_ITER_COMMON_DTYPE0x00000010;
  flags &= ~(NPY_ITER_EXTERNAL_LOOP0x00000008|
                  NPY_ITER_BUFFERED0x00000200);

  for (inest = 0; inest < nnest; ++inest) {
      NewNpyArrayIterObject *iter;
      int *op_axes_nop[NPY_MAXARGS32];

      /*
       * All the operands' op_axes are the same, except for
       * allocated outputs.
       */
      for (iop = 0; iop < nop; ++iop) {
          if (op_flags[iop]&NPY_ITER_ALLOCATE0x01000000) {
              if (inest == 0) {
                  op_axes_nop[iop] = NULL((void*)0);
              }
              else {
                  op_axes_nop[iop] = negones;
              }
          }
          else {
              op_axes_nop[iop] = nested_op_axes[inest];
          }
      }

      /*
      printf("\n");
      for (iop = 0; iop < nop; ++iop) {
          npy_intp i;

          for (i = 0; i < nested_naxes[inest]; ++i) {
              printf("%d ", (int)op_axes_nop[iop][i]);
          }
          printf("\n");
      }
      */

      /* Allocate the iterator */
      iter = (NewNpyArrayIterObject *)npyiter_new(&NpyIter_Type, NULL((void*)0), NULL((void*)0));
      if (iter == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }

      if (inest < nnest-1) {
          iter->iter = NpyIter_AdvancedNew(nop, op, flags, order,
                              casting, op_flags, op_request_dtypes,
                              nested_naxes[inest], op_axes_nop,
                              NULL((void*)0),
                              0);
      }
      else {
          iter->iter = NpyIter_AdvancedNew(nop, op, flags_inner, order,
                              casting, op_flags_inner,
                              op_request_dtypes_inner,
                              nested_naxes[inest], op_axes_nop,
                              NULL((void*)0),
                              buffersize);
      }

      if (iter->iter == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }

      /* Cache some values for the member functions to use */
      if (npyiter_cache_values(iter) < 0) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }

      if (NpyIter_GetIterSize(iter->iter) == 0) {
          iter->started = 1;
          iter->finished = 1;
      }
      else {
          iter->started = 0;
          iter->finished = 0;
      }

      /*
       * If there are any allocated outputs or any copies were made,
       * adjust op so that the other iterators use the same ones.
       */
      if (inest == 0) {
          PyArrayObject **operands = NpyIter_GetOperandArray(iter->iter);
          for (iop = 0; iop < nop; ++iop) {
              if (op[iop] != operands[iop]) {
                  Py_XDECREF(op[iop])_Py_XDECREF(((PyObject*)(op[iop])));
                  op[iop] = operands[iop];
                  Py_INCREF(op[iop])_Py_INCREF(((PyObject*)(op[iop])));
              }

              /*
               * Clear any flags allowing copies for
               * the rest of the iterators
               */
              op_flags[iop] &= ~(NPY_ITER_COPY0x00400000|
                               NPY_ITER_UPDATEIFCOPY0x00800000);
          }
          /* Clear the common dtype flag for the rest of the iterators */
          flags &= ~NPY_ITER_COMMON_DTYPE0x00000010;
      }

      PyTuple_SET_ITEM(ret, inest, (PyObject *)iter)PyTuple_SetItem(ret, inest, (PyObject *)iter);
  }

  /* Release our references to the ops and dtypes */
  for (iop = 0; iop < nop; ++iop) {
      Py_XDECREF(op[iop])_Py_XDECREF(((PyObject*)(op[iop])));
      Py_XDECREF(op_request_dtypes[iop])_Py_XDECREF(((PyObject*)(op_request_dtypes[iop])));
      Py_XDECREF(op_request_dtypes_inner[iop])_Py_XDECREF(((PyObject*)(op_request_dtypes_inner[iop])));
  }

  /* Set up the nested child references */
  for (inest = 0; inest < nnest-1; ++inest) {
      NewNpyArrayIterObject *iter;
      iter = (NewNpyArrayIterObject *)PyTuple_GET_ITEM(ret, inest)((((void) (0)), (PyTupleObject *)(ret))->ob_item[inest]);
      /*
       * Indicates which iterator to reset with new base pointers
       * each iteration step.
       */
      iter->nested_child =
              (NewNpyArrayIterObject *)PyTuple_GET_ITEM(ret, inest+1)((((void) (0)), (PyTupleObject *)(ret))->ob_item[inest+1]);
      Py_INCREF(iter->nested_child)_Py_INCREF(((PyObject*)(iter->nested_child)));
      /*
       * Need to do a nested reset so all the iterators point
       * at the right data
       */
      if (NpyIter_ResetBasePointers(iter->nested_child->iter,
                              iter->dataptrs, NULL((void*)0)) != NPY_SUCCEED1) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
  }

  return ret;

1123fail:
  for (iop = 0; iop < nop; ++iop) {
      Py_XDECREF(op[iop])_Py_XDECREF(((PyObject*)(op[iop])));
      Py_XDECREF(op_request_dtypes[iop])_Py_XDECREF(((PyObject*)(op_request_dtypes[iop])));
      Py_XDECREF(op_request_dtypes_inner[iop])_Py_XDECREF(((PyObject*)(op_request_dtypes_inner[iop])));
  }
  return NULL((void*)0);
1130}


1133static void
1134npyiter_dealloc(NewNpyArrayIterObject *self)
1135{
  if (self->iter) {
      /* Store error, so that WriteUnraisable cannot clear an existing one */
      PyObject *exc, *val, *tb;
      PyErr_Fetch(&exc, &val, &tb);
      if (npyiter_has_writeback(self->iter)) {
          if (PyErr_WarnEx(PyExc_RuntimeWarning,
                  "Temporary data has not been written back to one of the "
                  "operands. Typically nditer is used as a context manager "
                  "otherwise 'close' must be called before reading iteration "
                  "results.", 1) < 0) {
              PyObject *s;

              s = PyUnicode_FromString("npyiter_dealloc");
              if (s) {
                  PyErr_WriteUnraisable(s);
                  Py_DECREF(s)_Py_DECREF(((PyObject*)(s)));
              }
              else {
                  PyErr_WriteUnraisable(Py_None(&_Py_NoneStruct));
              }
          }
      }
      if (!NpyIter_Deallocate(self->iter)) {
          PyErr_WriteUnraisable(Py_None(&_Py_NoneStruct));
      }
      self->iter = NULL((void*)0);
      Py_XDECREF(self->nested_child)_Py_XDECREF(((PyObject*)(self->nested_child)));
      self->nested_child = NULL((void*)0);
      PyErr_Restore(exc, val, tb);
  }
  Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject*)self);
1167}

1169static int
1170npyiter_resetbasepointers(NewNpyArrayIterObject *self)
1171{
  while (self->nested_child) {
      if (NpyIter_ResetBasePointers(self->nested_child->iter,
                                      self->dataptrs, NULL((void*)0)) != NPY_SUCCEED1) {
          return NPY_FAIL0;
      }
      self = self->nested_child;
      if (NpyIter_GetIterSize(self->iter) == 0) {
          self->started = 1;
          self->finished = 1;
      }
      else {
          self->started = 0;
          self->finished = 0;
      }
  }

  return NPY_SUCCEED1;
1189}

1191static PyObject *
1192npyiter_reset(NewNpyArrayIterObject *self)
1193{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  if (NpyIter_Reset(self->iter, NULL((void*)0)) != NPY_SUCCEED1) {
      return NULL((void*)0);
  }
  if (NpyIter_GetIterSize(self->iter) == 0) {
      self->started = 1;
      self->finished = 1;
  }
  else {
      self->started = 0;
      self->finished = 0;
  }

  if (self->get_multi_index == NULL((void*)0) && NpyIter_HasMultiIndex(self->iter)) {
      self->get_multi_index = NpyIter_GetGetMultiIndex(self->iter, NULL((void*)0));
  }

  /* If there is nesting, the nested iterators should be reset */
  if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
      return NULL((void*)0);
  }

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

1224/*
* Makes a copy of the iterator.  Note that the nesting is not
* copied.
*/
1228static PyObject *
1229npyiter_copy(NewNpyArrayIterObject *self)
1230{
  NewNpyArrayIterObject *iter;

  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  /* Allocate the iterator */
  iter = (NewNpyArrayIterObject *)npyiter_new(&NpyIter_Type, NULL((void*)0), NULL((void*)0));
  if (iter == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* Copy the C iterator */
  iter->iter = NpyIter_Copy(self->iter);
  if (iter->iter == NULL((void*)0)) {
      Py_DECREF(iter)_Py_DECREF(((PyObject*)(iter)));
      return NULL((void*)0);
  }

  /* Cache some values for the member functions to use */
  if (npyiter_cache_values(iter) < 0) {
      Py_DECREF(iter)_Py_DECREF(((PyObject*)(iter)));
      return NULL((void*)0);
  }

  iter->started = self->started;
  iter->finished = self->finished;

  return (PyObject *)iter;
1262}

1264static PyObject *
1265npyiter_iternext(NewNpyArrayIterObject *self)
1266{
  if (self->iter != NULL((void*)0) && self->iternext != NULL((void*)0) &&
                      !self->finished && self->iternext(self->iter)) {
      /* If there is nesting, the nested iterators should be reset */
      if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
          return NULL((void*)0);
      }

      Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct);
  }
  else {
      if (PyErr_Occurred()) {
          /* casting error, buffer cleanup will occur at reset or dealloc */
          return NULL((void*)0);
      }
      self->finished = 1;
      Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);
  }
1284}

1286static PyObject *
1287npyiter_remove_axis(NewNpyArrayIterObject *self, PyObject *args)
1288{
  int axis = 0;

  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "i:remove_axis", &axis)) {
      return NULL((void*)0);
  }

  if (NpyIter_RemoveAxis(self->iter, axis) != NPY_SUCCEED1) {
      return NULL((void*)0);
  }
  /* RemoveAxis invalidates cached values */
  if (npyiter_cache_values(self) < 0) {
      return NULL((void*)0);
  }
  /* RemoveAxis also resets the iterator */
  if (NpyIter_GetIterSize(self->iter) == 0) {
      self->started = 1;
      self->finished = 1;
  }
  else {
      self->started = 0;
      self->finished = 0;
  }

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

1321static PyObject *
1322npyiter_remove_multi_index(NewNpyArrayIterObject *self)
1323{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  NpyIter_RemoveMultiIndex(self->iter);
  /* RemoveMultiIndex invalidates cached values */
  npyiter_cache_values(self);
  /* RemoveMultiIndex also resets the iterator */
  if (NpyIter_GetIterSize(self->iter) == 0) {
      self->started = 1;
      self->finished = 1;
  }
  else {
      self->started = 0;
      self->finished = 0;
  }

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

1346static PyObject *
1347npyiter_enable_external_loop(NewNpyArrayIterObject *self)
1348{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  NpyIter_EnableExternalLoop(self->iter);
  /* EnableExternalLoop invalidates cached values */
  npyiter_cache_values(self);
  /* EnableExternalLoop also resets the iterator */
  if (NpyIter_GetIterSize(self->iter) == 0) {
      self->started = 1;
      self->finished = 1;
  }
  else {
      self->started = 0;
      self->finished = 0;
  }

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

1371static PyObject *
1372npyiter_debug_print(NewNpyArrayIterObject *self)
1373{
  if (self->iter != NULL((void*)0)) {
      NpyIter_DebugPrint(self->iter);
  }
  else {
      printf("Iterator: (nil)\n")__printf_chk (2 - 1, "Iterator: (nil)\n");
  }

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

1384NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1385npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i);

1387static PyObject *npyiter_value_get(NewNpyArrayIterObject *self)
1388{
  PyObject *ret;

  npy_intp iop, nop;

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  nop = NpyIter_GetNOp(self->iter);

  /* Return an array  or tuple of arrays with the values */
  if (nop == 1) {
      ret = npyiter_seq_item(self, 0);
  }
  else {
      ret = PyTuple_New(nop);
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
      for (iop = 0; iop < nop; ++iop) {
          PyObject *a = npyiter_seq_item(self, iop);
          if (a == NULL((void*)0)) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              return NULL((void*)0);
          }
          PyTuple_SET_ITEM(ret, iop, a)PyTuple_SetItem(ret, iop, a);
      }
  }

  return ret;
1421}

1423static PyObject *npyiter_operands_get(NewNpyArrayIterObject *self)
1424{
  PyObject *ret;

  npy_intp iop, nop;
  PyArrayObject **operands;

  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }
  nop = NpyIter_GetNOp(self->iter);
  operands = self->operands;

  ret = PyTuple_New(nop);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  for (iop = 0; iop < nop; ++iop) {
      PyObject *operand = (PyObject *)operands[iop];

      Py_INCREF(operand)_Py_INCREF(((PyObject*)(operand)));
      PyTuple_SET_ITEM(ret, iop, operand)PyTuple_SetItem(ret, iop, operand);
  }

  return ret;
1450}

1452static PyObject *npyiter_itviews_get(NewNpyArrayIterObject *self)
1453{
  PyObject *ret;

  npy_intp iop, nop;

  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }
  nop = NpyIter_GetNOp(self->iter);

  ret = PyTuple_New(nop);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  for (iop = 0; iop < nop; ++iop) {
      PyArrayObject *view = NpyIter_GetIterView(self->iter, iop);

      if (view == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
      PyTuple_SET_ITEM(ret, iop, (PyObject *)view)PyTuple_SetItem(ret, iop, (PyObject *)view);
  }

  return ret;
1480}

1482static PyObject *
1483npyiter_next(NewNpyArrayIterObject *self)
1484{
  if (self->iter == NULL((void*)0) || self->iternext == NULL((void*)0) ||
              self->finished) {
      return NULL((void*)0);
  }

  /*
   * Use the started flag for the Python iteration protocol to work
   * when buffering is enabled.
   */
  if (self->started) {
      if (!self->iternext(self->iter)) {
          /*
           * A casting error may be set here (or no error causing a
           * StopIteration). Buffers may only be cleaned up later.
           */
          self->finished = 1;
          return NULL((void*)0);
      }

      /* If there is nesting, the nested iterators should be reset */
      if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
          return NULL((void*)0);
      }
  }
  self->started = 1;

  return npyiter_value_get(self);
1512};

1514static PyObject *npyiter_shape_get(NewNpyArrayIterObject *self)
1515{
  npy_intp ndim, shape[NPY_MAXDIMS32];

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  if (NpyIter_GetShape(self->iter, shape) == NPY_SUCCEED1) {
      ndim = NpyIter_GetNDim(self->iter);
      return PyArray_IntTupleFromIntp(ndim, shape);
  }

  return NULL((void*)0);
1530}

1532static PyObject *npyiter_multi_index_get(NewNpyArrayIterObject *self)
1533{
  npy_intp ndim, multi_index[NPY_MAXDIMS32];

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  if (self->get_multi_index != NULL((void*)0)) {
      ndim = NpyIter_GetNDim(self->iter);
      self->get_multi_index(self->iter, multi_index);
      return PyArray_IntTupleFromIntp(ndim, multi_index);
  }
  else {
      if (!NpyIter_HasMultiIndex(self->iter)) {
          PyErr_SetString(PyExc_ValueError,
                  "Iterator is not tracking a multi-index");
          return NULL((void*)0);
      }
      else if (NpyIter_HasDelayedBufAlloc(self->iter)) {
          PyErr_SetString(PyExc_ValueError,
                  "Iterator construction used delayed buffer allocation, "
                  "and no reset has been done yet");
          return NULL((void*)0);
      }
      else {
          PyErr_SetString(PyExc_ValueError,
                  "Iterator is in an invalid state");
          return NULL((void*)0);
      }
  }
1565}

1567static int
1568npyiter_multi_index_set(NewNpyArrayIterObject *self, PyObject *value)
1569{
  npy_intp idim, ndim, multi_index[NPY_MAXDIMS32];

  if (value == NULL((void*)0)) {
1
Assuming 'value' is not equal to NULL→
2
←
Taking false branch→
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete nditer multi_index");
      return -1;
  }
  if (self->iter == NULL((void*)0)) {
3
←
Assuming field 'iter' is not equal to NULL→
4
←
Taking false branch→
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return -1;
  }

  if (NpyIter_HasMultiIndex(self->iter)) {
5
←
Taking true branch→
      ndim = NpyIter_GetNDim(self->iter);
      if (!PySequence_Check(value)) {
6
←
Assuming the condition is false→
7
←
Taking false branch→
          PyErr_SetString(PyExc_ValueError,
                  "multi_index must be set with a sequence");
          return -1;
      }
      if (PySequence_Size(value) != ndim) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
          PyErr_SetString(PyExc_ValueError,
                  "Wrong number of indices");
          return -1;
      }
      for (idim = 0; idim < ndim; ++idim) {
10
←
Assuming 'idim' is < 'ndim'→
11
←
Loop condition is true.  Entering loop body→
          PyObject *v = PySequence_GetItem(value, idim);
12
←
Calling 'PySequence_GetItem'→
14
←
Returning from 'PySequence_GetItem'→
16
←
PyObject ownership leak with reference count of 1
          multi_index[idim] = PyLong_AsLong(v);
          if (error_converting(multi_index[idim])(((multi_index[idim]) == -1) && PyErr_Occurred())) {
15
←
Assuming the condition is false→
              Py_XDECREF(v)_Py_XDECREF(((PyObject*)(v)));
              return -1;
          }
      }
      if (NpyIter_GotoMultiIndex(self->iter, multi_index) != NPY_SUCCEED1) {
          return -1;
      }
      self->started = 0;
      self->finished = 0;

      /* If there is nesting, the nested iterators should be reset */
      if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
          return -1;
      }

      return 0;
  }
  else {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is not tracking a multi-index");
      return -1;
  }
1621}

1623static PyObject *npyiter_index_get(NewNpyArrayIterObject *self)
1624{
  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  if (NpyIter_HasIndex(self->iter)) {
      npy_intp ind = *NpyIter_GetIndexPtr(self->iter);
      return PyLong_FromLong(ind);
  }
  else {
      PyErr_SetString(PyExc_ValueError,
              "Iterator does not have an index");
      return NULL((void*)0);
  }
1640}

1642static int npyiter_index_set(NewNpyArrayIterObject *self, PyObject *value)
1643{
  if (value == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete nditer index");
      return -1;
  }
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return -1;
  }

  if (NpyIter_HasIndex(self->iter)) {
      npy_intp ind;
      ind = PyLong_AsLong(value);
      if (error_converting(ind)(((ind) == -1) && PyErr_Occurred())) {
          return -1;
      }
      if (NpyIter_GotoIndex(self->iter, ind) != NPY_SUCCEED1) {
          return -1;
      }
      self->started = 0;
      self->finished = 0;

      /* If there is nesting, the nested iterators should be reset */
      if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
          return -1;
      }

      return 0;
  }
  else {
      PyErr_SetString(PyExc_ValueError,
              "Iterator does not have an index");
      return -1;
  }
1679}

1681static PyObject *npyiter_iterindex_get(NewNpyArrayIterObject *self)
1682{
  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  return PyLong_FromLong(NpyIter_GetIterIndex(self->iter));
1690}

1692static int npyiter_iterindex_set(NewNpyArrayIterObject *self, PyObject *value)
1693{
  npy_intp iterindex;

  if (value == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete nditer iterindex");
      return -1;
  }
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return -1;
  }

  iterindex = PyLong_AsLong(value);
  if (error_converting(iterindex)(((iterindex) == -1) && PyErr_Occurred())) {
      return -1;
  }
  if (NpyIter_GotoIterIndex(self->iter, iterindex) != NPY_SUCCEED1) {
      return -1;
  }
  self->started = 0;
  self->finished = 0;

  /* If there is nesting, the nested iterators should be reset */
  if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
      return -1;
  }

  return 0;
1723}

1725static PyObject *npyiter_iterrange_get(NewNpyArrayIterObject *self)
1726{
  npy_intp istart = 0, iend = 0;
  PyObject *ret;

  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  NpyIter_GetIterIndexRange(self->iter, &istart, &iend);

  ret = PyTuple_New(2);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }

  PyTuple_SET_ITEM(ret, 0, PyLong_FromLong(istart))PyTuple_SetItem(ret, 0, PyLong_FromLong(istart));
  PyTuple_SET_ITEM(ret, 1, PyLong_FromLong(iend))PyTuple_SetItem(ret, 1, PyLong_FromLong(iend));

  return ret;
1747}

1749static int npyiter_iterrange_set(NewNpyArrayIterObject *self, PyObject *value)
1750{
  npy_intp istart = 0, iend = 0;

  if (value == NULL((void*)0)) {
      PyErr_SetString(PyExc_AttributeError,
              "Cannot delete nditer iterrange");
      return -1;
  }
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return -1;
  }

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(value, "nn", &istart, &iend)) {
      return -1;
  }

  if (NpyIter_ResetToIterIndexRange(self->iter, istart, iend, NULL((void*)0))
                                                  != NPY_SUCCEED1) {
      return -1;
  }
  if (istart < iend) {
      self->started = self->finished = 0;
  }
  else {
      self->started = self->finished = 1;
  }

  if (self->get_multi_index == NULL((void*)0) && NpyIter_HasMultiIndex(self->iter)) {
      self->get_multi_index = NpyIter_GetGetMultiIndex(self->iter, NULL((void*)0));
  }

  /* If there is nesting, the nested iterators should be reset */
  if (npyiter_resetbasepointers(self) != NPY_SUCCEED1) {
      return -1;
  }

  return 0;
1789}

1791static PyObject *npyiter_has_delayed_bufalloc_get(NewNpyArrayIterObject *self)
1792{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      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);
  }
1805}

1807static PyObject *npyiter_iterationneedsapi_get(NewNpyArrayIterObject *self)
1808{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  if (NpyIter_IterationNeedsAPI(self->iter)) {
      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);
  }
1821}

1823static PyObject *npyiter_has_multi_index_get(NewNpyArrayIterObject *self)
1824{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  if (NpyIter_HasMultiIndex(self->iter)) {
      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);
  }
1837}

1839static PyObject *npyiter_has_index_get(NewNpyArrayIterObject *self)
1840{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  if (NpyIter_HasIndex(self->iter)) {
      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);
  }
1853}

1855static PyObject *npyiter_dtypes_get(NewNpyArrayIterObject *self)
1856{
  PyObject *ret;

  npy_intp iop, nop;
  PyArray_Descr **dtypes;

  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }
  nop = NpyIter_GetNOp(self->iter);

  ret = PyTuple_New(nop);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  dtypes = self->dtypes;
  for (iop = 0; iop < nop; ++iop) {
      PyArray_Descr *dtype = dtypes[iop];

      Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
      PyTuple_SET_ITEM(ret, iop, (PyObject *)dtype)PyTuple_SetItem(ret, iop, (PyObject *)dtype);
  }

  return ret;
1882}

1884static PyObject *npyiter_ndim_get(NewNpyArrayIterObject *self)
1885{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  return PyLong_FromLong(NpyIter_GetNDim(self->iter));
1893}

1895static PyObject *npyiter_nop_get(NewNpyArrayIterObject *self)
1896{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  return PyLong_FromLong(NpyIter_GetNOp(self->iter));
1904}

1906static PyObject *npyiter_itersize_get(NewNpyArrayIterObject *self)
1907{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is invalid");
      return NULL((void*)0);
  }

  return PyLong_FromLong(NpyIter_GetIterSize(self->iter));
1915}

1917static PyObject *npyiter_finished_get(NewNpyArrayIterObject *self)
1918{
  if (self->iter == NULL((void*)0) || !self->finished) {
      Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);
  }
  else {
      Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct);
  }
1925}

1927NPY_NO_EXPORT__attribute__((visibility("hidden"))) Py_ssize_t
1928npyiter_seq_length(NewNpyArrayIterObject *self)
1929{
  if (self->iter == NULL((void*)0)) {
      return 0;
  }
  else {
      return NpyIter_GetNOp(self->iter);
  }
1936}

1938NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1939npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i)
1940{
  npy_intp ret_ndim;
  npy_intp nop, innerloopsize, innerstride;
  char *dataptr;
  PyArray_Descr *dtype;
  int has_external_loop;
  Py_ssize_t i_orig = i;

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator construction used delayed buffer allocation, "
              "and no reset has been done yet");
      return NULL((void*)0);
  }
  nop = NpyIter_GetNOp(self->iter);

  /* Negative indexing */
  if (i < 0) {
      i += nop;
  }

  if (i < 0 || i >= nop) {
      PyErr_Format(PyExc_IndexError,
              "Iterator operand index %zd is out of bounds", i_orig);
      return NULL((void*)0);
  }

1973#if 0
  /*
   * This check is disabled because it prevents things like
   * np.add(it[0], it[1], it[2]), where it[2] is a write-only
   * parameter.  When write-only, the value of it[i] is
   * likely random junk, as if it were allocated with an
   * np.empty(...) call.
   */
  if (!self->readflags[i]) {
      PyErr_Format(PyExc_RuntimeError,
              "Iterator operand %zd is write-only", i);
      return NULL((void*)0);
  }
1986#endif

  dataptr = self->dataptrs[i];
  dtype = self->dtypes[i];
  has_external_loop = NpyIter_HasExternalLoop(self->iter);

  if (has_external_loop) {
      innerloopsize = *self->innerloopsizeptr;
      innerstride = self->innerstrides[i];
      ret_ndim = 1;
  }
  else {
      innerloopsize = 1;
      innerstride = 0;
      /* If the iterator is going over every element, return array scalars */
      ret_ndim = 0;
  }

  Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
  return PyArray_NewFromDescrAndBase(
          &PyArray_Type, dtype,
          ret_ndim, &innerloopsize, &innerstride, dataptr,
          self->writeflags[i] ? NPY_ARRAY_WRITEABLE0x0400 : 0,
          NULL((void*)0), (PyObject *)self);
2010}

2012NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2013npyiter_seq_slice(NewNpyArrayIterObject *self,
                  Py_ssize_t ilow, Py_ssize_t ihigh)
2015{
  PyObject *ret;
  npy_intp nop;
  Py_ssize_t i;

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator construction used delayed buffer allocation, "
              "and no reset has been done yet");
      return NULL((void*)0);
  }
  nop = NpyIter_GetNOp(self->iter);
  if (ilow < 0) {
      ilow = 0;
  }
  else if (ilow >= nop) {
      ilow = nop-1;
  }
  if (ihigh < ilow) {
      ihigh = ilow;
  }
  else if (ihigh > nop) {
      ihigh = nop;
  }

  ret = PyTuple_New(ihigh-ilow);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  for (i = ilow; i < ihigh ; ++i) {
      PyObject *item = npyiter_seq_item(self, i);
      if (item == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
      PyTuple_SET_ITEM(ret, i-ilow, item)PyTuple_SetItem(ret, i-ilow, item);
  }
  return ret;
2059}

2061NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2062npyiter_seq_ass_item(NewNpyArrayIterObject *self, Py_ssize_t i, PyObject *v)
2063{

  npy_intp nop, innerloopsize, innerstride;
  char *dataptr;
  PyArray_Descr *dtype;
  PyArrayObject *tmp;
  int ret, has_external_loop;
  Py_ssize_t i_orig = i;


  if (v == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
              "Cannot delete iterator elements");
      return -1;
  }

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return -1;
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator construction used delayed buffer allocation, "
              "and no reset has been done yet");
      return -1;
  }
  nop = NpyIter_GetNOp(self->iter);

  /* Negative indexing */
  if (i < 0) {
      i += nop;
  }

  if (i < 0 || i >= nop) {
      PyErr_Format(PyExc_IndexError,
              "Iterator operand index %zd is out of bounds", i_orig);
      return -1;
  }
  if (!self->writeflags[i]) {
      PyErr_Format(PyExc_RuntimeError,
              "Iterator operand %zd is not writeable", i_orig);
      return -1;
  }

  dataptr = self->dataptrs[i];
  dtype = self->dtypes[i];
  has_external_loop = NpyIter_HasExternalLoop(self->iter);

  if (has_external_loop) {
      innerloopsize = *self->innerloopsizeptr;
      innerstride = self->innerstrides[i];
  }
  else {
      innerloopsize = 1;
      innerstride = 0;
  }

  /* TODO - there should be a better way than this... */
  Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
  tmp = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
                              1, &innerloopsize,
                              &innerstride, dataptr,
                              NPY_ARRAY_WRITEABLE0x0400, NULL((void*)0));
  if (tmp == NULL((void*)0)) {
      return -1;
  }

  ret = PyArray_CopyObject(tmp, v);
  Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
  return ret;
2135}

2137static int
2138npyiter_seq_ass_slice(NewNpyArrayIterObject *self, Py_ssize_t ilow,
              Py_ssize_t ihigh, PyObject *v)
2140{
  npy_intp nop;
  Py_ssize_t i;

  if (v == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
              "Cannot delete iterator elements");
      return -1;
  }

  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return -1;
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator construction used delayed buffer allocation, "
              "and no reset has been done yet");
      return -1;
  }
  nop = NpyIter_GetNOp(self->iter);
  if (ilow < 0) {
      ilow = 0;
  }
  else if (ilow >= nop) {
      ilow = nop-1;
  }
  if (ihigh < ilow) {
      ihigh = ilow;
  }
  else if (ihigh > nop) {
      ihigh = nop;
  }

  if (!PySequence_Check(v) || PySequence_Size(v) != ihigh-ilow) {
      PyErr_SetString(PyExc_ValueError,
              "Wrong size to assign to iterator slice");
      return -1;
  }

  for (i = ilow; i < ihigh ; ++i) {
      PyObject *item = PySequence_GetItem(v, i-ilow);
      if (item == NULL((void*)0)) {
          return -1;
      }
      if (npyiter_seq_ass_item(self, i, item) < 0) {
          Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
          return -1;
      }
      Py_DECREF(item)_Py_DECREF(((PyObject*)(item)));
  }

  return 0;
2195}

2197static PyObject *
2198npyiter_subscript(NewNpyArrayIterObject *self, PyObject *op)
2199{
  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return NULL((void*)0);
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator construction used delayed buffer allocation, "
              "and no reset has been done yet");
      return NULL((void*)0);
  }

  if (PyLong_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 24))) != 0) ||
                  (PyIndex_Check(op)((op)->ob_type->tp_as_number != ((void*)0) && (
op)->ob_type->tp_as_number->nb_index != ((void*)0)) && !PySequence_Check(op))) {
      npy_intp i = PyArray_PyIntAsIntp(op);
      if (error_converting(i)(((i) == -1) && PyErr_Occurred())) {
          return NULL((void*)0);
      }
      return npyiter_seq_item(self, i);
  }
  else if (PySlice_Check(op)((((PyObject*)(op))->ob_type) == &PySlice_Type)) {
      Py_ssize_t istart = 0, iend = 0, istep = 0, islicelength;
      if (PySlice_GetIndicesEx(op, NpyIter_GetNOp(self->iter),( PySlice_Unpack((op), (&istart), (&iend), (&istep
)) < 0 ? ((*(&islicelength) = 0), -1) : ((*(&islicelength
) = PySlice_AdjustIndices((NpyIter_GetNOp(self->iter)), (&
istart), (&iend), *(&istep))), 0))
                               &istart, &iend, &istep, &islicelength)( PySlice_Unpack((op), (&istart), (&iend), (&istep
)) < 0 ? ((*(&islicelength) = 0), -1) : ((*(&islicelength
) = PySlice_AdjustIndices((NpyIter_GetNOp(self->iter)), (&
istart), (&iend), *(&istep))), 0)) < 0) {
          return NULL((void*)0);
      }
      if (istep != 1) {
          PyErr_SetString(PyExc_ValueError,
                  "Iterator slicing only supports a step of 1");
          return NULL((void*)0);
      }
      return npyiter_seq_slice(self, istart, iend);
  }

  PyErr_SetString(PyExc_TypeError,
          "invalid index type for iterator indexing");
  return NULL((void*)0);
2238}

2240static int
2241npyiter_ass_subscript(NewNpyArrayIterObject *self, PyObject *op,
                      PyObject *value)
2243{
  if (value == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
              "Cannot delete iterator elements");
      return -1;
  }
  if (self->iter == NULL((void*)0) || self->finished) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator is past the end");
      return -1;
  }

  if (NpyIter_HasDelayedBufAlloc(self->iter)) {
      PyErr_SetString(PyExc_ValueError,
              "Iterator construction used delayed buffer allocation, "
              "and no reset has been done yet");
      return -1;
  }

  if (PyLong_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 24))) != 0) ||
                  (PyIndex_Check(op)((op)->ob_type->tp_as_number != ((void*)0) && (
op)->ob_type->tp_as_number->nb_index != ((void*)0)) && !PySequence_Check(op))) {
      npy_intp i = PyArray_PyIntAsIntp(op);
      if (error_converting(i)(((i) == -1) && PyErr_Occurred())) {
          return -1;
      }
      return npyiter_seq_ass_item(self, i, value);
  }
  else if (PySlice_Check(op)((((PyObject*)(op))->ob_type) == &PySlice_Type)) {
      Py_ssize_t istart = 0, iend = 0, istep = 0, islicelength = 0;
      if (PySlice_GetIndicesEx(op, NpyIter_GetNOp(self->iter),( PySlice_Unpack((op), (&istart), (&iend), (&istep
)) < 0 ? ((*(&islicelength) = 0), -1) : ((*(&islicelength
) = PySlice_AdjustIndices((NpyIter_GetNOp(self->iter)), (&
istart), (&iend), *(&istep))), 0))
                               &istart, &iend, &istep, &islicelength)( PySlice_Unpack((op), (&istart), (&iend), (&istep
)) < 0 ? ((*(&islicelength) = 0), -1) : ((*(&islicelength
) = PySlice_AdjustIndices((NpyIter_GetNOp(self->iter)), (&
istart), (&iend), *(&istep))), 0)) < 0) {
          return -1;
      }
      if (istep != 1) {
          PyErr_SetString(PyExc_ValueError,
                  "Iterator slice assignment only supports a step of 1");
          return -1;
      }
      return npyiter_seq_ass_slice(self, istart, iend, value);
  }

  PyErr_SetString(PyExc_TypeError,
          "invalid index type for iterator indexing");
  return -1;
2287}

2289static PyObject *
2290npyiter_enter(NewNpyArrayIterObject *self)
2291{
  if (self->iter == NULL((void*)0)) {
      PyErr_SetString(PyExc_RuntimeError, "operation on non-initialized iterator");
      return NULL((void*)0);
  }
  Py_INCREF(self)_Py_INCREF(((PyObject*)(self)));
  return (PyObject *)self;
2298}

2300static PyObject *
2301npyiter_close(NewNpyArrayIterObject *self)
2302{
  NpyIter *iter = self->iter;
  int ret;
  if (self->iter == NULL((void*)0)) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  ret = NpyIter_Deallocate(iter);
  self->iter = NULL((void*)0);
  Py_XDECREF(self->nested_child)_Py_XDECREF(((PyObject*)(self->nested_child)));
  self->nested_child = NULL((void*)0);
  if (ret != NPY_SUCCEED1) {
      return NULL((void*)0);
  }
  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
2316}

2318static PyObject *
2319npyiter_exit(NewNpyArrayIterObject *self, PyObject *NPY_UNUSED(args)(__NPY_UNUSED_TAGGEDargs) __attribute__ ((__unused__)))
2320{
  /* even if called via exception handling, writeback any data */
  return npyiter_close(self);
2323}

2325static PyMethodDef npyiter_methods[] = {
  {"reset",
      (PyCFunction)npyiter_reset,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"copy",
      (PyCFunction)npyiter_copy,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"__copy__",
      (PyCFunction)npyiter_copy,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"iternext",
      (PyCFunction)npyiter_iternext,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"remove_axis",
      (PyCFunction)npyiter_remove_axis,
      METH_VARARGS0x0001, NULL((void*)0)},
  {"remove_multi_index",
      (PyCFunction)npyiter_remove_multi_index,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"enable_external_loop",
      (PyCFunction)npyiter_enable_external_loop,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"debug_print",
      (PyCFunction)npyiter_debug_print,
      METH_NOARGS0x0004, NULL((void*)0)},
  {"__enter__", (PyCFunction)npyiter_enter,
       METH_NOARGS0x0004,  NULL((void*)0)},
  {"__exit__",  (PyCFunction)npyiter_exit,
       METH_VARARGS0x0001, NULL((void*)0)},
  {"close",  (PyCFunction)npyiter_close,
       METH_NOARGS0x0004, NULL((void*)0)},
  {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)},
2357};

2359static PyMemberDef npyiter_members[] = {
  {NULL((void*)0), 0, 0, 0, NULL((void*)0)},
2361};

2363static PyGetSetDef npyiter_getsets[] = {
  {"value",
      (getter)npyiter_value_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"shape",
      (getter)npyiter_shape_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"multi_index",
      (getter)npyiter_multi_index_get,
      (setter)npyiter_multi_index_set,
      NULL((void*)0), NULL((void*)0)},
  {"index",
      (getter)npyiter_index_get,
      (setter)npyiter_index_set,
      NULL((void*)0), NULL((void*)0)},
  {"iterindex",
      (getter)npyiter_iterindex_get,
      (setter)npyiter_iterindex_set,
      NULL((void*)0), NULL((void*)0)},
  {"iterrange",
      (getter)npyiter_iterrange_get,
      (setter)npyiter_iterrange_set,
      NULL((void*)0), NULL((void*)0)},
  {"operands",
      (getter)npyiter_operands_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"itviews",
      (getter)npyiter_itviews_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"has_delayed_bufalloc",
      (getter)npyiter_has_delayed_bufalloc_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"iterationneedsapi",
      (getter)npyiter_iterationneedsapi_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"has_multi_index",
      (getter)npyiter_has_multi_index_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"has_index",
      (getter)npyiter_has_index_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"dtypes",
      (getter)npyiter_dtypes_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"ndim",
      (getter)npyiter_ndim_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"nop",
      (getter)npyiter_nop_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"itersize",
      (getter)npyiter_itersize_get,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"finished",
      (getter)npyiter_finished_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)}
2421};

2423NPY_NO_EXPORT__attribute__((visibility("hidden"))) PySequenceMethods npyiter_as_sequence = {
  (lenfunc)npyiter_seq_length,            /*sq_length*/
  (binaryfunc)NULL((void*)0),                       /*sq_concat*/
  (ssizeargfunc)NULL((void*)0),                     /*sq_repeat*/
  (ssizeargfunc)npyiter_seq_item,         /*sq_item*/
  (ssizessizeargfunc)NULL((void*)0),                /*sq_slice*/
  (ssizeobjargproc)npyiter_seq_ass_item,  /*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 */
2434};

2436NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyMappingMethods npyiter_as_mapping = {
  (lenfunc)npyiter_seq_length,          /*mp_length*/
  (binaryfunc)npyiter_subscript,        /*mp_subscript*/
  (objobjargproc)npyiter_ass_subscript, /*mp_ass_subscript*/
2440};

2442NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyTypeObject NpyIter_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
  .tp_name = "numpy.nditer",
  .tp_basicsize = sizeof(NewNpyArrayIterObject),
  .tp_dealloc = (destructor)npyiter_dealloc,
  .tp_as_sequence = &npyiter_as_sequence,
  .tp_as_mapping = &npyiter_as_mapping,
  .tp_flags = Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),
  .tp_iternext = (iternextfunc)npyiter_next,
  .tp_methods = npyiter_methods,
  .tp_members = npyiter_members,
  .tp_getset = npyiter_getsets,
  .tp_init = (initproc)npyiter_init,
  .tp_new = npyiter_new,
2456};

←

/opt/pyrefcon/lib/pyrefcon/models/models/PySequence_GetItem.model

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