From bb3475e8eb379ee18f3d8f37caa8040b852a6213 Mon Sep 17 00:00:00 2001 From: "Anna (navi) Figueiredo Gomes" Date: Sat, 23 Mar 2024 01:21:46 +0100 Subject: all: rename redis -> redict symbols and comments Signed-off-by: Anna (navi) Figueiredo Gomes --- read.c | 306 ++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 153 insertions(+), 153 deletions(-) (limited to 'read.c') 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; } -- cgit v1.2.3