fix signedness errors in ziplist testing code

[redis.git] / ziplist.c

diff --git a/ziplist.c b/ziplist.c
index 8ac84975643ae814cdba2c09c0ed0eb9ccac6865..b03ba43f53f1e4c42c976cd621e47b51cde79fcd 100644 (file)
--- a/ziplist.c
+++ b/ziplist.c
@@ -45,7 +45,7 @@
 
 /* Utility macros */
 #define ZIPLIST_BYTES(zl) (*((unsigned int*)(zl)))
 
 /* Utility macros */
 #define ZIPLIST_BYTES(zl) (*((unsigned int*)(zl)))

-#define ZIPLIST_TAIL_OFFSET(zl) (*((zl)+sizeof(unsigned int)))
+#define ZIPLIST_TAIL_OFFSET(zl) (*((unsigned int*)((zl)+sizeof(unsigned int))))

 #define ZIPLIST_LENGTH(zl) (*((zl)+2*sizeof(unsigned int)))
 #define ZIPLIST_HEADER_SIZE (2*sizeof(unsigned int)+1)
 #define ZIPLIST_ENTRY_HEAD(zl) ((zl)+ZIPLIST_HEADER_SIZE)
 #define ZIPLIST_LENGTH(zl) (*((zl)+2*sizeof(unsigned int)))
 #define ZIPLIST_HEADER_SIZE (2*sizeof(unsigned int)+1)
 #define ZIPLIST_ENTRY_HEAD(zl) ((zl)+ZIPLIST_HEADER_SIZE)


@@ -63,7 +63,7 @@ typedef struct zlentry {
 } zlentry;
 
 /* Return bytes needed to store integer encoded by 'encoding' */
 } zlentry;
 
 /* Return bytes needed to store integer encoded by 'encoding' */

-static unsigned int zipEncodingSize(char encoding) {
+static unsigned int zipEncodingSize(unsigned char encoding) {

     if (encoding == ZIP_ENC_SHORT) {
         return sizeof(short int);
     } else if (encoding == ZIP_ENC_INT) {
     if (encoding == ZIP_ENC_SHORT) {
         return sizeof(short int);
     } else if (encoding == ZIP_ENC_INT) {


@@ -133,18 +133,47 @@ static unsigned int zipEncodeLength(unsigned char *p, char encoding, unsigned in
     return len;
 }
 
     return len;
 }
 

+/* Decode the length of the previous element stored at "p". */
+static unsigned int zipPrevDecodeLength(unsigned char *p, unsigned int *lensize) {
+    unsigned int len = *p;
+    if (len < ZIP_BIGLEN) {
+        if (lensize) *lensize = 1;
+    } else {
+        if (lensize) *lensize = 1+sizeof(len);
+        memcpy(&len,p+1,sizeof(len));
+    }
+    return len;
+}
+
+/* Encode the length of the previous entry and write it to "p". Return the
+ * number of bytes needed to encode this length if "p" is NULL. */
+static unsigned int zipPrevEncodeLength(unsigned char *p, unsigned int len) {
+    if (p == NULL) {
+        return (len < ZIP_BIGLEN) ? 1 : sizeof(len)+1;
+    } else {
+        if (len < ZIP_BIGLEN) {
+            p[0] = len;
+            return 1;
+        } else {
+            p[0] = ZIP_BIGLEN;
+            memcpy(p+1,&len,sizeof(len));
+            return 1+sizeof(len);
+        }
+    }
+}
+

 /* Return the difference in number of bytes needed to store the new length
  * "len" on the entry pointed to by "p". */
 static int zipPrevLenByteDiff(unsigned char *p, unsigned int len) {
     unsigned int prevlensize;
 /* Return the difference in number of bytes needed to store the new length
  * "len" on the entry pointed to by "p". */
 static int zipPrevLenByteDiff(unsigned char *p, unsigned int len) {
     unsigned int prevlensize;

-    zipDecodeLength(p,&prevlensize);
-    return zipEncodeLength(NULL,ZIP_ENC_RAW,len)-prevlensize;
+    zipPrevDecodeLength(p,&prevlensize);
+    return zipPrevEncodeLength(NULL,len)-prevlensize;

 }
 
 /* Check if string pointed to by 'entry' can be encoded as an integer.
  * Stores the integer value in 'v' and its encoding in 'encoding'.
  * Warning: this function requires a NULL-terminated string! */
 }
 
 /* Check if string pointed to by 'entry' can be encoded as an integer.
  * Stores the integer value in 'v' and its encoding in 'encoding'.
  * Warning: this function requires a NULL-terminated string! */

-static int zipTryEncoding(unsigned char *entry, long long *v, char *encoding) {
+static int zipTryEncoding(unsigned char *entry, long long *v, unsigned char *encoding) {

     long long value;
     char *eptr;
 
     long long value;
     char *eptr;
 


@@ -165,7 +194,7 @@ static int zipTryEncoding(unsigned char *entry, long long *v, char *encoding) {
 }
 
 /* Store integer 'value' at 'p', encoded as 'encoding' */
 }
 
 /* Store integer 'value' at 'p', encoded as 'encoding' */

-static void zipSaveInteger(unsigned char *p, long long value, char encoding) {
+static void zipSaveInteger(unsigned char *p, long long value, unsigned char encoding) {

     short int s;
     int i;
     long long l;
     short int s;
     int i;
     long long l;


@@ -184,7 +213,7 @@ static void zipSaveInteger(unsigned char *p, long long value, char encoding) {
 }
 
 /* Read integer encoded as 'encoding' from 'p' */
 }
 
 /* Read integer encoded as 'encoding' from 'p' */

-static long long zipLoadInteger(unsigned char *p, char encoding) {
+static long long zipLoadInteger(unsigned char *p, unsigned char encoding) {

     short int s;
     int i;
     long long l, ret;
     short int s;
     int i;
     long long l, ret;


@@ -206,7 +235,7 @@ static long long zipLoadInteger(unsigned char *p, char encoding) {
 /* Return a struct with all information about an entry. */
 static zlentry zipEntry(unsigned char *p) {
     zlentry e;
 /* Return a struct with all information about an entry. */
 static zlentry zipEntry(unsigned char *p) {
     zlentry e;

-    e.prevrawlen = zipDecodeLength(p,&e.prevrawlensize);
+    e.prevrawlen = zipPrevDecodeLength(p,&e.prevrawlensize);

     e.len = zipDecodeLength(p+e.prevrawlensize,&e.lensize);
     e.headersize = e.prevrawlensize+e.lensize;
     e.encoding = ZIP_ENCODING(p+e.prevrawlensize);
     e.len = zipDecodeLength(p+e.prevrawlensize,&e.lensize);
     e.headersize = e.prevrawlensize+e.lensize;
     e.encoding = ZIP_ENCODING(p+e.prevrawlensize);


@@ -240,7 +269,7 @@ static unsigned char *ziplistResize(unsigned char *zl, unsigned int len) {
 }
 
 /* Delete "num" entries, starting at "p". Returns pointer to the ziplist. */
 }
 
 /* Delete "num" entries, starting at "p". Returns pointer to the ziplist. */

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

     unsigned int i, totlen, deleted = 0;
     int nextdiff = 0;
     zlentry first = zipEntry(p);
     unsigned int i, totlen, deleted = 0;
     int nextdiff = 0;
     zlentry first = zipEntry(p);


@@ -257,7 +286,7 @@ static unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, int n
              * prevlen. Note that we can always store this length because
              * it was previously stored by an entry that is being deleted. */
             nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);
              * prevlen. Note that we can always store this length because
              * it was previously stored by an entry that is being deleted. */
             nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);

-            zipEncodeLength(p-nextdiff,ZIP_ENC_RAW,first.prevrawlen);
+            zipPrevEncodeLength(p-nextdiff,first.prevrawlen);

 
             /* Update offset for tail */
             ZIPLIST_TAIL_OFFSET(zl) -= totlen+nextdiff;
 
             /* Update offset for tail */
             ZIPLIST_TAIL_OFFSET(zl) -= totlen+nextdiff;


@@ -281,7 +310,7 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
     unsigned int curlen = ZIPLIST_BYTES(zl), reqlen, prevlen = 0;
     unsigned int offset, nextdiff = 0;
     unsigned char *tail;
     unsigned int curlen = ZIPLIST_BYTES(zl), reqlen, prevlen = 0;
     unsigned int offset, nextdiff = 0;
     unsigned char *tail;

-    char encoding = ZIP_ENC_RAW;
+    unsigned char encoding = ZIP_ENC_RAW;

     long long value;
     zlentry entry;
 
     long long value;
     zlentry entry;
 


@@ -305,13 +334,13 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
 
     /* We need space for both the length of the previous entry and
      * the length of the payload. */
 
     /* We need space for both the length of the previous entry and
      * the length of the payload. */

-    reqlen += zipEncodeLength(NULL,ZIP_ENC_RAW,prevlen);
+    reqlen += zipPrevEncodeLength(NULL,prevlen);

     reqlen += zipEncodeLength(NULL,encoding,slen);
 
     /* When the insert position is not equal to the tail, we need to
      * make sure that the next entry can hold this entry's length in
      * its prevlen field. */
     reqlen += zipEncodeLength(NULL,encoding,slen);
 
     /* When the insert position is not equal to the tail, we need to
      * make sure that the next entry can hold this entry's length in
      * its prevlen field. */

-    nextdiff = p[0] != ZIP_END ? zipPrevLenByteDiff(p,reqlen) : 0;
+    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;

 
     /* Store offset because a realloc may change the address of zl. */
     offset = p-zl;
 
     /* Store offset because a realloc may change the address of zl. */
     offset = p-zl;


@@ -323,7 +352,7 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
         /* Subtract one because of the ZIP_END bytes */
         memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
         /* Encode this entry's raw length in the next entry. */
         /* Subtract one because of the ZIP_END bytes */
         memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
         /* Encode this entry's raw length in the next entry. */

-        zipEncodeLength(p+reqlen,ZIP_ENC_RAW,reqlen);
+        zipPrevEncodeLength(p+reqlen,reqlen);

         /* Update offset for tail */
         ZIPLIST_TAIL_OFFSET(zl) += reqlen+nextdiff;
     } else {
         /* Update offset for tail */
         ZIPLIST_TAIL_OFFSET(zl) += reqlen+nextdiff;
     } else {


@@ -332,7 +361,7 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
     }
 
     /* Write the entry */
     }
 
     /* Write the entry */

-    p += zipEncodeLength(p,ZIP_ENC_RAW,prevlen);
+    p += zipPrevEncodeLength(p,prevlen);

     p += zipEncodeLength(p,encoding,slen);
     if (encoding != ZIP_ENC_RAW) {
         zipSaveInteger(p,value,encoding);
     p += zipEncodeLength(p,encoding,slen);
     if (encoding != ZIP_ENC_RAW) {
         zipSaveInteger(p,value,encoding);


@@ -373,20 +402,62 @@ unsigned char *ziplistPop(unsigned char *zl, sds *target, int where) {
     return zl;
 }
 
     return zl;
 }
 

-/* Returns an offset to use for iterating with ziplistNext. */
-unsigned char *ziplistIndex(unsigned char *zl, unsigned int index) {
-    unsigned char *p = zl+ZIPLIST_HEADER_SIZE;
-    unsigned int i = 0;
-    for (; i < index; i++) {
-        if (*p == ZIP_END) break;
-        p += zipRawEntryLength(p);
+/* Returns an offset to use for iterating with ziplistNext. When the given
+ * index is negative, the list is traversed back to front. When the list
+ * doesn't contain an element at the provided index, NULL is returned. */
+unsigned char *ziplistIndex(unsigned char *zl, int index) {
+    unsigned char *p;
+    zlentry entry;
+    if (index < 0) {
+        index = (-index)-1;
+        p = ZIPLIST_ENTRY_TAIL(zl);
+        if (p[0] != ZIP_END) {
+            entry = zipEntry(p);
+            while (entry.prevrawlen > 0 && index--) {
+                p -= entry.prevrawlen;
+                entry = zipEntry(p);
+            }
+        }
+    } else {
+        p = ZIPLIST_ENTRY_HEAD(zl);
+        while (p[0] != ZIP_END && index--) {
+            p += zipRawEntryLength(p);
+        }

     }
     }

-    return p;
+    return (p[0] == ZIP_END || index > 0) ? NULL : p;

 }
 
 /* Return pointer to next entry in ziplist. */
 }
 
 /* Return pointer to next entry in ziplist. */

-unsigned char *ziplistNext(unsigned char *p) {
-    return *p == ZIP_END ? p : p+zipRawEntryLength(p);
+unsigned char *ziplistNext(unsigned char *zl, unsigned char *p) {
+    ((void) zl);
+
+    /* "p" could be equal to ZIP_END, caused by ziplistDelete,
+     * and we should return NULL. Otherwise, we should return NULL
+     * when the *next* element is ZIP_END (there is no next entry). */
+    if (p[0] == ZIP_END) {
+        return NULL;
+    } else {
+        p = p+zipRawEntryLength(p);
+        return (p[0] == ZIP_END) ? NULL : p;
+    }
+}
+
+/* Return pointer to previous entry in ziplist. */
+unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) {
+    zlentry entry;
+
+    /* Iterating backwards from ZIP_END should return the tail. When "p" is
+     * equal to the first element of the list, we're already at the head,
+     * and should return NULL. */
+    if (p[0] == ZIP_END) {
+        p = ZIPLIST_ENTRY_TAIL(zl);
+        return (p[0] == ZIP_END) ? NULL : p;
+    } else if (p == ZIPLIST_ENTRY_HEAD(zl)) {
+        return NULL;
+    } else {
+        entry = zipEntry(p);
+        return p-entry.prevrawlen;
+    }

 }
 
 /* Get entry pointer to by 'p' and store in either 'e' or 'v' depending
 }
 
 /* Get entry pointer to by 'p' and store in either 'e' or 'v' depending


@@ -395,7 +466,7 @@ unsigned char *ziplistNext(unsigned char *p) {
  * Return 0 if 'p' points to the end of the zipmap, 1 otherwise. */
 unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
     zlentry entry;
  * Return 0 if 'p' points to the end of the zipmap, 1 otherwise. */
 unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
     zlentry entry;

-    if (*p == ZIP_END) return 0;
+    if (p == NULL || p[0] == ZIP_END) return 0;

     if (sstr) *sstr = NULL;
 
     entry = zipEntry(p);
     if (sstr) *sstr = NULL;
 
     entry = zipEntry(p);


@@ -412,10 +483,9 @@ unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *sl
     return 1;
 }
 
     return 1;
 }
 

-/* Delete a range of entries from the ziplist. */
-unsigned char *ziplistDeleteRange(unsigned char *zl, unsigned int index, unsigned int num) {
-    unsigned char *p = ziplistIndex(zl,index);
-    return __ziplistDelete(zl,p,num);
+/* Insert an entry at "p". */
+unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
+    return __ziplistInsert(zl,p,s,slen);

 }
 
 /* Delete a single entry from the ziplist, pointed to by *p.
 }
 
 /* Delete a single entry from the ziplist, pointed to by *p.


@@ -426,17 +496,25 @@ unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
     zl = __ziplistDelete(zl,*p,1);
 
     /* Store pointer to current element in p, because ziplistDelete will
     zl = __ziplistDelete(zl,*p,1);
 
     /* Store pointer to current element in p, because ziplistDelete will

-     * do a realloc which might result in a different "zl"-pointer. */
+     * do a realloc which might result in a different "zl"-pointer.
+     * When the delete direction is back to front, we might delete the last
+     * entry and end up with "p" pointing to ZIP_END, so check this. */

     *p = zl+offset;
     return zl;
 }
 
     *p = zl+offset;
     return zl;
 }
 

+/* Delete a range of entries from the ziplist. */
+unsigned char *ziplistDeleteRange(unsigned char *zl, unsigned int index, unsigned int num) {
+    unsigned char *p = ziplistIndex(zl,index);
+    return (p == NULL) ? zl : __ziplistDelete(zl,p,num);
+}
+

 /* Compare entry pointer to by 'p' with 'entry'. Return 1 if equal. */
 unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int slen) {
     zlentry entry;
     unsigned char sencoding;
 /* Compare entry pointer to by 'p' with 'entry'. Return 1 if equal. */
 unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int slen) {
     zlentry entry;
     unsigned char sencoding;

-    long long val, sval;
-    if (*p == ZIP_END) return 0;
+    long long zval, sval;
+    if (p[0] == ZIP_END) return 0;

 
     entry = zipEntry(p);
     if (entry.encoding == ZIP_ENC_RAW) {
 
     entry = zipEntry(p);
     if (entry.encoding == ZIP_ENC_RAW) {


@@ -450,8 +528,8 @@ unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int
         /* Try to compare encoded values */
         if (zipTryEncoding(sstr,&sval,&sencoding)) {
             if (entry.encoding == sencoding) {
         /* Try to compare encoded values */
         if (zipTryEncoding(sstr,&sval,&sencoding)) {
             if (entry.encoding == sencoding) {

-                val = zipLoadInteger(p+entry.headersize,entry.encoding);
-                return val == sval;
+                zval = zipLoadInteger(p+entry.headersize,entry.encoding);
+                return zval == sval;

             }
         }
     }
             }
         }
     }


@@ -518,22 +596,23 @@ unsigned char *createIntList() {
     char buf[32];
 
     sprintf(buf, "100");
     char buf[32];
 
     sprintf(buf, "100");

-    zl = ziplistPush(zl, buf, strlen(buf), ZIPLIST_TAIL);
+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);

     sprintf(buf, "128000");
     sprintf(buf, "128000");

-    zl = ziplistPush(zl, buf, strlen(buf), ZIPLIST_TAIL);
+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);

     sprintf(buf, "-100");
     sprintf(buf, "-100");

-    zl = ziplistPush(zl, buf, strlen(buf), ZIPLIST_HEAD);
+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_HEAD);

     sprintf(buf, "4294967296");
     sprintf(buf, "4294967296");

-    zl = ziplistPush(zl, buf, strlen(buf), ZIPLIST_HEAD);
+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_HEAD);

     sprintf(buf, "non integer");
     sprintf(buf, "non integer");

-    zl = ziplistPush(zl, buf, strlen(buf), ZIPLIST_TAIL);
+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);

     sprintf(buf, "much much longer non integer");
     sprintf(buf, "much much longer non integer");

-    zl = ziplistPush(zl, buf, strlen(buf), ZIPLIST_TAIL);
+    zl = ziplistPush(zl, (unsigned char*)buf, strlen(buf), ZIPLIST_TAIL);

     return zl;
 }
 
 int main(int argc, char **argv) {
     return zl;
 }
 
 int main(int argc, char **argv) {

-    unsigned char *zl, *p, *q, *entry;
+    unsigned char *zl, *p;
+    unsigned char *entry;

     unsigned int elen;
     long long value;
     sds s;
     unsigned int elen;
     long long value;
     sds s;


@@ -560,6 +639,83 @@ int main(int argc, char **argv) {
     printf("Pop tail: %s (length %ld)\n", s, sdslen(s));
     ziplistRepr(zl);
 
     printf("Pop tail: %s (length %ld)\n", s, sdslen(s));
     ziplistRepr(zl);
 

+    printf("Get element at index 3:\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, 3);
+        if (!ziplistGet(p, &entry, &elen, &value)) {
+            printf("ERROR: Could not access index 3\n");
+            return 1;
+        }
+        if (entry) {
+            fwrite(entry,elen,1,stdout);
+            printf("\n");
+        } else {
+            printf("%lld\n", value);
+        }
+        printf("\n");
+    }
+
+    printf("Get element at index 4 (out of range):\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, 4);
+        if (p == NULL) {
+            printf("No entry\n");
+        } else {
+            printf("ERROR: Out of range index should return NULL, returned offset: %ld\n", p-zl);
+            return 1;
+        }
+        printf("\n");
+    }
+
+    printf("Get element at index -1 (last element):\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, -1);
+        if (!ziplistGet(p, &entry, &elen, &value)) {
+            printf("ERROR: Could not access index -1\n");
+            return 1;
+        }
+        if (entry) {
+            fwrite(entry,elen,1,stdout);
+            printf("\n");
+        } else {
+            printf("%lld\n", value);
+        }
+        printf("\n");
+    }
+
+    printf("Get element at index -4 (first element):\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, -4);
+        if (!ziplistGet(p, &entry, &elen, &value)) {
+            printf("ERROR: Could not access index -4\n");
+            return 1;
+        }
+        if (entry) {
+            fwrite(entry,elen,1,stdout);
+            printf("\n");
+        } else {
+            printf("%lld\n", value);
+        }
+        printf("\n");
+    }
+
+    printf("Get element at index -5 (reverse out of range):\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, -5);
+        if (p == NULL) {
+            printf("No entry\n");
+        } else {
+            printf("ERROR: Out of range index should return NULL, returned offset: %ld\n", p-zl);
+            return 1;
+        }
+        printf("\n");
+    }
+

     printf("Iterate list from 0 to end:\n");
     {
         zl = createList();
     printf("Iterate list from 0 to end:\n");
     {
         zl = createList();


@@ -571,7 +727,7 @@ int main(int argc, char **argv) {
             } else {
                 printf("%lld", value);
             }
             } else {
                 printf("%lld", value);
             }

-            p = ziplistNext(p);
+            p = ziplistNext(zl,p);

             printf("\n");
         }
         printf("\n");
             printf("\n");
         }
         printf("\n");


@@ -588,7 +744,7 @@ int main(int argc, char **argv) {
             } else {
                 printf("%lld", value);
             }
             } else {
                 printf("%lld", value);
             }

-            p = ziplistNext(p);
+            p = ziplistNext(zl,p);

             printf("\n");
         }
         printf("\n");
             printf("\n");
         }
         printf("\n");


@@ -605,7 +761,7 @@ int main(int argc, char **argv) {
             } else {
                 printf("%lld", value);
             }
             } else {
                 printf("%lld", value);
             }

-            p = ziplistNext(p);
+            p = ziplistNext(zl,p);

             printf("\n");
         }
         printf("\n");
             printf("\n");
         }
         printf("\n");


@@ -623,6 +779,41 @@ int main(int argc, char **argv) {
         printf("\n");
     }
 
         printf("\n");
     }
 

+    printf("Iterate from back to front:\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, -1);
+        while (ziplistGet(p, &entry, &elen, &value)) {
+            printf("Entry: ");
+            if (entry) {
+                fwrite(entry,elen,1,stdout);
+            } else {
+                printf("%lld", value);
+            }
+            p = ziplistPrev(zl,p);
+            printf("\n");
+        }
+        printf("\n");
+    }
+
+    printf("Iterate from back to front, deleting all items:\n");
+    {
+        zl = createList();
+        p = ziplistIndex(zl, -1);
+        while (ziplistGet(p, &entry, &elen, &value)) {
+            printf("Entry: ");
+            if (entry) {
+                fwrite(entry,elen,1,stdout);
+            } else {
+                printf("%lld", value);
+            }
+            zl = ziplistDelete(zl,&p);
+            p = ziplistPrev(zl,p);
+            printf("\n");
+        }
+        printf("\n");
+    }
+

     printf("Delete inclusive range 0,0:\n");
     {
         zl = createList();
     printf("Delete inclusive range 0,0:\n");
     {
         zl = createList();


@@ -661,19 +852,19 @@ int main(int argc, char **argv) {
     printf("Delete foo while iterating:\n");
     {
         zl = createList();
     printf("Delete foo while iterating:\n");
     {
         zl = createList();

-        p = ziplistIndex(zl, 0);
-        while (ziplistGet(p, &entry, &elen, &value)) {
-            if (entry && strncmp("foo", entry, elen) == 0) {
+        p = ziplistIndex(zl,0);
+        while (ziplistGet(p,&entry,&elen,&value)) {
+            if (entry && strncmp("foo",(char*)entry,elen) == 0) {

                 printf("Delete foo\n");
                 printf("Delete foo\n");

-                zl = ziplistDelete(zl, &p);
+                zl = ziplistDelete(zl,&p);

             } else {
                 printf("Entry: ");
                 if (entry) {
                     fwrite(entry,elen,1,stdout);
                 } else {
             } else {
                 printf("Entry: ");
                 if (entry) {
                     fwrite(entry,elen,1,stdout);
                 } else {

-                    printf("%lld", value);
+                    printf("%lld",value);

                 }
                 }

-                p = ziplistNext(p);
+                p = ziplistNext(zl,p);

                 printf("\n");
             }
         }
                 printf("\n");
             }
         }


@@ -681,27 +872,48 @@ int main(int argc, char **argv) {
         ziplistRepr(zl);
     }
 
         ziplistRepr(zl);
     }
 

+    printf("Create long list and check indices:\n");
+    {
+        zl = ziplistNew();
+        char buf[32];
+        int i,len;
+        for (i = 0; i < 1000; i++) {
+            len = sprintf(buf,"%d",i);
+            zl = ziplistPush(zl,(unsigned char*)buf,len,ZIPLIST_TAIL);
+        }
+        for (i = 0; i < 1000; i++) {
+            p = ziplistIndex(zl,i);
+            assert(ziplistGet(p,NULL,NULL,&value));
+            assert(i == value);
+
+            p = ziplistIndex(zl,-i-1);
+            assert(ziplistGet(p,NULL,NULL,&value));
+            assert(999-i == value);
+        }
+        printf("SUCCESS\n\n");
+    }
+

     printf("Compare strings with ziplist entries:\n");
     {
         zl = createList();
     printf("Compare strings with ziplist entries:\n");
     {
         zl = createList();

-        p = ziplistIndex(zl, 0);
-        if (!ziplistCompare(p,"hello",5)) {
+        p = ziplistIndex(zl,0);
+        if (!ziplistCompare(p,(unsigned char*)"hello",5)) {

             printf("ERROR: not \"hello\"\n");
             printf("ERROR: not \"hello\"\n");

-            return;
+            return 1;

         }
         }

-        if (ziplistCompare(p,"hella",5)) {
+        if (ziplistCompare(p,(unsigned char*)"hella",5)) {

             printf("ERROR: \"hella\"\n");
             printf("ERROR: \"hella\"\n");

-            return;
+            return 1;

         }
 
         }
 

-        p = ziplistIndex(zl, 3);
-        if (!ziplistCompare(p,"1024",4)) {
+        p = ziplistIndex(zl,3);
+        if (!ziplistCompare(p,(unsigned char*)"1024",4)) {

             printf("ERROR: not \"1024\"\n");
             printf("ERROR: not \"1024\"\n");

-            return;
+            return 1;

         }
         }

-        if (ziplistCompare(p,"1025",4)) {
+        if (ziplistCompare(p,(unsigned char*)"1025",4)) {

             printf("ERROR: \"1025\"\n");
             printf("ERROR: \"1025\"\n");

-            return;
+            return 1;

         }
         printf("SUCCESS\n");
     }
         }
         printf("SUCCESS\n");
     }