Function list_ass_slice

src/JSArrayProxy.cc:166–264

a[ilow:ihigh] = v if v != NULL. * del a[ilow:ihigh] if v == NULL. */ private

 */
// private
static int list_ass_slice(JSArrayProxy *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
{
  /* Because [X]DECREF can recursively invoke list operations on
     this list, we must postpone all [X]DECREF activity until
     after the list is back in its canonical shape.  Therefore
     we must allocate an additional array, 'recycle', into which
     we temporarily copy the items that are deleted from the
     list. :-( */
  PyObject **item;
  PyObject **vitem = NULL;
  PyObject *v_as_SF = NULL;   /* PySequence_Fast(v) */
  Py_ssize_t n;   /* # of elements in replacement list */
  Py_ssize_t norig;   /* # of elements in list getting replaced */
  Py_ssize_t d;   /* Change in size */
  Py_ssize_t k;
  size_t s;
  int result = -1;              /* guilty until proved innocent */
#define b ((PyListObject *)v)
  Py_ssize_t selfLength = JSArrayProxyMethodDefinitions::JSArrayProxy_length(self);
  if (v == NULL) {
    n = 0;
  }
  else {
    if ((PyListObject *)self == b) {
      /* Special case "a[i:j] = a" -- copy b first */
      v = list_slice(self, 0, selfLength);
      if (v == NULL) {
        return result;
      }
      result = list_ass_slice(self, ilow, ihigh, v);
      Py_DECREF(v);
      return result;
    }
    v_as_SF = PySequence_Fast(v, "can only assign an iterable");
    if (v_as_SF == NULL) {
      return result;
    }
    n = PySequence_Fast_GET_SIZE(v_as_SF);
    vitem = PySequence_Fast_ITEMS(v_as_SF);
  }

  if (ilow < 0) {
    ilow = 0;
  }
  else if (ilow > selfLength) {
    ilow = selfLength;
  }

  if (ihigh < ilow) {
    ihigh = ilow;
  }
  else if (ihigh > selfLength) {
    ihigh = selfLength;
  }

  norig = ihigh - ilow;
  assert(norig >= 0);
  d = n - norig;