a question about __ziplistDelete function in ziplist.c

[秦超]

I have a question about __ziplistDelete function as follows:

```bash

            /* When the tail contains more than one entry, we need to take

             * "nextdiff" in account as well. Otherwise, a change in the

             * size of prevlen doesn't have an effect on the *tail* offset. */

            zipEntry(p, &tail);

            if (p[tail.headersize+tail.len] != ZIP_END) {

                ZIPLIST_TAIL_OFFSET(zl) =

                   intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);

            }

```

As we know, ZIPLIST_TAIL_OFFSET macro returns the offset of the last item(entry) inside the ziplist.

When the tail contians just one entry instead of more than one entry , should we take "nextdiff"

 in account as well? Is there a problem about these lines:

```bash

      if (p[tail.headersize+tail.len] != ZIP_END) {

                ZIPLIST_TAIL_OFFSET(zl) =

                   intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);

            }

```

Thanks.

```bash

/* Delete "num" entries, starting at "p". Returns pointer to the ziplist. */

unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsigned int num) {

    unsigned int i, totlen, deleted = 0;

    size_t offset;

    int nextdiff = 0;

    zlentry first, tail;

    zipEntry(p, &first);

    for (i = 0; p[0] != ZIP_END && i < num; i++) {

        p += zipRawEntryLength(p);

        deleted++;

    }

    totlen = p-first.p; /* Bytes taken by the element(s) to delete. */

    if (totlen > 0) {

        if (p[0] != ZIP_END) {

            /* Storing `prevrawlen` in this entry may increase or decrease the

             * number of bytes required compare to the current `prevrawlen`.

             * There always is room to store this, because it was previously

             * stored by an entry that is now being deleted. */

            nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);

            /* Note that there is always space when p jumps backward: if

             * the new previous entry is large, one of the deleted elements

             * had a 5 bytes prevlen header, so there is for sure at least

             * 5 bytes free and we need just 4. */

            p -= nextdiff;

            zipStorePrevEntryLength(p,first.prevrawlen);

            /* Update offset for tail */

            ZIPLIST_TAIL_OFFSET(zl) =

                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))-totlen);

            /* When the tail contains more than one entry, we need to take

             * "nextdiff" in account as well. Otherwise, a change in the

             * size of prevlen doesn't have an effect on the *tail* offset. */

            zipEntry(p, &tail);

            if (p[tail.headersize+tail.len] != ZIP_END) {

                ZIPLIST_TAIL_OFFSET(zl) =

                   intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);

            }

            /* Move tail to the front of the ziplist */

            memmove(first.p,p,

                intrev32ifbe(ZIPLIST_BYTES(zl))-(p-zl)-1);

        } else {

            /* The entire tail was deleted. No need to move memory. */

            ZIPLIST_TAIL_OFFSET(zl) =

                intrev32ifbe((first.p-zl)-first.prevrawlen);

        }

        /* Resize and update length */

        offset = first.p-zl;

        zl = ziplistResize(zl, intrev32ifbe(ZIPLIST_BYTES(zl))-totlen+nextdiff);

        ZIPLIST_INCR_LENGTH(zl,-deleted);

        p = zl+offset;

        /* When nextdiff != 0, the raw length of the next entry has changed, so

         * we need to cascade the update throughout the ziplist */

        if (nextdiff != 0)

            zl = __ziplistCascadeUpdate(zl,p);

    }

    return zl;

}

```