From b36603b0bdb010fae50343454ddebd54929a97f2 Mon Sep 17 00:00:00 2001 From: Johannes Löthberg Date: Tue, 20 Jan 2015 13:16:51 +0100 Subject: Rename sds.{h,c} to yasl.{h,c} --- Makefile | 4 +- src/sds.c | 797 ------------------------------------------------------------- src/sds.h | 131 ---------- src/yasl.c | 797 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/yasl.h | 131 ++++++++++ 5 files changed, 930 insertions(+), 930 deletions(-) delete mode 100644 src/sds.c delete mode 100644 src/sds.h create mode 100644 src/yasl.c create mode 100644 src/yasl.h diff --git a/Makefile b/Makefile index ebaf366..f7bc480 100644 --- a/Makefile +++ b/Makefile @@ -2,8 +2,8 @@ CFLAGS += -O2 -std=c99 -ggdb -fPIE -pie -fstack-protector-all -Wl,-z,relro -Wl,- CFLAGS += -Weverything -Wno-disabled-macro-expansion -Wno-vla -Wno-cast-align CC = clang -SOURCES = test/twbctf.c src/sds.c -HEADERS = test/twbctf.h src/sds.h +SOURCES = test/twbctf.c src/yasl.c +HEADERS = test/twbctf.h src/yasl.h MANPAGES = docs/sds.3 docs/sdsnew.3 docs/sdsfree.3 all: sds-test $(MANPAGES) diff --git a/src/sds.c b/src/sds.c deleted file mode 100644 index 674fc48..0000000 --- a/src/sds.c +++ /dev/null @@ -1,797 +0,0 @@ -/* SDS (Simple Dynamic Strings), A C dynamic strings library. - * - * Copyright (c) 2006-2014, Salvatore Sanfilippo - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include -#include -#include -#include -#include -#include - -#include "sds.h" - - -/// Initialization - -/* Create a new sds string with the content specified by the 'init' pointer - * and 'initlen'. - * If NULL is used for 'init' the string is initialized with zero bytes. - * - * The string is always null-termined (all the sds strings are, always) so - * even if you create an sds string with: - * - * mystring = sdsnew("abc", 3"); - * - * You can print the string with printf() as there is an implicit \0 at the - * end of the string. However the string is binary safe and can contain - * \0 characters in the middle, as the length is stored in the sds header. */ -sds sdsnew(const void *init, size_t initlen) { - struct sdshdr *sh; - - if (init) { - sh = malloc(sizeof(struct sdshdr) + initlen + 1); - } else { - sh = calloc(sizeof(struct sdshdr) + initlen + 1, 1); - } - if (sh == NULL) { return NULL; } - - sh->len = initlen; - sh->free = 0; - if (initlen && init) { - memcpy(sh->buf, init, initlen); - } - sh->buf[initlen] = '\0'; - return (char*)sh->buf; -} - -/* Duplicate an sds string. */ -sds sdsdup(const sds s) { - return sdsnew(s, sdslen(s)); -} - -/* Create an empty (zero length) sds string. Even in this case the string - * always has an implicit null term. */ -sds sdsempty(void) { - return sdsnew("", 0); -} - -/* Create an sds string from a long long value. It is much faster than: - * - * sdscatprintf(sdsempty(), "%lld\n", value); - */ -sds sdsfromlonglong(long long value) { - char buf[32], *p; - unsigned long long v; - - v = (unsigned long long)((value < 0) ? -value : value); - p = buf + 31; /* point to the last character */ - do { - *p-- = '0' + (v%10); - v /= 10; - } while(v); - if (value < 0) { *p-- = '-'; } - p++; - return sdsnew(p, (size_t)(32 - (p - buf))); -} - - -/// Querying - -/* Compare two sds strings s1 and s2 with memcmp(). - * - * Return value: - * - * 1 if s1 > s2. - * -1 if s1 < s2. - * 0 if s1 and s2 are exactly the same binary string. - * - * If two strings share exactly the same prefix, but one of the two has - * additional characters, the longer string is considered to be greater than - * the smaller one. */ -int sdscmp(const sds s1, const sds s2) { - size_t l1, l2, minlen; - int cmp; - - l1 = sdslen(s1); - l2 = sdslen(s2); - minlen = (l1 < l2) ? l1 : l2; - cmp = memcmp(s1, s2, minlen); - if (cmp == 0) { return (int)(l1 - l2); } - return cmp; -} - - -/// Modification - -/* Modify an sds string on-place to make it empty (zero length). - * However all the existing buffer is not discarded but set as free space - * so that next append operations will not require allocations up to the - * number of bytes previously available. */ -void sdsclear(sds s) { - struct sdshdr *sh = sdsheader(s); - sh->free += sh->len; - sh->len = 0; - sh->buf[0] = '\0'; -} - -/* Grow the sds to have the specified length. Bytes that were not part of - * the original length of the sds will be set to zero. - * - * if the specified length is smaller than the current length, no operation - * is performed. */ -sds sdsgrowzero(sds s, size_t len) { - struct sdshdr *sh = sdsheader(s); - size_t totlen, curlen = sh->len; - - if (len <= curlen) { return s; } - s = sdsMakeRoomFor(s, len - curlen); - if (s == NULL) { return NULL; } - - /* Make sure added region doesn't contain garbage */ - sh = sdsheader(s); - memset(s + curlen, 0, (len - curlen + 1)); /* also set trailing \0 byte */ - totlen = sh->len + sh->free; - sh->len = len; - sh->free = totlen - sh->len; - return s; -} - -/* Destructively modify the sds string 's' to hold the specified binary - * safe string pointed by 't' of length 'len' bytes. */ -sds sdscpylen(sds s, const char *t, size_t len) { - struct sdshdr *sh = sdsheader(s); - size_t totlen = sh->free + sh->len; - - if (totlen < len) { - s = sdsMakeRoomFor(s, len - sh->len); - if (s == NULL) { return NULL; } - sh = sdsheader(s); - totlen = sh->free + sh->len; - } - memcpy(s, t, len); - s[len] = '\0'; - sh->len = len; - sh->free = totlen - len; - return s; -} - -/* Like sdscpylen() but 't' must be a null-termined string so that the length - * of the string is obtained with strlen(). */ -sds sdscpy(sds s, const char *t) { - return sdscpylen(s, t, strlen(t)); -} - -/* Join an array of C strings using the specified separator (also a C string). - * Returns the result as an sds string. */ -sds sdsjoin(char **argv, int argc, char *sep, size_t seplen) { - sds join = sdsempty(); - - for (int j = 0; j < argc; j++) { - join = sdscat(join, argv[j]); - if (j != argc - 1) { join = sdscatlen(join, sep, seplen); } - } - return join; -} - -/* Like sdsjoin, but joins an array of SDS strings. */ -sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) { - sds join = sdsempty(); - - for (int j = 0; j < argc; j++) { - join = sdscatsds(join, argv[j]); - if (j != argc - 1) { join = sdscatlen(join, sep, seplen); } - } - return join; -} - -/* Modify the string substituting all the occurrences of the set of - * characters specified in the 'from' string to the corresponding character - * in the 'to' array. - * - * For instance: sdsmapchars(mystring, "ho", "01", 2) - * will have the effect of turning the string "hello" into "0ell1". - * - * The function returns the sds string pointer, that is always the same - * as the input pointer since no resize is needed. */ -sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { - for (size_t j = 0; j < sdslen(s); j++) { - for (size_t i = 0; i < setlen; i++) { - if (s[j] == from[i]) { - s[j] = to[i]; - break; - } - } - } - return s; -} - -/* Turn the string into a smaller (or equal) string containing only the - * substring specified by the 'start' and 'end' indexes. - * - * start and end can be negative, where -1 means the last character of the - * string, -2 the penultimate character, and so forth. - * - * The interval is inclusive, so the start and end characters will be part - * of the resulting string. - * - * The string is modified in-place. - * - * Example: - * - * s = sdsauto("Hello World"); - * sdsrange(s, 1, -1); => "ello World" - */ -void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end) { - struct sdshdr *sh = sdsheader(s); - size_t newlen, len = sdslen(s); - - if (len == 0) { return; } - if (start < 0) { - start = (ptrdiff_t)len + start; - if (start < 0) { start = 0; } - } - if (end < 0) { - end = (ptrdiff_t)len + end; - if (end < 0) { end = 0; } - } - newlen = (size_t)((start > end) ? 0 : (end - start) + 1); - if (newlen != 0) { - if ((size_t)start >= len) { - newlen = 0; - } else if ((size_t)end >= len) { - end = (ptrdiff_t)len - 1; - newlen = (size_t)((start > end) ? 0 : (end - start) + 1); - } - } else { - start = 0; - } - if (start && newlen) { memmove(sh->buf, sh->buf + start, newlen); } - sh->buf[newlen] = 0; - sh->free = sh->free + (sh->len - newlen); - sh->len = newlen; -} - -/* Apply tolower() to every character of the sds string 's'. */ -void sdstolower(sds s) { - for (size_t j = 0; j < sdslen(s); j++) { - s[j] = (char)tolower(s[j]); - } -} - -/* Apply toupper() to every character of the sds string 's'. */ -void sdstoupper(sds s) { - for (size_t j = 0; j < sdslen(s); j++) { - s[j] = (char)toupper(s[j]); - } -} - -/* Remove the part of the string from left and from right composed just of - * contiguous characters found in 'cset', that is a null terminted C string. - * - * After the call, the modified sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. - * - * Example: - * - * s = sdsauto("AA...AA.a.aa.aHelloWorld :::"); - * s = sdstrim(s, "A. :"); - * printf("%s\n", s); - * - * Output will be just "Hello World". - */ -void sdstrim(sds s, const char *cset) { - struct sdshdr *sh = sdsheader(s); - char *start, *end, *sp, *ep; - size_t len; - - sp = start = s; - ep = end = s + sdslen(s) - 1; - while(sp <= end && strchr(cset, *sp)) { sp++; } - while(ep > start && strchr(cset, *ep)) { ep--; } - len = (size_t)((sp > ep) ? 0 : ((ep - sp) + 1)); - if (sh->buf != sp) { memmove(sh->buf, sp, len); } - sh->buf[len] = '\0'; - sh->free = sh->free + (sh->len - len); - sh->len = len; -} - -/* Set the sds string length to the length as obtained with strlen(), so - * considering as content only up to the first null term character. - * - * This function is useful when the sds string is hacked manually in some - * way, like in the following example: - * - * s = sdsauto("foobar"); - * s[2] = '\0'; - * sdsupdatelen(s); - * printf("%d\n", sdslen(s)); - * - * The output will be "2", but if we comment out the call to sdsupdatelen() - * the output will be "6" as the string was modified but the logical length - * remains 6 bytes. */ -void sdsupdatelen(sds s) { - struct sdshdr *sh = sdsheader(s); - size_t reallen = strlen(s); - sh->free += (sh->len - reallen); - sh->len = reallen; -} - -/* Split a line into arguments, where every argument can be in the - * following programming-language REPL-alike form: - * - * foo bar "newline are supported\n" and "\xff\x00otherstuff" - * - * The number of arguments is stored into *argc, and an array - * of sds is returned. - * - * The caller should free the resulting array of sds strings with - * sdsfreesplitres(). - * - * Note that sdscatrepr() is able to convert back a string into - * a quoted string in the same format sdssplitargs() is able to parse. - * - * The function returns the allocated tokens on success, even when the - * input string is empty, or NULL if the input contains unbalanced - * quotes or closed quotes followed by non space characters - * as in: "foo"bar or "foo' - */ -sds *sdssplitargs(const char *line, int *argc) { - const char *p = line; - char *current = NULL; - char **vector = NULL; - - *argc = 0; - while(1) { - /* skip blanks */ - while(*p && isspace(*p)) { p++; } - if (*p) { - /* get a token */ - int inq=0; /* set to 1 if we are in "quotes" */ - int insq=0; /* set to 1 if we are in 'single quotes' */ - int done=0; - - if (current == NULL) { current = sdsempty(); } - while(!done) { - if (inq) { - if (*p == '\\' && *(p + 1) == 'x' && - is_hex_digit(*(p + 2)) && - is_hex_digit(*(p + 3))) - { - unsigned char byte; - - byte = (unsigned char)((hex_digit_to_int(*(p + 2)) * 16) + - hex_digit_to_int(*(p + 3))); - current = sdscatlen(current, (char*)&byte, 1); - p += 3; - } else if (*p == '\\' && *(p + 1)) { - char c; - - p++; - switch(*p) { - case 'n': c = '\n'; break; - case 'r': c = '\r'; break; - case 't': c = '\t'; break; - case 'b': c = '\b'; break; - case 'a': c = '\a'; break; - default: c = *p; break; - } - current = sdscatlen(current, &c, 1); - } else if (*p == '"') { - /* closing quote must be followed by a space or - * nothing at all. */ - if (*(p + 1) && !isspace(*(p + 1))) { goto err; } - done=1; - } else if (!*p) { - /* unterminated quotes */ - goto err; - } else { - current = sdscatlen(current, p, 1); - } - } else if (insq) { - if (*p == '\\' && *(p + 1) == '\'') { - p++; - current = sdscatlen(current, "'", 1); - } else if (*p == '\'') { - /* closing quote must be followed by a space or - * nothing at all. */ - if (*(p + 1) && !isspace(*(p + 1))) { goto err; } - done=1; - } else if (!*p) { - /* unterminated quotes */ - goto err; - } else { - current = sdscatlen(current, p, 1); - } - } else { - switch(*p) { - case ' ': - case '\n': - case '\r': - case '\t': - case '\0': - done=1; - break; - case '"': - inq=1; - break; - case '\'': - insq=1; - break; - default: - current = sdscatlen(current, p, 1); - break; - } - } - if (*p) { p++; } - } - /* add the token to the vector */ - vector = realloc(vector, (unsigned long)((*argc) + 1) * (sizeof (char *))); - vector[*argc] = current; - (*argc)++; - current = NULL; - } else { - /* Even on empty input string return something not NULL. */ - if (vector == NULL) { vector = malloc(sizeof(void*)); } - return vector; - } - } - -err: - while((*argc)--) { - sdsfree(vector[*argc]); - } - free(vector); - if (current) { sdsfree(current); } - *argc = 0; - return NULL; -} - -/* Split 's' with separator in 'sep'. An array - * of sds strings is returned. *count will be set - * by reference to the number of tokens returned. - * - * On out of memory, zero length string, zero length - * separator, NULL is returned. - * - * Note that 'sep' is able to split a string using - * a multi-character separator. For example - * sdssplit("foo_-_bar", "_-_"); will return two - * elements "foo" and "bar". - * - * This version of the function is binary-safe but - * requires length arguments. sdssplit() is just the - * same function but for zero-terminated strings. - */ -sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { - size_t elements = 0, slots = 5, start = 0; - sds *tokens; - - if (seplen < 1) { return NULL; } - - tokens = malloc(sizeof(sds)*slots); - if (tokens == NULL) { return NULL; } - - if (len == 0) { - *count = 0; - return tokens; - } - for (size_t j = 0; j < (len - (seplen - 1)); j++) { - /* make sure there is room for the next element and the final one */ - if (slots < elements + 2) { - sds *newtokens; - - slots *= 2; - newtokens = realloc(tokens, sizeof(sds) * slots); - if (newtokens == NULL) { goto cleanup; } - tokens = newtokens; - } - /* search the separator */ - if ((seplen == 1 && *(s + j) == sep[0]) || (memcmp(s + j, sep, seplen) == 0)) { - tokens[elements] = sdsnew(s + start, (size_t)(j - start)); - if (tokens[elements] == NULL) { goto cleanup; } - elements++; - start = j + seplen; - j = j + seplen - 1; /* skip the separator */ - } - } - /* Add the final element. We are sure there is room in the tokens array. */ - tokens[elements] = sdsnew(s + start, (size_t)(len - start)); - if (tokens[elements] == NULL) { goto cleanup; } - elements++; - *count = elements; - return tokens; - -cleanup: - { - for (size_t i = 0; i < elements; i++) { - sdsfree(tokens[i]); - } - free(tokens); - *count = 0; - return NULL; - } -} - -// Concatenation - -/* Append the specified null termianted C string to the sds string 's'. - * - * After the call, the passed sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. */ -sds sdscat(sds s, const char *t) { - return sdscatlen(s, t, strlen(t)); -} - -/* Append the specified sds 't' to the existing sds 's'. - * - * After the call, the modified sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. */ -sds sdscatsds(sds s, const sds t) { - return sdscatlen(s, t, sdslen(t)); -} - -/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the - * end of the specified sds string 's'. - * - * After the call, the passed sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. */ -sds sdscatlen(sds s, const void *t, size_t len) { - struct sdshdr *sh; - size_t curlen = sdslen(s); - - s = sdsMakeRoomFor(s, len); - if (s == NULL) { return NULL; } - sh = sdsheader(s); - memcpy(s + curlen, t, len); - sh->len = curlen + len; - sh->free = sh->free - len; - s[curlen + len] = '\0'; - return s; -} - -/* Append to the sds string "s" an escaped string representation where - * all the non-printable characters (tested with isprint()) are turned into - * escapes in the form "\n\r\a...." or "\x". - * - * After the call, the modified sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. */ -sds sdscatrepr(sds s, const char *p, size_t len) { - s = sdscatlen(s, "\"", 1); - while(len--) { - switch(*p) { - case '\\': - case '"': - s = sdscatprintf(s, "\\%c", *p); - break; - case '\n': s = sdscatlen(s, "\\n", 2); break; - case '\r': s = sdscatlen(s, "\\r", 2); break; - case '\t': s = sdscatlen(s, "\\t", 2); break; - case '\a': s = sdscatlen(s, "\\a", 2); break; - case '\b': s = sdscatlen(s, "\\b", 2); break; - default: - if (isprint(*p)) { - s = sdscatprintf(s, "%c", *p); - } else { - s = sdscatprintf(s, "\\x%02x", (unsigned char)*p); - break; - } - } - p++; - } - return sdscatlen(s, "\"", 1); -} - -/* Like sdscatpritf() but gets va_list instead of being variadic. */ -#pragma GCC diagnostic ignored "-Wformat-nonliteral" -sds sdscatvprintf(sds s, const char *fmt, va_list ap) { - va_list cpy; - char *buf, *t; - size_t buflen = 16; - - while(1) { - buf = malloc(buflen); - if (buf == NULL) { return NULL; } - buf[buflen - 2] = '\0'; - va_copy(cpy, ap); - vsnprintf(buf, buflen, fmt, cpy); - if (buf[buflen - 2] != '\0') { - free(buf); - buflen *= 2; - continue; - } - break; - } - t = sdscat(s, buf); - free(buf); - return t; -} -#pragma GCC diagnostic warning "-Wformat-nonliteral" - -/* Append to the sds string 's' a string obtained using printf-alike format - * specifier. - * - * After the call, the modified sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. - * - * Example: - * - * s = sdsempty("Sum is: "); - * s = sdscatprintf(s, "%d + %d = %d", a, b, a + b). - * - * Often you need to create a string from scratch with the printf-alike - * format. When this is the need, just use sdsempty() as the target string: - * - * s = sdscatprintf(sdsempty(), "... your format ...", args); - */ -sds sdscatprintf(sds s, const char *fmt, ...) { - va_list ap; - char *t; - va_start(ap, fmt); - t = sdscatvprintf(s, fmt, ap); - va_end(ap); - return t; -} - - -/// Freeing - -/* Free an sds string. No operation is performed if 's' is NULL. */ -void sdsfree(sds s) { - if (s == NULL) { return; } - free(sdsheader(s)); -} - -/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */ -void sdsfreesplitres(sds *tokens, size_t count) { - if (!tokens) { return; } - while(count--) { - sdsfree(tokens[count]); - } - free(tokens); -} - - -// Low-level functions - -/* Return the total size of the allocation of the specifed sds string, - * including: - * 1) The sds header before the pointer. - * 2) The string. - * 3) The free buffer at the end if any. - * 4) The implicit null term. - */ -size_t sdsAllocSize(sds s) { - struct sdshdr *sh = sdsheader(s); - - return sizeof(*sh) + sh->len + sh->free + 1; -} - -/* Increment the sds length and decrements the left free space at the - * end of the string according to 'incr'. Also set the null term - * in the new end of the string. - * - * This function is used in order to fix the string length after the - * user calls sdsMakeRoomFor(), writes something after the end of - * the current string, and finally needs to set the new length. - * - * Usage example: - * - * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the - * following schema, to cat bytes coming from the kernel to the end of an - * sds string without copying into an intermediate buffer: - * - * oldlen = sdslen(s); - * s = sdsMakeRoomFor(s, BUFFER_SIZE); - * nread = read(fd, s + oldlen, BUFFER_SIZE); - * ... check for nread <= 0 and handle it ... - * sdsIncrLen(s, nread); - */ -void sdsIncrLen(sds s, size_t incr) { - struct sdshdr *sh = sdsheader(s); - - assert(sh->free >= incr); - sh->len += incr; - sh->free -= incr; - s[sh->len] = '\0'; -} - -/* Enlarge the free space at the end of the sds string so that the caller - * is sure that after calling this function can overwrite up to addlen - * bytes after the end of the string, plus one more byte for nul term. - * - * Note: this does not change the *length* of the sds string as returned - * by sdslen(), but only the free buffer space we have. */ -sds sdsMakeRoomFor(sds s, size_t addlen) { - struct sdshdr *sh, *newsh; - size_t free = sdsavail(s); - size_t len, newlen; - - if (free >= addlen) { return s; } - len = sdslen(s); - sh = sdsheader(s); - newlen = (len + addlen); - if (newlen < SDS_MAX_PREALLOC) { - newlen *= 2; - } else { - newlen += SDS_MAX_PREALLOC; - } - newsh = realloc(sh, sizeof(struct sdshdr) + newlen + 1); - if (newsh == NULL) { return NULL; } - - newsh->free = newlen - len; - return newsh->buf; -} - -/* Reallocate the sds string so that it has no free space at the end. The - * contained string remains not altered, but next concatenation operations - * will require a reallocation. - * - * After the call, the passed sds string is no longer valid and all the - * references must be substituted with the new pointer returned by the call. */ -sds sdsRemoveFreeSpace(sds s) { - struct sdshdr *sh; - - sh = sdsheader(s); - sh = realloc(sh, sizeof(struct sdshdr) + sh->len + 1); - sh->free = 0; - return sh->buf; -} - - -/// Low-level helper functions - -/* Helper function for sdssplitargs() that returns non zero if 'c' - * is a valid hex digit. */ -int is_hex_digit(char c) { - return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || - (c >= 'A' && c <= 'F'); -} - -/* Helper function for sdssplitargs() that converts a hex digit into an - * integer from 0 to 15 */ -int hex_digit_to_int(char c) { - switch(c) { - case '0': return 0; - case '1': return 1; - case '2': return 2; - case '3': return 3; - case '4': return 4; - case '5': return 5; - case '6': return 6; - case '7': return 7; - case '8': return 8; - case '9': return 9; - case 'a': case 'A': return 10; - case 'b': case 'B': return 11; - case 'c': case 'C': return 12; - case 'd': case 'D': return 13; - case 'e': case 'E': return 14; - case 'f': case 'F': return 15; - default: return 0; - } -} - diff --git a/src/sds.h b/src/sds.h deleted file mode 100644 index 6b3a951..0000000 --- a/src/sds.h +++ /dev/null @@ -1,131 +0,0 @@ -/* SDS (Simple Dynamic Strings), A C dynamic strings library. - * - * Copyright (c) 2006-2014, Salvatore Sanfilippo - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef SDS_H -#define SDS_H - -#define SDS_MAX_PREALLOC (1024*1024) - -#include -#include -#include - -typedef char *sds; - -struct sdshdr { - size_t len; - size_t free; - char buf[]; -}; - - -/** - * User API function prototypes - */ - -/// Initialization -sds sdsnew(const void *init, size_t initlen); -sds sdsdup(const sds s); -sds sdsempty(void); -sds sdsfromlonglong(long long value); - - -/// Querying -int sdscmp(const sds s1, const sds s2); - - -/// Modification -void sdsclear(sds s); -sds sdsgrowzero(sds s, size_t len); -sds sdscpylen(sds s, const char *t, size_t len); -sds sdscpy(sds s, const char *t); -sds sdsjoin(char **argv, int argc, char *sep, size_t seplen); -sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen); -sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen); -void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end); -void sdstolower(sds s); -void sdstoupper(sds s); -void sdstrim(sds s, const char *cset); -void sdsupdatelen(sds s); -sds *sdssplitargs(const char *line, int *argc); -sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count); - -// Concatenation -sds sdscat(sds s, const char *t); -sds sdscatsds(sds s, const sds t); -sds sdscatlen(sds s, const void *t, size_t len); -sds sdscatrepr(sds s, const char *p, size_t len); -sds sdscatvprintf(sds s, const char *fmt, va_list ap); -#ifdef __GNUC__ -sds sdscatprintf(sds s, const char *fmt, ...) - __attribute__((format(printf, 2, 3))); -#else -sds sdscatprintf(sds s, const char *fmt, ...); -#endif - - -/// Freeing -void sdsfree(sds s); -void sdsfreesplitres(sds *tokens, size_t count); - - -/// Low-level API function prototypes -size_t sdsAllocSize(sds s); -void sdsIncrLen(sds s, size_t incr); -sds sdsMakeRoomFor(sds s, size_t addlen); -sds sdsRemoveFreeSpace(sds s); - - -/// Low-level helper functions -int is_hex_digit(char c); -int hex_digit_to_int(char c); - - -/** - * Inline functions - */ - -static inline struct sdshdr *sdsheader(const sds s) { - /* The sdshdr pointer has a different alignment than the original char - * pointer, so cast it through a void pointer to silence the warning. */ - return (void *)(s - (sizeof (struct sdshdr))); -} - -static inline sds sdsauto(const char *s) { - return sdsnew(s, s ? strlen(s) : 0); -} - -static inline size_t sdsavail(const sds s) { - return sdsheader(s)->free; -} - -static inline size_t sdslen(const sds s) { - return sdsheader(s)->len; -} - - -#endif diff --git a/src/yasl.c b/src/yasl.c new file mode 100644 index 0000000..bd6d668 --- /dev/null +++ b/src/yasl.c @@ -0,0 +1,797 @@ +/* SDS (Simple Dynamic Strings), A C dynamic strings library. + * + * Copyright (c) 2006-2014, Salvatore Sanfilippo + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include + +#include "yasl.h" + + +/// Initialization + +/* Create a new sds string with the content specified by the 'init' pointer + * and 'initlen'. + * If NULL is used for 'init' the string is initialized with zero bytes. + * + * The string is always null-termined (all the sds strings are, always) so + * even if you create an sds string with: + * + * mystring = sdsnew("abc", 3"); + * + * You can print the string with printf() as there is an implicit \0 at the + * end of the string. However the string is binary safe and can contain + * \0 characters in the middle, as the length is stored in the sds header. */ +sds sdsnew(const void *init, size_t initlen) { + struct sdshdr *sh; + + if (init) { + sh = malloc(sizeof(struct sdshdr) + initlen + 1); + } else { + sh = calloc(sizeof(struct sdshdr) + initlen + 1, 1); + } + if (sh == NULL) { return NULL; } + + sh->len = initlen; + sh->free = 0; + if (initlen && init) { + memcpy(sh->buf, init, initlen); + } + sh->buf[initlen] = '\0'; + return (char*)sh->buf; +} + +/* Duplicate an sds string. */ +sds sdsdup(const sds s) { + return sdsnew(s, sdslen(s)); +} + +/* Create an empty (zero length) sds string. Even in this case the string + * always has an implicit null term. */ +sds sdsempty(void) { + return sdsnew("", 0); +} + +/* Create an sds string from a long long value. It is much faster than: + * + * sdscatprintf(sdsempty(), "%lld\n", value); + */ +sds sdsfromlonglong(long long value) { + char buf[32], *p; + unsigned long long v; + + v = (unsigned long long)((value < 0) ? -value : value); + p = buf + 31; /* point to the last character */ + do { + *p-- = '0' + (v%10); + v /= 10; + } while(v); + if (value < 0) { *p-- = '-'; } + p++; + return sdsnew(p, (size_t)(32 - (p - buf))); +} + + +/// Querying + +/* Compare two sds strings s1 and s2 with memcmp(). + * + * Return value: + * + * 1 if s1 > s2. + * -1 if s1 < s2. + * 0 if s1 and s2 are exactly the same binary string. + * + * If two strings share exactly the same prefix, but one of the two has + * additional characters, the longer string is considered to be greater than + * the smaller one. */ +int sdscmp(const sds s1, const sds s2) { + size_t l1, l2, minlen; + int cmp; + + l1 = sdslen(s1); + l2 = sdslen(s2); + minlen = (l1 < l2) ? l1 : l2; + cmp = memcmp(s1, s2, minlen); + if (cmp == 0) { return (int)(l1 - l2); } + return cmp; +} + + +/// Modification + +/* Modify an sds string on-place to make it empty (zero length). + * However all the existing buffer is not discarded but set as free space + * so that next append operations will not require allocations up to the + * number of bytes previously available. */ +void sdsclear(sds s) { + struct sdshdr *sh = sdsheader(s); + sh->free += sh->len; + sh->len = 0; + sh->buf[0] = '\0'; +} + +/* Grow the sds to have the specified length. Bytes that were not part of + * the original length of the sds will be set to zero. + * + * if the specified length is smaller than the current length, no operation + * is performed. */ +sds sdsgrowzero(sds s, size_t len) { + struct sdshdr *sh = sdsheader(s); + size_t totlen, curlen = sh->len; + + if (len <= curlen) { return s; } + s = sdsMakeRoomFor(s, len - curlen); + if (s == NULL) { return NULL; } + + /* Make sure added region doesn't contain garbage */ + sh = sdsheader(s); + memset(s + curlen, 0, (len - curlen + 1)); /* also set trailing \0 byte */ + totlen = sh->len + sh->free; + sh->len = len; + sh->free = totlen - sh->len; + return s; +} + +/* Destructively modify the sds string 's' to hold the specified binary + * safe string pointed by 't' of length 'len' bytes. */ +sds sdscpylen(sds s, const char *t, size_t len) { + struct sdshdr *sh = sdsheader(s); + size_t totlen = sh->free + sh->len; + + if (totlen < len) { + s = sdsMakeRoomFor(s, len - sh->len); + if (s == NULL) { return NULL; } + sh = sdsheader(s); + totlen = sh->free + sh->len; + } + memcpy(s, t, len); + s[len] = '\0'; + sh->len = len; + sh->free = totlen - len; + return s; +} + +/* Like sdscpylen() but 't' must be a null-termined string so that the length + * of the string is obtained with strlen(). */ +sds sdscpy(sds s, const char *t) { + return sdscpylen(s, t, strlen(t)); +} + +/* Join an array of C strings using the specified separator (also a C string). + * Returns the result as an sds string. */ +sds sdsjoin(char **argv, int argc, char *sep, size_t seplen) { + sds join = sdsempty(); + + for (int j = 0; j < argc; j++) { + join = sdscat(join, argv[j]); + if (j != argc - 1) { join = sdscatlen(join, sep, seplen); } + } + return join; +} + +/* Like sdsjoin, but joins an array of SDS strings. */ +sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) { + sds join = sdsempty(); + + for (int j = 0; j < argc; j++) { + join = sdscatsds(join, argv[j]); + if (j != argc - 1) { join = sdscatlen(join, sep, seplen); } + } + return join; +} + +/* Modify the string substituting all the occurrences of the set of + * characters specified in the 'from' string to the corresponding character + * in the 'to' array. + * + * For instance: sdsmapchars(mystring, "ho", "01", 2) + * will have the effect of turning the string "hello" into "0ell1". + * + * The function returns the sds string pointer, that is always the same + * as the input pointer since no resize is needed. */ +sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { + for (size_t j = 0; j < sdslen(s); j++) { + for (size_t i = 0; i < setlen; i++) { + if (s[j] == from[i]) { + s[j] = to[i]; + break; + } + } + } + return s; +} + +/* Turn the string into a smaller (or equal) string containing only the + * substring specified by the 'start' and 'end' indexes. + * + * start and end can be negative, where -1 means the last character of the + * string, -2 the penultimate character, and so forth. + * + * The interval is inclusive, so the start and end characters will be part + * of the resulting string. + * + * The string is modified in-place. + * + * Example: + * + * s = sdsauto("Hello World"); + * sdsrange(s, 1, -1); => "ello World" + */ +void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end) { + struct sdshdr *sh = sdsheader(s); + size_t newlen, len = sdslen(s); + + if (len == 0) { return; } + if (start < 0) { + start = (ptrdiff_t)len + start; + if (start < 0) { start = 0; } + } + if (end < 0) { + end = (ptrdiff_t)len + end; + if (end < 0) { end = 0; } + } + newlen = (size_t)((start > end) ? 0 : (end - start) + 1); + if (newlen != 0) { + if ((size_t)start >= len) { + newlen = 0; + } else if ((size_t)end >= len) { + end = (ptrdiff_t)len - 1; + newlen = (size_t)((start > end) ? 0 : (end - start) + 1); + } + } else { + start = 0; + } + if (start && newlen) { memmove(sh->buf, sh->buf + start, newlen); } + sh->buf[newlen] = 0; + sh->free = sh->free + (sh->len - newlen); + sh->len = newlen; +} + +/* Apply tolower() to every character of the sds string 's'. */ +void sdstolower(sds s) { + for (size_t j = 0; j < sdslen(s); j++) { + s[j] = (char)tolower(s[j]); + } +} + +/* Apply toupper() to every character of the sds string 's'. */ +void sdstoupper(sds s) { + for (size_t j = 0; j < sdslen(s); j++) { + s[j] = (char)toupper(s[j]); + } +} + +/* Remove the part of the string from left and from right composed just of + * contiguous characters found in 'cset', that is a null terminted C string. + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. + * + * Example: + * + * s = sdsauto("AA...AA.a.aa.aHelloWorld :::"); + * s = sdstrim(s, "A. :"); + * printf("%s\n", s); + * + * Output will be just "Hello World". + */ +void sdstrim(sds s, const char *cset) { + struct sdshdr *sh = sdsheader(s); + char *start, *end, *sp, *ep; + size_t len; + + sp = start = s; + ep = end = s + sdslen(s) - 1; + while(sp <= end && strchr(cset, *sp)) { sp++; } + while(ep > start && strchr(cset, *ep)) { ep--; } + len = (size_t)((sp > ep) ? 0 : ((ep - sp) + 1)); + if (sh->buf != sp) { memmove(sh->buf, sp, len); } + sh->buf[len] = '\0'; + sh->free = sh->free + (sh->len - len); + sh->len = len; +} + +/* Set the sds string length to the length as obtained with strlen(), so + * considering as content only up to the first null term character. + * + * This function is useful when the sds string is hacked manually in some + * way, like in the following example: + * + * s = sdsauto("foobar"); + * s[2] = '\0'; + * sdsupdatelen(s); + * printf("%d\n", sdslen(s)); + * + * The output will be "2", but if we comment out the call to sdsupdatelen() + * the output will be "6" as the string was modified but the logical length + * remains 6 bytes. */ +void sdsupdatelen(sds s) { + struct sdshdr *sh = sdsheader(s); + size_t reallen = strlen(s); + sh->free += (sh->len - reallen); + sh->len = reallen; +} + +/* Split a line into arguments, where every argument can be in the + * following programming-language REPL-alike form: + * + * foo bar "newline are supported\n" and "\xff\x00otherstuff" + * + * The number of arguments is stored into *argc, and an array + * of sds is returned. + * + * The caller should free the resulting array of sds strings with + * sdsfreesplitres(). + * + * Note that sdscatrepr() is able to convert back a string into + * a quoted string in the same format sdssplitargs() is able to parse. + * + * The function returns the allocated tokens on success, even when the + * input string is empty, or NULL if the input contains unbalanced + * quotes or closed quotes followed by non space characters + * as in: "foo"bar or "foo' + */ +sds *sdssplitargs(const char *line, int *argc) { + const char *p = line; + char *current = NULL; + char **vector = NULL; + + *argc = 0; + while(1) { + /* skip blanks */ + while(*p && isspace(*p)) { p++; } + if (*p) { + /* get a token */ + int inq=0; /* set to 1 if we are in "quotes" */ + int insq=0; /* set to 1 if we are in 'single quotes' */ + int done=0; + + if (current == NULL) { current = sdsempty(); } + while(!done) { + if (inq) { + if (*p == '\\' && *(p + 1) == 'x' && + is_hex_digit(*(p + 2)) && + is_hex_digit(*(p + 3))) + { + unsigned char byte; + + byte = (unsigned char)((hex_digit_to_int(*(p + 2)) * 16) + + hex_digit_to_int(*(p + 3))); + current = sdscatlen(current, (char*)&byte, 1); + p += 3; + } else if (*p == '\\' && *(p + 1)) { + char c; + + p++; + switch(*p) { + case 'n': c = '\n'; break; + case 'r': c = '\r'; break; + case 't': c = '\t'; break; + case 'b': c = '\b'; break; + case 'a': c = '\a'; break; + default: c = *p; break; + } + current = sdscatlen(current, &c, 1); + } else if (*p == '"') { + /* closing quote must be followed by a space or + * nothing at all. */ + if (*(p + 1) && !isspace(*(p + 1))) { goto err; } + done=1; + } else if (!*p) { + /* unterminated quotes */ + goto err; + } else { + current = sdscatlen(current, p, 1); + } + } else if (insq) { + if (*p == '\\' && *(p + 1) == '\'') { + p++; + current = sdscatlen(current, "'", 1); + } else if (*p == '\'') { + /* closing quote must be followed by a space or + * nothing at all. */ + if (*(p + 1) && !isspace(*(p + 1))) { goto err; } + done=1; + } else if (!*p) { + /* unterminated quotes */ + goto err; + } else { + current = sdscatlen(current, p, 1); + } + } else { + switch(*p) { + case ' ': + case '\n': + case '\r': + case '\t': + case '\0': + done=1; + break; + case '"': + inq=1; + break; + case '\'': + insq=1; + break; + default: + current = sdscatlen(current, p, 1); + break; + } + } + if (*p) { p++; } + } + /* add the token to the vector */ + vector = realloc(vector, (unsigned long)((*argc) + 1) * (sizeof (char *))); + vector[*argc] = current; + (*argc)++; + current = NULL; + } else { + /* Even on empty input string return something not NULL. */ + if (vector == NULL) { vector = malloc(sizeof(void*)); } + return vector; + } + } + +err: + while((*argc)--) { + sdsfree(vector[*argc]); + } + free(vector); + if (current) { sdsfree(current); } + *argc = 0; + return NULL; +} + +/* Split 's' with separator in 'sep'. An array + * of sds strings is returned. *count will be set + * by reference to the number of tokens returned. + * + * On out of memory, zero length string, zero length + * separator, NULL is returned. + * + * Note that 'sep' is able to split a string using + * a multi-character separator. For example + * sdssplit("foo_-_bar", "_-_"); will return two + * elements "foo" and "bar". + * + * This version of the function is binary-safe but + * requires length arguments. sdssplit() is just the + * same function but for zero-terminated strings. + */ +sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { + size_t elements = 0, slots = 5, start = 0; + sds *tokens; + + if (seplen < 1) { return NULL; } + + tokens = malloc(sizeof(sds)*slots); + if (tokens == NULL) { return NULL; } + + if (len == 0) { + *count = 0; + return tokens; + } + for (size_t j = 0; j < (len - (seplen - 1)); j++) { + /* make sure there is room for the next element and the final one */ + if (slots < elements + 2) { + sds *newtokens; + + slots *= 2; + newtokens = realloc(tokens, sizeof(sds) * slots); + if (newtokens == NULL) { goto cleanup; } + tokens = newtokens; + } + /* search the separator */ + if ((seplen == 1 && *(s + j) == sep[0]) || (memcmp(s + j, sep, seplen) == 0)) { + tokens[elements] = sdsnew(s + start, (size_t)(j - start)); + if (tokens[elements] == NULL) { goto cleanup; } + elements++; + start = j + seplen; + j = j + seplen - 1; /* skip the separator */ + } + } + /* Add the final element. We are sure there is room in the tokens array. */ + tokens[elements] = sdsnew(s + start, (size_t)(len - start)); + if (tokens[elements] == NULL) { goto cleanup; } + elements++; + *count = elements; + return tokens; + +cleanup: + { + for (size_t i = 0; i < elements; i++) { + sdsfree(tokens[i]); + } + free(tokens); + *count = 0; + return NULL; + } +} + +// Concatenation + +/* Append the specified null termianted C string to the sds string 's'. + * + * After the call, the passed sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscat(sds s, const char *t) { + return sdscatlen(s, t, strlen(t)); +} + +/* Append the specified sds 't' to the existing sds 's'. + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscatsds(sds s, const sds t) { + return sdscatlen(s, t, sdslen(t)); +} + +/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the + * end of the specified sds string 's'. + * + * After the call, the passed sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscatlen(sds s, const void *t, size_t len) { + struct sdshdr *sh; + size_t curlen = sdslen(s); + + s = sdsMakeRoomFor(s, len); + if (s == NULL) { return NULL; } + sh = sdsheader(s); + memcpy(s + curlen, t, len); + sh->len = curlen + len; + sh->free = sh->free - len; + s[curlen + len] = '\0'; + return s; +} + +/* Append to the sds string "s" an escaped string representation where + * all the non-printable characters (tested with isprint()) are turned into + * escapes in the form "\n\r\a...." or "\x". + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscatrepr(sds s, const char *p, size_t len) { + s = sdscatlen(s, "\"", 1); + while(len--) { + switch(*p) { + case '\\': + case '"': + s = sdscatprintf(s, "\\%c", *p); + break; + case '\n': s = sdscatlen(s, "\\n", 2); break; + case '\r': s = sdscatlen(s, "\\r", 2); break; + case '\t': s = sdscatlen(s, "\\t", 2); break; + case '\a': s = sdscatlen(s, "\\a", 2); break; + case '\b': s = sdscatlen(s, "\\b", 2); break; + default: + if (isprint(*p)) { + s = sdscatprintf(s, "%c", *p); + } else { + s = sdscatprintf(s, "\\x%02x", (unsigned char)*p); + break; + } + } + p++; + } + return sdscatlen(s, "\"", 1); +} + +/* Like sdscatpritf() but gets va_list instead of being variadic. */ +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +sds sdscatvprintf(sds s, const char *fmt, va_list ap) { + va_list cpy; + char *buf, *t; + size_t buflen = 16; + + while(1) { + buf = malloc(buflen); + if (buf == NULL) { return NULL; } + buf[buflen - 2] = '\0'; + va_copy(cpy, ap); + vsnprintf(buf, buflen, fmt, cpy); + if (buf[buflen - 2] != '\0') { + free(buf); + buflen *= 2; + continue; + } + break; + } + t = sdscat(s, buf); + free(buf); + return t; +} +#pragma GCC diagnostic warning "-Wformat-nonliteral" + +/* Append to the sds string 's' a string obtained using printf-alike format + * specifier. + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. + * + * Example: + * + * s = sdsempty("Sum is: "); + * s = sdscatprintf(s, "%d + %d = %d", a, b, a + b). + * + * Often you need to create a string from scratch with the printf-alike + * format. When this is the need, just use sdsempty() as the target string: + * + * s = sdscatprintf(sdsempty(), "... your format ...", args); + */ +sds sdscatprintf(sds s, const char *fmt, ...) { + va_list ap; + char *t; + va_start(ap, fmt); + t = sdscatvprintf(s, fmt, ap); + va_end(ap); + return t; +} + + +/// Freeing + +/* Free an sds string. No operation is performed if 's' is NULL. */ +void sdsfree(sds s) { + if (s == NULL) { return; } + free(sdsheader(s)); +} + +/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */ +void sdsfreesplitres(sds *tokens, size_t count) { + if (!tokens) { return; } + while(count--) { + sdsfree(tokens[count]); + } + free(tokens); +} + + +// Low-level functions + +/* Return the total size of the allocation of the specifed sds string, + * including: + * 1) The sds header before the pointer. + * 2) The string. + * 3) The free buffer at the end if any. + * 4) The implicit null term. + */ +size_t sdsAllocSize(sds s) { + struct sdshdr *sh = sdsheader(s); + + return sizeof(*sh) + sh->len + sh->free + 1; +} + +/* Increment the sds length and decrements the left free space at the + * end of the string according to 'incr'. Also set the null term + * in the new end of the string. + * + * This function is used in order to fix the string length after the + * user calls sdsMakeRoomFor(), writes something after the end of + * the current string, and finally needs to set the new length. + * + * Usage example: + * + * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the + * following schema, to cat bytes coming from the kernel to the end of an + * sds string without copying into an intermediate buffer: + * + * oldlen = sdslen(s); + * s = sdsMakeRoomFor(s, BUFFER_SIZE); + * nread = read(fd, s + oldlen, BUFFER_SIZE); + * ... check for nread <= 0 and handle it ... + * sdsIncrLen(s, nread); + */ +void sdsIncrLen(sds s, size_t incr) { + struct sdshdr *sh = sdsheader(s); + + assert(sh->free >= incr); + sh->len += incr; + sh->free -= incr; + s[sh->len] = '\0'; +} + +/* Enlarge the free space at the end of the sds string so that the caller + * is sure that after calling this function can overwrite up to addlen + * bytes after the end of the string, plus one more byte for nul term. + * + * Note: this does not change the *length* of the sds string as returned + * by sdslen(), but only the free buffer space we have. */ +sds sdsMakeRoomFor(sds s, size_t addlen) { + struct sdshdr *sh, *newsh; + size_t free = sdsavail(s); + size_t len, newlen; + + if (free >= addlen) { return s; } + len = sdslen(s); + sh = sdsheader(s); + newlen = (len + addlen); + if (newlen < SDS_MAX_PREALLOC) { + newlen *= 2; + } else { + newlen += SDS_MAX_PREALLOC; + } + newsh = realloc(sh, sizeof(struct sdshdr) + newlen + 1); + if (newsh == NULL) { return NULL; } + + newsh->free = newlen - len; + return newsh->buf; +} + +/* Reallocate the sds string so that it has no free space at the end. The + * contained string remains not altered, but next concatenation operations + * will require a reallocation. + * + * After the call, the passed sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdsRemoveFreeSpace(sds s) { + struct sdshdr *sh; + + sh = sdsheader(s); + sh = realloc(sh, sizeof(struct sdshdr) + sh->len + 1); + sh->free = 0; + return sh->buf; +} + + +/// Low-level helper functions + +/* Helper function for sdssplitargs() that returns non zero if 'c' + * is a valid hex digit. */ +int is_hex_digit(char c) { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || + (c >= 'A' && c <= 'F'); +} + +/* Helper function for sdssplitargs() that converts a hex digit into an + * integer from 0 to 15 */ +int hex_digit_to_int(char c) { + switch(c) { + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; + case '8': return 8; + case '9': return 9; + case 'a': case 'A': return 10; + case 'b': case 'B': return 11; + case 'c': case 'C': return 12; + case 'd': case 'D': return 13; + case 'e': case 'E': return 14; + case 'f': case 'F': return 15; + default: return 0; + } +} + diff --git a/src/yasl.h b/src/yasl.h new file mode 100644 index 0000000..6b3a951 --- /dev/null +++ b/src/yasl.h @@ -0,0 +1,131 @@ +/* SDS (Simple Dynamic Strings), A C dynamic strings library. + * + * Copyright (c) 2006-2014, Salvatore Sanfilippo + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SDS_H +#define SDS_H + +#define SDS_MAX_PREALLOC (1024*1024) + +#include +#include +#include + +typedef char *sds; + +struct sdshdr { + size_t len; + size_t free; + char buf[]; +}; + + +/** + * User API function prototypes + */ + +/// Initialization +sds sdsnew(const void *init, size_t initlen); +sds sdsdup(const sds s); +sds sdsempty(void); +sds sdsfromlonglong(long long value); + + +/// Querying +int sdscmp(const sds s1, const sds s2); + + +/// Modification +void sdsclear(sds s); +sds sdsgrowzero(sds s, size_t len); +sds sdscpylen(sds s, const char *t, size_t len); +sds sdscpy(sds s, const char *t); +sds sdsjoin(char **argv, int argc, char *sep, size_t seplen); +sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen); +sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen); +void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end); +void sdstolower(sds s); +void sdstoupper(sds s); +void sdstrim(sds s, const char *cset); +void sdsupdatelen(sds s); +sds *sdssplitargs(const char *line, int *argc); +sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count); + +// Concatenation +sds sdscat(sds s, const char *t); +sds sdscatsds(sds s, const sds t); +sds sdscatlen(sds s, const void *t, size_t len); +sds sdscatrepr(sds s, const char *p, size_t len); +sds sdscatvprintf(sds s, const char *fmt, va_list ap); +#ifdef __GNUC__ +sds sdscatprintf(sds s, const char *fmt, ...) + __attribute__((format(printf, 2, 3))); +#else +sds sdscatprintf(sds s, const char *fmt, ...); +#endif + + +/// Freeing +void sdsfree(sds s); +void sdsfreesplitres(sds *tokens, size_t count); + + +/// Low-level API function prototypes +size_t sdsAllocSize(sds s); +void sdsIncrLen(sds s, size_t incr); +sds sdsMakeRoomFor(sds s, size_t addlen); +sds sdsRemoveFreeSpace(sds s); + + +/// Low-level helper functions +int is_hex_digit(char c); +int hex_digit_to_int(char c); + + +/** + * Inline functions + */ + +static inline struct sdshdr *sdsheader(const sds s) { + /* The sdshdr pointer has a different alignment than the original char + * pointer, so cast it through a void pointer to silence the warning. */ + return (void *)(s - (sizeof (struct sdshdr))); +} + +static inline sds sdsauto(const char *s) { + return sdsnew(s, s ? strlen(s) : 0); +} + +static inline size_t sdsavail(const sds s) { + return sdsheader(s)->free; +} + +static inline size_t sdslen(const sds s) { + return sdsheader(s)->len; +} + + +#endif -- cgit v1.2.3-54-g00ecf From 2c3baba200a74d7ad6f64e9ef37251849139c9a4 Mon Sep 17 00:00:00 2001 From: Johannes Löthberg Date: Tue, 20 Jan 2015 13:29:14 +0100 Subject: Update functions to use the yasl prefix instead of sds --- src/yasl.c | 250 ++++++++++++++++++++++++++++++------------------------------- src/yasl.h | 78 +++++++++---------- 2 files changed, 164 insertions(+), 164 deletions(-) diff --git a/src/yasl.c b/src/yasl.c index bd6d668..931a0ee 100644 --- a/src/yasl.c +++ b/src/yasl.c @@ -44,12 +44,12 @@ * The string is always null-termined (all the sds strings are, always) so * even if you create an sds string with: * - * mystring = sdsnew("abc", 3"); + * mystring = yaslnew("abc", 3"); * * You can print the string with printf() as there is an implicit \0 at the * end of the string. However the string is binary safe and can contain * \0 characters in the middle, as the length is stored in the sds header. */ -sds sdsnew(const void *init, size_t initlen) { +sds yaslnew(const void *init, size_t initlen) { struct sdshdr *sh; if (init) { @@ -69,21 +69,21 @@ sds sdsnew(const void *init, size_t initlen) { } /* Duplicate an sds string. */ -sds sdsdup(const sds s) { - return sdsnew(s, sdslen(s)); +sds yasldup(const sds s) { + return yaslnew(s, yasllen(s)); } /* Create an empty (zero length) sds string. Even in this case the string * always has an implicit null term. */ -sds sdsempty(void) { - return sdsnew("", 0); +sds yaslempty(void) { + return yaslnew("", 0); } /* Create an sds string from a long long value. It is much faster than: * - * sdscatprintf(sdsempty(), "%lld\n", value); + * yaslcatprintf(yaslempty(), "%lld\n", value); */ -sds sdsfromlonglong(long long value) { +sds yaslfromlonglong(long long value) { char buf[32], *p; unsigned long long v; @@ -95,7 +95,7 @@ sds sdsfromlonglong(long long value) { } while(v); if (value < 0) { *p-- = '-'; } p++; - return sdsnew(p, (size_t)(32 - (p - buf))); + return yaslnew(p, (size_t)(32 - (p - buf))); } @@ -112,12 +112,12 @@ sds sdsfromlonglong(long long value) { * If two strings share exactly the same prefix, but one of the two has * additional characters, the longer string is considered to be greater than * the smaller one. */ -int sdscmp(const sds s1, const sds s2) { +int yaslcmp(const sds s1, const sds s2) { size_t l1, l2, minlen; int cmp; - l1 = sdslen(s1); - l2 = sdslen(s2); + l1 = yasllen(s1); + l2 = yasllen(s2); minlen = (l1 < l2) ? l1 : l2; cmp = memcmp(s1, s2, minlen); if (cmp == 0) { return (int)(l1 - l2); } @@ -131,8 +131,8 @@ int sdscmp(const sds s1, const sds s2) { * However all the existing buffer is not discarded but set as free space * so that next append operations will not require allocations up to the * number of bytes previously available. */ -void sdsclear(sds s) { - struct sdshdr *sh = sdsheader(s); +void yaslclear(sds s) { + struct sdshdr *sh = yaslheader(s); sh->free += sh->len; sh->len = 0; sh->buf[0] = '\0'; @@ -143,16 +143,16 @@ void sdsclear(sds s) { * * if the specified length is smaller than the current length, no operation * is performed. */ -sds sdsgrowzero(sds s, size_t len) { - struct sdshdr *sh = sdsheader(s); +sds yaslgrowzero(sds s, size_t len) { + struct sdshdr *sh = yaslheader(s); size_t totlen, curlen = sh->len; if (len <= curlen) { return s; } - s = sdsMakeRoomFor(s, len - curlen); + s = yaslMakeRoomFor(s, len - curlen); if (s == NULL) { return NULL; } /* Make sure added region doesn't contain garbage */ - sh = sdsheader(s); + sh = yaslheader(s); memset(s + curlen, 0, (len - curlen + 1)); /* also set trailing \0 byte */ totlen = sh->len + sh->free; sh->len = len; @@ -162,14 +162,14 @@ sds sdsgrowzero(sds s, size_t len) { /* Destructively modify the sds string 's' to hold the specified binary * safe string pointed by 't' of length 'len' bytes. */ -sds sdscpylen(sds s, const char *t, size_t len) { - struct sdshdr *sh = sdsheader(s); +sds yaslcpylen(sds s, const char *t, size_t len) { + struct sdshdr *sh = yaslheader(s); size_t totlen = sh->free + sh->len; if (totlen < len) { - s = sdsMakeRoomFor(s, len - sh->len); + s = yaslMakeRoomFor(s, len - sh->len); if (s == NULL) { return NULL; } - sh = sdsheader(s); + sh = yaslheader(s); totlen = sh->free + sh->len; } memcpy(s, t, len); @@ -179,31 +179,31 @@ sds sdscpylen(sds s, const char *t, size_t len) { return s; } -/* Like sdscpylen() but 't' must be a null-termined string so that the length +/* Like yaslcpylen() but 't' must be a null-termined string so that the length * of the string is obtained with strlen(). */ -sds sdscpy(sds s, const char *t) { - return sdscpylen(s, t, strlen(t)); +sds yaslcpy(sds s, const char *t) { + return yaslcpylen(s, t, strlen(t)); } /* Join an array of C strings using the specified separator (also a C string). * Returns the result as an sds string. */ -sds sdsjoin(char **argv, int argc, char *sep, size_t seplen) { - sds join = sdsempty(); +sds yasljoin(char **argv, int argc, char *sep, size_t seplen) { + sds join = yaslempty(); for (int j = 0; j < argc; j++) { - join = sdscat(join, argv[j]); - if (j != argc - 1) { join = sdscatlen(join, sep, seplen); } + join = yaslcat(join, argv[j]); + if (j != argc - 1) { join = yaslcatlen(join, sep, seplen); } } return join; } -/* Like sdsjoin, but joins an array of SDS strings. */ -sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) { - sds join = sdsempty(); +/* Like yasljoin, but joins an array of SDS strings. */ +sds yasljoinyasl(sds *argv, int argc, const char *sep, size_t seplen) { + sds join = yaslempty(); for (int j = 0; j < argc; j++) { - join = sdscatsds(join, argv[j]); - if (j != argc - 1) { join = sdscatlen(join, sep, seplen); } + join = yaslcatyasl(join, argv[j]); + if (j != argc - 1) { join = yaslcatlen(join, sep, seplen); } } return join; } @@ -212,13 +212,13 @@ sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) { * characters specified in the 'from' string to the corresponding character * in the 'to' array. * - * For instance: sdsmapchars(mystring, "ho", "01", 2) + * For instance: yaslmapchars(mystring, "ho", "01", 2) * will have the effect of turning the string "hello" into "0ell1". * * The function returns the sds string pointer, that is always the same * as the input pointer since no resize is needed. */ -sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { - for (size_t j = 0; j < sdslen(s); j++) { +sds yaslmapchars(sds s, const char *from, const char *to, size_t setlen) { + for (size_t j = 0; j < yasllen(s); j++) { for (size_t i = 0; i < setlen; i++) { if (s[j] == from[i]) { s[j] = to[i]; @@ -242,12 +242,12 @@ sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { * * Example: * - * s = sdsauto("Hello World"); - * sdsrange(s, 1, -1); => "ello World" + * s = yaslauto("Hello World"); + * yaslrange(s, 1, -1); => "ello World" */ -void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end) { - struct sdshdr *sh = sdsheader(s); - size_t newlen, len = sdslen(s); +void yaslrange(sds s, ptrdiff_t start, ptrdiff_t end) { + struct sdshdr *sh = yaslheader(s); + size_t newlen, len = yasllen(s); if (len == 0) { return; } if (start < 0) { @@ -276,15 +276,15 @@ void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end) { } /* Apply tolower() to every character of the sds string 's'. */ -void sdstolower(sds s) { - for (size_t j = 0; j < sdslen(s); j++) { +void yasltolower(sds s) { + for (size_t j = 0; j < yasllen(s); j++) { s[j] = (char)tolower(s[j]); } } /* Apply toupper() to every character of the sds string 's'. */ -void sdstoupper(sds s) { - for (size_t j = 0; j < sdslen(s); j++) { +void yasltoupper(sds s) { + for (size_t j = 0; j < yasllen(s); j++) { s[j] = (char)toupper(s[j]); } } @@ -297,19 +297,19 @@ void sdstoupper(sds s) { * * Example: * - * s = sdsauto("AA...AA.a.aa.aHelloWorld :::"); - * s = sdstrim(s, "A. :"); + * s = yaslauto("AA...AA.a.aa.aHelloWorld :::"); + * s = yasltrim(s, "A. :"); * printf("%s\n", s); * * Output will be just "Hello World". */ -void sdstrim(sds s, const char *cset) { - struct sdshdr *sh = sdsheader(s); +void yasltrim(sds s, const char *cset) { + struct sdshdr *sh = yaslheader(s); char *start, *end, *sp, *ep; size_t len; sp = start = s; - ep = end = s + sdslen(s) - 1; + ep = end = s + yasllen(s) - 1; while(sp <= end && strchr(cset, *sp)) { sp++; } while(ep > start && strchr(cset, *ep)) { ep--; } len = (size_t)((sp > ep) ? 0 : ((ep - sp) + 1)); @@ -325,16 +325,16 @@ void sdstrim(sds s, const char *cset) { * This function is useful when the sds string is hacked manually in some * way, like in the following example: * - * s = sdsauto("foobar"); + * s = yaslauto("foobar"); * s[2] = '\0'; - * sdsupdatelen(s); - * printf("%d\n", sdslen(s)); + * yaslupdatelen(s); + * printf("%d\n", yasllen(s)); * - * The output will be "2", but if we comment out the call to sdsupdatelen() + * The output will be "2", but if we comment out the call to yaslupdatelen() * the output will be "6" as the string was modified but the logical length * remains 6 bytes. */ -void sdsupdatelen(sds s) { - struct sdshdr *sh = sdsheader(s); +void yaslupdatelen(sds s) { + struct sdshdr *sh = yaslheader(s); size_t reallen = strlen(s); sh->free += (sh->len - reallen); sh->len = reallen; @@ -349,17 +349,17 @@ void sdsupdatelen(sds s) { * of sds is returned. * * The caller should free the resulting array of sds strings with - * sdsfreesplitres(). + * yaslfreesplitres(). * - * Note that sdscatrepr() is able to convert back a string into - * a quoted string in the same format sdssplitargs() is able to parse. + * Note that yaslcatrepr() is able to convert back a string into + * a quoted string in the same format yaslsplitargs() is able to parse. * * The function returns the allocated tokens on success, even when the * input string is empty, or NULL if the input contains unbalanced * quotes or closed quotes followed by non space characters * as in: "foo"bar or "foo' */ -sds *sdssplitargs(const char *line, int *argc) { +sds *yaslsplitargs(const char *line, int *argc) { const char *p = line; char *current = NULL; char **vector = NULL; @@ -374,7 +374,7 @@ sds *sdssplitargs(const char *line, int *argc) { int insq=0; /* set to 1 if we are in 'single quotes' */ int done=0; - if (current == NULL) { current = sdsempty(); } + if (current == NULL) { current = yaslempty(); } while(!done) { if (inq) { if (*p == '\\' && *(p + 1) == 'x' && @@ -385,7 +385,7 @@ sds *sdssplitargs(const char *line, int *argc) { byte = (unsigned char)((hex_digit_to_int(*(p + 2)) * 16) + hex_digit_to_int(*(p + 3))); - current = sdscatlen(current, (char*)&byte, 1); + current = yaslcatlen(current, (char*)&byte, 1); p += 3; } else if (*p == '\\' && *(p + 1)) { char c; @@ -399,7 +399,7 @@ sds *sdssplitargs(const char *line, int *argc) { case 'a': c = '\a'; break; default: c = *p; break; } - current = sdscatlen(current, &c, 1); + current = yaslcatlen(current, &c, 1); } else if (*p == '"') { /* closing quote must be followed by a space or * nothing at all. */ @@ -409,12 +409,12 @@ sds *sdssplitargs(const char *line, int *argc) { /* unterminated quotes */ goto err; } else { - current = sdscatlen(current, p, 1); + current = yaslcatlen(current, p, 1); } } else if (insq) { if (*p == '\\' && *(p + 1) == '\'') { p++; - current = sdscatlen(current, "'", 1); + current = yaslcatlen(current, "'", 1); } else if (*p == '\'') { /* closing quote must be followed by a space or * nothing at all. */ @@ -424,7 +424,7 @@ sds *sdssplitargs(const char *line, int *argc) { /* unterminated quotes */ goto err; } else { - current = sdscatlen(current, p, 1); + current = yaslcatlen(current, p, 1); } } else { switch(*p) { @@ -442,7 +442,7 @@ sds *sdssplitargs(const char *line, int *argc) { insq=1; break; default: - current = sdscatlen(current, p, 1); + current = yaslcatlen(current, p, 1); break; } } @@ -462,10 +462,10 @@ sds *sdssplitargs(const char *line, int *argc) { err: while((*argc)--) { - sdsfree(vector[*argc]); + yaslfree(vector[*argc]); } free(vector); - if (current) { sdsfree(current); } + if (current) { yaslfree(current); } *argc = 0; return NULL; } @@ -486,7 +486,7 @@ err: * requires length arguments. sdssplit() is just the * same function but for zero-terminated strings. */ -sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { +sds *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { size_t elements = 0, slots = 5, start = 0; sds *tokens; @@ -511,7 +511,7 @@ sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size } /* search the separator */ if ((seplen == 1 && *(s + j) == sep[0]) || (memcmp(s + j, sep, seplen) == 0)) { - tokens[elements] = sdsnew(s + start, (size_t)(j - start)); + tokens[elements] = yaslnew(s + start, (size_t)(j - start)); if (tokens[elements] == NULL) { goto cleanup; } elements++; start = j + seplen; @@ -519,7 +519,7 @@ sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size } } /* Add the final element. We are sure there is room in the tokens array. */ - tokens[elements] = sdsnew(s + start, (size_t)(len - start)); + tokens[elements] = yaslnew(s + start, (size_t)(len - start)); if (tokens[elements] == NULL) { goto cleanup; } elements++; *count = elements; @@ -528,7 +528,7 @@ sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size cleanup: { for (size_t i = 0; i < elements; i++) { - sdsfree(tokens[i]); + yaslfree(tokens[i]); } free(tokens); *count = 0; @@ -542,16 +542,16 @@ cleanup: * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds sdscat(sds s, const char *t) { - return sdscatlen(s, t, strlen(t)); +sds yaslcat(sds s, const char *t) { + return yaslcatlen(s, t, strlen(t)); } /* Append the specified sds 't' to the existing sds 's'. * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds sdscatsds(sds s, const sds t) { - return sdscatlen(s, t, sdslen(t)); +sds yaslcatyasl(sds s, const sds t) { + return yaslcatlen(s, t, yasllen(t)); } /* Append the specified binary-safe string pointed by 't' of 'len' bytes to the @@ -559,13 +559,13 @@ sds sdscatsds(sds s, const sds t) { * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds sdscatlen(sds s, const void *t, size_t len) { +sds yaslcatlen(sds s, const void *t, size_t len) { struct sdshdr *sh; - size_t curlen = sdslen(s); + size_t curlen = yasllen(s); - s = sdsMakeRoomFor(s, len); + s = yaslMakeRoomFor(s, len); if (s == NULL) { return NULL; } - sh = sdsheader(s); + sh = yaslheader(s); memcpy(s + curlen, t, len); sh->len = curlen + len; sh->free = sh->free - len; @@ -579,35 +579,35 @@ sds sdscatlen(sds s, const void *t, size_t len) { * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds sdscatrepr(sds s, const char *p, size_t len) { - s = sdscatlen(s, "\"", 1); +sds yaslcatrepr(sds s, const char *p, size_t len) { + s = yaslcatlen(s, "\"", 1); while(len--) { switch(*p) { case '\\': case '"': - s = sdscatprintf(s, "\\%c", *p); + s = yaslcatprintf(s, "\\%c", *p); break; - case '\n': s = sdscatlen(s, "\\n", 2); break; - case '\r': s = sdscatlen(s, "\\r", 2); break; - case '\t': s = sdscatlen(s, "\\t", 2); break; - case '\a': s = sdscatlen(s, "\\a", 2); break; - case '\b': s = sdscatlen(s, "\\b", 2); break; + case '\n': s = yaslcatlen(s, "\\n", 2); break; + case '\r': s = yaslcatlen(s, "\\r", 2); break; + case '\t': s = yaslcatlen(s, "\\t", 2); break; + case '\a': s = yaslcatlen(s, "\\a", 2); break; + case '\b': s = yaslcatlen(s, "\\b", 2); break; default: if (isprint(*p)) { - s = sdscatprintf(s, "%c", *p); + s = yaslcatprintf(s, "%c", *p); } else { - s = sdscatprintf(s, "\\x%02x", (unsigned char)*p); + s = yaslcatprintf(s, "\\x%02x", (unsigned char)*p); break; } } p++; } - return sdscatlen(s, "\"", 1); + return yaslcatlen(s, "\"", 1); } -/* Like sdscatpritf() but gets va_list instead of being variadic. */ +/* Like yaslcatpritf() but gets va_list instead of being variadic. */ #pragma GCC diagnostic ignored "-Wformat-nonliteral" -sds sdscatvprintf(sds s, const char *fmt, va_list ap) { +sds yaslcatvprintf(sds s, const char *fmt, va_list ap) { va_list cpy; char *buf, *t; size_t buflen = 16; @@ -625,7 +625,7 @@ sds sdscatvprintf(sds s, const char *fmt, va_list ap) { } break; } - t = sdscat(s, buf); + t = yaslcat(s, buf); free(buf); return t; } @@ -639,19 +639,19 @@ sds sdscatvprintf(sds s, const char *fmt, va_list ap) { * * Example: * - * s = sdsempty("Sum is: "); - * s = sdscatprintf(s, "%d + %d = %d", a, b, a + b). + * s = yaslempty("Sum is: "); + * s = yaslcatprintf(s, "%d + %d = %d", a, b, a + b). * * Often you need to create a string from scratch with the printf-alike - * format. When this is the need, just use sdsempty() as the target string: + * format. When this is the need, just use yaslempty() as the target string: * - * s = sdscatprintf(sdsempty(), "... your format ...", args); + * s = yaslcatprintf(yaslempty(), "... your format ...", args); */ -sds sdscatprintf(sds s, const char *fmt, ...) { +sds yaslcatprintf(sds s, const char *fmt, ...) { va_list ap; char *t; va_start(ap, fmt); - t = sdscatvprintf(s, fmt, ap); + t = yaslcatvprintf(s, fmt, ap); va_end(ap); return t; } @@ -660,16 +660,16 @@ sds sdscatprintf(sds s, const char *fmt, ...) { /// Freeing /* Free an sds string. No operation is performed if 's' is NULL. */ -void sdsfree(sds s) { +void yaslfree(sds s) { if (s == NULL) { return; } - free(sdsheader(s)); + free(yaslheader(s)); } -/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */ -void sdsfreesplitres(sds *tokens, size_t count) { +/* Free the result returned by yaslsplitlen(), or do nothing if 'tokens' is NULL. */ +void yaslfreesplitres(sds *tokens, size_t count) { if (!tokens) { return; } while(count--) { - sdsfree(tokens[count]); + yaslfree(tokens[count]); } free(tokens); } @@ -684,8 +684,8 @@ void sdsfreesplitres(sds *tokens, size_t count) { * 3) The free buffer at the end if any. * 4) The implicit null term. */ -size_t sdsAllocSize(sds s) { - struct sdshdr *sh = sdsheader(s); +size_t yaslAllocSize(sds s) { + struct sdshdr *sh = yaslheader(s); return sizeof(*sh) + sh->len + sh->free + 1; } @@ -695,23 +695,23 @@ size_t sdsAllocSize(sds s) { * in the new end of the string. * * This function is used in order to fix the string length after the - * user calls sdsMakeRoomFor(), writes something after the end of + * user calls yaslMakeRoomFor(), writes something after the end of * the current string, and finally needs to set the new length. * * Usage example: * - * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the + * Using yaslIncrLen() and yaslMakeRoomFor() it is possible to mount the * following schema, to cat bytes coming from the kernel to the end of an * sds string without copying into an intermediate buffer: * - * oldlen = sdslen(s); - * s = sdsMakeRoomFor(s, BUFFER_SIZE); + * oldlen = yasllen(s); + * s = yaslMakeRoomFor(s, BUFFER_SIZE); * nread = read(fd, s + oldlen, BUFFER_SIZE); * ... check for nread <= 0 and handle it ... - * sdsIncrLen(s, nread); + * yaslIncrLen(s, nread); */ -void sdsIncrLen(sds s, size_t incr) { - struct sdshdr *sh = sdsheader(s); +void yaslIncrLen(sds s, size_t incr) { + struct sdshdr *sh = yaslheader(s); assert(sh->free >= incr); sh->len += incr; @@ -724,15 +724,15 @@ void sdsIncrLen(sds s, size_t incr) { * bytes after the end of the string, plus one more byte for nul term. * * Note: this does not change the *length* of the sds string as returned - * by sdslen(), but only the free buffer space we have. */ -sds sdsMakeRoomFor(sds s, size_t addlen) { + * by yasllen(), but only the free buffer space we have. */ +sds yaslMakeRoomFor(sds s, size_t addlen) { struct sdshdr *sh, *newsh; - size_t free = sdsavail(s); + size_t free = yaslavail(s); size_t len, newlen; if (free >= addlen) { return s; } - len = sdslen(s); - sh = sdsheader(s); + len = yasllen(s); + sh = yaslheader(s); newlen = (len + addlen); if (newlen < SDS_MAX_PREALLOC) { newlen *= 2; @@ -752,10 +752,10 @@ sds sdsMakeRoomFor(sds s, size_t addlen) { * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds sdsRemoveFreeSpace(sds s) { +sds yaslRemoveFreeSpace(sds s) { struct sdshdr *sh; - sh = sdsheader(s); + sh = yaslheader(s); sh = realloc(sh, sizeof(struct sdshdr) + sh->len + 1); sh->free = 0; return sh->buf; @@ -764,14 +764,14 @@ sds sdsRemoveFreeSpace(sds s) { /// Low-level helper functions -/* Helper function for sdssplitargs() that returns non zero if 'c' +/* Helper function for yaslsplitargs() that returns non zero if 'c' * is a valid hex digit. */ int is_hex_digit(char c) { return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); } -/* Helper function for sdssplitargs() that converts a hex digit into an +/* Helper function for yaslsplitargs() that converts a hex digit into an * integer from 0 to 15 */ int hex_digit_to_int(char c) { switch(c) { diff --git a/src/yasl.h b/src/yasl.h index 6b3a951..8906ee9 100644 --- a/src/yasl.h +++ b/src/yasl.h @@ -48,56 +48,56 @@ struct sdshdr { */ /// Initialization -sds sdsnew(const void *init, size_t initlen); -sds sdsdup(const sds s); -sds sdsempty(void); -sds sdsfromlonglong(long long value); +sds yaslnew(const void *init, size_t initlen); +sds yasldup(const sds s); +sds yaslempty(void); +sds yaslfromlonglong(long long value); /// Querying -int sdscmp(const sds s1, const sds s2); +int yaslcmp(const sds s1, const sds s2); /// Modification -void sdsclear(sds s); -sds sdsgrowzero(sds s, size_t len); -sds sdscpylen(sds s, const char *t, size_t len); -sds sdscpy(sds s, const char *t); -sds sdsjoin(char **argv, int argc, char *sep, size_t seplen); -sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen); -sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen); -void sdsrange(sds s, ptrdiff_t start, ptrdiff_t end); -void sdstolower(sds s); -void sdstoupper(sds s); -void sdstrim(sds s, const char *cset); -void sdsupdatelen(sds s); -sds *sdssplitargs(const char *line, int *argc); -sds *sdssplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count); +void yaslclear(sds s); +sds yaslgrowzero(sds s, size_t len); +sds yaslcpylen(sds s, const char *t, size_t len); +sds yaslcpy(sds s, const char *t); +sds yasljoin(char **argv, int argc, char *sep, size_t seplen); +sds yasljoinyasl(sds *argv, int argc, const char *sep, size_t seplen); +sds yaslmapchars(sds s, const char *from, const char *to, size_t setlen); +void yaslrange(sds s, ptrdiff_t start, ptrdiff_t end); +void yasltolower(sds s); +void yasltoupper(sds s); +void yasltrim(sds s, const char *cset); +void yaslupdatelen(sds s); +sds *yaslsplitargs(const char *line, int *argc); +sds *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count); // Concatenation -sds sdscat(sds s, const char *t); -sds sdscatsds(sds s, const sds t); -sds sdscatlen(sds s, const void *t, size_t len); -sds sdscatrepr(sds s, const char *p, size_t len); -sds sdscatvprintf(sds s, const char *fmt, va_list ap); +sds yaslcat(sds s, const char *t); +sds yaslcatyasl(sds s, const sds t); +sds yaslcatlen(sds s, const void *t, size_t len); +sds yaslcatrepr(sds s, const char *p, size_t len); +sds yaslcatvprintf(sds s, const char *fmt, va_list ap); #ifdef __GNUC__ -sds sdscatprintf(sds s, const char *fmt, ...) +sds yaslcatprintf(sds s, const char *fmt, ...) __attribute__((format(printf, 2, 3))); #else -sds sdscatprintf(sds s, const char *fmt, ...); +sds yaslcatprintf(sds s, const char *fmt, ...); #endif /// Freeing -void sdsfree(sds s); -void sdsfreesplitres(sds *tokens, size_t count); +void yaslfree(sds s); +void yaslfreesplitres(sds *tokens, size_t count); /// Low-level API function prototypes -size_t sdsAllocSize(sds s); -void sdsIncrLen(sds s, size_t incr); -sds sdsMakeRoomFor(sds s, size_t addlen); -sds sdsRemoveFreeSpace(sds s); +size_t yaslAllocSize(sds s); +void yaslIncrLen(sds s, size_t incr); +sds yaslMakeRoomFor(sds s, size_t addlen); +sds yaslRemoveFreeSpace(sds s); /// Low-level helper functions @@ -109,22 +109,22 @@ int hex_digit_to_int(char c); * Inline functions */ -static inline struct sdshdr *sdsheader(const sds s) { +static inline struct sdshdr *yaslheader(const sds s) { /* The sdshdr pointer has a different alignment than the original char * pointer, so cast it through a void pointer to silence the warning. */ return (void *)(s - (sizeof (struct sdshdr))); } -static inline sds sdsauto(const char *s) { - return sdsnew(s, s ? strlen(s) : 0); +static inline sds yaslauto(const char *s) { + return yaslnew(s, s ? strlen(s) : 0); } -static inline size_t sdsavail(const sds s) { - return sdsheader(s)->free; +static inline size_t yaslavail(const sds s) { + return yaslheader(s)->free; } -static inline size_t sdslen(const sds s) { - return sdsheader(s)->len; +static inline size_t yasllen(const sds s) { + return yaslheader(s)->len; } -- cgit v1.2.3-54-g00ecf From 44333a7d92936dcac9c94fdb4ae4026a3dea0ba8 Mon Sep 17 00:00:00 2001 From: Johannes Löthberg Date: Tue, 20 Jan 2015 13:36:07 +0100 Subject: Rename sdshdr → yastrhdr MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/yasl.c | 32 ++++++++++++++++---------------- src/yasl.h | 8 ++++---- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/yasl.c b/src/yasl.c index 931a0ee..a878908 100644 --- a/src/yasl.c +++ b/src/yasl.c @@ -50,12 +50,12 @@ * end of the string. However the string is binary safe and can contain * \0 characters in the middle, as the length is stored in the sds header. */ sds yaslnew(const void *init, size_t initlen) { - struct sdshdr *sh; + struct yastrhdr *sh; if (init) { - sh = malloc(sizeof(struct sdshdr) + initlen + 1); + sh = malloc(sizeof(struct yastrhdr) + initlen + 1); } else { - sh = calloc(sizeof(struct sdshdr) + initlen + 1, 1); + sh = calloc(sizeof(struct yastrhdr) + initlen + 1, 1); } if (sh == NULL) { return NULL; } @@ -132,7 +132,7 @@ int yaslcmp(const sds s1, const sds s2) { * so that next append operations will not require allocations up to the * number of bytes previously available. */ void yaslclear(sds s) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); sh->free += sh->len; sh->len = 0; sh->buf[0] = '\0'; @@ -144,7 +144,7 @@ void yaslclear(sds s) { * if the specified length is smaller than the current length, no operation * is performed. */ sds yaslgrowzero(sds s, size_t len) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); size_t totlen, curlen = sh->len; if (len <= curlen) { return s; } @@ -163,7 +163,7 @@ sds yaslgrowzero(sds s, size_t len) { /* Destructively modify the sds string 's' to hold the specified binary * safe string pointed by 't' of length 'len' bytes. */ sds yaslcpylen(sds s, const char *t, size_t len) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); size_t totlen = sh->free + sh->len; if (totlen < len) { @@ -246,7 +246,7 @@ sds yaslmapchars(sds s, const char *from, const char *to, size_t setlen) { * yaslrange(s, 1, -1); => "ello World" */ void yaslrange(sds s, ptrdiff_t start, ptrdiff_t end) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); size_t newlen, len = yasllen(s); if (len == 0) { return; } @@ -304,7 +304,7 @@ void yasltoupper(sds s) { * Output will be just "Hello World". */ void yasltrim(sds s, const char *cset) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); char *start, *end, *sp, *ep; size_t len; @@ -334,7 +334,7 @@ void yasltrim(sds s, const char *cset) { * the output will be "6" as the string was modified but the logical length * remains 6 bytes. */ void yaslupdatelen(sds s) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); size_t reallen = strlen(s); sh->free += (sh->len - reallen); sh->len = reallen; @@ -560,7 +560,7 @@ sds yaslcatyasl(sds s, const sds t) { * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ sds yaslcatlen(sds s, const void *t, size_t len) { - struct sdshdr *sh; + struct yastrhdr *sh; size_t curlen = yasllen(s); s = yaslMakeRoomFor(s, len); @@ -685,7 +685,7 @@ void yaslfreesplitres(sds *tokens, size_t count) { * 4) The implicit null term. */ size_t yaslAllocSize(sds s) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); return sizeof(*sh) + sh->len + sh->free + 1; } @@ -711,7 +711,7 @@ size_t yaslAllocSize(sds s) { * yaslIncrLen(s, nread); */ void yaslIncrLen(sds s, size_t incr) { - struct sdshdr *sh = yaslheader(s); + struct yastrhdr *sh = yaslheader(s); assert(sh->free >= incr); sh->len += incr; @@ -726,7 +726,7 @@ void yaslIncrLen(sds s, size_t incr) { * Note: this does not change the *length* of the sds string as returned * by yasllen(), but only the free buffer space we have. */ sds yaslMakeRoomFor(sds s, size_t addlen) { - struct sdshdr *sh, *newsh; + struct yastrhdr *sh, *newsh; size_t free = yaslavail(s); size_t len, newlen; @@ -739,7 +739,7 @@ sds yaslMakeRoomFor(sds s, size_t addlen) { } else { newlen += SDS_MAX_PREALLOC; } - newsh = realloc(sh, sizeof(struct sdshdr) + newlen + 1); + newsh = realloc(sh, sizeof(struct yastrhdr) + newlen + 1); if (newsh == NULL) { return NULL; } newsh->free = newlen - len; @@ -753,10 +753,10 @@ sds yaslMakeRoomFor(sds s, size_t addlen) { * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ sds yaslRemoveFreeSpace(sds s) { - struct sdshdr *sh; + struct yastrhdr *sh; sh = yaslheader(s); - sh = realloc(sh, sizeof(struct sdshdr) + sh->len + 1); + sh = realloc(sh, sizeof(struct yastrhdr) + sh->len + 1); sh->free = 0; return sh->buf; } diff --git a/src/yasl.h b/src/yasl.h index 8906ee9..9de5df4 100644 --- a/src/yasl.h +++ b/src/yasl.h @@ -36,7 +36,7 @@ typedef char *sds; -struct sdshdr { +struct yastrhdr { size_t len; size_t free; char buf[]; @@ -109,10 +109,10 @@ int hex_digit_to_int(char c); * Inline functions */ -static inline struct sdshdr *yaslheader(const sds s) { - /* The sdshdr pointer has a different alignment than the original char +static inline struct yastrhdr *yaslheader(const sds s) { + /* The yastrhdr pointer has a different alignment than the original char * pointer, so cast it through a void pointer to silence the warning. */ - return (void *)(s - (sizeof (struct sdshdr))); + return (void *)(s - (sizeof (struct yastrhdr))); } static inline sds yaslauto(const char *s) { -- cgit v1.2.3-54-g00ecf From ef10accb453946b27ea89a3bc53a31b1a0f562bf Mon Sep 17 00:00:00 2001 From: Johannes Löthberg Date: Tue, 20 Jan 2015 13:59:17 +0100 Subject: Rename sds typedef to yastr --- src/yasl.c | 74 +++++++++++++++++++++++++++++++------------------------------- src/yasl.h | 74 +++++++++++++++++++++++++++++++------------------------------- 2 files changed, 74 insertions(+), 74 deletions(-) diff --git a/src/yasl.c b/src/yasl.c index a878908..c6ffc29 100644 --- a/src/yasl.c +++ b/src/yasl.c @@ -49,7 +49,7 @@ * You can print the string with printf() as there is an implicit \0 at the * end of the string. However the string is binary safe and can contain * \0 characters in the middle, as the length is stored in the sds header. */ -sds yaslnew(const void *init, size_t initlen) { +yastr yaslnew(const void *init, size_t initlen) { struct yastrhdr *sh; if (init) { @@ -69,13 +69,13 @@ sds yaslnew(const void *init, size_t initlen) { } /* Duplicate an sds string. */ -sds yasldup(const sds s) { +yastr yasldup(const yastr s) { return yaslnew(s, yasllen(s)); } /* Create an empty (zero length) sds string. Even in this case the string * always has an implicit null term. */ -sds yaslempty(void) { +yastr yaslempty(void) { return yaslnew("", 0); } @@ -83,7 +83,7 @@ sds yaslempty(void) { * * yaslcatprintf(yaslempty(), "%lld\n", value); */ -sds yaslfromlonglong(long long value) { +yastr yaslfromlonglong(long long value) { char buf[32], *p; unsigned long long v; @@ -112,7 +112,7 @@ sds yaslfromlonglong(long long value) { * If two strings share exactly the same prefix, but one of the two has * additional characters, the longer string is considered to be greater than * the smaller one. */ -int yaslcmp(const sds s1, const sds s2) { +int yaslcmp(const yastr s1, const yastr s2) { size_t l1, l2, minlen; int cmp; @@ -131,7 +131,7 @@ int yaslcmp(const sds s1, const sds s2) { * However all the existing buffer is not discarded but set as free space * so that next append operations will not require allocations up to the * number of bytes previously available. */ -void yaslclear(sds s) { +void yaslclear(yastr s) { struct yastrhdr *sh = yaslheader(s); sh->free += sh->len; sh->len = 0; @@ -143,7 +143,7 @@ void yaslclear(sds s) { * * if the specified length is smaller than the current length, no operation * is performed. */ -sds yaslgrowzero(sds s, size_t len) { +yastr yaslgrowzero(yastr s, size_t len) { struct yastrhdr *sh = yaslheader(s); size_t totlen, curlen = sh->len; @@ -162,7 +162,7 @@ sds yaslgrowzero(sds s, size_t len) { /* Destructively modify the sds string 's' to hold the specified binary * safe string pointed by 't' of length 'len' bytes. */ -sds yaslcpylen(sds s, const char *t, size_t len) { +yastr yaslcpylen(yastr s, const char *t, size_t len) { struct yastrhdr *sh = yaslheader(s); size_t totlen = sh->free + sh->len; @@ -181,14 +181,14 @@ sds yaslcpylen(sds s, const char *t, size_t len) { /* Like yaslcpylen() but 't' must be a null-termined string so that the length * of the string is obtained with strlen(). */ -sds yaslcpy(sds s, const char *t) { +yastr yaslcpy(yastr s, const char *t) { return yaslcpylen(s, t, strlen(t)); } /* Join an array of C strings using the specified separator (also a C string). * Returns the result as an sds string. */ -sds yasljoin(char **argv, int argc, char *sep, size_t seplen) { - sds join = yaslempty(); +yastr yasljoin(char **argv, int argc, char *sep, size_t seplen) { + yastr join = yaslempty(); for (int j = 0; j < argc; j++) { join = yaslcat(join, argv[j]); @@ -198,8 +198,8 @@ sds yasljoin(char **argv, int argc, char *sep, size_t seplen) { } /* Like yasljoin, but joins an array of SDS strings. */ -sds yasljoinyasl(sds *argv, int argc, const char *sep, size_t seplen) { - sds join = yaslempty(); +yastr yasljoinyasl(yastr *argv, int argc, const char *sep, size_t seplen) { + yastr join = yaslempty(); for (int j = 0; j < argc; j++) { join = yaslcatyasl(join, argv[j]); @@ -217,7 +217,7 @@ sds yasljoinyasl(sds *argv, int argc, const char *sep, size_t seplen) { * * The function returns the sds string pointer, that is always the same * as the input pointer since no resize is needed. */ -sds yaslmapchars(sds s, const char *from, const char *to, size_t setlen) { +yastr yaslmapchars(yastr s, const char *from, const char *to, size_t setlen) { for (size_t j = 0; j < yasllen(s); j++) { for (size_t i = 0; i < setlen; i++) { if (s[j] == from[i]) { @@ -245,7 +245,7 @@ sds yaslmapchars(sds s, const char *from, const char *to, size_t setlen) { * s = yaslauto("Hello World"); * yaslrange(s, 1, -1); => "ello World" */ -void yaslrange(sds s, ptrdiff_t start, ptrdiff_t end) { +void yaslrange(yastr s, ptrdiff_t start, ptrdiff_t end) { struct yastrhdr *sh = yaslheader(s); size_t newlen, len = yasllen(s); @@ -276,14 +276,14 @@ void yaslrange(sds s, ptrdiff_t start, ptrdiff_t end) { } /* Apply tolower() to every character of the sds string 's'. */ -void yasltolower(sds s) { +void yasltolower(yastr s) { for (size_t j = 0; j < yasllen(s); j++) { s[j] = (char)tolower(s[j]); } } /* Apply toupper() to every character of the sds string 's'. */ -void yasltoupper(sds s) { +void yasltoupper(yastr s) { for (size_t j = 0; j < yasllen(s); j++) { s[j] = (char)toupper(s[j]); } @@ -303,7 +303,7 @@ void yasltoupper(sds s) { * * Output will be just "Hello World". */ -void yasltrim(sds s, const char *cset) { +void yasltrim(yastr s, const char *cset) { struct yastrhdr *sh = yaslheader(s); char *start, *end, *sp, *ep; size_t len; @@ -333,7 +333,7 @@ void yasltrim(sds s, const char *cset) { * The output will be "2", but if we comment out the call to yaslupdatelen() * the output will be "6" as the string was modified but the logical length * remains 6 bytes. */ -void yaslupdatelen(sds s) { +void yaslupdatelen(yastr s) { struct yastrhdr *sh = yaslheader(s); size_t reallen = strlen(s); sh->free += (sh->len - reallen); @@ -359,7 +359,7 @@ void yaslupdatelen(sds s) { * quotes or closed quotes followed by non space characters * as in: "foo"bar or "foo' */ -sds *yaslsplitargs(const char *line, int *argc) { +yastr *yaslsplitargs(const char *line, int *argc) { const char *p = line; char *current = NULL; char **vector = NULL; @@ -486,13 +486,13 @@ err: * requires length arguments. sdssplit() is just the * same function but for zero-terminated strings. */ -sds *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { +yastr *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { size_t elements = 0, slots = 5, start = 0; - sds *tokens; + yastr *tokens; if (seplen < 1) { return NULL; } - tokens = malloc(sizeof(sds)*slots); + tokens = malloc(sizeof(yastr)*slots); if (tokens == NULL) { return NULL; } if (len == 0) { @@ -502,10 +502,10 @@ sds *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, siz for (size_t j = 0; j < (len - (seplen - 1)); j++) { /* make sure there is room for the next element and the final one */ if (slots < elements + 2) { - sds *newtokens; + yastr *newtokens; slots *= 2; - newtokens = realloc(tokens, sizeof(sds) * slots); + newtokens = realloc(tokens, sizeof(yastr) * slots); if (newtokens == NULL) { goto cleanup; } tokens = newtokens; } @@ -542,7 +542,7 @@ cleanup: * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds yaslcat(sds s, const char *t) { +yastr yaslcat(yastr s, const char *t) { return yaslcatlen(s, t, strlen(t)); } @@ -550,7 +550,7 @@ sds yaslcat(sds s, const char *t) { * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds yaslcatyasl(sds s, const sds t) { +yastr yaslcatyasl(yastr s, const yastr t) { return yaslcatlen(s, t, yasllen(t)); } @@ -559,7 +559,7 @@ sds yaslcatyasl(sds s, const sds t) { * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds yaslcatlen(sds s, const void *t, size_t len) { +yastr yaslcatlen(yastr s, const void *t, size_t len) { struct yastrhdr *sh; size_t curlen = yasllen(s); @@ -579,7 +579,7 @@ sds yaslcatlen(sds s, const void *t, size_t len) { * * After the call, the modified sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds yaslcatrepr(sds s, const char *p, size_t len) { +yastr yaslcatrepr(yastr s, const char *p, size_t len) { s = yaslcatlen(s, "\"", 1); while(len--) { switch(*p) { @@ -607,7 +607,7 @@ sds yaslcatrepr(sds s, const char *p, size_t len) { /* Like yaslcatpritf() but gets va_list instead of being variadic. */ #pragma GCC diagnostic ignored "-Wformat-nonliteral" -sds yaslcatvprintf(sds s, const char *fmt, va_list ap) { +yastr yaslcatvprintf(yastr s, const char *fmt, va_list ap) { va_list cpy; char *buf, *t; size_t buflen = 16; @@ -647,7 +647,7 @@ sds yaslcatvprintf(sds s, const char *fmt, va_list ap) { * * s = yaslcatprintf(yaslempty(), "... your format ...", args); */ -sds yaslcatprintf(sds s, const char *fmt, ...) { +yastr yaslcatprintf(yastr s, const char *fmt, ...) { va_list ap; char *t; va_start(ap, fmt); @@ -660,13 +660,13 @@ sds yaslcatprintf(sds s, const char *fmt, ...) { /// Freeing /* Free an sds string. No operation is performed if 's' is NULL. */ -void yaslfree(sds s) { +void yaslfree(yastr s) { if (s == NULL) { return; } free(yaslheader(s)); } /* Free the result returned by yaslsplitlen(), or do nothing if 'tokens' is NULL. */ -void yaslfreesplitres(sds *tokens, size_t count) { +void yaslfreesplitres(yastr *tokens, size_t count) { if (!tokens) { return; } while(count--) { yaslfree(tokens[count]); @@ -684,7 +684,7 @@ void yaslfreesplitres(sds *tokens, size_t count) { * 3) The free buffer at the end if any. * 4) The implicit null term. */ -size_t yaslAllocSize(sds s) { +size_t yaslAllocSize(yastr s) { struct yastrhdr *sh = yaslheader(s); return sizeof(*sh) + sh->len + sh->free + 1; @@ -710,7 +710,7 @@ size_t yaslAllocSize(sds s) { * ... check for nread <= 0 and handle it ... * yaslIncrLen(s, nread); */ -void yaslIncrLen(sds s, size_t incr) { +void yaslIncrLen(yastr s, size_t incr) { struct yastrhdr *sh = yaslheader(s); assert(sh->free >= incr); @@ -725,7 +725,7 @@ void yaslIncrLen(sds s, size_t incr) { * * Note: this does not change the *length* of the sds string as returned * by yasllen(), but only the free buffer space we have. */ -sds yaslMakeRoomFor(sds s, size_t addlen) { +yastr yaslMakeRoomFor(yastr s, size_t addlen) { struct yastrhdr *sh, *newsh; size_t free = yaslavail(s); size_t len, newlen; @@ -752,7 +752,7 @@ sds yaslMakeRoomFor(sds s, size_t addlen) { * * After the call, the passed sds string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ -sds yaslRemoveFreeSpace(sds s) { +yastr yaslRemoveFreeSpace(yastr s) { struct yastrhdr *sh; sh = yaslheader(s); diff --git a/src/yasl.h b/src/yasl.h index 9de5df4..965000b 100644 --- a/src/yasl.h +++ b/src/yasl.h @@ -34,7 +34,7 @@ #include #include -typedef char *sds; +typedef char *yastr; struct yastrhdr { size_t len; @@ -48,56 +48,56 @@ struct yastrhdr { */ /// Initialization -sds yaslnew(const void *init, size_t initlen); -sds yasldup(const sds s); -sds yaslempty(void); -sds yaslfromlonglong(long long value); +yastr yaslnew(const void *init, size_t initlen); +yastr yasldup(const yastr s); +yastr yaslempty(void); +yastr yaslfromlonglong(long long value); /// Querying -int yaslcmp(const sds s1, const sds s2); +int yaslcmp(const yastr s1, const yastr s2); /// Modification -void yaslclear(sds s); -sds yaslgrowzero(sds s, size_t len); -sds yaslcpylen(sds s, const char *t, size_t len); -sds yaslcpy(sds s, const char *t); -sds yasljoin(char **argv, int argc, char *sep, size_t seplen); -sds yasljoinyasl(sds *argv, int argc, const char *sep, size_t seplen); -sds yaslmapchars(sds s, const char *from, const char *to, size_t setlen); -void yaslrange(sds s, ptrdiff_t start, ptrdiff_t end); -void yasltolower(sds s); -void yasltoupper(sds s); -void yasltrim(sds s, const char *cset); -void yaslupdatelen(sds s); -sds *yaslsplitargs(const char *line, int *argc); -sds *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count); +void yaslclear(yastr s); +yastr yaslgrowzero(yastr s, size_t len); +yastr yaslcpylen(yastr s, const char *t, size_t len); +yastr yaslcpy(yastr s, const char *t); +yastr yasljoin(char **argv, int argc, char *sep, size_t seplen); +yastr yasljoinyasl(yastr *argv, int argc, const char *sep, size_t seplen); +yastr yaslmapchars(yastr s, const char *from, const char *to, size_t setlen); +void yaslrange(yastr s, ptrdiff_t start, ptrdiff_t end); +void yasltolower(yastr s); +void yasltoupper(yastr s); +void yasltrim(yastr s, const char *cset); +void yaslupdatelen(yastr s); +yastr *yaslsplitargs(const char *line, int *argc); +yastr *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count); // Concatenation -sds yaslcat(sds s, const char *t); -sds yaslcatyasl(sds s, const sds t); -sds yaslcatlen(sds s, const void *t, size_t len); -sds yaslcatrepr(sds s, const char *p, size_t len); -sds yaslcatvprintf(sds s, const char *fmt, va_list ap); +yastr yaslcat(yastr s, const char *t); +yastr yaslcatyasl(yastr s, const yastr t); +yastr yaslcatlen(yastr s, const void *t, size_t len); +yastr yaslcatrepr(yastr s, const char *p, size_t len); +yastr yaslcatvprintf(yastr s, const char *fmt, va_list ap); #ifdef __GNUC__ -sds yaslcatprintf(sds s, const char *fmt, ...) +yastr yaslcatprintf(yastr s, const char *fmt, ...) __attribute__((format(printf, 2, 3))); #else -sds yaslcatprintf(sds s, const char *fmt, ...); +yastr yaslcatprintf(yastr s, const char *fmt, ...); #endif /// Freeing -void yaslfree(sds s); -void yaslfreesplitres(sds *tokens, size_t count); +void yaslfree(yastr s); +void yaslfreesplitres(yastr *tokens, size_t count); /// Low-level API function prototypes -size_t yaslAllocSize(sds s); -void yaslIncrLen(sds s, size_t incr); -sds yaslMakeRoomFor(sds s, size_t addlen); -sds yaslRemoveFreeSpace(sds s); +size_t yaslAllocSize(yastr s); +void yaslIncrLen(yastr s, size_t incr); +yastr yaslMakeRoomFor(yastr s, size_t addlen); +yastr yaslRemoveFreeSpace(yastr s); /// Low-level helper functions @@ -109,21 +109,21 @@ int hex_digit_to_int(char c); * Inline functions */ -static inline struct yastrhdr *yaslheader(const sds s) { +static inline struct yastrhdr *yaslheader(const yastr s) { /* The yastrhdr pointer has a different alignment than the original char * pointer, so cast it through a void pointer to silence the warning. */ return (void *)(s - (sizeof (struct yastrhdr))); } -static inline sds yaslauto(const char *s) { +static inline yastr yaslauto(const char *s) { return yaslnew(s, s ? strlen(s) : 0); } -static inline size_t yaslavail(const sds s) { +static inline size_t yaslavail(const yastr s) { return yaslheader(s)->free; } -static inline size_t yasllen(const sds s) { +static inline size_t yasllen(const yastr s) { return yaslheader(s)->len; } -- cgit v1.2.3-54-g00ecf From f62a96be23d7f24fd8d788aa857fc0206c36a6a5 Mon Sep 17 00:00:00 2001 From: Johannes Löthberg Date: Tue, 20 Jan 2015 14:08:04 +0100 Subject: Update all comments to refer to yasl --- src/yasl.c | 100 ++++++++++++++++++++++++++++++------------------------------- src/yasl.h | 8 ++--- 2 files changed, 54 insertions(+), 54 deletions(-) diff --git a/src/yasl.c b/src/yasl.c index c6ffc29..265e86c 100644 --- a/src/yasl.c +++ b/src/yasl.c @@ -1,4 +1,4 @@ -/* SDS (Simple Dynamic Strings), A C dynamic strings library. +/* yasl, Yet Another String Library for C * * Copyright (c) 2006-2014, Salvatore Sanfilippo * All rights reserved. @@ -37,18 +37,18 @@ /// Initialization -/* Create a new sds string with the content specified by the 'init' pointer +/* Create a new yasl string with the content specified by the 'init' pointer * and 'initlen'. * If NULL is used for 'init' the string is initialized with zero bytes. * - * The string is always null-termined (all the sds strings are, always) so - * even if you create an sds string with: + * The string is always null-termined (all the yasl strings are, always) so + * even if you create a yasl string with: * * mystring = yaslnew("abc", 3"); * * You can print the string with printf() as there is an implicit \0 at the * end of the string. However the string is binary safe and can contain - * \0 characters in the middle, as the length is stored in the sds header. */ + * \0 characters in the middle, as the length is stored in the yasl header. */ yastr yaslnew(const void *init, size_t initlen) { struct yastrhdr *sh; @@ -68,18 +68,18 @@ yastr yaslnew(const void *init, size_t initlen) { return (char*)sh->buf; } -/* Duplicate an sds string. */ +/* Duplicate a yasl string. */ yastr yasldup(const yastr s) { return yaslnew(s, yasllen(s)); } -/* Create an empty (zero length) sds string. Even in this case the string +/* Create an empty (zero length) yasl string. Even in this case the string * always has an implicit null term. */ yastr yaslempty(void) { return yaslnew("", 0); } -/* Create an sds string from a long long value. It is much faster than: +/* Create a yasl string from a long long value. It is much faster than: * * yaslcatprintf(yaslempty(), "%lld\n", value); */ @@ -101,7 +101,7 @@ yastr yaslfromlonglong(long long value) { /// Querying -/* Compare two sds strings s1 and s2 with memcmp(). +/* Compare two yasl strings s1 and s2 with memcmp(). * * Return value: * @@ -127,7 +127,7 @@ int yaslcmp(const yastr s1, const yastr s2) { /// Modification -/* Modify an sds string on-place to make it empty (zero length). +/* Modify a yasl string in-place to make it empty (zero length). * However all the existing buffer is not discarded but set as free space * so that next append operations will not require allocations up to the * number of bytes previously available. */ @@ -138,8 +138,8 @@ void yaslclear(yastr s) { sh->buf[0] = '\0'; } -/* Grow the sds to have the specified length. Bytes that were not part of - * the original length of the sds will be set to zero. +/* Grow the yasl string to have the specified length. Bytes that were not part + * of the original length of the yasl string will be set to zero. * * if the specified length is smaller than the current length, no operation * is performed. */ @@ -160,7 +160,7 @@ yastr yaslgrowzero(yastr s, size_t len) { return s; } -/* Destructively modify the sds string 's' to hold the specified binary +/* Destructively modify the yasl string 's' to hold the specified binary * safe string pointed by 't' of length 'len' bytes. */ yastr yaslcpylen(yastr s, const char *t, size_t len) { struct yastrhdr *sh = yaslheader(s); @@ -186,7 +186,7 @@ yastr yaslcpy(yastr s, const char *t) { } /* Join an array of C strings using the specified separator (also a C string). - * Returns the result as an sds string. */ + * Returns the result as a yasl string. */ yastr yasljoin(char **argv, int argc, char *sep, size_t seplen) { yastr join = yaslempty(); @@ -197,7 +197,7 @@ yastr yasljoin(char **argv, int argc, char *sep, size_t seplen) { return join; } -/* Like yasljoin, but joins an array of SDS strings. */ +/* Like yasljoin, but joins an array of yasl strings. */ yastr yasljoinyasl(yastr *argv, int argc, const char *sep, size_t seplen) { yastr join = yaslempty(); @@ -215,7 +215,7 @@ yastr yasljoinyasl(yastr *argv, int argc, const char *sep, size_t seplen) { * For instance: yaslmapchars(mystring, "ho", "01", 2) * will have the effect of turning the string "hello" into "0ell1". * - * The function returns the sds string pointer, that is always the same + * The function returns the yasl string pointer, that is always the same * as the input pointer since no resize is needed. */ yastr yaslmapchars(yastr s, const char *from, const char *to, size_t setlen) { for (size_t j = 0; j < yasllen(s); j++) { @@ -275,14 +275,14 @@ void yaslrange(yastr s, ptrdiff_t start, ptrdiff_t end) { sh->len = newlen; } -/* Apply tolower() to every character of the sds string 's'. */ +/* Apply tolower() to every character of the yasl string 's'. */ void yasltolower(yastr s) { for (size_t j = 0; j < yasllen(s); j++) { s[j] = (char)tolower(s[j]); } } -/* Apply toupper() to every character of the sds string 's'. */ +/* Apply toupper() to every character of the yasl string 's'. */ void yasltoupper(yastr s) { for (size_t j = 0; j < yasllen(s); j++) { s[j] = (char)toupper(s[j]); @@ -292,7 +292,7 @@ void yasltoupper(yastr s) { /* Remove the part of the string from left and from right composed just of * contiguous characters found in 'cset', that is a null terminted C string. * - * After the call, the modified sds string is no longer valid and all the + * After the call, the modified yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. * * Example: @@ -319,10 +319,10 @@ void yasltrim(yastr s, const char *cset) { sh->len = len; } -/* Set the sds string length to the length as obtained with strlen(), so +/* Set the yasl string length to the length as obtained with strlen(), so * considering as content only up to the first null term character. * - * This function is useful when the sds string is hacked manually in some + * This function is useful when the yasl string is hacked manually in some * way, like in the following example: * * s = yaslauto("foobar"); @@ -346,9 +346,9 @@ void yaslupdatelen(yastr s) { * foo bar "newline are supported\n" and "\xff\x00otherstuff" * * The number of arguments is stored into *argc, and an array - * of sds is returned. + * of yasl strings is returned. * - * The caller should free the resulting array of sds strings with + * The caller should free the resulting array of yasl strings with * yaslfreesplitres(). * * Note that yaslcatrepr() is able to convert back a string into @@ -471,7 +471,7 @@ err: } /* Split 's' with separator in 'sep'. An array - * of sds strings is returned. *count will be set + * of yasl strings is returned. *count will be set * by reference to the number of tokens returned. * * On out of memory, zero length string, zero length @@ -479,11 +479,11 @@ err: * * Note that 'sep' is able to split a string using * a multi-character separator. For example - * sdssplit("foo_-_bar", "_-_"); will return two + * yaslsplit("foo_-_bar", "_-_"); will return two * elements "foo" and "bar". * * This version of the function is binary-safe but - * requires length arguments. sdssplit() is just the + * requires length arguments. yaslsplit() is just the * same function but for zero-terminated strings. */ yastr *yaslsplitlen(const char *s, size_t len, const char *sep, size_t seplen, size_t *count) { @@ -538,26 +538,26 @@ cleanup: // Concatenation -/* Append the specified null termianted C string to the sds string 's'. +/* Append the specified null termianted C string to the yasl string 's'. * - * After the call, the passed sds string is no longer valid and all the + * After the call, the passed yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ yastr yaslcat(yastr s, const char *t) { return yaslcatlen(s, t, strlen(t)); } -/* Append the specified sds 't' to the existing sds 's'. +/* Append the specified yasl string 't' to the existing yasl string 's'. * - * After the call, the modified sds string is no longer valid and all the + * After the call, the modified yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ yastr yaslcatyasl(yastr s, const yastr t) { return yaslcatlen(s, t, yasllen(t)); } /* Append the specified binary-safe string pointed by 't' of 'len' bytes to the - * end of the specified sds string 's'. + * end of the specified yasl string 's'. * - * After the call, the passed sds string is no longer valid and all the + * After the call, the passed yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ yastr yaslcatlen(yastr s, const void *t, size_t len) { struct yastrhdr *sh; @@ -573,11 +573,11 @@ yastr yaslcatlen(yastr s, const void *t, size_t len) { return s; } -/* Append to the sds string "s" an escaped string representation where +/* Append to the yasl string "s" an escaped string representation where * all the non-printable characters (tested with isprint()) are turned into * escapes in the form "\n\r\a...." or "\x". * - * After the call, the modified sds string is no longer valid and all the + * After the call, the modified yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ yastr yaslcatrepr(yastr s, const char *p, size_t len) { s = yaslcatlen(s, "\"", 1); @@ -631,10 +631,10 @@ yastr yaslcatvprintf(yastr s, const char *fmt, va_list ap) { } #pragma GCC diagnostic warning "-Wformat-nonliteral" -/* Append to the sds string 's' a string obtained using printf-alike format +/* Append to the yasl string 's' a string obtained using printf-alike format * specifier. * - * After the call, the modified sds string is no longer valid and all the + * After the call, the modified yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. * * Example: @@ -659,7 +659,7 @@ yastr yaslcatprintf(yastr s, const char *fmt, ...) { /// Freeing -/* Free an sds string. No operation is performed if 's' is NULL. */ +/* Free a yasl string. No operation is performed if 's' is NULL. */ void yaslfree(yastr s) { if (s == NULL) { return; } free(yaslheader(s)); @@ -677,9 +677,9 @@ void yaslfreesplitres(yastr *tokens, size_t count) { // Low-level functions -/* Return the total size of the allocation of the specifed sds string, +/* Return the total size of the allocation of the specifed yasl string, * including: - * 1) The sds header before the pointer. + * 1) The yasl header before the pointer. * 2) The string. * 3) The free buffer at the end if any. * 4) The implicit null term. @@ -690,9 +690,9 @@ size_t yaslAllocSize(yastr s) { return sizeof(*sh) + sh->len + sh->free + 1; } -/* Increment the sds length and decrements the left free space at the - * end of the string according to 'incr'. Also set the null term - * in the new end of the string. +/* Increment the yasl string length and decrements the left free space at the + * end of the string according to 'incr'. Also set the null term in the new end + * of the string. * * This function is used in order to fix the string length after the * user calls yaslMakeRoomFor(), writes something after the end of @@ -701,8 +701,8 @@ size_t yaslAllocSize(yastr s) { * Usage example: * * Using yaslIncrLen() and yaslMakeRoomFor() it is possible to mount the - * following schema, to cat bytes coming from the kernel to the end of an - * sds string without copying into an intermediate buffer: + * following schema, to cat bytes coming from the kernel to the end of a + * yasl string without copying into an intermediate buffer: * * oldlen = yasllen(s); * s = yaslMakeRoomFor(s, BUFFER_SIZE); @@ -719,11 +719,11 @@ void yaslIncrLen(yastr s, size_t incr) { s[sh->len] = '\0'; } -/* Enlarge the free space at the end of the sds string so that the caller +/* Enlarge the free space at the end of the yasl string so that the caller * is sure that after calling this function can overwrite up to addlen * bytes after the end of the string, plus one more byte for nul term. * - * Note: this does not change the *length* of the sds string as returned + * Note: this does not change the *length* of the yasl string as returned * by yasllen(), but only the free buffer space we have. */ yastr yaslMakeRoomFor(yastr s, size_t addlen) { struct yastrhdr *sh, *newsh; @@ -734,10 +734,10 @@ yastr yaslMakeRoomFor(yastr s, size_t addlen) { len = yasllen(s); sh = yaslheader(s); newlen = (len + addlen); - if (newlen < SDS_MAX_PREALLOC) { + if (newlen < YASL_MAX_PREALLOC) { newlen *= 2; } else { - newlen += SDS_MAX_PREALLOC; + newlen += YASL_MAX_PREALLOC; } newsh = realloc(sh, sizeof(struct yastrhdr) + newlen + 1); if (newsh == NULL) { return NULL; } @@ -746,11 +746,11 @@ yastr yaslMakeRoomFor(yastr s, size_t addlen) { return newsh->buf; } -/* Reallocate the sds string so that it has no free space at the end. The +/* Reallocate the yasl string so that it has no free space at the end. The * contained string remains not altered, but next concatenation operations * will require a reallocation. * - * After the call, the passed sds string is no longer valid and all the + * After the call, the passed yasl string is no longer valid and all the * references must be substituted with the new pointer returned by the call. */ yastr yaslRemoveFreeSpace(yastr s) { struct yastrhdr *sh; diff --git a/src/yasl.h b/src/yasl.h index 965000b..90860bc 100644 --- a/src/yasl.h +++ b/src/yasl.h @@ -1,4 +1,4 @@ -/* SDS (Simple Dynamic Strings), A C dynamic strings library. +/* yasl, Yet Another String Library for C * * Copyright (c) 2006-2014, Salvatore Sanfilippo * All rights reserved. @@ -25,10 +25,10 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#ifndef SDS_H -#define SDS_H +#ifndef YASL_H +#define YASL_H -#define SDS_MAX_PREALLOC (1024*1024) +#define YASL_MAX_PREALLOC (1024*1024) #include #include -- cgit v1.2.3-54-g00ecf From f413a5d72c077d3bfa571c6757261ea191d1c694 Mon Sep 17 00:00:00 2001 From: Johannes Löthberg Date: Tue, 20 Jan 2015 14:17:20 +0100 Subject: test: Bring testsuite up to date with yasl rename --- Makefile | 12 +-- test/test.c | 290 ++++++++++++++++++++++++++++++------------------------------ 2 files changed, 151 insertions(+), 151 deletions(-) diff --git a/Makefile b/Makefile index f7bc480..01e9925 100644 --- a/Makefile +++ b/Makefile @@ -6,11 +6,11 @@ SOURCES = test/twbctf.c src/yasl.c HEADERS = test/twbctf.h src/yasl.h MANPAGES = docs/sds.3 docs/sdsnew.3 docs/sdsfree.3 -all: sds-test $(MANPAGES) +all: yasl-test $(MANPAGES) -sds-test: $(SOURCES) $(HEADERS) test/test.c - @echo "==> Building sds-test" +yasl-test: $(SOURCES) $(HEADERS) test/test.c + @echo "==> Building yasl-test" $(CC) $(CFLAGS) -Isrc -o $@ $(SOURCES) docs/%.3: docs/%.rst @@ -18,13 +18,13 @@ docs/%.3: docs/%.rst sphinx-build -b man -E docs/ docs/ -test: sds-test +test: yasl-test @echo "==> Running test suite" - ./sds-test + ./yasl-test clean: - rm -f sds-test + rm -f yasl-test rm docs/*.3 diff --git a/test/test.c b/test/test.c index 243826e..e7a4948 100644 --- a/test/test.c +++ b/test/test.c @@ -1,241 +1,241 @@ #include #include -#include +#include #include "twbctf.h" -bool check_string_length (void); -bool create_with_length (void); -bool string_concat (void); -bool sdscpy_against_longer_str (void); -bool sdscpy_against_shorter_str (void); -bool sdscatprintf_base_case (void); -bool sdstrim_trims_correctly (void); -bool sdsrange_one_one (void); -bool sdsrange_one_none (void); -bool sdsrange_ntwo_none (void); -bool sdsrange_two_one (void); -bool sdsrange_one_hund (void); -bool sdsrange_hund_hund (void); -bool sdscmp_foo_foa (void); -bool sdscmp_aar_bar (void); -bool sdscmp_bar_bar (void); -bool sdscatrepr_test (void); -bool sdsnew_check_free_len (void); -bool sdsMakeRoomFor_test (void); -bool sdsIncrLen_content (void); -bool sdsIncrLen_len (void); -bool sdsIncrLen_free (void); -bool test_sdstolower (void); -bool test_sdstoupper (void); +bool check_string_length (void); +bool create_with_length (void); +bool string_concat (void); +bool yaslcpy_against_longer_str (void); +bool yaslcpy_against_shorter_str (void); +bool yaslcatprintf_base_case (void); +bool yasltrim_trims_correctly (void); +bool yaslrange_one_one (void); +bool yaslrange_one_none (void); +bool yaslrange_ntwo_none (void); +bool yaslrange_two_one (void); +bool yaslrange_one_hund (void); +bool yaslrange_hund_hund (void); +bool yaslcmp_foo_foa (void); +bool yaslcmp_aar_bar (void); +bool yaslcmp_bar_bar (void); +bool yaslcatrepr_test (void); +bool yaslnew_check_free_len (void); +bool yaslMakeRoomFor_test (void); +bool yaslIncrLen_content (void); +bool yaslIncrLen_len (void); +bool yaslIncrLen_free (void); +bool test_yasltolower (void); +bool test_yasltoupper (void); static const struct test test_list [] = { - { "create a string and obtain the length", check_string_length }, - { "create a string with specified length", create_with_length }, - { "string concatenation", string_concat }, - { "sdscpy() against a longer string", sdscpy_against_longer_str }, - { "sdscpy() against a shorter string", sdscpy_against_shorter_str }, - { "basic sdscatprintf() usecase", sdscatprintf_base_case }, - { "sdstrim() trims correctly", sdstrim_trims_correctly }, - { "sdsrange(..., 1, 1)", sdsrange_one_one }, - { "sdsrange(..., 1, -1)", sdsrange_one_none }, - { "sdsrange(..., -2, -1)", sdsrange_ntwo_none }, - { "sdsrange(..., 2, 1)", sdsrange_two_one }, - { "sdsrange(..., 1, 100)", sdsrange_one_hund }, - { "sdsrange(..., 100, 100)", sdsrange_hund_hund }, - { "sdscmp(foo, foa)", sdscmp_foo_foa }, - { "sdscmp(aar, bar)", sdscmp_aar_bar }, - { "sdscmp(bar, bar)", sdscmp_bar_bar }, - { "sdscatrepr(...data...)", sdscatrepr_test }, - { "sdsnew() free/len buffers", sdsnew_check_free_len }, - { "sdsMakeRoomFor()", sdsMakeRoomFor_test }, - { "content after sdsIncrLen()", sdsIncrLen_content }, - { "len after sdsIncrLen()", sdsIncrLen_len }, - { "free after sdsIncrLen()", sdsIncrLen_free }, - { "sdstolower()", test_sdstolower }, - { "sdstoupper()", test_sdstoupper }, + { "create a string and obtain the length", check_string_length }, + { "create a string with specified length", create_with_length }, + { "string concatenation", string_concat }, + { "yaslcpy() against a longer string", yaslcpy_against_longer_str }, + { "yaslcpy() against a shorter string", yaslcpy_against_shorter_str }, + { "basic yaslcatprintf() usecase", yaslcatprintf_base_case }, + { "yasltrim() trims correctly", yasltrim_trims_correctly }, + { "yaslrange(..., 1, 1)", yaslrange_one_one }, + { "yaslrange(..., 1, -1)", yaslrange_one_none }, + { "yaslrange(..., -2, -1)", yaslrange_ntwo_none }, + { "yaslrange(..., 2, 1)", yaslrange_two_one }, + { "yaslrange(..., 1, 100)", yaslrange_one_hund }, + { "yaslrange(..., 100, 100)", yaslrange_hund_hund }, + { "yaslcmp(foo, foa)", yaslcmp_foo_foa }, + { "yaslcmp(aar, bar)", yaslcmp_aar_bar }, + { "yaslcmp(bar, bar)", yaslcmp_bar_bar }, + { "yaslcatrepr(...data...)", yaslcatrepr_test }, + { "yaslnew() free/len buffers", yaslnew_check_free_len }, + { "yaslMakeRoomFor()", yaslMakeRoomFor_test }, + { "content after yaslIncrLen()", yaslIncrLen_content }, + { "len after yaslIncrLen()", yaslIncrLen_len }, + { "free after yaslIncrLen()", yaslIncrLen_free }, + { "yasltolower()", test_yasltolower }, + { "yasltoupper()", test_yasltoupper }, }; -static inline void sdsfrees(sds *string) { if (*string) sdsfree(*string); } -#define _sds_cleanup_ __attribute__((cleanup(sdsfrees))) +static inline void yaslfrees(yastr *string) { if (*string) yaslfree(*string); } +#define _yastr_cleanup_ __attribute__((cleanup(yaslfrees))) bool check_string_length(void) { - _sds_cleanup_ sds x = sdsauto("foo"); - return (sdslen(x) == 3 && memcmp(x, "foo\0", 4) == 0); + _yastr_cleanup_ yastr x = yaslauto("foo"); + return (yasllen(x) == 3 && memcmp(x, "foo\0", 4) == 0); } bool create_with_length(void) { - _sds_cleanup_ sds x = sdsnew("foo", 2); - return (sdslen(x) == 2 && memcmp(x, "fo\0", 3) == 0); + _yastr_cleanup_ yastr x = yaslnew("foo", 2); + return (yasllen(x) == 2 && memcmp(x, "fo\0", 3) == 0); } bool string_concat(void) { - _sds_cleanup_ sds x = sdsnew("foo", 2); - x = sdscat(x, "bar"); - return (sdslen(x) == 5 && memcmp(x, "fobar\0", 6) == 0); + _yastr_cleanup_ yastr x = yaslnew("foo", 2); + x = yaslcat(x, "bar"); + return (yasllen(x) == 5 && memcmp(x, "fobar\0", 6) == 0); } bool -sdscpy_against_longer_str(void) { - _sds_cleanup_ sds x = sdsauto("foo"); - x = sdscpy(x, "a"); - return (sdslen(x) == 1 && memcmp(x, "a\0", 2) == 0); +yaslcpy_against_longer_str(void) { + _yastr_cleanup_ yastr x = yaslauto("foo"); + x = yaslcpy(x, "a"); + return (yasllen(x) == 1 && memcmp(x, "a\0", 2) == 0); } bool -sdscpy_against_shorter_str(void) { - _sds_cleanup_ sds x = sdsnew("foo",2); - x = sdscpy(x, "xxxxyyyyzzzz"); - return (sdslen(x) == 12 && memcmp(x, "xxxxyyyyzzzz\0", 12) == 0); +yaslcpy_against_shorter_str(void) { + _yastr_cleanup_ yastr x = yaslnew("foo",2); + x = yaslcpy(x, "xxxxyyyyzzzz"); + return (yasllen(x) == 12 && memcmp(x, "xxxxyyyyzzzz\0", 12) == 0); } bool -sdscatprintf_base_case(void) { - _sds_cleanup_ sds x = sdscatprintf(sdsempty(), "%d", 123); - return (sdslen(x) == 3 && memcmp(x, "123\0", 4) == 0); +yaslcatprintf_base_case(void) { + _yastr_cleanup_ yastr x = yaslcatprintf(yaslempty(), "%d", 123); + return (yasllen(x) == 3 && memcmp(x, "123\0", 4) == 0); } bool -sdstrim_trims_correctly(void) { - _sds_cleanup_ sds x = sdsauto("xxciaoyy"); - sdstrim(x, "xy"); - return (sdslen(x) == 4 && memcmp(x, "ciao\0", 5) == 0); +yasltrim_trims_correctly(void) { + _yastr_cleanup_ yastr x = yaslauto("xxciaoyy"); + yasltrim(x, "xy"); + return (yasllen(x) == 4 && memcmp(x, "ciao\0", 5) == 0); } bool -sdsrange_one_one (void) { - _sds_cleanup_ sds x = sdsauto("ciao"); - _sds_cleanup_ sds y = sdsdup(x); - sdsrange(y, 1, 1); - return (sdslen(y) == 1 && memcmp(y, "i\0", 2) == 0); +yaslrange_one_one(void) { + _yastr_cleanup_ yastr x = yaslauto("ciao"); + _yastr_cleanup_ yastr y = yasldup(x); + yaslrange(y, 1, 1); + return (yasllen(y) == 1 && memcmp(y, "i\0", 2) == 0); } bool -sdsrange_one_none (void) { - _sds_cleanup_ sds x = sdsauto("ciao"); - _sds_cleanup_ sds y = sdsdup(x); - sdsrange(y, 1, -1); - return (sdslen(y) == 3 && memcmp(y, "iao\0", 4) == 0); +yaslrange_one_none(void) { + _yastr_cleanup_ yastr x = yaslauto("ciao"); + _yastr_cleanup_ yastr y = yasldup(x); + yaslrange(y, 1, -1); + return (yasllen(y) == 3 && memcmp(y, "iao\0", 4) == 0); } bool -sdsrange_ntwo_none (void) { - _sds_cleanup_ sds x = sdsauto("ciao"); - _sds_cleanup_ sds y = sdsdup(x); - sdsrange(y, -2, -1); - return (sdslen(y) == 2 && memcmp(y, "ao\0", 3) == 0); +yaslrange_ntwo_none(void) { + _yastr_cleanup_ yastr x = yaslauto("ciao"); + _yastr_cleanup_ yastr y = yasldup(x); + yaslrange(y, -2, -1); + return (yasllen(y) == 2 && memcmp(y, "ao\0", 3) == 0); } bool -sdsrange_two_one (void) { - _sds_cleanup_ sds x = sdsauto("ciao"); - _sds_cleanup_ sds y = sdsdup(x); - sdsrange(y, 2, 1); - return (sdslen(y) == 0 && memcmp(y, "\0", 1) == 0); +yaslrange_two_one(void) { + _yastr_cleanup_ yastr x = yaslauto("ciao"); + _yastr_cleanup_ yastr y = yasldup(x); + yaslrange(y, 2, 1); + return (yasllen(y) == 0 && memcmp(y, "\0", 1) == 0); } bool -sdsrange_one_hund (void) { - _sds_cleanup_ sds x = sdsauto("ciao"); - _sds_cleanup_ sds y = sdsdup(x); - sdsrange(y, 1, 100); - return (sdslen(y) == 3 && memcmp(y, "iao\0", 4) == 0); +yaslrange_one_hund(void) { + _yastr_cleanup_ yastr x = yaslauto("ciao"); + _yastr_cleanup_ yastr y = yasldup(x); + yaslrange(y, 1, 100); + return (yasllen(y) == 3 && memcmp(y, "iao\0", 4) == 0); } bool -sdsrange_hund_hund (void) { - _sds_cleanup_ sds x = sdsauto("ciao"); - _sds_cleanup_ sds y = sdsdup(x); - sdsrange(y, 100, 100); - return (sdslen(y) == 0 && memcmp(y, "\0", 1) == 0); +yaslrange_hund_hund(void) { + _yastr_cleanup_ yastr x = yaslauto("ciao"); + _yastr_cleanup_ yastr y = yasldup(x); + yaslrange(y, 100, 100); + return (yasllen(y) == 0 && memcmp(y, "\0", 1) == 0); } bool -sdscmp_foo_foa (void) { - _sds_cleanup_ sds x = sdsauto("foo"); - _sds_cleanup_ sds y = sdsauto("foa"); - return (sdscmp(x, y) > 0); +yaslcmp_foo_foa(void) { + _yastr_cleanup_ yastr x = yaslauto("foo"); + _yastr_cleanup_ yastr y = yaslauto("foa"); + return (yaslcmp(x, y) > 0); } bool -sdscmp_aar_bar (void) { - _sds_cleanup_ sds x = sdsauto("aar"); - _sds_cleanup_ sds y = sdsauto("bar"); - return (sdscmp(x, y) < 0); +yaslcmp_aar_bar(void) { + _yastr_cleanup_ yastr x = yaslauto("aar"); + _yastr_cleanup_ yastr y = yaslauto("bar"); + return (yaslcmp(x, y) < 0); } bool -sdscmp_bar_bar (void) { - _sds_cleanup_ sds x = sdsauto("bar"); - _sds_cleanup_ sds y = sdsauto("bar"); - return (sdscmp(x, y) == 0); +yaslcmp_bar_bar(void) { + _yastr_cleanup_ yastr x = yaslauto("bar"); + _yastr_cleanup_ yastr y = yaslauto("bar"); + return (yaslcmp(x, y) == 0); } bool -sdscatrepr_test (void) { - _sds_cleanup_ sds x = sdsnew("\a\n\0foo\r", 7); - _sds_cleanup_ sds y = sdscatrepr(sdsempty(), x, sdslen(x)); +yaslcatrepr_test(void) { + _yastr_cleanup_ yastr x = yaslnew("\a\n\0foo\r", 7); + _yastr_cleanup_ yastr y = yaslcatrepr(yaslempty(), x, yasllen(x)); return (memcmp(y, "\"\\a\\n\\x00foo\\r\"", 15) == 0); } bool -sdsnew_check_free_len (void) { - _sds_cleanup_ sds x = sdsauto("0"); - struct sdshdr *sh = (void*) (x-(sizeof(struct sdshdr))); +yaslnew_check_free_len(void) { + _yastr_cleanup_ yastr x = yaslauto("0"); + struct yastrhdr *sh = (void*) (x-(sizeof(struct yastrhdr))); return (sh->len == 1 && sh->free == 0); } bool -sdsMakeRoomFor_test (void) { - _sds_cleanup_ sds x = sdsauto("0"); - x = sdsMakeRoomFor(x, 1); - struct sdshdr *sh = (void*) (x-(sizeof(struct sdshdr))); +yaslMakeRoomFor_test(void) { + _yastr_cleanup_ yastr x = yaslauto("0"); + x = yaslMakeRoomFor(x, 1); + struct yastrhdr *sh = (void*) (x-(sizeof(struct yastrhdr))); return (sh->len == 1 && sh->free > 0); } bool -sdsIncrLen_content (void) { - _sds_cleanup_ sds x = sdsauto("0"); - x = sdsMakeRoomFor(x, 1); +yaslIncrLen_content(void) { + _yastr_cleanup_ yastr x = yaslauto("0"); + x = yaslMakeRoomFor(x, 1); x[1] = '1'; - sdsIncrLen(x, 1); + yaslIncrLen(x, 1); return (x[0] == '0' && x[1] == '1'); } bool -sdsIncrLen_len (void) { - _sds_cleanup_ sds x = sdsauto("0"); - x = sdsMakeRoomFor(x, 1); - struct sdshdr *sh = (void*) (x-(sizeof(struct sdshdr))); +yaslIncrLen_len(void) { + _yastr_cleanup_ yastr x = yaslauto("0"); + x = yaslMakeRoomFor(x, 1); + struct yastrhdr *sh = (void*) (x-(sizeof(struct yastrhdr))); x[1] = '1'; - sdsIncrLen(x, 1); + yaslIncrLen(x, 1); return (sh->len == 2); } bool -sdsIncrLen_free (void) { - _sds_cleanup_ sds x = sdsauto("0"); - x = sdsMakeRoomFor(x, 1); - struct sdshdr *sh = (void*) (x-(sizeof(struct sdshdr))); +yaslIncrLen_free(void) { + _yastr_cleanup_ yastr x = yaslauto("0"); + x = yaslMakeRoomFor(x, 1); + struct yastrhdr *sh = (void*) (x-(sizeof(struct yastrhdr))); size_t oldfree = sh->free; x[1] = '1'; - sdsIncrLen(x, 1); + yaslIncrLen(x, 1); return (sh->free == oldfree-1); } bool -test_sdstolower (void) { - _sds_cleanup_ sds x = sdsauto("0FoO1bar\n"); - sdstolower(x); +test_yasltolower(void) { + _yastr_cleanup_ yastr x = yaslauto("0FoO1bar\n"); + yasltolower(x); return memcmp(x, "0foo1bar\n\0", 10) == 0; } bool -test_sdstoupper (void) { - _sds_cleanup_ sds x = sdsauto("0FoO1bar\n"); - sdstoupper(x); +test_yasltoupper(void) { + _yastr_cleanup_ yastr x = yaslauto("0FoO1bar\n"); + yasltoupper(x); return memcmp(x, "0FOO1BAR\n\0", 10) == 0; } -- cgit v1.2.3-54-g00ecf