all: rename redis -> redict symbols and commentsmaster

Signed-off-by: Anna (navi) Figueiredo Gomes <navi@vlhl.dev>

1 files changed, 153 insertions, 153 deletions

diff --git a/read.c b/read.c
index 55060b4..7b50ff2 100644
--- a/read.c
+++ b/read.c
@@ -30,9 +30,9 @@
 #include "win32.h"
 
 /* Initial size of our nested reply stack and how much we grow it when needd */
-#define REDIS_READER_STACK_SIZE 9
+#define REDICT_READER_STACK_SIZE 9
 
-static void __redisReaderSetError(redisReader *r, int type, const char *str) {
+static void __redictReaderSetError(redictReader *r, int type, const char *str) {
     size_t len;
 
     if (r->reply != NULL && r->fn && r->fn->freeObject) {
@@ -80,20 +80,20 @@ static size_t chrtos(char *buf, size_t size, char byte) {
     return len;
 }
 
-static void __redisReaderSetErrorProtocolByte(redisReader *r, char byte) {
+static void __redictReaderSetErrorProtocolByte(redictReader *r, char byte) {
     char cbuf[8], sbuf[128];
 
     chrtos(cbuf,sizeof(cbuf),byte);
     snprintf(sbuf,sizeof(sbuf),
         "Protocol error, got %s as reply type byte", cbuf);
-    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,sbuf);
+    __redictReaderSetError(r,REDICT_ERR_PROTOCOL,sbuf);
 }
 
-static void __redisReaderSetErrorOOM(redisReader *r) {
-    __redisReaderSetError(r,REDIS_ERR_OOM,"Out of memory");
+static void __redictReaderSetErrorOOM(redictReader *r) {
+    __redictReaderSetError(r,REDICT_ERR_OOM,"Out of memory");
 }
 
-static char *readBytes(redisReader *r, unsigned int bytes) {
+static char *readBytes(redictReader *r, unsigned int bytes) {
     char *p;
     if (r->len-r->pos >= bytes) {
         p = r->buf+r->pos;
@@ -129,8 +129,8 @@ static char *seekNewline(char *s, size_t len) {
     return ret;
 }
 
-/* Convert a string into a long long. Returns REDIS_OK if the string could be
- * parsed into a (non-overflowing) long long, REDIS_ERR otherwise. The value
+/* Convert a string into a long long. Returns REDICT_OK if the string could be
+ * parsed into a (non-overflowing) long long, REDICT_ERR otherwise. The value
  * will be set to the parsed value when appropriate.
  *
  * Note that this function demands that the string strictly represents
@@ -148,12 +148,12 @@ static int string2ll(const char *s, size_t slen, long long *value) {
     unsigned long long v;
 
     if (plen == slen)
-        return REDIS_ERR;
+        return REDICT_ERR;
 
     /* Special case: first and only digit is 0. */
     if (slen == 1 && p[0] == '0') {
         if (value != NULL) *value = 0;
-        return REDIS_OK;
+        return REDICT_OK;
     }
 
     if (p[0] == '-') {
@@ -162,7 +162,7 @@ static int string2ll(const char *s, size_t slen, long long *value) {
 
         /* Abort on only a negative sign. */
         if (plen == slen)
-            return REDIS_ERR;
+            return REDICT_ERR;
     }
 
     /* First digit should be 1-9, otherwise the string should just be 0. */
@@ -171,18 +171,18 @@ static int string2ll(const char *s, size_t slen, long long *value) {
         p++; plen++;
     } else if (p[0] == '0' && slen == 1) {
         *value = 0;
-        return REDIS_OK;
+        return REDICT_OK;
     } else {
-        return REDIS_ERR;
+        return REDICT_ERR;
     }
 
     while (plen < slen && p[0] >= '0' && p[0] <= '9') {
         if (v > (ULLONG_MAX / 10)) /* Overflow. */
-            return REDIS_ERR;
+            return REDICT_ERR;
         v *= 10;
 
         if (v > (ULLONG_MAX - (p[0]-'0'))) /* Overflow. */
-            return REDIS_ERR;
+            return REDICT_ERR;
         v += p[0]-'0';
 
         p++; plen++;
@@ -190,21 +190,21 @@ static int string2ll(const char *s, size_t slen, long long *value) {
 
     /* Return if not all bytes were used. */
     if (plen < slen)
-        return REDIS_ERR;
+        return REDICT_ERR;
 
     if (negative) {
         if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */
-            return REDIS_ERR;
+            return REDICT_ERR;
         if (value != NULL) *value = -v;
     } else {
         if (v > LLONG_MAX) /* Overflow. */
-            return REDIS_ERR;
+            return REDICT_ERR;
         if (value != NULL) *value = v;
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-static char *readLine(redisReader *r, int *_len) {
+static char *readLine(redictReader *r, int *_len) {
     char *p, *s;
     int len;
 
@@ -219,8 +219,8 @@ static char *readLine(redisReader *r, int *_len) {
     return NULL;
 }
 
-static void moveToNextTask(redisReader *r) {
-    redisReadTask *cur, *prv;
+static void moveToNextTask(redictReader *r) {
+    redictReadTask *cur, *prv;
     while (r->ridx >= 0) {
         /* Return a.s.a.p. when the stack is now empty. */
         if (r->ridx == 0) {
@@ -230,11 +230,11 @@ static void moveToNextTask(redisReader *r) {
 
         cur = r->task[r->ridx];
         prv = r->task[r->ridx-1];
-        assert(prv->type == REDIS_REPLY_ARRAY ||
-               prv->type == REDIS_REPLY_MAP ||
-               prv->type == REDIS_REPLY_ATTR ||
-               prv->type == REDIS_REPLY_SET ||
-               prv->type == REDIS_REPLY_PUSH);
+        assert(prv->type == REDICT_REPLY_ARRAY ||
+               prv->type == REDICT_REPLY_MAP ||
+               prv->type == REDICT_REPLY_ATTR ||
+               prv->type == REDICT_REPLY_SET ||
+               prv->type == REDICT_REPLY_PUSH);
         if (cur->idx == prv->elements-1) {
             r->ridx--;
         } else {
@@ -248,35 +248,35 @@ static void moveToNextTask(redisReader *r) {
     }
 }
 
-static int processLineItem(redisReader *r) {
-    redisReadTask *cur = r->task[r->ridx];
+static int processLineItem(redictReader *r) {
+    redictReadTask *cur = r->task[r->ridx];
     void *obj;
     char *p;
     int len;
 
     if ((p = readLine(r,&len)) != NULL) {
-        if (cur->type == REDIS_REPLY_INTEGER) {
+        if (cur->type == REDICT_REPLY_INTEGER) {
             long long v;
 
-            if (string2ll(p, len, &v) == REDIS_ERR) {
-                __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+            if (string2ll(p, len, &v) == REDICT_ERR) {
+                __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                         "Bad integer value");
-                return REDIS_ERR;
+                return REDICT_ERR;
             }
 
             if (r->fn && r->fn->createInteger) {
                 obj = r->fn->createInteger(cur,v);
             } else {
-                obj = (void*)REDIS_REPLY_INTEGER;
+                obj = (void*)REDICT_REPLY_INTEGER;
             }
-        } else if (cur->type == REDIS_REPLY_DOUBLE) {
+        } else if (cur->type == REDICT_REPLY_DOUBLE) {
             char buf[326], *eptr;
             double d;
 
             if ((size_t)len >= sizeof(buf)) {
-                __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                         "Double value is too large");
-                return REDIS_ERR;
+                return REDICT_ERR;
             }
 
             memcpy(buf,p,len);
@@ -296,65 +296,65 @@ static int processLineItem(redisReader *r) {
                  * etc. We explicity handle our two allowed infinite cases and NaN
                  * above, so strtod() should only result in finite values. */
                 if (buf[0] == '\0' || eptr != &buf[len] || !isfinite(d)) {
-                    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                    __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                             "Bad double value");
-                    return REDIS_ERR;
+                    return REDICT_ERR;
                 }
             }
 
             if (r->fn && r->fn->createDouble) {
                 obj = r->fn->createDouble(cur,d,buf,len);
             } else {
-                obj = (void*)REDIS_REPLY_DOUBLE;
+                obj = (void*)REDICT_REPLY_DOUBLE;
             }
-        } else if (cur->type == REDIS_REPLY_NIL) {
+        } else if (cur->type == REDICT_REPLY_NIL) {
             if (len != 0) {
-                __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                         "Bad nil value");
-                return REDIS_ERR;
+                return REDICT_ERR;
             }
 
             if (r->fn && r->fn->createNil)
                 obj = r->fn->createNil(cur);
             else
-                obj = (void*)REDIS_REPLY_NIL;
-        } else if (cur->type == REDIS_REPLY_BOOL) {
+                obj = (void*)REDICT_REPLY_NIL;
+        } else if (cur->type == REDICT_REPLY_BOOL) {
             int bval;
 
             if (len != 1 || !strchr("tTfF", p[0])) {
-                __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                         "Bad bool value");
-                return REDIS_ERR;
+                return REDICT_ERR;
             }
 
             bval = p[0] == 't' || p[0] == 'T';
             if (r->fn && r->fn->createBool)
                 obj = r->fn->createBool(cur,bval);
             else
-                obj = (void*)REDIS_REPLY_BOOL;
-        } else if (cur->type == REDIS_REPLY_BIGNUM) {
+                obj = (void*)REDICT_REPLY_BOOL;
+        } else if (cur->type == REDICT_REPLY_BIGNUM) {
             /* Ensure all characters are decimal digits (with possible leading
              * minus sign). */
             for (int i = 0; i < len; i++) {
                 /* XXX Consider: Allow leading '+'? Error on leading '0's? */
                 if (i == 0 && p[0] == '-') continue;
                 if (p[i] < '0' || p[i] > '9') {
-                    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                    __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                             "Bad bignum value");
-                    return REDIS_ERR;
+                    return REDICT_ERR;
                 }
             }
             if (r->fn && r->fn->createString)
                 obj = r->fn->createString(cur,p,len);
             else
-                obj = (void*)REDIS_REPLY_BIGNUM;
+                obj = (void*)REDICT_REPLY_BIGNUM;
         } else {
             /* Type will be error or status. */
             for (int i = 0; i < len; i++) {
                 if (p[i] == '\r' || p[i] == '\n') {
-                    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                    __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                             "Bad simple string value");
-                    return REDIS_ERR;
+                    return REDICT_ERR;
                 }
             }
             if (r->fn && r->fn->createString)
@@ -364,21 +364,21 @@ static int processLineItem(redisReader *r) {
         }
 
         if (obj == NULL) {
-            __redisReaderSetErrorOOM(r);
-            return REDIS_ERR;
+            __redictReaderSetErrorOOM(r);
+            return REDICT_ERR;
         }
 
         /* Set reply if this is the root object. */
         if (r->ridx == 0) r->reply = obj;
         moveToNextTask(r);
-        return REDIS_OK;
+        return REDICT_OK;
     }
 
-    return REDIS_ERR;
+    return REDICT_ERR;
 }
 
-static int processBulkItem(redisReader *r) {
-    redisReadTask *cur = r->task[r->ridx];
+static int processBulkItem(redictReader *r) {
+    redictReadTask *cur = r->task[r->ridx];
     void *obj = NULL;
     char *p, *s;
     long long len;
@@ -391,16 +391,16 @@ static int processBulkItem(redisReader *r) {
         p = r->buf+r->pos;
         bytelen = s-(r->buf+r->pos)+2; /* include \r\n */
 
-        if (string2ll(p, bytelen - 2, &len) == REDIS_ERR) {
-            __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+        if (string2ll(p, bytelen - 2, &len) == REDICT_ERR) {
+            __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                     "Bad bulk string length");
-            return REDIS_ERR;
+            return REDICT_ERR;
         }
 
         if (len < -1 || (LLONG_MAX > SIZE_MAX && len > (long long)SIZE_MAX)) {
-            __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+            __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                     "Bulk string length out of range");
-            return REDIS_ERR;
+            return REDICT_ERR;
         }
 
         if (len == -1) {
@@ -408,19 +408,19 @@ static int processBulkItem(redisReader *r) {
             if (r->fn && r->fn->createNil)
                 obj = r->fn->createNil(cur);
             else
-                obj = (void*)REDIS_REPLY_NIL;
+                obj = (void*)REDICT_REPLY_NIL;
             success = 1;
         } else {
             /* Only continue when the buffer contains the entire bulk item. */
             bytelen += len+2; /* include \r\n */
             if (r->pos+bytelen <= r->len) {
-                if ((cur->type == REDIS_REPLY_VERB && len < 4) ||
-                    (cur->type == REDIS_REPLY_VERB && s[5] != ':'))
+                if ((cur->type == REDICT_REPLY_VERB && len < 4) ||
+                    (cur->type == REDICT_REPLY_VERB && s[5] != ':'))
                 {
-                    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+                    __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                             "Verbatim string 4 bytes of content type are "
                             "missing or incorrectly encoded.");
-                    return REDIS_ERR;
+                    return REDICT_ERR;
                 }
                 if (r->fn && r->fn->createString)
                     obj = r->fn->createString(cur,s+2,len);
@@ -433,8 +433,8 @@ static int processBulkItem(redisReader *r) {
         /* Proceed when obj was created. */
         if (success) {
             if (obj == NULL) {
-                __redisReaderSetErrorOOM(r);
-                return REDIS_ERR;
+                __redictReaderSetErrorOOM(r);
+                return REDICT_ERR;
             }
 
             r->pos += bytelen;
@@ -442,19 +442,19 @@ static int processBulkItem(redisReader *r) {
             /* Set reply if this is the root object. */
             if (r->ridx == 0) r->reply = obj;
             moveToNextTask(r);
-            return REDIS_OK;
+            return REDICT_OK;
         }
     }
 
-    return REDIS_ERR;
+    return REDICT_ERR;
 }
 
-static int redisReaderGrow(redisReader *r) {
-    redisReadTask **aux;
+static int redictReaderGrow(redictReader *r) {
+    redictReadTask **aux;
     int newlen;
 
     /* Grow our stack size */
-    newlen = r->tasks + REDIS_READER_STACK_SIZE;
+    newlen = r->tasks + REDICT_READER_STACK_SIZE;
     aux = hi_realloc(r->task, sizeof(*r->task) * newlen);
     if (aux == NULL)
         goto oom;
@@ -468,30 +468,30 @@ static int redisReaderGrow(redisReader *r) {
             goto oom;
     }
 
-    return REDIS_OK;
+    return REDICT_OK;
 oom:
-    __redisReaderSetErrorOOM(r);
-    return REDIS_ERR;
+    __redictReaderSetErrorOOM(r);
+    return REDICT_ERR;
 }
 
 /* Process the array, map and set types. */
-static int processAggregateItem(redisReader *r) {
-    redisReadTask *cur = r->task[r->ridx];
+static int processAggregateItem(redictReader *r) {
+    redictReadTask *cur = r->task[r->ridx];
     void *obj;
     char *p;
     long long elements;
     int root = 0, len;
 
     if (r->ridx == r->tasks - 1) {
-        if (redisReaderGrow(r) == REDIS_ERR)
-            return REDIS_ERR;
+        if (redictReaderGrow(r) == REDICT_ERR)
+            return REDICT_ERR;
     }
 
     if ((p = readLine(r,&len)) != NULL) {
-        if (string2ll(p, len, &elements) == REDIS_ERR) {
-            __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+        if (string2ll(p, len, &elements) == REDICT_ERR) {
+            __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                     "Bad multi-bulk length");
-            return REDIS_ERR;
+            return REDICT_ERR;
         }
 
         root = (r->ridx == 0);
@@ -499,25 +499,25 @@ static int processAggregateItem(redisReader *r) {
         if (elements < -1 || (LLONG_MAX > SIZE_MAX && elements > SIZE_MAX) ||
             (r->maxelements > 0 && elements > r->maxelements))
         {
-            __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
+            __redictReaderSetError(r,REDICT_ERR_PROTOCOL,
                     "Multi-bulk length out of range");
-            return REDIS_ERR;
+            return REDICT_ERR;
         }
 
         if (elements == -1) {
             if (r->fn && r->fn->createNil)
                 obj = r->fn->createNil(cur);
             else
-                obj = (void*)REDIS_REPLY_NIL;
+                obj = (void*)REDICT_REPLY_NIL;
 
             if (obj == NULL) {
-                __redisReaderSetErrorOOM(r);
-                return REDIS_ERR;
+                __redictReaderSetErrorOOM(r);
+                return REDICT_ERR;
             }
 
             moveToNextTask(r);
         } else {
-            if (cur->type == REDIS_REPLY_MAP || cur->type == REDIS_REPLY_ATTR) elements *= 2;
+            if (cur->type == REDICT_REPLY_MAP || cur->type == REDICT_REPLY_ATTR) elements *= 2;
 
             if (r->fn && r->fn->createArray)
                 obj = r->fn->createArray(cur,elements);
@@ -525,8 +525,8 @@ static int processAggregateItem(redisReader *r) {
                 obj = (void*)(uintptr_t)cur->type;
 
             if (obj == NULL) {
-                __redisReaderSetErrorOOM(r);
-                return REDIS_ERR;
+                __redictReaderSetErrorOOM(r);
+                return REDICT_ERR;
             }
 
             /* Modify task stack when there are more than 0 elements. */
@@ -547,14 +547,14 @@ static int processAggregateItem(redisReader *r) {
 
         /* Set reply if this is the root object. */
         if (root) r->reply = obj;
-        return REDIS_OK;
+        return REDICT_OK;
     }
 
-    return REDIS_ERR;
+    return REDICT_ERR;
 }
 
-static int processItem(redisReader *r) {
-    redisReadTask *cur = r->task[r->ridx];
+static int processItem(redictReader *r) {
+    redictReadTask *cur = r->task[r->ridx];
     char *p;
 
     /* check if we need to read type */
@@ -562,86 +562,86 @@ static int processItem(redisReader *r) {
         if ((p = readBytes(r,1)) != NULL) {
             switch (p[0]) {
             case '-':
-                cur->type = REDIS_REPLY_ERROR;
+                cur->type = REDICT_REPLY_ERROR;
                 break;
             case '+':
-                cur->type = REDIS_REPLY_STATUS;
+                cur->type = REDICT_REPLY_STATUS;
                 break;
             case ':':
-                cur->type = REDIS_REPLY_INTEGER;
+                cur->type = REDICT_REPLY_INTEGER;
                 break;
             case ',':
-                cur->type = REDIS_REPLY_DOUBLE;
+                cur->type = REDICT_REPLY_DOUBLE;
                 break;
             case '_':
-                cur->type = REDIS_REPLY_NIL;
+                cur->type = REDICT_REPLY_NIL;
                 break;
             case '$':
-                cur->type = REDIS_REPLY_STRING;
+                cur->type = REDICT_REPLY_STRING;
                 break;
             case '*':
-                cur->type = REDIS_REPLY_ARRAY;
+                cur->type = REDICT_REPLY_ARRAY;
                 break;
             case '%':
-                cur->type = REDIS_REPLY_MAP;
+                cur->type = REDICT_REPLY_MAP;
                 break;
             case '|':
-                cur->type = REDIS_REPLY_ATTR;
+                cur->type = REDICT_REPLY_ATTR;
                 break;
             case '~':
-                cur->type = REDIS_REPLY_SET;
+                cur->type = REDICT_REPLY_SET;
                 break;
             case '#':
-                cur->type = REDIS_REPLY_BOOL;
+                cur->type = REDICT_REPLY_BOOL;
                 break;
             case '=':
-                cur->type = REDIS_REPLY_VERB;
+                cur->type = REDICT_REPLY_VERB;
                 break;
             case '>':
-                cur->type = REDIS_REPLY_PUSH;
+                cur->type = REDICT_REPLY_PUSH;
                 break;
             case '(':
-                cur->type = REDIS_REPLY_BIGNUM;
+                cur->type = REDICT_REPLY_BIGNUM;
                 break;
             default:
-                __redisReaderSetErrorProtocolByte(r,*p);
-                return REDIS_ERR;
+                __redictReaderSetErrorProtocolByte(r,*p);
+                return REDICT_ERR;
             }
         } else {
             /* could not consume 1 byte */
-            return REDIS_ERR;
+            return REDICT_ERR;
         }
     }
 
     /* process typed item */
     switch(cur->type) {
-    case REDIS_REPLY_ERROR:
-    case REDIS_REPLY_STATUS:
-    case REDIS_REPLY_INTEGER:
-    case REDIS_REPLY_DOUBLE:
-    case REDIS_REPLY_NIL:
-    case REDIS_REPLY_BOOL:
-    case REDIS_REPLY_BIGNUM:
+    case REDICT_REPLY_ERROR:
+    case REDICT_REPLY_STATUS:
+    case REDICT_REPLY_INTEGER:
+    case REDICT_REPLY_DOUBLE:
+    case REDICT_REPLY_NIL:
+    case REDICT_REPLY_BOOL:
+    case REDICT_REPLY_BIGNUM:
         return processLineItem(r);
-    case REDIS_REPLY_STRING:
-    case REDIS_REPLY_VERB:
+    case REDICT_REPLY_STRING:
+    case REDICT_REPLY_VERB:
         return processBulkItem(r);
-    case REDIS_REPLY_ARRAY:
-    case REDIS_REPLY_MAP:
-    case REDIS_REPLY_ATTR:
-    case REDIS_REPLY_SET:
-    case REDIS_REPLY_PUSH:
+    case REDICT_REPLY_ARRAY:
+    case REDICT_REPLY_MAP:
+    case REDICT_REPLY_ATTR:
+    case REDICT_REPLY_SET:
+    case REDICT_REPLY_PUSH:
         return processAggregateItem(r);
     default:
         assert(NULL);
-        return REDIS_ERR; /* Avoid warning. */
+        return REDICT_ERR; /* Avoid warning. */
     }
 }
 
-redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn) {
-    redisReader *r;
+redictReader *redictReaderCreateWithFunctions(redictReplyObjectFunctions *fn) {
+    redictReader *r;
 
-    r = hi_calloc(1,sizeof(redisReader));
+    r = hi_calloc(1,sizeof(redictReader));
     if (r == NULL)
         return NULL;
 
@@ -649,28 +649,28 @@ redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn) {
     if (r->buf == NULL)
         goto oom;
 
-    r->task = hi_calloc(REDIS_READER_STACK_SIZE, sizeof(*r->task));
+    r->task = hi_calloc(REDICT_READER_STACK_SIZE, sizeof(*r->task));
     if (r->task == NULL)
         goto oom;
 
-    for (; r->tasks < REDIS_READER_STACK_SIZE; r->tasks++) {
+    for (; r->tasks < REDICT_READER_STACK_SIZE; r->tasks++) {
         r->task[r->tasks] = hi_calloc(1, sizeof(**r->task));
         if (r->task[r->tasks] == NULL)
             goto oom;
     }
 
     r->fn = fn;
-    r->maxbuf = REDIS_READER_MAX_BUF;
-    r->maxelements = REDIS_READER_MAX_ARRAY_ELEMENTS;
+    r->maxbuf = REDICT_READER_MAX_BUF;
+    r->maxelements = REDICT_READER_MAX_ARRAY_ELEMENTS;
     r->ridx = -1;
 
     return r;
 oom:
-    redisReaderFree(r);
+    redictReaderFree(r);
     return NULL;
 }
 
-void redisReaderFree(redisReader *r) {
+void redictReaderFree(redictReader *r) {
     if (r == NULL)
         return;
 
@@ -690,12 +690,12 @@ void redisReaderFree(redisReader *r) {
     hi_free(r);
 }
 
-int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
+int redictReaderFeed(redictReader *r, const char *buf, size_t len) {
     sds newbuf;
 
     /* Return early when this reader is in an erroneous state. */
     if (r->err)
-        return REDIS_ERR;
+        return REDICT_ERR;
 
     /* Copy the provided buffer. */
     if (buf != NULL && len >= 1) {
@@ -715,24 +715,24 @@ int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
         r->len = sdslen(r->buf);
     }
 
-    return REDIS_OK;
+    return REDICT_OK;
 oom:
-    __redisReaderSetErrorOOM(r);
-    return REDIS_ERR;
+    __redictReaderSetErrorOOM(r);
+    return REDICT_ERR;
 }
 
-int redisReaderGetReply(redisReader *r, void **reply) {
+int redictReaderGetReply(redictReader *r, void **reply) {
     /* Default target pointer to NULL. */
     if (reply != NULL)
         *reply = NULL;
 
     /* Return early when this reader is in an erroneous state. */
     if (r->err)
-        return REDIS_ERR;
+        return REDICT_ERR;
 
     /* When the buffer is empty, there will never be a reply. */
     if (r->len == 0)
-        return REDIS_OK;
+        return REDICT_OK;
 
     /* Set first item to process when the stack is empty. */
     if (r->ridx == -1) {
@@ -747,17 +747,17 @@ int redisReaderGetReply(redisReader *r, void **reply) {
 
     /* Process items in reply. */
     while (r->ridx >= 0)
-        if (processItem(r) != REDIS_OK)
+        if (processItem(r) != REDICT_OK)
             break;
 
     /* Return ASAP when an error occurred. */
     if (r->err)
-        return REDIS_ERR;
+        return REDICT_ERR;
 
     /* Discard part of the buffer when we've consumed at least 1k, to avoid
      * doing unnecessary calls to memmove() in sds.c. */
     if (r->pos >= 1024) {
-        if (sdsrange(r->buf,r->pos,-1) < 0) return REDIS_ERR;
+        if (sdsrange(r->buf,r->pos,-1) < 0) return REDICT_ERR;
         r->pos = 0;
         r->len = sdslen(r->buf);
     }
@@ -771,5 +771,5 @@ int redisReaderGetReply(redisReader *r, void **reply) {
         }
         r->reply = NULL;
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }